VTTBuilder.h source code [clang_source_code/include/clang/AST/VTTBuilder.h]

1	//===- VTTBuilder.h - C++ VTT layout builder --------------------- 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	// This contains code dealing with generation of the layout of virtual table
10	// tables (VTT).
11	//
12	//===----------------------------------------------------------------------===//
13
14	#ifndef LLVM_CLANG_AST_VTTBUILDER_H
15	#define LLVM_CLANG_AST_VTTBUILDER_H
16
17	#include "clang/AST/BaseSubobject.h"
18	#include "clang/AST/CharUnits.h"
19	#include "clang/Basic/LLVM.h"
20	#include "llvm/ADT/DenseMap.h"
21	#include "llvm/ADT/PointerIntPair.h"
22	#include "llvm/ADT/SmallPtrSet.h"
23	#include "llvm/ADT/SmallVector.h"
24	#include <cstdint>
25
26	namespace clang {
27
28	class ASTContext;
29	class ASTRecordLayout;
30	class CXXRecordDecl;
31
32	class VTTVTable {
33	llvm::PointerIntPair<const CXXRecordDecl *, 1, bool> BaseAndIsVirtual;
34	CharUnits BaseOffset;
35
36	public:
37	VTTVTable() = default;
38	VTTVTable(const CXXRecordDecl *Base, CharUnits BaseOffset, bool BaseIsVirtual)
39	: BaseAndIsVirtual(Base, BaseIsVirtual), BaseOffset(BaseOffset) {}
40	VTTVTable(BaseSubobject Base, bool BaseIsVirtual)
41	: BaseAndIsVirtual(Base.getBase(), BaseIsVirtual),
42	BaseOffset(Base.getBaseOffset()) {}
43
44	const CXXRecordDecl *getBase() const {
45	return BaseAndIsVirtual.getPointer();
46	}
47
48	CharUnits getBaseOffset() const {
49	return BaseOffset;
50	}
51
52	bool isVirtual() const {
53	return BaseAndIsVirtual.getInt();
54	}
55
56	BaseSubobject getBaseSubobject() const {
57	return BaseSubobject(getBase(), getBaseOffset());
58	}
59	};
60
61	struct VTTComponent {
62	uint64_t VTableIndex;
63	BaseSubobject VTableBase;
64
65	VTTComponent() = default;
66	VTTComponent(uint64_t VTableIndex, BaseSubobject VTableBase)
67	: VTableIndex(VTableIndex), VTableBase(VTableBase) {}
68	};
69
70	/// Class for building VTT layout information.
71	class VTTBuilder {
72	ASTContext &Ctx;
73
74	/// The most derived class for which we're building this vtable.
75	const CXXRecordDecl *MostDerivedClass;
76
77	using VTTVTablesVectorTy = SmallVector<VTTVTable, 64>;
78
79	/// The VTT vtables.
80	VTTVTablesVectorTy VTTVTables;
81
82	using VTTComponentsVectorTy = SmallVector<VTTComponent, 64>;
83
84	/// The VTT components.
85	VTTComponentsVectorTy VTTComponents;
86
87	/// The AST record layout of the most derived class.
88	const ASTRecordLayout &MostDerivedClassLayout;
89
90	using VisitedVirtualBasesSetTy = llvm::SmallPtrSet<const CXXRecordDecl *, 4>;
91
92	using AddressPointsMapTy = llvm::DenseMap<BaseSubobject, uint64_t>;
93
94	/// The sub-VTT indices for the bases of the most derived class.
95	llvm::DenseMap<BaseSubobject, uint64_t> SubVTTIndicies;
96
97	/// The secondary virtual pointer indices of all subobjects of
98	/// the most derived class.
99	llvm::DenseMap<BaseSubobject, uint64_t> SecondaryVirtualPointerIndices;
100
101	/// Whether the VTT builder should generate LLVM IR for the VTT.
102	bool GenerateDefinition;
103
104	/// Add a vtable pointer to the VTT currently being built.
105	void AddVTablePointer(BaseSubobject Base, uint64_t VTableIndex,
106	const CXXRecordDecl *VTableClass);
107
108	/// Lay out the secondary VTTs of the given base subobject.
109	void LayoutSecondaryVTTs(BaseSubobject Base);
110
111	/// Lay out the secondary virtual pointers for the given base
112	/// subobject.
113	///
114	/// \param BaseIsMorallyVirtual whether the base subobject is a virtual base
115	/// or a direct or indirect base of a virtual base.
116	void LayoutSecondaryVirtualPointers(BaseSubobject Base,
117	bool BaseIsMorallyVirtual,
118	uint64_t VTableIndex,
119	const CXXRecordDecl *VTableClass,
120	VisitedVirtualBasesSetTy &VBases);
121
122	/// Lay out the secondary virtual pointers for the given base
123	/// subobject.
124	void LayoutSecondaryVirtualPointers(BaseSubobject Base,
125	uint64_t VTableIndex);
126
127	/// Lay out the VTTs for the virtual base classes of the given
128	/// record declaration.
129	void LayoutVirtualVTTs(const CXXRecordDecl *RD,
130	VisitedVirtualBasesSetTy &VBases);
131
132	/// Lay out the VTT for the given subobject, including any
133	/// secondary VTTs, secondary virtual pointers and virtual VTTs.
134	void LayoutVTT(BaseSubobject Base, bool BaseIsVirtual);
135
136	public:
137	VTTBuilder(ASTContext &Ctx, const CXXRecordDecl *MostDerivedClass,
138	bool GenerateDefinition);
139
140	// Returns a reference to the VTT components.
141	const VTTComponentsVectorTy &getVTTComponents() const {
142	return VTTComponents;
143	}
144
145	// Returns a reference to the VTT vtables.
146	const VTTVTablesVectorTy &getVTTVTables() const {
147	return VTTVTables;
148	}
149
150	/// Returns a reference to the sub-VTT indices.
151	const llvm::DenseMap<BaseSubobject, uint64_t> &getSubVTTIndicies() const {
152	return SubVTTIndicies;
153	}
154
155	/// Returns a reference to the secondary virtual pointer indices.
156	const llvm::DenseMap<BaseSubobject, uint64_t> &
157	getSecondaryVirtualPointerIndices() const {
158	return SecondaryVirtualPointerIndices;
159	}
160	};
161
162	} // namespace clang
163
164	#endif // LLVM_CLANG_AST_VTTBUILDER_H
165