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
| //===--- 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 {
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::iterator> locals() {
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.
class Function {
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 stackx
unsigned getArgSize() const { return ArgSize; }
/// Returns a pointer to the start of the code.
CodePtr getCodeBegin() const;
/// Returns a pointer to the end of the code.
CodePtr getCodeEnd() const;
/// Returns the original FunctionDecl.
const FunctionDecl *getDecl() const { return F; }
/// Returns the lcoation.
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 ParamTypes.size() != Params.size(); }
/// Range over the scope blocks.
llvm::iterator_range<llvm::SmallVector<Scope, 2>::iterator> scopes() {
return llvm::make_range(Scopes.begin(), Scopes.end());
}
/// Range over argument types.
using arg_reverse_iterator = SmallVectorImpl<PrimType>::reverse_iterator;
llvm::iterator_range<arg_reverse_iterator> args_reverse() {
return llvm::make_range(ParamTypes.rbegin(), ParamTypes.rend());
}
/// Returns a specific scope.
Scope &getScope(unsigned Idx) { 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); }
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);
/// 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;
}
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;
/// 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;
public:
/// Dumps the disassembled bytecode to \c llvm::errs().
void dump() const;
void dump(llvm::raw_ostream &OS) const;
};
} // namespace interp
} // namespace clang
#endif
|