Lines Matching defs:CGF
123 EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
131 EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
136 llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,
151 llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF,
156 llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
160 void emitVirtualObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE,
164 void emitRethrow(CodeGenFunction &CGF, bool isNoReturn) override;
165 void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) override;
167 void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) override;
170 emitTerminateForUnexpectedException(CodeGenFunction &CGF,
182 void EmitBadTypeidCall(CodeGenFunction &CGF) override;
183 llvm::Value *EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy,
229 llvm::Value *emitDynamicCastCall(CodeGenFunction &CGF, Address Value,
234 llvm::Value *emitExactDynamicCast(CodeGenFunction &CGF, Address ThisAddr,
240 llvm::Value *emitDynamicCastToVoid(CodeGenFunction &CGF, Address Value,
243 bool EmitBadCastCall(CodeGenFunction &CGF) override;
246 GetVirtualBaseClassOffset(CodeGenFunction &CGF, Address This,
266 void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy,
269 void EmitInstanceFunctionProlog(CodeGenFunction &CGF) override;
271 AddedStructorArgs getImplicitConstructorArgs(CodeGenFunction &CGF,
277 llvm::Value *getCXXDestructorImplicitParam(CodeGenFunction &CGF,
283 void EmitDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *DD,
291 bool isVirtualOffsetNeededForVTableField(CodeGenFunction &CGF,
303 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass,
307 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass,
313 CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD,
318 EmitVirtualDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *Dtor,
339 llvm::Value *performThisAdjustment(CodeGenFunction &CGF, Address This,
343 llvm::Value *performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
358 Address InitializeArrayCookie(CodeGenFunction &CGF,
363 llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF,
367 void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
370 void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
386 LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD,
428 LoadVTablePtr(CodeGenFunction &CGF, Address This,
492 void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV,
496 Address InitializeArrayCookie(CodeGenFunction &CGF,
501 llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF, Address allocPtr,
529 void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) override;
531 emitTerminateForUnexpectedException(CodeGenFunction &CGF,
544 void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
624 CodeGenFunction &CGF, const Expr *E, Address ThisAddr,
627 CGBuilderTy &Builder = CGF.Builder;
636 llvm::BasicBlock *FnVirtual = CGF.createBasicBlock("memptr.virtual");
637 llvm::BasicBlock *FnNonVirtual = CGF.createBasicBlock("memptr.nonvirtual");
638 llvm::BasicBlock *FnEnd = CGF.createBasicBlock("memptr.end");
650 llvm::Value *This = ThisAddr.emitRawPointer(CGF);
670 CGF.EmitBlock(FnVirtual);
673 llvm::Type *VTableTy = CGF.CGM.GlobalsInt8PtrTy;
675 CGF.CGM.getDynamicOffsetAlignment(ThisAddr.getAlignment(), RD,
676 CGF.getPointerAlign());
677 llvm::Value *VTable = CGF.GetVTablePtr(
687 VTableOffset = Builder.CreateTrunc(VTableOffset, CGF.Int32Ty);
695 bool ShouldEmitCFICheck = CGF.SanOpts.has(SanitizerKind::CFIMFCall) &&
706 CodeGenFunction::SanitizerScope SanScope(&CGF);
715 TypeId = llvm::MetadataAsValue::get(CGF.getLLVMContext(), MD);
720 Builder.CreateGEP(CGF.Int8Ty, VTable, VTableOffset);
737 Builder.CreateGEP(CGF.Int8Ty, VTable, VTableOffset);
747 VirtualFn = CGF.Builder.CreateCall(
753 CGF.Builder.CreateGEP(CGF.Int8Ty, VTable, VTableOffset);
754 VirtualFn = CGF.Builder.CreateAlignedLoad(CGF.UnqualPtrTy, VFPAddr,
755 CGF.getPointerAlign(),
766 CheckSourceLocation = CGF.EmitCheckSourceLocation(E->getBeginLoc());
767 CheckTypeDesc = CGF.EmitCheckTypeDescriptor(QualType(MPT, 0));
769 llvm::ConstantInt::get(CGF.Int8Ty, CodeGenFunction::CFITCK_VMFCall),
775 CGF.EmitTrapCheck(CheckResult, SanitizerHandler::CFICheckFail);
782 CGF.EmitCheck(std::make_pair(CheckResult, SanitizerKind::SO_CFIMFCall),
791 CGF.EmitBranch(FnEnd);
795 CGF.EmitBlock(FnNonVirtual);
797 Builder.CreateIntToPtr(FnAsInt, CGF.UnqualPtrTy, "memptr.nonvirtualfn");
803 CodeGenFunction::SanitizerScope SanScope(&CGF);
806 llvm::ConstantInt::get(CGF.Int8Ty, CodeGenFunction::CFITCK_NVMFCall),
818 llvm::MetadataAsValue::get(CGF.getLLVMContext(), MD);
826 CGF.EmitCheck(std::make_pair(Bit, SanitizerKind::SO_CFIMFCall),
828 {NonVirtualFn, llvm::UndefValue::get(CGF.IntPtrTy)});
835 CGF.EmitBlock(FnEnd);
836 llvm::PHINode *CalleePtr = Builder.CreatePHI(CGF.UnqualPtrTy, 2);
844 llvm::PHINode *DiscriminatorPHI = Builder.CreatePHI(CGF.IntPtrTy, 2);
845 DiscriminatorPHI->addIncoming(llvm::ConstantInt::get(CGF.IntPtrTy, 0),
865 CodeGenFunction &CGF, const Expr *E, Address Base, llvm::Value *MemPtr,
869 CGBuilderTy &Builder = CGF.Builder;
872 return Builder.CreateInBoundsGEP(CGF.Int8Ty, Base.emitRawPointer(CGF), MemPtr,
919 ItaniumCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
930 CGBuilderTy &Builder = CGF.Builder;
943 llvm::BasicBlock *ResignBB = CGF.createBasicBlock("resign");
944 llvm::BasicBlock *MergeBB = CGF.createBasicBlock("merge");
955 CGF.EmitBlock(ResignBB);
959 CGF.emitPointerAuthResign(MemFnPtr, SrcType, CurAuthInfo, NewAuthInfo,
965 CGF.EmitBlock(MergeBB);
1238 ItaniumCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
1243 CGBuilderTy &Builder = CGF.Builder;
1312 ItaniumCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
1315 CGBuilderTy &Builder = CGF.Builder;
1367 void ItaniumCXXABI::emitVirtualObjectDelete(CodeGenFunction &CGF,
1380 llvm::Value *VTable = CGF.GetVTablePtr(Ptr, CGF.UnqualPtrTy, ClassDecl);
1383 llvm::Value *OffsetPtr = CGF.Builder.CreateConstInBoundsGEP1_64(
1384 CGF.IntPtrTy, VTable, -2, "complete-offset.ptr");
1385 llvm::Value *Offset = CGF.Builder.CreateAlignedLoad(CGF.IntPtrTy, OffsetPtr,
1386 CGF.getPointerAlign());
1389 llvm::Value *CompletePtr = Ptr.emitRawPointer(CGF);
1391 CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, CompletePtr, Offset);
1395 CGF.pushCallObjectDeleteCleanup(DE->getOperatorDelete(), CompletePtr,
1402 EmitVirtualDestructorCall(CGF, Dtor, DtorType, Ptr, DE,
1406 CGF.PopCleanupBlock();
1409 void ItaniumCXXABI::emitRethrow(CodeGenFunction &CGF, bool isNoReturn) {
1418 CGF.EmitNoreturnRuntimeCallOrInvoke(Fn, {});
1420 CGF.EmitRuntimeCallOrInvoke(Fn);
1443 void ItaniumCXXABI::emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) {
1446 llvm::Type *SizeTy = CGF.ConvertType(getContext().getSizeType());
1450 llvm::CallInst *ExceptionPtr = CGF.EmitNounwindRuntimeCall(
1453 CharUnits ExnAlign = CGF.getContext().getExnObjectAlignment();
1454 CGF.EmitAnyExprToExn(
1482 CGF.EmitNoreturnRuntimeCallOrInvoke(getThrowFn(CGM), args);
1485 static llvm::FunctionCallee getItaniumDynamicCastFn(CodeGenFunction &CGF) {
1491 llvm::Type *Int8PtrTy = CGF.Int8PtrTy;
1492 llvm::Type *GlobInt8PtrTy = CGF.GlobalsInt8PtrTy;
1494 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1501 llvm::AttrBuilder FuncAttrs(CGF.getLLVMContext());
1506 CGF.getLLVMContext(), llvm::AttributeList::FunctionIndex, FuncAttrs);
1508 return CGF.CGM.CreateRuntimeFunction(FTy, "__dynamic_cast", Attrs);
1511 static llvm::FunctionCallee getBadCastFn(CodeGenFunction &CGF) {
1513 llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
1514 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_cast");
1569 static llvm::FunctionCallee getBadTypeidFn(CodeGenFunction &CGF) {
1571 llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
1573 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_typeid");
1580 void ItaniumCXXABI::EmitBadTypeidCall(CodeGenFunction &CGF) {
1581 llvm::FunctionCallee Fn = getBadTypeidFn(CGF);
1582 llvm::CallBase *Call = CGF.EmitRuntimeCallOrInvoke(Fn);
1584 CGF.Builder.CreateUnreachable();
1587 llvm::Value *ItaniumCXXABI::EmitTypeid(CodeGenFunction &CGF,
1593 llvm::Value *Value = CGF.GetVTablePtr(ThisPtr, CGM.GlobalsInt8PtrTy,
1598 Value = CGF.Builder.CreateCall(
1604 CGF.Builder.CreateConstInBoundsGEP1_64(StdTypeInfoPtrTy, Value, -1ULL);
1606 return CGF.Builder.CreateAlignedLoad(StdTypeInfoPtrTy, Value,
1607 CGF.getPointerAlign());
1616 CodeGenFunction &CGF, Address ThisAddr, QualType SrcRecordTy,
1619 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1622 CGF.CGM.GetAddrOfRTTIDescriptor(SrcRecordTy.getUnqualifiedType());
1624 CGF.CGM.GetAddrOfRTTIDescriptor(DestRecordTy.getUnqualifiedType());
1631 computeOffsetHint(CGF.getContext(), SrcDecl, DestDecl).getQuantity());
1634 llvm::Value *Value = ThisAddr.emitRawPointer(CGF);
1642 CGF.GetVTablePtr(ThisAddr, CGM.Int8PtrTy, SrcDecl,
1649 Value = CGF.EmitNounwindRuntimeCall(getItaniumDynamicCastFn(CGF), args);
1655 CGF.createBasicBlock("dynamic_cast.bad_cast");
1657 llvm::Value *IsNull = CGF.Builder.CreateIsNull(Value);
1658 CGF.Builder.CreateCondBr(IsNull, BadCastBlock, CastEnd);
1660 CGF.EmitBlock(BadCastBlock);
1661 EmitBadCastCall(CGF);
1668 CodeGenFunction &CGF, Address ThisAddr, QualType SrcRecordTy,
1712 ThisAddr = Address(emitDynamicCastToVoid(CGF, ThisAddr, SrcRecordTy),
1713 CGF.VoidPtrTy, ThisAddr.getAlignment());
1722 CGF.EmitBranch(CastFail);
1723 return llvm::PoisonValue::get(CGF.VoidPtrTy);
1730 llvm::Instruction *VPtr = CGF.Builder.CreateLoad(
1731 ThisAddr.withElementType(CGF.VoidPtrPtrTy), "vtable");
1733 VPtr, CGM.getTBAAVTablePtrAccessInfo(CGF.VoidPtrPtrTy));
1734 llvm::Value *Success = CGF.Builder.CreateICmpEQ(
1736 llvm::Value *Result = ThisAddr.emitRawPointer(CGF);
1738 Result = CGF.Builder.CreateInBoundsGEP(
1739 CGF.CharTy, Result,
1740 {llvm::ConstantInt::get(CGF.PtrDiffTy, -Offset->getQuantity())});
1741 CGF.Builder.CreateCondBr(Success, CastSuccess, CastFail);
1745 llvm::Value *ItaniumCXXABI::emitDynamicCastToVoid(CodeGenFunction &CGF,
1754 CGF.GetVTablePtr(ThisAddr, CGF.UnqualPtrTy, ClassDecl);
1758 CGF.Builder.CreateConstInBoundsGEP1_32(CGM.Int32Ty, VTable, -2U);
1759 OffsetToTop = CGF.Builder.CreateAlignedLoad(
1763 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1767 CGF.GetVTablePtr(ThisAddr, CGF.UnqualPtrTy, ClassDecl);
1771 CGF.Builder.CreateConstInBoundsGEP1_64(PtrDiffLTy, VTable, -2ULL);
1772 OffsetToTop = CGF.Builder.CreateAlignedLoad(
1773 PtrDiffLTy, OffsetToTop, CGF.getPointerAlign(), "offset.to.top");
1776 return CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, ThisAddr.emitRawPointer(CGF),
1780 bool ItaniumCXXABI::EmitBadCastCall(CodeGenFunction &CGF) {
1781 llvm::FunctionCallee Fn = getBadCastFn(CGF);
1782 llvm::CallBase *Call = CGF.EmitRuntimeCallOrInvoke(Fn);
1784 CGF.Builder.CreateUnreachable();
1789 ItaniumCXXABI::GetVirtualBaseClassOffset(CodeGenFunction &CGF,
1793 llvm::Value *VTablePtr = CGF.GetVTablePtr(This, CGM.Int8PtrTy, ClassDecl);
1798 CGF.Builder.CreateConstGEP1_64(
1799 CGF.Int8Ty, VTablePtr, VBaseOffsetOffset.getQuantity(),
1804 VBaseOffset = CGF.Builder.CreateAlignedLoad(
1805 CGF.Int32Ty, VBaseOffsetPtr, CharUnits::fromQuantity(4),
1808 VBaseOffset = CGF.Builder.CreateAlignedLoad(
1809 CGM.PtrDiffTy, VBaseOffsetPtr, CGF.getPointerAlign(), "vbase.offset");
1867 void ItaniumCXXABI::addImplicitStructorParams(CodeGenFunction &CGF,
1870 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
1874 if (NeedsVTTParameter(CGF.CurGD)) {
1885 getStructorImplicitParamDecl(CGF) = VTTDecl;
1889 void ItaniumCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
1891 if (CGF.CurFuncDecl && CGF.CurFuncDecl->hasAttr<NakedAttr>())
1896 setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF));
1899 if (getStructorImplicitParamDecl(CGF)) {
1900 getStructorImplicitParamValue(CGF) = CGF.Builder.CreateLoad(
1901 CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)), "vtt");
1912 if (HasThisReturn(CGF.CurGD))
1913 CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
1917 CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type,
1926 CGF.GetVTTParameter(GlobalDecl(D, Type), ForVirtualBase, Delegating);
1934 CodeGenFunction &CGF, const CXXDestructorDecl *DD, CXXDtorType Type,
1937 return CGF.GetVTTParameter(GD, ForVirtualBase, Delegating);
1940 void ItaniumCXXABI::EmitDestructorCall(CodeGenFunction &CGF,
1947 getCXXDestructorImplicitParam(CGF, DD, Type, ForVirtualBase, Delegating);
1953 Callee = CGF.BuildAppleKextVirtualDestructorCall(DD, Type, DD->getParent());
1957 CGF.EmitCXXDestructorCall(GD, Callee, CGF.getAsNaturalPointerTo(This, ThisTy),
2059 CodeGenFunction &CGF, CodeGenFunction::VPtr Vptr) {
2062 return NeedsVTTParameter(CGF.CurGD);
2066 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
2070 NeedsVTTParameter(CGF.CurGD)) {
2071 return getVTableAddressPointInStructorWithVTT(CGF, VTableClass, Base,
2109 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
2112 NeedsVTTParameter(CGF.CurGD) && "This class doesn't have VTT");
2119 llvm::Value *VTT = CGF.LoadCXXVTT();
2121 VTT = CGF.Builder.CreateConstInBoundsGEP1_64(CGF.GlobalsVoidPtrTy, VTT,
2126 CGF.Builder.CreateAlignedLoad(CGF.GlobalsVoidPtrTy, VTT,
2127 CGF.getPointerAlign());
2129 if (auto &Schema = CGF.CGM.getCodeGenOpts().PointerAuth.CXXVTTVTablePointers) {
2130 CGPointerAuthInfo PointerAuth = CGF.EmitPointerAuthInfo(Schema, VTT,
2133 AP = CGF.EmitPointerAuthAuth(PointerAuth, AP);
2178 CGCallee ItaniumCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF,
2185 llvm::Value *VTable = CGF.GetVTablePtr(This, PtrTy, MethodDecl->getParent());
2190 if (!Schema && CGF.ShouldEmitVTableTypeCheckedLoad(MethodDecl->getParent())) {
2191 VFunc = CGF.EmitVTableTypeCheckedLoad(
2197 CGF.EmitTypeMetadataCodeForVCall(MethodDecl->getParent(), VTable, Loc);
2201 VFuncLoad = CGF.Builder.CreateCall(
2205 VTableSlotPtr = CGF.Builder.CreateConstInBoundsGEP1_64(
2207 VFuncLoad = CGF.Builder.CreateAlignedLoad(PtrTy, VTableSlotPtr,
2208 CGF.getPointerAlign());
2233 PointerAuth = CGF.EmitPointerAuthInfo(Schema, VTableSlotPtr, GD, QualType());
2240 CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType,
2251 llvm::FunctionType *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
2261 CGF.EmitCXXDestructorCall(GD, Callee, This.emitRawPointer(CGF), ThisTy,
2342 static llvm::Value *performTypeAdjustment(CodeGenFunction &CGF,
2349 return InitialPtr.emitRawPointer(CGF);
2351 Address V = InitialPtr.withElementType(CGF.Int8Ty);
2355 V = CGF.Builder.CreateConstInBoundsByteGEP(V,
2363 CGF.GetVTablePtr(V, CGF.Int8PtrTy, UnadjustedClass);
2366 llvm::Value *OffsetPtr = CGF.Builder.CreateConstInBoundsGEP1_64(
2367 CGF.Int8Ty, VTablePtr, VirtualAdjustment);
2368 if (CGF.CGM.getItaniumVTableContext().isRelativeLayout()) {
2371 CGF.Builder.CreateAlignedLoad(CGF.Int32Ty, OffsetPtr,
2375 CGF.ConvertType(CGF.getContext().getPointerDiffType());
2378 Offset = CGF.Builder.CreateAlignedLoad(PtrDiffTy, OffsetPtr,
2379 CGF.getPointerAlign());
2382 ResultPtr = CGF.Builder.CreateInBoundsGEP(V.getElementType(),
2383 V.emitRawPointer(CGF), Offset);
2385 ResultPtr = V.emitRawPointer(CGF);
2391 ResultPtr = CGF.Builder.CreateConstInBoundsGEP1_64(CGF.Int8Ty, ResultPtr,
2399 ItaniumCXXABI::performThisAdjustment(CodeGenFunction &CGF, Address This,
2402 return performTypeAdjustment(CGF, This, UnadjustedClass, TI.This.NonVirtual,
2408 ItaniumCXXABI::performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
2411 return performTypeAdjustment(CGF, Ret, UnadjustedClass, RA.NonVirtual,
2416 void ARMCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
2418 if (!isa<CXXDestructorDecl>(CGF.CurGD.getDecl()))
2419 return ItaniumCXXABI::EmitReturnFromThunk(CGF, RV, ResultType);
2422 llvm::Type *T = CGF.ReturnValue.getElementType();
2424 return ItaniumCXXABI::EmitReturnFromThunk(CGF, Undef, ResultType);
2436 Address ItaniumCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
2446 CharUnits SizeSize = CGF.getSizeSize();
2457 CookiePtr = CGF.Builder.CreateConstInBoundsByteGEP(CookiePtr, CookieOffset);
2460 Address NumElementsPtr = CookiePtr.withElementType(CGF.SizeTy);
2461 llvm::Instruction *SI = CGF.Builder.CreateStore(NumElements, NumElementsPtr);
2473 CGF.Builder.CreateCall(F, NumElementsPtr.emitRawPointer(CGF));
2478 return CGF.Builder.CreateConstInBoundsByteGEP(NewPtr, CookieSize);
2481 llvm::Value *ItaniumCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
2486 CharUnits numElementsOffset = cookieSize - CGF.getSizeSize();
2489 CGF.Builder.CreateConstInBoundsByteGEP(numElementsPtr, numElementsOffset);
2492 numElementsPtr = numElementsPtr.withElementType(CGF.SizeTy);
2494 return CGF.Builder.CreateLoad(numElementsPtr);
2501 llvm::FunctionType::get(CGF.SizeTy, CGF.UnqualPtrTy, false);
2504 return CGF.Builder.CreateCall(F, numElementsPtr.emitRawPointer(CGF));
2520 Address ARMCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
2531 cookie = cookie.withElementType(CGF.SizeTy);
2532 llvm::Value *elementSize = llvm::ConstantInt::get(CGF.SizeTy,
2534 CGF.Builder.CreateStore(elementSize, cookie);
2537 cookie = CGF.Builder.CreateConstInBoundsGEP(cookie, 1);
2538 CGF.Builder.CreateStore(numElements, cookie);
2543 return CGF.Builder.CreateConstInBoundsByteGEP(newPtr, cookieSize);
2546 llvm::Value *ARMCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
2552 = CGF.Builder.CreateConstInBoundsByteGEP(allocPtr, CGF.getSizeSize());
2554 numElementsPtr = numElementsPtr.withElementType(CGF.SizeTy);
2555 return CGF.Builder.CreateLoad(numElementsPtr);
2602 void Emit(CodeGenFunction &CGF, Flags flags) override {
2603 CGF.EmitNounwindRuntimeCall(getGuardAbortFn(CGF.CGM, Guard->getType()),
2611 void ItaniumCXXABI::EmitGuardedInit(CodeGenFunction &CGF,
2615 CGBuilderTy &Builder = CGF.Builder;
2637 guardTy = CGF.Int8Ty;
2643 guardTy = CGF.SizeTy;
2644 guardAlignment = CGF.getSizeAlign();
2646 guardTy = CGF.Int64Ty;
2652 CGF.CGM.getLLVMContext(),
2653 CGF.CGM.getDataLayout().getDefaultGlobalsAddressSpace());
2718 unsigned MaxInlineWidthInBits = CGF.getTarget().getMaxAtomicInlineWidth();
2719 llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end");
2760 llvm::BasicBlock *InitCheckBlock = CGF.createBasicBlock("init.check");
2763 CGF.EmitCXXGuardedInitBranch(NeedsInit, InitCheckBlock, EndBlock,
2766 CGF.EmitBlock(InitCheckBlock);
2788 = CGF.EmitNounwindRuntimeCall(getGuardAcquireFn(CGM, guardPtrTy), guard);
2790 llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
2796 CGF.EHStack.pushCleanup<CallGuardAbort>(EHCleanup, guard);
2798 CGF.EmitBlock(InitBlock);
2808 CGF.EmitCXXGlobalVarDeclInit(D, var, shouldPerformInit);
2812 CGF.PopCleanupBlock();
2815 CGF.EmitNounwindRuntimeCall(getGuardReleaseFn(CGM, guardPtrTy),
2816 guardAddr.emitRawPointer(CGF));
2825 CGF.EmitBlock(EndBlock);
2829 static void emitGlobalDtorWithCXAAtExit(CodeGenFunction &CGF,
2832 assert(!CGF.getTarget().getTriple().isOSAIX() &&
2834 assert((TLS || CGF.getTypes().getCodeGenOpts().CXAAtExit) &&
2838 const llvm::Triple &T = CGF.getTarget().getTriple();
2844 llvm::Type *dtorTy = CGF.UnqualPtrTy;
2848 auto AddrPtrTy = AddrAS ? llvm::PointerType::get(CGF.getLLVMContext(), AddrAS)
2849 : CGF.Int8PtrTy;
2853 CGF.CGM.CreateRuntimeVariable(CGF.Int8Ty, "__dso_handle");
2860 llvm::FunctionType::get(CGF.IntTy, paramTys, false);
2863 llvm::FunctionCallee atexit = CGF.CGM.CreateRuntimeFunction(atexitTy, Name);
2867 const auto &Context = CGF.CGM.getContext();
2873 dtorCallee = CGF.CGM.getFunctionPointer(dtorCallee, fnType);
2880 addr = llvm::Constant::getNullValue(CGF.Int8PtrTy);
2883 CGF.EmitNounwindRuntimeCall(atexit, args);
2906 CodeGenFunction CGF(*this);
2907 CGF.StartFunction(GlobalDecl(), getContext().VoidTy, GlobalCleanupFn,
2910 auto AL = ApplyDebugLocation::CreateArtificial(CGF);
2913 llvm::FunctionType *dtorFuncTy = llvm::FunctionType::get(CGF.VoidTy, false);
2924 llvm::Value *V = CGF.unregisterGlobalDtorWithUnAtExit(Dtor);
2926 CGF.Builder.CreateIsNull(V, "needs_destruct");
2929 CGF.createBasicBlock("destruct.call");
2930 llvm::BasicBlock *EndBlock = CGF.createBasicBlock(
2934 CGF.Builder.CreateCondBr(NeedsDestruct, DestructCallBlock, EndBlock);
2936 CGF.EmitBlock(DestructCallBlock);
2939 llvm::CallInst *CI = CGF.Builder.CreateCall(dtorFuncTy, Dtor);
2943 CGF.EmitBlock(EndBlock);
2948 CGF.FinishFunction();
2961 CodeGenFunction CGF(*this);
2962 CGF.StartFunction(GlobalDecl(), getContext().VoidTy, GlobalInitFn,
2965 auto AL = ApplyDebugLocation::CreateArtificial(CGF);
2977 emitGlobalDtorWithCXAAtExit(CGF, Dtor, nullptr, false);
2981 CGF.registerGlobalDtorWithAtExit(Dtor);
2985 CGF.FinishFunction();
2994 void ItaniumCXXABI::registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
3010 return CGF.registerGlobalDtorWithLLVM(D, dtor, addr);
3017 return emitGlobalDtorWithCXAAtExit(CGF, dtor, addr, D.getTLSKind());
3026 CGF.registerGlobalDtorWithAtExit(D, dtor, addr);
3311 LValue ItaniumCXXABI::EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,
3314 llvm::Value *Val = CGF.CGM.GetAddrOfGlobalVar(VD);
3317 llvm::CallInst *CallVal = CGF.Builder.CreateCall(Wrapper);
3322 LV = CGF.MakeNaturalAlignRawAddrLValue(CallVal, LValType);
3324 LV = CGF.MakeRawAddrLValue(CallVal, LValType,
3325 CGF.getContext().getDeclAlign(VD));
3382 CodeGenFunction CGF(CGM);
3383 CGF.CurGD = GlobalDecl(MD);
3384 CGF.CurFuncIsThunk = true;
3388 CGF.BuildFunctionArgList(CGF.CurGD, FunctionArgs);
3390 CGF.StartFunction(GlobalDecl(), FnInfo.getReturnType(), ThunkFn, FnInfo,
3392 llvm::Value *ThisVal = loadIncomingCXXThis(CGF);
3393 setCXXABIThisValue(CGF, ThisVal);
3397 CGF.EmitDelegateCallArg(CallArgs, VD, SourceLocation());
3404 getThisAddress(CGF), ThunkTy);
3406 CGF.EmitCall(CallInfo, Callee, ReturnValueSlot(), CallArgs, &CallOrInvoke,
3411 CGF.Builder.CreateRetVoid();
3413 CGF.Builder.CreateRet(Call);
3417 CGF.EmitBlock(CGF.createBasicBlock());
3418 CGF.FinishFunction();
4805 void Emit(CodeGenFunction &CGF, Flags flags) override {
4807 CGF.EmitNounwindRuntimeCall(getEndCatchFn(CGF.CGM));
4811 CGF.EmitRuntimeCallOrInvoke(getEndCatchFn(CGF.CGM));
4822 static llvm::Value *CallBeginCatch(CodeGenFunction &CGF,
4826 CGF.EmitNounwindRuntimeCall(getBeginCatchFn(CGF.CGM), Exn);
4828 CGF.EHStack.pushCleanup<CallEndCatch>(
4830 EndMightThrow && !CGF.CGM.getLangOpts().AssumeNothrowExceptionDtor);
4837 static void InitCatchParam(CodeGenFunction &CGF,
4842 llvm::Value *Exn = CGF.getExceptionFromSlot();
4845 CGF.CGM.getContext().getCanonicalType(CatchParam.getType());
4846 llvm::Type *LLVMCatchTy = CGF.ConvertTypeForMem(CatchType);
4855 llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, EndCatchMightThrow);
4870 CGF.CGM.getTargetCodeGenInfo().getSizeOfUnwindException();
4872 CGF.Builder.CreateConstGEP1_32(CGF.Int8Ty, Exn, HeaderSize);
4890 llvm::Type *PtrTy = CGF.ConvertTypeForMem(CaughtType);
4894 CGF.CreateTempAlloca(PtrTy, CGF.getPointerAlign(), "exn.byref.tmp");
4895 llvm::Value *Casted = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
4896 CGF.Builder.CreateStore(Casted, ExnPtrTmp);
4899 AdjustedExn = ExnPtrTmp.emitRawPointer(CGF);
4904 CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.byref");
4905 CGF.Builder.CreateStore(ExnCast, ParamAddr);
4910 TypeEvaluationKind TEK = CGF.getEvaluationKind(CatchType);
4912 llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, false);
4918 CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.casted");
4922 CastExn = CGF.EmitARCRetainNonBlock(CastExn);
4928 CGF.Builder.CreateStore(CastExn, ParamAddr);
4932 CGF.EmitARCInitWeak(ParamAddr, CastExn);
4940 LValue srcLV = CGF.MakeNaturalAlignAddrLValue(AdjustedExn, CatchType);
4941 LValue destLV = CGF.MakeAddrLValue(ParamAddr, CatchType);
4944 CGF.EmitStoreOfComplex(CGF.EmitLoadOfComplex(srcLV, Loc), destLV,
4948 llvm::Value *ExnLoad = CGF.EmitLoadOfScalar(srcLV, Loc);
4949 CGF.EmitStoreOfScalar(ExnLoad, destLV, /*init*/ true);
4960 CharUnits caughtExnAlignment = CGF.CGM.getClassPointerAlignment(catchRD);
4962 llvm::Type *PtrTy = CGF.UnqualPtrTy; // addrspace 0 ok
4968 llvm::Value *rawAdjustedExn = CallBeginCatch(CGF, Exn, true);
4969 Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
4971 LValue Dest = CGF.MakeAddrLValue(ParamAddr, CatchType);
4972 LValue Src = CGF.MakeAddrLValue(adjustedExn, CatchType);
4973 CGF.EmitAggregateCopy(Dest, Src, CatchType, AggValueSlot::DoesNotOverlap);
4980 CGF.EmitNounwindRuntimeCall(getGetExceptionPtrFn(CGF.CGM), Exn);
4983 Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
4989 opaque(CGF, OpaqueValueExpr::findInCopyConstruct(copyExpr),
4990 CGF.MakeAddrLValue(adjustedExn, CatchParam.getType()));
4993 CGF.EHStack.pushTerminate();
4996 CGF.EmitAggExpr(copyExpr,
5004 CGF.EHStack.popTerminate();
5010 CallBeginCatch(CGF, Exn, true);
5015 void ItaniumCXXABI::emitBeginCatch(CodeGenFunction &CGF,
5042 llvm::Value *Exn = CGF.getExceptionFromSlot();
5043 CallBeginCatch(CGF, Exn, true);
5048 CodeGenFunction::AutoVarEmission var = CGF.EmitAutoVarAlloca(*CatchParam);
5049 InitCatchParam(CGF, *CatchParam, var.getObjectAddress(CGF), S->getBeginLoc());
5050 CGF.EmitAutoVarCleanups(var);
5109 ItaniumCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
5113 assert(CGF.CGM.getLangOpts().CPlusPlus);
5114 return CGF.EmitNounwindRuntimeCall(getClangCallTerminateFn(CGF.CGM), Exn);
5116 return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn());
5120 ItaniumCXXABI::LoadVTablePtr(CodeGenFunction &CGF, Address This,
5122 return {CGF.GetVTablePtr(This, CGM.Int8PtrTy, RD), RD};
5137 void WebAssemblyCXXABI::emitBeginCatch(CodeGenFunction &CGF,
5139 if (CGF.getTarget().hasFeature("exception-handling"))
5140 CGF.EHStack.pushCleanup<CatchRetScope>(
5141 NormalCleanup, cast<llvm::CatchPadInst>(CGF.CurrentFuncletPad));
5142 ItaniumCXXABI::emitBeginCatch(CGF, C);
5146 WebAssemblyCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
5154 return CGCXXABI::emitTerminateForUnexpectedException(CGF, Exn);
5158 void XLCXXABI::registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
5162 llvm::PointerType *PtrTy = CGF.UnqualPtrTy;
5173 llvm::Function *DtorStub = CGF.createTLSAtExitStub(D, Dtor, Addr, AtExit);
5178 CGF.EmitNounwindRuntimeCall(AtExit, {NV, DtorStub});
5186 cast<llvm::Function>(CGF.createAtExitStub(D, Dtor, Addr));
5189 CGF.registerGlobalDtorWithAtExit(DtorStub);
5210 CodeGenFunction CGF(CGM);
5212 CGF.StartFunction(GlobalDecl(), CGM.getContext().VoidTy, StermFinalizer, FI,
5220 llvm::Value *V = CGF.unregisterGlobalDtorWithUnAtExit(dtorStub);
5222 llvm::Value *NeedsDestruct = CGF.Builder.CreateIsNull(V, "needs_destruct");
5224 llvm::BasicBlock *DestructCallBlock = CGF.createBasicBlock("destruct.call");
5225 llvm::BasicBlock *EndBlock = CGF.createBasicBlock("destruct.end");
5229 CGF.Builder.CreateCondBr(NeedsDestruct, DestructCallBlock, EndBlock);
5231 CGF.EmitBlock(DestructCallBlock);
5234 llvm::CallInst *CI = CGF.Builder.CreateCall(dtorStub);
5239 CGF.EmitBlock(EndBlock);
5241 CGF.FinishFunction();