clang 8.0.0

MacOSXAPIChecker.cpp
Go to the documentation of this file.
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 }
ento
clang::CallExpr::getArg
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2553
clang::CallExpr::getNumArgs
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:2540
BugType.h
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:813
Checker.h
CheckerManager.h
llvm::SmallString
Definition: LLVM.h:35
clang::Decl::hasAttr
bool hasAttr() const
Definition: DeclBase.h:531
BuiltinCheckerRegistration.h
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:22
clang::SourceLocation::isMacroID
bool isMacroID() const
Definition: SourceLocation.h:101
clang::VarDecl::isStaticLocal
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:1060
clang::Stmt::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:276
TargetInfo.h
Defines the clang::TargetInfo interface.
clang::CallExpr
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2396
clang::NamedDecl::getName
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:276
clang::CallExpr::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.cpp:1428
ProgramStateTrait.h
CheckerContext.h