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 | |
Pirama Arumuga Nainar | 58878f8 | 2015-05-06 11:48:57 -0700 | [diff] [blame] | 21 | static llvm::GlobalVariable * |
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 | |
Pirama Arumuga Nainar | 4967a71 | 2016-09-19 22:19:55 -0700 | [diff] [blame^] | 47 | llvm::Type *Int8PtrTy = CGM.Int8PtrTy, *Int32Ty = CGM.Int32Ty; |
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()); |
Pirama Arumuga Nainar | 58878f8 | 2015-05-06 11:48:57 -0700 | [diff] [blame] | 50 | |
| 51 | SmallVector<llvm::GlobalVariable *, 8> VTables; |
Peter Collingbourne | e2ff5ab | 2011-09-26 01:56:06 +0000 | [diff] [blame] | 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]; |
Pirama Arumuga Nainar | 58878f8 | 2015-05-06 11:48:57 -0700 | [diff] [blame] | 64 | llvm::GlobalVariable *VTable = VTables[i->VTableIndex]; |
Peter Collingbourne | e2ff5ab | 2011-09-26 01:56:06 +0000 | [diff] [blame] | 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[] = { |
Pirama Arumuga Nainar | 4967a71 | 2016-09-19 22:19:55 -0700 | [diff] [blame^] | 78 | llvm::ConstantInt::get(Int32Ty, 0), |
| 79 | llvm::ConstantInt::get(Int32Ty, AddressPoint) |
Peter Collingbourne | e2ff5ab | 2011-09-26 01:56:06 +0000 | [diff] [blame] | 80 | }; |
| 81 | |
Pirama Arumuga Nainar | 58878f8 | 2015-05-06 11:48:57 -0700 | [diff] [blame] | 82 | llvm::Constant *Init = llvm::ConstantExpr::getInBoundsGetElementPtr( |
| 83 | VTable->getValueType(), VTable, Idxs); |
Peter Collingbourne | e2ff5ab | 2011-09-26 01:56:06 +0000 | [diff] [blame] | 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); |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 111 | StringRef Name = OutName.str(); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 112 | |
Peter Collingbourne | bf1c5ae | 2011-09-26 01:56:36 +0000 | [diff] [blame] | 113 | // This will also defer the definition of the VTT. |
Timur Iskhodzhanov | a53d7a0 | 2013-09-27 14:48:01 +0000 | [diff] [blame] | 114 | (void) CGM.getCXXABI().getAddrOfVTable(RD, CharUnits()); |
Anders Carlsson | e3d6cf2 | 2011-05-16 04:08:36 +0000 | [diff] [blame] | 115 | |
Peter Collingbourne | 4c341ac | 2011-09-26 01:56:10 +0000 | [diff] [blame] | 116 | VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 117 | |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 118 | llvm::ArrayType *ArrayType = |
Chris Lattner | 8b41868 | 2012-02-07 00:39:47 +0000 | [diff] [blame] | 119 | llvm::ArrayType::get(CGM.Int8PtrTy, Builder.getVTTComponents().size()); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 120 | |
Anders Carlsson | 1cbce12 | 2011-01-29 19:16:51 +0000 | [diff] [blame] | 121 | llvm::GlobalVariable *GV = |
| 122 | CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType, |
| 123 | llvm::GlobalValue::ExternalLinkage); |
Pirama Arumuga Nainar | 4967a71 | 2016-09-19 22:19:55 -0700 | [diff] [blame^] | 124 | GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 125 | return GV; |
| 126 | } |
| 127 | |
Anders Carlsson | af44035 | 2010-03-23 04:11:45 +0000 | [diff] [blame] | 128 | uint64_t CodeGenVTables::getSubVTTIndex(const CXXRecordDecl *RD, |
Anders Carlsson | c11bb21 | 2010-05-02 23:53:25 +0000 | [diff] [blame] | 129 | BaseSubobject Base) { |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 130 | BaseSubobjectPairTy ClassSubobjectPair(RD, Base); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 131 | |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 132 | SubVTTIndiciesMapTy::iterator I = SubVTTIndicies.find(ClassSubobjectPair); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 133 | if (I != SubVTTIndicies.end()) |
| 134 | return I->second; |
| 135 | |
Peter Collingbourne | 4c341ac | 2011-09-26 01:56:10 +0000 | [diff] [blame] | 136 | VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 137 | |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 138 | for (llvm::DenseMap<BaseSubobject, uint64_t>::const_iterator I = |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 139 | Builder.getSubVTTIndicies().begin(), |
| 140 | E = Builder.getSubVTTIndicies().end(); I != E; ++I) { |
| 141 | // Insert all indices. |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 142 | BaseSubobjectPairTy ClassSubobjectPair(RD, I->first); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 143 | |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 144 | SubVTTIndicies.insert(std::make_pair(ClassSubobjectPair, I->second)); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 145 | } |
| 146 | |
Anders Carlsson | 3855a07 | 2010-05-03 00:55:11 +0000 | [diff] [blame] | 147 | I = SubVTTIndicies.find(ClassSubobjectPair); |
Anders Carlsson | 58b7eee | 2010-01-21 16:50:45 +0000 | [diff] [blame] | 148 | assert(I != SubVTTIndicies.end() && "Did not find index!"); |
| 149 | |
| 150 | return I->second; |
| 151 | } |
Anders Carlsson | e1dcc22 | 2010-03-26 04:23:58 +0000 | [diff] [blame] | 152 | |
| 153 | uint64_t |
| 154 | CodeGenVTables::getSecondaryVirtualPointerIndex(const CXXRecordDecl *RD, |
| 155 | BaseSubobject Base) { |
| 156 | SecondaryVirtualPointerIndicesMapTy::iterator I = |
| 157 | SecondaryVirtualPointerIndices.find(std::make_pair(RD, Base)); |
| 158 | |
| 159 | if (I != SecondaryVirtualPointerIndices.end()) |
| 160 | return I->second; |
| 161 | |
Peter Collingbourne | 4c341ac | 2011-09-26 01:56:10 +0000 | [diff] [blame] | 162 | VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false); |
Anders Carlsson | e1dcc22 | 2010-03-26 04:23:58 +0000 | [diff] [blame] | 163 | |
| 164 | // Insert all secondary vpointer indices. |
| 165 | for (llvm::DenseMap<BaseSubobject, uint64_t>::const_iterator I = |
| 166 | Builder.getSecondaryVirtualPointerIndices().begin(), |
| 167 | E = Builder.getSecondaryVirtualPointerIndices().end(); I != E; ++I) { |
| 168 | std::pair<const CXXRecordDecl *, BaseSubobject> Pair = |
| 169 | std::make_pair(RD, I->first); |
| 170 | |
| 171 | SecondaryVirtualPointerIndices.insert(std::make_pair(Pair, I->second)); |
| 172 | } |
| 173 | |
| 174 | I = SecondaryVirtualPointerIndices.find(std::make_pair(RD, Base)); |
| 175 | assert(I != SecondaryVirtualPointerIndices.end() && "Did not find index!"); |
| 176 | |
| 177 | return I->second; |
| 178 | } |