Lines Matching defs:CGF
124 EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
132 EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
137 llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,
152 llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF,
157 llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
161 void emitVirtualObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE,
165 void emitRethrow(CodeGenFunction &CGF, bool isNoReturn) override;
166 void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) override;
168 void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) override;
171 emitTerminateForUnexpectedException(CodeGenFunction &CGF,
183 void EmitBadTypeidCall(CodeGenFunction &CGF) override;
184 llvm::Value *EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy,
230 llvm::Value *emitDynamicCastCall(CodeGenFunction &CGF, Address Value,
235 llvm::Value *emitExactDynamicCast(CodeGenFunction &CGF, Address ThisAddr,
241 llvm::Value *emitDynamicCastToVoid(CodeGenFunction &CGF, Address Value,
244 bool EmitBadCastCall(CodeGenFunction &CGF) override;
247 GetVirtualBaseClassOffset(CodeGenFunction &CGF, Address This,
267 void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy,
270 void EmitInstanceFunctionProlog(CodeGenFunction &CGF) override;
272 AddedStructorArgs getImplicitConstructorArgs(CodeGenFunction &CGF,
278 llvm::Value *getCXXDestructorImplicitParam(CodeGenFunction &CGF,
284 void EmitDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *DD,
292 bool isVirtualOffsetNeededForVTableField(CodeGenFunction &CGF,
304 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass,
308 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass,
314 CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD,
318 llvm::Value *EmitVirtualDestructorCall(CodeGenFunction &CGF,
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,
489 void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV,
493 Address InitializeArrayCookie(CodeGenFunction &CGF,
498 llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF, Address allocPtr,
526 void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) override;
528 emitTerminateForUnexpectedException(CodeGenFunction &CGF,
541 void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
628 CodeGenFunction &CGF, const Expr *E, Address ThisAddr,
631 CGBuilderTy &Builder = CGF.Builder;
640 llvm::BasicBlock *FnVirtual = CGF.createBasicBlock("memptr.virtual");
641 llvm::BasicBlock *FnNonVirtual = CGF.createBasicBlock("memptr.nonvirtual");
642 llvm::BasicBlock *FnEnd = CGF.createBasicBlock("memptr.end");
654 llvm::Value *This = ThisAddr.emitRawPointer(CGF);
674 CGF.EmitBlock(FnVirtual);
677 llvm::Type *VTableTy = CGF.CGM.GlobalsInt8PtrTy;
679 CGF.CGM.getDynamicOffsetAlignment(ThisAddr.getAlignment(), RD,
680 CGF.getPointerAlign());
681 llvm::Value *VTable = CGF.GetVTablePtr(
691 VTableOffset = Builder.CreateTrunc(VTableOffset, CGF.Int32Ty);
699 bool ShouldEmitCFICheck = CGF.SanOpts.has(SanitizerKind::CFIMFCall) &&
710 CodeGenFunction::SanitizerScope SanScope(&CGF);
719 TypeId = llvm::MetadataAsValue::get(CGF.getLLVMContext(), MD);
724 Builder.CreateGEP(CGF.Int8Ty, VTable, VTableOffset);
741 Builder.CreateGEP(CGF.Int8Ty, VTable, VTableOffset);
751 VirtualFn = CGF.Builder.CreateCall(
757 CGF.Builder.CreateGEP(CGF.Int8Ty, VTable, VTableOffset);
758 VirtualFn = CGF.Builder.CreateAlignedLoad(CGF.UnqualPtrTy, VFPAddr,
759 CGF.getPointerAlign(),
770 CheckSourceLocation = CGF.EmitCheckSourceLocation(E->getBeginLoc());
771 CheckTypeDesc = CGF.EmitCheckTypeDescriptor(QualType(MPT, 0));
773 llvm::ConstantInt::get(CGF.Int8Ty, CodeGenFunction::CFITCK_VMFCall),
779 CGF.EmitTrapCheck(CheckResult, SanitizerHandler::CFICheckFail);
786 CGF.EmitCheck(std::make_pair(CheckResult, SanitizerKind::CFIMFCall),
795 CGF.EmitBranch(FnEnd);
799 CGF.EmitBlock(FnNonVirtual);
801 Builder.CreateIntToPtr(FnAsInt, CGF.UnqualPtrTy, "memptr.nonvirtualfn");
807 CodeGenFunction::SanitizerScope SanScope(&CGF);
810 llvm::ConstantInt::get(CGF.Int8Ty, CodeGenFunction::CFITCK_NVMFCall),
822 llvm::MetadataAsValue::get(CGF.getLLVMContext(), MD);
830 CGF.EmitCheck(std::make_pair(Bit, SanitizerKind::CFIMFCall),
832 {NonVirtualFn, llvm::UndefValue::get(CGF.IntPtrTy)});
839 CGF.EmitBlock(FnEnd);
840 llvm::PHINode *CalleePtr = Builder.CreatePHI(CGF.UnqualPtrTy, 2);
848 llvm::PHINode *DiscriminatorPHI = Builder.CreatePHI(CGF.IntPtrTy, 2);
849 DiscriminatorPHI->addIncoming(llvm::ConstantInt::get(CGF.IntPtrTy, 0),
869 CodeGenFunction &CGF, const Expr *E, Address Base, llvm::Value *MemPtr,
873 CGBuilderTy &Builder = CGF.Builder;
876 return Builder.CreateInBoundsGEP(CGF.Int8Ty, Base.emitRawPointer(CGF), MemPtr,
923 ItaniumCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
934 CGBuilderTy &Builder = CGF.Builder;
947 llvm::BasicBlock *ResignBB = CGF.createBasicBlock("resign");
948 llvm::BasicBlock *MergeBB = CGF.createBasicBlock("merge");
959 CGF.EmitBlock(ResignBB);
963 CGF.emitPointerAuthResign(MemFnPtr, SrcType, CurAuthInfo, NewAuthInfo,
969 CGF.EmitBlock(MergeBB);
1242 ItaniumCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
1247 CGBuilderTy &Builder = CGF.Builder;
1316 ItaniumCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
1319 CGBuilderTy &Builder = CGF.Builder;
1371 void ItaniumCXXABI::emitVirtualObjectDelete(CodeGenFunction &CGF,
1384 llvm::Value *VTable = CGF.GetVTablePtr(Ptr, CGF.UnqualPtrTy, ClassDecl);
1387 llvm::Value *OffsetPtr = CGF.Builder.CreateConstInBoundsGEP1_64(
1388 CGF.IntPtrTy, VTable, -2, "complete-offset.ptr");
1389 llvm::Value *Offset = CGF.Builder.CreateAlignedLoad(CGF.IntPtrTy, OffsetPtr,
1390 CGF.getPointerAlign());
1393 llvm::Value *CompletePtr = Ptr.emitRawPointer(CGF);
1395 CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, CompletePtr, Offset);
1399 CGF.pushCallObjectDeleteCleanup(DE->getOperatorDelete(), CompletePtr,
1406 EmitVirtualDestructorCall(CGF, Dtor, DtorType, Ptr, DE);
1409 CGF.PopCleanupBlock();
1412 void ItaniumCXXABI::emitRethrow(CodeGenFunction &CGF, bool isNoReturn) {
1421 CGF.EmitNoreturnRuntimeCallOrInvoke(Fn, std::nullopt);
1423 CGF.EmitRuntimeCallOrInvoke(Fn);
1446 void ItaniumCXXABI::emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) {
1449 llvm::Type *SizeTy = CGF.ConvertType(getContext().getSizeType());
1453 llvm::CallInst *ExceptionPtr = CGF.EmitNounwindRuntimeCall(
1456 CharUnits ExnAlign = CGF.getContext().getExnObjectAlignment();
1457 CGF.EmitAnyExprToExn(
1485 CGF.EmitNoreturnRuntimeCallOrInvoke(getThrowFn(CGM), args);
1488 static llvm::FunctionCallee getItaniumDynamicCastFn(CodeGenFunction &CGF) {
1494 llvm::Type *Int8PtrTy = CGF.Int8PtrTy;
1495 llvm::Type *GlobInt8PtrTy = CGF.GlobalsInt8PtrTy;
1497 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1504 llvm::AttrBuilder FuncAttrs(CGF.getLLVMContext());
1509 CGF.getLLVMContext(), llvm::AttributeList::FunctionIndex, FuncAttrs);
1511 return CGF.CGM.CreateRuntimeFunction(FTy, "__dynamic_cast", Attrs);
1514 static llvm::FunctionCallee getBadCastFn(CodeGenFunction &CGF) {
1516 llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
1517 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_cast");
1572 static llvm::FunctionCallee getBadTypeidFn(CodeGenFunction &CGF) {
1574 llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
1576 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_typeid");
1583 void ItaniumCXXABI::EmitBadTypeidCall(CodeGenFunction &CGF) {
1584 llvm::FunctionCallee Fn = getBadTypeidFn(CGF);
1585 llvm::CallBase *Call = CGF.EmitRuntimeCallOrInvoke(Fn);
1587 CGF.Builder.CreateUnreachable();
1590 llvm::Value *ItaniumCXXABI::EmitTypeid(CodeGenFunction &CGF,
1596 llvm::Value *Value = CGF.GetVTablePtr(ThisPtr, CGM.GlobalsInt8PtrTy,
1601 Value = CGF.Builder.CreateCall(
1607 CGF.Builder.CreateConstInBoundsGEP1_64(StdTypeInfoPtrTy, Value, -1ULL);
1609 return CGF.Builder.CreateAlignedLoad(StdTypeInfoPtrTy, Value,
1610 CGF.getPointerAlign());
1619 CodeGenFunction &CGF, Address ThisAddr, QualType SrcRecordTy,
1622 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1625 CGF.CGM.GetAddrOfRTTIDescriptor(SrcRecordTy.getUnqualifiedType());
1627 CGF.CGM.GetAddrOfRTTIDescriptor(DestRecordTy.getUnqualifiedType());
1634 computeOffsetHint(CGF.getContext(), SrcDecl, DestDecl).getQuantity());
1637 llvm::Value *Value = ThisAddr.emitRawPointer(CGF);
1645 CGF.GetVTablePtr(ThisAddr, CGM.Int8PtrTy, SrcDecl,
1652 Value = CGF.EmitNounwindRuntimeCall(getItaniumDynamicCastFn(CGF), args);
1658 CGF.createBasicBlock("dynamic_cast.bad_cast");
1660 llvm::Value *IsNull = CGF.Builder.CreateIsNull(Value);
1661 CGF.Builder.CreateCondBr(IsNull, BadCastBlock, CastEnd);
1663 CGF.EmitBlock(BadCastBlock);
1664 EmitBadCastCall(CGF);
1671 CodeGenFunction &CGF, Address ThisAddr, QualType SrcRecordTy,
1715 ThisAddr = Address(emitDynamicCastToVoid(CGF, ThisAddr, SrcRecordTy),
1716 CGF.VoidPtrTy, ThisAddr.getAlignment());
1725 CGF.EmitBranch(CastFail);
1726 return llvm::PoisonValue::get(CGF.VoidPtrTy);
1733 llvm::Instruction *VPtr = CGF.Builder.CreateLoad(
1734 ThisAddr.withElementType(CGF.VoidPtrPtrTy), "vtable");
1736 VPtr, CGM.getTBAAVTablePtrAccessInfo(CGF.VoidPtrPtrTy));
1737 llvm::Value *Success = CGF.Builder.CreateICmpEQ(
1739 llvm::Value *Result = ThisAddr.emitRawPointer(CGF);
1741 Result = CGF.Builder.CreateInBoundsGEP(
1742 CGF.CharTy, Result,
1743 {llvm::ConstantInt::get(CGF.PtrDiffTy, -Offset->getQuantity())});
1744 CGF.Builder.CreateCondBr(Success, CastSuccess, CastFail);
1748 llvm::Value *ItaniumCXXABI::emitDynamicCastToVoid(CodeGenFunction &CGF,
1757 CGF.GetVTablePtr(ThisAddr, CGF.UnqualPtrTy, ClassDecl);
1761 CGF.Builder.CreateConstInBoundsGEP1_32(CGM.Int32Ty, VTable, -2U);
1762 OffsetToTop = CGF.Builder.CreateAlignedLoad(
1766 CGF.ConvertType(CGF.getContext().getPointerDiffType());
1770 CGF.GetVTablePtr(ThisAddr, CGF.UnqualPtrTy, ClassDecl);
1774 CGF.Builder.CreateConstInBoundsGEP1_64(PtrDiffLTy, VTable, -2ULL);
1775 OffsetToTop = CGF.Builder.CreateAlignedLoad(
1776 PtrDiffLTy, OffsetToTop, CGF.getPointerAlign(), "offset.to.top");
1779 return CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, ThisAddr.emitRawPointer(CGF),
1783 bool ItaniumCXXABI::EmitBadCastCall(CodeGenFunction &CGF) {
1784 llvm::FunctionCallee Fn = getBadCastFn(CGF);
1785 llvm::CallBase *Call = CGF.EmitRuntimeCallOrInvoke(Fn);
1787 CGF.Builder.CreateUnreachable();
1792 ItaniumCXXABI::GetVirtualBaseClassOffset(CodeGenFunction &CGF,
1796 llvm::Value *VTablePtr = CGF.GetVTablePtr(This, CGM.Int8PtrTy, ClassDecl);
1801 CGF.Builder.CreateConstGEP1_64(
1802 CGF.Int8Ty, VTablePtr, VBaseOffsetOffset.getQuantity(),
1807 VBaseOffset = CGF.Builder.CreateAlignedLoad(
1808 CGF.Int32Ty, VBaseOffsetPtr, CharUnits::fromQuantity(4),
1811 VBaseOffset = CGF.Builder.CreateAlignedLoad(
1812 CGM.PtrDiffTy, VBaseOffsetPtr, CGF.getPointerAlign(), "vbase.offset");
1870 void ItaniumCXXABI::addImplicitStructorParams(CodeGenFunction &CGF,
1873 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
1877 if (NeedsVTTParameter(CGF.CurGD)) {
1888 getStructorImplicitParamDecl(CGF) = VTTDecl;
1892 void ItaniumCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
1894 if (CGF.CurFuncDecl && CGF.CurFuncDecl->hasAttr<NakedAttr>())
1899 setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF));
1902 if (getStructorImplicitParamDecl(CGF)) {
1903 getStructorImplicitParamValue(CGF) = CGF.Builder.CreateLoad(
1904 CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)), "vtt");
1915 if (HasThisReturn(CGF.CurGD))
1916 CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
1920 CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type,
1929 CGF.GetVTTParameter(GlobalDecl(D, Type), ForVirtualBase, Delegating);
1937 CodeGenFunction &CGF, const CXXDestructorDecl *DD, CXXDtorType Type,
1940 return CGF.GetVTTParameter(GD, ForVirtualBase, Delegating);
1943 void ItaniumCXXABI::EmitDestructorCall(CodeGenFunction &CGF,
1950 getCXXDestructorImplicitParam(CGF, DD, Type, ForVirtualBase, Delegating);
1956 Callee = CGF.BuildAppleKextVirtualDestructorCall(DD, Type, DD->getParent());
1960 CGF.EmitCXXDestructorCall(GD, Callee, CGF.getAsNaturalPointerTo(This, ThisTy),
2062 CodeGenFunction &CGF, CodeGenFunction::VPtr Vptr) {
2065 return NeedsVTTParameter(CGF.CurGD);
2069 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
2073 NeedsVTTParameter(CGF.CurGD)) {
2074 return getVTableAddressPointInStructorWithVTT(CGF, VTableClass, Base,
2111 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
2114 NeedsVTTParameter(CGF.CurGD) && "This class doesn't have VTT");
2121 llvm::Value *VTT = CGF.LoadCXXVTT();
2123 VTT = CGF.Builder.CreateConstInBoundsGEP1_64(CGF.GlobalsVoidPtrTy, VTT,
2128 CGF.Builder.CreateAlignedLoad(CGF.GlobalsVoidPtrTy, VTT,
2129 CGF.getPointerAlign());
2131 if (auto &Schema = CGF.CGM.getCodeGenOpts().PointerAuth.CXXVTTVTablePointers) {
2132 CGPointerAuthInfo PointerAuth = CGF.EmitPointerAuthInfo(Schema, VTT,
2135 AP = CGF.EmitPointerAuthAuth(PointerAuth, AP);
2180 CGCallee ItaniumCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF,
2187 llvm::Value *VTable = CGF.GetVTablePtr(This, PtrTy, MethodDecl->getParent());
2192 if (!Schema && CGF.ShouldEmitVTableTypeCheckedLoad(MethodDecl->getParent())) {
2193 VFunc = CGF.EmitVTableTypeCheckedLoad(
2199 CGF.EmitTypeMetadataCodeForVCall(MethodDecl->getParent(), VTable, Loc);
2203 VFuncLoad = CGF.Builder.CreateCall(
2207 VTableSlotPtr = CGF.Builder.CreateConstInBoundsGEP1_64(
2209 VFuncLoad = CGF.Builder.CreateAlignedLoad(PtrTy, VTableSlotPtr,
2210 CGF.getPointerAlign());
2235 PointerAuth = CGF.EmitPointerAuthInfo(Schema, VTableSlotPtr, GD, QualType());
2242 CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType,
2253 llvm::FunctionType *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
2263 CGF.EmitCXXDestructorCall(GD, Callee, This.emitRawPointer(CGF), ThisTy,
2334 static llvm::Value *performTypeAdjustment(CodeGenFunction &CGF,
2341 return InitialPtr.emitRawPointer(CGF);
2343 Address V = InitialPtr.withElementType(CGF.Int8Ty);
2347 V = CGF.Builder.CreateConstInBoundsByteGEP(V,
2355 CGF.GetVTablePtr(V, CGF.Int8PtrTy, UnadjustedClass);
2358 llvm::Value *OffsetPtr = CGF.Builder.CreateConstInBoundsGEP1_64(
2359 CGF.Int8Ty, VTablePtr, VirtualAdjustment);
2360 if (CGF.CGM.getItaniumVTableContext().isRelativeLayout()) {
2363 CGF.Builder.CreateAlignedLoad(CGF.Int32Ty, OffsetPtr,
2367 CGF.ConvertType(CGF.getContext().getPointerDiffType());
2370 Offset = CGF.Builder.CreateAlignedLoad(PtrDiffTy, OffsetPtr,
2371 CGF.getPointerAlign());
2374 ResultPtr = CGF.Builder.CreateInBoundsGEP(V.getElementType(),
2375 V.emitRawPointer(CGF), Offset);
2377 ResultPtr = V.emitRawPointer(CGF);
2383 ResultPtr = CGF.Builder.CreateConstInBoundsGEP1_64(CGF.Int8Ty, ResultPtr,
2391 ItaniumCXXABI::performThisAdjustment(CodeGenFunction &CGF, Address This,
2394 return performTypeAdjustment(CGF, This, UnadjustedClass, TI.This.NonVirtual,
2400 ItaniumCXXABI::performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
2403 return performTypeAdjustment(CGF, Ret, UnadjustedClass, RA.NonVirtual,
2408 void ARMCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
2410 if (!isa<CXXDestructorDecl>(CGF.CurGD.getDecl()))
2411 return ItaniumCXXABI::EmitReturnFromThunk(CGF, RV, ResultType);
2414 llvm::Type *T = CGF.ReturnValue.getElementType();
2416 return ItaniumCXXABI::EmitReturnFromThunk(CGF, Undef, ResultType);
2428 Address ItaniumCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
2438 CharUnits SizeSize = CGF.getSizeSize();
2449 CookiePtr = CGF.Builder.CreateConstInBoundsByteGEP(CookiePtr, CookieOffset);
2452 Address NumElementsPtr = CookiePtr.withElementType(CGF.SizeTy);
2453 llvm::Instruction *SI = CGF.Builder.CreateStore(NumElements, NumElementsPtr);
2465 CGF.Builder.CreateCall(F, NumElementsPtr.emitRawPointer(CGF));
2470 return CGF.Builder.CreateConstInBoundsByteGEP(NewPtr, CookieSize);
2473 llvm::Value *ItaniumCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
2478 CharUnits numElementsOffset = cookieSize - CGF.getSizeSize();
2481 CGF.Builder.CreateConstInBoundsByteGEP(numElementsPtr, numElementsOffset);
2484 numElementsPtr = numElementsPtr.withElementType(CGF.SizeTy);
2486 return CGF.Builder.CreateLoad(numElementsPtr);
2493 llvm::FunctionType::get(CGF.SizeTy, CGF.UnqualPtrTy, false);
2496 return CGF.Builder.CreateCall(F, numElementsPtr.emitRawPointer(CGF));
2512 Address ARMCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
2523 cookie = cookie.withElementType(CGF.SizeTy);
2524 llvm::Value *elementSize = llvm::ConstantInt::get(CGF.SizeTy,
2526 CGF.Builder.CreateStore(elementSize, cookie);
2529 cookie = CGF.Builder.CreateConstInBoundsGEP(cookie, 1);
2530 CGF.Builder.CreateStore(numElements, cookie);
2535 return CGF.Builder.CreateConstInBoundsByteGEP(newPtr, cookieSize);
2538 llvm::Value *ARMCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
2544 = CGF.Builder.CreateConstInBoundsByteGEP(allocPtr, CGF.getSizeSize());
2546 numElementsPtr = numElementsPtr.withElementType(CGF.SizeTy);
2547 return CGF.Builder.CreateLoad(numElementsPtr);
2594 void Emit(CodeGenFunction &CGF, Flags flags) override {
2595 CGF.EmitNounwindRuntimeCall(getGuardAbortFn(CGF.CGM, Guard->getType()),
2603 void ItaniumCXXABI::EmitGuardedInit(CodeGenFunction &CGF,
2607 CGBuilderTy &Builder = CGF.Builder;
2629 guardTy = CGF.Int8Ty;
2635 guardTy = CGF.SizeTy;
2636 guardAlignment = CGF.getSizeAlign();
2638 guardTy = CGF.Int64Ty;
2644 CGF.CGM.getLLVMContext(),
2645 CGF.CGM.getDataLayout().getDefaultGlobalsAddressSpace());
2710 unsigned MaxInlineWidthInBits = CGF.getTarget().getMaxAtomicInlineWidth();
2711 llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end");
2752 llvm::BasicBlock *InitCheckBlock = CGF.createBasicBlock("init.check");
2755 CGF.EmitCXXGuardedInitBranch(NeedsInit, InitCheckBlock, EndBlock,
2758 CGF.EmitBlock(InitCheckBlock);
2780 = CGF.EmitNounwindRuntimeCall(getGuardAcquireFn(CGM, guardPtrTy), guard);
2782 llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
2788 CGF.EHStack.pushCleanup<CallGuardAbort>(EHCleanup, guard);
2790 CGF.EmitBlock(InitBlock);
2800 CGF.EmitCXXGlobalVarDeclInit(D, var, shouldPerformInit);
2804 CGF.PopCleanupBlock();
2807 CGF.EmitNounwindRuntimeCall(getGuardReleaseFn(CGM, guardPtrTy),
2808 guardAddr.emitRawPointer(CGF));
2817 CGF.EmitBlock(EndBlock);
2821 static void emitGlobalDtorWithCXAAtExit(CodeGenFunction &CGF,
2824 assert(!CGF.getTarget().getTriple().isOSAIX() &&
2826 assert((TLS || CGF.getTypes().getCodeGenOpts().CXAAtExit) &&
2830 const llvm::Triple &T = CGF.getTarget().getTriple();
2836 llvm::Type *dtorTy = CGF.UnqualPtrTy;
2840 auto AddrPtrTy = AddrAS ? llvm::PointerType::get(CGF.getLLVMContext(), AddrAS)
2841 : CGF.Int8PtrTy;
2845 CGF.CGM.CreateRuntimeVariable(CGF.Int8Ty, "__dso_handle");
2852 llvm::FunctionType::get(CGF.IntTy, paramTys, false);
2855 llvm::FunctionCallee atexit = CGF.CGM.CreateRuntimeFunction(atexitTy, Name);
2859 const auto &Context = CGF.CGM.getContext();
2865 dtorCallee = CGF.CGM.getFunctionPointer(dtorCallee, fnType);
2872 addr = llvm::Constant::getNullValue(CGF.Int8PtrTy);
2875 CGF.EmitNounwindRuntimeCall(atexit, args);
2898 CodeGenFunction CGF(*this);
2899 CGF.StartFunction(GlobalDecl(), getContext().VoidTy, GlobalCleanupFn,
2902 auto AL = ApplyDebugLocation::CreateArtificial(CGF);
2905 llvm::FunctionType *dtorFuncTy = llvm::FunctionType::get(CGF.VoidTy, false);
2916 llvm::Value *V = CGF.unregisterGlobalDtorWithUnAtExit(Dtor);
2918 CGF.Builder.CreateIsNull(V, "needs_destruct");
2921 CGF.createBasicBlock("destruct.call");
2922 llvm::BasicBlock *EndBlock = CGF.createBasicBlock(
2926 CGF.Builder.CreateCondBr(NeedsDestruct, DestructCallBlock, EndBlock);
2928 CGF.EmitBlock(DestructCallBlock);
2931 llvm::CallInst *CI = CGF.Builder.CreateCall(dtorFuncTy, Dtor);
2935 CGF.EmitBlock(EndBlock);
2940 CGF.FinishFunction();
2953 CodeGenFunction CGF(*this);
2954 CGF.StartFunction(GlobalDecl(), getContext().VoidTy, GlobalInitFn,
2957 auto AL = ApplyDebugLocation::CreateArtificial(CGF);
2969 emitGlobalDtorWithCXAAtExit(CGF, Dtor, nullptr, false);
2973 CGF.registerGlobalDtorWithAtExit(Dtor);
2977 CGF.FinishFunction();
2986 void ItaniumCXXABI::registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
2998 return CGF.registerGlobalDtorWithLLVM(D, dtor, addr);
3005 return emitGlobalDtorWithCXAAtExit(CGF, dtor, addr, D.getTLSKind());
3014 CGF.registerGlobalDtorWithAtExit(D, dtor, addr);
3298 LValue ItaniumCXXABI::EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,
3301 llvm::Value *Val = CGF.CGM.GetAddrOfGlobalVar(VD);
3304 llvm::CallInst *CallVal = CGF.Builder.CreateCall(Wrapper);
3309 LV = CGF.MakeNaturalAlignRawAddrLValue(CallVal, LValType);
3311 LV = CGF.MakeRawAddrLValue(CallVal, LValType,
3312 CGF.getContext().getDeclAlign(VD));
3369 CodeGenFunction CGF(CGM);
3370 CGF.CurGD = GlobalDecl(MD);
3371 CGF.CurFuncIsThunk = true;
3375 CGF.BuildFunctionArgList(CGF.CurGD, FunctionArgs);
3377 CGF.StartFunction(GlobalDecl(), FnInfo.getReturnType(), ThunkFn, FnInfo,
3379 llvm::Value *ThisVal = loadIncomingCXXThis(CGF);
3380 setCXXABIThisValue(CGF, ThisVal);
3384 CGF.EmitDelegateCallArg(CallArgs, VD, SourceLocation());
3391 getThisAddress(CGF), ThunkTy);
3393 CGF.EmitCall(CallInfo, Callee, ReturnValueSlot(), CallArgs, &CallOrInvoke,
3398 CGF.Builder.CreateRetVoid();
3400 CGF.Builder.CreateRet(Call);
3404 CGF.EmitBlock(CGF.createBasicBlock());
3405 CGF.FinishFunction();
4779 void Emit(CodeGenFunction &CGF, Flags flags) override {
4781 CGF.EmitNounwindRuntimeCall(getEndCatchFn(CGF.CGM));
4785 CGF.EmitRuntimeCallOrInvoke(getEndCatchFn(CGF.CGM));
4796 static llvm::Value *CallBeginCatch(CodeGenFunction &CGF,
4800 CGF.EmitNounwindRuntimeCall(getBeginCatchFn(CGF.CGM), Exn);
4802 CGF.EHStack.pushCleanup<CallEndCatch>(
4804 EndMightThrow && !CGF.CGM.getLangOpts().AssumeNothrowExceptionDtor);
4811 static void InitCatchParam(CodeGenFunction &CGF,
4816 llvm::Value *Exn = CGF.getExceptionFromSlot();
4819 CGF.CGM.getContext().getCanonicalType(CatchParam.getType());
4820 llvm::Type *LLVMCatchTy = CGF.ConvertTypeForMem(CatchType);
4829 llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, EndCatchMightThrow);
4844 CGF.CGM.getTargetCodeGenInfo().getSizeOfUnwindException();
4846 CGF.Builder.CreateConstGEP1_32(CGF.Int8Ty, Exn, HeaderSize);
4864 llvm::Type *PtrTy = CGF.ConvertTypeForMem(CaughtType);
4868 CGF.CreateTempAlloca(PtrTy, CGF.getPointerAlign(), "exn.byref.tmp");
4869 llvm::Value *Casted = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
4870 CGF.Builder.CreateStore(Casted, ExnPtrTmp);
4873 AdjustedExn = ExnPtrTmp.emitRawPointer(CGF);
4878 CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.byref");
4879 CGF.Builder.CreateStore(ExnCast, ParamAddr);
4884 TypeEvaluationKind TEK = CGF.getEvaluationKind(CatchType);
4886 llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, false);
4892 CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.casted");
4896 CastExn = CGF.EmitARCRetainNonBlock(CastExn);
4902 CGF.Builder.CreateStore(CastExn, ParamAddr);
4906 CGF.EmitARCInitWeak(ParamAddr, CastExn);
4914 LValue srcLV = CGF.MakeNaturalAlignAddrLValue(AdjustedExn, CatchType);
4915 LValue destLV = CGF.MakeAddrLValue(ParamAddr, CatchType);
4918 CGF.EmitStoreOfComplex(CGF.EmitLoadOfComplex(srcLV, Loc), destLV,
4922 llvm::Value *ExnLoad = CGF.EmitLoadOfScalar(srcLV, Loc);
4923 CGF.EmitStoreOfScalar(ExnLoad, destLV, /*init*/ true);
4934 CharUnits caughtExnAlignment = CGF.CGM.getClassPointerAlignment(catchRD);
4936 llvm::Type *PtrTy = CGF.UnqualPtrTy; // addrspace 0 ok
4942 llvm::Value *rawAdjustedExn = CallBeginCatch(CGF, Exn, true);
4943 Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
4945 LValue Dest = CGF.MakeAddrLValue(ParamAddr, CatchType);
4946 LValue Src = CGF.MakeAddrLValue(adjustedExn, CatchType);
4947 CGF.EmitAggregateCopy(Dest, Src, CatchType, AggValueSlot::DoesNotOverlap);
4954 CGF.EmitNounwindRuntimeCall(getGetExceptionPtrFn(CGF.CGM), Exn);
4957 Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
4963 opaque(CGF, OpaqueValueExpr::findInCopyConstruct(copyExpr),
4964 CGF.MakeAddrLValue(adjustedExn, CatchParam.getType()));
4967 CGF.EHStack.pushTerminate();
4970 CGF.EmitAggExpr(copyExpr,
4978 CGF.EHStack.popTerminate();
4984 CallBeginCatch(CGF, Exn, true);
4989 void ItaniumCXXABI::emitBeginCatch(CodeGenFunction &CGF,
5016 llvm::Value *Exn = CGF.getExceptionFromSlot();
5017 CallBeginCatch(CGF, Exn, true);
5022 CodeGenFunction::AutoVarEmission var = CGF.EmitAutoVarAlloca(*CatchParam);
5023 InitCatchParam(CGF, *CatchParam, var.getObjectAddress(CGF), S->getBeginLoc());
5024 CGF.EmitAutoVarCleanups(var);
5083 ItaniumCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
5087 assert(CGF.CGM.getLangOpts().CPlusPlus);
5088 return CGF.EmitNounwindRuntimeCall(getClangCallTerminateFn(CGF.CGM), Exn);
5090 return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn());
5094 ItaniumCXXABI::LoadVTablePtr(CodeGenFunction &CGF, Address This,
5096 return {CGF.GetVTablePtr(This, CGM.Int8PtrTy, RD), RD};
5111 void WebAssemblyCXXABI::emitBeginCatch(CodeGenFunction &CGF,
5113 if (CGF.getTarget().hasFeature("exception-handling"))
5114 CGF.EHStack.pushCleanup<CatchRetScope>(
5115 NormalCleanup, cast<llvm::CatchPadInst>(CGF.CurrentFuncletPad));
5116 ItaniumCXXABI::emitBeginCatch(CGF, C);
5120 WebAssemblyCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
5128 return CGCXXABI::emitTerminateForUnexpectedException(CGF, Exn);
5132 void XLCXXABI::registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
5136 llvm::PointerType *PtrTy = CGF.UnqualPtrTy;
5147 llvm::Function *DtorStub = CGF.createTLSAtExitStub(D, Dtor, Addr, AtExit);
5152 CGF.EmitNounwindRuntimeCall(AtExit, {NV, DtorStub});
5160 cast<llvm::Function>(CGF.createAtExitStub(D, Dtor, Addr));
5163 CGF.registerGlobalDtorWithAtExit(DtorStub);
5184 CodeGenFunction CGF(CGM);
5186 CGF.StartFunction(GlobalDecl(), CGM.getContext().VoidTy, StermFinalizer, FI,
5194 llvm::Value *V = CGF.unregisterGlobalDtorWithUnAtExit(dtorStub);
5196 llvm::Value *NeedsDestruct = CGF.Builder.CreateIsNull(V, "needs_destruct");
5198 llvm::BasicBlock *DestructCallBlock = CGF.createBasicBlock("destruct.call");
5199 llvm::BasicBlock *EndBlock = CGF.createBasicBlock("destruct.end");
5203 CGF.Builder.CreateCondBr(NeedsDestruct, DestructCallBlock, EndBlock);
5205 CGF.EmitBlock(DestructCallBlock);
5208 llvm::CallInst *CI = CGF.Builder.CreateCall(dtorStub);
5213 CGF.EmitBlock(EndBlock);
5215 CGF.FinishFunction();