Debian Codegraph @

llvm-project/clang/lib/AST/Interp/Function.h

raw
1 //===--- Function.h - Bytecode function for the VM --------------*- 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 // Defines the Function class which holds all bytecode function-specific data.
10 //
11 // The scope class which describes local variables is also defined here.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #ifndef LLVM_CLANG_AST_INTERP_FUNCTION_H
16 #define LLVM_CLANG_AST_INTERP_FUNCTION_H
17
18 #include "Pointer.h"
19 #include "Source.h"
20 #include "clang/AST/Decl.h"
21 #include "llvm/Support/raw_ostream.h"
22
23 namespace clang {
24 namespace interp {
25 class Program;
26 class ByteCodeEmitter;
27 enum PrimType : uint32_t;
28
29 /// Describes a scope block.
30 ///
31 /// The block gathers all the descriptors of the locals defined in this block.
32 class Scope final {
33 public:
34 /// Information about a local's storage.
35 struct Local {
36 /// Offset of the local in frame.
37 unsigned Offset;
38 /// Descriptor of the local.
39 Descriptor *Desc;
40 };
41
42 using LocalVectorTy = llvm::SmallVector<Local, 8>;
43
44 Scope(LocalVectorTy &&Descriptors) : Descriptors(std::move(Descriptors)) {}
45
46 llvm::iterator_range<LocalVectorTy::const_iterator> locals() const {
47 return llvm::make_range(Descriptors.begin(), Descriptors.end());
48 }
49
50 private:
51 /// Object descriptors in this block.
52 LocalVectorTy Descriptors;
53 };
54
55 /// Bytecode function.
56 ///
57 /// Contains links to the bytecode of the function, as well as metadata
58 /// describing all arguments and stack-local variables.
59 ///
60 /// # Calling Convention
61 ///
62 /// When calling a function, all argument values must be on the stack.
63 ///
64 /// If the function has a This pointer (i.e. hasThisPointer() returns true,
65 /// the argument values need to be preceeded by a Pointer for the This object.
66 ///
67 /// If the function uses Return Value Optimization, the arguments (and
68 /// potentially the This pointer) need to be proceeded by a Pointer pointing
69 /// to the location to construct the returned value.
70 ///
71 /// After the function has been called, it will remove all arguments,
72 /// including RVO and This pointer, from the stack.
73 ///
74 class Function final {
75 public:
76 using ParamDescriptor = std::pair<PrimType, Descriptor *>;
77
78 /// Returns the size of the function's local stack.
79 unsigned getFrameSize() const { return FrameSize; }
80 /// Returns the size of the argument stack.
81 unsigned getArgSize() const { return ArgSize; }
82
83 /// Returns a pointer to the start of the code.
84 CodePtr getCodeBegin() const { return Code.data(); }
85 /// Returns a pointer to the end of the code.
86 CodePtr getCodeEnd() const { return Code.data() + Code.size(); }
87
88 /// Returns the original FunctionDecl.
89 const FunctionDecl *getDecl() const { return F; }
90
91 /// Returns the name of the function decl this code
92 /// was generated for.
93 const std::string getName() const { return F->getNameInfo().getAsString(); }
94
95 /// Returns the location.
96 SourceLocation getLoc() const { return Loc; }
97
98 /// Returns a parameter descriptor.
99 ParamDescriptor getParamDescriptor(unsigned Offset) const;
100
101 /// Checks if the first argument is a RVO pointer.
102 bool hasRVO() const { return HasRVO; }
103
104 /// Range over the scope blocks.
105 llvm::iterator_range<llvm::SmallVector<Scope, 2>::const_iterator>
106 scopes() const {
107 return llvm::make_range(Scopes.begin(), Scopes.end());
108 }
109
110 /// Range over argument types.
111 using arg_reverse_iterator =
112 SmallVectorImpl<PrimType>::const_reverse_iterator;
113 llvm::iterator_range<arg_reverse_iterator> args_reverse() const {
114 return llvm::reverse(ParamTypes);
115 }
116
117 /// Returns a specific scope.
118 Scope &getScope(unsigned Idx) { return Scopes[Idx]; }
119 const Scope &getScope(unsigned Idx) const { return Scopes[Idx]; }
120
121 /// Returns the source information at a given PC.
122 SourceInfo getSource(CodePtr PC) const;
123
124 /// Checks if the function is valid to call in constexpr.
125 bool isConstexpr() const { return IsValid; }
126
127 /// Checks if the function is virtual.
128 bool isVirtual() const;
129
130 /// Checks if the function is a constructor.
131 bool isConstructor() const { return isa<CXXConstructorDecl>(F); }
132
133 /// Checks if the function is fully done compiling.
134 bool isFullyCompiled() const { return IsFullyCompiled; }
135
136 bool hasThisPointer() const { return HasThisPointer; }
137
138 // Checks if the funtion already has a body attached.
139 bool hasBody() const { return HasBody; }
140
141 unsigned getNumParams() const { return ParamTypes.size(); }
142
143 private:
144 /// Construct a function representing an actual function.
145 Function(Program &P, const FunctionDecl *F, unsigned ArgSize,
146 llvm::SmallVector<PrimType, 8> &&ParamTypes,
147 llvm::DenseMap<unsigned, ParamDescriptor> &&Params,
148 bool HasThisPointer, bool HasRVO);
149
150 /// Sets the code of a function.
151 void setCode(unsigned NewFrameSize, std::vector<char> &&NewCode, SourceMap &&NewSrcMap,
152 llvm::SmallVector<Scope, 2> &&NewScopes) {
153 FrameSize = NewFrameSize;
154 Code = std::move(NewCode);
155 SrcMap = std::move(NewSrcMap);
156 Scopes = std::move(NewScopes);
157 IsValid = true;
158 HasBody = true;
159 }
160
161 void setIsFullyCompiled(bool FC) { IsFullyCompiled = FC; }
162
163 private:
164 friend class Program;
165 friend class ByteCodeEmitter;
166
167 /// Program reference.
168 Program &P;
169 /// Location of the executed code.
170 SourceLocation Loc;
171 /// Declaration this function was compiled from.
172 const FunctionDecl *F;
173 /// Local area size: storage + metadata.
174 unsigned FrameSize = 0;
175 /// Size of the argument stack.
176 unsigned ArgSize;
177 /// Program code.
178 std::vector<char> Code;
179 /// Opcode-to-expression mapping.
180 SourceMap SrcMap;
181 /// List of block descriptors.
182 llvm::SmallVector<Scope, 2> Scopes;
183 /// List of argument types.
184 llvm::SmallVector<PrimType, 8> ParamTypes;
185 /// Map from byte offset to parameter descriptor.
186 llvm::DenseMap<unsigned, ParamDescriptor> Params;
187 /// Flag to indicate if the function is valid.
188 bool IsValid = false;
189 /// Flag to indicate if the function is done being
190 /// compiled to bytecode.
191 bool IsFullyCompiled = false;
192 /// Flag indicating if this function takes the this pointer
193 /// as the first implicit argument
194 bool HasThisPointer = false;
195 /// Whether this function has Return Value Optimization, i.e.
196 /// the return value is constructed in the caller's stack frame.
197 /// This is done for functions that return non-primive values.
198 bool HasRVO = false;
199 /// If we've already compiled the function's body.
200 bool HasBody = false;
201
202 public:
203 /// Dumps the disassembled bytecode to \c llvm::errs().
204 void dump() const;
205 void dump(llvm::raw_ostream &OS) const;
206 };
207
208 } // namespace interp
209 } // namespace clang
210
211 #endif