34#include "llvm/ADT/Hashing.h"
35#include "llvm/ADT/STLExtras.h"
36#include "llvm/ADT/StringExtras.h"
37#include "llvm/IR/DataLayout.h"
38#include "llvm/IR/Intrinsics.h"
39#include "llvm/IR/IntrinsicsWebAssembly.h"
40#include "llvm/IR/LLVMContext.h"
41#include "llvm/IR/MDBuilder.h"
42#include "llvm/IR/MatrixBuilder.h"
43#include "llvm/Passes/OptimizationLevel.h"
44#include "llvm/Support/ConvertUTF.h"
45#include "llvm/Support/MathExtras.h"
46#include "llvm/Support/Path.h"
47#include "llvm/Support/SaveAndRestore.h"
48#include "llvm/Support/xxhash.h"
49#include "llvm/Transforms/Utils/SanitizerStats.h"
55using namespace CodeGen;
59 "ubsan-unique-traps", llvm::cl::Optional,
60 llvm::cl::desc(
"Deoptimize traps for UBSAN so there is 1 trap per check."));
65 "ubsan-guard-checks", llvm::cl::Optional,
66 llvm::cl::desc(
"Guard UBSAN checks with `llvm.allow.ubsan.check()`."));
75CodeGenFunction::CreateTempAllocaWithoutCast(llvm::Type *Ty,
CharUnits Align,
77 llvm::Value *ArraySize) {
87 llvm::Value *ArraySize,
92 llvm::Value *
V = Alloca.getPointer();
99 llvm::IRBuilderBase::InsertPointGuard IPG(
Builder);
107 Ty->getPointerTo(DestAddrSpace),
true);
118 llvm::Value *ArraySize) {
119 llvm::AllocaInst *Alloca;
121 Alloca =
Builder.CreateAlloca(Ty, ArraySize, Name);
126 Allocas->Add(Alloca);
160 auto *ArrayTy = cast<llvm::ArrayType>(
Result.getElementType());
161 auto *VectorTy = llvm::FixedVectorType::get(ArrayTy->getElementType(),
162 ArrayTy->getNumElements());
193 CGFPOptionsRAII FPOptsRAII(*
this,
E);
211 if (
const auto *CondOp = dyn_cast<AbstractConditionalOperator>(
234 if (!ignoreResult && aggSlot.
isIgnored())
239 llvm_unreachable(
"bad evaluation kind");
281 llvm_unreachable(
"bad evaluation kind");
321 bool Precise = isa_and_nonnull<VarDecl>(VD) &&
322 VD->
hasAttr<ObjCPreciseLifetimeAttr>();
343 llvm_unreachable(
"temporary cannot have dynamic storage duration");
345 llvm_unreachable(
"unknown storage duration");
353 auto *ClassDecl = cast<CXXRecordDecl>(RT->getDecl());
354 if (!ClassDecl->hasTrivialDestructor())
355 ReferenceTemporaryDtor = ClassDecl->getDestructor();
358 if (!ReferenceTemporaryDtor)
365 llvm::FunctionCallee CleanupFn;
366 llvm::Constant *CleanupArg;
372 CleanupArg = llvm::Constant::getNullValue(CGF.
Int8PtrTy);
376 CleanupArg = cast<llvm::Constant>(ReferenceTemporary.
emitRawPointer(CGF));
397 llvm_unreachable(
"temporary cannot have dynamic storage duration");
419 auto *GV =
new llvm::GlobalVariable(
421 llvm::GlobalValue::PrivateLinkage,
Init,
".ref.tmp",
nullptr,
422 llvm::GlobalValue::NotThreadLocal,
426 llvm::Constant *
C = GV;
428 C = TCG.performAddrSpaceCast(
430 GV->getValueType()->getPointerTo(
433 return RawAddress(
C, GV->getValueType(), alignment);
442 llvm_unreachable(
"temporary can't have dynamic storage duration");
444 llvm_unreachable(
"unknown storage duration");
458 "Reference should never be pseudo-strong!");
466 if (
auto *Var = dyn_cast<llvm::GlobalVariable>(
Object.getPointer())) {
476 if (Var->hasInitializer())
485 default: llvm_unreachable(
"expected scalar or aggregate expression");
508 for (
const auto &Ignored : CommaLHSs)
511 if (
const auto *opaque = dyn_cast<OpaqueValueExpr>(
E)) {
512 if (opaque->getType()->isRecordType()) {
513 assert(Adjustments.empty());
521 if (
auto *Var = dyn_cast<llvm::GlobalVariable>(
522 Object.getPointer()->stripPointerCasts())) {
528 if (!Var->hasInitializer()) {
544 if (!ShouldEmitLifetimeMarkers)
554 ConditionalEvaluation *OldConditional =
nullptr;
555 CGBuilderTy::InsertPoint OldIP;
561 OldConditional = OutermostConditional;
562 OutermostConditional =
nullptr;
565 llvm::BasicBlock *
Block = OldConditional->getStartingBlock();
566 Builder.restoreIP(CGBuilderTy::InsertPoint(
567 Block, llvm::BasicBlock::iterator(
Block->back())));
577 if (OldConditional) {
578 OutermostConditional = OldConditional;
595 switch (Adjustment.Kind) {
599 Adjustment.DerivedToBase.BasePath->path_begin(),
600 Adjustment.DerivedToBase.BasePath->path_end(),
608 "materialized temporary field is not a simple lvalue");
649 const llvm::Constant *Elts) {
650 return cast<llvm::ConstantInt>(Elts->getAggregateElement(Idx))
657 Builder.CreateMul(Ptr, Builder.getInt64(0xbf58476d1ce4e5b9u));
659 Builder.CreateXor(A0, Builder.CreateLShr(A0, Builder.getInt64(31)));
660 return Builder.CreateXor(Acc, A1);
687 llvm::Value *ArraySize) {
694 if (Ptr->getType()->getPointerAddressSpace())
702 SanitizerScope SanScope(
this);
705 llvm::BasicBlock *Done =
nullptr;
710 auto PtrToAlloca = dyn_cast<llvm::AllocaInst>(Ptr->stripPointerCasts());
713 llvm::Value *IsNonNull =
nullptr;
714 bool IsGuaranteedNonNull =
715 SkippedChecks.
has(SanitizerKind::Null) || PtrToAlloca;
717 if ((
SanOpts.
has(SanitizerKind::Null) || AllowNullPointers) &&
718 !IsGuaranteedNonNull) {
720 IsNonNull =
Builder.CreateIsNotNull(Ptr);
724 IsGuaranteedNonNull = IsNonNull ==
True;
727 if (!IsGuaranteedNonNull) {
728 if (AllowNullPointers) {
733 Builder.CreateCondBr(IsNonNull, Rest, Done);
736 Checks.push_back(std::make_pair(IsNonNull, SanitizerKind::Null));
742 !SkippedChecks.
has(SanitizerKind::ObjectSize) &&
745 llvm::Value *
Size = llvm::ConstantInt::get(
IntPtrTy, TySize);
750 llvm::Constant *ConstantSize = dyn_cast<llvm::Constant>(Size);
751 if (!ConstantSize || !ConstantSize->isNullValue()) {
757 llvm::Function *F =
CGM.
getIntrinsic(llvm::Intrinsic::objectsize, Tys);
759 llvm::Value *NullIsUnknown =
Builder.getFalse();
761 llvm::Value *LargeEnough =
Builder.CreateICmpUGE(
762 Builder.CreateCall(F, {Ptr, Min, NullIsUnknown, Dynamic}), Size);
763 Checks.push_back(std::make_pair(LargeEnough, SanitizerKind::ObjectSize));
767 llvm::MaybeAlign AlignVal;
768 llvm::Value *PtrAsInt =
nullptr;
771 !SkippedChecks.
has(SanitizerKind::Alignment)) {
779 if (AlignVal && *AlignVal > llvm::Align(1) &&
780 (!PtrToAlloca || PtrToAlloca->getAlign() < *AlignVal)) {
782 llvm::Value *Align =
Builder.CreateAnd(
783 PtrAsInt, llvm::ConstantInt::get(
IntPtrTy, AlignVal->value() - 1));
784 llvm::Value *Aligned =
787 Checks.push_back(std::make_pair(Aligned, SanitizerKind::Alignment));
791 if (Checks.size() > 0) {
792 llvm::Constant *StaticData[] = {
794 llvm::ConstantInt::get(
Int8Ty, AlignVal ? llvm::Log2(*AlignVal) : 1),
795 llvm::ConstantInt::get(
Int8Ty, TCK)};
796 EmitCheck(Checks, SanitizerHandler::TypeMismatch, StaticData,
797 PtrAsInt ? PtrAsInt : Ptr);
812 if (!IsGuaranteedNonNull) {
814 IsNonNull =
Builder.CreateIsNotNull(Ptr);
818 Builder.CreateCondBr(IsNonNull, VptrNotNull, Done);
824 llvm::raw_svector_ostream Out(MangledName);
832 llvm::Value *TypeHash =
833 llvm::ConstantInt::get(
Int64Ty, xxh3_64bits(Out.str()));
835 llvm::Type *VPtrTy = llvm::PointerType::get(
IntPtrTy, 0);
847 const int CacheSize = 128;
848 llvm::Type *HashTable = llvm::ArrayType::get(
IntPtrTy, CacheSize);
850 "__ubsan_vptr_type_cache");
851 llvm::Value *Slot =
Builder.CreateAnd(Hash,
854 llvm::Value *Indices[] = {
Builder.getInt32(0), Slot };
863 llvm::Value *EqualHash =
Builder.CreateICmpEQ(CacheVal, Hash);
864 llvm::Constant *StaticData[] = {
868 llvm::ConstantInt::get(
Int8Ty, TCK)
870 llvm::Value *DynamicData[] = { Ptr, Hash };
871 EmitCheck(std::make_pair(EqualHash, SanitizerKind::Vptr),
872 SanitizerHandler::DynamicTypeCacheMiss, StaticData,
886 uint64_t EltSize =
C.getTypeSizeInChars(EltTy).getQuantity();
894 auto *ParamDecl = dyn_cast<ParmVarDecl>(ArrayDeclRef->getDecl());
898 auto *POSAttr = ParamDecl->getAttr<PassObjectSizeAttr>();
903 int POSType = POSAttr->getType();
904 if (POSType != 0 && POSType != 1)
908 auto PassedSizeIt = SizeArguments.find(ParamDecl);
909 if (PassedSizeIt == SizeArguments.end())
913 assert(LocalDeclMap.count(PassedSizeDecl) &&
"Passed size not loadable");
914 Address AddrOfSize = LocalDeclMap.find(PassedSizeDecl)->second;
917 llvm::Value *SizeOfElement =
918 llvm::ConstantInt::get(SizeInBytes->getType(), EltSize);
919 return Builder.CreateUDiv(SizeInBytes, SizeOfElement);
928 StrictFlexArraysLevel) {
931 IndexedType =
Base->getType();
932 return CGF.
Builder.getInt32(VT->getNumElements());
937 if (
const auto *CE = dyn_cast<CastExpr>(
Base)) {
938 if (CE->getCastKind() == CK_ArrayToPointerDecay &&
939 !CE->getSubExpr()->isFlexibleArrayMemberLike(CGF.
getContext(),
940 StrictFlexArraysLevel)) {
941 CodeGenFunction::SanitizerScope SanScope(&CGF);
943 IndexedType = CE->getSubExpr()->getType();
945 if (
const auto *CAT = dyn_cast<ConstantArrayType>(AT))
946 return CGF.
Builder.getInt(CAT->getSize());
948 if (
const auto *VAT = dyn_cast<VariableArrayType>(AT))
954 CodeGenFunction::SanitizerScope SanScope(&CGF);
956 QualType EltTy{
Base->getType()->getPointeeOrArrayElementType(), 0};
958 IndexedType =
Base->getType();
983class StructAccessBase
987 bool IsExpectedRecordDecl(
const Expr *
E)
const {
995 StructAccessBase(
const RecordDecl *ExpectedRD) : ExpectedRD(ExpectedRD) {}
1018 const Expr *VisitStmt(
const Stmt *S) {
return nullptr; }
1034 return IsExpectedRecordDecl(
E) ?
E :
nullptr;
1037 if (IsExpectedRecordDecl(
E) &&
E->isArrow())
1039 const Expr *Res = Visit(
E->getBase());
1040 return !Res && IsExpectedRecordDecl(
E) ?
E : Res;
1043 return IsExpectedRecordDecl(
E) ?
E :
nullptr;
1046 return IsExpectedRecordDecl(
E) ?
E :
nullptr;
1050 if (IsExpectedRecordDecl(
E))
1052 return Visit(
E->getBase());
1055 return Visit(
E->getSubExpr());
1058 return Visit(
E->getSubExpr());
1061 return Visit(
E->getSubExpr());
1064 return Visit(
E->getSubExpr());
1077 int64_t FieldNo = -1;
1086 Indices.emplace_back(std::make_pair(RD, CGF.
Builder.getInt32(FieldNo)));
1095 Indices.emplace_back(std::make_pair(RD, CGF.
Builder.getInt32(FieldNo)));
1117 const Expr *StructBase = StructAccessBase(RD).Visit(
Base);
1121 llvm::Value *Res =
nullptr;
1122 if (
const auto *DRE = dyn_cast<DeclRefExpr>(StructBase)) {
1126 }
else if (
const MemberExpr *ME = dyn_cast<MemberExpr>(StructBase)) {
1144 for (
auto I = Indices.rbegin(),
E = Indices.rend(); I !=
E; ++I)
1147 {Zero, I->second},
"..counted_by.gep");
1161 const auto *CountDRE = cast<DeclRefExpr>(CAT->getCountExpr());
1162 const auto *CountDecl = CountDRE->getDecl();
1163 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(CountDecl))
1164 CountDecl = IFD->getAnonField();
1166 return dyn_cast<FieldDecl>(CountDecl);
1170 llvm::Value *Index,
QualType IndexType,
1172 assert(
SanOpts.
has(SanitizerKind::ArrayBounds) &&
1173 "should not be called unless adding bounds checks");
1177 llvm::Value *Bound =
1186 QualType IndexedType,
bool Accessed) {
1190 SanitizerScope SanScope(
this);
1193 llvm::Value *IndexVal =
Builder.CreateIntCast(Index,
SizeTy, IndexSigned);
1194 llvm::Value *BoundVal =
Builder.CreateIntCast(Bound,
SizeTy,
false);
1196 llvm::Constant *StaticData[] = {
1201 llvm::Value *Check = Accessed ?
Builder.CreateICmpULT(IndexVal, BoundVal)
1202 :
Builder.CreateICmpULE(IndexVal, BoundVal);
1203 EmitCheck(std::make_pair(Check, SanitizerKind::ArrayBounds),
1204 SanitizerHandler::OutOfBounds, StaticData, Index);
1209 bool isInc,
bool isPre) {
1212 llvm::Value *NextVal;
1213 if (isa<llvm::IntegerType>(InVal.first->getType())) {
1214 uint64_t AmountVal = isInc ? 1 : -1;
1215 NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal,
true);
1218 NextVal =
Builder.CreateAdd(InVal.first, NextVal, isInc ?
"inc" :
"dec");
1221 llvm::APFloat FVal(
getContext().getFloatTypeSemantics(ElemTy), 1);
1227 NextVal =
Builder.CreateFAdd(InVal.first, NextVal, isInc ?
"inc" :
"dec");
1240 return isPre ? IncVal : InVal;
1250 DI->EmitExplicitCastType(
E->
getType());
1267 if (
const CastExpr *CE = dyn_cast<CastExpr>(
E)) {
1268 if (
const auto *ECE = dyn_cast<ExplicitCastExpr>(CE))
1271 switch (CE->getCastKind()) {
1275 case CK_AddressSpaceConversion:
1276 if (
auto PtrTy = CE->getSubExpr()->getType()->getAs<
PointerType>()) {
1277 if (PtrTy->getPointeeType()->isVoidType())
1283 CE->getSubExpr(), &InnerBaseInfo, &InnerTBAAInfo, IsKnownNonNull);
1284 if (BaseInfo) *BaseInfo = InnerBaseInfo;
1285 if (TBAAInfo) *TBAAInfo = InnerTBAAInfo;
1287 if (isa<ExplicitCastExpr>(CE)) {
1291 E->
getType(), &TargetTypeBaseInfo, &TargetTypeTBAAInfo);
1304 if (CGF.
SanOpts.
has(SanitizerKind::CFIUnrelatedCast) &&
1305 CE->getCastKind() == CK_BitCast) {
1313 llvm::Type *ElemTy =
1316 if (CE->getCastKind() == CK_AddressSpaceConversion)
1325 case CK_ArrayToPointerDecay:
1329 case CK_UncheckedDerivedToBase:
1330 case CK_DerivedToBase: {
1337 CE->getSubExpr(), BaseInfo,
nullptr,
1339 CE->getCastKind() == CK_UncheckedDerivedToBase));
1340 auto Derived = CE->getSubExpr()->
getType()->getPointeeCXXRecordDecl();
1342 Addr, Derived, CE->path_begin(), CE->path_end(),
1355 if (UO->getOpcode() == UO_AddrOf) {
1364 if (
auto *
Call = dyn_cast<CallExpr>(
E)) {
1365 switch (
Call->getBuiltinCallee()) {
1368 case Builtin::BIaddressof:
1369 case Builtin::BI__addressof:
1370 case Builtin::BI__builtin_addressof: {
1384 true, BaseInfo, TBAAInfo, IsKnownNonNull);
1403 return Builder.CreateICmpNE(
V, llvm::Constant::getNullValue(
V->getType()));
1414 llvm::Value *
U = llvm::UndefValue::get(EltTy);
1429 llvm_unreachable(
"bad evaluation kind");
1449 while (!isa<CXXThisExpr>(
Base)) {
1451 if (isa<CXXDynamicCastExpr>(
Base))
1454 if (
const auto *CE = dyn_cast<CastExpr>(
Base)) {
1455 Base = CE->getSubExpr();
1456 }
else if (
const auto *PE = dyn_cast<ParenExpr>(
Base)) {
1457 Base = PE->getSubExpr();
1458 }
else if (
const auto *UO = dyn_cast<UnaryOperator>(
Base)) {
1459 if (UO->getOpcode() == UO_Extension)
1460 Base = UO->getSubExpr();
1472 if (
SanOpts.
has(SanitizerKind::ArrayBounds) && isa<ArraySubscriptExpr>(
E))
1478 if (
const auto *ME = dyn_cast<MemberExpr>(
E)) {
1481 SkippedChecks.
set(SanitizerKind::Alignment,
true);
1482 if (IsBaseCXXThis || isa<DeclRefExpr>(ME->getBase()))
1483 SkippedChecks.
set(SanitizerKind::Null,
true);
1507 LValue LV = EmitLValueHelper(
E, IsKnownNonNull);
1516 if (isa<OpaqueValueExpr>(SE))
1518 return cast<CallExpr>(SE)->getCallReturnType(Ctx)->
getPointeeType();
1521LValue CodeGenFunction::EmitLValueHelper(
const Expr *
E,
1527 case Expr::ObjCPropertyRefExprClass:
1528 llvm_unreachable(
"cannot emit a property reference directly");
1530 case Expr::ObjCSelectorExprClass:
1532 case Expr::ObjCIsaExprClass:
1534 case Expr::BinaryOperatorClass:
1536 case Expr::CompoundAssignOperatorClass: {
1539 Ty = AT->getValueType();
1544 case Expr::CallExprClass:
1545 case Expr::CXXMemberCallExprClass:
1546 case Expr::CXXOperatorCallExprClass:
1547 case Expr::UserDefinedLiteralClass:
1549 case Expr::CXXRewrittenBinaryOperatorClass:
1550 return EmitLValue(cast<CXXRewrittenBinaryOperator>(
E)->getSemanticForm(),
1552 case Expr::VAArgExprClass:
1554 case Expr::DeclRefExprClass:
1556 case Expr::ConstantExprClass: {
1562 return EmitLValue(cast<ConstantExpr>(
E)->getSubExpr(), IsKnownNonNull);
1564 case Expr::ParenExprClass:
1565 return EmitLValue(cast<ParenExpr>(
E)->getSubExpr(), IsKnownNonNull);
1566 case Expr::GenericSelectionExprClass:
1567 return EmitLValue(cast<GenericSelectionExpr>(
E)->getResultExpr(),
1569 case Expr::PredefinedExprClass:
1571 case Expr::StringLiteralClass:
1573 case Expr::ObjCEncodeExprClass:
1575 case Expr::PseudoObjectExprClass:
1577 case Expr::InitListExprClass:
1579 case Expr::CXXTemporaryObjectExprClass:
1580 case Expr::CXXConstructExprClass:
1582 case Expr::CXXBindTemporaryExprClass:
1584 case Expr::CXXUuidofExprClass:
1586 case Expr::LambdaExprClass:
1589 case Expr::ExprWithCleanupsClass: {
1590 const auto *cleanups = cast<ExprWithCleanups>(
E);
1591 RunCleanupsScope
Scope(*
this);
1598 Scope.ForceCleanup({&
V});
1608 case Expr::CXXDefaultArgExprClass: {
1609 auto *DAE = cast<CXXDefaultArgExpr>(
E);
1610 CXXDefaultArgExprScope
Scope(*
this, DAE);
1611 return EmitLValue(DAE->getExpr(), IsKnownNonNull);
1613 case Expr::CXXDefaultInitExprClass: {
1614 auto *DIE = cast<CXXDefaultInitExpr>(
E);
1615 CXXDefaultInitExprScope
Scope(*
this, DIE);
1616 return EmitLValue(DIE->getExpr(), IsKnownNonNull);
1618 case Expr::CXXTypeidExprClass:
1621 case Expr::ObjCMessageExprClass:
1623 case Expr::ObjCIvarRefExprClass:
1625 case Expr::StmtExprClass:
1627 case Expr::UnaryOperatorClass:
1629 case Expr::ArraySubscriptExprClass:
1631 case Expr::MatrixSubscriptExprClass:
1633 case Expr::ArraySectionExprClass:
1635 case Expr::ExtVectorElementExprClass:
1637 case Expr::CXXThisExprClass:
1639 case Expr::MemberExprClass:
1641 case Expr::CompoundLiteralExprClass:
1643 case Expr::ConditionalOperatorClass:
1645 case Expr::BinaryConditionalOperatorClass:
1647 case Expr::ChooseExprClass:
1648 return EmitLValue(cast<ChooseExpr>(
E)->getChosenSubExpr(), IsKnownNonNull);
1649 case Expr::OpaqueValueExprClass:
1651 case Expr::SubstNonTypeTemplateParmExprClass:
1652 return EmitLValue(cast<SubstNonTypeTemplateParmExpr>(
E)->getReplacement(),
1654 case Expr::ImplicitCastExprClass:
1655 case Expr::CStyleCastExprClass:
1656 case Expr::CXXFunctionalCastExprClass:
1657 case Expr::CXXStaticCastExprClass:
1658 case Expr::CXXDynamicCastExprClass:
1659 case Expr::CXXReinterpretCastExprClass:
1660 case Expr::CXXConstCastExprClass:
1661 case Expr::CXXAddrspaceCastExprClass:
1662 case Expr::ObjCBridgedCastExprClass:
1665 case Expr::MaterializeTemporaryExprClass:
1668 case Expr::CoawaitExprClass:
1670 case Expr::CoyieldExprClass:
1672 case Expr::PackIndexingExprClass:
1673 return EmitLValue(cast<PackIndexingExpr>(
E)->getSelectedExpr());
1680 assert(
type.isCanonical());
1681 assert(!
type->isReferenceType());
1689 if (
const auto *RT = dyn_cast<RecordType>(
type))
1690 if (
const auto *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
1691 if (RD->hasMutableFields() || !RD->isTrivial())
1712 if (
const auto *ref = dyn_cast<ReferenceType>(
type)) {
1728CodeGenFunction::ConstantEmission
1734 if (isa<ParmVarDecl>(value)) {
1736 }
else if (
auto *var = dyn_cast<VarDecl>(value)) {
1738 }
else if (isa<EnumConstantDecl>(value)) {
1743 if (CEK ==
CEK_None)
return ConstantEmission();
1746 bool resultIsReference;
1752 resultIsReference =
false;
1753 resultType = refExpr->
getType();
1758 resultIsReference =
true;
1759 resultType = value->
getType();
1763 return ConstantEmission();
1768 return ConstantEmission();
1779 auto *MD = dyn_cast_or_null<CXXMethodDecl>(
CurCodeDecl);
1780 if (MD && MD->getParent()->isLambda() &&
1781 MD->getOverloadedOperator() == OO_Call) {
1784 if (
const VarDecl *VD = dyn_cast<const VarDecl>(
D)) {
1785 if (!VD->hasAttr<CUDADeviceAttr>()) {
1786 return ConstantEmission();
1795 result.
Val, resultType);
1799 if (isa<VarDecl>(value)) {
1800 if (!
getContext().DeclMustBeEmitted(cast<VarDecl>(value)))
1803 assert(isa<EnumConstantDecl>(value));
1808 if (resultIsReference)
1826CodeGenFunction::ConstantEmission
1830 return ConstantEmission();
1834 const CodeGenFunction::ConstantEmission &Constant,
Expr *
E) {
1835 assert(Constant &&
"not a constant");
1836 if (Constant.isReference())
1840 return Constant.getValue();
1855 return ET->getDecl()->getIntegerType()->isBooleanType();
1864 llvm::APInt &
Min, llvm::APInt &End,
1865 bool StrictEnums,
bool IsBool) {
1867 bool IsRegularCPlusPlusEnum = CGF.
getLangOpts().CPlusPlus && StrictEnums &&
1869 if (!IsBool && !IsRegularCPlusPlusEnum)
1882llvm::MDNode *CodeGenFunction::getRangeForLoadFromType(
QualType Ty) {
1883 llvm::APInt
Min, End;
1889 return MDHelper.createRange(
Min, End);
1894 bool HasBoolCheck =
SanOpts.
has(SanitizerKind::Bool);
1895 bool HasEnumCheck =
SanOpts.
has(SanitizerKind::Enum);
1896 if (!HasBoolCheck && !HasEnumCheck)
1901 bool NeedsBoolCheck = HasBoolCheck && IsBool;
1902 bool NeedsEnumCheck = HasEnumCheck && Ty->
getAs<
EnumType>();
1903 if (!NeedsBoolCheck && !NeedsEnumCheck)
1910 cast<llvm::IntegerType>(
Value->
getType())->getBitWidth() == 1)
1913 llvm::APInt
Min, End;
1918 SanitizerScope SanScope(
this);
1922 Check =
Builder.CreateICmpULE(
Value, llvm::ConstantInt::get(Ctx, End));
1924 llvm::Value *Upper =
1925 Builder.CreateICmpSLE(
Value, llvm::ConstantInt::get(Ctx, End));
1926 llvm::Value *Lower =
1928 Check =
Builder.CreateAnd(Upper, Lower);
1933 NeedsEnumCheck ? SanitizerKind::Enum : SanitizerKind::Bool;
1934 EmitCheck(std::make_pair(Check, Kind), SanitizerHandler::LoadInvalidValue,
1944 bool isNontemporal) {
1945 if (
auto *GV = dyn_cast<llvm::GlobalValue>(Addr.
getBasePointer()))
1946 if (GV->isThreadLocal())
1952 if (ClangVecTy->isExtVectorBoolType()) {
1954 unsigned ValNumElems =
1955 cast<llvm::FixedVectorType>(ValTy)->getNumElements();
1958 const auto *RawIntTy = RawIntV->getType();
1959 assert(RawIntTy->isIntegerTy() &&
"compressed iN storage for bitvectors");
1961 auto *PaddedVecTy = llvm::FixedVectorType::get(
1962 Builder.getInt1Ty(), RawIntTy->getPrimitiveSizeInBits());
1963 llvm::Value *
V =
Builder.CreateBitCast(RawIntV, PaddedVecTy);
1972 const auto *VTy = cast<llvm::FixedVectorType>(EltTy);
1976 llvm::VectorType *vec4Ty =
1977 llvm::FixedVectorType::get(VTy->getElementType(), 4);
1999 if (isNontemporal) {
2000 llvm::MDNode *
Node = llvm::MDNode::get(
2001 Load->getContext(), llvm::ConstantAsMetadata::get(
Builder.getInt32(1)));
2002 Load->setMetadata(llvm::LLVMContext::MD_nontemporal,
Node);
2011 if (llvm::MDNode *RangeInfo = getRangeForLoadFromType(Ty)) {
2012 Load->setMetadata(llvm::LLVMContext::MD_range, RangeInfo);
2013 Load->setMetadata(llvm::LLVMContext::MD_noundef,
2033 unsigned MemNumElems = StoreTy->getPrimitiveSizeInBits();
2050 auto *PaddedVecTy = llvm::FixedVectorType::get(
2051 Builder.getInt1Ty(), RawIntTy->getPrimitiveSizeInBits());
2055 unsigned ValNumElems = cast<llvm::FixedVectorType>(ValTy)->getNumElements();
2071 bool IsVector =
true) {
2072 auto *ArrayTy = dyn_cast<llvm::ArrayType>(Addr.
getElementType());
2073 if (ArrayTy && IsVector) {
2074 auto *VectorTy = llvm::FixedVectorType::get(ArrayTy->getElementType(),
2075 ArrayTy->getNumElements());
2079 auto *VectorTy = dyn_cast<llvm::VectorType>(Addr.
getElementType());
2080 if (VectorTy && !IsVector) {
2081 auto *ArrayTy = llvm::ArrayType::get(
2082 VectorTy->getElementType(),
2083 cast<llvm::FixedVectorType>(VectorTy)->getNumElements());
2097 value->getType()->isVectorTy());
2107 bool isInit,
bool isNontemporal) {
2108 if (
auto *GV = dyn_cast<llvm::GlobalValue>(Addr.
getBasePointer()))
2109 if (GV->isThreadLocal())
2115 auto *VecTy = dyn_cast<llvm::FixedVectorType>(SrcTy);
2118 if (VecTy && !ClangVecTy->isExtVectorBoolType() &&
2119 cast<llvm::FixedVectorType>(VecTy)->getNumElements() == 3) {
2123 SrcTy = llvm::FixedVectorType::get(VecTy->getElementType(), 4);
2142 if (isNontemporal) {
2143 llvm::MDNode *
Node =
2144 llvm::MDNode::get(
Store->getContext(),
2145 llvm::ConstantAsMetadata::get(
Builder.getInt32(1)));
2146 Store->setMetadata(llvm::LLVMContext::MD_nontemporal,
Node);
2186 llvm_unreachable(
"bad evaluation kind");
2242 llvm::MatrixBuilder MB(
Builder);
2243 MB.CreateIndexAssumption(Idx, MatTy->getNumElementsFlattened());
2245 llvm::LoadInst *
Load =
2250 assert(LV.
isBitField() &&
"Unknown LValue type!");
2268 const unsigned StorageSize =
2271 assert(
static_cast<unsigned>(Offset + Info.
Size) <= StorageSize);
2272 unsigned HighBits = StorageSize - Offset - Info.
Size;
2274 Val =
Builder.CreateShl(Val, HighBits,
"bf.shl");
2275 if (Offset + HighBits)
2276 Val =
Builder.CreateAShr(Val, Offset + HighBits,
"bf.ashr");
2279 Val =
Builder.CreateLShr(Val, Offset,
"bf.lshr");
2280 if (
static_cast<unsigned>(Offset) + Info.
Size < StorageSize)
2282 Val, llvm::APInt::getLowBitsSet(StorageSize, Info.
Size),
"bf.clear");
2298 llvm::Type *DstTy = llvm::FixedVectorType::get(Vec->getType(), 1);
2300 Vec =
Builder.CreateInsertElement(DstTy, Vec, Zero,
"cast.splat");
2310 llvm::Value *Elt = llvm::ConstantInt::get(
SizeTy, InIdx);
2318 for (
unsigned i = 0; i != NumResultElts; ++i)
2321 Vec =
Builder.CreateShuffleVector(Vec, Mask);
2340 return VectorBasePtrPlusIx;
2346 "Bad type for register variable");
2347 llvm::MDNode *RegName = cast<llvm::MDNode>(
2348 cast<llvm::MetadataAsValue>(LV.
getGlobalReg())->getMetadata());
2352 llvm::Type *Ty = OrigTy;
2353 if (OrigTy->isPointerTy())
2355 llvm::Type *Types[] = { Ty };
2357 llvm::Function *F =
CGM.
getIntrinsic(llvm::Intrinsic::read_register, Types);
2359 F, llvm::MetadataAsValue::get(Ty->getContext(), RegName));
2360 if (OrigTy->isPointerTy())
2375 auto *IRStoreTy = dyn_cast<llvm::IntegerType>(Vec->getType());
2377 auto *IRVecTy = llvm::FixedVectorType::get(
2378 Builder.getInt1Ty(), IRStoreTy->getPrimitiveSizeInBits());
2379 Vec =
Builder.CreateBitCast(Vec, IRVecTy);
2386 Vec =
Builder.CreateBitCast(Vec, IRStoreTy);
2405 llvm::MatrixBuilder MB(
Builder);
2406 MB.CreateIndexAssumption(Idx, MatTy->getNumElementsFlattened());
2416 assert(Dst.
isBitField() &&
"Unknown LValue type");
2424 llvm_unreachable(
"present but none");
2472 RHS =
Builder.CreatePtrToInt(RHS, ResultType,
"sub.ptr.rhs.cast");
2474 ResultType,
"sub.ptr.lhs.cast");
2475 llvm::Value *BytesBetween =
Builder.CreateSub(LHS, RHS,
"ivar.offset");
2486 assert(Src.
isScalar() &&
"Can't emit an agg store with this method");
2502 llvm::Value *MaskedVal = SrcVal;
2504 const bool UseVolatile =
2507 const unsigned StorageSize =
2512 if (StorageSize != Info.
Size) {
2513 assert(StorageSize > Info.
Size &&
"Invalid bitfield size.");
2520 SrcVal, llvm::APInt::getLowBitsSet(StorageSize, Info.
Size),
2524 SrcVal =
Builder.CreateShl(SrcVal, Offset,
"bf.shl");
2528 Val, ~llvm::APInt::getBitsSet(StorageSize, Offset, Offset + Info.
Size),
2532 SrcVal =
Builder.CreateOr(Val, SrcVal,
"bf.set");
2534 assert(Offset == 0);
2550 llvm::Value *ResultVal = MaskedVal;
2554 assert(Info.
Size <= StorageSize);
2555 unsigned HighBits = StorageSize - Info.
Size;
2557 ResultVal =
Builder.CreateShl(ResultVal, HighBits,
"bf.result.shl");
2558 ResultVal =
Builder.CreateAShr(ResultVal, HighBits,
"bf.result.ashr");
2576 "this should only occur for non-vector l-values");
2589 unsigned NumSrcElts = VTy->getNumElements();
2590 unsigned NumDstElts =
2591 cast<llvm::FixedVectorType>(Vec->getType())->getNumElements();
2592 if (NumDstElts == NumSrcElts) {
2597 for (
unsigned i = 0; i != NumSrcElts; ++i)
2600 Vec =
Builder.CreateShuffleVector(SrcVal, Mask);
2601 }
else if (NumDstElts > NumSrcElts) {
2607 for (
unsigned i = 0; i != NumSrcElts; ++i)
2608 ExtMask.push_back(i);
2609 ExtMask.resize(NumDstElts, -1);
2610 llvm::Value *ExtSrcVal =
Builder.CreateShuffleVector(SrcVal, ExtMask);
2613 for (
unsigned i = 0; i != NumDstElts; ++i)
2623 for (
unsigned i = 0; i != NumSrcElts; ++i)
2625 Vec =
Builder.CreateShuffleVector(Vec, ExtSrcVal, Mask);
2628 llvm_unreachable(
"unexpected shorten vector length");
2634 llvm::Value *Elt = llvm::ConstantInt::get(
SizeTy, InIdx);
2635 Vec =
Builder.CreateInsertElement(Vec, SrcVal, Elt);
2645 "Bad type for register variable");
2646 llvm::MDNode *RegName = cast<llvm::MDNode>(
2647 cast<llvm::MetadataAsValue>(Dst.
getGlobalReg())->getMetadata());
2648 assert(RegName &&
"Register LValue is not metadata");
2652 llvm::Type *Ty = OrigTy;
2653 if (OrigTy->isPointerTy())
2655 llvm::Type *Types[] = { Ty };
2657 llvm::Function *F =
CGM.
getIntrinsic(llvm::Intrinsic::write_register, Types);
2659 if (OrigTy->isPointerTy())
2662 F, {llvm::MetadataAsValue::get(Ty->getContext(), RegName),
Value});
2670 bool IsMemberAccess=
false) {
2674 if (isa<ObjCIvarRefExpr>(
E)) {
2687 auto *Exp = cast<ObjCIvarRefExpr>(
const_cast<Expr *
>(
E));
2693 if (
const auto *Exp = dyn_cast<DeclRefExpr>(
E)) {
2694 if (
const auto *VD = dyn_cast<VarDecl>(Exp->getDecl())) {
2695 if (VD->hasGlobalStorage()) {
2704 if (
const auto *Exp = dyn_cast<UnaryOperator>(
E)) {
2709 if (
const auto *Exp = dyn_cast<ParenExpr>(
E)) {
2723 if (
const auto *Exp = dyn_cast<GenericSelectionExpr>(
E)) {
2728 if (
const auto *Exp = dyn_cast<ImplicitCastExpr>(
E)) {
2733 if (
const auto *Exp = dyn_cast<CStyleCastExpr>(
E)) {
2738 if (
const auto *Exp = dyn_cast<ObjCBridgedCastExpr>(
E)) {
2743 if (
const auto *Exp = dyn_cast<ArraySubscriptExpr>(
E)) {
2756 if (
const auto *Exp = dyn_cast<MemberExpr>(
E)) {
2770 CGF, VD, Addr,
Loc);
2781 std::optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
2782 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD);
2786 if (!Res || ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
2787 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
2790 assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
2791 ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
2792 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
2794 "Expected link clause OR to clause with unified memory enabled.");
2804 llvm::LoadInst *
Load =
2809 PointeeBaseInfo, PointeeTBAAInfo);
2818 PointeeBaseInfo, PointeeTBAAInfo);
2828 BaseInfo, TBAAInfo);
2858 V = CGF.
Builder.CreateThreadLocalAddress(
V);
2862 Address Addr(
V, RealVarTy, Alignment);
2866 VD->
hasAttr<OMPThreadPrivateDeclAttr>()) {
2881 if (FD->
hasAttr<WeakRefAttr>()) {
2900 llvm::Value *ThisValue) {
2913 AsmLabelAttr *
Asm = VD->
getAttr<AsmLabelAttr>();
2914 assert(
Asm->getLabel().size() < 64-Name.size() &&
2915 "Register name too big");
2916 Name.append(
Asm->getLabel());
2917 llvm::NamedMDNode *M =
2918 CGM.
getModule().getOrInsertNamedMetadata(Name);
2919 if (M->getNumOperands() == 0) {
2922 llvm::Metadata *Ops[] = {Str};
2929 llvm::MetadataAsValue::get(CGM.
getLLVMContext(), M->getOperand(0));
2943 if (
E->refersToEnclosingVariableOrCapture())
2972 case llvm::GlobalValue::ExternalLinkage:
2973 case llvm::GlobalValue::LinkOnceODRLinkage:
2974 case llvm::GlobalValue::WeakODRLinkage:
2975 case llvm::GlobalValue::InternalLinkage:
2976 case llvm::GlobalValue::PrivateLinkage:
2988 "should not emit an unevaluated operand");
2990 if (
const auto *VD = dyn_cast<VarDecl>(ND)) {
2993 VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())
3001 (VD->getType()->isReferenceType() ||
3003 VD->getAnyInitializer(VD);
3005 E->getLocation(), *VD->evaluateValue(), VD->
getType());
3006 assert(Val &&
"failed to emit constant expression");
3009 if (!VD->getType()->isReferenceType()) {
3014 auto *PTy = llvm::PointerType::get(
3015 VarTy,
getTypes().getTargetAddressSpace(VD->getType()));
3032 if (
E->refersToEnclosingVariableOrCapture()) {
3033 VD = VD->getCanonicalDecl();
3037 auto I = LocalDeclMap.find(VD);
3038 if (I != LocalDeclMap.end()) {
3040 if (VD->getType()->isReferenceType())
3079 assert((ND->
isUsed(
false) || !isa<VarDecl>(ND) ||
E->isNonOdrUse() ||
3080 !
E->getLocation().isValid()) &&
3081 "Should not use decl without marking it used!");
3083 if (ND->
hasAttr<WeakRefAttr>()) {
3084 const auto *VD = cast<ValueDecl>(ND);
3089 if (
const auto *VD = dyn_cast<VarDecl>(ND)) {
3091 if (VD->hasLinkage() || VD->isStaticDataMember())
3097 auto iter = LocalDeclMap.find(VD);
3098 if (iter != LocalDeclMap.end()) {
3099 addr = iter->second;
3103 }
else if (VD->isStaticLocal()) {
3111 llvm_unreachable(
"DeclRefExpr for Decl not entered in LocalDeclMap?");
3122 VD->hasAttr<OMPThreadPrivateDeclAttr>()) {
3129 bool isBlockByref = VD->isEscapingByref();
3139 bool isLocalStorage = VD->hasLocalStorage();
3141 bool NonGCable = isLocalStorage &&
3149 bool isImpreciseLifetime =
3150 (isLocalStorage && !VD->hasAttr<ObjCPreciseLifetimeAttr>());
3151 if (isImpreciseLifetime)
3157 if (
const auto *FD = dyn_cast<FunctionDecl>(ND))
3163 if (
const auto *BD = dyn_cast<BindingDecl>(ND)) {
3164 if (
E->refersToEnclosingVariableOrCapture()) {
3173 if (
const auto *GD = dyn_cast<MSGuidDecl>(ND))
3177 if (
const auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
3181 if (AS !=
T.getAddressSpace()) {
3183 auto PtrTy = ATPO.getElementType()->getPointerTo(TargetAS);
3185 CGM, ATPO.getPointer(), AS,
T.getAddressSpace(), PtrTy);
3186 ATPO =
ConstantAddress(ASC, ATPO.getElementType(), ATPO.getAlignment());
3192 llvm_unreachable(
"Unhandled DeclRefExpr");
3197 if (
E->getOpcode() == UO_Extension)
3201 switch (
E->getOpcode()) {
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");
3231 if (
E->getOpcode() == UO_Real &&
3240 (
E->getOpcode() == UO_Real
3251 bool isInc =
E->getOpcode() == UO_PreInc;
3273 auto SL =
E->getFunctionName();
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;
3550 llvm::Value *Allow =
3552 llvm::ConstantInt::get(
CGM.
Int8Ty, CheckHandler));
3554 for (llvm::Value **Cond : {&FatalCond, &RecoverableCond, &TrapCond}) {
3562 if (!FatalCond && !RecoverableCond)
3565 llvm::Value *JointCond;
3566 if (FatalCond && RecoverableCond)
3567 JointCond =
Builder.CreateAnd(FatalCond, RecoverableCond);
3569 JointCond = FatalCond ? FatalCond : RecoverableCond;
3575 for (
int i = 1, n = Checked.size(); i < n; ++i) {
3577 "All recoverable kinds in a single check must be same!");
3584 llvm::Instruction *Branch =
Builder.CreateCondBr(JointCond, Cont, Handlers);
3587 llvm::MDNode *
Node = MDHelper.createLikelyBranchWeights();
3588 Branch->setMetadata(llvm::LLVMContext::MD_prof,
Node);
3597 Args.reserve(DynamicArgs.size() + 1);
3598 ArgTypes.reserve(DynamicArgs.size() + 1);
3601 if (!StaticArgs.empty()) {
3602 llvm::Constant *Info = llvm::ConstantStruct::getAnon(StaticArgs);
3603 auto *InfoPtr =
new llvm::GlobalVariable(
3605 llvm::GlobalVariable::PrivateLinkage, Info,
"",
nullptr,
3606 llvm::GlobalVariable::NotThreadLocal,
3608 InfoPtr->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3610 Args.push_back(InfoPtr);
3611 ArgTypes.push_back(Args.back()->getType());
3614 for (
size_t i = 0, n = DynamicArgs.size(); i != n; ++i) {
3620 llvm::FunctionType *FnType =
3621 llvm::FunctionType::get(
CGM.
VoidTy, ArgTypes,
false);
3623 if (!FatalCond || !RecoverableCond) {
3627 (FatalCond !=
nullptr), Cont);
3631 llvm::BasicBlock *NonFatalHandlerBB =
3634 Builder.CreateCondBr(FatalCond, NonFatalHandlerBB, FatalHandlerBB);
3647 SanitizerMask Kind, llvm::Value *Cond, llvm::ConstantInt *TypeId,
3652 llvm::BranchInst *BI =
Builder.CreateCondBr(Cond, Cont, CheckBB);
3655 llvm::MDNode *
Node = MDHelper.createLikelyBranchWeights();
3656 BI->setMetadata(llvm::LLVMContext::MD_prof,
Node);
3662 llvm::CallInst *CheckCall;
3663 llvm::FunctionCallee SlowPathFn;
3665 llvm::Constant *Info = llvm::ConstantStruct::getAnon(StaticArgs);
3667 new llvm::GlobalVariable(
CGM.
getModule(), Info->getType(),
false,
3668 llvm::GlobalVariable::PrivateLinkage, Info);
3669 InfoPtr->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3673 "__cfi_slowpath_diag",
3676 CheckCall =
Builder.CreateCall(SlowPathFn, {TypeId, Ptr, InfoPtr});
3681 CheckCall =
Builder.CreateCall(SlowPathFn, {TypeId, Ptr});
3685 cast<llvm::GlobalValue>(SlowPathFn.getCallee()->stripPointerCasts()));
3686 CheckCall->setDoesNotThrow();
3696 QualType QInt64Ty =
C.getIntTypeForBitwidth(64,
false);
3703 FnArgs.push_back(&ArgCallsiteTypeId);
3704 FnArgs.push_back(&ArgAddr);
3705 FnArgs.push_back(&ArgCFICheckFailData);
3709 llvm::Function *F = llvm::Function::Create(
3711 llvm::GlobalValue::WeakAnyLinkage,
"__cfi_check", M);
3714 F->setAlignment(llvm::Align(4096));
3717 llvm::LLVMContext &Ctx = M->getContext();
3718 llvm::BasicBlock *BB = llvm::BasicBlock::Create(Ctx,
"entry", F);
3721 llvm::CallInst::Create(M->getFunction(
"__cfi_check_fail"), Args,
"", BB);
3722 llvm::ReturnInst::Create(Ctx,
nullptr, BB);
3733 SanitizerScope SanScope(
this);
3739 Args.push_back(&ArgData);
3740 Args.push_back(&ArgAddr);
3745 llvm::Function *F = llvm::Function::Create(
3747 llvm::GlobalValue::WeakODRLinkage,
"__cfi_check_fail", &
CGM.
getModule());
3751 F->setVisibility(llvm::GlobalValue::HiddenVisibility);
3769 llvm::Value *DataIsNotNullPtr =
3771 EmitTrapCheck(DataIsNotNullPtr, SanitizerHandler::CFICheckFail);
3773 llvm::StructType *SourceLocationTy =
3775 llvm::StructType *CfiCheckFailDataTy =
3780 Builder.CreatePointerCast(
Data, CfiCheckFailDataTy->getPointerTo(0)), 0,
3786 llvm::Value *AllVtables = llvm::MetadataAsValue::get(
3789 llvm::Value *ValidVtable =
Builder.CreateZExt(
3791 {Addr, AllVtables}),
3794 const std::pair<int, SanitizerMask> CheckKinds[] = {
3802 for (
auto CheckKindMaskPair : CheckKinds) {
3803 int Kind = CheckKindMaskPair.first;
3806 Builder.CreateICmpNE(CheckKind, llvm::ConstantInt::get(
Int8Ty, Kind));
3808 EmitCheck(std::make_pair(Cond, Mask), SanitizerHandler::CFICheckFail, {},
3809 {
Data, Addr, ValidVtable});
3821 if (
SanOpts.
has(SanitizerKind::Unreachable)) {
3822 SanitizerScope SanScope(
this);
3824 SanitizerKind::Unreachable),
3825 SanitizerHandler::BuiltinUnreachable,
3837 if ((
int)TrapBBs.size() <= CheckHandlerID)
3838 TrapBBs.resize(CheckHandlerID + 1);
3840 llvm::BasicBlock *&TrapBB = TrapBBs[CheckHandlerID];
3845 auto Call = TrapBB->begin();
3846 assert(isa<llvm::CallInst>(
Call) &&
"Expected call in trap BB");
3848 Call->applyMergedLocation(
Call->getDebugLoc(),
3849 Builder.getCurrentDebugLocation());
3850 Builder.CreateCondBr(Checked, Cont, TrapBB);
3853 Builder.CreateCondBr(Checked, Cont, TrapBB);
3856 llvm::CallInst *TrapCall =
Builder.CreateCall(
3860 ? TrapBB->getParent()->size()
3861 :
static_cast<uint64_t>(CheckHandlerID)));
3864 auto A = llvm::Attribute::get(
getLLVMContext(),
"trap-func-name",
3866 TrapCall->addFnAttr(A);
3868 TrapCall->setDoesNotReturn();
3869 TrapCall->setDoesNotThrow();
3877 llvm::CallInst *TrapCall =
3881 auto A = llvm::Attribute::get(
getLLVMContext(),
"trap-func-name",
3883 TrapCall->addFnAttr(A);
3893 "Array to pointer decay must have array source type!");
3908 "Expected pointer to array");
3928 const auto *CE = dyn_cast<CastExpr>(
E);
3929 if (!CE || CE->getCastKind() != CK_ArrayToPointerDecay)
3941 llvm::Type *elemType,
3947 const llvm::Twine &name =
"arrayidx") {
3959 llvm::Type *elementType,
bool inbounds,
3962 const llvm::Twine &name =
"arrayidx") {
3977 if (
auto constantIdx = dyn_cast<llvm::ConstantInt>(idx)) {
3978 CharUnits offset = constantIdx->getZExtValue() * eltSize;
3997 return D &&
D->
hasAttr<BPFPreserveStaticOffsetAttr>();
4004 if (PointeeType.
isNull())
4017 llvm::Function *Fn =
4037 if (
const auto *ME = dyn_cast<MemberExpr>(
E))
4040 if (
const auto *DRE = dyn_cast<DeclRefExpr>(
E)) {
4041 const auto *VarDef = dyn_cast<VarDecl>(DRE->getDecl());
4045 const auto *PtrT = VarDef->getType()->getAs<
PointerType>();
4051 if (
const auto *RecT = dyn_cast<RecordType>(PointeeT))
4052 return RecT->getDecl()->
hasAttr<BPFPreserveAccessIndexAttr>();
4065 const llvm::Twine &name =
"arrayidx") {
4068 for (
auto *idx : indices.drop_back())
4069 assert(isa<llvm::ConstantInt>(idx) &&
4070 cast<llvm::ConstantInt>(idx)->isZero());
4087 llvm::Value *eltPtr;
4088 auto LastIndex = dyn_cast<llvm::ConstantInt>(indices.back());
4093 signedIndices, loc, eltAlign, name);
4097 unsigned idx = LastIndex->getZExtValue();
4098 llvm::DIType *DbgInfo =
nullptr;
4101 eltPtr = CGF.
Builder.CreatePreserveArrayAccessIndex(
4114 unsigned FieldNo = 0;
4117 if (
const auto *
Record = dyn_cast<RecordDecl>(
D))
4123 if (
const auto *Field = dyn_cast<FieldDecl>(
D))
4129 if (isa<FieldDecl>(
D))
4149 if (FD1OuterRec != FD2OuterRec)
4151 return std::optional<int64_t>();
4153 int64_t FD1Offset = 0;
4155 return std::optional<int64_t>();
4157 int64_t FD2Offset = 0;
4159 return std::optional<int64_t>();
4161 return std::make_optional<int64_t>(FD1Offset - FD2Offset);
4168 llvm::Value *IdxPre =
4170 bool SignedIndices =
false;
4171 auto EmitIdxAfterBase = [&, IdxPre](
bool Promote) -> llvm::Value * {
4173 if (
E->getLHS() !=
E->getIdx()) {
4174 assert(
E->getRHS() ==
E->getIdx() &&
"index was neither LHS nor RHS");
4180 SignedIndices |= IdxSigned;
4186 if (Promote && Idx->getType() !=
IntPtrTy)
4196 !isa<ExtVectorElementExpr>(
E->getBase())) {
4199 auto *Idx = EmitIdxAfterBase(
false);
4200 assert(LHS.
isSimple() &&
"Can only subscript lvalue vectors here!");
4208 if (isa<ExtVectorElementExpr>(
E->getBase())) {
4210 auto *Idx = EmitIdxAfterBase(
true);
4229 auto *Idx = EmitIdxAfterBase(
true);
4239 Idx =
Builder.CreateMul(Idx, numElements);
4241 Idx =
Builder.CreateNSWMul(Idx, numElements);
4253 auto *Idx = EmitIdxAfterBase(
true);
4256 llvm::Value *InterfaceSizeVal =
4257 llvm::ConstantInt::get(Idx->getType(), InterfaceSize.
getQuantity());
4259 llvm::Value *ScaledIdx =
Builder.CreateMul(Idx, InterfaceSizeVal);
4270 llvm::Value *EltPtr =
4272 ScaledIdx,
false, SignedIndices,
E->
getExprLoc());
4273 Addr =
Address(EltPtr, OrigBaseElemTy, EltAlign);
4279 assert(Array->getType()->isArrayType() &&
4280 "Array to pointer decay must have array source type!");
4284 if (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(Array))
4288 auto *Idx = EmitIdxAfterBase(
true);
4290 if (
SanOpts.
has(SanitizerKind::ArrayBounds)) {
4301 if (
const auto *ME = dyn_cast<MemberExpr>(Array);
4307 if (std::optional<int64_t> Diff =
4316 llvm::Type *CountTy =
ConvertType(CountFD->getType());
4321 ".counted_by.load");
4325 Array->getType(), Accessed);
4334 *
this, ArrayLV.
getAddress(), {CGM.getSize(CharUnits::Zero()), Idx},
4342 auto *Idx = EmitIdxAfterBase(
true);
4362 !
E->isIncomplete() &&
4363 "incomplete matrix subscript expressions should be rejected during Sema");
4367 llvm::Value *NumRows =
Builder.getIntN(
4368 RowIdx->getType()->getScalarSizeInBits(),
4370 llvm::Value *FinalIdx =
4381 bool IsLowerBound) {
4383 if (
auto *ASE = dyn_cast<ArraySectionExpr>(
Base->IgnoreParenImpCasts())) {
4398 "Expected pointer to array");
4417 bool IsLowerBound) {
4419 assert(!
E->isOpenACCArraySection() &&
4420 "OpenACC Array section codegen not implemented");
4424 if (
auto *AT =
getContext().getAsArrayType(BaseTy))
4425 ResultExprTy = AT->getElementType();
4428 llvm::Value *Idx =
nullptr;
4429 if (IsLowerBound ||
E->getColonLocFirst().isInvalid()) {
4433 if (
auto *LowerBound =
E->getLowerBound()) {
4436 LowerBound->getType()->hasSignedIntegerRepresentation());
4438 Idx = llvm::ConstantInt::getNullValue(
IntPtrTy);
4444 auto *Length =
E->getLength();
4445 llvm::APSInt ConstLength;
4448 if (std::optional<llvm::APSInt> CL = Length->getIntegerConstantExpr(
C)) {
4452 auto *LowerBound =
E->getLowerBound();
4455 if (std::optional<llvm::APSInt> LB =
4456 LowerBound->getIntegerConstantExpr(
C)) {
4458 LowerBound =
nullptr;
4463 else if (!LowerBound)
4466 if (Length || LowerBound) {
4467 auto *LowerBoundVal =
4471 LowerBound->getType()->hasSignedIntegerRepresentation())
4472 : llvm::ConstantInt::get(
IntPtrTy, ConstLowerBound);
4477 Length->getType()->hasSignedIntegerRepresentation())
4478 : llvm::ConstantInt::get(
IntPtrTy, ConstLength);
4479 Idx =
Builder.CreateAdd(LowerBoundVal, LengthVal,
"lb_add_len",
4482 if (Length && LowerBound) {
4484 Idx, llvm::ConstantInt::get(
IntPtrTy, 1),
"idx_sub_1",
4488 Idx = llvm::ConstantInt::get(
IntPtrTy, ConstLength + ConstLowerBound);
4494 if (
auto *VAT =
C.getAsVariableArrayType(ArrayTy)) {
4495 Length = VAT->getSizeExpr();
4496 if (std::optional<llvm::APSInt> L = Length->getIntegerConstantExpr(
C)) {
4501 auto *CAT =
C.getAsConstantArrayType(ArrayTy);
4502 assert(CAT &&
"unexpected type for array initializer");
4503 ConstLength = CAT->getSize();
4506 auto *LengthVal =
Builder.CreateIntCast(
4508 Length->getType()->hasSignedIntegerRepresentation());
4510 LengthVal, llvm::ConstantInt::get(
IntPtrTy, 1),
"len_sub_1",
4515 Idx = llvm::ConstantInt::get(
IntPtrTy, ConstLength);
4524 if (
auto *VLA =
getContext().getAsVariableArrayType(ResultExprTy)) {
4530 BaseTy, VLA->getElementType(), IsLowerBound);
4539 Idx =
Builder.CreateMul(Idx, NumElements);
4541 Idx =
Builder.CreateNSWMul(Idx, NumElements);
4550 assert(Array->getType()->isArrayType() &&
4551 "Array to pointer decay must have array source type!");
4555 if (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(Array))
4562 *
this, ArrayLV.
getAddress(), {CGM.getSize(CharUnits::Zero()), Idx},
4563 ResultExprTy, !
getLangOpts().isSignedOverflowDefined(),
4570 ResultExprTy, IsLowerBound);
4593 Base.getQuals().removeObjCGCAttr();
4602 "Result must be a vector");
4617 E->getEncodedElementAccess(Indices);
4619 if (
Base.isSimple()) {
4620 llvm::Constant *CV =
4625 assert(
Base.isExtVectorElt() &&
"Can only subscript lvalue vec elts here!");
4627 llvm::Constant *BaseElts =
Base.getExtVectorElts();
4630 for (
unsigned i = 0, e = Indices.size(); i != e; ++i)
4631 CElts.push_back(BaseElts->getAggregateElement(Indices[i]));
4632 llvm::Constant *CV = llvm::ConstantVector::get(CElts);
4643 Expr *BaseExpr =
E->getBase();
4654 SkippedChecks.
set(SanitizerKind::Alignment,
true);
4655 if (IsBaseCXXThis || isa<DeclRefExpr>(BaseExpr))
4656 SkippedChecks.
set(SanitizerKind::Null,
true);
4664 if (
auto *Field = dyn_cast<FieldDecl>(ND)) {
4679 if (
const auto *FD = dyn_cast<FunctionDecl>(ND))
4682 llvm_unreachable(
"Unhandled member declaration!");
4689 llvm::Value *ThisValue) {
4690 bool HasExplicitObjectParameter =
false;
4691 const auto *MD = dyn_cast_if_present<CXXMethodDecl>(
CurCodeDecl);
4693 HasExplicitObjectParameter = MD->isExplicitObjectMemberFunction();
4694 assert(MD->getParent()->isLambda());
4695 assert(MD->getParent() ==
Field->getParent());
4698 if (HasExplicitObjectParameter) {
4700 auto It = LocalDeclMap.find(
D);
4701 assert(It != LocalDeclMap.end() &&
"explicit parameter not loaded?");
4702 Address AddrOfExplicitObject = It->getSecond();
4703 if (
D->getType()->isReferenceType())
4708 D->getType().getNonReferenceType());
4711 auto *ThisTy =
D->getType().getNonReferenceType()->getAsCXXRecordDecl();
4712 auto *LambdaTy = cast<CXXRecordDecl>(
Field->getParent());
4713 if (ThisTy != LambdaTy) {
4716 LambdaLV.
getAddress(), ThisTy, BasePathArray.begin(),
4734 unsigned FieldIndex) {
4735 unsigned I = 0, Skipped = 0;
4738 if (I == FieldIndex)
4740 if (F->isUnnamedBitField())
4745 return FieldIndex - Skipped;
4754 if (Offset.isZero())
4795 if (RD->isDynamicClass())
4798 for (
const auto &
Base : RD->bases())
4845 llvm::Type *FieldIntTy = llvm::Type::getIntNTy(
getLLVMContext(), SS);
4881 assert(!FieldTBAAInfo.
Offset &&
4882 "Nonzero offset for an access with no base type!");
4895 FieldTBAAInfo.
Size =
4902 if (
auto *ClassDef = dyn_cast<CXXRecordDecl>(rec)) {
4904 ClassDef->isDynamicClass()) {
4965 if (field->
hasAttr<AnnotateAttr>())
4990 V =
V.withElementType(llvmType);
5003 if (
E->isFileScope()) {
5012 const Expr *InitExpr =
E->getInitializer();
5035 assert(
E->isTransparent() &&
"non-transparent glvalue init list");
5043 const Expr *Operand) {
5044 if (
auto *ThrowExpr = dyn_cast<CXXThrowExpr>(Operand->IgnoreParens())) {
5046 return std::nullopt;
5055std::optional<LValue> HandleConditionalOperatorLValueSimpleCase(
5057 const Expr *condExpr =
E->getCond();
5060 const Expr *Live =
E->getTrueExpr(), *Dead =
E->getFalseExpr();
5062 std::swap(Live, Dead);
5070 if (
auto *ThrowExpr = dyn_cast<CXXThrowExpr>(Live->
IgnoreParens())) {
5072 llvm::Type *ElemTy = CGF.
ConvertType(Dead->getType());
5081 return std::nullopt;
5083struct ConditionalInfo {
5084 llvm::BasicBlock *lhsBlock, *rhsBlock;
5085 std::optional<LValue> LHS, RHS;
5090template<
typename FuncTy>
5093 const FuncTy &BranchGenFunc) {
5099 CodeGenFunction::ConditionalEvaluation eval(CGF);
5107 Info.LHS = BranchGenFunc(CGF,
E->getTrueExpr());
5109 Info.lhsBlock = CGF.
Builder.GetInsertBlock();
5112 CGF.
Builder.CreateBr(endBlock);
5117 Info.RHS = BranchGenFunc(CGF,
E->getFalseExpr());
5119 Info.rhsBlock = CGF.
Builder.GetInsertBlock();
5131 "Unexpected conditional operator!");
5135 OpaqueValueMapping binding(*
this,
E);
5136 if (HandleConditionalOperatorLValueSimpleCase(*
this,
E))
5146 if (!
expr->isGLValue()) {
5149 "Unexpected conditional operator!");
5153 OpaqueValueMapping binding(*
this,
expr);
5154 if (std::optional<LValue> Res =
5155 HandleConditionalOperatorLValueSimpleCase(*
this,
expr))
5158 ConditionalInfo Info = EmitConditionalBlocks(
5163 if ((Info.LHS && !Info.LHS->isSimple()) ||
5164 (Info.RHS && !Info.RHS->isSimple()))
5167 if (Info.LHS && Info.RHS) {
5168 Address lhsAddr = Info.LHS->getAddress();
5169 Address rhsAddr = Info.RHS->getAddress();
5171 lhsAddr, rhsAddr, Info.lhsBlock, Info.rhsBlock,
5174 std::max(Info.LHS->getBaseInfo().getAlignmentSource(),
5175 Info.RHS->getBaseInfo().getAlignmentSource());
5177 Info.LHS->getTBAAInfo(), Info.RHS->getTBAAInfo());
5181 assert((Info.LHS || Info.RHS) &&
5182 "both operands of glvalue conditional are throw-expressions?");
5183 return Info.LHS ? *Info.LHS : *Info.RHS;
5195 switch (
E->getCastKind()) {
5198 case CK_LValueToRValueBitCast:
5199 case CK_ArrayToPointerDecay:
5200 case CK_FunctionToPointerDecay:
5201 case CK_NullToMemberPointer:
5202 case CK_NullToPointer:
5203 case CK_IntegralToPointer:
5204 case CK_PointerToIntegral:
5205 case CK_PointerToBoolean:
5206 case CK_IntegralCast:
5207 case CK_BooleanToSignedIntegral:
5208 case CK_IntegralToBoolean:
5209 case CK_IntegralToFloating:
5210 case CK_FloatingToIntegral:
5211 case CK_FloatingToBoolean:
5212 case CK_FloatingCast:
5213 case CK_FloatingRealToComplex:
5214 case CK_FloatingComplexToReal:
5215 case CK_FloatingComplexToBoolean:
5216 case CK_FloatingComplexCast:
5217 case CK_FloatingComplexToIntegralComplex:
5218 case CK_IntegralRealToComplex:
5219 case CK_IntegralComplexToReal:
5220 case CK_IntegralComplexToBoolean:
5221 case CK_IntegralComplexCast:
5222 case CK_IntegralComplexToFloatingComplex:
5223 case CK_DerivedToBaseMemberPointer:
5224 case CK_BaseToDerivedMemberPointer:
5225 case CK_MemberPointerToBoolean:
5226 case CK_ReinterpretMemberPointer:
5227 case CK_AnyPointerToBlockPointerCast:
5228 case CK_ARCProduceObject:
5229 case CK_ARCConsumeObject:
5230 case CK_ARCReclaimReturnedObject:
5231 case CK_ARCExtendBlockObject:
5232 case CK_CopyAndAutoreleaseBlockObject:
5233 case CK_IntToOCLSampler:
5234 case CK_FloatingToFixedPoint:
5235 case CK_FixedPointToFloating:
5236 case CK_FixedPointCast:
5237 case CK_FixedPointToBoolean:
5238 case CK_FixedPointToIntegral:
5239 case CK_IntegralToFixedPoint:
5241 case CK_HLSLVectorTruncation:
5242 case CK_HLSLArrayRValue:
5246 llvm_unreachable(
"dependent cast kind in IR gen!");
5248 case CK_BuiltinFnToFnPtr:
5249 llvm_unreachable(
"builtin functions are handled elsewhere");
5252 case CK_NonAtomicToAtomic:
5253 case CK_AtomicToNonAtomic:
5259 const auto *DCE = cast<CXXDynamicCastExpr>(
E);
5263 case CK_ConstructorConversion:
5264 case CK_UserDefinedConversion:
5265 case CK_CPointerToObjCPointerCast:
5266 case CK_BlockPointerToObjCPointerCast:
5267 case CK_LValueToRValue:
5276 if (
E->changesVolatileQualification())
5282 if (
V.getElementType() !=
T)
5289 case CK_UncheckedDerivedToBase:
5290 case CK_DerivedToBase: {
5291 const auto *DerivedClassTy =
5293 auto *DerivedClassDecl = cast<CXXRecordDecl>(DerivedClassTy->getDecl());
5300 This, DerivedClassDecl,
E->path_begin(),
E->path_end(),
5311 case CK_BaseToDerived: {
5313 auto *DerivedClassDecl = cast<CXXRecordDecl>(DerivedClassTy->getDecl());
5319 LV.
getAddress(), DerivedClassDecl,
E->path_begin(),
E->path_end(),
5328 if (
SanOpts.
has(SanitizerKind::CFIDerivedCast))
5336 case CK_LValueBitCast: {
5338 const auto *CE = cast<ExplicitCastExpr>(
E);
5345 if (
SanOpts.
has(SanitizerKind::CFIUnrelatedCast))
5353 case CK_AddressSpaceConversion: {
5364 case CK_ObjCObjectLValueCast: {
5370 case CK_ZeroToOCLOpaqueType:
5371 llvm_unreachable(
"NULL to OpenCL opaque type lvalue cast is not valid");
5373 case CK_VectorSplat: {
5381 llvm_unreachable(
"Unhandled lvalue cast kind?");
5393 llvm::DenseMap<const OpaqueValueExpr*,LValue>::iterator
5394 it = OpaqueLValues.find(e);
5396 if (it != OpaqueLValues.end())
5399 assert(e->
isUnique() &&
"LValue for a nonunique OVE hasn't been emitted");
5407 llvm::DenseMap<const OpaqueValueExpr*,RValue>::iterator
5408 it = OpaqueRValues.find(e);
5410 if (it != OpaqueRValues.end())
5413 assert(e->
isUnique() &&
"RValue for a nonunique OVE hasn't been emitted");
5438 llvm_unreachable(
"bad evaluation kind");
5451 if (
const auto *CE = dyn_cast<CXXMemberCallExpr>(
E))
5454 if (
const auto *CE = dyn_cast<CUDAKernelCallExpr>(
E))
5459 if (
const auto *CE = dyn_cast<CXXOperatorCallExpr>(
E))
5460 if (
const auto *MD =
5461 dyn_cast_if_present<CXXMethodDecl>(CE->getCalleeDecl());
5462 MD && MD->isImplicitObjectMemberFunction())
5491 if (!PD->isInlineBuiltinDeclaration())
5500 std::string NoBuiltinFD = (
"no-builtin-" + FD->
getName()).str();
5501 std::string NoBuiltins =
"no-builtins";
5504 std::string FDInlineName = (Ident +
".inline").str();
5506 bool IsPredefinedLibFunction =
5508 bool HasAttributeNoBuiltin =
5509 CGF.
CurFn->getAttributes().hasFnAttr(NoBuiltinFD) ||
5510 CGF.
CurFn->getAttributes().hasFnAttr(NoBuiltins);
5514 if (CGF.
CurFn->getName() != FDInlineName &&
5517 llvm::Function *Fn = llvm::cast<llvm::Function>(CalleePtr);
5518 llvm::Module *M = Fn->getParent();
5519 llvm::Function *Clone = M->getFunction(FDInlineName);
5521 Clone = llvm::Function::Create(Fn->getFunctionType(),
5522 llvm::GlobalValue::InternalLinkage,
5523 Fn->getAddressSpace(), FDInlineName, M);
5524 Clone->addFnAttr(llvm::Attribute::AlwaysInline);
5535 else if (!IsPredefinedLibFunction || !HasAttributeNoBuiltin)
5541 FD->
hasAttr<CUDAGlobalAttr>())
5543 cast<llvm::GlobalValue>(CalleePtr->stripPointerCasts()));
5552 if (
auto ICE = dyn_cast<ImplicitCastExpr>(
E)) {
5553 if (ICE->getCastKind() == CK_FunctionToPointerDecay ||
5554 ICE->getCastKind() == CK_BuiltinFnToFnPtr) {
5559 }
else if (
auto DRE = dyn_cast<DeclRefExpr>(
E)) {
5560 if (
auto FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
5563 }
else if (
auto ME = dyn_cast<MemberExpr>(
E)) {
5564 if (
auto FD = dyn_cast<FunctionDecl>(ME->
getMemberDecl())) {
5570 }
else if (
auto NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(
E)) {
5574 }
else if (
auto PDE = dyn_cast<CXXPseudoDestructorExpr>(
E)) {
5579 llvm::Value *calleePtr;
5591 if (
const auto *VD =
5597 CGCallee callee(calleeInfo, calleePtr, pointerAuth);
5603 if (
E->getOpcode() == BO_Comma) {
5609 if (
E->getOpcode() == BO_PtrMemD ||
5610 E->getOpcode() == BO_PtrMemI)
5613 assert(
E->getOpcode() == BO_Assign &&
"unexpected binary l-value");
5655 llvm::Value *
Result =
nullptr;
5658 if (
SanOpts.
has(SanitizerKind::ImplicitBitfieldConversion))
5684 llvm_unreachable(
"bad evaluation kind");
5694 assert(
E->getCallReturnType(
getContext())->isReferenceType() &&
5695 "Can't have a scalar return unless the return type is a "
5708 &&
"binding l-value to type which needs a temporary");
5745 assert(
E->getMethodDecl()->getReturnType()->isReferenceType() &&
5746 "Can't have a scalar return unless the return type is a "
5768 return Builder.CreateZExtOrTrunc(OffsetValue,
5773 llvm::Value *BaseValue,
5775 unsigned CVRQualifiers) {
5777 Ivar, CVRQualifiers);
5782 llvm::Value *BaseValue =
nullptr;
5783 const Expr *BaseExpr =
E->getBase();
5793 ObjectTy = BaseExpr->
getType();
5813 llvm::Value *Chain) {
5817 "Call must have function pointer type!");
5819 const Decl *TargetDecl =
5822 assert((!isa_and_present<FunctionDecl>(TargetDecl) ||
5823 !cast<FunctionDecl>(TargetDecl)->isImmediateFunction()) &&
5824 "trying to emit a call to an immediate function");
5828 auto PointeeType = cast<PointerType>(CalleeType)->getPointeeType();
5833 (!TargetDecl || !isa<FunctionDecl>(TargetDecl)) &&
5834 !isa<FunctionNoProtoType>(PointeeType)) {
5835 if (llvm::Constant *PrefixSig =
5837 SanitizerScope SanScope(
this);
5840 llvm::Type *PrefixSigType = PrefixSig->getType();
5841 llvm::StructType *PrefixStructTy = llvm::StructType::get(
5844 llvm::Value *CalleePtr =
Callee.getFunctionPointer();
5848 Address(CalleePtr, CalleePtr->getType(),
5851 Callee.getPointerAuthInfo(),
nullptr);
5864 llvm::Value *AlignedCalleePtr;
5866 llvm::Value *CalleeAddress =
5868 llvm::Value *Mask = llvm::ConstantInt::get(
IntPtrTy, ~1);
5869 llvm::Value *AlignedCalleeAddress =
5870 Builder.CreateAnd(CalleeAddress, Mask);
5872 Builder.CreateIntToPtr(AlignedCalleeAddress, CalleePtr->getType());
5874 AlignedCalleePtr = CalleePtr;
5877 llvm::Value *CalleePrefixStruct = AlignedCalleePtr;
5878 llvm::Value *CalleeSigPtr =
5880 llvm::Value *CalleeSig =
5882 llvm::Value *CalleeSigMatch =
Builder.CreateICmpEQ(CalleeSig, PrefixSig);
5886 Builder.CreateCondBr(CalleeSigMatch, TypeCheck, Cont);
5893 llvm::Value *CalleeTypeHashMatch =
5894 Builder.CreateICmpEQ(CalleeTypeHash, TypeHash);
5897 EmitCheck(std::make_pair(CalleeTypeHashMatch, SanitizerKind::Function),
5898 SanitizerHandler::FunctionTypeMismatch, StaticData,
5906 const auto *FnType = cast<FunctionType>(PointeeType);
5911 (!TargetDecl || !isa<FunctionDecl>(TargetDecl))) {
5912 SanitizerScope SanScope(
this);
5921 llvm::Value *TypeId = llvm::MetadataAsValue::get(
getLLVMContext(), MD);
5923 llvm::Value *CalleePtr =
Callee.getFunctionPointer();
5924 llvm::Value *TypeTest =
Builder.CreateCall(
5928 llvm::Constant *StaticData[] = {
5935 CalleePtr, StaticData);
5937 EmitCheck(std::make_pair(TypeTest, SanitizerKind::CFIICall),
5938 SanitizerHandler::CFICheckFail, StaticData,
5939 {CalleePtr, llvm::UndefValue::get(
IntPtrTy)});
5954 bool StaticOperator =
false;
5955 if (
auto *OCE = dyn_cast<CXXOperatorCallExpr>(
E)) {
5956 if (OCE->isAssignmentOp())
5959 switch (OCE->getOperator()) {
5961 case OO_GreaterGreater:
5973 if (
const auto *MD =
5974 dyn_cast_if_present<CXXMethodDecl>(OCE->getCalleeDecl());
5975 MD && MD->isStatic())
5976 StaticOperator =
true;
5980 if (StaticOperator) {
5986 EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), Arguments,
5987 E->getDirectCallee(), 0, Order);
5990 Args, FnType, Chain);
6012 if (isa<FunctionNoProtoType>(FnType) || Chain) {
6014 int AS =
Callee.getFunctionPointer()->getType()->getPointerAddressSpace();
6015 CalleeTy = CalleeTy->getPointerTo(AS);
6017 llvm::Value *CalleePtr =
Callee.getFunctionPointer();
6018 CalleePtr =
Builder.CreateBitCast(CalleePtr, CalleeTy,
"callee.knr.cast");
6019 Callee.setFunctionPointer(CalleePtr);
6026 isa<CUDAKernelCallExpr>(
E) &&
6027 (!TargetDecl || !isa<FunctionDecl>(TargetDecl))) {
6028 llvm::Value *Handle =
Callee.getFunctionPointer();
6033 llvm::CallBase *CallOrInvoke =
nullptr;
6040 if (
auto *CalleeDecl = dyn_cast_or_null<FunctionDecl>(TargetDecl)) {
6043 DI->EmitFuncDeclForCallSite(CallOrInvoke,
6044 DI->getFunctionType(CalleeDecl, ResTy, Args),
6055 if (
E->getOpcode() == BO_PtrMemI) {
6070 return MakeAddrLValue(MemberAddr, MPT->getPointeeType(), BaseInfo, TBAAInfo);
6087 llvm_unreachable(
"bad evaluation kind");
6091 assert(Val->getType()->isFPOrFPVectorTy());
6092 if (Accuracy == 0.0 || !isa<llvm::Instruction>(Val))
6096 llvm::MDNode *
Node = MDHelper.createFPMath(Accuracy);
6098 cast<llvm::Instruction>(Val)->setMetadata(llvm::LLVMContext::MD_fpmath,
Node);
6102 llvm::Type *EltTy = Val->getType()->getScalarType();
6103 if (!EltTy->isFloatTy())
6123 llvm::Type *EltTy = Val->getType()->getScalarType();
6124 if (!EltTy->isFloatTy())
6144 struct LValueOrRValue {
6157 const Expr *resultExpr =
E->getResultExpr();
6158 LValueOrRValue result;
6161 i =
E->semantics_begin(), e =
E->semantics_end(); i != e; ++i) {
6162 const Expr *semantic = *i;
6166 if (
const auto *ov = dyn_cast<OpaqueValueExpr>(semantic)) {
6168 if (ov->isUnique()) {
6169 assert(ov != resultExpr &&
6170 "A unique OVE cannot be used as the result expression");
6176 typedef CodeGenFunction::OpaqueValueMappingData OVMA;
6178 if (ov == resultExpr && ov->
isPRValue() && !forLValue &&
6183 opaqueData = OVMA::bind(CGF, ov, LV);
6188 opaqueData = OVMA::bind(CGF, ov, ov->getSourceExpr());
6191 if (ov == resultExpr) {
6199 opaques.push_back(opaqueData);
6203 }
else if (semantic == resultExpr) {
6216 for (
unsigned i = 0, e = opaques.size(); i != e; ++i)
6217 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 llvm::Value * emitHashMix(CGBuilderTy &Builder, llvm::Value *Acc, llvm::Value *Ptr)
static const Expr * isSimpleArrayDecayOperand(const Expr *E)
isSimpleArrayDecayOperand - If the specified expr is a simple decay from an array to pointer,...
static llvm::cl::opt< bool > ClSanitizeGuardChecks("ubsan-guard-checks", llvm::cl::Optional, llvm::cl::desc("Guard UBSAN checks with `llvm.allow.ubsan.check()`."))
static bool hasBooleanRepresentation(QualType Ty)
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 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 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 RawAddress MaybeConvertMatrixAddress(RawAddress Addr, CodeGenFunction &CGF, bool IsVector=true)
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 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 LValue EmitThreadPrivateVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD, QualType T, Address Addr, llvm::Type *RealVarTy, SourceLocation Loc)
static bool getGEPIndicesToField(CodeGenFunction &CGF, const RecordDecl *RD, const FieldDecl *Field, RecIndicesTy &Indices)
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 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."))
static RawAddress createReferenceTemporary(CodeGenFunction &CGF, const MaterializeTemporaryExpr *M, const Expr *Inner, RawAddress *Alloca=nullptr)
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 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.
static QualType getPointeeType(const MemRegion *R)
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
llvm::DenseMap< const CXXMethodDecl *, CXXCastPath > LambdaCastPaths
For capturing lambdas with an explicit object parameter whose type is derived from the lambda type,...
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...
This class represents BOTH the OpenMP Array Section and OpenACC 'subarray', with a boolean differenti...
static QualType getBaseOriginalType(const Expr *Base)
Return original type of the base expression for array section.
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
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".
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.
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...
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
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.
PointerAuthOptions PointerAuth
Configuration for pointer-signing.
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...
Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...
llvm::Value * getBasePointer() const
llvm::Value * emitRawPointer(CodeGenFunction &CGF) const
Return the pointer contained in this class after authenticating it and adding offset to it if necessa...
CharUnits getAlignment() const
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Address 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()
void setAlignment(CharUnits Value)
void replaceBasePointer(llvm::Value *P)
This function is used in situations where the caller is doing some sort of opaque "laundering" of the...
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 CreateGEP(CodeGenFunction &CGF, Address Addr, llvm::Value *Index, const llvm::Twine &Name="")
Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty, llvm::Type *ElementTy, const llvm::Twine &Name="")
Address CreateConstGEP2_32(Address Addr, unsigned Idx0, unsigned Idx1, 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 CreatePreserveUnionAccessIndex(Address Addr, unsigned FieldIndex, llvm::MDNode *DbgInfo)
Address CreateStripInvariantGroup(Address Addr)
Address CreateAddrSpaceCast(Address Addr, llvm::Type *Ty, llvm::Type *ElementTy, 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 CreateInBoundsGEP(Address Addr, ArrayRef< llvm::Value * > IdxList, llvm::Type *ElementType, CharUnits Align, const 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 ConstantAddress 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.
bool containsFieldDecl(const FieldDecl *FD) const
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)
llvm::Value * GetVTablePtr(Address This, llvm::Type *VTableTy, const CXXRecordDecl *VTableClass, VTableAuthMode AuthMode=VTableAuthMode::Authenticate)
GetVTablePtr - Return the Value of the vtable pointer member pointed to by This.
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.
void EmitBitfieldConversionCheck(llvm::Value *Src, QualType SrcType, llvm::Value *Dst, QualType DstType, const CGBitFieldInfo &Info, SourceLocation Loc)
Emit a check that an [implicit] conversion of a bitfield.
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.
RawAddress CreateDefaultAlignTempAlloca(llvm::Type *Ty, const Twine &Name="tmp")
CreateDefaultAlignedTempAlloca - This creates an alloca with the default ABI alignment of the given L...
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...
RawAddress CreateTempAllocaWithoutCast(llvm::Type *Ty, CharUnits align, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
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)
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...
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **callOrInvoke, bool IsMustTail, SourceLocation Loc, bool IsVirtualFunctionPointerThunk=false)
EmitCall - Generate a call of the given function, expecting the given result type,...
Address makeNaturalAddressForPointer(llvm::Value *Ptr, QualType T, CharUnits Alignment=CharUnits::Zero(), bool ForPointeeType=false, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
Construct an address with the natural alignment of T.
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 ...
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.
RawAddress CreateMemTemp(QualType T, const Twine &Name="tmp", RawAddress *Alloca=nullptr)
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen and cas...
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)
RawAddress CreateMemTempWithoutCast(QualType T, const Twine &Name="tmp")
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen without...
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...
Address mergeAddressesInConditionalExpr(Address LHS, Address RHS, llvm::BasicBlock *LHSBlock, llvm::BasicBlock *RHSBlock, llvm::BasicBlock *MergeBlock, QualType MergedType)
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.
AggValueSlot CreateAggTemp(QualType T, const Twine &Name="tmp", RawAddress *Alloca=nullptr)
CreateAggTemp - Create a temporary memory object for the given aggregate type.
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)
const TargetCodeGenInfo & getTargetHooks() const
llvm::Value * emitBoolVecConversion(llvm::Value *SrcVec, unsigned NumElementsDst, const llvm::Twine &Name="")
LValue MakeNaturalAlignRawAddrLValue(llvm::Value *V, QualType T)
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)
llvm::Value * authPointerToPointerCast(llvm::Value *ResultPtr, QualType SourceType, QualType DestType)
void SetSqrtFPAccuracy(llvm::Value *Val)
Set the minimum required accuracy of the given sqrt operation based on CodeGenOpts.
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)
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 EmitAggFinalDestCopy(QualType Type, AggValueSlot Dest, const LValue &Src, ExprValueKind SrcKind)
EmitAggFinalDestCopy - Emit copy of the specified aggregate into destination address.
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)
LValue EmitArraySectionExpr(const ArraySectionExpr *E, bool IsLowerBound=true)
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)
void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, LValue LV, QualType Type, SanitizerSet SkippedChecks=SanitizerSet(), llvm::Value *ArraySize=nullptr)
llvm::SmallVector< const ParmVarDecl *, 4 > FnArgs
Save Parameter Decl for coroutine.
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()
llvm::Value * EmitWithOriginalRHSBitfieldAssignment(const BinaryOperator *E, llvm::Value **Previous, QualType *SrcType)
Retrieve the implicit cast expression of the rhs in a binary operator expression by passing pointers ...
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)
RawAddress CreateIRTemp(QualType T, const Twine &Name="tmp")
CreateIRTemp - Create a temporary IR object of the given type, with appropriate alignment.
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
LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
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...
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)
Given a value of type T* that may not be to a complete object, construct an l-value with the natural ...
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.
RValue EmitLoadOfAnyValue(LValue V, AggValueSlot Slot=AggValueSlot::ignored(), SourceLocation Loc={})
Like EmitLoadOfLValue but also handles complex and aggregate types.
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)
llvm::Type * convertTypeForLoadStore(QualType ASTTy, llvm::Type *LLVMTy=nullptr)
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::Constant * getRawFunctionPointer(GlobalDecl GD, llvm::Type *Ty=nullptr)
Return a function pointer for a reference to the given function.
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)
llvm::Constant * getFunctionPointer(GlobalDecl GD, llvm::Type *Ty=nullptr)
Return the ABI-correct function pointer value for a reference to the given function.
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.
CGPointerAuthInfo getFunctionPointerAuthInfo(QualType T)
Return the abstract pointer authentication schema for a pointer to the given function type.
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.
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
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.
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)
bool isObjCStrong() const
bool isGlobalObjCRef() const
void setObjCArray(bool Value)
bool isVolatileQualified() const
RValue asAggregateRValue() const
llvm::Value * getPointer(CodeGenFunction &CGF) const
llvm::Value * getMatrixIdx() const
llvm::Value * getGlobalReg() const
static LValue MakeAddr(Address Addr, QualType type, ASTContext &Context, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)
const Qualifiers & getQuals() const
static LValue MakeExtVectorElt(Address Addr, llvm::Constant *Elts, QualType type, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)
Address getAddress() 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
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)
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)
Convert an Address to an RValue.
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.
An abstract representation of an aligned address.
RawAddress withElementType(llvm::Type *ElemTy) const
Return address with different element type, but same pointer and alignment.
llvm::Type * getElementType() const
Return the type of the values stored in this address.
llvm::Value * getPointer() const
ReturnValueSlot - Contains the address where the return value of a function can be stored,...
Address performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, Address Addr, LangAS SrcAddr, LangAS DestAddr, llvm::Type *DestTy, bool IsNonNull=false) const
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].
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.
Represents a sugar type with __counted_by or __sized_by annotations, including their _or_null variant...
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)
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()
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 refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
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 ...
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.
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.
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.
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
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.
An expression that sends a message to the given Objective-C object or class.
Represents a class type in Objective C.
ObjCSelectorExpr used for @selector in Objective-C.
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 parenthesized expression, e.g.
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
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.
const Expr *const * const_semantics_iterator
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 getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
QualType withCVRQualifiers(unsigned CVR) 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.
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.
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 isCountAttributedType() 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 isBitIntType() 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
bool isSubscriptableVectorType() 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),...
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 ...
bool isEmptyFieldForLayout(const ASTContext &Context, const FieldDecl *FD)
isEmptyFieldForLayout - Return true iff the field is "empty", that is, either a zero-width bit-field ...
@ 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.
constexpr Variable var(Literal L)
Returns the variable of L.
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.
const FunctionProtoType * T
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.
PointerAuthSchema FunctionPointers
The ABI for C function pointers.
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