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 * |
Timur Iskhodzhanov | a53d7a0 | 2013-09-27 14:48:01 +0000 | [diff] [blame] | 22 | GetAddrOfVTTVTable(CodeGenVTables &CGVT, CodeGenModule &CGM, |
| 23 | const CXXRecordDecl *MostDerivedClass, |
Benjamin Kramer | f5c7504 | 2011-10-22 19:16:39 +0000 | [diff] [blame] | 24 | const VTTVTable &VTable, |
| 25 | llvm::GlobalVariable::LinkageTypes Linkage, |
| 26 | llvm::DenseMap<BaseSubobject, uint64_t> &AddressPoints) { |
Peter Collingbourne | e2ff5ab | 2011-09-26 01:56:06 +0000 | [diff] [blame] | 27 | if (VTable.getBase() == MostDerivedClass) { |
| 28 | assert(VTable.getBaseOffset().isZero() && |
Anders Carlsson | 2c822f1 | 2010-03-26 03:56:54 +0000 | [diff] [blame] | 29 | "Most derived class vtable must have a zero offset!"); |
| 30 | // This is a regular vtable. |
Timur Iskhodzhanov | a53d7a0 | 2013-09-27 14:48:01 +0000 | [diff] [blame] | 31 | return CGM.getCXXABI().getAddrOfVTable(MostDerivedClass, CharUnits()); |
Anders Carlsson | 2c822f1 | 2010-03-26 03:56:54 +0000 | [diff] [blame] | 32 | } |
| 33 | |
Peter Collingbourne | e2ff5ab | 2011-09-26 01:56:06 +0000 | [diff] [blame] | 34 | return CGVT.GenerateConstructionVTable(MostDerivedClass, |
| 35 | VTable.getBaseSubobject(), |
| 36 | VTable.isVirtual(), |
| 37 | Linkage, |
| 38 | AddressPoints); |
Anders Carlsson | 2c822f1 | 2010-03-26 03:56:54 +0000 | [diff] [blame] | 39 | } |
| 40 | |
Anders Carlsson | 1cbce12 | 2011-01-29 19:16:51 +0000 | [diff] [blame] | 41 | void |
| 42 | CodeGenVTables::EmitVTTDefinition(llvm::GlobalVariable *VTT, |
| 43 | llvm::GlobalVariable::LinkageTypes Linkage, |
| 44 | const CXXRecordDecl *RD) { |
Peter Collingbourne | 4c341ac | 2011-09-26 01:56:10 +0000 | [diff] [blame] | 45 | VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/true); |
Anders Carlsson | 1cbce12 | 2011-01-29 19:16:51 +0000 | [diff] [blame] | 46 | |
Chris Lattner | 8b41868 | 2012-02-07 00:39:47 +0000 | [diff] [blame] | 47 | llvm::Type *Int8PtrTy = CGM.Int8PtrTy, *Int64Ty = CGM.Int64Ty; |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 48 | llvm::ArrayType *ArrayType = |
Anders Carlsson | 1cbce12 | 2011-01-29 19:16:51 +0000 | [diff] [blame] | 49 | llvm::ArrayType::get(Int8PtrTy, Builder.getVTTComponents().size()); |
| 50 | |
Peter Collingbourne | e2ff5ab | 2011-09-26 01:56:06 +0000 | [diff] [blame] | 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()); |
Timur Iskhodzhanov | a53d7a0 | 2013-09-27 14:48:01 +0000 | [diff] [blame] | 56 | VTables.push_back(GetAddrOfVTTVTable(*this, CGM, RD, *i, Linkage, |
Peter Collingbourne | e2ff5ab | 2011-09-26 01:56:06 +0000 | [diff] [blame] | 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. |
Timur Iskhodzhanov | 5f0db58 | 2013-11-05 15:54:58 +0000 | [diff] [blame] | 68 | AddressPoint = |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 69 | getItaniumVTableContext().getVTableLayout(RD).getAddressPoint( |
| 70 | i->VTableBase); |
Peter Collingbourne | e2ff5ab | 2011-09-26 01:56:06 +0000 | [diff] [blame] | 71 | assert(AddressPoint != 0 && "Did not find vtable address point!"); |
| 72 | } else { |
| 73 | AddressPoint = VTableAddressPoints[i->VTableIndex].lookup(i->VTableBase); |
| 74 | assert(AddressPoint != 0 && "Did not find ctor vtable address point!"); |
| 75 | } |
| 76 | |
| 77 | llvm::Value *Idxs[] = { |
| 78 | llvm::ConstantInt::get(Int64Ty, 0), |
| 79 | llvm::ConstantInt::get(Int64Ty, AddressPoint) |
| 80 | }; |
| 81 | |
| 82 | llvm::Constant *Init = |
| 83 | llvm::ConstantExpr::getInBoundsGetElementPtr(VTable, Idxs); |
| 84 | |
| 85 | Init = llvm::ConstantExpr::getBitCast(Init, Int8PtrTy); |
| 86 | |
| 87 | VTTComponents.push_back(Init); |
| 88 | } |
| 89 | |
| 90 | llvm::Constant *Init = llvm::ConstantArray::get(ArrayType, VTTComponents); |
Anders Carlsson | 1cbce12 | 2011-01-29 19:16:51 +0000 | [diff] [blame] | 91 | |
| 92 | VTT->setInitializer(Init); |
| 93 | |
| 94 | // Set the correct linkage. |
| 95 | VTT->setLinkage(Linkage); |
Anders Carlsson | 691222d | 2011-01-29 19:34:19 +0000 | [diff] [blame] | 96 | |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 97 | if (CGM.supportsCOMDAT() && VTT->isWeakForLinker()) |
| 98 | VTT->setComdat(CGM.getModule().getOrInsertComdat(VTT->getName())); |
| 99 | |
Anders Carlsson | 691222d | 2011-01-29 19:34:19 +0000 | [diff] [blame] | 100 | // Set the right visibility. |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 101 | CGM.setGlobalVisibility(VTT, RD); |
Anders Carlsson | 1cbce12 | 2011-01-29 19:16:51 +0000 | [diff] [blame] | 102 | } |
| 103 | |
| 104 | llvm::GlobalVariable *CodeGenVTables::GetAddrOfVTT(const CXXRecordDecl *RD) { |
| 105 | assert(RD->getNumVBases() && "Only classes with virtual bases need a VTT"); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 106 | |
Dylan Noblesmith | f7ccbad | 2012-02-05 02:13:05 +0000 | [diff] [blame] | 107 | SmallString<256> OutName; |
Rafael Espindola | f0be979 | 2011-02-11 02:52:17 +0000 | [diff] [blame] | 108 | llvm::raw_svector_ostream Out(OutName); |
Timur Iskhodzhanov | 11f22a3 | 2013-10-03 06:26:13 +0000 | [diff] [blame] | 109 | cast<ItaniumMangleContext>(CGM.getCXXABI().getMangleContext()) |
| 110 | .mangleCXXVTT(RD, Out); |
Rafael Espindola | f0be979 | 2011-02-11 02:52:17 +0000 | [diff] [blame] | 111 | Out.flush(); |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 112 | StringRef Name = OutName.str(); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 113 | |
Peter Collingbourne | bf1c5ae | 2011-09-26 01:56:36 +0000 | [diff] [blame] | 114 | // This will also defer the definition of the VTT. |
Timur Iskhodzhanov | a53d7a0 | 2013-09-27 14:48:01 +0000 | [diff] [blame] | 115 | (void) CGM.getCXXABI().getAddrOfVTable(RD, CharUnits()); |
Anders Carlsson | e3d6cf2 | 2011-05-16 04:08:36 +0000 | [diff] [blame] | 116 | |
Peter Collingbourne | 4c341ac | 2011-09-26 01:56:10 +0000 | [diff] [blame] | 117 | VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 118 | |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 119 | llvm::ArrayType *ArrayType = |
Chris Lattner | 8b41868 | 2012-02-07 00:39:47 +0000 | [diff] [blame] | 120 | llvm::ArrayType::get(CGM.Int8PtrTy, Builder.getVTTComponents().size()); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 121 | |
Anders Carlsson | 1cbce12 | 2011-01-29 19:16:51 +0000 | [diff] [blame] | 122 | llvm::GlobalVariable *GV = |
| 123 | CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType, |
| 124 | llvm::GlobalValue::ExternalLinkage); |
| 125 | GV->setUnnamedAddr(true); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 126 | return GV; |
| 127 | } |
| 128 | |
Anders Carlsson | af44035 | 2010-03-23 04:11:45 +0000 | [diff] [blame] | 129 | uint64_t CodeGenVTables::getSubVTTIndex(const CXXRecordDecl *RD, |
Anders Carlsson | c11bb21 | 2010-05-02 23:53:25 +0000 | [diff] [blame] | 130 | BaseSubobject Base) { |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 131 | BaseSubobjectPairTy ClassSubobjectPair(RD, Base); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 132 | |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 133 | SubVTTIndiciesMapTy::iterator I = SubVTTIndicies.find(ClassSubobjectPair); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 134 | if (I != SubVTTIndicies.end()) |
| 135 | return I->second; |
| 136 | |
Peter Collingbourne | 4c341ac | 2011-09-26 01:56:10 +0000 | [diff] [blame] | 137 | VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 138 | |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 139 | for (llvm::DenseMap<BaseSubobject, uint64_t>::const_iterator I = |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 140 | Builder.getSubVTTIndicies().begin(), |
| 141 | E = Builder.getSubVTTIndicies().end(); I != E; ++I) { |
| 142 | // Insert all indices. |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 143 | BaseSubobjectPairTy ClassSubobjectPair(RD, I->first); |
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 | SubVTTIndicies.insert(std::make_pair(ClassSubobjectPair, I->second)); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 146 | } |
| 147 | |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 148 | I = SubVTTIndicies.find(ClassSubobjectPair); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 149 | assert(I != SubVTTIndicies.end() && "Did not find index!"); |
| 150 | |
| 151 | return I->second; |
| 152 | } |
Anders Carlsson | e1dcc22 | 2010-03-26 04:23:58 +0000 | [diff] [blame] | 153 | |
| 154 | uint64_t |
| 155 | CodeGenVTables::getSecondaryVirtualPointerIndex(const CXXRecordDecl *RD, |
| 156 | BaseSubobject Base) { |
| 157 | SecondaryVirtualPointerIndicesMapTy::iterator I = |
| 158 | SecondaryVirtualPointerIndices.find(std::make_pair(RD, Base)); |
| 159 | |
| 160 | if (I != SecondaryVirtualPointerIndices.end()) |
| 161 | return I->second; |
| 162 | |
Peter Collingbourne | 4c341ac | 2011-09-26 01:56:10 +0000 | [diff] [blame] | 163 | VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false); |
Anders Carlsson | e1dcc22 | 2010-03-26 04:23:58 +0000 | [diff] [blame] | 164 | |
| 165 | // Insert all secondary vpointer indices. |
| 166 | for (llvm::DenseMap<BaseSubobject, uint64_t>::const_iterator I = |
| 167 | Builder.getSecondaryVirtualPointerIndices().begin(), |
| 168 | E = Builder.getSecondaryVirtualPointerIndices().end(); I != E; ++I) { |
| 169 | std::pair<const CXXRecordDecl *, BaseSubobject> Pair = |
| 170 | std::make_pair(RD, I->first); |
| 171 | |
| 172 | SecondaryVirtualPointerIndices.insert(std::make_pair(Pair, I->second)); |
| 173 | } |
| 174 | |
| 175 | I = SecondaryVirtualPointerIndices.find(std::make_pair(RD, Base)); |
| 176 | assert(I != SecondaryVirtualPointerIndices.end() && "Did not find index!"); |
| 177 | |
| 178 | return I->second; |
| 179 | } |
| 180 | |