22#include "llvm/IR/Intrinsics.h"
25using namespace CodeGen;
28struct MemberCallInfo {
37 llvm::Value *This, llvm::Value *ImplicitParam,
40 auto *MD = cast<CXXMethodDecl>(GD.
getDecl());
42 assert(CE ==
nullptr || isa<CXXMemberCallExpr>(CE) ||
43 isa<CXXOperatorCallExpr>(CE));
44 assert(MD->isImplicitObjectMemberFunction() &&
45 "Trying to emit a member or operator call expr on a static method!");
59 unsigned PrefixSize = Args.size() - 1;
69 unsigned ArgsToSkip = 0;
70 if (
const auto *Op = dyn_cast<CXXOperatorCallExpr>(CE)) {
71 if (
const auto *M = dyn_cast<CXXMethodDecl>(Op->getCalleeDecl()))
73 static_cast<unsigned>(!M->isExplicitObjectMemberFunction());
80 "No CallExpr specified for function with non-zero number of arguments");
82 return {required, PrefixSize};
85RValue CodeGenFunction::EmitCXXMemberOrOperatorCall(
88 llvm::Value *This, llvm::Value *ImplicitParam,
QualType ImplicitParamTy,
93 *
this, MD, This, ImplicitParam, ImplicitParamTy, CE, Args, RtlArgs);
95 Args, FPT, CallInfo.ReqArgs, CallInfo.PrefixSize);
108 "Pointer/Object mixup");
112 if (SrcAS != DstAS) {
121 ImplicitParamTy, CE, Args,
nullptr);
142 BaseQuals = PTy->getPointeeType().getQualifiers();
183 return cast<CXXRecordDecl>(Ty->
getDecl());
192 if (isa<BinaryOperator>(callee))
195 const MemberExpr *ME = cast<MemberExpr>(callee);
219 assert(isa<CXXMemberCallExpr>(CE) || isa<CXXOperatorCallExpr>(CE));
222 bool CanUseVirtualCall = MD->
isVirtual() && !HasQualifier;
225 if (CanUseVirtualCall &&
229 assert(DevirtualizedMethod);
231 const Expr *Inner =
Base->IgnoreParenBaseCasts();
239 DevirtualizedMethod =
nullptr;
249 DevirtualizedMethod =
nullptr;
253 bool TrivialForCodegen =
255 bool TrivialAssignment =
264 LValue TrivialAssignmentRHS;
265 if (
auto *OCE = dyn_cast<CXXOperatorCallExpr>(CE)) {
266 if (OCE->isAssignmentOp()) {
267 if (TrivialAssignment) {
270 RtlArgs = &RtlArgStorage;
293 assert(
ReturnValue.isNull() &&
"Constructor shouldn't have return value");
301 false,
This.getAddress(*
this), Args,
307 if (TrivialForCodegen) {
308 if (isa<CXXDestructorDecl>(MD))
311 if (TrivialAssignment) {
317 LValue RHS = isa<CXXOperatorCallExpr>(CE)
318 ? TrivialAssignmentRHS
325 "unknown trivial member function");
330 DevirtualizedMethod ? DevirtualizedMethod : MD;
332 if (
const auto *Dtor = dyn_cast<CXXDestructorDecl>(CalleeDecl))
349 if (
const auto *CMCE = dyn_cast<CXXMemberCallExpr>(CE)) {
350 auto *IOA = CMCE->getImplicitObjectArgument();
352 if (IsImplicitObjectCXXThis)
353 SkippedChecks.
set(SanitizerKind::Alignment,
true);
354 if (IsImplicitObjectCXXThis || isa<DeclRefExpr>(IOA))
355 SkippedChecks.
set(SanitizerKind::Null,
true);
360 This.emitRawPointer(*
this),
370 bool UseVirtualCall = CanUseVirtualCall && !DevirtualizedMethod;
374 "Destructor shouldn't have explicit parameters");
375 assert(
ReturnValue.isNull() &&
"Destructor shouldn't have return value");
376 if (UseVirtualCall) {
378 This.getAddress(*
this),
379 cast<CXXMemberCallExpr>(CE));
383 if (
getLangOpts().AppleKext && Dtor->isVirtual() && HasQualifier)
385 else if (!DevirtualizedMethod)
393 IsArrow ?
Base->getType()->getPointeeType() :
Base->getType();
405 if (UseVirtualCall) {
419 else if (!DevirtualizedMethod)
432 *
this, CalleeDecl,
This.getAddress(*
this), UseVirtualCall);
433 This.setAddress(NewThisAddr);
468 llvm::Value *ThisPtrForCall =
nullptr;
471 ThisPtrForCall, MemFnPtr, MPT);
496 "Trying to emit a member call expr on a static method!");
526 std::vector<CharUnits> VBPtrOffsets =
528 for (
CharUnits VBPtrOffset : VBPtrOffsets) {
530 if (VBPtrOffset >= NVSize)
532 std::pair<CharUnits, CharUnits> LastStore = Stores.pop_back_val();
533 CharUnits LastStoreOffset = LastStore.first;
534 CharUnits LastStoreSize = LastStore.second;
536 CharUnits SplitBeforeOffset = LastStoreOffset;
537 CharUnits SplitBeforeSize = VBPtrOffset - SplitBeforeOffset;
538 assert(!SplitBeforeSize.
isNegative() &&
"negative store size!");
539 if (!SplitBeforeSize.
isZero())
540 Stores.emplace_back(SplitBeforeOffset, SplitBeforeSize);
542 CharUnits SplitAfterOffset = VBPtrOffset + VBPtrWidth;
543 CharUnits SplitAfterSize = LastStoreSize - SplitAfterOffset;
544 assert(!SplitAfterSize.
isNegative() &&
"negative store size!");
545 if (!SplitAfterSize.
isZero())
546 Stores.emplace_back(SplitAfterOffset, SplitAfterSize);
556 if (!NullConstantForBase->isNullValue()) {
557 llvm::GlobalVariable *NullVariable =
new llvm::GlobalVariable(
559 true, llvm::GlobalVariable::PrivateLinkage,
560 NullConstantForBase, Twine());
564 NullVariable->setAlignment(Align.
getAsAlign());
569 for (std::pair<CharUnits, CharUnits> Store : Stores) {
572 llvm::Value *StoreSizeVal = CGF.
CGM.
getSize(StoreSize);
583 for (std::pair<CharUnits, CharUnits> Store : Stores) {
586 llvm::Value *StoreSizeVal = CGF.
CGM.
getSize(StoreSize);
589 CGF.
Builder.getInt8(0), StoreSizeVal);
597 assert(!Dest.
isIgnored() &&
"Must have a destination!");
643 bool ForVirtualBase =
false;
658 ForVirtualBase =
true;
673 Exp = E->getSubExpr();
674 assert(isa<CXXConstructExpr>(Exp) &&
675 "EmitSynthesizedCXXCopyCtor - unknown copy ctor expr");
678 RunCleanupsScope
Scope(*
this);
688 &&
"EmitSynthesizedCXXCopyCtor - Copied-in Array");
707 unsigned minElements,
708 llvm::Value *&numElements,
709 llvm::Value *&sizeWithoutCookie) {
716 return sizeWithoutCookie;
720 unsigned sizeWidth = CGF.
SizeTy->getBitWidth();
723 llvm::APInt cookieSize(sizeWidth,
733 assert(isa<llvm::IntegerType>(numElements->getType()));
742 = (*e->
getArraySize())->getType()->isSignedIntegerOrEnumerationType();
743 llvm::IntegerType *numElementsType
744 = cast<llvm::IntegerType>(numElements->getType());
745 unsigned numElementsWidth = numElementsType->getBitWidth();
748 llvm::APInt arraySizeMultiplier(sizeWidth, 1);
751 type = CAT->getElementType();
752 arraySizeMultiplier *= CAT->getSize();
756 llvm::APInt typeSizeMultiplier(sizeWidth, typeSize.
getQuantity());
757 typeSizeMultiplier *= arraySizeMultiplier;
764 if (llvm::ConstantInt *numElementsC =
765 dyn_cast<llvm::ConstantInt>(numElements)) {
766 const llvm::APInt &count = numElementsC->getValue();
768 bool hasAnyOverflow =
false;
771 if (isSigned && count.isNegative())
772 hasAnyOverflow =
true;
777 else if (numElementsWidth > sizeWidth &&
778 numElementsWidth - sizeWidth > count.countl_zero())
779 hasAnyOverflow =
true;
782 llvm::APInt adjustedCount = count.zextOrTrunc(sizeWidth);
786 if (adjustedCount.ult(minElements))
787 hasAnyOverflow =
true;
792 numElements = llvm::ConstantInt::get(CGF.
SizeTy,
793 adjustedCount * arraySizeMultiplier);
797 llvm::APInt allocationSize
798 = adjustedCount.umul_ov(typeSizeMultiplier, overflow);
799 hasAnyOverflow |= overflow;
802 if (cookieSize != 0) {
805 sizeWithoutCookie = llvm::ConstantInt::get(CGF.
SizeTy, allocationSize);
807 allocationSize = allocationSize.uadd_ov(cookieSize, overflow);
808 hasAnyOverflow |= overflow;
812 if (hasAnyOverflow) {
813 size = llvm::Constant::getAllOnesValue(CGF.
SizeTy);
815 size = llvm::ConstantInt::get(CGF.
SizeTy, allocationSize);
833 llvm::Value *hasOverflow =
nullptr;
838 if (numElementsWidth > sizeWidth) {
839 llvm::APInt threshold =
840 llvm::APInt::getOneBitSet(numElementsWidth, sizeWidth);
842 llvm::Value *thresholdV
843 = llvm::ConstantInt::get(numElementsType, threshold);
845 hasOverflow = CGF.
Builder.CreateICmpUGE(numElements, thresholdV);
846 numElements = CGF.
Builder.CreateTrunc(numElements, CGF.
SizeTy);
849 }
else if (isSigned) {
850 if (numElementsWidth < sizeWidth)
851 numElements = CGF.
Builder.CreateSExt(numElements, CGF.
SizeTy);
858 if (typeSizeMultiplier == 1)
859 hasOverflow = CGF.
Builder.CreateICmpSLT(numElements,
860 llvm::ConstantInt::get(CGF.
SizeTy, minElements));
863 }
else if (numElementsWidth < sizeWidth) {
864 numElements = CGF.
Builder.CreateZExt(numElements, CGF.
SizeTy);
867 assert(numElements->getType() == CGF.
SizeTy);
872 hasOverflow = CGF.
Builder.CreateICmpULT(numElements,
873 llvm::ConstantInt::get(CGF.
SizeTy, minElements));
874 }
else if (numElementsWidth > sizeWidth) {
878 hasOverflow = CGF.
Builder.CreateOr(hasOverflow,
879 CGF.
Builder.CreateICmpULT(numElements,
880 llvm::ConstantInt::get(CGF.
SizeTy, minElements)));
893 if (typeSizeMultiplier != 1) {
894 llvm::Function *umul_with_overflow
898 llvm::ConstantInt::get(CGF.
SizeTy, typeSizeMultiplier);
899 llvm::Value *result =
900 CGF.
Builder.CreateCall(umul_with_overflow, {size, tsmV});
902 llvm::Value *overflowed = CGF.
Builder.CreateExtractValue(result, 1);
904 hasOverflow = CGF.
Builder.CreateOr(hasOverflow, overflowed);
906 hasOverflow = overflowed;
908 size = CGF.
Builder.CreateExtractValue(result, 0);
911 if (arraySizeMultiplier != 1) {
914 if (typeSize.
isOne()) {
915 assert(arraySizeMultiplier == typeSizeMultiplier);
921 llvm::ConstantInt::get(CGF.
SizeTy, arraySizeMultiplier);
922 numElements = CGF.
Builder.CreateMul(numElements, asmV);
927 assert(arraySizeMultiplier == 1);
931 if (cookieSize != 0) {
932 sizeWithoutCookie = size;
934 llvm::Function *uadd_with_overflow
937 llvm::Value *cookieSizeV = llvm::ConstantInt::get(CGF.
SizeTy, cookieSize);
938 llvm::Value *result =
939 CGF.
Builder.CreateCall(uadd_with_overflow, {size, cookieSizeV});
941 llvm::Value *overflowed = CGF.
Builder.CreateExtractValue(result, 1);
943 hasOverflow = CGF.
Builder.CreateOr(hasOverflow, overflowed);
945 hasOverflow = overflowed;
947 size = CGF.
Builder.CreateExtractValue(result, 0);
954 size = CGF.
Builder.CreateSelect(hasOverflow,
955 llvm::Constant::getAllOnesValue(CGF.
SizeTy),
960 sizeWithoutCookie = size;
962 assert(sizeWithoutCookie &&
"didn't set sizeWithoutCookie?");
992 llvm_unreachable(
"bad evaluation kind");
997 Address BeginPtr, llvm::Value *NumElements,
998 llvm::Value *AllocSizeWithoutCookie) {
1006 unsigned InitListElements = 0;
1012 llvm::Instruction *CleanupDominator =
nullptr;
1019 auto TryMemsetInitialization = [&]() ->
bool {
1029 auto *RemainingSize = AllocSizeWithoutCookie;
1030 if (InitListElements) {
1032 auto *InitializedSize = llvm::ConstantInt::get(
1033 RemainingSize->getType(),
1034 getContext().getTypeSizeInChars(ElementType).getQuantity() *
1036 RemainingSize =
Builder.CreateSub(RemainingSize, InitializedSize);
1048 const Expr *IgnoreParen =
nullptr;
1050 IgnoreParen =
Init->IgnoreParenImpCasts();
1051 CPLIE = dyn_cast<CXXParenListInitExpr>(IgnoreParen);
1052 SL = dyn_cast<StringLiteral>(IgnoreParen);
1053 OCEE = dyn_cast<ObjCEncodeExpr>(IgnoreParen);
1057 if (ILE || CPLIE || SL || OCEE) {
1078 cast<ConstantArrayType>(
Init->getType()->getAsArrayTypeUnsafe())
1081 CurPtr, InitListElements,
"string.init.end");
1084 llvm::ConstantInt *ConstNum = dyn_cast<llvm::ConstantInt>(NumElements);
1085 if (!ConstNum || !ConstNum->equalsInt(InitListElements)) {
1086 bool OK = TryMemsetInitialization();
1088 assert(OK &&
"couldn't memset character type?");
1095 InitListElements = InitExprs.size();
1118 EndOfInit, ElementType, ElementAlign,
1125 for (
const Expr *IE : InitExprs) {
1151 while (
Init &&
Init->getType()->isConstantArrayType()) {
1152 auto *SubILE = dyn_cast<InitListExpr>(
Init);
1155 assert(SubILE->getNumInits() == 0 &&
"explicit inits in array filler?");
1156 Init = SubILE->getArrayFiller();
1165 llvm::ConstantInt *ConstNum = dyn_cast<llvm::ConstantInt>(NumElements);
1166 if (ConstNum && ConstNum->getZExtValue() <= InitListElements) {
1168 if (CleanupDominator)
1173 assert(
Init &&
"have trailing elements to initialize but no initializer");
1185 if (TryMemsetInitialization())
1197 if (InitListElements)
1198 NumElements =
Builder.CreateSub(
1200 llvm::ConstantInt::get(NumElements->getType(), InitListElements));
1203 CCE->requiresZeroInitialization());
1209 if (isa<ImplicitValueInitExpr>(
Init)) {
1210 if (TryMemsetInitialization())
1221 assert(
getContext().hasSameUnqualifiedType(ElementType,
Init->getType()) &&
1222 "got wrong type of element to initialize");
1225 if (
auto *ILE = dyn_cast<InitListExpr>(
Init))
1226 if (ILE->
getNumInits() == 0 && TryMemsetInitialization())
1231 if (
auto *ILE = dyn_cast<InitListExpr>(
Init)) {
1233 if (RType->getDecl()->isStruct()) {
1234 unsigned NumElements = 0;
1235 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RType->getDecl()))
1236 NumElements = CXXRD->getNumBases();
1237 for (
auto *Field : RType->getDecl()->fields())
1238 if (!
Field->isUnnamedBitField())
1242 for (
unsigned i = 0, e = ILE->
getNumInits(); i != e; ++i)
1243 if (!isa<ImplicitValueInitExpr>(ILE->
getInit(i)))
1245 if (ILE->
getNumInits() == NumElements && TryMemsetInitialization())
1252 llvm::BasicBlock *EntryBB =
Builder.GetInsertBlock();
1265 EndPtr,
"array.isempty");
1266 Builder.CreateCondBr(IsEmpty, ContBB, LoopBB);
1273 llvm::PHINode *CurPtrPhi =
1290 CleanupDominator =
Builder.CreateUnreachable();
1298 if (CleanupDominator) {
1300 CleanupDominator->eraseFromParent();
1304 llvm::Value *NextPtr =
Builder.CreateConstInBoundsGEP1_32(
1309 llvm::Value *IsEnd =
Builder.CreateICmpEQ(NextPtr, EndPtr,
"array.atend");
1310 Builder.CreateCondBr(IsEnd, ContBB, LoopBB);
1311 CurPtrPhi->addIncoming(NextPtr,
Builder.GetInsertBlock());
1317 QualType ElementType, llvm::Type *ElementTy,
1318 Address NewPtr, llvm::Value *NumElements,
1319 llvm::Value *AllocSizeWithoutCookie) {
1323 AllocSizeWithoutCookie);
1335 llvm::CallBase *CallOrInvoke;
1340 Args, CalleeType,
false),
1348 llvm::Function *Fn = dyn_cast<llvm::Function>(CalleePtr);
1350 Fn && Fn->hasFnAttribute(llvm::Attribute::NoBuiltin)) {
1351 CallOrInvoke->addFnAttr(llvm::Attribute::Builtin);
1368 if (
auto *FD = dyn_cast<FunctionDecl>(
Decl))
1371 llvm_unreachable(
"predeclared global operator new/delete is missing");
1376struct UsualDeleteParams {
1377 bool DestroyingDelete =
false;
1379 bool Alignment =
false;
1384 UsualDeleteParams Params;
1394 Params.DestroyingDelete =
true;
1406 Params.Alignment =
true;
1410 assert(AI == AE &&
"unexpected usual deallocation function parameter");
1418 template<
typename Traits>
1421 typedef typename Traits::ValueTy ValueTy;
1423 typedef typename Traits::RValueTy RValueTy;
1424 struct PlacementArg {
1429 unsigned NumPlacementArgs : 31;
1430 LLVM_PREFERRED_TYPE(
bool)
1431 unsigned PassAlignmentToPlacementDelete : 1;
1437 PlacementArg *getPlacementArgs() {
1438 return reinterpret_cast<PlacementArg *
>(
this + 1);
1442 static size_t getExtraSize(
size_t NumPlacementArgs) {
1443 return NumPlacementArgs *
sizeof(PlacementArg);
1446 CallDeleteDuringNew(
size_t NumPlacementArgs,
1448 ValueTy AllocSize,
bool PassAlignmentToPlacementDelete,
1450 : NumPlacementArgs(NumPlacementArgs),
1451 PassAlignmentToPlacementDelete(PassAlignmentToPlacementDelete),
1452 OperatorDelete(OperatorDelete), Ptr(Ptr), AllocSize(AllocSize),
1453 AllocAlign(AllocAlign) {}
1455 void setPlacementArg(
unsigned I, RValueTy Arg,
QualType Type) {
1456 assert(I < NumPlacementArgs &&
"index out of range");
1457 getPlacementArgs()[I] = {Arg,
Type};
1466 DeleteArgs.
add(Traits::get(CGF, Ptr), FPT->getParamType(0));
1469 UsualDeleteParams Params;
1470 if (NumPlacementArgs) {
1473 Params.Alignment = PassAlignmentToPlacementDelete;
1480 assert(!Params.DestroyingDelete &&
1481 "should not call destroying delete in a new-expression");
1485 DeleteArgs.add(Traits::get(CGF, AllocSize),
1492 if (Params.Alignment)
1493 DeleteArgs.add(
RValue::get(llvm::ConstantInt::get(
1498 for (
unsigned I = 0; I != NumPlacementArgs; ++I) {
1499 auto Arg = getPlacementArgs()[I];
1500 DeleteArgs.add(Traits::get(CGF, Arg.ArgValue), Arg.ArgType);
1514 llvm::Value *AllocSize,
1522 struct DirectCleanupTraits {
1523 typedef llvm::Value *ValueTy;
1529 typedef CallDeleteDuringNew<DirectCleanupTraits> DirectCleanup;
1535 auto &Arg = NewArgs[I + NumNonPlacementArgs];
1536 Cleanup->setPlacementArg(I, Arg.getRValue(CGF), Arg.Ty);
1548 struct ConditionalCleanupTraits {
1552 return V.restore(CGF);
1555 typedef CallDeleteDuringNew<ConditionalCleanupTraits> ConditionalCleanup;
1557 ConditionalCleanup *Cleanup = CGF.
EHStack
1566 auto &Arg = NewArgs[I + NumNonPlacementArgs];
1567 Cleanup->setPlacementArg(
1583 unsigned minElements = 0;
1588 const Expr *IgnoreParen =
Init->IgnoreParenImpCasts();
1590 isa<StringLiteral>(IgnoreParen) || isa<ObjCEncodeExpr>(IgnoreParen)) {
1592 cast<ConstantArrayType>(
Init->getType()->getAsArrayTypeUnsafe())
1594 }
else if (ILE || CPLIE) {
1599 llvm::Value *numElements =
nullptr;
1600 llvm::Value *allocSizeWithoutCookie =
nullptr;
1601 llvm::Value *allocSize =
1603 allocSizeWithoutCookie);
1634 unsigned ParamsToSkip = 0;
1641 if (allocSize != allocSizeWithoutCookie) {
1643 allocAlign = std::max(allocAlign, cookieAlign);
1654 "wrong type for alignment parameter");
1658 assert(allocator->
isVariadic() &&
"can't pass alignment to allocator");
1667 AbstractCallee(), ParamsToSkip);
1674 if (
auto *newCall = dyn_cast<llvm::CallBase>(RV.
getScalarVal()))
1685 unsigned AllocatorAlign = llvm::bit_floor(std::min<uint64_t>(
1687 allocationAlign = std::max(
1688 allocationAlign,
getContext().toCharUnitsFromBits(AllocatorAlign));
1702 llvm::BasicBlock *nullCheckBB =
nullptr;
1703 llvm::BasicBlock *contBB =
nullptr;
1707 ConditionalEvaluation conditional(*
this);
1710 conditional.begin(*
this);
1712 nullCheckBB =
Builder.GetInsertBlock();
1717 Builder.CreateCondBr(isNull, contBB, notNullBB);
1724 llvm::Instruction *cleanupDominator =
nullptr;
1730 cleanupDominator =
Builder.CreateUnreachable();
1733 assert((allocSize == allocSizeWithoutCookie) ==
1735 if (allocSize != allocSizeWithoutCookie) {
1759 SkippedChecks.
set(SanitizerKind::Null, nullCheck);
1762 result, allocType, result.
getAlignment(), SkippedChecks,
1766 allocSizeWithoutCookie);
1773 if (resultPtr->getType() != resultType)
1774 resultPtr =
Builder.CreateBitCast(resultPtr, resultType);
1779 if (operatorDeleteCleanup.
isValid()) {
1781 cleanupDominator->eraseFromParent();
1785 conditional.end(*
this);
1787 llvm::BasicBlock *notNullBB =
Builder.GetInsertBlock();
1790 llvm::PHINode *PHI =
Builder.CreatePHI(resultPtr->getType(), 2);
1791 PHI->addIncoming(resultPtr, notNullBB);
1792 PHI->addIncoming(llvm::Constant::getNullValue(resultPtr->getType()),
1802 llvm::Value *Ptr,
QualType DeleteTy,
1803 llvm::Value *NumElements,
1805 assert((!NumElements && CookieSize.
isZero()) ||
1812 auto ParamTypeIt = DeleteFTy->param_type_begin();
1820 llvm::AllocaInst *DestroyingDeleteTag =
nullptr;
1821 if (Params.DestroyingDelete) {
1826 DestroyingDeleteTag->setAlignment(Align.
getAsAlign());
1833 QualType SizeType = *ParamTypeIt++;
1843 if (!CookieSize.
isZero())
1851 if (Params.Alignment) {
1852 QualType AlignValType = *ParamTypeIt++;
1856 llvm::Value *Align = llvm::ConstantInt::get(
ConvertType(AlignValType),
1861 assert(ParamTypeIt == DeleteFTy->param_type_end() &&
1862 "unknown parameter to usual delete function");
1869 if (DestroyingDeleteTag && DestroyingDeleteTag->use_empty())
1870 DestroyingDeleteTag->eraseFromParent();
1880 CallObjectDelete(llvm::Value *Ptr,
1883 : Ptr(Ptr), OperatorDelete(OperatorDelete), ElementType(ElementType) {}
1893 llvm::Value *CompletePtr,
1896 OperatorDelete, ElementType);
1907 if (Dtor && Dtor->isVirtual())
1922 llvm::BasicBlock *UnconditionalDeleteBlock) {
1943 bool UseVirtualCall =
true;
1945 if (
auto *DevirtualizedDtor =
1946 dyn_cast_or_null<const CXXDestructorDecl>(
1949 UseVirtualCall =
false;
1955 Dtor = DevirtualizedDtor;
1962 UseVirtualCall =
true;
1965 if (UseVirtualCall) {
1977 CGF.
EHStack.pushCleanup<CallObjectDelete>(
2004 CGF.
EmitBlock(UnconditionalDeleteBlock);
2018 llvm::Value *NumElements;
2022 CallArrayDelete(llvm::Value *Ptr,
2024 llvm::Value *NumElements,
2027 : Ptr(Ptr), OperatorDelete(OperatorDelete), NumElements(NumElements),
2028 ElementType(ElementType), CookieSize(CookieSize) {}
2031 CGF.
EmitDeleteCall(OperatorDelete, Ptr, ElementType, NumElements,
2042 llvm::Value *numElements =
nullptr;
2043 llvm::Value *allocatedPtr =
nullptr;
2046 numElements, allocatedPtr, cookieSize);
2048 assert(allocatedPtr &&
"ReadArrayCookie didn't set allocated pointer");
2053 allocatedPtr, operatorDelete,
2054 numElements, elementType,
2059 assert(numElements &&
"no element count for a type with a destructor!");
2067 deletedPtr.
getElementType(), arrayBegin, numElements,
"delete.end");
2119 GEP.push_back(Zero);
2123 =
getContext().getAsConstantArrayType(DeleteTy)) {
2125 DeleteTy = Arr->getElementType();
2128 GEP.push_back(Zero);
2149 if (
const auto *CE = dyn_cast<CastExpr>(E)) {
2155 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(E))
2158 if (
const auto *BO = dyn_cast<BinaryOperator>(E))
2162 if (
const auto *ACO = dyn_cast<AbstractConditionalOperator>(E))
2168 if (isa<ArraySubscriptExpr>(E))
2171 if (
const auto *UO = dyn_cast<UnaryOperator>(E))
2172 if (UO->getOpcode() == UO_Deref)
2179 llvm::Type *StdTypeInfoPtrTy) {
2190 ThisPtr, SrcRecordTy);
2202 llvm::BasicBlock *BadTypeidBlock =
2219 llvm::Type *PtrTy = llvm::PointerType::getUnqual(
getLLVMContext());
2222 auto MaybeASCast = [=](
auto &&
TypeInfo) {
2252 return llvm::Constant::getNullValue(DestLTy);
2259 CGF.
Builder.ClearInsertionPoint();
2260 return llvm::PoisonValue::get(DestLTy);
2276 if (IsDynamicCastToVoid) {
2283 SrcRecordTy = SrcTy;
2297 if (!
Builder.GetInsertBlock())
2303 assert(SrcRecordTy->
isRecordType() &&
"source type must be a record type!");
2307 bool IsExact = !IsDynamicCastToVoid &&
2315 bool ShouldNullCheckSrcValue =
2319 llvm::BasicBlock *CastNull =
nullptr;
2320 llvm::BasicBlock *CastNotNull =
nullptr;
2323 if (ShouldNullCheckSrcValue) {
2333 if (IsDynamicCastToVoid) {
2335 }
else if (IsExact) {
2339 *
this, ThisAddr, SrcRecordTy, DestTy, DestRecordTy, CastEnd, CastNull);
2342 "destination type must be a record type!");
2344 DestTy, DestRecordTy, CastEnd);
2346 CastNotNull =
Builder.GetInsertBlock();
2348 llvm::Value *NullValue =
nullptr;
2349 if (ShouldNullCheckSrcValue) {
2354 CastNull =
Builder.GetInsertBlock();
2363 PHI->addIncoming(
Value, CastNotNull);
2364 PHI->addIncoming(NullValue, CastNull);
static MemberCallInfo commonEmitCXXMemberOrOperatorCall(CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This, llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *CE, CallArgList &Args, CallArgList *RtlArgs)
static llvm::Value * EmitDynamicCastToNull(CodeGenFunction &CGF, QualType DestTy)
static llvm::Value * EmitTypeidFromVTable(CodeGenFunction &CGF, const Expr *E, llvm::Type *StdTypeInfoPtrTy)
static RValue EmitNewDeleteCall(CodeGenFunction &CGF, const FunctionDecl *CalleeDecl, const FunctionProtoType *CalleeType, const CallArgList &Args)
Emit a call to an operator new or operator delete function, as implicitly created by new-expressions ...
static void EmitDestroyingObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE, Address Ptr, QualType ElementType)
Emit the code for deleting a single object with a destroying operator delete.
static void EmitNullBaseClassInitialization(CodeGenFunction &CGF, Address DestPtr, const CXXRecordDecl *Base)
static void EnterNewDeleteCleanup(CodeGenFunction &CGF, const CXXNewExpr *E, Address NewPtr, llvm::Value *AllocSize, CharUnits AllocAlign, const CallArgList &NewArgs)
Enter a cleanup to call 'operator delete' if the initializer in a new-expression throws.
static bool isGLValueFromPointerDeref(const Expr *E)
static bool EmitObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE, Address Ptr, QualType ElementType, llvm::BasicBlock *UnconditionalDeleteBlock)
Emit the code for deleting a single object.
static UsualDeleteParams getUsualDeleteParams(const FunctionDecl *FD)
static CXXRecordDecl * getCXXRecord(const Expr *E)
static CharUnits CalculateCookiePadding(CodeGenFunction &CGF, const CXXNewExpr *E)
static void EmitArrayDelete(CodeGenFunction &CGF, const CXXDeleteExpr *E, Address deletedPtr, QualType elementType)
Emit the code for deleting an array of objects.
static void StoreAnyExprIntoOneUnit(CodeGenFunction &CGF, const Expr *Init, QualType AllocType, Address NewPtr, AggValueSlot::Overlap_t MayOverlap)
static void EmitNewInitializer(CodeGenFunction &CGF, const CXXNewExpr *E, QualType ElementType, llvm::Type *ElementTy, Address NewPtr, llvm::Value *NumElements, llvm::Value *AllocSizeWithoutCookie)
static llvm::Value * EmitCXXNewAllocSize(CodeGenFunction &CGF, const CXXNewExpr *e, unsigned minElements, llvm::Value *&numElements, llvm::Value *&sizeWithoutCookie)
llvm::MachO::Target Target
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
TranslationUnitDecl * getTranslationUnitDecl() const
const ConstantArrayType * getAsConstantArrayType(QualType T) const
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
DeclarationNameTable DeclarationNames
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const
Return number of constant array elements.
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
CharUnits getNonVirtualAlignment() const
getNonVirtualAlignment - Get the non-virtual alignment (in chars) of an object, which is the alignmen...
CharUnits getNonVirtualSize() const
getNonVirtualSize - Get the non-virtual size (in chars) of an object, which is the size of the object...
Represents an array type, per C99 6.7.5.2 - Array Declarators.
A builtin binary operation expression such as "x + y" or "x <= y".
Represents a call to a CUDA kernel function.
Represents a call to a C++ constructor.
bool isElidable() const
Whether this construction is elidable.
Expr * getArg(unsigned Arg)
Return the specified argument.
bool requiresZeroInitialization() const
Whether this construction first requires zero-initialization before the initializer is called.
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
CXXConstructionKind getConstructionKind() const
Determine whether this constructor is actually constructing a base class (rather than a complete obje...
Represents a C++ constructor within a class.
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Represents a delete expression for memory deallocation and destructor calls, e.g.
FunctionDecl * getOperatorDelete() const
QualType getDestroyedType() const
Retrieve the type being destroyed.
Represents a C++ destructor within a class.
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
bool isAlwaysNull() const
isAlwaysNull - Return whether the result of the dynamic_cast is proven to always be null.
Represents a call to a member function that may be written either with member call syntax (e....
SourceLocation getExprLoc() const LLVM_READONLY
Represents a static or instance method of a struct/union/class.
bool isImplicitObjectMemberFunction() const
[C++2b][dcl.fct]/p7 An implicit object member function is a non-static member function without an exp...
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
QualType getThisType() const
Return the type of the this pointer.
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Qualifiers getMethodQualifiers() const
CXXMethodDecl * getDevirtualizedMethod(const Expr *Base, bool IsAppleKext)
If it's possible to devirtualize a call to this method, return the called function.
CXXMethodDecl * getCorrespondingMethodInClass(const CXXRecordDecl *RD, bool MayBeBase=false)
Find the method in RD that corresponds to this one.
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
llvm::iterator_range< arg_iterator > placement_arguments()
QualType getAllocatedType() const
std::optional< Expr * > getArraySize()
This might return std::nullopt even if isArray() returns true, since there might not be an array size...
bool hasInitializer() const
Whether this new-expression has any initializer at all.
bool shouldNullCheckAllocation() const
True if the allocation result needs to be null-checked.
bool passAlignment() const
Indicates whether the required alignment should be implicitly passed to the allocation function.
FunctionDecl * getOperatorDelete() const
unsigned getNumPlacementArgs() const
TypeSourceInfo * getAllocatedTypeSourceInfo() const
FunctionDecl * getOperatorNew() const
Expr * getInitializer()
The initializer of this new-expression.
A call to an overloaded operator written using operator syntax.
Represents a list-initialization with parenthesis.
ArrayRef< Expr * > getInitExprs()
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
bool isArrow() const
Determine whether this pseudo-destructor expression was written using an '->' (otherwise,...
QualType getDestroyedType() const
Retrieve the type being destroyed.
Represents a C++ struct/union/class.
bool isEffectivelyFinal() const
Determine whether it's impossible for a class to be derived from this class.
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
bool isDynamicClass() const
bool hasDefinition() const
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
QualType getTypeOperand(ASTContext &Context) const
Retrieves the type operand of this typeid() expression after various required adjustments (removing r...
bool isTypeOperand() const
Expr * getExprOperand() const
bool isMostDerived(ASTContext &Context) const
Best-effort check if the expression operand refers to a most derived object.
bool isPotentiallyEvaluated() const
Determine whether this typeid has a type operand which is potentially evaluated, per C++11 [expr....
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
SourceLocation getBeginLoc() const LLVM_READONLY
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
CharUnits - This is an opaque type for sizes expressed in character units.
CharUnits alignmentAtOffset(CharUnits offset) const
Given that this is a non-zero alignment value, what is the alignment at the given offset?
bool isNegative() const
isNegative - Test whether the quantity is less than zero.
bool isZero() const
isZero - Test whether the quantity equals zero.
llvm::Align getAsAlign() const
getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
CharUnits alignmentOfArrayElement(CharUnits elementSize) const
Given that this is the alignment of the first element of an array, return the minimum alignment of an...
bool isOne() const
isOne - Test whether the quantity equals one.
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...
llvm::Value * emitRawPointer(CodeGenFunction &CGF) const
Return the pointer contained in this class after authenticating it and adding offset to it if necessa...
CharUnits getAlignment() const
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Address withElementType(llvm::Type *ElemTy) const
Return address with different element type, but same pointer and alignment.
Address setKnownNonNull()
void setAlignment(CharUnits Value)
llvm::PointerType * getType() const
Return the type of the pointer value.
bool isSanitizerChecked() const
Address getAddress() const
IsZeroed_t isZeroed() const
static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)
forAddr - Make a slot for an aggregate value.
A scoped helper to set the current debug location to the specified location or preferred location of ...
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset, const llvm::Twine &Name="")
Given a pointer to i8, adjust it by a given constant offset.
llvm::Value * CreateIsNull(Address Addr, const Twine &Name="")
llvm::CallInst * CreateMemSet(Address Dest, llvm::Value *Value, llvm::Value *Size, bool IsVolatile=false)
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Address CreateLaunderInvariantGroup(Address Addr)
llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)
llvm::ConstantInt * getSize(CharUnits N)
Address CreateConstInBoundsGEP(Address Addr, uint64_t Index, const llvm::Twine &Name="")
Given addr = T* ... produce name = getelementptr inbounds addr, i64 index where i64 is actually the t...
Address CreateInBoundsGEP(Address Addr, ArrayRef< llvm::Value * > IdxList, llvm::Type *ElementType, CharUnits Align, const Twine &Name="")
virtual RValue EmitCUDAKernelCallExpr(CodeGenFunction &CGF, const CUDAKernelCallExpr *E, ReturnValueSlot ReturnValue)
virtual bool shouldEmitExactDynamicCast(QualType DestRecordTy)=0
virtual std::vector< CharUnits > getVBPtrOffsets(const CXXRecordDecl *RD)
Gets the offsets of all the virtual base pointers in a given class.
virtual void ReadArrayCookie(CodeGenFunction &CGF, Address Ptr, const CXXDeleteExpr *expr, QualType ElementType, llvm::Value *&NumElements, llvm::Value *&AllocPtr, CharUnits &CookieSize)
Reads the array cookie associated with the given pointer, if it has one.
virtual std::pair< llvm::Value *, const CXXRecordDecl * > LoadVTablePtr(CodeGenFunction &CGF, Address This, const CXXRecordDecl *RD)=0
Load a vtable from This, an object of polymorphic type RD, or from one of its virtual bases if it doe...
virtual Address adjustThisArgumentForVirtualFunctionCall(CodeGenFunction &CGF, GlobalDecl GD, Address This, bool VirtualCall)
Perform ABI-specific "this" argument adjustment required prior to a call of a virtual function.
virtual llvm::Value * EmitVirtualDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType, Address This, DeleteOrMemberCallExpr E)=0
Emit the ABI-specific virtual destructor call.
virtual void emitVirtualObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE, Address Ptr, QualType ElementType, const CXXDestructorDecl *Dtor)=0
virtual llvm::Value * emitExactDynamicCast(CodeGenFunction &CGF, Address Value, QualType SrcRecordTy, QualType DestTy, QualType DestRecordTy, llvm::BasicBlock *CastSuccess, llvm::BasicBlock *CastFail)=0
Emit a dynamic_cast from SrcRecordTy to DestRecordTy.
virtual const CXXRecordDecl * getThisArgumentTypeForMethod(GlobalDecl GD)
Get the type of the implicit "this" parameter used by a method.
virtual bool EmitBadCastCall(CodeGenFunction &CGF)=0
virtual llvm::Value * EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy, Address ThisPtr, llvm::Type *StdTypeInfoPtrTy)=0
virtual CGCallee EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, const Expr *E, Address This, llvm::Value *&ThisPtrForCall, llvm::Value *MemPtr, const MemberPointerType *MPT)
Load a member function from an object and a member function pointer.
virtual CharUnits GetArrayCookieSize(const CXXNewExpr *expr)
Returns the extra size required in order to store the array cookie for the given new-expression.
virtual void EmitBadTypeidCall(CodeGenFunction &CGF)=0
virtual llvm::Value * emitDynamicCastToVoid(CodeGenFunction &CGF, Address Value, QualType SrcRecordTy)=0
virtual bool shouldTypeidBeNullChecked(bool IsDeref, QualType SrcRecordTy)=0
virtual llvm::Value * emitDynamicCastCall(CodeGenFunction &CGF, Address Value, QualType SrcRecordTy, QualType DestTy, QualType DestRecordTy, llvm::BasicBlock *CastEnd)=0
virtual Address InitializeArrayCookie(CodeGenFunction &CGF, Address NewPtr, llvm::Value *NumElements, const CXXNewExpr *expr, QualType ElementType)
Initialize the array cookie for the given allocation.
virtual bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr, QualType SrcRecordTy)=0
All available information about a concrete callee.
static CGCallee forVirtual(const CallExpr *CE, GlobalDecl MD, Address Addr, llvm::FunctionType *FTy)
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
void addHeapAllocSiteMetadata(llvm::CallBase *CallSite, QualType AllocatedTy, SourceLocation Loc)
Add heapallocsite metadata for MSAllocator calls.
CGFunctionInfo - Class to encapsulate the information about a function definition.
CallArgList - Type for representing both the value and type of arguments in a call.
void add(RValue rvalue, QualType type)
void addFrom(const CallArgList &other)
Add all the arguments from another CallArgList to this one.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
void EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D, Address This, Address Src, const CXXConstructExpr *E)
void pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete, llvm::Value *CompletePtr, QualType ElementType)
void EmitARCDestroyWeak(Address addr)
RValue EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E, ReturnValueSlot ReturnValue)
void EmitNullInitialization(Address DestPtr, QualType Ty)
EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)
DeactivateCleanupBlock - Deactivates the given cleanup block.
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
void PopCleanupBlock(bool FallThroughIsBranchThrough=false)
PopCleanupBlock - Will pop the cleanup entry on the stack and process all branch fixups.
bool sanitizePerformTypeCheck() const
Whether any type-checking sanitizers are enabled.
SanitizerSet SanOpts
Sanitizers enabled for this function.
void EmitVTablePtrCheckForCall(const CXXRecordDecl *RD, llvm::Value *VTable, CFITypeCheckKind TCK, SourceLocation Loc)
EmitVTablePtrCheckForCall - Virtual method MD is being called via VTable.
void EmitCallArgs(CallArgList &Args, PrototypeWrapper Prototype, llvm::iterator_range< CallExpr::const_arg_iterator > ArgRange, AbstractCallee AC=AbstractCallee(), unsigned ParamsToSkip=0, EvaluationOrder Order=EvaluationOrder::Default)
void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin, Address arrayEndPointer, QualType elementType, CharUnits elementAlignment, Destroyer *destroyer)
void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp)
void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D, const ArrayType *ArrayTy, Address ArrayPtr, const CXXConstructExpr *E, bool NewPointerIsChecked, bool ZeroInitialization=false)
void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating, Address This, QualType ThisTy)
LValue EmitLValue(const Expr *E, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
EmitLValue - Emit code to compute a designator that specifies the location of the expression.
void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr, QualType DeleteTy, llvm::Value *NumElements=nullptr, CharUnits CookieSize=CharUnits())
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
RValue EmitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E)
const LangOptions & getLangOpts() const
void emitArrayDestroy(llvm::Value *begin, llvm::Value *end, QualType elementType, CharUnits elementAlign, Destroyer *destroyer, bool checkZeroLength, bool useEHCleanup)
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
RValue EmitCXXMemberOrOperatorCall(const CXXMethodDecl *Method, const CGCallee &Callee, ReturnValueSlot ReturnValue, llvm::Value *This, llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *E, CallArgList *RtlArgs)
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...
@ TCK_ConstructorCall
Checking the 'this' pointer for a constructor call.
@ TCK_MemberCall
Checking the 'this' pointer for a call to a non-static member function.
@ TCK_DynamicOperation
Checking the operand of a dynamic_cast or a typeid expression.
void EmitIgnoredExpr(const Expr *E)
EmitIgnoredExpr - Emit an expression in a context which ignores the result.
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **callOrInvoke, bool IsMustTail, SourceLocation Loc)
EmitCall - Generate a call of the given function, expecting the given result type,...
llvm::Type * ConvertTypeForMem(QualType T)
void EmitAggregateAssign(LValue Dest, LValue Src, QualType EltTy)
Emit an aggregate assignment.
void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
@ ForceRightToLeft
! Language semantics require right-to-left evaluation.
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
void EmitNewArrayInitializer(const CXXNewExpr *E, QualType elementType, llvm::Type *ElementTy, Address NewPtr, llvm::Value *NumElements, llvm::Value *AllocSizeWithoutCookie)
void initFullExprCleanup()
Set up the last cleanup that was pushed as a conditional full-expression cleanup.
bool isInConditionalBranch() const
isInConditionalBranch - Return true if we're currently emitting one branch or the other of a conditio...
llvm::Value * getTypeSize(QualType Ty)
Returns calculated size of the specified type.
Address EmitPointerWithAlignment(const Expr *Addr, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
EmitPointerWithAlignment - Given an expression with a pointer type, emit the value and compute our be...
void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit)
EmitComplexExprIntoLValue - Emit the given expression of complex type and place its result into the s...
RValue EmitBuiltinNewDeleteCall(const FunctionProtoType *Type, const CallExpr *TheCallExpr, bool IsDelete)
void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type, bool ForVirtualBase, bool Delegating, AggValueSlot ThisAVS, const CXXConstructExpr *E)
CGDebugInfo * getDebugInfo()
void EmitBranch(llvm::BasicBlock *Block)
EmitBranch - Emit a branch to the specified basic block from the current insert block,...
void EmitCXXDeleteExpr(const CXXDeleteExpr *E)
const TargetCodeGenInfo & getTargetHooks() const
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type.
ASTContext & getContext() const
CGCallee BuildAppleKextVirtualCall(const CXXMethodDecl *MD, NestedNameSpecifier *Qual, llvm::Type *Ty)
RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue)
bool needsEHCleanup(QualType::DestructionKind kind)
Determines whether an EH cleanup is required to destroy a type with the given destruction kind.
void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest)
llvm::Type * ConvertType(QualType T)
llvm::Value * EmitCXXTypeidExpr(const CXXTypeidExpr *E)
RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E, ReturnValueSlot ReturnValue)
CodeGenTypes & getTypes() const
void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, LValue LV, QualType Type, SanitizerSet SkippedChecks=SanitizerSet(), llvm::Value *ArraySize=nullptr)
llvm::Value * EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE)
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
const CallExpr * MustTailCall
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
RValue EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E, ReturnValueSlot ReturnValue)
llvm::LLVMContext & getLLVMContext()
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...
llvm::Value * EmitCXXNewExpr(const CXXNewExpr *E)
RValue EmitCXXMemberOrOperatorMemberCallExpr(const CallExpr *CE, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue, bool HasQualifier, NestedNameSpecifier *Qualifier, bool IsArrow, const Expr *Base)
void EmitARCDestroyStrong(Address addr, ARCPreciseLifetime_t precise)
void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin, llvm::Value *arrayEnd, QualType elementType, CharUnits elementAlignment, Destroyer *destroyer)
static bool IsWrappedCXXThis(const Expr *E)
Check if E is a C++ "this" pointer wrapped in value-preserving casts.
void EmitExplicitCastExprType(const ExplicitCastExpr *E, CodeGenFunction *CGF=nullptr)
Emit type info if type of an expression is a variably modified type.
llvm::Module & getModule() const
llvm::Constant * EmitNullConstantForBase(const CXXRecordDecl *Record)
Return a null constant appropriate for zero-initializing a base class with the given type.
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
llvm::Constant * GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty=nullptr, bool ForVTable=false, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the given function.
llvm::Constant * getAddrOfCXXStructor(GlobalDecl GD, const CGFunctionInfo *FnInfo=nullptr, llvm::FunctionType *FnType=nullptr, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the constructor/destructor of the given type.
const LangOptions & getLangOpts() const
CGCUDARuntime & getCUDARuntime()
Return a reference to the configured CUDA runtime.
CharUnits getNaturalTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, bool forPointeeType=false)
CodeGenTypes & getTypes()
CGCXXABI & getCXXABI() const
const CodeGenOptions & getCodeGenOpts() const
LangAS GetGlobalVarAddressSpace(const VarDecl *D)
Return the AST address space of the underlying global variable for D, as determined by its declaratio...
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys=std::nullopt)
llvm::ConstantInt * getSize(CharUnits numChars)
Emit the given number of characters as a value of type size_t.
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
const CGFunctionInfo & arrangeCXXMethodDeclaration(const CXXMethodDecl *MD)
C++ methods have some special rules and also have implicit parameters.
CanQualType DeriveThisType(const CXXRecordDecl *RD, const CXXMethodDecl *MD)
Derives the 'this' type for codegen purposes, i.e.
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
const CGFunctionInfo & arrangeCXXMethodCall(const CallArgList &args, const FunctionProtoType *type, RequiredArgs required, unsigned numPrefixArgs)
Arrange a call to a C++ method, passing the given arguments.
const CGFunctionInfo & arrangeFreeFunctionCall(const CallArgList &Args, const FunctionType *Ty, bool ChainCall)
Figure out the rules for calling a function with the given formal type using the given arguments.
bool isZeroInitializable(QualType T)
IsZeroInitializable - Return whether a type can be zero-initialized (in the C++ sense) with an LLVM z...
const CGFunctionInfo & arrangeCXXStructorDeclaration(GlobalDecl GD)
llvm::Constant * tryEmitAbstract(const Expr *E, QualType T)
Try to emit the result of the given expression as an abstract constant.
Information for lazily generating a cleanup.
A saved depth on the scope stack.
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
T * pushCleanupWithExtra(CleanupKind Kind, size_t N, As... A)
Push a cleanup with non-constant storage requirements on the stack.
AlignmentSource getAlignmentSource() const
LValue - This represents an lvalue references.
Address getAddress(CodeGenFunction &CGF) const
RValue - This trivial value class is used to represent the result of an expression that is evaluated.
static RValue get(llvm::Value *V)
static RValue getAggregate(Address addr, bool isVolatile=false)
Convert an Address to an RValue.
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
A class for recording the number of arguments that a function signature requires.
static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype, unsigned additional)
Compute the arguments required by the given formal prototype, given that there may be some additional...
ReturnValueSlot - Contains the address where the return value of a function can be stored,...
Address performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, Address Addr, LangAS SrcAddr, LangAS DestAddr, llvm::Type *DestTy, bool IsNonNull=false) const
Represents the canonical version of C arrays with a specified constant size.
DeclContext * getParent()
getParent - Returns the containing DeclContext.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Decl - This represents one declaration (or definition), e.g.
The name of a declaration.
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
EnumDecl * getDecl() const
QualType getTypeAsWritten() const
getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
This represents one expression.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const
Determine whether the result of this expression is a temporary object of the given class type.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Represents a function declaration or definition.
bool isDestroyingOperatorDelete() const
Determine whether this is a destroying operator delete.
QualType getReturnType() const
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
bool isVariadic() const
Whether this function is variadic.
bool isReservedGlobalPlacementOperator() const
Determines whether this operator new or delete is one of the reserved global placement operators: voi...
bool isReplaceableGlobalAllocationFunction(std::optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
bool isDefaulted() const
Whether this function is defaulted.
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
Represents a prototype with parameter type info, e.g.
param_type_iterator param_type_begin() const
unsigned getNumParams() const
QualType getParamType(unsigned i) const
param_type_iterator param_type_end() const
GlobalDecl - represents a global declaration.
CXXCtorType getCtorType() const
const Decl * getDecl() const
Represents an implicitly-generated value initialization of an object of a given type.
Describes an C or C++ initializer list.
bool isStringLiteralInit() const
Is this an initializer for an array of characters, initialized by a string literal or an @encode?
unsigned getNumInits() const
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
const Expr * getInit(unsigned Init) const
ArrayRef< Expr * > inits()
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
bool hasQualifier() const
Determines whether this member expression actually had a C++ nested-name-specifier prior to the name ...
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name.
A pointer to member type per C++ 8.3.3 - Pointers to members.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
ObjCEncodeExpr, used for @encode in Objective-C.
PointerType - C99 6.7.5.1 - Pointer Declarators.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
LangAS getAddressSpace() const
Return the address space of this type.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType getCanonicalType() const
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
bool hasStrongOrWeakObjCLifetime() const
The collection of all-type qualifiers we support.
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
LangAS getAddressSpace() const
bool mayInsertExtraPadding(bool EmitRemark=false) const
Whether we are allowed to insert extra padding between fields.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Base for LValueReferenceType and RValueReferenceType.
Scope - A scope is a transient data structure that is used while parsing the program.
Encodes a location in the source.
StringLiteral - This represents a string literal expression, e.g.
SourceLocation getBeginLoc() const
Get the begin source location.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isConstantArrayType() const
bool isVoidPointerType() const
bool isPointerType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
@ EHCleanup
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< ArrayType > arrayType
Matches all kinds of arrays.
bool This(InterpState &S, CodePtr OpPC)
bool Zero(InterpState &S, CodePtr OpPC)
The JSON file list parser is used to communicate input to InstallAPI.
CXXCtorType
C++ constructor types.
@ Ctor_Base
Base object ctor.
@ Ctor_Complete
Complete object ctor.
@ Dtor_Complete
Complete object dtor.
LangAS
Defines the address space values used by the address space qualifier of QualType.
const FunctionProtoType * T
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
__DEVICE__ _Tp arg(const std::complex< _Tp > &__c)
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
CharUnits getPointerSize() const
llvm::IntegerType * SizeTy
CharUnits getSizeAlign() const
CharUnits getPointerAlign() const
A metaprogramming class for ensuring that a value will dominate an arbitrary position in a function.
static saved_type save(CodeGenFunction &CGF, type value)
void set(SanitizerMask K, bool Value)
Enable or disable a certain (single) sanitizer.
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.