1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
#pragma once
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
//=== AnyCall.h - Abstraction over different callables --------*- C++ -*--//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// A utility class for performing generic operations over different callables.
//
//===----------------------------------------------------------------------===//
//
#ifndef LLVM_CLANG_ANALYSIS_ANYCALL_H
#define LLVM_CLANG_ANALYSIS_ANYCALL_H
#include "clang/AST/Decl.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/ExprObjC.h"
#include <optional>
namespace clang {
/// An instance of this class corresponds to a call.
/// It might be a syntactically-concrete call, done as a part of evaluating an
/// expression, or it may be an abstract callee with no associated expression.
class AnyCall {
public:
enum Kind {
/// A function, function pointer, or a C++ method call
Function,
/// A call to an Objective-C method
ObjCMethod,
/// A call to an Objective-C block
Block,
/// An implicit C++ destructor call (called implicitly
/// or by operator 'delete')
Destructor,
/// An implicit or explicit C++ constructor call
Constructor,
/// A C++ inherited constructor produced by a "using T::T" directive
InheritedConstructor,
/// A C++ allocation function call (operator `new`), via C++ new-expression
Allocator,
/// A C++ deallocation function call (operator `delete`), via C++
/// delete-expression
Deallocator
};
private:
/// Either expression or declaration (but not both at the same time)
/// can be null.
/// Call expression, is null when is not known (then declaration is non-null),
/// or for implicit destructor calls (when no expression exists.)
const Expr *E = nullptr;
/// Corresponds to a statically known declaration of the called function,
/// or null if it is not known (e.g. for a function pointer).
const Decl *D = nullptr;
Kind K;
public:
AnyCall(const CallExpr *CE) : E(CE) {
D = CE->getCalleeDecl();
K = (CE->getCallee()->getType()->getAs<BlockPointerType>()) ? Block
: Function;
if (D && ((K == Function && !isa<FunctionDecl>(D)) ||
(K == Block && !isa<BlockDecl>(D))))
D = nullptr;
}
AnyCall(const ObjCMessageExpr *ME)
: E(ME), D(ME->getMethodDecl()), K(ObjCMethod) {}
AnyCall(const CXXNewExpr *NE)
: E(NE), D(NE->getOperatorNew()), K(Allocator) {}
AnyCall(const CXXDeleteExpr *NE)
: E(NE), D(NE->getOperatorDelete()), K(Deallocator) {}
AnyCall(const CXXConstructExpr *NE)
: E(NE), D(NE->getConstructor()), K(Constructor) {}
AnyCall(const CXXInheritedCtorInitExpr *CIE)
: E(CIE), D(CIE->getConstructor()), K(InheritedConstructor) {}
AnyCall(const CXXDestructorDecl *D) : E(nullptr), D(D), K(Destructor) {}
AnyCall(const CXXConstructorDecl *D) : E(nullptr), D(D), K(Constructor) {}
AnyCall(const ObjCMethodDecl *D) : E(nullptr), D(D), K(ObjCMethod) {}
AnyCall(const FunctionDecl *D) : E(nullptr), D(D) {
if (isa<CXXConstructorDecl>(D)) {
K = Constructor;
} else if (isa <CXXDestructorDecl>(D)) {
K = Destructor;
} else {
K = Function;
}
}
/// If @c E is a generic call (to ObjC method /function/block/etc),
/// return a constructed @c AnyCall object. Return std::nullopt otherwise.
static std::optional<AnyCall> forExpr(const Expr *E) {
if (const auto *ME = dyn_cast<ObjCMessageExpr>(E)) {
return AnyCall(ME);
} else if (const auto *CE = dyn_cast<CallExpr>(E)) {
return AnyCall(CE);
} else if (const auto *CXNE = dyn_cast<CXXNewExpr>(E)) {
return AnyCall(CXNE);
} else if (const auto *CXDE = dyn_cast<CXXDeleteExpr>(E)) {
return AnyCall(CXDE);
} else if (const auto *CXCE = dyn_cast<CXXConstructExpr>(E)) {
return AnyCall(CXCE);
} else if (const auto *CXCIE = dyn_cast<CXXInheritedCtorInitExpr>(E)) {
return AnyCall(CXCIE);
} else {
return std::nullopt;
}
}
/// If @c D is a callable (Objective-C method or a function), return
/// a constructed @c AnyCall object. Return std::nullopt otherwise.
// FIXME: block support.
static std::optional<AnyCall> forDecl(const Decl *D) {
if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
return AnyCall(FD);
} else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
return AnyCall(MD);
}
return std::nullopt;
}
/// \returns formal parameters for direct calls (including virtual calls)
ArrayRef<ParmVarDecl *> parameters() const {
if (!D)
return std::nullopt;
if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
return FD->parameters();
} else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
return MD->parameters();
} else if (const auto *BD = dyn_cast<BlockDecl>(D)) {
return BD->parameters();
} else {
return std::nullopt;
}
}
using param_const_iterator = ArrayRef<ParmVarDecl *>::const_iterator;
param_const_iterator param_begin() const { return parameters().begin(); }
param_const_iterator param_end() const { return parameters().end(); }
size_t param_size() const { return parameters().size(); }
bool param_empty() const { return parameters().empty(); }
QualType getReturnType(ASTContext &Ctx) const {
switch (K) {
case Function:
if (E)
return cast<CallExpr>(E)->getCallReturnType(Ctx);
return cast<FunctionDecl>(D)->getReturnType();
case ObjCMethod:
if (E)
return cast<ObjCMessageExpr>(E)->getCallReturnType(Ctx);
return cast<ObjCMethodDecl>(D)->getReturnType();
case Block:
// FIXME: BlockDecl does not know its return type,
// hence the asymmetry with the function and method cases above.
return cast<CallExpr>(E)->getCallReturnType(Ctx);
case Destructor:
case Constructor:
case InheritedConstructor:
case Allocator:
case Deallocator:
return cast<FunctionDecl>(D)->getReturnType();
}
llvm_unreachable("Unknown AnyCall::Kind");
}
/// \returns Function identifier if it is a named declaration,
/// @c nullptr otherwise.
const IdentifierInfo *getIdentifier() const {
if (const auto *ND = dyn_cast_or_null<NamedDecl>(D))
return ND->getIdentifier();
return nullptr;
}
const Decl *getDecl() const {
return D;
}
const Expr *getExpr() const {
return E;
}
Kind getKind() const {
return K;
}
void dump() const {
if (E)
E->dump();
if (D)
D->dump();
}
};
}
#endif // LLVM_CLANG_ANALYSIS_ANYCALL_H
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
|
