1//=======- PtrTypesSemantics.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#ifndef LLVM_CLANG_ANALYZER_WEBKIT_PTRTYPESEMANTICS_H
10#define LLVM_CLANG_ANALYZER_WEBKIT_PTRTYPESEMANTICS_H
11
12#include "llvm/ADT/APInt.h"
13#include "llvm/ADT/DenseMap.h"
14#include "llvm/ADT/DenseSet.h"
15#include "llvm/ADT/PointerUnion.h"
16#include <optional>
17#include <string>
18
19namespace clang {
20class CXXBaseSpecifier;
21class CXXMethodDecl;
22class CXXRecordDecl;
23class Decl;
24class FunctionDecl;
25class NamedDecl;
26class QualType;
27class RecordType;
28class Stmt;
29class TranslationUnitDecl;
30class Type;
31class TypedefDecl;
32class VarDecl;
33
34// Ref-countability of a type is implicitly defined by Ref<T> and RefPtr<T>
35// implementation. It can be modeled as: type T having public methods ref() and
36// deref()
37
38// In WebKit there are two ref-counted templated smart pointers: RefPtr<T> and
39// Ref<T>.
40
41/// \returns CXXRecordDecl of the base if the type has ref as a public method,
42/// nullptr if not, std::nullopt if inconclusive.
43std::optional<const clang::CXXRecordDecl *>
44hasPublicMethodInBase(const CXXBaseSpecifier *Base,
45 llvm::StringRef NameToMatch);
46
47/// \returns true if \p Class is ref-countable, false if not, std::nullopt if
48/// inconclusive.
49std::optional<bool> isRefCountable(const clang::CXXRecordDecl *Class);
50
51/// \returns true if \p Class is checked-pointer compatible, false if not,
52/// std::nullopt if inconclusive.
53std::optional<bool> isCheckedPtrCapable(const clang::CXXRecordDecl *Class);
54
55/// \returns true if \p Class is ref-counted, false if not.
56bool isRefCounted(const clang::CXXRecordDecl *Class);
57
58/// \returns true if \p Class is a CheckedPtr / CheckedRef, false if not.
59bool isCheckedPtr(const clang::CXXRecordDecl *Class);
60
61/// \returns true if \p Class is a RetainPtr, false if not.
62bool isRetainPtrOrOSPtr(const clang::CXXRecordDecl *Class);
63
64/// \returns true if \p Class is a weak smart pointer (WeakPtr, InlineWeakPtr,
65/// etc...), false if not.
66bool isWeakPtr(const clang::CXXRecordDecl *Class);
67
68/// \returns true if \p Class is a smart pointer (RefPtr, WeakPtr, etc...),
69/// false if not.
70bool isSmartPtr(const clang::CXXRecordDecl *Class);
71
72/// \returns true if \p Class is ref-countable AND not ref-counted, false if
73/// not, std::nullopt if inconclusive.
74std::optional<bool> isUncounted(const clang::QualType T);
75
76/// \returns true if \p Class is CheckedPtr capable AND not checked, false if
77/// not, std::nullopt if inconclusive.
78std::optional<bool> isUnchecked(const clang::QualType T);
79
80/// An inter-procedural analysis facility that detects CF types with the
81/// underlying pointer type.
82class RetainTypeChecker {
83 llvm::DenseSet<const RecordType *> CFPointees;
84 llvm::DenseSet<const Type *> RecordlessTypes;
85 bool IsARCEnabled{false};
86 bool DefaultSynthProperties{true};
87
88public:
89 void visitTranslationUnitDecl(const TranslationUnitDecl *);
90 void visitTypedef(const TypedefDecl *);
91 bool isUnretained(const QualType, bool ignoreARC = false);
92 bool isARCEnabled() const { return IsARCEnabled; }
93 bool defaultSynthProperties() const { return DefaultSynthProperties; }
94};
95
96/// \returns true if \p Class is ref-countable AND not ref-counted, false if
97/// not, std::nullopt if inconclusive.
98std::optional<bool> isUncounted(const clang::CXXRecordDecl* Class);
99
100/// \returns true if \p Class is CheckedPtr capable AND not checked, false if
101/// not, std::nullopt if inconclusive.
102std::optional<bool> isUnchecked(const clang::CXXRecordDecl *Class);
103
104/// \returns true if \p T is either a raw pointer or reference to an uncounted
105/// class, false if not, std::nullopt if inconclusive.
106std::optional<bool> isUncountedPtr(const clang::QualType T);
107
108/// \returns true if \p T is either a raw pointer or reference to an unchecked
109/// class, false if not, std::nullopt if inconclusive.
110std::optional<bool> isUncheckedPtr(const clang::QualType T);
111
112/// \returns true if \p T is a RefPtr, Ref, CheckedPtr, CheckedRef, or its
113/// variant, false if not.
114bool isRefOrCheckedPtrType(const clang::QualType T);
115
116/// \returns true if \p T is a RetainPtr, false if not.
117bool isRetainPtrOrOSPtrType(const clang::QualType T);
118
119/// \returns true if \p T is a RefPtr, Ref, CheckedPtr, CheckedRef, or
120/// unique_ptr, false if not.
121bool isOwnerPtrType(const clang::QualType T);
122
123/// \returns true if \p F creates ref-countable object from uncounted parameter,
124/// false if not.
125bool isCtorOfRefCounted(const clang::FunctionDecl *F);
126
127/// \returns true if \p F creates checked ptr object from uncounted parameter,
128/// false if not.
129bool isCtorOfCheckedPtr(const clang::FunctionDecl *F);
130
131/// \returns true if \p F creates ref-countable or checked ptr object from
132/// uncounted parameter, false if not.
133bool isCtorOfSafePtr(const clang::FunctionDecl *F);
134
135/// \returns true if \p F is std::move or WTF::move.
136bool isStdOrWTFMove(const clang::FunctionDecl *F);
137
138/// \returns true if \p Name is RefPtr, Ref, or its variant, false if not.
139bool isRefType(const std::string &Name);
140
141/// \returns true if \p Name is CheckedRef or CheckedPtr, false if not.
142bool isCheckedPtr(const std::string &Name);
143
144/// \returns true if \p Name is RetainPtr or its variant, false if not.
145bool isRetainPtrOrOSPtr(const std::string &Name);
146
147/// \returns true if \p Name is an owning smart pointer such as Ref, CheckedPtr,
148/// and unique_ptr.
149bool isOwnerPtr(const std::string &Name);
150
151/// \returns true if \p Name is a smart pointer type name, false if not.
152bool isSmartPtrClass(const std::string &Name);
153
154/// \returns true if \p M is getter of a ref-counted class, false if not.
155std::optional<bool> isGetterOfSafePtr(const clang::CXXMethodDecl *Method);
156
157/// \returns true if \p F is a conversion between ref-countable or ref-counted
158/// pointer types.
159bool isPtrConversion(const FunctionDecl *F);
160
161/// \returns true if \p F's return type is annotated with
162/// [[clang::annotate_type("webkit.nodelete")]].
163bool isNoDeleteFunction(const FunctionDecl *F);
164
165/// \returns true if \p F is a builtin function which is considered trivial.
166bool isTrivialBuiltinFunction(const FunctionDecl *F);
167
168/// \returns true if \p F is a static singleton function.
169bool isSingleton(const NamedDecl *F);
170
171/// An inter-procedural analysis facility that detects functions with "trivial"
172/// behavior with respect to reference counting, such as simple field getters.
173class TrivialFunctionAnalysis {
174public:
175 /// \returns true if \p D is a "trivial" function.
176 bool isTrivial(const Decl *D, const Stmt **OffendingStmt = nullptr) const {
177 return isTrivialImpl(D, Cache&: TheCache, OffendingStmt);
178 }
179 bool isTrivial(const Stmt *S, const Stmt **OffendingStmt = nullptr) const {
180 return isTrivialImpl(S, Cache&: TheCache, OffendingStmt);
181 }
182 bool hasTrivialDtor(const VarDecl *VD) const {
183 return hasTrivialDtorImpl(VD, Cache&: TheCache);
184 }
185
186private:
187 friend class TrivialFunctionAnalysisVisitor;
188
189 using CacheTy =
190 llvm::DenseMap<llvm::PointerUnion<const Decl *, const Stmt *>, bool>;
191 mutable CacheTy TheCache{};
192
193 static bool isTrivialImpl(const Decl *D, CacheTy &Cache, const Stmt **);
194 static bool isTrivialImpl(const Stmt *S, CacheTy &Cache, const Stmt **);
195 static bool hasTrivialDtorImpl(const VarDecl *VD, CacheTy &Cache);
196};
197
198} // namespace clang
199
200#endif
201