1//=======- RawPtrRefMemberChecker.cpp ----------------------------*- 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#include "ASTUtils.h"
10#include "DiagOutputUtils.h"
11#include "PtrTypesSemantics.h"
12#include "RawPtrRefSafetyModel.h"
13#include "clang/AST/Decl.h"
14#include "clang/AST/DeclCXX.h"
15#include "clang/AST/DynamicRecursiveASTVisitor.h"
16#include "clang/Basic/SourceManager.h"
17#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
18#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
19#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
20#include "clang/StaticAnalyzer/Core/Checker.h"
21#include "llvm/Support/Casting.h"
22#include <optional>
23
24using namespace clang;
25using namespace ento;
26
27namespace {
28
29class RawPtrRefMemberChecker
30 : public Checker<check::ASTDecl<TranslationUnitDecl>> {
31private:
32 BugType Bug;
33 mutable BugReporter *BR;
34 mutable llvm::DenseSet<const ObjCIvarDecl *> IvarDeclsToIgnore;
35
36protected:
37 const std::unique_ptr<PtrRefSafetyModel> Model;
38
39public:
40 RawPtrRefMemberChecker(const char *description,
41 std::unique_ptr<PtrRefSafetyModel> Model)
42 : Bug(this, description, "WebKit coding guidelines"),
43 Model(std::move(Model)) {}
44
45 std::optional<bool> isUnsafePtr(QualType QT, bool IgnoreARC = false) const {
46 return isUnsafePtrForStorage(Model: *Model, T: QT, IgnoreARC);
47 }
48
49 void checkASTDecl(const TranslationUnitDecl *TUD, AnalysisManager &MGR,
50 BugReporter &BRArg) const {
51 BR = &BRArg;
52
53 // The calls to checkAST* from AnalysisConsumer don't
54 // visit template instantiations or lambda classes. We
55 // want to visit those, so we make our own RecursiveASTVisitor.
56 struct LocalVisitor : ConstDynamicRecursiveASTVisitor {
57 const RawPtrRefMemberChecker *Checker;
58 explicit LocalVisitor(const RawPtrRefMemberChecker *Checker)
59 : Checker(Checker) {
60 assert(Checker);
61 ShouldVisitTemplateInstantiations = true;
62 ShouldVisitImplicitCode = false;
63 }
64
65 bool VisitTypedefDecl(const TypedefDecl *TD) override {
66 if (auto *RTC = Checker->Model->retainTypeChecker())
67 RTC->visitTypedef(TD);
68 return true;
69 }
70
71 bool VisitRecordDecl(const RecordDecl *RD) override {
72 Checker->visitRecordDecl(RD);
73 return true;
74 }
75
76 bool VisitObjCContainerDecl(const ObjCContainerDecl *CD) override {
77 Checker->visitObjCDecl(CD);
78 return true;
79 }
80 };
81
82 LocalVisitor visitor(this);
83 if (auto *RTC = Model->retainTypeChecker())
84 RTC->visitTranslationUnitDecl(TUD);
85 visitor.TraverseDecl(D: TUD);
86 }
87
88 void visitRecordDecl(const RecordDecl *RD) const {
89 if (shouldSkipDecl(RD))
90 return;
91
92 for (auto *Member : RD->fields())
93 visitMember(Member, RD);
94 }
95
96 void visitMember(const FieldDecl *Member, const RecordDecl *RD) const {
97 auto QT = Member->getType();
98 const Type *MemberType = QT.getTypePtrOrNull();
99
100 while (MemberType) {
101 auto IsUnsafePtr = isUnsafePtr(QT);
102 if (IsUnsafePtr && *IsUnsafePtr)
103 break;
104 if (!MemberType->isPointerType())
105 return;
106 QT = MemberType->getPointeeType();
107 MemberType = QT.getTypePtrOrNull();
108 }
109
110 if (!MemberType)
111 return;
112
113 if (auto *MemberCXXRD = MemberType->getPointeeCXXRecordDecl())
114 reportBug(Member, MemberType, Pointee: MemberCXXRD, ClassCXXRD: RD);
115 else if (auto *ObjCDecl = getObjCDeclFromObjCPtr(TypePtr: MemberType))
116 reportBug(Member, MemberType, Pointee: ObjCDecl, ClassCXXRD: RD);
117 }
118
119 void visitObjCDecl(const ObjCContainerDecl *CD) const {
120 if (BR->getSourceManager().isInSystemHeader(Loc: CD->getLocation()))
121 return;
122
123 if (auto *ID = dyn_cast<ObjCImplementationDecl>(Val: CD)) {
124 ObjCContainerDecl::PropertyMap map;
125 CD->collectPropertiesToImplement(PM&: map);
126 for (auto it : map)
127 visitObjCPropertyDecl(CD, PD: it.second);
128
129 if (auto *Interface = ID->getClassInterface()) {
130 for (auto *Ivar : Interface->ivars())
131 visitIvarDecl(CD, Ivar);
132 }
133 for (auto *PropImpl : ID->property_impls())
134 visitPropImpl(CD, PID: PropImpl);
135 for (auto *Ivar : ID->ivars())
136 visitIvarDecl(CD, Ivar);
137 return;
138 }
139 }
140
141 void visitIvarDecl(const ObjCContainerDecl *CD,
142 const ObjCIvarDecl *Ivar) const {
143 if (BR->getSourceManager().isInSystemHeader(Loc: Ivar->getLocation()))
144 return;
145
146 if (IvarDeclsToIgnore.contains(V: Ivar))
147 return;
148
149 auto QT = Ivar->getType();
150 const Type *IvarType = QT.getTypePtrOrNull();
151 if (!IvarType)
152 return;
153
154 auto IsUnsafePtr = isUnsafePtr(QT);
155 if (!IsUnsafePtr || !*IsUnsafePtr)
156 return;
157
158 IvarDeclsToIgnore.insert(V: Ivar);
159
160 if (auto *MemberCXXRD = IvarType->getPointeeCXXRecordDecl())
161 reportBug(Member: Ivar, MemberType: IvarType, Pointee: MemberCXXRD, ClassCXXRD: CD);
162 else if (auto *ObjCDecl = getObjCDeclFromObjCPtr(TypePtr: IvarType))
163 reportBug(Member: Ivar, MemberType: IvarType, Pointee: ObjCDecl, ClassCXXRD: CD);
164 }
165
166 void visitObjCPropertyDecl(const ObjCContainerDecl *CD,
167 const ObjCPropertyDecl *PD) const {
168 if (BR->getSourceManager().isInSystemHeader(Loc: PD->getLocation()))
169 return;
170
171 if (const ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(Val: CD)) {
172 auto *RTC = Model->retainTypeChecker();
173 if (!RTC || !RTC->defaultSynthProperties() ||
174 ID->isObjCRequiresPropertyDefs())
175 return;
176 }
177
178 auto [IsUnsafe, PropType] = isPropImplUnsafePtr(PD);
179 if (!IsUnsafe)
180 return;
181
182 if (auto *MemberCXXRD = PropType->getPointeeCXXRecordDecl())
183 reportBug(Member: PD, MemberType: PropType, Pointee: MemberCXXRD, ClassCXXRD: CD);
184 else if (auto *ObjCDecl = getObjCDeclFromObjCPtr(TypePtr: PropType))
185 reportBug(Member: PD, MemberType: PropType, Pointee: ObjCDecl, ClassCXXRD: CD);
186 }
187
188 void visitPropImpl(const ObjCContainerDecl *CD,
189 const ObjCPropertyImplDecl *PID) const {
190 if (BR->getSourceManager().isInSystemHeader(Loc: PID->getLocation()))
191 return;
192
193 if (PID->getPropertyImplementation() != ObjCPropertyImplDecl::Synthesize)
194 return;
195
196 auto *PropDecl = PID->getPropertyDecl();
197 if (auto *IvarDecl = PID->getPropertyIvarDecl()) {
198 if (IvarDeclsToIgnore.contains(V: IvarDecl))
199 return;
200 IvarDeclsToIgnore.insert(V: IvarDecl);
201 }
202 auto [IsUnsafe, PropType] = isPropImplUnsafePtr(PD: PropDecl);
203 if (!IsUnsafe)
204 return;
205
206 if (auto *MemberCXXRD = PropType->getPointeeCXXRecordDecl())
207 reportBug(Member: PropDecl, MemberType: PropType, Pointee: MemberCXXRD, ClassCXXRD: CD);
208 else if (auto *ObjCDecl = getObjCDeclFromObjCPtr(TypePtr: PropType))
209 reportBug(Member: PropDecl, MemberType: PropType, Pointee: ObjCDecl, ClassCXXRD: CD);
210 }
211
212 std::pair<bool, const Type *>
213 isPropImplUnsafePtr(const ObjCPropertyDecl *PD) const {
214 if (!PD)
215 return {false, nullptr};
216
217 auto QT = PD->getType();
218 const Type *PropType = QT.getTypePtrOrNull();
219 if (!PropType)
220 return {false, nullptr};
221
222 // "assign" property doesn't retain even under ARC so treat it as unsafe.
223 bool ignoreARC =
224 !PD->isReadOnly() && PD->getSetterKind() == ObjCPropertyDecl::Assign;
225 bool IsWeak =
226 PD->getPropertyAttributes() & ObjCPropertyAttribute::kind_weak;
227 bool HasSafeAttr = PD->isRetaining() || IsWeak;
228 auto IsUnsafePtr = isUnsafePtr(QT, IgnoreARC: ignoreARC);
229 return {IsUnsafePtr && *IsUnsafePtr && !HasSafeAttr, PropType};
230 }
231
232 bool shouldSkipDecl(const RecordDecl *RD) const {
233 if (!RD->isThisDeclarationADefinition())
234 return true;
235
236 if (RD->isImplicit())
237 return true;
238
239 if (RD->isLambda())
240 return true;
241
242 // If the construct doesn't have a source file, then it's not something
243 // we want to diagnose.
244 const auto RDLocation = RD->getLocation();
245 if (!RDLocation.isValid())
246 return true;
247
248 const auto Kind = RD->getTagKind();
249 if (Kind != TagTypeKind::Struct && Kind != TagTypeKind::Class &&
250 Kind != TagTypeKind::Union)
251 return true;
252
253 // Ignore CXXRecords that come from system headers.
254 if (BR->getSourceManager().isInSystemHeader(Loc: RDLocation))
255 return true;
256
257 // Ref-counted smartpointers actually have raw-pointer to uncounted type as
258 // a member but we trust them to handle it correctly.
259 auto CXXRD = llvm::dyn_cast_or_null<CXXRecordDecl>(Val: RD);
260 if (CXXRD && isSmartPtr(Class: CXXRD))
261 return true;
262
263 return false;
264 }
265
266 template <typename DeclType, typename PointeeType, typename ParentDeclType>
267 void reportBug(const DeclType *Member, const Type *MemberType,
268 const PointeeType *Pointee,
269 const ParentDeclType *ClassCXXRD) const {
270 assert(Member);
271 assert(MemberType);
272 assert(Pointee);
273
274 SmallString<100> Buf;
275 llvm::raw_svector_ostream Os(Buf);
276
277 if (isa<ObjCContainerDecl>(ClassCXXRD)) {
278 if (isa<ObjCPropertyDecl>(Member))
279 Os << "Property ";
280 else
281 Os << "Instance variable ";
282 } else
283 Os << "Member variable ";
284 printQuotedName(Os, Member);
285 Os << " (of ";
286 printQuotedQualifiedName(Os, ClassCXXRD);
287 Os << ")";
288 if (Member->getType().getTypePtrOrNull() == MemberType)
289 Os << " is a ";
290 else
291 Os << " contains a ";
292 if (printPointer(Os, T: MemberType) == PrintDeclKind::Pointer) {
293 auto Typedef = MemberType->getAs<TypedefType>();
294 assert(Typedef);
295 printQuotedQualifiedName(Os, D: Typedef->getDecl());
296 } else
297 printQuotedQualifiedName(Os, Pointee);
298
299 PathDiagnosticLocation BSLoc(Member->getSourceRange().getBegin(),
300 BR->getSourceManager());
301 auto Report = std::make_unique<BasicBugReport>(args: Bug, args: Os.str(), args&: BSLoc);
302 Report->addRange(R: Member->getSourceRange());
303 if (auto *EnclosingCtx = Member->getDeclContext())
304 Report->setDeclWithIssue(Decl::castFromDeclContext(EnclosingCtx));
305 BR->emitReport(R: std::move(Report));
306 }
307
308 enum class PrintDeclKind { Pointee, Pointer };
309 PrintDeclKind printPointer(llvm::raw_svector_ostream &Os,
310 const Type *T) const {
311 // Retain/OS types are frequently spelled through a typedef (e.g. CFXXXRef);
312 // print the typedef name rather than desugaring to the pointee.
313 if (Model->retainTypeChecker() && !isa<ObjCObjectPointerType>(Val: T) &&
314 T->getAs<TypedefType>()) {
315 Os << Model->typeName() << " ";
316 return PrintDeclKind::Pointer;
317 }
318 T = T->getUnqualifiedDesugaredType();
319 bool IsPtr = isa<PointerType>(Val: T) || isa<ObjCObjectPointerType>(Val: T);
320 Os << (IsPtr ? "raw pointer" : "reference") << " to " << Model->typeName()
321 << " ";
322 return PrintDeclKind::Pointee;
323 }
324};
325
326class NoUncountedMemberChecker final : public RawPtrRefMemberChecker {
327public:
328 NoUncountedMemberChecker()
329 : RawPtrRefMemberChecker("Member variable is a raw-pointer/reference to "
330 "reference-countable type",
331 makeRefPtrSafetyModel()) {}
332};
333
334class NoUncheckedPtrMemberChecker final : public RawPtrRefMemberChecker {
335public:
336 NoUncheckedPtrMemberChecker()
337 : RawPtrRefMemberChecker("Member variable is a raw-pointer/reference to "
338 "checked-pointer capable type",
339 makeCheckedPtrSafetyModel()) {}
340};
341
342class NoUnretainedMemberChecker final : public RawPtrRefMemberChecker {
343public:
344 NoUnretainedMemberChecker()
345 : RawPtrRefMemberChecker("Member variable is a raw-pointer/reference to "
346 "retainable type",
347 makeRetainPtrSafetyModel()) {}
348};
349
350} // namespace
351
352void ento::registerNoUncountedMemberChecker(CheckerManager &Mgr) {
353 Mgr.registerChecker<NoUncountedMemberChecker>();
354}
355
356bool ento::shouldRegisterNoUncountedMemberChecker(const CheckerManager &Mgr) {
357 return true;
358}
359
360void ento::registerNoUncheckedPtrMemberChecker(CheckerManager &Mgr) {
361 Mgr.registerChecker<NoUncheckedPtrMemberChecker>();
362}
363
364bool ento::shouldRegisterNoUncheckedPtrMemberChecker(
365 const CheckerManager &Mgr) {
366 return true;
367}
368
369void ento::registerNoUnretainedMemberChecker(CheckerManager &Mgr) {
370 Mgr.registerChecker<NoUnretainedMemberChecker>();
371}
372
373bool ento::shouldRegisterNoUnretainedMemberChecker(const CheckerManager &Mgr) {
374 return true;
375}
376