33#include "llvm/ADT/Hashing.h"
34#include "llvm/ADT/STLExtras.h"
35#include "llvm/ADT/StringExtras.h"
36#include "llvm/IR/DataLayout.h"
37#include "llvm/IR/Intrinsics.h"
38#include "llvm/IR/IntrinsicsWebAssembly.h"
39#include "llvm/IR/LLVMContext.h"
40#include "llvm/IR/MDBuilder.h"
41#include "llvm/IR/MatrixBuilder.h"
42#include "llvm/Passes/OptimizationLevel.h"
43#include "llvm/Support/ConvertUTF.h"
44#include "llvm/Support/MathExtras.h"
45#include "llvm/Support/Path.h"
46#include "llvm/Support/SaveAndRestore.h"
47#include "llvm/Support/xxhash.h"
48#include "llvm/Transforms/Utils/SanitizerStats.h"
54using namespace CodeGen;
58 "ubsan-unique-traps", llvm::cl::Optional,
59 llvm::cl::desc(
"Deoptimize traps for UBSAN so there is 1 trap per check"),
60 llvm::cl::init(
false));
68Address CodeGenFunction::CreateTempAllocaWithoutCast(llvm::Type *Ty,
71 llvm::Value *ArraySize) {
81 llvm::Value *ArraySize,
86 llvm::Value *
V = Alloca.getPointer();
93 llvm::IRBuilderBase::InsertPointGuard IPG(
Builder);
101 Ty->getPointerTo(DestAddrSpace),
true);
112 llvm::Value *ArraySize) {
114 return Builder.CreateAlloca(Ty, ArraySize, Name);
142 const Twine &Name,
Address *Alloca) {
147 auto *ArrayTy = cast<llvm::ArrayType>(
Result.getElementType());
148 auto *VectorTy = llvm::FixedVectorType::get(ArrayTy->getElementType(),
149 ArrayTy->getNumElements());
179 CGFPOptionsRAII FPOptsRAII(*
this, E);
197 if (
const auto *CondOp = dyn_cast<AbstractConditionalOperator>(
220 if (!ignoreResult && aggSlot.
isIgnored())
225 llvm_unreachable(
"bad evaluation kind");
267 llvm_unreachable(
"bad evaluation kind");
308 VD && isa<VarDecl>(VD) && VD->
hasAttr<ObjCPreciseLifetimeAttr>();
329 llvm_unreachable(
"temporary cannot have dynamic storage duration");
331 llvm_unreachable(
"unknown storage duration");
339 auto *ClassDecl = cast<CXXRecordDecl>(RT->getDecl());
340 if (!ClassDecl->hasTrivialDestructor())
341 ReferenceTemporaryDtor = ClassDecl->getDestructor();
344 if (!ReferenceTemporaryDtor)
351 llvm::FunctionCallee CleanupFn;
352 llvm::Constant *CleanupArg;
355 ReferenceTemporary, E->
getType(),
358 CleanupArg = llvm::Constant::getNullValue(CGF.
Int8PtrTy);
362 CleanupArg = cast<llvm::Constant>(ReferenceTemporary.
getPointer());
377 ReferenceTemporary, E->
getType(),
383 llvm_unreachable(
"temporary cannot have dynamic storage duration");
405 auto *GV =
new llvm::GlobalVariable(
407 llvm::GlobalValue::PrivateLinkage,
Init,
".ref.tmp",
nullptr,
408 llvm::GlobalValue::NotThreadLocal,
412 llvm::Constant *
C = GV;
414 C = TCG.performAddrSpaceCast(
416 GV->getValueType()->getPointerTo(
419 return Address(
C, GV->getValueType(), alignment);
428 llvm_unreachable(
"temporary can't have dynamic storage duration");
430 llvm_unreachable(
"unknown storage duration");
444 "Reference should never be pseudo-strong!");
452 if (
auto *Var = dyn_cast<llvm::GlobalVariable>(
Object.getPointer())) {
462 if (Var->hasInitializer())
471 default: llvm_unreachable(
"expected scalar or aggregate expression");
494 for (
const auto &Ignored : CommaLHSs)
497 if (
const auto *opaque = dyn_cast<OpaqueValueExpr>(E)) {
498 if (opaque->getType()->isRecordType()) {
499 assert(Adjustments.empty());
507 if (
auto *Var = dyn_cast<llvm::GlobalVariable>(
508 Object.getPointer()->stripPointerCasts())) {
514 if (!Var->hasInitializer()) {
530 if (!ShouldEmitLifetimeMarkers)
540 ConditionalEvaluation *OldConditional =
nullptr;
541 CGBuilderTy::InsertPoint OldIP;
547 OldConditional = OutermostConditional;
548 OutermostConditional =
nullptr;
551 llvm::BasicBlock *
Block = OldConditional->getStartingBlock();
552 Builder.restoreIP(CGBuilderTy::InsertPoint(
553 Block, llvm::BasicBlock::iterator(
Block->back())));
563 if (OldConditional) {
564 OutermostConditional = OldConditional;
581 switch (Adjustment.Kind) {
585 Adjustment.DerivedToBase.BasePath->path_begin(),
586 Adjustment.DerivedToBase.BasePath->path_end(),
594 "materialized temporary field is not a simple lvalue");
635 const llvm::Constant *Elts) {
636 return cast<llvm::ConstantInt>(Elts->getAggregateElement(Idx))
643 llvm::Value *KMul = Builder.getInt64(0x9ddfea08eb382d69ULL);
644 llvm::Value *K47 = Builder.getInt64(47);
645 llvm::Value *A0 = Builder.CreateMul(Builder.CreateXor(Low, High), KMul);
646 llvm::Value *A1 = Builder.CreateXor(Builder.CreateLShr(A0, K47), A0);
647 llvm::Value *B0 = Builder.CreateMul(Builder.CreateXor(High, A1), KMul);
648 llvm::Value *B1 = Builder.CreateXor(Builder.CreateLShr(B0, K47), B0);
649 return Builder.CreateMul(B1, KMul);
676 llvm::Value *ArraySize) {
683 if (Ptr->getType()->getPointerAddressSpace())
691 SanitizerScope SanScope(
this);
694 llvm::BasicBlock *Done =
nullptr;
699 auto PtrToAlloca = dyn_cast<llvm::AllocaInst>(Ptr->stripPointerCasts());
702 llvm::Value *IsNonNull =
nullptr;
703 bool IsGuaranteedNonNull =
704 SkippedChecks.
has(SanitizerKind::Null) || PtrToAlloca;
706 if ((
SanOpts.
has(SanitizerKind::Null) || AllowNullPointers) &&
707 !IsGuaranteedNonNull) {
709 IsNonNull =
Builder.CreateIsNotNull(Ptr);
713 IsGuaranteedNonNull = IsNonNull == True;
716 if (!IsGuaranteedNonNull) {
717 if (AllowNullPointers) {
722 Builder.CreateCondBr(IsNonNull, Rest, Done);
725 Checks.push_back(std::make_pair(IsNonNull, SanitizerKind::Null));
731 !SkippedChecks.
has(SanitizerKind::ObjectSize) &&
734 llvm::Value *
Size = llvm::ConstantInt::get(
IntPtrTy, TySize);
739 llvm::Constant *ConstantSize = dyn_cast<llvm::Constant>(Size);
740 if (!ConstantSize || !ConstantSize->isNullValue()) {
746 llvm::Function *F =
CGM.
getIntrinsic(llvm::Intrinsic::objectsize, Tys);
748 llvm::Value *NullIsUnknown =
Builder.getFalse();
750 llvm::Value *LargeEnough =
Builder.CreateICmpUGE(
751 Builder.CreateCall(F, {Ptr, Min, NullIsUnknown, Dynamic}), Size);
752 Checks.push_back(std::make_pair(LargeEnough, SanitizerKind::ObjectSize));
756 llvm::MaybeAlign AlignVal;
757 llvm::Value *PtrAsInt =
nullptr;
760 !SkippedChecks.
has(SanitizerKind::Alignment)) {
768 if (AlignVal && *AlignVal > llvm::Align(1) &&
769 (!PtrToAlloca || PtrToAlloca->getAlign() < *AlignVal)) {
771 llvm::Value *Align =
Builder.CreateAnd(
772 PtrAsInt, llvm::ConstantInt::get(
IntPtrTy, AlignVal->value() - 1));
773 llvm::Value *Aligned =
776 Checks.push_back(std::make_pair(Aligned, SanitizerKind::Alignment));
780 if (Checks.size() > 0) {
781 llvm::Constant *StaticData[] = {
783 llvm::ConstantInt::get(
Int8Ty, AlignVal ? llvm::Log2(*AlignVal) : 1),
784 llvm::ConstantInt::get(
Int8Ty, TCK)};
785 EmitCheck(Checks, SanitizerHandler::TypeMismatch, StaticData,
786 PtrAsInt ? PtrAsInt : Ptr);
801 if (!IsGuaranteedNonNull) {
803 IsNonNull =
Builder.CreateIsNotNull(Ptr);
807 Builder.CreateCondBr(IsNonNull, VptrNotNull, Done);
817 llvm::raw_svector_ostream Out(MangledName);
824 llvm::hash_code TypeHash =
hash_value(Out.str());
827 llvm::Value *Low = llvm::ConstantInt::get(
Int64Ty, TypeHash);
836 const int CacheSize = 128;
837 llvm::Type *HashTable = llvm::ArrayType::get(
IntPtrTy, CacheSize);
839 "__ubsan_vptr_type_cache");
840 llvm::Value *Slot =
Builder.CreateAnd(Hash,
843 llvm::Value *Indices[] = {
Builder.getInt32(0), Slot };
852 llvm::Value *EqualHash =
Builder.CreateICmpEQ(CacheVal, Hash);
853 llvm::Constant *StaticData[] = {
857 llvm::ConstantInt::get(
Int8Ty, TCK)
859 llvm::Value *DynamicData[] = { Ptr, Hash };
860 EmitCheck(std::make_pair(EqualHash, SanitizerKind::Vptr),
861 SanitizerHandler::DynamicTypeCacheMiss, StaticData,
875 uint64_t EltSize =
C.getTypeSizeInChars(EltTy).getQuantity();
883 auto *ParamDecl = dyn_cast<ParmVarDecl>(ArrayDeclRef->getDecl());
887 auto *POSAttr = ParamDecl->getAttr<PassObjectSizeAttr>();
892 int POSType = POSAttr->getType();
893 if (POSType != 0 && POSType != 1)
897 auto PassedSizeIt = SizeArguments.find(ParamDecl);
898 if (PassedSizeIt == SizeArguments.end())
902 assert(LocalDeclMap.count(PassedSizeDecl) &&
"Passed size not loadable");
903 Address AddrOfSize = LocalDeclMap.find(PassedSizeDecl)->second;
906 llvm::Value *SizeOfElement =
907 llvm::ConstantInt::get(SizeInBytes->getType(), EltSize);
908 return Builder.CreateUDiv(SizeInBytes, SizeOfElement);
917 StrictFlexArraysLevel) {
920 IndexedType =
Base->getType();
921 return CGF.
Builder.getInt32(VT->getNumElements());
926 if (
const auto *CE = dyn_cast<CastExpr>(
Base)) {
927 if (CE->getCastKind() == CK_ArrayToPointerDecay &&
928 !CE->getSubExpr()->isFlexibleArrayMemberLike(CGF.
getContext(),
929 StrictFlexArraysLevel)) {
930 CodeGenFunction::SanitizerScope SanScope(&CGF);
932 IndexedType = CE->getSubExpr()->getType();
934 if (
const auto *CAT = dyn_cast<ConstantArrayType>(AT))
935 return CGF.
Builder.getInt(CAT->getSize());
937 if (
const auto *VAT = dyn_cast<VariableArrayType>(AT))
943 CodeGenFunction::SanitizerScope SanScope(&CGF);
945 QualType EltTy{
Base->getType()->getPointeeOrArrayElementType(), 0};
947 IndexedType =
Base->getType();
972class StructAccessBase
976 bool IsExpectedRecordDecl(
const Expr *E)
const {
984 StructAccessBase(
const RecordDecl *ExpectedRD) : ExpectedRD(ExpectedRD) {}
1007 const Expr *VisitStmt(
const Stmt *S) {
return nullptr; }
1023 return IsExpectedRecordDecl(E) ? E :
nullptr;
1026 if (IsExpectedRecordDecl(E) && E->
isArrow())
1029 return !Res && IsExpectedRecordDecl(E) ? E : Res;
1032 return IsExpectedRecordDecl(E) ? E :
nullptr;
1035 return IsExpectedRecordDecl(E) ? E :
nullptr;
1039 if (IsExpectedRecordDecl(E))
1065 int64_t FieldNo = -1;
1067 if (
const auto *Field = dyn_cast<FieldDecl>(D)) {
1070 Indices.emplace_back(std::make_pair(RD, CGF.
Builder.getInt32(FieldNo)));
1075 if (
const auto *
Record = dyn_cast<RecordDecl>(D)) {
1080 Indices.emplace_back(std::make_pair(RD, CGF.
Builder.getInt32(FieldNo)));
1102 const Expr *StructBase = StructAccessBase(RD).Visit(
Base);
1106 llvm::Value *Res =
nullptr;
1107 if (
const auto *DRE = dyn_cast<DeclRefExpr>(StructBase)) {
1111 }
else if (
const MemberExpr *ME = dyn_cast<MemberExpr>(StructBase)) {
1129 for (
auto I = Indices.rbegin(), E = Indices.rend(); I != E; ++I)
1130 Res =
Builder.CreateInBoundsGEP(
1132 {Zero, I->second},
"..counted_by.gep");
1139 if (!FD || !FD->
hasAttr<CountedByAttr>())
1142 const auto *CBA = FD->
getAttr<CountedByAttr>();
1146 auto GetNonAnonStructOrUnion =
1167 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(ND))
1168 ND = IFD->getAnonField();
1170 return dyn_cast<FieldDecl>(ND);
1174 llvm::Value *Index,
QualType IndexType,
1176 assert(
SanOpts.
has(SanitizerKind::ArrayBounds) &&
1177 "should not be called unless adding bounds checks");
1181 llvm::Value *Bound =
1190 QualType IndexedType,
bool Accessed) {
1194 SanitizerScope SanScope(
this);
1197 llvm::Value *IndexVal =
Builder.CreateIntCast(Index,
SizeTy, IndexSigned);
1198 llvm::Value *BoundVal =
Builder.CreateIntCast(Bound,
SizeTy,
false);
1200 llvm::Constant *StaticData[] = {
1205 llvm::Value *Check = Accessed ?
Builder.CreateICmpULT(IndexVal, BoundVal)
1206 :
Builder.CreateICmpULE(IndexVal, BoundVal);
1207 EmitCheck(std::make_pair(Check, SanitizerKind::ArrayBounds),
1208 SanitizerHandler::OutOfBounds, StaticData, Index);
1213 bool isInc,
bool isPre) {
1216 llvm::Value *NextVal;
1217 if (isa<llvm::IntegerType>(InVal.first->getType())) {
1218 uint64_t AmountVal = isInc ? 1 : -1;
1219 NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal,
true);
1222 NextVal =
Builder.CreateAdd(InVal.first, NextVal, isInc ?
"inc" :
"dec");
1225 llvm::APFloat FVal(
getContext().getFloatTypeSemantics(ElemTy), 1);
1231 NextVal =
Builder.CreateFAdd(InVal.first, NextVal, isInc ?
"inc" :
"dec");
1244 return isPre ? IncVal : InVal;
1254 DI->EmitExplicitCastType(E->
getType());
1271 if (
const CastExpr *CE = dyn_cast<CastExpr>(E)) {
1272 if (
const auto *ECE = dyn_cast<ExplicitCastExpr>(CE))
1275 switch (CE->getCastKind()) {
1279 case CK_AddressSpaceConversion:
1280 if (
auto PtrTy = CE->getSubExpr()->getType()->getAs<
PointerType>()) {
1281 if (PtrTy->getPointeeType()->isVoidType())
1287 CE->getSubExpr(), &InnerBaseInfo, &InnerTBAAInfo, IsKnownNonNull);
1288 if (BaseInfo) *BaseInfo = InnerBaseInfo;
1289 if (TBAAInfo) *TBAAInfo = InnerTBAAInfo;
1291 if (isa<ExplicitCastExpr>(CE)) {
1295 E->
getType(), &TargetTypeBaseInfo, &TargetTypeTBAAInfo);
1309 if (CGF.
SanOpts.
has(SanitizerKind::CFIUnrelatedCast) &&
1310 CE->getCastKind() == CK_BitCast) {
1318 llvm::Type *ElemTy =
1321 if (CE->getCastKind() == CK_AddressSpaceConversion)
1329 case CK_ArrayToPointerDecay:
1333 case CK_UncheckedDerivedToBase:
1334 case CK_DerivedToBase: {
1341 CE->getSubExpr(), BaseInfo,
nullptr,
1343 CE->getCastKind() == CK_UncheckedDerivedToBase));
1344 auto Derived = CE->getSubExpr()->
getType()->getPointeeCXXRecordDecl();
1346 Addr, Derived, CE->path_begin(), CE->path_end(),
1359 if (UO->getOpcode() == UO_AddrOf) {
1368 if (
auto *
Call = dyn_cast<CallExpr>(E)) {
1369 switch (
Call->getBuiltinCallee()) {
1372 case Builtin::BIaddressof:
1373 case Builtin::BI__addressof:
1374 case Builtin::BI__builtin_addressof: {
1408 return Builder.CreateICmpNE(
V, llvm::Constant::getNullValue(
V->getType()));
1419 llvm::Value *
U = llvm::UndefValue::get(EltTy);
1434 llvm_unreachable(
"bad evaluation kind");
1454 while (!isa<CXXThisExpr>(
Base)) {
1456 if (isa<CXXDynamicCastExpr>(
Base))
1459 if (
const auto *CE = dyn_cast<CastExpr>(
Base)) {
1460 Base = CE->getSubExpr();
1461 }
else if (
const auto *PE = dyn_cast<ParenExpr>(
Base)) {
1462 Base = PE->getSubExpr();
1463 }
else if (
const auto *UO = dyn_cast<UnaryOperator>(
Base)) {
1464 if (UO->getOpcode() == UO_Extension)
1465 Base = UO->getSubExpr();
1477 if (
SanOpts.
has(SanitizerKind::ArrayBounds) && isa<ArraySubscriptExpr>(E))
1483 if (
const auto *ME = dyn_cast<MemberExpr>(E)) {
1486 SkippedChecks.
set(SanitizerKind::Alignment,
true);
1487 if (IsBaseCXXThis || isa<DeclRefExpr>(ME->getBase()))
1488 SkippedChecks.
set(SanitizerKind::Null,
true);
1513 LValue LV = EmitLValueHelper(E, IsKnownNonNull);
1522 if (isa<OpaqueValueExpr>(SE))
1524 return cast<CallExpr>(SE)->getCallReturnType(Ctx)->
getPointeeType();
1527LValue CodeGenFunction::EmitLValueHelper(
const Expr *E,
1533 case Expr::ObjCPropertyRefExprClass:
1534 llvm_unreachable(
"cannot emit a property reference directly");
1536 case Expr::ObjCSelectorExprClass:
1538 case Expr::ObjCIsaExprClass:
1540 case Expr::BinaryOperatorClass:
1542 case Expr::CompoundAssignOperatorClass: {
1545 Ty = AT->getValueType();
1550 case Expr::CallExprClass:
1551 case Expr::CXXMemberCallExprClass:
1552 case Expr::CXXOperatorCallExprClass:
1553 case Expr::UserDefinedLiteralClass:
1555 case Expr::CXXRewrittenBinaryOperatorClass:
1556 return EmitLValue(cast<CXXRewrittenBinaryOperator>(E)->getSemanticForm(),
1558 case Expr::VAArgExprClass:
1560 case Expr::DeclRefExprClass:
1562 case Expr::ConstantExprClass: {
1568 return EmitLValue(cast<ConstantExpr>(E)->getSubExpr(), IsKnownNonNull);
1570 case Expr::ParenExprClass:
1571 return EmitLValue(cast<ParenExpr>(E)->getSubExpr(), IsKnownNonNull);
1572 case Expr::GenericSelectionExprClass:
1573 return EmitLValue(cast<GenericSelectionExpr>(E)->getResultExpr(),
1575 case Expr::PredefinedExprClass:
1577 case Expr::StringLiteralClass:
1579 case Expr::ObjCEncodeExprClass:
1581 case Expr::PseudoObjectExprClass:
1583 case Expr::InitListExprClass:
1585 case Expr::CXXTemporaryObjectExprClass:
1586 case Expr::CXXConstructExprClass:
1588 case Expr::CXXBindTemporaryExprClass:
1590 case Expr::CXXUuidofExprClass:
1592 case Expr::LambdaExprClass:
1595 case Expr::ExprWithCleanupsClass: {
1596 const auto *cleanups = cast<ExprWithCleanups>(E);
1597 RunCleanupsScope
Scope(*
this);
1604 Scope.ForceCleanup({&
V});
1614 case Expr::CXXDefaultArgExprClass: {
1615 auto *DAE = cast<CXXDefaultArgExpr>(E);
1616 CXXDefaultArgExprScope
Scope(*
this, DAE);
1617 return EmitLValue(DAE->getExpr(), IsKnownNonNull);
1619 case Expr::CXXDefaultInitExprClass: {
1620 auto *DIE = cast<CXXDefaultInitExpr>(E);
1621 CXXDefaultInitExprScope
Scope(*
this, DIE);
1622 return EmitLValue(DIE->getExpr(), IsKnownNonNull);
1624 case Expr::CXXTypeidExprClass:
1627 case Expr::ObjCMessageExprClass:
1629 case Expr::ObjCIvarRefExprClass:
1631 case Expr::StmtExprClass:
1633 case Expr::UnaryOperatorClass:
1635 case Expr::ArraySubscriptExprClass:
1637 case Expr::MatrixSubscriptExprClass:
1639 case Expr::OMPArraySectionExprClass:
1641 case Expr::ExtVectorElementExprClass:
1643 case Expr::CXXThisExprClass:
1645 case Expr::MemberExprClass:
1647 case Expr::CompoundLiteralExprClass:
1649 case Expr::ConditionalOperatorClass:
1651 case Expr::BinaryConditionalOperatorClass:
1653 case Expr::ChooseExprClass:
1654 return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(), IsKnownNonNull);
1655 case Expr::OpaqueValueExprClass:
1657 case Expr::SubstNonTypeTemplateParmExprClass:
1658 return EmitLValue(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement(),
1660 case Expr::ImplicitCastExprClass:
1661 case Expr::CStyleCastExprClass:
1662 case Expr::CXXFunctionalCastExprClass:
1663 case Expr::CXXStaticCastExprClass:
1664 case Expr::CXXDynamicCastExprClass:
1665 case Expr::CXXReinterpretCastExprClass:
1666 case Expr::CXXConstCastExprClass:
1667 case Expr::CXXAddrspaceCastExprClass:
1668 case Expr::ObjCBridgedCastExprClass:
1671 case Expr::MaterializeTemporaryExprClass:
1674 case Expr::CoawaitExprClass:
1676 case Expr::CoyieldExprClass:
1678 case Expr::PackIndexingExprClass:
1679 return EmitLValue(cast<PackIndexingExpr>(E)->getSelectedExpr());
1686 assert(
type.isCanonical());
1687 assert(!
type->isReferenceType());
1695 if (
const auto *RT = dyn_cast<RecordType>(
type))
1696 if (
const auto *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
1697 if (RD->hasMutableFields() || !RD->isTrivial())
1718 if (
const auto *ref = dyn_cast<ReferenceType>(
type)) {
1734CodeGenFunction::ConstantEmission
1740 if (isa<ParmVarDecl>(value)) {
1742 }
else if (
auto *var = dyn_cast<VarDecl>(value)) {
1744 }
else if (isa<EnumConstantDecl>(value)) {
1749 if (CEK ==
CEK_None)
return ConstantEmission();
1752 bool resultIsReference;
1758 resultIsReference =
false;
1759 resultType = refExpr->
getType();
1764 resultIsReference =
true;
1765 resultType = value->
getType();
1769 return ConstantEmission();
1774 return ConstantEmission();
1785 auto *MD = dyn_cast_or_null<CXXMethodDecl>(
CurCodeDecl);
1786 if (MD && MD->getParent()->isLambda() &&
1787 MD->getOverloadedOperator() == OO_Call) {
1790 if (
const VarDecl *VD = dyn_cast<const VarDecl>(D)) {
1791 if (!VD->hasAttr<CUDADeviceAttr>()) {
1792 return ConstantEmission();
1801 result.
Val, resultType);
1805 if (isa<VarDecl>(value)) {
1806 if (!
getContext().DeclMustBeEmitted(cast<VarDecl>(value)))
1809 assert(isa<EnumConstantDecl>(value));
1814 if (resultIsReference)
1832CodeGenFunction::ConstantEmission
1836 return ConstantEmission();
1840 const CodeGenFunction::ConstantEmission &Constant,
Expr *E) {
1841 assert(Constant &&
"not a constant");
1842 if (Constant.isReference())
1846 return Constant.getValue();
1861 return ET->getDecl()->getIntegerType()->isBooleanType();
1870 llvm::APInt &
Min, llvm::APInt &End,
1871 bool StrictEnums,
bool IsBool) {
1873 bool IsRegularCPlusPlusEnum = CGF.
getLangOpts().CPlusPlus && StrictEnums &&
1875 if (!IsBool && !IsRegularCPlusPlusEnum)
1888llvm::MDNode *CodeGenFunction::getRangeForLoadFromType(
QualType Ty) {
1889 llvm::APInt
Min, End;
1895 return MDHelper.createRange(
Min, End);
1900 bool HasBoolCheck =
SanOpts.
has(SanitizerKind::Bool);
1901 bool HasEnumCheck =
SanOpts.
has(SanitizerKind::Enum);
1902 if (!HasBoolCheck && !HasEnumCheck)
1907 bool NeedsBoolCheck = HasBoolCheck && IsBool;
1908 bool NeedsEnumCheck = HasEnumCheck && Ty->
getAs<
EnumType>();
1909 if (!NeedsBoolCheck && !NeedsEnumCheck)
1916 cast<llvm::IntegerType>(
Value->
getType())->getBitWidth() == 1)
1919 llvm::APInt
Min, End;
1924 SanitizerScope SanScope(
this);
1928 Check =
Builder.CreateICmpULE(
Value, llvm::ConstantInt::get(Ctx, End));
1930 llvm::Value *Upper =
1931 Builder.CreateICmpSLE(
Value, llvm::ConstantInt::get(Ctx, End));
1932 llvm::Value *Lower =
1934 Check =
Builder.CreateAnd(Upper, Lower);
1939 NeedsEnumCheck ? SanitizerKind::Enum : SanitizerKind::Bool;
1940 EmitCheck(std::make_pair(Check, Kind), SanitizerHandler::LoadInvalidValue,
1950 bool isNontemporal) {
1951 if (
auto *GV = dyn_cast<llvm::GlobalValue>(Addr.
getPointer()))
1952 if (GV->isThreadLocal())
1958 if (ClangVecTy->isExtVectorBoolType()) {
1960 unsigned ValNumElems =
1961 cast<llvm::FixedVectorType>(ValTy)->getNumElements();
1964 const auto *RawIntTy = RawIntV->getType();
1965 assert(RawIntTy->isIntegerTy() &&
"compressed iN storage for bitvectors");
1967 auto *PaddedVecTy = llvm::FixedVectorType::get(
1968 Builder.getInt1Ty(), RawIntTy->getPrimitiveSizeInBits());
1969 llvm::Value *
V =
Builder.CreateBitCast(RawIntV, PaddedVecTy);
1978 const auto *VTy = cast<llvm::FixedVectorType>(EltTy);
1982 llvm::VectorType *vec4Ty =
1983 llvm::FixedVectorType::get(VTy->getElementType(), 4);
2002 if (isNontemporal) {
2003 llvm::MDNode *
Node = llvm::MDNode::get(
2004 Load->getContext(), llvm::ConstantAsMetadata::get(
Builder.getInt32(1)));
2005 Load->setMetadata(llvm::LLVMContext::MD_nontemporal,
Node);
2014 if (llvm::MDNode *RangeInfo = getRangeForLoadFromType(Ty)) {
2015 Load->setMetadata(llvm::LLVMContext::MD_range, RangeInfo);
2016 Load->setMetadata(llvm::LLVMContext::MD_noundef,
2031 "wrong value rep of bool");
2041 "wrong value rep of bool");
2047 auto *PaddedVecTy = llvm::FixedVectorType::get(
2048 Builder.getInt1Ty(), RawIntTy->getPrimitiveSizeInBits());
2052 unsigned ValNumElems = cast<llvm::FixedVectorType>(ValTy)->getNumElements();
2062 bool IsVector =
true) {
2063 auto *ArrayTy = dyn_cast<llvm::ArrayType>(Addr.
getElementType());
2064 if (ArrayTy && IsVector) {
2065 auto *VectorTy = llvm::FixedVectorType::get(ArrayTy->getElementType(),
2066 ArrayTy->getNumElements());
2070 auto *VectorTy = dyn_cast<llvm::VectorType>(Addr.
getElementType());
2071 if (VectorTy && !IsVector) {
2072 auto *ArrayTy = llvm::ArrayType::get(
2073 VectorTy->getElementType(),
2074 cast<llvm::FixedVectorType>(VectorTy)->getNumElements());
2088 value->getType()->isVectorTy());
2098 bool isInit,
bool isNontemporal) {
2099 if (
auto *GV = dyn_cast<llvm::GlobalValue>(Addr.
getPointer()))
2100 if (GV->isThreadLocal())
2106 auto *VecTy = dyn_cast<llvm::FixedVectorType>(SrcTy);
2107 if (VecTy && ClangVecTy->isExtVectorBoolType()) {
2110 unsigned MemNumElems = MemIntTy->getPrimitiveSizeInBits();
2117 if (VecTy && cast<llvm::FixedVectorType>(VecTy)->getNumElements() == 3) {
2121 SrcTy = llvm::FixedVectorType::get(VecTy->getElementType(), 4);
2140 if (isNontemporal) {
2141 llvm::MDNode *
Node =
2142 llvm::MDNode::get(
Store->getContext(),
2143 llvm::ConstantAsMetadata::get(
Builder.getInt32(1)));
2144 Store->setMetadata(llvm::LLVMContext::MD_nontemporal,
Node);
2225 llvm::MatrixBuilder MB(
Builder);
2226 MB.CreateIndexAssumption(Idx, MatTy->getNumElementsFlattened());
2228 llvm::LoadInst *
Load =
2233 assert(LV.
isBitField() &&
"Unknown LValue type!");
2251 const unsigned StorageSize =
2254 assert(
static_cast<unsigned>(Offset + Info.
Size) <= StorageSize);
2255 unsigned HighBits = StorageSize - Offset - Info.
Size;
2257 Val =
Builder.CreateShl(Val, HighBits,
"bf.shl");
2258 if (Offset + HighBits)
2259 Val =
Builder.CreateAShr(Val, Offset + HighBits,
"bf.ashr");
2262 Val =
Builder.CreateLShr(Val, Offset,
"bf.lshr");
2263 if (
static_cast<unsigned>(Offset) + Info.
Size < StorageSize)
2265 Val, llvm::APInt::getLowBitsSet(StorageSize, Info.
Size),
"bf.clear");
2281 llvm::Type *DstTy = llvm::FixedVectorType::get(Vec->getType(), 1);
2283 Vec =
Builder.CreateInsertElement(DstTy, Vec, Zero,
"cast.splat");
2293 llvm::Value *Elt = llvm::ConstantInt::get(
SizeTy, InIdx);
2301 for (
unsigned i = 0; i != NumResultElts; ++i)
2304 Vec =
Builder.CreateShuffleVector(Vec, Mask);
2323 return VectorBasePtrPlusIx;
2329 "Bad type for register variable");
2330 llvm::MDNode *RegName = cast<llvm::MDNode>(
2331 cast<llvm::MetadataAsValue>(LV.
getGlobalReg())->getMetadata());
2335 llvm::Type *Ty = OrigTy;
2336 if (OrigTy->isPointerTy())
2338 llvm::Type *Types[] = { Ty };
2340 llvm::Function *F =
CGM.
getIntrinsic(llvm::Intrinsic::read_register, Types);
2342 F, llvm::MetadataAsValue::get(Ty->getContext(), RegName));
2343 if (OrigTy->isPointerTy())
2358 auto *IRStoreTy = dyn_cast<llvm::IntegerType>(Vec->getType());
2360 auto *IRVecTy = llvm::FixedVectorType::get(
2361 Builder.getInt1Ty(), IRStoreTy->getPrimitiveSizeInBits());
2362 Vec =
Builder.CreateBitCast(Vec, IRVecTy);
2369 Vec =
Builder.CreateBitCast(Vec, IRStoreTy);
2388 llvm::MatrixBuilder MB(
Builder);
2389 MB.CreateIndexAssumption(Idx, MatTy->getNumElementsFlattened());
2399 assert(Dst.
isBitField() &&
"Unknown LValue type");
2407 llvm_unreachable(
"present but none");
2455 RHS =
Builder.CreatePtrToInt(RHS, ResultType,
"sub.ptr.rhs.cast");
2458 "sub.ptr.lhs.cast");
2459 llvm::Value *BytesBetween =
Builder.CreateSub(LHS, RHS,
"ivar.offset");
2471 assert(Src.
isScalar() &&
"Can't emit an agg store with this method");
2487 llvm::Value *MaskedVal = SrcVal;
2489 const bool UseVolatile =
2492 const unsigned StorageSize =
2497 if (StorageSize != Info.
Size) {
2498 assert(StorageSize > Info.
Size &&
"Invalid bitfield size.");
2505 SrcVal, llvm::APInt::getLowBitsSet(StorageSize, Info.
Size),
2509 SrcVal =
Builder.CreateShl(SrcVal, Offset,
"bf.shl");
2513 Val, ~llvm::APInt::getBitsSet(StorageSize, Offset, Offset + Info.
Size),
2517 SrcVal =
Builder.CreateOr(Val, SrcVal,
"bf.set");
2519 assert(Offset == 0);
2535 llvm::Value *ResultVal = MaskedVal;
2539 assert(Info.
Size <= StorageSize);
2540 unsigned HighBits = StorageSize - Info.
Size;
2542 ResultVal =
Builder.CreateShl(ResultVal, HighBits,
"bf.result.shl");
2543 ResultVal =
Builder.CreateAShr(ResultVal, HighBits,
"bf.result.ashr");
2561 "this should only occur for non-vector l-values");
2574 unsigned NumSrcElts = VTy->getNumElements();
2575 unsigned NumDstElts =
2576 cast<llvm::FixedVectorType>(Vec->getType())->getNumElements();
2577 if (NumDstElts == NumSrcElts) {
2582 for (
unsigned i = 0; i != NumSrcElts; ++i)
2585 Vec =
Builder.CreateShuffleVector(SrcVal, Mask);
2586 }
else if (NumDstElts > NumSrcElts) {
2592 for (
unsigned i = 0; i != NumSrcElts; ++i)
2593 ExtMask.push_back(i);
2594 ExtMask.resize(NumDstElts, -1);
2595 llvm::Value *ExtSrcVal =
Builder.CreateShuffleVector(SrcVal, ExtMask);
2598 for (
unsigned i = 0; i != NumDstElts; ++i)
2608 for (
unsigned i = 0; i != NumSrcElts; ++i)
2610 Vec =
Builder.CreateShuffleVector(Vec, ExtSrcVal, Mask);
2613 llvm_unreachable(
"unexpected shorten vector length");
2619 llvm::Value *Elt = llvm::ConstantInt::get(
SizeTy, InIdx);
2620 Vec =
Builder.CreateInsertElement(Vec, SrcVal, Elt);
2630 "Bad type for register variable");
2631 llvm::MDNode *RegName = cast<llvm::MDNode>(
2632 cast<llvm::MetadataAsValue>(Dst.
getGlobalReg())->getMetadata());
2633 assert(RegName &&
"Register LValue is not metadata");
2637 llvm::Type *Ty = OrigTy;
2638 if (OrigTy->isPointerTy())
2640 llvm::Type *Types[] = { Ty };
2642 llvm::Function *F =
CGM.
getIntrinsic(llvm::Intrinsic::write_register, Types);
2644 if (OrigTy->isPointerTy())
2647 F, {llvm::MetadataAsValue::get(Ty->getContext(), RegName),
Value});
2655 bool IsMemberAccess=
false) {
2659 if (isa<ObjCIvarRefExpr>(E)) {
2672 auto *Exp = cast<ObjCIvarRefExpr>(
const_cast<Expr *
>(E));
2678 if (
const auto *Exp = dyn_cast<DeclRefExpr>(E)) {
2679 if (
const auto *VD = dyn_cast<VarDecl>(Exp->getDecl())) {
2680 if (VD->hasGlobalStorage()) {
2689 if (
const auto *Exp = dyn_cast<UnaryOperator>(E)) {
2694 if (
const auto *Exp = dyn_cast<ParenExpr>(E)) {
2708 if (
const auto *Exp = dyn_cast<GenericSelectionExpr>(E)) {
2713 if (
const auto *Exp = dyn_cast<ImplicitCastExpr>(E)) {
2718 if (
const auto *Exp = dyn_cast<CStyleCastExpr>(E)) {
2723 if (
const auto *Exp = dyn_cast<ObjCBridgedCastExpr>(E)) {
2728 if (
const auto *Exp = dyn_cast<ArraySubscriptExpr>(E)) {
2741 if (
const auto *Exp = dyn_cast<MemberExpr>(E)) {
2755 CGF, VD, Addr, Loc);
2766 std::optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
2767 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD);
2771 if (!Res || ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
2772 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
2775 assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
2776 ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
2777 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
2779 "Expected link clause OR to clause with unified memory enabled.");
2789 llvm::LoadInst *
Load =
2795 PointeeType, PointeeBaseInfo, PointeeTBAAInfo,
2806 PointeeBaseInfo, PointeeTBAAInfo);
2847 V = CGF.
Builder.CreateThreadLocalAddress(
V);
2851 Address Addr(
V, RealVarTy, Alignment);
2855 VD->
hasAttr<OMPThreadPrivateDeclAttr>()) {
2870 if (FD->
hasAttr<WeakRefAttr>()) {
2889 llvm::Value *ThisValue) {
2902 AsmLabelAttr *
Asm = VD->
getAttr<AsmLabelAttr>();
2903 assert(
Asm->getLabel().size() < 64-Name.size() &&
2904 "Register name too big");
2905 Name.append(
Asm->getLabel());
2906 llvm::NamedMDNode *M =
2907 CGM.
getModule().getOrInsertNamedMetadata(Name);
2908 if (M->getNumOperands() == 0) {
2911 llvm::Metadata *Ops[] = {Str};
2918 llvm::MetadataAsValue::get(CGM.
getLLVMContext(), M->getOperand(0));
2961 case llvm::GlobalValue::ExternalLinkage:
2962 case llvm::GlobalValue::LinkOnceODRLinkage:
2963 case llvm::GlobalValue::WeakODRLinkage:
2964 case llvm::GlobalValue::InternalLinkage:
2965 case llvm::GlobalValue::PrivateLinkage:
2977 "should not emit an unevaluated operand");
2979 if (
const auto *VD = dyn_cast<VarDecl>(ND)) {
2982 VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())
2990 (VD->getType()->isReferenceType() ||
2992 VD->getAnyInitializer(VD);
2994 E->
getLocation(), *VD->evaluateValue(), VD->getType());
2995 assert(Val &&
"failed to emit constant expression");
2998 if (!VD->getType()->isReferenceType()) {
3003 auto *PTy = llvm::PointerType::get(
3004 VarTy,
getTypes().getTargetAddressSpace(VD->getType()));
3022 VD = VD->getCanonicalDecl();
3026 auto I = LocalDeclMap.find(VD);
3027 if (I != LocalDeclMap.end()) {
3029 if (VD->getType()->isReferenceType())
3069 "Should not use decl without marking it used!");
3071 if (ND->
hasAttr<WeakRefAttr>()) {
3072 const auto *VD = cast<ValueDecl>(ND);
3077 if (
const auto *VD = dyn_cast<VarDecl>(ND)) {
3079 if (VD->hasLinkage() || VD->isStaticDataMember())
3085 auto iter = LocalDeclMap.find(VD);
3086 if (iter != LocalDeclMap.end()) {
3087 addr = iter->second;
3091 }
else if (VD->isStaticLocal()) {
3099 llvm_unreachable(
"DeclRefExpr for Decl not entered in LocalDeclMap?");
3109 VD->hasAttr<OMPThreadPrivateDeclAttr>()) {
3116 bool isBlockByref = VD->isEscapingByref();
3126 bool isLocalStorage = VD->hasLocalStorage();
3128 bool NonGCable = isLocalStorage &&
3136 bool isImpreciseLifetime =
3137 (isLocalStorage && !VD->hasAttr<ObjCPreciseLifetimeAttr>());
3138 if (isImpreciseLifetime)
3144 if (
const auto *FD = dyn_cast<FunctionDecl>(ND)) {
3148 if (
getContext().getTargetInfo().allowDebugInfoForExternalRef()) {
3151 cast<llvm::Function>(LV.
getPointer(*this)->stripPointerCasts());
3152 if (!Fn->getSubprogram())
3153 DI->EmitFunctionDecl(FD, FD->
getLocation(), T, Fn);
3163 if (
const auto *BD = dyn_cast<BindingDecl>(ND)) {
3173 if (
const auto *GD = dyn_cast<MSGuidDecl>(ND))
3177 if (
const auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
3183 auto PtrTy = ATPO.getElementType()->getPointerTo(TargetAS);
3186 ATPO =
ConstantAddress(ASC, ATPO.getElementType(), ATPO.getAlignment());
3192 llvm_unreachable(
"Unhandled DeclRefExpr");
3202 default: llvm_unreachable(
"Unknown unary operator lvalue!");
3205 assert(!T.
isNull() &&
"CodeGenFunction::EmitUnaryOpLValue: Illegal type");
3227 assert(LV.
isSimple() &&
"real/imag on non-ordinary l-value");
3251 bool isInc = E->
getOpcode() == UO_PreInc;
3274 assert(SL !=
nullptr &&
"No StringLiteral name in PredefinedExpr");
3275 StringRef FnName =
CurFn->getName();
3276 if (FnName.starts_with(
"\01"))
3277 FnName = FnName.substr(1);
3278 StringRef NameItems[] = {
3280 std::string GVName = llvm::join(NameItems, NameItems + 2,
".");
3281 if (
auto *BD = dyn_cast_or_null<BlockDecl>(
CurCodeDecl)) {
3282 std::string Name = std::string(SL->getString());
3283 if (!Name.empty()) {
3284 unsigned Discriminator =
3287 Name +=
"_" + Twine(Discriminator + 1).str();
3314 uint16_t TypeKind = -1;
3331 StringRef(), std::nullopt, Buffer, std::nullopt);
3333 llvm::Constant *Components[] = {
3337 llvm::Constant *Descriptor = llvm::ConstantStruct::getAnon(Components);
3339 auto *GV =
new llvm::GlobalVariable(
3341 true, llvm::GlobalVariable::PrivateLinkage, Descriptor);
3342 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3354 if (
V->getType() == TargetTy)
3359 if (
V->getType()->isFloatingPointTy()) {
3360 unsigned Bits =
V->getType()->getPrimitiveSizeInBits().getFixedValue();
3361 if (Bits <= TargetTy->getIntegerBitWidth())
3367 if (
V->getType()->isIntegerTy() &&
3368 V->getType()->getIntegerBitWidth() <= TargetTy->getIntegerBitWidth())
3369 return Builder.CreateZExt(
V, TargetTy);
3372 if (!
V->getType()->isPointerTy()) {
3377 return Builder.CreatePtrToInt(
V, TargetTy);
3397 int PathComponentsToStrip =
3399 if (PathComponentsToStrip < 0) {
3400 assert(PathComponentsToStrip !=
INT_MIN);
3401 int PathComponentsToKeep = -PathComponentsToStrip;
3402 auto I = llvm::sys::path::rbegin(FilenameString);
3403 auto E = llvm::sys::path::rend(FilenameString);
3404 while (I != E && --PathComponentsToKeep)
3407 FilenameString = FilenameString.substr(I - E);
3408 }
else if (PathComponentsToStrip > 0) {
3409 auto I = llvm::sys::path::begin(FilenameString);
3410 auto E = llvm::sys::path::end(FilenameString);
3411 while (I != E && PathComponentsToStrip--)
3416 FilenameString.substr(I - llvm::sys::path::begin(FilenameString));
3418 FilenameString = llvm::sys::path::filename(FilenameString);
3424 cast<llvm::GlobalVariable>(
3425 FilenameGV.getPointer()->stripPointerCasts()));
3426 Filename = FilenameGV.getPointer();
3437 return llvm::ConstantStruct::getAnon(
Data);
3442enum class CheckRecoverableKind {
3454 assert(Kind.countPopulation() == 1);
3455 if (Kind == SanitizerKind::Vptr)
3456 return CheckRecoverableKind::AlwaysRecoverable;
3457 else if (Kind == SanitizerKind::Return || Kind == SanitizerKind::Unreachable)
3458 return CheckRecoverableKind::Unrecoverable;
3460 return CheckRecoverableKind::Recoverable;
3464struct SanitizerHandlerInfo {
3465 char const *
const Name;
3471#define SANITIZER_CHECK(Enum, Name, Version) {#Name, Version},
3473#undef SANITIZER_CHECK
3477 llvm::FunctionType *FnType,
3480 CheckRecoverableKind RecoverKind,
bool IsFatal,
3481 llvm::BasicBlock *ContBB) {
3482 assert(IsFatal || RecoverKind != CheckRecoverableKind::Unrecoverable);
3483 std::optional<ApplyDebugLocation> DL;
3484 if (!CGF.
Builder.getCurrentDebugLocation()) {
3488 bool NeedsAbortSuffix =
3489 IsFatal && RecoverKind != CheckRecoverableKind::Unrecoverable;
3492 const StringRef CheckName = CheckInfo.Name;
3493 std::string FnName =
"__ubsan_handle_" + CheckName.str();
3494 if (CheckInfo.Version && !MinimalRuntime)
3495 FnName +=
"_v" + llvm::utostr(CheckInfo.Version);
3497 FnName +=
"_minimal";
3498 if (NeedsAbortSuffix)
3501 !IsFatal || RecoverKind == CheckRecoverableKind::AlwaysRecoverable;
3505 B.addAttribute(llvm::Attribute::NoReturn)
3506 .addAttribute(llvm::Attribute::NoUnwind);
3508 B.addUWTableAttr(llvm::UWTableKind::Default);
3513 llvm::AttributeList::FunctionIndex, B),
3517 HandlerCall->setDoesNotReturn();
3518 CGF.
Builder.CreateUnreachable();
3525 ArrayRef<std::pair<llvm::Value *, SanitizerMask>> Checked,
3529 assert(Checked.size() > 0);
3530 assert(CheckHandler >= 0 &&
3534 llvm::Value *FatalCond =
nullptr;
3535 llvm::Value *RecoverableCond =
nullptr;
3536 llvm::Value *TrapCond =
nullptr;
3537 for (
int i = 0, n = Checked.size(); i < n; ++i) {
3538 llvm::Value *Check = Checked[i].first;
3540 llvm::Value *&Cond =
3546 Cond = Cond ?
Builder.CreateAnd(Cond, Check) : Check;
3551 if (!FatalCond && !RecoverableCond)
3554 llvm::Value *JointCond;
3555 if (FatalCond && RecoverableCond)
3556 JointCond =
Builder.CreateAnd(FatalCond, RecoverableCond);
3558 JointCond = FatalCond ? FatalCond : RecoverableCond;
3564 for (
int i = 1, n = Checked.size(); i < n; ++i) {
3566 "All recoverable kinds in a single check must be same!");
3573 llvm::Instruction *Branch =
Builder.CreateCondBr(JointCond, Cont, Handlers);
3577 llvm::MDNode *
Node = MDHelper.createBranchWeights((1U << 20) - 1, 1);
3578 Branch->setMetadata(llvm::LLVMContext::MD_prof,
Node);
3587 Args.reserve(DynamicArgs.size() + 1);
3588 ArgTypes.reserve(DynamicArgs.size() + 1);
3591 if (!StaticArgs.empty()) {
3592 llvm::Constant *Info = llvm::ConstantStruct::getAnon(StaticArgs);
3593 auto *InfoPtr =
new llvm::GlobalVariable(
3595 llvm::GlobalVariable::PrivateLinkage, Info,
"",
nullptr,
3596 llvm::GlobalVariable::NotThreadLocal,
3598 InfoPtr->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3600 Args.push_back(InfoPtr);
3601 ArgTypes.push_back(Args.back()->getType());
3604 for (
size_t i = 0, n = DynamicArgs.size(); i != n; ++i) {
3610 llvm::FunctionType *FnType =
3611 llvm::FunctionType::get(
CGM.
VoidTy, ArgTypes,
false);
3613 if (!FatalCond || !RecoverableCond) {
3617 (FatalCond !=
nullptr), Cont);
3621 llvm::BasicBlock *NonFatalHandlerBB =
3624 Builder.CreateCondBr(FatalCond, NonFatalHandlerBB, FatalHandlerBB);
3637 SanitizerMask Kind, llvm::Value *Cond, llvm::ConstantInt *TypeId,
3642 llvm::BranchInst *BI =
Builder.CreateCondBr(Cond, Cont, CheckBB);
3645 llvm::MDNode *
Node = MDHelper.createBranchWeights((1U << 20) - 1, 1);
3646 BI->setMetadata(llvm::LLVMContext::MD_prof,
Node);
3652 llvm::CallInst *CheckCall;
3653 llvm::FunctionCallee SlowPathFn;
3655 llvm::Constant *Info = llvm::ConstantStruct::getAnon(StaticArgs);
3657 new llvm::GlobalVariable(
CGM.
getModule(), Info->getType(),
false,
3658 llvm::GlobalVariable::PrivateLinkage, Info);
3659 InfoPtr->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3663 "__cfi_slowpath_diag",
3666 CheckCall =
Builder.CreateCall(SlowPathFn, {TypeId, Ptr, InfoPtr});
3671 CheckCall =
Builder.CreateCall(SlowPathFn, {TypeId, Ptr});
3675 cast<llvm::GlobalValue>(SlowPathFn.getCallee()->stripPointerCasts()));
3676 CheckCall->setDoesNotThrow();
3685 auto &Ctx = M->getContext();
3686 llvm::Function *F = llvm::Function::Create(
3688 llvm::GlobalValue::WeakAnyLinkage,
"__cfi_check", M);
3689 F->setAlignment(llvm::Align(4096));
3691 llvm::BasicBlock *BB = llvm::BasicBlock::Create(Ctx,
"entry", F);
3694 llvm::CallInst::Create(M->getFunction(
"__cfi_check_fail"), Args,
"", BB);
3695 llvm::ReturnInst::Create(Ctx,
nullptr, BB);
3706 SanitizerScope SanScope(
this);
3712 Args.push_back(&ArgData);
3713 Args.push_back(&ArgAddr);
3718 llvm::Function *F = llvm::Function::Create(
3720 llvm::GlobalValue::WeakODRLinkage,
"__cfi_check_fail", &
CGM.
getModule());
3724 F->setVisibility(llvm::GlobalValue::HiddenVisibility);
3742 llvm::Value *DataIsNotNullPtr =
3744 EmitTrapCheck(DataIsNotNullPtr, SanitizerHandler::CFICheckFail);
3746 llvm::StructType *SourceLocationTy =
3748 llvm::StructType *CfiCheckFailDataTy =
3751 llvm::Value *
V =
Builder.CreateConstGEP2_32(
3753 Builder.CreatePointerCast(
Data, CfiCheckFailDataTy->getPointerTo(0)), 0,
3759 llvm::Value *AllVtables = llvm::MetadataAsValue::get(
3762 llvm::Value *ValidVtable =
Builder.CreateZExt(
3764 {Addr, AllVtables}),
3767 const std::pair<int, SanitizerMask> CheckKinds[] = {
3775 for (
auto CheckKindMaskPair : CheckKinds) {
3776 int Kind = CheckKindMaskPair.first;
3779 Builder.CreateICmpNE(CheckKind, llvm::ConstantInt::get(
Int8Ty, Kind));
3781 EmitCheck(std::make_pair(Cond, Mask), SanitizerHandler::CFICheckFail, {},
3782 {
Data, Addr, ValidVtable});
3794 if (
SanOpts.
has(SanitizerKind::Unreachable)) {
3795 SanitizerScope SanScope(
this);
3797 SanitizerKind::Unreachable),
3798 SanitizerHandler::BuiltinUnreachable,
3810 if ((
int)TrapBBs.size() <= CheckHandlerID)
3811 TrapBBs.resize(CheckHandlerID + 1);
3813 llvm::BasicBlock *&TrapBB = TrapBBs[CheckHandlerID];
3818 auto Call = TrapBB->begin();
3819 assert(isa<llvm::CallInst>(
Call) &&
"Expected call in trap BB");
3821 Call->applyMergedLocation(
Call->getDebugLoc(),
3822 Builder.getCurrentDebugLocation());
3823 Builder.CreateCondBr(Checked, Cont, TrapBB);
3826 Builder.CreateCondBr(Checked, Cont, TrapBB);
3829 llvm::CallInst *TrapCall =
Builder.CreateCall(
3832 ? TrapBB->getParent()->size()
3836 auto A = llvm::Attribute::get(
getLLVMContext(),
"trap-func-name",
3838 TrapCall->addFnAttr(A);
3840 TrapCall->setDoesNotReturn();
3841 TrapCall->setDoesNotThrow();
3849 llvm::CallInst *TrapCall =
3853 auto A = llvm::Attribute::get(
getLLVMContext(),
"trap-func-name",
3855 TrapCall->addFnAttr(A);
3865 "Array to pointer decay must have array source type!");
3880 "Expected pointer to array");
3900 const auto *CE = dyn_cast<CastExpr>(E);
3901 if (!CE || CE->getCastKind() != CK_ArrayToPointerDecay)
3913 llvm::Type *elemType,
3919 const llvm::Twine &name =
"arrayidx") {
3934 if (
auto constantIdx = dyn_cast<llvm::ConstantInt>(idx)) {
3935 CharUnits offset = constantIdx->getZExtValue() * eltSize;
3954 return D && D->
hasAttr<BPFPreserveStaticOffsetAttr>();
3961 if (PointeeType.
isNull())
3974 llvm::Function *Fn =
3994 if (
const auto *ME = dyn_cast<MemberExpr>(E))
3997 if (
const auto *DRE = dyn_cast<DeclRefExpr>(E)) {
3998 const auto *VarDef = dyn_cast<VarDecl>(DRE->getDecl());
4002 const auto *PtrT = VarDef->getType()->getAs<
PointerType>();
4008 if (
const auto *RecT = dyn_cast<RecordType>(PointeeT))
4009 return RecT->getDecl()->
hasAttr<BPFPreserveAccessIndexAttr>();
4022 const llvm::Twine &name =
"arrayidx") {
4025 for (
auto *idx : indices.drop_back())
4026 assert(isa<llvm::ConstantInt>(idx) &&
4027 cast<llvm::ConstantInt>(idx)->isZero());
4044 llvm::Value *eltPtr;
4045 auto LastIndex = dyn_cast<llvm::ConstantInt>(indices.back());
4050 signedIndices, loc, name);
4053 unsigned idx = LastIndex->getZExtValue();
4054 llvm::DIType *DbgInfo =
nullptr;
4071 unsigned FieldNo = 0;
4074 if (
const auto *
Record = dyn_cast<RecordDecl>(D))
4080 if (
const auto *Field = dyn_cast<FieldDecl>(D))
4086 if (isa<FieldDecl>(D))
4106 if (FD1OuterRec != FD2OuterRec)
4108 return std::optional<int64_t>();
4110 int64_t FD1Offset = 0;
4112 return std::optional<int64_t>();
4114 int64_t FD2Offset = 0;
4116 return std::optional<int64_t>();
4118 return std::make_optional<int64_t>(FD1Offset - FD2Offset);
4125 llvm::Value *IdxPre =
4127 bool SignedIndices =
false;
4128 auto EmitIdxAfterBase = [&, IdxPre](
bool Promote) -> llvm::Value * {
4131 assert(E->
getRHS() == E->
getIdx() &&
"index was neither LHS nor RHS");
4137 SignedIndices |= IdxSigned;
4143 if (Promote && Idx->getType() !=
IntPtrTy)
4153 !isa<ExtVectorElementExpr>(E->
getBase())) {
4156 auto *Idx = EmitIdxAfterBase(
false);
4157 assert(LHS.
isSimple() &&
"Can only subscript lvalue vectors here!");
4166 if (isa<ExtVectorElementExpr>(E->
getBase())) {
4168 auto *Idx = EmitIdxAfterBase(
true);
4187 auto *Idx = EmitIdxAfterBase(
true);
4197 Idx =
Builder.CreateMul(Idx, numElements);
4199 Idx =
Builder.CreateNSWMul(Idx, numElements);
4211 auto *Idx = EmitIdxAfterBase(
true);
4214 llvm::Value *InterfaceSizeVal =
4215 llvm::ConstantInt::get(Idx->getType(), InterfaceSize.
getQuantity());
4217 llvm::Value *ScaledIdx =
Builder.CreateMul(Idx, InterfaceSizeVal);
4228 llvm::Value *EltPtr =
4231 Addr =
Address(EltPtr, OrigBaseElemTy, EltAlign);
4237 assert(Array->getType()->isArrayType() &&
4238 "Array to pointer decay must have array source type!");
4242 if (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(Array))
4246 auto *Idx = EmitIdxAfterBase(
true);
4248 if (
SanOpts.
has(SanitizerKind::ArrayBounds)) {
4259 if (
const auto *ME = dyn_cast<MemberExpr>(Array);
4265 if (std::optional<int64_t> Diff =
4274 llvm::Type *CountTy =
ConvertType(CountFD->getType());
4275 llvm::Value *Res =
Builder.CreateInBoundsGEP(
4279 ".counted_by.load");
4283 Array->getType(), Accessed);
4292 *
this, ArrayLV.
getAddress(*
this), {CGM.getSize(CharUnits::Zero()), Idx},
4300 auto *Idx = EmitIdxAfterBase(
true);
4321 "incomplete matrix subscript expressions should be rejected during Sema");
4325 llvm::Value *NumRows =
Builder.getIntN(
4326 RowIdx->getType()->getScalarSizeInBits(),
4328 llvm::Value *FinalIdx =
4339 bool IsLowerBound) {
4341 if (
auto *ASE = dyn_cast<OMPArraySectionExpr>(
Base->IgnoreParenImpCasts())) {
4356 "Expected pointer to array");
4375 bool IsLowerBound) {
4378 if (
auto *AT =
getContext().getAsArrayType(BaseTy))
4379 ResultExprTy = AT->getElementType();
4382 llvm::Value *Idx =
nullptr;
4390 LowerBound->getType()->hasSignedIntegerRepresentation());
4392 Idx = llvm::ConstantInt::getNullValue(
IntPtrTy);
4399 llvm::APSInt ConstLength;
4402 if (std::optional<llvm::APSInt> CL = Length->getIntegerConstantExpr(
C)) {
4409 if (std::optional<llvm::APSInt> LB =
4410 LowerBound->getIntegerConstantExpr(
C)) {
4412 LowerBound =
nullptr;
4417 else if (!LowerBound)
4420 if (Length || LowerBound) {
4421 auto *LowerBoundVal =
4425 LowerBound->getType()->hasSignedIntegerRepresentation())
4426 : llvm::ConstantInt::get(
IntPtrTy, ConstLowerBound);
4431 Length->getType()->hasSignedIntegerRepresentation())
4432 : llvm::ConstantInt::get(
IntPtrTy, ConstLength);
4433 Idx =
Builder.CreateAdd(LowerBoundVal, LengthVal,
"lb_add_len",
4436 if (Length && LowerBound) {
4438 Idx, llvm::ConstantInt::get(
IntPtrTy, 1),
"idx_sub_1",
4442 Idx = llvm::ConstantInt::get(
IntPtrTy, ConstLength + ConstLowerBound);
4448 if (
auto *VAT =
C.getAsVariableArrayType(ArrayTy)) {
4449 Length = VAT->getSizeExpr();
4450 if (std::optional<llvm::APSInt> L = Length->getIntegerConstantExpr(
C)) {
4455 auto *CAT =
C.getAsConstantArrayType(ArrayTy);
4456 assert(CAT &&
"unexpected type for array initializer");
4457 ConstLength = CAT->getSize();
4460 auto *LengthVal =
Builder.CreateIntCast(
4462 Length->getType()->hasSignedIntegerRepresentation());
4464 LengthVal, llvm::ConstantInt::get(
IntPtrTy, 1),
"len_sub_1",
4469 Idx = llvm::ConstantInt::get(
IntPtrTy, ConstLength);
4478 if (
auto *VLA =
getContext().getAsVariableArrayType(ResultExprTy)) {
4484 BaseTy, VLA->getElementType(), IsLowerBound);
4493 Idx =
Builder.CreateMul(Idx, NumElements);
4495 Idx =
Builder.CreateNSWMul(Idx, NumElements);
4504 assert(Array->getType()->isArrayType() &&
4505 "Array to pointer decay must have array source type!");
4509 if (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(Array))
4516 *
this, ArrayLV.
getAddress(*
this), {CGM.getSize(CharUnits::Zero()), Idx},
4517 ResultExprTy, !
getLangOpts().isSignedOverflowDefined(),
4523 TBAAInfo, BaseTy, ResultExprTy,
4547 Base.getQuals().removeObjCGCAttr();
4556 "Result must be a vector");
4573 if (
Base.isSimple()) {
4574 llvm::Constant *CV =
4579 assert(
Base.isExtVectorElt() &&
"Can only subscript lvalue vec elts here!");
4581 llvm::Constant *BaseElts =
Base.getExtVectorElts();
4584 for (
unsigned i = 0, e = Indices.size(); i != e; ++i)
4585 CElts.push_back(BaseElts->getAggregateElement(Indices[i]));
4586 llvm::Constant *CV = llvm::ConstantVector::get(CElts);
4608 SkippedChecks.
set(SanitizerKind::Alignment,
true);
4609 if (IsBaseCXXThis || isa<DeclRefExpr>(BaseExpr))
4610 SkippedChecks.
set(SanitizerKind::Null,
true);
4618 if (
auto *Field = dyn_cast<FieldDecl>(ND)) {
4633 if (
const auto *FD = dyn_cast<FunctionDecl>(ND))
4636 llvm_unreachable(
"Unhandled member declaration!");
4643 llvm::Value *ThisValue) {
4644 bool HasExplicitObjectParameter =
false;
4645 if (
const auto *MD = dyn_cast_if_present<CXXMethodDecl>(
CurCodeDecl)) {
4646 HasExplicitObjectParameter = MD->isExplicitObjectMemberFunction();
4647 assert(MD->getParent()->isLambda());
4648 assert(MD->getParent() ==
Field->getParent());
4651 if (HasExplicitObjectParameter) {
4653 auto It = LocalDeclMap.find(D);
4654 assert(It != LocalDeclMap.end() &&
"explicit parameter not loaded?");
4655 Address AddrOfExplicitObject = It->getSecond();
4676 unsigned FieldIndex) {
4677 unsigned I = 0, Skipped = 0;
4680 if (I == FieldIndex)
4682 if (F->isUnnamedBitfield())
4687 return FieldIndex - Skipped;
4696 if (Offset.isZero())
4737 if (RD->isDynamicClass())
4740 for (
const auto &
Base : RD->bases())
4787 llvm::Type *FieldIntTy = llvm::Type::getIntNTy(
getLLVMContext(), SS);
4823 assert(!FieldTBAAInfo.
Offset &&
4824 "Nonzero offset for an access with no base type!");
4837 FieldTBAAInfo.
Size =
4844 if (
auto *ClassDef = dyn_cast<CXXRecordDecl>(rec)) {
4846 ClassDef->isDynamicClass()) {
4871 Builder.CreatePreserveUnionAccessIndex(
4905 if (field->
hasAttr<AnnotateAttr>())
4930 V =
V.withElementType(llvmType);
4975 assert(E->
isTransparent() &&
"non-transparent glvalue init list");
4983 const Expr *Operand) {
4984 if (
auto *ThrowExpr = dyn_cast<CXXThrowExpr>(Operand->IgnoreParens())) {
4986 return std::nullopt;
4995std::optional<LValue> HandleConditionalOperatorLValueSimpleCase(
5002 std::swap(Live, Dead);
5010 if (
auto *ThrowExpr = dyn_cast<CXXThrowExpr>(Live->
IgnoreParens())) {
5012 llvm::Type *ElemTy = CGF.
ConvertType(Dead->getType());
5021 return std::nullopt;
5023struct ConditionalInfo {
5024 llvm::BasicBlock *lhsBlock, *rhsBlock;
5025 std::optional<LValue> LHS, RHS;
5030template<
typename FuncTy>
5033 const FuncTy &BranchGenFunc) {
5039 CodeGenFunction::ConditionalEvaluation eval(CGF);
5049 Info.lhsBlock = CGF.
Builder.GetInsertBlock();
5052 CGF.
Builder.CreateBr(endBlock);
5059 Info.rhsBlock = CGF.
Builder.GetInsertBlock();
5071 "Unexpected conditional operator!");
5075 OpaqueValueMapping binding(*
this, E);
5076 if (HandleConditionalOperatorLValueSimpleCase(*
this, E))
5086 if (!
expr->isGLValue()) {
5089 "Unexpected conditional operator!");
5093 OpaqueValueMapping binding(*
this,
expr);
5094 if (std::optional<LValue> Res =
5095 HandleConditionalOperatorLValueSimpleCase(*
this,
expr))
5098 ConditionalInfo Info = EmitConditionalBlocks(
5103 if ((Info.LHS && !Info.LHS->isSimple()) ||
5104 (Info.RHS && !Info.RHS->isSimple()))
5107 if (Info.LHS && Info.RHS) {
5108 Address lhsAddr = Info.LHS->getAddress(*
this);
5109 Address rhsAddr = Info.RHS->getAddress(*
this);
5110 llvm::PHINode *phi =
Builder.CreatePHI(lhsAddr.
getType(), 2,
"cond-lvalue");
5111 phi->addIncoming(lhsAddr.
getPointer(), Info.lhsBlock);
5112 phi->addIncoming(rhsAddr.
getPointer(), Info.rhsBlock);
5116 std::max(Info.LHS->getBaseInfo().getAlignmentSource(),
5117 Info.RHS->getBaseInfo().getAlignmentSource());
5119 Info.LHS->getTBAAInfo(), Info.RHS->getTBAAInfo());
5123 assert((Info.LHS || Info.RHS) &&
5124 "both operands of glvalue conditional are throw-expressions?");
5125 return Info.LHS ? *Info.LHS : *Info.RHS;
5140 case CK_LValueToRValueBitCast:
5141 case CK_ArrayToPointerDecay:
5142 case CK_FunctionToPointerDecay:
5143 case CK_NullToMemberPointer:
5144 case CK_NullToPointer:
5145 case CK_IntegralToPointer:
5146 case CK_PointerToIntegral:
5147 case CK_PointerToBoolean:
5148 case CK_IntegralCast:
5149 case CK_BooleanToSignedIntegral:
5150 case CK_IntegralToBoolean:
5151 case CK_IntegralToFloating:
5152 case CK_FloatingToIntegral:
5153 case CK_FloatingToBoolean:
5154 case CK_FloatingCast:
5155 case CK_FloatingRealToComplex:
5156 case CK_FloatingComplexToReal:
5157 case CK_FloatingComplexToBoolean:
5158 case CK_FloatingComplexCast:
5159 case CK_FloatingComplexToIntegralComplex:
5160 case CK_IntegralRealToComplex:
5161 case CK_IntegralComplexToReal:
5162 case CK_IntegralComplexToBoolean:
5163 case CK_IntegralComplexCast:
5164 case CK_IntegralComplexToFloatingComplex:
5165 case CK_DerivedToBaseMemberPointer:
5166 case CK_BaseToDerivedMemberPointer:
5167 case CK_MemberPointerToBoolean:
5168 case CK_ReinterpretMemberPointer:
5169 case CK_AnyPointerToBlockPointerCast:
5170 case CK_ARCProduceObject:
5171 case CK_ARCConsumeObject:
5172 case CK_ARCReclaimReturnedObject:
5173 case CK_ARCExtendBlockObject:
5174 case CK_CopyAndAutoreleaseBlockObject:
5175 case CK_IntToOCLSampler:
5176 case CK_FloatingToFixedPoint:
5177 case CK_FixedPointToFloating:
5178 case CK_FixedPointCast:
5179 case CK_FixedPointToBoolean:
5180 case CK_FixedPointToIntegral:
5181 case CK_IntegralToFixedPoint:
5183 case CK_HLSLVectorTruncation:
5187 llvm_unreachable(
"dependent cast kind in IR gen!");
5189 case CK_BuiltinFnToFnPtr:
5190 llvm_unreachable(
"builtin functions are handled elsewhere");
5193 case CK_NonAtomicToAtomic:
5194 case CK_AtomicToNonAtomic:
5200 const auto *DCE = cast<CXXDynamicCastExpr>(E);
5204 case CK_ConstructorConversion:
5205 case CK_UserDefinedConversion:
5206 case CK_CPointerToObjCPointerCast:
5207 case CK_BlockPointerToObjCPointerCast:
5208 case CK_LValueToRValue:
5223 if (
V.getElementType() != T)
5230 case CK_UncheckedDerivedToBase:
5231 case CK_DerivedToBase: {
5232 const auto *DerivedClassTy =
5234 auto *DerivedClassDecl = cast<CXXRecordDecl>(DerivedClassTy->getDecl());
5252 case CK_BaseToDerived: {
5254 auto *DerivedClassDecl = cast<CXXRecordDecl>(DerivedClassTy->getDecl());
5269 if (
SanOpts.
has(SanitizerKind::CFIDerivedCast))
5277 case CK_LValueBitCast: {
5279 const auto *CE = cast<ExplicitCastExpr>(E);
5286 if (
SanOpts.
has(SanitizerKind::CFIUnrelatedCast))
5294 case CK_AddressSpaceConversion: {
5305 case CK_ObjCObjectLValueCast: {
5311 case CK_ZeroToOCLOpaqueType:
5312 llvm_unreachable(
"NULL to OpenCL opaque type lvalue cast is not valid");
5314 case CK_VectorSplat: {
5322 llvm_unreachable(
"Unhandled lvalue cast kind?");
5334 llvm::DenseMap<const OpaqueValueExpr*,LValue>::iterator
5335 it = OpaqueLValues.find(e);
5337 if (it != OpaqueLValues.end())
5340 assert(e->
isUnique() &&
"LValue for a nonunique OVE hasn't been emitted");
5348 llvm::DenseMap<const OpaqueValueExpr*,RValue>::iterator
5349 it = OpaqueRValues.find(e);
5351 if (it != OpaqueRValues.end())
5354 assert(e->
isUnique() &&
"RValue for a nonunique OVE hasn't been emitted");
5379 llvm_unreachable(
"bad evaluation kind");
5392 if (
const auto *CE = dyn_cast<CXXMemberCallExpr>(E))
5395 if (
const auto *CE = dyn_cast<CUDAKernelCallExpr>(E))
5400 if (
const auto *CE = dyn_cast<CXXOperatorCallExpr>(E))
5401 if (
const auto *MD =
5402 dyn_cast_if_present<CXXMethodDecl>(CE->getCalleeDecl());
5403 MD && MD->isImplicitObjectMemberFunction())
5432 if (!PD->isInlineBuiltinDeclaration())
5441 std::string NoBuiltinFD = (
"no-builtin-" + FD->
getName()).str();
5442 std::string NoBuiltins =
"no-builtins";
5445 std::string FDInlineName = (Ident +
".inline").str();
5447 bool IsPredefinedLibFunction =
5449 bool HasAttributeNoBuiltin =
5450 CGF.
CurFn->getAttributes().hasFnAttr(NoBuiltinFD) ||
5451 CGF.
CurFn->getAttributes().hasFnAttr(NoBuiltins);
5455 if (CGF.
CurFn->getName() != FDInlineName &&
5458 llvm::Function *Fn = llvm::cast<llvm::Function>(CalleePtr);
5459 llvm::Module *M = Fn->getParent();
5460 llvm::Function *Clone = M->getFunction(FDInlineName);
5462 Clone = llvm::Function::Create(Fn->getFunctionType(),
5463 llvm::GlobalValue::InternalLinkage,
5464 Fn->getAddressSpace(), FDInlineName, M);
5465 Clone->addFnAttr(llvm::Attribute::AlwaysInline);
5476 else if (!IsPredefinedLibFunction || !HasAttributeNoBuiltin)
5482 FD->
hasAttr<CUDAGlobalAttr>())
5484 cast<llvm::GlobalValue>(CalleePtr->stripPointerCasts()));
5493 if (
auto ICE = dyn_cast<ImplicitCastExpr>(E)) {
5494 if (ICE->getCastKind() == CK_FunctionToPointerDecay ||
5495 ICE->getCastKind() == CK_BuiltinFnToFnPtr) {
5500 }
else if (
auto DRE = dyn_cast<DeclRefExpr>(E)) {
5501 if (
auto FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
5504 }
else if (
auto ME = dyn_cast<MemberExpr>(E)) {
5505 if (
auto FD = dyn_cast<FunctionDecl>(ME->
getMemberDecl())) {
5511 }
else if (
auto NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
5515 }
else if (
auto PDE = dyn_cast<CXXPseudoDestructorExpr>(E)) {
5520 llvm::Value *calleePtr;
5532 if (
const auto *VD =
5537 CGCallee callee(calleeInfo, calleePtr);
5553 assert(E->
getOpcode() == BO_Assign &&
"unexpected binary l-value");
5591 llvm_unreachable(
"bad evaluation kind");
5602 "Can't have a scalar return unless the return type is a "
5615 &&
"binding l-value to type which needs a temporary");
5653 "Can't have a scalar return unless the return type is a "
5675 return Builder.CreateZExtOrTrunc(OffsetValue,
5680 llvm::Value *BaseValue,
5682 unsigned CVRQualifiers) {
5684 Ivar, CVRQualifiers);
5689 llvm::Value *BaseValue =
nullptr;
5700 ObjectTy = BaseExpr->
getType();
5720 llvm::Value *Chain) {
5724 "Call must have function pointer type!");
5726 const Decl *TargetDecl =
5729 assert((!isa_and_present<FunctionDecl>(TargetDecl) ||
5730 !cast<FunctionDecl>(TargetDecl)->isImmediateFunction()) &&
5731 "trying to emit a call to an immediate function");
5735 auto PointeeType = cast<PointerType>(CalleeType)->
getPointeeType();
5740 (!TargetDecl || !isa<FunctionDecl>(TargetDecl)) &&
5741 !isa<FunctionNoProtoType>(PointeeType)) {
5742 if (llvm::Constant *PrefixSig =
5744 SanitizerScope SanScope(
this);
5747 llvm::Type *PrefixSigType = PrefixSig->getType();
5748 llvm::StructType *PrefixStructTy = llvm::StructType::get(
5751 llvm::Value *CalleePtr =
Callee.getFunctionPointer();
5762 llvm::Value *AlignedCalleePtr;
5764 llvm::Value *CalleeAddress =
5766 llvm::Value *Mask = llvm::ConstantInt::get(
IntPtrTy, ~1);
5767 llvm::Value *AlignedCalleeAddress =
5768 Builder.CreateAnd(CalleeAddress, Mask);
5770 Builder.CreateIntToPtr(AlignedCalleeAddress, CalleePtr->getType());
5772 AlignedCalleePtr = CalleePtr;
5775 llvm::Value *CalleePrefixStruct = AlignedCalleePtr;
5776 llvm::Value *CalleeSigPtr =
5777 Builder.CreateConstGEP2_32(PrefixStructTy, CalleePrefixStruct, -1, 0);
5778 llvm::Value *CalleeSig =
5780 llvm::Value *CalleeSigMatch =
Builder.CreateICmpEQ(CalleeSig, PrefixSig);
5784 Builder.CreateCondBr(CalleeSigMatch, TypeCheck, Cont);
5789 Builder.CreateConstGEP2_32(PrefixStructTy, CalleePrefixStruct, -1, 1),
5791 llvm::Value *CalleeTypeHashMatch =
5792 Builder.CreateICmpEQ(CalleeTypeHash, TypeHash);
5795 EmitCheck(std::make_pair(CalleeTypeHashMatch, SanitizerKind::Function),
5796 SanitizerHandler::FunctionTypeMismatch, StaticData,
5804 const auto *FnType = cast<FunctionType>(PointeeType);
5809 (!TargetDecl || !isa<FunctionDecl>(TargetDecl))) {
5810 SanitizerScope SanScope(
this);
5819 llvm::Value *TypeId = llvm::MetadataAsValue::get(
getLLVMContext(), MD);
5821 llvm::Value *CalleePtr =
Callee.getFunctionPointer();
5822 llvm::Value *TypeTest =
Builder.CreateCall(
5826 llvm::Constant *StaticData[] = {
5833 CalleePtr, StaticData);
5835 EmitCheck(std::make_pair(TypeTest, SanitizerKind::CFIICall),
5836 SanitizerHandler::CFICheckFail, StaticData,
5837 {CalleePtr, llvm::UndefValue::get(
IntPtrTy)});
5852 bool StaticOperator =
false;
5853 if (
auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) {
5854 if (OCE->isAssignmentOp())
5857 switch (OCE->getOperator()) {
5859 case OO_GreaterGreater:
5871 if (
const auto *MD =
5872 dyn_cast_if_present<CXXMethodDecl>(OCE->getCalleeDecl());
5873 MD && MD->isStatic())
5874 StaticOperator =
true;
5878 if (StaticOperator) {
5884 EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), Arguments,
5888 Args, FnType, Chain);
5910 if (isa<FunctionNoProtoType>(FnType) || Chain) {
5912 int AS =
Callee.getFunctionPointer()->getType()->getPointerAddressSpace();
5913 CalleeTy = CalleeTy->getPointerTo(AS);
5915 llvm::Value *CalleePtr =
Callee.getFunctionPointer();
5916 CalleePtr =
Builder.CreateBitCast(CalleePtr, CalleeTy,
"callee.knr.cast");
5917 Callee.setFunctionPointer(CalleePtr);
5924 isa<CUDAKernelCallExpr>(E) &&
5925 (!TargetDecl || !isa<FunctionDecl>(TargetDecl))) {
5926 llvm::Value *Handle =
Callee.getFunctionPointer();
5931 llvm::CallBase *CallOrInvoke =
nullptr;
5938 if (
auto *CalleeDecl = dyn_cast_or_null<FunctionDecl>(TargetDecl)) {
5941 DI->EmitFuncDeclForCallSite(CallOrInvoke,
5942 DI->getFunctionType(CalleeDecl, ResTy, Args),
5968 return MakeAddrLValue(MemberAddr, MPT->getPointeeType(), BaseInfo, TBAAInfo);
5985 llvm_unreachable(
"bad evaluation kind");
5989 assert(Val->getType()->isFPOrFPVectorTy());
5990 if (Accuracy == 0.0 || !isa<llvm::Instruction>(Val))
5994 llvm::MDNode *
Node = MDHelper.createFPMath(Accuracy);
5996 cast<llvm::Instruction>(Val)->setMetadata(llvm::LLVMContext::MD_fpmath,
Node);
6000 llvm::Type *EltTy = Val->getType()->getScalarType();
6001 if (!EltTy->isFloatTy())
6021 llvm::Type *EltTy = Val->getType()->getScalarType();
6022 if (!EltTy->isFloatTy())
6042 struct LValueOrRValue {
6056 LValueOrRValue result;
6060 const Expr *semantic = *i;
6064 if (
const auto *ov = dyn_cast<OpaqueValueExpr>(semantic)) {
6066 if (ov->isUnique()) {
6067 assert(ov != resultExpr &&
6068 "A unique OVE cannot be used as the result expression");
6074 typedef CodeGenFunction::OpaqueValueMappingData OVMA;
6076 if (ov == resultExpr && ov->
isPRValue() && !forLValue &&
6081 opaqueData = OVMA::bind(CGF, ov, LV);
6086 opaqueData = OVMA::bind(CGF, ov, ov->getSourceExpr());
6089 if (ov == resultExpr) {
6097 opaques.push_back(opaqueData);
6101 }
else if (semantic == resultExpr) {
6114 for (
unsigned i = 0, e = opaques.size(); i != e; ++i)
6115 opaques[i].unbind(CGF);
Defines the clang::ASTContext interface.
Defines enum values for all the target-independent builtin functions.
CodeGenFunction::ComplexPairTy ComplexPairTy
static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E, LValue &LV, bool IsMemberAccess=false)
static LValue EmitGlobalNamedRegister(const VarDecl *VD, CodeGenModule &CGM)
Named Registers are named metadata pointing to the register name which will be read from/written to a...
static const Expr * isSimpleArrayDecayOperand(const Expr *E)
isSimpleArrayDecayOperand - If the specified expr is a simple decay from an array to pointer,...
static bool hasBooleanRepresentation(QualType Ty)
static llvm::cl::opt< bool > ClSanitizeDebugDeoptimization("ubsan-unique-traps", llvm::cl::Optional, llvm::cl::desc("Deoptimize traps for UBSAN so there is 1 trap per check"), llvm::cl::init(false))
static CheckRecoverableKind getRecoverableKind(SanitizerMask Kind)
static bool hasBPFPreserveStaticOffset(const RecordDecl *D)
static Address emitAddrOfFieldStorage(CodeGenFunction &CGF, Address base, const FieldDecl *field)
Drill down to the storage of a field without walking into reference types.
ConstantEmissionKind
Can we constant-emit a load of a reference to a variable of the given type? This is different from pr...
static bool isConstantEmittableObjectType(QualType type)
Given an object of the given canonical type, can we safely copy a value out of it based on its initia...
static llvm::Value * emitHash16Bytes(CGBuilderTy &Builder, llvm::Value *Low, llvm::Value *High)
Emit the hash_16_bytes function from include/llvm/ADT/Hashing.h.
static QualType getFixedSizeElementType(const ASTContext &ctx, const VariableArrayType *vla)
static LValue EmitCapturedFieldLValue(CodeGenFunction &CGF, const FieldDecl *FD, llvm::Value *ThisValue)
static std::optional< LValue > EmitLValueOrThrowExpression(CodeGenFunction &CGF, const Expr *Operand)
Emit the operand of a glvalue conditional operator.
static Address createReferenceTemporary(CodeGenFunction &CGF, const MaterializeTemporaryExpr *M, const Expr *Inner, Address *Alloca=nullptr)
static llvm::Value * emitArraySubscriptGEP(CodeGenFunction &CGF, llvm::Type *elemType, llvm::Value *ptr, ArrayRef< llvm::Value * > indices, bool inbounds, bool signedIndices, SourceLocation loc, const llvm::Twine &name="arrayidx")
static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF, const Expr *E, GlobalDecl GD)
static LValueOrRValue emitPseudoObjectExpr(CodeGenFunction &CGF, const PseudoObjectExpr *E, bool forLValue, AggValueSlot slot)
static Address wrapWithBPFPreserveStaticOffset(CodeGenFunction &CGF, Address &Addr)
static DeclRefExpr * tryToConvertMemberExprToDeclRefExpr(CodeGenFunction &CGF, const MemberExpr *ME)
static llvm::Value * getArrayIndexingBound(CodeGenFunction &CGF, const Expr *Base, QualType &IndexedType, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel)
If Base is known to point to the start of an array, return the length of that array.
static RValue EmitLoadOfMatrixLValue(LValue LV, SourceLocation Loc, CodeGenFunction &CGF)
static ConstantEmissionKind checkVarTypeForConstantEmission(QualType type)
static Address MaybeConvertMatrixAddress(Address Addr, CodeGenFunction &CGF, bool IsVector=true)
static QualType getConstantExprReferredType(const FullExpr *E, const ASTContext &Ctx)
static bool getRangeForType(CodeGenFunction &CGF, QualType Ty, llvm::APInt &Min, llvm::APInt &End, bool StrictEnums, bool IsBool)
static std::optional< int64_t > getOffsetDifferenceInBits(CodeGenFunction &CGF, const FieldDecl *FD1, const FieldDecl *FD2)
Returns the relative offset difference between FD1 and FD2.
static CGCallee EmitDirectCallee(CodeGenFunction &CGF, GlobalDecl GD)
static bool getGEPIndicesToField(CodeGenFunction &CGF, const RecordDecl *RD, const FieldDecl *FD, RecIndicesTy &Indices)
static LValue EmitThreadPrivateVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD, QualType T, Address Addr, llvm::Type *RealVarTy, SourceLocation Loc)
static bool OnlyHasInlineBuiltinDeclaration(const FunctionDecl *FD)
static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF, const Expr *E, const VarDecl *VD)
static bool hasAnyVptr(const QualType Type, const ASTContext &Context)
static bool getFieldOffsetInBits(CodeGenFunction &CGF, const RecordDecl *RD, const FieldDecl *FD, int64_t &Offset)
The offset of a field from the beginning of the record.
static bool IsPreserveAIArrayBase(CodeGenFunction &CGF, const Expr *ArrayBase)
Given an array base, check whether its member access belongs to a record with preserve_access_index a...
static Address emitDeclTargetVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD, QualType T)
static bool canEmitSpuriousReferenceToVariable(CodeGenFunction &CGF, const DeclRefExpr *E, const VarDecl *VD)
Determine whether we can emit a reference to VD from the current context, despite not necessarily hav...
static CharUnits getArrayElementAlign(CharUnits arrayAlign, llvm::Value *idx, CharUnits eltSize)
static bool isAAPCS(const TargetInfo &TargetInfo)
Helper method to check if the underlying ABI is AAPCS.
static void EmitStoreOfMatrixScalar(llvm::Value *value, LValue lvalue, bool isInit, CodeGenFunction &CGF)
static llvm::Constant * EmitFunctionDeclPointer(CodeGenModule &CGM, GlobalDecl GD)
static Address EmitPointerWithAlignment(const Expr *E, LValueBaseInfo *BaseInfo, TBAAAccessInfo *TBAAInfo, KnownNonNull_t IsKnownNonNull, CodeGenFunction &CGF)
static Address emitPreserveStructAccess(CodeGenFunction &CGF, LValue base, Address addr, const FieldDecl *field)
const SanitizerHandlerInfo SanitizerHandlers[]
static Address emitAddrOfZeroSizeField(CodeGenFunction &CGF, Address Base, const FieldDecl *Field)
Get the address of a zero-sized field within a record.
static void emitCheckHandlerCall(CodeGenFunction &CGF, llvm::FunctionType *FnType, ArrayRef< llvm::Value * > FnArgs, SanitizerHandler CheckHandler, CheckRecoverableKind RecoverKind, bool IsFatal, llvm::BasicBlock *ContBB)
static Address emitOMPArraySectionBase(CodeGenFunction &CGF, const Expr *Base, LValueBaseInfo &BaseInfo, TBAAAccessInfo &TBAAInfo, QualType BaseTy, QualType ElTy, bool IsLowerBound)
static void pushTemporaryCleanup(CodeGenFunction &CGF, const MaterializeTemporaryExpr *M, const Expr *E, Address ReferenceTemporary)
llvm::MachO::Record Record
static const SanitizerMask AlwaysRecoverable
static const SanitizerMask Unrecoverable
static const RecordType * getRecordType(QualType QT)
Checks that the passed in QualType either is of RecordType or points to RecordType.
Defines the SourceManager interface.
const LValueBase getLValueBase() const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
SourceManager & getSourceManager()
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
uint64_t getFieldOffset(const ValueDecl *FD) const
Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
Builtin::Context & BuiltinInfo
const LangOptions & getLangOpts() const
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
const NoSanitizeList & getNoSanitizeList() const
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
const VariableArrayType * getAsVariableArrayType(QualType T) const
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
unsigned getTargetAddressSpace(LangAS AS) const
uint64_t getCharWidth() const
Return the size of the character type, in bits.
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
Expr * getCond() const
getCond - Return the expression representing the condition for the ?: operator.
Expr * getTrueExpr() const
getTrueExpr - Return the subexpression representing the value of the expression if the condition eval...
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression representing the value of the expression if the condition eva...
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
SourceLocation getExprLoc() const LLVM_READONLY
Expr * getLHS()
An array access can be written A[4] or 4[A] (both are equivalent).
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
A builtin binary operation expression such as "x + y" or "x <= y".
SourceLocation getExprLoc() const
bool isPredefinedLibFunction(unsigned ID) const
Determines whether this builtin is a predefined libc/libm function, such as "malloc",...
Represents binding an expression to a temporary.
CXXTemporary * getTemporary()
const Expr * getSubExpr() const
Represents a call to a C++ constructor.
Represents a C++ destructor within a class.
Represents a C++ struct/union/class.
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
bool isDynamicClass() const
bool hasDefinition() const
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
MSGuidDecl * getGuidDecl() const
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.
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
path_iterator path_begin()
CastKind getCastKind() const
bool changesVolatileQualification() const
Return.
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?
llvm::MaybeAlign getAsMaybeAlign() const
getAsMaybeAlign - Returns Quantity as a valid llvm::Align or std::nullopt, Beware llvm::MaybeAlign as...
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.
static CharUnits One()
One - Construct a CharUnits quantity of one.
CharUnits alignmentOfArrayElement(CharUnits elementSize) const
Given that this is the alignment of the first element of an array, return the minimum alignment of an...
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
SanitizerSet SanitizeTrap
Set of sanitizer checks that trap rather than diagnose.
SanitizerSet SanitizeRecover
Set of sanitizer checks that are non-fatal (i.e.
std::string TrapFuncName
If not an empty string, trap intrinsics are lowered to calls to this function instead of to trap inst...
CharUnits getAlignment() const
Return the alignment of this pointer.
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Address withPointer(llvm::Value *NewPointer, KnownNonNull_t IsKnownNonNull) const
Return address with different pointer, but same element type and alignment.
Address withElementType(llvm::Type *ElemTy) const
Return address with different element type, but same pointer and alignment.
KnownNonNull_t isKnownNonNull() const
Whether the pointer is known not to be null.
Address setKnownNonNull()
Set the non-null bit.
llvm::Value * getPointer() const
llvm::PointerType * getType() const
Return the type of the pointer value.
static AggValueSlot ignored()
ignored - Returns an aggregate value slot indicating that the aggregate value is being ignored.
Address getAddress() const
void setExternallyDestructed(bool destructed=true)
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.
Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty, llvm::Type *ElementTy, const llvm::Twine &Name="")
Address CreateConstArrayGEP(Address Addr, uint64_t Index, const llvm::Twine &Name="")
Given addr = [n x T]* ... produce name = getelementptr inbounds addr, i64 0, i64 index where i64 is a...
Address CreateStructGEP(Address Addr, unsigned Index, const llvm::Twine &Name="")
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Address CreatePreserveStructAccessIndex(Address Addr, unsigned Index, unsigned FieldIndex, llvm::MDNode *DbgInfo)
Address CreateLaunderInvariantGroup(Address Addr)
llvm::LoadInst * CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
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 CreateAddrSpaceCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Address CreateGEP(Address Addr, llvm::Value *Index, const llvm::Twine &Name="")
virtual llvm::Function * getKernelStub(llvm::GlobalValue *Handle)=0
Get kernel stub by kernel handle.
virtual void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D, llvm::FunctionCallee Dtor, llvm::Constant *Addr)=0
Emit code to force the execution of a destructor during global teardown.
virtual llvm::Value * EmitMemberPointerIsNotNull(CodeGenFunction &CGF, llvm::Value *MemPtr, const MemberPointerType *MPT)
Determine if a member pointer is non-null. Returns an i1.
virtual LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD, QualType LValType)=0
Emit a reference to a non-local thread_local variable (including triggering the initialization of all...
virtual bool usesThreadWrapperFunction(const VarDecl *VD) const =0
MangleContext & getMangleContext()
Gets the mangle context.
Abstract information about a function or function prototype.
const GlobalDecl getCalleeDecl() const
All available information about a concrete callee.
CGCalleeInfo getAbstractInfo() const
const CXXPseudoDestructorExpr * getPseudoDestructorExpr() const
bool isPseudoDestructor() const
static CGCallee forBuiltin(unsigned builtinID, const FunctionDecl *builtinDecl)
unsigned getBuiltinID() const
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
const FunctionDecl * getBuiltinDecl() const
static CGCallee forPseudoDestructor(const CXXPseudoDestructorExpr *E)
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
llvm::DIType * getOrCreateStandaloneType(QualType Ty, SourceLocation Loc)
Emit standalone debug info for a type.
llvm::DIType * getOrCreateRecordType(QualType Ty, SourceLocation L)
Emit record type's standalone debug info.
CGFunctionInfo - Class to encapsulate the information about a function definition.
virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest, llvm::Value *ivarOffset)=0
virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest)=0
virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy, llvm::Value *BaseValue, const ObjCIvarDecl *Ivar, unsigned CVRQualifiers)=0
virtual llvm::Value * EmitIvarOffset(CodeGen::CodeGenFunction &CGF, const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)=0
virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, Address AddrWeakObj)=0
virtual Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel)=0
Get the address of a selector for the specified name and type values.
virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest)=0
virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest, bool threadlocal=false)=0
virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, Address VDAddr, SourceLocation Loc)
Returns address of the threadprivate variable for the current thread.
virtual Address getAddrOfDeclareTargetVar(const VarDecl *VD)
Returns the address of the variable marked as declare target with link clause OR as declare target wi...
bool hasRequiresUnifiedSharedMemory() const
Return whether the unified_shared_memory has been specified.
bool isNontemporalDecl(const ValueDecl *VD) const
Checks if the VD variable is marked as nontemporal declaration in current context.
virtual void checkAndEmitLastprivateConditional(CodeGenFunction &CGF, const Expr *LHS)
Checks if the provided LVal is lastprivate conditional and emits the code to update the value of the ...
CGRecordLayout - This class handles struct and union layout info while lowering AST types to LLVM typ...
const CGBitFieldInfo & getBitFieldInfo(const FieldDecl *FD) const
Return the BitFieldInfo that corresponds to the field FD.
unsigned getLLVMFieldNo(const FieldDecl *FD) const
Return llvm::StructType element number that corresponds to the field FD.
CallArgList - Type for representing both the value and type of arguments in a call.
void add(RValue rvalue, QualType type)
virtual llvm::Value * getContextValue() const
virtual const FieldDecl * lookup(const VarDecl *VD) const
Lookup the captured field decl for a variable.
static ConstantEmission forValue(llvm::Constant *C)
static ConstantEmission forReference(llvm::Constant *C)
static bool shouldBindAsLValue(const Expr *expr)
static bool shouldBindAsLValue(const Expr *expr)
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
llvm::Value * EmitFromMemory(llvm::Value *Value, QualType Ty)
EmitFromMemory - Change a scalar value from its memory representation to its value representation.
LValue EmitOpaqueValueLValue(const OpaqueValueExpr *e)
RValue EmitLoadOfGlobalRegLValue(LValue LV)
LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E)
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E)
llvm::Value * EmitLifetimeStart(llvm::TypeSize Size, llvm::Value *Addr)
void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, llvm::Value *V, QualType Type, CharUnits Alignment=CharUnits::Zero(), SanitizerSet SkippedChecks=SanitizerSet(), llvm::Value *ArraySize=nullptr)
Emit a check that V is the address of storage of the appropriate size and alignment for an object of ...
LValue EmitOMPArraySectionExpr(const OMPArraySectionExpr *E, bool IsLowerBound=true)
Address EmitCXXMemberDataPointerAddress(const Expr *E, Address base, llvm::Value *memberPtr, const MemberPointerType *memberPtrType, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
llvm::Value * EmitNonNullRValueCheck(RValue RV, QualType T)
Create a check that a scalar RValue is non-null.
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts=false)
ContainsLabel - Return true if the statement contains a label in it.
LValue EmitCastLValue(const CastExpr *E)
void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount, Stmt::Likelihood LH=Stmt::LH_None, const Expr *ConditionalOp=nullptr)
EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g.
llvm::CallInst * EmitTrapCall(llvm::Intrinsic::ID IntrID)
Emit a call to trap or debugtrap and attach function attribute "trap-func-name" if specified.
bool sanitizePerformTypeCheck() const
Whether any type-checking sanitizers are enabled.
void EmitSanitizerStatReport(llvm::SanitizerStatKind SSK)
SanitizerSet SanOpts
Sanitizers enabled for this function.
LValue EmitCoawaitLValue(const CoawaitExpr *E)
LValue getOrCreateOpaqueLValueMapping(const OpaqueValueExpr *e)
Given an opaque value expression, return its LValue mapping if it exists, otherwise create one.
LValue EmitAggExprToLValue(const Expr *E)
EmitAggExprToLValue - Emit the computation of the specified expression of aggregate type into a tempo...
llvm::Value * EmitIvarOffsetAsPointerDiff(const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)
void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)
EmitStoreThroughLValue - Store the specified rvalue into the specified lvalue, where both are guarant...
void pushLifetimeExtendedDestroy(CleanupKind kind, Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue)
LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E)
CGCapturedStmtInfo * CapturedStmtInfo
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 EmitBoundsCheck(const Expr *E, const Expr *Base, llvm::Value *Index, QualType IndexType, bool Accessed)
Emit a check that Base points into an array object, which we can access at index Index.
bool inSuspendBlock() const
Address EmitLoadOfPointer(Address Ptr, const PointerType *PtrTy, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
Load a pointer with type PtrTy stored at address Ptr.
VlaSizePair getVLASize(const VariableArrayType *vla)
Returns an LLVM value that corresponds to the size, in non-variably-sized elements,...
CleanupKind getARCCleanupKind()
Retrieves the default cleanup kind for an ARC cleanup.
RValue EmitRValueForField(LValue LV, const FieldDecl *FD, SourceLocation Loc)
LValue EmitLValue(const Expr *E, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
EmitLValue - Emit code to compute a designator that specifies the location of the expression.
void EmitVTablePtrCheckForCast(QualType T, Address Derived, bool MayBeNull, CFITypeCheckKind TCK, SourceLocation Loc)
Derived is the presumed address of an object of type T after a cast.
RValue EmitAtomicLoad(LValue LV, SourceLocation SL, AggValueSlot Slot=AggValueSlot::ignored())
llvm::Value * EmitIvarOffset(const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)
llvm::Value * EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored)
LValue EmitBinaryOperatorLValue(const BinaryOperator *E)
void EmitVariablyModifiedType(QualType Ty)
EmitVLASize - Capture all the sizes for the VLA expressions in the given variably-modified type and s...
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)
LValue EmitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E)
llvm::Value * EmitARCLoadWeakRetained(Address addr)
Address CreateTempAllocaWithoutCast(llvm::Type *Ty, CharUnits align, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
const LangOptions & getLangOpts() const
llvm::Value * LoadPassedObjectSize(const Expr *E, QualType EltTy)
If E references a parameter with pass_object_size info or a constant array size modifier,...
llvm::Constant * EmitCheckTypeDescriptor(QualType T)
Emit a description of a type in a format suitable for passing to a runtime sanitizer handler.
LValue EmitLValueForFieldInitialization(LValue Base, const FieldDecl *Field)
EmitLValueForFieldInitialization - Like EmitLValueForField, except that if the Field is a reference,...
LValue EmitInitListLValue(const InitListExpr *E)
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
void EmitTrapCheck(llvm::Value *Checked, SanitizerHandler CheckHandlerID)
Create a basic block that will call the trap intrinsic, and emit a conditional branch to it,...
void EmitUnreachable(SourceLocation Loc)
Emit a reached-unreachable diagnostic if Loc is valid and runtime checking is enabled.
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...
Address EmitLoadOfReference(LValue RefLVal, LValueBaseInfo *PointeeBaseInfo=nullptr, TBAAAccessInfo *PointeeTBAAInfo=nullptr)
ComplexPairTy EmitComplexExpr(const Expr *E, bool IgnoreReal=false, bool IgnoreImag=false)
EmitComplexExpr - Emit the computation of the specified expression of complex type,...
RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)
EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...
RValue convertTempToRValue(Address addr, QualType type, SourceLocation Loc)
Address EmitExtVectorElementLValue(LValue V)
void EmitAnyExprToMem(const Expr *E, Address Location, Qualifiers Quals, bool IsInitializer)
EmitAnyExprToMem - Emits the code necessary to evaluate an arbitrary expression into the given memory...
@ TCK_DowncastPointer
Checking the operand of a static_cast to a derived pointer type.
@ TCK_DowncastReference
Checking the operand of a static_cast to a derived reference type.
@ TCK_MemberAccess
Checking the object expression in a non-static data member access.
@ TCK_Store
Checking the destination of a store. Must be suitably sized and aligned.
@ TCK_UpcastToVirtualBase
Checking the operand of a cast to a virtual base object.
@ 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.
@ TCK_ReferenceBinding
Checking the bound value in a reference binding.
@ TCK_Upcast
Checking the operand of a cast to a base object.
void SetDivFPAccuracy(llvm::Value *Val)
Set the minimum required accuracy of the given sqrt operation based on CodeGenOpts.
RValue EmitObjCMessageExpr(const ObjCMessageExpr *E, ReturnValueSlot Return=ReturnValueSlot())
void EmitIgnoredExpr(const Expr *E)
EmitIgnoredExpr - Emit an expression in a context which ignores the result.
LValue EmitCallExprLValue(const CallExpr *E)
LValue EmitUnsupportedLValue(const Expr *E, const char *Name)
EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue an ErrorUnsupported style ...
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)
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
llvm::AssertingVH< llvm::Instruction > AllocaInsertPt
AllocaInsertPoint - This is an instruction in the entry block before which we prefer to insert alloca...
void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
unsigned getDebugInfoFIndex(const RecordDecl *Rec, unsigned FieldIndex)
Get the record field index as represented in debug info.
LValue EmitLValueForField(LValue Base, const FieldDecl *Field)
LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK)
Same as EmitLValue but additionally we generate checking code to guard against undefined behavior.
static Destroyer destroyCXXObject
@ ForceLeftToRight
! Language semantics require left-to-right evaluation.
@ Default
! No language constraints on evaluation order.
@ ForceRightToLeft
! Language semantics require right-to-left evaluation.
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, llvm::Value **Result=nullptr)
EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints as EmitStoreThroughLValue.
void EmitCfiCheckStub()
Emit a stub for the cross-DSO CFI check function.
llvm::Value * EmitObjCConsumeObject(QualType T, llvm::Value *Ptr)
ConstantEmission tryEmitAsConstant(DeclRefExpr *refExpr)
llvm::Value * EmitARCLoadWeak(Address addr)
const TargetInfo & getTarget() const
LValue EmitCXXConstructLValue(const CXXConstructExpr *E)
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.
std::pair< LValue, llvm::Value * > EmitARCStoreAutoreleasing(const BinaryOperator *e)
LValue EmitVAArgExprLValue(const VAArgExpr *E)
bool EmitScalarRangeCheck(llvm::Value *Value, QualType Ty, SourceLocation Loc)
Check if the scalar Value is within the valid range for the given type Ty.
llvm::Function * generateDestroyHelper(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray, const VarDecl *VD)
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...
llvm::Value * EmitCountedByFieldExpr(const Expr *Base, const FieldDecl *FAMDecl, const FieldDecl *CountDecl)
Build an expression accessing the "counted_by" field.
LValue EmitCoyieldLValue(const CoyieldExpr *E)
RValue EmitAnyExprToTemp(const Expr *E)
EmitAnyExprToTemp - Similarly to EmitAnyExpr(), however, the result will always be accessible even if...
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 EmitSimpleCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue)
Address EmitArrayToPointerDecay(const Expr *Array, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
void EmitCheck(ArrayRef< std::pair< llvm::Value *, SanitizerMask > > Checked, SanitizerHandler Check, ArrayRef< llvm::Constant * > StaticArgs, ArrayRef< llvm::Value * > DynamicArgs)
Create a basic block that will either trap or call a handler function in the UBSan runtime with the p...
LValue EmitUnaryOpLValue(const UnaryOperator *E)
ComplexPairTy EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV, bool isInc, bool isPre)
RValue EmitUnsupportedRValue(const Expr *E, const char *Name)
EmitUnsupportedRValue - Emit a dummy r-value using the type of E and issue an ErrorUnsupported style ...
static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts)
getAccessedFieldNo - Given an encoded value and a result number, return the input field number being ...
RValue EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue)
RValue EmitAnyExpr(const Expr *E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
EmitAnyExpr - Emit code to compute the specified expression which can have any type.
void EmitBoundsCheckImpl(const Expr *E, llvm::Value *Bound, llvm::Value *Index, QualType IndexType, QualType IndexedType, bool Accessed)
void StartFunction(GlobalDecl GD, QualType RetTy, llvm::Function *Fn, const CGFunctionInfo &FnInfo, const FunctionArgList &Args, SourceLocation Loc=SourceLocation(), SourceLocation StartLoc=SourceLocation())
Emit code for the start of a function.
void EmitCfiCheckFail()
Emit a cross-DSO CFI failure handling function.
RValue EmitLoadOfExtVectorElementLValue(LValue V)
ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc)
EmitLoadOfComplex - Load a complex number from the specified l-value.
static bool ShouldNullCheckClassCastValue(const CastExpr *Cast)
llvm::Value * EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy, QualType DstTy, SourceLocation Loc)
Emit a conversion from the specified complex type to the specified destination type,...
llvm::Constant * EmitCheckSourceLocation(SourceLocation Loc)
Emit a description of a source location in a format suitable for passing to a runtime sanitizer handl...
LValue EmitComplexAssignmentLValue(const BinaryOperator *E)
Emit an l-value for an assignment (simple or compound) of complex type.
void ErrorUnsupported(const Stmt *S, const char *Type)
ErrorUnsupported - Print out an error that codegen doesn't support the specified stmt yet.
CGDebugInfo * getDebugInfo()
LValue EmitObjCSelectorLValue(const ObjCSelectorExpr *E)
Address emitBlockByrefAddress(Address baseAddr, const VarDecl *V, bool followForward=true)
BuildBlockByrefAddress - Computes the location of the data in a variable which is declared as __block...
LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E)
Address emitAddrOfImagComponent(Address complex, QualType complexType)
LValue EmitDeclRefLValue(const DeclRefExpr *E)
Address CreateDefaultAlignTempAlloca(llvm::Type *Ty, const Twine &Name="tmp")
CreateDefaultAlignedTempAlloca - This creates an alloca with the default ABI alignment of the given L...
const TargetCodeGenInfo & getTargetHooks() const
llvm::Value * emitBoolVecConversion(llvm::Value *SrcVec, unsigned NumElementsDst, const llvm::Twine &Name="")
LValue EmitPredefinedLValue(const PredefinedExpr *E)
RValue EmitReferenceBindingToExpr(const Expr *E)
Emits a reference binding to the passed in expression.
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type.
Address GetAddressOfDerivedClass(Address Value, const CXXRecordDecl *Derived, CastExpr::path_const_iterator PathBegin, CastExpr::path_const_iterator PathEnd, bool NullCheckValue)
void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst)
llvm::Value * EmitToMemory(llvm::Value *Value, QualType Ty)
EmitToMemory - Change a scalar value from its value representation to its in-memory representation.
llvm::Value * EmitCheckValue(llvm::Value *V)
Convert a value into a format suitable for passing to a runtime sanitizer handler.
void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType, Address Ptr)
bool IsInPreservedAIRegion
True if CodeGen currently emits code inside presereved access index region.
llvm::Value * EmitARCRetain(QualType type, llvm::Value *value)
void SetSqrtFPAccuracy(llvm::Value *Val)
Set the minimum required accuracy of the given sqrt operation based on CodeGenOpts.
Address CreateMemTempWithoutCast(QualType T, const Twine &Name="tmp")
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen without...
RValue EmitPseudoObjectRValue(const PseudoObjectExpr *e, AggValueSlot slot=AggValueSlot::ignored())
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
ASTContext & getContext() const
llvm::Value * EmitARCStoreStrong(LValue lvalue, llvm::Value *value, bool resultIgnored)
LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E)
llvm::Value * EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty, SourceLocation Loc, AlignmentSource Source=AlignmentSource::Type, bool isNontemporal=false)
EmitLoadOfScalar - Load a scalar value from an address, taking care to appropriately convert from the...
CGCallee EmitCallee(const Expr *E)
Address CreateMemTemp(QualType T, const Twine &Name="tmp", Address *Alloca=nullptr)
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen and cas...
void EmitNullabilityCheck(LValue LHS, llvm::Value *RHS, SourceLocation Loc)
Given an assignment *LHS = RHS, emit a test that checks if RHS is nonnull, if LHS is marked _Nonnull.
void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty)
LValue EmitLoadOfPointerLValue(Address Ptr, const PointerType *PtrTy)
void EmitDeclRefExprDbgValue(const DeclRefExpr *E, const APValue &Init)
void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)
llvm::Instruction * getPostAllocaInsertPoint()
Return PostAllocaInsertPt.
Address GetAddressOfBaseClass(Address Value, const CXXRecordDecl *Derived, CastExpr::path_const_iterator PathBegin, CastExpr::path_const_iterator PathEnd, bool NullCheckValue, SourceLocation Loc)
GetAddressOfBaseClass - This function will add the necessary delta to the load of 'this' and returns ...
LValue EmitMemberExpr(const MemberExpr *E)
void pushDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)
LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E, bool Accessed=false)
RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue)
bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result, bool AllowLabels=false)
ConstantFoldsToSimpleInteger - If the specified expression does not fold to a constant,...
llvm::ConstantInt * getUBSanFunctionTypeHash(QualType T) const
Return a type hash constant for a function instrumented by -fsanitize=function.
static Destroyer destroyARCWeak
llvm::DenseMap< const ValueDecl *, FieldDecl * > LambdaCaptureFields
CleanupKind getCleanupKind(QualType::DestructionKind 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)
Address GetAddrOfBlockDecl(const VarDecl *var)
CodeGenTypes & getTypes() const
void EmitARCInitWeak(Address addr, llvm::Value *value)
bool IsSanitizerScope
True if CodeGen currently emits code implementing sanitizer checks.
LValue EmitCXXTypeidLValue(const CXXTypeidExpr *E)
void EmitStoreThroughGlobalRegLValue(RValue Src, LValue Dst)
Address EmitCXXUuidofExpr(const CXXUuidofExpr *E)
LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T)
QualType BuildFunctionArgList(GlobalDecl GD, FunctionArgList &Args)
LValue EmitStringLiteralLValue(const StringLiteral *E)
static Destroyer destroyARCStrongPrecise
llvm::Value * EvaluateExprAsBool(const Expr *E)
EvaluateExprAsBool - Perform the usual unary conversions on the specified expression and compare the ...
Address LoadCXXThisAddress()
Address CreateIRTemp(QualType T, const Twine &Name="tmp")
CreateIRTemp - Create a temporary IR object of the given type, with appropriate alignment.
llvm::Value * EmitCheckedInBoundsGEP(llvm::Type *ElemTy, llvm::Value *Ptr, ArrayRef< llvm::Value * > IdxList, bool SignedIndices, bool IsSubtraction, SourceLocation Loc, const Twine &Name="")
Same as IRBuilder::CreateInBoundsGEP, but additionally emits a check to detect undefined behavior whe...
llvm::Value * EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr)
llvm::Value * EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE)
uint64_t getProfileCount(const Stmt *S)
Get the profiler's count for the given statement.
LValue EmitMatrixSubscriptExpr(const MatrixSubscriptExpr *E)
LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e)
static bool hasAggregateEvaluationKind(QualType T)
llvm::Value * EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, bool isInc, bool isPre)
const FieldDecl * FindCountedByField(const FieldDecl *FD)
Find the FieldDecl specified in a FAM's "counted_by" attribute.
void SetFPAccuracy(llvm::Value *Val, float Accuracy)
SetFPAccuracy - Set the minimum required accuracy of the given floating point operation,...
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit)
EmitStoreOfComplex - Store a complex number into the specified l-value.
LValue EmitLoadOfReferenceLValue(LValue RefLVal)
const CallExpr * MustTailCall
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
LValue EmitObjCIsaExpr(const ObjCIsaExpr *E)
void EmitCfiSlowPathCheck(SanitizerMask Kind, llvm::Value *Cond, llvm::ConstantInt *TypeId, llvm::Value *Ptr, ArrayRef< llvm::Constant * > StaticArgs)
Emit a slow path cross-DSO CFI check which calls __cfi_slowpath if Cond if false.
void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit)
Address EmitFieldAnnotations(const FieldDecl *D, Address V)
Emit field annotations for the given field & value.
llvm::Value * EmitScalarConversion(llvm::Value *Src, QualType SrcTy, QualType DstTy, SourceLocation Loc)
Emit a conversion from the specified type to the specified destination type, both of which are LLVM s...
AggValueSlot CreateAggTemp(QualType T, const Twine &Name="tmp", Address *Alloca=nullptr)
CreateAggTemp - Create a temporary memory object for the given aggregate type.
LValue EmitCXXUuidofLValue(const CXXUuidofExpr *E)
std::pair< llvm::Value *, llvm::Value * > ComplexPairTy
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
static bool isNullPointerAllowed(TypeCheckKind TCK)
Determine whether the pointer type check TCK permits null pointers.
static Destroyer destroyARCStrongImprecise
RValue getOrCreateOpaqueRValueMapping(const OpaqueValueExpr *e)
Given an opaque value expression, return its RValue mapping if it exists, otherwise create one.
void EmitIgnoredConditionalOperator(const AbstractConditionalOperator *E)
RValue GetUndefRValue(QualType Ty)
GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
LValue EmitLValueForIvar(QualType ObjectTy, llvm::Value *Base, const ObjCIvarDecl *Ivar, unsigned CVRQualifiers)
RValue EmitCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue=ReturnValueSlot())
RValue EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E, ReturnValueSlot ReturnValue)
llvm::Value * emitScalarConstant(const ConstantEmission &Constant, Expr *E)
LValue EmitStmtExprLValue(const StmtExpr *E)
void EnsureInsertPoint()
EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go.
LValue MakeNaturalAlignPointeeAddrLValue(llvm::Value *V, QualType T)
llvm::LLVMContext & getLLVMContext()
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...
bool LValueIsSuitableForInlineAtomic(LValue Src)
void incrementProfileCounter(const Stmt *S, llvm::Value *StepV=nullptr)
Increment the profiler's counter for the given statement by StepV.
Address emitAddrOfRealComponent(Address complex, QualType complexType)
static bool isVptrCheckRequired(TypeCheckKind TCK, QualType Ty)
Determine whether the pointer type check TCK requires a vptr check.
LValue EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E)
LValue EmitConditionalOperatorLValue(const AbstractConditionalOperator *E)
void EmitStoreOfScalar(llvm::Value *Value, Address Addr, bool Volatile, QualType Ty, AlignmentSource Source=AlignmentSource::Type, bool isInit=false, bool isNontemporal=false)
EmitStoreOfScalar - Store a scalar value to an address, taking care to appropriately convert from the...
LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E)
RValue EmitLoadOfBitfieldLValue(LValue LV, SourceLocation Loc)
LValue EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E)
LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E)
LValue EmitLValueForLambdaField(const FieldDecl *Field)
static bool IsWrappedCXXThis(const Expr *E)
Check if E is a C++ "this" pointer wrapped in value-preserving casts.
This class organizes the cross-function state that is used while generating LLVM code.
ConstantAddress GetAddrOfMSGuidDecl(const MSGuidDecl *GD)
Get the address of a GUID.
void EmitExplicitCastExprType(const ExplicitCastExpr *E, CodeGenFunction *CGF=nullptr)
Emit type info if type of an expression is a variably modified type.
void setDSOLocal(llvm::GlobalValue *GV) const
llvm::Module & getModule() const
llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false, bool AssumeConvergent=false)
Create or return a runtime function declaration with the specified type and name.
CGDebugInfo * getModuleDebugInfo()
ConstantAddress GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *E)
Returns a pointer to a constant global variable for the given file-scope compound literal expression.
llvm::ConstantInt * CreateCrossDsoCfiTypeId(llvm::Metadata *MD)
Generate a cross-DSO type identifier for MD.
void setTypeDescriptorInMap(QualType Ty, llvm::Constant *C)
llvm::FunctionCallee getAddrAndTypeOfCXXStructor(GlobalDecl GD, const CGFunctionInfo *FnInfo=nullptr, llvm::FunctionType *FnType=nullptr, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
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.
Address createUnnamedGlobalFrom(const VarDecl &D, llvm::Constant *Constant, CharUnits Align)
DiagnosticsEngine & getDiags() const
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()
const TargetInfo & getTarget() const
llvm::Metadata * CreateMetadataIdentifierForType(QualType T)
Create a metadata identifier for the given type.
llvm::Constant * getTypeDescriptorFromMap(QualType Ty)
void addUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.used metadata.
llvm::MDNode * getTBAABaseTypeInfo(QualType QTy)
getTBAABaseTypeInfo - Get metadata that describes the given base access type.
llvm::GlobalValue::LinkageTypes getLLVMLinkageVarDefinition(const VarDecl *VD)
Returns LLVM linkage for a declarator.
const llvm::DataLayout & getDataLayout() const
CGCXXABI & getCXXABI() const
ConstantAddress GetWeakRefReference(const ValueDecl *VD)
Get a reference to the target of VD.
CGOpenMPRuntime & getOpenMPRuntime()
Return a reference to the configured OpenMP runtime.
SanitizerMetadata * getSanitizerMetadata()
llvm::Metadata * CreateMetadataIdentifierGeneralized(QualType T)
Create a metadata identifier for the generalization of the given type.
const llvm::Triple & getTriple() const
llvm::Constant * getOrCreateStaticVarDecl(const VarDecl &D, llvm::GlobalValue::LinkageTypes Linkage)
void DecorateInstructionWithTBAA(llvm::Instruction *Inst, TBAAAccessInfo TBAAInfo)
DecorateInstructionWithTBAA - Decorate the instruction with a TBAA tag.
TBAAAccessInfo getTBAAInfoForSubobject(LValue Base, QualType AccessType)
getTBAAInfoForSubobject - Get TBAA information for an access with a given base lvalue.
llvm::Constant * CreateRuntimeVariable(llvm::Type *Ty, StringRef Name)
Create a new runtime global variable with the specified type and name.
TBAAAccessInfo getTBAAAccessInfo(QualType AccessType)
getTBAAAccessInfo - Get TBAA information that describes an access to an object of the given type.
ConstantAddress GetAddrOfConstantStringFromLiteral(const StringLiteral *S, StringRef Name=".str")
Return a pointer to a constant array for the given string literal.
ASTContext & getContext() const
ConstantAddress GetAddrOfTemplateParamObject(const TemplateParamObjectDecl *TPO)
Get the address of a template parameter object.
TBAAAccessInfo mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo, TBAAAccessInfo TargetInfo)
mergeTBAAInfoForCast - Get merged TBAA information for the purposes of type casts.
llvm::Constant * GetAddrOfGlobalVar(const VarDecl *D, llvm::Type *Ty=nullptr, ForDefinition_t IsForDefinition=NotForDefinition)
Return the llvm::Constant for the address of the given global variable.
llvm::MDNode * getTBAATypeInfo(QualType QTy)
getTBAATypeInfo - Get metadata used to describe accesses to objects of the given type.
const TargetCodeGenInfo & getTargetCodeGenInfo()
const CodeGenOptions & getCodeGenOpts() const
StringRef getMangledName(GlobalDecl GD)
CharUnits getNaturalPointeeTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
TBAAAccessInfo mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA, TBAAAccessInfo InfoB)
mergeTBAAInfoForConditionalOperator - Get merged TBAA information for the purposes of conditional ope...
llvm::LLVMContext & getLLVMContext()
CGObjCRuntime & getObjCRuntime()
Return a reference to the configured Objective-C runtime.
ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E, const Expr *Inner)
Returns a pointer to a global variable representing a temporary with static or thread storage duratio...
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
LangAS GetGlobalConstantAddressSpace() const
Return the AST address space of constant literal, which is used to emit the constant literal as globa...
void SetLLVMFunctionAttributes(GlobalDecl GD, const CGFunctionInfo &Info, llvm::Function *F, bool IsThunk)
Set the LLVM function attributes (sext, zext, etc).
CharUnits getMinimumObjectSize(QualType Ty)
Returns the minimum object size for an object of the given type.
void SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F)
Set the LLVM function attributes which only apply to a function definition.
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys=std::nullopt)
ConstantAddress GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *)
Return a pointer to a constant array for the given ObjCEncodeExpr node.
ConstantAddress GetAddrOfConstantCString(const std::string &Str, const char *GlobalName=nullptr)
Returns a pointer to a character array containing the literal and a terminating '\0' character.
void setCurrentStmt(const Stmt *S)
If the execution count for the current statement is known, record that as the current count.
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
const CGRecordLayout & getCGRecordLayout(const RecordDecl *)
getCGRecordLayout - Return record layout info for the given record decl.
const llvm::DataLayout & getDataLayout() const
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.
llvm::Type * ConvertTypeForMem(QualType T, bool ForBitField=false)
ConvertTypeForMem - Convert type T into a llvm::Type.
A specialization of Address that requires the address to be an LLVM Constant.
ConstantAddress withElementType(llvm::Type *ElemTy) const
llvm::Constant * getPointer() const
llvm::Constant * emitAbstract(const Expr *E, QualType T)
Emit the result of the given expression as an abstract constant, asserting that it succeeded.
llvm::Constant * tryEmitConstantExpr(const ConstantExpr *CE)
FunctionArgList - Type for representing both the decl and type of parameters to a function.
void mergeForCast(const LValueBaseInfo &Info)
AlignmentSource getAlignmentSource() const
LValue - This represents an lvalue references.
Expr * getBaseIvarExp() const
llvm::Constant * getExtVectorElts() const
static LValue MakeGlobalReg(llvm::Value *V, CharUnits alignment, QualType type)
void setObjCIvar(bool Value)
static LValue MakeExtVectorElt(Address vecAddress, llvm::Constant *Elts, QualType type, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)
bool isObjCStrong() const
bool isGlobalObjCRef() const
void setObjCArray(bool Value)
bool isVolatileQualified() const
static LValue MakeAddr(Address address, QualType type, ASTContext &Context, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)
CharUnits getAlignment() const
llvm::Value * getMatrixIdx() const
Address getAddress(CodeGenFunction &CGF) const
llvm::Value * getGlobalReg() const
const Qualifiers & getQuals() const
unsigned getVRQualifiers() const
void setThreadLocalRef(bool Value)
void setGlobalObjCRef(bool Value)
bool isExtVectorElt() const
llvm::Value * getVectorIdx() const
void setNontemporal(bool Value)
LValueBaseInfo getBaseInfo() const
llvm::Value * getPointer(CodeGenFunction &CGF) const
void setARCPreciseLifetime(ARCPreciseLifetime_t value)
const CGBitFieldInfo & getBitFieldInfo() const
bool isThreadLocalRef() const
KnownNonNull_t isKnownNonNull() const
TBAAAccessInfo getTBAAInfo() const
void setNonGC(bool Value)
Address getVectorAddress() const
bool isNontemporal() const
static LValue MakeBitfield(Address Addr, const CGBitFieldInfo &Info, QualType type, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)
Create a new object to represent a bit-field access.
static LValue MakeVectorElt(Address vecAddress, llvm::Value *Idx, QualType type, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)
void setAddress(Address address)
void setBaseIvarExp(Expr *V)
RValue asAggregateRValue(CodeGenFunction &CGF) const
Address getExtVectorAddress() const
static LValue MakeMatrixElt(Address matAddress, llvm::Value *Idx, QualType type, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)
Address getMatrixAddress() const
Address getBitFieldAddress() 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)
static RValue getComplex(llvm::Value *V1, llvm::Value *V2)
Address getAggregateAddress() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
ReturnValueSlot - Contains the address where the return value of a function can be stored,...
virtual llvm::Value * performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, llvm::Value *V, LangAS SrcAddr, LangAS DestAddr, llvm::Type *DestTy, bool IsNonNull=false) const
Perform address space cast of an expression of pointer type.
virtual llvm::Constant * getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const
Return a constant used by UBSan as a signature to identify functions possessing type information,...
Complex values, per C99 6.2.5p11.
QualType getElementType() const
CompoundLiteralExpr - [C99 6.5.2.5].
const Expr * getInitializer() const
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
Represents a concrete matrix type with constant number of rows and columns.
unsigned getNumRows() const
Returns the number of rows in the matrix.
The results of name lookup within a DeclContext.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
A reference to a declared variable, function, enum, etc.
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
SourceLocation getLocation() const
Decl - This represents one declaration (or definition), e.g.
SourceLocation getLocation() const
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
DeclContext * getDeclContext()
The name of a declaration.
void ConvertArgToString(ArgumentKind Kind, intptr_t Val, StringRef Modifier, StringRef Argument, ArrayRef< ArgumentValue > PrevArgs, SmallVectorImpl< char > &Output, ArrayRef< intptr_t > QualTypeVals) const
Converts a diagnostic argument (as an intptr_t) into the string that represents it.
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
void getValueRange(llvm::APInt &Max, llvm::APInt &Min) const
Calculates the [Min,Max) values the enum can store based on the NumPositiveBits and NumNegativeBits.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
EnumDecl * getDecl() const
ExplicitCastExpr - An explicit cast written in the source code.
This represents one expression.
const Expr * skipRValueSubobjectAdjustments(SmallVectorImpl< const Expr * > &CommaLHS, SmallVectorImpl< SubobjectAdjustment > &Adjustments) const
Walk outwards from an expression we want to bind a reference to and find the expression whose lifetim...
Expr * IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY
Skip past any parentheses and casts which do not change the value (including ptr->int casts of the sa...
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsLValue - Evaluate an expression to see if we can fold it to an lvalue with link time known ...
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
Decl * getReferencedDeclOfCallee()
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
bool isFlexibleArrayMemberLike(ASTContext &Context, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel, bool IgnoreTemplateOrMacroSubstitution=false) const
Check whether this array fits the idiom of a flexible array member, depending on the value of -fstric...
bool isOBJCGCCandidate(ASTContext &Ctx) const
isOBJCGCCandidate - Return true if this expression may be used in a read/ write barrier.
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
bool isArrow() const
isArrow - Return true if the base expression is a pointer to vector, return false if the base express...
void getEncodedElementAccess(SmallVectorImpl< uint32_t > &Elts) const
getEncodedElementAccess - Encode the elements accessed into an llvm aggregate Constant of ConstantInt...
const Expr * getBase() const
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
bool isZeroSize(const ASTContext &Ctx) const
Determine if this field is a subobject of zero size, that is, either a zero-length bit-field or a fie...
FullExpr - Represents a "full-expression" node.
const Expr * getSubExpr() const
Represents a function declaration or definition.
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
Represents a prototype with parameter type info, e.g.
GlobalDecl - represents a global declaration.
const Decl * getDecl() const
Describes an C or C++ initializer list.
bool isTransparent() const
Is this a transparent initializer list (that is, an InitListExpr that is purely syntactic,...
const Expr * getInit(unsigned Init) const
StrictFlexArraysLevelKind
SanitizerSet Sanitize
Set of enabled sanitizers.
virtual void mangleCXXRTTI(QualType T, raw_ostream &)=0
unsigned getBlockId(const BlockDecl *BD, bool Local)
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Expr * getSubExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.
ValueDecl * getExtendingDecl()
Get the declaration which triggered the lifetime-extension of this temporary, if any.
MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.
bool isIncomplete() const
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why? This is only meaningful if the named memb...
SourceLocation getExprLoc() const LLVM_READONLY
A pointer to member type per C++ 8.3.3 - Pointers to members.
bool isObjCBOOLType(QualType T) const
Returns true if.
This represents a decl that may have a name.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
A C++ nested-name-specifier augmented with source location information.
bool containsType(SanitizerMask Mask, StringRef MangledTypeName, StringRef Category=StringRef()) const
OpenMP 5.0 [2.1.5, Array Sections].
Expr * getLength()
Get length of array section.
SourceLocation getColonLocFirst() const
SourceLocation getExprLoc() const LLVM_READONLY
Expr * getBase()
An array section can be written only as Base[LowerBound:Length].
static QualType getBaseOriginalType(const Expr *Base)
Return original type of the base expression for array section.
Expr * getLowerBound()
Get lower bound of array section.
ObjCEncodeExpr, used for @encode in Objective-C.
Represents an ObjC class declaration.
ObjCIvarDecl - Represents an ObjC instance variable.
ObjCIvarRefExpr - A reference to an ObjC instance variable.
const Expr * getBase() const
An expression that sends a message to the given Objective-C object or class.
const ObjCMethodDecl * getMethodDecl() const
QualType getReturnType() const
Represents a class type in Objective C.
ObjCSelectorExpr used for @selector in Objective-C.
Selector getSelector() const
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
ParenExpr - This represents a parethesized expression, e.g.
const Expr * getSubExpr() const
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
[C99 6.4.2.2] - A predefined identifier such as func.
StringRef getIdentKindName() const
PredefinedIdentKind getIdentKind() const
StringLiteral * getFunctionName()
Represents an unpacked "presumed" location which can be presented to the user.
unsigned getColumn() const
Return the presumed column number of this location.
const char * getFilename() const
Return the presumed filename of this location.
unsigned getLine() const
Return the presumed line number of this location.
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
semantics_iterator semantics_end()
semantics_iterator semantics_begin()
const Expr *const * const_semantics_iterator
Expr * getResultExpr()
Return the result-bearing expression, or null if there is none.
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 getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
QualType withCVRQualifiers(unsigned CVR) const
void * getAsOpaquePtr() const
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
bool isConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)
The collection of all-type qualifiers we support.
unsigned getCVRQualifiers() const
@ 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.
void addCVRQualifiers(unsigned mask)
void addQualifiers(Qualifiers Q)
Add the qualifiers from the given set to this set.
void setAddressSpace(LangAS space)
ObjCLifetime getObjCLifetime() const
Represents a struct/union/class.
field_range fields() const
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
bool isAnonymousStructOrUnion() const
Whether this is an anonymous struct or union.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Scope - A scope is a transient data structure that is used while parsing the program.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const
Returns the "presumed" location of a SourceLocation specifies.
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Stmt - This represents one statement.
StmtClass getStmtClass() const
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
Exposes information about the current target.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
virtual StringRef getABI() const
Get the ABI currently in use.
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 isBlockPointerType() const
bool isBooleanType() const
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
bool hasAttr(attr::Kind AK) const
Determine whether this type had the specified attribute applied to it (looking through top-level type...
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type.
bool isFunctionPointerType() const
bool isArithmeticType() const
bool isConstantMatrixType() 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>.
bool isReferenceType() const
bool isVariableArrayType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isExtVectorBoolType() const
bool isAnyComplexType() const
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isAtomicType() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool isVectorType() const
bool isFloatingType() const
const T * getAs() const
Member-template getAs<specific type>'.
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
bool isRecordType() const
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
SourceLocation getExprLoc() const
Expr * getSubExpr() const
Represents a call to the builtin function __builtin_va_arg.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
TLSKind getTLSKind() const
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
@ TLS_Dynamic
TLS with a dynamic initializer.
@ TLS_None
Not a TLS variable.
Represents a C array with a specified size that is not an integer-constant-expression.
Represents a GCC generic vector type.
unsigned getNumElements() const
AlignmentSource
The source of the alignment of an l-value; an expression of confidence in the alignment actually matc...
@ 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...
static AlignmentSource getFieldAlignmentSource(AlignmentSource Source)
Given that the base address has the given alignment source, what's our confidence in the alignment of...
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< ArrayType > arrayType
Matches all kinds of arrays.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
const AstTypeMatcher< FunctionType > functionType
Matches FunctionType nodes.
const void * Store
Store - This opaque type encapsulates an immutable mapping from locations to values.
bool This(InterpState &S, CodePtr OpPC)
bool Zero(InterpState &S, CodePtr OpPC)
bool Load(InterpState &S, CodePtr OpPC)
bool Cast(InterpState &S, CodePtr OpPC)
The JSON file list parser is used to communicate input to InstallAPI.
@ OK_BitField
A bitfield object is a bitfield on a C or C++ record.
@ Asm
Assembly: we accept this only so that we can preprocess it.
StorageDuration
The storage duration for an object (per C++ [basic.stc]).
@ SD_Thread
Thread storage duration.
@ SD_Static
Static storage duration.
@ SD_FullExpression
Full-expression storage duration (for temporaries).
@ SD_Automatic
Automatic storage duration (most local variables).
@ SD_Dynamic
Dynamic storage duration.
@ Result
The result type of a method or function.
@ Dtor_Complete
Complete object dtor.
llvm::hash_code hash_value(const CustomizableOptional< T > &O)
LangAS getLangASFromTargetAS(unsigned TargetAS)
@ Interface
The "__interface" keyword introduces the elaborated-type-specifier.
@ Other
Other implicit parameter.
@ NOUR_Unevaluated
This name appears in an unevaluated operand.
@ NOUR_Constant
This name appears as a potential result of an lvalue-to-rvalue conversion that is a constant expressi...
__INTPTR_TYPE__ intptr_t
A signed integer type with the property that any valid pointer to void can be converted to this type,...
Structure with information about how a bitfield should be accessed.
CharUnits VolatileStorageOffset
The offset of the bitfield storage from the start of the struct.
unsigned VolatileOffset
The offset within a contiguous run of bitfields that are represented as a single "field" within the L...
unsigned Offset
The offset within a contiguous run of bitfields that are represented as a single "field" within the L...
unsigned VolatileStorageSize
The storage size in bits which should be used when accessing this bitfield.
unsigned Size
The total size of the bit-field, in bits.
unsigned StorageSize
The storage size in bits which should be used when accessing this bitfield.
unsigned IsSigned
Whether the bit-field is signed.
static Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, Address VDAddr, SourceLocation Loc)
Returns address of the threadprivate variable for the current thread.
llvm::PointerType * VoidPtrTy
llvm::IntegerType * Int64Ty
CharUnits getIntAlign() const
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
unsigned char PointerWidthInBits
The width of a pointer into the generic address space.
llvm::IntegerType * SizeTy
llvm::IntegerType * Int32Ty
llvm::IntegerType * IntPtrTy
llvm::PointerType * Int8PtrTy
llvm::PointerType * UnqualPtrTy
CharUnits getPointerAlign() const
LangAS getASTAllocaAddressSpace() const
llvm::MDNode * AccessType
AccessType - The final access type.
uint64_t Offset
Offset - The byte offset of the final access within the base one.
static TBAAAccessInfo getMayAliasInfo()
uint64_t Size
Size - The size of access, in bytes.
llvm::MDNode * BaseType
BaseType - The base/leading access type.
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
bool HasSideEffects
Whether the evaluated expression has side effects.
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.
An adjustment to be made to the temporary created when emitting a reference binding,...
@ DerivedToBaseAdjustment
@ MemberPointerAdjustment