xref: /freebsd/contrib/llvm-project/clang/lib/AST/Interp/Function.h (revision 9f23cbd6cae82fd77edfad7173432fa8dccd0a95)
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
212