clang  14.0.0git
Program.h
Go to the documentation of this file.
1 //===--- Program.h - Bytecode for the constexpr 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 a program which organises and links multiple bytecode functions.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_CLANG_AST_INTERP_PROGRAM_H
14 #define LLVM_CLANG_AST_INTERP_PROGRAM_H
15 
16 #include <map>
17 #include <vector>
18 #include "Function.h"
19 #include "Pointer.h"
20 #include "PrimType.h"
21 #include "Record.h"
22 #include "Source.h"
23 #include "llvm/ADT/DenseMap.h"
24 #include "llvm/ADT/PointerUnion.h"
25 #include "llvm/ADT/StringRef.h"
26 #include "llvm/Support/Allocator.h"
27 
28 namespace clang {
29 class RecordDecl;
30 class Expr;
31 class FunctionDecl;
32 class Stmt;
33 class StringLiteral;
34 class VarDecl;
35 
36 namespace interp {
37 class Context;
38 class State;
39 class Record;
40 class Scope;
41 
42 /// The program contains and links the bytecode for all functions.
43 class Program {
44 public:
45  Program(Context &Ctx) : Ctx(Ctx) {}
46 
47  /// Marshals a native pointer to an ID for embedding in bytecode.
48  unsigned getOrCreateNativePointer(const void *Ptr);
49 
50  /// Returns the value of a marshalled native pointer.
51  const void *getNativePointer(unsigned Idx);
52 
53  /// Emits a string literal among global data.
54  unsigned createGlobalString(const StringLiteral *S);
55 
56  /// Returns a pointer to a global.
57  Pointer getPtrGlobal(unsigned Idx);
58 
59  /// Returns the value of a global.
60  Block *getGlobal(unsigned Idx) {
61  assert(Idx < Globals.size());
62  return Globals[Idx]->block();
63  }
64 
65  /// Finds a global's index.
67 
68  /// Returns or creates a global an creates an index to it.
70 
71  /// Returns or creates a dummy value for parameters.
73 
74  /// Creates a global and returns its index.
76 
77  /// Creates a global from a lifetime-extended temporary.
79 
80  /// Creates a new function from a code range.
81  template <typename... Ts>
82  Function *createFunction(const FunctionDecl *Def, Ts &&... Args) {
83  auto *Func = new Function(*this, Def, std::forward<Ts>(Args)...);
84  Funcs.insert({Def, std::unique_ptr<Function>(Func)});
85  return Func;
86  }
87  /// Creates an anonymous function.
88  template <typename... Ts>
89  Function *createFunction(Ts &&... Args) {
90  auto *Func = new Function(*this, std::forward<Ts>(Args)...);
91  AnonFuncs.emplace_back(Func);
92  return Func;
93  }
94 
95  /// Returns a function.
97 
98  /// Returns a pointer to a function if it exists and can be compiled.
99  /// If a function couldn't be compiled, an error is returned.
100  /// If a function was not yet defined, a null pointer is returned.
102 
103  /// Returns a record or creates one if it does not exist.
104  Record *getOrCreateRecord(const RecordDecl *RD);
105 
106  /// Creates a descriptor for a primitive type.
108  bool IsConst = false,
109  bool IsTemporary = false,
110  bool IsMutable = false) {
111  return allocateDescriptor(D, Type, IsConst, IsTemporary, IsMutable);
112  }
113 
114  /// Creates a descriptor for a composite type.
115  Descriptor *createDescriptor(const DeclTy &D, const Type *Ty,
116  bool IsConst = false, bool IsTemporary = false,
117  bool IsMutable = false);
118 
119  /// Context to manage declaration lifetimes.
120  class DeclScope {
121  public:
122  DeclScope(Program &P, const VarDecl *VD) : P(P) { P.startDeclaration(VD); }
123  ~DeclScope() { P.endDeclaration(); }
124 
125  private:
126  Program &P;
127  };
128 
129  /// Returns the current declaration ID.
131  if (CurrentDeclaration == NoDeclaration)
132  return llvm::Optional<unsigned>{};
133  return LastDeclaration;
134  }
135 
136 private:
137  friend class DeclScope;
138 
140  bool IsStatic, bool IsExtern);
141 
142  /// Reference to the VM context.
143  Context &Ctx;
144  /// Mapping from decls to cached bytecode functions.
145  llvm::DenseMap<const FunctionDecl *, std::unique_ptr<Function>> Funcs;
146  /// List of anonymous functions.
147  std::vector<std::unique_ptr<Function>> AnonFuncs;
148 
149  /// Function relocation locations.
150  llvm::DenseMap<const FunctionDecl *, std::vector<unsigned>> Relocs;
151 
152  /// Native pointers referenced by bytecode.
153  std::vector<const void *> NativePointers;
154  /// Cached native pointer indices.
155  llvm::DenseMap<const void *, unsigned> NativePointerIndices;
156 
157  /// Custom allocator for global storage.
158  using PoolAllocTy = llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator>;
159 
160  /// Descriptor + storage for a global object.
161  ///
162  /// Global objects never go out of scope, thus they do not track pointers.
163  class Global {
164  public:
165  /// Create a global descriptor for string literals.
166  template <typename... Tys>
167  Global(Tys... Args) : B(std::forward<Tys>(Args)...) {}
168 
169  /// Allocates the global in the pool, reserving storate for data.
170  void *operator new(size_t Meta, PoolAllocTy &Alloc, size_t Data) {
171  return Alloc.Allocate(Meta + Data, alignof(void *));
172  }
173 
174  /// Return a pointer to the data.
175  char *data() { return B.data(); }
176  /// Return a pointer to the block.
177  Block *block() { return &B; }
178 
179  private:
180  /// Required metadata - does not actually track pointers.
181  Block B;
182  };
183 
184  /// Allocator for globals.
185  PoolAllocTy Allocator;
186 
187  /// Global objects.
188  std::vector<Global *> Globals;
189  /// Cached global indices.
190  llvm::DenseMap<const void *, unsigned> GlobalIndices;
191 
192  /// Mapping from decls to record metadata.
193  llvm::DenseMap<const RecordDecl *, Record *> Records;
194 
195  /// Dummy parameter to generate pointers from.
196  llvm::DenseMap<const ParmVarDecl *, unsigned> DummyParams;
197 
198  /// Creates a new descriptor.
199  template <typename... Ts>
200  Descriptor *allocateDescriptor(Ts &&... Args) {
201  return new (Allocator) Descriptor(std::forward<Ts>(Args)...);
202  }
203 
204  /// No declaration ID.
205  static constexpr unsigned NoDeclaration = (unsigned)-1;
206  /// Last declaration ID.
207  unsigned LastDeclaration = 0;
208  /// Current declaration ID.
209  unsigned CurrentDeclaration = NoDeclaration;
210 
211  /// Starts evaluating a declaration.
212  void startDeclaration(const VarDecl *Decl) {
213  LastDeclaration += 1;
214  CurrentDeclaration = LastDeclaration;
215  }
216 
217  /// Ends a global declaration.
218  void endDeclaration() {
219  CurrentDeclaration = NoDeclaration;
220  }
221 
222 public:
223  /// Dumps the disassembled bytecode to \c llvm::errs().
224  void dump() const;
225  void dump(llvm::raw_ostream &OS) const;
226 };
227 
228 } // namespace interp
229 } // namespace clang
230 
231 #endif
Pointer.h
clang::interp::Program::createFunction
Function * createFunction(Ts &&... Args)
Creates an anonymous function.
Definition: Program.h:89
clang::interp::Program::DeclScope::~DeclScope
~DeclScope()
Definition: Program.h:123
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:673
clang::interp::Program::DeclScope
Context to manage declaration lifetimes.
Definition: Program.h:120
clang::ParmVarDecl
Represents a parameter to a function.
Definition: Decl.h:1665
llvm::Optional< unsigned >
clang::interp::Context
Holds all information required to evaluate constexpr code in a module.
Definition: Context.h:37
clang::interp::Program::getCurrentDecl
llvm::Optional< unsigned > getCurrentDecl() const
Returns the current declaration ID.
Definition: Program.h:130
llvm::Expected
Definition: LLVM.h:41
clang::interp::Program::getFunction
Function * getFunction(const FunctionDecl *F)
Returns a function.
Definition: Program.cpp:203
clang::interp::Pointer
A pointer to a memory block, live or dead.
Definition: Pointer.h:39
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1490
clang::interp::Program::getGlobal
Block * getGlobal(unsigned Idx)
Returns the value of a global.
Definition: Program.h:60
Source.h
clang::interp::Program::DeclScope::DeclScope
DeclScope(Program &P, const VarDecl *VD)
Definition: Program.h:122
clang::interp::Program::createDescriptor
Descriptor * createDescriptor(const DeclTy &D, PrimType Type, bool IsConst=false, bool IsTemporary=false, bool IsMutable=false)
Creates a descriptor for a primitive type.
Definition: Program.h:107
clang::interp::Block
A memory block, either on the stack or in the heap.
Definition: InterpBlock.h:37
clang::interp::PrimType
PrimType
Enumeration of the primitive types of the VM.
Definition: PrimType.h:27
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:876
clang::StringLiteral
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1761
PrimType.h
clang::interp::Program::getOrCreateNativePointer
unsigned getOrCreateNativePointer(const void *Ptr)
Marshals a native pointer to an ID for embedding in bytecode.
Definition: Program.cpp:21
clang::interp::Program::getOrCreateFunction
llvm::Expected< Function * > getOrCreateFunction(const FunctionDecl *F)
Returns a pointer to a function if it exists and can be compiled.
Definition: Program.cpp:209
clang::interp::Program::getOrCreateGlobal
llvm::Optional< unsigned > getOrCreateGlobal(const ValueDecl *VD)
Returns or creates a global an creates an index to it.
Definition: Program.cpp:126
clang::interp::Program::getOrCreateRecord
Record * getOrCreateRecord(const RecordDecl *RD)
Returns a record or creates one if it does not exist.
Definition: Program.cpp:222
clang::interp::Program::getPtrGlobal
Pointer getPtrGlobal(unsigned Idx)
Returns a pointer to a global.
Definition: Program.cpp:97
P
StringRef P
Definition: ASTMatchersInternal.cpp:563
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:676
State
LineState State
Definition: UnwrappedLineFormatter.cpp:986
clang::interp::Program::dump
void dump() const
Dumps the disassembled bytecode to llvm::errs().
Definition: Disasm.cpp:74
std
Definition: Format.h:4034
clang::interp::Program::getOrCreateDummy
llvm::Optional< unsigned > getOrCreateDummy(const ParmVarDecl *PD)
Returns or creates a dummy value for parameters.
Definition: Program.cpp:137
IsStatic
bool IsStatic
Definition: Format.cpp:2345
clang::interp::Descriptor
Describes a memory block created by an allocation site.
Definition: Descriptor.h:51
clang::interp::Program::Program
Program(Context &Ctx)
Definition: Program.h:45
clang
Definition: CalledOnceCheck.h:17
clang::interp::Program::createFunction
Function * createFunction(const FunctionDecl *Def, Ts &&... Args)
Creates a new function from a code range.
Definition: Program.h:82
Function.h
clang::interp::Function
Bytecode function.
Definition: Function.h:59
clang::DeclaratorContext::Block
@ Block
unsigned
clang::interp::DeclTy
unsigned llvm::PointerUnion< const Decl *, const Expr * > DeclTy
Definition: Descriptor.h:26
clang::interp::Program::createGlobalString
unsigned createGlobalString(const StringLiteral *S)
Emits a string literal among global data.
Definition: Program.cpp:36
clang::interp::Program
The program contains and links the bytecode for all functions.
Definition: Program.h:43
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::interp::Program::createGlobal
llvm::Optional< unsigned > createGlobal(const ValueDecl *VD)
Creates a global and returns its index.
Definition: Program.cpp:156
clang::interp::Record
Structure/Class descriptor.
Definition: Record.h:23
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1856
clang::RecordDecl
Represents a struct/union/class.
Definition: Decl.h:3859
clang::interp::Program::getNativePointer
const void * getNativePointer(unsigned Idx)
Returns the value of a marshalled native pointer.
Definition: Program.cpp:32
Record.h