/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/CodeGen/CGCXX.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | //===--- CGCXX.cpp - Emit LLVM Code for declarations ----------------------===// |
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. |
10 | | // |
11 | | //===----------------------------------------------------------------------===// |
12 | | |
13 | | // We might split this into multiple files if it gets too unwieldy |
14 | | |
15 | | #include "CGCXXABI.h" |
16 | | #include "CodeGenFunction.h" |
17 | | #include "CodeGenModule.h" |
18 | | #include "clang/AST/ASTContext.h" |
19 | | #include "clang/AST/Attr.h" |
20 | | #include "clang/AST/Decl.h" |
21 | | #include "clang/AST/DeclCXX.h" |
22 | | #include "clang/AST/DeclObjC.h" |
23 | | #include "clang/AST/Mangle.h" |
24 | | #include "clang/AST/RecordLayout.h" |
25 | | #include "clang/AST/StmtCXX.h" |
26 | | #include "clang/Basic/CodeGenOptions.h" |
27 | | #include "llvm/ADT/StringExtras.h" |
28 | | using namespace clang; |
29 | | using namespace CodeGen; |
30 | | |
31 | | |
32 | | /// Try to emit a base destructor as an alias to its primary |
33 | | /// base-class destructor. |
34 | 8.06k | bool CodeGenModule::TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D) { |
35 | 8.06k | if (!getCodeGenOpts().CXXCtorDtorAliases) |
36 | 7.85k | return true; |
37 | | |
38 | | // Producing an alias to a base class ctor/dtor can degrade debug quality |
39 | | // as the debugger cannot tell them apart. |
40 | 209 | if (getCodeGenOpts().OptimizationLevel == 0) |
41 | 69 | return true; |
42 | | |
43 | | // If sanitizing memory to check for use-after-dtor, do not emit as |
44 | | // an alias, unless this class owns no members. |
45 | 140 | if (getCodeGenOpts().SanitizeMemoryUseAfterDtor && |
46 | 140 | !D->getParent()->field_empty()0 ) |
47 | 0 | return true; |
48 | | |
49 | | // If the destructor doesn't have a trivial body, we have to emit it |
50 | | // separately. |
51 | 140 | if (!D->hasTrivialBody()) |
52 | 18 | return true; |
53 | | |
54 | 122 | const CXXRecordDecl *Class = D->getParent(); |
55 | | |
56 | | // We are going to instrument this destructor, so give up even if it is |
57 | | // currently empty. |
58 | 122 | if (Class->mayInsertExtraPadding()) |
59 | 0 | return true; |
60 | | |
61 | | // If we need to manipulate a VTT parameter, give up. |
62 | 122 | if (Class->getNumVBases()) { |
63 | | // Extra Credit: passing extra parameters is perfectly safe |
64 | | // in many calling conventions, so only bail out if the ctor's |
65 | | // calling convention is nonstandard. |
66 | 6 | return true; |
67 | 6 | } |
68 | | |
69 | | // If any field has a non-trivial destructor, we have to emit the |
70 | | // destructor separately. |
71 | 116 | for (const auto *I : Class->fields()) |
72 | 14 | if (I->getType().isDestructedType()) |
73 | 12 | return true; |
74 | | |
75 | | // Try to find a unique base class with a non-trivial destructor. |
76 | 104 | const CXXRecordDecl *UniqueBase = nullptr; |
77 | 104 | for (const auto &I : Class->bases()) { |
78 | | |
79 | | // We're in the base destructor, so skip virtual bases. |
80 | 73 | if (I.isVirtual()) continue0 ; |
81 | | |
82 | | // Skip base classes with trivial destructors. |
83 | 73 | const auto *Base = |
84 | 73 | cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl()); |
85 | 73 | if (Base->hasTrivialDestructor()) continue7 ; |
86 | | |
87 | | // If we've already found a base class with a non-trivial |
88 | | // destructor, give up. |
89 | 66 | if (UniqueBase) return true4 ; |
90 | 62 | UniqueBase = Base; |
91 | 62 | } |
92 | | |
93 | | // If we didn't find any bases with a non-trivial destructor, then |
94 | | // the base destructor is actually effectively trivial, which can |
95 | | // happen if it was needlessly user-defined or if there are virtual |
96 | | // bases with non-trivial destructors. |
97 | 100 | if (!UniqueBase) |
98 | 42 | return true; |
99 | | |
100 | | // If the base is at a non-zero offset, give up. |
101 | 58 | const ASTRecordLayout &ClassLayout = Context.getASTRecordLayout(Class); |
102 | 58 | if (!ClassLayout.getBaseClassOffset(UniqueBase).isZero()) |
103 | 2 | return true; |
104 | | |
105 | | // Give up if the calling conventions don't match. We could update the call, |
106 | | // but it is probably not worth it. |
107 | 56 | const CXXDestructorDecl *BaseD = UniqueBase->getDestructor(); |
108 | 56 | if (BaseD->getType()->castAs<FunctionType>()->getCallConv() != |
109 | 56 | D->getType()->castAs<FunctionType>()->getCallConv()) |
110 | 2 | return true; |
111 | | |
112 | 54 | GlobalDecl AliasDecl(D, Dtor_Base); |
113 | 54 | GlobalDecl TargetDecl(BaseD, Dtor_Base); |
114 | | |
115 | | // The alias will use the linkage of the referent. If we can't |
116 | | // support aliases with that linkage, fail. |
117 | 54 | llvm::GlobalValue::LinkageTypes Linkage = getFunctionLinkage(AliasDecl); |
118 | | |
119 | | // We can't use an alias if the linkage is not valid for one. |
120 | 54 | if (!llvm::GlobalAlias::isValidLinkage(Linkage)) |
121 | 2 | return true; |
122 | | |
123 | 52 | llvm::GlobalValue::LinkageTypes TargetLinkage = |
124 | 52 | getFunctionLinkage(TargetDecl); |
125 | | |
126 | | // Check if we have it already. |
127 | 52 | StringRef MangledName = getMangledName(AliasDecl); |
128 | 52 | llvm::GlobalValue *Entry = GetGlobalValue(MangledName); |
129 | 52 | if (Entry && !Entry->isDeclaration()21 ) |
130 | 0 | return false; |
131 | 52 | if (Replacements.count(MangledName)) |
132 | 0 | return false; |
133 | | |
134 | | // Derive the type for the alias. |
135 | 52 | llvm::Type *AliasValueType = getTypes().GetFunctionType(AliasDecl); |
136 | 52 | llvm::PointerType *AliasType = AliasValueType->getPointerTo(); |
137 | | |
138 | | // Find the referent. Some aliases might require a bitcast, in |
139 | | // which case the caller is responsible for ensuring the soundness |
140 | | // of these semantics. |
141 | 52 | auto *Ref = cast<llvm::GlobalValue>(GetAddrOfGlobal(TargetDecl)); |
142 | 52 | llvm::Constant *Aliasee = Ref; |
143 | 52 | if (Ref->getType() != AliasType) |
144 | 52 | Aliasee = llvm::ConstantExpr::getBitCast(Ref, AliasType); |
145 | | |
146 | | // Instead of creating as alias to a linkonce_odr, replace all of the uses |
147 | | // of the aliasee. |
148 | 52 | if (llvm::GlobalValue::isDiscardableIfUnused(Linkage) && |
149 | 52 | !(21 TargetLinkage == llvm::GlobalValue::AvailableExternallyLinkage21 && |
150 | 21 | TargetDecl.getDecl()->hasAttr<AlwaysInlineAttr>()2 )) { |
151 | | // FIXME: An extern template instantiation will create functions with |
152 | | // linkage "AvailableExternally". In libc++, some classes also define |
153 | | // members with attribute "AlwaysInline" and expect no reference to |
154 | | // be generated. It is desirable to reenable this optimisation after |
155 | | // corresponding LLVM changes. |
156 | 19 | addReplacement(MangledName, Aliasee); |
157 | 19 | return false; |
158 | 19 | } |
159 | | |
160 | | // If we have a weak, non-discardable alias (weak, weak_odr), like an extern |
161 | | // template instantiation or a dllexported class, avoid forming it on COFF. |
162 | | // A COFF weak external alias cannot satisfy a normal undefined symbol |
163 | | // reference from another TU. The other TU must also mark the referenced |
164 | | // symbol as weak, which we cannot rely on. |
165 | 33 | if (llvm::GlobalValue::isWeakForLinker(Linkage) && |
166 | 33 | getTriple().isOSBinFormatCOFF()8 ) { |
167 | 7 | return true; |
168 | 7 | } |
169 | | |
170 | | // If we don't have a definition for the destructor yet or the definition is |
171 | | // avaialable_externally, don't emit an alias. We can't emit aliases to |
172 | | // declarations; that's just not how aliases work. |
173 | 26 | if (Ref->isDeclarationForLinker()) |
174 | 5 | return true; |
175 | | |
176 | | // Don't create an alias to a linker weak symbol. This avoids producing |
177 | | // different COMDATs in different TUs. Another option would be to |
178 | | // output the alias both for weak_odr and linkonce_odr, but that |
179 | | // requires explicit comdat support in the IL. |
180 | 21 | if (llvm::GlobalValue::isWeakForLinker(TargetLinkage)) |
181 | 2 | return true; |
182 | | |
183 | | // Create the alias with no name. |
184 | 19 | auto *Alias = llvm::GlobalAlias::create(AliasValueType, 0, Linkage, "", |
185 | 19 | Aliasee, &getModule()); |
186 | | |
187 | | // Destructors are always unnamed_addr. |
188 | 19 | Alias->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); |
189 | | |
190 | | // Switch any previous uses to the alias. |
191 | 19 | if (Entry) { |
192 | 0 | assert(Entry->getType() == AliasType && |
193 | 0 | "declaration exists with different type"); |
194 | 0 | Alias->takeName(Entry); |
195 | 0 | Entry->replaceAllUsesWith(Alias); |
196 | 0 | Entry->eraseFromParent(); |
197 | 19 | } else { |
198 | 19 | Alias->setName(MangledName); |
199 | 19 | } |
200 | | |
201 | | // Finally, set up the alias with its proper name and attributes. |
202 | 0 | SetCommonAttributes(AliasDecl, Alias); |
203 | | |
204 | 19 | return false; |
205 | 21 | } |
206 | | |
207 | 56.7k | llvm::Function *CodeGenModule::codegenCXXStructor(GlobalDecl GD) { |
208 | 56.7k | const CGFunctionInfo &FnInfo = getTypes().arrangeCXXStructorDeclaration(GD); |
209 | 56.7k | auto *Fn = cast<llvm::Function>( |
210 | 56.7k | getAddrOfCXXStructor(GD, &FnInfo, /*FnType=*/nullptr, |
211 | 56.7k | /*DontDefer=*/true, ForDefinition)); |
212 | | |
213 | 56.7k | setFunctionLinkage(GD, Fn); |
214 | | |
215 | 56.7k | CodeGenFunction(*this).GenerateCode(GD, Fn, FnInfo); |
216 | 56.7k | setNonAliasAttributes(GD, Fn); |
217 | 56.7k | SetLLVMFunctionAttributesForDefinition(cast<CXXMethodDecl>(GD.getDecl()), Fn); |
218 | 56.7k | return Fn; |
219 | 56.7k | } |
220 | | |
221 | | llvm::FunctionCallee CodeGenModule::getAddrAndTypeOfCXXStructor( |
222 | | GlobalDecl GD, const CGFunctionInfo *FnInfo, llvm::FunctionType *FnType, |
223 | 203k | bool DontDefer, ForDefinition_t IsForDefinition) { |
224 | 203k | auto *MD = cast<CXXMethodDecl>(GD.getDecl()); |
225 | | |
226 | 203k | if (isa<CXXDestructorDecl>(MD)) { |
227 | | // Always alias equivalent complete destructors to base destructors in the |
228 | | // MS ABI. |
229 | 68.0k | if (getTarget().getCXXABI().isMicrosoft() && |
230 | 68.0k | GD.getDtorType() == Dtor_Complete2.38k && |
231 | 68.0k | MD->getParent()->getNumVBases() == 0498 ) |
232 | 123 | GD = GD.getWithDtorType(Dtor_Base); |
233 | 68.0k | } |
234 | | |
235 | 203k | if (!FnType) { |
236 | 203k | if (!FnInfo) |
237 | 146k | FnInfo = &getTypes().arrangeCXXStructorDeclaration(GD); |
238 | 203k | FnType = getTypes().GetFunctionType(*FnInfo); |
239 | 203k | } |
240 | | |
241 | 203k | llvm::Constant *Ptr = GetOrCreateLLVMFunction( |
242 | 203k | getMangledName(GD), FnType, GD, /*ForVTable=*/false, DontDefer, |
243 | 203k | /*IsThunk=*/false, /*ExtraAttrs=*/llvm::AttributeList(), IsForDefinition); |
244 | 203k | return {FnType, Ptr}; |
245 | 203k | } |
246 | | |
247 | | static CGCallee BuildAppleKextVirtualCall(CodeGenFunction &CGF, |
248 | | GlobalDecl GD, |
249 | | llvm::Type *Ty, |
250 | 15 | const CXXRecordDecl *RD) { |
251 | 15 | assert(!CGF.CGM.getTarget().getCXXABI().isMicrosoft() && |
252 | 15 | "No kext in Microsoft ABI"); |
253 | 0 | CodeGenModule &CGM = CGF.CGM; |
254 | 15 | llvm::Value *VTable = CGM.getCXXABI().getAddrOfVTable(RD, CharUnits()); |
255 | 15 | Ty = Ty->getPointerTo(); |
256 | 15 | VTable = CGF.Builder.CreateBitCast(VTable, Ty->getPointerTo()); |
257 | 15 | assert(VTable && "BuildVirtualCall = kext vtbl pointer is null"); |
258 | 0 | uint64_t VTableIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(GD); |
259 | 15 | const VTableLayout &VTLayout = CGM.getItaniumVTableContext().getVTableLayout(RD); |
260 | 15 | VTableLayout::AddressPointLocation AddressPoint = |
261 | 15 | VTLayout.getAddressPoint(BaseSubobject(RD, CharUnits::Zero())); |
262 | 15 | VTableIndex += VTLayout.getVTableOffset(AddressPoint.VTableIndex) + |
263 | 15 | AddressPoint.AddressPointIndex; |
264 | 15 | llvm::Value *VFuncPtr = |
265 | 15 | CGF.Builder.CreateConstInBoundsGEP1_64(Ty, VTable, VTableIndex, "vfnkxt"); |
266 | 15 | llvm::Value *VFunc = CGF.Builder.CreateAlignedLoad( |
267 | 15 | Ty, VFuncPtr, llvm::Align(CGF.PointerAlignInBytes)); |
268 | 15 | CGCallee Callee(GD, VFunc); |
269 | 15 | return Callee; |
270 | 15 | } |
271 | | |
272 | | /// BuildAppleKextVirtualCall - This routine is to support gcc's kext ABI making |
273 | | /// indirect call to virtual functions. It makes the call through indexing |
274 | | /// into the vtable. |
275 | | CGCallee |
276 | | CodeGenFunction::BuildAppleKextVirtualCall(const CXXMethodDecl *MD, |
277 | | NestedNameSpecifier *Qual, |
278 | 8 | llvm::Type *Ty) { |
279 | 8 | assert((Qual->getKind() == NestedNameSpecifier::TypeSpec) && |
280 | 8 | "BuildAppleKextVirtualCall - bad Qual kind"); |
281 | | |
282 | 0 | const Type *QTy = Qual->getAsType(); |
283 | 8 | QualType T = QualType(QTy, 0); |
284 | 8 | const RecordType *RT = T->getAs<RecordType>(); |
285 | 8 | assert(RT && "BuildAppleKextVirtualCall - Qual type must be record"); |
286 | 0 | const auto *RD = cast<CXXRecordDecl>(RT->getDecl()); |
287 | | |
288 | 8 | if (const auto *DD = dyn_cast<CXXDestructorDecl>(MD)) |
289 | 2 | return BuildAppleKextVirtualDestructorCall(DD, Dtor_Complete, RD); |
290 | | |
291 | 6 | return ::BuildAppleKextVirtualCall(*this, MD, Ty, RD); |
292 | 8 | } |
293 | | |
294 | | /// BuildVirtualCall - This routine makes indirect vtable call for |
295 | | /// call to virtual destructors. It returns 0 if it could not do it. |
296 | | CGCallee |
297 | | CodeGenFunction::BuildAppleKextVirtualDestructorCall( |
298 | | const CXXDestructorDecl *DD, |
299 | | CXXDtorType Type, |
300 | 9 | const CXXRecordDecl *RD) { |
301 | 9 | assert(DD->isVirtual() && Type != Dtor_Base); |
302 | | // Compute the function type we're calling. |
303 | 0 | const CGFunctionInfo &FInfo = CGM.getTypes().arrangeCXXStructorDeclaration( |
304 | 9 | GlobalDecl(DD, Dtor_Complete)); |
305 | 9 | llvm::Type *Ty = CGM.getTypes().GetFunctionType(FInfo); |
306 | 9 | return ::BuildAppleKextVirtualCall(*this, GlobalDecl(DD, Type), Ty, RD); |
307 | 9 | } |