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/DataLayout.h"
29 #include "llvm/IR/Intrinsics.h"
30 #include "llvm/IR/Value.h"
32 using namespace clang;
33 using namespace CodeGen;
36 class ItaniumCXXABI : public CodeGen::CGCXXABI {
41 ItaniumCXXABI(CodeGen::CodeGenModule &CGM, bool IsARM = false) :
42 CGCXXABI(CGM), IsARM(IsARM) { }
44 bool isReturnTypeIndirect(const CXXRecordDecl *RD) const {
45 // Structures with either a non-trivial destructor or a non-trivial
46 // copy constructor are always indirect.
47 return !RD->hasTrivialDestructor() || RD->hasNonTrivialCopyConstructor();
50 RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const {
51 // Structures with either a non-trivial destructor or a non-trivial
52 // copy constructor are always indirect.
53 if (!RD->hasTrivialDestructor() || RD->hasNonTrivialCopyConstructor())
58 bool isZeroInitializable(const MemberPointerType *MPT);
60 llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT);
62 llvm::Value *EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
64 llvm::Value *MemFnPtr,
65 const MemberPointerType *MPT);
67 llvm::Value *EmitMemberDataPointerAddress(CodeGenFunction &CGF,
70 const MemberPointerType *MPT);
72 llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,
75 llvm::Constant *EmitMemberPointerConversion(const CastExpr *E,
78 llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT);
80 llvm::Constant *EmitMemberPointer(const CXXMethodDecl *MD);
81 llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT,
83 llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT);
84 llvm::Constant *BuildMemberPointer(const CXXMethodDecl *MD,
85 CharUnits ThisAdjustment);
87 llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF,
90 const MemberPointerType *MPT,
93 llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
95 const MemberPointerType *MPT);
97 llvm::Value *adjustToCompleteObject(CodeGenFunction &CGF,
101 void BuildConstructorSignature(const CXXConstructorDecl *Ctor,
104 SmallVectorImpl<CanQualType> &ArgTys);
106 void BuildDestructorSignature(const CXXDestructorDecl *Dtor,
109 SmallVectorImpl<CanQualType> &ArgTys);
111 void BuildInstanceFunctionParams(CodeGenFunction &CGF,
113 FunctionArgList &Params);
115 void EmitInstanceFunctionProlog(CodeGenFunction &CGF);
117 llvm::Value *EmitConstructorCall(CodeGenFunction &CGF,
118 const CXXConstructorDecl *D,
119 CXXCtorType Type, bool ForVirtualBase,
122 CallExpr::const_arg_iterator ArgBeg,
123 CallExpr::const_arg_iterator ArgEnd);
125 RValue EmitVirtualDestructorCall(CodeGenFunction &CGF,
126 const CXXDestructorDecl *Dtor,
127 CXXDtorType DtorType,
128 SourceLocation CallLoc,
129 ReturnValueSlot ReturnValue,
132 StringRef GetPureVirtualCallName() { return "__cxa_pure_virtual"; }
133 StringRef GetDeletedVirtualCallName() { return "__cxa_deleted_virtual"; }
135 CharUnits getArrayCookieSizeImpl(QualType elementType);
136 llvm::Value *InitializeArrayCookie(CodeGenFunction &CGF,
138 llvm::Value *NumElements,
139 const CXXNewExpr *expr,
140 QualType ElementType);
141 llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF,
142 llvm::Value *allocPtr,
143 CharUnits cookieSize);
145 void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
146 llvm::GlobalVariable *DeclPtr, bool PerformInit);
147 void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
148 llvm::Constant *dtor, llvm::Constant *addr);
150 llvm::Function *getOrCreateThreadLocalWrapper(const VarDecl *VD,
151 llvm::GlobalVariable *Var);
152 void EmitThreadLocalInitFuncs(
153 llvm::ArrayRef<std::pair<const VarDecl *, llvm::GlobalVariable *> > Decls,
154 llvm::Function *InitFunc);
155 LValue EmitThreadLocalDeclRefExpr(CodeGenFunction &CGF,
156 const DeclRefExpr *DRE);
159 class ARMCXXABI : public ItaniumCXXABI {
161 ARMCXXABI(CodeGen::CodeGenModule &CGM) : ItaniumCXXABI(CGM, /*ARM*/ true) {}
163 void BuildConstructorSignature(const CXXConstructorDecl *Ctor,
166 SmallVectorImpl<CanQualType> &ArgTys);
168 void BuildDestructorSignature(const CXXDestructorDecl *Dtor,
171 SmallVectorImpl<CanQualType> &ArgTys);
173 void BuildInstanceFunctionParams(CodeGenFunction &CGF,
175 FunctionArgList &Params);
177 void EmitInstanceFunctionProlog(CodeGenFunction &CGF);
179 void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV, QualType ResTy);
181 CharUnits getArrayCookieSizeImpl(QualType elementType);
182 llvm::Value *InitializeArrayCookie(CodeGenFunction &CGF,
184 llvm::Value *NumElements,
185 const CXXNewExpr *expr,
186 QualType ElementType);
187 llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF, llvm::Value *allocPtr,
188 CharUnits cookieSize);
190 /// \brief Returns true if the given instance method is one of the
191 /// kinds that the ARM ABI says returns 'this'.
192 bool HasThisReturn(GlobalDecl GD) const {
193 const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(GD.getDecl());
194 if (!MD) return false;
195 return ((isa<CXXDestructorDecl>(MD) && GD.getDtorType() != Dtor_Deleting) ||
196 (isa<CXXConstructorDecl>(MD)));
201 CodeGen::CGCXXABI *CodeGen::CreateItaniumCXXABI(CodeGenModule &CGM) {
202 switch (CGM.getTarget().getCXXABI().getKind()) {
203 // For IR-generation purposes, there's no significant difference
204 // between the ARM and iOS ABIs.
205 case TargetCXXABI::GenericARM:
206 case TargetCXXABI::iOS:
207 return new ARMCXXABI(CGM);
209 // Note that AArch64 uses the generic ItaniumCXXABI class since it doesn't
210 // include the other 32-bit ARM oddities: constructor/destructor return values
211 // and array cookies.
212 case TargetCXXABI::GenericAArch64:
213 return new ItaniumCXXABI(CGM, /*IsARM = */ true);
215 case TargetCXXABI::GenericItanium:
216 return new ItaniumCXXABI(CGM);
218 case TargetCXXABI::Microsoft:
219 llvm_unreachable("Microsoft ABI is not Itanium-based");
221 llvm_unreachable("bad ABI kind");
225 ItaniumCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
226 if (MPT->isMemberDataPointer())
227 return CGM.PtrDiffTy;
228 return llvm::StructType::get(CGM.PtrDiffTy, CGM.PtrDiffTy, NULL);
231 /// In the Itanium and ARM ABIs, method pointers have the form:
232 /// struct { ptrdiff_t ptr; ptrdiff_t adj; } memptr;
234 /// In the Itanium ABI:
235 /// - method pointers are virtual if (memptr.ptr & 1) is nonzero
236 /// - the this-adjustment is (memptr.adj)
237 /// - the virtual offset is (memptr.ptr - 1)
240 /// - method pointers are virtual if (memptr.adj & 1) is nonzero
241 /// - the this-adjustment is (memptr.adj >> 1)
242 /// - the virtual offset is (memptr.ptr)
243 /// ARM uses 'adj' for the virtual flag because Thumb functions
244 /// may be only single-byte aligned.
246 /// If the member is virtual, the adjusted 'this' pointer points
247 /// to a vtable pointer from which the virtual offset is applied.
249 /// If the member is non-virtual, memptr.ptr is the address of
250 /// the function to call.
252 ItaniumCXXABI::EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
254 llvm::Value *MemFnPtr,
255 const MemberPointerType *MPT) {
256 CGBuilderTy &Builder = CGF.Builder;
258 const FunctionProtoType *FPT =
259 MPT->getPointeeType()->getAs<FunctionProtoType>();
260 const CXXRecordDecl *RD =
261 cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
263 llvm::FunctionType *FTy =
264 CGM.getTypes().GetFunctionType(
265 CGM.getTypes().arrangeCXXMethodType(RD, FPT));
267 llvm::Constant *ptrdiff_1 = llvm::ConstantInt::get(CGM.PtrDiffTy, 1);
269 llvm::BasicBlock *FnVirtual = CGF.createBasicBlock("memptr.virtual");
270 llvm::BasicBlock *FnNonVirtual = CGF.createBasicBlock("memptr.nonvirtual");
271 llvm::BasicBlock *FnEnd = CGF.createBasicBlock("memptr.end");
273 // Extract memptr.adj, which is in the second field.
274 llvm::Value *RawAdj = Builder.CreateExtractValue(MemFnPtr, 1, "memptr.adj");
276 // Compute the true adjustment.
277 llvm::Value *Adj = RawAdj;
279 Adj = Builder.CreateAShr(Adj, ptrdiff_1, "memptr.adj.shifted");
281 // Apply the adjustment and cast back to the original struct type
283 llvm::Value *Ptr = Builder.CreateBitCast(This, Builder.getInt8PtrTy());
284 Ptr = Builder.CreateInBoundsGEP(Ptr, Adj);
285 This = Builder.CreateBitCast(Ptr, This->getType(), "this.adjusted");
287 // Load the function pointer.
288 llvm::Value *FnAsInt = Builder.CreateExtractValue(MemFnPtr, 0, "memptr.ptr");
290 // If the LSB in the function pointer is 1, the function pointer points to
291 // a virtual function.
292 llvm::Value *IsVirtual;
294 IsVirtual = Builder.CreateAnd(RawAdj, ptrdiff_1);
296 IsVirtual = Builder.CreateAnd(FnAsInt, ptrdiff_1);
297 IsVirtual = Builder.CreateIsNotNull(IsVirtual, "memptr.isvirtual");
298 Builder.CreateCondBr(IsVirtual, FnVirtual, FnNonVirtual);
300 // In the virtual path, the adjustment left 'This' pointing to the
301 // vtable of the correct base subobject. The "function pointer" is an
302 // offset within the vtable (+1 for the virtual flag on non-ARM).
303 CGF.EmitBlock(FnVirtual);
305 // Cast the adjusted this to a pointer to vtable pointer and load.
306 llvm::Type *VTableTy = Builder.getInt8PtrTy();
307 llvm::Value *VTable = Builder.CreateBitCast(This, VTableTy->getPointerTo());
308 VTable = Builder.CreateLoad(VTable, "memptr.vtable");
311 llvm::Value *VTableOffset = FnAsInt;
312 if (!IsARM) VTableOffset = Builder.CreateSub(VTableOffset, ptrdiff_1);
313 VTable = Builder.CreateGEP(VTable, VTableOffset);
315 // Load the virtual function to call.
316 VTable = Builder.CreateBitCast(VTable, FTy->getPointerTo()->getPointerTo());
317 llvm::Value *VirtualFn = Builder.CreateLoad(VTable, "memptr.virtualfn");
318 CGF.EmitBranch(FnEnd);
320 // In the non-virtual path, the function pointer is actually a
322 CGF.EmitBlock(FnNonVirtual);
323 llvm::Value *NonVirtualFn =
324 Builder.CreateIntToPtr(FnAsInt, FTy->getPointerTo(), "memptr.nonvirtualfn");
327 CGF.EmitBlock(FnEnd);
328 llvm::PHINode *Callee = Builder.CreatePHI(FTy->getPointerTo(), 2);
329 Callee->addIncoming(VirtualFn, FnVirtual);
330 Callee->addIncoming(NonVirtualFn, FnNonVirtual);
334 /// Compute an l-value by applying the given pointer-to-member to a
336 llvm::Value *ItaniumCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF,
339 const MemberPointerType *MPT) {
340 assert(MemPtr->getType() == CGM.PtrDiffTy);
342 CGBuilderTy &Builder = CGF.Builder;
344 unsigned AS = Base->getType()->getPointerAddressSpace();
347 Base = Builder.CreateBitCast(Base, Builder.getInt8Ty()->getPointerTo(AS));
349 // Apply the offset, which we assume is non-null.
350 llvm::Value *Addr = Builder.CreateInBoundsGEP(Base, MemPtr, "memptr.offset");
352 // Cast the address to the appropriate pointer type, adopting the
353 // address space of the base pointer.
355 = CGF.ConvertTypeForMem(MPT->getPointeeType())->getPointerTo(AS);
356 return Builder.CreateBitCast(Addr, PType);
359 /// Perform a bitcast, derived-to-base, or base-to-derived member pointer
362 /// Bitcast conversions are always a no-op under Itanium.
364 /// Obligatory offset/adjustment diagram:
365 /// <-- offset --> <-- adjustment -->
366 /// |--------------------------|----------------------|--------------------|
367 /// ^Derived address point ^Base address point ^Member address point
369 /// So when converting a base member pointer to a derived member pointer,
370 /// we add the offset to the adjustment because the address point has
371 /// decreased; and conversely, when converting a derived MP to a base MP
372 /// we subtract the offset from the adjustment because the address point
375 /// The standard forbids (at compile time) conversion to and from
376 /// virtual bases, which is why we don't have to consider them here.
378 /// The standard forbids (at run time) casting a derived MP to a base
379 /// MP when the derived MP does not point to a member of the base.
380 /// This is why -1 is a reasonable choice for null data member
383 ItaniumCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
386 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
387 E->getCastKind() == CK_BaseToDerivedMemberPointer ||
388 E->getCastKind() == CK_ReinterpretMemberPointer);
390 // Under Itanium, reinterprets don't require any additional processing.
391 if (E->getCastKind() == CK_ReinterpretMemberPointer) return src;
393 // Use constant emission if we can.
394 if (isa<llvm::Constant>(src))
395 return EmitMemberPointerConversion(E, cast<llvm::Constant>(src));
397 llvm::Constant *adj = getMemberPointerAdjustment(E);
398 if (!adj) return src;
400 CGBuilderTy &Builder = CGF.Builder;
401 bool isDerivedToBase = (E->getCastKind() == CK_DerivedToBaseMemberPointer);
403 const MemberPointerType *destTy =
404 E->getType()->castAs<MemberPointerType>();
406 // For member data pointers, this is just a matter of adding the
407 // offset if the source is non-null.
408 if (destTy->isMemberDataPointer()) {
411 dst = Builder.CreateNSWSub(src, adj, "adj");
413 dst = Builder.CreateNSWAdd(src, adj, "adj");
416 llvm::Value *null = llvm::Constant::getAllOnesValue(src->getType());
417 llvm::Value *isNull = Builder.CreateICmpEQ(src, null, "memptr.isnull");
418 return Builder.CreateSelect(isNull, src, dst);
421 // The this-adjustment is left-shifted by 1 on ARM.
423 uint64_t offset = cast<llvm::ConstantInt>(adj)->getZExtValue();
425 adj = llvm::ConstantInt::get(adj->getType(), offset);
428 llvm::Value *srcAdj = Builder.CreateExtractValue(src, 1, "src.adj");
431 dstAdj = Builder.CreateNSWSub(srcAdj, adj, "adj");
433 dstAdj = Builder.CreateNSWAdd(srcAdj, adj, "adj");
435 return Builder.CreateInsertValue(src, dstAdj, 1);
439 ItaniumCXXABI::EmitMemberPointerConversion(const CastExpr *E,
440 llvm::Constant *src) {
441 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
442 E->getCastKind() == CK_BaseToDerivedMemberPointer ||
443 E->getCastKind() == CK_ReinterpretMemberPointer);
445 // Under Itanium, reinterprets don't require any additional processing.
446 if (E->getCastKind() == CK_ReinterpretMemberPointer) return src;
448 // If the adjustment is trivial, we don't need to do anything.
449 llvm::Constant *adj = getMemberPointerAdjustment(E);
450 if (!adj) return src;
452 bool isDerivedToBase = (E->getCastKind() == CK_DerivedToBaseMemberPointer);
454 const MemberPointerType *destTy =
455 E->getType()->castAs<MemberPointerType>();
457 // For member data pointers, this is just a matter of adding the
458 // offset if the source is non-null.
459 if (destTy->isMemberDataPointer()) {
460 // null maps to null.
461 if (src->isAllOnesValue()) return src;
464 return llvm::ConstantExpr::getNSWSub(src, adj);
466 return llvm::ConstantExpr::getNSWAdd(src, adj);
469 // The this-adjustment is left-shifted by 1 on ARM.
471 uint64_t offset = cast<llvm::ConstantInt>(adj)->getZExtValue();
473 adj = llvm::ConstantInt::get(adj->getType(), offset);
476 llvm::Constant *srcAdj = llvm::ConstantExpr::getExtractValue(src, 1);
477 llvm::Constant *dstAdj;
479 dstAdj = llvm::ConstantExpr::getNSWSub(srcAdj, adj);
481 dstAdj = llvm::ConstantExpr::getNSWAdd(srcAdj, adj);
483 return llvm::ConstantExpr::getInsertValue(src, dstAdj, 1);
487 ItaniumCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
488 // Itanium C++ ABI 2.3:
489 // A NULL pointer is represented as -1.
490 if (MPT->isMemberDataPointer())
491 return llvm::ConstantInt::get(CGM.PtrDiffTy, -1ULL, /*isSigned=*/true);
493 llvm::Constant *Zero = llvm::ConstantInt::get(CGM.PtrDiffTy, 0);
494 llvm::Constant *Values[2] = { Zero, Zero };
495 return llvm::ConstantStruct::getAnon(Values);
499 ItaniumCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
501 // Itanium C++ ABI 2.3:
502 // A pointer to data member is an offset from the base address of
503 // the class object containing it, represented as a ptrdiff_t
504 return llvm::ConstantInt::get(CGM.PtrDiffTy, offset.getQuantity());
507 llvm::Constant *ItaniumCXXABI::EmitMemberPointer(const CXXMethodDecl *MD) {
508 return BuildMemberPointer(MD, CharUnits::Zero());
511 llvm::Constant *ItaniumCXXABI::BuildMemberPointer(const CXXMethodDecl *MD,
512 CharUnits ThisAdjustment) {
513 assert(MD->isInstance() && "Member function must not be static!");
514 MD = MD->getCanonicalDecl();
516 CodeGenTypes &Types = CGM.getTypes();
518 // Get the function pointer (or index if this is a virtual function).
519 llvm::Constant *MemPtr[2];
520 if (MD->isVirtual()) {
521 uint64_t Index = CGM.getVTableContext().getMethodVTableIndex(MD);
523 const ASTContext &Context = getContext();
524 CharUnits PointerWidth =
525 Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
526 uint64_t VTableOffset = (Index * PointerWidth.getQuantity());
529 // ARM C++ ABI 3.2.1:
530 // This ABI specifies that adj contains twice the this
531 // adjustment, plus 1 if the member function is virtual. The
532 // least significant bit of adj then makes exactly the same
533 // discrimination as the least significant bit of ptr does for
535 MemPtr[0] = llvm::ConstantInt::get(CGM.PtrDiffTy, VTableOffset);
536 MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
537 2 * ThisAdjustment.getQuantity() + 1);
539 // Itanium C++ ABI 2.3:
540 // For a virtual function, [the pointer field] is 1 plus the
541 // virtual table offset (in bytes) of the function,
542 // represented as a ptrdiff_t.
543 MemPtr[0] = llvm::ConstantInt::get(CGM.PtrDiffTy, VTableOffset + 1);
544 MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
545 ThisAdjustment.getQuantity());
548 const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
550 // Check whether the function has a computable LLVM signature.
551 if (Types.isFuncTypeConvertible(FPT)) {
552 // The function has a computable LLVM signature; use the correct type.
553 Ty = Types.GetFunctionType(Types.arrangeCXXMethodDeclaration(MD));
555 // Use an arbitrary non-function type to tell GetAddrOfFunction that the
556 // function type is incomplete.
559 llvm::Constant *addr = CGM.GetAddrOfFunction(MD, Ty);
561 MemPtr[0] = llvm::ConstantExpr::getPtrToInt(addr, CGM.PtrDiffTy);
562 MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy, (IsARM ? 2 : 1) *
563 ThisAdjustment.getQuantity());
566 return llvm::ConstantStruct::getAnon(MemPtr);
569 llvm::Constant *ItaniumCXXABI::EmitMemberPointer(const APValue &MP,
571 const MemberPointerType *MPT = MPType->castAs<MemberPointerType>();
572 const ValueDecl *MPD = MP.getMemberPointerDecl();
574 return EmitNullMemberPointer(MPT);
576 // Compute the this-adjustment.
577 CharUnits ThisAdjustment = CharUnits::Zero();
578 ArrayRef<const CXXRecordDecl*> Path = MP.getMemberPointerPath();
579 bool DerivedMember = MP.isMemberPointerToDerivedMember();
580 const CXXRecordDecl *RD = cast<CXXRecordDecl>(MPD->getDeclContext());
581 for (unsigned I = 0, N = Path.size(); I != N; ++I) {
582 const CXXRecordDecl *Base = RD;
583 const CXXRecordDecl *Derived = Path[I];
585 std::swap(Base, Derived);
587 getContext().getASTRecordLayout(Derived).getBaseClassOffset(Base);
591 ThisAdjustment = -ThisAdjustment;
593 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MPD))
594 return BuildMemberPointer(MD, ThisAdjustment);
596 CharUnits FieldOffset =
597 getContext().toCharUnitsFromBits(getContext().getFieldOffset(MPD));
598 return EmitMemberDataPointer(MPT, ThisAdjustment + FieldOffset);
601 /// The comparison algorithm is pretty easy: the member pointers are
602 /// the same if they're either bitwise identical *or* both null.
604 /// ARM is different here only because null-ness is more complicated.
606 ItaniumCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
609 const MemberPointerType *MPT,
611 CGBuilderTy &Builder = CGF.Builder;
613 llvm::ICmpInst::Predicate Eq;
614 llvm::Instruction::BinaryOps And, Or;
616 Eq = llvm::ICmpInst::ICMP_NE;
617 And = llvm::Instruction::Or;
618 Or = llvm::Instruction::And;
620 Eq = llvm::ICmpInst::ICMP_EQ;
621 And = llvm::Instruction::And;
622 Or = llvm::Instruction::Or;
625 // Member data pointers are easy because there's a unique null
626 // value, so it just comes down to bitwise equality.
627 if (MPT->isMemberDataPointer())
628 return Builder.CreateICmp(Eq, L, R);
630 // For member function pointers, the tautologies are more complex.
631 // The Itanium tautology is:
632 // (L == R) <==> (L.ptr == R.ptr && (L.ptr == 0 || L.adj == R.adj))
633 // The ARM tautology is:
634 // (L == R) <==> (L.ptr == R.ptr &&
635 // (L.adj == R.adj ||
636 // (L.ptr == 0 && ((L.adj|R.adj) & 1) == 0)))
637 // The inequality tautologies have exactly the same structure, except
638 // applying De Morgan's laws.
640 llvm::Value *LPtr = Builder.CreateExtractValue(L, 0, "lhs.memptr.ptr");
641 llvm::Value *RPtr = Builder.CreateExtractValue(R, 0, "rhs.memptr.ptr");
643 // This condition tests whether L.ptr == R.ptr. This must always be
644 // true for equality to hold.
645 llvm::Value *PtrEq = Builder.CreateICmp(Eq, LPtr, RPtr, "cmp.ptr");
647 // This condition, together with the assumption that L.ptr == R.ptr,
648 // tests whether the pointers are both null. ARM imposes an extra
650 llvm::Value *Zero = llvm::Constant::getNullValue(LPtr->getType());
651 llvm::Value *EqZero = Builder.CreateICmp(Eq, LPtr, Zero, "cmp.ptr.null");
653 // This condition tests whether L.adj == R.adj. If this isn't
654 // true, the pointers are unequal unless they're both null.
655 llvm::Value *LAdj = Builder.CreateExtractValue(L, 1, "lhs.memptr.adj");
656 llvm::Value *RAdj = Builder.CreateExtractValue(R, 1, "rhs.memptr.adj");
657 llvm::Value *AdjEq = Builder.CreateICmp(Eq, LAdj, RAdj, "cmp.adj");
659 // Null member function pointers on ARM clear the low bit of Adj,
660 // so the zero condition has to check that neither low bit is set.
662 llvm::Value *One = llvm::ConstantInt::get(LPtr->getType(), 1);
664 // Compute (l.adj | r.adj) & 1 and test it against zero.
665 llvm::Value *OrAdj = Builder.CreateOr(LAdj, RAdj, "or.adj");
666 llvm::Value *OrAdjAnd1 = Builder.CreateAnd(OrAdj, One);
667 llvm::Value *OrAdjAnd1EqZero = Builder.CreateICmp(Eq, OrAdjAnd1, Zero,
669 EqZero = Builder.CreateBinOp(And, EqZero, OrAdjAnd1EqZero);
672 // Tie together all our conditions.
673 llvm::Value *Result = Builder.CreateBinOp(Or, EqZero, AdjEq);
674 Result = Builder.CreateBinOp(And, PtrEq, Result,
675 Inequality ? "memptr.ne" : "memptr.eq");
680 ItaniumCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
682 const MemberPointerType *MPT) {
683 CGBuilderTy &Builder = CGF.Builder;
685 /// For member data pointers, this is just a check against -1.
686 if (MPT->isMemberDataPointer()) {
687 assert(MemPtr->getType() == CGM.PtrDiffTy);
688 llvm::Value *NegativeOne =
689 llvm::Constant::getAllOnesValue(MemPtr->getType());
690 return Builder.CreateICmpNE(MemPtr, NegativeOne, "memptr.tobool");
693 // In Itanium, a member function pointer is not null if 'ptr' is not null.
694 llvm::Value *Ptr = Builder.CreateExtractValue(MemPtr, 0, "memptr.ptr");
696 llvm::Constant *Zero = llvm::ConstantInt::get(Ptr->getType(), 0);
697 llvm::Value *Result = Builder.CreateICmpNE(Ptr, Zero, "memptr.tobool");
699 // On ARM, a member function pointer is also non-null if the low bit of 'adj'
700 // (the virtual bit) is set.
702 llvm::Constant *One = llvm::ConstantInt::get(Ptr->getType(), 1);
703 llvm::Value *Adj = Builder.CreateExtractValue(MemPtr, 1, "memptr.adj");
704 llvm::Value *VirtualBit = Builder.CreateAnd(Adj, One, "memptr.virtualbit");
705 llvm::Value *IsVirtual = Builder.CreateICmpNE(VirtualBit, Zero,
707 Result = Builder.CreateOr(Result, IsVirtual);
713 /// The Itanium ABI requires non-zero initialization only for data
714 /// member pointers, for which '0' is a valid offset.
715 bool ItaniumCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
716 return MPT->getPointeeType()->isFunctionType();
719 /// The Itanium ABI always places an offset to the complete object
720 /// at entry -2 in the vtable.
721 llvm::Value *ItaniumCXXABI::adjustToCompleteObject(CodeGenFunction &CGF,
724 // Grab the vtable pointer as an intptr_t*.
725 llvm::Value *vtable = CGF.GetVTablePtr(ptr, CGF.IntPtrTy->getPointerTo());
727 // Track back to entry -2 and pull out the offset there.
728 llvm::Value *offsetPtr =
729 CGF.Builder.CreateConstInBoundsGEP1_64(vtable, -2, "complete-offset.ptr");
730 llvm::LoadInst *offset = CGF.Builder.CreateLoad(offsetPtr);
731 offset->setAlignment(CGF.PointerAlignInBytes);
734 ptr = CGF.Builder.CreateBitCast(ptr, CGF.Int8PtrTy);
735 return CGF.Builder.CreateInBoundsGEP(ptr, offset);
738 /// The generic ABI passes 'this', plus a VTT if it's initializing a
740 void ItaniumCXXABI::BuildConstructorSignature(const CXXConstructorDecl *Ctor,
743 SmallVectorImpl<CanQualType> &ArgTys) {
744 ASTContext &Context = getContext();
746 // 'this' is already there.
748 // Check if we need to add a VTT parameter (which has type void **).
749 if (Type == Ctor_Base && Ctor->getParent()->getNumVBases() != 0)
750 ArgTys.push_back(Context.getPointerType(Context.VoidPtrTy));
753 /// The ARM ABI does the same as the Itanium ABI, but returns 'this'.
754 void ARMCXXABI::BuildConstructorSignature(const CXXConstructorDecl *Ctor,
757 SmallVectorImpl<CanQualType> &ArgTys) {
758 ItaniumCXXABI::BuildConstructorSignature(Ctor, Type, ResTy, ArgTys);
762 /// The generic ABI passes 'this', plus a VTT if it's destroying a
764 void ItaniumCXXABI::BuildDestructorSignature(const CXXDestructorDecl *Dtor,
767 SmallVectorImpl<CanQualType> &ArgTys) {
768 ASTContext &Context = getContext();
770 // 'this' is already there.
772 // Check if we need to add a VTT parameter (which has type void **).
773 if (Type == Dtor_Base && Dtor->getParent()->getNumVBases() != 0)
774 ArgTys.push_back(Context.getPointerType(Context.VoidPtrTy));
777 /// The ARM ABI does the same as the Itanium ABI, but returns 'this'
778 /// for non-deleting destructors.
779 void ARMCXXABI::BuildDestructorSignature(const CXXDestructorDecl *Dtor,
782 SmallVectorImpl<CanQualType> &ArgTys) {
783 ItaniumCXXABI::BuildDestructorSignature(Dtor, Type, ResTy, ArgTys);
785 if (Type != Dtor_Deleting)
789 void ItaniumCXXABI::BuildInstanceFunctionParams(CodeGenFunction &CGF,
791 FunctionArgList &Params) {
792 /// Create the 'this' variable.
793 BuildThisParam(CGF, Params);
795 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
796 assert(MD->isInstance());
798 // Check if we need a VTT parameter as well.
799 if (CodeGenVTables::needsVTTParameter(CGF.CurGD)) {
800 ASTContext &Context = getContext();
802 // FIXME: avoid the fake decl
803 QualType T = Context.getPointerType(Context.VoidPtrTy);
804 ImplicitParamDecl *VTTDecl
805 = ImplicitParamDecl::Create(Context, 0, MD->getLocation(),
806 &Context.Idents.get("vtt"), T);
807 Params.push_back(VTTDecl);
808 getVTTDecl(CGF) = VTTDecl;
812 void ARMCXXABI::BuildInstanceFunctionParams(CodeGenFunction &CGF,
814 FunctionArgList &Params) {
815 ItaniumCXXABI::BuildInstanceFunctionParams(CGF, ResTy, Params);
817 // Return 'this' from certain constructors and destructors.
818 if (HasThisReturn(CGF.CurGD))
819 ResTy = Params[0]->getType();
822 void ItaniumCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
823 /// Initialize the 'this' slot.
826 /// Initialize the 'vtt' slot if needed.
827 if (getVTTDecl(CGF)) {
829 = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getVTTDecl(CGF)),
834 void ARMCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
835 ItaniumCXXABI::EmitInstanceFunctionProlog(CGF);
837 /// Initialize the return slot to 'this' at the start of the
839 if (HasThisReturn(CGF.CurGD))
840 CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
843 llvm::Value *ItaniumCXXABI::EmitConstructorCall(CodeGenFunction &CGF,
844 const CXXConstructorDecl *D,
845 CXXCtorType Type, bool ForVirtualBase,
848 CallExpr::const_arg_iterator ArgBeg,
849 CallExpr::const_arg_iterator ArgEnd) {
850 llvm::Value *VTT = CGF.GetVTTParameter(GlobalDecl(D, Type), ForVirtualBase,
852 QualType VTTTy = getContext().getPointerType(getContext().VoidPtrTy);
853 llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(D, Type);
855 // FIXME: Provide a source location here.
856 CGF.EmitCXXMemberCall(D, SourceLocation(), Callee, ReturnValueSlot(), This,
857 VTT, VTTTy, ArgBeg, ArgEnd);
861 RValue ItaniumCXXABI::EmitVirtualDestructorCall(CodeGenFunction &CGF,
862 const CXXDestructorDecl *Dtor,
863 CXXDtorType DtorType,
864 SourceLocation CallLoc,
865 ReturnValueSlot ReturnValue,
867 assert(DtorType == Dtor_Deleting || DtorType == Dtor_Complete);
869 const CGFunctionInfo *FInfo
870 = &CGM.getTypes().arrangeCXXDestructor(Dtor, DtorType);
871 llvm::Type *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
872 llvm::Value *Callee = CGF.BuildVirtualCall(Dtor, DtorType, This, Ty);
874 return CGF.EmitCXXMemberCall(Dtor, CallLoc, Callee, ReturnValue, This,
875 /*ImplicitParam=*/0, QualType(), 0, 0);
878 void ARMCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
879 RValue RV, QualType ResultType) {
880 if (!isa<CXXDestructorDecl>(CGF.CurGD.getDecl()))
881 return ItaniumCXXABI::EmitReturnFromThunk(CGF, RV, ResultType);
883 // Destructor thunks in the ARM ABI have indeterminate results.
885 cast<llvm::PointerType>(CGF.ReturnValue->getType())->getElementType();
886 RValue Undef = RValue::get(llvm::UndefValue::get(T));
887 return ItaniumCXXABI::EmitReturnFromThunk(CGF, Undef, ResultType);
890 /************************** Array allocation cookies **************************/
892 CharUnits ItaniumCXXABI::getArrayCookieSizeImpl(QualType elementType) {
893 // The array cookie is a size_t; pad that up to the element alignment.
894 // The cookie is actually right-justified in that space.
895 return std::max(CharUnits::fromQuantity(CGM.SizeSizeInBytes),
896 CGM.getContext().getTypeAlignInChars(elementType));
899 llvm::Value *ItaniumCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
901 llvm::Value *NumElements,
902 const CXXNewExpr *expr,
903 QualType ElementType) {
904 assert(requiresArrayCookie(expr));
906 unsigned AS = NewPtr->getType()->getPointerAddressSpace();
908 ASTContext &Ctx = getContext();
909 QualType SizeTy = Ctx.getSizeType();
910 CharUnits SizeSize = Ctx.getTypeSizeInChars(SizeTy);
912 // The size of the cookie.
913 CharUnits CookieSize =
914 std::max(SizeSize, Ctx.getTypeAlignInChars(ElementType));
915 assert(CookieSize == getArrayCookieSizeImpl(ElementType));
917 // Compute an offset to the cookie.
918 llvm::Value *CookiePtr = NewPtr;
919 CharUnits CookieOffset = CookieSize - SizeSize;
920 if (!CookieOffset.isZero())
921 CookiePtr = CGF.Builder.CreateConstInBoundsGEP1_64(CookiePtr,
922 CookieOffset.getQuantity());
924 // Write the number of elements into the appropriate slot.
925 llvm::Value *NumElementsPtr
926 = CGF.Builder.CreateBitCast(CookiePtr,
927 CGF.ConvertType(SizeTy)->getPointerTo(AS));
928 CGF.Builder.CreateStore(NumElements, NumElementsPtr);
930 // Finally, compute a pointer to the actual data buffer by skipping
931 // over the cookie completely.
932 return CGF.Builder.CreateConstInBoundsGEP1_64(NewPtr,
933 CookieSize.getQuantity());
936 llvm::Value *ItaniumCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
937 llvm::Value *allocPtr,
938 CharUnits cookieSize) {
939 // The element size is right-justified in the cookie.
940 llvm::Value *numElementsPtr = allocPtr;
941 CharUnits numElementsOffset =
942 cookieSize - CharUnits::fromQuantity(CGF.SizeSizeInBytes);
943 if (!numElementsOffset.isZero())
945 CGF.Builder.CreateConstInBoundsGEP1_64(numElementsPtr,
946 numElementsOffset.getQuantity());
948 unsigned AS = allocPtr->getType()->getPointerAddressSpace();
950 CGF.Builder.CreateBitCast(numElementsPtr, CGF.SizeTy->getPointerTo(AS));
951 return CGF.Builder.CreateLoad(numElementsPtr);
954 CharUnits ARMCXXABI::getArrayCookieSizeImpl(QualType elementType) {
955 // ARM says that the cookie is always:
956 // struct array_cookie {
957 // std::size_t element_size; // element_size != 0
958 // std::size_t element_count;
960 // But the base ABI doesn't give anything an alignment greater than
961 // 8, so we can dismiss this as typical ABI-author blindness to
962 // actual language complexity and round up to the element alignment.
963 return std::max(CharUnits::fromQuantity(2 * CGM.SizeSizeInBytes),
964 CGM.getContext().getTypeAlignInChars(elementType));
967 llvm::Value *ARMCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
969 llvm::Value *numElements,
970 const CXXNewExpr *expr,
971 QualType elementType) {
972 assert(requiresArrayCookie(expr));
974 // NewPtr is a char*, but we generalize to arbitrary addrspaces.
975 unsigned AS = newPtr->getType()->getPointerAddressSpace();
977 // The cookie is always at the start of the buffer.
978 llvm::Value *cookie = newPtr;
980 // The first element is the element size.
981 cookie = CGF.Builder.CreateBitCast(cookie, CGF.SizeTy->getPointerTo(AS));
982 llvm::Value *elementSize = llvm::ConstantInt::get(CGF.SizeTy,
983 getContext().getTypeSizeInChars(elementType).getQuantity());
984 CGF.Builder.CreateStore(elementSize, cookie);
986 // The second element is the element count.
987 cookie = CGF.Builder.CreateConstInBoundsGEP1_32(cookie, 1);
988 CGF.Builder.CreateStore(numElements, cookie);
990 // Finally, compute a pointer to the actual data buffer by skipping
991 // over the cookie completely.
992 CharUnits cookieSize = ARMCXXABI::getArrayCookieSizeImpl(elementType);
993 return CGF.Builder.CreateConstInBoundsGEP1_64(newPtr,
994 cookieSize.getQuantity());
997 llvm::Value *ARMCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
998 llvm::Value *allocPtr,
999 CharUnits cookieSize) {
1000 // The number of elements is at offset sizeof(size_t) relative to
1001 // the allocated pointer.
1002 llvm::Value *numElementsPtr
1003 = CGF.Builder.CreateConstInBoundsGEP1_64(allocPtr, CGF.SizeSizeInBytes);
1005 unsigned AS = allocPtr->getType()->getPointerAddressSpace();
1007 CGF.Builder.CreateBitCast(numElementsPtr, CGF.SizeTy->getPointerTo(AS));
1008 return CGF.Builder.CreateLoad(numElementsPtr);
1011 /*********************** Static local initialization **************************/
1013 static llvm::Constant *getGuardAcquireFn(CodeGenModule &CGM,
1014 llvm::PointerType *GuardPtrTy) {
1015 // int __cxa_guard_acquire(__guard *guard_object);
1016 llvm::FunctionType *FTy =
1017 llvm::FunctionType::get(CGM.getTypes().ConvertType(CGM.getContext().IntTy),
1018 GuardPtrTy, /*isVarArg=*/false);
1019 return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_acquire",
1020 llvm::AttributeSet::get(CGM.getLLVMContext(),
1021 llvm::AttributeSet::FunctionIndex,
1022 llvm::Attribute::NoUnwind));
1025 static llvm::Constant *getGuardReleaseFn(CodeGenModule &CGM,
1026 llvm::PointerType *GuardPtrTy) {
1027 // void __cxa_guard_release(__guard *guard_object);
1028 llvm::FunctionType *FTy =
1029 llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
1030 return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_release",
1031 llvm::AttributeSet::get(CGM.getLLVMContext(),
1032 llvm::AttributeSet::FunctionIndex,
1033 llvm::Attribute::NoUnwind));
1036 static llvm::Constant *getGuardAbortFn(CodeGenModule &CGM,
1037 llvm::PointerType *GuardPtrTy) {
1038 // void __cxa_guard_abort(__guard *guard_object);
1039 llvm::FunctionType *FTy =
1040 llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
1041 return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_abort",
1042 llvm::AttributeSet::get(CGM.getLLVMContext(),
1043 llvm::AttributeSet::FunctionIndex,
1044 llvm::Attribute::NoUnwind));
1048 struct CallGuardAbort : EHScopeStack::Cleanup {
1049 llvm::GlobalVariable *Guard;
1050 CallGuardAbort(llvm::GlobalVariable *Guard) : Guard(Guard) {}
1052 void Emit(CodeGenFunction &CGF, Flags flags) {
1053 CGF.EmitNounwindRuntimeCall(getGuardAbortFn(CGF.CGM, Guard->getType()),
1059 /// The ARM code here follows the Itanium code closely enough that we
1060 /// just special-case it at particular places.
1061 void ItaniumCXXABI::EmitGuardedInit(CodeGenFunction &CGF,
1063 llvm::GlobalVariable *var,
1064 bool shouldPerformInit) {
1065 CGBuilderTy &Builder = CGF.Builder;
1067 // We only need to use thread-safe statics for local non-TLS variables;
1068 // global initialization is always single-threaded.
1069 bool threadsafe = getContext().getLangOpts().ThreadsafeStatics &&
1070 D.isLocalVarDecl() && !D.getTLSKind();
1072 // If we have a global variable with internal linkage and thread-safe statics
1073 // are disabled, we can just let the guard variable be of type i8.
1074 bool useInt8GuardVariable = !threadsafe && var->hasInternalLinkage();
1076 llvm::IntegerType *guardTy;
1077 if (useInt8GuardVariable) {
1078 guardTy = CGF.Int8Ty;
1080 // Guard variables are 64 bits in the generic ABI and size width on ARM
1081 // (i.e. 32-bit on AArch32, 64-bit on AArch64).
1082 guardTy = (IsARM ? CGF.SizeTy : CGF.Int64Ty);
1084 llvm::PointerType *guardPtrTy = guardTy->getPointerTo();
1086 // Create the guard variable if we don't already have it (as we
1087 // might if we're double-emitting this function body).
1088 llvm::GlobalVariable *guard = CGM.getStaticLocalDeclGuardAddress(&D);
1090 // Mangle the name for the guard.
1091 SmallString<256> guardName;
1093 llvm::raw_svector_ostream out(guardName);
1094 getMangleContext().mangleItaniumGuardVariable(&D, out);
1098 // Create the guard variable with a zero-initializer.
1099 // Just absorb linkage and visibility from the guarded variable.
1100 guard = new llvm::GlobalVariable(CGM.getModule(), guardTy,
1101 false, var->getLinkage(),
1102 llvm::ConstantInt::get(guardTy, 0),
1104 guard->setVisibility(var->getVisibility());
1105 // If the variable is thread-local, so is its guard variable.
1106 guard->setThreadLocalMode(var->getThreadLocalMode());
1108 CGM.setStaticLocalDeclGuardAddress(&D, guard);
1111 // Test whether the variable has completed initialization.
1112 llvm::Value *isInitialized;
1114 // ARM C++ ABI 3.2.3.1:
1115 // To support the potential use of initialization guard variables
1116 // as semaphores that are the target of ARM SWP and LDREX/STREX
1117 // synchronizing instructions we define a static initialization
1118 // guard variable to be a 4-byte aligned, 4- byte word with the
1119 // following inline access protocol.
1120 // #define INITIALIZED 1
1121 // if ((obj_guard & INITIALIZED) != INITIALIZED) {
1122 // if (__cxa_guard_acquire(&obj_guard))
1125 if (IsARM && !useInt8GuardVariable) {
1126 llvm::Value *V = Builder.CreateLoad(guard);
1127 llvm::Value *Test1 = llvm::ConstantInt::get(guardTy, 1);
1128 V = Builder.CreateAnd(V, Test1);
1129 isInitialized = Builder.CreateIsNull(V, "guard.uninitialized");
1131 // Itanium C++ ABI 3.3.2:
1132 // The following is pseudo-code showing how these functions can be used:
1133 // if (obj_guard.first_byte == 0) {
1134 // if ( __cxa_guard_acquire (&obj_guard) ) {
1136 // ... initialize the object ...;
1138 // __cxa_guard_abort (&obj_guard);
1141 // ... queue object destructor with __cxa_atexit() ...;
1142 // __cxa_guard_release (&obj_guard);
1146 // Load the first byte of the guard variable.
1147 llvm::LoadInst *LI =
1148 Builder.CreateLoad(Builder.CreateBitCast(guard, CGM.Int8PtrTy));
1149 LI->setAlignment(1);
1152 // An implementation supporting thread-safety on multiprocessor
1153 // systems must also guarantee that references to the initialized
1154 // object do not occur before the load of the initialization flag.
1156 // In LLVM, we do this by marking the load Acquire.
1158 LI->setAtomic(llvm::Acquire);
1160 isInitialized = Builder.CreateIsNull(LI, "guard.uninitialized");
1163 llvm::BasicBlock *InitCheckBlock = CGF.createBasicBlock("init.check");
1164 llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end");
1166 // Check if the first byte of the guard variable is zero.
1167 Builder.CreateCondBr(isInitialized, InitCheckBlock, EndBlock);
1169 CGF.EmitBlock(InitCheckBlock);
1171 // Variables used when coping with thread-safe statics and exceptions.
1173 // Call __cxa_guard_acquire.
1175 = CGF.EmitNounwindRuntimeCall(getGuardAcquireFn(CGM, guardPtrTy), guard);
1177 llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
1179 Builder.CreateCondBr(Builder.CreateIsNotNull(V, "tobool"),
1180 InitBlock, EndBlock);
1182 // Call __cxa_guard_abort along the exceptional edge.
1183 CGF.EHStack.pushCleanup<CallGuardAbort>(EHCleanup, guard);
1185 CGF.EmitBlock(InitBlock);
1188 // Emit the initializer and add a global destructor if appropriate.
1189 CGF.EmitCXXGlobalVarDeclInit(D, var, shouldPerformInit);
1192 // Pop the guard-abort cleanup if we pushed one.
1193 CGF.PopCleanupBlock();
1195 // Call __cxa_guard_release. This cannot throw.
1196 CGF.EmitNounwindRuntimeCall(getGuardReleaseFn(CGM, guardPtrTy), guard);
1198 Builder.CreateStore(llvm::ConstantInt::get(guardTy, 1), guard);
1201 CGF.EmitBlock(EndBlock);
1204 /// Register a global destructor using __cxa_atexit.
1205 static void emitGlobalDtorWithCXAAtExit(CodeGenFunction &CGF,
1206 llvm::Constant *dtor,
1207 llvm::Constant *addr,
1209 const char *Name = "__cxa_atexit";
1211 const llvm::Triple &T = CGF.getTarget().getTriple();
1212 Name = T.isMacOSX() ? "_tlv_atexit" : "__cxa_thread_atexit";
1215 // We're assuming that the destructor function is something we can
1216 // reasonably call with the default CC. Go ahead and cast it to the
1218 llvm::Type *dtorTy =
1219 llvm::FunctionType::get(CGF.VoidTy, CGF.Int8PtrTy, false)->getPointerTo();
1221 // extern "C" int __cxa_atexit(void (*f)(void *), void *p, void *d);
1222 llvm::Type *paramTys[] = { dtorTy, CGF.Int8PtrTy, CGF.Int8PtrTy };
1223 llvm::FunctionType *atexitTy =
1224 llvm::FunctionType::get(CGF.IntTy, paramTys, false);
1226 // Fetch the actual function.
1227 llvm::Constant *atexit = CGF.CGM.CreateRuntimeFunction(atexitTy, Name);
1228 if (llvm::Function *fn = dyn_cast<llvm::Function>(atexit))
1229 fn->setDoesNotThrow();
1231 // Create a variable that binds the atexit to this shared object.
1232 llvm::Constant *handle =
1233 CGF.CGM.CreateRuntimeVariable(CGF.Int8Ty, "__dso_handle");
1235 llvm::Value *args[] = {
1236 llvm::ConstantExpr::getBitCast(dtor, dtorTy),
1237 llvm::ConstantExpr::getBitCast(addr, CGF.Int8PtrTy),
1240 CGF.EmitNounwindRuntimeCall(atexit, args);
1243 /// Register a global destructor as best as we know how.
1244 void ItaniumCXXABI::registerGlobalDtor(CodeGenFunction &CGF,
1246 llvm::Constant *dtor,
1247 llvm::Constant *addr) {
1248 // Use __cxa_atexit if available.
1249 if (CGM.getCodeGenOpts().CXAAtExit)
1250 return emitGlobalDtorWithCXAAtExit(CGF, dtor, addr, D.getTLSKind());
1253 CGM.ErrorUnsupported(&D, "non-trivial TLS destruction");
1255 // In Apple kexts, we want to add a global destructor entry.
1256 // FIXME: shouldn't this be guarded by some variable?
1257 if (CGM.getLangOpts().AppleKext) {
1258 // Generate a global destructor entry.
1259 return CGM.AddCXXDtorEntry(dtor, addr);
1262 CGF.registerGlobalDtorWithAtExit(dtor, addr);
1265 /// Get the appropriate linkage for the wrapper function. This is essentially
1266 /// the weak form of the variable's linkage; every translation unit which wneeds
1267 /// the wrapper emits a copy, and we want the linker to merge them.
1268 static llvm::GlobalValue::LinkageTypes getThreadLocalWrapperLinkage(
1269 llvm::GlobalValue::LinkageTypes VarLinkage) {
1270 if (llvm::GlobalValue::isLinkerPrivateLinkage(VarLinkage))
1271 return llvm::GlobalValue::LinkerPrivateWeakLinkage;
1272 // For internal linkage variables, we don't need an external or weak wrapper.
1273 if (llvm::GlobalValue::isLocalLinkage(VarLinkage))
1275 return llvm::GlobalValue::WeakODRLinkage;
1279 ItaniumCXXABI::getOrCreateThreadLocalWrapper(const VarDecl *VD,
1280 llvm::GlobalVariable *Var) {
1281 // Mangle the name for the thread_local wrapper function.
1282 SmallString<256> WrapperName;
1284 llvm::raw_svector_ostream Out(WrapperName);
1285 getMangleContext().mangleItaniumThreadLocalWrapper(VD, Out);
1289 if (llvm::Value *V = Var->getParent()->getNamedValue(WrapperName))
1290 return cast<llvm::Function>(V);
1292 llvm::Type *RetTy = Var->getType();
1293 if (VD->getType()->isReferenceType())
1294 RetTy = RetTy->getPointerElementType();
1296 llvm::FunctionType *FnTy = llvm::FunctionType::get(RetTy, false);
1297 llvm::Function *Wrapper = llvm::Function::Create(
1298 FnTy, getThreadLocalWrapperLinkage(Var->getLinkage()), WrapperName.str(),
1300 // Always resolve references to the wrapper at link time.
1301 Wrapper->setVisibility(llvm::GlobalValue::HiddenVisibility);
1305 void ItaniumCXXABI::EmitThreadLocalInitFuncs(
1306 llvm::ArrayRef<std::pair<const VarDecl *, llvm::GlobalVariable *> > Decls,
1307 llvm::Function *InitFunc) {
1308 for (unsigned I = 0, N = Decls.size(); I != N; ++I) {
1309 const VarDecl *VD = Decls[I].first;
1310 llvm::GlobalVariable *Var = Decls[I].second;
1312 // Mangle the name for the thread_local initialization function.
1313 SmallString<256> InitFnName;
1315 llvm::raw_svector_ostream Out(InitFnName);
1316 getMangleContext().mangleItaniumThreadLocalInit(VD, Out);
1320 // If we have a definition for the variable, emit the initialization
1321 // function as an alias to the global Init function (if any). Otherwise,
1322 // produce a declaration of the initialization function.
1323 llvm::GlobalValue *Init = 0;
1324 bool InitIsInitFunc = false;
1325 if (VD->hasDefinition()) {
1326 InitIsInitFunc = true;
1329 new llvm::GlobalAlias(InitFunc->getType(), Var->getLinkage(),
1330 InitFnName.str(), InitFunc, &CGM.getModule());
1332 // Emit a weak global function referring to the initialization function.
1333 // This function will not exist if the TU defining the thread_local
1334 // variable in question does not need any dynamic initialization for
1335 // its thread_local variables.
1336 llvm::FunctionType *FnTy = llvm::FunctionType::get(CGM.VoidTy, false);
1337 Init = llvm::Function::Create(
1338 FnTy, llvm::GlobalVariable::ExternalWeakLinkage, InitFnName.str(),
1343 Init->setVisibility(Var->getVisibility());
1345 llvm::Function *Wrapper = getOrCreateThreadLocalWrapper(VD, Var);
1346 llvm::LLVMContext &Context = CGM.getModule().getContext();
1347 llvm::BasicBlock *Entry = llvm::BasicBlock::Create(Context, "", Wrapper);
1348 CGBuilderTy Builder(Entry);
1349 if (InitIsInitFunc) {
1351 Builder.CreateCall(Init);
1353 // Don't know whether we have an init function. Call it if it exists.
1354 llvm::Value *Have = Builder.CreateIsNotNull(Init);
1355 llvm::BasicBlock *InitBB = llvm::BasicBlock::Create(Context, "", Wrapper);
1356 llvm::BasicBlock *ExitBB = llvm::BasicBlock::Create(Context, "", Wrapper);
1357 Builder.CreateCondBr(Have, InitBB, ExitBB);
1359 Builder.SetInsertPoint(InitBB);
1360 Builder.CreateCall(Init);
1361 Builder.CreateBr(ExitBB);
1363 Builder.SetInsertPoint(ExitBB);
1366 // For a reference, the result of the wrapper function is a pointer to
1367 // the referenced object.
1368 llvm::Value *Val = Var;
1369 if (VD->getType()->isReferenceType()) {
1370 llvm::LoadInst *LI = Builder.CreateLoad(Val);
1371 LI->setAlignment(CGM.getContext().getDeclAlign(VD).getQuantity());
1375 Builder.CreateRet(Val);
1379 LValue ItaniumCXXABI::EmitThreadLocalDeclRefExpr(CodeGenFunction &CGF,
1380 const DeclRefExpr *DRE) {
1381 const VarDecl *VD = cast<VarDecl>(DRE->getDecl());
1382 QualType T = VD->getType();
1383 llvm::Type *Ty = CGF.getTypes().ConvertTypeForMem(T);
1384 llvm::Value *Val = CGF.CGM.GetAddrOfGlobalVar(VD, Ty);
1385 llvm::Function *Wrapper =
1386 getOrCreateThreadLocalWrapper(VD, cast<llvm::GlobalVariable>(Val));
1388 Val = CGF.Builder.CreateCall(Wrapper);
1391 if (VD->getType()->isReferenceType())
1392 LV = CGF.MakeNaturalAlignAddrLValue(Val, T);
1394 LV = CGF.MakeAddrLValue(Val, DRE->getType(),
1395 CGF.getContext().getDeclAlign(VD));
1396 // FIXME: need setObjCGCLValueClass?