Lines Matching defs:CGF
121 void emitVirtualObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE,
125 void emitRethrow(CodeGenFunction &CGF, bool isNoReturn) override;
126 void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) override;
128 void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) override;
148 void EmitBadTypeidCall(CodeGenFunction &CGF) override;
149 llvm::Value *EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy,
160 llvm::Value *emitExactDynamicCast(CodeGenFunction &CGF, Address Value,
168 llvm::Value *emitDynamicCastCall(CodeGenFunction &CGF, Address Value,
173 llvm::Value *emitDynamicCastToVoid(CodeGenFunction &CGF, Address Value,
176 bool EmitBadCastCall(CodeGenFunction &CGF) override;
182 GetVirtualBaseClassOffset(CodeGenFunction &CGF, Address This,
187 EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,
191 EmitDtorCompleteObjectHandler(CodeGenFunction &CGF);
193 void initializeHiddenVirtualInheritanceMembers(CodeGenFunction &CGF,
281 adjustThisArgumentForVirtualFunctionCall(CodeGenFunction &CGF, GlobalDecl GD,
285 void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy,
288 void EmitInstanceFunctionProlog(CodeGenFunction &CGF) override;
290 AddedStructorArgs getImplicitConstructorArgs(CodeGenFunction &CGF,
296 llvm::Value *getCXXDestructorImplicitParam(CodeGenFunction &CGF,
302 void EmitDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *DD,
313 bool isVirtualOffsetNeededForVTableField(CodeGenFunction &CGF,
327 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass,
333 CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD,
338 EmitVirtualDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *Dtor,
343 void adjustCallArgsForDestructorThunk(CodeGenFunction &CGF, GlobalDecl GD,
347 CallArgs.add(RValue::get(getStructorImplicitParamValue(CGF)),
418 llvm::Value *performThisAdjustment(CodeGenFunction &CGF, Address This,
422 llvm::Value *performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
437 LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD,
440 void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
443 void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
474 Address InitializeArrayCookie(CodeGenFunction &CGF,
479 llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF,
611 llvm::Value *GetVBaseOffsetFromVBPtr(CodeGenFunction &CGF,
617 llvm::Value *GetVBaseOffsetFromVBPtr(CodeGenFunction &CGF,
625 return GetVBaseOffsetFromVBPtr(CGF, Base, VBPOffset, VBTOffset, VBPtr);
629 performBaseAdjustment(CodeGenFunction &CGF, Address Value,
634 llvm::Value *AdjustVirtualBase(CodeGenFunction &CGF, const Expr *E,
651 void EmitVBPtrStores(CodeGenFunction &CGF, const CXXRecordDecl *RD);
680 llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF,
686 llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
691 EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
701 llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,
714 EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, const Expr *E,
799 LoadVTablePtr(CodeGenFunction &CGF, Address This,
889 void MicrosoftCXXABI::emitVirtualObjectDelete(CodeGenFunction &CGF,
898 llvm::Value *MDThis = EmitVirtualDestructorCall(CGF, Dtor, DtorType, Ptr, DE,
901 CGF.EmitDeleteCall(DE->getOperatorDelete(), MDThis, ElementType);
904 void MicrosoftCXXABI::emitRethrow(CodeGenFunction &CGF, bool isNoReturn) {
909 CGF.EmitNoreturnRuntimeCallOrInvoke(Fn, Args);
911 CGF.EmitRuntimeCallOrInvoke(Fn, Args);
914 void MicrosoftCXXABI::emitBeginCatch(CodeGenFunction &CGF,
919 llvm::BasicBlock *CatchPadBB = CGF.Builder.GetInsertBlock();
922 CGF.CurrentFuncletPad = CPI;
927 CGF.EHStack.pushCleanup<CatchRetScope>(NormalCleanup, CPI);
931 CodeGenFunction::AutoVarEmission var = CGF.EmitAutoVarAlloca(*CatchParam);
932 CPI->setArgOperand(2, var.getObjectAddress(CGF).emitRawPointer(CGF));
933 CGF.EHStack.pushCleanup<CatchRetScope>(NormalCleanup, CPI);
934 CGF.EmitAutoVarCleanups(var);
941 MicrosoftCXXABI::performBaseAdjustment(CodeGenFunction &CGF, Address Value,
943 Value = Value.withElementType(CGF.Int8Ty);
951 return std::make_tuple(Value, llvm::ConstantInt::get(CGF.Int32Ty, 0),
967 GetVirtualBaseClassOffset(CGF, Value, SrcDecl, PolymorphicBase);
968 llvm::Value *Ptr = CGF.Builder.CreateInBoundsGEP(
969 Value.getElementType(), Value.emitRawPointer(CGF), Offset);
971 CGF.CGM.getVBaseAlignment(Value.getAlignment(), SrcDecl, PolymorphicBase);
972 return std::make_tuple(Address(Ptr, CGF.Int8Ty, VBaseAlign), Offset,
981 static llvm::CallBase *emitRTtypeidCall(CodeGenFunction &CGF,
983 llvm::Type *ArgTypes[] = {CGF.Int8PtrTy};
985 llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false);
987 llvm::FunctionCallee Fn = CGF.CGM.CreateRuntimeFunction(FTy, "__RTtypeid");
988 return CGF.EmitRuntimeCallOrInvoke(Fn, Args);
991 void MicrosoftCXXABI::EmitBadTypeidCall(CodeGenFunction &CGF) {
993 emitRTtypeidCall(CGF, llvm::Constant::getNullValue(CGM.VoidPtrTy));
995 CGF.Builder.CreateUnreachable();
998 llvm::Value *MicrosoftCXXABI::EmitTypeid(CodeGenFunction &CGF,
1003 performBaseAdjustment(CGF, ThisPtr, SrcRecordTy);
1004 llvm::CallBase *Typeid = emitRTtypeidCall(CGF, ThisPtr.emitRawPointer(CGF));
1005 return CGF.Builder.CreateBitCast(Typeid, StdTypeInfoPtrTy);
1016 CodeGenFunction &CGF, Address This, QualType SrcRecordTy, QualType DestTy,
1019 CGF.CGM.GetAddrOfRTTIDescriptor(SrcRecordTy.getUnqualifiedType());
1021 CGF.CGM.GetAddrOfRTTIDescriptor(DestRecordTy.getUnqualifiedType());
1025 performBaseAdjustment(CGF, This, SrcRecordTy);
1026 llvm::Value *ThisPtr = This.emitRawPointer(CGF);
1027 Offset = CGF.Builder.CreateTrunc(Offset, CGF.Int32Ty);
1035 llvm::Type *ArgTypes[] = {CGF.Int8PtrTy, CGF.Int32Ty, CGF.Int8PtrTy,
1036 CGF.Int8PtrTy, CGF.Int32Ty};
1037 llvm::FunctionCallee Function = CGF.CGM.CreateRuntimeFunction(
1038 llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false),
1042 llvm::ConstantInt::get(CGF.Int32Ty, DestTy->isReferenceType())};
1043 return CGF.EmitRuntimeCallOrInvoke(Function, Args);
1046 llvm::Value *MicrosoftCXXABI::emitDynamicCastToVoid(CodeGenFunction &CGF,
1050 performBaseAdjustment(CGF, Value, SrcRecordTy);
1054 llvm::Type *ArgTypes[] = {CGF.Int8PtrTy};
1055 llvm::FunctionCallee Function = CGF.CGM.CreateRuntimeFunction(
1056 llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false),
1058 llvm::Value *Args[] = {Value.emitRawPointer(CGF)};
1059 return CGF.EmitRuntimeCall(Function, Args);
1062 bool MicrosoftCXXABI::EmitBadCastCall(CodeGenFunction &CGF) {
1067 CodeGenFunction &CGF, Address This, const CXXRecordDecl *ClassDecl,
1081 GetVBaseOffsetFromVBPtr(CGF, This, VBPtrOffset, VBTableOffset);
1083 CGF.Builder.CreateSExtOrBitCast(VBPtrToNewBase, CGM.PtrDiffTy);
1084 return CGF.Builder.CreateNSWAdd(VBPtrOffset, VBPtrToNewBase);
1192 MicrosoftCXXABI::EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,
1194 llvm::Value *IsMostDerivedClass = getStructorImplicitParamValue(CGF);
1198 CGF.Builder.CreateIsNotNull(IsMostDerivedClass, "is_complete_object");
1200 llvm::BasicBlock *CallVbaseCtorsBB = CGF.createBasicBlock("ctor.init_vbases");
1201 llvm::BasicBlock *SkipVbaseCtorsBB = CGF.createBasicBlock("ctor.skip_vbases");
1202 CGF.Builder.CreateCondBr(IsCompleteObject,
1205 CGF.EmitBlock(CallVbaseCtorsBB);
1208 EmitVBPtrStores(CGF, RD);
1210 // CGF will put the base ctor calls in this basic block for us later.
1216 MicrosoftCXXABI::EmitDtorCompleteObjectHandler(CodeGenFunction &CGF) {
1217 llvm::Value *IsMostDerivedClass = getStructorImplicitParamValue(CGF);
1221 CGF.Builder.CreateIsNotNull(IsMostDerivedClass, "is_complete_object");
1223 llvm::BasicBlock *CallVbaseDtorsBB = CGF.createBasicBlock("Dtor.dtor_vbases");
1224 llvm::BasicBlock *SkipVbaseDtorsBB = CGF.createBasicBlock("Dtor.skip_vbases");
1225 CGF.Builder.CreateCondBr(IsCompleteObject,
1228 CGF.EmitBlock(CallVbaseDtorsBB);
1229 // CGF will put the base dtor calls in this basic block for us later.
1235 CodeGenFunction &CGF, const CXXRecordDecl *RD) {
1252 CGBuilderTy &Builder = CGF.Builder;
1264 GetVirtualBaseClassOffset(CGF, getThisAddress(CGF), RD, VBase);
1271 VtorDispValue = Builder.CreateTruncOrBitCast(VtorDispValue, CGF.Int32Ty);
1274 Int8This = getThisValue(CGF);
1277 Builder.CreateInBoundsGEP(CGF.Int8Ty, Int8This, VBaseOffset);
1279 VtorDispPtr = Builder.CreateConstGEP1_32(CGF.Int8Ty, VtorDispPtr, -4);
1313 void MicrosoftCXXABI::EmitVBPtrStores(CodeGenFunction &CGF,
1315 Address This = getThisAddress(CGF);
1330 Address VBPtr = CGF.Builder.CreateConstInBoundsByteGEP(This, Offs);
1332 CGF.Builder.CreateConstInBoundsGEP2_32(GV->getValueType(), GV, 0, 0);
1334 CGF.Builder.CreateStore(GVPtr, VBPtr);
1465 CodeGenFunction &CGF, GlobalDecl GD, Address This,
1474 This = This.withElementType(CGF.Int8Ty);
1476 return CGF.Builder.CreateConstByteGEP(This, Adjustment);
1505 Result = Result.withElementType(CGF.Int8Ty);
1510 GetVirtualBaseClassOffset(CGF, Result, Derived, VBase);
1511 llvm::Value *VBasePtr = CGF.Builder.CreateInBoundsGEP(
1512 Result.getElementType(), Result.emitRawPointer(CGF), VBaseOffset);
1514 CGF.CGM.getVBaseAlignment(Result.getAlignment(), Derived, VBase);
1515 Result = Address(VBasePtr, CGF.Int8Ty, VBaseAlign);
1519 Result = Result.withElementType(CGF.Int8Ty);
1525 Result = CGF.Builder.CreateConstByteGEP(Result, StaticOffset);
1527 Result = CGF.Builder.CreateConstInBoundsByteGEP(Result, StaticOffset);
1533 void MicrosoftCXXABI::addImplicitStructorParams(CodeGenFunction &CGF,
1537 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
1541 Context, /*DC=*/nullptr, CGF.CurGD.getDecl()->getLocation(),
1551 getStructorImplicitParamDecl(CGF) = IsMostDerived;
1552 } else if (isDeletingDtor(CGF.CurGD)) {
1554 Context, /*DC=*/nullptr, CGF.CurGD.getDecl()->getLocation(),
1558 getStructorImplicitParamDecl(CGF) = ShouldDelete;
1562 void MicrosoftCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
1564 if (CGF.CurFuncDecl && CGF.CurFuncDecl->hasAttr<NakedAttr>())
1579 llvm::Value *This = loadIncomingCXXThis(CGF);
1580 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
1581 if (!CGF.CurFuncIsThunk && MD->isVirtual()) {
1582 CharUnits Adjustment = getVirtualFunctionPrologueThisAdjustment(CGF.CurGD);
1585 This = CGF.Builder.CreateConstInBoundsGEP1_32(CGF.Int8Ty, This,
1589 setCXXABIThisValue(CGF, This);
1599 if (HasThisReturn(CGF.CurGD) || hasMostDerivedReturn(CGF.CurGD))
1600 CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
1603 assert(getStructorImplicitParamDecl(CGF) &&
1605 getStructorImplicitParamValue(CGF)
1606 = CGF.Builder.CreateLoad(
1607 CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)),
1611 if (isDeletingDtor(CGF.CurGD)) {
1612 assert(getStructorImplicitParamDecl(CGF) &&
1614 getStructorImplicitParamValue(CGF)
1615 = CGF.Builder.CreateLoad(
1616 CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)),
1622 CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type,
1634 MostDerivedArg = getStructorImplicitParamValue(CGF);
1645 CodeGenFunction &CGF, const CXXDestructorDecl *DD, CXXDtorType Type,
1650 void MicrosoftCXXABI::EmitDestructorCall(CodeGenFunction &CGF,
1667 This = adjustThisArgumentForVirtualFunctionCall(CGF, GlobalDecl(DD, Type),
1672 if (ForVirtualBase && isa<CXXConstructorDecl>(CGF.CurCodeDecl)) {
1673 BaseDtorEndBB = EmitDtorCompleteObjectHandler(CGF);
1677 getCXXDestructorImplicitParam(CGF, DD, Type, ForVirtualBase,
1679 CGF.EmitCXXDestructorCall(GD, Callee, CGF.getAsNaturalPointerTo(This, ThisTy),
1685 CGF.Builder.CreateBr(BaseDtorEndBB);
1686 CGF.EmitBlock(BaseDtorEndBB);
1781 CodeGenFunction &CGF, CodeGenFunction::VPtr Vptr) {
1786 CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
1946 CGCallee MicrosoftCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF,
1951 CGBuilderTy &Builder = CGF.Builder;
1953 Ty = CGF.UnqualPtrTy;
1955 adjustThisArgumentForVirtualFunctionCall(CGF, GD, This, true);
1959 CGF.GetVTablePtr(VPtr, CGF.UnqualPtrTy, MethodDecl->getParent());
1977 if (CGF.ShouldEmitVTableTypeCheckedLoad(MethodDecl->getParent())) {
1978 VFunc = CGF.EmitVTableTypeCheckedLoad(
1985 CGF.EmitTypeMetadataCodeForVCall(getObjectWithVPtr(), VTable, Loc);
1989 VFunc = Builder.CreateAlignedLoad(Ty, VFuncPtr, CGF.getPointerAlign());
1997 CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType,
2010 llvm::FunctionType *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
2015 llvm::IntegerType::getInt32Ty(CGF.getLLVMContext()),
2025 This = adjustThisArgumentForVirtualFunctionCall(CGF, GD, This, true);
2027 CGF.EmitCXXDestructorCall(GD, Callee, This.emitRawPointer(CGF), ThisTy,
2102 CodeGenFunction CGF(CGM);
2103 CGF.CurGD = GlobalDecl(MD);
2104 CGF.CurFuncIsThunk = true;
2109 buildThisParam(CGF, FunctionArgs);
2112 CGF.StartFunction(GlobalDecl(), FnInfo.getReturnType(), ThunkFn, FnInfo,
2115 ApplyDebugLocation AL(CGF, MD->getLocation());
2116 setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF));
2120 llvm::Type *ThunkPtrTy = CGF.UnqualPtrTy;
2122 CGF.GetVTablePtr(getThisAddress(CGF), CGF.UnqualPtrTy, MD->getParent());
2124 llvm::Value *VFuncPtr = CGF.Builder.CreateConstInBoundsGEP1_64(
2127 CGF.Builder.CreateAlignedLoad(ThunkPtrTy, VFuncPtr, CGF.getPointerAlign());
2129 CGF.EmitMustTailThunk(MD, getThisValue(CGF), {ThunkTy, Callee});
2223 CodeGenFunction &CGF, Address This,
2227 return This.emitRawPointer(CGF);
2229 This = This.withElementType(CGF.Int8Ty);
2233 V = This.emitRawPointer(CGF);
2238 CGF.Builder.CreateConstInBoundsByteGEP(This,
2240 VtorDispPtr = VtorDispPtr.withElementType(CGF.Int32Ty);
2241 llvm::Value *VtorDisp = CGF.Builder.CreateLoad(VtorDispPtr, "vtordisp");
2242 V = CGF.Builder.CreateGEP(This.getElementType(), This.emitRawPointer(CGF),
2243 CGF.Builder.CreateNeg(VtorDisp));
2257 CGF, Address(V, CGF.Int8Ty, CGF.getPointerAlign()),
2260 V = CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, VBPtr, VBaseOffset);
2268 V = CGF.Builder.CreateConstGEP1_32(CGF.Int8Ty, V, TA.NonVirtual);
2276 CodeGenFunction &CGF, Address Ret,
2280 return Ret.emitRawPointer(CGF);
2282 Ret = Ret.withElementType(CGF.Int8Ty);
2284 llvm::Value *V = Ret.emitRawPointer(CGF);
2287 int32_t IntSize = CGF.getIntSize().getQuantity();
2290 GetVBaseOffsetFromVBPtr(CGF, Ret, RA.Virtual.Microsoft.VBPtrOffset,
2292 V = CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, VBPtr, VBaseOffset);
2296 V = CGF.Builder.CreateConstInBoundsGEP1_32(CGF.Int8Ty, V, RA.NonVirtual);
2322 llvm::Value *MicrosoftCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
2325 Address numElementsPtr = allocPtr.withElementType(CGF.SizeTy);
2326 return CGF.Builder.CreateLoad(numElementsPtr);
2329 Address MicrosoftCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
2343 Address numElementsPtr = cookiePtr.withElementType(CGF.SizeTy);
2344 CGF.Builder.CreateStore(numElements, numElementsPtr);
2348 return CGF.Builder.CreateConstInBoundsByteGEP(newPtr, cookieSize);
2351 static void emitGlobalDtorWithTLRegDtor(CodeGenFunction &CGF, const VarDecl &VD,
2355 llvm::Constant *DtorStub = CGF.createAtExitStub(VD, Dtor, Addr);
2359 CGF.IntTy, DtorStub->getType(), /*isVarArg=*/false);
2361 llvm::FunctionCallee TLRegDtor = CGF.CGM.CreateRuntimeFunction(
2367 CGF.EmitNounwindRuntimeCall(TLRegDtor, DtorStub);
2370 void MicrosoftCXXABI::registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
2377 return emitGlobalDtorWithTLRegDtor(CGF, D, Dtor, Addr);
2384 CGF.registerGlobalDtorWithAtExit(D, Dtor, Addr);
2468 static void emitTlsGuardCheck(CodeGenFunction &CGF, llvm::GlobalValue *TlsGuard,
2472 CGF.Builder.CreateLoad(Address(TlsGuard, CGF.Int8Ty, CharUnits::One()));
2474 CGF.Builder.CreateICmpEQ(TlsGuardValue, CGF.Builder.getInt8(0));
2475 CGF.Builder.CreateCondBr(CmpResult, DynInitBB, ContinueBB);
2478 static void emitDynamicTlsInitializationCall(CodeGenFunction &CGF,
2481 llvm::FunctionCallee Initializer = getDynTlsOnDemandInitFn(CGF.CGM);
2484 llvm::CallInst *CallVal = CGF.Builder.CreateCall(InitializerFunction);
2487 CGF.Builder.CreateBr(ContinueBB);
2490 static void emitDynamicTlsInitialization(CodeGenFunction &CGF) {
2492 CGF.createBasicBlock("dyntls.dyn_init", CGF.CurFn);
2494 CGF.createBasicBlock("dyntls.continue", CGF.CurFn);
2496 llvm::GlobalValue *TlsGuard = getTlsGuardVar(CGF.CGM);
2498 emitTlsGuardCheck(CGF, TlsGuard, DynInitBB, ContinueBB);
2499 CGF.Builder.SetInsertPoint(DynInitBB);
2500 emitDynamicTlsInitializationCall(CGF, TlsGuard, ContinueBB);
2501 CGF.Builder.SetInsertPoint(ContinueBB);
2504 LValue MicrosoftCXXABI::EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,
2512 emitDynamicTlsInitialization(CGF);
2516 llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD);
2517 llvm::Type *RealVarTy = CGF.getTypes().ConvertTypeForMem(VD->getType());
2519 CharUnits Alignment = CGF.getContext().getDeclAlign(VD);
2523 ? CGF.EmitLoadOfReferenceLValue(Addr, VD->getType(),
2525 : CGF.MakeAddrLValue(Addr, LValType, AlignmentSource::Decl);
2586 void Emit(CodeGenFunction &CGF, Flags flags) override {
2589 CGBuilderTy &Builder = CGF.Builder;
2592 llvm::ConstantInt::get(CGF.IntTy, ~(1ULL << GuardNum));
2601 void Emit(CodeGenFunction &CGF, Flags flags) override {
2603 CGF.EmitNounwindRuntimeCall(getInitThreadAbortFn(CGF.CGM), Guard);
2608 void MicrosoftCXXABI::EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
2615 llvm::Function *F = CGF.CurFn;
2618 CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit);
2629 CGBuilderTy &Builder = CGF.Builder;
2630 llvm::IntegerType *GuardTy = CGF.Int32Ty;
2658 ErrorUnsupportedABI(CGF, "more than 32 guarded initializations");
2709 llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
2710 llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end");
2711 CGF.EmitCXXGuardedInitBranch(NeedsInit, InitBlock, EndBlock,
2716 CGF.EmitBlock(InitBlock);
2718 CGF.EHStack.pushCleanup<ResetGuardBit>(EHCleanup, GuardAddr, GuardNum);
2719 CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit);
2720 CGF.PopCleanupBlock();
2724 CGF.EmitBlock(EndBlock);
2745 llvm::BasicBlock *AttemptInitBlock = CGF.createBasicBlock("init.attempt");
2746 llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end");
2747 CGF.EmitCXXGuardedInitBranch(IsUninitialized, AttemptInitBlock, EndBlock,
2752 CGF.EmitBlock(AttemptInitBlock);
2753 CGF.EmitNounwindRuntimeCall(getInitThreadHeaderFn(CGM),
2759 llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
2763 CGF.EmitBlock(InitBlock);
2764 CGF.EHStack.pushCleanup<CallInitThreadAbort>(EHCleanup, GuardAddr);
2765 CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit);
2766 CGF.PopCleanupBlock();
2767 CGF.EmitNounwindRuntimeCall(getInitThreadFooterFn(CGM),
2771 CGF.EmitBlock(EndBlock);
3010 MicrosoftCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
3015 CGBuilderTy &Builder = CGF.Builder;
3070 MicrosoftCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
3073 CGBuilderTy &Builder = CGF.Builder;
3132 MicrosoftCXXABI::GetVBaseOffsetFromVBPtr(CodeGenFunction &CGF,
3137 CGBuilderTy &Builder = CGF.Builder;
3140 CGM.Int8Ty, This.emitRawPointer(CGF), VBPtrOffset, "vbptr");
3149 VBPtrAlign = CGF.getPointerAlign();
3170 CodeGenFunction &CGF, const Expr *E, const CXXRecordDecl *RD,
3172 CGBuilderTy &Builder = CGF.Builder;
3184 VBaseAdjustBB = CGF.createBasicBlock("memptr.vadjust");
3185 SkipAdjustBB = CGF.createBasicBlock("memptr.skip_vadjust");
3190 CGF.EmitBlock(VBaseAdjustBB);
3198 DiagnosticsEngine &Diags = CGF.CGM.getDiags();
3210 GetVBaseOffsetFromVBPtr(CGF, Base, VBPtrOffset, VBTableOffset, &VBPtr);
3217 CGF.EmitBlock(SkipAdjustBB);
3219 Phi->addIncoming(Base.emitRawPointer(CGF), OriginalBB);
3227 CodeGenFunction &CGF, const Expr *E, Address Base, llvm::Value *MemPtr,
3230 CGBuilderTy &Builder = CGF.Builder;
3251 Addr = AdjustVirtualBase(CGF, E, RD, Base, VirtualBaseAdjustmentOffset,
3254 Addr = Base.emitRawPointer(CGF);
3258 return Builder.CreateInBoundsGEP(CGF.Int8Ty, Addr, FieldOffset,
3263 MicrosoftCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
3292 CGBuilderTy &Builder = CGF.Builder;
3295 llvm::Value *IsNotNull = EmitMemberPointerIsNotNull(CGF, Src, SrcTy);
3308 llvm::BasicBlock *ConvertBB = CGF.createBasicBlock("memptr.convert");
3309 llvm::BasicBlock *ContinueBB = CGF.createBasicBlock("memptr.converted");
3311 CGF.EmitBlock(ConvertBB);
3320 CGF.EmitBlock(ContinueBB);
3509 CodeGenFunction &CGF, const Expr *E, Address This,
3516 CGBuilderTy &Builder = CGF.Builder;
3539 ThisPtrForCall = AdjustVirtualBase(CGF, E, RD, This,
3542 ThisPtrForCall = This.emitRawPointer(CGF);
3546 ThisPtrForCall = Builder.CreateInBoundsGEP(CGF.Int8Ty, ThisPtrForCall,
4089 CodeGenFunction CGF(CGM);
4090 CGF.CurGD = GlobalDecl(CD, Ctor_Complete);
4096 buildThisParam(CGF, FunctionArgs);
4121 auto NL = ApplyDebugLocation::CreateEmpty(CGF);
4122 CGF.StartFunction(GlobalDecl(), FnInfo.getReturnType(), ThunkFn, FnInfo,
4125 auto AL = ApplyDebugLocation::CreateArtificial(CGF);
4126 setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF));
4127 llvm::Value *This = getThisValue(CGF);
4130 IsCopy ? CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(&SrcParam), "src")
4150 CodeGenFunction::RunCleanupsScope Cleanups(CGF);
4153 CGF.EmitCallArgs(Args, FPT, llvm::ArrayRef(ArgVec), CD, IsCopy ? 1 : 0);
4157 addImplicitConstructorArgs(CGF, CD, Ctor_Complete,
4167 CGF.EmitCall(CalleeInfo, Callee, ReturnValueSlot(), Args);
4173 CGF.FinishFunction(SourceLocation());
4444 void MicrosoftCXXABI::emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) {
4450 Address AI = CGF.CreateMemTemp(ThrowType);
4451 CGF.EmitAnyExprToMem(SubExpr, AI, ThrowType.getQualifiers(),
4459 llvm::Value *Args[] = {AI.emitRawPointer(CGF), TI};
4460 CGF.EmitNoreturnRuntimeCallOrInvoke(getThrowFn(), Args);
4464 MicrosoftCXXABI::LoadVTablePtr(CodeGenFunction &CGF, Address This,
4467 performBaseAdjustment(CGF, This, QualType(RD->getTypeForDecl(), 0));
4468 return {CGF.GetVTablePtr(This, CGM.Int8PtrTy, RD), RD};