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

   1 // MacOSXAPIChecker.h - Checks proper use of various MacOS X APIs --*- 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 MacOSXAPIChecker, which is an assortment of checks on calls
  11 // to various, widely used Apple APIs.
  12 //
  13 // FIXME: What's currently in BasicObjCFoundationChecks.cpp should be migrated
  14 // to here, using the new Checker interface.
  15 //
  16 //===----------------------------------------------------------------------===//
  17
  18 #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
  19 #include "clang/Basic/TargetInfo.h"
  20 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
  21 #include "clang/StaticAnalyzer/Core/Checker.h"
  22 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
  23 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
  24 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
  25 #include "llvm/ADT/SmallString.h"
  26 #include "llvm/ADT/StringSwitch.h"
  27 #include "llvm/Support/raw_ostream.h"
  28
  29 using namespace clang;
  30 using namespace ento;
  31
  32 namespace {
  33 class MacOSXAPIChecker : public Checker< check::PreStmt<CallExpr> > {
  34   mutable std::unique_ptr<BugType> BT_dispatchOnce;
  35
  36   static const ObjCIvarRegion *getParentIvarRegion(const MemRegion *R);
  37
  38 public:
  39   void checkPreStmt(const CallExpr *CE, CheckerContext &C) const;
  40
  41   void CheckDispatchOnce(CheckerContext &C, const CallExpr *CE,
  42                          StringRef FName) const;
  43
  44   typedef void (MacOSXAPIChecker::*SubChecker)(CheckerContext &,
  45                                                const CallExpr *,
  46                                                StringRef FName) const;
  47 };
  48 } //end anonymous namespace
  49
  50 //===----------------------------------------------------------------------===//
  51 // dispatch_once and dispatch_once_f
  52 //===----------------------------------------------------------------------===//
  53
  54 const ObjCIvarRegion *
  55 MacOSXAPIChecker::getParentIvarRegion(const MemRegion *R) {
  56   const SubRegion *SR = dyn_cast<SubRegion>(R);
  57   while (SR) {
  58     if (const ObjCIvarRegion *IR = dyn_cast<ObjCIvarRegion>(SR))
  59       return IR;
  60     SR = dyn_cast<SubRegion>(SR->getSuperRegion());
  61   }
  62   return nullptr;
  63 }
  64
  65 void MacOSXAPIChecker::CheckDispatchOnce(CheckerContext &C, const CallExpr *CE,
  66                                          StringRef FName) const {
  67   if (CE->getNumArgs() < 1)
  68     return;
  69
  70   // Check if the first argument is improperly allocated.  If so, issue a
  71   // warning because that's likely to be bad news.
  72   const MemRegion *R = C.getSVal(CE->getArg(0)).getAsRegion();
  73   if (!R)
  74     return;
  75
  76   // Global variables are fine.
  77   const MemRegion *RB = R->getBaseRegion();
  78   const MemSpaceRegion *RS = RB->getMemorySpace();
  79   if (isa<GlobalsSpaceRegion>(RS))
  80     return;
  81
  82   // Handle _dispatch_once.  In some versions of the OS X SDK we have the case
  83   // that dispatch_once is a macro that wraps a call to _dispatch_once.
  84   // _dispatch_once is then a function which then calls the real dispatch_once.
  85   // Users do not care; they just want the warning at the top-level call.
  86   if (CE->getBeginLoc().isMacroID()) {
  87     StringRef TrimmedFName = FName.ltrim('_');
  88     if (TrimmedFName != FName)
  89       FName = TrimmedFName;
  90   }
  91
  92   SmallString<256> S;
  93   llvm::raw_svector_ostream os(S);
  94   bool SuggestStatic = false;
  95   os << "Call to '" << FName << "' uses";
  96   if (const VarRegion *VR = dyn_cast<VarRegion>(RB)) {
  97     const VarDecl *VD = VR->getDecl();
  98     // FIXME: These should have correct memory space and thus should be filtered
  99     // out earlier. This branch only fires when we're looking from a block,
 100     // which we analyze as a top-level declaration, onto a static local
 101     // in a function that contains the block.
 102     if (VD->isStaticLocal())
 103       return;
 104     // We filtered out globals earlier, so it must be a local variable
 105     // or a block variable which is under UnknownSpaceRegion.
 106     if (VR != R)
 107       os << " memory within";
 108     if (VD->hasAttr<BlocksAttr>())
 109       os << " the block variable '";
 110     else
 111       os << " the local variable '";
 112     os << VR->getDecl()->getName() << '\'';
 113     SuggestStatic = true;
 114   } else if (const ObjCIvarRegion *IVR = getParentIvarRegion(R)) {
 115     if (IVR != R)
 116       os << " memory within";
 117     os << " the instance variable '" << IVR->getDecl()->getName() << '\'';
 118   } else if (isa<HeapSpaceRegion>(RS)) {
 119     os << " heap-allocated memory";
 120   } else if (isa<UnknownSpaceRegion>(RS)) {
 121     // Presence of an IVar superregion has priority over this branch, because
 122     // ObjC objects are on the heap even if the core doesn't realize this.
 123     // Presence of a block variable base region has priority over this branch,
 124     // because block variables are known to be either on stack or on heap
 125     // (might actually move between the two, hence UnknownSpace).
 126     return;
 127   } else {
 128     os << " stack allocated memory";
 129   }
 130   os << " for the predicate value.  Using such transient memory for "
 131         "the predicate is potentially dangerous.";
 132   if (SuggestStatic)
 133     os << "  Perhaps you intended to declare the variable as 'static'?";
 134
 135   ExplodedNode *N = C.generateErrorNode();
 136   if (!N)
 137     return;
 138
 139   if (!BT_dispatchOnce)
 140     BT_dispatchOnce.reset(new BugType(this, "Improper use of 'dispatch_once'",
 141                                       "API Misuse (Apple)"));
 142
 143   auto report = llvm::make_unique<BugReport>(*BT_dispatchOnce, os.str(), N);
 144   report->addRange(CE->getArg(0)->getSourceRange());
 145   C.emitReport(std::move(report));
 146 }
 147
 148 //===----------------------------------------------------------------------===//
 149 // Central dispatch function.
 150 //===----------------------------------------------------------------------===//
 151
 152 void MacOSXAPIChecker::checkPreStmt(const CallExpr *CE,
 153                                     CheckerContext &C) const {
 154   StringRef Name = C.getCalleeName(CE);
 155   if (Name.empty())
 156     return;
 157
 158   SubChecker SC =
 159     llvm::StringSwitch<SubChecker>(Name)
 160       .Cases("dispatch_once",
 161              "_dispatch_once",
 162              "dispatch_once_f",
 163              &MacOSXAPIChecker::CheckDispatchOnce)
 164       .Default(nullptr);
 165
 166   if (SC)
 167     (this->*SC)(C, CE, Name);
 168 }
 169
 170 //===----------------------------------------------------------------------===//
 171 // Registration.
 172 //===----------------------------------------------------------------------===//
 173
 174 void ento::registerMacOSXAPIChecker(CheckerManager &mgr) {
 175   mgr.registerChecker<MacOSXAPIChecker>();
 176 }