40#include "llvm/ADT/STLExtras.h"
41#include "llvm/ADT/ScopeExit.h"
42#include "llvm/ADT/StringExtras.h"
43#include "llvm/IR/DataLayout.h"
44#include "llvm/IR/Intrinsics.h"
45#include "llvm/IR/LLVMContext.h"
46#include "llvm/IR/MDBuilder.h"
47#include "llvm/IR/MatrixBuilder.h"
48#include "llvm/Support/ConvertUTF.h"
49#include "llvm/Support/Endian.h"
50#include "llvm/Support/MathExtras.h"
51#include "llvm/Support/Path.h"
52#include "llvm/Support/xxhash.h"
53#include "llvm/Transforms/Utils/SanitizerStats.h"
66 "ubsan-guard-checks", llvm::cl::Optional,
67 llvm::cl::desc(
"Guard UBSAN checks with `llvm.allow.ubsan.check()`."));
93#define SANITIZER_CHECK(Enum, Name, Version, Msg) \
94 case SanitizerHandler::Enum: \
99 llvm_unreachable(
"unhandled switch case");
107 llvm::Value *ArraySize) {
115 llvm::Value *ArraySize) {
125 llvm::IRBuilderBase::InsertPointGuard IPG(Builder);
142 llvm::Value *ArraySize,
146 *AllocaAddr = Alloca;
147 return MaybeCastStackAddressSpace(Alloca, DestLangAS, ArraySize);
155 llvm::Value *ArraySize) {
156 llvm::AllocaInst *Alloca;
158 Alloca =
Builder.CreateAlloca(Ty, ArraySize, Name);
161 new llvm::AllocaInst(Ty,
CGM.getDataLayout().getAllocaAddrSpace(),
163 if (
SanOpts.Mask & SanitizerKind::Address) {
164 Alloca->addAnnotationMetadata({
"alloca_name_altered", Name.str()});
167 Allocas->Add(Alloca);
202 auto *VectorTy = llvm::FixedVectorType::get(ArrayTy->getElementType(),
203 ArrayTy->getNumElements());
226 PGO->setCurrentStmt(E);
229 return CGM.getCXXABI().EmitMemberPointerIsNotNull(*
this, MemPtr, MPT);
252 if (
const auto *CondOp = dyn_cast<AbstractConditionalOperator>(
275 if (!ignoreResult && aggSlot.
isIgnored())
280 llvm_unreachable(
"bad evaluation kind");
322 llvm_unreachable(
"bad evaluation kind");
345 llvm_unreachable(
"bad evaluation kind");
385 bool Precise = isa_and_nonnull<VarDecl>(VD) &&
386 VD->
hasAttr<ObjCPreciseLifetimeAttr>();
407 llvm_unreachable(
"temporary cannot have dynamic storage duration");
409 llvm_unreachable(
"unknown storage duration");
419 if (
const auto *ClassDecl =
423 ReferenceTemporaryDtor = ClassDecl->getDestructor();
425 if (!ReferenceTemporaryDtor)
428 llvm::FunctionCallee CleanupFn;
429 llvm::Constant *CleanupArg;
435 CleanupArg = llvm::Constant::getNullValue(CGF.
Int8PtrTy);
452 llvm_unreachable(
"temporary cannot have dynamic storage duration");
475 auto *GV =
new llvm::GlobalVariable(
477 llvm::GlobalValue::PrivateLinkage,
Init,
".ref.tmp",
nullptr,
478 llvm::GlobalValue::NotThreadLocal,
482 llvm::Constant *
C = GV;
484 C = TCG.performAddrSpaceCast(
486 llvm::PointerType::get(
490 return RawAddress(
C, GV->getValueType(), alignment);
499 llvm_unreachable(
"temporary can't have dynamic storage duration");
501 llvm_unreachable(
"unknown storage duration");
515 "Reference should never be pseudo-strong!");
523 if (
auto *Var = dyn_cast<llvm::GlobalVariable>(Object.getPointer())) {
525 Object = Object.withElementType(Ty);
533 if (Var->hasInitializer())
536 Var->setInitializer(
CGM.EmitNullConstant(E->
getType()));
542 default: llvm_unreachable(
"expected scalar or aggregate expression");
565 for (
const auto &Ignored : CommaLHSs)
568 if (
const auto *opaque = dyn_cast<OpaqueValueExpr>(E)) {
569 if (opaque->getType()->isRecordType()) {
570 assert(Adjustments.empty());
578 if (
auto *Var = dyn_cast<llvm::GlobalVariable>(
579 Object.getPointer()->stripPointerCasts())) {
581 Object = Object.withElementType(TemporaryType);
585 if (!Var->hasInitializer()) {
586 Var->setInitializer(
CGM.EmitNullConstant(E->
getType()));
591 Object.getAlignment());
607 if (!ShouldEmitLifetimeMarkers)
618 CGBuilderTy::InsertPoint OldIP;
620 ((!
SanOpts.has(SanitizerKind::HWAddress) &&
621 !
SanOpts.has(SanitizerKind::Memory) &&
622 !
CGM.getCodeGenOpts().SanitizeAddressUseAfterScope) ||
624 OldConditional = OutermostConditional;
625 OutermostConditional =
nullptr;
629 Builder.restoreIP(CGBuilderTy::InsertPoint(
630 Block, llvm::BasicBlock::iterator(
Block->back())));
637 if (OldConditional) {
638 OutermostConditional = OldConditional;
655 switch (Adjustment.Kind) {
659 Adjustment.DerivedToBase.BasePath->path_begin(),
660 Adjustment.DerivedToBase.BasePath->path_end(),
668 "materialized temporary field is not a simple lvalue");
676 E, Object, Ptr, Adjustment.Ptr.MPT,
true);
709 const llvm::Constant *Elts) {
717 Builder.CreateMul(Ptr, Builder.getInt64(0xbf58476d1ce4e5b9u));
719 Builder.CreateXor(A0, Builder.CreateLShr(A0, Builder.getInt64(31)));
720 return Builder.CreateXor(Acc, A1);
737 return SanOpts.has(SanitizerKind::Null) ||
738 SanOpts.has(SanitizerKind::Alignment) ||
739 SanOpts.has(SanitizerKind::ObjectSize) ||
740 SanOpts.has(SanitizerKind::Vptr);
747 llvm::Value *ArraySize) {
754 if (Ptr->getType()->getPointerAddressSpace())
765 auto PtrToAlloca = dyn_cast<llvm::AllocaInst>(Ptr->stripPointerCasts());
767 llvm::Value *IsNonNull =
nullptr;
768 bool IsGuaranteedNonNull =
769 SkippedChecks.
has(SanitizerKind::Null) || PtrToAlloca;
771 llvm::BasicBlock *Done =
nullptr;
772 bool DoneViaNullSanitize =
false;
775 auto CheckHandler = SanitizerHandler::TypeMismatch;
777 {SanitizerKind::SO_Null,
778 SanitizerKind::SO_ObjectSize,
779 SanitizerKind::SO_Alignment},
787 if ((
SanOpts.has(SanitizerKind::Null) || AllowNullPointers) &&
788 !IsGuaranteedNonNull) {
790 IsNonNull =
Builder.CreateIsNotNull(Ptr);
794 IsGuaranteedNonNull = IsNonNull ==
True;
797 if (!IsGuaranteedNonNull) {
798 if (AllowNullPointers) {
802 DoneViaNullSanitize =
true;
804 Builder.CreateCondBr(IsNonNull, Rest, Done);
807 Checks.push_back(std::make_pair(IsNonNull, SanitizerKind::SO_Null));
812 if (
SanOpts.has(SanitizerKind::ObjectSize) &&
813 !SkippedChecks.
has(SanitizerKind::ObjectSize) &&
815 uint64_t TySize =
CGM.getMinimumObjectSize(Ty).getQuantity();
816 llvm::Value *Size = llvm::ConstantInt::get(
IntPtrTy, TySize);
818 Size =
Builder.CreateMul(Size, ArraySize);
821 llvm::Constant *ConstantSize = dyn_cast<llvm::Constant>(Size);
822 if (!ConstantSize || !ConstantSize->isNullValue()) {
829 llvm::Function *F =
CGM.getIntrinsic(llvm::Intrinsic::objectsize, Tys);
831 llvm::Value *NullIsUnknown =
Builder.getFalse();
832 llvm::Value *Dynamic =
Builder.getFalse();
833 llvm::Value *LargeEnough =
Builder.CreateICmpUGE(
834 Builder.CreateCall(F, {Ptr, Min, NullIsUnknown, Dynamic}), Size);
836 std::make_pair(LargeEnough, SanitizerKind::SO_ObjectSize));
840 llvm::MaybeAlign AlignVal;
841 llvm::Value *PtrAsInt =
nullptr;
843 if (
SanOpts.has(SanitizerKind::Alignment) &&
844 !SkippedChecks.
has(SanitizerKind::Alignment)) {
847 AlignVal =
CGM.getNaturalTypeAlignment(Ty,
nullptr,
nullptr,
852 if (AlignVal && *AlignVal > llvm::Align(1) &&
853 (!PtrToAlloca || PtrToAlloca->getAlign() < *AlignVal)) {
855 llvm::Value *Align =
Builder.CreateAnd(
856 PtrAsInt, llvm::ConstantInt::get(
IntPtrTy, AlignVal->value() - 1));
857 llvm::Value *Aligned =
861 std::make_pair(Aligned, SanitizerKind::SO_Alignment));
865 if (Checks.size() > 0) {
866 llvm::Constant *StaticData[] = {
868 llvm::ConstantInt::get(
Int8Ty, AlignVal ? llvm::Log2(*AlignVal) : 1),
869 llvm::ConstantInt::get(
Int8Ty, TCK)};
870 EmitCheck(Checks, CheckHandler, StaticData, PtrAsInt ? PtrAsInt : Ptr);
882 if (
SanOpts.has(SanitizerKind::Vptr) &&
885 SanitizerHandler::DynamicTypeCacheMiss);
889 if (!IsGuaranteedNonNull) {
891 IsNonNull =
Builder.CreateIsNotNull(Ptr);
895 Builder.CreateCondBr(IsNonNull, VptrNotNull, Done);
901 llvm::raw_svector_ostream Out(MangledName);
906 if (!
CGM.getContext().getNoSanitizeList().containsType(SanitizerKind::Vptr,
909 llvm::Value *TypeHash =
910 llvm::ConstantInt::get(
Int64Ty, xxh3_64bits(Out.str()));
924 const int CacheSize = 128;
925 llvm::Type *HashTable = llvm::ArrayType::get(
IntPtrTy, CacheSize);
926 llvm::Value *
Cache =
CGM.CreateRuntimeVariable(HashTable,
927 "__ubsan_vptr_type_cache");
928 llvm::Value *Slot =
Builder.CreateAnd(Hash,
931 llvm::Value *Indices[] = {
Builder.getInt32(0), Slot };
932 llvm::Value *CacheVal =
Builder.CreateAlignedLoad(
940 llvm::Value *EqualHash =
Builder.CreateICmpEQ(CacheVal, Hash);
941 llvm::Constant *StaticData[] = {
945 llvm::ConstantInt::get(
Int8Ty, TCK)
947 llvm::Value *DynamicData[] = { Ptr, Hash };
948 EmitCheck(std::make_pair(EqualHash, SanitizerKind::SO_Vptr),
949 SanitizerHandler::DynamicTypeCacheMiss, StaticData,
957 {DoneViaNullSanitize ? SanitizerKind::SO_Null : SanitizerKind::SO_Vptr},
958 DoneViaNullSanitize ? SanitizerHandler::TypeMismatch
959 : SanitizerHandler::DynamicTypeCacheMiss);
968 uint64_t EltSize =
C.getTypeSizeInChars(EltTy).getQuantity();
976 auto *ParamDecl = dyn_cast<ParmVarDecl>(ArrayDeclRef->getDecl());
980 auto *POSAttr = ParamDecl->getAttr<PassObjectSizeAttr>();
985 int POSType = POSAttr->getType();
986 if (POSType != 0 && POSType != 1)
990 auto PassedSizeIt = SizeArguments.find(ParamDecl);
991 if (PassedSizeIt == SizeArguments.end())
995 assert(LocalDeclMap.count(PassedSizeDecl) &&
"Passed size not loadable");
996 Address AddrOfSize = LocalDeclMap.find(PassedSizeDecl)->second;
999 llvm::Value *SizeOfElement =
1000 llvm::ConstantInt::get(SizeInBytes->getType(), EltSize);
1001 return Builder.CreateUDiv(SizeInBytes, SizeOfElement);
1010 StrictFlexArraysLevel) {
1013 IndexedType =
Base->getType();
1014 return CGF.
Builder.getInt32(VT->getNumElements());
1019 if (
const auto *CE = dyn_cast<CastExpr>(
Base)) {
1020 if (CE->getCastKind() == CK_ArrayToPointerDecay &&
1021 !CE->getSubExpr()->isFlexibleArrayMemberLike(CGF.
getContext(),
1022 StrictFlexArraysLevel)) {
1025 IndexedType = CE->getSubExpr()->getType();
1027 if (
const auto *CAT = dyn_cast<ConstantArrayType>(AT))
1028 return CGF.
Builder.getInt(CAT->getSize());
1030 if (
const auto *VAT = dyn_cast<VariableArrayType>(AT))
1038 QualType EltTy{
Base->getType()->getPointeeOrArrayElementType(), 0};
1040 IndexedType =
Base->getType();
1065class StructAccessBase
1066 :
public ConstStmtVisitor<StructAccessBase, const Expr *> {
1067 const RecordDecl *ExpectedRD;
1069 bool IsExpectedRecordDecl(
const Expr *E)
const {
1077 StructAccessBase(
const RecordDecl *ExpectedRD) : ExpectedRD(ExpectedRD) {}
1096 const Expr *Visit(
const Expr *E) {
1097 return ConstStmtVisitor<StructAccessBase, const Expr *>::Visit(E);
1100 const Expr *VisitStmt(
const Stmt *S) {
return nullptr; }
1115 const Expr *VisitDeclRefExpr(
const DeclRefExpr *E) {
1116 return IsExpectedRecordDecl(E) ? E :
nullptr;
1118 const Expr *VisitMemberExpr(
const MemberExpr *E) {
1119 if (IsExpectedRecordDecl(E) && E->
isArrow())
1121 const Expr *Res = Visit(E->
getBase());
1122 return !Res && IsExpectedRecordDecl(E) ? E : Res;
1124 const Expr *VisitCompoundLiteralExpr(
const CompoundLiteralExpr *E) {
1125 return IsExpectedRecordDecl(E) ? E :
nullptr;
1127 const Expr *VisitCallExpr(
const CallExpr *E) {
1128 return IsExpectedRecordDecl(E) ? E :
nullptr;
1131 const Expr *VisitArraySubscriptExpr(
const ArraySubscriptExpr *E) {
1132 if (IsExpectedRecordDecl(E))
1136 const Expr *VisitCastExpr(
const CastExpr *E) {
1138 return IsExpectedRecordDecl(E) ? E :
nullptr;
1141 const Expr *VisitParenExpr(
const ParenExpr *E) {
1144 const Expr *VisitUnaryAddrOf(
const UnaryOperator *E) {
1147 const Expr *VisitUnaryDeref(
const UnaryOperator *E) {
1160 int64_t FieldNo = -1;
1169 Indices.emplace_back(CGF.
Builder.getInt32(FieldNo));
1178 Indices.emplace_back(CGF.
Builder.getInt32(FieldNo));
1192 const Expr *StructBase = StructAccessBase(RD).Visit(
Base);
1196 llvm::Value *Res =
nullptr;
1201 Res =
Addr.emitRawPointer(*
this);
1202 }
else if (StructBase->
isLValue()) {
1205 Res =
Addr.emitRawPointer(*
this);
1212 if (Indices.empty())
1215 Indices.push_back(
Builder.getInt32(0));
1239 llvm::Value *Index,
QualType IndexType,
1241 assert(
SanOpts.has(SanitizerKind::ArrayBounds) &&
1242 "should not be called unless adding bounds checks");
1246 llvm::Value *Bound =
1255 QualType IndexedType,
bool Accessed) {
1259 auto CheckKind = SanitizerKind::SO_ArrayBounds;
1260 auto CheckHandler = SanitizerHandler::OutOfBounds;
1264 llvm::Value *IndexVal =
Builder.CreateIntCast(Index,
SizeTy, IndexSigned);
1265 llvm::Value *BoundVal =
Builder.CreateIntCast(Bound,
SizeTy,
false);
1267 llvm::Constant *StaticData[] = {
1272 llvm::Value *Check = Accessed ?
Builder.CreateICmpULT(IndexVal, BoundVal)
1273 :
Builder.CreateICmpULE(IndexVal, BoundVal);
1274 EmitCheck(std::make_pair(Check, CheckKind), CheckHandler, StaticData, Index);
1283 auto *TypeNameMD = MDB.createString(ATMD->TypeName);
1284 auto *ContainsPtrC =
Builder.getInt1(ATMD->ContainsPointer);
1285 auto *ContainsPtrMD = MDB.createConstant(ContainsPtrC);
1288 return llvm::MDNode::get(
CGM.getLLVMContext(), {TypeNameMD, ContainsPtrMD});
1292 assert(
SanOpts.has(SanitizerKind::AllocToken) &&
1293 "Only needed with -fsanitize=alloc-token");
1294 CB->setMetadata(llvm::LLVMContext::MD_alloc_token,
1306 assert(
SanOpts.has(SanitizerKind::AllocToken) &&
1307 "Only needed with -fsanitize=alloc-token");
1309 CB->setMetadata(llvm::LLVMContext::MD_alloc_token, MDN);
1314 bool isInc,
bool isPre) {
1317 llvm::Value *NextVal;
1319 uint64_t AmountVal = isInc ? 1 : -1;
1320 NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal,
true);
1323 NextVal =
Builder.CreateAdd(InVal.first, NextVal, isInc ?
"inc" :
"dec");
1326 llvm::APFloat FVal(
getContext().getFloatTypeSemantics(ElemTy), 1);
1332 NextVal =
Builder.CreateFAdd(InVal.first, NextVal, isInc ?
"inc" :
"dec");
1340 CGM.getOpenMPRuntime().checkAndEmitLastprivateConditional(*
this,
1345 return isPre ? IncVal : InVal;
1355 DI->EmitExplicitCastType(E->
getType());
1366 if (
auto *constantIdx = dyn_cast<llvm::ConstantInt>(idx)) {
1367 CharUnits offset = constantIdx->getZExtValue() * eltSize;
1381 assert(BO->
isAdditiveOp() &&
"Expect an addition or subtraction.");
1384 bool isSubtraction = BO->
getOpcode() == BO_Sub;
1387 llvm::Value *
index =
nullptr;
1391 std::swap(pointerOperand, indexOperand);
1403 BO, pointerOperand, pointer, indexOperand,
index, isSubtraction);
1410 nullptr, IsKnownNonNull);
1423 if (
const CastExpr *CE = dyn_cast<CastExpr>(E)) {
1424 if (
const auto *ECE = dyn_cast<ExplicitCastExpr>(CE))
1427 switch (CE->getCastKind()) {
1431 case CK_AddressSpaceConversion:
1432 if (
auto PtrTy = CE->getSubExpr()->getType()->getAs<
PointerType>()) {
1433 if (PtrTy->getPointeeType()->isVoidType())
1439 CE->getSubExpr(), &InnerBaseInfo, &InnerTBAAInfo, IsKnownNonNull);
1440 if (BaseInfo) *BaseInfo = InnerBaseInfo;
1441 if (TBAAInfo) *TBAAInfo = InnerTBAAInfo;
1447 E->
getType(), &TargetTypeBaseInfo, &TargetTypeTBAAInfo);
1455 BaseInfo->mergeForCast(TargetTypeBaseInfo);
1456 Addr.setAlignment(Align);
1460 if (CGF.
SanOpts.
has(SanitizerKind::CFIUnrelatedCast) &&
1461 CE->getCastKind() == CK_BitCast) {
1469 llvm::Type *ElemTy =
1471 Addr =
Addr.withElementType(ElemTy);
1472 if (CE->getCastKind() == CK_AddressSpaceConversion)
1482 case CK_ArrayToPointerDecay:
1486 case CK_UncheckedDerivedToBase:
1487 case CK_DerivedToBase: {
1494 CE->getSubExpr(), BaseInfo,
nullptr,
1496 CE->getCastKind() == CK_UncheckedDerivedToBase));
1497 auto Derived = CE->getSubExpr()->
getType()->getPointeeCXXRecordDecl();
1499 Addr, Derived, CE->path_begin(), CE->path_end(),
1512 if (UO->getOpcode() == UO_AddrOf) {
1513 LValue LV = CGF.
EmitLValue(UO->getSubExpr(), IsKnownNonNull);
1514 if (BaseInfo) *BaseInfo = LV.getBaseInfo();
1515 if (TBAAInfo) *TBAAInfo = LV.getTBAAInfo();
1516 return LV.getAddress();
1521 if (
auto *
Call = dyn_cast<CallExpr>(E)) {
1522 switch (
Call->getBuiltinCallee()) {
1525 case Builtin::BIaddressof:
1526 case Builtin::BI__addressof:
1527 case Builtin::BI__builtin_addressof: {
1529 if (BaseInfo) *BaseInfo = LV.getBaseInfo();
1530 if (TBAAInfo) *TBAAInfo = LV.getTBAAInfo();
1531 return LV.getAddress();
1537 if (
auto *BO = dyn_cast<BinaryOperator>(E)) {
1538 if (BO->isAdditiveOp())
1547 true, BaseInfo, TBAAInfo, IsKnownNonNull);
1557 if (IsKnownNonNull && !
Addr.isKnownNonNull())
1558 Addr.setKnownNonNull();
1565 return CGM.getCXXABI().EmitMemberPointerIsNotNull(*
this,
V, MPT);
1566 return Builder.CreateICmpNE(
V, llvm::Constant::getNullValue(
V->getType()));
1577 llvm::Value *
U = llvm::UndefValue::get(EltTy);
1592 llvm_unreachable(
"bad evaluation kind");
1617 if (
const auto *CE = dyn_cast<CastExpr>(
Base)) {
1618 Base = CE->getSubExpr();
1619 }
else if (
const auto *PE = dyn_cast<ParenExpr>(
Base)) {
1620 Base = PE->getSubExpr();
1621 }
else if (
const auto *UO = dyn_cast<UnaryOperator>(
Base)) {
1622 if (UO->getOpcode() == UO_Extension)
1623 Base = UO->getSubExpr();
1641 if (
const auto *ME = dyn_cast<MemberExpr>(E)) {
1644 SkippedChecks.
set(SanitizerKind::Alignment,
true);
1646 SkippedChecks.
set(SanitizerKind::Null,
true);
1673 CGM.runWithSufficientStackSpace(
1674 E->
getExprLoc(), [&] { LV = EmitLValueHelper(E, IsKnownNonNull); });
1686 return cast<CallExpr>(SE)->getCallReturnType(Ctx)->getPointeeType();
1689LValue CodeGenFunction::EmitLValueHelper(
const Expr *E,
1691 ApplyDebugLocation DL(*
this, E);
1695 case Expr::ObjCPropertyRefExprClass:
1696 llvm_unreachable(
"cannot emit a property reference directly");
1698 case Expr::ObjCSelectorExprClass:
1700 case Expr::ObjCIsaExprClass:
1702 case Expr::BinaryOperatorClass:
1704 case Expr::CompoundAssignOperatorClass: {
1706 if (
const AtomicType *AT = Ty->
getAs<AtomicType>())
1707 Ty = AT->getValueType();
1712 case Expr::CallExprClass:
1713 case Expr::CXXMemberCallExprClass:
1714 case Expr::CXXOperatorCallExprClass:
1715 case Expr::UserDefinedLiteralClass:
1717 case Expr::CXXRewrittenBinaryOperatorClass:
1720 case Expr::VAArgExprClass:
1722 case Expr::DeclRefExprClass:
1724 case Expr::ConstantExprClass: {
1726 if (llvm::Value *
Result = ConstantEmitter(*this).tryEmitConstantExpr(CE)) {
1732 case Expr::ParenExprClass:
1734 case Expr::GenericSelectionExprClass:
1737 case Expr::PredefinedExprClass:
1739 case Expr::StringLiteralClass:
1741 case Expr::ObjCEncodeExprClass:
1743 case Expr::PseudoObjectExprClass:
1745 case Expr::InitListExprClass:
1747 case Expr::CXXTemporaryObjectExprClass:
1748 case Expr::CXXConstructExprClass:
1750 case Expr::CXXBindTemporaryExprClass:
1752 case Expr::CXXUuidofExprClass:
1754 case Expr::LambdaExprClass:
1757 case Expr::ExprWithCleanupsClass: {
1760 LValue LV =
EmitLValue(cleanups->getSubExpr(), IsKnownNonNull);
1761 if (LV.isSimple()) {
1764 Address
Addr = LV.getAddress();
1765 llvm::Value *
V =
Addr.getBasePointer();
1766 Scope.ForceCleanup({&
V});
1767 Addr.replaceBasePointer(
V);
1769 LV.getBaseInfo(), LV.getTBAAInfo());
1776 case Expr::CXXDefaultArgExprClass: {
1779 return EmitLValue(DAE->getExpr(), IsKnownNonNull);
1781 case Expr::CXXDefaultInitExprClass: {
1784 return EmitLValue(DIE->getExpr(), IsKnownNonNull);
1786 case Expr::CXXTypeidExprClass:
1789 case Expr::ObjCMessageExprClass:
1791 case Expr::ObjCIvarRefExprClass:
1793 case Expr::StmtExprClass:
1795 case Expr::UnaryOperatorClass:
1797 case Expr::ArraySubscriptExprClass:
1799 case Expr::MatrixSubscriptExprClass:
1801 case Expr::ArraySectionExprClass:
1803 case Expr::ExtVectorElementExprClass:
1805 case Expr::CXXThisExprClass:
1807 case Expr::MemberExprClass:
1809 case Expr::CompoundLiteralExprClass:
1811 case Expr::ConditionalOperatorClass:
1813 case Expr::BinaryConditionalOperatorClass:
1815 case Expr::ChooseExprClass:
1817 case Expr::OpaqueValueExprClass:
1819 case Expr::SubstNonTypeTemplateParmExprClass:
1822 case Expr::ImplicitCastExprClass:
1823 case Expr::CStyleCastExprClass:
1824 case Expr::CXXFunctionalCastExprClass:
1825 case Expr::CXXStaticCastExprClass:
1826 case Expr::CXXDynamicCastExprClass:
1827 case Expr::CXXReinterpretCastExprClass:
1828 case Expr::CXXConstCastExprClass:
1829 case Expr::CXXAddrspaceCastExprClass:
1830 case Expr::ObjCBridgedCastExprClass:
1833 case Expr::MaterializeTemporaryExprClass:
1836 case Expr::CoawaitExprClass:
1838 case Expr::CoyieldExprClass:
1840 case Expr::PackIndexingExprClass:
1842 case Expr::HLSLOutArgExprClass:
1843 llvm_unreachable(
"cannot emit a HLSL out argument directly");
1850 assert(
type.isCanonical());
1851 assert(!
type->isReferenceType());
1859 if (
const auto *RT = dyn_cast<RecordType>(
type))
1860 if (
const auto *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
1861 RD = RD->getDefinitionOrSelf();
1862 if (RD->hasMutableFields() || !RD->isTrivial())
1884 if (
const auto *ref = dyn_cast<ReferenceType>(
type)) {
1908 }
else if (
const auto *var = dyn_cast<VarDecl>(
Value)) {
1918 bool resultIsReference;
1924 resultIsReference =
false;
1930 resultIsReference =
true;
1951 auto *MD = dyn_cast_or_null<CXXMethodDecl>(
CurCodeDecl);
1952 if (
isLambdaMethod(MD) && MD->getOverloadedOperator() == OO_Call) {
1955 if (
const VarDecl *VD = dyn_cast<const VarDecl>(D)) {
1956 if (!VD->hasAttr<CUDADeviceAttr>()) {
1979 if (resultIsReference)
2006 assert(Constant &&
"not a constant");
2022 llvm::APInt &
Min, llvm::APInt &End,
2023 bool StrictEnums,
bool IsBool) {
2025 bool IsRegularCPlusPlusEnum =
2026 CGF.
getLangOpts().CPlusPlus && StrictEnums && ED && !ED->isFixed();
2027 if (!IsBool && !IsRegularCPlusPlusEnum)
2034 ED->getValueRange(End,
Min);
2039llvm::MDNode *CodeGenFunction::getRangeForLoadFromType(QualType Ty) {
2040 llvm::APInt
Min, End;
2046 return MDHelper.createRange(
Min, End);
2054 }
else if (
CGM.getCodeGenOpts().OptimizationLevel > 0) {
2055 if (llvm::MDNode *RangeInfo = getRangeForLoadFromType(Ty)) {
2056 Load->setMetadata(llvm::LLVMContext::MD_range, RangeInfo);
2057 Load->setMetadata(llvm::LLVMContext::MD_noundef,
2058 llvm::MDNode::get(
CGM.getLLVMContext(), {}));
2065 bool HasBoolCheck =
SanOpts.has(SanitizerKind::Bool);
2066 bool HasEnumCheck =
SanOpts.has(SanitizerKind::Enum);
2067 if (!HasBoolCheck && !HasEnumCheck)
2072 bool NeedsBoolCheck = HasBoolCheck && IsBool;
2074 if (!NeedsBoolCheck && !NeedsEnumCheck)
2084 if (NeedsEnumCheck &&
2085 getContext().isTypeIgnoredBySanitizer(SanitizerKind::Enum, Ty))
2088 llvm::APInt
Min, End;
2093 NeedsEnumCheck ? SanitizerKind::SO_Enum : SanitizerKind::SO_Bool;
2096 auto CheckHandler = SanitizerHandler::LoadInvalidValue;
2101 Check =
Builder.CreateICmpULE(
Value, llvm::ConstantInt::get(Ctx, End));
2103 llvm::Value *Upper =
2104 Builder.CreateICmpSLE(
Value, llvm::ConstantInt::get(Ctx, End));
2105 llvm::Value *Lower =
2107 Check =
Builder.CreateAnd(Upper, Lower);
2111 EmitCheck(std::make_pair(Check, Kind), CheckHandler, StaticArgs,
Value);
2120 bool isNontemporal) {
2121 if (
auto *GV = dyn_cast<llvm::GlobalValue>(
Addr.getBasePointer()))
2122 if (GV->isThreadLocal())
2128 if (ClangVecTy->isPackedVectorBoolType(
getContext())) {
2130 unsigned ValNumElems =
2133 auto *RawIntV =
Builder.CreateLoad(
Addr, Volatile,
"load_bits");
2134 const auto *RawIntTy = RawIntV->getType();
2135 assert(RawIntTy->isIntegerTy() &&
"compressed iN storage for bitvectors");
2137 auto *PaddedVecTy = llvm::FixedVectorType::get(
2138 Builder.getInt1Ty(), RawIntTy->getPrimitiveSizeInBits());
2139 llvm::Value *
V =
Builder.CreateBitCast(RawIntV, PaddedVecTy);
2152 if (VTy != NewVecTy) {
2154 llvm::Value *
V =
Builder.CreateLoad(Cast, Volatile,
"loadVecN");
2155 unsigned OldNumElements = VTy->getNumElements();
2157 std::iota(Mask.begin(), Mask.end(), 0);
2158 V =
Builder.CreateShuffleVector(
V, Mask,
"extractVec");
2173 llvm::LoadInst *Load =
Builder.CreateLoad(
Addr, Volatile);
2174 if (isNontemporal) {
2175 llvm::MDNode *Node = llvm::MDNode::get(
2176 Load->getContext(), llvm::ConstantAsMetadata::get(
Builder.getInt32(1)));
2177 Load->setMetadata(llvm::LLVMContext::MD_nontemporal, Node);
2180 CGM.DecorateInstructionWithTBAA(Load, TBAAInfo);
2192 Ty = AtomicTy->getValueType();
2196 if (StoreTy->isVectorTy() && StoreTy->getScalarSizeInBits() >
2201 unsigned MemNumElems = StoreTy->getPrimitiveSizeInBits();
2222 Ty = AtomicTy->getValueType();
2228 auto *PaddedVecTy = llvm::FixedVectorType::get(
2229 Builder.getInt1Ty(), RawIntTy->getPrimitiveSizeInBits());
2249 bool IsVector =
true) {
2250 auto *ArrayTy = dyn_cast<llvm::ArrayType>(
Addr.getElementType());
2251 if (ArrayTy && IsVector) {
2252 auto *VectorTy = llvm::FixedVectorType::get(ArrayTy->getElementType(),
2253 ArrayTy->getNumElements());
2255 return Addr.withElementType(VectorTy);
2257 auto *VectorTy = dyn_cast<llvm::VectorType>(
Addr.getElementType());
2258 if (VectorTy && !IsVector) {
2259 auto *ArrayTy = llvm::ArrayType::get(
2260 VectorTy->getElementType(),
2263 return Addr.withElementType(ArrayTy);
2275 value->getType()->isVectorTy());
2277 lvalue.getBaseInfo(), lvalue.getTBAAInfo(), isInit,
2278 lvalue.isNontemporal());
2285 bool isInit,
bool isNontemporal) {
2286 if (
auto *GV = dyn_cast<llvm::GlobalValue>(
Addr.getBasePointer()))
2287 if (GV->isThreadLocal())
2295 if (
auto *VecTy = dyn_cast<llvm::FixedVectorType>(SrcTy)) {
2297 CGM.getABIInfo().getOptimalVectorMemoryType(VecTy,
getLangOpts());
2298 if (!ClangVecTy->isPackedVectorBoolType(
getContext()) &&
2299 VecTy != NewVecTy) {
2301 VecTy->getNumElements());
2302 std::iota(Mask.begin(), Mask.begin() + VecTy->getNumElements(), 0);
2306 Mask,
"extractVec");
2309 if (
Addr.getElementType() != SrcTy)
2310 Addr =
Addr.withElementType(SrcTy);
2327 if (isNontemporal) {
2328 llvm::MDNode *Node =
2329 llvm::MDNode::get(Store->getContext(),
2330 llvm::ConstantAsMetadata::get(
Builder.getInt32(1)));
2331 Store->setMetadata(llvm::LLVMContext::MD_nontemporal, Node);
2334 CGM.DecorateInstructionWithTBAA(Store, TBAAInfo);
2353 assert(LV.getType()->isConstantMatrixType());
2355 LV.setAddress(
Addr);
2371 llvm_unreachable(
"bad evaluation kind");
2434 if (
CGM.getCodeGenOpts().OptimizationLevel > 0) {
2436 llvm::MatrixBuilder MB(
Builder);
2437 MB.CreateIndexAssumption(Idx, MatTy->getNumElementsFlattened());
2439 llvm::LoadInst *Load =
2444 assert(LV.
isBitField() &&
"Unknown LValue type!");
2462 const unsigned StorageSize =
2465 assert(
static_cast<unsigned>(Offset + Info.
Size) <= StorageSize);
2466 unsigned HighBits = StorageSize - Offset - Info.
Size;
2468 Val =
Builder.CreateShl(Val, HighBits,
"bf.shl");
2469 if (Offset + HighBits)
2470 Val =
Builder.CreateAShr(Val, Offset + HighBits,
"bf.ashr");
2473 Val =
Builder.CreateLShr(Val, Offset,
"bf.lshr");
2474 if (
static_cast<unsigned>(Offset) + Info.
Size < StorageSize)
2476 Val, llvm::APInt::getLowBitsSet(StorageSize, Info.
Size),
"bf.clear");
2492 llvm::Type *DstTy = llvm::FixedVectorType::get(Vec->getType(), 1);
2493 llvm::Value *
Zero = llvm::Constant::getNullValue(
CGM.Int64Ty);
2494 Vec =
Builder.CreateInsertElement(DstTy, Vec,
Zero,
"cast.splat");
2504 llvm::Value *Elt = llvm::ConstantInt::get(
SizeTy, InIdx);
2506 llvm::Value *Element =
Builder.CreateExtractElement(Vec, Elt);
2509 if (Element->getType()->getPrimitiveSizeInBits() >
2510 LVTy->getPrimitiveSizeInBits())
2511 Element =
Builder.CreateTrunc(Element, LVTy);
2520 for (
unsigned i = 0; i != NumResultElts; ++i)
2523 Vec =
Builder.CreateShuffleVector(Vec, Mask);
2535 llvm::Type *VectorElementTy =
CGM.getTypes().ConvertType(EQT);
2543 Builder.CreateConstInBoundsGEP(CastToPointerElement, ix,
2546 return VectorBasePtrPlusIx;
2552 "Bad type for register variable");
2557 llvm::Type *OrigTy =
CGM.getTypes().ConvertType(LV.
getType());
2558 llvm::Type *Ty = OrigTy;
2559 if (OrigTy->isPointerTy())
2560 Ty =
CGM.getTypes().getDataLayout().getIntPtrType(OrigTy);
2561 llvm::Type *Types[] = { Ty };
2563 llvm::Function *F =
CGM.getIntrinsic(llvm::Intrinsic::read_register, Types);
2565 F, llvm::MetadataAsValue::get(Ty->getContext(), RegName));
2566 if (OrigTy->isPointerTy())
2581 llvm::Type *VecTy = Vec->getType();
2584 if (SrcVal->getType()->getPrimitiveSizeInBits() <
2585 VecTy->getScalarSizeInBits())
2586 SrcVal =
Builder.CreateZExt(SrcVal, VecTy->getScalarType());
2588 auto *IRStoreTy = dyn_cast<llvm::IntegerType>(Vec->getType());
2590 auto *IRVecTy = llvm::FixedVectorType::get(
2591 Builder.getInt1Ty(), IRStoreTy->getPrimitiveSizeInBits());
2592 Vec =
Builder.CreateBitCast(Vec, IRVecTy);
2599 if (
auto *EltTy = dyn_cast<llvm::FixedVectorType>(SrcVal->getType());
2600 EltTy && EltTy->getNumElements() == 1)
2601 SrcVal =
Builder.CreateBitCast(SrcVal, EltTy->getElementType());
2607 Vec =
Builder.CreateBitCast(Vec, IRStoreTy);
2626 if (
CGM.getCodeGenOpts().OptimizationLevel > 0) {
2628 llvm::MatrixBuilder MB(
Builder);
2629 MB.CreateIndexAssumption(Idx, MatTy->getNumElementsFlattened());
2640 assert(Dst.
isBitField() &&
"Unknown LValue type");
2655 llvm_unreachable(
"present but none");
2690 CGM.getObjCRuntime().EmitObjCWeakAssign(*
this, src, LvalueDst);
2702 llvm::Value *RHS = dst.emitRawPointer(*
this);
2703 RHS =
Builder.CreatePtrToInt(RHS, ResultType,
"sub.ptr.rhs.cast");
2705 ResultType,
"sub.ptr.lhs.cast");
2706 llvm::Value *BytesBetween =
Builder.CreateSub(LHS, RHS,
"ivar.offset");
2707 CGM.getObjCRuntime().EmitObjCIvarAssign(*
this, src, dst, BytesBetween);
2709 CGM.getObjCRuntime().EmitObjCGlobalAssign(*
this, src, LvalueDst,
2713 CGM.getObjCRuntime().EmitObjCStrongCastAssign(*
this, src, LvalueDst);
2717 assert(Src.
isScalar() &&
"Can't emit an agg store with this method");
2733 llvm::Value *MaskedVal = SrcVal;
2735 const bool UseVolatile =
2738 const unsigned StorageSize =
2743 if (StorageSize != Info.
Size) {
2744 assert(StorageSize > Info.
Size &&
"Invalid bitfield size.");
2751 SrcVal, llvm::APInt::getLowBitsSet(StorageSize, Info.
Size),
2755 SrcVal =
Builder.CreateShl(SrcVal, Offset,
"bf.shl");
2759 Val, ~llvm::APInt::getBitsSet(StorageSize, Offset, Offset + Info.
Size),
2763 SrcVal =
Builder.CreateOr(Val, SrcVal,
"bf.set");
2765 assert(Offset == 0);
2772 CGM.getCodeGenOpts().ForceAAPCSBitfieldLoad)
2773 Builder.CreateLoad(Ptr,
true,
"bf.load");
2782 llvm::Value *ResultVal = MaskedVal;
2786 assert(Info.
Size <= StorageSize);
2787 unsigned HighBits = StorageSize - Info.
Size;
2789 ResultVal =
Builder.CreateShl(ResultVal, HighBits,
"bf.result.shl");
2790 ResultVal =
Builder.CreateAShr(ResultVal, HighBits,
"bf.result.ashr");
2805 SrcVal->getType()->getScalarSizeInBits())
2814 "this should only occur for non-vector l-values");
2822 llvm::Type *VecTy = Vec->getType();
2826 unsigned NumSrcElts = VTy->getNumElements();
2828 if (NumDstElts == NumSrcElts) {
2833 for (
unsigned i = 0; i != NumSrcElts; ++i)
2836 Vec =
Builder.CreateShuffleVector(SrcVal, Mask);
2837 }
else if (NumDstElts > NumSrcElts) {
2843 for (
unsigned i = 0; i != NumSrcElts; ++i)
2844 ExtMask.push_back(i);
2845 ExtMask.resize(NumDstElts, -1);
2846 llvm::Value *ExtSrcVal =
Builder.CreateShuffleVector(SrcVal, ExtMask);
2849 for (
unsigned i = 0; i != NumDstElts; ++i)
2859 for (
unsigned i = 0; i != NumSrcElts; ++i)
2861 Vec =
Builder.CreateShuffleVector(Vec, ExtSrcVal, Mask);
2864 llvm_unreachable(
"unexpected shorten vector length");
2870 llvm::Value *Elt = llvm::ConstantInt::get(
SizeTy, InIdx);
2872 Vec =
Builder.CreateInsertElement(Vec, SrcVal, Elt);
2882 "Bad type for register variable");
2885 assert(RegName &&
"Register LValue is not metadata");
2888 llvm::Type *OrigTy =
CGM.getTypes().ConvertType(Dst.
getType());
2889 llvm::Type *Ty = OrigTy;
2890 if (OrigTy->isPointerTy())
2891 Ty =
CGM.getTypes().getDataLayout().getIntPtrType(OrigTy);
2892 llvm::Type *Types[] = { Ty };
2894 llvm::Function *F =
CGM.getIntrinsic(llvm::Intrinsic::write_register, Types);
2896 if (OrigTy->isPointerTy())
2899 F, {llvm::MetadataAsValue::get(Ty->getContext(), RegName),
Value});
2907 bool IsMemberAccess=
false) {
2919 LV.setObjCIvar(
false);
2923 LV.setObjCIvar(
true);
2925 LV.setBaseIvarExp(Exp->getBase());
2930 if (
const auto *Exp = dyn_cast<DeclRefExpr>(E)) {
2931 if (
const auto *VD = dyn_cast<VarDecl>(Exp->getDecl())) {
2932 if (VD->hasGlobalStorage()) {
2933 LV.setGlobalObjCRef(
true);
2941 if (
const auto *Exp = dyn_cast<UnaryOperator>(E)) {
2946 if (
const auto *Exp = dyn_cast<ParenExpr>(E)) {
2948 if (LV.isObjCIvar()) {
2955 LV.setObjCIvar(
false);
2960 if (
const auto *Exp = dyn_cast<GenericSelectionExpr>(E)) {
2965 if (
const auto *Exp = dyn_cast<ImplicitCastExpr>(E)) {
2970 if (
const auto *Exp = dyn_cast<CStyleCastExpr>(E)) {
2975 if (
const auto *Exp = dyn_cast<ObjCBridgedCastExpr>(E)) {
2980 if (
const auto *Exp = dyn_cast<ArraySubscriptExpr>(E)) {
2982 if (LV.isObjCIvar() && !LV.isObjCArray())
2985 LV.setObjCIvar(
false);
2986 else if (LV.isGlobalObjCRef() && !LV.isObjCArray())
2989 LV.setGlobalObjCRef(
false);
2993 if (
const auto *Exp = dyn_cast<MemberExpr>(E)) {
3007 CGF, VD,
Addr, Loc);
3012 Addr =
Addr.withElementType(RealVarTy);
3018 std::optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
3019 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD);
3023 if (!Res || ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
3024 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
3027 assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
3028 ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
3029 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
3031 "Expected link clause OR to clause with unified memory enabled.");
3041 llvm::LoadInst *Load =
3046 PTy, PointeeBaseInfo, PointeeTBAAInfo,
true);
3049 llvm::MDBuilder MDB(Ctx);
3051 if (
CGM.getTypes().getTargetAddressSpace(PTy) == 0 &&
3052 !
CGM.getCodeGenOpts().NullPointerIsValid)
3053 Load->setMetadata(llvm::LLVMContext::MD_nonnull,
3054 llvm::MDNode::get(Ctx, {}));
3060 llvm::LLVMContext::MD_align,
3061 llvm::MDNode::get(Ctx, MDB.createConstant(llvm::ConstantInt::get(
3062 Builder.getInt64Ty(), AlignVal))));
3067 true, PointeeBaseInfo,
3077 PointeeBaseInfo, PointeeTBAAInfo);
3087 BaseInfo, TBAAInfo);
3117 V = CGF.
Builder.CreateThreadLocalAddress(
V);
3125 VD->
hasAttr<OMPThreadPrivateDeclAttr>()) {
3140 if (FD->
hasAttr<WeakRefAttr>()) {
3155 if (
auto *GV = dyn_cast<llvm::GlobalValue>(
V))
3156 V = llvm::NoCFIValue::get(GV);
3163 llvm::Value *ThisValue) {
3176 AsmLabelAttr *
Asm = VD->
getAttr<AsmLabelAttr>();
3177 assert(
Asm->getLabel().size() < 64-Name.size() &&
3178 "Register name too big");
3179 Name.append(
Asm->getLabel());
3180 llvm::NamedMDNode *M =
3181 CGM.
getModule().getOrInsertNamedMetadata(Name);
3182 if (M->getNumOperands() == 0) {
3185 llvm::Metadata *Ops[] = {Str};
3192 llvm::MetadataAsValue::get(CGM.
getLLVMContext(), M->getOperand(0));
3235 case llvm::GlobalValue::ExternalLinkage:
3236 case llvm::GlobalValue::LinkOnceODRLinkage:
3237 case llvm::GlobalValue::WeakODRLinkage:
3238 case llvm::GlobalValue::InternalLinkage:
3239 case llvm::GlobalValue::PrivateLinkage:
3251 "should not emit an unevaluated operand");
3253 if (
const auto *VD = dyn_cast<VarDecl>(ND)) {
3256 VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())
3264 (VD->getType()->isReferenceType() ||
3266 VD->getAnyInitializer(VD);
3268 E->
getLocation(), *VD->evaluateValue(), VD->getType());
3269 assert(Val &&
"failed to emit constant expression");
3272 if (!VD->getType()->isReferenceType()) {
3274 Addr =
CGM.createUnnamedGlobalFrom(*VD, Val,
3277 auto *PTy = llvm::PointerType::get(
3296 VD = VD->getCanonicalDecl();
3300 auto I = LocalDeclMap.find(VD);
3301 if (I != LocalDeclMap.end()) {
3303 if (VD->getType()->isReferenceType())
3311 CGM.getOpenMPRuntime().isNontemporalDecl(VD))
3328 CGM.getOpenMPRuntime().isNontemporalDecl(VD))
3344 "Should not use decl without marking it used!");
3346 if (ND->
hasAttr<WeakRefAttr>()) {
3352 if (
const auto *VD = dyn_cast<VarDecl>(ND)) {
3354 if (VD->hasLinkage() || VD->isStaticDataMember())
3360 auto iter = LocalDeclMap.find(VD);
3361 if (iter != LocalDeclMap.end()) {
3362 addr = iter->second;
3366 }
else if (VD->isStaticLocal()) {
3367 llvm::Constant *var =
CGM.getOrCreateStaticVarDecl(
3368 *VD,
CGM.getLLVMLinkageVarDefinition(VD));
3374 llvm_unreachable(
"DeclRefExpr for Decl not entered in LocalDeclMap?");
3385 VD->hasAttr<OMPThreadPrivateDeclAttr>()) {
3392 bool isBlockByref = VD->isEscapingByref();
3398 LValue LV = VD->getType()->isReferenceType() ?
3402 bool isLocalStorage = VD->hasLocalStorage();
3404 bool NonGCable = isLocalStorage &&
3405 !VD->getType()->isReferenceType() &&
3412 bool isImpreciseLifetime =
3413 (isLocalStorage && !VD->hasAttr<ObjCPreciseLifetimeAttr>());
3414 if (isImpreciseLifetime)
3420 if (
const auto *FD = dyn_cast<FunctionDecl>(ND))
3426 if (
const auto *BD = dyn_cast<BindingDecl>(ND)) {
3443 if (
const auto *GD = dyn_cast<MSGuidDecl>(ND))
3447 if (
const auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
3448 auto ATPO =
CGM.GetAddrOfTemplateParamObject(TPO);
3451 if (AS !=
T.getAddressSpace()) {
3453 auto PtrTy = llvm::PointerType::get(
CGM.getLLVMContext(), TargetAS);
3456 ATPO =
ConstantAddress(ASC, ATPO.getElementType(), ATPO.getAlignment());
3462 llvm_unreachable(
"Unhandled DeclRefExpr");
3472 default: llvm_unreachable(
"Unknown unary operator lvalue!");
3475 assert(!
T.isNull() &&
"CodeGenFunction::EmitUnaryOpLValue: Illegal type");
3497 assert(LV.
isSimple() &&
"real/imag on non-ordinary l-value");
3514 CGM.getTBAAInfoForSubobject(LV,
T));
3521 bool isInc = E->
getOpcode() == UO_PreInc;
3544 assert(SL !=
nullptr &&
"No StringLiteral name in PredefinedExpr");
3545 StringRef FnName =
CurFn->getName();
3546 FnName.consume_front(
"\01");
3547 StringRef NameItems[] = {
3549 std::string GVName = llvm::join(NameItems, NameItems + 2,
".");
3550 if (
auto *BD = dyn_cast_or_null<BlockDecl>(
CurCodeDecl)) {
3551 std::string Name = std::string(SL->getString());
3552 if (!Name.empty()) {
3553 unsigned Discriminator =
3554 CGM.getCXXABI().getMangleContext().getBlockId(BD,
true);
3556 Name +=
"_" + Twine(Discriminator + 1).str();
3557 auto C =
CGM.GetAddrOfConstantCString(Name, GVName);
3560 auto C =
CGM.GetAddrOfConstantCString(std::string(FnName), GVName);
3564 auto C =
CGM.GetAddrOfConstantStringFromLiteral(SL, GVName);
3581 if (llvm::Constant *
C =
CGM.getTypeDescriptorFromMap(
T))
3586 bool IsBitInt =
false;
3588 if (
T->isIntegerType()) {
3591 (
T->isSignedIntegerType() ? 1 : 0);
3595 if (
T->isSignedIntegerType() &&
T->getAs<
BitIntType>()) {
3598 " non positive amount of bits in __BitInt type");
3600 " too many bits in __BitInt type");
3607 }
else if (
T->isFloatingType()) {
3616 (
intptr_t)
T.getAsOpaquePtr(), StringRef(),
3617 StringRef(), {}, Buffer, {});
3622 char S[6] = {
'\0',
'\0',
'\0',
'\0',
'\0',
'\0'};
3625 llvm::support::endian::write32(S + 1, Bits,
3627 ? llvm::endianness::big
3628 : llvm::endianness::little);
3629 StringRef Str = StringRef(S,
sizeof(S) /
sizeof(
decltype(S[0])));
3633 llvm::Constant *Components[] = {
3637 llvm::Constant *Descriptor = llvm::ConstantStruct::getAnon(Components);
3639 auto *GV =
new llvm::GlobalVariable(
3640 CGM.getModule(), Descriptor->getType(),
3641 true, llvm::GlobalVariable::PrivateLinkage, Descriptor);
3642 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3643 CGM.getSanitizerMetadata()->disableSanitizerForGlobal(GV);
3646 CGM.setTypeDescriptorInMap(
T, GV);
3654 if (
V->getType() == TargetTy)
3659 if (
V->getType()->isFloatingPointTy()) {
3660 unsigned Bits =
V->getType()->getPrimitiveSizeInBits().getFixedValue();
3661 if (Bits <= TargetTy->getIntegerBitWidth())
3667 if (
V->getType()->isIntegerTy() &&
3668 V->getType()->getIntegerBitWidth() <= TargetTy->getIntegerBitWidth())
3669 return Builder.CreateZExt(
V, TargetTy);
3672 if (!
V->getType()->isPointerTy()) {
3677 return Builder.CreatePtrToInt(
V, TargetTy);
3690 llvm::Constant *Filename;
3697 int PathComponentsToStrip =
3698 CGM.getCodeGenOpts().EmitCheckPathComponentsToStrip;
3699 if (PathComponentsToStrip < 0) {
3700 assert(PathComponentsToStrip !=
INT_MIN);
3701 int PathComponentsToKeep = -PathComponentsToStrip;
3702 auto I = llvm::sys::path::rbegin(FilenameString);
3703 auto E = llvm::sys::path::rend(FilenameString);
3704 while (I != E && --PathComponentsToKeep)
3707 FilenameString = FilenameString.substr(I - E);
3708 }
else if (PathComponentsToStrip > 0) {
3709 auto I = llvm::sys::path::begin(FilenameString);
3710 auto E = llvm::sys::path::end(FilenameString);
3711 while (I != E && PathComponentsToStrip--)
3716 FilenameString.substr(I - llvm::sys::path::begin(FilenameString));
3718 FilenameString = llvm::sys::path::filename(FilenameString);
3722 CGM.GetAddrOfConstantCString(std::string(FilenameString),
".src");
3723 CGM.getSanitizerMetadata()->disableSanitizerForGlobal(
3725 FilenameGV.getPointer()->stripPointerCasts()));
3726 Filename = FilenameGV.getPointer();
3730 Filename = llvm::Constant::getNullValue(
Int8PtrTy);
3737 return llvm::ConstantStruct::getAnon(
Data);
3742enum class CheckRecoverableKind {
3753static CheckRecoverableKind
3755 if (Ordinal == SanitizerKind::SO_Vptr)
3756 return CheckRecoverableKind::AlwaysRecoverable;
3757 else if (Ordinal == SanitizerKind::SO_Return ||
3758 Ordinal == SanitizerKind::SO_Unreachable)
3759 return CheckRecoverableKind::Unrecoverable;
3761 return CheckRecoverableKind::Recoverable;
3765struct SanitizerHandlerInfo {
3766 char const *
const Name;
3772#define SANITIZER_CHECK(Enum, Name, Version, Msg) {#Name, Version},
3774#undef SANITIZER_CHECK
3778 llvm::FunctionType *FnType,
3781 CheckRecoverableKind RecoverKind,
bool IsFatal,
3782 llvm::BasicBlock *ContBB,
bool NoMerge) {
3783 assert(IsFatal || RecoverKind != CheckRecoverableKind::Unrecoverable);
3784 std::optional<ApplyDebugLocation> DL;
3785 if (!CGF.
Builder.getCurrentDebugLocation()) {
3789 bool NeedsAbortSuffix =
3790 IsFatal && RecoverKind != CheckRecoverableKind::Unrecoverable;
3793 const StringRef CheckName = CheckInfo.Name;
3794 std::string FnName =
"__ubsan_handle_" + CheckName.str();
3795 if (CheckInfo.Version && !MinimalRuntime)
3796 FnName +=
"_v" + llvm::utostr(CheckInfo.Version);
3798 FnName +=
"_minimal";
3799 if (NeedsAbortSuffix)
3802 !IsFatal || RecoverKind == CheckRecoverableKind::AlwaysRecoverable;
3806 B.addAttribute(llvm::Attribute::NoReturn)
3807 .addAttribute(llvm::Attribute::NoUnwind);
3809 B.addUWTableAttr(llvm::UWTableKind::Default);
3814 llvm::AttributeList::FunctionIndex, B),
3820 HandlerCall->addFnAttr(llvm::Attribute::NoMerge);
3822 HandlerCall->setDoesNotReturn();
3823 CGF.
Builder.CreateUnreachable();
3830 ArrayRef<std::pair<llvm::Value *, SanitizerKind::SanitizerOrdinal>> Checked,
3834 assert(Checked.size() > 0);
3835 assert(CheckHandler >= 0 &&
3839 llvm::Value *FatalCond =
nullptr;
3840 llvm::Value *RecoverableCond =
nullptr;
3841 llvm::Value *TrapCond =
nullptr;
3842 bool NoMerge =
false;
3849 for (
auto &[Check, Ord] : Checked) {
3850 llvm::Value *GuardedCheck = Check;
3852 (
CGM.getCodeGenOpts().SanitizeSkipHotCutoffs[Ord] > 0)) {
3854 CGM.getIntrinsic(llvm::Intrinsic::allow_ubsan_check),
3855 llvm::ConstantInt::get(
CGM.Int8Ty, Ord));
3860 llvm::Value *&
Cond =
CGM.getCodeGenOpts().SanitizeTrap.has(Ord) ? TrapCond
3861 :
CGM.getCodeGenOpts().SanitizeRecover.has(Ord)
3866 if (!
CGM.getCodeGenOpts().SanitizeMergeHandlers.has(Ord))
3872 if (!FatalCond && !RecoverableCond)
3875 llvm::Value *JointCond;
3876 if (FatalCond && RecoverableCond)
3877 JointCond =
Builder.CreateAnd(FatalCond, RecoverableCond);
3879 JointCond = FatalCond ? FatalCond : RecoverableCond;
3883 assert(
SanOpts.has(Checked[0].second));
3885 for (
int i = 1, n = Checked.size(); i < n; ++i) {
3887 "All recoverable kinds in a single check must be same!");
3888 assert(
SanOpts.has(Checked[i].second));
3894 llvm::Instruction *Branch =
Builder.CreateCondBr(JointCond, Cont, Handlers);
3897 llvm::MDNode *Node = MDHelper.createLikelyBranchWeights();
3898 Branch->setMetadata(llvm::LLVMContext::MD_prof, Node);
3902 if (
CGM.getCodeGenOpts().SanitizeMinimalRuntime) {
3903 switch (CheckHandler) {
3904 case SanitizerHandler::TypeMismatch:
3907 assert(DynamicArgs.size() == 1);
3923 Args.reserve(DynamicArgs.size() + 1);
3924 ArgTypes.reserve(DynamicArgs.size() + 1);
3927 if (!StaticArgs.empty()) {
3928 llvm::Constant *Info = llvm::ConstantStruct::getAnon(StaticArgs);
3929 auto *InfoPtr =
new llvm::GlobalVariable(
3930 CGM.getModule(), Info->getType(),
3933 false, llvm::GlobalVariable::PrivateLinkage, Info,
"",
3934 nullptr, llvm::GlobalVariable::NotThreadLocal,
3935 CGM.getDataLayout().getDefaultGlobalsAddressSpace());
3936 InfoPtr->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3937 CGM.getSanitizerMetadata()->disableSanitizerForGlobal(InfoPtr);
3938 Args.push_back(InfoPtr);
3939 ArgTypes.push_back(Args.back()->getType());
3942 for (llvm::Value *DynamicArg : DynamicArgs) {
3947 llvm::FunctionType *FnType =
3948 llvm::FunctionType::get(
CGM.VoidTy, ArgTypes,
false);
3950 if (!FatalCond || !RecoverableCond) {
3954 (FatalCond !=
nullptr), Cont, NoMerge);
3958 llvm::BasicBlock *NonFatalHandlerBB =
3961 Builder.CreateCondBr(FatalCond, NonFatalHandlerBB, FatalHandlerBB);
3964 NonFatalHandlerBB, NoMerge);
3975 llvm::ConstantInt *TypeId, llvm::Value *Ptr,
3980 llvm::BranchInst *BI =
Builder.CreateCondBr(
Cond, Cont, CheckBB);
3983 llvm::MDNode *Node = MDHelper.createLikelyBranchWeights();
3984 BI->setMetadata(llvm::LLVMContext::MD_prof, Node);
3988 bool WithDiag = !
CGM.getCodeGenOpts().SanitizeTrap.has(Ordinal);
3990 llvm::CallInst *CheckCall;
3991 llvm::FunctionCallee SlowPathFn;
3993 llvm::Constant *Info = llvm::ConstantStruct::getAnon(StaticArgs);
3995 new llvm::GlobalVariable(
CGM.getModule(), Info->getType(),
false,
3996 llvm::GlobalVariable::PrivateLinkage, Info);
3997 InfoPtr->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3998 CGM.getSanitizerMetadata()->disableSanitizerForGlobal(InfoPtr);
4000 SlowPathFn =
CGM.getModule().getOrInsertFunction(
4001 "__cfi_slowpath_diag",
4004 CheckCall =
Builder.CreateCall(SlowPathFn, {TypeId, Ptr, InfoPtr});
4006 SlowPathFn =
CGM.getModule().getOrInsertFunction(
4009 CheckCall =
Builder.CreateCall(SlowPathFn, {TypeId, Ptr});
4014 CheckCall->setDoesNotThrow();
4022 llvm::Module *M = &
CGM.getModule();
4024 QualType QInt64Ty =
C.getIntTypeForBitwidth(64,
false);
4031 FnArgs.push_back(&ArgCallsiteTypeId);
4032 FnArgs.push_back(&ArgAddr);
4033 FnArgs.push_back(&ArgCFICheckFailData);
4035 CGM.getTypes().arrangeBuiltinFunctionDeclaration(
C.VoidTy,
FnArgs);
4037 llvm::Function *F = llvm::Function::Create(
4039 llvm::GlobalValue::WeakAnyLinkage,
"__cfi_check", M);
4041 CGM.SetLLVMFunctionAttributesForDefinition(
nullptr, F);
4042 F->setAlignment(llvm::Align(4096));
4045 llvm::LLVMContext &Ctx = M->getContext();
4046 llvm::BasicBlock *BB = llvm::BasicBlock::Create(Ctx,
"entry", F);
4049 llvm::CallInst::Create(M->getFunction(
"__cfi_check_fail"), Args,
"", BB);
4050 llvm::ReturnInst::Create(Ctx,
nullptr, BB);
4061 auto CheckHandler = SanitizerHandler::CFICheckFail;
4068 {SanitizerKind::SO_CFIVCall, SanitizerKind::SO_CFINVCall,
4069 SanitizerKind::SO_CFIDerivedCast, SanitizerKind::SO_CFIUnrelatedCast,
4070 SanitizerKind::SO_CFIICall},
4077 Args.push_back(&ArgData);
4078 Args.push_back(&ArgAddr);
4083 llvm::Function *F = llvm::Function::Create(
4085 llvm::GlobalValue::WeakODRLinkage,
"__cfi_check_fail", &
CGM.getModule());
4088 CGM.SetLLVMFunctionAttributesForDefinition(
nullptr, F);
4089 F->setVisibility(llvm::GlobalValue::HiddenVisibility);
4109 llvm::Value *DataIsNotNullPtr =
4114 EmitTrapCheck(DataIsNotNullPtr, SanitizerHandler::CFICheckFail,
4117 llvm::StructType *SourceLocationTy =
4119 llvm::StructType *CfiCheckFailDataTy =
4122 llvm::Value *
V =
Builder.CreateConstGEP2_32(
4126 llvm::Value *CheckKind =
Builder.CreateLoad(CheckKindAddr);
4128 llvm::Value *AllVtables = llvm::MetadataAsValue::get(
4129 CGM.getLLVMContext(),
4130 llvm::MDString::get(
CGM.getLLVMContext(),
"all-vtables"));
4131 llvm::Value *ValidVtable =
Builder.CreateZExt(
4132 Builder.CreateCall(
CGM.getIntrinsic(llvm::Intrinsic::type_test),
4133 {Addr, AllVtables}),
4136 const std::pair<int, SanitizerKind::SanitizerOrdinal> CheckKinds[] = {
4143 for (
auto CheckKindOrdinalPair : CheckKinds) {
4144 int Kind = CheckKindOrdinalPair.first;
4151 Builder.CreateICmpNE(CheckKind, llvm::ConstantInt::get(
Int8Ty, Kind));
4152 if (
CGM.getLangOpts().Sanitize.has(Ordinal))
4153 EmitCheck(std::make_pair(
Cond, Ordinal), SanitizerHandler::CFICheckFail,
4166 CGM.addUsedGlobal(F);
4170 if (
SanOpts.has(SanitizerKind::Unreachable)) {
4171 auto CheckOrdinal = SanitizerKind::SO_Unreachable;
4172 auto CheckHandler = SanitizerHandler::BuiltinUnreachable;
4188 if ((
int)TrapBBs.size() <= CheckHandlerID)
4189 TrapBBs.resize(CheckHandlerID + 1);
4191 llvm::BasicBlock *&TrapBB = TrapBBs[CheckHandlerID];
4193 llvm::DILocation *TrapLocation =
Builder.getCurrentDebugLocation();
4194 llvm::StringRef TrapMessage;
4195 llvm::StringRef TrapCategory;
4196 auto DebugTrapReasonKind =
CGM.getCodeGenOpts().getSanitizeDebugTrapReasons();
4198 DebugTrapReasonKind ==
4204 TrapCategory =
"Undefined Behavior Sanitizer";
4208 DebugTrapReasonKind !=
4212 TrapLocation, TrapCategory, TrapMessage);
4215 NoMerge = NoMerge || !
CGM.getCodeGenOpts().OptimizationLevel ||
4219 if (TrapBB && !NoMerge) {
4220 auto Call = TrapBB->begin();
4223 Call->applyMergedLocation(
Call->getDebugLoc(), TrapLocation);
4225 Builder.CreateCondBr(Checked, Cont, TrapBB,
4226 MDHelper.createLikelyBranchWeights());
4229 Builder.CreateCondBr(Checked, Cont, TrapBB,
4230 MDHelper.createLikelyBranchWeights());
4235 llvm::CallInst *TrapCall =
4236 Builder.CreateCall(
CGM.getIntrinsic(llvm::Intrinsic::ubsantrap),
4237 llvm::ConstantInt::get(
CGM.Int8Ty, CheckHandlerID));
4239 if (!
CGM.getCodeGenOpts().TrapFuncName.empty()) {
4240 auto A = llvm::Attribute::get(
getLLVMContext(),
"trap-func-name",
4241 CGM.getCodeGenOpts().TrapFuncName);
4242 TrapCall->addFnAttr(A);
4245 TrapCall->addFnAttr(llvm::Attribute::NoMerge);
4246 TrapCall->setDoesNotReturn();
4247 TrapCall->setDoesNotThrow();
4255 llvm::CallInst *TrapCall =
4256 Builder.CreateCall(
CGM.getIntrinsic(IntrID));
4258 if (!
CGM.getCodeGenOpts().TrapFuncName.empty()) {
4259 auto A = llvm::Attribute::get(
getLLVMContext(),
"trap-func-name",
4260 CGM.getCodeGenOpts().TrapFuncName);
4261 TrapCall->addFnAttr(A);
4265 TrapCall->addFnAttr(llvm::Attribute::NoMerge);
4273 "Array to pointer decay must have array source type!");
4282 Addr =
Addr.withElementType(NewTy);
4288 "Expected pointer to array");
4299 if (TBAAInfo) *TBAAInfo =
CGM.getTBAAAccessInfo(EltType);
4308 const auto *CE = dyn_cast<CastExpr>(E);
4309 if (!CE || CE->getCastKind() != CK_ArrayToPointerDecay)
4321 llvm::Type *elemType,
4327 const llvm::Twine &name =
"arrayidx") {
4339 llvm::Type *elementType,
bool inbounds,
4342 const llvm::Twine &name =
"arrayidx") {
4362 return D && D->
hasAttr<BPFPreserveStaticOffsetAttr>();
4369 if (PointeeType.
isNull())
4382 llvm::Function *Fn =
4384 llvm::CallInst *
Call = CGF.
Builder.CreateCall(Fn, {
Addr.emitRawPointer(CGF)});
4402 if (
const auto *ME = dyn_cast<MemberExpr>(E))
4403 return ME->getMemberDecl()->hasAttr<BPFPreserveAccessIndexAttr>();
4405 if (
const auto *DRE = dyn_cast<DeclRefExpr>(E)) {
4406 const auto *VarDef = dyn_cast<VarDecl>(DRE->getDecl());
4410 const auto *PtrT = VarDef->getType()->getAs<
PointerType>();
4416 if (
const auto *RecT = dyn_cast<RecordType>(PointeeT))
4417 return RecT->getDecl()
4418 ->getMostRecentDecl()
4419 ->
hasAttr<BPFPreserveAccessIndexAttr>();
4432 const llvm::Twine &name =
"arrayidx") {
4435 for (
auto *idx : indices.drop_back())
4454 llvm::Value *eltPtr;
4455 auto LastIndex = dyn_cast<llvm::ConstantInt>(indices.back());
4460 signedIndices, loc, eltAlign, name);
4464 unsigned idx = LastIndex->getZExtValue();
4465 llvm::DIType *DbgInfo =
nullptr;
4468 eltPtr = CGF.
Builder.CreatePreserveArrayAccessIndex(
4480struct StructFieldAccess
4481 :
public ConstStmtVisitor<StructFieldAccess, const Expr *> {
4482 const Expr *VisitCastExpr(
const CastExpr *E) {
4487 const Expr *VisitParenExpr(
const ParenExpr *E) {
4496 const FieldDecl *Field, int64_t &Offset) {
4499 unsigned FieldNo = 0;
4534 if (FD1OuterRec != FD2OuterRec)
4536 return std::optional<int64_t>();
4538 int64_t FD1Offset = 0;
4540 return std::optional<int64_t>();
4542 int64_t FD2Offset = 0;
4544 return std::optional<int64_t>();
4546 return std::make_optional<int64_t>(FD1Offset - FD2Offset);
4558 QualType ArrayTy,
bool Accessed,
bool FlexibleArray) {
4560 if (!ME || !ME->getMemberDecl()->getType()->isCountAttributedType())
4565 if (FlexibleArray &&
4566 !ME->isFlexibleArrayMemberLike(
getContext(), StrictFlexArraysLevel))
4574 if (std::optional<int64_t> Diff =
4576 if (!
Addr.isValid()) {
4594 Builder.getInt32(*Diff),
".counted_by.gep");
4596 ".counted_by.load");
4607 llvm::Value *IdxPre =
4609 bool SignedIndices =
false;
4610 auto EmitIdxAfterBase = [&, IdxPre](
bool Promote) -> llvm::Value * {
4613 assert(E->
getRHS() == E->
getIdx() &&
"index was neither LHS nor RHS");
4619 SignedIndices |= IdxSigned;
4621 if (
SanOpts.has(SanitizerKind::ArrayBounds))
4625 if (Promote && Idx->getType() !=
IntPtrTy)
4638 auto *Idx = EmitIdxAfterBase(
false);
4639 assert(LHS.
isSimple() &&
"Can only subscript lvalue vectors here!");
4647 std::optional<LValue> LV =
4648 CGM.getHLSLRuntime().emitResourceArraySubscriptExpr(E, *
this);
4658 auto *Idx = EmitIdxAfterBase(
true);
4665 CGM.getTBAAInfoForSubobject(LV, EltType));
4677 auto *Idx = EmitIdxAfterBase(
true);
4687 Idx =
Builder.CreateMul(Idx, numElements);
4689 Idx =
Builder.CreateNSWMul(Idx, numElements);
4701 auto *Idx = EmitIdxAfterBase(
true);
4704 llvm::Value *InterfaceSizeVal =
4705 llvm::ConstantInt::get(Idx->getType(), InterfaceSize.
getQuantity());
4707 llvm::Value *ScaledIdx =
Builder.CreateMul(Idx, InterfaceSizeVal);
4713 llvm::Type *OrigBaseElemTy =
Addr.getElementType();
4718 llvm::Value *EltPtr =
4720 ScaledIdx,
false, SignedIndices, E->
getExprLoc());
4727 assert(Array->getType()->isArrayType() &&
4728 "Array to pointer decay must have array source type!");
4732 if (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(Array))
4736 auto *Idx = EmitIdxAfterBase(
true);
4738 if (
SanOpts.has(SanitizerKind::ArrayBounds))
4746 *
this, ArrayLV.
getAddress(), {CGM.getSize(CharUnits::Zero()), Idx},
4750 if (!
CGM.getCodeGenOpts().NewStructPathTBAA) {
4753 EltTBAAInfo =
CGM.getTBAAInfoForSubobject(ArrayLV, E->
getType());
4758 EltTBAAInfo =
CGM.getTBAAAccessInfo(E->
getType());
4780 auto *Idx = EmitIdxAfterBase(
true);
4787 if (
SanOpts.has(SanitizerKind::ArrayBounds)) {
4788 StructFieldAccess Visitor;
4791 if (
const auto *CE = dyn_cast_if_present<CastExpr>(
Base);
4792 CE && CE->getCastKind() == CK_LValueToRValue)
4820 "incomplete matrix subscript expressions should be rejected during Sema");
4827 llvm::Value *NumRows =
Builder.getIntN(
4828 RowIdx->getType()->getScalarSizeInBits(),
4830 llvm::Value *FinalIdx =
4841 bool IsLowerBound) {
4843 if (
auto *ASE = dyn_cast<ArraySectionExpr>(
Base->IgnoreParenImpCasts())) {
4847 BaseInfo = BaseLVal.getBaseInfo();
4852 Addr =
Addr.withElementType(NewTy);
4858 "Expected pointer to array");
4868 BaseInfo.mergeForCast(TypeBaseInfo);
4877 bool IsLowerBound) {
4880 "OpenACC Array section codegen not implemented");
4884 if (
auto *AT =
getContext().getAsArrayType(BaseTy))
4885 ResultExprTy = AT->getElementType();
4888 llvm::Value *Idx =
nullptr;
4896 LowerBound->getType()->hasSignedIntegerRepresentation());
4898 Idx = llvm::ConstantInt::getNullValue(
IntPtrTy);
4903 auto &
C =
CGM.getContext();
4905 llvm::APSInt ConstLength;
4908 if (std::optional<llvm::APSInt>
CL = Length->getIntegerConstantExpr(
C)) {
4915 if (std::optional<llvm::APSInt> LB =
4916 LowerBound->getIntegerConstantExpr(
C)) {
4918 LowerBound =
nullptr;
4923 else if (!LowerBound)
4926 if (Length || LowerBound) {
4927 auto *LowerBoundVal =
4931 LowerBound->getType()->hasSignedIntegerRepresentation())
4932 : llvm::ConstantInt::get(
IntPtrTy, ConstLowerBound);
4937 Length->getType()->hasSignedIntegerRepresentation())
4938 : llvm::ConstantInt::get(
IntPtrTy, ConstLength);
4939 Idx =
Builder.CreateAdd(LowerBoundVal, LengthVal,
"lb_add_len",
4942 if (Length && LowerBound) {
4944 Idx, llvm::ConstantInt::get(
IntPtrTy, 1),
"idx_sub_1",
4948 Idx = llvm::ConstantInt::get(
IntPtrTy, ConstLength + ConstLowerBound);
4954 if (
auto *VAT =
C.getAsVariableArrayType(ArrayTy)) {
4955 Length = VAT->getSizeExpr();
4956 if (std::optional<llvm::APSInt> L = Length->getIntegerConstantExpr(
C)) {
4961 auto *CAT =
C.getAsConstantArrayType(ArrayTy);
4962 assert(CAT &&
"unexpected type for array initializer");
4963 ConstLength = CAT->getSize();
4966 auto *LengthVal =
Builder.CreateIntCast(
4968 Length->getType()->hasSignedIntegerRepresentation());
4970 LengthVal, llvm::ConstantInt::get(
IntPtrTy, 1),
"len_sub_1",
4975 Idx = llvm::ConstantInt::get(
IntPtrTy, ConstLength);
4984 if (
auto *VLA =
getContext().getAsVariableArrayType(ResultExprTy)) {
4990 BaseTy, VLA->getElementType(), IsLowerBound);
4999 Idx =
Builder.CreateMul(Idx, NumElements);
5001 Idx =
Builder.CreateNSWMul(Idx, NumElements);
5010 assert(Array->getType()->isArrayType() &&
5011 "Array to pointer decay must have array source type!");
5015 if (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(Array))
5022 *
this, ArrayLV.
getAddress(), {CGM.getSize(CharUnits::Zero()), Idx},
5023 ResultExprTy, !
getLangOpts().PointerOverflowDefined,
5026 TBAAInfo =
CGM.getTBAAInfoForSubobject(ArrayLV, ResultExprTy);
5030 ResultExprTy, IsLowerBound);
5053 Base.getQuals().removeObjCGCAttr();
5062 "Result must be a vector");
5070 if (LTy->getScalarSizeInBits() > Vec->getType()->getScalarSizeInBits())
5071 Vec =
Builder.CreateZExt(Vec, LTy);
5072 Builder.CreateStore(Vec, VecMem);
5083 if (
Base.isSimple()) {
5084 llvm::Constant *CV =
5089 assert(
Base.isExtVectorElt() &&
"Can only subscript lvalue vec elts here!");
5091 llvm::Constant *BaseElts =
Base.getExtVectorElts();
5094 for (
unsigned Index : Indices)
5095 CElts.push_back(BaseElts->getAggregateElement(Index));
5096 llvm::Constant *CV = llvm::ConstantVector::get(CElts);
5103 while (
auto *BaseMemberExpr = dyn_cast<MemberExpr>(UnderlyingBaseExpr))
5104 UnderlyingBaseExpr = BaseMemberExpr->getBase()->
IgnoreParens();
5118 bool IsInBounds = !
getLangOpts().PointerOverflowDefined &&
5130 SkippedChecks.
set(SanitizerKind::Alignment,
true);
5132 SkippedChecks.
set(SanitizerKind::Null,
true);
5140 if (
auto *Field = dyn_cast<FieldDecl>(ND)) {
5148 CGM.getOpenMPRuntime().isNontemporalDecl(Field)) ||
5155 if (
const auto *FD = dyn_cast<FunctionDecl>(ND))
5158 llvm_unreachable(
"Unhandled member declaration!");
5165 llvm::Value *ThisValue) {
5166 bool HasExplicitObjectParameter =
false;
5167 const auto *MD = dyn_cast_if_present<CXXMethodDecl>(
CurCodeDecl);
5169 HasExplicitObjectParameter = MD->isExplicitObjectMemberFunction();
5170 assert(MD->getParent()->isLambda());
5171 assert(MD->getParent() == Field->getParent());
5174 if (HasExplicitObjectParameter) {
5176 auto It = LocalDeclMap.find(D);
5177 assert(It != LocalDeclMap.end() &&
"explicit parameter not loaded?");
5178 Address AddrOfExplicitObject = It->getSecond();
5189 if (ThisTy != LambdaTy) {
5192 LambdaLV.
getAddress(), ThisTy, BasePathArray.begin(),
5212 unsigned FieldIndex) {
5213 unsigned I = 0, Skipped = 0;
5216 if (I == FieldIndex)
5218 if (F->isUnnamedBitField())
5223 return FieldIndex - Skipped;
5233 if (Offset.isZero())
5246 const FieldDecl *field,
bool IsInBounds) {
5279 if (RD->isDynamicClass())
5282 for (
const auto &
Base : RD->bases())
5286 for (
const FieldDecl *Field : RD->fields())
5301 const bool UseVolatile =
isAAPCS(
CGM.getTarget()) &&
5302 CGM.getCodeGenOpts().AAPCSBitfieldWidth &&
5333 llvm::Type *FieldIntTy = llvm::Type::getIntNTy(
getLLVMContext(), SS);
5334 Addr =
Addr.withElementType(FieldIntTy);
5369 assert(!FieldTBAAInfo.
Offset &&
5370 "Nonzero offset for an access with no base type!");
5383 FieldTBAAInfo.
Size =
5390 if (
auto *ClassDef = dyn_cast<CXXRecordDecl>(rec)) {
5391 if (
CGM.getCodeGenOpts().StrictVTablePointers &&
5392 ClassDef->isDynamicClass()) {
5406 if (
CGM.getCodeGenOpts().StrictVTablePointers &&
5410 addr =
Builder.CreateLaunderInvariantGroup(addr);
5453 if (field->
hasAttr<AnnotateAttr>())
5469 QualType FieldType = Field->getType();
5475 *
this,
Base.getAddress(), Field,
5480 V =
V.withElementType(llvmType);
5489 CGM.getTBAAInfoForSubobject(
Base, FieldType));
5525 assert(E->
isTransparent() &&
"non-transparent glvalue init list");
5533 const Expr *Operand) {
5534 if (
auto *ThrowExpr = dyn_cast<CXXThrowExpr>(Operand->IgnoreParens())) {
5536 return std::nullopt;
5545std::optional<LValue> HandleConditionalOperatorLValueSimpleCase(
5547 const Expr *condExpr = E->
getCond();
5552 std::swap(Live, Dead);
5561 if (
auto *ThrowExpr = dyn_cast<CXXThrowExpr>(Live->
IgnoreParens())) {
5572 return std::nullopt;
5574struct ConditionalInfo {
5575 llvm::BasicBlock *lhsBlock, *rhsBlock;
5576 std::optional<LValue> LHS, RHS;
5581template<
typename FuncTy>
5583 const AbstractConditionalOperator *E,
5584 const FuncTy &BranchGenFunc) {
5600 Info.lhsBlock = CGF.
Builder.GetInsertBlock();
5603 CGF.
Builder.CreateBr(endBlock);
5610 Info.rhsBlock = CGF.
Builder.GetInsertBlock();
5622 "Unexpected conditional operator!");
5627 if (HandleConditionalOperatorLValueSimpleCase(*
this, E))
5630 EmitConditionalBlocks(*
this, E, [](CodeGenFunction &CGF,
const Expr *E) {
5637 if (!
expr->isGLValue()) {
5640 "Unexpected conditional operator!");
5645 if (std::optional<LValue> Res =
5646 HandleConditionalOperatorLValueSimpleCase(*
this,
expr))
5649 ConditionalInfo Info = EmitConditionalBlocks(
5650 *
this,
expr, [](CodeGenFunction &CGF,
const Expr *E) {
5654 if ((Info.LHS && !Info.LHS->isSimple()) ||
5655 (Info.RHS && !Info.RHS->isSimple()))
5658 if (Info.LHS && Info.RHS) {
5659 Address lhsAddr = Info.LHS->getAddress();
5660 Address rhsAddr = Info.RHS->getAddress();
5662 lhsAddr, rhsAddr, Info.lhsBlock, Info.rhsBlock,
5665 std::max(Info.LHS->getBaseInfo().getAlignmentSource(),
5666 Info.RHS->getBaseInfo().getAlignmentSource());
5668 Info.LHS->getTBAAInfo(), Info.RHS->getTBAAInfo());
5672 assert((Info.LHS || Info.RHS) &&
5673 "both operands of glvalue conditional are throw-expressions?");
5674 return Info.LHS ? *Info.LHS : *Info.RHS;
5686 auto RestoreCurCast =
5687 llvm::make_scope_exit([
this, Prev =
CurCast] {
CurCast = Prev; });
5692 case CK_LValueToRValueBitCast:
5693 case CK_ArrayToPointerDecay:
5694 case CK_FunctionToPointerDecay:
5695 case CK_NullToMemberPointer:
5696 case CK_NullToPointer:
5697 case CK_IntegralToPointer:
5698 case CK_PointerToIntegral:
5699 case CK_PointerToBoolean:
5700 case CK_IntegralCast:
5701 case CK_BooleanToSignedIntegral:
5702 case CK_IntegralToBoolean:
5703 case CK_IntegralToFloating:
5704 case CK_FloatingToIntegral:
5705 case CK_FloatingToBoolean:
5706 case CK_FloatingCast:
5707 case CK_FloatingRealToComplex:
5708 case CK_FloatingComplexToReal:
5709 case CK_FloatingComplexToBoolean:
5710 case CK_FloatingComplexCast:
5711 case CK_FloatingComplexToIntegralComplex:
5712 case CK_IntegralRealToComplex:
5713 case CK_IntegralComplexToReal:
5714 case CK_IntegralComplexToBoolean:
5715 case CK_IntegralComplexCast:
5716 case CK_IntegralComplexToFloatingComplex:
5717 case CK_DerivedToBaseMemberPointer:
5718 case CK_BaseToDerivedMemberPointer:
5719 case CK_MemberPointerToBoolean:
5720 case CK_ReinterpretMemberPointer:
5721 case CK_AnyPointerToBlockPointerCast:
5722 case CK_ARCProduceObject:
5723 case CK_ARCConsumeObject:
5724 case CK_ARCReclaimReturnedObject:
5725 case CK_ARCExtendBlockObject:
5726 case CK_CopyAndAutoreleaseBlockObject:
5727 case CK_IntToOCLSampler:
5728 case CK_FloatingToFixedPoint:
5729 case CK_FixedPointToFloating:
5730 case CK_FixedPointCast:
5731 case CK_FixedPointToBoolean:
5732 case CK_FixedPointToIntegral:
5733 case CK_IntegralToFixedPoint:
5735 case CK_HLSLVectorTruncation:
5736 case CK_HLSLArrayRValue:
5737 case CK_HLSLElementwiseCast:
5738 case CK_HLSLAggregateSplatCast:
5742 llvm_unreachable(
"dependent cast kind in IR gen!");
5744 case CK_BuiltinFnToFnPtr:
5745 llvm_unreachable(
"builtin functions are handled elsewhere");
5748 case CK_NonAtomicToAtomic:
5749 case CK_AtomicToNonAtomic:
5759 case CK_ConstructorConversion:
5760 case CK_UserDefinedConversion:
5761 case CK_CPointerToObjCPointerCast:
5762 case CK_BlockPointerToObjCPointerCast:
5763 case CK_LValueToRValue:
5778 if (
V.getElementType() !=
T)
5785 case CK_UncheckedDerivedToBase:
5786 case CK_DerivedToBase: {
5800 CGM.getTBAAInfoForSubobject(LV, E->
getType()));
5804 case CK_BaseToDerived: {
5819 if (
SanOpts.has(SanitizerKind::CFIDerivedCast))
5825 CGM.getTBAAInfoForSubobject(LV, E->
getType()));
5827 case CK_LValueBitCast: {
5831 CGM.EmitExplicitCastExprType(CE,
this);
5836 if (
SanOpts.has(SanitizerKind::CFIUnrelatedCast))
5842 CGM.getTBAAInfoForSubobject(LV, E->
getType()));
5844 case CK_AddressSpaceConversion: {
5854 case CK_ObjCObjectLValueCast: {
5858 CGM.getTBAAInfoForSubobject(LV, E->
getType()));
5860 case CK_ZeroToOCLOpaqueType:
5861 llvm_unreachable(
"NULL to OpenCL opaque type lvalue cast is not valid");
5863 case CK_VectorSplat: {
5871 llvm_unreachable(
"Unhandled lvalue cast kind?");
5879std::pair<LValue, LValue>
5894 return std::make_pair(BaseLV, TempLV);
5902 llvm::Value *
Addr = TempLV.getAddress().getBasePointer();
5907 Address TmpAddr(
Addr, ElTy, TempLV.getAlignment());
5917 llvm::DenseMap<const OpaqueValueExpr*,LValue>::iterator
5918 it = OpaqueLValues.find(e);
5920 if (it != OpaqueLValues.end())
5923 assert(e->
isUnique() &&
"LValue for a nonunique OVE hasn't been emitted");
5931 llvm::DenseMap<const OpaqueValueExpr*,RValue>::iterator
5932 it = OpaqueRValues.find(e);
5934 if (it != OpaqueRValues.end())
5937 assert(e->
isUnique() &&
"RValue for a nonunique OVE hasn't been emitted");
5943 return OpaqueLValues.contains(E);
5944 return OpaqueRValues.contains(E);
5968 llvm_unreachable(
"bad evaluation kind");
5977 llvm::CallBase **CallOrInvoke) {
5978 llvm::CallBase *CallOrInvokeStorage;
5979 if (!CallOrInvoke) {
5980 CallOrInvoke = &CallOrInvokeStorage;
5983 auto AddCoroElideSafeOnExit = llvm::make_scope_exit([&] {
5985 auto *I = *CallOrInvoke;
5987 I->addFnAttr(llvm::Attribute::CoroElideSafe);
5995 if (
const auto *CE = dyn_cast<CXXMemberCallExpr>(E))
5998 if (
const auto *CE = dyn_cast<CUDAKernelCallExpr>(E))
6003 if (
const auto *CE = dyn_cast<CXXOperatorCallExpr>(E))
6004 if (
const auto *MD =
6005 dyn_cast_if_present<CXXMethodDecl>(CE->getCalleeDecl());
6006 MD && MD->isImplicitObjectMemberFunction())
6021 nullptr, CallOrInvoke);
6027 llvm::CallBase **CallOrInvoke) {
6030 nullptr, CallOrInvoke);
6038 if (!PD->isInlineBuiltinDeclaration())
6047 std::string NoBuiltinFD = (
"no-builtin-" + FD->
getName()).str();
6048 std::string NoBuiltins =
"no-builtins";
6051 std::string FDInlineName = (Ident +
".inline").str();
6053 bool IsPredefinedLibFunction =
6055 bool HasAttributeNoBuiltin =
6056 CGF.
CurFn->getAttributes().hasFnAttr(NoBuiltinFD) ||
6057 CGF.
CurFn->getAttributes().hasFnAttr(NoBuiltins);
6061 if (CGF.
CurFn->getName() != FDInlineName &&
6064 llvm::Function *Fn = llvm::cast<llvm::Function>(CalleePtr);
6065 llvm::Module *M = Fn->getParent();
6066 llvm::Function *Clone = M->getFunction(FDInlineName);
6068 Clone = llvm::Function::Create(Fn->getFunctionType(),
6069 llvm::GlobalValue::InternalLinkage,
6070 Fn->getAddressSpace(), FDInlineName, M);
6071 Clone->addFnAttr(llvm::Attribute::AlwaysInline);
6082 else if (!IsPredefinedLibFunction || !HasAttributeNoBuiltin)
6088 FD->
hasAttr<CUDAGlobalAttr>())
6096 if (DeviceKernelAttr::isOpenCLSpelling(FD->
getAttr<DeviceKernelAttr>()))
6105 if (
auto ICE = dyn_cast<ImplicitCastExpr>(E)) {
6106 if (ICE->getCastKind() == CK_FunctionToPointerDecay ||
6107 ICE->getCastKind() == CK_BuiltinFnToFnPtr) {
6113 if (ICE->getCastKind() == CK_LValueToRValue) {
6114 const Expr *SubExpr = ICE->getSubExpr();
6116 std::pair<llvm::Value *, CGPointerAuthInfo>
Result =
6123 if (
const auto *VD =
6134 }
else if (
auto DRE = dyn_cast<DeclRefExpr>(E)) {
6135 if (
auto FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
6138 }
else if (
auto ME = dyn_cast<MemberExpr>(E)) {
6139 if (
auto FD = dyn_cast<FunctionDecl>(ME->getMemberDecl())) {
6145 }
else if (
auto NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
6149 }
else if (
auto PDE = dyn_cast<CXXPseudoDestructorExpr>(E)) {
6154 llvm::Value *calleePtr;
6166 if (
const auto *VD =
6172 CGCallee callee(calleeInfo, calleePtr, pointerAuth);
6188 assert(E->
getOpcode() == BO_Assign &&
"unexpected binary l-value");
6251 llvm::Value *
Result =
nullptr;
6254 if (
SanOpts.has(SanitizerKind::ImplicitBitfieldConversion))
6269 CGM.getOpenMPRuntime().checkAndEmitLastprivateConditional(*
this,
6286 llvm_unreachable(
"bad evaluation kind");
6302 llvm::CallBase **CallOrInvoke) {
6310 "Can't have a scalar return unless the return type is a "
6323 &&
"binding l-value to type which needs a temporary");
6361 "Can't have a scalar return unless the return type is a "
6375 return CGM.getObjCRuntime().EmitIvarOffset(*
this,
Interface, Ivar);
6383 return Builder.CreateZExtOrTrunc(OffsetValue,
6388 llvm::Value *BaseValue,
6390 unsigned CVRQualifiers) {
6391 return CGM.getObjCRuntime().EmitObjCValueForIvar(*
this, ObjectTy, BaseValue,
6392 Ivar, CVRQualifiers);
6397 llvm::Value *BaseValue =
nullptr;
6408 ObjectTy = BaseExpr->
getType();
6430 llvm::CallBase **CallOrInvoke,
6435 "Call must have function pointer type!");
6437 const Decl *TargetDecl =
6440 assert((!isa_and_present<FunctionDecl>(TargetDecl) ||
6442 "trying to emit a call to an immediate function");
6450 if (
SanOpts.has(SanitizerKind::Function) &&
6453 if (llvm::Constant *PrefixSig =
6454 CGM.getTargetCodeGenInfo().getUBSanFunctionSignature(
CGM)) {
6455 auto CheckOrdinal = SanitizerKind::SO_Function;
6456 auto CheckHandler = SanitizerHandler::FunctionTypeMismatch;
6460 llvm::Type *PrefixSigType = PrefixSig->getType();
6461 llvm::StructType *PrefixStructTy = llvm::StructType::get(
6462 CGM.getLLVMContext(), {PrefixSigType, Int32Ty},
true);
6464 llvm::Value *CalleePtr = Callee.getFunctionPointer();
6465 if (
CGM.getCodeGenOpts().PointerAuth.FunctionPointers) {
6468 Address(CalleePtr, CalleePtr->getType(),
6470 CalleePtr->getPointerAlignment(
CGM.getDataLayout())),
6471 Callee.getPointerAuthInfo(),
nullptr);
6472 CalleePtr =
Addr.emitRawPointer(*
this);
6484 llvm::Value *AlignedCalleePtr;
6485 if (
CGM.getTriple().isARM() ||
CGM.getTriple().isThumb()) {
6486 llvm::Value *CalleeAddress =
6488 llvm::Value *Mask = llvm::ConstantInt::get(
IntPtrTy, ~1);
6489 llvm::Value *AlignedCalleeAddress =
6490 Builder.CreateAnd(CalleeAddress, Mask);
6492 Builder.CreateIntToPtr(AlignedCalleeAddress, CalleePtr->getType());
6494 AlignedCalleePtr = CalleePtr;
6497 llvm::Value *CalleePrefixStruct = AlignedCalleePtr;
6498 llvm::Value *CalleeSigPtr =
6499 Builder.CreateConstGEP2_32(PrefixStructTy, CalleePrefixStruct, -1, 0);
6500 llvm::Value *CalleeSig =
6502 llvm::Value *CalleeSigMatch =
Builder.CreateICmpEQ(CalleeSig, PrefixSig);
6506 Builder.CreateCondBr(CalleeSigMatch, TypeCheck, Cont);
6509 llvm::Value *CalleeTypeHash =
Builder.CreateAlignedLoad(
6511 Builder.CreateConstGEP2_32(PrefixStructTy, CalleePrefixStruct, -1, 1),
6513 llvm::Value *CalleeTypeHashMatch =
6514 Builder.CreateICmpEQ(CalleeTypeHash, TypeHash);
6517 EmitCheck(std::make_pair(CalleeTypeHashMatch, CheckOrdinal), CheckHandler,
6518 StaticData, {CalleePtr});
6527 if (
const auto *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl);
6528 FD && DeviceKernelAttr::isOpenCLSpelling(FD->getAttr<DeviceKernelAttr>()))
6529 CGM.getTargetCodeGenInfo().setOCLKernelStubCallingConvention(FnType);
6536 if (
SanOpts.has(SanitizerKind::CFIICall) &&
6538 auto CheckOrdinal = SanitizerKind::SO_CFIICall;
6539 auto CheckHandler = SanitizerHandler::CFICheckFail;
6543 llvm::Metadata *MD =
6544 CGM.CreateMetadataIdentifierForFnType(
QualType(FnType, 0));
6546 llvm::Value *TypeId = llvm::MetadataAsValue::get(
getLLVMContext(), MD);
6548 llvm::Value *CalleePtr = Callee.getFunctionPointer();
6549 llvm::Value *TypeTest =
Builder.CreateCall(
6550 CGM.getIntrinsic(llvm::Intrinsic::type_test), {CalleePtr, TypeId});
6552 auto CrossDsoTypeId =
CGM.CreateCrossDsoCfiTypeId(MD);
6553 llvm::Constant *StaticData[] = {
6558 if (
CGM.getCodeGenOpts().SanitizeCfiCrossDso && CrossDsoTypeId) {
6562 EmitCheck(std::make_pair(TypeTest, CheckOrdinal), CheckHandler,
6563 StaticData, {CalleePtr, llvm::UndefValue::get(
IntPtrTy)});
6578 bool StaticOperator =
false;
6579 if (
auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) {
6580 if (OCE->isAssignmentOp())
6583 switch (OCE->getOperator()) {
6585 case OO_GreaterGreater:
6597 if (
const auto *MD =
6598 dyn_cast_if_present<CXXMethodDecl>(OCE->getCalleeDecl());
6599 MD && MD->isStatic())
6600 StaticOperator =
true;
6604 if (StaticOperator) {
6608 Arguments = drop_begin(Arguments, 1);
6610 EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), Arguments,
6614 Args, FnType, Chain);
6617 *ResolvedFnInfo = &FnInfo;
6622 if (
CGM.getLangOpts().HIP && !
CGM.getLangOpts().CUDAIsDevice &&
6625 llvm::Value *Handle = Callee.getFunctionPointer();
6627 Address(Handle, Handle->getType(),
CGM.getPointerAlign()));
6628 Callee.setFunctionPointer(
Stub);
6630 llvm::CallBase *LocalCallOrInvoke =
nullptr;
6634 if (
auto *CalleeDecl = dyn_cast_or_null<FunctionDecl>(TargetDecl)) {
6640 DI->EmitFuncDeclForCallSite(LocalCallOrInvoke,
6641 DI->getFunctionType(CalleeDecl, ResTy, Args),
6644 if (CalleeDecl->hasAttr<RestrictAttr>() ||
6645 CalleeDecl->hasAttr<AllocSizeAttr>()) {
6647 if (
SanOpts.has(SanitizerKind::AllocToken)) {
6654 *CallOrInvoke = LocalCallOrInvoke;
6673 bool IsInBounds = !
getLangOpts().PointerOverflowDefined &&
6676 E, BaseAddr, OffsetV, MPT, IsInBounds, &BaseInfo, &TBAAInfo);
6678 return MakeAddrLValue(MemberAddr, MPT->getPointeeType(), BaseInfo, TBAAInfo);
6695 llvm_unreachable(
"bad evaluation kind");
6699 assert(Val->getType()->isFPOrFPVectorTy());
6704 llvm::MDNode *Node = MDHelper.createFPMath(Accuracy);
6710 llvm::Type *EltTy = Val->getType()->getScalarType();
6711 if (!EltTy->isFloatTy())
6715 !
CGM.getCodeGenOpts().OpenCLCorrectlyRoundedDivSqrt) ||
6717 !
CGM.getCodeGenOpts().HIPCorrectlyRoundedDivSqrt)) {
6731 llvm::Type *EltTy = Val->getType()->getScalarType();
6732 if (!EltTy->isFloatTy())
6736 !
CGM.getCodeGenOpts().OpenCLCorrectlyRoundedDivSqrt) ||
6738 !
CGM.getCodeGenOpts().HIPCorrectlyRoundedDivSqrt)) {
6752 struct LValueOrRValue {
6766 LValueOrRValue result;
6770 const Expr *semantic = *i;
6774 if (
const auto *ov = dyn_cast<OpaqueValueExpr>(semantic)) {
6776 if (ov->isUnique()) {
6777 assert(ov != resultExpr &&
6778 "A unique OVE cannot be used as the result expression");
6786 if (ov == resultExpr && ov->
isPRValue() && !forLValue &&
6791 opaqueData = OVMA::bind(CGF, ov, LV);
6796 opaqueData = OVMA::bind(CGF, ov, ov->getSourceExpr());
6799 if (ov == resultExpr) {
6807 opaques.push_back(opaqueData);
6811 }
else if (semantic == resultExpr) {
6843 std::tuple<LValue, QualType, llvm::SmallVector<llvm::Value *, 4>>, 16>
6845 llvm::IntegerType *IdxTy = llvm::IntegerType::get(
getLLVMContext(), 32);
6846 WorkList.push_back({Val, Val.
getType(), {llvm::ConstantInt::get(IdxTy, 0)}});
6848 while (!WorkList.empty()) {
6849 auto [LVal,
T, IdxList] = WorkList.pop_back_val();
6850 T =
T.getCanonicalType().getUnqualifiedType();
6853 if (
const auto *CAT = dyn_cast<ConstantArrayType>(
T)) {
6854 uint64_t Size = CAT->getZExtSize();
6855 for (int64_t I = Size - 1; I > -1; I--) {
6857 IdxListCopy.push_back(llvm::ConstantInt::get(IdxTy, I));
6858 WorkList.emplace_back(LVal, CAT->getElementType(), IdxListCopy);
6860 }
else if (
const auto *RT = dyn_cast<RecordType>(
T)) {
6862 assert(!
Record->isUnion() &&
"Union types not supported in flat cast.");
6867 std::tuple<LValue, QualType, llvm::SmallVector<llvm::Value *, 4>>, 16>
6876 "HLSL doesn't support multiple inheritance.");
6879 IdxListCopy.push_back(llvm::ConstantInt::get(
6881 ReverseList.emplace_back(LVal,
Base->getType(), IdxListCopy);
6890 bool createdGEP =
false;
6891 for (
auto *FD :
Record->fields()) {
6892 if (FD->isBitField()) {
6893 if (FD->isUnnamedBitField())
6897 Address GEP =
Builder.CreateInBoundsGEP(LVal.getAddress(), IdxList,
6898 LLVMT, Align,
"gep");
6902 ReverseList.push_back({FieldLVal, FD->
getType(), {}});
6905 IdxListCopy.push_back(
6907 ReverseList.emplace_back(LVal, FD->getType(), IdxListCopy);
6911 std::reverse(ReverseList.begin(), ReverseList.end());
6912 llvm::append_range(WorkList, ReverseList);
6913 }
else if (
const auto *VT = dyn_cast<VectorType>(
T)) {
6916 Address GEP =
Builder.CreateInBoundsGEP(LVal.getAddress(), IdxList, LLVMT,
6917 Align,
"vector.gep");
6919 for (
unsigned I = 0, E = VT->getNumElements(); I < E; I++) {
6920 llvm::Constant *Idx = llvm::ConstantInt::get(IdxTy, I);
6924 AccessList.emplace_back(LV);
6927 if (!IdxList.empty()) {
6930 Address GEP =
Builder.CreateInBoundsGEP(LVal.getAddress(), IdxList,
6931 LLVMT, Align,
"gep");
6934 AccessList.emplace_back(LVal);
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
Defines enum values for all the target-independent builtin functions.
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 bool getFieldOffsetInBits(CodeGenFunction &CGF, const RecordDecl *RD, const FieldDecl *Field, int64_t &Offset)
The offset of a field from the beginning of the record.
static bool hasBPFPreserveStaticOffset(const RecordDecl *D)
ConstantEmissionKind
Can we constant-emit a load of a reference to a variable of the given type?
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 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 CheckRecoverableKind getRecoverableKind(SanitizerKind::SanitizerOrdinal Ordinal)
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")
SmallVector< llvm::Value *, 8 > RecIndicesTy
static GlobalDecl getGlobalDeclForDirectCall(const FunctionDecl *FD)
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 llvm::StringRef GetUBSanTrapForHandler(SanitizerHandler ID)
static llvm::Value * getArrayIndexingBound(CodeGenFunction &CGF, const Expr *Base, QualType &IndexedType, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel)
If Base is known to point to the start of an array, return the length of that array.
static RValue EmitLoadOfMatrixLValue(LValue LV, SourceLocation Loc, CodeGenFunction &CGF)
static ConstantEmissionKind checkVarTypeForConstantEmission(QualType type)
static Address emitAddrOfZeroSizeField(CodeGenFunction &CGF, Address Base, const FieldDecl *Field, bool IsInBounds)
Get the address of a zero-sized field within a record.
static QualType getConstantExprReferredType(const FullExpr *E, const ASTContext &Ctx)
static Address emitAddrOfFieldStorage(CodeGenFunction &CGF, Address base, const FieldDecl *field, bool IsInBounds)
Drill down to the storage of a field without walking into reference types.
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 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)
VariableTypeDescriptorKind
@ TK_Float
A floating-point type.
@ TK_Unknown
Any other type. The value representation is unspecified.
@ TK_Integer
An integer type.
@ TK_BitInt
An _BitInt(N) type.
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 void emitCheckHandlerCall(CodeGenFunction &CGF, llvm::FunctionType *FnType, ArrayRef< llvm::Value * > FnArgs, SanitizerHandler CheckHandler, CheckRecoverableKind RecoverKind, bool IsFatal, llvm::BasicBlock *ContBB, bool NoMerge)
static Address emitOMPArraySectionBase(CodeGenFunction &CGF, const Expr *Base, LValueBaseInfo &BaseInfo, TBAAAccessInfo &TBAAInfo, QualType BaseTy, QualType ElTy, bool IsLowerBound)
static mlir::Value emitPointerArithmetic(CIRGenFunction &cgf, const BinOpInfo &op, bool isSubtraction)
Emit pointer + index arithmetic.
static Address createReferenceTemporary(CIRGenFunction &cgf, const MaterializeTemporaryExpr *m, const Expr *inner)
static bool isAAPCS(const TargetInfo &targetInfo)
Helper method to check if the underlying ABI is AAPCS.
static CharUnits getArrayElementAlign(CharUnits arrayAlign, mlir::Value idx, CharUnits eltSize)
static void pushTemporaryCleanup(CIRGenFunction &cgf, const MaterializeTemporaryExpr *m, const Expr *e, Address referenceTemporary)
static QualType getFixedSizeElementType(const ASTContext &astContext, const VariableArrayType *vla)
static bool canEmitSpuriousReferenceToVariable(CIRGenFunction &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 DeclRefExpr * tryToConvertMemberExprToDeclRefExpr(CIRGenFunction &cgf, const MemberExpr *me)
static unsigned getCharWidth(tok::TokenKind kind, const TargetInfo &Target)
llvm::MachO::Record Record
Defines the clang::Module class, which describes a module in the source code.
static const SanitizerMask AlwaysRecoverable
static const SanitizerMask Unrecoverable
#define LIST_SANITIZER_CHECKS
Defines the SourceManager interface.
static QualType getPointeeType(const MemRegion *R)
a trap message and trap category.
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.
static CanQualType getCanonicalType(QualType T)
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
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>.
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.
CanQualType getCanonicalTagType(const TagDecl *TD) const
unsigned getTargetAddressSpace(LangAS AS) const
bool isSentinelNullExpr(const Expr *E)
uint64_t getCharWidth() const
Return the size of the character type, in bits.
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
Expr * getCond() const
getCond - Return the expression representing the condition for the ?
Expr * getTrueExpr() const
getTrueExpr - Return the subexpression representing the value of the expression if the condition eval...
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression representing the value of the expression if the condition eva...
This class represents BOTH the OpenMP Array Section and OpenACC 'subarray', with a boolean differenti...
Expr * getBase()
Get base of the array section.
Expr * getLength()
Get length of array section.
static QualType getBaseOriginalType(const Expr *Base)
Return original type of the base expression for array section.
SourceLocation getExprLoc() const LLVM_READONLY
Expr * getLowerBound()
Get lower bound of array section.
bool isOpenACCArraySection() const
SourceLocation getColonLocFirst() const
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
SourceLocation getExprLoc() const LLVM_READONLY
Expr * getLHS()
An array access can be written A[4] or 4[A] (both are equivalent).
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
A builtin binary operation expression such as "x + y" or "x <= y".
SourceLocation getExprLoc() const
static bool isAdditiveOp(Opcode Opc)
A fixed int type of a specified bitwidth.
unsigned getNumBits() const
bool isPredefinedLibFunction(unsigned ID) const
Determines whether this builtin is a predefined libc/libm function, such as "malloc",...
Represents binding an expression to a temporary.
CXXTemporary * getTemporary()
const Expr * getSubExpr() const
Represents a call to a C++ constructor.
Represents a C++ destructor within a class.
Represents a C++ struct/union/class.
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
bool isStandardLayout() const
Determine whether this class is standard-layout per C++ [class]p7.
unsigned getNumBases() const
Retrieves the number of base classes of this class.
base_class_iterator bases_begin()
bool isDynamicClass() const
bool hasDefinition() const
const CXXRecordDecl * getStandardLayoutBaseWithFields() const
If this is a standard-layout class or union, any and all data members will be declared in the same ty...
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
MSGuidDecl * getGuidDecl() const
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
SourceLocation getBeginLoc() const
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
bool isCoroElideSafe() const
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
path_iterator path_begin()
CastKind getCastKind() const
bool changesVolatileQualification() const
Return.
CharUnits - This is an opaque type for sizes expressed in character units.
CharUnits alignmentAtOffset(CharUnits offset) const
Given that this is a non-zero alignment value, what is the alignment at the given offset?
llvm::MaybeAlign getAsMaybeAlign() const
getAsMaybeAlign - Returns Quantity as a valid llvm::Align or std::nullopt, Beware llvm::MaybeAlign as...
llvm::Align getAsAlign() const
getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
static CharUnits One()
One - Construct a CharUnits quantity of one.
CharUnits alignmentOfArrayElement(CharUnits elementSize) const
Given that this is the alignment of the first element of an array, return the minimum alignment of an...
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
@ None
Trap Messages are omitted.
@ Detailed
Trap Message includes more context (e.g.
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.
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 forLValue(const LValue &LV, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)
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 source atom group for CGDebugInfo::addInstToCurrentSourceAtom.
A scoped helper to set the current debug location to the specified location or preferred location of ...
static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF)
Apply TemporaryLocation if it is valid.
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 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 CreateConstByteGEP(Address Addr, CharUnits Offset, const llvm::Twine &Name="")
Address CreatePreserveStructAccessIndex(Address Addr, unsigned Index, unsigned FieldIndex, llvm::MDNode *DbgInfo)
Address CreateAddrSpaceCast(Address Addr, llvm::Type *Ty, llvm::Type *ElementTy, const llvm::Twine &Name="")
virtual llvm::Function * getKernelStub(llvm::GlobalValue *Handle)=0
Get kernel stub by kernel handle.
virtual void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D, llvm::FunctionCallee Dtor, llvm::Constant *Addr)=0
Emit code to force the execution of a destructor during global teardown.
virtual 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
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::DILocation * CreateTrapFailureMessageFor(llvm::DebugLoc TrapLocation, StringRef Category, StringRef FailureMsg)
Create a debug location from TrapLocation that adds an artificial inline frame where the frame name i...
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 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.
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 addWriteback(LValue srcLV, Address temporary, llvm::Value *toUse, const Expr *writebackExpr=nullptr)
void add(RValue rvalue, QualType type)
The scope of a CXXDefaultInitExpr.
An object to manage conditionally-evaluated expressions.
llvm::BasicBlock * getStartingBlock() const
Returns a block which will be executed prior to each evaluation of the conditional code.
static ConstantEmission forValue(llvm::Constant *C)
static ConstantEmission forReference(llvm::Constant *C)
LValue getReferenceLValue(CodeGenFunction &CGF, const Expr *RefExpr) const
llvm::Constant * getValue() const
A non-RAII class containing all the information about a bound opaque value.
static bool shouldBindAsLValue(const Expr *expr)
static OpaqueValueMappingData bind(CodeGenFunction &CGF, const OpaqueValueExpr *ov, const Expr *e)
An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
static bool shouldBindAsLValue(const Expr *expr)
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited.
RAII object to set/unset CodeGenFunction::IsSanitizerScope.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
LValue EmitMatrixSubscriptExpr(const MatrixSubscriptExpr *E)
LValue EmitCoawaitLValue(const CoawaitExpr *E)
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.
llvm::Value * EmitObjCConsumeObject(QualType T, llvm::Value *Ptr)
Produce the code for a CK_ARCConsumeObject.
LValue EmitLoadOfReferenceLValue(LValue RefLVal)
void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount, Stmt::Likelihood LH=Stmt::LH_None, const Expr *ConditionalOp=nullptr, const VarDecl *ConditionalDecl=nullptr)
EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g.
RValue EmitObjCMessageExpr(const ObjCMessageExpr *E, ReturnValueSlot Return=ReturnValueSlot())
llvm::Value * emitBoolVecConversion(llvm::Value *SrcVec, unsigned NumElementsDst, const llvm::Twine &Name="")
void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest)
LValue EmitCXXConstructLValue(const CXXConstructExpr *E)
LValue EmitConditionalOperatorLValue(const AbstractConditionalOperator *E)
std::pair< LValue, llvm::Value * > EmitARCStoreAutoreleasing(const BinaryOperator *e)
ComplexPairTy EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV, bool isInc, bool isPre)
void SetDivFPAccuracy(llvm::Value *Val)
Set the minimum required accuracy of the given sqrt operation based on CodeGenOpts.
SanitizerSet SanOpts
Sanitizers enabled for this function.
LValue EmitInitListLValue(const InitListExpr *E)
bool isUnderlyingBasePointerConstantNull(const Expr *E)
Check whether the underlying base pointer is a constant null.
void EmitARCInitWeak(Address addr, llvm::Value *value)
i8* @objc_initWeak(i8** addr, i8* value) Returns value.
RawAddress CreateIRTemp(QualType T, const Twine &Name="tmp")
CreateIRTemp - Create a temporary IR object of the given type, with appropriate alignment.
LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E, bool Accessed=false)
Address LoadCXXThisAddress()
static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts=false)
ContainsLabel - Return true if the statement contains a label in it.
LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E)
llvm::Value * GetCountedByFieldExprGEP(const Expr *Base, const FieldDecl *FD, const FieldDecl *CountDecl)
void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit)
EmitComplexExprIntoLValue - Emit the given expression of complex type and place its result into the s...
const CastExpr * CurCast
If a cast expression is being visited, this holds the current cast's expression.
llvm::Type * ConvertType(QualType T)
Address EmitCXXUuidofExpr(const CXXUuidofExpr *E)
void EmitSanitizerStatReport(llvm::SanitizerStatKind SSK)
static Destroyer destroyARCWeak
CGCapturedStmtInfo * CapturedStmtInfo
RValue EmitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E)
ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc)
EmitLoadOfComplex - Load a complex number from the specified l-value.
bool inSuspendBlock() const
llvm::Value * EmitARCRetain(QualType type, llvm::Value *value)
Produce the code to do a retain.
llvm::Value * EmitPointerAuthQualify(PointerAuthQualifier Qualifier, llvm::Value *Pointer, QualType ValueType, Address StorageAddress, bool IsKnownNonNull)
CleanupKind getARCCleanupKind()
Retrieves the default cleanup kind for an ARC cleanup.
void EmitAggFinalDestCopy(QualType Type, AggValueSlot Dest, const LValue &Src, ExprValueKind SrcKind)
EmitAggFinalDestCopy - Emit copy of the specified aggregate into destination address.
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 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 ...
void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst)
RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke)
LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E)
void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)
LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E)
RValue convertTempToRValue(Address addr, QualType type, SourceLocation Loc)
Given the address of a temporary variable, produce an r-value of its type.
LValue EmitObjCIsaExpr(const ObjCIsaExpr *E)
void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, llvm::Value **Result=nullptr)
EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints as EmitStoreThroughLValue.
llvm::Constant * EmitCheckSourceLocation(SourceLocation Loc)
Emit a description of a source location in a format suitable for passing to a runtime sanitizer handl...
LValue EmitCXXUuidofLValue(const CXXUuidofExpr *E)
llvm::Value * EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, bool isInc, bool isPre)
void SetSqrtFPAccuracy(llvm::Value *Val)
Set the minimum required accuracy of the given sqrt operation based on CodeGenOpts.
RValue EmitSimpleCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke=nullptr)
Emit a CallExpr without considering whether it might be a subclass.
static bool isNullPointerAllowed(TypeCheckKind TCK)
Determine whether the pointer type check TCK permits null pointers.
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.
RValue EmitPseudoObjectRValue(const PseudoObjectExpr *e, AggValueSlot slot=AggValueSlot::ignored())
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
void addInstToCurrentSourceAtom(llvm::Instruction *KeyInstruction, llvm::Value *Backup)
See CGDebugInfo::addInstToCurrentSourceAtom.
unsigned getDebugInfoFIndex(const RecordDecl *Rec, unsigned FieldIndex)
Get the record field index as represented in debug info.
const LangOptions & getLangOpts() const
void EmitCfiCheckFail()
Emit a cross-DSO CFI failure handling function.
RValue EmitReferenceBindingToExpr(const Expr *E)
Emits a reference binding to the passed in expression.
llvm::Value * EmitARCStoreStrong(LValue lvalue, llvm::Value *value, bool resultIgnored)
Store into a strong object.
LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E)
LValue EmitLValueForIvar(QualType ObjectTy, llvm::Value *Base, const ObjCIvarDecl *Ivar, unsigned CVRQualifiers)
Address GetAddressOfDerivedClass(Address Value, const CXXRecordDecl *Derived, CastExpr::path_const_iterator PathBegin, CastExpr::path_const_iterator PathEnd, bool NullCheckValue)
void EmitIgnoredConditionalOperator(const AbstractConditionalOperator *E)
Address EmitFieldAnnotations(const FieldDecl *D, Address V)
Emit field annotations for the given field & value.
void pushDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)
pushDestroy - Push the standard destructor for the given type as at least a normal cleanup.
void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
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.
llvm::Value * EmitPointerAuthUnqualify(PointerAuthQualifier Qualifier, llvm::Value *Pointer, QualType PointerType, Address StorageAddress, bool IsKnownNonNull)
void EmitDeclRefExprDbgValue(const DeclRefExpr *E, const APValue &Init)
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.
static Destroyer destroyCXXObject
Address EmitLoadOfPointer(Address Ptr, const PointerType *PtrTy, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
Load a pointer with type PtrTy stored at address Ptr.
RValue EmitLoadOfGlobalRegLValue(LValue LV)
Load of global named registers are always calls to intrinsics.
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.
TypeCheckKind
Situations in which we might emit a check for the suitability of a pointer or glvalue.
@ 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.
LValue EmitBinaryOperatorLValue(const BinaryOperator *E)
bool InNoMergeAttributedStmt
True if the current statement has nomerge attribute.
LValue EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E)
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
llvm::AssertingVH< llvm::Instruction > AllocaInsertPt
AllocaInsertPoint - This is an instruction in the entry block before which we prefer to insert alloca...
void maybeAttachRangeForLoad(llvm::LoadInst *Load, QualType Ty, SourceLocation Loc)
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.
LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e)
llvm::Constant * EmitCheckTypeDescriptor(QualType T)
Emit a description of a type in a format suitable for passing to a runtime sanitizer handler.
void EmitBoundsCheckImpl(const Expr *E, llvm::Value *Bound, llvm::Value *Index, QualType IndexType, QualType IndexedType, bool Accessed)
LValue EmitOpaqueValueLValue(const OpaqueValueExpr *e)
llvm::Value * LoadPassedObjectSize(const Expr *E, QualType EltTy)
If E references a parameter with pass_object_size info or a constant array size modifier,...
@ ForceLeftToRight
! Language semantics require left-to-right evaluation.
@ Default
! No language constraints on evaluation order.
@ ForceRightToLeft
! Language semantics require right-to-left evaluation.
llvm::Value * EmitIvarOffsetAsPointerDiff(const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)
RValue EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke)
RValue EmitLoadOfAnyValue(LValue V, AggValueSlot Slot=AggValueSlot::ignored(), SourceLocation Loc={})
Like EmitLoadOfLValue but also handles complex and aggregate types.
LValue EmitLValueForField(LValue Base, const FieldDecl *Field, bool IsInBounds=true)
RawAddress CreateDefaultAlignTempAlloca(llvm::Type *Ty, const Twine &Name="tmp")
CreateDefaultAlignedTempAlloca - This creates an alloca with the default ABI alignment of the given L...
const TargetInfo & getTarget() const
LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E)
bool isInConditionalBranch() const
isInConditionalBranch - Return true if we're currently emitting one branch or the other of a conditio...
Address EmitCXXMemberDataPointerAddress(const Expr *E, Address base, llvm::Value *memberPtr, const MemberPointerType *memberPtrType, bool IsInBounds, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
Emit the address of a field using a member data pointer.
LValue EmitHLSLOutArgExpr(const HLSLOutArgExpr *E, CallArgList &Args, QualType Ty)
static bool isVptrCheckRequired(TypeCheckKind TCK, QualType Ty)
Determine whether the pointer type check TCK requires a vptr check.
CGCallee EmitCallee(const Expr *E)
void EmitIgnoredExpr(const Expr *E)
EmitIgnoredExpr - Emit an expression in a context which ignores the result.
RValue EmitCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue=ReturnValueSlot(), llvm::CallBase **CallOrInvoke=nullptr)
RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)
EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...
LValue EmitArraySectionExpr(const ArraySectionExpr *E, bool IsLowerBound=true)
Address GetAddrOfBlockDecl(const VarDecl *var)
llvm::Value * EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy, QualType DstTy, SourceLocation Loc)
Emit a conversion from the specified complex type to the specified destination type,...
void pushCleanupAfterFullExpr(CleanupKind Kind, As... A)
Queue a cleanup to be pushed after finishing the current full-expression, potentially with an active ...
void EmitCfiCheckStub()
Emit a stub for the cross-DSO CFI check function.
void pushFullExprCleanup(CleanupKind kind, As... A)
pushFullExprCleanup - Push a cleanup to be run at the end of the current full-expression.
static Destroyer destroyARCStrongImprecise
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.
LValue EmitAggExprToLValue(const Expr *E)
EmitAggExprToLValue - Emit the computation of the specified expression of aggregate type into a tempo...
void SetFPAccuracy(llvm::Value *Val, float Accuracy)
SetFPAccuracy - Set the minimum required accuracy of the given floating point operation,...
Address mergeAddressesInConditionalExpr(Address LHS, Address RHS, llvm::BasicBlock *LHSBlock, llvm::BasicBlock *RHSBlock, llvm::BasicBlock *MergeBlock, QualType MergedType)
Address emitAddrOfImagComponent(Address complex, QualType complexType)
llvm::Value * EvaluateExprAsBool(const Expr *E)
EvaluateExprAsBool - Perform the usual unary conversions on the specified expression and compare the ...
LValue EmitPredefinedLValue(const PredefinedExpr *E)
void EmitCheck(ArrayRef< std::pair< llvm::Value *, SanitizerKind::SanitizerOrdinal > > Checked, SanitizerHandler Check, ArrayRef< llvm::Constant * > StaticArgs, ArrayRef< llvm::Value * > DynamicArgs, const TrapReason *TR=nullptr)
Create a basic block that will either trap or call a handler function in the UBSan runtime with the p...
LValue EmitDeclRefLValue(const DeclRefExpr *E)
LValue EmitStringLiteralLValue(const StringLiteral *E)
AggValueSlot CreateAggTemp(QualType T, const Twine &Name="tmp", RawAddress *Alloca=nullptr)
CreateAggTemp - Create a temporary memory object for the given aggregate type.
RValue getOrCreateOpaqueRValueMapping(const OpaqueValueExpr *e)
Given an opaque value expression, return its RValue mapping if it exists, otherwise create one.
RValue EmitAtomicLoad(LValue LV, SourceLocation SL, AggValueSlot Slot=AggValueSlot::ignored())
CGDebugInfo * getDebugInfo()
llvm::Value * emitScalarConstant(const ConstantEmission &Constant, Expr *E)
llvm::Value * getTypeSize(QualType Ty)
Returns calculated size of the specified type.
bool EmitLifetimeStart(llvm::Value *Addr)
Emit a lifetime.begin marker if some criteria are satisfied.
LValue EmitUnsupportedLValue(const Expr *E, const char *Name)
EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue an ErrorUnsupported style ...
LValue MakeRawAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment, AlignmentSource Source=AlignmentSource::Type)
Same as MakeAddrLValue above except that the pointer is known to be unsigned.
llvm::MDNode * buildAllocToken(QualType AllocType)
Build metadata used by the AllocToken instrumentation.
RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke=nullptr)
LValue EmitLValueForFieldInitialization(LValue Base, const FieldDecl *Field)
EmitLValueForFieldInitialization - Like EmitLValueForField, except that if the Field is a reference,...
llvm::Value * EmitToMemory(llvm::Value *Value, QualType Ty)
EmitToMemory - Change a scalar value from its value representation to its in-memory representation.
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...
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...
LValue getOrCreateOpaqueLValueMapping(const OpaqueValueExpr *e)
Given an opaque value expression, return its LValue mapping if it exists, otherwise create one.
bool EmitScalarRangeCheck(llvm::Value *Value, QualType Ty, SourceLocation Loc)
Check if the scalar Value is within the valid range for the given type Ty.
ComplexPairTy EmitComplexExpr(const Expr *E, bool IgnoreReal=false, bool IgnoreImag=false)
EmitComplexExpr - Emit the computation of the specified expression of complex type,...
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,...
const TargetCodeGenInfo & getTargetHooks() const
llvm::ConstantInt * getUBSanFunctionTypeHash(QualType T) const
Return a type hash constant for a function instrumented by -fsanitize=function.
LValue EmitHLSLArrayAssignLValue(const BinaryOperator *E)
RawAddress CreateMemTempWithoutCast(QualType T, const Twine &Name="tmp")
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen without...
void incrementProfileCounter(const Stmt *S, llvm::Value *StepV=nullptr)
Increment the profiler's counter for the given statement by StepV.
LValue EmitVAArgExprLValue(const VAArgExpr *E)
bool IsInPreservedAIRegion
True if CodeGen currently emits code inside presereved access index region.
RValue EmitAnyExprToTemp(const Expr *E)
EmitAnyExprToTemp - Similarly to EmitAnyExpr(), however, the result will always be accessible even if...
VlaSizePair getVLASize(const VariableArrayType *vla)
Returns an LLVM value that corresponds to the size, in non-variably-sized elements,...
LValue EmitStmtExprLValue(const StmtExpr *E)
llvm::Value * EmitARCLoadWeakRetained(Address addr)
i8* @objc_loadWeakRetained(i8** addr)
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
ASTContext & getContext() const
RawAddress CreateTempAllocaWithoutCast(llvm::Type *Ty, CharUnits align, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
CreateTempAlloca - This creates a alloca and inserts it into the entry block.
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 * 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...
void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty)
void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit)
EmitStoreOfComplex - Store a complex number into the specified l-value.
LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E)
void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)
EmitStoreThroughLValue - Store the specified rvalue into the specified lvalue, where both are guarant...
Address EmitArrayToPointerDecay(const Expr *Array, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
void pushLifetimeExtendedDestroy(CleanupKind kind, Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
RValue EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue)
RValue GetUndefRValue(QualType Ty)
GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
llvm::Instruction * getPostAllocaInsertPoint()
Return PostAllocaInsertPt.
void EmitAllocToken(llvm::CallBase *CB, QualType AllocType)
Emit and set additional metadata used by the AllocToken instrumentation.
LValue EmitComplexAssignmentLValue(const BinaryOperator *E)
Emit an l-value for an assignment (simple or compound) of complex type.
LValue EmitCastLValue(const CastExpr *E)
EmitCastLValue - Casts are never lvalues unless that cast is to a reference type.
llvm::Value * EmitPointerArithmetic(const BinaryOperator *BO, Expr *pointerOperand, llvm::Value *pointer, Expr *indexOperand, llvm::Value *index, bool isSubtraction)
Emit pointer + index arithmetic.
LValue EmitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E)
LValue EmitLoadOfPointerLValue(Address Ptr, const PointerType *PtrTy)
llvm::Value * EmitCheckValue(llvm::Value *V)
Convert a value into a format suitable for passing to a runtime sanitizer handler.
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...
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.
LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E)
llvm::DenseMap< const ValueDecl *, FieldDecl * > LambdaCaptureFields
RValue EmitUnsupportedRValue(const Expr *E, const char *Name)
EmitUnsupportedRValue - Emit a dummy r-value using the type of E and issue an ErrorUnsupported style ...
CleanupKind getCleanupKind(QualType::DestructionKind kind)
std::pair< LValue, LValue > EmitHLSLOutArgLValues(const HLSLOutArgExpr *E, QualType Ty)
LValue EmitObjCSelectorLValue(const ObjCSelectorExpr *E)
llvm::Type * ConvertTypeForMem(QualType T)
LValue EmitCallExprLValue(const CallExpr *E, llvm::CallBase **CallOrInvoke=nullptr)
RValue EmitLoadOfBitfieldLValue(LValue LV, SourceLocation Loc)
llvm::Value * EmitARCLoadWeak(Address addr)
i8* @objc_loadWeak(i8** addr) Essentially objc_autorelease(objc_loadWeakRetained(addr)).
LValue EmitLValueForLambdaField(const FieldDecl *Field)
void markStmtMaybeUsed(const Stmt *S)
CodeGenTypes & getTypes() const
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
llvm::Value * EmitIvarOffset(const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)
bool IsSanitizerScope
True if CodeGen currently emits code implementing sanitizer checks.
void FlattenAccessAndTypeLValue(LValue LVal, SmallVectorImpl< LValue > &AccessList)
LValue EmitCoyieldLValue(const CoyieldExpr *E)
void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, LValue LV, QualType Type, SanitizerSet SkippedChecks=SanitizerSet(), llvm::Value *ArraySize=nullptr)
void EmitCfiSlowPathCheck(SanitizerKind::SanitizerOrdinal Ordinal, 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.
llvm::SmallVector< const ParmVarDecl *, 4 > FnArgs
Save Parameter Decl for coroutine.
void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType, Address Ptr)
Emits all the code to cause the given temporary to be cleaned up.
llvm::Value * authPointerToPointerCast(llvm::Value *ResultPtr, QualType SourceType, QualType DestType)
LValue EmitUnaryOpLValue(const UnaryOperator *E)
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...
bool LValueIsSuitableForInlineAtomic(LValue Src)
An LValue is a candidate for having its loads and stores be made atomic if we are operating under /vo...
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...
Address EmitLoadOfReference(LValue RefLVal, LValueBaseInfo *PointeeBaseInfo=nullptr, TBAAAccessInfo *PointeeTBAAInfo=nullptr)
RValue EmitRValueForField(LValue LV, const FieldDecl *FD, SourceLocation Loc)
llvm::Value * EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr)
LValue EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E)
llvm::Type * convertTypeForLoadStore(QualType ASTTy, llvm::Type *LLVMTy=nullptr)
bool sanitizePerformTypeCheck() const
Whether any type-checking sanitizers are enabled.
Address EmitExtVectorElementLValue(LValue V)
Generates lvalue for partial ext_vector access.
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...
void EmitInitializationToLValue(const Expr *E, LValue LV, AggValueSlot::IsZeroed_t IsZeroed=AggValueSlot::IsNotZeroed)
EmitInitializationToLValue - Emit an initializer to an LValue.
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type.
Address emitAddrOfRealComponent(Address complex, QualType complexType)
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...
RValue EmitLoadOfExtVectorElementLValue(LValue V)
static bool hasAggregateEvaluationKind(QualType T)
static bool IsWrappedCXXThis(const Expr *E)
Check if E is a C++ "this" pointer wrapped in value-preserving casts.
void EmitCallArgs(CallArgList &Args, PrototypeWrapper Prototype, llvm::iterator_range< CallExpr::const_arg_iterator > ArgRange, AbstractCallee AC=AbstractCallee(), unsigned ParamsToSkip=0, EvaluationOrder Order=EvaluationOrder::Default)
EmitCallArgs - Emit call arguments for a function.
llvm::Value * EmitMatrixIndexExpr(const Expr *E)
llvm::CallInst * EmitTrapCall(llvm::Intrinsic::ID IntrID)
Emit a call to trap or debugtrap and attach function attribute "trap-func-name" if specified.
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
void EmitTrapCheck(llvm::Value *Checked, SanitizerHandler CheckHandlerID, bool NoMerge=false, const TrapReason *TR=nullptr)
Create a basic block that will call the trap intrinsic, and emit a conditional branch to it,...
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit)
llvm::Value * EmitFromMemory(llvm::Value *Value, QualType Ty)
EmitFromMemory - Change a scalar value from its memory representation to its value representation.
const CallExpr * MustTailCall
uint64_t getProfileCount(const Stmt *S)
Get the profiler's count for the given statement.
llvm::Value * EmitLoadOfCountedByField(const Expr *Base, const FieldDecl *FD, const FieldDecl *CountDecl)
Build an expression accessing the "counted_by" field.
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
void EmitUnreachable(SourceLocation Loc)
Emit a reached-unreachable diagnostic if Loc is valid and runtime checking is enabled.
bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result, bool AllowLabels=false)
ConstantFoldsToSimpleInteger - If the specified expression does not fold to a constant,...
void ErrorUnsupported(const Stmt *S, const char *Type)
ErrorUnsupported - Print out an error that codegen doesn't support the specified stmt yet.
LValue EmitCXXTypeidLValue(const CXXTypeidExpr *E)
llvm::Function * generateDestroyHelper(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray, const VarDecl *VD)
generateDestroyHelper - Generates a helper function which, when invoked, destroys the given object.
LValue EmitMemberExpr(const MemberExpr *E)
std::pair< llvm::Value *, llvm::Value * > ComplexPairTy
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
ConstantEmission tryEmitAsConstant(const DeclRefExpr *RefExpr)
Try to emit a reference to the given value without producing it as an l-value.
LValue EmitLValue(const Expr *E, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
EmitLValue - Emit code to compute a designator that specifies the location of the expression.
void EmitStoreThroughGlobalRegLValue(RValue Src, LValue Dst)
Store of global named registers are always calls to intrinsics.
bool isOpaqueValueEmitted(const OpaqueValueExpr *E)
isOpaqueValueEmitted - Return true if the opaque value expression has already been emitted.
std::pair< llvm::Value *, CGPointerAuthInfo > EmitOrigPointerRValue(const Expr *E)
Retrieve a pointer rvalue and its ptrauth info.
llvm::Value * EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored)
i8* @objc_storeWeak(i8** addr, i8* value) Returns value.
void EnsureInsertPoint()
EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go.
llvm::LLVMContext & getLLVMContext()
RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke)
static Destroyer destroyARCStrongPrecise
static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts)
getAccessedFieldNo - Given an encoded value and a result number, return the input field number being ...
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...
void EmitVariablyModifiedType(QualType Ty)
EmitVLASize - Capture all the sizes for the VLA expressions in the given variably-modified type and s...
static bool ShouldNullCheckClassCastValue(const CastExpr *Cast)
llvm::Value * EmitNonNullRValueCheck(RValue RV, QualType T)
Create a check that a scalar RValue is non-null.
void EmitCountedByBoundsChecking(const Expr *E, llvm::Value *Idx, Address Addr, QualType IdxTy, QualType ArrayTy, bool Accessed, bool FlexibleArray)
EmitCountedByBoundsChecking - If the array being accessed has a "counted_by" attribute,...
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...
llvm::Value * EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE)
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
LValue MakeNaturalAlignRawAddrLValue(llvm::Value *V, QualType T)
QualType BuildFunctionArgList(GlobalDecl GD, FunctionArgList &Args)
llvm::Value * EmitCXXTypeidExpr(const CXXTypeidExpr *E)
This class organizes the cross-function state that is used while generating LLVM code.
void EmitExplicitCastExprType(const ExplicitCastExpr *E, CodeGenFunction *CGF=nullptr)
Emit type info if type of an expression is a variably modified type.
llvm::Module & getModule() const
llvm::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()
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 * GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty=nullptr, bool ForVTable=false, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the given function.
llvm::Constant * getFunctionPointer(GlobalDecl GD, llvm::Type *Ty=nullptr)
Return the ABI-correct function pointer value for a reference to the given function.
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()
CGPointerAuthInfo getPointerAuthInfoForPointeeType(QualType type)
llvm::GlobalValue::LinkageTypes getLLVMLinkageVarDefinition(const VarDecl *VD)
Returns LLVM linkage for a declarator.
CGCXXABI & getCXXABI() const
ConstantAddress GetWeakRefReference(const ValueDecl *VD)
Get a reference to the target of VD.
CGOpenMPRuntime & getOpenMPRuntime()
Return a reference to the configured OpenMP runtime.
TBAAAccessInfo getTBAAAccessInfo(QualType AccessType)
getTBAAAccessInfo - Get TBAA information that describes an access to an object of the given type.
ASTContext & getContext() const
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.
const CodeGenOptions & getCodeGenOpts() const
StringRef getMangledName(GlobalDecl GD)
CharUnits getNaturalPointeeTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
llvm::LLVMContext & getLLVMContext()
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys={})
ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E, const Expr *Inner)
Returns a pointer to a global variable representing a temporary with static or thread storage duratio...
LangAS GetGlobalConstantAddressSpace() const
Return the AST address space of constant literal, which is used to emit the constant literal as globa...
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.
A specialization of Address that requires the address to be an LLVM Constant.
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.
FunctionArgList - Type for representing both the decl and type of parameters to a function.
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)
bool isObjCStrong() const
bool isGlobalObjCRef() const
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
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)
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.
CharUnits getAlignment() const
Return the alignment of this pointer.
llvm::Type * getElementType() const
Return the type of the values stored in this address.
llvm::Value * getPointer() const
unsigned getAddressSpace() const
Return the address space that this address resides in.
ReturnValueSlot - Contains the address where the return value of a function can be stored,...
Address performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, Address Addr, LangAS SrcAddr, llvm::Type *DestTy, bool IsNonNull=false) const
StringRef getCategory() const
StringRef getMessage() const
Complex values, per C99 6.2.5p11.
QualType getElementType() const
CompoundLiteralExpr - [C99 6.5.2.5].
const Expr * getInitializer() const
Represents a concrete matrix type with constant number of rows and columns.
unsigned getNumRows() const
Returns the number of rows in the matrix.
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
A reference to a declared variable, function, enum, etc.
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
SourceLocation getLocation() const
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()
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 isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
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 isOBJCGCCandidate(ASTContext &Ctx) const
isOBJCGCCandidate - Return true if this expression may be used in a read/ write barrier.
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
bool isArrow() const
isArrow - Return true if the base expression is a pointer to vector, return false if the base express...
void getEncodedElementAccess(SmallVectorImpl< uint32_t > &Elts) const
getEncodedElementAccess - Encode the elements accessed into an llvm aggregate Constant of ConstantInt...
const Expr * getBase() const
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
const FieldDecl * findCountedByField() const
Find the FieldDecl specified in a FAM's "counted_by" attribute.
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.
FunctionDecl * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Represents a prototype with parameter type info, e.g.
FunctionType - C99 6.7.5.3 - Function Declarators.
GlobalDecl - represents a global declaration.
const Decl * getDecl() const
This class represents temporary values used to represent inout and out arguments in HLSL.
const OpaqueValueExpr * getCastedTemporary() const
const OpaqueValueExpr * getOpaqueArgLValue() const
bool isInOut() const
returns true if the parameter is inout and false if the parameter is out.
const Expr * getWritebackCast() const
const Expr * getArgLValue() const
Return the l-value expression that was written as the argument in source.
Describes an C or C++ initializer list.
bool isTransparent() const
Is this a transparent initializer list (that is, an InitListExpr that is purely syntactic,...
const Expr * getInit(unsigned Init) const
StrictFlexArraysLevelKind
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Expr * getSubExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.
ValueDecl * getExtendingDecl()
Get the declaration which triggered the lifetime-extension of this temporary, if any.
MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.
bool isIncomplete() const
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
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.
ObjCEncodeExpr, used for @encode in Objective-C.
Represents an ObjC class declaration.
ObjCIvarDecl - Represents an ObjC instance variable.
ObjCIvarRefExpr - A reference to an ObjC instance variable.
const Expr * getBase() const
An expression that sends a message to the given Objective-C object or class.
const ObjCMethodDecl * getMethodDecl() const
QualType getReturnType() const
ObjCSelectorExpr used for @selector in Objective-C.
Selector getSelector() const
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
const Expr * getSubExpr() const
Pointer-authentication qualifiers.
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
[C99 6.4.2.2] - A predefined identifier such as func.
StringRef getIdentKindName() const
PredefinedIdentKind getIdentKind() const
StringLiteral * getFunctionName()
Represents an unpacked "presumed" location which can be presented to the user.
unsigned getColumn() const
Return the presumed column number of this location.
const char * getFilename() const
Return the presumed filename of this location.
unsigned getLine() const
Return the presumed line number of this location.
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
semantics_iterator semantics_end()
semantics_iterator semantics_begin()
const Expr *const * const_semantics_iterator
Expr * getResultExpr()
Return the result-bearing expression, or null if there is none.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
PointerAuthQualifier getPointerAuth() const
QualType withoutLocalFastQualifiers() const
bool isNull() const
Return true if this QualType doesn't point to a type yet.
LangAS getAddressSpace() const
Return the address space of this type.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
QualType withCVRQualifiers(unsigned CVR) const
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)
PointerAuthQualifier getPointerAuth() const
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.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const
Returns the "presumed" location of a SourceLocation specifies.
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
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.
bool isBlockPointerType() const
bool hasPointeeToToCFIUncheckedCalleeFunctionType() const
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
bool isPackedVectorBoolType(const ASTContext &ctx) const
bool hasAttr(attr::Kind AK) const
Determine whether this type had the specified attribute applied to it (looking through top-level type...
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isConstantArrayType() const
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
bool isFunctionPointerType() const
CXXRecordDecl * castAsCXXRecordDecl() 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 isEnumeralType() 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 isObjectType() const
Determine whether this type is an object type.
bool isHLSLResourceRecord() const
EnumDecl * getAsEnumDecl() const
Retrieves the EnumDecl this type refers to.
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 isAnyPointerType() 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
bool isHLSLResourceRecordArray() const
bool hasBooleanRepresentation() const
Determine whether this type has a boolean representation – i.e., it is a boolean type,...
bool isCFIUncheckedCalleeFunctionType() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
SourceLocation getExprLoc() const
Expr * getSubExpr() const
Represents a call to the builtin function __builtin_va_arg.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
TLSKind getTLSKind() const
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
@ TLS_Dynamic
TLS with a dynamic initializer.
@ TLS_None
Not a TLS variable.
Represents a C array with a specified size that is not an integer-constant-expression.
Represents a GCC generic vector type.
unsigned getNumElements() const
AlignmentSource
The source of the alignment of an l-value; an expression of confidence in the alignment actually matc...
@ Type
The l-value was considered opaque, so the alignment was determined from a type.
@ 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
const AstTypeMatcher< FunctionType > functionType
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
std::optional< llvm::AllocTokenMetadata > getAllocTokenMetadata(QualType T, const ASTContext &Ctx)
Get the information required for construction of an allocation token ID.
QualType inferPossibleType(const CallExpr *E, const ASTContext &Ctx, const CastExpr *CastE)
Infer the possible allocated type from an allocation call expression.
The JSON file list parser is used to communicate input to InstallAPI.
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
bool isa(CodeGen::Address addr)
@ 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.
const FunctionProtoType * T
@ Dtor_Complete
Complete object dtor.
LangAS
Defines the address space values used by the address space qualifier of QualType.
llvm::cl::opt< bool > ClSanitizeGuardChecks
SmallVector< CXXBaseSpecifier *, 4 > CXXCastPath
A simple array of base specifiers.
U cast(CodeGen::Address addr)
LangAS getLangASFromTargetAS(unsigned TargetAS)
@ Interface
The "__interface" keyword introduces the elaborated-type-specifier.
bool isLambdaMethod(const DeclContext *DC)
@ 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
CharUnits getPointerAlign() const
llvm::PointerType * DefaultPtrTy
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.
bool isIncomplete() const
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
bool HasSideEffects
Whether the evaluated expression has side effects.
void set(SanitizerMask K, bool Value)
Enable or disable a certain (single) sanitizer.
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
An adjustment to be made to the temporary created when emitting a reference binding,...
@ DerivedToBaseAdjustment
@ MemberPointerAdjustment