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 "CGRecordLayout.h"
23 #include "CGVTables.h"
24 #include "CodeGenFunction.h"
25 #include "CodeGenModule.h"
26 #include "clang/AST/Mangle.h"
27 #include "clang/AST/Type.h"
28 #include "llvm/IR/CallSite.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/Intrinsics.h"
31 #include "llvm/IR/Value.h"
33 using namespace clang;
34 using namespace CodeGen;
37 class ItaniumCXXABI : public CodeGen::CGCXXABI {
38 /// VTables - All the vtables which have been defined.
39 llvm::DenseMap<const CXXRecordDecl *, llvm::GlobalVariable *> VTables;
42 bool UseARMMethodPtrABI;
43 bool UseARMGuardVarABI;
45 ItaniumMangleContext &getMangleContext() {
46 return cast<ItaniumMangleContext>(CodeGen::CGCXXABI::getMangleContext());
50 ItaniumCXXABI(CodeGen::CodeGenModule &CGM,
51 bool UseARMMethodPtrABI = false,
52 bool UseARMGuardVarABI = false) :
53 CGCXXABI(CGM), UseARMMethodPtrABI(UseARMMethodPtrABI),
54 UseARMGuardVarABI(UseARMGuardVarABI) { }
56 bool classifyReturnType(CGFunctionInfo &FI) const override;
58 RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const override {
59 // Structures with either a non-trivial destructor or a non-trivial
60 // copy constructor are always indirect.
61 // FIXME: Use canCopyArgument() when it is fixed to handle lazily declared
63 if (RD->hasNonTrivialDestructor() || RD->hasNonTrivialCopyConstructor())
68 bool isZeroInitializable(const MemberPointerType *MPT) override;
70 llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT) override;
73 EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
76 llvm::Value *MemFnPtr,
77 const MemberPointerType *MPT) override;
80 EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
83 const MemberPointerType *MPT) override;
85 llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,
87 llvm::Value *Src) override;
88 llvm::Constant *EmitMemberPointerConversion(const CastExpr *E,
89 llvm::Constant *Src) override;
91 llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT) override;
93 llvm::Constant *EmitMemberPointer(const CXXMethodDecl *MD) override;
94 llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT,
95 CharUnits offset) override;
96 llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT) override;
97 llvm::Constant *BuildMemberPointer(const CXXMethodDecl *MD,
98 CharUnits ThisAdjustment);
100 llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF,
101 llvm::Value *L, llvm::Value *R,
102 const MemberPointerType *MPT,
103 bool Inequality) override;
105 llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
107 const MemberPointerType *MPT) override;
109 void emitVirtualObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE,
110 llvm::Value *Ptr, QualType ElementType,
111 const CXXDestructorDecl *Dtor) override;
113 void emitRethrow(CodeGenFunction &CGF, bool isNoReturn) override;
115 void EmitFundamentalRTTIDescriptor(QualType Type);
116 void EmitFundamentalRTTIDescriptors();
117 llvm::Constant *getAddrOfRTTIDescriptor(QualType Ty) override;
119 bool shouldTypeidBeNullChecked(bool IsDeref, QualType SrcRecordTy) override;
120 void EmitBadTypeidCall(CodeGenFunction &CGF) override;
121 llvm::Value *EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy,
122 llvm::Value *ThisPtr,
123 llvm::Type *StdTypeInfoPtrTy) override;
125 bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
126 QualType SrcRecordTy) override;
128 llvm::Value *EmitDynamicCastCall(CodeGenFunction &CGF, llvm::Value *Value,
129 QualType SrcRecordTy, QualType DestTy,
130 QualType DestRecordTy,
131 llvm::BasicBlock *CastEnd) override;
133 llvm::Value *EmitDynamicCastToVoid(CodeGenFunction &CGF, llvm::Value *Value,
134 QualType SrcRecordTy,
135 QualType DestTy) override;
137 bool EmitBadCastCall(CodeGenFunction &CGF) override;
140 GetVirtualBaseClassOffset(CodeGenFunction &CGF, llvm::Value *This,
141 const CXXRecordDecl *ClassDecl,
142 const CXXRecordDecl *BaseClassDecl) override;
144 void EmitCXXConstructors(const CXXConstructorDecl *D) override;
146 void buildStructorSignature(const CXXMethodDecl *MD, StructorType T,
147 SmallVectorImpl<CanQualType> &ArgTys) override;
149 bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor,
150 CXXDtorType DT) const override {
151 // Itanium does not emit any destructor variant as an inline thunk.
152 // Delegating may occur as an optimization, but all variants are either
153 // emitted with external linkage or as linkonce if they are inline and used.
157 void EmitCXXDestructors(const CXXDestructorDecl *D) override;
159 void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy,
160 FunctionArgList &Params) override;
162 void EmitInstanceFunctionProlog(CodeGenFunction &CGF) override;
164 unsigned addImplicitConstructorArgs(CodeGenFunction &CGF,
165 const CXXConstructorDecl *D,
166 CXXCtorType Type, bool ForVirtualBase,
168 CallArgList &Args) override;
170 void EmitDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *DD,
171 CXXDtorType Type, bool ForVirtualBase,
172 bool Delegating, llvm::Value *This) override;
174 void emitVTableDefinitions(CodeGenVTables &CGVT,
175 const CXXRecordDecl *RD) override;
177 llvm::Value *getVTableAddressPointInStructor(
178 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass,
179 BaseSubobject Base, const CXXRecordDecl *NearestVBase,
180 bool &NeedsVirtualOffset) override;
183 getVTableAddressPointForConstExpr(BaseSubobject Base,
184 const CXXRecordDecl *VTableClass) override;
186 llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD,
187 CharUnits VPtrOffset) override;
189 llvm::Value *getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD,
191 llvm::Type *Ty) override;
193 llvm::Value *EmitVirtualDestructorCall(CodeGenFunction &CGF,
194 const CXXDestructorDecl *Dtor,
195 CXXDtorType DtorType,
197 const CXXMemberCallExpr *CE) override;
199 void emitVirtualInheritanceTables(const CXXRecordDecl *RD) override;
201 void setThunkLinkage(llvm::Function *Thunk, bool ForVTable, GlobalDecl GD,
202 bool ReturnAdjustment) override {
203 // Allow inlining of thunks by emitting them with available_externally
204 // linkage together with vtables when needed.
206 Thunk->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
209 llvm::Value *performThisAdjustment(CodeGenFunction &CGF, llvm::Value *This,
210 const ThisAdjustment &TA) override;
212 llvm::Value *performReturnAdjustment(CodeGenFunction &CGF, llvm::Value *Ret,
213 const ReturnAdjustment &RA) override;
215 size_t getSrcArgforCopyCtor(const CXXConstructorDecl *,
216 FunctionArgList &Args) const override {
217 assert(!Args.empty() && "expected the arglist to not be empty!");
218 return Args.size() - 1;
221 StringRef GetPureVirtualCallName() override { return "__cxa_pure_virtual"; }
222 StringRef GetDeletedVirtualCallName() override
223 { return "__cxa_deleted_virtual"; }
225 CharUnits getArrayCookieSizeImpl(QualType elementType) override;
226 llvm::Value *InitializeArrayCookie(CodeGenFunction &CGF,
228 llvm::Value *NumElements,
229 const CXXNewExpr *expr,
230 QualType ElementType) override;
231 llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF,
232 llvm::Value *allocPtr,
233 CharUnits cookieSize) override;
235 void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
236 llvm::GlobalVariable *DeclPtr,
237 bool PerformInit) override;
238 void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
239 llvm::Constant *dtor, llvm::Constant *addr) override;
241 llvm::Function *getOrCreateThreadLocalWrapper(const VarDecl *VD,
243 void EmitThreadLocalInitFuncs(
245 ArrayRef<std::pair<const VarDecl *, llvm::GlobalVariable *>>
247 ArrayRef<llvm::Function *> CXXThreadLocalInits,
248 ArrayRef<llvm::GlobalVariable *> CXXThreadLocalInitVars) override;
250 bool usesThreadWrapperFunction() const override { return true; }
251 LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD,
252 QualType LValType) override;
254 bool NeedsVTTParameter(GlobalDecl GD) override;
256 /**************************** RTTI Uniqueness ******************************/
259 /// Returns true if the ABI requires RTTI type_info objects to be unique
260 /// across a program.
261 virtual bool shouldRTTIBeUnique() const { return true; }
264 /// What sort of unique-RTTI behavior should we use?
265 enum RTTIUniquenessKind {
266 /// We are guaranteeing, or need to guarantee, that the RTTI string
270 /// We are not guaranteeing uniqueness for the RTTI string, so we
271 /// can demote to hidden visibility but must use string comparisons.
274 /// We are not guaranteeing uniqueness for the RTTI string, so we
275 /// have to use string comparisons, but we also have to emit it with
276 /// non-hidden visibility.
280 /// Return the required visibility status for the given type and linkage in
283 classifyRTTIUniqueness(QualType CanTy,
284 llvm::GlobalValue::LinkageTypes Linkage) const;
285 friend class ItaniumRTTIBuilder;
287 void emitCXXStructor(const CXXMethodDecl *MD, StructorType Type) override;
290 class ARMCXXABI : public ItaniumCXXABI {
292 ARMCXXABI(CodeGen::CodeGenModule &CGM) :
293 ItaniumCXXABI(CGM, /* UseARMMethodPtrABI = */ true,
294 /* UseARMGuardVarABI = */ true) {}
296 bool HasThisReturn(GlobalDecl GD) const override {
297 return (isa<CXXConstructorDecl>(GD.getDecl()) || (
298 isa<CXXDestructorDecl>(GD.getDecl()) &&
299 GD.getDtorType() != Dtor_Deleting));
302 void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV,
303 QualType ResTy) override;
305 CharUnits getArrayCookieSizeImpl(QualType elementType) override;
306 llvm::Value *InitializeArrayCookie(CodeGenFunction &CGF,
308 llvm::Value *NumElements,
309 const CXXNewExpr *expr,
310 QualType ElementType) override;
311 llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF, llvm::Value *allocPtr,
312 CharUnits cookieSize) override;
315 class iOS64CXXABI : public ARMCXXABI {
317 iOS64CXXABI(CodeGen::CodeGenModule &CGM) : ARMCXXABI(CGM) {}
319 // ARM64 libraries are prepared for non-unique RTTI.
320 bool shouldRTTIBeUnique() const override { return false; }
324 CodeGen::CGCXXABI *CodeGen::CreateItaniumCXXABI(CodeGenModule &CGM) {
325 switch (CGM.getTarget().getCXXABI().getKind()) {
326 // For IR-generation purposes, there's no significant difference
327 // between the ARM and iOS ABIs.
328 case TargetCXXABI::GenericARM:
329 case TargetCXXABI::iOS:
330 return new ARMCXXABI(CGM);
332 case TargetCXXABI::iOS64:
333 return new iOS64CXXABI(CGM);
335 // Note that AArch64 uses the generic ItaniumCXXABI class since it doesn't
336 // include the other 32-bit ARM oddities: constructor/destructor return values
337 // and array cookies.
338 case TargetCXXABI::GenericAArch64:
339 return new ItaniumCXXABI(CGM, /* UseARMMethodPtrABI = */ true,
340 /* UseARMGuardVarABI = */ true);
342 case TargetCXXABI::GenericMIPS:
343 return new ItaniumCXXABI(CGM, /* UseARMMethodPtrABI = */ true);
345 case TargetCXXABI::GenericItanium:
346 if (CGM.getContext().getTargetInfo().getTriple().getArch()
347 == llvm::Triple::le32) {
348 // For PNaCl, use ARM-style method pointers so that PNaCl code
349 // does not assume anything about the alignment of function
351 return new ItaniumCXXABI(CGM, /* UseARMMethodPtrABI = */ true,
352 /* UseARMGuardVarABI = */ false);
354 return new ItaniumCXXABI(CGM);
356 case TargetCXXABI::Microsoft:
357 llvm_unreachable("Microsoft ABI is not Itanium-based");
359 llvm_unreachable("bad ABI kind");
363 ItaniumCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
364 if (MPT->isMemberDataPointer())
365 return CGM.PtrDiffTy;
366 return llvm::StructType::get(CGM.PtrDiffTy, CGM.PtrDiffTy, nullptr);
369 /// In the Itanium and ARM ABIs, method pointers have the form:
370 /// struct { ptrdiff_t ptr; ptrdiff_t adj; } memptr;
372 /// In the Itanium ABI:
373 /// - method pointers are virtual if (memptr.ptr & 1) is nonzero
374 /// - the this-adjustment is (memptr.adj)
375 /// - the virtual offset is (memptr.ptr - 1)
378 /// - method pointers are virtual if (memptr.adj & 1) is nonzero
379 /// - the this-adjustment is (memptr.adj >> 1)
380 /// - the virtual offset is (memptr.ptr)
381 /// ARM uses 'adj' for the virtual flag because Thumb functions
382 /// may be only single-byte aligned.
384 /// If the member is virtual, the adjusted 'this' pointer points
385 /// to a vtable pointer from which the virtual offset is applied.
387 /// If the member is non-virtual, memptr.ptr is the address of
388 /// the function to call.
389 llvm::Value *ItaniumCXXABI::EmitLoadOfMemberFunctionPointer(
390 CodeGenFunction &CGF, const Expr *E, llvm::Value *&This,
391 llvm::Value *MemFnPtr, const MemberPointerType *MPT) {
392 CGBuilderTy &Builder = CGF.Builder;
394 const FunctionProtoType *FPT =
395 MPT->getPointeeType()->getAs<FunctionProtoType>();
396 const CXXRecordDecl *RD =
397 cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
399 llvm::FunctionType *FTy =
400 CGM.getTypes().GetFunctionType(
401 CGM.getTypes().arrangeCXXMethodType(RD, FPT));
403 llvm::Constant *ptrdiff_1 = llvm::ConstantInt::get(CGM.PtrDiffTy, 1);
405 llvm::BasicBlock *FnVirtual = CGF.createBasicBlock("memptr.virtual");
406 llvm::BasicBlock *FnNonVirtual = CGF.createBasicBlock("memptr.nonvirtual");
407 llvm::BasicBlock *FnEnd = CGF.createBasicBlock("memptr.end");
409 // Extract memptr.adj, which is in the second field.
410 llvm::Value *RawAdj = Builder.CreateExtractValue(MemFnPtr, 1, "memptr.adj");
412 // Compute the true adjustment.
413 llvm::Value *Adj = RawAdj;
414 if (UseARMMethodPtrABI)
415 Adj = Builder.CreateAShr(Adj, ptrdiff_1, "memptr.adj.shifted");
417 // Apply the adjustment and cast back to the original struct type
419 llvm::Value *Ptr = Builder.CreateBitCast(This, Builder.getInt8PtrTy());
420 Ptr = Builder.CreateInBoundsGEP(Ptr, Adj);
421 This = Builder.CreateBitCast(Ptr, This->getType(), "this.adjusted");
423 // Load the function pointer.
424 llvm::Value *FnAsInt = Builder.CreateExtractValue(MemFnPtr, 0, "memptr.ptr");
426 // If the LSB in the function pointer is 1, the function pointer points to
427 // a virtual function.
428 llvm::Value *IsVirtual;
429 if (UseARMMethodPtrABI)
430 IsVirtual = Builder.CreateAnd(RawAdj, ptrdiff_1);
432 IsVirtual = Builder.CreateAnd(FnAsInt, ptrdiff_1);
433 IsVirtual = Builder.CreateIsNotNull(IsVirtual, "memptr.isvirtual");
434 Builder.CreateCondBr(IsVirtual, FnVirtual, FnNonVirtual);
436 // In the virtual path, the adjustment left 'This' pointing to the
437 // vtable of the correct base subobject. The "function pointer" is an
438 // offset within the vtable (+1 for the virtual flag on non-ARM).
439 CGF.EmitBlock(FnVirtual);
441 // Cast the adjusted this to a pointer to vtable pointer and load.
442 llvm::Type *VTableTy = Builder.getInt8PtrTy();
443 llvm::Value *VTable = CGF.GetVTablePtr(This, VTableTy);
446 llvm::Value *VTableOffset = FnAsInt;
447 if (!UseARMMethodPtrABI)
448 VTableOffset = Builder.CreateSub(VTableOffset, ptrdiff_1);
449 VTable = Builder.CreateGEP(VTable, VTableOffset);
451 // Load the virtual function to call.
452 VTable = Builder.CreateBitCast(VTable, FTy->getPointerTo()->getPointerTo());
453 llvm::Value *VirtualFn = Builder.CreateLoad(VTable, "memptr.virtualfn");
454 CGF.EmitBranch(FnEnd);
456 // In the non-virtual path, the function pointer is actually a
458 CGF.EmitBlock(FnNonVirtual);
459 llvm::Value *NonVirtualFn =
460 Builder.CreateIntToPtr(FnAsInt, FTy->getPointerTo(), "memptr.nonvirtualfn");
463 CGF.EmitBlock(FnEnd);
464 llvm::PHINode *Callee = Builder.CreatePHI(FTy->getPointerTo(), 2);
465 Callee->addIncoming(VirtualFn, FnVirtual);
466 Callee->addIncoming(NonVirtualFn, FnNonVirtual);
470 /// Compute an l-value by applying the given pointer-to-member to a
472 llvm::Value *ItaniumCXXABI::EmitMemberDataPointerAddress(
473 CodeGenFunction &CGF, const Expr *E, llvm::Value *Base, llvm::Value *MemPtr,
474 const MemberPointerType *MPT) {
475 assert(MemPtr->getType() == CGM.PtrDiffTy);
477 CGBuilderTy &Builder = CGF.Builder;
479 unsigned AS = Base->getType()->getPointerAddressSpace();
482 Base = Builder.CreateBitCast(Base, Builder.getInt8Ty()->getPointerTo(AS));
484 // Apply the offset, which we assume is non-null.
485 llvm::Value *Addr = Builder.CreateInBoundsGEP(Base, MemPtr, "memptr.offset");
487 // Cast the address to the appropriate pointer type, adopting the
488 // address space of the base pointer.
490 = CGF.ConvertTypeForMem(MPT->getPointeeType())->getPointerTo(AS);
491 return Builder.CreateBitCast(Addr, PType);
494 /// Perform a bitcast, derived-to-base, or base-to-derived member pointer
497 /// Bitcast conversions are always a no-op under Itanium.
499 /// Obligatory offset/adjustment diagram:
500 /// <-- offset --> <-- adjustment -->
501 /// |--------------------------|----------------------|--------------------|
502 /// ^Derived address point ^Base address point ^Member address point
504 /// So when converting a base member pointer to a derived member pointer,
505 /// we add the offset to the adjustment because the address point has
506 /// decreased; and conversely, when converting a derived MP to a base MP
507 /// we subtract the offset from the adjustment because the address point
510 /// The standard forbids (at compile time) conversion to and from
511 /// virtual bases, which is why we don't have to consider them here.
513 /// The standard forbids (at run time) casting a derived MP to a base
514 /// MP when the derived MP does not point to a member of the base.
515 /// This is why -1 is a reasonable choice for null data member
518 ItaniumCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
521 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
522 E->getCastKind() == CK_BaseToDerivedMemberPointer ||
523 E->getCastKind() == CK_ReinterpretMemberPointer);
525 // Under Itanium, reinterprets don't require any additional processing.
526 if (E->getCastKind() == CK_ReinterpretMemberPointer) return src;
528 // Use constant emission if we can.
529 if (isa<llvm::Constant>(src))
530 return EmitMemberPointerConversion(E, cast<llvm::Constant>(src));
532 llvm::Constant *adj = getMemberPointerAdjustment(E);
533 if (!adj) return src;
535 CGBuilderTy &Builder = CGF.Builder;
536 bool isDerivedToBase = (E->getCastKind() == CK_DerivedToBaseMemberPointer);
538 const MemberPointerType *destTy =
539 E->getType()->castAs<MemberPointerType>();
541 // For member data pointers, this is just a matter of adding the
542 // offset if the source is non-null.
543 if (destTy->isMemberDataPointer()) {
546 dst = Builder.CreateNSWSub(src, adj, "adj");
548 dst = Builder.CreateNSWAdd(src, adj, "adj");
551 llvm::Value *null = llvm::Constant::getAllOnesValue(src->getType());
552 llvm::Value *isNull = Builder.CreateICmpEQ(src, null, "memptr.isnull");
553 return Builder.CreateSelect(isNull, src, dst);
556 // The this-adjustment is left-shifted by 1 on ARM.
557 if (UseARMMethodPtrABI) {
558 uint64_t offset = cast<llvm::ConstantInt>(adj)->getZExtValue();
560 adj = llvm::ConstantInt::get(adj->getType(), offset);
563 llvm::Value *srcAdj = Builder.CreateExtractValue(src, 1, "src.adj");
566 dstAdj = Builder.CreateNSWSub(srcAdj, adj, "adj");
568 dstAdj = Builder.CreateNSWAdd(srcAdj, adj, "adj");
570 return Builder.CreateInsertValue(src, dstAdj, 1);
574 ItaniumCXXABI::EmitMemberPointerConversion(const CastExpr *E,
575 llvm::Constant *src) {
576 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
577 E->getCastKind() == CK_BaseToDerivedMemberPointer ||
578 E->getCastKind() == CK_ReinterpretMemberPointer);
580 // Under Itanium, reinterprets don't require any additional processing.
581 if (E->getCastKind() == CK_ReinterpretMemberPointer) return src;
583 // If the adjustment is trivial, we don't need to do anything.
584 llvm::Constant *adj = getMemberPointerAdjustment(E);
585 if (!adj) return src;
587 bool isDerivedToBase = (E->getCastKind() == CK_DerivedToBaseMemberPointer);
589 const MemberPointerType *destTy =
590 E->getType()->castAs<MemberPointerType>();
592 // For member data pointers, this is just a matter of adding the
593 // offset if the source is non-null.
594 if (destTy->isMemberDataPointer()) {
595 // null maps to null.
596 if (src->isAllOnesValue()) return src;
599 return llvm::ConstantExpr::getNSWSub(src, adj);
601 return llvm::ConstantExpr::getNSWAdd(src, adj);
604 // The this-adjustment is left-shifted by 1 on ARM.
605 if (UseARMMethodPtrABI) {
606 uint64_t offset = cast<llvm::ConstantInt>(adj)->getZExtValue();
608 adj = llvm::ConstantInt::get(adj->getType(), offset);
611 llvm::Constant *srcAdj = llvm::ConstantExpr::getExtractValue(src, 1);
612 llvm::Constant *dstAdj;
614 dstAdj = llvm::ConstantExpr::getNSWSub(srcAdj, adj);
616 dstAdj = llvm::ConstantExpr::getNSWAdd(srcAdj, adj);
618 return llvm::ConstantExpr::getInsertValue(src, dstAdj, 1);
622 ItaniumCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
623 // Itanium C++ ABI 2.3:
624 // A NULL pointer is represented as -1.
625 if (MPT->isMemberDataPointer())
626 return llvm::ConstantInt::get(CGM.PtrDiffTy, -1ULL, /*isSigned=*/true);
628 llvm::Constant *Zero = llvm::ConstantInt::get(CGM.PtrDiffTy, 0);
629 llvm::Constant *Values[2] = { Zero, Zero };
630 return llvm::ConstantStruct::getAnon(Values);
634 ItaniumCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
636 // Itanium C++ ABI 2.3:
637 // A pointer to data member is an offset from the base address of
638 // the class object containing it, represented as a ptrdiff_t
639 return llvm::ConstantInt::get(CGM.PtrDiffTy, offset.getQuantity());
642 llvm::Constant *ItaniumCXXABI::EmitMemberPointer(const CXXMethodDecl *MD) {
643 return BuildMemberPointer(MD, CharUnits::Zero());
646 llvm::Constant *ItaniumCXXABI::BuildMemberPointer(const CXXMethodDecl *MD,
647 CharUnits ThisAdjustment) {
648 assert(MD->isInstance() && "Member function must not be static!");
649 MD = MD->getCanonicalDecl();
651 CodeGenTypes &Types = CGM.getTypes();
653 // Get the function pointer (or index if this is a virtual function).
654 llvm::Constant *MemPtr[2];
655 if (MD->isVirtual()) {
656 uint64_t Index = CGM.getItaniumVTableContext().getMethodVTableIndex(MD);
658 const ASTContext &Context = getContext();
659 CharUnits PointerWidth =
660 Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
661 uint64_t VTableOffset = (Index * PointerWidth.getQuantity());
663 if (UseARMMethodPtrABI) {
664 // ARM C++ ABI 3.2.1:
665 // This ABI specifies that adj contains twice the this
666 // adjustment, plus 1 if the member function is virtual. The
667 // least significant bit of adj then makes exactly the same
668 // discrimination as the least significant bit of ptr does for
670 MemPtr[0] = llvm::ConstantInt::get(CGM.PtrDiffTy, VTableOffset);
671 MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
672 2 * ThisAdjustment.getQuantity() + 1);
674 // Itanium C++ ABI 2.3:
675 // For a virtual function, [the pointer field] is 1 plus the
676 // virtual table offset (in bytes) of the function,
677 // represented as a ptrdiff_t.
678 MemPtr[0] = llvm::ConstantInt::get(CGM.PtrDiffTy, VTableOffset + 1);
679 MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
680 ThisAdjustment.getQuantity());
683 const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
685 // Check whether the function has a computable LLVM signature.
686 if (Types.isFuncTypeConvertible(FPT)) {
687 // The function has a computable LLVM signature; use the correct type.
688 Ty = Types.GetFunctionType(Types.arrangeCXXMethodDeclaration(MD));
690 // Use an arbitrary non-function type to tell GetAddrOfFunction that the
691 // function type is incomplete.
694 llvm::Constant *addr = CGM.GetAddrOfFunction(MD, Ty);
696 MemPtr[0] = llvm::ConstantExpr::getPtrToInt(addr, CGM.PtrDiffTy);
697 MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
698 (UseARMMethodPtrABI ? 2 : 1) *
699 ThisAdjustment.getQuantity());
702 return llvm::ConstantStruct::getAnon(MemPtr);
705 llvm::Constant *ItaniumCXXABI::EmitMemberPointer(const APValue &MP,
707 const MemberPointerType *MPT = MPType->castAs<MemberPointerType>();
708 const ValueDecl *MPD = MP.getMemberPointerDecl();
710 return EmitNullMemberPointer(MPT);
712 CharUnits ThisAdjustment = getMemberPointerPathAdjustment(MP);
714 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MPD))
715 return BuildMemberPointer(MD, ThisAdjustment);
717 CharUnits FieldOffset =
718 getContext().toCharUnitsFromBits(getContext().getFieldOffset(MPD));
719 return EmitMemberDataPointer(MPT, ThisAdjustment + FieldOffset);
722 /// The comparison algorithm is pretty easy: the member pointers are
723 /// the same if they're either bitwise identical *or* both null.
725 /// ARM is different here only because null-ness is more complicated.
727 ItaniumCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
730 const MemberPointerType *MPT,
732 CGBuilderTy &Builder = CGF.Builder;
734 llvm::ICmpInst::Predicate Eq;
735 llvm::Instruction::BinaryOps And, Or;
737 Eq = llvm::ICmpInst::ICMP_NE;
738 And = llvm::Instruction::Or;
739 Or = llvm::Instruction::And;
741 Eq = llvm::ICmpInst::ICMP_EQ;
742 And = llvm::Instruction::And;
743 Or = llvm::Instruction::Or;
746 // Member data pointers are easy because there's a unique null
747 // value, so it just comes down to bitwise equality.
748 if (MPT->isMemberDataPointer())
749 return Builder.CreateICmp(Eq, L, R);
751 // For member function pointers, the tautologies are more complex.
752 // The Itanium tautology is:
753 // (L == R) <==> (L.ptr == R.ptr && (L.ptr == 0 || L.adj == R.adj))
754 // The ARM tautology is:
755 // (L == R) <==> (L.ptr == R.ptr &&
756 // (L.adj == R.adj ||
757 // (L.ptr == 0 && ((L.adj|R.adj) & 1) == 0)))
758 // The inequality tautologies have exactly the same structure, except
759 // applying De Morgan's laws.
761 llvm::Value *LPtr = Builder.CreateExtractValue(L, 0, "lhs.memptr.ptr");
762 llvm::Value *RPtr = Builder.CreateExtractValue(R, 0, "rhs.memptr.ptr");
764 // This condition tests whether L.ptr == R.ptr. This must always be
765 // true for equality to hold.
766 llvm::Value *PtrEq = Builder.CreateICmp(Eq, LPtr, RPtr, "cmp.ptr");
768 // This condition, together with the assumption that L.ptr == R.ptr,
769 // tests whether the pointers are both null. ARM imposes an extra
771 llvm::Value *Zero = llvm::Constant::getNullValue(LPtr->getType());
772 llvm::Value *EqZero = Builder.CreateICmp(Eq, LPtr, Zero, "cmp.ptr.null");
774 // This condition tests whether L.adj == R.adj. If this isn't
775 // true, the pointers are unequal unless they're both null.
776 llvm::Value *LAdj = Builder.CreateExtractValue(L, 1, "lhs.memptr.adj");
777 llvm::Value *RAdj = Builder.CreateExtractValue(R, 1, "rhs.memptr.adj");
778 llvm::Value *AdjEq = Builder.CreateICmp(Eq, LAdj, RAdj, "cmp.adj");
780 // Null member function pointers on ARM clear the low bit of Adj,
781 // so the zero condition has to check that neither low bit is set.
782 if (UseARMMethodPtrABI) {
783 llvm::Value *One = llvm::ConstantInt::get(LPtr->getType(), 1);
785 // Compute (l.adj | r.adj) & 1 and test it against zero.
786 llvm::Value *OrAdj = Builder.CreateOr(LAdj, RAdj, "or.adj");
787 llvm::Value *OrAdjAnd1 = Builder.CreateAnd(OrAdj, One);
788 llvm::Value *OrAdjAnd1EqZero = Builder.CreateICmp(Eq, OrAdjAnd1, Zero,
790 EqZero = Builder.CreateBinOp(And, EqZero, OrAdjAnd1EqZero);
793 // Tie together all our conditions.
794 llvm::Value *Result = Builder.CreateBinOp(Or, EqZero, AdjEq);
795 Result = Builder.CreateBinOp(And, PtrEq, Result,
796 Inequality ? "memptr.ne" : "memptr.eq");
801 ItaniumCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
803 const MemberPointerType *MPT) {
804 CGBuilderTy &Builder = CGF.Builder;
806 /// For member data pointers, this is just a check against -1.
807 if (MPT->isMemberDataPointer()) {
808 assert(MemPtr->getType() == CGM.PtrDiffTy);
809 llvm::Value *NegativeOne =
810 llvm::Constant::getAllOnesValue(MemPtr->getType());
811 return Builder.CreateICmpNE(MemPtr, NegativeOne, "memptr.tobool");
814 // In Itanium, a member function pointer is not null if 'ptr' is not null.
815 llvm::Value *Ptr = Builder.CreateExtractValue(MemPtr, 0, "memptr.ptr");
817 llvm::Constant *Zero = llvm::ConstantInt::get(Ptr->getType(), 0);
818 llvm::Value *Result = Builder.CreateICmpNE(Ptr, Zero, "memptr.tobool");
820 // On ARM, a member function pointer is also non-null if the low bit of 'adj'
821 // (the virtual bit) is set.
822 if (UseARMMethodPtrABI) {
823 llvm::Constant *One = llvm::ConstantInt::get(Ptr->getType(), 1);
824 llvm::Value *Adj = Builder.CreateExtractValue(MemPtr, 1, "memptr.adj");
825 llvm::Value *VirtualBit = Builder.CreateAnd(Adj, One, "memptr.virtualbit");
826 llvm::Value *IsVirtual = Builder.CreateICmpNE(VirtualBit, Zero,
828 Result = Builder.CreateOr(Result, IsVirtual);
834 bool ItaniumCXXABI::classifyReturnType(CGFunctionInfo &FI) const {
835 const CXXRecordDecl *RD = FI.getReturnType()->getAsCXXRecordDecl();
839 // Return indirectly if we have a non-trivial copy ctor or non-trivial dtor.
840 // FIXME: Use canCopyArgument() when it is fixed to handle lazily declared
842 if (RD->hasNonTrivialDestructor() || RD->hasNonTrivialCopyConstructor()) {
843 FI.getReturnInfo() = ABIArgInfo::getIndirect(0, /*ByVal=*/false);
849 /// The Itanium ABI requires non-zero initialization only for data
850 /// member pointers, for which '0' is a valid offset.
851 bool ItaniumCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
852 return MPT->getPointeeType()->isFunctionType();
855 /// The Itanium ABI always places an offset to the complete object
856 /// at entry -2 in the vtable.
857 void ItaniumCXXABI::emitVirtualObjectDelete(CodeGenFunction &CGF,
858 const CXXDeleteExpr *DE,
860 QualType ElementType,
861 const CXXDestructorDecl *Dtor) {
862 bool UseGlobalDelete = DE->isGlobalDelete();
863 if (UseGlobalDelete) {
864 // Derive the complete-object pointer, which is what we need
865 // to pass to the deallocation function.
867 // Grab the vtable pointer as an intptr_t*.
868 llvm::Value *VTable = CGF.GetVTablePtr(Ptr, CGF.IntPtrTy->getPointerTo());
870 // Track back to entry -2 and pull out the offset there.
871 llvm::Value *OffsetPtr = CGF.Builder.CreateConstInBoundsGEP1_64(
872 VTable, -2, "complete-offset.ptr");
873 llvm::LoadInst *Offset = CGF.Builder.CreateLoad(OffsetPtr);
874 Offset->setAlignment(CGF.PointerAlignInBytes);
877 llvm::Value *CompletePtr = CGF.Builder.CreateBitCast(Ptr, CGF.Int8PtrTy);
878 CompletePtr = CGF.Builder.CreateInBoundsGEP(CompletePtr, Offset);
880 // If we're supposed to call the global delete, make sure we do so
881 // even if the destructor throws.
882 CGF.pushCallObjectDeleteCleanup(DE->getOperatorDelete(), CompletePtr,
886 // FIXME: Provide a source location here even though there's no
887 // CXXMemberCallExpr for dtor call.
888 CXXDtorType DtorType = UseGlobalDelete ? Dtor_Complete : Dtor_Deleting;
889 EmitVirtualDestructorCall(CGF, Dtor, DtorType, Ptr, /*CE=*/nullptr);
892 CGF.PopCleanupBlock();
895 void ItaniumCXXABI::emitRethrow(CodeGenFunction &CGF, bool isNoReturn) {
896 // void __cxa_rethrow();
898 llvm::FunctionType *FTy =
899 llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false);
901 llvm::Constant *Fn = CGM.CreateRuntimeFunction(FTy, "__cxa_rethrow");
904 CGF.EmitNoreturnRuntimeCallOrInvoke(Fn, None);
906 CGF.EmitRuntimeCallOrInvoke(Fn);
909 static llvm::Constant *getItaniumDynamicCastFn(CodeGenFunction &CGF) {
910 // void *__dynamic_cast(const void *sub,
911 // const abi::__class_type_info *src,
912 // const abi::__class_type_info *dst,
913 // std::ptrdiff_t src2dst_offset);
915 llvm::Type *Int8PtrTy = CGF.Int8PtrTy;
916 llvm::Type *PtrDiffTy =
917 CGF.ConvertType(CGF.getContext().getPointerDiffType());
919 llvm::Type *Args[4] = { Int8PtrTy, Int8PtrTy, Int8PtrTy, PtrDiffTy };
921 llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, Args, false);
923 // Mark the function as nounwind readonly.
924 llvm::Attribute::AttrKind FuncAttrs[] = { llvm::Attribute::NoUnwind,
925 llvm::Attribute::ReadOnly };
926 llvm::AttributeSet Attrs = llvm::AttributeSet::get(
927 CGF.getLLVMContext(), llvm::AttributeSet::FunctionIndex, FuncAttrs);
929 return CGF.CGM.CreateRuntimeFunction(FTy, "__dynamic_cast", Attrs);
932 static llvm::Constant *getBadCastFn(CodeGenFunction &CGF) {
933 // void __cxa_bad_cast();
934 llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
935 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_cast");
938 /// \brief Compute the src2dst_offset hint as described in the
939 /// Itanium C++ ABI [2.9.7]
940 static CharUnits computeOffsetHint(ASTContext &Context,
941 const CXXRecordDecl *Src,
942 const CXXRecordDecl *Dst) {
943 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
944 /*DetectVirtual=*/false);
946 // If Dst is not derived from Src we can skip the whole computation below and
947 // return that Src is not a public base of Dst. Record all inheritance paths.
948 if (!Dst->isDerivedFrom(Src, Paths))
949 return CharUnits::fromQuantity(-2ULL);
951 unsigned NumPublicPaths = 0;
954 // Now walk all possible inheritance paths.
955 for (CXXBasePaths::paths_iterator I = Paths.begin(), E = Paths.end(); I != E;
957 if (I->Access != AS_public) // Ignore non-public inheritance.
962 for (CXXBasePath::iterator J = I->begin(), JE = I->end(); J != JE; ++J) {
963 // If the path contains a virtual base class we can't give any hint.
965 if (J->Base->isVirtual())
966 return CharUnits::fromQuantity(-1ULL);
968 if (NumPublicPaths > 1) // Won't use offsets, skip computation.
971 // Accumulate the base class offsets.
972 const ASTRecordLayout &L = Context.getASTRecordLayout(J->Class);
973 Offset += L.getBaseClassOffset(J->Base->getType()->getAsCXXRecordDecl());
977 // -2: Src is not a public base of Dst.
978 if (NumPublicPaths == 0)
979 return CharUnits::fromQuantity(-2ULL);
981 // -3: Src is a multiple public base type but never a virtual base type.
982 if (NumPublicPaths > 1)
983 return CharUnits::fromQuantity(-3ULL);
985 // Otherwise, the Src type is a unique public nonvirtual base type of Dst.
986 // Return the offset of Src from the origin of Dst.
990 static llvm::Constant *getBadTypeidFn(CodeGenFunction &CGF) {
991 // void __cxa_bad_typeid();
992 llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
994 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_typeid");
997 bool ItaniumCXXABI::shouldTypeidBeNullChecked(bool IsDeref,
998 QualType SrcRecordTy) {
1002 void ItaniumCXXABI::EmitBadTypeidCall(CodeGenFunction &CGF) {
1003 llvm::Value *Fn = getBadTypeidFn(CGF);
1004 CGF.EmitRuntimeCallOrInvoke(Fn).setDoesNotReturn();
1005 CGF.Builder.CreateUnreachable();
1008 llvm::Value *ItaniumCXXABI::EmitTypeid(CodeGenFunction &CGF,
1009 QualType SrcRecordTy,
1010 llvm::Value *ThisPtr,
1011 llvm::Type *StdTypeInfoPtrTy) {
1012 llvm::Value *Value =
1013 CGF.GetVTablePtr(ThisPtr, StdTypeInfoPtrTy->getPointerTo());
1015 // Load the type info.
1016 Value = CGF.Builder.CreateConstInBoundsGEP1_64(Value, -1ULL);
1017 return CGF.Builder.CreateLoad(Value);
1020 bool ItaniumCXXABI::shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
1021 QualType SrcRecordTy) {
1025 llvm::Value *ItaniumCXXABI::EmitDynamicCastCall(
1026 CodeGenFunction &CGF, llvm::Value *Value, QualType SrcRecordTy,
1027 QualType DestTy, QualType DestRecordTy, llvm::BasicBlock *CastEnd) {
1028 llvm::Type *PtrDiffLTy =
1029 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1030 llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1032 llvm::Value *SrcRTTI =
1033 CGF.CGM.GetAddrOfRTTIDescriptor(SrcRecordTy.getUnqualifiedType());
1034 llvm::Value *DestRTTI =
1035 CGF.CGM.GetAddrOfRTTIDescriptor(DestRecordTy.getUnqualifiedType());
1037 // Compute the offset hint.
1038 const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl();
1039 const CXXRecordDecl *DestDecl = DestRecordTy->getAsCXXRecordDecl();
1040 llvm::Value *OffsetHint = llvm::ConstantInt::get(
1042 computeOffsetHint(CGF.getContext(), SrcDecl, DestDecl).getQuantity());
1044 // Emit the call to __dynamic_cast.
1045 Value = CGF.EmitCastToVoidPtr(Value);
1047 llvm::Value *args[] = {Value, SrcRTTI, DestRTTI, OffsetHint};
1048 Value = CGF.EmitNounwindRuntimeCall(getItaniumDynamicCastFn(CGF), args);
1049 Value = CGF.Builder.CreateBitCast(Value, DestLTy);
1051 /// C++ [expr.dynamic.cast]p9:
1052 /// A failed cast to reference type throws std::bad_cast
1053 if (DestTy->isReferenceType()) {
1054 llvm::BasicBlock *BadCastBlock =
1055 CGF.createBasicBlock("dynamic_cast.bad_cast");
1057 llvm::Value *IsNull = CGF.Builder.CreateIsNull(Value);
1058 CGF.Builder.CreateCondBr(IsNull, BadCastBlock, CastEnd);
1060 CGF.EmitBlock(BadCastBlock);
1061 EmitBadCastCall(CGF);
1067 llvm::Value *ItaniumCXXABI::EmitDynamicCastToVoid(CodeGenFunction &CGF,
1069 QualType SrcRecordTy,
1071 llvm::Type *PtrDiffLTy =
1072 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1073 llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1075 // Get the vtable pointer.
1076 llvm::Value *VTable = CGF.GetVTablePtr(Value, PtrDiffLTy->getPointerTo());
1078 // Get the offset-to-top from the vtable.
1079 llvm::Value *OffsetToTop =
1080 CGF.Builder.CreateConstInBoundsGEP1_64(VTable, -2ULL);
1081 OffsetToTop = CGF.Builder.CreateLoad(OffsetToTop, "offset.to.top");
1083 // Finally, add the offset to the pointer.
1084 Value = CGF.EmitCastToVoidPtr(Value);
1085 Value = CGF.Builder.CreateInBoundsGEP(Value, OffsetToTop);
1087 return CGF.Builder.CreateBitCast(Value, DestLTy);
1090 bool ItaniumCXXABI::EmitBadCastCall(CodeGenFunction &CGF) {
1091 llvm::Value *Fn = getBadCastFn(CGF);
1092 CGF.EmitRuntimeCallOrInvoke(Fn).setDoesNotReturn();
1093 CGF.Builder.CreateUnreachable();
1098 ItaniumCXXABI::GetVirtualBaseClassOffset(CodeGenFunction &CGF,
1100 const CXXRecordDecl *ClassDecl,
1101 const CXXRecordDecl *BaseClassDecl) {
1102 llvm::Value *VTablePtr = CGF.GetVTablePtr(This, CGM.Int8PtrTy);
1103 CharUnits VBaseOffsetOffset =
1104 CGM.getItaniumVTableContext().getVirtualBaseOffsetOffset(ClassDecl,
1107 llvm::Value *VBaseOffsetPtr =
1108 CGF.Builder.CreateConstGEP1_64(VTablePtr, VBaseOffsetOffset.getQuantity(),
1109 "vbase.offset.ptr");
1110 VBaseOffsetPtr = CGF.Builder.CreateBitCast(VBaseOffsetPtr,
1111 CGM.PtrDiffTy->getPointerTo());
1113 llvm::Value *VBaseOffset =
1114 CGF.Builder.CreateLoad(VBaseOffsetPtr, "vbase.offset");
1119 void ItaniumCXXABI::EmitCXXConstructors(const CXXConstructorDecl *D) {
1120 // Just make sure we're in sync with TargetCXXABI.
1121 assert(CGM.getTarget().getCXXABI().hasConstructorVariants());
1123 // The constructor used for constructing this as a base class;
1124 // ignores virtual bases.
1125 CGM.EmitGlobal(GlobalDecl(D, Ctor_Base));
1127 // The constructor used for constructing this as a complete class;
1128 // constructs the virtual bases, then calls the base constructor.
1129 if (!D->getParent()->isAbstract()) {
1130 // We don't need to emit the complete ctor if the class is abstract.
1131 CGM.EmitGlobal(GlobalDecl(D, Ctor_Complete));
1136 ItaniumCXXABI::buildStructorSignature(const CXXMethodDecl *MD, StructorType T,
1137 SmallVectorImpl<CanQualType> &ArgTys) {
1138 ASTContext &Context = getContext();
1140 // All parameters are already in place except VTT, which goes after 'this'.
1141 // These are Clang types, so we don't need to worry about sret yet.
1143 // Check if we need to add a VTT parameter (which has type void **).
1144 if (T == StructorType::Base && MD->getParent()->getNumVBases() != 0)
1145 ArgTys.insert(ArgTys.begin() + 1,
1146 Context.getPointerType(Context.VoidPtrTy));
1149 void ItaniumCXXABI::EmitCXXDestructors(const CXXDestructorDecl *D) {
1150 // The destructor used for destructing this as a base class; ignores
1152 CGM.EmitGlobal(GlobalDecl(D, Dtor_Base));
1154 // The destructor used for destructing this as a most-derived class;
1155 // call the base destructor and then destructs any virtual bases.
1156 CGM.EmitGlobal(GlobalDecl(D, Dtor_Complete));
1158 // The destructor in a virtual table is always a 'deleting'
1159 // destructor, which calls the complete destructor and then uses the
1160 // appropriate operator delete.
1162 CGM.EmitGlobal(GlobalDecl(D, Dtor_Deleting));
1165 void ItaniumCXXABI::addImplicitStructorParams(CodeGenFunction &CGF,
1167 FunctionArgList &Params) {
1168 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
1169 assert(isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD));
1171 // Check if we need a VTT parameter as well.
1172 if (NeedsVTTParameter(CGF.CurGD)) {
1173 ASTContext &Context = getContext();
1175 // FIXME: avoid the fake decl
1176 QualType T = Context.getPointerType(Context.VoidPtrTy);
1177 ImplicitParamDecl *VTTDecl
1178 = ImplicitParamDecl::Create(Context, nullptr, MD->getLocation(),
1179 &Context.Idents.get("vtt"), T);
1180 Params.insert(Params.begin() + 1, VTTDecl);
1181 getStructorImplicitParamDecl(CGF) = VTTDecl;
1185 void ItaniumCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
1186 /// Initialize the 'this' slot.
1189 /// Initialize the 'vtt' slot if needed.
1190 if (getStructorImplicitParamDecl(CGF)) {
1191 getStructorImplicitParamValue(CGF) = CGF.Builder.CreateLoad(
1192 CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)), "vtt");
1195 /// If this is a function that the ABI specifies returns 'this', initialize
1196 /// the return slot to 'this' at the start of the function.
1198 /// Unlike the setting of return types, this is done within the ABI
1199 /// implementation instead of by clients of CGCXXABI because:
1200 /// 1) getThisValue is currently protected
1201 /// 2) in theory, an ABI could implement 'this' returns some other way;
1202 /// HasThisReturn only specifies a contract, not the implementation
1203 if (HasThisReturn(CGF.CurGD))
1204 CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
1207 unsigned ItaniumCXXABI::addImplicitConstructorArgs(
1208 CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type,
1209 bool ForVirtualBase, bool Delegating, CallArgList &Args) {
1210 if (!NeedsVTTParameter(GlobalDecl(D, Type)))
1213 // Insert the implicit 'vtt' argument as the second argument.
1215 CGF.GetVTTParameter(GlobalDecl(D, Type), ForVirtualBase, Delegating);
1216 QualType VTTTy = getContext().getPointerType(getContext().VoidPtrTy);
1217 Args.insert(Args.begin() + 1,
1218 CallArg(RValue::get(VTT), VTTTy, /*needscopy=*/false));
1219 return 1; // Added one arg.
1222 void ItaniumCXXABI::EmitDestructorCall(CodeGenFunction &CGF,
1223 const CXXDestructorDecl *DD,
1224 CXXDtorType Type, bool ForVirtualBase,
1225 bool Delegating, llvm::Value *This) {
1226 GlobalDecl GD(DD, Type);
1227 llvm::Value *VTT = CGF.GetVTTParameter(GD, ForVirtualBase, Delegating);
1228 QualType VTTTy = getContext().getPointerType(getContext().VoidPtrTy);
1230 llvm::Value *Callee = nullptr;
1231 if (getContext().getLangOpts().AppleKext)
1232 Callee = CGF.BuildAppleKextVirtualDestructorCall(DD, Type, DD->getParent());
1235 Callee = CGM.getAddrOfCXXStructor(DD, getFromDtorType(Type));
1237 CGF.EmitCXXMemberOrOperatorCall(DD, Callee, ReturnValueSlot(), This, VTT,
1241 void ItaniumCXXABI::emitVTableDefinitions(CodeGenVTables &CGVT,
1242 const CXXRecordDecl *RD) {
1243 llvm::GlobalVariable *VTable = getAddrOfVTable(RD, CharUnits());
1244 if (VTable->hasInitializer())
1247 ItaniumVTableContext &VTContext = CGM.getItaniumVTableContext();
1248 const VTableLayout &VTLayout = VTContext.getVTableLayout(RD);
1249 llvm::GlobalVariable::LinkageTypes Linkage = CGM.getVTableLinkage(RD);
1250 llvm::Constant *RTTI =
1251 CGM.GetAddrOfRTTIDescriptor(CGM.getContext().getTagDeclType(RD));
1253 // Create and set the initializer.
1254 llvm::Constant *Init = CGVT.CreateVTableInitializer(
1255 RD, VTLayout.vtable_component_begin(), VTLayout.getNumVTableComponents(),
1256 VTLayout.vtable_thunk_begin(), VTLayout.getNumVTableThunks(), RTTI);
1257 VTable->setInitializer(Init);
1259 // Set the correct linkage.
1260 VTable->setLinkage(Linkage);
1262 // Set the right visibility.
1263 CGM.setGlobalVisibility(VTable, RD);
1265 // Use pointer alignment for the vtable. Otherwise we would align them based
1266 // on the size of the initializer which doesn't make sense as only single
1268 unsigned PAlign = CGM.getTarget().getPointerAlign(0);
1269 VTable->setAlignment(getContext().toCharUnitsFromBits(PAlign).getQuantity());
1271 // If this is the magic class __cxxabiv1::__fundamental_type_info,
1272 // we will emit the typeinfo for the fundamental types. This is the
1273 // same behaviour as GCC.
1274 const DeclContext *DC = RD->getDeclContext();
1275 if (RD->getIdentifier() &&
1276 RD->getIdentifier()->isStr("__fundamental_type_info") &&
1277 isa<NamespaceDecl>(DC) && cast<NamespaceDecl>(DC)->getIdentifier() &&
1278 cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__cxxabiv1") &&
1279 DC->getParent()->isTranslationUnit())
1280 EmitFundamentalRTTIDescriptors();
1283 llvm::Value *ItaniumCXXABI::getVTableAddressPointInStructor(
1284 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
1285 const CXXRecordDecl *NearestVBase, bool &NeedsVirtualOffset) {
1286 bool NeedsVTTParam = CGM.getCXXABI().NeedsVTTParameter(CGF.CurGD);
1287 NeedsVirtualOffset = (NeedsVTTParam && NearestVBase);
1289 llvm::Value *VTableAddressPoint;
1290 if (NeedsVTTParam && (Base.getBase()->getNumVBases() || NearestVBase)) {
1291 // Get the secondary vpointer index.
1292 uint64_t VirtualPointerIndex =
1293 CGM.getVTables().getSecondaryVirtualPointerIndex(VTableClass, Base);
1296 llvm::Value *VTT = CGF.LoadCXXVTT();
1297 if (VirtualPointerIndex)
1298 VTT = CGF.Builder.CreateConstInBoundsGEP1_64(VTT, VirtualPointerIndex);
1300 // And load the address point from the VTT.
1301 VTableAddressPoint = CGF.Builder.CreateLoad(VTT);
1303 llvm::Constant *VTable =
1304 CGM.getCXXABI().getAddrOfVTable(VTableClass, CharUnits());
1305 uint64_t AddressPoint = CGM.getItaniumVTableContext()
1306 .getVTableLayout(VTableClass)
1307 .getAddressPoint(Base);
1308 VTableAddressPoint =
1309 CGF.Builder.CreateConstInBoundsGEP2_64(VTable, 0, AddressPoint);
1312 return VTableAddressPoint;
1315 llvm::Constant *ItaniumCXXABI::getVTableAddressPointForConstExpr(
1316 BaseSubobject Base, const CXXRecordDecl *VTableClass) {
1317 llvm::Constant *VTable = getAddrOfVTable(VTableClass, CharUnits());
1319 // Find the appropriate vtable within the vtable group.
1320 uint64_t AddressPoint = CGM.getItaniumVTableContext()
1321 .getVTableLayout(VTableClass)
1322 .getAddressPoint(Base);
1323 llvm::Value *Indices[] = {
1324 llvm::ConstantInt::get(CGM.Int64Ty, 0),
1325 llvm::ConstantInt::get(CGM.Int64Ty, AddressPoint)
1328 return llvm::ConstantExpr::getInBoundsGetElementPtr(VTable, Indices);
1331 llvm::GlobalVariable *ItaniumCXXABI::getAddrOfVTable(const CXXRecordDecl *RD,
1332 CharUnits VPtrOffset) {
1333 assert(VPtrOffset.isZero() && "Itanium ABI only supports zero vptr offsets");
1335 llvm::GlobalVariable *&VTable = VTables[RD];
1339 // Queue up this v-table for possible deferred emission.
1340 CGM.addDeferredVTable(RD);
1342 SmallString<256> OutName;
1343 llvm::raw_svector_ostream Out(OutName);
1344 getMangleContext().mangleCXXVTable(RD, Out);
1346 StringRef Name = OutName.str();
1348 ItaniumVTableContext &VTContext = CGM.getItaniumVTableContext();
1349 llvm::ArrayType *ArrayType = llvm::ArrayType::get(
1350 CGM.Int8PtrTy, VTContext.getVTableLayout(RD).getNumVTableComponents());
1352 VTable = CGM.CreateOrReplaceCXXRuntimeVariable(
1353 Name, ArrayType, llvm::GlobalValue::ExternalLinkage);
1354 VTable->setUnnamedAddr(true);
1356 if (RD->hasAttr<DLLImportAttr>())
1357 VTable->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
1358 else if (RD->hasAttr<DLLExportAttr>())
1359 VTable->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
1364 llvm::Value *ItaniumCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF,
1368 GD = GD.getCanonicalDecl();
1369 Ty = Ty->getPointerTo()->getPointerTo();
1370 llvm::Value *VTable = CGF.GetVTablePtr(This, Ty);
1372 uint64_t VTableIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(GD);
1373 llvm::Value *VFuncPtr =
1374 CGF.Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfn");
1375 return CGF.Builder.CreateLoad(VFuncPtr);
1378 llvm::Value *ItaniumCXXABI::EmitVirtualDestructorCall(
1379 CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType,
1380 llvm::Value *This, const CXXMemberCallExpr *CE) {
1381 assert(CE == nullptr || CE->arg_begin() == CE->arg_end());
1382 assert(DtorType == Dtor_Deleting || DtorType == Dtor_Complete);
1384 const CGFunctionInfo *FInfo = &CGM.getTypes().arrangeCXXStructorDeclaration(
1385 Dtor, getFromDtorType(DtorType));
1386 llvm::Type *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
1387 llvm::Value *Callee =
1388 getVirtualFunctionPointer(CGF, GlobalDecl(Dtor, DtorType), This, Ty);
1390 CGF.EmitCXXMemberOrOperatorCall(Dtor, Callee, ReturnValueSlot(), This,
1391 /*ImplicitParam=*/nullptr, QualType(), CE);
1395 void ItaniumCXXABI::emitVirtualInheritanceTables(const CXXRecordDecl *RD) {
1396 CodeGenVTables &VTables = CGM.getVTables();
1397 llvm::GlobalVariable *VTT = VTables.GetAddrOfVTT(RD);
1398 VTables.EmitVTTDefinition(VTT, CGM.getVTableLinkage(RD), RD);
1401 static llvm::Value *performTypeAdjustment(CodeGenFunction &CGF,
1403 int64_t NonVirtualAdjustment,
1404 int64_t VirtualAdjustment,
1405 bool IsReturnAdjustment) {
1406 if (!NonVirtualAdjustment && !VirtualAdjustment)
1409 llvm::Type *Int8PtrTy = CGF.Int8PtrTy;
1410 llvm::Value *V = CGF.Builder.CreateBitCast(Ptr, Int8PtrTy);
1412 if (NonVirtualAdjustment && !IsReturnAdjustment) {
1413 // Perform the non-virtual adjustment for a base-to-derived cast.
1414 V = CGF.Builder.CreateConstInBoundsGEP1_64(V, NonVirtualAdjustment);
1417 if (VirtualAdjustment) {
1418 llvm::Type *PtrDiffTy =
1419 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1421 // Perform the virtual adjustment.
1422 llvm::Value *VTablePtrPtr =
1423 CGF.Builder.CreateBitCast(V, Int8PtrTy->getPointerTo());
1425 llvm::Value *VTablePtr = CGF.Builder.CreateLoad(VTablePtrPtr);
1427 llvm::Value *OffsetPtr =
1428 CGF.Builder.CreateConstInBoundsGEP1_64(VTablePtr, VirtualAdjustment);
1430 OffsetPtr = CGF.Builder.CreateBitCast(OffsetPtr, PtrDiffTy->getPointerTo());
1432 // Load the adjustment offset from the vtable.
1433 llvm::Value *Offset = CGF.Builder.CreateLoad(OffsetPtr);
1435 // Adjust our pointer.
1436 V = CGF.Builder.CreateInBoundsGEP(V, Offset);
1439 if (NonVirtualAdjustment && IsReturnAdjustment) {
1440 // Perform the non-virtual adjustment for a derived-to-base cast.
1441 V = CGF.Builder.CreateConstInBoundsGEP1_64(V, NonVirtualAdjustment);
1444 // Cast back to the original type.
1445 return CGF.Builder.CreateBitCast(V, Ptr->getType());
1448 llvm::Value *ItaniumCXXABI::performThisAdjustment(CodeGenFunction &CGF,
1450 const ThisAdjustment &TA) {
1451 return performTypeAdjustment(CGF, This, TA.NonVirtual,
1452 TA.Virtual.Itanium.VCallOffsetOffset,
1453 /*IsReturnAdjustment=*/false);
1457 ItaniumCXXABI::performReturnAdjustment(CodeGenFunction &CGF, llvm::Value *Ret,
1458 const ReturnAdjustment &RA) {
1459 return performTypeAdjustment(CGF, Ret, RA.NonVirtual,
1460 RA.Virtual.Itanium.VBaseOffsetOffset,
1461 /*IsReturnAdjustment=*/true);
1464 void ARMCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
1465 RValue RV, QualType ResultType) {
1466 if (!isa<CXXDestructorDecl>(CGF.CurGD.getDecl()))
1467 return ItaniumCXXABI::EmitReturnFromThunk(CGF, RV, ResultType);
1469 // Destructor thunks in the ARM ABI have indeterminate results.
1471 cast<llvm::PointerType>(CGF.ReturnValue->getType())->getElementType();
1472 RValue Undef = RValue::get(llvm::UndefValue::get(T));
1473 return ItaniumCXXABI::EmitReturnFromThunk(CGF, Undef, ResultType);
1476 /************************** Array allocation cookies **************************/
1478 CharUnits ItaniumCXXABI::getArrayCookieSizeImpl(QualType elementType) {
1479 // The array cookie is a size_t; pad that up to the element alignment.
1480 // The cookie is actually right-justified in that space.
1481 return std::max(CharUnits::fromQuantity(CGM.SizeSizeInBytes),
1482 CGM.getContext().getTypeAlignInChars(elementType));
1485 llvm::Value *ItaniumCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
1486 llvm::Value *NewPtr,
1487 llvm::Value *NumElements,
1488 const CXXNewExpr *expr,
1489 QualType ElementType) {
1490 assert(requiresArrayCookie(expr));
1492 unsigned AS = NewPtr->getType()->getPointerAddressSpace();
1494 ASTContext &Ctx = getContext();
1495 QualType SizeTy = Ctx.getSizeType();
1496 CharUnits SizeSize = Ctx.getTypeSizeInChars(SizeTy);
1498 // The size of the cookie.
1499 CharUnits CookieSize =
1500 std::max(SizeSize, Ctx.getTypeAlignInChars(ElementType));
1501 assert(CookieSize == getArrayCookieSizeImpl(ElementType));
1503 // Compute an offset to the cookie.
1504 llvm::Value *CookiePtr = NewPtr;
1505 CharUnits CookieOffset = CookieSize - SizeSize;
1506 if (!CookieOffset.isZero())
1507 CookiePtr = CGF.Builder.CreateConstInBoundsGEP1_64(CookiePtr,
1508 CookieOffset.getQuantity());
1510 // Write the number of elements into the appropriate slot.
1511 llvm::Type *NumElementsTy = CGF.ConvertType(SizeTy)->getPointerTo(AS);
1512 llvm::Value *NumElementsPtr =
1513 CGF.Builder.CreateBitCast(CookiePtr, NumElementsTy);
1514 llvm::Instruction *SI = CGF.Builder.CreateStore(NumElements, NumElementsPtr);
1515 if (CGM.getLangOpts().Sanitize.has(SanitizerKind::Address) && AS == 0 &&
1516 expr->getOperatorNew()->isReplaceableGlobalAllocationFunction()) {
1517 // The store to the CookiePtr does not need to be instrumented.
1518 CGM.getSanitizerMetadata()->disableSanitizerForInstruction(SI);
1519 llvm::FunctionType *FTy =
1520 llvm::FunctionType::get(CGM.VoidTy, NumElementsTy, false);
1522 CGM.CreateRuntimeFunction(FTy, "__asan_poison_cxx_array_cookie");
1523 CGF.Builder.CreateCall(F, NumElementsPtr);
1526 // Finally, compute a pointer to the actual data buffer by skipping
1527 // over the cookie completely.
1528 return CGF.Builder.CreateConstInBoundsGEP1_64(NewPtr,
1529 CookieSize.getQuantity());
1532 llvm::Value *ItaniumCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
1533 llvm::Value *allocPtr,
1534 CharUnits cookieSize) {
1535 // The element size is right-justified in the cookie.
1536 llvm::Value *numElementsPtr = allocPtr;
1537 CharUnits numElementsOffset =
1538 cookieSize - CharUnits::fromQuantity(CGF.SizeSizeInBytes);
1539 if (!numElementsOffset.isZero())
1541 CGF.Builder.CreateConstInBoundsGEP1_64(numElementsPtr,
1542 numElementsOffset.getQuantity());
1544 unsigned AS = allocPtr->getType()->getPointerAddressSpace();
1546 CGF.Builder.CreateBitCast(numElementsPtr, CGF.SizeTy->getPointerTo(AS));
1547 if (!CGM.getLangOpts().Sanitize.has(SanitizerKind::Address) || AS != 0)
1548 return CGF.Builder.CreateLoad(numElementsPtr);
1549 // In asan mode emit a function call instead of a regular load and let the
1550 // run-time deal with it: if the shadow is properly poisoned return the
1551 // cookie, otherwise return 0 to avoid an infinite loop calling DTORs.
1552 // We can't simply ignore this load using nosanitize metadata because
1553 // the metadata may be lost.
1554 llvm::FunctionType *FTy =
1555 llvm::FunctionType::get(CGF.SizeTy, CGF.SizeTy->getPointerTo(0), false);
1557 CGM.CreateRuntimeFunction(FTy, "__asan_load_cxx_array_cookie");
1558 return CGF.Builder.CreateCall(F, numElementsPtr);
1561 CharUnits ARMCXXABI::getArrayCookieSizeImpl(QualType elementType) {
1562 // ARM says that the cookie is always:
1563 // struct array_cookie {
1564 // std::size_t element_size; // element_size != 0
1565 // std::size_t element_count;
1567 // But the base ABI doesn't give anything an alignment greater than
1568 // 8, so we can dismiss this as typical ABI-author blindness to
1569 // actual language complexity and round up to the element alignment.
1570 return std::max(CharUnits::fromQuantity(2 * CGM.SizeSizeInBytes),
1571 CGM.getContext().getTypeAlignInChars(elementType));
1574 llvm::Value *ARMCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
1575 llvm::Value *newPtr,
1576 llvm::Value *numElements,
1577 const CXXNewExpr *expr,
1578 QualType elementType) {
1579 assert(requiresArrayCookie(expr));
1581 // NewPtr is a char*, but we generalize to arbitrary addrspaces.
1582 unsigned AS = newPtr->getType()->getPointerAddressSpace();
1584 // The cookie is always at the start of the buffer.
1585 llvm::Value *cookie = newPtr;
1587 // The first element is the element size.
1588 cookie = CGF.Builder.CreateBitCast(cookie, CGF.SizeTy->getPointerTo(AS));
1589 llvm::Value *elementSize = llvm::ConstantInt::get(CGF.SizeTy,
1590 getContext().getTypeSizeInChars(elementType).getQuantity());
1591 CGF.Builder.CreateStore(elementSize, cookie);
1593 // The second element is the element count.
1594 cookie = CGF.Builder.CreateConstInBoundsGEP1_32(cookie, 1);
1595 CGF.Builder.CreateStore(numElements, cookie);
1597 // Finally, compute a pointer to the actual data buffer by skipping
1598 // over the cookie completely.
1599 CharUnits cookieSize = ARMCXXABI::getArrayCookieSizeImpl(elementType);
1600 return CGF.Builder.CreateConstInBoundsGEP1_64(newPtr,
1601 cookieSize.getQuantity());
1604 llvm::Value *ARMCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
1605 llvm::Value *allocPtr,
1606 CharUnits cookieSize) {
1607 // The number of elements is at offset sizeof(size_t) relative to
1608 // the allocated pointer.
1609 llvm::Value *numElementsPtr
1610 = CGF.Builder.CreateConstInBoundsGEP1_64(allocPtr, CGF.SizeSizeInBytes);
1612 unsigned AS = allocPtr->getType()->getPointerAddressSpace();
1614 CGF.Builder.CreateBitCast(numElementsPtr, CGF.SizeTy->getPointerTo(AS));
1615 return CGF.Builder.CreateLoad(numElementsPtr);
1618 /*********************** Static local initialization **************************/
1620 static llvm::Constant *getGuardAcquireFn(CodeGenModule &CGM,
1621 llvm::PointerType *GuardPtrTy) {
1622 // int __cxa_guard_acquire(__guard *guard_object);
1623 llvm::FunctionType *FTy =
1624 llvm::FunctionType::get(CGM.getTypes().ConvertType(CGM.getContext().IntTy),
1625 GuardPtrTy, /*isVarArg=*/false);
1626 return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_acquire",
1627 llvm::AttributeSet::get(CGM.getLLVMContext(),
1628 llvm::AttributeSet::FunctionIndex,
1629 llvm::Attribute::NoUnwind));
1632 static llvm::Constant *getGuardReleaseFn(CodeGenModule &CGM,
1633 llvm::PointerType *GuardPtrTy) {
1634 // void __cxa_guard_release(__guard *guard_object);
1635 llvm::FunctionType *FTy =
1636 llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
1637 return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_release",
1638 llvm::AttributeSet::get(CGM.getLLVMContext(),
1639 llvm::AttributeSet::FunctionIndex,
1640 llvm::Attribute::NoUnwind));
1643 static llvm::Constant *getGuardAbortFn(CodeGenModule &CGM,
1644 llvm::PointerType *GuardPtrTy) {
1645 // void __cxa_guard_abort(__guard *guard_object);
1646 llvm::FunctionType *FTy =
1647 llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
1648 return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_abort",
1649 llvm::AttributeSet::get(CGM.getLLVMContext(),
1650 llvm::AttributeSet::FunctionIndex,
1651 llvm::Attribute::NoUnwind));
1655 struct CallGuardAbort : EHScopeStack::Cleanup {
1656 llvm::GlobalVariable *Guard;
1657 CallGuardAbort(llvm::GlobalVariable *Guard) : Guard(Guard) {}
1659 void Emit(CodeGenFunction &CGF, Flags flags) override {
1660 CGF.EmitNounwindRuntimeCall(getGuardAbortFn(CGF.CGM, Guard->getType()),
1666 /// The ARM code here follows the Itanium code closely enough that we
1667 /// just special-case it at particular places.
1668 void ItaniumCXXABI::EmitGuardedInit(CodeGenFunction &CGF,
1670 llvm::GlobalVariable *var,
1671 bool shouldPerformInit) {
1672 CGBuilderTy &Builder = CGF.Builder;
1674 // We only need to use thread-safe statics for local non-TLS variables;
1675 // global initialization is always single-threaded.
1676 bool threadsafe = getContext().getLangOpts().ThreadsafeStatics &&
1677 D.isLocalVarDecl() && !D.getTLSKind();
1679 // If we have a global variable with internal linkage and thread-safe statics
1680 // are disabled, we can just let the guard variable be of type i8.
1681 bool useInt8GuardVariable = !threadsafe && var->hasInternalLinkage();
1683 llvm::IntegerType *guardTy;
1684 if (useInt8GuardVariable) {
1685 guardTy = CGF.Int8Ty;
1687 // Guard variables are 64 bits in the generic ABI and size width on ARM
1688 // (i.e. 32-bit on AArch32, 64-bit on AArch64).
1689 guardTy = (UseARMGuardVarABI ? CGF.SizeTy : CGF.Int64Ty);
1691 llvm::PointerType *guardPtrTy = guardTy->getPointerTo();
1693 // Create the guard variable if we don't already have it (as we
1694 // might if we're double-emitting this function body).
1695 llvm::GlobalVariable *guard = CGM.getStaticLocalDeclGuardAddress(&D);
1697 // Mangle the name for the guard.
1698 SmallString<256> guardName;
1700 llvm::raw_svector_ostream out(guardName);
1701 getMangleContext().mangleStaticGuardVariable(&D, out);
1705 // Create the guard variable with a zero-initializer.
1706 // Just absorb linkage and visibility from the guarded variable.
1707 guard = new llvm::GlobalVariable(CGM.getModule(), guardTy,
1708 false, var->getLinkage(),
1709 llvm::ConstantInt::get(guardTy, 0),
1711 guard->setVisibility(var->getVisibility());
1712 // If the variable is thread-local, so is its guard variable.
1713 guard->setThreadLocalMode(var->getThreadLocalMode());
1715 // The ABI says: It is suggested that it be emitted in the same COMDAT group
1716 // as the associated data object
1717 if (!D.isLocalVarDecl() && var->isWeakForLinker() && CGM.supportsCOMDAT()) {
1718 llvm::Comdat *C = CGM.getModule().getOrInsertComdat(var->getName());
1719 guard->setComdat(C);
1721 CGF.CurFn->setComdat(C);
1724 CGM.setStaticLocalDeclGuardAddress(&D, guard);
1727 // Test whether the variable has completed initialization.
1729 // Itanium C++ ABI 3.3.2:
1730 // The following is pseudo-code showing how these functions can be used:
1731 // if (obj_guard.first_byte == 0) {
1732 // if ( __cxa_guard_acquire (&obj_guard) ) {
1734 // ... initialize the object ...;
1736 // __cxa_guard_abort (&obj_guard);
1739 // ... queue object destructor with __cxa_atexit() ...;
1740 // __cxa_guard_release (&obj_guard);
1744 // Load the first byte of the guard variable.
1745 llvm::LoadInst *LI =
1746 Builder.CreateLoad(Builder.CreateBitCast(guard, CGM.Int8PtrTy));
1747 LI->setAlignment(1);
1750 // An implementation supporting thread-safety on multiprocessor
1751 // systems must also guarantee that references to the initialized
1752 // object do not occur before the load of the initialization flag.
1754 // In LLVM, we do this by marking the load Acquire.
1756 LI->setAtomic(llvm::Acquire);
1758 // For ARM, we should only check the first bit, rather than the entire byte:
1760 // ARM C++ ABI 3.2.3.1:
1761 // To support the potential use of initialization guard variables
1762 // as semaphores that are the target of ARM SWP and LDREX/STREX
1763 // synchronizing instructions we define a static initialization
1764 // guard variable to be a 4-byte aligned, 4-byte word with the
1765 // following inline access protocol.
1766 // #define INITIALIZED 1
1767 // if ((obj_guard & INITIALIZED) != INITIALIZED) {
1768 // if (__cxa_guard_acquire(&obj_guard))
1772 // and similarly for ARM64:
1774 // ARM64 C++ ABI 3.2.2:
1775 // This ABI instead only specifies the value bit 0 of the static guard
1776 // variable; all other bits are platform defined. Bit 0 shall be 0 when the
1777 // variable is not initialized and 1 when it is.
1779 (UseARMGuardVarABI && !useInt8GuardVariable)
1780 ? Builder.CreateAnd(LI, llvm::ConstantInt::get(CGM.Int8Ty, 1))
1782 llvm::Value *isInitialized = Builder.CreateIsNull(V, "guard.uninitialized");
1784 llvm::BasicBlock *InitCheckBlock = CGF.createBasicBlock("init.check");
1785 llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end");
1787 // Check if the first byte of the guard variable is zero.
1788 Builder.CreateCondBr(isInitialized, InitCheckBlock, EndBlock);
1790 CGF.EmitBlock(InitCheckBlock);
1792 // Variables used when coping with thread-safe statics and exceptions.
1794 // Call __cxa_guard_acquire.
1796 = CGF.EmitNounwindRuntimeCall(getGuardAcquireFn(CGM, guardPtrTy), guard);
1798 llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
1800 Builder.CreateCondBr(Builder.CreateIsNotNull(V, "tobool"),
1801 InitBlock, EndBlock);
1803 // Call __cxa_guard_abort along the exceptional edge.
1804 CGF.EHStack.pushCleanup<CallGuardAbort>(EHCleanup, guard);
1806 CGF.EmitBlock(InitBlock);
1809 // Emit the initializer and add a global destructor if appropriate.
1810 CGF.EmitCXXGlobalVarDeclInit(D, var, shouldPerformInit);
1813 // Pop the guard-abort cleanup if we pushed one.
1814 CGF.PopCleanupBlock();
1816 // Call __cxa_guard_release. This cannot throw.
1817 CGF.EmitNounwindRuntimeCall(getGuardReleaseFn(CGM, guardPtrTy), guard);
1819 Builder.CreateStore(llvm::ConstantInt::get(guardTy, 1), guard);
1822 CGF.EmitBlock(EndBlock);
1825 /// Register a global destructor using __cxa_atexit.
1826 static void emitGlobalDtorWithCXAAtExit(CodeGenFunction &CGF,
1827 llvm::Constant *dtor,
1828 llvm::Constant *addr,
1830 const char *Name = "__cxa_atexit";
1832 const llvm::Triple &T = CGF.getTarget().getTriple();
1833 Name = T.isMacOSX() ? "_tlv_atexit" : "__cxa_thread_atexit";
1836 // We're assuming that the destructor function is something we can
1837 // reasonably call with the default CC. Go ahead and cast it to the
1839 llvm::Type *dtorTy =
1840 llvm::FunctionType::get(CGF.VoidTy, CGF.Int8PtrTy, false)->getPointerTo();
1842 // extern "C" int __cxa_atexit(void (*f)(void *), void *p, void *d);
1843 llvm::Type *paramTys[] = { dtorTy, CGF.Int8PtrTy, CGF.Int8PtrTy };
1844 llvm::FunctionType *atexitTy =
1845 llvm::FunctionType::get(CGF.IntTy, paramTys, false);
1847 // Fetch the actual function.
1848 llvm::Constant *atexit = CGF.CGM.CreateRuntimeFunction(atexitTy, Name);
1849 if (llvm::Function *fn = dyn_cast<llvm::Function>(atexit))
1850 fn->setDoesNotThrow();
1852 // Create a variable that binds the atexit to this shared object.
1853 llvm::Constant *handle =
1854 CGF.CGM.CreateRuntimeVariable(CGF.Int8Ty, "__dso_handle");
1856 llvm::Value *args[] = {
1857 llvm::ConstantExpr::getBitCast(dtor, dtorTy),
1858 llvm::ConstantExpr::getBitCast(addr, CGF.Int8PtrTy),
1861 CGF.EmitNounwindRuntimeCall(atexit, args);
1864 /// Register a global destructor as best as we know how.
1865 void ItaniumCXXABI::registerGlobalDtor(CodeGenFunction &CGF,
1867 llvm::Constant *dtor,
1868 llvm::Constant *addr) {
1869 // Use __cxa_atexit if available.
1870 if (CGM.getCodeGenOpts().CXAAtExit)
1871 return emitGlobalDtorWithCXAAtExit(CGF, dtor, addr, D.getTLSKind());
1874 CGM.ErrorUnsupported(&D, "non-trivial TLS destruction");
1876 // In Apple kexts, we want to add a global destructor entry.
1877 // FIXME: shouldn't this be guarded by some variable?
1878 if (CGM.getLangOpts().AppleKext) {
1879 // Generate a global destructor entry.
1880 return CGM.AddCXXDtorEntry(dtor, addr);
1883 CGF.registerGlobalDtorWithAtExit(D, dtor, addr);
1886 static bool isThreadWrapperReplaceable(const VarDecl *VD,
1887 CodeGen::CodeGenModule &CGM) {
1888 assert(!VD->isStaticLocal() && "static local VarDecls don't need wrappers!");
1889 // OS X prefers to have references to thread local variables to go through
1890 // the thread wrapper instead of directly referencing the backing variable.
1891 return VD->getTLSKind() == VarDecl::TLS_Dynamic &&
1892 CGM.getTarget().getTriple().isMacOSX();
1895 /// Get the appropriate linkage for the wrapper function. This is essentially
1896 /// the weak form of the variable's linkage; every translation unit which needs
1897 /// the wrapper emits a copy, and we want the linker to merge them.
1898 static llvm::GlobalValue::LinkageTypes
1899 getThreadLocalWrapperLinkage(const VarDecl *VD, CodeGen::CodeGenModule &CGM) {
1900 llvm::GlobalValue::LinkageTypes VarLinkage =
1901 CGM.getLLVMLinkageVarDefinition(VD, /*isConstant=*/false);
1903 // For internal linkage variables, we don't need an external or weak wrapper.
1904 if (llvm::GlobalValue::isLocalLinkage(VarLinkage))
1907 // If the thread wrapper is replaceable, give it appropriate linkage.
1908 if (isThreadWrapperReplaceable(VD, CGM)) {
1909 if (llvm::GlobalVariable::isLinkOnceLinkage(VarLinkage) ||
1910 llvm::GlobalVariable::isWeakODRLinkage(VarLinkage))
1911 return llvm::GlobalVariable::WeakAnyLinkage;
1914 return llvm::GlobalValue::WeakODRLinkage;
1918 ItaniumCXXABI::getOrCreateThreadLocalWrapper(const VarDecl *VD,
1920 // Mangle the name for the thread_local wrapper function.
1921 SmallString<256> WrapperName;
1923 llvm::raw_svector_ostream Out(WrapperName);
1924 getMangleContext().mangleItaniumThreadLocalWrapper(VD, Out);
1928 if (llvm::Value *V = CGM.getModule().getNamedValue(WrapperName))
1929 return cast<llvm::Function>(V);
1931 llvm::Type *RetTy = Val->getType();
1932 if (VD->getType()->isReferenceType())
1933 RetTy = RetTy->getPointerElementType();
1935 llvm::FunctionType *FnTy = llvm::FunctionType::get(RetTy, false);
1936 llvm::Function *Wrapper =
1937 llvm::Function::Create(FnTy, getThreadLocalWrapperLinkage(VD, CGM),
1938 WrapperName.str(), &CGM.getModule());
1939 // Always resolve references to the wrapper at link time.
1940 if (!Wrapper->hasLocalLinkage() && !isThreadWrapperReplaceable(VD, CGM))
1941 Wrapper->setVisibility(llvm::GlobalValue::HiddenVisibility);
1945 void ItaniumCXXABI::EmitThreadLocalInitFuncs(
1947 ArrayRef<std::pair<const VarDecl *, llvm::GlobalVariable *>>
1948 CXXThreadLocals, ArrayRef<llvm::Function *> CXXThreadLocalInits,
1949 ArrayRef<llvm::GlobalVariable *> CXXThreadLocalInitVars) {
1950 llvm::Function *InitFunc = nullptr;
1951 if (!CXXThreadLocalInits.empty()) {
1952 // Generate a guarded initialization function.
1953 llvm::FunctionType *FTy =
1954 llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
1955 InitFunc = CGM.CreateGlobalInitOrDestructFunction(FTy, "__tls_init",
1958 llvm::GlobalVariable *Guard = new llvm::GlobalVariable(
1959 CGM.getModule(), CGM.Int8Ty, /*isConstant=*/false,
1960 llvm::GlobalVariable::InternalLinkage,
1961 llvm::ConstantInt::get(CGM.Int8Ty, 0), "__tls_guard");
1962 Guard->setThreadLocal(true);
1963 CodeGenFunction(CGM)
1964 .GenerateCXXGlobalInitFunc(InitFunc, CXXThreadLocalInits, Guard);
1966 for (unsigned I = 0, N = CXXThreadLocals.size(); I != N; ++I) {
1967 const VarDecl *VD = CXXThreadLocals[I].first;
1968 llvm::GlobalVariable *Var = CXXThreadLocals[I].second;
1970 // Some targets require that all access to thread local variables go through
1971 // the thread wrapper. This means that we cannot attempt to create a thread
1972 // wrapper or a thread helper.
1973 if (isThreadWrapperReplaceable(VD, CGM) && !VD->hasDefinition())
1976 // Mangle the name for the thread_local initialization function.
1977 SmallString<256> InitFnName;
1979 llvm::raw_svector_ostream Out(InitFnName);
1980 getMangleContext().mangleItaniumThreadLocalInit(VD, Out);
1984 // If we have a definition for the variable, emit the initialization
1985 // function as an alias to the global Init function (if any). Otherwise,
1986 // produce a declaration of the initialization function.
1987 llvm::GlobalValue *Init = nullptr;
1988 bool InitIsInitFunc = false;
1989 if (VD->hasDefinition()) {
1990 InitIsInitFunc = true;
1992 Init = llvm::GlobalAlias::create(Var->getLinkage(), InitFnName.str(),
1995 // Emit a weak global function referring to the initialization function.
1996 // This function will not exist if the TU defining the thread_local
1997 // variable in question does not need any dynamic initialization for
1998 // its thread_local variables.
1999 llvm::FunctionType *FnTy = llvm::FunctionType::get(CGM.VoidTy, false);
2000 Init = llvm::Function::Create(
2001 FnTy, llvm::GlobalVariable::ExternalWeakLinkage, InitFnName.str(),
2006 Init->setVisibility(Var->getVisibility());
2008 llvm::Function *Wrapper = getOrCreateThreadLocalWrapper(VD, Var);
2009 llvm::LLVMContext &Context = CGM.getModule().getContext();
2010 llvm::BasicBlock *Entry = llvm::BasicBlock::Create(Context, "", Wrapper);
2011 CGBuilderTy Builder(Entry);
2012 if (InitIsInitFunc) {
2014 Builder.CreateCall(Init);
2016 // Don't know whether we have an init function. Call it if it exists.
2017 llvm::Value *Have = Builder.CreateIsNotNull(Init);
2018 llvm::BasicBlock *InitBB = llvm::BasicBlock::Create(Context, "", Wrapper);
2019 llvm::BasicBlock *ExitBB = llvm::BasicBlock::Create(Context, "", Wrapper);
2020 Builder.CreateCondBr(Have, InitBB, ExitBB);
2022 Builder.SetInsertPoint(InitBB);
2023 Builder.CreateCall(Init);
2024 Builder.CreateBr(ExitBB);
2026 Builder.SetInsertPoint(ExitBB);
2029 // For a reference, the result of the wrapper function is a pointer to
2030 // the referenced object.
2031 llvm::Value *Val = Var;
2032 if (VD->getType()->isReferenceType()) {
2033 llvm::LoadInst *LI = Builder.CreateLoad(Val);
2034 LI->setAlignment(CGM.getContext().getDeclAlign(VD).getQuantity());
2037 if (Val->getType() != Wrapper->getReturnType())
2038 Val = Builder.CreatePointerBitCastOrAddrSpaceCast(
2039 Val, Wrapper->getReturnType(), "");
2040 Builder.CreateRet(Val);
2044 LValue ItaniumCXXABI::EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,
2046 QualType LValType) {
2047 QualType T = VD->getType();
2048 llvm::Type *Ty = CGF.getTypes().ConvertTypeForMem(T);
2049 llvm::Value *Val = CGF.CGM.GetAddrOfGlobalVar(VD, Ty);
2050 llvm::Function *Wrapper = getOrCreateThreadLocalWrapper(VD, Val);
2052 Val = CGF.Builder.CreateCall(Wrapper);
2055 if (VD->getType()->isReferenceType())
2056 LV = CGF.MakeNaturalAlignAddrLValue(Val, LValType);
2058 LV = CGF.MakeAddrLValue(Val, LValType, CGF.getContext().getDeclAlign(VD));
2059 // FIXME: need setObjCGCLValueClass?
2063 /// Return whether the given global decl needs a VTT parameter, which it does
2064 /// if it's a base constructor or destructor with virtual bases.
2065 bool ItaniumCXXABI::NeedsVTTParameter(GlobalDecl GD) {
2066 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
2068 // We don't have any virtual bases, just return early.
2069 if (!MD->getParent()->getNumVBases())
2072 // Check if we have a base constructor.
2073 if (isa<CXXConstructorDecl>(MD) && GD.getCtorType() == Ctor_Base)
2076 // Check if we have a base destructor.
2077 if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
2084 class ItaniumRTTIBuilder {
2085 CodeGenModule &CGM; // Per-module state.
2086 llvm::LLVMContext &VMContext;
2087 const ItaniumCXXABI &CXXABI; // Per-module state.
2089 /// Fields - The fields of the RTTI descriptor currently being built.
2090 SmallVector<llvm::Constant *, 16> Fields;
2092 /// GetAddrOfTypeName - Returns the mangled type name of the given type.
2093 llvm::GlobalVariable *
2094 GetAddrOfTypeName(QualType Ty, llvm::GlobalVariable::LinkageTypes Linkage);
2096 /// GetAddrOfExternalRTTIDescriptor - Returns the constant for the RTTI
2097 /// descriptor of the given type.
2098 llvm::Constant *GetAddrOfExternalRTTIDescriptor(QualType Ty);
2100 /// BuildVTablePointer - Build the vtable pointer for the given type.
2101 void BuildVTablePointer(const Type *Ty);
2103 /// BuildSIClassTypeInfo - Build an abi::__si_class_type_info, used for single
2104 /// inheritance, according to the Itanium C++ ABI, 2.9.5p6b.
2105 void BuildSIClassTypeInfo(const CXXRecordDecl *RD);
2107 /// BuildVMIClassTypeInfo - Build an abi::__vmi_class_type_info, used for
2108 /// classes with bases that do not satisfy the abi::__si_class_type_info
2109 /// constraints, according ti the Itanium C++ ABI, 2.9.5p5c.
2110 void BuildVMIClassTypeInfo(const CXXRecordDecl *RD);
2112 /// BuildPointerTypeInfo - Build an abi::__pointer_type_info struct, used
2113 /// for pointer types.
2114 void BuildPointerTypeInfo(QualType PointeeTy);
2116 /// BuildObjCObjectTypeInfo - Build the appropriate kind of
2117 /// type_info for an object type.
2118 void BuildObjCObjectTypeInfo(const ObjCObjectType *Ty);
2120 /// BuildPointerToMemberTypeInfo - Build an abi::__pointer_to_member_type_info
2121 /// struct, used for member pointer types.
2122 void BuildPointerToMemberTypeInfo(const MemberPointerType *Ty);
2125 ItaniumRTTIBuilder(const ItaniumCXXABI &ABI)
2126 : CGM(ABI.CGM), VMContext(CGM.getModule().getContext()), CXXABI(ABI) {}
2128 // Pointer type info flags.
2130 /// PTI_Const - Type has const qualifier.
2133 /// PTI_Volatile - Type has volatile qualifier.
2136 /// PTI_Restrict - Type has restrict qualifier.
2139 /// PTI_Incomplete - Type is incomplete.
2140 PTI_Incomplete = 0x8,
2142 /// PTI_ContainingClassIncomplete - Containing class is incomplete.
2143 /// (in pointer to member).
2144 PTI_ContainingClassIncomplete = 0x10
2147 // VMI type info flags.
2149 /// VMI_NonDiamondRepeat - Class has non-diamond repeated inheritance.
2150 VMI_NonDiamondRepeat = 0x1,
2152 /// VMI_DiamondShaped - Class is diamond shaped.
2153 VMI_DiamondShaped = 0x2
2156 // Base class type info flags.
2158 /// BCTI_Virtual - Base class is virtual.
2161 /// BCTI_Public - Base class is public.
2165 /// BuildTypeInfo - Build the RTTI type info struct for the given type.
2167 /// \param Force - true to force the creation of this RTTI value
2168 llvm::Constant *BuildTypeInfo(QualType Ty, bool Force = false);
2172 llvm::GlobalVariable *ItaniumRTTIBuilder::GetAddrOfTypeName(
2173 QualType Ty, llvm::GlobalVariable::LinkageTypes Linkage) {
2174 SmallString<256> OutName;
2175 llvm::raw_svector_ostream Out(OutName);
2176 CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(Ty, Out);
2178 StringRef Name = OutName.str();
2180 // We know that the mangled name of the type starts at index 4 of the
2181 // mangled name of the typename, so we can just index into it in order to
2182 // get the mangled name of the type.
2183 llvm::Constant *Init = llvm::ConstantDataArray::getString(VMContext,
2186 llvm::GlobalVariable *GV =
2187 CGM.CreateOrReplaceCXXRuntimeVariable(Name, Init->getType(), Linkage);
2189 GV->setInitializer(Init);
2195 ItaniumRTTIBuilder::GetAddrOfExternalRTTIDescriptor(QualType Ty) {
2196 // Mangle the RTTI name.
2197 SmallString<256> OutName;
2198 llvm::raw_svector_ostream Out(OutName);
2199 CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
2201 StringRef Name = OutName.str();
2203 // Look for an existing global.
2204 llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(Name);
2207 // Create a new global variable.
2208 GV = new llvm::GlobalVariable(CGM.getModule(), CGM.Int8PtrTy,
2210 llvm::GlobalValue::ExternalLinkage, nullptr,
2212 if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
2213 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
2214 if (RD->hasAttr<DLLImportAttr>())
2215 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
2219 return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
2222 /// TypeInfoIsInStandardLibrary - Given a builtin type, returns whether the type
2223 /// info for that type is defined in the standard library.
2224 static bool TypeInfoIsInStandardLibrary(const BuiltinType *Ty) {
2225 // Itanium C++ ABI 2.9.2:
2226 // Basic type information (e.g. for "int", "bool", etc.) will be kept in
2227 // the run-time support library. Specifically, the run-time support
2228 // library should contain type_info objects for the types X, X* and
2229 // X const*, for every X in: void, std::nullptr_t, bool, wchar_t, char,
2230 // unsigned char, signed char, short, unsigned short, int, unsigned int,
2231 // long, unsigned long, long long, unsigned long long, float, double,
2232 // long double, char16_t, char32_t, and the IEEE 754r decimal and
2233 // half-precision floating point types.
2234 switch (Ty->getKind()) {
2235 case BuiltinType::Void:
2236 case BuiltinType::NullPtr:
2237 case BuiltinType::Bool:
2238 case BuiltinType::WChar_S:
2239 case BuiltinType::WChar_U:
2240 case BuiltinType::Char_U:
2241 case BuiltinType::Char_S:
2242 case BuiltinType::UChar:
2243 case BuiltinType::SChar:
2244 case BuiltinType::Short:
2245 case BuiltinType::UShort:
2246 case BuiltinType::Int:
2247 case BuiltinType::UInt:
2248 case BuiltinType::Long:
2249 case BuiltinType::ULong:
2250 case BuiltinType::LongLong:
2251 case BuiltinType::ULongLong:
2252 case BuiltinType::Half:
2253 case BuiltinType::Float:
2254 case BuiltinType::Double:
2255 case BuiltinType::LongDouble:
2256 case BuiltinType::Char16:
2257 case BuiltinType::Char32:
2258 case BuiltinType::Int128:
2259 case BuiltinType::UInt128:
2260 case BuiltinType::OCLImage1d:
2261 case BuiltinType::OCLImage1dArray:
2262 case BuiltinType::OCLImage1dBuffer:
2263 case BuiltinType::OCLImage2d:
2264 case BuiltinType::OCLImage2dArray:
2265 case BuiltinType::OCLImage3d:
2266 case BuiltinType::OCLSampler:
2267 case BuiltinType::OCLEvent:
2270 case BuiltinType::Dependent:
2271 #define BUILTIN_TYPE(Id, SingletonId)
2272 #define PLACEHOLDER_TYPE(Id, SingletonId) \
2273 case BuiltinType::Id:
2274 #include "clang/AST/BuiltinTypes.def"
2275 llvm_unreachable("asking for RRTI for a placeholder type!");
2277 case BuiltinType::ObjCId:
2278 case BuiltinType::ObjCClass:
2279 case BuiltinType::ObjCSel:
2280 llvm_unreachable("FIXME: Objective-C types are unsupported!");
2283 llvm_unreachable("Invalid BuiltinType Kind!");
2286 static bool TypeInfoIsInStandardLibrary(const PointerType *PointerTy) {
2287 QualType PointeeTy = PointerTy->getPointeeType();
2288 const BuiltinType *BuiltinTy = dyn_cast<BuiltinType>(PointeeTy);
2292 // Check the qualifiers.
2293 Qualifiers Quals = PointeeTy.getQualifiers();
2294 Quals.removeConst();
2299 return TypeInfoIsInStandardLibrary(BuiltinTy);
2302 /// IsStandardLibraryRTTIDescriptor - Returns whether the type
2303 /// information for the given type exists in the standard library.
2304 static bool IsStandardLibraryRTTIDescriptor(QualType Ty) {
2305 // Type info for builtin types is defined in the standard library.
2306 if (const BuiltinType *BuiltinTy = dyn_cast<BuiltinType>(Ty))
2307 return TypeInfoIsInStandardLibrary(BuiltinTy);
2309 // Type info for some pointer types to builtin types is defined in the
2310 // standard library.
2311 if (const PointerType *PointerTy = dyn_cast<PointerType>(Ty))
2312 return TypeInfoIsInStandardLibrary(PointerTy);
2317 /// ShouldUseExternalRTTIDescriptor - Returns whether the type information for
2318 /// the given type exists somewhere else, and that we should not emit the type
2319 /// information in this translation unit. Assumes that it is not a
2320 /// standard-library type.
2321 static bool ShouldUseExternalRTTIDescriptor(CodeGenModule &CGM,
2323 ASTContext &Context = CGM.getContext();
2325 // If RTTI is disabled, assume it might be disabled in the
2326 // translation unit that defines any potential key function, too.
2327 if (!Context.getLangOpts().RTTI) return false;
2329 if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
2330 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
2331 if (!RD->hasDefinition())
2334 if (!RD->isDynamicClass())
2337 // FIXME: this may need to be reconsidered if the key function
2339 if (CGM.getVTables().isVTableExternal(RD))
2342 if (RD->hasAttr<DLLImportAttr>())
2349 /// IsIncompleteClassType - Returns whether the given record type is incomplete.
2350 static bool IsIncompleteClassType(const RecordType *RecordTy) {
2351 return !RecordTy->getDecl()->isCompleteDefinition();
2354 /// ContainsIncompleteClassType - Returns whether the given type contains an
2355 /// incomplete class type. This is true if
2357 /// * The given type is an incomplete class type.
2358 /// * The given type is a pointer type whose pointee type contains an
2359 /// incomplete class type.
2360 /// * The given type is a member pointer type whose class is an incomplete
2362 /// * The given type is a member pointer type whoise pointee type contains an
2363 /// incomplete class type.
2364 /// is an indirect or direct pointer to an incomplete class type.
2365 static bool ContainsIncompleteClassType(QualType Ty) {
2366 if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
2367 if (IsIncompleteClassType(RecordTy))
2371 if (const PointerType *PointerTy = dyn_cast<PointerType>(Ty))
2372 return ContainsIncompleteClassType(PointerTy->getPointeeType());
2374 if (const MemberPointerType *MemberPointerTy =
2375 dyn_cast<MemberPointerType>(Ty)) {
2376 // Check if the class type is incomplete.
2377 const RecordType *ClassType = cast<RecordType>(MemberPointerTy->getClass());
2378 if (IsIncompleteClassType(ClassType))
2381 return ContainsIncompleteClassType(MemberPointerTy->getPointeeType());
2387 // CanUseSingleInheritance - Return whether the given record decl has a "single,
2388 // public, non-virtual base at offset zero (i.e. the derived class is dynamic
2389 // iff the base is)", according to Itanium C++ ABI, 2.95p6b.
2390 static bool CanUseSingleInheritance(const CXXRecordDecl *RD) {
2391 // Check the number of bases.
2392 if (RD->getNumBases() != 1)
2396 CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin();
2398 // Check that the base is not virtual.
2399 if (Base->isVirtual())
2402 // Check that the base is public.
2403 if (Base->getAccessSpecifier() != AS_public)
2406 // Check that the class is dynamic iff the base is.
2407 const CXXRecordDecl *BaseDecl =
2408 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
2409 if (!BaseDecl->isEmpty() &&
2410 BaseDecl->isDynamicClass() != RD->isDynamicClass())
2416 void ItaniumRTTIBuilder::BuildVTablePointer(const Type *Ty) {
2417 // abi::__class_type_info.
2418 static const char * const ClassTypeInfo =
2419 "_ZTVN10__cxxabiv117__class_type_infoE";
2420 // abi::__si_class_type_info.
2421 static const char * const SIClassTypeInfo =
2422 "_ZTVN10__cxxabiv120__si_class_type_infoE";
2423 // abi::__vmi_class_type_info.
2424 static const char * const VMIClassTypeInfo =
2425 "_ZTVN10__cxxabiv121__vmi_class_type_infoE";
2427 const char *VTableName = nullptr;
2429 switch (Ty->getTypeClass()) {
2430 #define TYPE(Class, Base)
2431 #define ABSTRACT_TYPE(Class, Base)
2432 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
2433 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
2434 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
2435 #include "clang/AST/TypeNodes.def"
2436 llvm_unreachable("Non-canonical and dependent types shouldn't get here");
2438 case Type::LValueReference:
2439 case Type::RValueReference:
2440 llvm_unreachable("References shouldn't get here");
2443 llvm_unreachable("Undeduced auto type shouldn't get here");
2446 // GCC treats vector and complex types as fundamental types.
2448 case Type::ExtVector:
2451 // FIXME: GCC treats block pointers as fundamental types?!
2452 case Type::BlockPointer:
2453 // abi::__fundamental_type_info.
2454 VTableName = "_ZTVN10__cxxabiv123__fundamental_type_infoE";
2457 case Type::ConstantArray:
2458 case Type::IncompleteArray:
2459 case Type::VariableArray:
2460 // abi::__array_type_info.
2461 VTableName = "_ZTVN10__cxxabiv117__array_type_infoE";
2464 case Type::FunctionNoProto:
2465 case Type::FunctionProto:
2466 // abi::__function_type_info.
2467 VTableName = "_ZTVN10__cxxabiv120__function_type_infoE";
2471 // abi::__enum_type_info.
2472 VTableName = "_ZTVN10__cxxabiv116__enum_type_infoE";
2475 case Type::Record: {
2476 const CXXRecordDecl *RD =
2477 cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());
2479 if (!RD->hasDefinition() || !RD->getNumBases()) {
2480 VTableName = ClassTypeInfo;
2481 } else if (CanUseSingleInheritance(RD)) {
2482 VTableName = SIClassTypeInfo;
2484 VTableName = VMIClassTypeInfo;
2490 case Type::ObjCObject:
2491 // Ignore protocol qualifiers.
2492 Ty = cast<ObjCObjectType>(Ty)->getBaseType().getTypePtr();
2494 // Handle id and Class.
2495 if (isa<BuiltinType>(Ty)) {
2496 VTableName = ClassTypeInfo;
2500 assert(isa<ObjCInterfaceType>(Ty));
2503 case Type::ObjCInterface:
2504 if (cast<ObjCInterfaceType>(Ty)->getDecl()->getSuperClass()) {
2505 VTableName = SIClassTypeInfo;
2507 VTableName = ClassTypeInfo;
2511 case Type::ObjCObjectPointer:
2513 // abi::__pointer_type_info.
2514 VTableName = "_ZTVN10__cxxabiv119__pointer_type_infoE";
2517 case Type::MemberPointer:
2518 // abi::__pointer_to_member_type_info.
2519 VTableName = "_ZTVN10__cxxabiv129__pointer_to_member_type_infoE";
2523 llvm::Constant *VTable =
2524 CGM.getModule().getOrInsertGlobal(VTableName, CGM.Int8PtrTy);
2526 llvm::Type *PtrDiffTy =
2527 CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
2529 // The vtable address point is 2.
2530 llvm::Constant *Two = llvm::ConstantInt::get(PtrDiffTy, 2);
2531 VTable = llvm::ConstantExpr::getInBoundsGetElementPtr(VTable, Two);
2532 VTable = llvm::ConstantExpr::getBitCast(VTable, CGM.Int8PtrTy);
2534 Fields.push_back(VTable);
2537 /// \brief Return the linkage that the type info and type info name constants
2538 /// should have for the given type.
2539 static llvm::GlobalVariable::LinkageTypes getTypeInfoLinkage(CodeGenModule &CGM,
2541 // Itanium C++ ABI 2.9.5p7:
2542 // In addition, it and all of the intermediate abi::__pointer_type_info
2543 // structs in the chain down to the abi::__class_type_info for the
2544 // incomplete class type must be prevented from resolving to the
2545 // corresponding type_info structs for the complete class type, possibly
2546 // by making them local static objects. Finally, a dummy class RTTI is
2547 // generated for the incomplete type that will not resolve to the final
2548 // complete class RTTI (because the latter need not exist), possibly by
2549 // making it a local static object.
2550 if (ContainsIncompleteClassType(Ty))
2551 return llvm::GlobalValue::InternalLinkage;
2553 switch (Ty->getLinkage()) {
2555 case InternalLinkage:
2556 case UniqueExternalLinkage:
2557 return llvm::GlobalValue::InternalLinkage;
2559 case VisibleNoLinkage:
2560 case ExternalLinkage:
2561 if (!CGM.getLangOpts().RTTI) {
2562 // RTTI is not enabled, which means that this type info struct is going
2563 // to be used for exception handling. Give it linkonce_odr linkage.
2564 return llvm::GlobalValue::LinkOnceODRLinkage;
2567 if (const RecordType *Record = dyn_cast<RecordType>(Ty)) {
2568 const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
2569 if (RD->hasAttr<WeakAttr>())
2570 return llvm::GlobalValue::WeakODRLinkage;
2571 if (RD->isDynamicClass())
2572 return CGM.getVTableLinkage(RD);
2575 return llvm::GlobalValue::LinkOnceODRLinkage;
2578 llvm_unreachable("Invalid linkage!");
2581 llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(QualType Ty, bool Force) {
2582 // We want to operate on the canonical type.
2583 Ty = CGM.getContext().getCanonicalType(Ty);
2585 // Check if we've already emitted an RTTI descriptor for this type.
2586 SmallString<256> OutName;
2587 llvm::raw_svector_ostream Out(OutName);
2588 CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
2590 StringRef Name = OutName.str();
2592 llvm::GlobalVariable *OldGV = CGM.getModule().getNamedGlobal(Name);
2593 if (OldGV && !OldGV->isDeclaration()) {
2594 assert(!OldGV->hasAvailableExternallyLinkage() &&
2595 "available_externally typeinfos not yet implemented");
2597 return llvm::ConstantExpr::getBitCast(OldGV, CGM.Int8PtrTy);
2600 // Check if there is already an external RTTI descriptor for this type.
2601 bool IsStdLib = IsStandardLibraryRTTIDescriptor(Ty);
2602 if (!Force && (IsStdLib || ShouldUseExternalRTTIDescriptor(CGM, Ty)))
2603 return GetAddrOfExternalRTTIDescriptor(Ty);
2605 // Emit the standard library with external linkage.
2606 llvm::GlobalVariable::LinkageTypes Linkage;
2608 Linkage = llvm::GlobalValue::ExternalLinkage;
2610 Linkage = getTypeInfoLinkage(CGM, Ty);
2612 // Add the vtable pointer.
2613 BuildVTablePointer(cast<Type>(Ty));
2616 llvm::GlobalVariable *TypeName = GetAddrOfTypeName(Ty, Linkage);
2617 llvm::Constant *TypeNameField;
2619 // If we're supposed to demote the visibility, be sure to set a flag
2620 // to use a string comparison for type_info comparisons.
2621 ItaniumCXXABI::RTTIUniquenessKind RTTIUniqueness =
2622 CXXABI.classifyRTTIUniqueness(Ty, Linkage);
2623 if (RTTIUniqueness != ItaniumCXXABI::RUK_Unique) {
2624 // The flag is the sign bit, which on ARM64 is defined to be clear
2625 // for global pointers. This is very ARM64-specific.
2626 TypeNameField = llvm::ConstantExpr::getPtrToInt(TypeName, CGM.Int64Ty);
2627 llvm::Constant *flag =
2628 llvm::ConstantInt::get(CGM.Int64Ty, ((uint64_t)1) << 63);
2629 TypeNameField = llvm::ConstantExpr::getAdd(TypeNameField, flag);
2631 llvm::ConstantExpr::getIntToPtr(TypeNameField, CGM.Int8PtrTy);
2633 TypeNameField = llvm::ConstantExpr::getBitCast(TypeName, CGM.Int8PtrTy);
2635 Fields.push_back(TypeNameField);
2637 switch (Ty->getTypeClass()) {
2638 #define TYPE(Class, Base)
2639 #define ABSTRACT_TYPE(Class, Base)
2640 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
2641 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
2642 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
2643 #include "clang/AST/TypeNodes.def"
2644 llvm_unreachable("Non-canonical and dependent types shouldn't get here");
2646 // GCC treats vector types as fundamental types.
2649 case Type::ExtVector:
2651 case Type::BlockPointer:
2652 // Itanium C++ ABI 2.9.5p4:
2653 // abi::__fundamental_type_info adds no data members to std::type_info.
2656 case Type::LValueReference:
2657 case Type::RValueReference:
2658 llvm_unreachable("References shouldn't get here");
2661 llvm_unreachable("Undeduced auto type shouldn't get here");
2663 case Type::ConstantArray:
2664 case Type::IncompleteArray:
2665 case Type::VariableArray:
2666 // Itanium C++ ABI 2.9.5p5:
2667 // abi::__array_type_info adds no data members to std::type_info.
2670 case Type::FunctionNoProto:
2671 case Type::FunctionProto:
2672 // Itanium C++ ABI 2.9.5p5:
2673 // abi::__function_type_info adds no data members to std::type_info.
2677 // Itanium C++ ABI 2.9.5p5:
2678 // abi::__enum_type_info adds no data members to std::type_info.
2681 case Type::Record: {
2682 const CXXRecordDecl *RD =
2683 cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());
2684 if (!RD->hasDefinition() || !RD->getNumBases()) {
2685 // We don't need to emit any fields.
2689 if (CanUseSingleInheritance(RD))
2690 BuildSIClassTypeInfo(RD);
2692 BuildVMIClassTypeInfo(RD);
2697 case Type::ObjCObject:
2698 case Type::ObjCInterface:
2699 BuildObjCObjectTypeInfo(cast<ObjCObjectType>(Ty));
2702 case Type::ObjCObjectPointer:
2703 BuildPointerTypeInfo(cast<ObjCObjectPointerType>(Ty)->getPointeeType());
2707 BuildPointerTypeInfo(cast<PointerType>(Ty)->getPointeeType());
2710 case Type::MemberPointer:
2711 BuildPointerToMemberTypeInfo(cast<MemberPointerType>(Ty));
2715 // No fields, at least for the moment.
2719 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Fields);
2721 llvm::GlobalVariable *GV =
2722 new llvm::GlobalVariable(CGM.getModule(), Init->getType(),
2723 /*Constant=*/true, Linkage, Init, Name);
2725 // If there's already an old global variable, replace it with the new one.
2727 GV->takeName(OldGV);
2728 llvm::Constant *NewPtr =
2729 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
2730 OldGV->replaceAllUsesWith(NewPtr);
2731 OldGV->eraseFromParent();
2734 // The Itanium ABI specifies that type_info objects must be globally
2735 // unique, with one exception: if the type is an incomplete class
2736 // type or a (possibly indirect) pointer to one. That exception
2737 // affects the general case of comparing type_info objects produced
2738 // by the typeid operator, which is why the comparison operators on
2739 // std::type_info generally use the type_info name pointers instead
2740 // of the object addresses. However, the language's built-in uses
2741 // of RTTI generally require class types to be complete, even when
2742 // manipulating pointers to those class types. This allows the
2743 // implementation of dynamic_cast to rely on address equality tests,
2744 // which is much faster.
2746 // All of this is to say that it's important that both the type_info
2747 // object and the type_info name be uniqued when weakly emitted.
2749 // Give the type_info object and name the formal visibility of the
2751 llvm::GlobalValue::VisibilityTypes llvmVisibility;
2752 if (llvm::GlobalValue::isLocalLinkage(Linkage))
2753 // If the linkage is local, only default visibility makes sense.
2754 llvmVisibility = llvm::GlobalValue::DefaultVisibility;
2755 else if (RTTIUniqueness == ItaniumCXXABI::RUK_NonUniqueHidden)
2756 llvmVisibility = llvm::GlobalValue::HiddenVisibility;
2758 llvmVisibility = CodeGenModule::GetLLVMVisibility(Ty->getVisibility());
2759 TypeName->setVisibility(llvmVisibility);
2760 GV->setVisibility(llvmVisibility);
2762 return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
2765 /// ComputeQualifierFlags - Compute the pointer type info flags from the
2766 /// given qualifier.
2767 static unsigned ComputeQualifierFlags(Qualifiers Quals) {
2770 if (Quals.hasConst())
2771 Flags |= ItaniumRTTIBuilder::PTI_Const;
2772 if (Quals.hasVolatile())
2773 Flags |= ItaniumRTTIBuilder::PTI_Volatile;
2774 if (Quals.hasRestrict())
2775 Flags |= ItaniumRTTIBuilder::PTI_Restrict;
2780 /// BuildObjCObjectTypeInfo - Build the appropriate kind of type_info
2781 /// for the given Objective-C object type.
2782 void ItaniumRTTIBuilder::BuildObjCObjectTypeInfo(const ObjCObjectType *OT) {
2784 const Type *T = OT->getBaseType().getTypePtr();
2785 assert(isa<BuiltinType>(T) || isa<ObjCInterfaceType>(T));
2787 // The builtin types are abi::__class_type_infos and don't require
2789 if (isa<BuiltinType>(T)) return;
2791 ObjCInterfaceDecl *Class = cast<ObjCInterfaceType>(T)->getDecl();
2792 ObjCInterfaceDecl *Super = Class->getSuperClass();
2794 // Root classes are also __class_type_info.
2797 QualType SuperTy = CGM.getContext().getObjCInterfaceType(Super);
2799 // Everything else is single inheritance.
2800 llvm::Constant *BaseTypeInfo =
2801 ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(SuperTy);
2802 Fields.push_back(BaseTypeInfo);
2805 /// BuildSIClassTypeInfo - Build an abi::__si_class_type_info, used for single
2806 /// inheritance, according to the Itanium C++ ABI, 2.95p6b.
2807 void ItaniumRTTIBuilder::BuildSIClassTypeInfo(const CXXRecordDecl *RD) {
2808 // Itanium C++ ABI 2.9.5p6b:
2809 // It adds to abi::__class_type_info a single member pointing to the
2810 // type_info structure for the base type,
2811 llvm::Constant *BaseTypeInfo =
2812 ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(RD->bases_begin()->getType());
2813 Fields.push_back(BaseTypeInfo);
2817 /// SeenBases - Contains virtual and non-virtual bases seen when traversing
2818 /// a class hierarchy.
2820 llvm::SmallPtrSet<const CXXRecordDecl *, 16> NonVirtualBases;
2821 llvm::SmallPtrSet<const CXXRecordDecl *, 16> VirtualBases;
2825 /// ComputeVMIClassTypeInfoFlags - Compute the value of the flags member in
2826 /// abi::__vmi_class_type_info.
2828 static unsigned ComputeVMIClassTypeInfoFlags(const CXXBaseSpecifier *Base,
2833 const CXXRecordDecl *BaseDecl =
2834 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
2836 if (Base->isVirtual()) {
2837 // Mark the virtual base as seen.
2838 if (!Bases.VirtualBases.insert(BaseDecl).second) {
2839 // If this virtual base has been seen before, then the class is diamond
2841 Flags |= ItaniumRTTIBuilder::VMI_DiamondShaped;
2843 if (Bases.NonVirtualBases.count(BaseDecl))
2844 Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
2847 // Mark the non-virtual base as seen.
2848 if (!Bases.NonVirtualBases.insert(BaseDecl).second) {
2849 // If this non-virtual base has been seen before, then the class has non-
2850 // diamond shaped repeated inheritance.
2851 Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
2853 if (Bases.VirtualBases.count(BaseDecl))
2854 Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
2859 for (const auto &I : BaseDecl->bases())
2860 Flags |= ComputeVMIClassTypeInfoFlags(&I, Bases);
2865 static unsigned ComputeVMIClassTypeInfoFlags(const CXXRecordDecl *RD) {
2870 for (const auto &I : RD->bases())
2871 Flags |= ComputeVMIClassTypeInfoFlags(&I, Bases);
2876 /// BuildVMIClassTypeInfo - Build an abi::__vmi_class_type_info, used for
2877 /// classes with bases that do not satisfy the abi::__si_class_type_info
2878 /// constraints, according ti the Itanium C++ ABI, 2.9.5p5c.
2879 void ItaniumRTTIBuilder::BuildVMIClassTypeInfo(const CXXRecordDecl *RD) {
2880 llvm::Type *UnsignedIntLTy =
2881 CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy);
2883 // Itanium C++ ABI 2.9.5p6c:
2884 // __flags is a word with flags describing details about the class
2885 // structure, which may be referenced by using the __flags_masks
2886 // enumeration. These flags refer to both direct and indirect bases.
2887 unsigned Flags = ComputeVMIClassTypeInfoFlags(RD);
2888 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
2890 // Itanium C++ ABI 2.9.5p6c:
2891 // __base_count is a word with the number of direct proper base class
2892 // descriptions that follow.
2893 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, RD->getNumBases()));
2895 if (!RD->getNumBases())
2898 llvm::Type *LongLTy =
2899 CGM.getTypes().ConvertType(CGM.getContext().LongTy);
2901 // Now add the base class descriptions.
2903 // Itanium C++ ABI 2.9.5p6c:
2904 // __base_info[] is an array of base class descriptions -- one for every
2905 // direct proper base. Each description is of the type:
2907 // struct abi::__base_class_type_info {
2909 // const __class_type_info *__base_type;
2910 // long __offset_flags;
2912 // enum __offset_flags_masks {
2913 // __virtual_mask = 0x1,
2914 // __public_mask = 0x2,
2915 // __offset_shift = 8
2918 for (const auto &Base : RD->bases()) {
2919 // The __base_type member points to the RTTI for the base type.
2920 Fields.push_back(ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(Base.getType()));
2922 const CXXRecordDecl *BaseDecl =
2923 cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
2925 int64_t OffsetFlags = 0;
2927 // All but the lower 8 bits of __offset_flags are a signed offset.
2928 // For a non-virtual base, this is the offset in the object of the base
2929 // subobject. For a virtual base, this is the offset in the virtual table of
2930 // the virtual base offset for the virtual base referenced (negative).
2932 if (Base.isVirtual())
2934 CGM.getItaniumVTableContext().getVirtualBaseOffsetOffset(RD, BaseDecl);
2936 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
2937 Offset = Layout.getBaseClassOffset(BaseDecl);
2940 OffsetFlags = uint64_t(Offset.getQuantity()) << 8;
2942 // The low-order byte of __offset_flags contains flags, as given by the
2943 // masks from the enumeration __offset_flags_masks.
2944 if (Base.isVirtual())
2945 OffsetFlags |= BCTI_Virtual;
2946 if (Base.getAccessSpecifier() == AS_public)
2947 OffsetFlags |= BCTI_Public;
2949 Fields.push_back(llvm::ConstantInt::get(LongLTy, OffsetFlags));
2953 /// BuildPointerTypeInfo - Build an abi::__pointer_type_info struct,
2954 /// used for pointer types.
2955 void ItaniumRTTIBuilder::BuildPointerTypeInfo(QualType PointeeTy) {
2957 QualType UnqualifiedPointeeTy =
2958 CGM.getContext().getUnqualifiedArrayType(PointeeTy, Quals);
2960 // Itanium C++ ABI 2.9.5p7:
2961 // __flags is a flag word describing the cv-qualification and other
2962 // attributes of the type pointed to
2963 unsigned Flags = ComputeQualifierFlags(Quals);
2965 // Itanium C++ ABI 2.9.5p7:
2966 // When the abi::__pbase_type_info is for a direct or indirect pointer to an
2967 // incomplete class type, the incomplete target type flag is set.
2968 if (ContainsIncompleteClassType(UnqualifiedPointeeTy))
2969 Flags |= PTI_Incomplete;
2971 llvm::Type *UnsignedIntLTy =
2972 CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy);
2973 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
2975 // Itanium C++ ABI 2.9.5p7:
2976 // __pointee is a pointer to the std::type_info derivation for the
2977 // unqualified type being pointed to.
2978 llvm::Constant *PointeeTypeInfo =
2979 ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(UnqualifiedPointeeTy);
2980 Fields.push_back(PointeeTypeInfo);
2983 /// BuildPointerToMemberTypeInfo - Build an abi::__pointer_to_member_type_info
2984 /// struct, used for member pointer types.
2986 ItaniumRTTIBuilder::BuildPointerToMemberTypeInfo(const MemberPointerType *Ty) {
2987 QualType PointeeTy = Ty->getPointeeType();
2990 QualType UnqualifiedPointeeTy =
2991 CGM.getContext().getUnqualifiedArrayType(PointeeTy, Quals);
2993 // Itanium C++ ABI 2.9.5p7:
2994 // __flags is a flag word describing the cv-qualification and other
2995 // attributes of the type pointed to.
2996 unsigned Flags = ComputeQualifierFlags(Quals);
2998 const RecordType *ClassType = cast<RecordType>(Ty->getClass());
3000 // Itanium C++ ABI 2.9.5p7:
3001 // When the abi::__pbase_type_info is for a direct or indirect pointer to an
3002 // incomplete class type, the incomplete target type flag is set.
3003 if (ContainsIncompleteClassType(UnqualifiedPointeeTy))
3004 Flags |= PTI_Incomplete;
3006 if (IsIncompleteClassType(ClassType))
3007 Flags |= PTI_ContainingClassIncomplete;
3009 llvm::Type *UnsignedIntLTy =
3010 CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy);
3011 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3013 // Itanium C++ ABI 2.9.5p7:
3014 // __pointee is a pointer to the std::type_info derivation for the
3015 // unqualified type being pointed to.
3016 llvm::Constant *PointeeTypeInfo =
3017 ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(UnqualifiedPointeeTy);
3018 Fields.push_back(PointeeTypeInfo);
3020 // Itanium C++ ABI 2.9.5p9:
3021 // __context is a pointer to an abi::__class_type_info corresponding to the
3022 // class type containing the member pointed to
3023 // (e.g., the "A" in "int A::*").
3025 ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(QualType(ClassType, 0)));
3028 llvm::Constant *ItaniumCXXABI::getAddrOfRTTIDescriptor(QualType Ty) {
3029 return ItaniumRTTIBuilder(*this).BuildTypeInfo(Ty);
3032 void ItaniumCXXABI::EmitFundamentalRTTIDescriptor(QualType Type) {
3033 QualType PointerType = getContext().getPointerType(Type);
3034 QualType PointerTypeConst = getContext().getPointerType(Type.withConst());
3035 ItaniumRTTIBuilder(*this).BuildTypeInfo(Type, true);
3036 ItaniumRTTIBuilder(*this).BuildTypeInfo(PointerType, true);
3037 ItaniumRTTIBuilder(*this).BuildTypeInfo(PointerTypeConst, true);
3040 void ItaniumCXXABI::EmitFundamentalRTTIDescriptors() {
3041 QualType FundamentalTypes[] = {
3042 getContext().VoidTy, getContext().NullPtrTy,
3043 getContext().BoolTy, getContext().WCharTy,
3044 getContext().CharTy, getContext().UnsignedCharTy,
3045 getContext().SignedCharTy, getContext().ShortTy,
3046 getContext().UnsignedShortTy, getContext().IntTy,
3047 getContext().UnsignedIntTy, getContext().LongTy,
3048 getContext().UnsignedLongTy, getContext().LongLongTy,
3049 getContext().UnsignedLongLongTy, getContext().HalfTy,
3050 getContext().FloatTy, getContext().DoubleTy,
3051 getContext().LongDoubleTy, getContext().Char16Ty,
3052 getContext().Char32Ty,
3054 for (const QualType &FundamentalType : FundamentalTypes)
3055 EmitFundamentalRTTIDescriptor(FundamentalType);
3058 /// What sort of uniqueness rules should we use for the RTTI for the
3060 ItaniumCXXABI::RTTIUniquenessKind ItaniumCXXABI::classifyRTTIUniqueness(
3061 QualType CanTy, llvm::GlobalValue::LinkageTypes Linkage) const {
3062 if (shouldRTTIBeUnique())
3065 // It's only necessary for linkonce_odr or weak_odr linkage.
3066 if (Linkage != llvm::GlobalValue::LinkOnceODRLinkage &&
3067 Linkage != llvm::GlobalValue::WeakODRLinkage)
3070 // It's only necessary with default visibility.
3071 if (CanTy->getVisibility() != DefaultVisibility)
3074 // If we're not required to publish this symbol, hide it.
3075 if (Linkage == llvm::GlobalValue::LinkOnceODRLinkage)
3076 return RUK_NonUniqueHidden;
3078 // If we're required to publish this symbol, as we might be under an
3079 // explicit instantiation, leave it with default visibility but
3080 // enable string-comparisons.
3081 assert(Linkage == llvm::GlobalValue::WeakODRLinkage);
3082 return RUK_NonUniqueVisible;
3085 // Find out how to codegen the complete destructor and constructor
3087 enum class StructorCodegen { Emit, RAUW, Alias, COMDAT };
3089 static StructorCodegen getCodegenToUse(CodeGenModule &CGM,
3090 const CXXMethodDecl *MD) {
3091 if (!CGM.getCodeGenOpts().CXXCtorDtorAliases)
3092 return StructorCodegen::Emit;
3094 // The complete and base structors are not equivalent if there are any virtual
3095 // bases, so emit separate functions.
3096 if (MD->getParent()->getNumVBases())
3097 return StructorCodegen::Emit;
3099 GlobalDecl AliasDecl;
3100 if (const auto *DD = dyn_cast<CXXDestructorDecl>(MD)) {
3101 AliasDecl = GlobalDecl(DD, Dtor_Complete);
3103 const auto *CD = cast<CXXConstructorDecl>(MD);
3104 AliasDecl = GlobalDecl(CD, Ctor_Complete);
3106 llvm::GlobalValue::LinkageTypes Linkage = CGM.getFunctionLinkage(AliasDecl);
3108 if (llvm::GlobalValue::isDiscardableIfUnused(Linkage))
3109 return StructorCodegen::RAUW;
3111 // FIXME: Should we allow available_externally aliases?
3112 if (!llvm::GlobalAlias::isValidLinkage(Linkage))
3113 return StructorCodegen::RAUW;
3115 if (llvm::GlobalValue::isWeakForLinker(Linkage)) {
3116 // Only ELF supports COMDATs with arbitrary names (C5/D5).
3117 if (CGM.getTarget().getTriple().isOSBinFormatELF())
3118 return StructorCodegen::COMDAT;
3119 return StructorCodegen::Emit;
3122 return StructorCodegen::Alias;
3125 static void emitConstructorDestructorAlias(CodeGenModule &CGM,
3126 GlobalDecl AliasDecl,
3127 GlobalDecl TargetDecl) {
3128 llvm::GlobalValue::LinkageTypes Linkage = CGM.getFunctionLinkage(AliasDecl);
3130 StringRef MangledName = CGM.getMangledName(AliasDecl);
3131 llvm::GlobalValue *Entry = CGM.GetGlobalValue(MangledName);
3132 if (Entry && !Entry->isDeclaration())
3135 auto *Aliasee = cast<llvm::GlobalValue>(CGM.GetAddrOfGlobal(TargetDecl));
3136 llvm::PointerType *AliasType = Aliasee->getType();
3138 // Create the alias with no name.
3139 auto *Alias = llvm::GlobalAlias::create(
3140 AliasType->getElementType(), 0, Linkage, "", Aliasee, &CGM.getModule());
3142 // Switch any previous uses to the alias.
3144 assert(Entry->getType() == AliasType &&
3145 "declaration exists with different type");
3146 Alias->takeName(Entry);
3147 Entry->replaceAllUsesWith(Alias);
3148 Entry->eraseFromParent();
3150 Alias->setName(MangledName);
3153 // Finally, set up the alias with its proper name and attributes.
3154 CGM.setAliasAttributes(cast<NamedDecl>(AliasDecl.getDecl()), Alias);
3157 void ItaniumCXXABI::emitCXXStructor(const CXXMethodDecl *MD,
3158 StructorType Type) {
3159 auto *CD = dyn_cast<CXXConstructorDecl>(MD);
3160 const CXXDestructorDecl *DD = CD ? nullptr : cast<CXXDestructorDecl>(MD);
3162 StructorCodegen CGType = getCodegenToUse(CGM, MD);
3164 if (Type == StructorType::Complete) {
3165 GlobalDecl CompleteDecl;
3166 GlobalDecl BaseDecl;
3168 CompleteDecl = GlobalDecl(CD, Ctor_Complete);
3169 BaseDecl = GlobalDecl(CD, Ctor_Base);
3171 CompleteDecl = GlobalDecl(DD, Dtor_Complete);
3172 BaseDecl = GlobalDecl(DD, Dtor_Base);
3175 if (CGType == StructorCodegen::Alias || CGType == StructorCodegen::COMDAT) {
3176 emitConstructorDestructorAlias(CGM, CompleteDecl, BaseDecl);
3180 if (CGType == StructorCodegen::RAUW) {
3181 StringRef MangledName = CGM.getMangledName(CompleteDecl);
3182 auto *Aliasee = cast<llvm::GlobalValue>(CGM.GetAddrOfGlobal(BaseDecl));
3183 CGM.addReplacement(MangledName, Aliasee);
3188 // The base destructor is equivalent to the base destructor of its
3189 // base class if there is exactly one non-virtual base class with a
3190 // non-trivial destructor, there are no fields with a non-trivial
3191 // destructor, and the body of the destructor is trivial.
3192 if (DD && Type == StructorType::Base && CGType != StructorCodegen::COMDAT &&
3193 !CGM.TryEmitBaseDestructorAsAlias(DD))
3196 llvm::Function *Fn = CGM.codegenCXXStructor(MD, Type);
3198 if (CGType == StructorCodegen::COMDAT) {
3199 SmallString<256> Buffer;
3200 llvm::raw_svector_ostream Out(Buffer);
3202 getMangleContext().mangleCXXDtorComdat(DD, Out);
3204 getMangleContext().mangleCXXCtorComdat(CD, Out);
3205 llvm::Comdat *C = CGM.getModule().getOrInsertComdat(Out.str());