Bug Summary

File:tools/clang/lib/CodeGen/ItaniumCXXABI.cpp
Warning:line 1349, column 27
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ItaniumCXXABI.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/include -I /build/llvm-toolchain-snapshot-10~svn373517/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/tools/clang/lib/CodeGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~svn373517=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-10-02-234743-9763-1 -x c++ /build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp
1//===------- ItaniumCXXABI.cpp - Emit LLVM Code from ASTs for a Module ----===//
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 provides C++ code generation targeting the Itanium C++ ABI. The class
10// in this file generates structures that follow the Itanium C++ ABI, which is
11// documented at:
12// http://www.codesourcery.com/public/cxx-abi/abi.html
13// http://www.codesourcery.com/public/cxx-abi/abi-eh.html
14//
15// It also supports the closely-related ARM ABI, documented at:
16// http://infocenter.arm.com/help/topic/com.arm.doc.ihi0041c/IHI0041C_cppabi.pdf
17//
18//===----------------------------------------------------------------------===//
19
20#include "CGCXXABI.h"
21#include "CGCleanup.h"
22#include "CGRecordLayout.h"
23#include "CGVTables.h"
24#include "CodeGenFunction.h"
25#include "CodeGenModule.h"
26#include "TargetInfo.h"
27#include "clang/CodeGen/ConstantInitBuilder.h"
28#include "clang/AST/Mangle.h"
29#include "clang/AST/Type.h"
30#include "clang/AST/StmtCXX.h"
31#include "llvm/IR/DataLayout.h"
32#include "llvm/IR/GlobalValue.h"
33#include "llvm/IR/Instructions.h"
34#include "llvm/IR/Intrinsics.h"
35#include "llvm/IR/Value.h"
36#include "llvm/Support/ScopedPrinter.h"
37
38using namespace clang;
39using namespace CodeGen;
40
41namespace {
42class ItaniumCXXABI : public CodeGen::CGCXXABI {
43 /// VTables - All the vtables which have been defined.
44 llvm::DenseMap<const CXXRecordDecl *, llvm::GlobalVariable *> VTables;
45
46 /// All the thread wrapper functions that have been used.
47 llvm::SmallVector<std::pair<const VarDecl *, llvm::Function *>, 8>
48 ThreadWrappers;
49
50protected:
51 bool UseARMMethodPtrABI;
52 bool UseARMGuardVarABI;
53 bool Use32BitVTableOffsetABI;
54
55 ItaniumMangleContext &getMangleContext() {
56 return cast<ItaniumMangleContext>(CodeGen::CGCXXABI::getMangleContext());
57 }
58
59public:
60 ItaniumCXXABI(CodeGen::CodeGenModule &CGM,
61 bool UseARMMethodPtrABI = false,
62 bool UseARMGuardVarABI = false) :
63 CGCXXABI(CGM), UseARMMethodPtrABI(UseARMMethodPtrABI),
64 UseARMGuardVarABI(UseARMGuardVarABI),
65 Use32BitVTableOffsetABI(false) { }
66
67 bool classifyReturnType(CGFunctionInfo &FI) const override;
68
69 RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const override {
70 // If C++ prohibits us from making a copy, pass by address.
71 if (!RD->canPassInRegisters())
72 return RAA_Indirect;
73 return RAA_Default;
74 }
75
76 bool isThisCompleteObject(GlobalDecl GD) const override {
77 // The Itanium ABI has separate complete-object vs. base-object
78 // variants of both constructors and destructors.
79 if (isa<CXXDestructorDecl>(GD.getDecl())) {
80 switch (GD.getDtorType()) {
81 case Dtor_Complete:
82 case Dtor_Deleting:
83 return true;
84
85 case Dtor_Base:
86 return false;
87
88 case Dtor_Comdat:
89 llvm_unreachable("emitting dtor comdat as function?")::llvm::llvm_unreachable_internal("emitting dtor comdat as function?"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 89)
;
90 }
91 llvm_unreachable("bad dtor kind")::llvm::llvm_unreachable_internal("bad dtor kind", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 91)
;
92 }
93 if (isa<CXXConstructorDecl>(GD.getDecl())) {
94 switch (GD.getCtorType()) {
95 case Ctor_Complete:
96 return true;
97
98 case Ctor_Base:
99 return false;
100
101 case Ctor_CopyingClosure:
102 case Ctor_DefaultClosure:
103 llvm_unreachable("closure ctors in Itanium ABI?")::llvm::llvm_unreachable_internal("closure ctors in Itanium ABI?"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 103)
;
104
105 case Ctor_Comdat:
106 llvm_unreachable("emitting ctor comdat as function?")::llvm::llvm_unreachable_internal("emitting ctor comdat as function?"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 106)
;
107 }
108 llvm_unreachable("bad dtor kind")::llvm::llvm_unreachable_internal("bad dtor kind", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 108)
;
109 }
110
111 // No other kinds.
112 return false;
113 }
114
115 bool isZeroInitializable(const MemberPointerType *MPT) override;
116
117 llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT) override;
118
119 CGCallee
120 EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
121 const Expr *E,
122 Address This,
123 llvm::Value *&ThisPtrForCall,
124 llvm::Value *MemFnPtr,
125 const MemberPointerType *MPT) override;
126
127 llvm::Value *
128 EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
129 Address Base,
130 llvm::Value *MemPtr,
131 const MemberPointerType *MPT) override;
132
133 llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,
134 const CastExpr *E,
135 llvm::Value *Src) override;
136 llvm::Constant *EmitMemberPointerConversion(const CastExpr *E,
137 llvm::Constant *Src) override;
138
139 llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT) override;
140
141 llvm::Constant *EmitMemberFunctionPointer(const CXXMethodDecl *MD) override;
142 llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT,
143 CharUnits offset) override;
144 llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT) override;
145 llvm::Constant *BuildMemberPointer(const CXXMethodDecl *MD,
146 CharUnits ThisAdjustment);
147
148 llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF,
149 llvm::Value *L, llvm::Value *R,
150 const MemberPointerType *MPT,
151 bool Inequality) override;
152
153 llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
154 llvm::Value *Addr,
155 const MemberPointerType *MPT) override;
156
157 void emitVirtualObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE,
158 Address Ptr, QualType ElementType,
159 const CXXDestructorDecl *Dtor) override;
160
161 void emitRethrow(CodeGenFunction &CGF, bool isNoReturn) override;
162 void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) override;
163
164 void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) override;
165
166 llvm::CallInst *
167 emitTerminateForUnexpectedException(CodeGenFunction &CGF,
168 llvm::Value *Exn) override;
169
170 void EmitFundamentalRTTIDescriptors(const CXXRecordDecl *RD);
171 llvm::Constant *getAddrOfRTTIDescriptor(QualType Ty) override;
172 CatchTypeInfo
173 getAddrOfCXXCatchHandlerType(QualType Ty,
174 QualType CatchHandlerType) override {
175 return CatchTypeInfo{getAddrOfRTTIDescriptor(Ty), 0};
176 }
177
178 bool shouldTypeidBeNullChecked(bool IsDeref, QualType SrcRecordTy) override;
179 void EmitBadTypeidCall(CodeGenFunction &CGF) override;
180 llvm::Value *EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy,
181 Address ThisPtr,
182 llvm::Type *StdTypeInfoPtrTy) override;
183
184 bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
185 QualType SrcRecordTy) override;
186
187 llvm::Value *EmitDynamicCastCall(CodeGenFunction &CGF, Address Value,
188 QualType SrcRecordTy, QualType DestTy,
189 QualType DestRecordTy,
190 llvm::BasicBlock *CastEnd) override;
191
192 llvm::Value *EmitDynamicCastToVoid(CodeGenFunction &CGF, Address Value,
193 QualType SrcRecordTy,
194 QualType DestTy) override;
195
196 bool EmitBadCastCall(CodeGenFunction &CGF) override;
197
198 llvm::Value *
199 GetVirtualBaseClassOffset(CodeGenFunction &CGF, Address This,
200 const CXXRecordDecl *ClassDecl,
201 const CXXRecordDecl *BaseClassDecl) override;
202
203 void EmitCXXConstructors(const CXXConstructorDecl *D) override;
204
205 AddedStructorArgs
206 buildStructorSignature(GlobalDecl GD,
207 SmallVectorImpl<CanQualType> &ArgTys) override;
208
209 bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor,
210 CXXDtorType DT) const override {
211 // Itanium does not emit any destructor variant as an inline thunk.
212 // Delegating may occur as an optimization, but all variants are either
213 // emitted with external linkage or as linkonce if they are inline and used.
214 return false;
215 }
216
217 void EmitCXXDestructors(const CXXDestructorDecl *D) override;
218
219 void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy,
220 FunctionArgList &Params) override;
221
222 void EmitInstanceFunctionProlog(CodeGenFunction &CGF) override;
223
224 AddedStructorArgs
225 addImplicitConstructorArgs(CodeGenFunction &CGF, const CXXConstructorDecl *D,
226 CXXCtorType Type, bool ForVirtualBase,
227 bool Delegating, CallArgList &Args) override;
228
229 void EmitDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *DD,
230 CXXDtorType Type, bool ForVirtualBase,
231 bool Delegating, Address This,
232 QualType ThisTy) override;
233
234 void emitVTableDefinitions(CodeGenVTables &CGVT,
235 const CXXRecordDecl *RD) override;
236
237 bool isVirtualOffsetNeededForVTableField(CodeGenFunction &CGF,
238 CodeGenFunction::VPtr Vptr) override;
239
240 bool doStructorsInitializeVPtrs(const CXXRecordDecl *VTableClass) override {
241 return true;
242 }
243
244 llvm::Constant *
245 getVTableAddressPoint(BaseSubobject Base,
246 const CXXRecordDecl *VTableClass) override;
247
248 llvm::Value *getVTableAddressPointInStructor(
249 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass,
250 BaseSubobject Base, const CXXRecordDecl *NearestVBase) override;
251
252 llvm::Value *getVTableAddressPointInStructorWithVTT(
253 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass,
254 BaseSubobject Base, const CXXRecordDecl *NearestVBase);
255
256 llvm::Constant *
257 getVTableAddressPointForConstExpr(BaseSubobject Base,
258 const CXXRecordDecl *VTableClass) override;
259
260 llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD,
261 CharUnits VPtrOffset) override;
262
263 CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD,
264 Address This, llvm::Type *Ty,
265 SourceLocation Loc) override;
266
267 llvm::Value *EmitVirtualDestructorCall(CodeGenFunction &CGF,
268 const CXXDestructorDecl *Dtor,
269 CXXDtorType DtorType, Address This,
270 DeleteOrMemberCallExpr E) override;
271
272 void emitVirtualInheritanceTables(const CXXRecordDecl *RD) override;
273
274 bool canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const override;
275 bool canSpeculativelyEmitVTableAsBaseClass(const CXXRecordDecl *RD) const;
276
277 void setThunkLinkage(llvm::Function *Thunk, bool ForVTable, GlobalDecl GD,
278 bool ReturnAdjustment) override {
279 // Allow inlining of thunks by emitting them with available_externally
280 // linkage together with vtables when needed.
281 if (ForVTable && !Thunk->hasLocalLinkage())
282 Thunk->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
283 CGM.setGVProperties(Thunk, GD);
284 }
285
286 bool exportThunk() override { return true; }
287
288 llvm::Value *performThisAdjustment(CodeGenFunction &CGF, Address This,
289 const ThisAdjustment &TA) override;
290
291 llvm::Value *performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
292 const ReturnAdjustment &RA) override;
293
294 size_t getSrcArgforCopyCtor(const CXXConstructorDecl *,
295 FunctionArgList &Args) const override {
296 assert(!Args.empty() && "expected the arglist to not be empty!")((!Args.empty() && "expected the arglist to not be empty!"
) ? static_cast<void> (0) : __assert_fail ("!Args.empty() && \"expected the arglist to not be empty!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 296, __PRETTY_FUNCTION__))
;
297 return Args.size() - 1;
298 }
299
300 StringRef GetPureVirtualCallName() override { return "__cxa_pure_virtual"; }
301 StringRef GetDeletedVirtualCallName() override
302 { return "__cxa_deleted_virtual"; }
303
304 CharUnits getArrayCookieSizeImpl(QualType elementType) override;
305 Address InitializeArrayCookie(CodeGenFunction &CGF,
306 Address NewPtr,
307 llvm::Value *NumElements,
308 const CXXNewExpr *expr,
309 QualType ElementType) override;
310 llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF,
311 Address allocPtr,
312 CharUnits cookieSize) override;
313
314 void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
315 llvm::GlobalVariable *DeclPtr,
316 bool PerformInit) override;
317 void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
318 llvm::FunctionCallee dtor,
319 llvm::Constant *addr) override;
320
321 llvm::Function *getOrCreateThreadLocalWrapper(const VarDecl *VD,
322 llvm::Value *Val);
323 void EmitThreadLocalInitFuncs(
324 CodeGenModule &CGM,
325 ArrayRef<const VarDecl *> CXXThreadLocals,
326 ArrayRef<llvm::Function *> CXXThreadLocalInits,
327 ArrayRef<const VarDecl *> CXXThreadLocalInitVars) override;
328
329 /// Determine whether we will definitely emit this variable with a constant
330 /// initializer, either because the language semantics demand it or because
331 /// we know that the initializer is a constant.
332 bool isEmittedWithConstantInitializer(const VarDecl *VD) const {
333 VD = VD->getMostRecentDecl();
334 if (VD->hasAttr<ConstInitAttr>())
335 return true;
336
337 // All later checks examine the initializer specified on the variable. If
338 // the variable is weak, such examination would not be correct.
339 if (VD->isWeak() || VD->hasAttr<SelectAnyAttr>())
340 return false;
341
342 const VarDecl *InitDecl = VD->getInitializingDeclaration();
343 if (!InitDecl)
344 return false;
345
346 // If there's no initializer to run, this is constant initialization.
347 if (!InitDecl->hasInit())
348 return true;
349
350 // If we have the only definition, we don't need a thread wrapper if we
351 // will emit the value as a constant.
352 if (isUniqueGVALinkage(getContext().GetGVALinkageForVariable(VD)))
353 return !VD->needsDestruction(getContext()) && InitDecl->evaluateValue();
354
355 // Otherwise, we need a thread wrapper unless we know that every
356 // translation unit will emit the value as a constant. We rely on
357 // ICE-ness not varying between translation units, which isn't actually
358 // guaranteed by the standard but is necessary for sanity.
359 return InitDecl->isInitKnownICE() && InitDecl->isInitICE();
360 }
361
362 bool usesThreadWrapperFunction(const VarDecl *VD) const override {
363 return !isEmittedWithConstantInitializer(VD) ||
364 VD->needsDestruction(getContext());
365 }
366 LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD,
367 QualType LValType) override;
368
369 bool NeedsVTTParameter(GlobalDecl GD) override;
370
371 /**************************** RTTI Uniqueness ******************************/
372
373protected:
374 /// Returns true if the ABI requires RTTI type_info objects to be unique
375 /// across a program.
376 virtual bool shouldRTTIBeUnique() const { return true; }
377
378public:
379 /// What sort of unique-RTTI behavior should we use?
380 enum RTTIUniquenessKind {
381 /// We are guaranteeing, or need to guarantee, that the RTTI string
382 /// is unique.
383 RUK_Unique,
384
385 /// We are not guaranteeing uniqueness for the RTTI string, so we
386 /// can demote to hidden visibility but must use string comparisons.
387 RUK_NonUniqueHidden,
388
389 /// We are not guaranteeing uniqueness for the RTTI string, so we
390 /// have to use string comparisons, but we also have to emit it with
391 /// non-hidden visibility.
392 RUK_NonUniqueVisible
393 };
394
395 /// Return the required visibility status for the given type and linkage in
396 /// the current ABI.
397 RTTIUniquenessKind
398 classifyRTTIUniqueness(QualType CanTy,
399 llvm::GlobalValue::LinkageTypes Linkage) const;
400 friend class ItaniumRTTIBuilder;
401
402 void emitCXXStructor(GlobalDecl GD) override;
403
404 std::pair<llvm::Value *, const CXXRecordDecl *>
405 LoadVTablePtr(CodeGenFunction &CGF, Address This,
406 const CXXRecordDecl *RD) override;
407
408 private:
409 bool hasAnyUnusedVirtualInlineFunction(const CXXRecordDecl *RD) const {
410 const auto &VtableLayout =
411 CGM.getItaniumVTableContext().getVTableLayout(RD);
412
413 for (const auto &VtableComponent : VtableLayout.vtable_components()) {
414 // Skip empty slot.
415 if (!VtableComponent.isUsedFunctionPointerKind())
416 continue;
417
418 const CXXMethodDecl *Method = VtableComponent.getFunctionDecl();
419 if (!Method->getCanonicalDecl()->isInlined())
420 continue;
421
422 StringRef Name = CGM.getMangledName(VtableComponent.getGlobalDecl());
423 auto *Entry = CGM.GetGlobalValue(Name);
424 // This checks if virtual inline function has already been emitted.
425 // Note that it is possible that this inline function would be emitted
426 // after trying to emit vtable speculatively. Because of this we do
427 // an extra pass after emitting all deferred vtables to find and emit
428 // these vtables opportunistically.
429 if (!Entry || Entry->isDeclaration())
430 return true;
431 }
432 return false;
433 }
434
435 bool isVTableHidden(const CXXRecordDecl *RD) const {
436 const auto &VtableLayout =
437 CGM.getItaniumVTableContext().getVTableLayout(RD);
438
439 for (const auto &VtableComponent : VtableLayout.vtable_components()) {
440 if (VtableComponent.isRTTIKind()) {
441 const CXXRecordDecl *RTTIDecl = VtableComponent.getRTTIDecl();
442 if (RTTIDecl->getVisibility() == Visibility::HiddenVisibility)
443 return true;
444 } else if (VtableComponent.isUsedFunctionPointerKind()) {
445 const CXXMethodDecl *Method = VtableComponent.getFunctionDecl();
446 if (Method->getVisibility() == Visibility::HiddenVisibility &&
447 !Method->isDefined())
448 return true;
449 }
450 }
451 return false;
452 }
453};
454
455class ARMCXXABI : public ItaniumCXXABI {
456public:
457 ARMCXXABI(CodeGen::CodeGenModule &CGM) :
458 ItaniumCXXABI(CGM, /*UseARMMethodPtrABI=*/true,
459 /*UseARMGuardVarABI=*/true) {}
460
461 bool HasThisReturn(GlobalDecl GD) const override {
462 return (isa<CXXConstructorDecl>(GD.getDecl()) || (
463 isa<CXXDestructorDecl>(GD.getDecl()) &&
464 GD.getDtorType() != Dtor_Deleting));
465 }
466
467 void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV,
468 QualType ResTy) override;
469
470 CharUnits getArrayCookieSizeImpl(QualType elementType) override;
471 Address InitializeArrayCookie(CodeGenFunction &CGF,
472 Address NewPtr,
473 llvm::Value *NumElements,
474 const CXXNewExpr *expr,
475 QualType ElementType) override;
476 llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF, Address allocPtr,
477 CharUnits cookieSize) override;
478};
479
480class iOS64CXXABI : public ARMCXXABI {
481public:
482 iOS64CXXABI(CodeGen::CodeGenModule &CGM) : ARMCXXABI(CGM) {
483 Use32BitVTableOffsetABI = true;
484 }
485
486 // ARM64 libraries are prepared for non-unique RTTI.
487 bool shouldRTTIBeUnique() const override { return false; }
488};
489
490class WebAssemblyCXXABI final : public ItaniumCXXABI {
491public:
492 explicit WebAssemblyCXXABI(CodeGen::CodeGenModule &CGM)
493 : ItaniumCXXABI(CGM, /*UseARMMethodPtrABI=*/true,
494 /*UseARMGuardVarABI=*/true) {}
495 void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) override;
496
497private:
498 bool HasThisReturn(GlobalDecl GD) const override {
499 return isa<CXXConstructorDecl>(GD.getDecl()) ||
500 (isa<CXXDestructorDecl>(GD.getDecl()) &&
501 GD.getDtorType() != Dtor_Deleting);
502 }
503 bool canCallMismatchedFunctionType() const override { return false; }
504};
505}
506
507CodeGen::CGCXXABI *CodeGen::CreateItaniumCXXABI(CodeGenModule &CGM) {
508 switch (CGM.getTarget().getCXXABI().getKind()) {
509 // For IR-generation purposes, there's no significant difference
510 // between the ARM and iOS ABIs.
511 case TargetCXXABI::GenericARM:
512 case TargetCXXABI::iOS:
513 case TargetCXXABI::WatchOS:
514 return new ARMCXXABI(CGM);
515
516 case TargetCXXABI::iOS64:
517 return new iOS64CXXABI(CGM);
518
519 // Note that AArch64 uses the generic ItaniumCXXABI class since it doesn't
520 // include the other 32-bit ARM oddities: constructor/destructor return values
521 // and array cookies.
522 case TargetCXXABI::GenericAArch64:
523 return new ItaniumCXXABI(CGM, /*UseARMMethodPtrABI=*/true,
524 /*UseARMGuardVarABI=*/true);
525
526 case TargetCXXABI::GenericMIPS:
527 return new ItaniumCXXABI(CGM, /*UseARMMethodPtrABI=*/true);
528
529 case TargetCXXABI::WebAssembly:
530 return new WebAssemblyCXXABI(CGM);
531
532 case TargetCXXABI::GenericItanium:
533 if (CGM.getContext().getTargetInfo().getTriple().getArch()
534 == llvm::Triple::le32) {
535 // For PNaCl, use ARM-style method pointers so that PNaCl code
536 // does not assume anything about the alignment of function
537 // pointers.
538 return new ItaniumCXXABI(CGM, /*UseARMMethodPtrABI=*/true);
539 }
540 return new ItaniumCXXABI(CGM);
541
542 case TargetCXXABI::Microsoft:
543 llvm_unreachable("Microsoft ABI is not Itanium-based")::llvm::llvm_unreachable_internal("Microsoft ABI is not Itanium-based"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 543)
;
544 }
545 llvm_unreachable("bad ABI kind")::llvm::llvm_unreachable_internal("bad ABI kind", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 545)
;
546}
547
548llvm::Type *
549ItaniumCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
550 if (MPT->isMemberDataPointer())
551 return CGM.PtrDiffTy;
552 return llvm::StructType::get(CGM.PtrDiffTy, CGM.PtrDiffTy);
553}
554
555/// In the Itanium and ARM ABIs, method pointers have the form:
556/// struct { ptrdiff_t ptr; ptrdiff_t adj; } memptr;
557///
558/// In the Itanium ABI:
559/// - method pointers are virtual if (memptr.ptr & 1) is nonzero
560/// - the this-adjustment is (memptr.adj)
561/// - the virtual offset is (memptr.ptr - 1)
562///
563/// In the ARM ABI:
564/// - method pointers are virtual if (memptr.adj & 1) is nonzero
565/// - the this-adjustment is (memptr.adj >> 1)
566/// - the virtual offset is (memptr.ptr)
567/// ARM uses 'adj' for the virtual flag because Thumb functions
568/// may be only single-byte aligned.
569///
570/// If the member is virtual, the adjusted 'this' pointer points
571/// to a vtable pointer from which the virtual offset is applied.
572///
573/// If the member is non-virtual, memptr.ptr is the address of
574/// the function to call.
575CGCallee ItaniumCXXABI::EmitLoadOfMemberFunctionPointer(
576 CodeGenFunction &CGF, const Expr *E, Address ThisAddr,
577 llvm::Value *&ThisPtrForCall,
578 llvm::Value *MemFnPtr, const MemberPointerType *MPT) {
579 CGBuilderTy &Builder = CGF.Builder;
580
581 const FunctionProtoType *FPT =
582 MPT->getPointeeType()->getAs<FunctionProtoType>();
583 const CXXRecordDecl *RD =
584 cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
585
586 llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
587 CGM.getTypes().arrangeCXXMethodType(RD, FPT, /*FD=*/nullptr));
588
589 llvm::Constant *ptrdiff_1 = llvm::ConstantInt::get(CGM.PtrDiffTy, 1);
590
591 llvm::BasicBlock *FnVirtual = CGF.createBasicBlock("memptr.virtual");
592 llvm::BasicBlock *FnNonVirtual = CGF.createBasicBlock("memptr.nonvirtual");
593 llvm::BasicBlock *FnEnd = CGF.createBasicBlock("memptr.end");
594
595 // Extract memptr.adj, which is in the second field.
596 llvm::Value *RawAdj = Builder.CreateExtractValue(MemFnPtr, 1, "memptr.adj");
597
598 // Compute the true adjustment.
599 llvm::Value *Adj = RawAdj;
600 if (UseARMMethodPtrABI)
601 Adj = Builder.CreateAShr(Adj, ptrdiff_1, "memptr.adj.shifted");
602
603 // Apply the adjustment and cast back to the original struct type
604 // for consistency.
605 llvm::Value *This = ThisAddr.getPointer();
606 llvm::Value *Ptr = Builder.CreateBitCast(This, Builder.getInt8PtrTy());
607 Ptr = Builder.CreateInBoundsGEP(Ptr, Adj);
608 This = Builder.CreateBitCast(Ptr, This->getType(), "this.adjusted");
609 ThisPtrForCall = This;
610
611 // Load the function pointer.
612 llvm::Value *FnAsInt = Builder.CreateExtractValue(MemFnPtr, 0, "memptr.ptr");
613
614 // If the LSB in the function pointer is 1, the function pointer points to
615 // a virtual function.
616 llvm::Value *IsVirtual;
617 if (UseARMMethodPtrABI)
618 IsVirtual = Builder.CreateAnd(RawAdj, ptrdiff_1);
619 else
620 IsVirtual = Builder.CreateAnd(FnAsInt, ptrdiff_1);
621 IsVirtual = Builder.CreateIsNotNull(IsVirtual, "memptr.isvirtual");
622 Builder.CreateCondBr(IsVirtual, FnVirtual, FnNonVirtual);
623
624 // In the virtual path, the adjustment left 'This' pointing to the
625 // vtable of the correct base subobject. The "function pointer" is an
626 // offset within the vtable (+1 for the virtual flag on non-ARM).
627 CGF.EmitBlock(FnVirtual);
628
629 // Cast the adjusted this to a pointer to vtable pointer and load.
630 llvm::Type *VTableTy = Builder.getInt8PtrTy();
631 CharUnits VTablePtrAlign =
632 CGF.CGM.getDynamicOffsetAlignment(ThisAddr.getAlignment(), RD,
633 CGF.getPointerAlign());
634 llvm::Value *VTable =
635 CGF.GetVTablePtr(Address(This, VTablePtrAlign), VTableTy, RD);
636
637 // Apply the offset.
638 // On ARM64, to reserve extra space in virtual member function pointers,
639 // we only pay attention to the low 32 bits of the offset.
640 llvm::Value *VTableOffset = FnAsInt;
641 if (!UseARMMethodPtrABI)
642 VTableOffset = Builder.CreateSub(VTableOffset, ptrdiff_1);
643 if (Use32BitVTableOffsetABI) {
644 VTableOffset = Builder.CreateTrunc(VTableOffset, CGF.Int32Ty);
645 VTableOffset = Builder.CreateZExt(VTableOffset, CGM.PtrDiffTy);
646 }
647 // Compute the address of the virtual function pointer.
648 llvm::Value *VFPAddr = Builder.CreateGEP(VTable, VTableOffset);
649
650 // Check the address of the function pointer if CFI on member function
651 // pointers is enabled.
652 llvm::Constant *CheckSourceLocation;
653 llvm::Constant *CheckTypeDesc;
654 bool ShouldEmitCFICheck = CGF.SanOpts.has(SanitizerKind::CFIMFCall) &&
655 CGM.HasHiddenLTOVisibility(RD);
656 if (ShouldEmitCFICheck) {
657 CodeGenFunction::SanitizerScope SanScope(&CGF);
658
659 CheckSourceLocation = CGF.EmitCheckSourceLocation(E->getBeginLoc());
660 CheckTypeDesc = CGF.EmitCheckTypeDescriptor(QualType(MPT, 0));
661 llvm::Constant *StaticData[] = {
662 llvm::ConstantInt::get(CGF.Int8Ty, CodeGenFunction::CFITCK_VMFCall),
663 CheckSourceLocation,
664 CheckTypeDesc,
665 };
666
667 llvm::Metadata *MD =
668 CGM.CreateMetadataIdentifierForVirtualMemPtrType(QualType(MPT, 0));
669 llvm::Value *TypeId = llvm::MetadataAsValue::get(CGF.getLLVMContext(), MD);
670
671 llvm::Value *TypeTest = Builder.CreateCall(
672 CGM.getIntrinsic(llvm::Intrinsic::type_test), {VFPAddr, TypeId});
673
674 if (CGM.getCodeGenOpts().SanitizeTrap.has(SanitizerKind::CFIMFCall)) {
675 CGF.EmitTrapCheck(TypeTest);
676 } else {
677 llvm::Value *AllVtables = llvm::MetadataAsValue::get(
678 CGM.getLLVMContext(),
679 llvm::MDString::get(CGM.getLLVMContext(), "all-vtables"));
680 llvm::Value *ValidVtable = Builder.CreateCall(
681 CGM.getIntrinsic(llvm::Intrinsic::type_test), {VTable, AllVtables});
682 CGF.EmitCheck(std::make_pair(TypeTest, SanitizerKind::CFIMFCall),
683 SanitizerHandler::CFICheckFail, StaticData,
684 {VTable, ValidVtable});
685 }
686
687 FnVirtual = Builder.GetInsertBlock();
688 }
689
690 // Load the virtual function to call.
691 VFPAddr = Builder.CreateBitCast(VFPAddr, FTy->getPointerTo()->getPointerTo());
692 llvm::Value *VirtualFn = Builder.CreateAlignedLoad(
693 VFPAddr, CGF.getPointerAlign(), "memptr.virtualfn");
694 CGF.EmitBranch(FnEnd);
695
696 // In the non-virtual path, the function pointer is actually a
697 // function pointer.
698 CGF.EmitBlock(FnNonVirtual);
699 llvm::Value *NonVirtualFn =
700 Builder.CreateIntToPtr(FnAsInt, FTy->getPointerTo(), "memptr.nonvirtualfn");
701
702 // Check the function pointer if CFI on member function pointers is enabled.
703 if (ShouldEmitCFICheck) {
704 CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl();
705 if (RD->hasDefinition()) {
706 CodeGenFunction::SanitizerScope SanScope(&CGF);
707
708 llvm::Constant *StaticData[] = {
709 llvm::ConstantInt::get(CGF.Int8Ty, CodeGenFunction::CFITCK_NVMFCall),
710 CheckSourceLocation,
711 CheckTypeDesc,
712 };
713
714 llvm::Value *Bit = Builder.getFalse();
715 llvm::Value *CastedNonVirtualFn =
716 Builder.CreateBitCast(NonVirtualFn, CGF.Int8PtrTy);
717 for (const CXXRecordDecl *Base : CGM.getMostBaseClasses(RD)) {
718 llvm::Metadata *MD = CGM.CreateMetadataIdentifierForType(
719 getContext().getMemberPointerType(
720 MPT->getPointeeType(),
721 getContext().getRecordType(Base).getTypePtr()));
722 llvm::Value *TypeId =
723 llvm::MetadataAsValue::get(CGF.getLLVMContext(), MD);
724
725 llvm::Value *TypeTest =
726 Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::type_test),
727 {CastedNonVirtualFn, TypeId});
728 Bit = Builder.CreateOr(Bit, TypeTest);
729 }
730
731 CGF.EmitCheck(std::make_pair(Bit, SanitizerKind::CFIMFCall),
732 SanitizerHandler::CFICheckFail, StaticData,
733 {CastedNonVirtualFn, llvm::UndefValue::get(CGF.IntPtrTy)});
734
735 FnNonVirtual = Builder.GetInsertBlock();
736 }
737 }
738
739 // We're done.
740 CGF.EmitBlock(FnEnd);
741 llvm::PHINode *CalleePtr = Builder.CreatePHI(FTy->getPointerTo(), 2);
742 CalleePtr->addIncoming(VirtualFn, FnVirtual);
743 CalleePtr->addIncoming(NonVirtualFn, FnNonVirtual);
744
745 CGCallee Callee(FPT, CalleePtr);
746 return Callee;
747}
748
749/// Compute an l-value by applying the given pointer-to-member to a
750/// base object.
751llvm::Value *ItaniumCXXABI::EmitMemberDataPointerAddress(
752 CodeGenFunction &CGF, const Expr *E, Address Base, llvm::Value *MemPtr,
753 const MemberPointerType *MPT) {
754 assert(MemPtr->getType() == CGM.PtrDiffTy)((MemPtr->getType() == CGM.PtrDiffTy) ? static_cast<void
> (0) : __assert_fail ("MemPtr->getType() == CGM.PtrDiffTy"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 754, __PRETTY_FUNCTION__))
;
755
756 CGBuilderTy &Builder = CGF.Builder;
757
758 // Cast to char*.
759 Base = Builder.CreateElementBitCast(Base, CGF.Int8Ty);
760
761 // Apply the offset, which we assume is non-null.
762 llvm::Value *Addr =
763 Builder.CreateInBoundsGEP(Base.getPointer(), MemPtr, "memptr.offset");
764
765 // Cast the address to the appropriate pointer type, adopting the
766 // address space of the base pointer.
767 llvm::Type *PType = CGF.ConvertTypeForMem(MPT->getPointeeType())
768 ->getPointerTo(Base.getAddressSpace());
769 return Builder.CreateBitCast(Addr, PType);
770}
771
772/// Perform a bitcast, derived-to-base, or base-to-derived member pointer
773/// conversion.
774///
775/// Bitcast conversions are always a no-op under Itanium.
776///
777/// Obligatory offset/adjustment diagram:
778/// <-- offset --> <-- adjustment -->
779/// |--------------------------|----------------------|--------------------|
780/// ^Derived address point ^Base address point ^Member address point
781///
782/// So when converting a base member pointer to a derived member pointer,
783/// we add the offset to the adjustment because the address point has
784/// decreased; and conversely, when converting a derived MP to a base MP
785/// we subtract the offset from the adjustment because the address point
786/// has increased.
787///
788/// The standard forbids (at compile time) conversion to and from
789/// virtual bases, which is why we don't have to consider them here.
790///
791/// The standard forbids (at run time) casting a derived MP to a base
792/// MP when the derived MP does not point to a member of the base.
793/// This is why -1 is a reasonable choice for null data member
794/// pointers.
795llvm::Value *
796ItaniumCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
797 const CastExpr *E,
798 llvm::Value *src) {
799 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||((E->getCastKind() == CK_DerivedToBaseMemberPointer || E->
getCastKind() == CK_BaseToDerivedMemberPointer || E->getCastKind
() == CK_ReinterpretMemberPointer) ? static_cast<void> (
0) : __assert_fail ("E->getCastKind() == CK_DerivedToBaseMemberPointer || E->getCastKind() == CK_BaseToDerivedMemberPointer || E->getCastKind() == CK_ReinterpretMemberPointer"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 801, __PRETTY_FUNCTION__))
800 E->getCastKind() == CK_BaseToDerivedMemberPointer ||((E->getCastKind() == CK_DerivedToBaseMemberPointer || E->
getCastKind() == CK_BaseToDerivedMemberPointer || E->getCastKind
() == CK_ReinterpretMemberPointer) ? static_cast<void> (
0) : __assert_fail ("E->getCastKind() == CK_DerivedToBaseMemberPointer || E->getCastKind() == CK_BaseToDerivedMemberPointer || E->getCastKind() == CK_ReinterpretMemberPointer"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 801, __PRETTY_FUNCTION__))
801 E->getCastKind() == CK_ReinterpretMemberPointer)((E->getCastKind() == CK_DerivedToBaseMemberPointer || E->
getCastKind() == CK_BaseToDerivedMemberPointer || E->getCastKind
() == CK_ReinterpretMemberPointer) ? static_cast<void> (
0) : __assert_fail ("E->getCastKind() == CK_DerivedToBaseMemberPointer || E->getCastKind() == CK_BaseToDerivedMemberPointer || E->getCastKind() == CK_ReinterpretMemberPointer"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 801, __PRETTY_FUNCTION__))
;
802
803 // Under Itanium, reinterprets don't require any additional processing.
804 if (E->getCastKind() == CK_ReinterpretMemberPointer) return src;
805
806 // Use constant emission if we can.
807 if (isa<llvm::Constant>(src))
808 return EmitMemberPointerConversion(E, cast<llvm::Constant>(src));
809
810 llvm::Constant *adj = getMemberPointerAdjustment(E);
811 if (!adj) return src;
812
813 CGBuilderTy &Builder = CGF.Builder;
814 bool isDerivedToBase = (E->getCastKind() == CK_DerivedToBaseMemberPointer);
815
816 const MemberPointerType *destTy =
817 E->getType()->castAs<MemberPointerType>();
818
819 // For member data pointers, this is just a matter of adding the
820 // offset if the source is non-null.
821 if (destTy->isMemberDataPointer()) {
822 llvm::Value *dst;
823 if (isDerivedToBase)
824 dst = Builder.CreateNSWSub(src, adj, "adj");
825 else
826 dst = Builder.CreateNSWAdd(src, adj, "adj");
827
828 // Null check.
829 llvm::Value *null = llvm::Constant::getAllOnesValue(src->getType());
830 llvm::Value *isNull = Builder.CreateICmpEQ(src, null, "memptr.isnull");
831 return Builder.CreateSelect(isNull, src, dst);
832 }
833
834 // The this-adjustment is left-shifted by 1 on ARM.
835 if (UseARMMethodPtrABI) {
836 uint64_t offset = cast<llvm::ConstantInt>(adj)->getZExtValue();
837 offset <<= 1;
838 adj = llvm::ConstantInt::get(adj->getType(), offset);
839 }
840
841 llvm::Value *srcAdj = Builder.CreateExtractValue(src, 1, "src.adj");
842 llvm::Value *dstAdj;
843 if (isDerivedToBase)
844 dstAdj = Builder.CreateNSWSub(srcAdj, adj, "adj");
845 else
846 dstAdj = Builder.CreateNSWAdd(srcAdj, adj, "adj");
847
848 return Builder.CreateInsertValue(src, dstAdj, 1);
849}
850
851llvm::Constant *
852ItaniumCXXABI::EmitMemberPointerConversion(const CastExpr *E,
853 llvm::Constant *src) {
854 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||((E->getCastKind() == CK_DerivedToBaseMemberPointer || E->
getCastKind() == CK_BaseToDerivedMemberPointer || E->getCastKind
() == CK_ReinterpretMemberPointer) ? static_cast<void> (
0) : __assert_fail ("E->getCastKind() == CK_DerivedToBaseMemberPointer || E->getCastKind() == CK_BaseToDerivedMemberPointer || E->getCastKind() == CK_ReinterpretMemberPointer"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 856, __PRETTY_FUNCTION__))
855 E->getCastKind() == CK_BaseToDerivedMemberPointer ||((E->getCastKind() == CK_DerivedToBaseMemberPointer || E->
getCastKind() == CK_BaseToDerivedMemberPointer || E->getCastKind
() == CK_ReinterpretMemberPointer) ? static_cast<void> (
0) : __assert_fail ("E->getCastKind() == CK_DerivedToBaseMemberPointer || E->getCastKind() == CK_BaseToDerivedMemberPointer || E->getCastKind() == CK_ReinterpretMemberPointer"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 856, __PRETTY_FUNCTION__))
856 E->getCastKind() == CK_ReinterpretMemberPointer)((E->getCastKind() == CK_DerivedToBaseMemberPointer || E->
getCastKind() == CK_BaseToDerivedMemberPointer || E->getCastKind
() == CK_ReinterpretMemberPointer) ? static_cast<void> (
0) : __assert_fail ("E->getCastKind() == CK_DerivedToBaseMemberPointer || E->getCastKind() == CK_BaseToDerivedMemberPointer || E->getCastKind() == CK_ReinterpretMemberPointer"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 856, __PRETTY_FUNCTION__))
;
857
858 // Under Itanium, reinterprets don't require any additional processing.
859 if (E->getCastKind() == CK_ReinterpretMemberPointer) return src;
860
861 // If the adjustment is trivial, we don't need to do anything.
862 llvm::Constant *adj = getMemberPointerAdjustment(E);
863 if (!adj) return src;
864
865 bool isDerivedToBase = (E->getCastKind() == CK_DerivedToBaseMemberPointer);
866
867 const MemberPointerType *destTy =
868 E->getType()->castAs<MemberPointerType>();
869
870 // For member data pointers, this is just a matter of adding the
871 // offset if the source is non-null.
872 if (destTy->isMemberDataPointer()) {
873 // null maps to null.
874 if (src->isAllOnesValue()) return src;
875
876 if (isDerivedToBase)
877 return llvm::ConstantExpr::getNSWSub(src, adj);
878 else
879 return llvm::ConstantExpr::getNSWAdd(src, adj);
880 }
881
882 // The this-adjustment is left-shifted by 1 on ARM.
883 if (UseARMMethodPtrABI) {
884 uint64_t offset = cast<llvm::ConstantInt>(adj)->getZExtValue();
885 offset <<= 1;
886 adj = llvm::ConstantInt::get(adj->getType(), offset);
887 }
888
889 llvm::Constant *srcAdj = llvm::ConstantExpr::getExtractValue(src, 1);
890 llvm::Constant *dstAdj;
891 if (isDerivedToBase)
892 dstAdj = llvm::ConstantExpr::getNSWSub(srcAdj, adj);
893 else
894 dstAdj = llvm::ConstantExpr::getNSWAdd(srcAdj, adj);
895
896 return llvm::ConstantExpr::getInsertValue(src, dstAdj, 1);
897}
898
899llvm::Constant *
900ItaniumCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
901 // Itanium C++ ABI 2.3:
902 // A NULL pointer is represented as -1.
903 if (MPT->isMemberDataPointer())
904 return llvm::ConstantInt::get(CGM.PtrDiffTy, -1ULL, /*isSigned=*/true);
905
906 llvm::Constant *Zero = llvm::ConstantInt::get(CGM.PtrDiffTy, 0);
907 llvm::Constant *Values[2] = { Zero, Zero };
908 return llvm::ConstantStruct::getAnon(Values);
909}
910
911llvm::Constant *
912ItaniumCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
913 CharUnits offset) {
914 // Itanium C++ ABI 2.3:
915 // A pointer to data member is an offset from the base address of
916 // the class object containing it, represented as a ptrdiff_t
917 return llvm::ConstantInt::get(CGM.PtrDiffTy, offset.getQuantity());
918}
919
920llvm::Constant *
921ItaniumCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) {
922 return BuildMemberPointer(MD, CharUnits::Zero());
923}
924
925llvm::Constant *ItaniumCXXABI::BuildMemberPointer(const CXXMethodDecl *MD,
926 CharUnits ThisAdjustment) {
927 assert(MD->isInstance() && "Member function must not be static!")((MD->isInstance() && "Member function must not be static!"
) ? static_cast<void> (0) : __assert_fail ("MD->isInstance() && \"Member function must not be static!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 927, __PRETTY_FUNCTION__))
;
928
929 CodeGenTypes &Types = CGM.getTypes();
930
931 // Get the function pointer (or index if this is a virtual function).
932 llvm::Constant *MemPtr[2];
933 if (MD->isVirtual()) {
934 uint64_t Index = CGM.getItaniumVTableContext().getMethodVTableIndex(MD);
935
936 const ASTContext &Context = getContext();
937 CharUnits PointerWidth =
938 Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
939 uint64_t VTableOffset = (Index * PointerWidth.getQuantity());
940
941 if (UseARMMethodPtrABI) {
942 // ARM C++ ABI 3.2.1:
943 // This ABI specifies that adj contains twice the this
944 // adjustment, plus 1 if the member function is virtual. The
945 // least significant bit of adj then makes exactly the same
946 // discrimination as the least significant bit of ptr does for
947 // Itanium.
948 MemPtr[0] = llvm::ConstantInt::get(CGM.PtrDiffTy, VTableOffset);
949 MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
950 2 * ThisAdjustment.getQuantity() + 1);
951 } else {
952 // Itanium C++ ABI 2.3:
953 // For a virtual function, [the pointer field] is 1 plus the
954 // virtual table offset (in bytes) of the function,
955 // represented as a ptrdiff_t.
956 MemPtr[0] = llvm::ConstantInt::get(CGM.PtrDiffTy, VTableOffset + 1);
957 MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
958 ThisAdjustment.getQuantity());
959 }
960 } else {
961 const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
962 llvm::Type *Ty;
963 // Check whether the function has a computable LLVM signature.
964 if (Types.isFuncTypeConvertible(FPT)) {
965 // The function has a computable LLVM signature; use the correct type.
966 Ty = Types.GetFunctionType(Types.arrangeCXXMethodDeclaration(MD));
967 } else {
968 // Use an arbitrary non-function type to tell GetAddrOfFunction that the
969 // function type is incomplete.
970 Ty = CGM.PtrDiffTy;
971 }
972 llvm::Constant *addr = CGM.GetAddrOfFunction(MD, Ty);
973
974 MemPtr[0] = llvm::ConstantExpr::getPtrToInt(addr, CGM.PtrDiffTy);
975 MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
976 (UseARMMethodPtrABI ? 2 : 1) *
977 ThisAdjustment.getQuantity());
978 }
979
980 return llvm::ConstantStruct::getAnon(MemPtr);
981}
982
983llvm::Constant *ItaniumCXXABI::EmitMemberPointer(const APValue &MP,
984 QualType MPType) {
985 const MemberPointerType *MPT = MPType->castAs<MemberPointerType>();
986 const ValueDecl *MPD = MP.getMemberPointerDecl();
987 if (!MPD)
988 return EmitNullMemberPointer(MPT);
989
990 CharUnits ThisAdjustment = getMemberPointerPathAdjustment(MP);
991
992 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MPD))
993 return BuildMemberPointer(MD, ThisAdjustment);
994
995 CharUnits FieldOffset =
996 getContext().toCharUnitsFromBits(getContext().getFieldOffset(MPD));
997 return EmitMemberDataPointer(MPT, ThisAdjustment + FieldOffset);
998}
999
1000/// The comparison algorithm is pretty easy: the member pointers are
1001/// the same if they're either bitwise identical *or* both null.
1002///
1003/// ARM is different here only because null-ness is more complicated.
1004llvm::Value *
1005ItaniumCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
1006 llvm::Value *L,
1007 llvm::Value *R,
1008 const MemberPointerType *MPT,
1009 bool Inequality) {
1010 CGBuilderTy &Builder = CGF.Builder;
1011
1012 llvm::ICmpInst::Predicate Eq;
1013 llvm::Instruction::BinaryOps And, Or;
1014 if (Inequality) {
1015 Eq = llvm::ICmpInst::ICMP_NE;
1016 And = llvm::Instruction::Or;
1017 Or = llvm::Instruction::And;
1018 } else {
1019 Eq = llvm::ICmpInst::ICMP_EQ;
1020 And = llvm::Instruction::And;
1021 Or = llvm::Instruction::Or;
1022 }
1023
1024 // Member data pointers are easy because there's a unique null
1025 // value, so it just comes down to bitwise equality.
1026 if (MPT->isMemberDataPointer())
1027 return Builder.CreateICmp(Eq, L, R);
1028
1029 // For member function pointers, the tautologies are more complex.
1030 // The Itanium tautology is:
1031 // (L == R) <==> (L.ptr == R.ptr && (L.ptr == 0 || L.adj == R.adj))
1032 // The ARM tautology is:
1033 // (L == R) <==> (L.ptr == R.ptr &&
1034 // (L.adj == R.adj ||
1035 // (L.ptr == 0 && ((L.adj|R.adj) & 1) == 0)))
1036 // The inequality tautologies have exactly the same structure, except
1037 // applying De Morgan's laws.
1038
1039 llvm::Value *LPtr = Builder.CreateExtractValue(L, 0, "lhs.memptr.ptr");
1040 llvm::Value *RPtr = Builder.CreateExtractValue(R, 0, "rhs.memptr.ptr");
1041
1042 // This condition tests whether L.ptr == R.ptr. This must always be
1043 // true for equality to hold.
1044 llvm::Value *PtrEq = Builder.CreateICmp(Eq, LPtr, RPtr, "cmp.ptr");
1045
1046 // This condition, together with the assumption that L.ptr == R.ptr,
1047 // tests whether the pointers are both null. ARM imposes an extra
1048 // condition.
1049 llvm::Value *Zero = llvm::Constant::getNullValue(LPtr->getType());
1050 llvm::Value *EqZero = Builder.CreateICmp(Eq, LPtr, Zero, "cmp.ptr.null");
1051
1052 // This condition tests whether L.adj == R.adj. If this isn't
1053 // true, the pointers are unequal unless they're both null.
1054 llvm::Value *LAdj = Builder.CreateExtractValue(L, 1, "lhs.memptr.adj");
1055 llvm::Value *RAdj = Builder.CreateExtractValue(R, 1, "rhs.memptr.adj");
1056 llvm::Value *AdjEq = Builder.CreateICmp(Eq, LAdj, RAdj, "cmp.adj");
1057
1058 // Null member function pointers on ARM clear the low bit of Adj,
1059 // so the zero condition has to check that neither low bit is set.
1060 if (UseARMMethodPtrABI) {
1061 llvm::Value *One = llvm::ConstantInt::get(LPtr->getType(), 1);
1062
1063 // Compute (l.adj | r.adj) & 1 and test it against zero.
1064 llvm::Value *OrAdj = Builder.CreateOr(LAdj, RAdj, "or.adj");
1065 llvm::Value *OrAdjAnd1 = Builder.CreateAnd(OrAdj, One);
1066 llvm::Value *OrAdjAnd1EqZero = Builder.CreateICmp(Eq, OrAdjAnd1, Zero,
1067 "cmp.or.adj");
1068 EqZero = Builder.CreateBinOp(And, EqZero, OrAdjAnd1EqZero);
1069 }
1070
1071 // Tie together all our conditions.
1072 llvm::Value *Result = Builder.CreateBinOp(Or, EqZero, AdjEq);
1073 Result = Builder.CreateBinOp(And, PtrEq, Result,
1074 Inequality ? "memptr.ne" : "memptr.eq");
1075 return Result;
1076}
1077
1078llvm::Value *
1079ItaniumCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
1080 llvm::Value *MemPtr,
1081 const MemberPointerType *MPT) {
1082 CGBuilderTy &Builder = CGF.Builder;
1083
1084 /// For member data pointers, this is just a check against -1.
1085 if (MPT->isMemberDataPointer()) {
1086 assert(MemPtr->getType() == CGM.PtrDiffTy)((MemPtr->getType() == CGM.PtrDiffTy) ? static_cast<void
> (0) : __assert_fail ("MemPtr->getType() == CGM.PtrDiffTy"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 1086, __PRETTY_FUNCTION__))
;
1087 llvm::Value *NegativeOne =
1088 llvm::Constant::getAllOnesValue(MemPtr->getType());
1089 return Builder.CreateICmpNE(MemPtr, NegativeOne, "memptr.tobool");
1090 }
1091
1092 // In Itanium, a member function pointer is not null if 'ptr' is not null.
1093 llvm::Value *Ptr = Builder.CreateExtractValue(MemPtr, 0, "memptr.ptr");
1094
1095 llvm::Constant *Zero = llvm::ConstantInt::get(Ptr->getType(), 0);
1096 llvm::Value *Result = Builder.CreateICmpNE(Ptr, Zero, "memptr.tobool");
1097
1098 // On ARM, a member function pointer is also non-null if the low bit of 'adj'
1099 // (the virtual bit) is set.
1100 if (UseARMMethodPtrABI) {
1101 llvm::Constant *One = llvm::ConstantInt::get(Ptr->getType(), 1);
1102 llvm::Value *Adj = Builder.CreateExtractValue(MemPtr, 1, "memptr.adj");
1103 llvm::Value *VirtualBit = Builder.CreateAnd(Adj, One, "memptr.virtualbit");
1104 llvm::Value *IsVirtual = Builder.CreateICmpNE(VirtualBit, Zero,
1105 "memptr.isvirtual");
1106 Result = Builder.CreateOr(Result, IsVirtual);
1107 }
1108
1109 return Result;
1110}
1111
1112bool ItaniumCXXABI::classifyReturnType(CGFunctionInfo &FI) const {
1113 const CXXRecordDecl *RD = FI.getReturnType()->getAsCXXRecordDecl();
1114 if (!RD)
1115 return false;
1116
1117 // If C++ prohibits us from making a copy, return by address.
1118 if (!RD->canPassInRegisters()) {
1119 auto Align = CGM.getContext().getTypeAlignInChars(FI.getReturnType());
1120 FI.getReturnInfo() = ABIArgInfo::getIndirect(Align, /*ByVal=*/false);
1121 return true;
1122 }
1123 return false;
1124}
1125
1126/// The Itanium ABI requires non-zero initialization only for data
1127/// member pointers, for which '0' is a valid offset.
1128bool ItaniumCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
1129 return MPT->isMemberFunctionPointer();
1130}
1131
1132/// The Itanium ABI always places an offset to the complete object
1133/// at entry -2 in the vtable.
1134void ItaniumCXXABI::emitVirtualObjectDelete(CodeGenFunction &CGF,
1135 const CXXDeleteExpr *DE,
1136 Address Ptr,
1137 QualType ElementType,
1138 const CXXDestructorDecl *Dtor) {
1139 bool UseGlobalDelete = DE->isGlobalDelete();
1140 if (UseGlobalDelete) {
1141 // Derive the complete-object pointer, which is what we need
1142 // to pass to the deallocation function.
1143
1144 // Grab the vtable pointer as an intptr_t*.
1145 auto *ClassDecl =
1146 cast<CXXRecordDecl>(ElementType->getAs<RecordType>()->getDecl());
1147 llvm::Value *VTable =
1148 CGF.GetVTablePtr(Ptr, CGF.IntPtrTy->getPointerTo(), ClassDecl);
1149
1150 // Track back to entry -2 and pull out the offset there.
1151 llvm::Value *OffsetPtr = CGF.Builder.CreateConstInBoundsGEP1_64(
1152 VTable, -2, "complete-offset.ptr");
1153 llvm::Value *Offset =
1154 CGF.Builder.CreateAlignedLoad(OffsetPtr, CGF.getPointerAlign());
1155
1156 // Apply the offset.
1157 llvm::Value *CompletePtr =
1158 CGF.Builder.CreateBitCast(Ptr.getPointer(), CGF.Int8PtrTy);
1159 CompletePtr = CGF.Builder.CreateInBoundsGEP(CompletePtr, Offset);
1160
1161 // If we're supposed to call the global delete, make sure we do so
1162 // even if the destructor throws.
1163 CGF.pushCallObjectDeleteCleanup(DE->getOperatorDelete(), CompletePtr,
1164 ElementType);
1165 }
1166
1167 // FIXME: Provide a source location here even though there's no
1168 // CXXMemberCallExpr for dtor call.
1169 CXXDtorType DtorType = UseGlobalDelete ? Dtor_Complete : Dtor_Deleting;
1170 EmitVirtualDestructorCall(CGF, Dtor, DtorType, Ptr, DE);
1171
1172 if (UseGlobalDelete)
1173 CGF.PopCleanupBlock();
1174}
1175
1176void ItaniumCXXABI::emitRethrow(CodeGenFunction &CGF, bool isNoReturn) {
1177 // void __cxa_rethrow();
1178
1179 llvm::FunctionType *FTy =
1180 llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
1181
1182 llvm::FunctionCallee Fn = CGM.CreateRuntimeFunction(FTy, "__cxa_rethrow");
1183
1184 if (isNoReturn)
1185 CGF.EmitNoreturnRuntimeCallOrInvoke(Fn, None);
1186 else
1187 CGF.EmitRuntimeCallOrInvoke(Fn);
1188}
1189
1190static llvm::FunctionCallee getAllocateExceptionFn(CodeGenModule &CGM) {
1191 // void *__cxa_allocate_exception(size_t thrown_size);
1192
1193 llvm::FunctionType *FTy =
1194 llvm::FunctionType::get(CGM.Int8PtrTy, CGM.SizeTy, /*isVarArg=*/false);
1195
1196 return CGM.CreateRuntimeFunction(FTy, "__cxa_allocate_exception");
1197}
1198
1199static llvm::FunctionCallee getThrowFn(CodeGenModule &CGM) {
1200 // void __cxa_throw(void *thrown_exception, std::type_info *tinfo,
1201 // void (*dest) (void *));
1202
1203 llvm::Type *Args[3] = { CGM.Int8PtrTy, CGM.Int8PtrTy, CGM.Int8PtrTy };
1204 llvm::FunctionType *FTy =
1205 llvm::FunctionType::get(CGM.VoidTy, Args, /*isVarArg=*/false);
1206
1207 return CGM.CreateRuntimeFunction(FTy, "__cxa_throw");
1208}
1209
1210void ItaniumCXXABI::emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) {
1211 QualType ThrowType = E->getSubExpr()->getType();
1212 // Now allocate the exception object.
1213 llvm::Type *SizeTy = CGF.ConvertType(getContext().getSizeType());
1214 uint64_t TypeSize = getContext().getTypeSizeInChars(ThrowType).getQuantity();
1215
1216 llvm::FunctionCallee AllocExceptionFn = getAllocateExceptionFn(CGM);
1217 llvm::CallInst *ExceptionPtr = CGF.EmitNounwindRuntimeCall(
1218 AllocExceptionFn, llvm::ConstantInt::get(SizeTy, TypeSize), "exception");
1219
1220 CharUnits ExnAlign = CGF.getContext().getExnObjectAlignment();
1221 CGF.EmitAnyExprToExn(E->getSubExpr(), Address(ExceptionPtr, ExnAlign));
1222
1223 // Now throw the exception.
1224 llvm::Constant *TypeInfo = CGM.GetAddrOfRTTIDescriptor(ThrowType,
1225 /*ForEH=*/true);
1226
1227 // The address of the destructor. If the exception type has a
1228 // trivial destructor (or isn't a record), we just pass null.
1229 llvm::Constant *Dtor = nullptr;
1230 if (const RecordType *RecordTy = ThrowType->getAs<RecordType>()) {
1231 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordTy->getDecl());
1232 if (!Record->hasTrivialDestructor()) {
1233 CXXDestructorDecl *DtorD = Record->getDestructor();
1234 Dtor = CGM.getAddrOfCXXStructor(GlobalDecl(DtorD, Dtor_Complete));
1235 Dtor = llvm::ConstantExpr::getBitCast(Dtor, CGM.Int8PtrTy);
1236 }
1237 }
1238 if (!Dtor) Dtor = llvm::Constant::getNullValue(CGM.Int8PtrTy);
1239
1240 llvm::Value *args[] = { ExceptionPtr, TypeInfo, Dtor };
1241 CGF.EmitNoreturnRuntimeCallOrInvoke(getThrowFn(CGM), args);
1242}
1243
1244static llvm::FunctionCallee getItaniumDynamicCastFn(CodeGenFunction &CGF) {
1245 // void *__dynamic_cast(const void *sub,
1246 // const abi::__class_type_info *src,
1247 // const abi::__class_type_info *dst,
1248 // std::ptrdiff_t src2dst_offset);
1249
1250 llvm::Type *Int8PtrTy = CGF.Int8PtrTy;
1251 llvm::Type *PtrDiffTy =
1252 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1253
1254 llvm::Type *Args[4] = { Int8PtrTy, Int8PtrTy, Int8PtrTy, PtrDiffTy };
1255
1256 llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, Args, false);
1257
1258 // Mark the function as nounwind readonly.
1259 llvm::Attribute::AttrKind FuncAttrs[] = { llvm::Attribute::NoUnwind,
1260 llvm::Attribute::ReadOnly };
1261 llvm::AttributeList Attrs = llvm::AttributeList::get(
1262 CGF.getLLVMContext(), llvm::AttributeList::FunctionIndex, FuncAttrs);
1263
1264 return CGF.CGM.CreateRuntimeFunction(FTy, "__dynamic_cast", Attrs);
1265}
1266
1267static llvm::FunctionCallee getBadCastFn(CodeGenFunction &CGF) {
1268 // void __cxa_bad_cast();
1269 llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
1270 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_cast");
1271}
1272
1273/// Compute the src2dst_offset hint as described in the
1274/// Itanium C++ ABI [2.9.7]
1275static CharUnits computeOffsetHint(ASTContext &Context,
1276 const CXXRecordDecl *Src,
1277 const CXXRecordDecl *Dst) {
1278 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1279 /*DetectVirtual=*/false);
1280
1281 // If Dst is not derived from Src we can skip the whole computation below and
1282 // return that Src is not a public base of Dst. Record all inheritance paths.
1283 if (!Dst->isDerivedFrom(Src, Paths))
1284 return CharUnits::fromQuantity(-2ULL);
1285
1286 unsigned NumPublicPaths = 0;
1287 CharUnits Offset;
1288
1289 // Now walk all possible inheritance paths.
1290 for (const CXXBasePath &Path : Paths) {
1291 if (Path.Access != AS_public) // Ignore non-public inheritance.
1292 continue;
1293
1294 ++NumPublicPaths;
1295
1296 for (const CXXBasePathElement &PathElement : Path) {
1297 // If the path contains a virtual base class we can't give any hint.
1298 // -1: no hint.
1299 if (PathElement.Base->isVirtual())
1300 return CharUnits::fromQuantity(-1ULL);
1301
1302 if (NumPublicPaths > 1) // Won't use offsets, skip computation.
1303 continue;
1304
1305 // Accumulate the base class offsets.
1306 const ASTRecordLayout &L = Context.getASTRecordLayout(PathElement.Class);
1307 Offset += L.getBaseClassOffset(
1308 PathElement.Base->getType()->getAsCXXRecordDecl());
1309 }
1310 }
1311
1312 // -2: Src is not a public base of Dst.
1313 if (NumPublicPaths == 0)
1314 return CharUnits::fromQuantity(-2ULL);
1315
1316 // -3: Src is a multiple public base type but never a virtual base type.
1317 if (NumPublicPaths > 1)
1318 return CharUnits::fromQuantity(-3ULL);
1319
1320 // Otherwise, the Src type is a unique public nonvirtual base type of Dst.
1321 // Return the offset of Src from the origin of Dst.
1322 return Offset;
1323}
1324
1325static llvm::FunctionCallee getBadTypeidFn(CodeGenFunction &CGF) {
1326 // void __cxa_bad_typeid();
1327 llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
1328
1329 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_typeid");
1330}
1331
1332bool ItaniumCXXABI::shouldTypeidBeNullChecked(bool IsDeref,
1333 QualType SrcRecordTy) {
1334 return IsDeref;
1335}
1336
1337void ItaniumCXXABI::EmitBadTypeidCall(CodeGenFunction &CGF) {
1338 llvm::FunctionCallee Fn = getBadTypeidFn(CGF);
1339 llvm::CallBase *Call = CGF.EmitRuntimeCallOrInvoke(Fn);
1340 Call->setDoesNotReturn();
1341 CGF.Builder.CreateUnreachable();
1342}
1343
1344llvm::Value *ItaniumCXXABI::EmitTypeid(CodeGenFunction &CGF,
1345 QualType SrcRecordTy,
1346 Address ThisPtr,
1347 llvm::Type *StdTypeInfoPtrTy) {
1348 auto *ClassDecl =
1349 cast<CXXRecordDecl>(SrcRecordTy->getAs<RecordType>()->getDecl());
1
Assuming the object is not a 'RecordType'
2
Called C++ object pointer is null
1350 llvm::Value *Value =
1351 CGF.GetVTablePtr(ThisPtr, StdTypeInfoPtrTy->getPointerTo(), ClassDecl);
1352
1353 // Load the type info.
1354 Value = CGF.Builder.CreateConstInBoundsGEP1_64(Value, -1ULL);
1355 return CGF.Builder.CreateAlignedLoad(Value, CGF.getPointerAlign());
1356}
1357
1358bool ItaniumCXXABI::shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
1359 QualType SrcRecordTy) {
1360 return SrcIsPtr;
1361}
1362
1363llvm::Value *ItaniumCXXABI::EmitDynamicCastCall(
1364 CodeGenFunction &CGF, Address ThisAddr, QualType SrcRecordTy,
1365 QualType DestTy, QualType DestRecordTy, llvm::BasicBlock *CastEnd) {
1366 llvm::Type *PtrDiffLTy =
1367 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1368 llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1369
1370 llvm::Value *SrcRTTI =
1371 CGF.CGM.GetAddrOfRTTIDescriptor(SrcRecordTy.getUnqualifiedType());
1372 llvm::Value *DestRTTI =
1373 CGF.CGM.GetAddrOfRTTIDescriptor(DestRecordTy.getUnqualifiedType());
1374
1375 // Compute the offset hint.
1376 const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl();
1377 const CXXRecordDecl *DestDecl = DestRecordTy->getAsCXXRecordDecl();
1378 llvm::Value *OffsetHint = llvm::ConstantInt::get(
1379 PtrDiffLTy,
1380 computeOffsetHint(CGF.getContext(), SrcDecl, DestDecl).getQuantity());
1381
1382 // Emit the call to __dynamic_cast.
1383 llvm::Value *Value = ThisAddr.getPointer();
1384 Value = CGF.EmitCastToVoidPtr(Value);
1385
1386 llvm::Value *args[] = {Value, SrcRTTI, DestRTTI, OffsetHint};
1387 Value = CGF.EmitNounwindRuntimeCall(getItaniumDynamicCastFn(CGF), args);
1388 Value = CGF.Builder.CreateBitCast(Value, DestLTy);
1389
1390 /// C++ [expr.dynamic.cast]p9:
1391 /// A failed cast to reference type throws std::bad_cast
1392 if (DestTy->isReferenceType()) {
1393 llvm::BasicBlock *BadCastBlock =
1394 CGF.createBasicBlock("dynamic_cast.bad_cast");
1395
1396 llvm::Value *IsNull = CGF.Builder.CreateIsNull(Value);
1397 CGF.Builder.CreateCondBr(IsNull, BadCastBlock, CastEnd);
1398
1399 CGF.EmitBlock(BadCastBlock);
1400 EmitBadCastCall(CGF);
1401 }
1402
1403 return Value;
1404}
1405
1406llvm::Value *ItaniumCXXABI::EmitDynamicCastToVoid(CodeGenFunction &CGF,
1407 Address ThisAddr,
1408 QualType SrcRecordTy,
1409 QualType DestTy) {
1410 llvm::Type *PtrDiffLTy =
1411 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1412 llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1413
1414 auto *ClassDecl =
1415 cast<CXXRecordDecl>(SrcRecordTy->getAs<RecordType>()->getDecl());
1416 // Get the vtable pointer.
1417 llvm::Value *VTable = CGF.GetVTablePtr(ThisAddr, PtrDiffLTy->getPointerTo(),
1418 ClassDecl);
1419
1420 // Get the offset-to-top from the vtable.
1421 llvm::Value *OffsetToTop =
1422 CGF.Builder.CreateConstInBoundsGEP1_64(VTable, -2ULL);
1423 OffsetToTop =
1424 CGF.Builder.CreateAlignedLoad(OffsetToTop, CGF.getPointerAlign(),
1425 "offset.to.top");
1426
1427 // Finally, add the offset to the pointer.
1428 llvm::Value *Value = ThisAddr.getPointer();
1429 Value = CGF.EmitCastToVoidPtr(Value);
1430 Value = CGF.Builder.CreateInBoundsGEP(Value, OffsetToTop);
1431
1432 return CGF.Builder.CreateBitCast(Value, DestLTy);
1433}
1434
1435bool ItaniumCXXABI::EmitBadCastCall(CodeGenFunction &CGF) {
1436 llvm::FunctionCallee Fn = getBadCastFn(CGF);
1437 llvm::CallBase *Call = CGF.EmitRuntimeCallOrInvoke(Fn);
1438 Call->setDoesNotReturn();
1439 CGF.Builder.CreateUnreachable();
1440 return true;
1441}
1442
1443llvm::Value *
1444ItaniumCXXABI::GetVirtualBaseClassOffset(CodeGenFunction &CGF,
1445 Address This,
1446 const CXXRecordDecl *ClassDecl,
1447 const CXXRecordDecl *BaseClassDecl) {
1448 llvm::Value *VTablePtr = CGF.GetVTablePtr(This, CGM.Int8PtrTy, ClassDecl);
1449 CharUnits VBaseOffsetOffset =
1450 CGM.getItaniumVTableContext().getVirtualBaseOffsetOffset(ClassDecl,
1451 BaseClassDecl);
1452
1453 llvm::Value *VBaseOffsetPtr =
1454 CGF.Builder.CreateConstGEP1_64(VTablePtr, VBaseOffsetOffset.getQuantity(),
1455 "vbase.offset.ptr");
1456 VBaseOffsetPtr = CGF.Builder.CreateBitCast(VBaseOffsetPtr,
1457 CGM.PtrDiffTy->getPointerTo());
1458
1459 llvm::Value *VBaseOffset =
1460 CGF.Builder.CreateAlignedLoad(VBaseOffsetPtr, CGF.getPointerAlign(),
1461 "vbase.offset");
1462
1463 return VBaseOffset;
1464}
1465
1466void ItaniumCXXABI::EmitCXXConstructors(const CXXConstructorDecl *D) {
1467 // Just make sure we're in sync with TargetCXXABI.
1468 assert(CGM.getTarget().getCXXABI().hasConstructorVariants())((CGM.getTarget().getCXXABI().hasConstructorVariants()) ? static_cast
<void> (0) : __assert_fail ("CGM.getTarget().getCXXABI().hasConstructorVariants()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 1468, __PRETTY_FUNCTION__))
;
1469
1470 // The constructor used for constructing this as a base class;
1471 // ignores virtual bases.
1472 CGM.EmitGlobal(GlobalDecl(D, Ctor_Base));
1473
1474 // The constructor used for constructing this as a complete class;
1475 // constructs the virtual bases, then calls the base constructor.
1476 if (!D->getParent()->isAbstract()) {
1477 // We don't need to emit the complete ctor if the class is abstract.
1478 CGM.EmitGlobal(GlobalDecl(D, Ctor_Complete));
1479 }
1480}
1481
1482CGCXXABI::AddedStructorArgs
1483ItaniumCXXABI::buildStructorSignature(GlobalDecl GD,
1484 SmallVectorImpl<CanQualType> &ArgTys) {
1485 ASTContext &Context = getContext();
1486
1487 // All parameters are already in place except VTT, which goes after 'this'.
1488 // These are Clang types, so we don't need to worry about sret yet.
1489
1490 // Check if we need to add a VTT parameter (which has type void **).
1491 if ((isa<CXXConstructorDecl>(GD.getDecl()) ? GD.getCtorType() == Ctor_Base
1492 : GD.getDtorType() == Dtor_Base) &&
1493 cast<CXXMethodDecl>(GD.getDecl())->getParent()->getNumVBases() != 0) {
1494 ArgTys.insert(ArgTys.begin() + 1,
1495 Context.getPointerType(Context.VoidPtrTy));
1496 return AddedStructorArgs::prefix(1);
1497 }
1498 return AddedStructorArgs{};
1499}
1500
1501void ItaniumCXXABI::EmitCXXDestructors(const CXXDestructorDecl *D) {
1502 // The destructor used for destructing this as a base class; ignores
1503 // virtual bases.
1504 CGM.EmitGlobal(GlobalDecl(D, Dtor_Base));
1505
1506 // The destructor used for destructing this as a most-derived class;
1507 // call the base destructor and then destructs any virtual bases.
1508 CGM.EmitGlobal(GlobalDecl(D, Dtor_Complete));
1509
1510 // The destructor in a virtual table is always a 'deleting'
1511 // destructor, which calls the complete destructor and then uses the
1512 // appropriate operator delete.
1513 if (D->isVirtual())
1514 CGM.EmitGlobal(GlobalDecl(D, Dtor_Deleting));
1515}
1516
1517void ItaniumCXXABI::addImplicitStructorParams(CodeGenFunction &CGF,
1518 QualType &ResTy,
1519 FunctionArgList &Params) {
1520 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
1521 assert(isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD))((isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl
>(MD)) ? static_cast<void> (0) : __assert_fail ("isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 1521, __PRETTY_FUNCTION__))
;
1522
1523 // Check if we need a VTT parameter as well.
1524 if (NeedsVTTParameter(CGF.CurGD)) {
1525 ASTContext &Context = getContext();
1526
1527 // FIXME: avoid the fake decl
1528 QualType T = Context.getPointerType(Context.VoidPtrTy);
1529 auto *VTTDecl = ImplicitParamDecl::Create(
1530 Context, /*DC=*/nullptr, MD->getLocation(), &Context.Idents.get("vtt"),
1531 T, ImplicitParamDecl::CXXVTT);
1532 Params.insert(Params.begin() + 1, VTTDecl);
1533 getStructorImplicitParamDecl(CGF) = VTTDecl;
1534 }
1535}
1536
1537void ItaniumCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
1538 // Naked functions have no prolog.
1539 if (CGF.CurFuncDecl && CGF.CurFuncDecl->hasAttr<NakedAttr>())
1540 return;
1541
1542 /// Initialize the 'this' slot. In the Itanium C++ ABI, no prologue
1543 /// adjustments are required, because they are all handled by thunks.
1544 setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF));
1545
1546 /// Initialize the 'vtt' slot if needed.
1547 if (getStructorImplicitParamDecl(CGF)) {
1548 getStructorImplicitParamValue(CGF) = CGF.Builder.CreateLoad(
1549 CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)), "vtt");
1550 }
1551
1552 /// If this is a function that the ABI specifies returns 'this', initialize
1553 /// the return slot to 'this' at the start of the function.
1554 ///
1555 /// Unlike the setting of return types, this is done within the ABI
1556 /// implementation instead of by clients of CGCXXABI because:
1557 /// 1) getThisValue is currently protected
1558 /// 2) in theory, an ABI could implement 'this' returns some other way;
1559 /// HasThisReturn only specifies a contract, not the implementation
1560 if (HasThisReturn(CGF.CurGD))
1561 CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
1562}
1563
1564CGCXXABI::AddedStructorArgs ItaniumCXXABI::addImplicitConstructorArgs(
1565 CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type,
1566 bool ForVirtualBase, bool Delegating, CallArgList &Args) {
1567 if (!NeedsVTTParameter(GlobalDecl(D, Type)))
1568 return AddedStructorArgs{};
1569
1570 // Insert the implicit 'vtt' argument as the second argument.
1571 llvm::Value *VTT =
1572 CGF.GetVTTParameter(GlobalDecl(D, Type), ForVirtualBase, Delegating);
1573 QualType VTTTy = getContext().getPointerType(getContext().VoidPtrTy);
1574 Args.insert(Args.begin() + 1, CallArg(RValue::get(VTT), VTTTy));
1575 return AddedStructorArgs::prefix(1); // Added one arg.
1576}
1577
1578void ItaniumCXXABI::EmitDestructorCall(CodeGenFunction &CGF,
1579 const CXXDestructorDecl *DD,
1580 CXXDtorType Type, bool ForVirtualBase,
1581 bool Delegating, Address This,
1582 QualType ThisTy) {
1583 GlobalDecl GD(DD, Type);
1584 llvm::Value *VTT = CGF.GetVTTParameter(GD, ForVirtualBase, Delegating);
1585 QualType VTTTy = getContext().getPointerType(getContext().VoidPtrTy);
1586
1587 CGCallee Callee;
1588 if (getContext().getLangOpts().AppleKext &&
1589 Type != Dtor_Base && DD->isVirtual())
1590 Callee = CGF.BuildAppleKextVirtualDestructorCall(DD, Type, DD->getParent());
1591 else
1592 Callee = CGCallee::forDirect(CGM.getAddrOfCXXStructor(GD), GD);
1593
1594 CGF.EmitCXXDestructorCall(GD, Callee, This.getPointer(), ThisTy, VTT, VTTTy,
1595 nullptr);
1596}
1597
1598void ItaniumCXXABI::emitVTableDefinitions(CodeGenVTables &CGVT,
1599 const CXXRecordDecl *RD) {
1600 llvm::GlobalVariable *VTable = getAddrOfVTable(RD, CharUnits());
1601 if (VTable->hasInitializer())
1602 return;
1603
1604 ItaniumVTableContext &VTContext = CGM.getItaniumVTableContext();
1605 const VTableLayout &VTLayout = VTContext.getVTableLayout(RD);
1606 llvm::GlobalVariable::LinkageTypes Linkage = CGM.getVTableLinkage(RD);
1607 llvm::Constant *RTTI =
1608 CGM.GetAddrOfRTTIDescriptor(CGM.getContext().getTagDeclType(RD));
1609
1610 // Create and set the initializer.
1611 ConstantInitBuilder Builder(CGM);
1612 auto Components = Builder.beginStruct();
1613 CGVT.createVTableInitializer(Components, VTLayout, RTTI);
1614 Components.finishAndSetAsInitializer(VTable);
1615
1616 // Set the correct linkage.
1617 VTable->setLinkage(Linkage);
1618
1619 if (CGM.supportsCOMDAT() && VTable->isWeakForLinker())
1620 VTable->setComdat(CGM.getModule().getOrInsertComdat(VTable->getName()));
1621
1622 // Set the right visibility.
1623 CGM.setGVProperties(VTable, RD);
1624
1625 // If this is the magic class __cxxabiv1::__fundamental_type_info,
1626 // we will emit the typeinfo for the fundamental types. This is the
1627 // same behaviour as GCC.
1628 const DeclContext *DC = RD->getDeclContext();
1629 if (RD->getIdentifier() &&
1630 RD->getIdentifier()->isStr("__fundamental_type_info") &&
1631 isa<NamespaceDecl>(DC) && cast<NamespaceDecl>(DC)->getIdentifier() &&
1632 cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__cxxabiv1") &&
1633 DC->getParent()->isTranslationUnit())
1634 EmitFundamentalRTTIDescriptors(RD);
1635
1636 if (!VTable->isDeclarationForLinker())
1637 CGM.EmitVTableTypeMetadata(VTable, VTLayout);
1638}
1639
1640bool ItaniumCXXABI::isVirtualOffsetNeededForVTableField(
1641 CodeGenFunction &CGF, CodeGenFunction::VPtr Vptr) {
1642 if (Vptr.NearestVBase == nullptr)
1643 return false;
1644 return NeedsVTTParameter(CGF.CurGD);
1645}
1646
1647llvm::Value *ItaniumCXXABI::getVTableAddressPointInStructor(
1648 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
1649 const CXXRecordDecl *NearestVBase) {
1650
1651 if ((Base.getBase()->getNumVBases() || NearestVBase != nullptr) &&
1652 NeedsVTTParameter(CGF.CurGD)) {
1653 return getVTableAddressPointInStructorWithVTT(CGF, VTableClass, Base,
1654 NearestVBase);
1655 }
1656 return getVTableAddressPoint(Base, VTableClass);
1657}
1658
1659llvm::Constant *
1660ItaniumCXXABI::getVTableAddressPoint(BaseSubobject Base,
1661 const CXXRecordDecl *VTableClass) {
1662 llvm::GlobalValue *VTable = getAddrOfVTable(VTableClass, CharUnits());
1663
1664 // Find the appropriate vtable within the vtable group, and the address point
1665 // within that vtable.
1666 VTableLayout::AddressPointLocation AddressPoint =
1667 CGM.getItaniumVTableContext()
1668 .getVTableLayout(VTableClass)
1669 .getAddressPoint(Base);
1670 llvm::Value *Indices[] = {
1671 llvm::ConstantInt::get(CGM.Int32Ty, 0),
1672 llvm::ConstantInt::get(CGM.Int32Ty, AddressPoint.VTableIndex),
1673 llvm::ConstantInt::get(CGM.Int32Ty, AddressPoint.AddressPointIndex),
1674 };
1675
1676 return llvm::ConstantExpr::getGetElementPtr(VTable->getValueType(), VTable,
1677 Indices, /*InBounds=*/true,
1678 /*InRangeIndex=*/1);
1679}
1680
1681llvm::Value *ItaniumCXXABI::getVTableAddressPointInStructorWithVTT(
1682 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
1683 const CXXRecordDecl *NearestVBase) {
1684 assert((Base.getBase()->getNumVBases() || NearestVBase != nullptr) &&(((Base.getBase()->getNumVBases() || NearestVBase != nullptr
) && NeedsVTTParameter(CGF.CurGD) && "This class doesn't have VTT"
) ? static_cast<void> (0) : __assert_fail ("(Base.getBase()->getNumVBases() || NearestVBase != nullptr) && NeedsVTTParameter(CGF.CurGD) && \"This class doesn't have VTT\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 1685, __PRETTY_FUNCTION__))
1685 NeedsVTTParameter(CGF.CurGD) && "This class doesn't have VTT")(((Base.getBase()->getNumVBases() || NearestVBase != nullptr
) && NeedsVTTParameter(CGF.CurGD) && "This class doesn't have VTT"
) ? static_cast<void> (0) : __assert_fail ("(Base.getBase()->getNumVBases() || NearestVBase != nullptr) && NeedsVTTParameter(CGF.CurGD) && \"This class doesn't have VTT\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 1685, __PRETTY_FUNCTION__))
;
1686
1687 // Get the secondary vpointer index.
1688 uint64_t VirtualPointerIndex =
1689 CGM.getVTables().getSecondaryVirtualPointerIndex(VTableClass, Base);
1690
1691 /// Load the VTT.
1692 llvm::Value *VTT = CGF.LoadCXXVTT();
1693 if (VirtualPointerIndex)
1694 VTT = CGF.Builder.CreateConstInBoundsGEP1_64(VTT, VirtualPointerIndex);
1695
1696 // And load the address point from the VTT.
1697 return CGF.Builder.CreateAlignedLoad(VTT, CGF.getPointerAlign());
1698}
1699
1700llvm::Constant *ItaniumCXXABI::getVTableAddressPointForConstExpr(
1701 BaseSubobject Base, const CXXRecordDecl *VTableClass) {
1702 return getVTableAddressPoint(Base, VTableClass);
1703}
1704
1705llvm::GlobalVariable *ItaniumCXXABI::getAddrOfVTable(const CXXRecordDecl *RD,
1706 CharUnits VPtrOffset) {
1707 assert(VPtrOffset.isZero() && "Itanium ABI only supports zero vptr offsets")((VPtrOffset.isZero() && "Itanium ABI only supports zero vptr offsets"
) ? static_cast<void> (0) : __assert_fail ("VPtrOffset.isZero() && \"Itanium ABI only supports zero vptr offsets\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 1707, __PRETTY_FUNCTION__))
;
1708
1709 llvm::GlobalVariable *&VTable = VTables[RD];
1710 if (VTable)
1711 return VTable;
1712
1713 // Queue up this vtable for possible deferred emission.
1714 CGM.addDeferredVTable(RD);
1715
1716 SmallString<256> Name;
1717 llvm::raw_svector_ostream Out(Name);
1718 getMangleContext().mangleCXXVTable(RD, Out);
1719
1720 const VTableLayout &VTLayout =
1721 CGM.getItaniumVTableContext().getVTableLayout(RD);
1722 llvm::Type *VTableType = CGM.getVTables().getVTableType(VTLayout);
1723
1724 // Use pointer alignment for the vtable. Otherwise we would align them based
1725 // on the size of the initializer which doesn't make sense as only single
1726 // values are read.
1727 unsigned PAlign = CGM.getTarget().getPointerAlign(0);
1728
1729 VTable = CGM.CreateOrReplaceCXXRuntimeVariable(
1730 Name, VTableType, llvm::GlobalValue::ExternalLinkage,
1731 getContext().toCharUnitsFromBits(PAlign).getQuantity());
1732 VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1733
1734 CGM.setGVProperties(VTable, RD);
1735
1736 return VTable;
1737}
1738
1739CGCallee ItaniumCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF,
1740 GlobalDecl GD,
1741 Address This,
1742 llvm::Type *Ty,
1743 SourceLocation Loc) {
1744 Ty = Ty->getPointerTo()->getPointerTo();
1745 auto *MethodDecl = cast<CXXMethodDecl>(GD.getDecl());
1746 llvm::Value *VTable = CGF.GetVTablePtr(This, Ty, MethodDecl->getParent());
1747
1748 uint64_t VTableIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(GD);
1749 llvm::Value *VFunc;
1750 if (CGF.ShouldEmitVTableTypeCheckedLoad(MethodDecl->getParent())) {
1751 VFunc = CGF.EmitVTableTypeCheckedLoad(
1752 MethodDecl->getParent(), VTable,
1753 VTableIndex * CGM.getContext().getTargetInfo().getPointerWidth(0) / 8);
1754 } else {
1755 CGF.EmitTypeMetadataCodeForVCall(MethodDecl->getParent(), VTable, Loc);
1756
1757 llvm::Value *VFuncPtr =
1758 CGF.Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfn");
1759 auto *VFuncLoad =
1760 CGF.Builder.CreateAlignedLoad(VFuncPtr, CGF.getPointerAlign());
1761
1762 // Add !invariant.load md to virtual function load to indicate that
1763 // function didn't change inside vtable.
1764 // It's safe to add it without -fstrict-vtable-pointers, but it would not
1765 // help in devirtualization because it will only matter if we will have 2
1766 // the same virtual function loads from the same vtable load, which won't
1767 // happen without enabled devirtualization with -fstrict-vtable-pointers.
1768 if (CGM.getCodeGenOpts().OptimizationLevel > 0 &&
1769 CGM.getCodeGenOpts().StrictVTablePointers)
1770 VFuncLoad->setMetadata(
1771 llvm::LLVMContext::MD_invariant_load,
1772 llvm::MDNode::get(CGM.getLLVMContext(),
1773 llvm::ArrayRef<llvm::Metadata *>()));
1774 VFunc = VFuncLoad;
1775 }
1776
1777 CGCallee Callee(GD, VFunc);
1778 return Callee;
1779}
1780
1781llvm::Value *ItaniumCXXABI::EmitVirtualDestructorCall(
1782 CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType,
1783 Address This, DeleteOrMemberCallExpr E) {
1784 auto *CE = E.dyn_cast<const CXXMemberCallExpr *>();
1785 auto *D = E.dyn_cast<const CXXDeleteExpr *>();
1786 assert((CE != nullptr) ^ (D != nullptr))(((CE != nullptr) ^ (D != nullptr)) ? static_cast<void>
(0) : __assert_fail ("(CE != nullptr) ^ (D != nullptr)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 1786, __PRETTY_FUNCTION__))
;
1787 assert(CE == nullptr || CE->arg_begin() == CE->arg_end())((CE == nullptr || CE->arg_begin() == CE->arg_end()) ? static_cast
<void> (0) : __assert_fail ("CE == nullptr || CE->arg_begin() == CE->arg_end()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 1787, __PRETTY_FUNCTION__))
;
1788 assert(DtorType == Dtor_Deleting || DtorType == Dtor_Complete)((DtorType == Dtor_Deleting || DtorType == Dtor_Complete) ? static_cast
<void> (0) : __assert_fail ("DtorType == Dtor_Deleting || DtorType == Dtor_Complete"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 1788, __PRETTY_FUNCTION__))
;
1789
1790 GlobalDecl GD(Dtor, DtorType);
1791 const CGFunctionInfo *FInfo =
1792 &CGM.getTypes().arrangeCXXStructorDeclaration(GD);
1793 llvm::FunctionType *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
1794 CGCallee Callee = CGCallee::forVirtual(CE, GD, This, Ty);
1795
1796 QualType ThisTy;
1797 if (CE) {
1798 ThisTy = CE->getObjectType();
1799 } else {
1800 ThisTy = D->getDestroyedType();
1801 }
1802
1803 CGF.EmitCXXDestructorCall(GD, Callee, This.getPointer(), ThisTy, nullptr,
1804 QualType(), nullptr);
1805 return nullptr;
1806}
1807
1808void ItaniumCXXABI::emitVirtualInheritanceTables(const CXXRecordDecl *RD) {
1809 CodeGenVTables &VTables = CGM.getVTables();
1810 llvm::GlobalVariable *VTT = VTables.GetAddrOfVTT(RD);
1811 VTables.EmitVTTDefinition(VTT, CGM.getVTableLinkage(RD), RD);
1812}
1813
1814bool ItaniumCXXABI::canSpeculativelyEmitVTableAsBaseClass(
1815 const CXXRecordDecl *RD) const {
1816 // We don't emit available_externally vtables if we are in -fapple-kext mode
1817 // because kext mode does not permit devirtualization.
1818 if (CGM.getLangOpts().AppleKext)
1819 return false;
1820
1821 // If the vtable is hidden then it is not safe to emit an available_externally
1822 // copy of vtable.
1823 if (isVTableHidden(RD))
1824 return false;
1825
1826 if (CGM.getCodeGenOpts().ForceEmitVTables)
1827 return true;
1828
1829 // If we don't have any not emitted inline virtual function then we are safe
1830 // to emit an available_externally copy of vtable.
1831 // FIXME we can still emit a copy of the vtable if we
1832 // can emit definition of the inline functions.
1833 if (hasAnyUnusedVirtualInlineFunction(RD))
1834 return false;
1835
1836 // For a class with virtual bases, we must also be able to speculatively
1837 // emit the VTT, because CodeGen doesn't have separate notions of "can emit
1838 // the vtable" and "can emit the VTT". For a base subobject, this means we
1839 // need to be able to emit non-virtual base vtables.
1840 if (RD->getNumVBases()) {
1841 for (const auto &B : RD->bases()) {
1842 auto *BRD = B.getType()->getAsCXXRecordDecl();
1843 assert(BRD && "no class for base specifier")((BRD && "no class for base specifier") ? static_cast
<void> (0) : __assert_fail ("BRD && \"no class for base specifier\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 1843, __PRETTY_FUNCTION__))
;
1844 if (B.isVirtual() || !BRD->isDynamicClass())
1845 continue;
1846 if (!canSpeculativelyEmitVTableAsBaseClass(BRD))
1847 return false;
1848 }
1849 }
1850
1851 return true;
1852}
1853
1854bool ItaniumCXXABI::canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const {
1855 if (!canSpeculativelyEmitVTableAsBaseClass(RD))
1856 return false;
1857
1858 // For a complete-object vtable (or more specifically, for the VTT), we need
1859 // to be able to speculatively emit the vtables of all dynamic virtual bases.
1860 for (const auto &B : RD->vbases()) {
1861 auto *BRD = B.getType()->getAsCXXRecordDecl();
1862 assert(BRD && "no class for base specifier")((BRD && "no class for base specifier") ? static_cast
<void> (0) : __assert_fail ("BRD && \"no class for base specifier\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 1862, __PRETTY_FUNCTION__))
;
1863 if (!BRD->isDynamicClass())
1864 continue;
1865 if (!canSpeculativelyEmitVTableAsBaseClass(BRD))
1866 return false;
1867 }
1868
1869 return true;
1870}
1871static llvm::Value *performTypeAdjustment(CodeGenFunction &CGF,
1872 Address InitialPtr,
1873 int64_t NonVirtualAdjustment,
1874 int64_t VirtualAdjustment,
1875 bool IsReturnAdjustment) {
1876 if (!NonVirtualAdjustment && !VirtualAdjustment)
1877 return InitialPtr.getPointer();
1878
1879 Address V = CGF.Builder.CreateElementBitCast(InitialPtr, CGF.Int8Ty);
1880
1881 // In a base-to-derived cast, the non-virtual adjustment is applied first.
1882 if (NonVirtualAdjustment && !IsReturnAdjustment) {
1883 V = CGF.Builder.CreateConstInBoundsByteGEP(V,
1884 CharUnits::fromQuantity(NonVirtualAdjustment));
1885 }
1886
1887 // Perform the virtual adjustment if we have one.
1888 llvm::Value *ResultPtr;
1889 if (VirtualAdjustment) {
1890 llvm::Type *PtrDiffTy =
1891 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1892
1893 Address VTablePtrPtr = CGF.Builder.CreateElementBitCast(V, CGF.Int8PtrTy);
1894 llvm::Value *VTablePtr = CGF.Builder.CreateLoad(VTablePtrPtr);
1895
1896 llvm::Value *OffsetPtr =
1897 CGF.Builder.CreateConstInBoundsGEP1_64(VTablePtr, VirtualAdjustment);
1898
1899 OffsetPtr = CGF.Builder.CreateBitCast(OffsetPtr, PtrDiffTy->getPointerTo());
1900
1901 // Load the adjustment offset from the vtable.
1902 llvm::Value *Offset =
1903 CGF.Builder.CreateAlignedLoad(OffsetPtr, CGF.getPointerAlign());
1904
1905 // Adjust our pointer.
1906 ResultPtr = CGF.Builder.CreateInBoundsGEP(V.getPointer(), Offset);
1907 } else {
1908 ResultPtr = V.getPointer();
1909 }
1910
1911 // In a derived-to-base conversion, the non-virtual adjustment is
1912 // applied second.
1913 if (NonVirtualAdjustment && IsReturnAdjustment) {
1914 ResultPtr = CGF.Builder.CreateConstInBoundsGEP1_64(ResultPtr,
1915 NonVirtualAdjustment);
1916 }
1917
1918 // Cast back to the original type.
1919 return CGF.Builder.CreateBitCast(ResultPtr, InitialPtr.getType());
1920}
1921
1922llvm::Value *ItaniumCXXABI::performThisAdjustment(CodeGenFunction &CGF,
1923 Address This,
1924 const ThisAdjustment &TA) {
1925 return performTypeAdjustment(CGF, This, TA.NonVirtual,
1926 TA.Virtual.Itanium.VCallOffsetOffset,
1927 /*IsReturnAdjustment=*/false);
1928}
1929
1930llvm::Value *
1931ItaniumCXXABI::performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
1932 const ReturnAdjustment &RA) {
1933 return performTypeAdjustment(CGF, Ret, RA.NonVirtual,
1934 RA.Virtual.Itanium.VBaseOffsetOffset,
1935 /*IsReturnAdjustment=*/true);
1936}
1937
1938void ARMCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
1939 RValue RV, QualType ResultType) {
1940 if (!isa<CXXDestructorDecl>(CGF.CurGD.getDecl()))
1941 return ItaniumCXXABI::EmitReturnFromThunk(CGF, RV, ResultType);
1942
1943 // Destructor thunks in the ARM ABI have indeterminate results.
1944 llvm::Type *T = CGF.ReturnValue.getElementType();
1945 RValue Undef = RValue::get(llvm::UndefValue::get(T));
1946 return ItaniumCXXABI::EmitReturnFromThunk(CGF, Undef, ResultType);
1947}
1948
1949/************************** Array allocation cookies **************************/
1950
1951CharUnits ItaniumCXXABI::getArrayCookieSizeImpl(QualType elementType) {
1952 // The array cookie is a size_t; pad that up to the element alignment.
1953 // The cookie is actually right-justified in that space.
1954 return std::max(CharUnits::fromQuantity(CGM.SizeSizeInBytes),
1955 CGM.getContext().getTypeAlignInChars(elementType));
1956}
1957
1958Address ItaniumCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
1959 Address NewPtr,
1960 llvm::Value *NumElements,
1961 const CXXNewExpr *expr,
1962 QualType ElementType) {
1963 assert(requiresArrayCookie(expr))((requiresArrayCookie(expr)) ? static_cast<void> (0) : __assert_fail
("requiresArrayCookie(expr)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 1963, __PRETTY_FUNCTION__))
;
1964
1965 unsigned AS = NewPtr.getAddressSpace();
1966
1967 ASTContext &Ctx = getContext();
1968 CharUnits SizeSize = CGF.getSizeSize();
1969
1970 // The size of the cookie.
1971 CharUnits CookieSize =
1972 std::max(SizeSize, Ctx.getTypeAlignInChars(ElementType));
1973 assert(CookieSize == getArrayCookieSizeImpl(ElementType))((CookieSize == getArrayCookieSizeImpl(ElementType)) ? static_cast
<void> (0) : __assert_fail ("CookieSize == getArrayCookieSizeImpl(ElementType)"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 1973, __PRETTY_FUNCTION__))
;
1974
1975 // Compute an offset to the cookie.
1976 Address CookiePtr = NewPtr;
1977 CharUnits CookieOffset = CookieSize - SizeSize;
1978 if (!CookieOffset.isZero())
1979 CookiePtr = CGF.Builder.CreateConstInBoundsByteGEP(CookiePtr, CookieOffset);
1980
1981 // Write the number of elements into the appropriate slot.
1982 Address NumElementsPtr =
1983 CGF.Builder.CreateElementBitCast(CookiePtr, CGF.SizeTy);
1984 llvm::Instruction *SI = CGF.Builder.CreateStore(NumElements, NumElementsPtr);
1985
1986 // Handle the array cookie specially in ASan.
1987 if (CGM.getLangOpts().Sanitize.has(SanitizerKind::Address) && AS == 0 &&
1988 (expr->getOperatorNew()->isReplaceableGlobalAllocationFunction() ||
1989 CGM.getCodeGenOpts().SanitizeAddressPoisonCustomArrayCookie)) {
1990 // The store to the CookiePtr does not need to be instrumented.
1991 CGM.getSanitizerMetadata()->disableSanitizerForInstruction(SI);
1992 llvm::FunctionType *FTy =
1993 llvm::FunctionType::get(CGM.VoidTy, NumElementsPtr.getType(), false);
1994 llvm::FunctionCallee F =
1995 CGM.CreateRuntimeFunction(FTy, "__asan_poison_cxx_array_cookie");
1996 CGF.Builder.CreateCall(F, NumElementsPtr.getPointer());
1997 }
1998
1999 // Finally, compute a pointer to the actual data buffer by skipping
2000 // over the cookie completely.
2001 return CGF.Builder.CreateConstInBoundsByteGEP(NewPtr, CookieSize);
2002}
2003
2004llvm::Value *ItaniumCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
2005 Address allocPtr,
2006 CharUnits cookieSize) {
2007 // The element size is right-justified in the cookie.
2008 Address numElementsPtr = allocPtr;
2009 CharUnits numElementsOffset = cookieSize - CGF.getSizeSize();
2010 if (!numElementsOffset.isZero())
2011 numElementsPtr =
2012 CGF.Builder.CreateConstInBoundsByteGEP(numElementsPtr, numElementsOffset);
2013
2014 unsigned AS = allocPtr.getAddressSpace();
2015 numElementsPtr = CGF.Builder.CreateElementBitCast(numElementsPtr, CGF.SizeTy);
2016 if (!CGM.getLangOpts().Sanitize.has(SanitizerKind::Address) || AS != 0)
2017 return CGF.Builder.CreateLoad(numElementsPtr);
2018 // In asan mode emit a function call instead of a regular load and let the
2019 // run-time deal with it: if the shadow is properly poisoned return the
2020 // cookie, otherwise return 0 to avoid an infinite loop calling DTORs.
2021 // We can't simply ignore this load using nosanitize metadata because
2022 // the metadata may be lost.
2023 llvm::FunctionType *FTy =
2024 llvm::FunctionType::get(CGF.SizeTy, CGF.SizeTy->getPointerTo(0), false);
2025 llvm::FunctionCallee F =
2026 CGM.CreateRuntimeFunction(FTy, "__asan_load_cxx_array_cookie");
2027 return CGF.Builder.CreateCall(F, numElementsPtr.getPointer());
2028}
2029
2030CharUnits ARMCXXABI::getArrayCookieSizeImpl(QualType elementType) {
2031 // ARM says that the cookie is always:
2032 // struct array_cookie {
2033 // std::size_t element_size; // element_size != 0
2034 // std::size_t element_count;
2035 // };
2036 // But the base ABI doesn't give anything an alignment greater than
2037 // 8, so we can dismiss this as typical ABI-author blindness to
2038 // actual language complexity and round up to the element alignment.
2039 return std::max(CharUnits::fromQuantity(2 * CGM.SizeSizeInBytes),
2040 CGM.getContext().getTypeAlignInChars(elementType));
2041}
2042
2043Address ARMCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
2044 Address newPtr,
2045 llvm::Value *numElements,
2046 const CXXNewExpr *expr,
2047 QualType elementType) {
2048 assert(requiresArrayCookie(expr))((requiresArrayCookie(expr)) ? static_cast<void> (0) : __assert_fail
("requiresArrayCookie(expr)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 2048, __PRETTY_FUNCTION__))
;
2049
2050 // The cookie is always at the start of the buffer.
2051 Address cookie = newPtr;
2052
2053 // The first element is the element size.
2054 cookie = CGF.Builder.CreateElementBitCast(cookie, CGF.SizeTy);
2055 llvm::Value *elementSize = llvm::ConstantInt::get(CGF.SizeTy,
2056 getContext().getTypeSizeInChars(elementType).getQuantity());
2057 CGF.Builder.CreateStore(elementSize, cookie);
2058
2059 // The second element is the element count.
2060 cookie = CGF.Builder.CreateConstInBoundsGEP(cookie, 1);
2061 CGF.Builder.CreateStore(numElements, cookie);
2062
2063 // Finally, compute a pointer to the actual data buffer by skipping
2064 // over the cookie completely.
2065 CharUnits cookieSize = ARMCXXABI::getArrayCookieSizeImpl(elementType);
2066 return CGF.Builder.CreateConstInBoundsByteGEP(newPtr, cookieSize);
2067}
2068
2069llvm::Value *ARMCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
2070 Address allocPtr,
2071 CharUnits cookieSize) {
2072 // The number of elements is at offset sizeof(size_t) relative to
2073 // the allocated pointer.
2074 Address numElementsPtr
2075 = CGF.Builder.CreateConstInBoundsByteGEP(allocPtr, CGF.getSizeSize());
2076
2077 numElementsPtr = CGF.Builder.CreateElementBitCast(numElementsPtr, CGF.SizeTy);
2078 return CGF.Builder.CreateLoad(numElementsPtr);
2079}
2080
2081/*********************** Static local initialization **************************/
2082
2083static llvm::FunctionCallee getGuardAcquireFn(CodeGenModule &CGM,
2084 llvm::PointerType *GuardPtrTy) {
2085 // int __cxa_guard_acquire(__guard *guard_object);
2086 llvm::FunctionType *FTy =
2087 llvm::FunctionType::get(CGM.getTypes().ConvertType(CGM.getContext().IntTy),
2088 GuardPtrTy, /*isVarArg=*/false);
2089 return CGM.CreateRuntimeFunction(
2090 FTy, "__cxa_guard_acquire",
2091 llvm::AttributeList::get(CGM.getLLVMContext(),
2092 llvm::AttributeList::FunctionIndex,
2093 llvm::Attribute::NoUnwind));
2094}
2095
2096static llvm::FunctionCallee getGuardReleaseFn(CodeGenModule &CGM,
2097 llvm::PointerType *GuardPtrTy) {
2098 // void __cxa_guard_release(__guard *guard_object);
2099 llvm::FunctionType *FTy =
2100 llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
2101 return CGM.CreateRuntimeFunction(
2102 FTy, "__cxa_guard_release",
2103 llvm::AttributeList::get(CGM.getLLVMContext(),
2104 llvm::AttributeList::FunctionIndex,
2105 llvm::Attribute::NoUnwind));
2106}
2107
2108static llvm::FunctionCallee getGuardAbortFn(CodeGenModule &CGM,
2109 llvm::PointerType *GuardPtrTy) {
2110 // void __cxa_guard_abort(__guard *guard_object);
2111 llvm::FunctionType *FTy =
2112 llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
2113 return CGM.CreateRuntimeFunction(
2114 FTy, "__cxa_guard_abort",
2115 llvm::AttributeList::get(CGM.getLLVMContext(),
2116 llvm::AttributeList::FunctionIndex,
2117 llvm::Attribute::NoUnwind));
2118}
2119
2120namespace {
2121 struct CallGuardAbort final : EHScopeStack::Cleanup {
2122 llvm::GlobalVariable *Guard;
2123 CallGuardAbort(llvm::GlobalVariable *Guard) : Guard(Guard) {}
2124
2125 void Emit(CodeGenFunction &CGF, Flags flags) override {
2126 CGF.EmitNounwindRuntimeCall(getGuardAbortFn(CGF.CGM, Guard->getType()),
2127 Guard);
2128 }
2129 };
2130}
2131
2132/// The ARM code here follows the Itanium code closely enough that we
2133/// just special-case it at particular places.
2134void ItaniumCXXABI::EmitGuardedInit(CodeGenFunction &CGF,
2135 const VarDecl &D,
2136 llvm::GlobalVariable *var,
2137 bool shouldPerformInit) {
2138 CGBuilderTy &Builder = CGF.Builder;
2139
2140 // Inline variables that weren't instantiated from variable templates have
2141 // partially-ordered initialization within their translation unit.
2142 bool NonTemplateInline =
2143 D.isInline() &&
2144 !isTemplateInstantiation(D.getTemplateSpecializationKind());
2145
2146 // We only need to use thread-safe statics for local non-TLS variables and
2147 // inline variables; other global initialization is always single-threaded
2148 // or (through lazy dynamic loading in multiple threads) unsequenced.
2149 bool threadsafe = getContext().getLangOpts().ThreadsafeStatics &&
2150 (D.isLocalVarDecl() || NonTemplateInline) &&
2151 !D.getTLSKind();
2152
2153 // If we have a global variable with internal linkage and thread-safe statics
2154 // are disabled, we can just let the guard variable be of type i8.
2155 bool useInt8GuardVariable = !threadsafe && var->hasInternalLinkage();
2156
2157 llvm::IntegerType *guardTy;
2158 CharUnits guardAlignment;
2159 if (useInt8GuardVariable) {
2160 guardTy = CGF.Int8Ty;
2161 guardAlignment = CharUnits::One();
2162 } else {
2163 // Guard variables are 64 bits in the generic ABI and size width on ARM
2164 // (i.e. 32-bit on AArch32, 64-bit on AArch64).
2165 if (UseARMGuardVarABI) {
2166 guardTy = CGF.SizeTy;
2167 guardAlignment = CGF.getSizeAlign();
2168 } else {
2169 guardTy = CGF.Int64Ty;
2170 guardAlignment = CharUnits::fromQuantity(
2171 CGM.getDataLayout().getABITypeAlignment(guardTy));
2172 }
2173 }
2174 llvm::PointerType *guardPtrTy = guardTy->getPointerTo();
2175
2176 // Create the guard variable if we don't already have it (as we
2177 // might if we're double-emitting this function body).
2178 llvm::GlobalVariable *guard = CGM.getStaticLocalDeclGuardAddress(&D);
2179 if (!guard) {
2180 // Mangle the name for the guard.
2181 SmallString<256> guardName;
2182 {
2183 llvm::raw_svector_ostream out(guardName);
2184 getMangleContext().mangleStaticGuardVariable(&D, out);
2185 }
2186
2187 // Create the guard variable with a zero-initializer.
2188 // Just absorb linkage and visibility from the guarded variable.
2189 guard = new llvm::GlobalVariable(CGM.getModule(), guardTy,
2190 false, var->getLinkage(),
2191 llvm::ConstantInt::get(guardTy, 0),
2192 guardName.str());
2193 guard->setDSOLocal(var->isDSOLocal());
2194 guard->setVisibility(var->getVisibility());
2195 // If the variable is thread-local, so is its guard variable.
2196 guard->setThreadLocalMode(var->getThreadLocalMode());
2197 guard->setAlignment(guardAlignment.getQuantity());
2198
2199 // The ABI says: "It is suggested that it be emitted in the same COMDAT
2200 // group as the associated data object." In practice, this doesn't work for
2201 // non-ELF and non-Wasm object formats, so only do it for ELF and Wasm.
2202 llvm::Comdat *C = var->getComdat();
2203 if (!D.isLocalVarDecl() && C &&
2204 (CGM.getTarget().getTriple().isOSBinFormatELF() ||
2205 CGM.getTarget().getTriple().isOSBinFormatWasm())) {
2206 guard->setComdat(C);
2207 // An inline variable's guard function is run from the per-TU
2208 // initialization function, not via a dedicated global ctor function, so
2209 // we can't put it in a comdat.
2210 if (!NonTemplateInline)
2211 CGF.CurFn->setComdat(C);
2212 } else if (CGM.supportsCOMDAT() && guard->isWeakForLinker()) {
2213 guard->setComdat(CGM.getModule().getOrInsertComdat(guard->getName()));
2214 }
2215
2216 CGM.setStaticLocalDeclGuardAddress(&D, guard);
2217 }
2218
2219 Address guardAddr = Address(guard, guardAlignment);
2220
2221 // Test whether the variable has completed initialization.
2222 //
2223 // Itanium C++ ABI 3.3.2:
2224 // The following is pseudo-code showing how these functions can be used:
2225 // if (obj_guard.first_byte == 0) {
2226 // if ( __cxa_guard_acquire (&obj_guard) ) {
2227 // try {
2228 // ... initialize the object ...;
2229 // } catch (...) {
2230 // __cxa_guard_abort (&obj_guard);
2231 // throw;
2232 // }
2233 // ... queue object destructor with __cxa_atexit() ...;
2234 // __cxa_guard_release (&obj_guard);
2235 // }
2236 // }
2237
2238 // Load the first byte of the guard variable.
2239 llvm::LoadInst *LI =
2240 Builder.CreateLoad(Builder.CreateElementBitCast(guardAddr, CGM.Int8Ty));
2241
2242 // Itanium ABI:
2243 // An implementation supporting thread-safety on multiprocessor
2244 // systems must also guarantee that references to the initialized
2245 // object do not occur before the load of the initialization flag.
2246 //
2247 // In LLVM, we do this by marking the load Acquire.
2248 if (threadsafe)
2249 LI->setAtomic(llvm::AtomicOrdering::Acquire);
2250
2251 // For ARM, we should only check the first bit, rather than the entire byte:
2252 //
2253 // ARM C++ ABI 3.2.3.1:
2254 // To support the potential use of initialization guard variables
2255 // as semaphores that are the target of ARM SWP and LDREX/STREX
2256 // synchronizing instructions we define a static initialization
2257 // guard variable to be a 4-byte aligned, 4-byte word with the
2258 // following inline access protocol.
2259 // #define INITIALIZED 1
2260 // if ((obj_guard & INITIALIZED) != INITIALIZED) {
2261 // if (__cxa_guard_acquire(&obj_guard))
2262 // ...
2263 // }
2264 //
2265 // and similarly for ARM64:
2266 //
2267 // ARM64 C++ ABI 3.2.2:
2268 // This ABI instead only specifies the value bit 0 of the static guard
2269 // variable; all other bits are platform defined. Bit 0 shall be 0 when the
2270 // variable is not initialized and 1 when it is.
2271 llvm::Value *V =
2272 (UseARMGuardVarABI && !useInt8GuardVariable)
2273 ? Builder.CreateAnd(LI, llvm::ConstantInt::get(CGM.Int8Ty, 1))
2274 : LI;
2275 llvm::Value *NeedsInit = Builder.CreateIsNull(V, "guard.uninitialized");
2276
2277 llvm::BasicBlock *InitCheckBlock = CGF.createBasicBlock("init.check");
2278 llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end");
2279
2280 // Check if the first byte of the guard variable is zero.
2281 CGF.EmitCXXGuardedInitBranch(NeedsInit, InitCheckBlock, EndBlock,
2282 CodeGenFunction::GuardKind::VariableGuard, &D);
2283
2284 CGF.EmitBlock(InitCheckBlock);
2285
2286 // Variables used when coping with thread-safe statics and exceptions.
2287 if (threadsafe) {
2288 // Call __cxa_guard_acquire.
2289 llvm::Value *V
2290 = CGF.EmitNounwindRuntimeCall(getGuardAcquireFn(CGM, guardPtrTy), guard);
2291
2292 llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
2293
2294 Builder.CreateCondBr(Builder.CreateIsNotNull(V, "tobool"),
2295 InitBlock, EndBlock);
2296
2297 // Call __cxa_guard_abort along the exceptional edge.
2298 CGF.EHStack.pushCleanup<CallGuardAbort>(EHCleanup, guard);
2299
2300 CGF.EmitBlock(InitBlock);
2301 }
2302
2303 // Emit the initializer and add a global destructor if appropriate.
2304 CGF.EmitCXXGlobalVarDeclInit(D, var, shouldPerformInit);
2305
2306 if (threadsafe) {
2307 // Pop the guard-abort cleanup if we pushed one.
2308 CGF.PopCleanupBlock();
2309
2310 // Call __cxa_guard_release. This cannot throw.
2311 CGF.EmitNounwindRuntimeCall(getGuardReleaseFn(CGM, guardPtrTy),
2312 guardAddr.getPointer());
2313 } else {
2314 Builder.CreateStore(llvm::ConstantInt::get(guardTy, 1), guardAddr);
2315 }
2316
2317 CGF.EmitBlock(EndBlock);
2318}
2319
2320/// Register a global destructor using __cxa_atexit.
2321static void emitGlobalDtorWithCXAAtExit(CodeGenFunction &CGF,
2322 llvm::FunctionCallee dtor,
2323 llvm::Constant *addr, bool TLS) {
2324 assert((TLS || CGF.getTypes().getCodeGenOpts().CXAAtExit) &&(((TLS || CGF.getTypes().getCodeGenOpts().CXAAtExit) &&
"__cxa_atexit is disabled") ? static_cast<void> (0) : __assert_fail
("(TLS || CGF.getTypes().getCodeGenOpts().CXAAtExit) && \"__cxa_atexit is disabled\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 2325, __PRETTY_FUNCTION__))
2325 "__cxa_atexit is disabled")(((TLS || CGF.getTypes().getCodeGenOpts().CXAAtExit) &&
"__cxa_atexit is disabled") ? static_cast<void> (0) : __assert_fail
("(TLS || CGF.getTypes().getCodeGenOpts().CXAAtExit) && \"__cxa_atexit is disabled\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 2325, __PRETTY_FUNCTION__))
;
2326 const char *Name = "__cxa_atexit";
2327 if (TLS) {
2328 const llvm::Triple &T = CGF.getTarget().getTriple();
2329 Name = T.isOSDarwin() ? "_tlv_atexit" : "__cxa_thread_atexit";
2330 }
2331
2332 // We're assuming that the destructor function is something we can
2333 // reasonably call with the default CC. Go ahead and cast it to the
2334 // right prototype.
2335 llvm::Type *dtorTy =
2336 llvm::FunctionType::get(CGF.VoidTy, CGF.Int8PtrTy, false)->getPointerTo();
2337
2338 // Preserve address space of addr.
2339 auto AddrAS = addr ? addr->getType()->getPointerAddressSpace() : 0;
2340 auto AddrInt8PtrTy =
2341 AddrAS ? CGF.Int8Ty->getPointerTo(AddrAS) : CGF.Int8PtrTy;
2342
2343 // Create a variable that binds the atexit to this shared object.
2344 llvm::Constant *handle =
2345 CGF.CGM.CreateRuntimeVariable(CGF.Int8Ty, "__dso_handle");
2346 auto *GV = cast<llvm::GlobalValue>(handle->stripPointerCasts());
2347 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
2348
2349 // extern "C" int __cxa_atexit(void (*f)(void *), void *p, void *d);
2350 llvm::Type *paramTys[] = {dtorTy, AddrInt8PtrTy, handle->getType()};
2351 llvm::FunctionType *atexitTy =
2352 llvm::FunctionType::get(CGF.IntTy, paramTys, false);
2353
2354 // Fetch the actual function.
2355 llvm::FunctionCallee atexit = CGF.CGM.CreateRuntimeFunction(atexitTy, Name);
2356 if (llvm::Function *fn = dyn_cast<llvm::Function>(atexit.getCallee()))
2357 fn->setDoesNotThrow();
2358
2359 if (!addr)
2360 // addr is null when we are trying to register a dtor annotated with
2361 // __attribute__((destructor)) in a constructor function. Using null here is
2362 // okay because this argument is just passed back to the destructor
2363 // function.
2364 addr = llvm::Constant::getNullValue(CGF.Int8PtrTy);
2365
2366 llvm::Value *args[] = {llvm::ConstantExpr::getBitCast(
2367 cast<llvm::Constant>(dtor.getCallee()), dtorTy),
2368 llvm::ConstantExpr::getBitCast(addr, AddrInt8PtrTy),
2369 handle};
2370 CGF.EmitNounwindRuntimeCall(atexit, args);
2371}
2372
2373void CodeGenModule::registerGlobalDtorsWithAtExit() {
2374 for (const auto I : DtorsUsingAtExit) {
2375 int Priority = I.first;
2376 const llvm::TinyPtrVector<llvm::Function *> &Dtors = I.second;
2377
2378 // Create a function that registers destructors that have the same priority.
2379 //
2380 // Since constructor functions are run in non-descending order of their
2381 // priorities, destructors are registered in non-descending order of their
2382 // priorities, and since destructor functions are run in the reverse order
2383 // of their registration, destructor functions are run in non-ascending
2384 // order of their priorities.
2385 CodeGenFunction CGF(*this);
2386 std::string GlobalInitFnName =
2387 std::string("__GLOBAL_init_") + llvm::to_string(Priority);
2388 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
2389 llvm::Function *GlobalInitFn = CreateGlobalInitOrDestructFunction(
2390 FTy, GlobalInitFnName, getTypes().arrangeNullaryFunction(),
2391 SourceLocation());
2392 ASTContext &Ctx = getContext();
2393 QualType ReturnTy = Ctx.VoidTy;
2394 QualType FunctionTy = Ctx.getFunctionType(ReturnTy, llvm::None, {});
2395 FunctionDecl *FD = FunctionDecl::Create(
2396 Ctx, Ctx.getTranslationUnitDecl(), SourceLocation(), SourceLocation(),
2397 &Ctx.Idents.get(GlobalInitFnName), FunctionTy, nullptr, SC_Static,
2398 false, false);
2399 CGF.StartFunction(GlobalDecl(FD), ReturnTy, GlobalInitFn,
2400 getTypes().arrangeNullaryFunction(), FunctionArgList(),
2401 SourceLocation(), SourceLocation());
2402
2403 for (auto *Dtor : Dtors) {
2404 // Register the destructor function calling __cxa_atexit if it is
2405 // available. Otherwise fall back on calling atexit.
2406 if (getCodeGenOpts().CXAAtExit)
2407 emitGlobalDtorWithCXAAtExit(CGF, Dtor, nullptr, false);
2408 else
2409 CGF.registerGlobalDtorWithAtExit(Dtor);
2410 }
2411
2412 CGF.FinishFunction();
2413 AddGlobalCtor(GlobalInitFn, Priority, nullptr);
2414 }
2415}
2416
2417/// Register a global destructor as best as we know how.
2418void ItaniumCXXABI::registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
2419 llvm::FunctionCallee dtor,
2420 llvm::Constant *addr) {
2421 if (D.isNoDestroy(CGM.getContext()))
2422 return;
2423
2424 // emitGlobalDtorWithCXAAtExit will emit a call to either __cxa_thread_atexit
2425 // or __cxa_atexit depending on whether this VarDecl is a thread-local storage
2426 // or not. CXAAtExit controls only __cxa_atexit, so use it if it is enabled.
2427 // We can always use __cxa_thread_atexit.
2428 if (CGM.getCodeGenOpts().CXAAtExit || D.getTLSKind())
2429 return emitGlobalDtorWithCXAAtExit(CGF, dtor, addr, D.getTLSKind());
2430
2431 // In Apple kexts, we want to add a global destructor entry.
2432 // FIXME: shouldn't this be guarded by some variable?
2433 if (CGM.getLangOpts().AppleKext) {
2434 // Generate a global destructor entry.
2435 return CGM.AddCXXDtorEntry(dtor, addr);
2436 }
2437
2438 CGF.registerGlobalDtorWithAtExit(D, dtor, addr);
2439}
2440
2441static bool isThreadWrapperReplaceable(const VarDecl *VD,
2442 CodeGen::CodeGenModule &CGM) {
2443 assert(!VD->isStaticLocal() && "static local VarDecls don't need wrappers!")((!VD->isStaticLocal() && "static local VarDecls don't need wrappers!"
) ? static_cast<void> (0) : __assert_fail ("!VD->isStaticLocal() && \"static local VarDecls don't need wrappers!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 2443, __PRETTY_FUNCTION__))
;
2444 // Darwin prefers to have references to thread local variables to go through
2445 // the thread wrapper instead of directly referencing the backing variable.
2446 return VD->getTLSKind() == VarDecl::TLS_Dynamic &&
2447 CGM.getTarget().getTriple().isOSDarwin();
2448}
2449
2450/// Get the appropriate linkage for the wrapper function. This is essentially
2451/// the weak form of the variable's linkage; every translation unit which needs
2452/// the wrapper emits a copy, and we want the linker to merge them.
2453static llvm::GlobalValue::LinkageTypes
2454getThreadLocalWrapperLinkage(const VarDecl *VD, CodeGen::CodeGenModule &CGM) {
2455 llvm::GlobalValue::LinkageTypes VarLinkage =
2456 CGM.getLLVMLinkageVarDefinition(VD, /*IsConstant=*/false);
2457
2458 // For internal linkage variables, we don't need an external or weak wrapper.
2459 if (llvm::GlobalValue::isLocalLinkage(VarLinkage))
2460 return VarLinkage;
2461
2462 // If the thread wrapper is replaceable, give it appropriate linkage.
2463 if (isThreadWrapperReplaceable(VD, CGM))
2464 if (!llvm::GlobalVariable::isLinkOnceLinkage(VarLinkage) &&
2465 !llvm::GlobalVariable::isWeakODRLinkage(VarLinkage))
2466 return VarLinkage;
2467 return llvm::GlobalValue::WeakODRLinkage;
2468}
2469
2470llvm::Function *
2471ItaniumCXXABI::getOrCreateThreadLocalWrapper(const VarDecl *VD,
2472 llvm::Value *Val) {
2473 // Mangle the name for the thread_local wrapper function.
2474 SmallString<256> WrapperName;
2475 {
2476 llvm::raw_svector_ostream Out(WrapperName);
2477 getMangleContext().mangleItaniumThreadLocalWrapper(VD, Out);
2478 }
2479
2480 // FIXME: If VD is a definition, we should regenerate the function attributes
2481 // before returning.
2482 if (llvm::Value *V = CGM.getModule().getNamedValue(WrapperName))
2483 return cast<llvm::Function>(V);
2484
2485 QualType RetQT = VD->getType();
2486 if (RetQT->isReferenceType())
2487 RetQT = RetQT.getNonReferenceType();
2488
2489 const CGFunctionInfo &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(
2490 getContext().getPointerType(RetQT), FunctionArgList());
2491
2492 llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FI);
2493 llvm::Function *Wrapper =
2494 llvm::Function::Create(FnTy, getThreadLocalWrapperLinkage(VD, CGM),
2495 WrapperName.str(), &CGM.getModule());
2496
2497 CGM.SetLLVMFunctionAttributes(GlobalDecl(), FI, Wrapper);
2498
2499 // Always resolve references to the wrapper at link time.
2500 if (!Wrapper->hasLocalLinkage())
2501 if (!isThreadWrapperReplaceable(VD, CGM) ||
2502 llvm::GlobalVariable::isLinkOnceLinkage(Wrapper->getLinkage()) ||
2503 llvm::GlobalVariable::isWeakODRLinkage(Wrapper->getLinkage()) ||
2504 VD->getVisibility() == HiddenVisibility)
2505 Wrapper->setVisibility(llvm::GlobalValue::HiddenVisibility);
2506
2507 if (isThreadWrapperReplaceable(VD, CGM)) {
2508 Wrapper->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2509 Wrapper->addFnAttr(llvm::Attribute::NoUnwind);
2510 }
2511
2512 ThreadWrappers.push_back({VD, Wrapper});
2513 return Wrapper;
2514}
2515
2516void ItaniumCXXABI::EmitThreadLocalInitFuncs(
2517 CodeGenModule &CGM, ArrayRef<const VarDecl *> CXXThreadLocals,
2518 ArrayRef<llvm::Function *> CXXThreadLocalInits,
2519 ArrayRef<const VarDecl *> CXXThreadLocalInitVars) {
2520 llvm::Function *InitFunc = nullptr;
2521
2522 // Separate initializers into those with ordered (or partially-ordered)
2523 // initialization and those with unordered initialization.
2524 llvm::SmallVector<llvm::Function *, 8> OrderedInits;
2525 llvm::SmallDenseMap<const VarDecl *, llvm::Function *> UnorderedInits;
2526 for (unsigned I = 0; I != CXXThreadLocalInits.size(); ++I) {
2527 if (isTemplateInstantiation(
2528 CXXThreadLocalInitVars[I]->getTemplateSpecializationKind()))
2529 UnorderedInits[CXXThreadLocalInitVars[I]->getCanonicalDecl()] =
2530 CXXThreadLocalInits[I];
2531 else
2532 OrderedInits.push_back(CXXThreadLocalInits[I]);
2533 }
2534
2535 if (!OrderedInits.empty()) {
2536 // Generate a guarded initialization function.
2537 llvm::FunctionType *FTy =
2538 llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
2539 const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
2540 InitFunc = CGM.CreateGlobalInitOrDestructFunction(FTy, "__tls_init", FI,
2541 SourceLocation(),
2542 /*TLS=*/true);
2543 llvm::GlobalVariable *Guard = new llvm::GlobalVariable(
2544 CGM.getModule(), CGM.Int8Ty, /*isConstant=*/false,
2545 llvm::GlobalVariable::InternalLinkage,
2546 llvm::ConstantInt::get(CGM.Int8Ty, 0), "__tls_guard");
2547 Guard->setThreadLocal(true);
2548
2549 CharUnits GuardAlign = CharUnits::One();
2550 Guard->setAlignment(GuardAlign.getQuantity());
2551
2552 CodeGenFunction(CGM).GenerateCXXGlobalInitFunc(
2553 InitFunc, OrderedInits, ConstantAddress(Guard, GuardAlign));
2554 // On Darwin platforms, use CXX_FAST_TLS calling convention.
2555 if (CGM.getTarget().getTriple().isOSDarwin()) {
2556 InitFunc->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2557 InitFunc->addFnAttr(llvm::Attribute::NoUnwind);
2558 }
2559 }
2560
2561 // Create declarations for thread wrappers for all thread-local variables
2562 // with non-discardable definitions in this translation unit.
2563 for (const VarDecl *VD : CXXThreadLocals) {
2564 if (VD->hasDefinition() &&
2565 !isDiscardableGVALinkage(getContext().GetGVALinkageForVariable(VD))) {
2566 llvm::GlobalValue *GV = CGM.GetGlobalValue(CGM.getMangledName(VD));
2567 getOrCreateThreadLocalWrapper(VD, GV);
2568 }
2569 }
2570
2571 // Emit all referenced thread wrappers.
2572 for (auto VDAndWrapper : ThreadWrappers) {
2573 const VarDecl *VD = VDAndWrapper.first;
2574 llvm::GlobalVariable *Var =
2575 cast<llvm::GlobalVariable>(CGM.GetGlobalValue(CGM.getMangledName(VD)));
2576 llvm::Function *Wrapper = VDAndWrapper.second;
2577
2578 // Some targets require that all access to thread local variables go through
2579 // the thread wrapper. This means that we cannot attempt to create a thread
2580 // wrapper or a thread helper.
2581 if (!VD->hasDefinition()) {
2582 if (isThreadWrapperReplaceable(VD, CGM)) {
2583 Wrapper->setLinkage(llvm::Function::ExternalLinkage);
2584 continue;
2585 }
2586
2587 // If this isn't a TU in which this variable is defined, the thread
2588 // wrapper is discardable.
2589 if (Wrapper->getLinkage() == llvm::Function::WeakODRLinkage)
2590 Wrapper->setLinkage(llvm::Function::LinkOnceODRLinkage);
2591 }
2592
2593 CGM.SetLLVMFunctionAttributesForDefinition(nullptr, Wrapper);
2594
2595 // Mangle the name for the thread_local initialization function.
2596 SmallString<256> InitFnName;
2597 {
2598 llvm::raw_svector_ostream Out(InitFnName);
2599 getMangleContext().mangleItaniumThreadLocalInit(VD, Out);
2600 }
2601
2602 llvm::FunctionType *InitFnTy = llvm::FunctionType::get(CGM.VoidTy, false);
2603
2604 // If we have a definition for the variable, emit the initialization
2605 // function as an alias to the global Init function (if any). Otherwise,
2606 // produce a declaration of the initialization function.
2607 llvm::GlobalValue *Init = nullptr;
2608 bool InitIsInitFunc = false;
2609 bool HasConstantInitialization = false;
2610 if (!usesThreadWrapperFunction(VD)) {
2611 HasConstantInitialization = true;
2612 } else if (VD->hasDefinition()) {
2613 InitIsInitFunc = true;
2614 llvm::Function *InitFuncToUse = InitFunc;
2615 if (isTemplateInstantiation(VD->getTemplateSpecializationKind()))
2616 InitFuncToUse = UnorderedInits.lookup(VD->getCanonicalDecl());
2617 if (InitFuncToUse)
2618 Init = llvm::GlobalAlias::create(Var->getLinkage(), InitFnName.str(),
2619 InitFuncToUse);
2620 } else {
2621 // Emit a weak global function referring to the initialization function.
2622 // This function will not exist if the TU defining the thread_local
2623 // variable in question does not need any dynamic initialization for
2624 // its thread_local variables.
2625 Init = llvm::Function::Create(InitFnTy,
2626 llvm::GlobalVariable::ExternalWeakLinkage,
2627 InitFnName.str(), &CGM.getModule());
2628 const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
2629 CGM.SetLLVMFunctionAttributes(GlobalDecl(), FI,
2630 cast<llvm::Function>(Init));
2631 }
2632
2633 if (Init) {
2634 Init->setVisibility(Var->getVisibility());
2635 Init->setDSOLocal(Var->isDSOLocal());
2636 }
2637
2638 llvm::LLVMContext &Context = CGM.getModule().getContext();
2639 llvm::BasicBlock *Entry = llvm::BasicBlock::Create(Context, "", Wrapper);
2640 CGBuilderTy Builder(CGM, Entry);
2641 if (HasConstantInitialization) {
2642 // No dynamic initialization to invoke.
2643 } else if (InitIsInitFunc) {
2644 if (Init) {
2645 llvm::CallInst *CallVal = Builder.CreateCall(InitFnTy, Init);
2646 if (isThreadWrapperReplaceable(VD, CGM)) {
2647 CallVal->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2648 llvm::Function *Fn =
2649 cast<llvm::Function>(cast<llvm::GlobalAlias>(Init)->getAliasee());
2650 Fn->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2651 }
2652 }
2653 } else {
2654 // Don't know whether we have an init function. Call it if it exists.
2655 llvm::Value *Have = Builder.CreateIsNotNull(Init);
2656 llvm::BasicBlock *InitBB = llvm::BasicBlock::Create(Context, "", Wrapper);
2657 llvm::BasicBlock *ExitBB = llvm::BasicBlock::Create(Context, "", Wrapper);
2658 Builder.CreateCondBr(Have, InitBB, ExitBB);
2659
2660 Builder.SetInsertPoint(InitBB);
2661 Builder.CreateCall(InitFnTy, Init);
2662 Builder.CreateBr(ExitBB);
2663
2664 Builder.SetInsertPoint(ExitBB);
2665 }
2666
2667 // For a reference, the result of the wrapper function is a pointer to
2668 // the referenced object.
2669 llvm::Value *Val = Var;
2670 if (VD->getType()->isReferenceType()) {
2671 CharUnits Align = CGM.getContext().getDeclAlign(VD);
2672 Val = Builder.CreateAlignedLoad(Val, Align);
2673 }
2674 if (Val->getType() != Wrapper->getReturnType())
2675 Val = Builder.CreatePointerBitCastOrAddrSpaceCast(
2676 Val, Wrapper->getReturnType(), "");
2677 Builder.CreateRet(Val);
2678 }
2679}
2680
2681LValue ItaniumCXXABI::EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,
2682 const VarDecl *VD,
2683 QualType LValType) {
2684 llvm::Value *Val = CGF.CGM.GetAddrOfGlobalVar(VD);
2685 llvm::Function *Wrapper = getOrCreateThreadLocalWrapper(VD, Val);
2686
2687 llvm::CallInst *CallVal = CGF.Builder.CreateCall(Wrapper);
2688 CallVal->setCallingConv(Wrapper->getCallingConv());
2689
2690 LValue LV;
2691 if (VD->getType()->isReferenceType())
2692 LV = CGF.MakeNaturalAlignAddrLValue(CallVal, LValType);
2693 else
2694 LV = CGF.MakeAddrLValue(CallVal, LValType,
2695 CGF.getContext().getDeclAlign(VD));
2696 // FIXME: need setObjCGCLValueClass?
2697 return LV;
2698}
2699
2700/// Return whether the given global decl needs a VTT parameter, which it does
2701/// if it's a base constructor or destructor with virtual bases.
2702bool ItaniumCXXABI::NeedsVTTParameter(GlobalDecl GD) {
2703 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
2704
2705 // We don't have any virtual bases, just return early.
2706 if (!MD->getParent()->getNumVBases())
2707 return false;
2708
2709 // Check if we have a base constructor.
2710 if (isa<CXXConstructorDecl>(MD) && GD.getCtorType() == Ctor_Base)
2711 return true;
2712
2713 // Check if we have a base destructor.
2714 if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
2715 return true;
2716
2717 return false;
2718}
2719
2720namespace {
2721class ItaniumRTTIBuilder {
2722 CodeGenModule &CGM; // Per-module state.
2723 llvm::LLVMContext &VMContext;
2724 const ItaniumCXXABI &CXXABI; // Per-module state.
2725
2726 /// Fields - The fields of the RTTI descriptor currently being built.
2727 SmallVector<llvm::Constant *, 16> Fields;
2728
2729 /// GetAddrOfTypeName - Returns the mangled type name of the given type.
2730 llvm::GlobalVariable *
2731 GetAddrOfTypeName(QualType Ty, llvm::GlobalVariable::LinkageTypes Linkage);
2732
2733 /// GetAddrOfExternalRTTIDescriptor - Returns the constant for the RTTI
2734 /// descriptor of the given type.
2735 llvm::Constant *GetAddrOfExternalRTTIDescriptor(QualType Ty);
2736
2737 /// BuildVTablePointer - Build the vtable pointer for the given type.
2738 void BuildVTablePointer(const Type *Ty);
2739
2740 /// BuildSIClassTypeInfo - Build an abi::__si_class_type_info, used for single
2741 /// inheritance, according to the Itanium C++ ABI, 2.9.5p6b.
2742 void BuildSIClassTypeInfo(const CXXRecordDecl *RD);
2743
2744 /// BuildVMIClassTypeInfo - Build an abi::__vmi_class_type_info, used for
2745 /// classes with bases that do not satisfy the abi::__si_class_type_info
2746 /// constraints, according ti the Itanium C++ ABI, 2.9.5p5c.
2747 void BuildVMIClassTypeInfo(const CXXRecordDecl *RD);
2748
2749 /// BuildPointerTypeInfo - Build an abi::__pointer_type_info struct, used
2750 /// for pointer types.
2751 void BuildPointerTypeInfo(QualType PointeeTy);
2752
2753 /// BuildObjCObjectTypeInfo - Build the appropriate kind of
2754 /// type_info for an object type.
2755 void BuildObjCObjectTypeInfo(const ObjCObjectType *Ty);
2756
2757 /// BuildPointerToMemberTypeInfo - Build an abi::__pointer_to_member_type_info
2758 /// struct, used for member pointer types.
2759 void BuildPointerToMemberTypeInfo(const MemberPointerType *Ty);
2760
2761public:
2762 ItaniumRTTIBuilder(const ItaniumCXXABI &ABI)
2763 : CGM(ABI.CGM), VMContext(CGM.getModule().getContext()), CXXABI(ABI) {}
2764
2765 // Pointer type info flags.
2766 enum {
2767 /// PTI_Const - Type has const qualifier.
2768 PTI_Const = 0x1,
2769
2770 /// PTI_Volatile - Type has volatile qualifier.
2771 PTI_Volatile = 0x2,
2772
2773 /// PTI_Restrict - Type has restrict qualifier.
2774 PTI_Restrict = 0x4,
2775
2776 /// PTI_Incomplete - Type is incomplete.
2777 PTI_Incomplete = 0x8,
2778
2779 /// PTI_ContainingClassIncomplete - Containing class is incomplete.
2780 /// (in pointer to member).
2781 PTI_ContainingClassIncomplete = 0x10,
2782
2783 /// PTI_TransactionSafe - Pointee is transaction_safe function (C++ TM TS).
2784 //PTI_TransactionSafe = 0x20,
2785
2786 /// PTI_Noexcept - Pointee is noexcept function (C++1z).
2787 PTI_Noexcept = 0x40,
2788 };
2789
2790 // VMI type info flags.
2791 enum {
2792 /// VMI_NonDiamondRepeat - Class has non-diamond repeated inheritance.
2793 VMI_NonDiamondRepeat = 0x1,
2794
2795 /// VMI_DiamondShaped - Class is diamond shaped.
2796 VMI_DiamondShaped = 0x2
2797 };
2798
2799 // Base class type info flags.
2800 enum {
2801 /// BCTI_Virtual - Base class is virtual.
2802 BCTI_Virtual = 0x1,
2803
2804 /// BCTI_Public - Base class is public.
2805 BCTI_Public = 0x2
2806 };
2807
2808 /// BuildTypeInfo - Build the RTTI type info struct for the given type, or
2809 /// link to an existing RTTI descriptor if one already exists.
2810 llvm::Constant *BuildTypeInfo(QualType Ty);
2811
2812 /// BuildTypeInfo - Build the RTTI type info struct for the given type.
2813 llvm::Constant *BuildTypeInfo(
2814 QualType Ty,
2815 llvm::GlobalVariable::LinkageTypes Linkage,
2816 llvm::GlobalValue::VisibilityTypes Visibility,
2817 llvm::GlobalValue::DLLStorageClassTypes DLLStorageClass);
2818};
2819}
2820
2821llvm::GlobalVariable *ItaniumRTTIBuilder::GetAddrOfTypeName(
2822 QualType Ty, llvm::GlobalVariable::LinkageTypes Linkage) {
2823 SmallString<256> Name;
2824 llvm::raw_svector_ostream Out(Name);
2825 CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(Ty, Out);
2826
2827 // We know that the mangled name of the type starts at index 4 of the
2828 // mangled name of the typename, so we can just index into it in order to
2829 // get the mangled name of the type.
2830 llvm::Constant *Init = llvm::ConstantDataArray::getString(VMContext,
2831 Name.substr(4));
2832 auto Align = CGM.getContext().getTypeAlignInChars(CGM.getContext().CharTy);
2833
2834 llvm::GlobalVariable *GV = CGM.CreateOrReplaceCXXRuntimeVariable(
2835 Name, Init->getType(), Linkage, Align.getQuantity());
2836
2837 GV->setInitializer(Init);
2838
2839 return GV;
2840}
2841
2842llvm::Constant *
2843ItaniumRTTIBuilder::GetAddrOfExternalRTTIDescriptor(QualType Ty) {
2844 // Mangle the RTTI name.
2845 SmallString<256> Name;
2846 llvm::raw_svector_ostream Out(Name);
2847 CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
2848
2849 // Look for an existing global.
2850 llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(Name);
2851
2852 if (!GV) {
2853 // Create a new global variable.
2854 // Note for the future: If we would ever like to do deferred emission of
2855 // RTTI, check if emitting vtables opportunistically need any adjustment.
2856
2857 GV = new llvm::GlobalVariable(CGM.getModule(), CGM.Int8PtrTy,
2858 /*isConstant=*/true,
2859 llvm::GlobalValue::ExternalLinkage, nullptr,
2860 Name);
2861 const CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
2862 CGM.setGVProperties(GV, RD);
2863 }
2864
2865 return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
2866}
2867
2868/// TypeInfoIsInStandardLibrary - Given a builtin type, returns whether the type
2869/// info for that type is defined in the standard library.
2870static bool TypeInfoIsInStandardLibrary(const BuiltinType *Ty) {
2871 // Itanium C++ ABI 2.9.2:
2872 // Basic type information (e.g. for "int", "bool", etc.) will be kept in
2873 // the run-time support library. Specifically, the run-time support
2874 // library should contain type_info objects for the types X, X* and
2875 // X const*, for every X in: void, std::nullptr_t, bool, wchar_t, char,
2876 // unsigned char, signed char, short, unsigned short, int, unsigned int,
2877 // long, unsigned long, long long, unsigned long long, float, double,
2878 // long double, char16_t, char32_t, and the IEEE 754r decimal and
2879 // half-precision floating point types.
2880 //
2881 // GCC also emits RTTI for __int128.
2882 // FIXME: We do not emit RTTI information for decimal types here.
2883
2884 // Types added here must also be added to EmitFundamentalRTTIDescriptors.
2885 switch (Ty->getKind()) {
2886 case BuiltinType::Void:
2887 case BuiltinType::NullPtr:
2888 case BuiltinType::Bool:
2889 case BuiltinType::WChar_S:
2890 case BuiltinType::WChar_U:
2891 case BuiltinType::Char_U:
2892 case BuiltinType::Char_S:
2893 case BuiltinType::UChar:
2894 case BuiltinType::SChar:
2895 case BuiltinType::Short:
2896 case BuiltinType::UShort:
2897 case BuiltinType::Int:
2898 case BuiltinType::UInt:
2899 case BuiltinType::Long:
2900 case BuiltinType::ULong:
2901 case BuiltinType::LongLong:
2902 case BuiltinType::ULongLong:
2903 case BuiltinType::Half:
2904 case BuiltinType::Float:
2905 case BuiltinType::Double:
2906 case BuiltinType::LongDouble:
2907 case BuiltinType::Float16:
2908 case BuiltinType::Float128:
2909 case BuiltinType::Char8:
2910 case BuiltinType::Char16:
2911 case BuiltinType::Char32:
2912 case BuiltinType::Int128:
2913 case BuiltinType::UInt128:
2914 return true;
2915
2916#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2917 case BuiltinType::Id:
2918#include "clang/Basic/OpenCLImageTypes.def"
2919#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2920 case BuiltinType::Id:
2921#include "clang/Basic/OpenCLExtensionTypes.def"
2922 case BuiltinType::OCLSampler:
2923 case BuiltinType::OCLEvent:
2924 case BuiltinType::OCLClkEvent:
2925 case BuiltinType::OCLQueue:
2926 case BuiltinType::OCLReserveID:
2927#define SVE_TYPE(Name, Id, SingletonId) \
2928 case BuiltinType::Id:
2929#include "clang/Basic/AArch64SVEACLETypes.def"
2930 case BuiltinType::ShortAccum:
2931 case BuiltinType::Accum:
2932 case BuiltinType::LongAccum:
2933 case BuiltinType::UShortAccum:
2934 case BuiltinType::UAccum:
2935 case BuiltinType::ULongAccum:
2936 case BuiltinType::ShortFract:
2937 case BuiltinType::Fract:
2938 case BuiltinType::LongFract:
2939 case BuiltinType::UShortFract:
2940 case BuiltinType::UFract:
2941 case BuiltinType::ULongFract:
2942 case BuiltinType::SatShortAccum:
2943 case BuiltinType::SatAccum:
2944 case BuiltinType::SatLongAccum:
2945 case BuiltinType::SatUShortAccum:
2946 case BuiltinType::SatUAccum:
2947 case BuiltinType::SatULongAccum:
2948 case BuiltinType::SatShortFract:
2949 case BuiltinType::SatFract:
2950 case BuiltinType::SatLongFract:
2951 case BuiltinType::SatUShortFract:
2952 case BuiltinType::SatUFract:
2953 case BuiltinType::SatULongFract:
2954 return false;
2955
2956 case BuiltinType::Dependent:
2957#define BUILTIN_TYPE(Id, SingletonId)
2958#define PLACEHOLDER_TYPE(Id, SingletonId) \
2959 case BuiltinType::Id:
2960#include "clang/AST/BuiltinTypes.def"
2961 llvm_unreachable("asking for RRTI for a placeholder type!")::llvm::llvm_unreachable_internal("asking for RRTI for a placeholder type!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 2961)
;
2962
2963 case BuiltinType::ObjCId:
2964 case BuiltinType::ObjCClass:
2965 case BuiltinType::ObjCSel:
2966 llvm_unreachable("FIXME: Objective-C types are unsupported!")::llvm::llvm_unreachable_internal("FIXME: Objective-C types are unsupported!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 2966)
;
2967 }
2968
2969 llvm_unreachable("Invalid BuiltinType Kind!")::llvm::llvm_unreachable_internal("Invalid BuiltinType Kind!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 2969)
;
2970}
2971
2972static bool TypeInfoIsInStandardLibrary(const PointerType *PointerTy) {
2973 QualType PointeeTy = PointerTy->getPointeeType();
2974 const BuiltinType *BuiltinTy = dyn_cast<BuiltinType>(PointeeTy);
2975 if (!BuiltinTy)
2976 return false;
2977
2978 // Check the qualifiers.
2979 Qualifiers Quals = PointeeTy.getQualifiers();
2980 Quals.removeConst();
2981
2982 if (!Quals.empty())
2983 return false;
2984
2985 return TypeInfoIsInStandardLibrary(BuiltinTy);
2986}
2987
2988/// IsStandardLibraryRTTIDescriptor - Returns whether the type
2989/// information for the given type exists in the standard library.
2990static bool IsStandardLibraryRTTIDescriptor(QualType Ty) {
2991 // Type info for builtin types is defined in the standard library.
2992 if (const BuiltinType *BuiltinTy = dyn_cast<BuiltinType>(Ty))
2993 return TypeInfoIsInStandardLibrary(BuiltinTy);
2994
2995 // Type info for some pointer types to builtin types is defined in the
2996 // standard library.
2997 if (const PointerType *PointerTy = dyn_cast<PointerType>(Ty))
2998 return TypeInfoIsInStandardLibrary(PointerTy);
2999
3000 return false;
3001}
3002
3003/// ShouldUseExternalRTTIDescriptor - Returns whether the type information for
3004/// the given type exists somewhere else, and that we should not emit the type
3005/// information in this translation unit. Assumes that it is not a
3006/// standard-library type.
3007static bool ShouldUseExternalRTTIDescriptor(CodeGenModule &CGM,
3008 QualType Ty) {
3009 ASTContext &Context = CGM.getContext();
3010
3011 // If RTTI is disabled, assume it might be disabled in the
3012 // translation unit that defines any potential key function, too.
3013 if (!Context.getLangOpts().RTTI) return false;
3014
3015 if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
3016 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
3017 if (!RD->hasDefinition())
3018 return false;
3019
3020 if (!RD->isDynamicClass())
3021 return false;
3022
3023 // FIXME: this may need to be reconsidered if the key function
3024 // changes.
3025 // N.B. We must always emit the RTTI data ourselves if there exists a key
3026 // function.
3027 bool IsDLLImport = RD->hasAttr<DLLImportAttr>();
3028
3029 // Don't import the RTTI but emit it locally.
3030 if (CGM.getTriple().isWindowsGNUEnvironment())
3031 return false;
3032
3033 if (CGM.getVTables().isVTableExternal(RD))
3034 return IsDLLImport && !CGM.getTriple().isWindowsItaniumEnvironment()
3035 ? false
3036 : true;
3037
3038 if (IsDLLImport)
3039 return true;
3040 }
3041
3042 return false;
3043}
3044
3045/// IsIncompleteClassType - Returns whether the given record type is incomplete.
3046static bool IsIncompleteClassType(const RecordType *RecordTy) {
3047 return !RecordTy->getDecl()->isCompleteDefinition();
3048}
3049
3050/// ContainsIncompleteClassType - Returns whether the given type contains an
3051/// incomplete class type. This is true if
3052///
3053/// * The given type is an incomplete class type.
3054/// * The given type is a pointer type whose pointee type contains an
3055/// incomplete class type.
3056/// * The given type is a member pointer type whose class is an incomplete
3057/// class type.
3058/// * The given type is a member pointer type whoise pointee type contains an
3059/// incomplete class type.
3060/// is an indirect or direct pointer to an incomplete class type.
3061static bool ContainsIncompleteClassType(QualType Ty) {
3062 if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
3063 if (IsIncompleteClassType(RecordTy))
3064 return true;
3065 }
3066
3067 if (const PointerType *PointerTy = dyn_cast<PointerType>(Ty))
3068 return ContainsIncompleteClassType(PointerTy->getPointeeType());
3069
3070 if (const MemberPointerType *MemberPointerTy =
3071 dyn_cast<MemberPointerType>(Ty)) {
3072 // Check if the class type is incomplete.
3073 const RecordType *ClassType = cast<RecordType>(MemberPointerTy->getClass());
3074 if (IsIncompleteClassType(ClassType))
3075 return true;
3076
3077 return ContainsIncompleteClassType(MemberPointerTy->getPointeeType());
3078 }
3079
3080 return false;
3081}
3082
3083// CanUseSingleInheritance - Return whether the given record decl has a "single,
3084// public, non-virtual base at offset zero (i.e. the derived class is dynamic
3085// iff the base is)", according to Itanium C++ ABI, 2.95p6b.
3086static bool CanUseSingleInheritance(const CXXRecordDecl *RD) {
3087 // Check the number of bases.
3088 if (RD->getNumBases() != 1)
3089 return false;
3090
3091 // Get the base.
3092 CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin();
3093
3094 // Check that the base is not virtual.
3095 if (Base->isVirtual())
3096 return false;
3097
3098 // Check that the base is public.
3099 if (Base->getAccessSpecifier() != AS_public)
3100 return false;
3101
3102 // Check that the class is dynamic iff the base is.
3103 const CXXRecordDecl *BaseDecl =
3104 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
3105 if (!BaseDecl->isEmpty() &&
3106 BaseDecl->isDynamicClass() != RD->isDynamicClass())
3107 return false;
3108
3109 return true;
3110}
3111
3112void ItaniumRTTIBuilder::BuildVTablePointer(const Type *Ty) {
3113 // abi::__class_type_info.
3114 static const char * const ClassTypeInfo =
3115 "_ZTVN10__cxxabiv117__class_type_infoE";
3116 // abi::__si_class_type_info.
3117 static const char * const SIClassTypeInfo =
3118 "_ZTVN10__cxxabiv120__si_class_type_infoE";
3119 // abi::__vmi_class_type_info.
3120 static const char * const VMIClassTypeInfo =
3121 "_ZTVN10__cxxabiv121__vmi_class_type_infoE";
3122
3123 const char *VTableName = nullptr;
3124
3125 switch (Ty->getTypeClass()) {
3126#define TYPE(Class, Base)
3127#define ABSTRACT_TYPE(Class, Base)
3128#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
3129#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3130#define DEPENDENT_TYPE(Class, Base) case Type::Class:
3131#include "clang/AST/TypeNodes.inc"
3132 llvm_unreachable("Non-canonical and dependent types shouldn't get here")::llvm::llvm_unreachable_internal("Non-canonical and dependent types shouldn't get here"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 3132)
;
3133
3134 case Type::LValueReference:
3135 case Type::RValueReference:
3136 llvm_unreachable("References shouldn't get here")::llvm::llvm_unreachable_internal("References shouldn't get here"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 3136)
;
3137
3138 case Type::Auto:
3139 case Type::DeducedTemplateSpecialization:
3140 llvm_unreachable("Undeduced type shouldn't get here")::llvm::llvm_unreachable_internal("Undeduced type shouldn't get here"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 3140)
;
3141
3142 case Type::Pipe:
3143 llvm_unreachable("Pipe types shouldn't get here")::llvm::llvm_unreachable_internal("Pipe types shouldn't get here"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 3143)
;
3144
3145 case Type::Builtin:
3146 // GCC treats vector and complex types as fundamental types.
3147 case Type::Vector:
3148 case Type::ExtVector:
3149 case Type::Complex:
3150 case Type::Atomic:
3151 // FIXME: GCC treats block pointers as fundamental types?!
3152 case Type::BlockPointer:
3153 // abi::__fundamental_type_info.
3154 VTableName = "_ZTVN10__cxxabiv123__fundamental_type_infoE";
3155 break;
3156
3157 case Type::ConstantArray:
3158 case Type::IncompleteArray:
3159 case Type::VariableArray:
3160 // abi::__array_type_info.
3161 VTableName = "_ZTVN10__cxxabiv117__array_type_infoE";
3162 break;
3163
3164 case Type::FunctionNoProto:
3165 case Type::FunctionProto:
3166 // abi::__function_type_info.
3167 VTableName = "_ZTVN10__cxxabiv120__function_type_infoE";
3168 break;
3169
3170 case Type::Enum:
3171 // abi::__enum_type_info.
3172 VTableName = "_ZTVN10__cxxabiv116__enum_type_infoE";
3173 break;
3174
3175 case Type::Record: {
3176 const CXXRecordDecl *RD =
3177 cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());
3178
3179 if (!RD->hasDefinition() || !RD->getNumBases()) {
3180 VTableName = ClassTypeInfo;
3181 } else if (CanUseSingleInheritance(RD)) {
3182 VTableName = SIClassTypeInfo;
3183 } else {
3184 VTableName = VMIClassTypeInfo;
3185 }
3186
3187 break;
3188 }
3189
3190 case Type::ObjCObject:
3191 // Ignore protocol qualifiers.
3192 Ty = cast<ObjCObjectType>(Ty)->getBaseType().getTypePtr();
3193
3194 // Handle id and Class.
3195 if (isa<BuiltinType>(Ty)) {
3196 VTableName = ClassTypeInfo;
3197 break;
3198 }
3199
3200 assert(isa<ObjCInterfaceType>(Ty))((isa<ObjCInterfaceType>(Ty)) ? static_cast<void>
(0) : __assert_fail ("isa<ObjCInterfaceType>(Ty)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 3200, __PRETTY_FUNCTION__))
;
3201 LLVM_FALLTHROUGH[[gnu::fallthrough]];
3202
3203 case Type::ObjCInterface:
3204 if (cast<ObjCInterfaceType>(Ty)->getDecl()->getSuperClass()) {
3205 VTableName = SIClassTypeInfo;
3206 } else {
3207 VTableName = ClassTypeInfo;
3208 }
3209 break;
3210
3211 case Type::ObjCObjectPointer:
3212 case Type::Pointer:
3213 // abi::__pointer_type_info.
3214 VTableName = "_ZTVN10__cxxabiv119__pointer_type_infoE";
3215 break;
3216
3217 case Type::MemberPointer:
3218 // abi::__pointer_to_member_type_info.
3219 VTableName = "_ZTVN10__cxxabiv129__pointer_to_member_type_infoE";
3220 break;
3221 }
3222
3223 llvm::Constant *VTable =
3224 CGM.getModule().getOrInsertGlobal(VTableName, CGM.Int8PtrTy);
3225 CGM.setDSOLocal(cast<llvm::GlobalValue>(VTable->stripPointerCasts()));
3226
3227 llvm::Type *PtrDiffTy =
3228 CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
3229
3230 // The vtable address point is 2.
3231 llvm::Constant *Two = llvm::ConstantInt::get(PtrDiffTy, 2);
3232 VTable =
3233 llvm::ConstantExpr::getInBoundsGetElementPtr(CGM.Int8PtrTy, VTable, Two);
3234 VTable = llvm::ConstantExpr::getBitCast(VTable, CGM.Int8PtrTy);
3235
3236 Fields.push_back(VTable);
3237}
3238
3239/// Return the linkage that the type info and type info name constants
3240/// should have for the given type.
3241static llvm::GlobalVariable::LinkageTypes getTypeInfoLinkage(CodeGenModule &CGM,
3242 QualType Ty) {
3243 // Itanium C++ ABI 2.9.5p7:
3244 // In addition, it and all of the intermediate abi::__pointer_type_info
3245 // structs in the chain down to the abi::__class_type_info for the
3246 // incomplete class type must be prevented from resolving to the
3247 // corresponding type_info structs for the complete class type, possibly
3248 // by making them local static objects. Finally, a dummy class RTTI is
3249 // generated for the incomplete type that will not resolve to the final
3250 // complete class RTTI (because the latter need not exist), possibly by
3251 // making it a local static object.
3252 if (ContainsIncompleteClassType(Ty))
3253 return llvm::GlobalValue::InternalLinkage;
3254
3255 switch (Ty->getLinkage()) {
3256 case NoLinkage:
3257 case InternalLinkage:
3258 case UniqueExternalLinkage:
3259 return llvm::GlobalValue::InternalLinkage;
3260
3261 case VisibleNoLinkage:
3262 case ModuleInternalLinkage:
3263 case ModuleLinkage:
3264 case ExternalLinkage:
3265 // RTTI is not enabled, which means that this type info struct is going
3266 // to be used for exception handling. Give it linkonce_odr linkage.
3267 if (!CGM.getLangOpts().RTTI)
3268 return llvm::GlobalValue::LinkOnceODRLinkage;
3269
3270 if (const RecordType *Record = dyn_cast<RecordType>(Ty)) {
3271 const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
3272 if (RD->hasAttr<WeakAttr>())
3273 return llvm::GlobalValue::WeakODRLinkage;
3274 if (CGM.getTriple().isWindowsItaniumEnvironment())
3275 if (RD->hasAttr<DLLImportAttr>() &&
3276 ShouldUseExternalRTTIDescriptor(CGM, Ty))
3277 return llvm::GlobalValue::ExternalLinkage;
3278 // MinGW always uses LinkOnceODRLinkage for type info.
3279 if (RD->isDynamicClass() &&
3280 !CGM.getContext()
3281 .getTargetInfo()
3282 .getTriple()
3283 .isWindowsGNUEnvironment())
3284 return CGM.getVTableLinkage(RD);
3285 }
3286
3287 return llvm::GlobalValue::LinkOnceODRLinkage;
3288 }
3289
3290 llvm_unreachable("Invalid linkage!")::llvm::llvm_unreachable_internal("Invalid linkage!", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 3290)
;
3291}
3292
3293llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(QualType Ty) {
3294 // We want to operate on the canonical type.
3295 Ty = Ty.getCanonicalType();
3296
3297 // Check if we've already emitted an RTTI descriptor for this type.
3298 SmallString<256> Name;
3299 llvm::raw_svector_ostream Out(Name);
3300 CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
3301
3302 llvm::GlobalVariable *OldGV = CGM.getModule().getNamedGlobal(Name);
3303 if (OldGV && !OldGV->isDeclaration()) {
3304 assert(!OldGV->hasAvailableExternallyLinkage() &&((!OldGV->hasAvailableExternallyLinkage() && "available_externally typeinfos not yet implemented"
) ? static_cast<void> (0) : __assert_fail ("!OldGV->hasAvailableExternallyLinkage() && \"available_externally typeinfos not yet implemented\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 3305, __PRETTY_FUNCTION__))
3305 "available_externally typeinfos not yet implemented")((!OldGV->hasAvailableExternallyLinkage() && "available_externally typeinfos not yet implemented"
) ? static_cast<void> (0) : __assert_fail ("!OldGV->hasAvailableExternallyLinkage() && \"available_externally typeinfos not yet implemented\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 3305, __PRETTY_FUNCTION__))
;
3306
3307 return llvm::ConstantExpr::getBitCast(OldGV, CGM.Int8PtrTy);
3308 }
3309
3310 // Check if there is already an external RTTI descriptor for this type.
3311 if (IsStandardLibraryRTTIDescriptor(Ty) ||
3312 ShouldUseExternalRTTIDescriptor(CGM, Ty))
3313 return GetAddrOfExternalRTTIDescriptor(Ty);
3314
3315 // Emit the standard library with external linkage.
3316 llvm::GlobalVariable::LinkageTypes Linkage = getTypeInfoLinkage(CGM, Ty);
3317
3318 // Give the type_info object and name the formal visibility of the
3319 // type itself.
3320 llvm::GlobalValue::VisibilityTypes llvmVisibility;
3321 if (llvm::GlobalValue::isLocalLinkage(Linkage))
3322 // If the linkage is local, only default visibility makes sense.
3323 llvmVisibility = llvm::GlobalValue::DefaultVisibility;
3324 else if (CXXABI.classifyRTTIUniqueness(Ty, Linkage) ==
3325 ItaniumCXXABI::RUK_NonUniqueHidden)
3326 llvmVisibility = llvm::GlobalValue::HiddenVisibility;
3327 else
3328 llvmVisibility = CodeGenModule::GetLLVMVisibility(Ty->getVisibility());
3329
3330 llvm::GlobalValue::DLLStorageClassTypes DLLStorageClass =
3331 llvm::GlobalValue::DefaultStorageClass;
3332 if (CGM.getTriple().isWindowsItaniumEnvironment()) {
3333 auto RD = Ty->getAsCXXRecordDecl();
3334 if (RD && RD->hasAttr<DLLExportAttr>())
3335 DLLStorageClass = llvm::GlobalValue::DLLExportStorageClass;
3336 }
3337
3338 return BuildTypeInfo(Ty, Linkage, llvmVisibility, DLLStorageClass);
3339}
3340
3341llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(
3342 QualType Ty,
3343 llvm::GlobalVariable::LinkageTypes Linkage,
3344 llvm::GlobalValue::VisibilityTypes Visibility,
3345 llvm::GlobalValue::DLLStorageClassTypes DLLStorageClass) {
3346 // Add the vtable pointer.
3347 BuildVTablePointer(cast<Type>(Ty));
3348
3349 // And the name.
3350 llvm::GlobalVariable *TypeName = GetAddrOfTypeName(Ty, Linkage);
3351 llvm::Constant *TypeNameField;
3352
3353 // If we're supposed to demote the visibility, be sure to set a flag
3354 // to use a string comparison for type_info comparisons.
3355 ItaniumCXXABI::RTTIUniquenessKind RTTIUniqueness =
3356 CXXABI.classifyRTTIUniqueness(Ty, Linkage);
3357 if (RTTIUniqueness != ItaniumCXXABI::RUK_Unique) {
3358 // The flag is the sign bit, which on ARM64 is defined to be clear
3359 // for global pointers. This is very ARM64-specific.
3360 TypeNameField = llvm::ConstantExpr::getPtrToInt(TypeName, CGM.Int64Ty);
3361 llvm::Constant *flag =
3362 llvm::ConstantInt::get(CGM.Int64Ty, ((uint64_t)1) << 63);
3363 TypeNameField = llvm::ConstantExpr::getAdd(TypeNameField, flag);
3364 TypeNameField =
3365 llvm::ConstantExpr::getIntToPtr(TypeNameField, CGM.Int8PtrTy);
3366 } else {
3367 TypeNameField = llvm::ConstantExpr::getBitCast(TypeName, CGM.Int8PtrTy);
3368 }
3369 Fields.push_back(TypeNameField);
3370
3371 switch (Ty->getTypeClass()) {
3372#define TYPE(Class, Base)
3373#define ABSTRACT_TYPE(Class, Base)
3374#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
3375#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3376#define DEPENDENT_TYPE(Class, Base) case Type::Class:
3377#include "clang/AST/TypeNodes.inc"
3378 llvm_unreachable("Non-canonical and dependent types shouldn't get here")::llvm::llvm_unreachable_internal("Non-canonical and dependent types shouldn't get here"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 3378)
;
3379
3380 // GCC treats vector types as fundamental types.
3381 case Type::Builtin:
3382 case Type::Vector:
3383 case Type::ExtVector:
3384 case Type::Complex:
3385 case Type::BlockPointer:
3386 // Itanium C++ ABI 2.9.5p4:
3387 // abi::__fundamental_type_info adds no data members to std::type_info.
3388 break;
3389
3390 case Type::LValueReference:
3391 case Type::RValueReference:
3392 llvm_unreachable("References shouldn't get here")::llvm::llvm_unreachable_internal("References shouldn't get here"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 3392)
;
3393
3394 case Type::Auto:
3395 case Type::DeducedTemplateSpecialization:
3396 llvm_unreachable("Undeduced type shouldn't get here")::llvm::llvm_unreachable_internal("Undeduced type shouldn't get here"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 3396)
;
3397
3398 case Type::Pipe:
3399 llvm_unreachable("Pipe type shouldn't get here")::llvm::llvm_unreachable_internal("Pipe type shouldn't get here"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 3399)
;
3400
3401 case Type::ConstantArray:
3402 case Type::IncompleteArray:
3403 case Type::VariableArray:
3404 // Itanium C++ ABI 2.9.5p5:
3405 // abi::__array_type_info adds no data members to std::type_info.
3406 break;
3407
3408 case Type::FunctionNoProto:
3409 case Type::FunctionProto:
3410 // Itanium C++ ABI 2.9.5p5:
3411 // abi::__function_type_info adds no data members to std::type_info.
3412 break;
3413
3414 case Type::Enum:
3415 // Itanium C++ ABI 2.9.5p5:
3416 // abi::__enum_type_info adds no data members to std::type_info.
3417 break;
3418
3419 case Type::Record: {
3420 const CXXRecordDecl *RD =
3421 cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());
3422 if (!RD->hasDefinition() || !RD->getNumBases()) {
3423 // We don't need to emit any fields.
3424 break;
3425 }
3426
3427 if (CanUseSingleInheritance(RD))
3428 BuildSIClassTypeInfo(RD);
3429 else
3430 BuildVMIClassTypeInfo(RD);
3431
3432 break;
3433 }
3434
3435 case Type::ObjCObject:
3436 case Type::ObjCInterface:
3437 BuildObjCObjectTypeInfo(cast<ObjCObjectType>(Ty));
3438 break;
3439
3440 case Type::ObjCObjectPointer:
3441 BuildPointerTypeInfo(cast<ObjCObjectPointerType>(Ty)->getPointeeType());
3442 break;
3443
3444 case Type::Pointer:
3445 BuildPointerTypeInfo(cast<PointerType>(Ty)->getPointeeType());
3446 break;
3447
3448 case Type::MemberPointer:
3449 BuildPointerToMemberTypeInfo(cast<MemberPointerType>(Ty));
3450 break;
3451
3452 case Type::Atomic:
3453 // No fields, at least for the moment.
3454 break;
3455 }
3456
3457 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Fields);
3458
3459 SmallString<256> Name;
3460 llvm::raw_svector_ostream Out(Name);
3461 CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
3462 llvm::Module &M = CGM.getModule();
3463 llvm::GlobalVariable *OldGV = M.getNamedGlobal(Name);
3464 llvm::GlobalVariable *GV =
3465 new llvm::GlobalVariable(M, Init->getType(),
3466 /*isConstant=*/true, Linkage, Init, Name);
3467
3468 // If there's already an old global variable, replace it with the new one.
3469 if (OldGV) {
3470 GV->takeName(OldGV);
3471 llvm::Constant *NewPtr =
3472 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
3473 OldGV->replaceAllUsesWith(NewPtr);
3474 OldGV->eraseFromParent();
3475 }
3476
3477 if (CGM.supportsCOMDAT() && GV->isWeakForLinker())
3478 GV->setComdat(M.getOrInsertComdat(GV->getName()));
3479
3480 CharUnits Align =
3481 CGM.getContext().toCharUnitsFromBits(CGM.getTarget().getPointerAlign(0));
3482 GV->setAlignment(Align.getQuantity());
3483
3484 // The Itanium ABI specifies that type_info objects must be globally
3485 // unique, with one exception: if the type is an incomplete class
3486 // type or a (possibly indirect) pointer to one. That exception
3487 // affects the general case of comparing type_info objects produced
3488 // by the typeid operator, which is why the comparison operators on
3489 // std::type_info generally use the type_info name pointers instead
3490 // of the object addresses. However, the language's built-in uses
3491 // of RTTI generally require class types to be complete, even when
3492 // manipulating pointers to those class types. This allows the
3493 // implementation of dynamic_cast to rely on address equality tests,
3494 // which is much faster.
3495
3496 // All of this is to say that it's important that both the type_info
3497 // object and the type_info name be uniqued when weakly emitted.
3498
3499 TypeName->setVisibility(Visibility);
3500 CGM.setDSOLocal(TypeName);
3501
3502 GV->setVisibility(Visibility);
3503 CGM.setDSOLocal(GV);
3504
3505 TypeName->setDLLStorageClass(DLLStorageClass);
3506 GV->setDLLStorageClass(DLLStorageClass);
3507
3508 TypeName->setPartition(CGM.getCodeGenOpts().SymbolPartition);
3509 GV->setPartition(CGM.getCodeGenOpts().SymbolPartition);
3510
3511 return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
3512}
3513
3514/// BuildObjCObjectTypeInfo - Build the appropriate kind of type_info
3515/// for the given Objective-C object type.
3516void ItaniumRTTIBuilder::BuildObjCObjectTypeInfo(const ObjCObjectType *OT) {
3517 // Drop qualifiers.
3518 const Type *T = OT->getBaseType().getTypePtr();
3519 assert(isa<BuiltinType>(T) || isa<ObjCInterfaceType>(T))((isa<BuiltinType>(T) || isa<ObjCInterfaceType>(T
)) ? static_cast<void> (0) : __assert_fail ("isa<BuiltinType>(T) || isa<ObjCInterfaceType>(T)"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 3519, __PRETTY_FUNCTION__))
;
3520
3521 // The builtin types are abi::__class_type_infos and don't require
3522 // extra fields.
3523 if (isa<BuiltinType>(T)) return;
3524
3525 ObjCInterfaceDecl *Class = cast<ObjCInterfaceType>(T)->getDecl();
3526 ObjCInterfaceDecl *Super = Class->getSuperClass();
3527
3528 // Root classes are also __class_type_info.
3529 if (!Super) return;
3530
3531 QualType SuperTy = CGM.getContext().getObjCInterfaceType(Super);
3532
3533 // Everything else is single inheritance.
3534 llvm::Constant *BaseTypeInfo =
3535 ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(SuperTy);
3536 Fields.push_back(BaseTypeInfo);
3537}
3538
3539/// BuildSIClassTypeInfo - Build an abi::__si_class_type_info, used for single
3540/// inheritance, according to the Itanium C++ ABI, 2.95p6b.
3541void ItaniumRTTIBuilder::BuildSIClassTypeInfo(const CXXRecordDecl *RD) {
3542 // Itanium C++ ABI 2.9.5p6b:
3543 // It adds to abi::__class_type_info a single member pointing to the
3544 // type_info structure for the base type,
3545 llvm::Constant *BaseTypeInfo =
3546 ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(RD->bases_begin()->getType());
3547 Fields.push_back(BaseTypeInfo);
3548}
3549
3550namespace {
3551 /// SeenBases - Contains virtual and non-virtual bases seen when traversing
3552 /// a class hierarchy.
3553 struct SeenBases {
3554 llvm::SmallPtrSet<const CXXRecordDecl *, 16> NonVirtualBases;
3555 llvm::SmallPtrSet<const CXXRecordDecl *, 16> VirtualBases;
3556 };
3557}
3558
3559/// ComputeVMIClassTypeInfoFlags - Compute the value of the flags member in
3560/// abi::__vmi_class_type_info.
3561///
3562static unsigned ComputeVMIClassTypeInfoFlags(const CXXBaseSpecifier *Base,
3563 SeenBases &Bases) {
3564
3565 unsigned Flags = 0;
3566
3567 const CXXRecordDecl *BaseDecl =
3568 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
3569
3570 if (Base->isVirtual()) {
3571 // Mark the virtual base as seen.
3572 if (!Bases.VirtualBases.insert(BaseDecl).second) {
3573 // If this virtual base has been seen before, then the class is diamond
3574 // shaped.
3575 Flags |= ItaniumRTTIBuilder::VMI_DiamondShaped;
3576 } else {
3577 if (Bases.NonVirtualBases.count(BaseDecl))
3578 Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
3579 }
3580 } else {
3581 // Mark the non-virtual base as seen.
3582 if (!Bases.NonVirtualBases.insert(BaseDecl).second) {
3583 // If this non-virtual base has been seen before, then the class has non-
3584 // diamond shaped repeated inheritance.
3585 Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
3586 } else {
3587 if (Bases.VirtualBases.count(BaseDecl))
3588 Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
3589 }
3590 }
3591
3592 // Walk all bases.
3593 for (const auto &I : BaseDecl->bases())
3594 Flags |= ComputeVMIClassTypeInfoFlags(&I, Bases);
3595
3596 return Flags;
3597}
3598
3599static unsigned ComputeVMIClassTypeInfoFlags(const CXXRecordDecl *RD) {
3600 unsigned Flags = 0;
3601 SeenBases Bases;
3602
3603 // Walk all bases.
3604 for (const auto &I : RD->bases())
3605 Flags |= ComputeVMIClassTypeInfoFlags(&I, Bases);
3606
3607 return Flags;
3608}
3609
3610/// BuildVMIClassTypeInfo - Build an abi::__vmi_class_type_info, used for
3611/// classes with bases that do not satisfy the abi::__si_class_type_info
3612/// constraints, according ti the Itanium C++ ABI, 2.9.5p5c.
3613void ItaniumRTTIBuilder::BuildVMIClassTypeInfo(const CXXRecordDecl *RD) {
3614 llvm::Type *UnsignedIntLTy =
3615 CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy);
3616
3617 // Itanium C++ ABI 2.9.5p6c:
3618 // __flags is a word with flags describing details about the class
3619 // structure, which may be referenced by using the __flags_masks
3620 // enumeration. These flags refer to both direct and indirect bases.
3621 unsigned Flags = ComputeVMIClassTypeInfoFlags(RD);
3622 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3623
3624 // Itanium C++ ABI 2.9.5p6c:
3625 // __base_count is a word with the number of direct proper base class
3626 // descriptions that follow.
3627 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, RD->getNumBases()));
3628
3629 if (!RD->getNumBases())
3630 return;
3631
3632 // Now add the base class descriptions.
3633
3634 // Itanium C++ ABI 2.9.5p6c:
3635 // __base_info[] is an array of base class descriptions -- one for every
3636 // direct proper base. Each description is of the type:
3637 //
3638 // struct abi::__base_class_type_info {
3639 // public:
3640 // const __class_type_info *__base_type;
3641 // long __offset_flags;
3642 //
3643 // enum __offset_flags_masks {
3644 // __virtual_mask = 0x1,
3645 // __public_mask = 0x2,
3646 // __offset_shift = 8
3647 // };
3648 // };
3649
3650 // If we're in mingw and 'long' isn't wide enough for a pointer, use 'long
3651 // long' instead of 'long' for __offset_flags. libstdc++abi uses long long on
3652 // LLP64 platforms.
3653 // FIXME: Consider updating libc++abi to match, and extend this logic to all
3654 // LLP64 platforms.
3655 QualType OffsetFlagsTy = CGM.getContext().LongTy;
3656 const TargetInfo &TI = CGM.getContext().getTargetInfo();
3657 if (TI.getTriple().isOSCygMing() && TI.getPointerWidth(0) > TI.getLongWidth())
3658 OffsetFlagsTy = CGM.getContext().LongLongTy;
3659 llvm::Type *OffsetFlagsLTy =
3660 CGM.getTypes().ConvertType(OffsetFlagsTy);
3661
3662 for (const auto &Base : RD->bases()) {
3663 // The __base_type member points to the RTTI for the base type.
3664 Fields.push_back(ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(Base.getType()));
3665
3666 const CXXRecordDecl *BaseDecl =
3667 cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
3668
3669 int64_t OffsetFlags = 0;
3670
3671 // All but the lower 8 bits of __offset_flags are a signed offset.
3672 // For a non-virtual base, this is the offset in the object of the base
3673 // subobject. For a virtual base, this is the offset in the virtual table of
3674 // the virtual base offset for the virtual base referenced (negative).
3675 CharUnits Offset;
3676 if (Base.isVirtual())
3677 Offset =
3678 CGM.getItaniumVTableContext().getVirtualBaseOffsetOffset(RD, BaseDecl);
3679 else {
3680 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
3681 Offset = Layout.getBaseClassOffset(BaseDecl);
3682 };
3683
3684 OffsetFlags = uint64_t(Offset.getQuantity()) << 8;
3685
3686 // The low-order byte of __offset_flags contains flags, as given by the
3687 // masks from the enumeration __offset_flags_masks.
3688 if (Base.isVirtual())
3689 OffsetFlags |= BCTI_Virtual;
3690 if (Base.getAccessSpecifier() == AS_public)
3691 OffsetFlags |= BCTI_Public;
3692
3693 Fields.push_back(llvm::ConstantInt::get(OffsetFlagsLTy, OffsetFlags));
3694 }
3695}
3696
3697/// Compute the flags for a __pbase_type_info, and remove the corresponding
3698/// pieces from \p Type.
3699static unsigned extractPBaseFlags(ASTContext &Ctx, QualType &Type) {
3700 unsigned Flags = 0;
3701
3702 if (Type.isConstQualified())
3703 Flags |= ItaniumRTTIBuilder::PTI_Const;
3704 if (Type.isVolatileQualified())
3705 Flags |= ItaniumRTTIBuilder::PTI_Volatile;
3706 if (Type.isRestrictQualified())
3707 Flags |= ItaniumRTTIBuilder::PTI_Restrict;
3708 Type = Type.getUnqualifiedType();
3709
3710 // Itanium C++ ABI 2.9.5p7:
3711 // When the abi::__pbase_type_info is for a direct or indirect pointer to an
3712 // incomplete class type, the incomplete target type flag is set.
3713 if (ContainsIncompleteClassType(Type))
3714 Flags |= ItaniumRTTIBuilder::PTI_Incomplete;
3715
3716 if (auto *Proto = Type->getAs<FunctionProtoType>()) {
3717 if (Proto->isNothrow()) {
3718 Flags |= ItaniumRTTIBuilder::PTI_Noexcept;
3719 Type = Ctx.getFunctionTypeWithExceptionSpec(Type, EST_None);
3720 }
3721 }
3722
3723 return Flags;
3724}
3725
3726/// BuildPointerTypeInfo - Build an abi::__pointer_type_info struct,
3727/// used for pointer types.
3728void ItaniumRTTIBuilder::BuildPointerTypeInfo(QualType PointeeTy) {
3729 // Itanium C++ ABI 2.9.5p7:
3730 // __flags is a flag word describing the cv-qualification and other
3731 // attributes of the type pointed to
3732 unsigned Flags = extractPBaseFlags(CGM.getContext(), PointeeTy);
3733
3734 llvm::Type *UnsignedIntLTy =
3735 CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy);
3736 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3737
3738 // Itanium C++ ABI 2.9.5p7:
3739 // __pointee is a pointer to the std::type_info derivation for the
3740 // unqualified type being pointed to.
3741 llvm::Constant *PointeeTypeInfo =
3742 ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(PointeeTy);
3743 Fields.push_back(PointeeTypeInfo);
3744}
3745
3746/// BuildPointerToMemberTypeInfo - Build an abi::__pointer_to_member_type_info
3747/// struct, used for member pointer types.
3748void
3749ItaniumRTTIBuilder::BuildPointerToMemberTypeInfo(const MemberPointerType *Ty) {
3750 QualType PointeeTy = Ty->getPointeeType();
3751
3752 // Itanium C++ ABI 2.9.5p7:
3753 // __flags is a flag word describing the cv-qualification and other
3754 // attributes of the type pointed to.
3755 unsigned Flags = extractPBaseFlags(CGM.getContext(), PointeeTy);
3756
3757 const RecordType *ClassType = cast<RecordType>(Ty->getClass());
3758 if (IsIncompleteClassType(ClassType))
3759 Flags |= PTI_ContainingClassIncomplete;
3760
3761 llvm::Type *UnsignedIntLTy =
3762 CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy);
3763 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3764
3765 // Itanium C++ ABI 2.9.5p7:
3766 // __pointee is a pointer to the std::type_info derivation for the
3767 // unqualified type being pointed to.
3768 llvm::Constant *PointeeTypeInfo =
3769 ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(PointeeTy);
3770 Fields.push_back(PointeeTypeInfo);
3771
3772 // Itanium C++ ABI 2.9.5p9:
3773 // __context is a pointer to an abi::__class_type_info corresponding to the
3774 // class type containing the member pointed to
3775 // (e.g., the "A" in "int A::*").
3776 Fields.push_back(
3777 ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(QualType(ClassType, 0)));
3778}
3779
3780llvm::Constant *ItaniumCXXABI::getAddrOfRTTIDescriptor(QualType Ty) {
3781 return ItaniumRTTIBuilder(*this).BuildTypeInfo(Ty);
3782}
3783
3784void ItaniumCXXABI::EmitFundamentalRTTIDescriptors(const CXXRecordDecl *RD) {
3785 // Types added here must also be added to TypeInfoIsInStandardLibrary.
3786 QualType FundamentalTypes[] = {
3787 getContext().VoidTy, getContext().NullPtrTy,
3788 getContext().BoolTy, getContext().WCharTy,
3789 getContext().CharTy, getContext().UnsignedCharTy,
3790 getContext().SignedCharTy, getContext().ShortTy,
3791 getContext().UnsignedShortTy, getContext().IntTy,
3792 getContext().UnsignedIntTy, getContext().LongTy,
3793 getContext().UnsignedLongTy, getContext().LongLongTy,
3794 getContext().UnsignedLongLongTy, getContext().Int128Ty,
3795 getContext().UnsignedInt128Ty, getContext().HalfTy,
3796 getContext().FloatTy, getContext().DoubleTy,
3797 getContext().LongDoubleTy, getContext().Float128Ty,
3798 getContext().Char8Ty, getContext().Char16Ty,
3799 getContext().Char32Ty
3800 };
3801 llvm::GlobalValue::DLLStorageClassTypes DLLStorageClass =
3802 RD->hasAttr<DLLExportAttr>()
3803 ? llvm::GlobalValue::DLLExportStorageClass
3804 : llvm::GlobalValue::DefaultStorageClass;
3805 llvm::GlobalValue::VisibilityTypes Visibility =
3806 CodeGenModule::GetLLVMVisibility(RD->getVisibility());
3807 for (const QualType &FundamentalType : FundamentalTypes) {
3808 QualType PointerType = getContext().getPointerType(FundamentalType);
3809 QualType PointerTypeConst = getContext().getPointerType(
3810 FundamentalType.withConst());
3811 for (QualType Type : {FundamentalType, PointerType, PointerTypeConst})
3812 ItaniumRTTIBuilder(*this).BuildTypeInfo(
3813 Type, llvm::GlobalValue::ExternalLinkage,
3814 Visibility, DLLStorageClass);
3815 }
3816}
3817
3818/// What sort of uniqueness rules should we use for the RTTI for the
3819/// given type?
3820ItaniumCXXABI::RTTIUniquenessKind ItaniumCXXABI::classifyRTTIUniqueness(
3821 QualType CanTy, llvm::GlobalValue::LinkageTypes Linkage) const {
3822 if (shouldRTTIBeUnique())
3823 return RUK_Unique;
3824
3825 // It's only necessary for linkonce_odr or weak_odr linkage.
3826 if (Linkage != llvm::GlobalValue::LinkOnceODRLinkage &&
3827 Linkage != llvm::GlobalValue::WeakODRLinkage)
3828 return RUK_Unique;
3829
3830 // It's only necessary with default visibility.
3831 if (CanTy->getVisibility() != DefaultVisibility)
3832 return RUK_Unique;
3833
3834 // If we're not required to publish this symbol, hide it.
3835 if (Linkage == llvm::GlobalValue::LinkOnceODRLinkage)
3836 return RUK_NonUniqueHidden;
3837
3838 // If we're required to publish this symbol, as we might be under an
3839 // explicit instantiation, leave it with default visibility but
3840 // enable string-comparisons.
3841 assert(Linkage == llvm::GlobalValue::WeakODRLinkage)((Linkage == llvm::GlobalValue::WeakODRLinkage) ? static_cast
<void> (0) : __assert_fail ("Linkage == llvm::GlobalValue::WeakODRLinkage"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 3841, __PRETTY_FUNCTION__))
;
3842 return RUK_NonUniqueVisible;
3843}
3844
3845// Find out how to codegen the complete destructor and constructor
3846namespace {
3847enum class StructorCodegen { Emit, RAUW, Alias, COMDAT };
3848}
3849static StructorCodegen getCodegenToUse(CodeGenModule &CGM,
3850 const CXXMethodDecl *MD) {
3851 if (!CGM.getCodeGenOpts().CXXCtorDtorAliases)
3852 return StructorCodegen::Emit;
3853
3854 // The complete and base structors are not equivalent if there are any virtual
3855 // bases, so emit separate functions.
3856 if (MD->getParent()->getNumVBases())
3857 return StructorCodegen::Emit;
3858
3859 GlobalDecl AliasDecl;
3860 if (const auto *DD = dyn_cast<CXXDestructorDecl>(MD)) {
3861 AliasDecl = GlobalDecl(DD, Dtor_Complete);
3862 } else {
3863 const auto *CD = cast<CXXConstructorDecl>(MD);
3864 AliasDecl = GlobalDecl(CD, Ctor_Complete);
3865 }
3866 llvm::GlobalValue::LinkageTypes Linkage = CGM.getFunctionLinkage(AliasDecl);
3867
3868 if (llvm::GlobalValue::isDiscardableIfUnused(Linkage))
3869 return StructorCodegen::RAUW;
3870
3871 // FIXME: Should we allow available_externally aliases?
3872 if (!llvm::GlobalAlias::isValidLinkage(Linkage))
3873 return StructorCodegen::RAUW;
3874
3875 if (llvm::GlobalValue::isWeakForLinker(Linkage)) {
3876 // Only ELF and wasm support COMDATs with arbitrary names (C5/D5).
3877 if (CGM.getTarget().getTriple().isOSBinFormatELF() ||
3878 CGM.getTarget().getTriple().isOSBinFormatWasm())
3879 return StructorCodegen::COMDAT;
3880 return StructorCodegen::Emit;
3881 }
3882
3883 return StructorCodegen::Alias;
3884}
3885
3886static void emitConstructorDestructorAlias(CodeGenModule &CGM,
3887 GlobalDecl AliasDecl,
3888 GlobalDecl TargetDecl) {
3889 llvm::GlobalValue::LinkageTypes Linkage = CGM.getFunctionLinkage(AliasDecl);
3890
3891 StringRef MangledName = CGM.getMangledName(AliasDecl);
3892 llvm::GlobalValue *Entry = CGM.GetGlobalValue(MangledName);
3893 if (Entry && !Entry->isDeclaration())
3894 return;
3895
3896 auto *Aliasee = cast<llvm::GlobalValue>(CGM.GetAddrOfGlobal(TargetDecl));
3897
3898 // Create the alias with no name.
3899 auto *Alias = llvm::GlobalAlias::create(Linkage, "", Aliasee);
3900
3901 // Constructors and destructors are always unnamed_addr.
3902 Alias->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3903
3904 // Switch any previous uses to the alias.
3905 if (Entry) {
3906 assert(Entry->getType() == Aliasee->getType() &&((Entry->getType() == Aliasee->getType() && "declaration exists with different type"
) ? static_cast<void> (0) : __assert_fail ("Entry->getType() == Aliasee->getType() && \"declaration exists with different type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 3907, __PRETTY_FUNCTION__))
3907 "declaration exists with different type")((Entry->getType() == Aliasee->getType() && "declaration exists with different type"
) ? static_cast<void> (0) : __assert_fail ("Entry->getType() == Aliasee->getType() && \"declaration exists with different type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 3907, __PRETTY_FUNCTION__))
;
3908 Alias->takeName(Entry);
3909 Entry->replaceAllUsesWith(Alias);
3910 Entry->eraseFromParent();
3911 } else {
3912 Alias->setName(MangledName);
3913 }
3914
3915 // Finally, set up the alias with its proper name and attributes.
3916 CGM.SetCommonAttributes(AliasDecl, Alias);
3917}
3918
3919void ItaniumCXXABI::emitCXXStructor(GlobalDecl GD) {
3920 auto *MD = cast<CXXMethodDecl>(GD.getDecl());
3921 auto *CD = dyn_cast<CXXConstructorDecl>(MD);
3922 const CXXDestructorDecl *DD = CD ? nullptr : cast<CXXDestructorDecl>(MD);
3923
3924 StructorCodegen CGType = getCodegenToUse(CGM, MD);
3925
3926 if (CD ? GD.getCtorType() == Ctor_Complete
3927 : GD.getDtorType() == Dtor_Complete) {
3928 GlobalDecl BaseDecl;
3929 if (CD)
3930 BaseDecl = GD.getWithCtorType(Ctor_Base);
3931 else
3932 BaseDecl = GD.getWithDtorType(Dtor_Base);
3933
3934 if (CGType == StructorCodegen::Alias || CGType == StructorCodegen::COMDAT) {
3935 emitConstructorDestructorAlias(CGM, GD, BaseDecl);
3936 return;
3937 }
3938
3939 if (CGType == StructorCodegen::RAUW) {
3940 StringRef MangledName = CGM.getMangledName(GD);
3941 auto *Aliasee = CGM.GetAddrOfGlobal(BaseDecl);
3942 CGM.addReplacement(MangledName, Aliasee);
3943 return;
3944 }
3945 }
3946
3947 // The base destructor is equivalent to the base destructor of its
3948 // base class if there is exactly one non-virtual base class with a
3949 // non-trivial destructor, there are no fields with a non-trivial
3950 // destructor, and the body of the destructor is trivial.
3951 if (DD && GD.getDtorType() == Dtor_Base &&
3952 CGType != StructorCodegen::COMDAT &&
3953 !CGM.TryEmitBaseDestructorAsAlias(DD))
3954 return;
3955
3956 // FIXME: The deleting destructor is equivalent to the selected operator
3957 // delete if:
3958 // * either the delete is a destroying operator delete or the destructor
3959 // would be trivial if it weren't virtual,
3960 // * the conversion from the 'this' parameter to the first parameter of the
3961 // destructor is equivalent to a bitcast,
3962 // * the destructor does not have an implicit "this" return, and
3963 // * the operator delete has the same calling convention and IR function type
3964 // as the destructor.
3965 // In such cases we should try to emit the deleting dtor as an alias to the
3966 // selected 'operator delete'.
3967
3968 llvm::Function *Fn = CGM.codegenCXXStructor(GD);
3969
3970 if (CGType == StructorCodegen::COMDAT) {
3971 SmallString<256> Buffer;
3972 llvm::raw_svector_ostream Out(Buffer);
3973 if (DD)
3974 getMangleContext().mangleCXXDtorComdat(DD, Out);
3975 else
3976 getMangleContext().mangleCXXCtorComdat(CD, Out);
3977 llvm::Comdat *C = CGM.getModule().getOrInsertComdat(Out.str());
3978 Fn->setComdat(C);
3979 } else {
3980 CGM.maybeSetTrivialComdat(*MD, *Fn);
3981 }
3982}
3983
3984static llvm::FunctionCallee getBeginCatchFn(CodeGenModule &CGM) {
3985 // void *__cxa_begin_catch(void*);
3986 llvm::FunctionType *FTy = llvm::FunctionType::get(
3987 CGM.Int8PtrTy, CGM.Int8PtrTy, /*isVarArg=*/false);
3988
3989 return CGM.CreateRuntimeFunction(FTy, "__cxa_begin_catch");
3990}
3991
3992static llvm::FunctionCallee getEndCatchFn(CodeGenModule &CGM) {
3993 // void __cxa_end_catch();
3994 llvm::FunctionType *FTy =
3995 llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
3996
3997 return CGM.CreateRuntimeFunction(FTy, "__cxa_end_catch");
3998}
3999
4000static llvm::FunctionCallee getGetExceptionPtrFn(CodeGenModule &CGM) {
4001 // void *__cxa_get_exception_ptr(void*);
4002 llvm::FunctionType *FTy = llvm::FunctionType::get(
4003 CGM.Int8PtrTy, CGM.Int8PtrTy, /*isVarArg=*/false);
4004
4005 return CGM.CreateRuntimeFunction(FTy, "__cxa_get_exception_ptr");
4006}
4007
4008namespace {
4009 /// A cleanup to call __cxa_end_catch. In many cases, the caught
4010 /// exception type lets us state definitively that the thrown exception
4011 /// type does not have a destructor. In particular:
4012 /// - Catch-alls tell us nothing, so we have to conservatively
4013 /// assume that the thrown exception might have a destructor.
4014 /// - Catches by reference behave according to their base types.
4015 /// - Catches of non-record types will only trigger for exceptions
4016 /// of non-record types, which never have destructors.
4017 /// - Catches of record types can trigger for arbitrary subclasses
4018 /// of the caught type, so we have to assume the actual thrown
4019 /// exception type might have a throwing destructor, even if the
4020 /// caught type's destructor is trivial or nothrow.
4021 struct CallEndCatch final : EHScopeStack::Cleanup {
4022 CallEndCatch(bool MightThrow) : MightThrow(MightThrow) {}
4023 bool MightThrow;
4024
4025 void Emit(CodeGenFunction &CGF, Flags flags) override {
4026 if (!MightThrow) {
4027 CGF.EmitNounwindRuntimeCall(getEndCatchFn(CGF.CGM));
4028 return;
4029 }
4030
4031 CGF.EmitRuntimeCallOrInvoke(getEndCatchFn(CGF.CGM));
4032 }
4033 };
4034}
4035
4036/// Emits a call to __cxa_begin_catch and enters a cleanup to call
4037/// __cxa_end_catch.
4038///
4039/// \param EndMightThrow - true if __cxa_end_catch might throw
4040static llvm::Value *CallBeginCatch(CodeGenFunction &CGF,
4041 llvm::Value *Exn,
4042 bool EndMightThrow) {
4043 llvm::CallInst *call =
4044 CGF.EmitNounwindRuntimeCall(getBeginCatchFn(CGF.CGM), Exn);
4045
4046 CGF.EHStack.pushCleanup<CallEndCatch>(NormalAndEHCleanup, EndMightThrow);
4047
4048 return call;
4049}
4050
4051/// A "special initializer" callback for initializing a catch
4052/// parameter during catch initialization.
4053static void InitCatchParam(CodeGenFunction &CGF,
4054 const VarDecl &CatchParam,
4055 Address ParamAddr,
4056 SourceLocation Loc) {
4057 // Load the exception from where the landing pad saved it.
4058 llvm::Value *Exn = CGF.getExceptionFromSlot();
4059
4060 CanQualType CatchType =
4061 CGF.CGM.getContext().getCanonicalType(CatchParam.getType());
4062 llvm::Type *LLVMCatchTy = CGF.ConvertTypeForMem(CatchType);
4063
4064 // If we're catching by reference, we can just cast the object
4065 // pointer to the appropriate pointer.
4066 if (isa<ReferenceType>(CatchType)) {
4067 QualType CaughtType = cast<ReferenceType>(CatchType)->getPointeeType();
4068 bool EndCatchMightThrow = CaughtType->isRecordType();
4069
4070 // __cxa_begin_catch returns the adjusted object pointer.
4071 llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, EndCatchMightThrow);
4072
4073 // We have no way to tell the personality function that we're
4074 // catching by reference, so if we're catching a pointer,
4075 // __cxa_begin_catch will actually return that pointer by value.
4076 if (const PointerType *PT = dyn_cast<PointerType>(CaughtType)) {
4077 QualType PointeeType = PT->getPointeeType();
4078
4079 // When catching by reference, generally we should just ignore
4080 // this by-value pointer and use the exception object instead.
4081 if (!PointeeType->isRecordType()) {
4082
4083 // Exn points to the struct _Unwind_Exception header, which
4084 // we have to skip past in order to reach the exception data.
4085 unsigned HeaderSize =
4086 CGF.CGM.getTargetCodeGenInfo().getSizeOfUnwindException();
4087 AdjustedExn = CGF.Builder.CreateConstGEP1_32(Exn, HeaderSize);
4088
4089 // However, if we're catching a pointer-to-record type that won't
4090 // work, because the personality function might have adjusted
4091 // the pointer. There's actually no way for us to fully satisfy
4092 // the language/ABI contract here: we can't use Exn because it
4093 // might have the wrong adjustment, but we can't use the by-value
4094 // pointer because it's off by a level of abstraction.
4095 //
4096 // The current solution is to dump the adjusted pointer into an
4097 // alloca, which breaks language semantics (because changing the
4098 // pointer doesn't change the exception) but at least works.
4099 // The better solution would be to filter out non-exact matches
4100 // and rethrow them, but this is tricky because the rethrow
4101 // really needs to be catchable by other sites at this landing
4102 // pad. The best solution is to fix the personality function.
4103 } else {
4104 // Pull the pointer for the reference type off.
4105 llvm::Type *PtrTy =
4106 cast<llvm::PointerType>(LLVMCatchTy)->getElementType();
4107
4108 // Create the temporary and write the adjusted pointer into it.
4109 Address ExnPtrTmp =
4110 CGF.CreateTempAlloca(PtrTy, CGF.getPointerAlign(), "exn.byref.tmp");
4111 llvm::Value *Casted = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
4112 CGF.Builder.CreateStore(Casted, ExnPtrTmp);
4113
4114 // Bind the reference to the temporary.
4115 AdjustedExn = ExnPtrTmp.getPointer();
4116 }
4117 }
4118
4119 llvm::Value *ExnCast =
4120 CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.byref");
4121 CGF.Builder.CreateStore(ExnCast, ParamAddr);
4122 return;
4123 }
4124
4125 // Scalars and complexes.
4126 TypeEvaluationKind TEK = CGF.getEvaluationKind(CatchType);
4127 if (TEK != TEK_Aggregate) {
4128 llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, false);
4129
4130 // If the catch type is a pointer type, __cxa_begin_catch returns
4131 // the pointer by value.
4132 if (CatchType->hasPointerRepresentation()) {
4133 llvm::Value *CastExn =
4134 CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.casted");
4135
4136 switch (CatchType.getQualifiers().getObjCLifetime()) {
4137 case Qualifiers::OCL_Strong:
4138 CastExn = CGF.EmitARCRetainNonBlock(CastExn);
4139 LLVM_FALLTHROUGH[[gnu::fallthrough]];
4140
4141 case Qualifiers::OCL_None:
4142 case Qualifiers::OCL_ExplicitNone:
4143 case Qualifiers::OCL_Autoreleasing:
4144 CGF.Builder.CreateStore(CastExn, ParamAddr);
4145 return;
4146
4147 case Qualifiers::OCL_Weak:
4148 CGF.EmitARCInitWeak(ParamAddr, CastExn);
4149 return;
4150 }
4151 llvm_unreachable("bad ownership qualifier!")::llvm::llvm_unreachable_internal("bad ownership qualifier!",
"/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 4151)
;
4152 }
4153
4154 // Otherwise, it returns a pointer into the exception object.
4155
4156 llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
4157 llvm::Value *Cast = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
4158
4159 LValue srcLV = CGF.MakeNaturalAlignAddrLValue(Cast, CatchType);
4160 LValue destLV = CGF.MakeAddrLValue(ParamAddr, CatchType);
4161 switch (TEK) {
4162 case TEK_Complex:
4163 CGF.EmitStoreOfComplex(CGF.EmitLoadOfComplex(srcLV, Loc), destLV,
4164 /*init*/ true);
4165 return;
4166 case TEK_Scalar: {
4167 llvm::Value *ExnLoad = CGF.EmitLoadOfScalar(srcLV, Loc);
4168 CGF.EmitStoreOfScalar(ExnLoad, destLV, /*init*/ true);
4169 return;
4170 }
4171 case TEK_Aggregate:
4172 llvm_unreachable("evaluation kind filtered out!")::llvm::llvm_unreachable_internal("evaluation kind filtered out!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 4172)
;
4173 }
4174 llvm_unreachable("bad evaluation kind")::llvm::llvm_unreachable_internal("bad evaluation kind", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 4174)
;
4175 }
4176
4177 assert(isa<RecordType>(CatchType) && "unexpected catch type!")((isa<RecordType>(CatchType) && "unexpected catch type!"
) ? static_cast<void> (0) : __assert_fail ("isa<RecordType>(CatchType) && \"unexpected catch type!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 4177, __PRETTY_FUNCTION__))
;
4178 auto catchRD = CatchType->getAsCXXRecordDecl();
4179 CharUnits caughtExnAlignment = CGF.CGM.getClassPointerAlignment(catchRD);
4180
4181 llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
4182
4183 // Check for a copy expression. If we don't have a copy expression,
4184 // that means a trivial copy is okay.
4185 const Expr *copyExpr = CatchParam.getInit();
4186 if (!copyExpr) {
4187 llvm::Value *rawAdjustedExn = CallBeginCatch(CGF, Exn, true);
4188 Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
4189 caughtExnAlignment);
4190 LValue Dest = CGF.MakeAddrLValue(ParamAddr, CatchType);
4191 LValue Src = CGF.MakeAddrLValue(adjustedExn, CatchType);
4192 CGF.EmitAggregateCopy(Dest, Src, CatchType, AggValueSlot::DoesNotOverlap);
4193 return;
4194 }
4195
4196 // We have to call __cxa_get_exception_ptr to get the adjusted
4197 // pointer before copying.
4198 llvm::CallInst *rawAdjustedExn =
4199 CGF.EmitNounwindRuntimeCall(getGetExceptionPtrFn(CGF.CGM), Exn);
4200
4201 // Cast that to the appropriate type.
4202 Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
4203 caughtExnAlignment);
4204
4205 // The copy expression is defined in terms of an OpaqueValueExpr.
4206 // Find it and map it to the adjusted expression.
4207 CodeGenFunction::OpaqueValueMapping
4208 opaque(CGF, OpaqueValueExpr::findInCopyConstruct(copyExpr),
4209 CGF.MakeAddrLValue(adjustedExn, CatchParam.getType()));
4210
4211 // Call the copy ctor in a terminate scope.
4212 CGF.EHStack.pushTerminate();
4213
4214 // Perform the copy construction.
4215 CGF.EmitAggExpr(copyExpr,
4216 AggValueSlot::forAddr(ParamAddr, Qualifiers(),
4217 AggValueSlot::IsNotDestructed,
4218 AggValueSlot::DoesNotNeedGCBarriers,
4219 AggValueSlot::IsNotAliased,
4220 AggValueSlot::DoesNotOverlap));
4221
4222 // Leave the terminate scope.
4223 CGF.EHStack.popTerminate();
4224
4225 // Undo the opaque value mapping.
4226 opaque.pop();
4227
4228 // Finally we can call __cxa_begin_catch.
4229 CallBeginCatch(CGF, Exn, true);
4230}
4231
4232/// Begins a catch statement by initializing the catch variable and
4233/// calling __cxa_begin_catch.
4234void ItaniumCXXABI::emitBeginCatch(CodeGenFunction &CGF,
4235 const CXXCatchStmt *S) {
4236 // We have to be very careful with the ordering of cleanups here:
4237 // C++ [except.throw]p4:
4238 // The destruction [of the exception temporary] occurs
4239 // immediately after the destruction of the object declared in
4240 // the exception-declaration in the handler.
4241 //
4242 // So the precise ordering is:
4243 // 1. Construct catch variable.
4244 // 2. __cxa_begin_catch
4245 // 3. Enter __cxa_end_catch cleanup
4246 // 4. Enter dtor cleanup
4247 //
4248 // We do this by using a slightly abnormal initialization process.
4249 // Delegation sequence:
4250 // - ExitCXXTryStmt opens a RunCleanupsScope
4251 // - EmitAutoVarAlloca creates the variable and debug info
4252 // - InitCatchParam initializes the variable from the exception
4253 // - CallBeginCatch calls __cxa_begin_catch
4254 // - CallBeginCatch enters the __cxa_end_catch cleanup
4255 // - EmitAutoVarCleanups enters the variable destructor cleanup
4256 // - EmitCXXTryStmt emits the code for the catch body
4257 // - EmitCXXTryStmt close the RunCleanupsScope
4258
4259 VarDecl *CatchParam = S->getExceptionDecl();
4260 if (!CatchParam) {
4261 llvm::Value *Exn = CGF.getExceptionFromSlot();
4262 CallBeginCatch(CGF, Exn, true);
4263 return;
4264 }
4265
4266 // Emit the local.
4267 CodeGenFunction::AutoVarEmission var = CGF.EmitAutoVarAlloca(*CatchParam);
4268 InitCatchParam(CGF, *CatchParam, var.getObjectAddress(CGF), S->getBeginLoc());
4269 CGF.EmitAutoVarCleanups(var);
4270}
4271
4272/// Get or define the following function:
4273/// void @__clang_call_terminate(i8* %exn) nounwind noreturn
4274/// This code is used only in C++.
4275static llvm::FunctionCallee getClangCallTerminateFn(CodeGenModule &CGM) {
4276 llvm::FunctionType *fnTy =
4277 llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*isVarArg=*/false);
4278 llvm::FunctionCallee fnRef = CGM.CreateRuntimeFunction(
4279 fnTy, "__clang_call_terminate", llvm::AttributeList(), /*Local=*/true);
4280 llvm::Function *fn =
4281 cast<llvm::Function>(fnRef.getCallee()->stripPointerCasts());
4282 if (fn->empty()) {
4283 fn->setDoesNotThrow();
4284 fn->setDoesNotReturn();
4285
4286 // What we really want is to massively penalize inlining without
4287 // forbidding it completely. The difference between that and
4288 // 'noinline' is negligible.
4289 fn->addFnAttr(llvm::Attribute::NoInline);
4290
4291 // Allow this function to be shared across translation units, but
4292 // we don't want it to turn into an exported symbol.
4293 fn->setLinkage(llvm::Function::LinkOnceODRLinkage);
4294 fn->setVisibility(llvm::Function::HiddenVisibility);
4295 if (CGM.supportsCOMDAT())
4296 fn->setComdat(CGM.getModule().getOrInsertComdat(fn->getName()));
4297
4298 // Set up the function.
4299 llvm::BasicBlock *entry =
4300 llvm::BasicBlock::Create(CGM.getLLVMContext(), "", fn);
4301 CGBuilderTy builder(CGM, entry);
4302
4303 // Pull the exception pointer out of the parameter list.
4304 llvm::Value *exn = &*fn->arg_begin();
4305
4306 // Call __cxa_begin_catch(exn).
4307 llvm::CallInst *catchCall = builder.CreateCall(getBeginCatchFn(CGM), exn);
4308 catchCall->setDoesNotThrow();
4309 catchCall->setCallingConv(CGM.getRuntimeCC());
4310
4311 // Call std::terminate().
4312 llvm::CallInst *termCall = builder.CreateCall(CGM.getTerminateFn());
4313 termCall->setDoesNotThrow();
4314 termCall->setDoesNotReturn();
4315 termCall->setCallingConv(CGM.getRuntimeCC());
4316
4317 // std::terminate cannot return.
4318 builder.CreateUnreachable();
4319 }
4320 return fnRef;
4321}
4322
4323llvm::CallInst *
4324ItaniumCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
4325 llvm::Value *Exn) {
4326 // In C++, we want to call __cxa_begin_catch() before terminating.
4327 if (Exn) {
4328 assert(CGF.CGM.getLangOpts().CPlusPlus)((CGF.CGM.getLangOpts().CPlusPlus) ? static_cast<void> (
0) : __assert_fail ("CGF.CGM.getLangOpts().CPlusPlus", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp"
, 4328, __PRETTY_FUNCTION__))
;
4329 return CGF.EmitNounwindRuntimeCall(getClangCallTerminateFn(CGF.CGM), Exn);
4330 }
4331 return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn());
4332}
4333
4334std::pair<llvm::Value *, const CXXRecordDecl *>
4335ItaniumCXXABI::LoadVTablePtr(CodeGenFunction &CGF, Address This,
4336 const CXXRecordDecl *RD) {
4337 return {CGF.GetVTablePtr(This, CGM.Int8PtrTy, RD), RD};
4338}
4339
4340void WebAssemblyCXXABI::emitBeginCatch(CodeGenFunction &CGF,
4341 const CXXCatchStmt *C) {
4342 if (CGF.getTarget().hasFeature("exception-handling"))
4343 CGF.EHStack.pushCleanup<CatchRetScope>(
4344 NormalCleanup, cast<llvm::CatchPadInst>(CGF.CurrentFuncletPad));
4345 ItaniumCXXABI::emitBeginCatch(CGF, C);
4346}