ItaniumCXXABI.cpp revision 221345
1//===------- ItaniumCXXABI.cpp - Emit LLVM Code from ASTs for a Module ----===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 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 12// documented at: 13// http://www.codesourcery.com/public/cxx-abi/abi.html 14// http://www.codesourcery.com/public/cxx-abi/abi-eh.html 15// 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 18// 19//===----------------------------------------------------------------------===// 20 21#include "CGCXXABI.h" 22#include "CGRecordLayout.h" 23#include "CodeGenFunction.h" 24#include "CodeGenModule.h" 25#include <clang/AST/Mangle.h> 26#include <clang/AST/Type.h> 27#include <llvm/Target/TargetData.h> 28#include <llvm/Value.h> 29 30using namespace clang; 31using namespace CodeGen; 32 33namespace { 34class ItaniumCXXABI : public CodeGen::CGCXXABI { 35private: 36 const llvm::IntegerType *PtrDiffTy; 37protected: 38 bool IsARM; 39 40 // It's a little silly for us to cache this. 41 const llvm::IntegerType *getPtrDiffTy() { 42 if (!PtrDiffTy) { 43 QualType T = getContext().getPointerDiffType(); 44 const llvm::Type *Ty = CGM.getTypes().ConvertTypeRecursive(T); 45 PtrDiffTy = cast<llvm::IntegerType>(Ty); 46 } 47 return PtrDiffTy; 48 } 49 50 bool NeedsArrayCookie(const CXXNewExpr *expr); 51 bool NeedsArrayCookie(const CXXDeleteExpr *expr, 52 QualType elementType); 53 54public: 55 ItaniumCXXABI(CodeGen::CodeGenModule &CGM, bool IsARM = false) : 56 CGCXXABI(CGM), PtrDiffTy(0), IsARM(IsARM) { } 57 58 bool isZeroInitializable(const MemberPointerType *MPT); 59 60 const llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT); 61 62 llvm::Value *EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, 63 llvm::Value *&This, 64 llvm::Value *MemFnPtr, 65 const MemberPointerType *MPT); 66 67 llvm::Value *EmitMemberDataPointerAddress(CodeGenFunction &CGF, 68 llvm::Value *Base, 69 llvm::Value *MemPtr, 70 const MemberPointerType *MPT); 71 72 llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF, 73 const CastExpr *E, 74 llvm::Value *Src); 75 76 llvm::Constant *EmitMemberPointerConversion(llvm::Constant *C, 77 const CastExpr *E); 78 79 llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT); 80 81 llvm::Constant *EmitMemberPointer(const CXXMethodDecl *MD); 82 llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT, 83 CharUnits offset); 84 85 llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF, 86 llvm::Value *L, 87 llvm::Value *R, 88 const MemberPointerType *MPT, 89 bool Inequality); 90 91 llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF, 92 llvm::Value *Addr, 93 const MemberPointerType *MPT); 94 95 void BuildConstructorSignature(const CXXConstructorDecl *Ctor, 96 CXXCtorType T, 97 CanQualType &ResTy, 98 llvm::SmallVectorImpl<CanQualType> &ArgTys); 99 100 void BuildDestructorSignature(const CXXDestructorDecl *Dtor, 101 CXXDtorType T, 102 CanQualType &ResTy, 103 llvm::SmallVectorImpl<CanQualType> &ArgTys); 104 105 void BuildInstanceFunctionParams(CodeGenFunction &CGF, 106 QualType &ResTy, 107 FunctionArgList &Params); 108 109 void EmitInstanceFunctionProlog(CodeGenFunction &CGF); 110 111 CharUnits GetArrayCookieSize(const CXXNewExpr *expr); 112 llvm::Value *InitializeArrayCookie(CodeGenFunction &CGF, 113 llvm::Value *NewPtr, 114 llvm::Value *NumElements, 115 const CXXNewExpr *expr, 116 QualType ElementType); 117 void ReadArrayCookie(CodeGenFunction &CGF, llvm::Value *Ptr, 118 const CXXDeleteExpr *expr, 119 QualType ElementType, llvm::Value *&NumElements, 120 llvm::Value *&AllocPtr, CharUnits &CookieSize); 121 122 void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D, 123 llvm::GlobalVariable *DeclPtr); 124}; 125 126class ARMCXXABI : public ItaniumCXXABI { 127public: 128 ARMCXXABI(CodeGen::CodeGenModule &CGM) : ItaniumCXXABI(CGM, /*ARM*/ true) {} 129 130 void BuildConstructorSignature(const CXXConstructorDecl *Ctor, 131 CXXCtorType T, 132 CanQualType &ResTy, 133 llvm::SmallVectorImpl<CanQualType> &ArgTys); 134 135 void BuildDestructorSignature(const CXXDestructorDecl *Dtor, 136 CXXDtorType T, 137 CanQualType &ResTy, 138 llvm::SmallVectorImpl<CanQualType> &ArgTys); 139 140 void BuildInstanceFunctionParams(CodeGenFunction &CGF, 141 QualType &ResTy, 142 FunctionArgList &Params); 143 144 void EmitInstanceFunctionProlog(CodeGenFunction &CGF); 145 146 void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV, QualType ResTy); 147 148 CharUnits GetArrayCookieSize(const CXXNewExpr *expr); 149 llvm::Value *InitializeArrayCookie(CodeGenFunction &CGF, 150 llvm::Value *NewPtr, 151 llvm::Value *NumElements, 152 const CXXNewExpr *expr, 153 QualType ElementType); 154 void ReadArrayCookie(CodeGenFunction &CGF, llvm::Value *Ptr, 155 const CXXDeleteExpr *expr, 156 QualType ElementType, llvm::Value *&NumElements, 157 llvm::Value *&AllocPtr, CharUnits &CookieSize); 158 159private: 160 /// \brief Returns true if the given instance method is one of the 161 /// kinds that the ARM ABI says returns 'this'. 162 static bool HasThisReturn(GlobalDecl GD) { 163 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl()); 164 return ((isa<CXXDestructorDecl>(MD) && GD.getDtorType() != Dtor_Deleting) || 165 (isa<CXXConstructorDecl>(MD))); 166 } 167}; 168} 169 170CodeGen::CGCXXABI *CodeGen::CreateItaniumCXXABI(CodeGenModule &CGM) { 171 return new ItaniumCXXABI(CGM); 172} 173 174CodeGen::CGCXXABI *CodeGen::CreateARMCXXABI(CodeGenModule &CGM) { 175 return new ARMCXXABI(CGM); 176} 177 178const llvm::Type * 179ItaniumCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) { 180 if (MPT->isMemberDataPointer()) 181 return getPtrDiffTy(); 182 else 183 return llvm::StructType::get(CGM.getLLVMContext(), 184 getPtrDiffTy(), getPtrDiffTy(), NULL); 185} 186 187/// In the Itanium and ARM ABIs, method pointers have the form: 188/// struct { ptrdiff_t ptr; ptrdiff_t adj; } memptr; 189/// 190/// In the Itanium ABI: 191/// - method pointers are virtual if (memptr.ptr & 1) is nonzero 192/// - the this-adjustment is (memptr.adj) 193/// - the virtual offset is (memptr.ptr - 1) 194/// 195/// In the ARM ABI: 196/// - method pointers are virtual if (memptr.adj & 1) is nonzero 197/// - the this-adjustment is (memptr.adj >> 1) 198/// - the virtual offset is (memptr.ptr) 199/// ARM uses 'adj' for the virtual flag because Thumb functions 200/// may be only single-byte aligned. 201/// 202/// If the member is virtual, the adjusted 'this' pointer points 203/// to a vtable pointer from which the virtual offset is applied. 204/// 205/// If the member is non-virtual, memptr.ptr is the address of 206/// the function to call. 207llvm::Value * 208ItaniumCXXABI::EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, 209 llvm::Value *&This, 210 llvm::Value *MemFnPtr, 211 const MemberPointerType *MPT) { 212 CGBuilderTy &Builder = CGF.Builder; 213 214 const FunctionProtoType *FPT = 215 MPT->getPointeeType()->getAs<FunctionProtoType>(); 216 const CXXRecordDecl *RD = 217 cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl()); 218 219 const llvm::FunctionType *FTy = 220 CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(RD, FPT), 221 FPT->isVariadic()); 222 223 const llvm::IntegerType *ptrdiff = getPtrDiffTy(); 224 llvm::Constant *ptrdiff_1 = llvm::ConstantInt::get(ptrdiff, 1); 225 226 llvm::BasicBlock *FnVirtual = CGF.createBasicBlock("memptr.virtual"); 227 llvm::BasicBlock *FnNonVirtual = CGF.createBasicBlock("memptr.nonvirtual"); 228 llvm::BasicBlock *FnEnd = CGF.createBasicBlock("memptr.end"); 229 230 // Extract memptr.adj, which is in the second field. 231 llvm::Value *RawAdj = Builder.CreateExtractValue(MemFnPtr, 1, "memptr.adj"); 232 233 // Compute the true adjustment. 234 llvm::Value *Adj = RawAdj; 235 if (IsARM) 236 Adj = Builder.CreateAShr(Adj, ptrdiff_1, "memptr.adj.shifted"); 237 238 // Apply the adjustment and cast back to the original struct type 239 // for consistency. 240 llvm::Value *Ptr = Builder.CreateBitCast(This, Builder.getInt8PtrTy()); 241 Ptr = Builder.CreateInBoundsGEP(Ptr, Adj); 242 This = Builder.CreateBitCast(Ptr, This->getType(), "this.adjusted"); 243 244 // Load the function pointer. 245 llvm::Value *FnAsInt = Builder.CreateExtractValue(MemFnPtr, 0, "memptr.ptr"); 246 247 // If the LSB in the function pointer is 1, the function pointer points to 248 // a virtual function. 249 llvm::Value *IsVirtual; 250 if (IsARM) 251 IsVirtual = Builder.CreateAnd(RawAdj, ptrdiff_1); 252 else 253 IsVirtual = Builder.CreateAnd(FnAsInt, ptrdiff_1); 254 IsVirtual = Builder.CreateIsNotNull(IsVirtual, "memptr.isvirtual"); 255 Builder.CreateCondBr(IsVirtual, FnVirtual, FnNonVirtual); 256 257 // In the virtual path, the adjustment left 'This' pointing to the 258 // vtable of the correct base subobject. The "function pointer" is an 259 // offset within the vtable (+1 for the virtual flag on non-ARM). 260 CGF.EmitBlock(FnVirtual); 261 262 // Cast the adjusted this to a pointer to vtable pointer and load. 263 const llvm::Type *VTableTy = Builder.getInt8PtrTy(); 264 llvm::Value *VTable = Builder.CreateBitCast(This, VTableTy->getPointerTo()); 265 VTable = Builder.CreateLoad(VTable, "memptr.vtable"); 266 267 // Apply the offset. 268 llvm::Value *VTableOffset = FnAsInt; 269 if (!IsARM) VTableOffset = Builder.CreateSub(VTableOffset, ptrdiff_1); 270 VTable = Builder.CreateGEP(VTable, VTableOffset); 271 272 // Load the virtual function to call. 273 VTable = Builder.CreateBitCast(VTable, FTy->getPointerTo()->getPointerTo()); 274 llvm::Value *VirtualFn = Builder.CreateLoad(VTable, "memptr.virtualfn"); 275 CGF.EmitBranch(FnEnd); 276 277 // In the non-virtual path, the function pointer is actually a 278 // function pointer. 279 CGF.EmitBlock(FnNonVirtual); 280 llvm::Value *NonVirtualFn = 281 Builder.CreateIntToPtr(FnAsInt, FTy->getPointerTo(), "memptr.nonvirtualfn"); 282 283 // We're done. 284 CGF.EmitBlock(FnEnd); 285 llvm::PHINode *Callee = Builder.CreatePHI(FTy->getPointerTo(), 2); 286 Callee->addIncoming(VirtualFn, FnVirtual); 287 Callee->addIncoming(NonVirtualFn, FnNonVirtual); 288 return Callee; 289} 290 291/// Compute an l-value by applying the given pointer-to-member to a 292/// base object. 293llvm::Value *ItaniumCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF, 294 llvm::Value *Base, 295 llvm::Value *MemPtr, 296 const MemberPointerType *MPT) { 297 assert(MemPtr->getType() == getPtrDiffTy()); 298 299 CGBuilderTy &Builder = CGF.Builder; 300 301 unsigned AS = cast<llvm::PointerType>(Base->getType())->getAddressSpace(); 302 303 // Cast to char*. 304 Base = Builder.CreateBitCast(Base, Builder.getInt8Ty()->getPointerTo(AS)); 305 306 // Apply the offset, which we assume is non-null. 307 llvm::Value *Addr = Builder.CreateInBoundsGEP(Base, MemPtr, "memptr.offset"); 308 309 // Cast the address to the appropriate pointer type, adopting the 310 // address space of the base pointer. 311 const llvm::Type *PType 312 = CGF.ConvertTypeForMem(MPT->getPointeeType())->getPointerTo(AS); 313 return Builder.CreateBitCast(Addr, PType); 314} 315 316/// Perform a derived-to-base or base-to-derived member pointer conversion. 317/// 318/// Obligatory offset/adjustment diagram: 319/// <-- offset --> <-- adjustment --> 320/// |--------------------------|----------------------|--------------------| 321/// ^Derived address point ^Base address point ^Member address point 322/// 323/// So when converting a base member pointer to a derived member pointer, 324/// we add the offset to the adjustment because the address point has 325/// decreased; and conversely, when converting a derived MP to a base MP 326/// we subtract the offset from the adjustment because the address point 327/// has increased. 328/// 329/// The standard forbids (at compile time) conversion to and from 330/// virtual bases, which is why we don't have to consider them here. 331/// 332/// The standard forbids (at run time) casting a derived MP to a base 333/// MP when the derived MP does not point to a member of the base. 334/// This is why -1 is a reasonable choice for null data member 335/// pointers. 336llvm::Value * 337ItaniumCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF, 338 const CastExpr *E, 339 llvm::Value *Src) { 340 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer || 341 E->getCastKind() == CK_BaseToDerivedMemberPointer); 342 343 if (isa<llvm::Constant>(Src)) 344 return EmitMemberPointerConversion(cast<llvm::Constant>(Src), E); 345 346 CGBuilderTy &Builder = CGF.Builder; 347 348 const MemberPointerType *SrcTy = 349 E->getSubExpr()->getType()->getAs<MemberPointerType>(); 350 const MemberPointerType *DestTy = E->getType()->getAs<MemberPointerType>(); 351 352 const CXXRecordDecl *SrcDecl = SrcTy->getClass()->getAsCXXRecordDecl(); 353 const CXXRecordDecl *DestDecl = DestTy->getClass()->getAsCXXRecordDecl(); 354 355 bool DerivedToBase = 356 E->getCastKind() == CK_DerivedToBaseMemberPointer; 357 358 const CXXRecordDecl *DerivedDecl; 359 if (DerivedToBase) 360 DerivedDecl = SrcDecl; 361 else 362 DerivedDecl = DestDecl; 363 364 llvm::Constant *Adj = 365 CGF.CGM.GetNonVirtualBaseClassOffset(DerivedDecl, 366 E->path_begin(), 367 E->path_end()); 368 if (!Adj) return Src; 369 370 // For member data pointers, this is just a matter of adding the 371 // offset if the source is non-null. 372 if (SrcTy->isMemberDataPointer()) { 373 llvm::Value *Dst; 374 if (DerivedToBase) 375 Dst = Builder.CreateNSWSub(Src, Adj, "adj"); 376 else 377 Dst = Builder.CreateNSWAdd(Src, Adj, "adj"); 378 379 // Null check. 380 llvm::Value *Null = llvm::Constant::getAllOnesValue(Src->getType()); 381 llvm::Value *IsNull = Builder.CreateICmpEQ(Src, Null, "memptr.isnull"); 382 return Builder.CreateSelect(IsNull, Src, Dst); 383 } 384 385 // The this-adjustment is left-shifted by 1 on ARM. 386 if (IsARM) { 387 uint64_t Offset = cast<llvm::ConstantInt>(Adj)->getZExtValue(); 388 Offset <<= 1; 389 Adj = llvm::ConstantInt::get(Adj->getType(), Offset); 390 } 391 392 llvm::Value *SrcAdj = Builder.CreateExtractValue(Src, 1, "src.adj"); 393 llvm::Value *DstAdj; 394 if (DerivedToBase) 395 DstAdj = Builder.CreateNSWSub(SrcAdj, Adj, "adj"); 396 else 397 DstAdj = Builder.CreateNSWAdd(SrcAdj, Adj, "adj"); 398 399 return Builder.CreateInsertValue(Src, DstAdj, 1); 400} 401 402llvm::Constant * 403ItaniumCXXABI::EmitMemberPointerConversion(llvm::Constant *C, 404 const CastExpr *E) { 405 const MemberPointerType *SrcTy = 406 E->getSubExpr()->getType()->getAs<MemberPointerType>(); 407 const MemberPointerType *DestTy = 408 E->getType()->getAs<MemberPointerType>(); 409 410 bool DerivedToBase = 411 E->getCastKind() == CK_DerivedToBaseMemberPointer; 412 413 const CXXRecordDecl *DerivedDecl; 414 if (DerivedToBase) 415 DerivedDecl = SrcTy->getClass()->getAsCXXRecordDecl(); 416 else 417 DerivedDecl = DestTy->getClass()->getAsCXXRecordDecl(); 418 419 // Calculate the offset to the base class. 420 llvm::Constant *Offset = 421 CGM.GetNonVirtualBaseClassOffset(DerivedDecl, 422 E->path_begin(), 423 E->path_end()); 424 // If there's no offset, we're done. 425 if (!Offset) return C; 426 427 // If the source is a member data pointer, we have to do a null 428 // check and then add the offset. In the common case, we can fold 429 // away the offset. 430 if (SrcTy->isMemberDataPointer()) { 431 assert(C->getType() == getPtrDiffTy()); 432 433 // If it's a constant int, just create a new constant int. 434 if (llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C)) { 435 int64_t Src = CI->getSExtValue(); 436 437 // Null converts to null. 438 if (Src == -1) return CI; 439 440 // Otherwise, just add the offset. 441 int64_t OffsetV = cast<llvm::ConstantInt>(Offset)->getSExtValue(); 442 int64_t Dst = (DerivedToBase ? Src - OffsetV : Src + OffsetV); 443 return llvm::ConstantInt::get(CI->getType(), Dst, /*signed*/ true); 444 } 445 446 // Otherwise, we have to form a constant select expression. 447 llvm::Constant *Null = llvm::Constant::getAllOnesValue(C->getType()); 448 449 llvm::Constant *IsNull = 450 llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_EQ, C, Null); 451 452 llvm::Constant *Dst; 453 if (DerivedToBase) 454 Dst = llvm::ConstantExpr::getNSWSub(C, Offset); 455 else 456 Dst = llvm::ConstantExpr::getNSWAdd(C, Offset); 457 458 return llvm::ConstantExpr::getSelect(IsNull, Null, Dst); 459 } 460 461 // The this-adjustment is left-shifted by 1 on ARM. 462 if (IsARM) { 463 int64_t OffsetV = cast<llvm::ConstantInt>(Offset)->getSExtValue(); 464 OffsetV <<= 1; 465 Offset = llvm::ConstantInt::get(Offset->getType(), OffsetV); 466 } 467 468 llvm::ConstantStruct *CS = cast<llvm::ConstantStruct>(C); 469 470 llvm::Constant *Values[2] = { CS->getOperand(0), 0 }; 471 if (DerivedToBase) 472 Values[1] = llvm::ConstantExpr::getSub(CS->getOperand(1), Offset); 473 else 474 Values[1] = llvm::ConstantExpr::getAdd(CS->getOperand(1), Offset); 475 476 return llvm::ConstantStruct::get(CGM.getLLVMContext(), Values, 2, 477 /*Packed=*/false); 478} 479 480 481llvm::Constant * 482ItaniumCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) { 483 const llvm::Type *ptrdiff_t = getPtrDiffTy(); 484 485 // Itanium C++ ABI 2.3: 486 // A NULL pointer is represented as -1. 487 if (MPT->isMemberDataPointer()) 488 return llvm::ConstantInt::get(ptrdiff_t, -1ULL, /*isSigned=*/true); 489 490 llvm::Constant *Zero = llvm::ConstantInt::get(ptrdiff_t, 0); 491 llvm::Constant *Values[2] = { Zero, Zero }; 492 return llvm::ConstantStruct::get(CGM.getLLVMContext(), Values, 2, 493 /*Packed=*/false); 494} 495 496llvm::Constant * 497ItaniumCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT, 498 CharUnits offset) { 499 // Itanium C++ ABI 2.3: 500 // A pointer to data member is an offset from the base address of 501 // the class object containing it, represented as a ptrdiff_t 502 return llvm::ConstantInt::get(getPtrDiffTy(), offset.getQuantity()); 503} 504 505llvm::Constant *ItaniumCXXABI::EmitMemberPointer(const CXXMethodDecl *MD) { 506 assert(MD->isInstance() && "Member function must not be static!"); 507 MD = MD->getCanonicalDecl(); 508 509 CodeGenTypes &Types = CGM.getTypes(); 510 const llvm::Type *ptrdiff_t = getPtrDiffTy(); 511 512 // Get the function pointer (or index if this is a virtual function). 513 llvm::Constant *MemPtr[2]; 514 if (MD->isVirtual()) { 515 uint64_t Index = CGM.getVTables().getMethodVTableIndex(MD); 516 517 const ASTContext &Context = getContext(); 518 CharUnits PointerWidth = 519 Context.toCharUnitsFromBits(Context.Target.getPointerWidth(0)); 520 uint64_t VTableOffset = (Index * PointerWidth.getQuantity()); 521 522 if (IsARM) { 523 // ARM C++ ABI 3.2.1: 524 // This ABI specifies that adj contains twice the this 525 // adjustment, plus 1 if the member function is virtual. The 526 // least significant bit of adj then makes exactly the same 527 // discrimination as the least significant bit of ptr does for 528 // Itanium. 529 MemPtr[0] = llvm::ConstantInt::get(ptrdiff_t, VTableOffset); 530 MemPtr[1] = llvm::ConstantInt::get(ptrdiff_t, 1); 531 } else { 532 // Itanium C++ ABI 2.3: 533 // For a virtual function, [the pointer field] is 1 plus the 534 // virtual table offset (in bytes) of the function, 535 // represented as a ptrdiff_t. 536 MemPtr[0] = llvm::ConstantInt::get(ptrdiff_t, VTableOffset + 1); 537 MemPtr[1] = llvm::ConstantInt::get(ptrdiff_t, 0); 538 } 539 } else { 540 const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>(); 541 const llvm::Type *Ty; 542 // Check whether the function has a computable LLVM signature. 543 if (!CodeGenTypes::VerifyFuncTypeComplete(FPT)) { 544 // The function has a computable LLVM signature; use the correct type. 545 Ty = Types.GetFunctionType(Types.getFunctionInfo(MD), 546 FPT->isVariadic()); 547 } else { 548 // Use an arbitrary non-function type to tell GetAddrOfFunction that the 549 // function type is incomplete. 550 Ty = ptrdiff_t; 551 } 552 llvm::Constant *addr = CGM.GetAddrOfFunction(MD, Ty); 553 554 MemPtr[0] = llvm::ConstantExpr::getPtrToInt(addr, ptrdiff_t); 555 MemPtr[1] = llvm::ConstantInt::get(ptrdiff_t, 0); 556 } 557 558 return llvm::ConstantStruct::get(CGM.getLLVMContext(), 559 MemPtr, 2, /*Packed=*/false); 560} 561 562/// The comparison algorithm is pretty easy: the member pointers are 563/// the same if they're either bitwise identical *or* both null. 564/// 565/// ARM is different here only because null-ness is more complicated. 566llvm::Value * 567ItaniumCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF, 568 llvm::Value *L, 569 llvm::Value *R, 570 const MemberPointerType *MPT, 571 bool Inequality) { 572 CGBuilderTy &Builder = CGF.Builder; 573 574 llvm::ICmpInst::Predicate Eq; 575 llvm::Instruction::BinaryOps And, Or; 576 if (Inequality) { 577 Eq = llvm::ICmpInst::ICMP_NE; 578 And = llvm::Instruction::Or; 579 Or = llvm::Instruction::And; 580 } else { 581 Eq = llvm::ICmpInst::ICMP_EQ; 582 And = llvm::Instruction::And; 583 Or = llvm::Instruction::Or; 584 } 585 586 // Member data pointers are easy because there's a unique null 587 // value, so it just comes down to bitwise equality. 588 if (MPT->isMemberDataPointer()) 589 return Builder.CreateICmp(Eq, L, R); 590 591 // For member function pointers, the tautologies are more complex. 592 // The Itanium tautology is: 593 // (L == R) <==> (L.ptr == R.ptr && (L.ptr == 0 || L.adj == R.adj)) 594 // The ARM tautology is: 595 // (L == R) <==> (L.ptr == R.ptr && 596 // (L.adj == R.adj || 597 // (L.ptr == 0 && ((L.adj|R.adj) & 1) == 0))) 598 // The inequality tautologies have exactly the same structure, except 599 // applying De Morgan's laws. 600 601 llvm::Value *LPtr = Builder.CreateExtractValue(L, 0, "lhs.memptr.ptr"); 602 llvm::Value *RPtr = Builder.CreateExtractValue(R, 0, "rhs.memptr.ptr"); 603 604 // This condition tests whether L.ptr == R.ptr. This must always be 605 // true for equality to hold. 606 llvm::Value *PtrEq = Builder.CreateICmp(Eq, LPtr, RPtr, "cmp.ptr"); 607 608 // This condition, together with the assumption that L.ptr == R.ptr, 609 // tests whether the pointers are both null. ARM imposes an extra 610 // condition. 611 llvm::Value *Zero = llvm::Constant::getNullValue(LPtr->getType()); 612 llvm::Value *EqZero = Builder.CreateICmp(Eq, LPtr, Zero, "cmp.ptr.null"); 613 614 // This condition tests whether L.adj == R.adj. If this isn't 615 // true, the pointers are unequal unless they're both null. 616 llvm::Value *LAdj = Builder.CreateExtractValue(L, 1, "lhs.memptr.adj"); 617 llvm::Value *RAdj = Builder.CreateExtractValue(R, 1, "rhs.memptr.adj"); 618 llvm::Value *AdjEq = Builder.CreateICmp(Eq, LAdj, RAdj, "cmp.adj"); 619 620 // Null member function pointers on ARM clear the low bit of Adj, 621 // so the zero condition has to check that neither low bit is set. 622 if (IsARM) { 623 llvm::Value *One = llvm::ConstantInt::get(LPtr->getType(), 1); 624 625 // Compute (l.adj | r.adj) & 1 and test it against zero. 626 llvm::Value *OrAdj = Builder.CreateOr(LAdj, RAdj, "or.adj"); 627 llvm::Value *OrAdjAnd1 = Builder.CreateAnd(OrAdj, One); 628 llvm::Value *OrAdjAnd1EqZero = Builder.CreateICmp(Eq, OrAdjAnd1, Zero, 629 "cmp.or.adj"); 630 EqZero = Builder.CreateBinOp(And, EqZero, OrAdjAnd1EqZero); 631 } 632 633 // Tie together all our conditions. 634 llvm::Value *Result = Builder.CreateBinOp(Or, EqZero, AdjEq); 635 Result = Builder.CreateBinOp(And, PtrEq, Result, 636 Inequality ? "memptr.ne" : "memptr.eq"); 637 return Result; 638} 639 640llvm::Value * 641ItaniumCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF, 642 llvm::Value *MemPtr, 643 const MemberPointerType *MPT) { 644 CGBuilderTy &Builder = CGF.Builder; 645 646 /// For member data pointers, this is just a check against -1. 647 if (MPT->isMemberDataPointer()) { 648 assert(MemPtr->getType() == getPtrDiffTy()); 649 llvm::Value *NegativeOne = 650 llvm::Constant::getAllOnesValue(MemPtr->getType()); 651 return Builder.CreateICmpNE(MemPtr, NegativeOne, "memptr.tobool"); 652 } 653 654 // In Itanium, a member function pointer is not null if 'ptr' is not null. 655 llvm::Value *Ptr = Builder.CreateExtractValue(MemPtr, 0, "memptr.ptr"); 656 657 llvm::Constant *Zero = llvm::ConstantInt::get(Ptr->getType(), 0); 658 llvm::Value *Result = Builder.CreateICmpNE(Ptr, Zero, "memptr.tobool"); 659 660 // On ARM, a member function pointer is also non-null if the low bit of 'adj' 661 // (the virtual bit) is set. 662 if (IsARM) { 663 llvm::Constant *One = llvm::ConstantInt::get(Ptr->getType(), 1); 664 llvm::Value *Adj = Builder.CreateExtractValue(MemPtr, 1, "memptr.adj"); 665 llvm::Value *VirtualBit = Builder.CreateAnd(Adj, One, "memptr.virtualbit"); 666 llvm::Value *IsVirtual = Builder.CreateICmpNE(VirtualBit, Zero, 667 "memptr.isvirtual"); 668 Result = Builder.CreateOr(Result, IsVirtual); 669 } 670 671 return Result; 672} 673 674/// The Itanium ABI requires non-zero initialization only for data 675/// member pointers, for which '0' is a valid offset. 676bool ItaniumCXXABI::isZeroInitializable(const MemberPointerType *MPT) { 677 return MPT->getPointeeType()->isFunctionType(); 678} 679 680/// The generic ABI passes 'this', plus a VTT if it's initializing a 681/// base subobject. 682void ItaniumCXXABI::BuildConstructorSignature(const CXXConstructorDecl *Ctor, 683 CXXCtorType Type, 684 CanQualType &ResTy, 685 llvm::SmallVectorImpl<CanQualType> &ArgTys) { 686 ASTContext &Context = getContext(); 687 688 // 'this' is already there. 689 690 // Check if we need to add a VTT parameter (which has type void **). 691 if (Type == Ctor_Base && Ctor->getParent()->getNumVBases() != 0) 692 ArgTys.push_back(Context.getPointerType(Context.VoidPtrTy)); 693} 694 695/// The ARM ABI does the same as the Itanium ABI, but returns 'this'. 696void ARMCXXABI::BuildConstructorSignature(const CXXConstructorDecl *Ctor, 697 CXXCtorType Type, 698 CanQualType &ResTy, 699 llvm::SmallVectorImpl<CanQualType> &ArgTys) { 700 ItaniumCXXABI::BuildConstructorSignature(Ctor, Type, ResTy, ArgTys); 701 ResTy = ArgTys[0]; 702} 703 704/// The generic ABI passes 'this', plus a VTT if it's destroying a 705/// base subobject. 706void ItaniumCXXABI::BuildDestructorSignature(const CXXDestructorDecl *Dtor, 707 CXXDtorType Type, 708 CanQualType &ResTy, 709 llvm::SmallVectorImpl<CanQualType> &ArgTys) { 710 ASTContext &Context = getContext(); 711 712 // 'this' is already there. 713 714 // Check if we need to add a VTT parameter (which has type void **). 715 if (Type == Dtor_Base && Dtor->getParent()->getNumVBases() != 0) 716 ArgTys.push_back(Context.getPointerType(Context.VoidPtrTy)); 717} 718 719/// The ARM ABI does the same as the Itanium ABI, but returns 'this' 720/// for non-deleting destructors. 721void ARMCXXABI::BuildDestructorSignature(const CXXDestructorDecl *Dtor, 722 CXXDtorType Type, 723 CanQualType &ResTy, 724 llvm::SmallVectorImpl<CanQualType> &ArgTys) { 725 ItaniumCXXABI::BuildDestructorSignature(Dtor, Type, ResTy, ArgTys); 726 727 if (Type != Dtor_Deleting) 728 ResTy = ArgTys[0]; 729} 730 731void ItaniumCXXABI::BuildInstanceFunctionParams(CodeGenFunction &CGF, 732 QualType &ResTy, 733 FunctionArgList &Params) { 734 /// Create the 'this' variable. 735 BuildThisParam(CGF, Params); 736 737 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl()); 738 assert(MD->isInstance()); 739 740 // Check if we need a VTT parameter as well. 741 if (CodeGenVTables::needsVTTParameter(CGF.CurGD)) { 742 ASTContext &Context = getContext(); 743 744 // FIXME: avoid the fake decl 745 QualType T = Context.getPointerType(Context.VoidPtrTy); 746 ImplicitParamDecl *VTTDecl 747 = ImplicitParamDecl::Create(Context, 0, MD->getLocation(), 748 &Context.Idents.get("vtt"), T); 749 Params.push_back(VTTDecl); 750 getVTTDecl(CGF) = VTTDecl; 751 } 752} 753 754void ARMCXXABI::BuildInstanceFunctionParams(CodeGenFunction &CGF, 755 QualType &ResTy, 756 FunctionArgList &Params) { 757 ItaniumCXXABI::BuildInstanceFunctionParams(CGF, ResTy, Params); 758 759 // Return 'this' from certain constructors and destructors. 760 if (HasThisReturn(CGF.CurGD)) 761 ResTy = Params[0]->getType(); 762} 763 764void ItaniumCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) { 765 /// Initialize the 'this' slot. 766 EmitThisParam(CGF); 767 768 /// Initialize the 'vtt' slot if needed. 769 if (getVTTDecl(CGF)) { 770 getVTTValue(CGF) 771 = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getVTTDecl(CGF)), 772 "vtt"); 773 } 774} 775 776void ARMCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) { 777 ItaniumCXXABI::EmitInstanceFunctionProlog(CGF); 778 779 /// Initialize the return slot to 'this' at the start of the 780 /// function. 781 if (HasThisReturn(CGF.CurGD)) 782 CGF.Builder.CreateStore(CGF.LoadCXXThis(), CGF.ReturnValue); 783} 784 785void ARMCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF, 786 RValue RV, QualType ResultType) { 787 if (!isa<CXXDestructorDecl>(CGF.CurGD.getDecl())) 788 return ItaniumCXXABI::EmitReturnFromThunk(CGF, RV, ResultType); 789 790 // Destructor thunks in the ARM ABI have indeterminate results. 791 const llvm::Type *T = 792 cast<llvm::PointerType>(CGF.ReturnValue->getType())->getElementType(); 793 RValue Undef = RValue::get(llvm::UndefValue::get(T)); 794 return ItaniumCXXABI::EmitReturnFromThunk(CGF, Undef, ResultType); 795} 796 797/************************** Array allocation cookies **************************/ 798 799bool ItaniumCXXABI::NeedsArrayCookie(const CXXNewExpr *expr) { 800 // If the class's usual deallocation function takes two arguments, 801 // it needs a cookie. 802 if (expr->doesUsualArrayDeleteWantSize()) 803 return true; 804 805 // Otherwise, if the class has a non-trivial destructor, it always 806 // needs a cookie. 807 const CXXRecordDecl *record = 808 expr->getAllocatedType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl(); 809 return (record && !record->hasTrivialDestructor()); 810} 811 812bool ItaniumCXXABI::NeedsArrayCookie(const CXXDeleteExpr *expr, 813 QualType elementType) { 814 // If the class's usual deallocation function takes two arguments, 815 // it needs a cookie. 816 if (expr->doesUsualArrayDeleteWantSize()) 817 return true; 818 819 // Otherwise, if the class has a non-trivial destructor, it always 820 // needs a cookie. 821 const CXXRecordDecl *record = 822 elementType->getBaseElementTypeUnsafe()->getAsCXXRecordDecl(); 823 return (record && !record->hasTrivialDestructor()); 824} 825 826CharUnits ItaniumCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) { 827 if (!NeedsArrayCookie(expr)) 828 return CharUnits::Zero(); 829 830 // Padding is the maximum of sizeof(size_t) and alignof(elementType) 831 ASTContext &Ctx = getContext(); 832 return std::max(Ctx.getTypeSizeInChars(Ctx.getSizeType()), 833 Ctx.getTypeAlignInChars(expr->getAllocatedType())); 834} 835 836llvm::Value *ItaniumCXXABI::InitializeArrayCookie(CodeGenFunction &CGF, 837 llvm::Value *NewPtr, 838 llvm::Value *NumElements, 839 const CXXNewExpr *expr, 840 QualType ElementType) { 841 assert(NeedsArrayCookie(expr)); 842 843 unsigned AS = cast<llvm::PointerType>(NewPtr->getType())->getAddressSpace(); 844 845 ASTContext &Ctx = getContext(); 846 QualType SizeTy = Ctx.getSizeType(); 847 CharUnits SizeSize = Ctx.getTypeSizeInChars(SizeTy); 848 849 // The size of the cookie. 850 CharUnits CookieSize = 851 std::max(SizeSize, Ctx.getTypeAlignInChars(ElementType)); 852 853 // Compute an offset to the cookie. 854 llvm::Value *CookiePtr = NewPtr; 855 CharUnits CookieOffset = CookieSize - SizeSize; 856 if (!CookieOffset.isZero()) 857 CookiePtr = CGF.Builder.CreateConstInBoundsGEP1_64(CookiePtr, 858 CookieOffset.getQuantity()); 859 860 // Write the number of elements into the appropriate slot. 861 llvm::Value *NumElementsPtr 862 = CGF.Builder.CreateBitCast(CookiePtr, 863 CGF.ConvertType(SizeTy)->getPointerTo(AS)); 864 CGF.Builder.CreateStore(NumElements, NumElementsPtr); 865 866 // Finally, compute a pointer to the actual data buffer by skipping 867 // over the cookie completely. 868 return CGF.Builder.CreateConstInBoundsGEP1_64(NewPtr, 869 CookieSize.getQuantity()); 870} 871 872void ItaniumCXXABI::ReadArrayCookie(CodeGenFunction &CGF, 873 llvm::Value *Ptr, 874 const CXXDeleteExpr *expr, 875 QualType ElementType, 876 llvm::Value *&NumElements, 877 llvm::Value *&AllocPtr, 878 CharUnits &CookieSize) { 879 // Derive a char* in the same address space as the pointer. 880 unsigned AS = cast<llvm::PointerType>(Ptr->getType())->getAddressSpace(); 881 const llvm::Type *CharPtrTy = CGF.Builder.getInt8Ty()->getPointerTo(AS); 882 883 // If we don't need an array cookie, bail out early. 884 if (!NeedsArrayCookie(expr, ElementType)) { 885 AllocPtr = CGF.Builder.CreateBitCast(Ptr, CharPtrTy); 886 NumElements = 0; 887 CookieSize = CharUnits::Zero(); 888 return; 889 } 890 891 QualType SizeTy = getContext().getSizeType(); 892 CharUnits SizeSize = getContext().getTypeSizeInChars(SizeTy); 893 const llvm::Type *SizeLTy = CGF.ConvertType(SizeTy); 894 895 CookieSize 896 = std::max(SizeSize, getContext().getTypeAlignInChars(ElementType)); 897 898 CharUnits NumElementsOffset = CookieSize - SizeSize; 899 900 // Compute the allocated pointer. 901 AllocPtr = CGF.Builder.CreateBitCast(Ptr, CharPtrTy); 902 AllocPtr = CGF.Builder.CreateConstInBoundsGEP1_64(AllocPtr, 903 -CookieSize.getQuantity()); 904 905 llvm::Value *NumElementsPtr = AllocPtr; 906 if (!NumElementsOffset.isZero()) 907 NumElementsPtr = 908 CGF.Builder.CreateConstInBoundsGEP1_64(NumElementsPtr, 909 NumElementsOffset.getQuantity()); 910 NumElementsPtr = 911 CGF.Builder.CreateBitCast(NumElementsPtr, SizeLTy->getPointerTo(AS)); 912 NumElements = CGF.Builder.CreateLoad(NumElementsPtr); 913} 914 915CharUnits ARMCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) { 916 if (!NeedsArrayCookie(expr)) 917 return CharUnits::Zero(); 918 919 // On ARM, the cookie is always: 920 // struct array_cookie { 921 // std::size_t element_size; // element_size != 0 922 // std::size_t element_count; 923 // }; 924 // TODO: what should we do if the allocated type actually wants 925 // greater alignment? 926 return getContext().getTypeSizeInChars(getContext().getSizeType()) * 2; 927} 928 929llvm::Value *ARMCXXABI::InitializeArrayCookie(CodeGenFunction &CGF, 930 llvm::Value *NewPtr, 931 llvm::Value *NumElements, 932 const CXXNewExpr *expr, 933 QualType ElementType) { 934 assert(NeedsArrayCookie(expr)); 935 936 // NewPtr is a char*. 937 938 unsigned AS = cast<llvm::PointerType>(NewPtr->getType())->getAddressSpace(); 939 940 ASTContext &Ctx = getContext(); 941 CharUnits SizeSize = Ctx.getTypeSizeInChars(Ctx.getSizeType()); 942 const llvm::IntegerType *SizeTy = 943 cast<llvm::IntegerType>(CGF.ConvertType(Ctx.getSizeType())); 944 945 // The cookie is always at the start of the buffer. 946 llvm::Value *CookiePtr = NewPtr; 947 948 // The first element is the element size. 949 CookiePtr = CGF.Builder.CreateBitCast(CookiePtr, SizeTy->getPointerTo(AS)); 950 llvm::Value *ElementSize = llvm::ConstantInt::get(SizeTy, 951 Ctx.getTypeSizeInChars(ElementType).getQuantity()); 952 CGF.Builder.CreateStore(ElementSize, CookiePtr); 953 954 // The second element is the element count. 955 CookiePtr = CGF.Builder.CreateConstInBoundsGEP1_32(CookiePtr, 1); 956 CGF.Builder.CreateStore(NumElements, CookiePtr); 957 958 // Finally, compute a pointer to the actual data buffer by skipping 959 // over the cookie completely. 960 CharUnits CookieSize = 2 * SizeSize; 961 return CGF.Builder.CreateConstInBoundsGEP1_64(NewPtr, 962 CookieSize.getQuantity()); 963} 964 965void ARMCXXABI::ReadArrayCookie(CodeGenFunction &CGF, 966 llvm::Value *Ptr, 967 const CXXDeleteExpr *expr, 968 QualType ElementType, 969 llvm::Value *&NumElements, 970 llvm::Value *&AllocPtr, 971 CharUnits &CookieSize) { 972 // Derive a char* in the same address space as the pointer. 973 unsigned AS = cast<llvm::PointerType>(Ptr->getType())->getAddressSpace(); 974 const llvm::Type *CharPtrTy = CGF.Builder.getInt8Ty()->getPointerTo(AS); 975 976 // If we don't need an array cookie, bail out early. 977 if (!NeedsArrayCookie(expr, ElementType)) { 978 AllocPtr = CGF.Builder.CreateBitCast(Ptr, CharPtrTy); 979 NumElements = 0; 980 CookieSize = CharUnits::Zero(); 981 return; 982 } 983 984 QualType SizeTy = getContext().getSizeType(); 985 CharUnits SizeSize = getContext().getTypeSizeInChars(SizeTy); 986 const llvm::Type *SizeLTy = CGF.ConvertType(SizeTy); 987 988 // The cookie size is always 2 * sizeof(size_t). 989 CookieSize = 2 * SizeSize; 990 991 // The allocated pointer is the input ptr, minus that amount. 992 AllocPtr = CGF.Builder.CreateBitCast(Ptr, CharPtrTy); 993 AllocPtr = CGF.Builder.CreateConstInBoundsGEP1_64(AllocPtr, 994 -CookieSize.getQuantity()); 995 996 // The number of elements is at offset sizeof(size_t) relative to that. 997 llvm::Value *NumElementsPtr 998 = CGF.Builder.CreateConstInBoundsGEP1_64(AllocPtr, 999 SizeSize.getQuantity()); 1000 NumElementsPtr = 1001 CGF.Builder.CreateBitCast(NumElementsPtr, SizeLTy->getPointerTo(AS)); 1002 NumElements = CGF.Builder.CreateLoad(NumElementsPtr); 1003} 1004 1005/*********************** Static local initialization **************************/ 1006 1007static llvm::Constant *getGuardAcquireFn(CodeGenModule &CGM, 1008 const llvm::PointerType *GuardPtrTy) { 1009 // int __cxa_guard_acquire(__guard *guard_object); 1010 1011 std::vector<const llvm::Type*> Args(1, GuardPtrTy); 1012 const llvm::FunctionType *FTy = 1013 llvm::FunctionType::get(CGM.getTypes().ConvertType(CGM.getContext().IntTy), 1014 Args, /*isVarArg=*/false); 1015 1016 return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_acquire"); 1017} 1018 1019static llvm::Constant *getGuardReleaseFn(CodeGenModule &CGM, 1020 const llvm::PointerType *GuardPtrTy) { 1021 // void __cxa_guard_release(__guard *guard_object); 1022 1023 std::vector<const llvm::Type*> Args(1, GuardPtrTy); 1024 1025 const llvm::FunctionType *FTy = 1026 llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()), 1027 Args, /*isVarArg=*/false); 1028 1029 return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_release"); 1030} 1031 1032static llvm::Constant *getGuardAbortFn(CodeGenModule &CGM, 1033 const llvm::PointerType *GuardPtrTy) { 1034 // void __cxa_guard_abort(__guard *guard_object); 1035 1036 std::vector<const llvm::Type*> Args(1, GuardPtrTy); 1037 1038 const llvm::FunctionType *FTy = 1039 llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()), 1040 Args, /*isVarArg=*/false); 1041 1042 return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_abort"); 1043} 1044 1045namespace { 1046 struct CallGuardAbort : EHScopeStack::Cleanup { 1047 llvm::GlobalVariable *Guard; 1048 CallGuardAbort(llvm::GlobalVariable *Guard) : Guard(Guard) {} 1049 1050 void Emit(CodeGenFunction &CGF, bool IsForEH) { 1051 CGF.Builder.CreateCall(getGuardAbortFn(CGF.CGM, Guard->getType()), Guard) 1052 ->setDoesNotThrow(); 1053 } 1054 }; 1055} 1056 1057/// The ARM code here follows the Itanium code closely enough that we 1058/// just special-case it at particular places. 1059void ItaniumCXXABI::EmitGuardedInit(CodeGenFunction &CGF, 1060 const VarDecl &D, 1061 llvm::GlobalVariable *GV) { 1062 CGBuilderTy &Builder = CGF.Builder; 1063 1064 // We only need to use thread-safe statics for local variables; 1065 // global initialization is always single-threaded. 1066 bool ThreadsafeStatics = (getContext().getLangOptions().ThreadsafeStatics && 1067 D.isLocalVarDecl()); 1068 1069 const llvm::IntegerType *GuardTy; 1070 1071 // If we have a global variable with internal linkage and thread-safe statics 1072 // are disabled, we can just let the guard variable be of type i8. 1073 bool UseInt8GuardVariable = !ThreadsafeStatics && GV->hasInternalLinkage(); 1074 if (UseInt8GuardVariable) 1075 GuardTy = Builder.getInt8Ty(); 1076 else { 1077 // Guard variables are 64 bits in the generic ABI and 32 bits on ARM. 1078 GuardTy = (IsARM ? Builder.getInt32Ty() : Builder.getInt64Ty()); 1079 } 1080 const llvm::PointerType *GuardPtrTy = GuardTy->getPointerTo(); 1081 1082 // Create the guard variable. 1083 llvm::SmallString<256> GuardVName; 1084 llvm::raw_svector_ostream Out(GuardVName); 1085 getMangleContext().mangleItaniumGuardVariable(&D, Out); 1086 Out.flush(); 1087 1088 // Just absorb linkage and visibility from the variable. 1089 llvm::GlobalVariable *GuardVariable = 1090 new llvm::GlobalVariable(CGM.getModule(), GuardTy, 1091 false, GV->getLinkage(), 1092 llvm::ConstantInt::get(GuardTy, 0), 1093 GuardVName.str()); 1094 GuardVariable->setVisibility(GV->getVisibility()); 1095 1096 // Test whether the variable has completed initialization. 1097 llvm::Value *IsInitialized; 1098 1099 // ARM C++ ABI 3.2.3.1: 1100 // To support the potential use of initialization guard variables 1101 // as semaphores that are the target of ARM SWP and LDREX/STREX 1102 // synchronizing instructions we define a static initialization 1103 // guard variable to be a 4-byte aligned, 4- byte word with the 1104 // following inline access protocol. 1105 // #define INITIALIZED 1 1106 // if ((obj_guard & INITIALIZED) != INITIALIZED) { 1107 // if (__cxa_guard_acquire(&obj_guard)) 1108 // ... 1109 // } 1110 if (IsARM && !UseInt8GuardVariable) { 1111 llvm::Value *V = Builder.CreateLoad(GuardVariable); 1112 V = Builder.CreateAnd(V, Builder.getInt32(1)); 1113 IsInitialized = Builder.CreateIsNull(V, "guard.uninitialized"); 1114 1115 // Itanium C++ ABI 3.3.2: 1116 // The following is pseudo-code showing how these functions can be used: 1117 // if (obj_guard.first_byte == 0) { 1118 // if ( __cxa_guard_acquire (&obj_guard) ) { 1119 // try { 1120 // ... initialize the object ...; 1121 // } catch (...) { 1122 // __cxa_guard_abort (&obj_guard); 1123 // throw; 1124 // } 1125 // ... queue object destructor with __cxa_atexit() ...; 1126 // __cxa_guard_release (&obj_guard); 1127 // } 1128 // } 1129 } else { 1130 // Load the first byte of the guard variable. 1131 const llvm::Type *PtrTy = Builder.getInt8PtrTy(); 1132 llvm::Value *V = 1133 Builder.CreateLoad(Builder.CreateBitCast(GuardVariable, PtrTy), "tmp"); 1134 1135 IsInitialized = Builder.CreateIsNull(V, "guard.uninitialized"); 1136 } 1137 1138 llvm::BasicBlock *InitCheckBlock = CGF.createBasicBlock("init.check"); 1139 llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end"); 1140 1141 // Check if the first byte of the guard variable is zero. 1142 Builder.CreateCondBr(IsInitialized, InitCheckBlock, EndBlock); 1143 1144 CGF.EmitBlock(InitCheckBlock); 1145 1146 // Variables used when coping with thread-safe statics and exceptions. 1147 if (ThreadsafeStatics) { 1148 // Call __cxa_guard_acquire. 1149 llvm::Value *V 1150 = Builder.CreateCall(getGuardAcquireFn(CGM, GuardPtrTy), GuardVariable); 1151 1152 llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init"); 1153 1154 Builder.CreateCondBr(Builder.CreateIsNotNull(V, "tobool"), 1155 InitBlock, EndBlock); 1156 1157 // Call __cxa_guard_abort along the exceptional edge. 1158 CGF.EHStack.pushCleanup<CallGuardAbort>(EHCleanup, GuardVariable); 1159 1160 CGF.EmitBlock(InitBlock); 1161 } 1162 1163 // Emit the initializer and add a global destructor if appropriate. 1164 CGF.EmitCXXGlobalVarDeclInit(D, GV); 1165 1166 if (ThreadsafeStatics) { 1167 // Pop the guard-abort cleanup if we pushed one. 1168 CGF.PopCleanupBlock(); 1169 1170 // Call __cxa_guard_release. This cannot throw. 1171 Builder.CreateCall(getGuardReleaseFn(CGM, GuardPtrTy), GuardVariable); 1172 } else { 1173 Builder.CreateStore(llvm::ConstantInt::get(GuardTy, 1), GuardVariable); 1174 } 1175 1176 CGF.EmitBlock(EndBlock); 1177} 1178