1//===--- CGVTT.cpp - Emit LLVM Code for C++ VTTs --------------------------===//
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 C++ code generation of VTTs (vtable tables).
10//
11//===----------------------------------------------------------------------===//
12
13#include "CodeGenModule.h"
14#include "CGCXXABI.h"
15#include "clang/AST/RecordLayout.h"
16#include "clang/AST/VTTBuilder.h"
17using namespace clang;
18using namespace CodeGen;
19
20static llvm::GlobalVariable *
21GetAddrOfVTTVTable(CodeGenVTables &CGVT, CodeGenModule &CGM,
22 const CXXRecordDecl *MostDerivedClass,
23 const VTTVTable &VTable,
24 llvm::GlobalVariable::LinkageTypes Linkage,
25 VTableLayout::AddressPointsMapTy &AddressPoints) {
26 if (VTable.getBase() == MostDerivedClass) {
27 assert(VTable.getBaseOffset().isZero() &&
28 "Most derived class vtable must have a zero offset!");
29 // This is a regular vtable.
30 return CGM.getCXXABI().getAddrOfVTable(RD: MostDerivedClass, VPtrOffset: CharUnits());
31 }
32
33 return CGVT.GenerateConstructionVTable(RD: MostDerivedClass,
34 Base: VTable.getBaseSubobject(),
35 BaseIsVirtual: VTable.isVirtual(),
36 Linkage,
37 AddressPoints);
38}
39
40void
41CodeGenVTables::EmitVTTDefinition(llvm::GlobalVariable *VTT,
42 llvm::GlobalVariable::LinkageTypes Linkage,
43 const CXXRecordDecl *RD) {
44 VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/true);
45 llvm::ArrayType *ArrayType = llvm::ArrayType::get(
46 ElementType: CGM.GlobalsInt8PtrTy, NumElements: Builder.getVTTComponents().size());
47
48 SmallVector<llvm::GlobalVariable *, 8> VTables;
49 SmallVector<VTableAddressPointsMapTy, 8> VTableAddressPoints;
50 for (const VTTVTable *i = Builder.getVTTVTables().begin(),
51 *e = Builder.getVTTVTables().end(); i != e; ++i) {
52 VTableAddressPoints.push_back(Elt: VTableAddressPointsMapTy());
53 VTables.push_back(Elt: GetAddrOfVTTVTable(CGVT&: *this, CGM, MostDerivedClass: RD, VTable: *i, Linkage,
54 AddressPoints&: VTableAddressPoints.back()));
55 }
56
57 SmallVector<llvm::Constant *, 8> VTTComponents;
58 for (const auto &[Idx, C] : llvm::enumerate(First: Builder.getVTTComponents())) {
59 const VTTVTable &VTTVT = Builder.getVTTVTables()[C.VTableIndex];
60 llvm::GlobalVariable *VTable = VTables[C.VTableIndex];
61 VTableLayout::AddressPointLocation AddressPoint;
62 if (VTTVT.getBase() == RD) {
63 // Just get the address point for the regular vtable.
64 AddressPoint =
65 getItaniumVTableContext().getVTableLayout(RD).getAddressPoint(
66 Base: C.VTableBase);
67 } else {
68 AddressPoint = VTableAddressPoints[C.VTableIndex].lookup(Val: C.VTableBase);
69 assert(AddressPoint.AddressPointIndex != 0 &&
70 "Did not find ctor vtable address point!");
71 }
72
73 llvm::Constant *Idxs[] = {
74 llvm::ConstantInt::get(Ty: CGM.Int32Ty, V: 0),
75 llvm::ConstantInt::get(Ty: CGM.Int32Ty, V: AddressPoint.VTableIndex),
76 llvm::ConstantInt::get(Ty: CGM.Int32Ty, V: AddressPoint.AddressPointIndex),
77 };
78
79 // Add inrange attribute to indicate that only the VTableIndex can be
80 // accessed.
81 unsigned ComponentSize =
82 CGM.getDataLayout().getTypeAllocSize(Ty: getVTableComponentType());
83 unsigned VTableSize = CGM.getDataLayout().getTypeAllocSize(
84 Ty: cast<llvm::StructType>(Val: VTable->getValueType())
85 ->getElementType(N: AddressPoint.VTableIndex));
86 unsigned Offset = ComponentSize * AddressPoint.AddressPointIndex;
87 llvm::ConstantRange InRange(
88 llvm::APInt(32, (int)-Offset, true),
89 llvm::APInt(32, (int)(VTableSize - Offset), true));
90 llvm::Constant *Init = llvm::ConstantExpr::getGetElementPtr(
91 DL: CGM.getDataLayout(), Ty: VTable->getValueType(), C: VTable, IdxList: Idxs,
92 NW: llvm::GEPNoWrapFlags::inBounds(), InRange);
93
94 if (auto PAuthQual =
95 CGM.getVTablePointerAuthentication(thisClass: VTTVT.getBase(),
96 /*IsVTTEntry=*/true)) {
97 llvm::Constant *Address = nullptr;
98 if (PAuthQual->isAddressDiscriminated())
99 Address = llvm::ConstantExpr::getGetElementPtr(
100 DL: CGM.getDataLayout(), Ty: VTT->getType(), C: VTT,
101 IdxList: llvm::ConstantInt::get(Ty: CGM.Int32Ty, V: Idx));
102 auto *Discriminator = llvm::ConstantInt::get(
103 Ty: CGM.IntPtrTy, V: PAuthQual->getExtraDiscriminator());
104 Init = CGM.getConstantSignedPointer(Pointer: Init, Key: PAuthQual->getKey(), StorageAddress: Address,
105 OtherDiscriminator: Discriminator);
106 }
107 VTTComponents.push_back(Elt: Init);
108 }
109
110 llvm::Constant *Init = llvm::ConstantArray::get(T: ArrayType, V: VTTComponents);
111
112 VTT->setInitializer(Init);
113
114 // Set the correct linkage.
115 VTT->setLinkage(Linkage);
116
117 if (CGM.supportsCOMDAT() && VTT->isWeakForLinker())
118 VTT->setComdat(CGM.getModule().getOrInsertComdat(Name: VTT->getName()));
119
120 // Set the visibility. This will already have been set on the VTT declaration.
121 // Set it again, now that we have a definition, as the implicit visibility can
122 // apply differently to definitions.
123 CGM.setGVProperties(GV: VTT, D: RD);
124}
125
126llvm::GlobalVariable *CodeGenVTables::GetAddrOfVTT(const CXXRecordDecl *RD) {
127 assert(RD->getNumVBases() && "Only classes with virtual bases need a VTT");
128
129 SmallString<256> OutName;
130 llvm::raw_svector_ostream Out(OutName);
131 cast<ItaniumMangleContext>(Val&: CGM.getCXXABI().getMangleContext())
132 .mangleCXXVTT(RD, Out);
133 StringRef Name = OutName.str();
134
135 // This will also defer the definition of the VTT.
136 (void) CGM.getCXXABI().getAddrOfVTable(RD, VPtrOffset: CharUnits());
137
138 VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false);
139
140 llvm::ArrayType *ArrayType = llvm::ArrayType::get(
141 ElementType: CGM.GlobalsInt8PtrTy, NumElements: Builder.getVTTComponents().size());
142 llvm::Align Align = CGM.getDataLayout().getABITypeAlign(Ty: CGM.GlobalsInt8PtrTy);
143
144 llvm::GlobalVariable *GV = CGM.CreateOrReplaceCXXRuntimeVariable(
145 Name, Ty: ArrayType, Linkage: llvm::GlobalValue::ExternalLinkage, Alignment: Align);
146 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
147 CGM.setGVProperties(GV, D: RD);
148 return GV;
149}
150
151uint64_t CodeGenVTables::getSubVTTIndex(const CXXRecordDecl *RD,
152 BaseSubobject Base) {
153 BaseSubobjectPairTy ClassSubobjectPair(RD, Base);
154
155 SubVTTIndicesMapTy::iterator I = SubVTTIndices.find(Val: ClassSubobjectPair);
156 if (I != SubVTTIndices.end())
157 return I->second;
158
159 VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false);
160
161 for (llvm::DenseMap<BaseSubobject, uint64_t>::const_iterator
162 I = Builder.getSubVTTIndices().begin(),
163 E = Builder.getSubVTTIndices().end();
164 I != E; ++I) {
165 // Insert all indices.
166 BaseSubobjectPairTy ClassSubobjectPair(RD, I->first);
167
168 SubVTTIndices.insert(KV: std::make_pair(x&: ClassSubobjectPair, y: I->second));
169 }
170
171 I = SubVTTIndices.find(Val: ClassSubobjectPair);
172 assert(I != SubVTTIndices.end() && "Did not find index!");
173
174 return I->second;
175}
176
177uint64_t
178CodeGenVTables::getSecondaryVirtualPointerIndex(const CXXRecordDecl *RD,
179 BaseSubobject Base) {
180 SecondaryVirtualPointerIndicesMapTy::iterator I =
181 SecondaryVirtualPointerIndices.find(Val: std::make_pair(x&: RD, y&: Base));
182
183 if (I != SecondaryVirtualPointerIndices.end())
184 return I->second;
185
186 VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false);
187
188 // Insert all secondary vpointer indices.
189 for (llvm::DenseMap<BaseSubobject, uint64_t>::const_iterator I =
190 Builder.getSecondaryVirtualPointerIndices().begin(),
191 E = Builder.getSecondaryVirtualPointerIndices().end(); I != E; ++I) {
192 std::pair<const CXXRecordDecl *, BaseSubobject> Pair =
193 std::make_pair(x&: RD, y: I->first);
194
195 SecondaryVirtualPointerIndices.insert(KV: std::make_pair(x&: Pair, y: I->second));
196 }
197
198 I = SecondaryVirtualPointerIndices.find(Val: std::make_pair(x&: RD, y&: Base));
199 assert(I != SecondaryVirtualPointerIndices.end() && "Did not find index!");
200
201 return I->second;
202}
203