1 //===--- CGVTT.cpp - Emit LLVM Code for C++ VTTs --------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This contains code dealing with C++ code generation of VTTs (vtable tables).
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CodeGenModule.h"
15 #include "CGCXXABI.h"
16 #include "clang/AST/RecordLayout.h"
17 #include "clang/AST/VTTBuilder.h"
18 using namespace clang;
19 using namespace CodeGen;
20 
21 static llvm::Constant *
22 GetAddrOfVTTVTable(CodeGenVTables &CGVT, const CXXRecordDecl *MostDerivedClass,
23                    const VTTVTable &VTable,
24                    llvm::GlobalVariable::LinkageTypes Linkage,
25                    llvm::DenseMap<BaseSubobject, uint64_t> &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 CGVT.GetAddrOfVTable(MostDerivedClass);
31   }
32 
33   return CGVT.GenerateConstructionVTable(MostDerivedClass,
34                                          VTable.getBaseSubobject(),
35                                          VTable.isVirtual(),
36                                          Linkage,
37                                          AddressPoints);
38 }
39 
40 void
41 CodeGenVTables::EmitVTTDefinition(llvm::GlobalVariable *VTT,
42                                   llvm::GlobalVariable::LinkageTypes Linkage,
43                                   const CXXRecordDecl *RD) {
44   VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/true);
45 
46   llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext()),
47              *Int64Ty = llvm::Type::getInt64Ty(CGM.getLLVMContext());
48   llvm::ArrayType *ArrayType =
49     llvm::ArrayType::get(Int8PtrTy, Builder.getVTTComponents().size());
50 
51   SmallVector<llvm::Constant *, 8> VTables;
52   SmallVector<VTableAddressPointsMapTy, 8> VTableAddressPoints;
53   for (const VTTVTable *i = Builder.getVTTVTables().begin(),
54                        *e = Builder.getVTTVTables().end(); i != e; ++i) {
55     VTableAddressPoints.push_back(VTableAddressPointsMapTy());
56     VTables.push_back(GetAddrOfVTTVTable(*this, RD, *i, Linkage,
57                                          VTableAddressPoints.back()));
58   }
59 
60   SmallVector<llvm::Constant *, 8> VTTComponents;
61   for (const VTTComponent *i = Builder.getVTTComponents().begin(),
62                           *e = Builder.getVTTComponents().end(); i != e; ++i) {
63     const VTTVTable &VTTVT = Builder.getVTTVTables()[i->VTableIndex];
64     llvm::Constant *VTable = VTables[i->VTableIndex];
65     uint64_t AddressPoint;
66     if (VTTVT.getBase() == RD) {
67       // Just get the address point for the regular vtable.
68       AddressPoint = VTContext.getVTableLayout(RD)
69                               .getAddressPoint(i->VTableBase);
70       assert(AddressPoint != 0 && "Did not find vtable address point!");
71     } else {
72       AddressPoint = VTableAddressPoints[i->VTableIndex].lookup(i->VTableBase);
73       assert(AddressPoint != 0 && "Did not find ctor vtable address point!");
74     }
75 
76      llvm::Value *Idxs[] = {
77        llvm::ConstantInt::get(Int64Ty, 0),
78        llvm::ConstantInt::get(Int64Ty, AddressPoint)
79      };
80 
81      llvm::Constant *Init =
82        llvm::ConstantExpr::getInBoundsGetElementPtr(VTable, Idxs);
83 
84      Init = llvm::ConstantExpr::getBitCast(Init, Int8PtrTy);
85 
86      VTTComponents.push_back(Init);
87   }
88 
89   llvm::Constant *Init = llvm::ConstantArray::get(ArrayType, VTTComponents);
90 
91   VTT->setInitializer(Init);
92 
93   // Set the correct linkage.
94   VTT->setLinkage(Linkage);
95 
96   // Set the right visibility.
97   CGM.setTypeVisibility(VTT, RD, CodeGenModule::TVK_ForVTT);
98 }
99 
100 llvm::GlobalVariable *CodeGenVTables::GetAddrOfVTT(const CXXRecordDecl *RD) {
101   assert(RD->getNumVBases() && "Only classes with virtual bases need a VTT");
102 
103   llvm::SmallString<256> OutName;
104   llvm::raw_svector_ostream Out(OutName);
105   CGM.getCXXABI().getMangleContext().mangleCXXVTT(RD, Out);
106   Out.flush();
107   StringRef Name = OutName.str();
108 
109   // This will also defer the definition of the VTT.
110   (void) GetAddrOfVTable(RD);
111 
112   VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false);
113 
114   llvm::Type *Int8PtrTy =
115     llvm::Type::getInt8PtrTy(CGM.getLLVMContext());
116   llvm::ArrayType *ArrayType =
117     llvm::ArrayType::get(Int8PtrTy, Builder.getVTTComponents().size());
118 
119   llvm::GlobalVariable *GV =
120     CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType,
121                                           llvm::GlobalValue::ExternalLinkage);
122   GV->setUnnamedAddr(true);
123   return GV;
124 }
125 
126 bool CodeGenVTables::needsVTTParameter(GlobalDecl GD) {
127   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
128 
129   // We don't have any virtual bases, just return early.
130   if (!MD->getParent()->getNumVBases())
131     return false;
132 
133   // Check if we have a base constructor.
134   if (isa<CXXConstructorDecl>(MD) && GD.getCtorType() == Ctor_Base)
135     return true;
136 
137   // Check if we have a base destructor.
138   if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
139     return true;
140 
141   return false;
142 }
143 
144 uint64_t CodeGenVTables::getSubVTTIndex(const CXXRecordDecl *RD,
145                                         BaseSubobject Base) {
146   BaseSubobjectPairTy ClassSubobjectPair(RD, Base);
147 
148   SubVTTIndiciesMapTy::iterator I = SubVTTIndicies.find(ClassSubobjectPair);
149   if (I != SubVTTIndicies.end())
150     return I->second;
151 
152   VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false);
153 
154   for (llvm::DenseMap<BaseSubobject, uint64_t>::const_iterator I =
155        Builder.getSubVTTIndicies().begin(),
156        E = Builder.getSubVTTIndicies().end(); I != E; ++I) {
157     // Insert all indices.
158     BaseSubobjectPairTy ClassSubobjectPair(RD, I->first);
159 
160     SubVTTIndicies.insert(std::make_pair(ClassSubobjectPair, I->second));
161   }
162 
163   I = SubVTTIndicies.find(ClassSubobjectPair);
164   assert(I != SubVTTIndicies.end() && "Did not find index!");
165 
166   return I->second;
167 }
168 
169 uint64_t
170 CodeGenVTables::getSecondaryVirtualPointerIndex(const CXXRecordDecl *RD,
171                                                 BaseSubobject Base) {
172   SecondaryVirtualPointerIndicesMapTy::iterator I =
173     SecondaryVirtualPointerIndices.find(std::make_pair(RD, Base));
174 
175   if (I != SecondaryVirtualPointerIndices.end())
176     return I->second;
177 
178   VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false);
179 
180   // Insert all secondary vpointer indices.
181   for (llvm::DenseMap<BaseSubobject, uint64_t>::const_iterator I =
182        Builder.getSecondaryVirtualPointerIndices().begin(),
183        E = Builder.getSecondaryVirtualPointerIndices().end(); I != E; ++I) {
184     std::pair<const CXXRecordDecl *, BaseSubobject> Pair =
185       std::make_pair(RD, I->first);
186 
187     SecondaryVirtualPointerIndices.insert(std::make_pair(Pair, I->second));
188   }
189 
190   I = SecondaryVirtualPointerIndices.find(std::make_pair(RD, Base));
191   assert(I != SecondaryVirtualPointerIndices.end() && "Did not find index!");
192 
193   return I->second;
194 }
195 
196