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