clang 18.0.0git
InterpBlock.h
Go to the documentation of this file.
1//===-- InterpBlock.h - Allocated blocks for the interpreter -*- 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 classes describing allocated blocks.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_AST_INTERP_BLOCK_H
14#define LLVM_CLANG_AST_INTERP_BLOCK_H
15
16#include "Descriptor.h"
17#include "clang/AST/Decl.h"
18#include "clang/AST/DeclCXX.h"
19#include "clang/AST/Expr.h"
21#include "llvm/ADT/PointerUnion.h"
22#include "llvm/Support/raw_ostream.h"
23
24namespace clang {
25namespace interp {
26class Block;
27class DeadBlock;
28class InterpState;
29class Pointer;
30enum PrimType : unsigned;
31
32/// A memory block, either on the stack or in the heap.
33///
34/// The storage described by the block is immediately followed by
35/// optional metadata, which is followed by the actual data.
36///
37/// Block* rawData() data()
38/// │ │ │
39/// │ │ │
40/// ▼ ▼ ▼
41/// ┌───────────────┬─────────────────────────┬─────────────────┐
42/// │ Block │ Metadata │ Data │
43/// │ sizeof(Block) │ Desc->getMetadataSize() │ Desc->getSize() │
44/// └───────────────┴─────────────────────────┴─────────────────┘
45///
46/// Desc->getAllocSize() describes the size after the Block, i.e.
47/// the data size and the metadata size.
48///
49class Block final {
50public:
51 /// Creates a new block.
52 Block(const std::optional<unsigned> &DeclID, Descriptor *Desc,
53 bool IsStatic = false, bool IsExtern = false)
55
56 Block(Descriptor *Desc, bool IsStatic = false, bool IsExtern = false)
58 Desc(Desc) {}
59
60 /// Returns the block's descriptor.
61 const Descriptor *getDescriptor() const { return Desc; }
62 /// Checks if the block has any live pointers.
63 bool hasPointers() const { return Pointers; }
64 /// Checks if the block is extern.
65 bool isExtern() const { return IsExtern; }
66 /// Checks if the block has static storage duration.
67 bool isStatic() const { return IsStatic; }
68 /// Checks if the block is temporary.
69 bool isTemporary() const { return Desc->IsTemporary; }
70 /// Returns the size of the block.
71 unsigned getSize() const { return Desc->getAllocSize(); }
72 /// Returns the declaration ID.
73 std::optional<unsigned> getDeclID() const { return DeclID; }
74
75 /// Returns a pointer to the stored data.
76 /// You are allowed to read Desc->getSize() bytes from this address.
77 std::byte *data() {
78 // rawData might contain metadata as well.
79 size_t DataOffset = Desc->getMetadataSize();
80 return rawData() + DataOffset;
81 }
82 const std::byte *data() const {
83 // rawData might contain metadata as well.
84 size_t DataOffset = Desc->getMetadataSize();
85 return rawData() + DataOffset;
86 }
87
88 /// Returns a pointer to the raw data, including metadata.
89 /// You are allowed to read Desc->getAllocSize() bytes from this address.
90 std::byte *rawData() {
91 return reinterpret_cast<std::byte *>(this) + sizeof(Block);
92 }
93 const std::byte *rawData() const {
94 return reinterpret_cast<const std::byte *>(this) + sizeof(Block);
95 }
96
97 /// Returns a view over the data.
98 template <typename T>
99 T &deref() { return *reinterpret_cast<T *>(data()); }
100
101 /// Invokes the constructor.
102 void invokeCtor() {
103 std::memset(rawData(), 0, Desc->getAllocSize());
104 if (Desc->CtorFn)
106 /*isActive=*/true, Desc);
107 }
108
109 /// Invokes the Destructor.
110 void invokeDtor() {
111 if (Desc->DtorFn)
112 Desc->DtorFn(this, data(), Desc);
113 }
114
115protected:
116 friend class Pointer;
117 friend class DeadBlock;
118 friend class InterpState;
119
122
123 /// Deletes a dead block at the end of its lifetime.
124 void cleanup();
125
126 /// Pointer chain management.
127 void addPointer(Pointer *P);
128 void removePointer(Pointer *P);
129 void replacePointer(Pointer *Old, Pointer *New);
130#ifndef NDEBUG
131 bool hasPointer(const Pointer *P) const;
132#endif
133
134 /// Start of the chain of pointers.
135 Pointer *Pointers = nullptr;
136 /// Unique identifier of the declaration.
137 std::optional<unsigned> DeclID;
138 /// Flag indicating if the block has static storage duration.
139 bool IsStatic = false;
140 /// Flag indicating if the block is an extern.
141 bool IsExtern = false;
142 /// Flag indicating if the pointer is dead.
143 bool IsDead = false;
144 /// Pointer to the stack slot descriptor.
146};
147
148/// Descriptor for a dead block.
149///
150/// Dead blocks are chained in a double-linked list to deallocate them
151/// whenever pointers become dead.
152class DeadBlock final {
153public:
154 /// Copies the block.
155 DeadBlock(DeadBlock *&Root, Block *Blk);
156
157 /// Returns a pointer to the stored data.
158 std::byte *data() { return B.data(); }
159 std::byte *rawData() { return B.rawData(); }
160
161private:
162 friend class Block;
163 friend class InterpState;
164
165 void free();
166
167 /// Root pointer of the list.
168 DeadBlock *&Root;
169 /// Previous block in the list.
170 DeadBlock *Prev;
171 /// Next block in the list.
172 DeadBlock *Next;
173
174 /// Actual block storing data and tracking pointers.
175 Block B;
176};
177
178} // namespace interp
179} // namespace clang
180
181#endif
StringRef P
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
const CFGBlock * Block
Definition: HTMLLogger.cpp:150
A memory block, either on the stack or in the heap.
Definition: InterpBlock.h:49
unsigned getSize() const
Returns the size of the block.
Definition: InterpBlock.h:71
bool IsExtern
Flag indicating if the block is an extern.
Definition: InterpBlock.h:141
void addPointer(Pointer *P)
Pointer chain management.
Definition: InterpBlock.cpp:19
void replacePointer(Pointer *Old, Pointer *New)
Definition: InterpBlock.cpp:61
void invokeDtor()
Invokes the Destructor.
Definition: InterpBlock.h:110
bool isExtern() const
Checks if the block is extern.
Definition: InterpBlock.h:65
Block(Descriptor *Desc, bool IsStatic=false, bool IsExtern=false)
Definition: InterpBlock.h:56
std::byte * data()
Returns a pointer to the stored data.
Definition: InterpBlock.h:77
Descriptor * Desc
Pointer to the stack slot descriptor.
Definition: InterpBlock.h:145
const Descriptor * getDescriptor() const
Returns the block's descriptor.
Definition: InterpBlock.h:61
bool hasPointer(const Pointer *P) const
Definition: InterpBlock.cpp:85
void removePointer(Pointer *P)
Definition: InterpBlock.cpp:36
const std::byte * rawData() const
Definition: InterpBlock.h:93
void invokeCtor()
Invokes the constructor.
Definition: InterpBlock.h:102
bool isStatic() const
Checks if the block has static storage duration.
Definition: InterpBlock.h:67
bool isTemporary() const
Checks if the block is temporary.
Definition: InterpBlock.h:69
std::byte * rawData()
Returns a pointer to the raw data, including metadata.
Definition: InterpBlock.h:90
const std::byte * data() const
Definition: InterpBlock.h:82
T & deref()
Returns a view over the data.
Definition: InterpBlock.h:99
void cleanup()
Deletes a dead block at the end of its lifetime.
Definition: InterpBlock.cpp:56
bool IsStatic
Flag indicating if the block has static storage duration.
Definition: InterpBlock.h:139
Pointer * Pointers
Start of the chain of pointers.
Definition: InterpBlock.h:135
Block(const std::optional< unsigned > &DeclID, Descriptor *Desc, bool IsStatic=false, bool IsExtern=false)
Creates a new block.
Definition: InterpBlock.h:52
Block(Descriptor *Desc, bool IsExtern, bool IsStatic, bool IsDead)
Definition: InterpBlock.h:120
bool IsDead
Flag indicating if the pointer is dead.
Definition: InterpBlock.h:143
std::optional< unsigned > DeclID
Unique identifier of the declaration.
Definition: InterpBlock.h:137
std::optional< unsigned > getDeclID() const
Returns the declaration ID.
Definition: InterpBlock.h:73
bool hasPointers() const
Checks if the block has any live pointers.
Definition: InterpBlock.h:63
Descriptor for a dead block.
Definition: InterpBlock.h:152
std::byte * data()
Returns a pointer to the stored data.
Definition: InterpBlock.h:158
Interpreter context.
Definition: InterpState.h:35
A pointer to a memory block, live or dead.
Definition: Pointer.h:65
PrimType
Enumeration of the primitive types of the VM.
Definition: PrimType.h:32
#define true
Definition: stdbool.h:21
Describes a memory block created by an allocation site.
Definition: Descriptor.h:77
const bool IsConst
Flag indicating if the block is mutable.
Definition: Descriptor.h:105
unsigned getAllocSize() const
Returns the allocated size, including metadata.
Definition: Descriptor.h:166
const BlockDtorFn DtorFn
Definition: Descriptor.h:115
const BlockCtorFn CtorFn
Storage management methods.
Definition: Descriptor.h:114
unsigned getMetadataSize() const
Returns the size of the metadata.
Definition: Descriptor.h:170
const bool IsMutable
Flag indicating if a field is mutable.
Definition: Descriptor.h:107
const bool IsTemporary
Flag indicating if the block is a temporary.
Definition: Descriptor.h:109