1 //===--- CGVTT.cpp - Emit LLVM Code for C++ VTTs --------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This contains code dealing with C++ code generation of VTTs (vtable tables).
12 //===----------------------------------------------------------------------===//
14 #include "CodeGenModule.h"
16 #include "clang/AST/RecordLayout.h"
17 #include "clang/AST/VTTBuilder.h"
18 using namespace clang;
19 using namespace CodeGen;
23 llvm::Constant *GetAddrOfVTTVTable(CodeGenVTables &CGVT,
24 const CXXRecordDecl *MostDerivedClass,
25 const VTTVTable &VTable,
26 llvm::GlobalVariable::LinkageTypes Linkage,
27 llvm::DenseMap<BaseSubobject, uint64_t> &AddressPoints) {
28 if (VTable.getBase() == MostDerivedClass) {
29 assert(VTable.getBaseOffset().isZero() &&
30 "Most derived class vtable must have a zero offset!");
31 // This is a regular vtable.
32 return CGVT.GetAddrOfVTable(MostDerivedClass);
35 return CGVT.GenerateConstructionVTable(MostDerivedClass,
36 VTable.getBaseSubobject(),
43 CodeGenVTables::EmitVTTDefinition(llvm::GlobalVariable *VTT,
44 llvm::GlobalVariable::LinkageTypes Linkage,
45 const CXXRecordDecl *RD) {
46 VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/true);
48 llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext()),
49 *Int64Ty = llvm::Type::getInt64Ty(CGM.getLLVMContext());
50 llvm::ArrayType *ArrayType =
51 llvm::ArrayType::get(Int8PtrTy, Builder.getVTTComponents().size());
53 SmallVector<llvm::Constant *, 8> VTables;
54 SmallVector<VTableAddressPointsMapTy, 8> VTableAddressPoints;
55 for (const VTTVTable *i = Builder.getVTTVTables().begin(),
56 *e = Builder.getVTTVTables().end(); i != e; ++i) {
57 VTableAddressPoints.push_back(VTableAddressPointsMapTy());
58 VTables.push_back(GetAddrOfVTTVTable(*this, RD, *i, Linkage,
59 VTableAddressPoints.back()));
62 SmallVector<llvm::Constant *, 8> VTTComponents;
63 for (const VTTComponent *i = Builder.getVTTComponents().begin(),
64 *e = Builder.getVTTComponents().end(); i != e; ++i) {
65 const VTTVTable &VTTVT = Builder.getVTTVTables()[i->VTableIndex];
66 llvm::Constant *VTable = VTables[i->VTableIndex];
67 uint64_t AddressPoint;
68 if (VTTVT.getBase() == RD) {
69 // Just get the address point for the regular vtable.
70 AddressPoint = VTContext.getVTableLayout(RD)
71 .getAddressPoint(i->VTableBase);
72 assert(AddressPoint != 0 && "Did not find vtable address point!");
74 AddressPoint = VTableAddressPoints[i->VTableIndex].lookup(i->VTableBase);
75 assert(AddressPoint != 0 && "Did not find ctor vtable address point!");
78 llvm::Value *Idxs[] = {
79 llvm::ConstantInt::get(Int64Ty, 0),
80 llvm::ConstantInt::get(Int64Ty, AddressPoint)
83 llvm::Constant *Init =
84 llvm::ConstantExpr::getInBoundsGetElementPtr(VTable, Idxs);
86 Init = llvm::ConstantExpr::getBitCast(Init, Int8PtrTy);
88 VTTComponents.push_back(Init);
91 llvm::Constant *Init = llvm::ConstantArray::get(ArrayType, VTTComponents);
93 VTT->setInitializer(Init);
95 // Set the correct linkage.
96 VTT->setLinkage(Linkage);
98 // Set the right visibility.
99 CGM.setTypeVisibility(VTT, RD, CodeGenModule::TVK_ForVTT);
102 llvm::GlobalVariable *CodeGenVTables::GetAddrOfVTT(const CXXRecordDecl *RD) {
103 assert(RD->getNumVBases() && "Only classes with virtual bases need a VTT");
105 llvm::SmallString<256> OutName;
106 llvm::raw_svector_ostream Out(OutName);
107 CGM.getCXXABI().getMangleContext().mangleCXXVTT(RD, Out);
109 StringRef Name = OutName.str();
111 // This will also defer the definition of the VTT.
112 (void) GetAddrOfVTable(RD);
114 VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false);
116 llvm::Type *Int8PtrTy =
117 llvm::Type::getInt8PtrTy(CGM.getLLVMContext());
118 llvm::ArrayType *ArrayType =
119 llvm::ArrayType::get(Int8PtrTy, Builder.getVTTComponents().size());
121 llvm::GlobalVariable *GV =
122 CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType,
123 llvm::GlobalValue::ExternalLinkage);
124 GV->setUnnamedAddr(true);
128 bool CodeGenVTables::needsVTTParameter(GlobalDecl GD) {
129 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
131 // We don't have any virtual bases, just return early.
132 if (!MD->getParent()->getNumVBases())
135 // Check if we have a base constructor.
136 if (isa<CXXConstructorDecl>(MD) && GD.getCtorType() == Ctor_Base)
139 // Check if we have a base destructor.
140 if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
146 uint64_t CodeGenVTables::getSubVTTIndex(const CXXRecordDecl *RD,
147 BaseSubobject Base) {
148 BaseSubobjectPairTy ClassSubobjectPair(RD, Base);
150 SubVTTIndiciesMapTy::iterator I = SubVTTIndicies.find(ClassSubobjectPair);
151 if (I != SubVTTIndicies.end())
154 VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false);
156 for (llvm::DenseMap<BaseSubobject, uint64_t>::const_iterator I =
157 Builder.getSubVTTIndicies().begin(),
158 E = Builder.getSubVTTIndicies().end(); I != E; ++I) {
159 // Insert all indices.
160 BaseSubobjectPairTy ClassSubobjectPair(RD, I->first);
162 SubVTTIndicies.insert(std::make_pair(ClassSubobjectPair, I->second));
165 I = SubVTTIndicies.find(ClassSubobjectPair);
166 assert(I != SubVTTIndicies.end() && "Did not find index!");
172 CodeGenVTables::getSecondaryVirtualPointerIndex(const CXXRecordDecl *RD,
173 BaseSubobject Base) {
174 SecondaryVirtualPointerIndicesMapTy::iterator I =
175 SecondaryVirtualPointerIndices.find(std::make_pair(RD, Base));
177 if (I != SecondaryVirtualPointerIndices.end())
180 VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false);
182 // Insert all secondary vpointer indices.
183 for (llvm::DenseMap<BaseSubobject, uint64_t>::const_iterator I =
184 Builder.getSecondaryVirtualPointerIndices().begin(),
185 E = Builder.getSecondaryVirtualPointerIndices().end(); I != E; ++I) {
186 std::pair<const CXXRecordDecl *, BaseSubobject> Pair =
187 std::make_pair(RD, I->first);
189 SecondaryVirtualPointerIndices.insert(std::make_pair(Pair, I->second));
192 I = SecondaryVirtualPointerIndices.find(std::make_pair(RD, Base));
193 assert(I != SecondaryVirtualPointerIndices.end() && "Did not find index!");