Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 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" |
John McCall | 4c40d98 | 2010-08-31 07:33:07 +0000 | [diff] [blame] | 15 | #include "CGCXXABI.h" |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 16 | #include "clang/AST/RecordLayout.h" |
Peter Collingbourne | 5c551f7 | 2011-09-26 01:56:24 +0000 | [diff] [blame] | 17 | #include "clang/AST/VTTBuilder.h" |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 18 | using namespace clang; |
| 19 | using namespace CodeGen; |
| 20 | |
Benjamin Kramer | f5c7504 | 2011-10-22 19:16:39 +0000 | [diff] [blame] | 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) { |
Peter Collingbourne | e2ff5ab | 2011-09-26 01:56:06 +0000 | [diff] [blame] | 26 | if (VTable.getBase() == MostDerivedClass) { |
| 27 | assert(VTable.getBaseOffset().isZero() && |
Anders Carlsson | 2c822f1 | 2010-03-26 03:56:54 +0000 | [diff] [blame] | 28 | "Most derived class vtable must have a zero offset!"); |
| 29 | // This is a regular vtable. |
Peter Collingbourne | e2ff5ab | 2011-09-26 01:56:06 +0000 | [diff] [blame] | 30 | return CGVT.GetAddrOfVTable(MostDerivedClass); |
Anders Carlsson | 2c822f1 | 2010-03-26 03:56:54 +0000 | [diff] [blame] | 31 | } |
| 32 | |
Peter Collingbourne | e2ff5ab | 2011-09-26 01:56:06 +0000 | [diff] [blame] | 33 | return CGVT.GenerateConstructionVTable(MostDerivedClass, |
| 34 | VTable.getBaseSubobject(), |
| 35 | VTable.isVirtual(), |
| 36 | Linkage, |
| 37 | AddressPoints); |
Anders Carlsson | 2c822f1 | 2010-03-26 03:56:54 +0000 | [diff] [blame] | 38 | } |
| 39 | |
Anders Carlsson | 1cbce12 | 2011-01-29 19:16:51 +0000 | [diff] [blame] | 40 | void |
| 41 | CodeGenVTables::EmitVTTDefinition(llvm::GlobalVariable *VTT, |
| 42 | llvm::GlobalVariable::LinkageTypes Linkage, |
| 43 | const CXXRecordDecl *RD) { |
Peter Collingbourne | 4c341ac | 2011-09-26 01:56:10 +0000 | [diff] [blame] | 44 | VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/true); |
Anders Carlsson | 1cbce12 | 2011-01-29 19:16:51 +0000 | [diff] [blame] | 45 | |
Chris Lattner | 8b41868 | 2012-02-07 00:39:47 +0000 | [diff] [blame] | 46 | llvm::Type *Int8PtrTy = CGM.Int8PtrTy, *Int64Ty = CGM.Int64Ty; |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 47 | llvm::ArrayType *ArrayType = |
Anders Carlsson | 1cbce12 | 2011-01-29 19:16:51 +0000 | [diff] [blame] | 48 | llvm::ArrayType::get(Int8PtrTy, Builder.getVTTComponents().size()); |
| 49 | |
Peter Collingbourne | e2ff5ab | 2011-09-26 01:56:06 +0000 | [diff] [blame] | 50 | SmallVector<llvm::Constant *, 8> VTables; |
| 51 | SmallVector<VTableAddressPointsMapTy, 8> VTableAddressPoints; |
| 52 | for (const VTTVTable *i = Builder.getVTTVTables().begin(), |
| 53 | *e = Builder.getVTTVTables().end(); i != e; ++i) { |
| 54 | VTableAddressPoints.push_back(VTableAddressPointsMapTy()); |
| 55 | VTables.push_back(GetAddrOfVTTVTable(*this, RD, *i, Linkage, |
| 56 | VTableAddressPoints.back())); |
| 57 | } |
| 58 | |
| 59 | SmallVector<llvm::Constant *, 8> VTTComponents; |
| 60 | for (const VTTComponent *i = Builder.getVTTComponents().begin(), |
| 61 | *e = Builder.getVTTComponents().end(); i != e; ++i) { |
| 62 | const VTTVTable &VTTVT = Builder.getVTTVTables()[i->VTableIndex]; |
| 63 | llvm::Constant *VTable = VTables[i->VTableIndex]; |
| 64 | uint64_t AddressPoint; |
| 65 | if (VTTVT.getBase() == RD) { |
| 66 | // Just get the address point for the regular vtable. |
Peter Collingbourne | e09cdf4 | 2011-09-26 01:56:50 +0000 | [diff] [blame] | 67 | AddressPoint = VTContext.getVTableLayout(RD) |
| 68 | .getAddressPoint(i->VTableBase); |
Peter Collingbourne | e2ff5ab | 2011-09-26 01:56:06 +0000 | [diff] [blame] | 69 | assert(AddressPoint != 0 && "Did not find vtable address point!"); |
| 70 | } else { |
| 71 | AddressPoint = VTableAddressPoints[i->VTableIndex].lookup(i->VTableBase); |
| 72 | assert(AddressPoint != 0 && "Did not find ctor vtable address point!"); |
| 73 | } |
| 74 | |
| 75 | llvm::Value *Idxs[] = { |
| 76 | llvm::ConstantInt::get(Int64Ty, 0), |
| 77 | llvm::ConstantInt::get(Int64Ty, AddressPoint) |
| 78 | }; |
| 79 | |
| 80 | llvm::Constant *Init = |
| 81 | llvm::ConstantExpr::getInBoundsGetElementPtr(VTable, Idxs); |
| 82 | |
| 83 | Init = llvm::ConstantExpr::getBitCast(Init, Int8PtrTy); |
| 84 | |
| 85 | VTTComponents.push_back(Init); |
| 86 | } |
| 87 | |
| 88 | llvm::Constant *Init = llvm::ConstantArray::get(ArrayType, VTTComponents); |
Anders Carlsson | 1cbce12 | 2011-01-29 19:16:51 +0000 | [diff] [blame] | 89 | |
| 90 | VTT->setInitializer(Init); |
| 91 | |
| 92 | // Set the correct linkage. |
| 93 | VTT->setLinkage(Linkage); |
Anders Carlsson | 691222d | 2011-01-29 19:34:19 +0000 | [diff] [blame] | 94 | |
| 95 | // Set the right visibility. |
Anders Carlsson | fa2e99f | 2011-01-29 20:24:48 +0000 | [diff] [blame] | 96 | CGM.setTypeVisibility(VTT, RD, CodeGenModule::TVK_ForVTT); |
Anders Carlsson | 1cbce12 | 2011-01-29 19:16:51 +0000 | [diff] [blame] | 97 | } |
| 98 | |
| 99 | llvm::GlobalVariable *CodeGenVTables::GetAddrOfVTT(const CXXRecordDecl *RD) { |
| 100 | assert(RD->getNumVBases() && "Only classes with virtual bases need a VTT"); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 101 | |
Dylan Noblesmith | f7ccbad | 2012-02-05 02:13:05 +0000 | [diff] [blame] | 102 | SmallString<256> OutName; |
Rafael Espindola | f0be979 | 2011-02-11 02:52:17 +0000 | [diff] [blame] | 103 | llvm::raw_svector_ostream Out(OutName); |
| 104 | CGM.getCXXABI().getMangleContext().mangleCXXVTT(RD, Out); |
| 105 | Out.flush(); |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 106 | StringRef Name = OutName.str(); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 107 | |
Peter Collingbourne | bf1c5ae | 2011-09-26 01:56:36 +0000 | [diff] [blame] | 108 | // This will also defer the definition of the VTT. |
| 109 | (void) GetAddrOfVTable(RD); |
Anders Carlsson | e3d6cf2 | 2011-05-16 04:08:36 +0000 | [diff] [blame] | 110 | |
Peter Collingbourne | 4c341ac | 2011-09-26 01:56:10 +0000 | [diff] [blame] | 111 | VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 112 | |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 113 | llvm::ArrayType *ArrayType = |
Chris Lattner | 8b41868 | 2012-02-07 00:39:47 +0000 | [diff] [blame] | 114 | llvm::ArrayType::get(CGM.Int8PtrTy, Builder.getVTTComponents().size()); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 115 | |
Anders Carlsson | 1cbce12 | 2011-01-29 19:16:51 +0000 | [diff] [blame] | 116 | llvm::GlobalVariable *GV = |
| 117 | CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType, |
| 118 | llvm::GlobalValue::ExternalLinkage); |
| 119 | GV->setUnnamedAddr(true); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 120 | return GV; |
| 121 | } |
| 122 | |
Anders Carlsson | af44035 | 2010-03-23 04:11:45 +0000 | [diff] [blame] | 123 | bool CodeGenVTables::needsVTTParameter(GlobalDecl GD) { |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 124 | const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl()); |
| 125 | |
| 126 | // We don't have any virtual bases, just return early. |
| 127 | if (!MD->getParent()->getNumVBases()) |
| 128 | return false; |
| 129 | |
| 130 | // Check if we have a base constructor. |
| 131 | if (isa<CXXConstructorDecl>(MD) && GD.getCtorType() == Ctor_Base) |
| 132 | return true; |
| 133 | |
| 134 | // Check if we have a base destructor. |
| 135 | if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base) |
| 136 | return true; |
| 137 | |
| 138 | return false; |
| 139 | } |
| 140 | |
Anders Carlsson | af44035 | 2010-03-23 04:11:45 +0000 | [diff] [blame] | 141 | uint64_t CodeGenVTables::getSubVTTIndex(const CXXRecordDecl *RD, |
Anders Carlsson | c11bb21 | 2010-05-02 23:53:25 +0000 | [diff] [blame] | 142 | BaseSubobject Base) { |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 143 | BaseSubobjectPairTy ClassSubobjectPair(RD, Base); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 144 | |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 145 | SubVTTIndiciesMapTy::iterator I = SubVTTIndicies.find(ClassSubobjectPair); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 146 | if (I != SubVTTIndicies.end()) |
| 147 | return I->second; |
| 148 | |
Peter Collingbourne | 4c341ac | 2011-09-26 01:56:10 +0000 | [diff] [blame] | 149 | VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 150 | |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 151 | for (llvm::DenseMap<BaseSubobject, uint64_t>::const_iterator I = |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 152 | Builder.getSubVTTIndicies().begin(), |
| 153 | E = Builder.getSubVTTIndicies().end(); I != E; ++I) { |
| 154 | // Insert all indices. |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 155 | BaseSubobjectPairTy ClassSubobjectPair(RD, I->first); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 156 | |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 157 | SubVTTIndicies.insert(std::make_pair(ClassSubobjectPair, I->second)); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 158 | } |
| 159 | |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 160 | I = SubVTTIndicies.find(ClassSubobjectPair); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 161 | assert(I != SubVTTIndicies.end() && "Did not find index!"); |
| 162 | |
| 163 | return I->second; |
| 164 | } |
Anders Carlsson | e1dcc22 | 2010-03-26 04:23:58 +0000 | [diff] [blame] | 165 | |
| 166 | uint64_t |
| 167 | CodeGenVTables::getSecondaryVirtualPointerIndex(const CXXRecordDecl *RD, |
| 168 | BaseSubobject Base) { |
| 169 | SecondaryVirtualPointerIndicesMapTy::iterator I = |
| 170 | SecondaryVirtualPointerIndices.find(std::make_pair(RD, Base)); |
| 171 | |
| 172 | if (I != SecondaryVirtualPointerIndices.end()) |
| 173 | return I->second; |
| 174 | |
Peter Collingbourne | 4c341ac | 2011-09-26 01:56:10 +0000 | [diff] [blame] | 175 | VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false); |
Anders Carlsson | e1dcc22 | 2010-03-26 04:23:58 +0000 | [diff] [blame] | 176 | |
| 177 | // Insert all secondary vpointer indices. |
| 178 | for (llvm::DenseMap<BaseSubobject, uint64_t>::const_iterator I = |
| 179 | Builder.getSecondaryVirtualPointerIndices().begin(), |
| 180 | E = Builder.getSecondaryVirtualPointerIndices().end(); I != E; ++I) { |
| 181 | std::pair<const CXXRecordDecl *, BaseSubobject> Pair = |
| 182 | std::make_pair(RD, I->first); |
| 183 | |
| 184 | SecondaryVirtualPointerIndices.insert(std::make_pair(Pair, I->second)); |
| 185 | } |
| 186 | |
| 187 | I = SecondaryVirtualPointerIndices.find(std::make_pair(RD, Base)); |
| 188 | assert(I != SecondaryVirtualPointerIndices.end() && "Did not find index!"); |
| 189 | |
| 190 | return I->second; |
| 191 | } |
| 192 | |