/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/CodeGen/CGVTT.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | //===--- CGVTT.cpp - Emit LLVM Code for C++ VTTs --------------------------===// |
2 | | // |
3 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | | // See https://llvm.org/LICENSE.txt for license information. |
5 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | | // |
7 | | //===----------------------------------------------------------------------===// |
8 | | // |
9 | | // This contains code dealing with C++ code generation of VTTs (vtable tables). |
10 | | // |
11 | | //===----------------------------------------------------------------------===// |
12 | | |
13 | | #include "CodeGenModule.h" |
14 | | #include "CGCXXABI.h" |
15 | | #include "clang/AST/RecordLayout.h" |
16 | | #include "clang/AST/VTTBuilder.h" |
17 | | using namespace clang; |
18 | | using namespace CodeGen; |
19 | | |
20 | | static llvm::GlobalVariable * |
21 | | GetAddrOfVTTVTable(CodeGenVTables &CGVT, CodeGenModule &CGM, |
22 | | const CXXRecordDecl *MostDerivedClass, |
23 | | const VTTVTable &VTable, |
24 | | llvm::GlobalVariable::LinkageTypes Linkage, |
25 | 669 | VTableLayout::AddressPointsMapTy &AddressPoints) { |
26 | 669 | if (VTable.getBase() == MostDerivedClass) { |
27 | 364 | assert(VTable.getBaseOffset().isZero() && |
28 | 364 | "Most derived class vtable must have a zero offset!"); |
29 | | // This is a regular vtable. |
30 | 0 | return CGM.getCXXABI().getAddrOfVTable(MostDerivedClass, CharUnits()); |
31 | 364 | } |
32 | | |
33 | 305 | return CGVT.GenerateConstructionVTable(MostDerivedClass, |
34 | 305 | VTable.getBaseSubobject(), |
35 | 305 | VTable.isVirtual(), |
36 | 305 | Linkage, |
37 | 305 | AddressPoints); |
38 | 669 | } |
39 | | |
40 | | void |
41 | | CodeGenVTables::EmitVTTDefinition(llvm::GlobalVariable *VTT, |
42 | | llvm::GlobalVariable::LinkageTypes Linkage, |
43 | 364 | const CXXRecordDecl *RD) { |
44 | 364 | VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/true); |
45 | 364 | llvm::ArrayType *ArrayType = |
46 | 364 | llvm::ArrayType::get(CGM.Int8PtrTy, Builder.getVTTComponents().size()); |
47 | | |
48 | 364 | SmallVector<llvm::GlobalVariable *, 8> VTables; |
49 | 364 | SmallVector<VTableAddressPointsMapTy, 8> VTableAddressPoints; |
50 | 364 | for (const VTTVTable *i = Builder.getVTTVTables().begin(), |
51 | 1.03k | *e = Builder.getVTTVTables().end(); i != e; ++i669 ) { |
52 | 669 | VTableAddressPoints.push_back(VTableAddressPointsMapTy()); |
53 | 669 | VTables.push_back(GetAddrOfVTTVTable(*this, CGM, RD, *i, Linkage, |
54 | 669 | VTableAddressPoints.back())); |
55 | 669 | } |
56 | | |
57 | 364 | SmallVector<llvm::Constant *, 8> VTTComponents; |
58 | 364 | for (const VTTComponent *i = Builder.getVTTComponents().begin(), |
59 | 1.83k | *e = Builder.getVTTComponents().end(); i != e; ++i1.46k ) { |
60 | 1.46k | const VTTVTable &VTTVT = Builder.getVTTVTables()[i->VTableIndex]; |
61 | 1.46k | llvm::GlobalVariable *VTable = VTables[i->VTableIndex]; |
62 | 1.46k | VTableLayout::AddressPointLocation AddressPoint; |
63 | 1.46k | if (VTTVT.getBase() == RD) { |
64 | | // Just get the address point for the regular vtable. |
65 | 781 | AddressPoint = |
66 | 781 | getItaniumVTableContext().getVTableLayout(RD).getAddressPoint( |
67 | 781 | i->VTableBase); |
68 | 781 | } else { |
69 | 687 | AddressPoint = VTableAddressPoints[i->VTableIndex].lookup(i->VTableBase); |
70 | 687 | assert(AddressPoint.AddressPointIndex != 0 && |
71 | 687 | "Did not find ctor vtable address point!"); |
72 | 687 | } |
73 | | |
74 | 0 | llvm::Value *Idxs[] = { |
75 | 1.46k | llvm::ConstantInt::get(CGM.Int32Ty, 0), |
76 | 1.46k | llvm::ConstantInt::get(CGM.Int32Ty, AddressPoint.VTableIndex), |
77 | 1.46k | llvm::ConstantInt::get(CGM.Int32Ty, AddressPoint.AddressPointIndex), |
78 | 1.46k | }; |
79 | | |
80 | 1.46k | llvm::Constant *Init = llvm::ConstantExpr::getGetElementPtr( |
81 | 1.46k | VTable->getValueType(), VTable, Idxs, /*InBounds=*/true, |
82 | 1.46k | /*InRangeIndex=*/1); |
83 | | |
84 | 1.46k | Init = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(Init, |
85 | 1.46k | CGM.Int8PtrTy); |
86 | | |
87 | 1.46k | VTTComponents.push_back(Init); |
88 | 1.46k | } |
89 | | |
90 | 364 | llvm::Constant *Init = llvm::ConstantArray::get(ArrayType, VTTComponents); |
91 | | |
92 | 364 | VTT->setInitializer(Init); |
93 | | |
94 | | // Set the correct linkage. |
95 | 364 | VTT->setLinkage(Linkage); |
96 | | |
97 | 364 | if (CGM.supportsCOMDAT() && VTT->isWeakForLinker()149 ) |
98 | 61 | VTT->setComdat(CGM.getModule().getOrInsertComdat(VTT->getName())); |
99 | | |
100 | | // Set the right visibility. |
101 | 364 | CGM.setGVProperties(VTT, RD); |
102 | 364 | } |
103 | | |
104 | 587 | llvm::GlobalVariable *CodeGenVTables::GetAddrOfVTT(const CXXRecordDecl *RD) { |
105 | 587 | assert(RD->getNumVBases() && "Only classes with virtual bases need a VTT"); |
106 | | |
107 | 0 | SmallString<256> OutName; |
108 | 587 | llvm::raw_svector_ostream Out(OutName); |
109 | 587 | cast<ItaniumMangleContext>(CGM.getCXXABI().getMangleContext()) |
110 | 587 | .mangleCXXVTT(RD, Out); |
111 | 587 | StringRef Name = OutName.str(); |
112 | | |
113 | | // This will also defer the definition of the VTT. |
114 | 587 | (void) CGM.getCXXABI().getAddrOfVTable(RD, CharUnits()); |
115 | | |
116 | 587 | VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false); |
117 | | |
118 | 587 | llvm::ArrayType *ArrayType = |
119 | 587 | llvm::ArrayType::get(CGM.Int8PtrTy, Builder.getVTTComponents().size()); |
120 | 587 | unsigned Align = CGM.getDataLayout().getABITypeAlignment(CGM.Int8PtrTy); |
121 | | |
122 | 587 | llvm::GlobalVariable *GV = CGM.CreateOrReplaceCXXRuntimeVariable( |
123 | 587 | Name, ArrayType, llvm::GlobalValue::ExternalLinkage, Align); |
124 | 587 | GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); |
125 | 587 | return GV; |
126 | 587 | } |
127 | | |
128 | | uint64_t CodeGenVTables::getSubVTTIndex(const CXXRecordDecl *RD, |
129 | 172 | BaseSubobject Base) { |
130 | 172 | BaseSubobjectPairTy ClassSubobjectPair(RD, Base); |
131 | | |
132 | 172 | SubVTTIndiciesMapTy::iterator I = SubVTTIndicies.find(ClassSubobjectPair); |
133 | 172 | if (I != SubVTTIndicies.end()) |
134 | 86 | return I->second; |
135 | | |
136 | 86 | VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false); |
137 | | |
138 | 86 | for (llvm::DenseMap<BaseSubobject, uint64_t>::const_iterator I = |
139 | 86 | Builder.getSubVTTIndicies().begin(), |
140 | 207 | E = Builder.getSubVTTIndicies().end(); I != E; ++I121 ) { |
141 | | // Insert all indices. |
142 | 121 | BaseSubobjectPairTy ClassSubobjectPair(RD, I->first); |
143 | | |
144 | 121 | SubVTTIndicies.insert(std::make_pair(ClassSubobjectPair, I->second)); |
145 | 121 | } |
146 | | |
147 | 86 | I = SubVTTIndicies.find(ClassSubobjectPair); |
148 | 86 | assert(I != SubVTTIndicies.end() && "Did not find index!"); |
149 | | |
150 | 0 | return I->second; |
151 | 172 | } |
152 | | |
153 | | uint64_t |
154 | | CodeGenVTables::getSecondaryVirtualPointerIndex(const CXXRecordDecl *RD, |
155 | 285 | BaseSubobject Base) { |
156 | 285 | SecondaryVirtualPointerIndicesMapTy::iterator I = |
157 | 285 | SecondaryVirtualPointerIndices.find(std::make_pair(RD, Base)); |
158 | | |
159 | 285 | if (I != SecondaryVirtualPointerIndices.end()) |
160 | 116 | return I->second; |
161 | | |
162 | 169 | VTTBuilder Builder(CGM.getContext(), RD, /*GenerateDefinition=*/false); |
163 | | |
164 | | // Insert all secondary vpointer indices. |
165 | 169 | for (llvm::DenseMap<BaseSubobject, uint64_t>::const_iterator I = |
166 | 169 | Builder.getSecondaryVirtualPointerIndices().begin(), |
167 | 434 | E = Builder.getSecondaryVirtualPointerIndices().end(); I != E; ++I265 ) { |
168 | 265 | std::pair<const CXXRecordDecl *, BaseSubobject> Pair = |
169 | 265 | std::make_pair(RD, I->first); |
170 | | |
171 | 265 | SecondaryVirtualPointerIndices.insert(std::make_pair(Pair, I->second)); |
172 | 265 | } |
173 | | |
174 | 169 | I = SecondaryVirtualPointerIndices.find(std::make_pair(RD, Base)); |
175 | 169 | assert(I != SecondaryVirtualPointerIndices.end() && "Did not find index!"); |
176 | | |
177 | 0 | return I->second; |
178 | 285 | } |