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
|
//===--- Function.h - Bytecode function for the VM --------------*- 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
//
//===----------------------------------------------------------------------===//
//
// Defines the Function class which holds all bytecode function-specific data.
//
// The scope class which describes local variables is also defined here.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_AST_INTERP_FUNCTION_H
#define LLVM_CLANG_AST_INTERP_FUNCTION_H
#include "Pointer.h"
#include "Source.h"
#include "clang/AST/Decl.h"
#include "llvm/Support/raw_ostream.h"
namespace clang {
namespace interp {
class Program;
class ByteCodeEmitter;
enum PrimType : uint32_t;
/// Describes a scope block.
///
/// The block gathers all the descriptors of the locals defined in this block.
class Scope final {
public:
/// Information about a local's storage.
struct Local {
/// Offset of the local in frame.
unsigned Offset;
/// Descriptor of the local.
Descriptor *Desc;
};
using LocalVectorTy = llvm::SmallVector<Local, 8>;
Scope(LocalVectorTy &&Descriptors) : Descriptors(std::move(Descriptors)) {}
llvm::iterator_range<LocalVectorTy::const_iterator> locals() const {
return llvm::make_range(Descriptors.begin(), Descriptors.end());
}
private:
/// Object descriptors in this block.
LocalVectorTy Descriptors;
};
/// Bytecode function.
///
/// Contains links to the bytecode of the function, as well as metadata
/// describing all arguments and stack-local variables.
///
/// # Calling Convention
///
/// When calling a function, all argument values must be on the stack.
///
/// If the function has a This pointer (i.e. hasThisPointer() returns true,
/// the argument values need to be preceeded by a Pointer for the This object.
///
/// If the function uses Return Value Optimization, the arguments (and
/// potentially the This pointer) need to be proceeded by a Pointer pointing
/// to the location to construct the returned value.
///
/// After the function has been called, it will remove all arguments,
/// including RVO and This pointer, from the stack.
///
class Function final {
public:
using ParamDescriptor = std::pair<PrimType, Descriptor *>;
/// Returns the size of the function's local stack.
unsigned getFrameSize() const { return FrameSize; }
/// Returns the size of the argument stack.
unsigned getArgSize() const { return ArgSize; }
/// Returns a pointer to the start of the code.
CodePtr getCodeBegin() const { return Code.data(); }
/// Returns a pointer to the end of the code.
CodePtr getCodeEnd() const { return Code.data() + Code.size(); }
/// Returns the original FunctionDecl.
const FunctionDecl *getDecl() const { return F; }
/// Returns the name of the function decl this code
/// was generated for.
const std::string getName() const { return F->getNameInfo().getAsString(); }
/// Returns the location.
SourceLocation getLoc() const { return Loc; }
/// Returns a parameter descriptor.
ParamDescriptor getParamDescriptor(unsigned Offset) const;
/// Checks if the first argument is a RVO pointer.
bool hasRVO() const { return HasRVO; }
/// Range over the scope blocks.
llvm::iterator_range<llvm::SmallVector<Scope, 2>::const_iterator>
scopes() const {
return llvm::make_range(Scopes.begin(), Scopes.end());
}
/// Range over argument types.
using arg_reverse_iterator =
SmallVectorImpl<PrimType>::const_reverse_iterator;
llvm::iterator_range<arg_reverse_iterator> args_reverse() const {
return llvm::reverse(ParamTypes);
}
/// Returns a specific scope.
Scope &getScope(unsigned Idx) { return Scopes[Idx]; }
const Scope &getScope(unsigned Idx) const { return Scopes[Idx]; }
/// Returns the source information at a given PC.
SourceInfo getSource(CodePtr PC) const;
/// Checks if the function is valid to call in constexpr.
bool isConstexpr() const { return IsValid; }
/// Checks if the function is virtual.
bool isVirtual() const;
/// Checks if the function is a constructor.
bool isConstructor() const { return isa<CXXConstructorDecl>(F); }
/// Checks if the function is fully done compiling.
bool isFullyCompiled() const { return IsFullyCompiled; }
bool hasThisPointer() const { return HasThisPointer; }
// Checks if the funtion already has a body attached.
bool hasBody() const { return HasBody; }
unsigned getNumParams() const { return ParamTypes.size(); }
private:
/// Construct a function representing an actual function.
Function(Program &P, const FunctionDecl *F, unsigned ArgSize,
llvm::SmallVector<PrimType, 8> &&ParamTypes,
llvm::DenseMap<unsigned, ParamDescriptor> &&Params,
bool HasThisPointer, bool HasRVO);
/// Sets the code of a function.
void setCode(unsigned NewFrameSize, std::vector<char> &&NewCode, SourceMap &&NewSrcMap,
llvm::SmallVector<Scope, 2> &&NewScopes) {
FrameSize = NewFrameSize;
Code = std::move(NewCode);
SrcMap = std::move(NewSrcMap);
Scopes = std::move(NewScopes);
IsValid = true;
HasBody = true;
}
void setIsFullyCompiled(bool FC) { IsFullyCompiled = FC; }
private:
friend class Program;
friend class ByteCodeEmitter;
/// Program reference.
Program &P;
/// Location of the executed code.
SourceLocation Loc;
/// Declaration this function was compiled from.
const FunctionDecl *F;
/// Local area size: storage + metadata.
unsigned FrameSize = 0;
/// Size of the argument stack.
unsigned ArgSize;
/// Program code.
std::vector<char> Code;
/// Opcode-to-expression mapping.
SourceMap SrcMap;
/// List of block descriptors.
llvm::SmallVector<Scope, 2> Scopes;
/// List of argument types.
llvm::SmallVector<PrimType, 8> ParamTypes;
/// Map from byte offset to parameter descriptor.
llvm::DenseMap<unsigned, ParamDescriptor> Params;
/// Flag to indicate if the function is valid.
bool IsValid = false;
/// Flag to indicate if the function is done being
/// compiled to bytecode.
bool IsFullyCompiled = false;
/// Flag indicating if this function takes the this pointer
/// as the first implicit argument
bool HasThisPointer = false;
/// Whether this function has Return Value Optimization, i.e.
/// the return value is constructed in the caller's stack frame.
/// This is done for functions that return non-primive values.
bool HasRVO = false;
/// If we've already compiled the function's body.
bool HasBody = false;
public:
/// Dumps the disassembled bytecode to \c llvm::errs().
void dump() const;
void dump(llvm::raw_ostream &OS) const;
};
} // namespace interp
} // namespace clang
#endif
|
