1 //===------- ItaniumCXXABI.cpp - Emit LLVM Code from ASTs for a Module ----===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This provides C++ code generation targeting the Itanium C++ ABI. The class
11 // in this file generates structures that follow the Itanium C++ ABI, which is
13 // http://www.codesourcery.com/public/cxx-abi/abi.html
14 // http://www.codesourcery.com/public/cxx-abi/abi-eh.html
16 // It also supports the closely-related ARM ABI, documented at:
17 // http://infocenter.arm.com/help/topic/com.arm.doc.ihi0041c/IHI0041C_cppabi.pdf
19 //===----------------------------------------------------------------------===//
22 #include "CGCleanup.h"
23 #include "CGRecordLayout.h"
24 #include "CGVTables.h"
25 #include "CodeGenFunction.h"
26 #include "CodeGenModule.h"
27 #include "TargetInfo.h"
28 #include "clang/AST/Mangle.h"
29 #include "clang/AST/Type.h"
30 #include "clang/AST/StmtCXX.h"
31 #include "llvm/IR/CallSite.h"
32 #include "llvm/IR/DataLayout.h"
33 #include "llvm/IR/Instructions.h"
34 #include "llvm/IR/Intrinsics.h"
35 #include "llvm/IR/Value.h"
37 using namespace clang;
38 using namespace CodeGen;
41 class ItaniumCXXABI : public CodeGen::CGCXXABI {
42 /// VTables - All the vtables which have been defined.
43 llvm::DenseMap<const CXXRecordDecl *, llvm::GlobalVariable *> VTables;
46 bool UseARMMethodPtrABI;
47 bool UseARMGuardVarABI;
49 ItaniumMangleContext &getMangleContext() {
50 return cast<ItaniumMangleContext>(CodeGen::CGCXXABI::getMangleContext());
54 ItaniumCXXABI(CodeGen::CodeGenModule &CGM,
55 bool UseARMMethodPtrABI = false,
56 bool UseARMGuardVarABI = false) :
57 CGCXXABI(CGM), UseARMMethodPtrABI(UseARMMethodPtrABI),
58 UseARMGuardVarABI(UseARMGuardVarABI) { }
60 bool classifyReturnType(CGFunctionInfo &FI) const override;
62 RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const override {
63 // Structures with either a non-trivial destructor or a non-trivial
64 // copy constructor are always indirect.
65 // FIXME: Use canCopyArgument() when it is fixed to handle lazily declared
67 if (RD->hasNonTrivialDestructor() || RD->hasNonTrivialCopyConstructor())
72 bool isThisCompleteObject(GlobalDecl GD) const override {
73 // The Itanium ABI has separate complete-object vs. base-object
74 // variants of both constructors and destructors.
75 if (isa<CXXDestructorDecl>(GD.getDecl())) {
76 switch (GD.getDtorType()) {
85 llvm_unreachable("emitting dtor comdat as function?");
87 llvm_unreachable("bad dtor kind");
89 if (isa<CXXConstructorDecl>(GD.getDecl())) {
90 switch (GD.getCtorType()) {
97 case Ctor_CopyingClosure:
98 case Ctor_DefaultClosure:
99 llvm_unreachable("closure ctors in Itanium ABI?");
102 llvm_unreachable("emitting ctor comdat as function?");
104 llvm_unreachable("bad dtor kind");
111 bool isZeroInitializable(const MemberPointerType *MPT) override;
113 llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT) override;
116 EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
119 llvm::Value *&ThisPtrForCall,
120 llvm::Value *MemFnPtr,
121 const MemberPointerType *MPT) override;
124 EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
127 const MemberPointerType *MPT) override;
129 llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,
131 llvm::Value *Src) override;
132 llvm::Constant *EmitMemberPointerConversion(const CastExpr *E,
133 llvm::Constant *Src) override;
135 llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT) override;
137 llvm::Constant *EmitMemberFunctionPointer(const CXXMethodDecl *MD) override;
138 llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT,
139 CharUnits offset) override;
140 llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT) override;
141 llvm::Constant *BuildMemberPointer(const CXXMethodDecl *MD,
142 CharUnits ThisAdjustment);
144 llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF,
145 llvm::Value *L, llvm::Value *R,
146 const MemberPointerType *MPT,
147 bool Inequality) override;
149 llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
151 const MemberPointerType *MPT) override;
153 void emitVirtualObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE,
154 Address Ptr, QualType ElementType,
155 const CXXDestructorDecl *Dtor) override;
157 CharUnits getAlignmentOfExnObject() {
158 unsigned Align = CGM.getContext().getTargetInfo().getExnObjectAlignment();
159 return CGM.getContext().toCharUnitsFromBits(Align);
162 void emitRethrow(CodeGenFunction &CGF, bool isNoReturn) override;
163 void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) override;
165 void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) override;
168 emitTerminateForUnexpectedException(CodeGenFunction &CGF,
169 llvm::Value *Exn) override;
171 void EmitFundamentalRTTIDescriptor(QualType Type);
172 void EmitFundamentalRTTIDescriptors();
173 llvm::Constant *getAddrOfRTTIDescriptor(QualType Ty) override;
175 getAddrOfCXXCatchHandlerType(QualType Ty,
176 QualType CatchHandlerType) override {
177 return CatchTypeInfo{getAddrOfRTTIDescriptor(Ty), 0};
180 bool shouldTypeidBeNullChecked(bool IsDeref, QualType SrcRecordTy) override;
181 void EmitBadTypeidCall(CodeGenFunction &CGF) override;
182 llvm::Value *EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy,
184 llvm::Type *StdTypeInfoPtrTy) override;
186 bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
187 QualType SrcRecordTy) override;
189 llvm::Value *EmitDynamicCastCall(CodeGenFunction &CGF, Address Value,
190 QualType SrcRecordTy, QualType DestTy,
191 QualType DestRecordTy,
192 llvm::BasicBlock *CastEnd) override;
194 llvm::Value *EmitDynamicCastToVoid(CodeGenFunction &CGF, Address Value,
195 QualType SrcRecordTy,
196 QualType DestTy) override;
198 bool EmitBadCastCall(CodeGenFunction &CGF) override;
201 GetVirtualBaseClassOffset(CodeGenFunction &CGF, Address This,
202 const CXXRecordDecl *ClassDecl,
203 const CXXRecordDecl *BaseClassDecl) override;
205 void EmitCXXConstructors(const CXXConstructorDecl *D) override;
207 void buildStructorSignature(const CXXMethodDecl *MD, StructorType T,
208 SmallVectorImpl<CanQualType> &ArgTys) override;
210 bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor,
211 CXXDtorType DT) const override {
212 // Itanium does not emit any destructor variant as an inline thunk.
213 // Delegating may occur as an optimization, but all variants are either
214 // emitted with external linkage or as linkonce if they are inline and used.
218 void EmitCXXDestructors(const CXXDestructorDecl *D) override;
220 void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy,
221 FunctionArgList &Params) override;
223 void EmitInstanceFunctionProlog(CodeGenFunction &CGF) override;
225 unsigned addImplicitConstructorArgs(CodeGenFunction &CGF,
226 const CXXConstructorDecl *D,
227 CXXCtorType Type, bool ForVirtualBase,
229 CallArgList &Args) override;
231 void EmitDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *DD,
232 CXXDtorType Type, bool ForVirtualBase,
233 bool Delegating, Address This) override;
235 void emitVTableDefinitions(CodeGenVTables &CGVT,
236 const CXXRecordDecl *RD) override;
238 bool isVirtualOffsetNeededForVTableField(CodeGenFunction &CGF,
239 CodeGenFunction::VPtr Vptr) override;
241 bool doStructorsInitializeVPtrs(const CXXRecordDecl *VTableClass) override {
246 getVTableAddressPoint(BaseSubobject Base,
247 const CXXRecordDecl *VTableClass) override;
249 llvm::Value *getVTableAddressPointInStructor(
250 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass,
251 BaseSubobject Base, const CXXRecordDecl *NearestVBase) override;
253 llvm::Value *getVTableAddressPointInStructorWithVTT(
254 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass,
255 BaseSubobject Base, const CXXRecordDecl *NearestVBase);
258 getVTableAddressPointForConstExpr(BaseSubobject Base,
259 const CXXRecordDecl *VTableClass) override;
261 llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD,
262 CharUnits VPtrOffset) override;
264 llvm::Value *getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD,
265 Address This, llvm::Type *Ty,
266 SourceLocation Loc) override;
268 llvm::Value *EmitVirtualDestructorCall(CodeGenFunction &CGF,
269 const CXXDestructorDecl *Dtor,
270 CXXDtorType DtorType,
272 const CXXMemberCallExpr *CE) override;
274 void emitVirtualInheritanceTables(const CXXRecordDecl *RD) override;
276 bool canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const override;
278 void setThunkLinkage(llvm::Function *Thunk, bool ForVTable, GlobalDecl GD,
279 bool ReturnAdjustment) override {
280 // Allow inlining of thunks by emitting them with available_externally
281 // linkage together with vtables when needed.
282 if (ForVTable && !Thunk->hasLocalLinkage())
283 Thunk->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
286 llvm::Value *performThisAdjustment(CodeGenFunction &CGF, Address This,
287 const ThisAdjustment &TA) override;
289 llvm::Value *performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
290 const ReturnAdjustment &RA) override;
292 size_t getSrcArgforCopyCtor(const CXXConstructorDecl *,
293 FunctionArgList &Args) const override {
294 assert(!Args.empty() && "expected the arglist to not be empty!");
295 return Args.size() - 1;
298 StringRef GetPureVirtualCallName() override { return "__cxa_pure_virtual"; }
299 StringRef GetDeletedVirtualCallName() override
300 { return "__cxa_deleted_virtual"; }
302 CharUnits getArrayCookieSizeImpl(QualType elementType) override;
303 Address InitializeArrayCookie(CodeGenFunction &CGF,
305 llvm::Value *NumElements,
306 const CXXNewExpr *expr,
307 QualType ElementType) override;
308 llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF,
310 CharUnits cookieSize) override;
312 void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
313 llvm::GlobalVariable *DeclPtr,
314 bool PerformInit) override;
315 void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
316 llvm::Constant *dtor, llvm::Constant *addr) override;
318 llvm::Function *getOrCreateThreadLocalWrapper(const VarDecl *VD,
320 void EmitThreadLocalInitFuncs(
322 ArrayRef<const VarDecl *> CXXThreadLocals,
323 ArrayRef<llvm::Function *> CXXThreadLocalInits,
324 ArrayRef<const VarDecl *> CXXThreadLocalInitVars) override;
326 bool usesThreadWrapperFunction() const override { return true; }
327 LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD,
328 QualType LValType) override;
330 bool NeedsVTTParameter(GlobalDecl GD) override;
332 /**************************** RTTI Uniqueness ******************************/
335 /// Returns true if the ABI requires RTTI type_info objects to be unique
336 /// across a program.
337 virtual bool shouldRTTIBeUnique() const { return true; }
340 /// What sort of unique-RTTI behavior should we use?
341 enum RTTIUniquenessKind {
342 /// We are guaranteeing, or need to guarantee, that the RTTI string
346 /// We are not guaranteeing uniqueness for the RTTI string, so we
347 /// can demote to hidden visibility but must use string comparisons.
350 /// We are not guaranteeing uniqueness for the RTTI string, so we
351 /// have to use string comparisons, but we also have to emit it with
352 /// non-hidden visibility.
356 /// Return the required visibility status for the given type and linkage in
359 classifyRTTIUniqueness(QualType CanTy,
360 llvm::GlobalValue::LinkageTypes Linkage) const;
361 friend class ItaniumRTTIBuilder;
363 void emitCXXStructor(const CXXMethodDecl *MD, StructorType Type) override;
366 bool hasAnyUsedVirtualInlineFunction(const CXXRecordDecl *RD) const {
367 const auto &VtableLayout =
368 CGM.getItaniumVTableContext().getVTableLayout(RD);
370 for (const auto &VtableComponent : VtableLayout.vtable_components()) {
371 if (!VtableComponent.isUsedFunctionPointerKind())
374 const CXXMethodDecl *Method = VtableComponent.getFunctionDecl();
375 if (Method->getCanonicalDecl()->isInlined())
381 bool isVTableHidden(const CXXRecordDecl *RD) const {
382 const auto &VtableLayout =
383 CGM.getItaniumVTableContext().getVTableLayout(RD);
385 for (const auto &VtableComponent : VtableLayout.vtable_components()) {
386 if (VtableComponent.isRTTIKind()) {
387 const CXXRecordDecl *RTTIDecl = VtableComponent.getRTTIDecl();
388 if (RTTIDecl->getVisibility() == Visibility::HiddenVisibility)
390 } else if (VtableComponent.isUsedFunctionPointerKind()) {
391 const CXXMethodDecl *Method = VtableComponent.getFunctionDecl();
392 if (Method->getVisibility() == Visibility::HiddenVisibility &&
393 !Method->isDefined())
401 class ARMCXXABI : public ItaniumCXXABI {
403 ARMCXXABI(CodeGen::CodeGenModule &CGM) :
404 ItaniumCXXABI(CGM, /* UseARMMethodPtrABI = */ true,
405 /* UseARMGuardVarABI = */ true) {}
407 bool HasThisReturn(GlobalDecl GD) const override {
408 return (isa<CXXConstructorDecl>(GD.getDecl()) || (
409 isa<CXXDestructorDecl>(GD.getDecl()) &&
410 GD.getDtorType() != Dtor_Deleting));
413 void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV,
414 QualType ResTy) override;
416 CharUnits getArrayCookieSizeImpl(QualType elementType) override;
417 Address InitializeArrayCookie(CodeGenFunction &CGF,
419 llvm::Value *NumElements,
420 const CXXNewExpr *expr,
421 QualType ElementType) override;
422 llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF, Address allocPtr,
423 CharUnits cookieSize) override;
426 class iOS64CXXABI : public ARMCXXABI {
428 iOS64CXXABI(CodeGen::CodeGenModule &CGM) : ARMCXXABI(CGM) {}
430 // ARM64 libraries are prepared for non-unique RTTI.
431 bool shouldRTTIBeUnique() const override { return false; }
434 class WebAssemblyCXXABI final : public ItaniumCXXABI {
436 explicit WebAssemblyCXXABI(CodeGen::CodeGenModule &CGM)
437 : ItaniumCXXABI(CGM, /*UseARMMethodPtrABI=*/true,
438 /*UseARMGuardVarABI=*/true) {}
441 bool HasThisReturn(GlobalDecl GD) const override {
442 return isa<CXXConstructorDecl>(GD.getDecl()) ||
443 (isa<CXXDestructorDecl>(GD.getDecl()) &&
444 GD.getDtorType() != Dtor_Deleting);
446 bool canCallMismatchedFunctionType() const override { return false; }
450 CodeGen::CGCXXABI *CodeGen::CreateItaniumCXXABI(CodeGenModule &CGM) {
451 switch (CGM.getTarget().getCXXABI().getKind()) {
452 // For IR-generation purposes, there's no significant difference
453 // between the ARM and iOS ABIs.
454 case TargetCXXABI::GenericARM:
455 case TargetCXXABI::iOS:
456 case TargetCXXABI::WatchOS:
457 return new ARMCXXABI(CGM);
459 case TargetCXXABI::iOS64:
460 return new iOS64CXXABI(CGM);
462 // Note that AArch64 uses the generic ItaniumCXXABI class since it doesn't
463 // include the other 32-bit ARM oddities: constructor/destructor return values
464 // and array cookies.
465 case TargetCXXABI::GenericAArch64:
466 return new ItaniumCXXABI(CGM, /* UseARMMethodPtrABI = */ true,
467 /* UseARMGuardVarABI = */ true);
469 case TargetCXXABI::GenericMIPS:
470 return new ItaniumCXXABI(CGM, /* UseARMMethodPtrABI = */ true);
472 case TargetCXXABI::WebAssembly:
473 return new WebAssemblyCXXABI(CGM);
475 case TargetCXXABI::GenericItanium:
476 if (CGM.getContext().getTargetInfo().getTriple().getArch()
477 == llvm::Triple::le32) {
478 // For PNaCl, use ARM-style method pointers so that PNaCl code
479 // does not assume anything about the alignment of function
481 return new ItaniumCXXABI(CGM, /* UseARMMethodPtrABI = */ true,
482 /* UseARMGuardVarABI = */ false);
484 return new ItaniumCXXABI(CGM);
486 case TargetCXXABI::Microsoft:
487 llvm_unreachable("Microsoft ABI is not Itanium-based");
489 llvm_unreachable("bad ABI kind");
493 ItaniumCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
494 if (MPT->isMemberDataPointer())
495 return CGM.PtrDiffTy;
496 return llvm::StructType::get(CGM.PtrDiffTy, CGM.PtrDiffTy, nullptr);
499 /// In the Itanium and ARM ABIs, method pointers have the form:
500 /// struct { ptrdiff_t ptr; ptrdiff_t adj; } memptr;
502 /// In the Itanium ABI:
503 /// - method pointers are virtual if (memptr.ptr & 1) is nonzero
504 /// - the this-adjustment is (memptr.adj)
505 /// - the virtual offset is (memptr.ptr - 1)
508 /// - method pointers are virtual if (memptr.adj & 1) is nonzero
509 /// - the this-adjustment is (memptr.adj >> 1)
510 /// - the virtual offset is (memptr.ptr)
511 /// ARM uses 'adj' for the virtual flag because Thumb functions
512 /// may be only single-byte aligned.
514 /// If the member is virtual, the adjusted 'this' pointer points
515 /// to a vtable pointer from which the virtual offset is applied.
517 /// If the member is non-virtual, memptr.ptr is the address of
518 /// the function to call.
519 llvm::Value *ItaniumCXXABI::EmitLoadOfMemberFunctionPointer(
520 CodeGenFunction &CGF, const Expr *E, Address ThisAddr,
521 llvm::Value *&ThisPtrForCall,
522 llvm::Value *MemFnPtr, const MemberPointerType *MPT) {
523 CGBuilderTy &Builder = CGF.Builder;
525 const FunctionProtoType *FPT =
526 MPT->getPointeeType()->getAs<FunctionProtoType>();
527 const CXXRecordDecl *RD =
528 cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
530 llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
531 CGM.getTypes().arrangeCXXMethodType(RD, FPT, /*FD=*/nullptr));
533 llvm::Constant *ptrdiff_1 = llvm::ConstantInt::get(CGM.PtrDiffTy, 1);
535 llvm::BasicBlock *FnVirtual = CGF.createBasicBlock("memptr.virtual");
536 llvm::BasicBlock *FnNonVirtual = CGF.createBasicBlock("memptr.nonvirtual");
537 llvm::BasicBlock *FnEnd = CGF.createBasicBlock("memptr.end");
539 // Extract memptr.adj, which is in the second field.
540 llvm::Value *RawAdj = Builder.CreateExtractValue(MemFnPtr, 1, "memptr.adj");
542 // Compute the true adjustment.
543 llvm::Value *Adj = RawAdj;
544 if (UseARMMethodPtrABI)
545 Adj = Builder.CreateAShr(Adj, ptrdiff_1, "memptr.adj.shifted");
547 // Apply the adjustment and cast back to the original struct type
549 llvm::Value *This = ThisAddr.getPointer();
550 llvm::Value *Ptr = Builder.CreateBitCast(This, Builder.getInt8PtrTy());
551 Ptr = Builder.CreateInBoundsGEP(Ptr, Adj);
552 This = Builder.CreateBitCast(Ptr, This->getType(), "this.adjusted");
553 ThisPtrForCall = This;
555 // Load the function pointer.
556 llvm::Value *FnAsInt = Builder.CreateExtractValue(MemFnPtr, 0, "memptr.ptr");
558 // If the LSB in the function pointer is 1, the function pointer points to
559 // a virtual function.
560 llvm::Value *IsVirtual;
561 if (UseARMMethodPtrABI)
562 IsVirtual = Builder.CreateAnd(RawAdj, ptrdiff_1);
564 IsVirtual = Builder.CreateAnd(FnAsInt, ptrdiff_1);
565 IsVirtual = Builder.CreateIsNotNull(IsVirtual, "memptr.isvirtual");
566 Builder.CreateCondBr(IsVirtual, FnVirtual, FnNonVirtual);
568 // In the virtual path, the adjustment left 'This' pointing to the
569 // vtable of the correct base subobject. The "function pointer" is an
570 // offset within the vtable (+1 for the virtual flag on non-ARM).
571 CGF.EmitBlock(FnVirtual);
573 // Cast the adjusted this to a pointer to vtable pointer and load.
574 llvm::Type *VTableTy = Builder.getInt8PtrTy();
575 CharUnits VTablePtrAlign =
576 CGF.CGM.getDynamicOffsetAlignment(ThisAddr.getAlignment(), RD,
577 CGF.getPointerAlign());
578 llvm::Value *VTable =
579 CGF.GetVTablePtr(Address(This, VTablePtrAlign), VTableTy, RD);
582 llvm::Value *VTableOffset = FnAsInt;
583 if (!UseARMMethodPtrABI)
584 VTableOffset = Builder.CreateSub(VTableOffset, ptrdiff_1);
585 VTable = Builder.CreateGEP(VTable, VTableOffset);
587 // Load the virtual function to call.
588 VTable = Builder.CreateBitCast(VTable, FTy->getPointerTo()->getPointerTo());
589 llvm::Value *VirtualFn =
590 Builder.CreateAlignedLoad(VTable, CGF.getPointerAlign(),
592 CGF.EmitBranch(FnEnd);
594 // In the non-virtual path, the function pointer is actually a
596 CGF.EmitBlock(FnNonVirtual);
597 llvm::Value *NonVirtualFn =
598 Builder.CreateIntToPtr(FnAsInt, FTy->getPointerTo(), "memptr.nonvirtualfn");
601 CGF.EmitBlock(FnEnd);
602 llvm::PHINode *Callee = Builder.CreatePHI(FTy->getPointerTo(), 2);
603 Callee->addIncoming(VirtualFn, FnVirtual);
604 Callee->addIncoming(NonVirtualFn, FnNonVirtual);
608 /// Compute an l-value by applying the given pointer-to-member to a
610 llvm::Value *ItaniumCXXABI::EmitMemberDataPointerAddress(
611 CodeGenFunction &CGF, const Expr *E, Address Base, llvm::Value *MemPtr,
612 const MemberPointerType *MPT) {
613 assert(MemPtr->getType() == CGM.PtrDiffTy);
615 CGBuilderTy &Builder = CGF.Builder;
618 Base = Builder.CreateElementBitCast(Base, CGF.Int8Ty);
620 // Apply the offset, which we assume is non-null.
622 Builder.CreateInBoundsGEP(Base.getPointer(), MemPtr, "memptr.offset");
624 // Cast the address to the appropriate pointer type, adopting the
625 // address space of the base pointer.
626 llvm::Type *PType = CGF.ConvertTypeForMem(MPT->getPointeeType())
627 ->getPointerTo(Base.getAddressSpace());
628 return Builder.CreateBitCast(Addr, PType);
631 /// Perform a bitcast, derived-to-base, or base-to-derived member pointer
634 /// Bitcast conversions are always a no-op under Itanium.
636 /// Obligatory offset/adjustment diagram:
637 /// <-- offset --> <-- adjustment -->
638 /// |--------------------------|----------------------|--------------------|
639 /// ^Derived address point ^Base address point ^Member address point
641 /// So when converting a base member pointer to a derived member pointer,
642 /// we add the offset to the adjustment because the address point has
643 /// decreased; and conversely, when converting a derived MP to a base MP
644 /// we subtract the offset from the adjustment because the address point
647 /// The standard forbids (at compile time) conversion to and from
648 /// virtual bases, which is why we don't have to consider them here.
650 /// The standard forbids (at run time) casting a derived MP to a base
651 /// MP when the derived MP does not point to a member of the base.
652 /// This is why -1 is a reasonable choice for null data member
655 ItaniumCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
658 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
659 E->getCastKind() == CK_BaseToDerivedMemberPointer ||
660 E->getCastKind() == CK_ReinterpretMemberPointer);
662 // Under Itanium, reinterprets don't require any additional processing.
663 if (E->getCastKind() == CK_ReinterpretMemberPointer) return src;
665 // Use constant emission if we can.
666 if (isa<llvm::Constant>(src))
667 return EmitMemberPointerConversion(E, cast<llvm::Constant>(src));
669 llvm::Constant *adj = getMemberPointerAdjustment(E);
670 if (!adj) return src;
672 CGBuilderTy &Builder = CGF.Builder;
673 bool isDerivedToBase = (E->getCastKind() == CK_DerivedToBaseMemberPointer);
675 const MemberPointerType *destTy =
676 E->getType()->castAs<MemberPointerType>();
678 // For member data pointers, this is just a matter of adding the
679 // offset if the source is non-null.
680 if (destTy->isMemberDataPointer()) {
683 dst = Builder.CreateNSWSub(src, adj, "adj");
685 dst = Builder.CreateNSWAdd(src, adj, "adj");
688 llvm::Value *null = llvm::Constant::getAllOnesValue(src->getType());
689 llvm::Value *isNull = Builder.CreateICmpEQ(src, null, "memptr.isnull");
690 return Builder.CreateSelect(isNull, src, dst);
693 // The this-adjustment is left-shifted by 1 on ARM.
694 if (UseARMMethodPtrABI) {
695 uint64_t offset = cast<llvm::ConstantInt>(adj)->getZExtValue();
697 adj = llvm::ConstantInt::get(adj->getType(), offset);
700 llvm::Value *srcAdj = Builder.CreateExtractValue(src, 1, "src.adj");
703 dstAdj = Builder.CreateNSWSub(srcAdj, adj, "adj");
705 dstAdj = Builder.CreateNSWAdd(srcAdj, adj, "adj");
707 return Builder.CreateInsertValue(src, dstAdj, 1);
711 ItaniumCXXABI::EmitMemberPointerConversion(const CastExpr *E,
712 llvm::Constant *src) {
713 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
714 E->getCastKind() == CK_BaseToDerivedMemberPointer ||
715 E->getCastKind() == CK_ReinterpretMemberPointer);
717 // Under Itanium, reinterprets don't require any additional processing.
718 if (E->getCastKind() == CK_ReinterpretMemberPointer) return src;
720 // If the adjustment is trivial, we don't need to do anything.
721 llvm::Constant *adj = getMemberPointerAdjustment(E);
722 if (!adj) return src;
724 bool isDerivedToBase = (E->getCastKind() == CK_DerivedToBaseMemberPointer);
726 const MemberPointerType *destTy =
727 E->getType()->castAs<MemberPointerType>();
729 // For member data pointers, this is just a matter of adding the
730 // offset if the source is non-null.
731 if (destTy->isMemberDataPointer()) {
732 // null maps to null.
733 if (src->isAllOnesValue()) return src;
736 return llvm::ConstantExpr::getNSWSub(src, adj);
738 return llvm::ConstantExpr::getNSWAdd(src, adj);
741 // The this-adjustment is left-shifted by 1 on ARM.
742 if (UseARMMethodPtrABI) {
743 uint64_t offset = cast<llvm::ConstantInt>(adj)->getZExtValue();
745 adj = llvm::ConstantInt::get(adj->getType(), offset);
748 llvm::Constant *srcAdj = llvm::ConstantExpr::getExtractValue(src, 1);
749 llvm::Constant *dstAdj;
751 dstAdj = llvm::ConstantExpr::getNSWSub(srcAdj, adj);
753 dstAdj = llvm::ConstantExpr::getNSWAdd(srcAdj, adj);
755 return llvm::ConstantExpr::getInsertValue(src, dstAdj, 1);
759 ItaniumCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
760 // Itanium C++ ABI 2.3:
761 // A NULL pointer is represented as -1.
762 if (MPT->isMemberDataPointer())
763 return llvm::ConstantInt::get(CGM.PtrDiffTy, -1ULL, /*isSigned=*/true);
765 llvm::Constant *Zero = llvm::ConstantInt::get(CGM.PtrDiffTy, 0);
766 llvm::Constant *Values[2] = { Zero, Zero };
767 return llvm::ConstantStruct::getAnon(Values);
771 ItaniumCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
773 // Itanium C++ ABI 2.3:
774 // A pointer to data member is an offset from the base address of
775 // the class object containing it, represented as a ptrdiff_t
776 return llvm::ConstantInt::get(CGM.PtrDiffTy, offset.getQuantity());
780 ItaniumCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) {
781 return BuildMemberPointer(MD, CharUnits::Zero());
784 llvm::Constant *ItaniumCXXABI::BuildMemberPointer(const CXXMethodDecl *MD,
785 CharUnits ThisAdjustment) {
786 assert(MD->isInstance() && "Member function must not be static!");
787 MD = MD->getCanonicalDecl();
789 CodeGenTypes &Types = CGM.getTypes();
791 // Get the function pointer (or index if this is a virtual function).
792 llvm::Constant *MemPtr[2];
793 if (MD->isVirtual()) {
794 uint64_t Index = CGM.getItaniumVTableContext().getMethodVTableIndex(MD);
796 const ASTContext &Context = getContext();
797 CharUnits PointerWidth =
798 Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
799 uint64_t VTableOffset = (Index * PointerWidth.getQuantity());
801 if (UseARMMethodPtrABI) {
802 // ARM C++ ABI 3.2.1:
803 // This ABI specifies that adj contains twice the this
804 // adjustment, plus 1 if the member function is virtual. The
805 // least significant bit of adj then makes exactly the same
806 // discrimination as the least significant bit of ptr does for
808 MemPtr[0] = llvm::ConstantInt::get(CGM.PtrDiffTy, VTableOffset);
809 MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
810 2 * ThisAdjustment.getQuantity() + 1);
812 // Itanium C++ ABI 2.3:
813 // For a virtual function, [the pointer field] is 1 plus the
814 // virtual table offset (in bytes) of the function,
815 // represented as a ptrdiff_t.
816 MemPtr[0] = llvm::ConstantInt::get(CGM.PtrDiffTy, VTableOffset + 1);
817 MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
818 ThisAdjustment.getQuantity());
821 const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
823 // Check whether the function has a computable LLVM signature.
824 if (Types.isFuncTypeConvertible(FPT)) {
825 // The function has a computable LLVM signature; use the correct type.
826 Ty = Types.GetFunctionType(Types.arrangeCXXMethodDeclaration(MD));
828 // Use an arbitrary non-function type to tell GetAddrOfFunction that the
829 // function type is incomplete.
832 llvm::Constant *addr = CGM.GetAddrOfFunction(MD, Ty);
834 MemPtr[0] = llvm::ConstantExpr::getPtrToInt(addr, CGM.PtrDiffTy);
835 MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
836 (UseARMMethodPtrABI ? 2 : 1) *
837 ThisAdjustment.getQuantity());
840 return llvm::ConstantStruct::getAnon(MemPtr);
843 llvm::Constant *ItaniumCXXABI::EmitMemberPointer(const APValue &MP,
845 const MemberPointerType *MPT = MPType->castAs<MemberPointerType>();
846 const ValueDecl *MPD = MP.getMemberPointerDecl();
848 return EmitNullMemberPointer(MPT);
850 CharUnits ThisAdjustment = getMemberPointerPathAdjustment(MP);
852 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MPD))
853 return BuildMemberPointer(MD, ThisAdjustment);
855 CharUnits FieldOffset =
856 getContext().toCharUnitsFromBits(getContext().getFieldOffset(MPD));
857 return EmitMemberDataPointer(MPT, ThisAdjustment + FieldOffset);
860 /// The comparison algorithm is pretty easy: the member pointers are
861 /// the same if they're either bitwise identical *or* both null.
863 /// ARM is different here only because null-ness is more complicated.
865 ItaniumCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
868 const MemberPointerType *MPT,
870 CGBuilderTy &Builder = CGF.Builder;
872 llvm::ICmpInst::Predicate Eq;
873 llvm::Instruction::BinaryOps And, Or;
875 Eq = llvm::ICmpInst::ICMP_NE;
876 And = llvm::Instruction::Or;
877 Or = llvm::Instruction::And;
879 Eq = llvm::ICmpInst::ICMP_EQ;
880 And = llvm::Instruction::And;
881 Or = llvm::Instruction::Or;
884 // Member data pointers are easy because there's a unique null
885 // value, so it just comes down to bitwise equality.
886 if (MPT->isMemberDataPointer())
887 return Builder.CreateICmp(Eq, L, R);
889 // For member function pointers, the tautologies are more complex.
890 // The Itanium tautology is:
891 // (L == R) <==> (L.ptr == R.ptr && (L.ptr == 0 || L.adj == R.adj))
892 // The ARM tautology is:
893 // (L == R) <==> (L.ptr == R.ptr &&
894 // (L.adj == R.adj ||
895 // (L.ptr == 0 && ((L.adj|R.adj) & 1) == 0)))
896 // The inequality tautologies have exactly the same structure, except
897 // applying De Morgan's laws.
899 llvm::Value *LPtr = Builder.CreateExtractValue(L, 0, "lhs.memptr.ptr");
900 llvm::Value *RPtr = Builder.CreateExtractValue(R, 0, "rhs.memptr.ptr");
902 // This condition tests whether L.ptr == R.ptr. This must always be
903 // true for equality to hold.
904 llvm::Value *PtrEq = Builder.CreateICmp(Eq, LPtr, RPtr, "cmp.ptr");
906 // This condition, together with the assumption that L.ptr == R.ptr,
907 // tests whether the pointers are both null. ARM imposes an extra
909 llvm::Value *Zero = llvm::Constant::getNullValue(LPtr->getType());
910 llvm::Value *EqZero = Builder.CreateICmp(Eq, LPtr, Zero, "cmp.ptr.null");
912 // This condition tests whether L.adj == R.adj. If this isn't
913 // true, the pointers are unequal unless they're both null.
914 llvm::Value *LAdj = Builder.CreateExtractValue(L, 1, "lhs.memptr.adj");
915 llvm::Value *RAdj = Builder.CreateExtractValue(R, 1, "rhs.memptr.adj");
916 llvm::Value *AdjEq = Builder.CreateICmp(Eq, LAdj, RAdj, "cmp.adj");
918 // Null member function pointers on ARM clear the low bit of Adj,
919 // so the zero condition has to check that neither low bit is set.
920 if (UseARMMethodPtrABI) {
921 llvm::Value *One = llvm::ConstantInt::get(LPtr->getType(), 1);
923 // Compute (l.adj | r.adj) & 1 and test it against zero.
924 llvm::Value *OrAdj = Builder.CreateOr(LAdj, RAdj, "or.adj");
925 llvm::Value *OrAdjAnd1 = Builder.CreateAnd(OrAdj, One);
926 llvm::Value *OrAdjAnd1EqZero = Builder.CreateICmp(Eq, OrAdjAnd1, Zero,
928 EqZero = Builder.CreateBinOp(And, EqZero, OrAdjAnd1EqZero);
931 // Tie together all our conditions.
932 llvm::Value *Result = Builder.CreateBinOp(Or, EqZero, AdjEq);
933 Result = Builder.CreateBinOp(And, PtrEq, Result,
934 Inequality ? "memptr.ne" : "memptr.eq");
939 ItaniumCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
941 const MemberPointerType *MPT) {
942 CGBuilderTy &Builder = CGF.Builder;
944 /// For member data pointers, this is just a check against -1.
945 if (MPT->isMemberDataPointer()) {
946 assert(MemPtr->getType() == CGM.PtrDiffTy);
947 llvm::Value *NegativeOne =
948 llvm::Constant::getAllOnesValue(MemPtr->getType());
949 return Builder.CreateICmpNE(MemPtr, NegativeOne, "memptr.tobool");
952 // In Itanium, a member function pointer is not null if 'ptr' is not null.
953 llvm::Value *Ptr = Builder.CreateExtractValue(MemPtr, 0, "memptr.ptr");
955 llvm::Constant *Zero = llvm::ConstantInt::get(Ptr->getType(), 0);
956 llvm::Value *Result = Builder.CreateICmpNE(Ptr, Zero, "memptr.tobool");
958 // On ARM, a member function pointer is also non-null if the low bit of 'adj'
959 // (the virtual bit) is set.
960 if (UseARMMethodPtrABI) {
961 llvm::Constant *One = llvm::ConstantInt::get(Ptr->getType(), 1);
962 llvm::Value *Adj = Builder.CreateExtractValue(MemPtr, 1, "memptr.adj");
963 llvm::Value *VirtualBit = Builder.CreateAnd(Adj, One, "memptr.virtualbit");
964 llvm::Value *IsVirtual = Builder.CreateICmpNE(VirtualBit, Zero,
966 Result = Builder.CreateOr(Result, IsVirtual);
972 bool ItaniumCXXABI::classifyReturnType(CGFunctionInfo &FI) const {
973 const CXXRecordDecl *RD = FI.getReturnType()->getAsCXXRecordDecl();
977 // Return indirectly if we have a non-trivial copy ctor or non-trivial dtor.
978 // FIXME: Use canCopyArgument() when it is fixed to handle lazily declared
980 if (RD->hasNonTrivialDestructor() || RD->hasNonTrivialCopyConstructor()) {
981 auto Align = CGM.getContext().getTypeAlignInChars(FI.getReturnType());
982 FI.getReturnInfo() = ABIArgInfo::getIndirect(Align, /*ByVal=*/false);
988 /// The Itanium ABI requires non-zero initialization only for data
989 /// member pointers, for which '0' is a valid offset.
990 bool ItaniumCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
991 return MPT->isMemberFunctionPointer();
994 /// The Itanium ABI always places an offset to the complete object
995 /// at entry -2 in the vtable.
996 void ItaniumCXXABI::emitVirtualObjectDelete(CodeGenFunction &CGF,
997 const CXXDeleteExpr *DE,
999 QualType ElementType,
1000 const CXXDestructorDecl *Dtor) {
1001 bool UseGlobalDelete = DE->isGlobalDelete();
1002 if (UseGlobalDelete) {
1003 // Derive the complete-object pointer, which is what we need
1004 // to pass to the deallocation function.
1006 // Grab the vtable pointer as an intptr_t*.
1008 cast<CXXRecordDecl>(ElementType->getAs<RecordType>()->getDecl());
1009 llvm::Value *VTable =
1010 CGF.GetVTablePtr(Ptr, CGF.IntPtrTy->getPointerTo(), ClassDecl);
1012 // Track back to entry -2 and pull out the offset there.
1013 llvm::Value *OffsetPtr = CGF.Builder.CreateConstInBoundsGEP1_64(
1014 VTable, -2, "complete-offset.ptr");
1015 llvm::Value *Offset =
1016 CGF.Builder.CreateAlignedLoad(OffsetPtr, CGF.getPointerAlign());
1018 // Apply the offset.
1019 llvm::Value *CompletePtr =
1020 CGF.Builder.CreateBitCast(Ptr.getPointer(), CGF.Int8PtrTy);
1021 CompletePtr = CGF.Builder.CreateInBoundsGEP(CompletePtr, Offset);
1023 // If we're supposed to call the global delete, make sure we do so
1024 // even if the destructor throws.
1025 CGF.pushCallObjectDeleteCleanup(DE->getOperatorDelete(), CompletePtr,
1029 // FIXME: Provide a source location here even though there's no
1030 // CXXMemberCallExpr for dtor call.
1031 CXXDtorType DtorType = UseGlobalDelete ? Dtor_Complete : Dtor_Deleting;
1032 EmitVirtualDestructorCall(CGF, Dtor, DtorType, Ptr, /*CE=*/nullptr);
1034 if (UseGlobalDelete)
1035 CGF.PopCleanupBlock();
1038 void ItaniumCXXABI::emitRethrow(CodeGenFunction &CGF, bool isNoReturn) {
1039 // void __cxa_rethrow();
1041 llvm::FunctionType *FTy =
1042 llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false);
1044 llvm::Constant *Fn = CGM.CreateRuntimeFunction(FTy, "__cxa_rethrow");
1047 CGF.EmitNoreturnRuntimeCallOrInvoke(Fn, None);
1049 CGF.EmitRuntimeCallOrInvoke(Fn);
1052 static llvm::Constant *getAllocateExceptionFn(CodeGenModule &CGM) {
1053 // void *__cxa_allocate_exception(size_t thrown_size);
1055 llvm::FunctionType *FTy =
1056 llvm::FunctionType::get(CGM.Int8PtrTy, CGM.SizeTy, /*IsVarArgs=*/false);
1058 return CGM.CreateRuntimeFunction(FTy, "__cxa_allocate_exception");
1061 static llvm::Constant *getThrowFn(CodeGenModule &CGM) {
1062 // void __cxa_throw(void *thrown_exception, std::type_info *tinfo,
1063 // void (*dest) (void *));
1065 llvm::Type *Args[3] = { CGM.Int8PtrTy, CGM.Int8PtrTy, CGM.Int8PtrTy };
1066 llvm::FunctionType *FTy =
1067 llvm::FunctionType::get(CGM.VoidTy, Args, /*IsVarArgs=*/false);
1069 return CGM.CreateRuntimeFunction(FTy, "__cxa_throw");
1072 void ItaniumCXXABI::emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) {
1073 QualType ThrowType = E->getSubExpr()->getType();
1074 // Now allocate the exception object.
1075 llvm::Type *SizeTy = CGF.ConvertType(getContext().getSizeType());
1076 uint64_t TypeSize = getContext().getTypeSizeInChars(ThrowType).getQuantity();
1078 llvm::Constant *AllocExceptionFn = getAllocateExceptionFn(CGM);
1079 llvm::CallInst *ExceptionPtr = CGF.EmitNounwindRuntimeCall(
1080 AllocExceptionFn, llvm::ConstantInt::get(SizeTy, TypeSize), "exception");
1082 CharUnits ExnAlign = getAlignmentOfExnObject();
1083 CGF.EmitAnyExprToExn(E->getSubExpr(), Address(ExceptionPtr, ExnAlign));
1085 // Now throw the exception.
1086 llvm::Constant *TypeInfo = CGM.GetAddrOfRTTIDescriptor(ThrowType,
1089 // The address of the destructor. If the exception type has a
1090 // trivial destructor (or isn't a record), we just pass null.
1091 llvm::Constant *Dtor = nullptr;
1092 if (const RecordType *RecordTy = ThrowType->getAs<RecordType>()) {
1093 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordTy->getDecl());
1094 if (!Record->hasTrivialDestructor()) {
1095 CXXDestructorDecl *DtorD = Record->getDestructor();
1096 Dtor = CGM.getAddrOfCXXStructor(DtorD, StructorType::Complete);
1097 Dtor = llvm::ConstantExpr::getBitCast(Dtor, CGM.Int8PtrTy);
1100 if (!Dtor) Dtor = llvm::Constant::getNullValue(CGM.Int8PtrTy);
1102 llvm::Value *args[] = { ExceptionPtr, TypeInfo, Dtor };
1103 CGF.EmitNoreturnRuntimeCallOrInvoke(getThrowFn(CGM), args);
1106 static llvm::Constant *getItaniumDynamicCastFn(CodeGenFunction &CGF) {
1107 // void *__dynamic_cast(const void *sub,
1108 // const abi::__class_type_info *src,
1109 // const abi::__class_type_info *dst,
1110 // std::ptrdiff_t src2dst_offset);
1112 llvm::Type *Int8PtrTy = CGF.Int8PtrTy;
1113 llvm::Type *PtrDiffTy =
1114 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1116 llvm::Type *Args[4] = { Int8PtrTy, Int8PtrTy, Int8PtrTy, PtrDiffTy };
1118 llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, Args, false);
1120 // Mark the function as nounwind readonly.
1121 llvm::Attribute::AttrKind FuncAttrs[] = { llvm::Attribute::NoUnwind,
1122 llvm::Attribute::ReadOnly };
1123 llvm::AttributeSet Attrs = llvm::AttributeSet::get(
1124 CGF.getLLVMContext(), llvm::AttributeSet::FunctionIndex, FuncAttrs);
1126 return CGF.CGM.CreateRuntimeFunction(FTy, "__dynamic_cast", Attrs);
1129 static llvm::Constant *getBadCastFn(CodeGenFunction &CGF) {
1130 // void __cxa_bad_cast();
1131 llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
1132 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_cast");
1135 /// \brief Compute the src2dst_offset hint as described in the
1136 /// Itanium C++ ABI [2.9.7]
1137 static CharUnits computeOffsetHint(ASTContext &Context,
1138 const CXXRecordDecl *Src,
1139 const CXXRecordDecl *Dst) {
1140 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1141 /*DetectVirtual=*/false);
1143 // If Dst is not derived from Src we can skip the whole computation below and
1144 // return that Src is not a public base of Dst. Record all inheritance paths.
1145 if (!Dst->isDerivedFrom(Src, Paths))
1146 return CharUnits::fromQuantity(-2ULL);
1148 unsigned NumPublicPaths = 0;
1151 // Now walk all possible inheritance paths.
1152 for (const CXXBasePath &Path : Paths) {
1153 if (Path.Access != AS_public) // Ignore non-public inheritance.
1158 for (const CXXBasePathElement &PathElement : Path) {
1159 // If the path contains a virtual base class we can't give any hint.
1161 if (PathElement.Base->isVirtual())
1162 return CharUnits::fromQuantity(-1ULL);
1164 if (NumPublicPaths > 1) // Won't use offsets, skip computation.
1167 // Accumulate the base class offsets.
1168 const ASTRecordLayout &L = Context.getASTRecordLayout(PathElement.Class);
1169 Offset += L.getBaseClassOffset(
1170 PathElement.Base->getType()->getAsCXXRecordDecl());
1174 // -2: Src is not a public base of Dst.
1175 if (NumPublicPaths == 0)
1176 return CharUnits::fromQuantity(-2ULL);
1178 // -3: Src is a multiple public base type but never a virtual base type.
1179 if (NumPublicPaths > 1)
1180 return CharUnits::fromQuantity(-3ULL);
1182 // Otherwise, the Src type is a unique public nonvirtual base type of Dst.
1183 // Return the offset of Src from the origin of Dst.
1187 static llvm::Constant *getBadTypeidFn(CodeGenFunction &CGF) {
1188 // void __cxa_bad_typeid();
1189 llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
1191 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_typeid");
1194 bool ItaniumCXXABI::shouldTypeidBeNullChecked(bool IsDeref,
1195 QualType SrcRecordTy) {
1199 void ItaniumCXXABI::EmitBadTypeidCall(CodeGenFunction &CGF) {
1200 llvm::Value *Fn = getBadTypeidFn(CGF);
1201 CGF.EmitRuntimeCallOrInvoke(Fn).setDoesNotReturn();
1202 CGF.Builder.CreateUnreachable();
1205 llvm::Value *ItaniumCXXABI::EmitTypeid(CodeGenFunction &CGF,
1206 QualType SrcRecordTy,
1208 llvm::Type *StdTypeInfoPtrTy) {
1210 cast<CXXRecordDecl>(SrcRecordTy->getAs<RecordType>()->getDecl());
1211 llvm::Value *Value =
1212 CGF.GetVTablePtr(ThisPtr, StdTypeInfoPtrTy->getPointerTo(), ClassDecl);
1214 // Load the type info.
1215 Value = CGF.Builder.CreateConstInBoundsGEP1_64(Value, -1ULL);
1216 return CGF.Builder.CreateAlignedLoad(Value, CGF.getPointerAlign());
1219 bool ItaniumCXXABI::shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
1220 QualType SrcRecordTy) {
1224 llvm::Value *ItaniumCXXABI::EmitDynamicCastCall(
1225 CodeGenFunction &CGF, Address ThisAddr, QualType SrcRecordTy,
1226 QualType DestTy, QualType DestRecordTy, llvm::BasicBlock *CastEnd) {
1227 llvm::Type *PtrDiffLTy =
1228 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1229 llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1231 llvm::Value *SrcRTTI =
1232 CGF.CGM.GetAddrOfRTTIDescriptor(SrcRecordTy.getUnqualifiedType());
1233 llvm::Value *DestRTTI =
1234 CGF.CGM.GetAddrOfRTTIDescriptor(DestRecordTy.getUnqualifiedType());
1236 // Compute the offset hint.
1237 const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl();
1238 const CXXRecordDecl *DestDecl = DestRecordTy->getAsCXXRecordDecl();
1239 llvm::Value *OffsetHint = llvm::ConstantInt::get(
1241 computeOffsetHint(CGF.getContext(), SrcDecl, DestDecl).getQuantity());
1243 // Emit the call to __dynamic_cast.
1244 llvm::Value *Value = ThisAddr.getPointer();
1245 Value = CGF.EmitCastToVoidPtr(Value);
1247 llvm::Value *args[] = {Value, SrcRTTI, DestRTTI, OffsetHint};
1248 Value = CGF.EmitNounwindRuntimeCall(getItaniumDynamicCastFn(CGF), args);
1249 Value = CGF.Builder.CreateBitCast(Value, DestLTy);
1251 /// C++ [expr.dynamic.cast]p9:
1252 /// A failed cast to reference type throws std::bad_cast
1253 if (DestTy->isReferenceType()) {
1254 llvm::BasicBlock *BadCastBlock =
1255 CGF.createBasicBlock("dynamic_cast.bad_cast");
1257 llvm::Value *IsNull = CGF.Builder.CreateIsNull(Value);
1258 CGF.Builder.CreateCondBr(IsNull, BadCastBlock, CastEnd);
1260 CGF.EmitBlock(BadCastBlock);
1261 EmitBadCastCall(CGF);
1267 llvm::Value *ItaniumCXXABI::EmitDynamicCastToVoid(CodeGenFunction &CGF,
1269 QualType SrcRecordTy,
1271 llvm::Type *PtrDiffLTy =
1272 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1273 llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1276 cast<CXXRecordDecl>(SrcRecordTy->getAs<RecordType>()->getDecl());
1277 // Get the vtable pointer.
1278 llvm::Value *VTable = CGF.GetVTablePtr(ThisAddr, PtrDiffLTy->getPointerTo(),
1281 // Get the offset-to-top from the vtable.
1282 llvm::Value *OffsetToTop =
1283 CGF.Builder.CreateConstInBoundsGEP1_64(VTable, -2ULL);
1285 CGF.Builder.CreateAlignedLoad(OffsetToTop, CGF.getPointerAlign(),
1288 // Finally, add the offset to the pointer.
1289 llvm::Value *Value = ThisAddr.getPointer();
1290 Value = CGF.EmitCastToVoidPtr(Value);
1291 Value = CGF.Builder.CreateInBoundsGEP(Value, OffsetToTop);
1293 return CGF.Builder.CreateBitCast(Value, DestLTy);
1296 bool ItaniumCXXABI::EmitBadCastCall(CodeGenFunction &CGF) {
1297 llvm::Value *Fn = getBadCastFn(CGF);
1298 CGF.EmitRuntimeCallOrInvoke(Fn).setDoesNotReturn();
1299 CGF.Builder.CreateUnreachable();
1304 ItaniumCXXABI::GetVirtualBaseClassOffset(CodeGenFunction &CGF,
1306 const CXXRecordDecl *ClassDecl,
1307 const CXXRecordDecl *BaseClassDecl) {
1308 llvm::Value *VTablePtr = CGF.GetVTablePtr(This, CGM.Int8PtrTy, ClassDecl);
1309 CharUnits VBaseOffsetOffset =
1310 CGM.getItaniumVTableContext().getVirtualBaseOffsetOffset(ClassDecl,
1313 llvm::Value *VBaseOffsetPtr =
1314 CGF.Builder.CreateConstGEP1_64(VTablePtr, VBaseOffsetOffset.getQuantity(),
1315 "vbase.offset.ptr");
1316 VBaseOffsetPtr = CGF.Builder.CreateBitCast(VBaseOffsetPtr,
1317 CGM.PtrDiffTy->getPointerTo());
1319 llvm::Value *VBaseOffset =
1320 CGF.Builder.CreateAlignedLoad(VBaseOffsetPtr, CGF.getPointerAlign(),
1326 void ItaniumCXXABI::EmitCXXConstructors(const CXXConstructorDecl *D) {
1327 // Just make sure we're in sync with TargetCXXABI.
1328 assert(CGM.getTarget().getCXXABI().hasConstructorVariants());
1330 // The constructor used for constructing this as a base class;
1331 // ignores virtual bases.
1332 CGM.EmitGlobal(GlobalDecl(D, Ctor_Base));
1334 // The constructor used for constructing this as a complete class;
1335 // constructs the virtual bases, then calls the base constructor.
1336 if (!D->getParent()->isAbstract()) {
1337 // We don't need to emit the complete ctor if the class is abstract.
1338 CGM.EmitGlobal(GlobalDecl(D, Ctor_Complete));
1343 ItaniumCXXABI::buildStructorSignature(const CXXMethodDecl *MD, StructorType T,
1344 SmallVectorImpl<CanQualType> &ArgTys) {
1345 ASTContext &Context = getContext();
1347 // All parameters are already in place except VTT, which goes after 'this'.
1348 // These are Clang types, so we don't need to worry about sret yet.
1350 // Check if we need to add a VTT parameter (which has type void **).
1351 if (T == StructorType::Base && MD->getParent()->getNumVBases() != 0)
1352 ArgTys.insert(ArgTys.begin() + 1,
1353 Context.getPointerType(Context.VoidPtrTy));
1356 void ItaniumCXXABI::EmitCXXDestructors(const CXXDestructorDecl *D) {
1357 // The destructor used for destructing this as a base class; ignores
1359 CGM.EmitGlobal(GlobalDecl(D, Dtor_Base));
1361 // The destructor used for destructing this as a most-derived class;
1362 // call the base destructor and then destructs any virtual bases.
1363 CGM.EmitGlobal(GlobalDecl(D, Dtor_Complete));
1365 // The destructor in a virtual table is always a 'deleting'
1366 // destructor, which calls the complete destructor and then uses the
1367 // appropriate operator delete.
1369 CGM.EmitGlobal(GlobalDecl(D, Dtor_Deleting));
1372 void ItaniumCXXABI::addImplicitStructorParams(CodeGenFunction &CGF,
1374 FunctionArgList &Params) {
1375 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
1376 assert(isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD));
1378 // Check if we need a VTT parameter as well.
1379 if (NeedsVTTParameter(CGF.CurGD)) {
1380 ASTContext &Context = getContext();
1382 // FIXME: avoid the fake decl
1383 QualType T = Context.getPointerType(Context.VoidPtrTy);
1384 ImplicitParamDecl *VTTDecl
1385 = ImplicitParamDecl::Create(Context, nullptr, MD->getLocation(),
1386 &Context.Idents.get("vtt"), T);
1387 Params.insert(Params.begin() + 1, VTTDecl);
1388 getStructorImplicitParamDecl(CGF) = VTTDecl;
1392 void ItaniumCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
1393 /// Initialize the 'this' slot.
1396 /// Initialize the 'vtt' slot if needed.
1397 if (getStructorImplicitParamDecl(CGF)) {
1398 getStructorImplicitParamValue(CGF) = CGF.Builder.CreateLoad(
1399 CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)), "vtt");
1402 /// If this is a function that the ABI specifies returns 'this', initialize
1403 /// the return slot to 'this' at the start of the function.
1405 /// Unlike the setting of return types, this is done within the ABI
1406 /// implementation instead of by clients of CGCXXABI because:
1407 /// 1) getThisValue is currently protected
1408 /// 2) in theory, an ABI could implement 'this' returns some other way;
1409 /// HasThisReturn only specifies a contract, not the implementation
1410 if (HasThisReturn(CGF.CurGD))
1411 CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
1414 unsigned ItaniumCXXABI::addImplicitConstructorArgs(
1415 CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type,
1416 bool ForVirtualBase, bool Delegating, CallArgList &Args) {
1417 if (!NeedsVTTParameter(GlobalDecl(D, Type)))
1420 // Insert the implicit 'vtt' argument as the second argument.
1422 CGF.GetVTTParameter(GlobalDecl(D, Type), ForVirtualBase, Delegating);
1423 QualType VTTTy = getContext().getPointerType(getContext().VoidPtrTy);
1424 Args.insert(Args.begin() + 1,
1425 CallArg(RValue::get(VTT), VTTTy, /*needscopy=*/false));
1426 return 1; // Added one arg.
1429 void ItaniumCXXABI::EmitDestructorCall(CodeGenFunction &CGF,
1430 const CXXDestructorDecl *DD,
1431 CXXDtorType Type, bool ForVirtualBase,
1432 bool Delegating, Address This) {
1433 GlobalDecl GD(DD, Type);
1434 llvm::Value *VTT = CGF.GetVTTParameter(GD, ForVirtualBase, Delegating);
1435 QualType VTTTy = getContext().getPointerType(getContext().VoidPtrTy);
1437 llvm::Value *Callee = nullptr;
1438 if (getContext().getLangOpts().AppleKext)
1439 Callee = CGF.BuildAppleKextVirtualDestructorCall(DD, Type, DD->getParent());
1442 Callee = CGM.getAddrOfCXXStructor(DD, getFromDtorType(Type));
1444 CGF.EmitCXXMemberOrOperatorCall(DD, Callee, ReturnValueSlot(),
1445 This.getPointer(), VTT, VTTTy, nullptr);
1448 void ItaniumCXXABI::emitVTableDefinitions(CodeGenVTables &CGVT,
1449 const CXXRecordDecl *RD) {
1450 llvm::GlobalVariable *VTable = getAddrOfVTable(RD, CharUnits());
1451 if (VTable->hasInitializer())
1454 ItaniumVTableContext &VTContext = CGM.getItaniumVTableContext();
1455 const VTableLayout &VTLayout = VTContext.getVTableLayout(RD);
1456 llvm::GlobalVariable::LinkageTypes Linkage = CGM.getVTableLinkage(RD);
1457 llvm::Constant *RTTI =
1458 CGM.GetAddrOfRTTIDescriptor(CGM.getContext().getTagDeclType(RD));
1460 // Create and set the initializer.
1461 llvm::Constant *Init = CGVT.CreateVTableInitializer(
1462 RD, VTLayout.vtable_component_begin(), VTLayout.getNumVTableComponents(),
1463 VTLayout.vtable_thunk_begin(), VTLayout.getNumVTableThunks(), RTTI);
1464 VTable->setInitializer(Init);
1466 // Set the correct linkage.
1467 VTable->setLinkage(Linkage);
1469 if (CGM.supportsCOMDAT() && VTable->isWeakForLinker())
1470 VTable->setComdat(CGM.getModule().getOrInsertComdat(VTable->getName()));
1472 // Set the right visibility.
1473 CGM.setGlobalVisibility(VTable, RD);
1475 // Use pointer alignment for the vtable. Otherwise we would align them based
1476 // on the size of the initializer which doesn't make sense as only single
1478 unsigned PAlign = CGM.getTarget().getPointerAlign(0);
1479 VTable->setAlignment(getContext().toCharUnitsFromBits(PAlign).getQuantity());
1481 // If this is the magic class __cxxabiv1::__fundamental_type_info,
1482 // we will emit the typeinfo for the fundamental types. This is the
1483 // same behaviour as GCC.
1484 const DeclContext *DC = RD->getDeclContext();
1485 if (RD->getIdentifier() &&
1486 RD->getIdentifier()->isStr("__fundamental_type_info") &&
1487 isa<NamespaceDecl>(DC) && cast<NamespaceDecl>(DC)->getIdentifier() &&
1488 cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__cxxabiv1") &&
1489 DC->getParent()->isTranslationUnit())
1490 EmitFundamentalRTTIDescriptors();
1492 if (!VTable->isDeclarationForLinker())
1493 CGM.EmitVTableTypeMetadata(VTable, VTLayout);
1496 bool ItaniumCXXABI::isVirtualOffsetNeededForVTableField(
1497 CodeGenFunction &CGF, CodeGenFunction::VPtr Vptr) {
1498 if (Vptr.NearestVBase == nullptr)
1500 return NeedsVTTParameter(CGF.CurGD);
1503 llvm::Value *ItaniumCXXABI::getVTableAddressPointInStructor(
1504 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
1505 const CXXRecordDecl *NearestVBase) {
1507 if ((Base.getBase()->getNumVBases() || NearestVBase != nullptr) &&
1508 NeedsVTTParameter(CGF.CurGD)) {
1509 return getVTableAddressPointInStructorWithVTT(CGF, VTableClass, Base,
1512 return getVTableAddressPoint(Base, VTableClass);
1516 ItaniumCXXABI::getVTableAddressPoint(BaseSubobject Base,
1517 const CXXRecordDecl *VTableClass) {
1518 llvm::GlobalValue *VTable = getAddrOfVTable(VTableClass, CharUnits());
1520 // Find the appropriate vtable within the vtable group.
1521 uint64_t AddressPoint = CGM.getItaniumVTableContext()
1522 .getVTableLayout(VTableClass)
1523 .getAddressPoint(Base);
1524 llvm::Value *Indices[] = {
1525 llvm::ConstantInt::get(CGM.Int32Ty, 0),
1526 llvm::ConstantInt::get(CGM.Int32Ty, AddressPoint)
1529 return llvm::ConstantExpr::getInBoundsGetElementPtr(VTable->getValueType(),
1533 llvm::Value *ItaniumCXXABI::getVTableAddressPointInStructorWithVTT(
1534 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
1535 const CXXRecordDecl *NearestVBase) {
1536 assert((Base.getBase()->getNumVBases() || NearestVBase != nullptr) &&
1537 NeedsVTTParameter(CGF.CurGD) && "This class doesn't have VTT");
1539 // Get the secondary vpointer index.
1540 uint64_t VirtualPointerIndex =
1541 CGM.getVTables().getSecondaryVirtualPointerIndex(VTableClass, Base);
1544 llvm::Value *VTT = CGF.LoadCXXVTT();
1545 if (VirtualPointerIndex)
1546 VTT = CGF.Builder.CreateConstInBoundsGEP1_64(VTT, VirtualPointerIndex);
1548 // And load the address point from the VTT.
1549 return CGF.Builder.CreateAlignedLoad(VTT, CGF.getPointerAlign());
1552 llvm::Constant *ItaniumCXXABI::getVTableAddressPointForConstExpr(
1553 BaseSubobject Base, const CXXRecordDecl *VTableClass) {
1554 return getVTableAddressPoint(Base, VTableClass);
1557 llvm::GlobalVariable *ItaniumCXXABI::getAddrOfVTable(const CXXRecordDecl *RD,
1558 CharUnits VPtrOffset) {
1559 assert(VPtrOffset.isZero() && "Itanium ABI only supports zero vptr offsets");
1561 llvm::GlobalVariable *&VTable = VTables[RD];
1565 // Queue up this vtable for possible deferred emission.
1566 CGM.addDeferredVTable(RD);
1568 SmallString<256> Name;
1569 llvm::raw_svector_ostream Out(Name);
1570 getMangleContext().mangleCXXVTable(RD, Out);
1572 ItaniumVTableContext &VTContext = CGM.getItaniumVTableContext();
1573 llvm::ArrayType *ArrayType = llvm::ArrayType::get(
1574 CGM.Int8PtrTy, VTContext.getVTableLayout(RD).getNumVTableComponents());
1576 VTable = CGM.CreateOrReplaceCXXRuntimeVariable(
1577 Name, ArrayType, llvm::GlobalValue::ExternalLinkage);
1578 VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1580 if (RD->hasAttr<DLLImportAttr>())
1581 VTable->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
1582 else if (RD->hasAttr<DLLExportAttr>())
1583 VTable->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
1588 llvm::Value *ItaniumCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF,
1592 SourceLocation Loc) {
1593 GD = GD.getCanonicalDecl();
1594 Ty = Ty->getPointerTo()->getPointerTo();
1595 auto *MethodDecl = cast<CXXMethodDecl>(GD.getDecl());
1596 llvm::Value *VTable = CGF.GetVTablePtr(This, Ty, MethodDecl->getParent());
1598 uint64_t VTableIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(GD);
1599 if (CGF.ShouldEmitVTableTypeCheckedLoad(MethodDecl->getParent())) {
1600 return CGF.EmitVTableTypeCheckedLoad(
1601 MethodDecl->getParent(), VTable,
1602 VTableIndex * CGM.getContext().getTargetInfo().getPointerWidth(0) / 8);
1604 CGF.EmitTypeMetadataCodeForVCall(MethodDecl->getParent(), VTable, Loc);
1606 llvm::Value *VFuncPtr =
1607 CGF.Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfn");
1608 return CGF.Builder.CreateAlignedLoad(VFuncPtr, CGF.getPointerAlign());
1612 llvm::Value *ItaniumCXXABI::EmitVirtualDestructorCall(
1613 CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType,
1614 Address This, const CXXMemberCallExpr *CE) {
1615 assert(CE == nullptr || CE->arg_begin() == CE->arg_end());
1616 assert(DtorType == Dtor_Deleting || DtorType == Dtor_Complete);
1618 const CGFunctionInfo *FInfo = &CGM.getTypes().arrangeCXXStructorDeclaration(
1619 Dtor, getFromDtorType(DtorType));
1620 llvm::Type *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
1621 llvm::Value *Callee =
1622 getVirtualFunctionPointer(CGF, GlobalDecl(Dtor, DtorType), This, Ty,
1623 CE ? CE->getLocStart() : SourceLocation());
1625 CGF.EmitCXXMemberOrOperatorCall(Dtor, Callee, ReturnValueSlot(),
1626 This.getPointer(), /*ImplicitParam=*/nullptr,
1631 void ItaniumCXXABI::emitVirtualInheritanceTables(const CXXRecordDecl *RD) {
1632 CodeGenVTables &VTables = CGM.getVTables();
1633 llvm::GlobalVariable *VTT = VTables.GetAddrOfVTT(RD);
1634 VTables.EmitVTTDefinition(VTT, CGM.getVTableLinkage(RD), RD);
1637 bool ItaniumCXXABI::canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const {
1638 // We don't emit available_externally vtables if we are in -fapple-kext mode
1639 // because kext mode does not permit devirtualization.
1640 if (CGM.getLangOpts().AppleKext)
1643 // If we don't have any inline virtual functions, and if vtable is not hidden,
1644 // then we are safe to emit available_externally copy of vtable.
1645 // FIXME we can still emit a copy of the vtable if we
1646 // can emit definition of the inline functions.
1647 return !hasAnyUsedVirtualInlineFunction(RD) && !isVTableHidden(RD);
1649 static llvm::Value *performTypeAdjustment(CodeGenFunction &CGF,
1651 int64_t NonVirtualAdjustment,
1652 int64_t VirtualAdjustment,
1653 bool IsReturnAdjustment) {
1654 if (!NonVirtualAdjustment && !VirtualAdjustment)
1655 return InitialPtr.getPointer();
1657 Address V = CGF.Builder.CreateElementBitCast(InitialPtr, CGF.Int8Ty);
1659 // In a base-to-derived cast, the non-virtual adjustment is applied first.
1660 if (NonVirtualAdjustment && !IsReturnAdjustment) {
1661 V = CGF.Builder.CreateConstInBoundsByteGEP(V,
1662 CharUnits::fromQuantity(NonVirtualAdjustment));
1665 // Perform the virtual adjustment if we have one.
1666 llvm::Value *ResultPtr;
1667 if (VirtualAdjustment) {
1668 llvm::Type *PtrDiffTy =
1669 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1671 Address VTablePtrPtr = CGF.Builder.CreateElementBitCast(V, CGF.Int8PtrTy);
1672 llvm::Value *VTablePtr = CGF.Builder.CreateLoad(VTablePtrPtr);
1674 llvm::Value *OffsetPtr =
1675 CGF.Builder.CreateConstInBoundsGEP1_64(VTablePtr, VirtualAdjustment);
1677 OffsetPtr = CGF.Builder.CreateBitCast(OffsetPtr, PtrDiffTy->getPointerTo());
1679 // Load the adjustment offset from the vtable.
1680 llvm::Value *Offset =
1681 CGF.Builder.CreateAlignedLoad(OffsetPtr, CGF.getPointerAlign());
1683 // Adjust our pointer.
1684 ResultPtr = CGF.Builder.CreateInBoundsGEP(V.getPointer(), Offset);
1686 ResultPtr = V.getPointer();
1689 // In a derived-to-base conversion, the non-virtual adjustment is
1691 if (NonVirtualAdjustment && IsReturnAdjustment) {
1692 ResultPtr = CGF.Builder.CreateConstInBoundsGEP1_64(ResultPtr,
1693 NonVirtualAdjustment);
1696 // Cast back to the original type.
1697 return CGF.Builder.CreateBitCast(ResultPtr, InitialPtr.getType());
1700 llvm::Value *ItaniumCXXABI::performThisAdjustment(CodeGenFunction &CGF,
1702 const ThisAdjustment &TA) {
1703 return performTypeAdjustment(CGF, This, TA.NonVirtual,
1704 TA.Virtual.Itanium.VCallOffsetOffset,
1705 /*IsReturnAdjustment=*/false);
1709 ItaniumCXXABI::performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
1710 const ReturnAdjustment &RA) {
1711 return performTypeAdjustment(CGF, Ret, RA.NonVirtual,
1712 RA.Virtual.Itanium.VBaseOffsetOffset,
1713 /*IsReturnAdjustment=*/true);
1716 void ARMCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
1717 RValue RV, QualType ResultType) {
1718 if (!isa<CXXDestructorDecl>(CGF.CurGD.getDecl()))
1719 return ItaniumCXXABI::EmitReturnFromThunk(CGF, RV, ResultType);
1721 // Destructor thunks in the ARM ABI have indeterminate results.
1722 llvm::Type *T = CGF.ReturnValue.getElementType();
1723 RValue Undef = RValue::get(llvm::UndefValue::get(T));
1724 return ItaniumCXXABI::EmitReturnFromThunk(CGF, Undef, ResultType);
1727 /************************** Array allocation cookies **************************/
1729 CharUnits ItaniumCXXABI::getArrayCookieSizeImpl(QualType elementType) {
1730 // The array cookie is a size_t; pad that up to the element alignment.
1731 // The cookie is actually right-justified in that space.
1732 return std::max(CharUnits::fromQuantity(CGM.SizeSizeInBytes),
1733 CGM.getContext().getTypeAlignInChars(elementType));
1736 Address ItaniumCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
1738 llvm::Value *NumElements,
1739 const CXXNewExpr *expr,
1740 QualType ElementType) {
1741 assert(requiresArrayCookie(expr));
1743 unsigned AS = NewPtr.getAddressSpace();
1745 ASTContext &Ctx = getContext();
1746 CharUnits SizeSize = CGF.getSizeSize();
1748 // The size of the cookie.
1749 CharUnits CookieSize =
1750 std::max(SizeSize, Ctx.getTypeAlignInChars(ElementType));
1751 assert(CookieSize == getArrayCookieSizeImpl(ElementType));
1753 // Compute an offset to the cookie.
1754 Address CookiePtr = NewPtr;
1755 CharUnits CookieOffset = CookieSize - SizeSize;
1756 if (!CookieOffset.isZero())
1757 CookiePtr = CGF.Builder.CreateConstInBoundsByteGEP(CookiePtr, CookieOffset);
1759 // Write the number of elements into the appropriate slot.
1760 Address NumElementsPtr =
1761 CGF.Builder.CreateElementBitCast(CookiePtr, CGF.SizeTy);
1762 llvm::Instruction *SI = CGF.Builder.CreateStore(NumElements, NumElementsPtr);
1764 // Handle the array cookie specially in ASan.
1765 if (CGM.getLangOpts().Sanitize.has(SanitizerKind::Address) && AS == 0 &&
1766 expr->getOperatorNew()->isReplaceableGlobalAllocationFunction()) {
1767 // The store to the CookiePtr does not need to be instrumented.
1768 CGM.getSanitizerMetadata()->disableSanitizerForInstruction(SI);
1769 llvm::FunctionType *FTy =
1770 llvm::FunctionType::get(CGM.VoidTy, NumElementsPtr.getType(), false);
1772 CGM.CreateRuntimeFunction(FTy, "__asan_poison_cxx_array_cookie");
1773 CGF.Builder.CreateCall(F, NumElementsPtr.getPointer());
1776 // Finally, compute a pointer to the actual data buffer by skipping
1777 // over the cookie completely.
1778 return CGF.Builder.CreateConstInBoundsByteGEP(NewPtr, CookieSize);
1781 llvm::Value *ItaniumCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
1783 CharUnits cookieSize) {
1784 // The element size is right-justified in the cookie.
1785 Address numElementsPtr = allocPtr;
1786 CharUnits numElementsOffset = cookieSize - CGF.getSizeSize();
1787 if (!numElementsOffset.isZero())
1789 CGF.Builder.CreateConstInBoundsByteGEP(numElementsPtr, numElementsOffset);
1791 unsigned AS = allocPtr.getAddressSpace();
1792 numElementsPtr = CGF.Builder.CreateElementBitCast(numElementsPtr, CGF.SizeTy);
1793 if (!CGM.getLangOpts().Sanitize.has(SanitizerKind::Address) || AS != 0)
1794 return CGF.Builder.CreateLoad(numElementsPtr);
1795 // In asan mode emit a function call instead of a regular load and let the
1796 // run-time deal with it: if the shadow is properly poisoned return the
1797 // cookie, otherwise return 0 to avoid an infinite loop calling DTORs.
1798 // We can't simply ignore this load using nosanitize metadata because
1799 // the metadata may be lost.
1800 llvm::FunctionType *FTy =
1801 llvm::FunctionType::get(CGF.SizeTy, CGF.SizeTy->getPointerTo(0), false);
1803 CGM.CreateRuntimeFunction(FTy, "__asan_load_cxx_array_cookie");
1804 return CGF.Builder.CreateCall(F, numElementsPtr.getPointer());
1807 CharUnits ARMCXXABI::getArrayCookieSizeImpl(QualType elementType) {
1808 // ARM says that the cookie is always:
1809 // struct array_cookie {
1810 // std::size_t element_size; // element_size != 0
1811 // std::size_t element_count;
1813 // But the base ABI doesn't give anything an alignment greater than
1814 // 8, so we can dismiss this as typical ABI-author blindness to
1815 // actual language complexity and round up to the element alignment.
1816 return std::max(CharUnits::fromQuantity(2 * CGM.SizeSizeInBytes),
1817 CGM.getContext().getTypeAlignInChars(elementType));
1820 Address ARMCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
1822 llvm::Value *numElements,
1823 const CXXNewExpr *expr,
1824 QualType elementType) {
1825 assert(requiresArrayCookie(expr));
1827 // The cookie is always at the start of the buffer.
1828 Address cookie = newPtr;
1830 // The first element is the element size.
1831 cookie = CGF.Builder.CreateElementBitCast(cookie, CGF.SizeTy);
1832 llvm::Value *elementSize = llvm::ConstantInt::get(CGF.SizeTy,
1833 getContext().getTypeSizeInChars(elementType).getQuantity());
1834 CGF.Builder.CreateStore(elementSize, cookie);
1836 // The second element is the element count.
1837 cookie = CGF.Builder.CreateConstInBoundsGEP(cookie, 1, CGF.getSizeSize());
1838 CGF.Builder.CreateStore(numElements, cookie);
1840 // Finally, compute a pointer to the actual data buffer by skipping
1841 // over the cookie completely.
1842 CharUnits cookieSize = ARMCXXABI::getArrayCookieSizeImpl(elementType);
1843 return CGF.Builder.CreateConstInBoundsByteGEP(newPtr, cookieSize);
1846 llvm::Value *ARMCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
1848 CharUnits cookieSize) {
1849 // The number of elements is at offset sizeof(size_t) relative to
1850 // the allocated pointer.
1851 Address numElementsPtr
1852 = CGF.Builder.CreateConstInBoundsByteGEP(allocPtr, CGF.getSizeSize());
1854 numElementsPtr = CGF.Builder.CreateElementBitCast(numElementsPtr, CGF.SizeTy);
1855 return CGF.Builder.CreateLoad(numElementsPtr);
1858 /*********************** Static local initialization **************************/
1860 static llvm::Constant *getGuardAcquireFn(CodeGenModule &CGM,
1861 llvm::PointerType *GuardPtrTy) {
1862 // int __cxa_guard_acquire(__guard *guard_object);
1863 llvm::FunctionType *FTy =
1864 llvm::FunctionType::get(CGM.getTypes().ConvertType(CGM.getContext().IntTy),
1865 GuardPtrTy, /*isVarArg=*/false);
1866 return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_acquire",
1867 llvm::AttributeSet::get(CGM.getLLVMContext(),
1868 llvm::AttributeSet::FunctionIndex,
1869 llvm::Attribute::NoUnwind));
1872 static llvm::Constant *getGuardReleaseFn(CodeGenModule &CGM,
1873 llvm::PointerType *GuardPtrTy) {
1874 // void __cxa_guard_release(__guard *guard_object);
1875 llvm::FunctionType *FTy =
1876 llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
1877 return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_release",
1878 llvm::AttributeSet::get(CGM.getLLVMContext(),
1879 llvm::AttributeSet::FunctionIndex,
1880 llvm::Attribute::NoUnwind));
1883 static llvm::Constant *getGuardAbortFn(CodeGenModule &CGM,
1884 llvm::PointerType *GuardPtrTy) {
1885 // void __cxa_guard_abort(__guard *guard_object);
1886 llvm::FunctionType *FTy =
1887 llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
1888 return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_abort",
1889 llvm::AttributeSet::get(CGM.getLLVMContext(),
1890 llvm::AttributeSet::FunctionIndex,
1891 llvm::Attribute::NoUnwind));
1895 struct CallGuardAbort final : EHScopeStack::Cleanup {
1896 llvm::GlobalVariable *Guard;
1897 CallGuardAbort(llvm::GlobalVariable *Guard) : Guard(Guard) {}
1899 void Emit(CodeGenFunction &CGF, Flags flags) override {
1900 CGF.EmitNounwindRuntimeCall(getGuardAbortFn(CGF.CGM, Guard->getType()),
1906 /// The ARM code here follows the Itanium code closely enough that we
1907 /// just special-case it at particular places.
1908 void ItaniumCXXABI::EmitGuardedInit(CodeGenFunction &CGF,
1910 llvm::GlobalVariable *var,
1911 bool shouldPerformInit) {
1912 CGBuilderTy &Builder = CGF.Builder;
1914 // Inline variables that weren't instantiated from variable templates have
1915 // partially-ordered initialization within their translation unit.
1916 bool NonTemplateInline =
1918 !isTemplateInstantiation(D.getTemplateSpecializationKind());
1920 // We only need to use thread-safe statics for local non-TLS variables and
1921 // inline variables; other global initialization is always single-threaded
1922 // or (through lazy dynamic loading in multiple threads) unsequenced.
1923 bool threadsafe = getContext().getLangOpts().ThreadsafeStatics &&
1924 (D.isLocalVarDecl() || NonTemplateInline) &&
1927 // If we have a global variable with internal linkage and thread-safe statics
1928 // are disabled, we can just let the guard variable be of type i8.
1929 bool useInt8GuardVariable = !threadsafe && var->hasInternalLinkage();
1931 llvm::IntegerType *guardTy;
1932 CharUnits guardAlignment;
1933 if (useInt8GuardVariable) {
1934 guardTy = CGF.Int8Ty;
1935 guardAlignment = CharUnits::One();
1937 // Guard variables are 64 bits in the generic ABI and size width on ARM
1938 // (i.e. 32-bit on AArch32, 64-bit on AArch64).
1939 if (UseARMGuardVarABI) {
1940 guardTy = CGF.SizeTy;
1941 guardAlignment = CGF.getSizeAlign();
1943 guardTy = CGF.Int64Ty;
1944 guardAlignment = CharUnits::fromQuantity(
1945 CGM.getDataLayout().getABITypeAlignment(guardTy));
1948 llvm::PointerType *guardPtrTy = guardTy->getPointerTo();
1950 // Create the guard variable if we don't already have it (as we
1951 // might if we're double-emitting this function body).
1952 llvm::GlobalVariable *guard = CGM.getStaticLocalDeclGuardAddress(&D);
1954 // Mangle the name for the guard.
1955 SmallString<256> guardName;
1957 llvm::raw_svector_ostream out(guardName);
1958 getMangleContext().mangleStaticGuardVariable(&D, out);
1961 // Create the guard variable with a zero-initializer.
1962 // Just absorb linkage and visibility from the guarded variable.
1963 guard = new llvm::GlobalVariable(CGM.getModule(), guardTy,
1964 false, var->getLinkage(),
1965 llvm::ConstantInt::get(guardTy, 0),
1967 guard->setVisibility(var->getVisibility());
1968 // If the variable is thread-local, so is its guard variable.
1969 guard->setThreadLocalMode(var->getThreadLocalMode());
1970 guard->setAlignment(guardAlignment.getQuantity());
1972 // The ABI says: "It is suggested that it be emitted in the same COMDAT
1973 // group as the associated data object." In practice, this doesn't work for
1974 // non-ELF object formats, so only do it for ELF.
1975 llvm::Comdat *C = var->getComdat();
1976 if (!D.isLocalVarDecl() && C &&
1977 CGM.getTarget().getTriple().isOSBinFormatELF()) {
1978 guard->setComdat(C);
1979 // An inline variable's guard function is run from the per-TU
1980 // initialization function, not via a dedicated global ctor function, so
1981 // we can't put it in a comdat.
1982 if (!NonTemplateInline)
1983 CGF.CurFn->setComdat(C);
1984 } else if (CGM.supportsCOMDAT() && guard->isWeakForLinker()) {
1985 guard->setComdat(CGM.getModule().getOrInsertComdat(guard->getName()));
1988 CGM.setStaticLocalDeclGuardAddress(&D, guard);
1991 Address guardAddr = Address(guard, guardAlignment);
1993 // Test whether the variable has completed initialization.
1995 // Itanium C++ ABI 3.3.2:
1996 // The following is pseudo-code showing how these functions can be used:
1997 // if (obj_guard.first_byte == 0) {
1998 // if ( __cxa_guard_acquire (&obj_guard) ) {
2000 // ... initialize the object ...;
2002 // __cxa_guard_abort (&obj_guard);
2005 // ... queue object destructor with __cxa_atexit() ...;
2006 // __cxa_guard_release (&obj_guard);
2010 // Load the first byte of the guard variable.
2011 llvm::LoadInst *LI =
2012 Builder.CreateLoad(Builder.CreateElementBitCast(guardAddr, CGM.Int8Ty));
2015 // An implementation supporting thread-safety on multiprocessor
2016 // systems must also guarantee that references to the initialized
2017 // object do not occur before the load of the initialization flag.
2019 // In LLVM, we do this by marking the load Acquire.
2021 LI->setAtomic(llvm::AtomicOrdering::Acquire);
2023 // For ARM, we should only check the first bit, rather than the entire byte:
2025 // ARM C++ ABI 3.2.3.1:
2026 // To support the potential use of initialization guard variables
2027 // as semaphores that are the target of ARM SWP and LDREX/STREX
2028 // synchronizing instructions we define a static initialization
2029 // guard variable to be a 4-byte aligned, 4-byte word with the
2030 // following inline access protocol.
2031 // #define INITIALIZED 1
2032 // if ((obj_guard & INITIALIZED) != INITIALIZED) {
2033 // if (__cxa_guard_acquire(&obj_guard))
2037 // and similarly for ARM64:
2039 // ARM64 C++ ABI 3.2.2:
2040 // This ABI instead only specifies the value bit 0 of the static guard
2041 // variable; all other bits are platform defined. Bit 0 shall be 0 when the
2042 // variable is not initialized and 1 when it is.
2044 (UseARMGuardVarABI && !useInt8GuardVariable)
2045 ? Builder.CreateAnd(LI, llvm::ConstantInt::get(CGM.Int8Ty, 1))
2047 llvm::Value *isInitialized = Builder.CreateIsNull(V, "guard.uninitialized");
2049 llvm::BasicBlock *InitCheckBlock = CGF.createBasicBlock("init.check");
2050 llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end");
2052 // Check if the first byte of the guard variable is zero.
2053 Builder.CreateCondBr(isInitialized, InitCheckBlock, EndBlock);
2055 CGF.EmitBlock(InitCheckBlock);
2057 // Variables used when coping with thread-safe statics and exceptions.
2059 // Call __cxa_guard_acquire.
2061 = CGF.EmitNounwindRuntimeCall(getGuardAcquireFn(CGM, guardPtrTy), guard);
2063 llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
2065 Builder.CreateCondBr(Builder.CreateIsNotNull(V, "tobool"),
2066 InitBlock, EndBlock);
2068 // Call __cxa_guard_abort along the exceptional edge.
2069 CGF.EHStack.pushCleanup<CallGuardAbort>(EHCleanup, guard);
2071 CGF.EmitBlock(InitBlock);
2074 // Emit the initializer and add a global destructor if appropriate.
2075 CGF.EmitCXXGlobalVarDeclInit(D, var, shouldPerformInit);
2078 // Pop the guard-abort cleanup if we pushed one.
2079 CGF.PopCleanupBlock();
2081 // Call __cxa_guard_release. This cannot throw.
2082 CGF.EmitNounwindRuntimeCall(getGuardReleaseFn(CGM, guardPtrTy),
2083 guardAddr.getPointer());
2085 Builder.CreateStore(llvm::ConstantInt::get(guardTy, 1), guardAddr);
2088 CGF.EmitBlock(EndBlock);
2091 /// Register a global destructor using __cxa_atexit.
2092 static void emitGlobalDtorWithCXAAtExit(CodeGenFunction &CGF,
2093 llvm::Constant *dtor,
2094 llvm::Constant *addr,
2096 const char *Name = "__cxa_atexit";
2098 const llvm::Triple &T = CGF.getTarget().getTriple();
2099 Name = T.isOSDarwin() ? "_tlv_atexit" : "__cxa_thread_atexit";
2102 // We're assuming that the destructor function is something we can
2103 // reasonably call with the default CC. Go ahead and cast it to the
2105 llvm::Type *dtorTy =
2106 llvm::FunctionType::get(CGF.VoidTy, CGF.Int8PtrTy, false)->getPointerTo();
2108 // extern "C" int __cxa_atexit(void (*f)(void *), void *p, void *d);
2109 llvm::Type *paramTys[] = { dtorTy, CGF.Int8PtrTy, CGF.Int8PtrTy };
2110 llvm::FunctionType *atexitTy =
2111 llvm::FunctionType::get(CGF.IntTy, paramTys, false);
2113 // Fetch the actual function.
2114 llvm::Constant *atexit = CGF.CGM.CreateRuntimeFunction(atexitTy, Name);
2115 if (llvm::Function *fn = dyn_cast<llvm::Function>(atexit))
2116 fn->setDoesNotThrow();
2118 // Create a variable that binds the atexit to this shared object.
2119 llvm::Constant *handle =
2120 CGF.CGM.CreateRuntimeVariable(CGF.Int8Ty, "__dso_handle");
2122 llvm::Value *args[] = {
2123 llvm::ConstantExpr::getBitCast(dtor, dtorTy),
2124 llvm::ConstantExpr::getBitCast(addr, CGF.Int8PtrTy),
2127 CGF.EmitNounwindRuntimeCall(atexit, args);
2130 /// Register a global destructor as best as we know how.
2131 void ItaniumCXXABI::registerGlobalDtor(CodeGenFunction &CGF,
2133 llvm::Constant *dtor,
2134 llvm::Constant *addr) {
2135 // Use __cxa_atexit if available.
2136 if (CGM.getCodeGenOpts().CXAAtExit)
2137 return emitGlobalDtorWithCXAAtExit(CGF, dtor, addr, D.getTLSKind());
2140 CGM.ErrorUnsupported(&D, "non-trivial TLS destruction");
2142 // In Apple kexts, we want to add a global destructor entry.
2143 // FIXME: shouldn't this be guarded by some variable?
2144 if (CGM.getLangOpts().AppleKext) {
2145 // Generate a global destructor entry.
2146 return CGM.AddCXXDtorEntry(dtor, addr);
2149 CGF.registerGlobalDtorWithAtExit(D, dtor, addr);
2152 static bool isThreadWrapperReplaceable(const VarDecl *VD,
2153 CodeGen::CodeGenModule &CGM) {
2154 assert(!VD->isStaticLocal() && "static local VarDecls don't need wrappers!");
2155 // Darwin prefers to have references to thread local variables to go through
2156 // the thread wrapper instead of directly referencing the backing variable.
2157 return VD->getTLSKind() == VarDecl::TLS_Dynamic &&
2158 CGM.getTarget().getTriple().isOSDarwin();
2161 /// Get the appropriate linkage for the wrapper function. This is essentially
2162 /// the weak form of the variable's linkage; every translation unit which needs
2163 /// the wrapper emits a copy, and we want the linker to merge them.
2164 static llvm::GlobalValue::LinkageTypes
2165 getThreadLocalWrapperLinkage(const VarDecl *VD, CodeGen::CodeGenModule &CGM) {
2166 llvm::GlobalValue::LinkageTypes VarLinkage =
2167 CGM.getLLVMLinkageVarDefinition(VD, /*isConstant=*/false);
2169 // For internal linkage variables, we don't need an external or weak wrapper.
2170 if (llvm::GlobalValue::isLocalLinkage(VarLinkage))
2173 // If the thread wrapper is replaceable, give it appropriate linkage.
2174 if (isThreadWrapperReplaceable(VD, CGM))
2175 if (!llvm::GlobalVariable::isLinkOnceLinkage(VarLinkage) &&
2176 !llvm::GlobalVariable::isWeakODRLinkage(VarLinkage))
2178 return llvm::GlobalValue::WeakODRLinkage;
2182 ItaniumCXXABI::getOrCreateThreadLocalWrapper(const VarDecl *VD,
2184 // Mangle the name for the thread_local wrapper function.
2185 SmallString<256> WrapperName;
2187 llvm::raw_svector_ostream Out(WrapperName);
2188 getMangleContext().mangleItaniumThreadLocalWrapper(VD, Out);
2191 // FIXME: If VD is a definition, we should regenerate the function attributes
2192 // before returning.
2193 if (llvm::Value *V = CGM.getModule().getNamedValue(WrapperName))
2194 return cast<llvm::Function>(V);
2196 QualType RetQT = VD->getType();
2197 if (RetQT->isReferenceType())
2198 RetQT = RetQT.getNonReferenceType();
2200 const CGFunctionInfo &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(
2201 getContext().getPointerType(RetQT), FunctionArgList());
2203 llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FI);
2204 llvm::Function *Wrapper =
2205 llvm::Function::Create(FnTy, getThreadLocalWrapperLinkage(VD, CGM),
2206 WrapperName.str(), &CGM.getModule());
2208 CGM.SetLLVMFunctionAttributes(nullptr, FI, Wrapper);
2210 if (VD->hasDefinition())
2211 CGM.SetLLVMFunctionAttributesForDefinition(nullptr, Wrapper);
2213 // Always resolve references to the wrapper at link time.
2214 if (!Wrapper->hasLocalLinkage() && !(isThreadWrapperReplaceable(VD, CGM) &&
2215 !llvm::GlobalVariable::isLinkOnceLinkage(Wrapper->getLinkage()) &&
2216 !llvm::GlobalVariable::isWeakODRLinkage(Wrapper->getLinkage())))
2217 Wrapper->setVisibility(llvm::GlobalValue::HiddenVisibility);
2219 if (isThreadWrapperReplaceable(VD, CGM)) {
2220 Wrapper->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2221 Wrapper->addFnAttr(llvm::Attribute::NoUnwind);
2226 void ItaniumCXXABI::EmitThreadLocalInitFuncs(
2227 CodeGenModule &CGM, ArrayRef<const VarDecl *> CXXThreadLocals,
2228 ArrayRef<llvm::Function *> CXXThreadLocalInits,
2229 ArrayRef<const VarDecl *> CXXThreadLocalInitVars) {
2230 llvm::Function *InitFunc = nullptr;
2231 if (!CXXThreadLocalInits.empty()) {
2232 // Generate a guarded initialization function.
2233 llvm::FunctionType *FTy =
2234 llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
2235 const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
2236 InitFunc = CGM.CreateGlobalInitOrDestructFunction(FTy, "__tls_init", FI,
2239 llvm::GlobalVariable *Guard = new llvm::GlobalVariable(
2240 CGM.getModule(), CGM.Int8Ty, /*isConstant=*/false,
2241 llvm::GlobalVariable::InternalLinkage,
2242 llvm::ConstantInt::get(CGM.Int8Ty, 0), "__tls_guard");
2243 Guard->setThreadLocal(true);
2245 CharUnits GuardAlign = CharUnits::One();
2246 Guard->setAlignment(GuardAlign.getQuantity());
2248 CodeGenFunction(CGM)
2249 .GenerateCXXGlobalInitFunc(InitFunc, CXXThreadLocalInits,
2250 Address(Guard, GuardAlign));
2251 // On Darwin platforms, use CXX_FAST_TLS calling convention.
2252 if (CGM.getTarget().getTriple().isOSDarwin()) {
2253 InitFunc->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2254 InitFunc->addFnAttr(llvm::Attribute::NoUnwind);
2257 for (const VarDecl *VD : CXXThreadLocals) {
2258 llvm::GlobalVariable *Var =
2259 cast<llvm::GlobalVariable>(CGM.GetGlobalValue(CGM.getMangledName(VD)));
2261 // Some targets require that all access to thread local variables go through
2262 // the thread wrapper. This means that we cannot attempt to create a thread
2263 // wrapper or a thread helper.
2264 if (isThreadWrapperReplaceable(VD, CGM) && !VD->hasDefinition())
2267 // Mangle the name for the thread_local initialization function.
2268 SmallString<256> InitFnName;
2270 llvm::raw_svector_ostream Out(InitFnName);
2271 getMangleContext().mangleItaniumThreadLocalInit(VD, Out);
2274 // If we have a definition for the variable, emit the initialization
2275 // function as an alias to the global Init function (if any). Otherwise,
2276 // produce a declaration of the initialization function.
2277 llvm::GlobalValue *Init = nullptr;
2278 bool InitIsInitFunc = false;
2279 if (VD->hasDefinition()) {
2280 InitIsInitFunc = true;
2282 Init = llvm::GlobalAlias::create(Var->getLinkage(), InitFnName.str(),
2285 // Emit a weak global function referring to the initialization function.
2286 // This function will not exist if the TU defining the thread_local
2287 // variable in question does not need any dynamic initialization for
2288 // its thread_local variables.
2289 llvm::FunctionType *FnTy = llvm::FunctionType::get(CGM.VoidTy, false);
2290 Init = llvm::Function::Create(
2291 FnTy, llvm::GlobalVariable::ExternalWeakLinkage, InitFnName.str(),
2293 const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
2294 CGM.SetLLVMFunctionAttributes(nullptr, FI, cast<llvm::Function>(Init));
2298 Init->setVisibility(Var->getVisibility());
2300 llvm::Function *Wrapper = getOrCreateThreadLocalWrapper(VD, Var);
2301 llvm::LLVMContext &Context = CGM.getModule().getContext();
2302 llvm::BasicBlock *Entry = llvm::BasicBlock::Create(Context, "", Wrapper);
2303 CGBuilderTy Builder(CGM, Entry);
2304 if (InitIsInitFunc) {
2306 llvm::CallInst *CallVal = Builder.CreateCall(Init);
2307 if (isThreadWrapperReplaceable(VD, CGM))
2308 CallVal->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2311 // Don't know whether we have an init function. Call it if it exists.
2312 llvm::Value *Have = Builder.CreateIsNotNull(Init);
2313 llvm::BasicBlock *InitBB = llvm::BasicBlock::Create(Context, "", Wrapper);
2314 llvm::BasicBlock *ExitBB = llvm::BasicBlock::Create(Context, "", Wrapper);
2315 Builder.CreateCondBr(Have, InitBB, ExitBB);
2317 Builder.SetInsertPoint(InitBB);
2318 Builder.CreateCall(Init);
2319 Builder.CreateBr(ExitBB);
2321 Builder.SetInsertPoint(ExitBB);
2324 // For a reference, the result of the wrapper function is a pointer to
2325 // the referenced object.
2326 llvm::Value *Val = Var;
2327 if (VD->getType()->isReferenceType()) {
2328 CharUnits Align = CGM.getContext().getDeclAlign(VD);
2329 Val = Builder.CreateAlignedLoad(Val, Align);
2331 if (Val->getType() != Wrapper->getReturnType())
2332 Val = Builder.CreatePointerBitCastOrAddrSpaceCast(
2333 Val, Wrapper->getReturnType(), "");
2334 Builder.CreateRet(Val);
2338 LValue ItaniumCXXABI::EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,
2340 QualType LValType) {
2341 llvm::Value *Val = CGF.CGM.GetAddrOfGlobalVar(VD);
2342 llvm::Function *Wrapper = getOrCreateThreadLocalWrapper(VD, Val);
2344 llvm::CallInst *CallVal = CGF.Builder.CreateCall(Wrapper);
2345 if (isThreadWrapperReplaceable(VD, CGF.CGM))
2346 CallVal->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2349 if (VD->getType()->isReferenceType())
2350 LV = CGF.MakeNaturalAlignAddrLValue(CallVal, LValType);
2352 LV = CGF.MakeAddrLValue(CallVal, LValType,
2353 CGF.getContext().getDeclAlign(VD));
2354 // FIXME: need setObjCGCLValueClass?
2358 /// Return whether the given global decl needs a VTT parameter, which it does
2359 /// if it's a base constructor or destructor with virtual bases.
2360 bool ItaniumCXXABI::NeedsVTTParameter(GlobalDecl GD) {
2361 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
2363 // We don't have any virtual bases, just return early.
2364 if (!MD->getParent()->getNumVBases())
2367 // Check if we have a base constructor.
2368 if (isa<CXXConstructorDecl>(MD) && GD.getCtorType() == Ctor_Base)
2371 // Check if we have a base destructor.
2372 if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
2379 class ItaniumRTTIBuilder {
2380 CodeGenModule &CGM; // Per-module state.
2381 llvm::LLVMContext &VMContext;
2382 const ItaniumCXXABI &CXXABI; // Per-module state.
2384 /// Fields - The fields of the RTTI descriptor currently being built.
2385 SmallVector<llvm::Constant *, 16> Fields;
2387 /// GetAddrOfTypeName - Returns the mangled type name of the given type.
2388 llvm::GlobalVariable *
2389 GetAddrOfTypeName(QualType Ty, llvm::GlobalVariable::LinkageTypes Linkage);
2391 /// GetAddrOfExternalRTTIDescriptor - Returns the constant for the RTTI
2392 /// descriptor of the given type.
2393 llvm::Constant *GetAddrOfExternalRTTIDescriptor(QualType Ty);
2395 /// BuildVTablePointer - Build the vtable pointer for the given type.
2396 void BuildVTablePointer(const Type *Ty);
2398 /// BuildSIClassTypeInfo - Build an abi::__si_class_type_info, used for single
2399 /// inheritance, according to the Itanium C++ ABI, 2.9.5p6b.
2400 void BuildSIClassTypeInfo(const CXXRecordDecl *RD);
2402 /// BuildVMIClassTypeInfo - Build an abi::__vmi_class_type_info, used for
2403 /// classes with bases that do not satisfy the abi::__si_class_type_info
2404 /// constraints, according ti the Itanium C++ ABI, 2.9.5p5c.
2405 void BuildVMIClassTypeInfo(const CXXRecordDecl *RD);
2407 /// BuildPointerTypeInfo - Build an abi::__pointer_type_info struct, used
2408 /// for pointer types.
2409 void BuildPointerTypeInfo(QualType PointeeTy);
2411 /// BuildObjCObjectTypeInfo - Build the appropriate kind of
2412 /// type_info for an object type.
2413 void BuildObjCObjectTypeInfo(const ObjCObjectType *Ty);
2415 /// BuildPointerToMemberTypeInfo - Build an abi::__pointer_to_member_type_info
2416 /// struct, used for member pointer types.
2417 void BuildPointerToMemberTypeInfo(const MemberPointerType *Ty);
2420 ItaniumRTTIBuilder(const ItaniumCXXABI &ABI)
2421 : CGM(ABI.CGM), VMContext(CGM.getModule().getContext()), CXXABI(ABI) {}
2423 // Pointer type info flags.
2425 /// PTI_Const - Type has const qualifier.
2428 /// PTI_Volatile - Type has volatile qualifier.
2431 /// PTI_Restrict - Type has restrict qualifier.
2434 /// PTI_Incomplete - Type is incomplete.
2435 PTI_Incomplete = 0x8,
2437 /// PTI_ContainingClassIncomplete - Containing class is incomplete.
2438 /// (in pointer to member).
2439 PTI_ContainingClassIncomplete = 0x10
2442 // VMI type info flags.
2444 /// VMI_NonDiamondRepeat - Class has non-diamond repeated inheritance.
2445 VMI_NonDiamondRepeat = 0x1,
2447 /// VMI_DiamondShaped - Class is diamond shaped.
2448 VMI_DiamondShaped = 0x2
2451 // Base class type info flags.
2453 /// BCTI_Virtual - Base class is virtual.
2456 /// BCTI_Public - Base class is public.
2460 /// BuildTypeInfo - Build the RTTI type info struct for the given type.
2462 /// \param Force - true to force the creation of this RTTI value
2463 llvm::Constant *BuildTypeInfo(QualType Ty, bool Force = false);
2467 llvm::GlobalVariable *ItaniumRTTIBuilder::GetAddrOfTypeName(
2468 QualType Ty, llvm::GlobalVariable::LinkageTypes Linkage) {
2469 SmallString<256> Name;
2470 llvm::raw_svector_ostream Out(Name);
2471 CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(Ty, Out);
2473 // We know that the mangled name of the type starts at index 4 of the
2474 // mangled name of the typename, so we can just index into it in order to
2475 // get the mangled name of the type.
2476 llvm::Constant *Init = llvm::ConstantDataArray::getString(VMContext,
2479 llvm::GlobalVariable *GV =
2480 CGM.CreateOrReplaceCXXRuntimeVariable(Name, Init->getType(), Linkage);
2482 GV->setInitializer(Init);
2488 ItaniumRTTIBuilder::GetAddrOfExternalRTTIDescriptor(QualType Ty) {
2489 // Mangle the RTTI name.
2490 SmallString<256> Name;
2491 llvm::raw_svector_ostream Out(Name);
2492 CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
2494 // Look for an existing global.
2495 llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(Name);
2498 // Create a new global variable.
2499 GV = new llvm::GlobalVariable(CGM.getModule(), CGM.Int8PtrTy,
2501 llvm::GlobalValue::ExternalLinkage, nullptr,
2503 if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
2504 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
2505 if (RD->hasAttr<DLLImportAttr>())
2506 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
2510 return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
2513 /// TypeInfoIsInStandardLibrary - Given a builtin type, returns whether the type
2514 /// info for that type is defined in the standard library.
2515 static bool TypeInfoIsInStandardLibrary(const BuiltinType *Ty) {
2516 // Itanium C++ ABI 2.9.2:
2517 // Basic type information (e.g. for "int", "bool", etc.) will be kept in
2518 // the run-time support library. Specifically, the run-time support
2519 // library should contain type_info objects for the types X, X* and
2520 // X const*, for every X in: void, std::nullptr_t, bool, wchar_t, char,
2521 // unsigned char, signed char, short, unsigned short, int, unsigned int,
2522 // long, unsigned long, long long, unsigned long long, float, double,
2523 // long double, char16_t, char32_t, and the IEEE 754r decimal and
2524 // half-precision floating point types.
2526 // GCC also emits RTTI for __int128.
2527 // FIXME: We do not emit RTTI information for decimal types here.
2529 // Types added here must also be added to EmitFundamentalRTTIDescriptors.
2530 switch (Ty->getKind()) {
2531 case BuiltinType::Void:
2532 case BuiltinType::NullPtr:
2533 case BuiltinType::Bool:
2534 case BuiltinType::WChar_S:
2535 case BuiltinType::WChar_U:
2536 case BuiltinType::Char_U:
2537 case BuiltinType::Char_S:
2538 case BuiltinType::UChar:
2539 case BuiltinType::SChar:
2540 case BuiltinType::Short:
2541 case BuiltinType::UShort:
2542 case BuiltinType::Int:
2543 case BuiltinType::UInt:
2544 case BuiltinType::Long:
2545 case BuiltinType::ULong:
2546 case BuiltinType::LongLong:
2547 case BuiltinType::ULongLong:
2548 case BuiltinType::Half:
2549 case BuiltinType::Float:
2550 case BuiltinType::Double:
2551 case BuiltinType::LongDouble:
2552 case BuiltinType::Float128:
2553 case BuiltinType::Char16:
2554 case BuiltinType::Char32:
2555 case BuiltinType::Int128:
2556 case BuiltinType::UInt128:
2559 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2560 case BuiltinType::Id:
2561 #include "clang/Basic/OpenCLImageTypes.def"
2562 case BuiltinType::OCLSampler:
2563 case BuiltinType::OCLEvent:
2564 case BuiltinType::OCLClkEvent:
2565 case BuiltinType::OCLQueue:
2566 case BuiltinType::OCLNDRange:
2567 case BuiltinType::OCLReserveID:
2570 case BuiltinType::Dependent:
2571 #define BUILTIN_TYPE(Id, SingletonId)
2572 #define PLACEHOLDER_TYPE(Id, SingletonId) \
2573 case BuiltinType::Id:
2574 #include "clang/AST/BuiltinTypes.def"
2575 llvm_unreachable("asking for RRTI for a placeholder type!");
2577 case BuiltinType::ObjCId:
2578 case BuiltinType::ObjCClass:
2579 case BuiltinType::ObjCSel:
2580 llvm_unreachable("FIXME: Objective-C types are unsupported!");
2583 llvm_unreachable("Invalid BuiltinType Kind!");
2586 static bool TypeInfoIsInStandardLibrary(const PointerType *PointerTy) {
2587 QualType PointeeTy = PointerTy->getPointeeType();
2588 const BuiltinType *BuiltinTy = dyn_cast<BuiltinType>(PointeeTy);
2592 // Check the qualifiers.
2593 Qualifiers Quals = PointeeTy.getQualifiers();
2594 Quals.removeConst();
2599 return TypeInfoIsInStandardLibrary(BuiltinTy);
2602 /// IsStandardLibraryRTTIDescriptor - Returns whether the type
2603 /// information for the given type exists in the standard library.
2604 static bool IsStandardLibraryRTTIDescriptor(QualType Ty) {
2605 // Type info for builtin types is defined in the standard library.
2606 if (const BuiltinType *BuiltinTy = dyn_cast<BuiltinType>(Ty))
2607 return TypeInfoIsInStandardLibrary(BuiltinTy);
2609 // Type info for some pointer types to builtin types is defined in the
2610 // standard library.
2611 if (const PointerType *PointerTy = dyn_cast<PointerType>(Ty))
2612 return TypeInfoIsInStandardLibrary(PointerTy);
2617 /// ShouldUseExternalRTTIDescriptor - Returns whether the type information for
2618 /// the given type exists somewhere else, and that we should not emit the type
2619 /// information in this translation unit. Assumes that it is not a
2620 /// standard-library type.
2621 static bool ShouldUseExternalRTTIDescriptor(CodeGenModule &CGM,
2623 ASTContext &Context = CGM.getContext();
2625 // If RTTI is disabled, assume it might be disabled in the
2626 // translation unit that defines any potential key function, too.
2627 if (!Context.getLangOpts().RTTI) return false;
2629 if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
2630 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
2631 if (!RD->hasDefinition())
2634 if (!RD->isDynamicClass())
2637 // FIXME: this may need to be reconsidered if the key function
2639 // N.B. We must always emit the RTTI data ourselves if there exists a key
2641 bool IsDLLImport = RD->hasAttr<DLLImportAttr>();
2642 if (CGM.getVTables().isVTableExternal(RD))
2643 return IsDLLImport ? false : true;
2652 /// IsIncompleteClassType - Returns whether the given record type is incomplete.
2653 static bool IsIncompleteClassType(const RecordType *RecordTy) {
2654 return !RecordTy->getDecl()->isCompleteDefinition();
2657 /// ContainsIncompleteClassType - Returns whether the given type contains an
2658 /// incomplete class type. This is true if
2660 /// * The given type is an incomplete class type.
2661 /// * The given type is a pointer type whose pointee type contains an
2662 /// incomplete class type.
2663 /// * The given type is a member pointer type whose class is an incomplete
2665 /// * The given type is a member pointer type whoise pointee type contains an
2666 /// incomplete class type.
2667 /// is an indirect or direct pointer to an incomplete class type.
2668 static bool ContainsIncompleteClassType(QualType Ty) {
2669 if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
2670 if (IsIncompleteClassType(RecordTy))
2674 if (const PointerType *PointerTy = dyn_cast<PointerType>(Ty))
2675 return ContainsIncompleteClassType(PointerTy->getPointeeType());
2677 if (const MemberPointerType *MemberPointerTy =
2678 dyn_cast<MemberPointerType>(Ty)) {
2679 // Check if the class type is incomplete.
2680 const RecordType *ClassType = cast<RecordType>(MemberPointerTy->getClass());
2681 if (IsIncompleteClassType(ClassType))
2684 return ContainsIncompleteClassType(MemberPointerTy->getPointeeType());
2690 // CanUseSingleInheritance - Return whether the given record decl has a "single,
2691 // public, non-virtual base at offset zero (i.e. the derived class is dynamic
2692 // iff the base is)", according to Itanium C++ ABI, 2.95p6b.
2693 static bool CanUseSingleInheritance(const CXXRecordDecl *RD) {
2694 // Check the number of bases.
2695 if (RD->getNumBases() != 1)
2699 CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin();
2701 // Check that the base is not virtual.
2702 if (Base->isVirtual())
2705 // Check that the base is public.
2706 if (Base->getAccessSpecifier() != AS_public)
2709 // Check that the class is dynamic iff the base is.
2710 const CXXRecordDecl *BaseDecl =
2711 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
2712 if (!BaseDecl->isEmpty() &&
2713 BaseDecl->isDynamicClass() != RD->isDynamicClass())
2719 void ItaniumRTTIBuilder::BuildVTablePointer(const Type *Ty) {
2720 // abi::__class_type_info.
2721 static const char * const ClassTypeInfo =
2722 "_ZTVN10__cxxabiv117__class_type_infoE";
2723 // abi::__si_class_type_info.
2724 static const char * const SIClassTypeInfo =
2725 "_ZTVN10__cxxabiv120__si_class_type_infoE";
2726 // abi::__vmi_class_type_info.
2727 static const char * const VMIClassTypeInfo =
2728 "_ZTVN10__cxxabiv121__vmi_class_type_infoE";
2730 const char *VTableName = nullptr;
2732 switch (Ty->getTypeClass()) {
2733 #define TYPE(Class, Base)
2734 #define ABSTRACT_TYPE(Class, Base)
2735 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
2736 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
2737 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
2738 #include "clang/AST/TypeNodes.def"
2739 llvm_unreachable("Non-canonical and dependent types shouldn't get here");
2741 case Type::LValueReference:
2742 case Type::RValueReference:
2743 llvm_unreachable("References shouldn't get here");
2746 llvm_unreachable("Undeduced auto type shouldn't get here");
2749 llvm_unreachable("Pipe types shouldn't get here");
2752 // GCC treats vector and complex types as fundamental types.
2754 case Type::ExtVector:
2757 // FIXME: GCC treats block pointers as fundamental types?!
2758 case Type::BlockPointer:
2759 // abi::__fundamental_type_info.
2760 VTableName = "_ZTVN10__cxxabiv123__fundamental_type_infoE";
2763 case Type::ConstantArray:
2764 case Type::IncompleteArray:
2765 case Type::VariableArray:
2766 // abi::__array_type_info.
2767 VTableName = "_ZTVN10__cxxabiv117__array_type_infoE";
2770 case Type::FunctionNoProto:
2771 case Type::FunctionProto:
2772 // abi::__function_type_info.
2773 VTableName = "_ZTVN10__cxxabiv120__function_type_infoE";
2777 // abi::__enum_type_info.
2778 VTableName = "_ZTVN10__cxxabiv116__enum_type_infoE";
2781 case Type::Record: {
2782 const CXXRecordDecl *RD =
2783 cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());
2785 if (!RD->hasDefinition() || !RD->getNumBases()) {
2786 VTableName = ClassTypeInfo;
2787 } else if (CanUseSingleInheritance(RD)) {
2788 VTableName = SIClassTypeInfo;
2790 VTableName = VMIClassTypeInfo;
2796 case Type::ObjCObject:
2797 // Ignore protocol qualifiers.
2798 Ty = cast<ObjCObjectType>(Ty)->getBaseType().getTypePtr();
2800 // Handle id and Class.
2801 if (isa<BuiltinType>(Ty)) {
2802 VTableName = ClassTypeInfo;
2806 assert(isa<ObjCInterfaceType>(Ty));
2809 case Type::ObjCInterface:
2810 if (cast<ObjCInterfaceType>(Ty)->getDecl()->getSuperClass()) {
2811 VTableName = SIClassTypeInfo;
2813 VTableName = ClassTypeInfo;
2817 case Type::ObjCObjectPointer:
2819 // abi::__pointer_type_info.
2820 VTableName = "_ZTVN10__cxxabiv119__pointer_type_infoE";
2823 case Type::MemberPointer:
2824 // abi::__pointer_to_member_type_info.
2825 VTableName = "_ZTVN10__cxxabiv129__pointer_to_member_type_infoE";
2829 llvm::Constant *VTable =
2830 CGM.getModule().getOrInsertGlobal(VTableName, CGM.Int8PtrTy);
2832 llvm::Type *PtrDiffTy =
2833 CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
2835 // The vtable address point is 2.
2836 llvm::Constant *Two = llvm::ConstantInt::get(PtrDiffTy, 2);
2838 llvm::ConstantExpr::getInBoundsGetElementPtr(CGM.Int8PtrTy, VTable, Two);
2839 VTable = llvm::ConstantExpr::getBitCast(VTable, CGM.Int8PtrTy);
2841 Fields.push_back(VTable);
2844 /// \brief Return the linkage that the type info and type info name constants
2845 /// should have for the given type.
2846 static llvm::GlobalVariable::LinkageTypes getTypeInfoLinkage(CodeGenModule &CGM,
2848 // Itanium C++ ABI 2.9.5p7:
2849 // In addition, it and all of the intermediate abi::__pointer_type_info
2850 // structs in the chain down to the abi::__class_type_info for the
2851 // incomplete class type must be prevented from resolving to the
2852 // corresponding type_info structs for the complete class type, possibly
2853 // by making them local static objects. Finally, a dummy class RTTI is
2854 // generated for the incomplete type that will not resolve to the final
2855 // complete class RTTI (because the latter need not exist), possibly by
2856 // making it a local static object.
2857 if (ContainsIncompleteClassType(Ty))
2858 return llvm::GlobalValue::InternalLinkage;
2860 switch (Ty->getLinkage()) {
2862 case InternalLinkage:
2863 case UniqueExternalLinkage:
2864 return llvm::GlobalValue::InternalLinkage;
2866 case VisibleNoLinkage:
2867 case ExternalLinkage:
2868 if (!CGM.getLangOpts().RTTI) {
2869 // RTTI is not enabled, which means that this type info struct is going
2870 // to be used for exception handling. Give it linkonce_odr linkage.
2871 return llvm::GlobalValue::LinkOnceODRLinkage;
2874 if (const RecordType *Record = dyn_cast<RecordType>(Ty)) {
2875 const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
2876 if (RD->hasAttr<WeakAttr>())
2877 return llvm::GlobalValue::WeakODRLinkage;
2878 if (RD->isDynamicClass()) {
2879 llvm::GlobalValue::LinkageTypes LT = CGM.getVTableLinkage(RD);
2880 // MinGW won't export the RTTI information when there is a key function.
2881 // Make sure we emit our own copy instead of attempting to dllimport it.
2882 if (RD->hasAttr<DLLImportAttr>() &&
2883 llvm::GlobalValue::isAvailableExternallyLinkage(LT))
2884 LT = llvm::GlobalValue::LinkOnceODRLinkage;
2889 return llvm::GlobalValue::LinkOnceODRLinkage;
2892 llvm_unreachable("Invalid linkage!");
2895 llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(QualType Ty, bool Force) {
2896 // We want to operate on the canonical type.
2897 Ty = Ty.getCanonicalType();
2899 // Check if we've already emitted an RTTI descriptor for this type.
2900 SmallString<256> Name;
2901 llvm::raw_svector_ostream Out(Name);
2902 CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
2904 llvm::GlobalVariable *OldGV = CGM.getModule().getNamedGlobal(Name);
2905 if (OldGV && !OldGV->isDeclaration()) {
2906 assert(!OldGV->hasAvailableExternallyLinkage() &&
2907 "available_externally typeinfos not yet implemented");
2909 return llvm::ConstantExpr::getBitCast(OldGV, CGM.Int8PtrTy);
2912 // Check if there is already an external RTTI descriptor for this type.
2913 bool IsStdLib = IsStandardLibraryRTTIDescriptor(Ty);
2914 if (!Force && (IsStdLib || ShouldUseExternalRTTIDescriptor(CGM, Ty)))
2915 return GetAddrOfExternalRTTIDescriptor(Ty);
2917 // Emit the standard library with external linkage.
2918 llvm::GlobalVariable::LinkageTypes Linkage;
2920 Linkage = llvm::GlobalValue::ExternalLinkage;
2922 Linkage = getTypeInfoLinkage(CGM, Ty);
2924 // Add the vtable pointer.
2925 BuildVTablePointer(cast<Type>(Ty));
2928 llvm::GlobalVariable *TypeName = GetAddrOfTypeName(Ty, Linkage);
2929 llvm::Constant *TypeNameField;
2931 // If we're supposed to demote the visibility, be sure to set a flag
2932 // to use a string comparison for type_info comparisons.
2933 ItaniumCXXABI::RTTIUniquenessKind RTTIUniqueness =
2934 CXXABI.classifyRTTIUniqueness(Ty, Linkage);
2935 if (RTTIUniqueness != ItaniumCXXABI::RUK_Unique) {
2936 // The flag is the sign bit, which on ARM64 is defined to be clear
2937 // for global pointers. This is very ARM64-specific.
2938 TypeNameField = llvm::ConstantExpr::getPtrToInt(TypeName, CGM.Int64Ty);
2939 llvm::Constant *flag =
2940 llvm::ConstantInt::get(CGM.Int64Ty, ((uint64_t)1) << 63);
2941 TypeNameField = llvm::ConstantExpr::getAdd(TypeNameField, flag);
2943 llvm::ConstantExpr::getIntToPtr(TypeNameField, CGM.Int8PtrTy);
2945 TypeNameField = llvm::ConstantExpr::getBitCast(TypeName, CGM.Int8PtrTy);
2947 Fields.push_back(TypeNameField);
2949 switch (Ty->getTypeClass()) {
2950 #define TYPE(Class, Base)
2951 #define ABSTRACT_TYPE(Class, Base)
2952 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
2953 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
2954 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
2955 #include "clang/AST/TypeNodes.def"
2956 llvm_unreachable("Non-canonical and dependent types shouldn't get here");
2958 // GCC treats vector types as fundamental types.
2961 case Type::ExtVector:
2963 case Type::BlockPointer:
2964 // Itanium C++ ABI 2.9.5p4:
2965 // abi::__fundamental_type_info adds no data members to std::type_info.
2968 case Type::LValueReference:
2969 case Type::RValueReference:
2970 llvm_unreachable("References shouldn't get here");
2973 llvm_unreachable("Undeduced auto type shouldn't get here");
2976 llvm_unreachable("Pipe type shouldn't get here");
2978 case Type::ConstantArray:
2979 case Type::IncompleteArray:
2980 case Type::VariableArray:
2981 // Itanium C++ ABI 2.9.5p5:
2982 // abi::__array_type_info adds no data members to std::type_info.
2985 case Type::FunctionNoProto:
2986 case Type::FunctionProto:
2987 // Itanium C++ ABI 2.9.5p5:
2988 // abi::__function_type_info adds no data members to std::type_info.
2992 // Itanium C++ ABI 2.9.5p5:
2993 // abi::__enum_type_info adds no data members to std::type_info.
2996 case Type::Record: {
2997 const CXXRecordDecl *RD =
2998 cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());
2999 if (!RD->hasDefinition() || !RD->getNumBases()) {
3000 // We don't need to emit any fields.
3004 if (CanUseSingleInheritance(RD))
3005 BuildSIClassTypeInfo(RD);
3007 BuildVMIClassTypeInfo(RD);
3012 case Type::ObjCObject:
3013 case Type::ObjCInterface:
3014 BuildObjCObjectTypeInfo(cast<ObjCObjectType>(Ty));
3017 case Type::ObjCObjectPointer:
3018 BuildPointerTypeInfo(cast<ObjCObjectPointerType>(Ty)->getPointeeType());
3022 BuildPointerTypeInfo(cast<PointerType>(Ty)->getPointeeType());
3025 case Type::MemberPointer:
3026 BuildPointerToMemberTypeInfo(cast<MemberPointerType>(Ty));
3030 // No fields, at least for the moment.
3034 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Fields);
3036 llvm::Module &M = CGM.getModule();
3037 llvm::GlobalVariable *GV =
3038 new llvm::GlobalVariable(M, Init->getType(),
3039 /*Constant=*/true, Linkage, Init, Name);
3041 // If there's already an old global variable, replace it with the new one.
3043 GV->takeName(OldGV);
3044 llvm::Constant *NewPtr =
3045 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
3046 OldGV->replaceAllUsesWith(NewPtr);
3047 OldGV->eraseFromParent();
3050 if (CGM.supportsCOMDAT() && GV->isWeakForLinker())
3051 GV->setComdat(M.getOrInsertComdat(GV->getName()));
3053 // The Itanium ABI specifies that type_info objects must be globally
3054 // unique, with one exception: if the type is an incomplete class
3055 // type or a (possibly indirect) pointer to one. That exception
3056 // affects the general case of comparing type_info objects produced
3057 // by the typeid operator, which is why the comparison operators on
3058 // std::type_info generally use the type_info name pointers instead
3059 // of the object addresses. However, the language's built-in uses
3060 // of RTTI generally require class types to be complete, even when
3061 // manipulating pointers to those class types. This allows the
3062 // implementation of dynamic_cast to rely on address equality tests,
3063 // which is much faster.
3065 // All of this is to say that it's important that both the type_info
3066 // object and the type_info name be uniqued when weakly emitted.
3068 // Give the type_info object and name the formal visibility of the
3070 llvm::GlobalValue::VisibilityTypes llvmVisibility;
3071 if (llvm::GlobalValue::isLocalLinkage(Linkage))
3072 // If the linkage is local, only default visibility makes sense.
3073 llvmVisibility = llvm::GlobalValue::DefaultVisibility;
3074 else if (RTTIUniqueness == ItaniumCXXABI::RUK_NonUniqueHidden)
3075 llvmVisibility = llvm::GlobalValue::HiddenVisibility;
3077 llvmVisibility = CodeGenModule::GetLLVMVisibility(Ty->getVisibility());
3078 TypeName->setVisibility(llvmVisibility);
3079 GV->setVisibility(llvmVisibility);
3081 return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
3084 /// ComputeQualifierFlags - Compute the pointer type info flags from the
3085 /// given qualifier.
3086 static unsigned ComputeQualifierFlags(Qualifiers Quals) {
3089 if (Quals.hasConst())
3090 Flags |= ItaniumRTTIBuilder::PTI_Const;
3091 if (Quals.hasVolatile())
3092 Flags |= ItaniumRTTIBuilder::PTI_Volatile;
3093 if (Quals.hasRestrict())
3094 Flags |= ItaniumRTTIBuilder::PTI_Restrict;
3099 /// BuildObjCObjectTypeInfo - Build the appropriate kind of type_info
3100 /// for the given Objective-C object type.
3101 void ItaniumRTTIBuilder::BuildObjCObjectTypeInfo(const ObjCObjectType *OT) {
3103 const Type *T = OT->getBaseType().getTypePtr();
3104 assert(isa<BuiltinType>(T) || isa<ObjCInterfaceType>(T));
3106 // The builtin types are abi::__class_type_infos and don't require
3108 if (isa<BuiltinType>(T)) return;
3110 ObjCInterfaceDecl *Class = cast<ObjCInterfaceType>(T)->getDecl();
3111 ObjCInterfaceDecl *Super = Class->getSuperClass();
3113 // Root classes are also __class_type_info.
3116 QualType SuperTy = CGM.getContext().getObjCInterfaceType(Super);
3118 // Everything else is single inheritance.
3119 llvm::Constant *BaseTypeInfo =
3120 ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(SuperTy);
3121 Fields.push_back(BaseTypeInfo);
3124 /// BuildSIClassTypeInfo - Build an abi::__si_class_type_info, used for single
3125 /// inheritance, according to the Itanium C++ ABI, 2.95p6b.
3126 void ItaniumRTTIBuilder::BuildSIClassTypeInfo(const CXXRecordDecl *RD) {
3127 // Itanium C++ ABI 2.9.5p6b:
3128 // It adds to abi::__class_type_info a single member pointing to the
3129 // type_info structure for the base type,
3130 llvm::Constant *BaseTypeInfo =
3131 ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(RD->bases_begin()->getType());
3132 Fields.push_back(BaseTypeInfo);
3136 /// SeenBases - Contains virtual and non-virtual bases seen when traversing
3137 /// a class hierarchy.
3139 llvm::SmallPtrSet<const CXXRecordDecl *, 16> NonVirtualBases;
3140 llvm::SmallPtrSet<const CXXRecordDecl *, 16> VirtualBases;
3144 /// ComputeVMIClassTypeInfoFlags - Compute the value of the flags member in
3145 /// abi::__vmi_class_type_info.
3147 static unsigned ComputeVMIClassTypeInfoFlags(const CXXBaseSpecifier *Base,
3152 const CXXRecordDecl *BaseDecl =
3153 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
3155 if (Base->isVirtual()) {
3156 // Mark the virtual base as seen.
3157 if (!Bases.VirtualBases.insert(BaseDecl).second) {
3158 // If this virtual base has been seen before, then the class is diamond
3160 Flags |= ItaniumRTTIBuilder::VMI_DiamondShaped;
3162 if (Bases.NonVirtualBases.count(BaseDecl))
3163 Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
3166 // Mark the non-virtual base as seen.
3167 if (!Bases.NonVirtualBases.insert(BaseDecl).second) {
3168 // If this non-virtual base has been seen before, then the class has non-
3169 // diamond shaped repeated inheritance.
3170 Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
3172 if (Bases.VirtualBases.count(BaseDecl))
3173 Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
3178 for (const auto &I : BaseDecl->bases())
3179 Flags |= ComputeVMIClassTypeInfoFlags(&I, Bases);
3184 static unsigned ComputeVMIClassTypeInfoFlags(const CXXRecordDecl *RD) {
3189 for (const auto &I : RD->bases())
3190 Flags |= ComputeVMIClassTypeInfoFlags(&I, Bases);
3195 /// BuildVMIClassTypeInfo - Build an abi::__vmi_class_type_info, used for
3196 /// classes with bases that do not satisfy the abi::__si_class_type_info
3197 /// constraints, according ti the Itanium C++ ABI, 2.9.5p5c.
3198 void ItaniumRTTIBuilder::BuildVMIClassTypeInfo(const CXXRecordDecl *RD) {
3199 llvm::Type *UnsignedIntLTy =
3200 CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy);
3202 // Itanium C++ ABI 2.9.5p6c:
3203 // __flags is a word with flags describing details about the class
3204 // structure, which may be referenced by using the __flags_masks
3205 // enumeration. These flags refer to both direct and indirect bases.
3206 unsigned Flags = ComputeVMIClassTypeInfoFlags(RD);
3207 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3209 // Itanium C++ ABI 2.9.5p6c:
3210 // __base_count is a word with the number of direct proper base class
3211 // descriptions that follow.
3212 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, RD->getNumBases()));
3214 if (!RD->getNumBases())
3217 llvm::Type *LongLTy =
3218 CGM.getTypes().ConvertType(CGM.getContext().LongTy);
3220 // Now add the base class descriptions.
3222 // Itanium C++ ABI 2.9.5p6c:
3223 // __base_info[] is an array of base class descriptions -- one for every
3224 // direct proper base. Each description is of the type:
3226 // struct abi::__base_class_type_info {
3228 // const __class_type_info *__base_type;
3229 // long __offset_flags;
3231 // enum __offset_flags_masks {
3232 // __virtual_mask = 0x1,
3233 // __public_mask = 0x2,
3234 // __offset_shift = 8
3237 for (const auto &Base : RD->bases()) {
3238 // The __base_type member points to the RTTI for the base type.
3239 Fields.push_back(ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(Base.getType()));
3241 const CXXRecordDecl *BaseDecl =
3242 cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
3244 int64_t OffsetFlags = 0;
3246 // All but the lower 8 bits of __offset_flags are a signed offset.
3247 // For a non-virtual base, this is the offset in the object of the base
3248 // subobject. For a virtual base, this is the offset in the virtual table of
3249 // the virtual base offset for the virtual base referenced (negative).
3251 if (Base.isVirtual())
3253 CGM.getItaniumVTableContext().getVirtualBaseOffsetOffset(RD, BaseDecl);
3255 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
3256 Offset = Layout.getBaseClassOffset(BaseDecl);
3259 OffsetFlags = uint64_t(Offset.getQuantity()) << 8;
3261 // The low-order byte of __offset_flags contains flags, as given by the
3262 // masks from the enumeration __offset_flags_masks.
3263 if (Base.isVirtual())
3264 OffsetFlags |= BCTI_Virtual;
3265 if (Base.getAccessSpecifier() == AS_public)
3266 OffsetFlags |= BCTI_Public;
3268 Fields.push_back(llvm::ConstantInt::get(LongLTy, OffsetFlags));
3272 /// BuildPointerTypeInfo - Build an abi::__pointer_type_info struct,
3273 /// used for pointer types.
3274 void ItaniumRTTIBuilder::BuildPointerTypeInfo(QualType PointeeTy) {
3276 QualType UnqualifiedPointeeTy =
3277 CGM.getContext().getUnqualifiedArrayType(PointeeTy, Quals);
3279 // Itanium C++ ABI 2.9.5p7:
3280 // __flags is a flag word describing the cv-qualification and other
3281 // attributes of the type pointed to
3282 unsigned Flags = ComputeQualifierFlags(Quals);
3284 // Itanium C++ ABI 2.9.5p7:
3285 // When the abi::__pbase_type_info is for a direct or indirect pointer to an
3286 // incomplete class type, the incomplete target type flag is set.
3287 if (ContainsIncompleteClassType(UnqualifiedPointeeTy))
3288 Flags |= PTI_Incomplete;
3290 llvm::Type *UnsignedIntLTy =
3291 CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy);
3292 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3294 // Itanium C++ ABI 2.9.5p7:
3295 // __pointee is a pointer to the std::type_info derivation for the
3296 // unqualified type being pointed to.
3297 llvm::Constant *PointeeTypeInfo =
3298 ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(UnqualifiedPointeeTy);
3299 Fields.push_back(PointeeTypeInfo);
3302 /// BuildPointerToMemberTypeInfo - Build an abi::__pointer_to_member_type_info
3303 /// struct, used for member pointer types.
3305 ItaniumRTTIBuilder::BuildPointerToMemberTypeInfo(const MemberPointerType *Ty) {
3306 QualType PointeeTy = Ty->getPointeeType();
3309 QualType UnqualifiedPointeeTy =
3310 CGM.getContext().getUnqualifiedArrayType(PointeeTy, Quals);
3312 // Itanium C++ ABI 2.9.5p7:
3313 // __flags is a flag word describing the cv-qualification and other
3314 // attributes of the type pointed to.
3315 unsigned Flags = ComputeQualifierFlags(Quals);
3317 const RecordType *ClassType = cast<RecordType>(Ty->getClass());
3319 // Itanium C++ ABI 2.9.5p7:
3320 // When the abi::__pbase_type_info is for a direct or indirect pointer to an
3321 // incomplete class type, the incomplete target type flag is set.
3322 if (ContainsIncompleteClassType(UnqualifiedPointeeTy))
3323 Flags |= PTI_Incomplete;
3325 if (IsIncompleteClassType(ClassType))
3326 Flags |= PTI_ContainingClassIncomplete;
3328 llvm::Type *UnsignedIntLTy =
3329 CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy);
3330 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3332 // Itanium C++ ABI 2.9.5p7:
3333 // __pointee is a pointer to the std::type_info derivation for the
3334 // unqualified type being pointed to.
3335 llvm::Constant *PointeeTypeInfo =
3336 ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(UnqualifiedPointeeTy);
3337 Fields.push_back(PointeeTypeInfo);
3339 // Itanium C++ ABI 2.9.5p9:
3340 // __context is a pointer to an abi::__class_type_info corresponding to the
3341 // class type containing the member pointed to
3342 // (e.g., the "A" in "int A::*").
3344 ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(QualType(ClassType, 0)));
3347 llvm::Constant *ItaniumCXXABI::getAddrOfRTTIDescriptor(QualType Ty) {
3348 return ItaniumRTTIBuilder(*this).BuildTypeInfo(Ty);
3351 void ItaniumCXXABI::EmitFundamentalRTTIDescriptor(QualType Type) {
3352 QualType PointerType = getContext().getPointerType(Type);
3353 QualType PointerTypeConst = getContext().getPointerType(Type.withConst());
3354 ItaniumRTTIBuilder(*this).BuildTypeInfo(Type, true);
3355 ItaniumRTTIBuilder(*this).BuildTypeInfo(PointerType, true);
3356 ItaniumRTTIBuilder(*this).BuildTypeInfo(PointerTypeConst, true);
3359 void ItaniumCXXABI::EmitFundamentalRTTIDescriptors() {
3360 // Types added here must also be added to TypeInfoIsInStandardLibrary.
3361 QualType FundamentalTypes[] = {
3362 getContext().VoidTy, getContext().NullPtrTy,
3363 getContext().BoolTy, getContext().WCharTy,
3364 getContext().CharTy, getContext().UnsignedCharTy,
3365 getContext().SignedCharTy, getContext().ShortTy,
3366 getContext().UnsignedShortTy, getContext().IntTy,
3367 getContext().UnsignedIntTy, getContext().LongTy,
3368 getContext().UnsignedLongTy, getContext().LongLongTy,
3369 getContext().UnsignedLongLongTy, getContext().Int128Ty,
3370 getContext().UnsignedInt128Ty, getContext().HalfTy,
3371 getContext().FloatTy, getContext().DoubleTy,
3372 getContext().LongDoubleTy, getContext().Float128Ty,
3373 getContext().Char16Ty, getContext().Char32Ty
3375 for (const QualType &FundamentalType : FundamentalTypes)
3376 EmitFundamentalRTTIDescriptor(FundamentalType);
3379 /// What sort of uniqueness rules should we use for the RTTI for the
3381 ItaniumCXXABI::RTTIUniquenessKind ItaniumCXXABI::classifyRTTIUniqueness(
3382 QualType CanTy, llvm::GlobalValue::LinkageTypes Linkage) const {
3383 if (shouldRTTIBeUnique())
3386 // It's only necessary for linkonce_odr or weak_odr linkage.
3387 if (Linkage != llvm::GlobalValue::LinkOnceODRLinkage &&
3388 Linkage != llvm::GlobalValue::WeakODRLinkage)
3391 // It's only necessary with default visibility.
3392 if (CanTy->getVisibility() != DefaultVisibility)
3395 // If we're not required to publish this symbol, hide it.
3396 if (Linkage == llvm::GlobalValue::LinkOnceODRLinkage)
3397 return RUK_NonUniqueHidden;
3399 // If we're required to publish this symbol, as we might be under an
3400 // explicit instantiation, leave it with default visibility but
3401 // enable string-comparisons.
3402 assert(Linkage == llvm::GlobalValue::WeakODRLinkage);
3403 return RUK_NonUniqueVisible;
3406 // Find out how to codegen the complete destructor and constructor
3408 enum class StructorCodegen { Emit, RAUW, Alias, COMDAT };
3410 static StructorCodegen getCodegenToUse(CodeGenModule &CGM,
3411 const CXXMethodDecl *MD) {
3412 if (!CGM.getCodeGenOpts().CXXCtorDtorAliases)
3413 return StructorCodegen::Emit;
3415 // The complete and base structors are not equivalent if there are any virtual
3416 // bases, so emit separate functions.
3417 if (MD->getParent()->getNumVBases())
3418 return StructorCodegen::Emit;
3420 GlobalDecl AliasDecl;
3421 if (const auto *DD = dyn_cast<CXXDestructorDecl>(MD)) {
3422 AliasDecl = GlobalDecl(DD, Dtor_Complete);
3424 const auto *CD = cast<CXXConstructorDecl>(MD);
3425 AliasDecl = GlobalDecl(CD, Ctor_Complete);
3427 llvm::GlobalValue::LinkageTypes Linkage = CGM.getFunctionLinkage(AliasDecl);
3429 if (llvm::GlobalValue::isDiscardableIfUnused(Linkage))
3430 return StructorCodegen::RAUW;
3432 // FIXME: Should we allow available_externally aliases?
3433 if (!llvm::GlobalAlias::isValidLinkage(Linkage))
3434 return StructorCodegen::RAUW;
3436 if (llvm::GlobalValue::isWeakForLinker(Linkage)) {
3437 // Only ELF supports COMDATs with arbitrary names (C5/D5).
3438 if (CGM.getTarget().getTriple().isOSBinFormatELF())
3439 return StructorCodegen::COMDAT;
3440 return StructorCodegen::Emit;
3443 return StructorCodegen::Alias;
3446 static void emitConstructorDestructorAlias(CodeGenModule &CGM,
3447 GlobalDecl AliasDecl,
3448 GlobalDecl TargetDecl) {
3449 llvm::GlobalValue::LinkageTypes Linkage = CGM.getFunctionLinkage(AliasDecl);
3451 StringRef MangledName = CGM.getMangledName(AliasDecl);
3452 llvm::GlobalValue *Entry = CGM.GetGlobalValue(MangledName);
3453 if (Entry && !Entry->isDeclaration())
3456 auto *Aliasee = cast<llvm::GlobalValue>(CGM.GetAddrOfGlobal(TargetDecl));
3458 // Create the alias with no name.
3459 auto *Alias = llvm::GlobalAlias::create(Linkage, "", Aliasee);
3461 // Switch any previous uses to the alias.
3463 assert(Entry->getType() == Aliasee->getType() &&
3464 "declaration exists with different type");
3465 Alias->takeName(Entry);
3466 Entry->replaceAllUsesWith(Alias);
3467 Entry->eraseFromParent();
3469 Alias->setName(MangledName);
3472 // Finally, set up the alias with its proper name and attributes.
3473 CGM.setAliasAttributes(cast<NamedDecl>(AliasDecl.getDecl()), Alias);
3476 void ItaniumCXXABI::emitCXXStructor(const CXXMethodDecl *MD,
3477 StructorType Type) {
3478 auto *CD = dyn_cast<CXXConstructorDecl>(MD);
3479 const CXXDestructorDecl *DD = CD ? nullptr : cast<CXXDestructorDecl>(MD);
3481 StructorCodegen CGType = getCodegenToUse(CGM, MD);
3483 if (Type == StructorType::Complete) {
3484 GlobalDecl CompleteDecl;
3485 GlobalDecl BaseDecl;
3487 CompleteDecl = GlobalDecl(CD, Ctor_Complete);
3488 BaseDecl = GlobalDecl(CD, Ctor_Base);
3490 CompleteDecl = GlobalDecl(DD, Dtor_Complete);
3491 BaseDecl = GlobalDecl(DD, Dtor_Base);
3494 if (CGType == StructorCodegen::Alias || CGType == StructorCodegen::COMDAT) {
3495 emitConstructorDestructorAlias(CGM, CompleteDecl, BaseDecl);
3499 if (CGType == StructorCodegen::RAUW) {
3500 StringRef MangledName = CGM.getMangledName(CompleteDecl);
3501 auto *Aliasee = CGM.GetAddrOfGlobal(BaseDecl);
3502 CGM.addReplacement(MangledName, Aliasee);
3507 // The base destructor is equivalent to the base destructor of its
3508 // base class if there is exactly one non-virtual base class with a
3509 // non-trivial destructor, there are no fields with a non-trivial
3510 // destructor, and the body of the destructor is trivial.
3511 if (DD && Type == StructorType::Base && CGType != StructorCodegen::COMDAT &&
3512 !CGM.TryEmitBaseDestructorAsAlias(DD))
3515 llvm::Function *Fn = CGM.codegenCXXStructor(MD, Type);
3517 if (CGType == StructorCodegen::COMDAT) {
3518 SmallString<256> Buffer;
3519 llvm::raw_svector_ostream Out(Buffer);
3521 getMangleContext().mangleCXXDtorComdat(DD, Out);
3523 getMangleContext().mangleCXXCtorComdat(CD, Out);
3524 llvm::Comdat *C = CGM.getModule().getOrInsertComdat(Out.str());
3527 CGM.maybeSetTrivialComdat(*MD, *Fn);
3531 static llvm::Constant *getBeginCatchFn(CodeGenModule &CGM) {
3532 // void *__cxa_begin_catch(void*);
3533 llvm::FunctionType *FTy = llvm::FunctionType::get(
3534 CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
3536 return CGM.CreateRuntimeFunction(FTy, "__cxa_begin_catch");
3539 static llvm::Constant *getEndCatchFn(CodeGenModule &CGM) {
3540 // void __cxa_end_catch();
3541 llvm::FunctionType *FTy =
3542 llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false);
3544 return CGM.CreateRuntimeFunction(FTy, "__cxa_end_catch");
3547 static llvm::Constant *getGetExceptionPtrFn(CodeGenModule &CGM) {
3548 // void *__cxa_get_exception_ptr(void*);
3549 llvm::FunctionType *FTy = llvm::FunctionType::get(
3550 CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
3552 return CGM.CreateRuntimeFunction(FTy, "__cxa_get_exception_ptr");
3556 /// A cleanup to call __cxa_end_catch. In many cases, the caught
3557 /// exception type lets us state definitively that the thrown exception
3558 /// type does not have a destructor. In particular:
3559 /// - Catch-alls tell us nothing, so we have to conservatively
3560 /// assume that the thrown exception might have a destructor.
3561 /// - Catches by reference behave according to their base types.
3562 /// - Catches of non-record types will only trigger for exceptions
3563 /// of non-record types, which never have destructors.
3564 /// - Catches of record types can trigger for arbitrary subclasses
3565 /// of the caught type, so we have to assume the actual thrown
3566 /// exception type might have a throwing destructor, even if the
3567 /// caught type's destructor is trivial or nothrow.
3568 struct CallEndCatch final : EHScopeStack::Cleanup {
3569 CallEndCatch(bool MightThrow) : MightThrow(MightThrow) {}
3572 void Emit(CodeGenFunction &CGF, Flags flags) override {
3574 CGF.EmitNounwindRuntimeCall(getEndCatchFn(CGF.CGM));
3578 CGF.EmitRuntimeCallOrInvoke(getEndCatchFn(CGF.CGM));
3583 /// Emits a call to __cxa_begin_catch and enters a cleanup to call
3584 /// __cxa_end_catch.
3586 /// \param EndMightThrow - true if __cxa_end_catch might throw
3587 static llvm::Value *CallBeginCatch(CodeGenFunction &CGF,
3589 bool EndMightThrow) {
3590 llvm::CallInst *call =
3591 CGF.EmitNounwindRuntimeCall(getBeginCatchFn(CGF.CGM), Exn);
3593 CGF.EHStack.pushCleanup<CallEndCatch>(NormalAndEHCleanup, EndMightThrow);
3598 /// A "special initializer" callback for initializing a catch
3599 /// parameter during catch initialization.
3600 static void InitCatchParam(CodeGenFunction &CGF,
3601 const VarDecl &CatchParam,
3603 SourceLocation Loc) {
3604 // Load the exception from where the landing pad saved it.
3605 llvm::Value *Exn = CGF.getExceptionFromSlot();
3607 CanQualType CatchType =
3608 CGF.CGM.getContext().getCanonicalType(CatchParam.getType());
3609 llvm::Type *LLVMCatchTy = CGF.ConvertTypeForMem(CatchType);
3611 // If we're catching by reference, we can just cast the object
3612 // pointer to the appropriate pointer.
3613 if (isa<ReferenceType>(CatchType)) {
3614 QualType CaughtType = cast<ReferenceType>(CatchType)->getPointeeType();
3615 bool EndCatchMightThrow = CaughtType->isRecordType();
3617 // __cxa_begin_catch returns the adjusted object pointer.
3618 llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, EndCatchMightThrow);
3620 // We have no way to tell the personality function that we're
3621 // catching by reference, so if we're catching a pointer,
3622 // __cxa_begin_catch will actually return that pointer by value.
3623 if (const PointerType *PT = dyn_cast<PointerType>(CaughtType)) {
3624 QualType PointeeType = PT->getPointeeType();
3626 // When catching by reference, generally we should just ignore
3627 // this by-value pointer and use the exception object instead.
3628 if (!PointeeType->isRecordType()) {
3630 // Exn points to the struct _Unwind_Exception header, which
3631 // we have to skip past in order to reach the exception data.
3632 unsigned HeaderSize =
3633 CGF.CGM.getTargetCodeGenInfo().getSizeOfUnwindException();
3634 AdjustedExn = CGF.Builder.CreateConstGEP1_32(Exn, HeaderSize);
3636 // However, if we're catching a pointer-to-record type that won't
3637 // work, because the personality function might have adjusted
3638 // the pointer. There's actually no way for us to fully satisfy
3639 // the language/ABI contract here: we can't use Exn because it
3640 // might have the wrong adjustment, but we can't use the by-value
3641 // pointer because it's off by a level of abstraction.
3643 // The current solution is to dump the adjusted pointer into an
3644 // alloca, which breaks language semantics (because changing the
3645 // pointer doesn't change the exception) but at least works.
3646 // The better solution would be to filter out non-exact matches
3647 // and rethrow them, but this is tricky because the rethrow
3648 // really needs to be catchable by other sites at this landing
3649 // pad. The best solution is to fix the personality function.
3651 // Pull the pointer for the reference type off.
3653 cast<llvm::PointerType>(LLVMCatchTy)->getElementType();
3655 // Create the temporary and write the adjusted pointer into it.
3657 CGF.CreateTempAlloca(PtrTy, CGF.getPointerAlign(), "exn.byref.tmp");
3658 llvm::Value *Casted = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
3659 CGF.Builder.CreateStore(Casted, ExnPtrTmp);
3661 // Bind the reference to the temporary.
3662 AdjustedExn = ExnPtrTmp.getPointer();
3666 llvm::Value *ExnCast =
3667 CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.byref");
3668 CGF.Builder.CreateStore(ExnCast, ParamAddr);
3672 // Scalars and complexes.
3673 TypeEvaluationKind TEK = CGF.getEvaluationKind(CatchType);
3674 if (TEK != TEK_Aggregate) {
3675 llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, false);
3677 // If the catch type is a pointer type, __cxa_begin_catch returns
3678 // the pointer by value.
3679 if (CatchType->hasPointerRepresentation()) {
3680 llvm::Value *CastExn =
3681 CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.casted");
3683 switch (CatchType.getQualifiers().getObjCLifetime()) {
3684 case Qualifiers::OCL_Strong:
3685 CastExn = CGF.EmitARCRetainNonBlock(CastExn);
3688 case Qualifiers::OCL_None:
3689 case Qualifiers::OCL_ExplicitNone:
3690 case Qualifiers::OCL_Autoreleasing:
3691 CGF.Builder.CreateStore(CastExn, ParamAddr);
3694 case Qualifiers::OCL_Weak:
3695 CGF.EmitARCInitWeak(ParamAddr, CastExn);
3698 llvm_unreachable("bad ownership qualifier!");
3701 // Otherwise, it returns a pointer into the exception object.
3703 llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
3704 llvm::Value *Cast = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
3706 LValue srcLV = CGF.MakeNaturalAlignAddrLValue(Cast, CatchType);
3707 LValue destLV = CGF.MakeAddrLValue(ParamAddr, CatchType);
3710 CGF.EmitStoreOfComplex(CGF.EmitLoadOfComplex(srcLV, Loc), destLV,
3714 llvm::Value *ExnLoad = CGF.EmitLoadOfScalar(srcLV, Loc);
3715 CGF.EmitStoreOfScalar(ExnLoad, destLV, /*init*/ true);
3719 llvm_unreachable("evaluation kind filtered out!");
3721 llvm_unreachable("bad evaluation kind");
3724 assert(isa<RecordType>(CatchType) && "unexpected catch type!");
3725 auto catchRD = CatchType->getAsCXXRecordDecl();
3726 CharUnits caughtExnAlignment = CGF.CGM.getClassPointerAlignment(catchRD);
3728 llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
3730 // Check for a copy expression. If we don't have a copy expression,
3731 // that means a trivial copy is okay.
3732 const Expr *copyExpr = CatchParam.getInit();
3734 llvm::Value *rawAdjustedExn = CallBeginCatch(CGF, Exn, true);
3735 Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
3736 caughtExnAlignment);
3737 CGF.EmitAggregateCopy(ParamAddr, adjustedExn, CatchType);
3741 // We have to call __cxa_get_exception_ptr to get the adjusted
3742 // pointer before copying.
3743 llvm::CallInst *rawAdjustedExn =
3744 CGF.EmitNounwindRuntimeCall(getGetExceptionPtrFn(CGF.CGM), Exn);
3746 // Cast that to the appropriate type.
3747 Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
3748 caughtExnAlignment);
3750 // The copy expression is defined in terms of an OpaqueValueExpr.
3751 // Find it and map it to the adjusted expression.
3752 CodeGenFunction::OpaqueValueMapping
3753 opaque(CGF, OpaqueValueExpr::findInCopyConstruct(copyExpr),
3754 CGF.MakeAddrLValue(adjustedExn, CatchParam.getType()));
3756 // Call the copy ctor in a terminate scope.
3757 CGF.EHStack.pushTerminate();
3759 // Perform the copy construction.
3760 CGF.EmitAggExpr(copyExpr,
3761 AggValueSlot::forAddr(ParamAddr, Qualifiers(),
3762 AggValueSlot::IsNotDestructed,
3763 AggValueSlot::DoesNotNeedGCBarriers,
3764 AggValueSlot::IsNotAliased));
3766 // Leave the terminate scope.
3767 CGF.EHStack.popTerminate();
3769 // Undo the opaque value mapping.
3772 // Finally we can call __cxa_begin_catch.
3773 CallBeginCatch(CGF, Exn, true);
3776 /// Begins a catch statement by initializing the catch variable and
3777 /// calling __cxa_begin_catch.
3778 void ItaniumCXXABI::emitBeginCatch(CodeGenFunction &CGF,
3779 const CXXCatchStmt *S) {
3780 // We have to be very careful with the ordering of cleanups here:
3781 // C++ [except.throw]p4:
3782 // The destruction [of the exception temporary] occurs
3783 // immediately after the destruction of the object declared in
3784 // the exception-declaration in the handler.
3786 // So the precise ordering is:
3787 // 1. Construct catch variable.
3788 // 2. __cxa_begin_catch
3789 // 3. Enter __cxa_end_catch cleanup
3790 // 4. Enter dtor cleanup
3792 // We do this by using a slightly abnormal initialization process.
3793 // Delegation sequence:
3794 // - ExitCXXTryStmt opens a RunCleanupsScope
3795 // - EmitAutoVarAlloca creates the variable and debug info
3796 // - InitCatchParam initializes the variable from the exception
3797 // - CallBeginCatch calls __cxa_begin_catch
3798 // - CallBeginCatch enters the __cxa_end_catch cleanup
3799 // - EmitAutoVarCleanups enters the variable destructor cleanup
3800 // - EmitCXXTryStmt emits the code for the catch body
3801 // - EmitCXXTryStmt close the RunCleanupsScope
3803 VarDecl *CatchParam = S->getExceptionDecl();
3805 llvm::Value *Exn = CGF.getExceptionFromSlot();
3806 CallBeginCatch(CGF, Exn, true);
3811 CodeGenFunction::AutoVarEmission var = CGF.EmitAutoVarAlloca(*CatchParam);
3812 InitCatchParam(CGF, *CatchParam, var.getObjectAddress(CGF), S->getLocStart());
3813 CGF.EmitAutoVarCleanups(var);
3816 /// Get or define the following function:
3817 /// void @__clang_call_terminate(i8* %exn) nounwind noreturn
3818 /// This code is used only in C++.
3819 static llvm::Constant *getClangCallTerminateFn(CodeGenModule &CGM) {
3820 llvm::FunctionType *fnTy =
3821 llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
3822 llvm::Constant *fnRef =
3823 CGM.CreateRuntimeFunction(fnTy, "__clang_call_terminate");
3825 llvm::Function *fn = dyn_cast<llvm::Function>(fnRef);
3826 if (fn && fn->empty()) {
3827 fn->setDoesNotThrow();
3828 fn->setDoesNotReturn();
3830 // What we really want is to massively penalize inlining without
3831 // forbidding it completely. The difference between that and
3832 // 'noinline' is negligible.
3833 fn->addFnAttr(llvm::Attribute::NoInline);
3835 // Allow this function to be shared across translation units, but
3836 // we don't want it to turn into an exported symbol.
3837 fn->setLinkage(llvm::Function::LinkOnceODRLinkage);
3838 fn->setVisibility(llvm::Function::HiddenVisibility);
3839 if (CGM.supportsCOMDAT())
3840 fn->setComdat(CGM.getModule().getOrInsertComdat(fn->getName()));
3842 // Set up the function.
3843 llvm::BasicBlock *entry =
3844 llvm::BasicBlock::Create(CGM.getLLVMContext(), "", fn);
3845 CGBuilderTy builder(CGM, entry);
3847 // Pull the exception pointer out of the parameter list.
3848 llvm::Value *exn = &*fn->arg_begin();
3850 // Call __cxa_begin_catch(exn).
3851 llvm::CallInst *catchCall = builder.CreateCall(getBeginCatchFn(CGM), exn);
3852 catchCall->setDoesNotThrow();
3853 catchCall->setCallingConv(CGM.getRuntimeCC());
3855 // Call std::terminate().
3856 llvm::CallInst *termCall = builder.CreateCall(CGM.getTerminateFn());
3857 termCall->setDoesNotThrow();
3858 termCall->setDoesNotReturn();
3859 termCall->setCallingConv(CGM.getRuntimeCC());
3861 // std::terminate cannot return.
3862 builder.CreateUnreachable();
3869 ItaniumCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
3871 // In C++, we want to call __cxa_begin_catch() before terminating.
3873 assert(CGF.CGM.getLangOpts().CPlusPlus);
3874 return CGF.EmitNounwindRuntimeCall(getClangCallTerminateFn(CGF.CGM), Exn);
3876 return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn());