38#include "llvm/ADT/ArrayRef.h"
39#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
40#include "llvm/IR/DataLayout.h"
41#include "llvm/IR/Dominators.h"
42#include "llvm/IR/FPEnv.h"
43#include "llvm/IR/IntrinsicInst.h"
44#include "llvm/IR/Intrinsics.h"
45#include "llvm/IR/MDBuilder.h"
46#include "llvm/IR/Operator.h"
47#include "llvm/Support/CRC.h"
48#include "llvm/Support/xxhash.h"
49#include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
50#include "llvm/Transforms/Utils/PromoteMemToReg.h"
54using namespace CodeGen;
64 if (CGOpts.DisableLifetimeMarkers)
68 if (CGOpts.SanitizeAddressUseAfterScope ||
74 return CGOpts.OptimizationLevel != 0;
77CodeGenFunction::CodeGenFunction(
CodeGenModule &cgm,
bool suppressNewContext)
79 Builder(cgm, cgm.getModule().getContext(),
llvm::ConstantFolder(),
81 SanOpts(CGM.getLangOpts().Sanitize), CurFPFeatures(CGM.getLangOpts()),
82 DebugInfo(CGM.getModuleDebugInfo()), PGO(cgm),
83 ShouldEmitLifetimeMarkers(
85 if (!suppressNewContext)
86 CGM.getCXXABI().getMangleContext().startNewFunction();
89 SetFastMathFlags(CurFPFeatures);
92CodeGenFunction::~CodeGenFunction() {
109llvm::fp::ExceptionBehavior
117 llvm_unreachable(
"Unsupported FP Exception Behavior");
122 llvm::FastMathFlags FMF;
123 FMF.setAllowReassoc(FPFeatures.getAllowFPReassociate());
124 FMF.setNoNaNs(FPFeatures.getNoHonorNaNs());
125 FMF.setNoInfs(FPFeatures.getNoHonorInfs());
126 FMF.setNoSignedZeros(FPFeatures.getNoSignedZero());
127 FMF.setAllowReciprocal(FPFeatures.getAllowReciprocal());
128 FMF.setApproxFunc(FPFeatures.getAllowApproxFunc());
142 ConstructorHelper(FPFeatures);
145void CodeGenFunction::CGFPOptionsRAII::ConstructorHelper(
FPOptions FPFeatures) {
146 OldFPFeatures = CGF.CurFPFeatures;
147 CGF.CurFPFeatures = FPFeatures;
149 OldExcept = CGF.Builder.getDefaultConstrainedExcept();
150 OldRounding = CGF.Builder.getDefaultConstrainedRounding();
152 if (OldFPFeatures == FPFeatures)
155 FMFGuard.emplace(CGF.Builder);
158 CGF.Builder.setDefaultConstrainedRounding(NewRoundingBehavior);
159 auto NewExceptionBehavior =
162 CGF.Builder.setDefaultConstrainedExcept(NewExceptionBehavior);
164 CGF.SetFastMathFlags(FPFeatures);
166 assert((CGF.CurFuncDecl ==
nullptr || CGF.Builder.getIsFPConstrained() ||
167 isa<CXXConstructorDecl>(CGF.CurFuncDecl) ||
168 isa<CXXDestructorDecl>(CGF.CurFuncDecl) ||
169 (NewExceptionBehavior == llvm::fp::ebIgnore &&
170 NewRoundingBehavior == llvm::RoundingMode::NearestTiesToEven)) &&
171 "FPConstrained should be enabled on entire function");
173 auto mergeFnAttrValue = [&](StringRef Name,
bool Value) {
175 CGF.CurFn->getFnAttribute(Name).getValueAsBool();
176 auto NewValue = OldValue &
Value;
177 if (OldValue != NewValue)
178 CGF.CurFn->addFnAttr(Name, llvm::toStringRef(NewValue));
180 mergeFnAttrValue(
"no-infs-fp-math", FPFeatures.getNoHonorInfs());
181 mergeFnAttrValue(
"no-nans-fp-math", FPFeatures.getNoHonorNaNs());
182 mergeFnAttrValue(
"no-signed-zeros-fp-math", FPFeatures.getNoSignedZero());
185 FPFeatures.getAllowFPReassociate() && FPFeatures.getAllowReciprocal() &&
186 FPFeatures.getAllowApproxFunc() && FPFeatures.getNoSignedZero() &&
191 CGF.CurFPFeatures = OldFPFeatures;
192 CGF.Builder.setDefaultConstrainedExcept(OldExcept);
193 CGF.Builder.setDefaultConstrainedRounding(OldRounding);
208 return ::MakeNaturalAlignAddrLValue(
V,
T,
false, *
this);
213 return ::MakeNaturalAlignAddrLValue(
V,
T,
true, *
this);
218 return ::MakeNaturalAlignAddrLValue(
V,
T,
false, *
this);
223 return ::MakeNaturalAlignAddrLValue(
V,
T,
true, *
this);
237 switch (
type->getTypeClass()) {
238#define TYPE(name, parent)
239#define ABSTRACT_TYPE(name, parent)
240#define NON_CANONICAL_TYPE(name, parent) case Type::name:
241#define DEPENDENT_TYPE(name, parent) case Type::name:
242#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(name, parent) case Type::name:
243#include "clang/AST/TypeNodes.inc"
244 llvm_unreachable(
"non-canonical or dependent type in IR-generation");
247 case Type::DeducedTemplateSpecialization:
248 llvm_unreachable(
"undeduced type in IR-generation");
253 case Type::BlockPointer:
254 case Type::LValueReference:
255 case Type::RValueReference:
256 case Type::MemberPointer:
258 case Type::ExtVector:
259 case Type::ConstantMatrix:
260 case Type::FunctionProto:
261 case Type::FunctionNoProto:
263 case Type::ObjCObjectPointer:
273 case Type::ConstantArray:
274 case Type::IncompleteArray:
275 case Type::VariableArray:
277 case Type::ObjCObject:
278 case Type::ObjCInterface:
279 case Type::ArrayParameter:
284 type = cast<AtomicType>(
type)->getValueType();
287 llvm_unreachable(
"unknown type kind!");
294 llvm::BasicBlock *CurBB =
Builder.GetInsertBlock();
297 assert(!CurBB->getTerminator() &&
"Unexpected terminated block.");
307 return llvm::DebugLoc();
314 llvm::BranchInst *BI =
316 if (BI && BI->isUnconditional() &&
320 llvm::DebugLoc Loc = BI->getDebugLoc();
321 Builder.SetInsertPoint(BI->getParent());
322 BI->eraseFromParent();
334 return llvm::DebugLoc();
339 if (!BB->use_empty()) {
347 assert(BreakContinueStack.empty() &&
348 "mismatched push/pop in break/continue stack!");
350 bool OnlySimpleReturnStmts = NumSimpleReturnExprs > 0
351 && NumSimpleReturnExprs == NumReturnExprs
366 if (OnlySimpleReturnStmts)
367 DI->EmitLocation(
Builder, LastStopPoint);
369 DI->EmitLocation(
Builder, EndLoc);
377 bool HasOnlyLifetimeMarkers =
379 bool EmitRetDbgLoc = !HasCleanups || HasOnlyLifetimeMarkers;
381 std::optional<ApplyDebugLocation> OAL;
386 if (OnlySimpleReturnStmts)
387 DI->EmitLocation(
Builder, EndLoc);
402 CurFn->addFnAttr(
"instrument-function-exit",
"__cyg_profile_func_exit");
404 CurFn->addFnAttr(
"instrument-function-exit-inlined",
405 "__cyg_profile_func_exit");
419 "did not remove all scopes from cleanup stack!");
423 if (IndirectBranch) {
430 if (!EscapedLocals.empty()) {
434 EscapeArgs.resize(EscapedLocals.size());
435 for (
auto &Pair : EscapedLocals)
436 EscapeArgs[Pair.second] = Pair.first;
437 llvm::Function *FrameEscapeFn = llvm::Intrinsic::getDeclaration(
445 Ptr->eraseFromParent();
449 if (PostAllocaInsertPt) {
450 llvm::Instruction *PostPtr = PostAllocaInsertPt;
451 PostAllocaInsertPt =
nullptr;
452 PostPtr->eraseFromParent();
457 if (IndirectBranch) {
458 llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress());
459 if (PN->getNumIncomingValues() == 0) {
460 PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType()));
461 PN->eraseFromParent();
470 for (
const auto &FuncletAndParent : TerminateFunclets)
476 for (
const auto &R : DeferredReplacements) {
477 if (llvm::Value *Old = R.first) {
478 Old->replaceAllUsesWith(R.second);
479 cast<llvm::Instruction>(Old)->eraseFromParent();
482 DeferredReplacements.clear();
491 llvm::DominatorTree DT(*
CurFn);
492 llvm::PromoteMemToReg(
498 for (llvm::Argument &A :
CurFn->args())
499 if (
auto *VT = dyn_cast<llvm::VectorType>(A.getType()))
501 std::max((uint64_t)LargestVectorWidth,
502 VT->getPrimitiveSizeInBits().getKnownMinValue());
505 if (
auto *VT = dyn_cast<llvm::VectorType>(
CurFn->getReturnType()))
507 std::max((uint64_t)LargestVectorWidth,
508 VT->getPrimitiveSizeInBits().getKnownMinValue());
520 if (
getContext().getTargetInfo().getTriple().isX86())
521 CurFn->addFnAttr(
"min-legal-vector-width",
522 llvm::utostr(LargestVectorWidth));
525 std::optional<std::pair<unsigned, unsigned>> VScaleRange =
528 CurFn->addFnAttr(llvm::Attribute::getWithVScaleRangeArgs(
540 if (RetAlloca && RetAlloca->use_empty()) {
541 RetAlloca->eraseFromParent();
594 llvm::raw_string_ostream Out(Mangled);
596 return llvm::ConstantInt::get(
597 CGM.
Int32Ty,
static_cast<uint32_t
>(llvm::xxh3_64bits(Mangled)));
600void CodeGenFunction::EmitKernelMetadata(
const FunctionDecl *FD,
601 llvm::Function *Fn) {
602 if (!FD->
hasAttr<OpenCLKernelAttr>() && !FD->
hasAttr<CUDAGlobalAttr>())
612 if (
const VecTypeHintAttr *A = FD->
getAttr<VecTypeHintAttr>()) {
613 QualType HintQTy = A->getTypeHint();
615 bool IsSignedInteger =
618 llvm::Metadata *AttrMDArgs[] = {
619 llvm::ConstantAsMetadata::get(llvm::UndefValue::get(
621 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
622 llvm::IntegerType::get(Context, 32),
623 llvm::APInt(32, (uint64_t)(IsSignedInteger ? 1 : 0))))};
624 Fn->setMetadata(
"vec_type_hint", llvm::MDNode::get(Context, AttrMDArgs));
627 if (
const WorkGroupSizeHintAttr *A = FD->
getAttr<WorkGroupSizeHintAttr>()) {
628 llvm::Metadata *AttrMDArgs[] = {
629 llvm::ConstantAsMetadata::get(
Builder.getInt32(A->getXDim())),
630 llvm::ConstantAsMetadata::get(
Builder.getInt32(A->getYDim())),
631 llvm::ConstantAsMetadata::get(
Builder.getInt32(A->getZDim()))};
632 Fn->setMetadata(
"work_group_size_hint", llvm::MDNode::get(Context, AttrMDArgs));
635 if (
const ReqdWorkGroupSizeAttr *A = FD->
getAttr<ReqdWorkGroupSizeAttr>()) {
636 llvm::Metadata *AttrMDArgs[] = {
637 llvm::ConstantAsMetadata::get(
Builder.getInt32(A->getXDim())),
638 llvm::ConstantAsMetadata::get(
Builder.getInt32(A->getYDim())),
639 llvm::ConstantAsMetadata::get(
Builder.getInt32(A->getZDim()))};
640 Fn->setMetadata(
"reqd_work_group_size", llvm::MDNode::get(Context, AttrMDArgs));
643 if (
const OpenCLIntelReqdSubGroupSizeAttr *A =
644 FD->
getAttr<OpenCLIntelReqdSubGroupSizeAttr>()) {
645 llvm::Metadata *AttrMDArgs[] = {
646 llvm::ConstantAsMetadata::get(
Builder.getInt32(A->getSubGroupSize()))};
647 Fn->setMetadata(
"intel_reqd_sub_group_size",
648 llvm::MDNode::get(Context, AttrMDArgs));
654 const Stmt *Body =
nullptr;
655 if (
auto *FD = dyn_cast_or_null<FunctionDecl>(F))
657 else if (
auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(F))
658 Body = OMD->getBody();
660 if (
auto *CS = dyn_cast_or_null<CompoundStmt>(Body)) {
661 auto LastStmt = CS->body_rbegin();
662 if (LastStmt != CS->body_rend())
663 return isa<ReturnStmt>(*LastStmt);
670 Fn->addFnAttr(
"sanitize_thread_no_checking_at_run_time");
671 Fn->removeFnAttr(llvm::Attribute::SanitizeThread);
676bool CodeGenFunction::requiresReturnValueCheck()
const {
677 return requiresReturnValueNullabilityCheck() ||
683 auto *MD = dyn_cast_or_null<CXXMethodDecl>(D);
684 if (!MD || !MD->getDeclName().getAsIdentifierInfo() ||
685 !MD->getDeclName().getAsIdentifierInfo()->isStr(
"allocate") ||
686 (MD->getNumParams() != 1 && MD->getNumParams() != 2))
689 if (MD->parameters()[0]->getType().getCanonicalType() != Ctx.
getSizeType())
692 if (MD->getNumParams() == 2) {
693 auto *PT = MD->parameters()[1]->getType()->getAs<
PointerType>();
694 if (!PT || !PT->isVoidPointerType() ||
695 !PT->getPointeeType().isConstQualified())
707bool CodeGenFunction::hasInAllocaArg(
const CXXMethodDecl *MD) {
711 return isInAllocaArgument(CGM.getCXXABI(), P->getType());
718 if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD))
731 "Do not use a CodeGenFunction object for more than one function");
735 DidCallStackSave =
false;
737 const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
744 assert(
CurFn->isDeclaration() &&
"Function already has body?");
749#define SANITIZER(NAME, ID) \
750 if (SanOpts.empty()) \
752 if (SanOpts.has(SanitizerKind::ID)) \
753 if (CGM.isInNoSanitizeList(SanitizerKind::ID, Fn, Loc)) \
754 SanOpts.set(SanitizerKind::ID, false);
756#include "clang/Basic/Sanitizers.def"
763 bool NoSanitizeCoverage =
false;
766 no_sanitize_mask |=
Attr->getMask();
768 if (
Attr->hasCoverage())
769 NoSanitizeCoverage =
true;
774 if (no_sanitize_mask & SanitizerKind::Address)
775 SanOpts.
set(SanitizerKind::KernelAddress,
false);
776 if (no_sanitize_mask & SanitizerKind::KernelAddress)
778 if (no_sanitize_mask & SanitizerKind::HWAddress)
779 SanOpts.
set(SanitizerKind::KernelHWAddress,
false);
780 if (no_sanitize_mask & SanitizerKind::KernelHWAddress)
784 Fn->addFnAttr(llvm::Attribute::NoSanitizeBounds);
787 Fn->addFnAttr(llvm::Attribute::NoSanitizeCoverage);
791 if (no_sanitize_mask & SanitizerKind::Thread)
792 Fn->addFnAttr(
"no_sanitize_thread");
797 CurFn->addFnAttr(llvm::Attribute::DisableSanitizerInstrumentation);
800 if (
SanOpts.
hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress))
801 Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
803 SanitizerKind::KernelHWAddress))
804 Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
806 Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);
808 Fn->addFnAttr(llvm::Attribute::SanitizeThread);
809 if (
SanOpts.
hasOneOf(SanitizerKind::Memory | SanitizerKind::KernelMemory))
810 Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
813 Fn->addFnAttr(llvm::Attribute::SafeStack);
814 if (
SanOpts.
has(SanitizerKind::ShadowCallStack))
815 Fn->addFnAttr(llvm::Attribute::ShadowCallStack);
818 if (
SanOpts.
hasOneOf(SanitizerKind::Fuzzer | SanitizerKind::FuzzerNoLink))
819 Fn->addFnAttr(llvm::Attribute::OptForFuzzing);
824 if (
const auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(D)) {
825 const IdentifierInfo *II = OMD->getSelector().getIdentifierInfoForSlot(0);
828 (OMD->getSelector().isUnarySelector() && II->
isStr(
".cxx_destruct"))) {
837 if (D &&
SanOpts.
has(SanitizerKind::CFIUnrelatedCast)) {
851 bool AlwaysXRayAttr =
false;
852 if (
const auto *XRayAttr = D ? D->
getAttr<XRayInstrumentAttr>() :
nullptr) {
858 Fn->addFnAttr(
"function-instrument",
"xray-always");
859 AlwaysXRayAttr =
true;
861 if (XRayAttr->neverXRayInstrument())
862 Fn->addFnAttr(
"function-instrument",
"xray-never");
863 if (
const auto *LogArgs = D->
getAttr<XRayLogArgsAttr>())
865 Fn->addFnAttr(
"xray-log-args",
866 llvm::utostr(LogArgs->getArgumentCount()));
871 "xray-instruction-threshold",
877 Fn->addFnAttr(
"xray-ignore-loops");
881 Fn->addFnAttr(
"xray-skip-exit");
885 Fn->addFnAttr(
"xray-skip-entry");
888 if (FuncGroups > 1) {
890 CurFn->getName().bytes_end());
891 auto Group = crc32(FuncName) % FuncGroups;
894 Fn->addFnAttr(
"function-instrument",
"xray-never");
901 Fn->addFnAttr(llvm::Attribute::SkipProfile);
904 Fn->addFnAttr(llvm::Attribute::NoProfile);
911 unsigned Count, Offset;
912 if (
const auto *
Attr =
913 D ? D->
getAttr<PatchableFunctionEntryAttr>() :
nullptr) {
914 Count =
Attr->getCount();
915 Offset =
Attr->getOffset();
920 if (Count && Offset <= Count) {
921 Fn->addFnAttr(
"patchable-function-entry", std::to_string(Count - Offset));
923 Fn->addFnAttr(
"patchable-function-prefix", std::to_string(Offset));
930 getContext().getTargetInfo().getTriple().isX86() &&
931 getContext().getTargetInfo().getTriple().getEnvironment() !=
932 llvm::Triple::CODE16)
933 Fn->addFnAttr(
"patchable-function",
"prologue-short-redirect");
937 Fn->addFnAttr(
"no-jump-tables",
"true");
941 Fn->addFnAttr(
"no-inline-line-tables");
945 Fn->addFnAttr(
"profile-sample-accurate");
948 Fn->addFnAttr(
"use-sample-profile");
950 if (D && D->
hasAttr<CFICanonicalJumpTableAttr>())
951 Fn->addFnAttr(
"cfi-canonical-jump-table");
953 if (D && D->
hasAttr<NoProfileFunctionAttr>())
954 Fn->addFnAttr(llvm::Attribute::NoProfile);
958 if (
auto *A = D->
getAttr<FunctionReturnThunksAttr>()) {
959 switch (A->getThunkType()) {
960 case FunctionReturnThunksAttr::Kind::Keep:
962 case FunctionReturnThunksAttr::Kind::Extern:
963 Fn->addFnAttr(llvm::Attribute::FnRetThunkExtern);
967 Fn->addFnAttr(llvm::Attribute::FnRetThunkExtern);
973 EmitKernelMetadata(FD, Fn);
978 if (FD &&
SanOpts.
has(SanitizerKind::Function)) {
980 llvm::LLVMContext &Ctx = Fn->getContext();
981 llvm::MDBuilder MDB(Ctx);
983 llvm::LLVMContext::MD_func_sanitize,
984 MDB.createRTTIPointerPrologue(
991 if (
SanOpts.
has(SanitizerKind::NullabilityReturn)) {
995 if (!(
SanOpts.
has(SanitizerKind::ReturnsNonnullAttribute) &&
997 RetValNullabilityPrecondition =
1016 Fn->addFnAttr(llvm::Attribute::NoRecurse);
1019 llvm::fp::ExceptionBehavior FPExceptionBehavior =
1021 Builder.setDefaultConstrainedRounding(RM);
1022 Builder.setDefaultConstrainedExcept(FPExceptionBehavior);
1024 (!FD && (FPExceptionBehavior != llvm::fp::ebIgnore ||
1025 RM != llvm::RoundingMode::NearestTiesToEven))) {
1026 Builder.setIsFPConstrained(
true);
1027 Fn->addFnAttr(llvm::Attribute::StrictFP);
1034 Fn->addFnAttr(
"stackrealign");
1038 Fn->removeFnAttr(
"zero-call-used-regs");
1045 llvm::Value *Undef = llvm::UndefValue::get(
Int32Ty);
1050 Builder.SetInsertPoint(EntryBB);
1054 if (requiresReturnValueCheck()) {
1065 DI->emitFunctionStart(GD, Loc, StartLoc,
1066 DI->getFunctionType(FD, RetTy, Args),
CurFn,
1072 CurFn->addFnAttr(
"instrument-function-entry",
"__cyg_profile_func_enter");
1074 CurFn->addFnAttr(
"instrument-function-entry-inlined",
1075 "__cyg_profile_func_enter");
1077 CurFn->addFnAttr(
"instrument-function-entry-inlined",
1078 "__cyg_profile_func_enter_bare");
1090 Fn->addFnAttr(
"fentry-call",
"true");
1092 Fn->addFnAttr(
"instrument-function-entry-inlined",
1098 <<
"-mnop-mcount" <<
"-mfentry";
1099 Fn->addFnAttr(
"mnop-mcount");
1105 <<
"-mrecord-mcount" <<
"-mfentry";
1106 Fn->addFnAttr(
"mrecord-mcount");
1112 if (
getContext().getTargetInfo().getTriple().getArch() !=
1113 llvm::Triple::systemz)
1115 <<
"-mpacked-stack";
1116 Fn->addFnAttr(
"packed-stack");
1121 Fn->addFnAttr(
"warn-stack-size",
1134 auto AI =
CurFn->arg_begin();
1150 llvm::Function::arg_iterator EI =
CurFn->arg_end();
1155 cast<llvm::GetElementPtrInst>(Addr)->getResultElementType();
1181 if (D && D->
hasAttr<HLSLShaderAttr>())
1186 if (
const CXXMethodDecl *MD = dyn_cast_if_present<CXXMethodDecl>(D);
1207 CXXThisValue = ThisFieldLValue.
getPointer(*
this);
1216 if (FD->hasCapturedVLAType()) {
1219 auto VAT = FD->getCapturedVLAType();
1220 VLASizeMap[VAT->getSizeExpr()] = ExprArg;
1227 CXXThisValue = CXXABIThisValue;
1231 if (CXXABIThisValue) {
1233 SkippedChecks.
set(SanitizerKind::ObjectSize,
true);
1240 SkippedChecks.
set(SanitizerKind::Null,
true);
1244 Loc, CXXABIThisValue, ThisTy, CXXABIThisAlignment, SkippedChecks);
1251 if (!FD || !FD->
hasAttr<NakedAttr>()) {
1252 for (
const VarDecl *VD : Args) {
1257 if (
const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD))
1258 Ty = PVD->getOriginalType();
1268 DI->EmitLocation(
Builder, StartLoc);
1273 LargestVectorWidth = VecWidth->getVectorWidth();
1279 if (
const CompoundStmt *S = dyn_cast<CompoundStmt>(Body))
1291 llvm::BasicBlock *SkipCountBB =
nullptr;
1316 if (F->isInterposable())
return;
1318 for (llvm::BasicBlock &BB : *F)
1319 for (llvm::Instruction &I : BB)
1323 F->setDoesNotThrow();
1343 bool PassedParams =
true;
1345 if (
auto Inherited = CD->getInheritedConstructor())
1351 Args.push_back(Param);
1352 if (!Param->hasAttr<PassObjectSizeAttr>())
1356 getContext(), Param->getDeclContext(), Param->getLocation(),
1363 if (MD && (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)))
1371 assert(Fn &&
"generating code for null Function");
1384 std::string FDInlineName = (Fn->getName() +
".inline").str();
1385 llvm::Module *M = Fn->getParent();
1386 llvm::Function *Clone = M->getFunction(FDInlineName);
1388 Clone = llvm::Function::Create(Fn->getFunctionType(),
1389 llvm::GlobalValue::InternalLinkage,
1390 Fn->getAddressSpace(), FDInlineName, M);
1391 Clone->addFnAttr(llvm::Attribute::AlwaysInline);
1393 Fn->setLinkage(llvm::GlobalValue::ExternalLinkage);
1403 if (LLVM_UNLIKELY(PD->isInlineBuiltinDeclaration())) {
1404 std::string FDInlineName = (Fn->getName() +
".inline").str();
1405 llvm::Module *M = Fn->getParent();
1406 if (llvm::Function *Clone = M->getFunction(FDInlineName)) {
1407 Clone->replaceAllUsesWith(Fn);
1408 Clone->eraseFromParent();
1416 if (FD->
hasAttr<NoDebugAttr>()) {
1419 Fn->setSubprogram(
nullptr);
1421 DebugInfo =
nullptr;
1431 CurEHLocation = BodyRange.
getEnd();
1443 if (SpecDecl->hasBody(SpecDecl))
1444 Loc = SpecDecl->getLocation();
1450 if (isa<CoroutineBodyStmt>(Body))
1451 ShouldEmitLifetimeMarkers =
true;
1455 if (ShouldEmitLifetimeMarkers)
1463 if (Body && isa_and_nonnull<CoroutineBodyStmt>(Body))
1469 CurFn->addFnAttr(llvm::Attribute::MustProgress);
1473 if (isa<CXXDestructorDecl>(FD))
1475 else if (isa<CXXConstructorDecl>(FD))
1479 FD->
hasAttr<CUDAGlobalAttr>())
1481 else if (isa<CXXMethodDecl>(FD) &&
1482 cast<CXXMethodDecl>(FD)->isLambdaStaticInvoker()) {
1486 }
else if (isa<CXXMethodDecl>(FD) &&
1489 cast<CXXMethodDecl>(FD)->getParent()->getLambdaStaticInvoker() &&
1490 hasInAllocaArg(cast<CXXMethodDecl>(FD))) {
1497 }
else if (FD->
isDefaulted() && isa<CXXMethodDecl>(FD) &&
1498 (cast<CXXMethodDecl>(FD)->isCopyAssignmentOperator() ||
1499 cast<CXXMethodDecl>(FD)->isMoveAssignmentOperator())) {
1506 llvm_unreachable(
"no definition for emitted function");
1516 bool ShouldEmitUnreachable =
1520 SanitizerScope SanScope(
this);
1521 llvm::Value *IsFalse =
Builder.getFalse();
1522 EmitCheck(std::make_pair(IsFalse, SanitizerKind::Return),
1523 SanitizerHandler::MissingReturn,
1525 }
else if (ShouldEmitUnreachable) {
1529 if (
SanOpts.
has(SanitizerKind::Return) || ShouldEmitUnreachable) {
1531 Builder.ClearInsertionPoint();
1540 if (!
CurFn->doesNotThrow())
1549 if (!S)
return false;
1556 if (isa<LabelStmt>(S))
1561 if (isa<SwitchCase>(S) && !IgnoreCaseStmts)
1565 if (isa<SwitchStmt>(S))
1566 IgnoreCaseStmts =
true;
1569 for (
const Stmt *SubStmt : S->children())
1581 if (!S)
return false;
1585 if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || isa<DoStmt>(S) ||
1589 if (isa<BreakStmt>(S))
1593 for (
const Stmt *SubStmt : S->children())
1601 if (!S)
return false;
1607 if (isa<IfStmt>(S) || isa<SwitchStmt>(S) || isa<WhileStmt>(S) ||
1608 isa<DoStmt>(S) || isa<ForStmt>(S) || isa<CompoundStmt>(S) ||
1609 isa<CXXForRangeStmt>(S) || isa<CXXTryStmt>(S) ||
1610 isa<ObjCForCollectionStmt>(S) || isa<ObjCAtTryStmt>(S))
1613 if (isa<DeclStmt>(S))
1616 for (
const Stmt *SubStmt : S->children())
1636 llvm::APSInt ResultInt;
1640 ResultBool = ResultInt.getBoolValue();
1648 llvm::APSInt &ResultInt,
1666 while (
const UnaryOperator *Op = dyn_cast<UnaryOperator>(
C->IgnoreParens())) {
1667 if (Op->getOpcode() != UO_LNot)
1669 C = Op->getSubExpr();
1671 return C->IgnoreParens();
1687 llvm::BasicBlock *FalseBlock, uint64_t TrueCount ,
1694 llvm::BasicBlock *ThenBlock =
nullptr;
1695 llvm::BasicBlock *ElseBlock =
nullptr;
1696 llvm::BasicBlock *NextBlock =
nullptr;
1713 if (LOp == BO_LAnd) {
1714 ThenBlock = CounterIncrBlock;
1715 ElseBlock = FalseBlock;
1716 NextBlock = TrueBlock;
1731 else if (LOp == BO_LOr) {
1732 ThenBlock = TrueBlock;
1733 ElseBlock = CounterIncrBlock;
1734 NextBlock = FalseBlock;
1736 llvm_unreachable(
"Expected Opcode must be that of a Logical Operator");
1760 const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock,
1764 if (
const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) {
1766 if (CondBOp->getOpcode() == BO_LAnd) {
1771 bool ConstantBool =
false;
1777 FalseBlock, TrueCount, LH);
1788 FalseBlock, TrueCount, LH, CondBOp);
1800 ConditionalEvaluation eval(*
this);
1817 FalseBlock, TrueCount, LH);
1823 if (CondBOp->getOpcode() == BO_LOr) {
1828 bool ConstantBool =
false;
1834 FalseBlock, TrueCount, LH);
1845 FalseBlock, TrueCount, LH, CondBOp);
1857 uint64_t RHSCount = TrueCount - LHSCount;
1859 ConditionalEvaluation eval(*
this);
1884 if (
const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) {
1892 if (CondUOp->getOpcode() == UO_LNot && !MCDCCondition) {
1910 ConditionalEvaluation cond(*
this);
1923 LHSScaledTrueCount = TrueCount * LHSRatio;
1932 LHSScaledTrueCount, LH, CondOp);
1939 TrueCount - LHSScaledTrueCount, LH, CondOp);
1945 if (
const CXXThrowExpr *Throw = dyn_cast<CXXThrowExpr>(Cond)) {
1965 const Expr *MCDCBaseExpr = Cond;
1972 MCDCBaseExpr = ConditionalOp;
1977 llvm::MDNode *Weights =
nullptr;
1978 llvm::MDNode *Unpredictable =
nullptr;
1985 auto *FD = dyn_cast_or_null<FunctionDecl>(
Call->getCalleeDecl());
1986 if (FD && FD->
getBuiltinID() == Builtin::BI__builtin_unpredictable) {
1988 Unpredictable = MDHelper.createUnpredictable();
1994 llvm::Value *NewCondV = emitCondLikelihoodViaExpectIntrinsic(CondV, LH);
1995 if (CondV != NewCondV)
2000 Weights = createProfileWeights(TrueCount, CurrentCount - TrueCount);
2003 Builder.CreateCondBr(CondV, TrueBlock, FalseBlock, Weights, Unpredictable);
2021 llvm::Value *sizeInChars) {
2025 llvm::Value *baseSizeInChars
2031 sizeInChars,
"vla.end");
2033 llvm::BasicBlock *originBB = CGF.
Builder.GetInsertBlock();
2041 llvm::PHINode *cur =
Builder.CreatePHI(begin.
getType(), 2,
"vla.cur");
2056 llvm::Value *done =
Builder.CreateICmpEQ(next, end,
"vla-init.isdone");
2057 Builder.CreateCondBr(done, contBB, loopBB);
2058 cur->addIncoming(next, loopBB);
2068 if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty())
2079 llvm::Value *SizeVal;
2086 dyn_cast_or_null<VariableArrayType>(
2089 SizeVal = VlaSize.NumElts;
2091 if (!eltSize.
isOne())
2112 llvm::GlobalVariable *NullVariable =
2113 new llvm::GlobalVariable(
CGM.
getModule(), NullConstant->getType(),
2115 llvm::GlobalVariable::PrivateLinkage,
2116 NullConstant, Twine());
2118 NullVariable->setAlignment(NullAlign.
getAsAlign());
2136 if (!IndirectBranch)
2142 IndirectBranch->addDestination(BB);
2143 return llvm::BlockAddress::get(
CurFn, BB);
2148 if (IndirectBranch)
return IndirectBranch->getParent();
2153 llvm::Value *DestVal = TmpBuilder.CreatePHI(
Int8PtrTy, 0,
2154 "indirect.goto.dest");
2157 IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal);
2158 return IndirectBranch->getParent();
2170 llvm::Value *numVLAElements =
nullptr;
2171 if (isa<VariableArrayType>(
arrayType)) {
2182 baseType = elementType;
2183 return numVLAElements;
2185 }
while (isa<VariableArrayType>(
arrayType));
2197 llvm::ConstantInt *zero =
Builder.getInt32(0);
2198 gepIndices.push_back(zero);
2203 llvm::ArrayType *llvmArrayType =
2205 while (llvmArrayType) {
2206 assert(isa<ConstantArrayType>(
arrayType));
2207 assert(cast<ConstantArrayType>(
arrayType)->getZExtSize() ==
2208 llvmArrayType->getNumElements());
2210 gepIndices.push_back(zero);
2211 countFromCLAs *= llvmArrayType->getNumElements();
2215 dyn_cast<llvm::ArrayType>(llvmArrayType->getElementType());
2218 "LLVM and Clang types are out-of-synch");
2226 countFromCLAs *= cast<ConstantArrayType>(
arrayType)->getZExtSize();
2237 gepIndices,
"array.begin"),
2243 llvm::Value *numElements
2244 = llvm::ConstantInt::get(
SizeTy, countFromCLAs);
2248 numElements =
Builder.CreateNUWMul(numVLAElements, numElements);
2255 assert(vla &&
"type was not a variable array type!");
2259CodeGenFunction::VlaSizePair
2262 llvm::Value *numElements =
nullptr;
2266 elementType =
type->getElementType();
2267 llvm::Value *vlaSize = VLASizeMap[
type->getSizeExpr()];
2268 assert(vlaSize &&
"no size for VLA!");
2269 assert(vlaSize->getType() ==
SizeTy);
2272 numElements = vlaSize;
2276 numElements =
Builder.CreateNUWMul(numElements, vlaSize);
2278 }
while ((
type =
getContext().getAsVariableArrayType(elementType)));
2280 return { numElements, elementType };
2283CodeGenFunction::VlaSizePair
2286 assert(vla &&
"type was not a variable array type!");
2290CodeGenFunction::VlaSizePair
2292 llvm::Value *VlaSize = VLASizeMap[Vla->
getSizeExpr()];
2293 assert(VlaSize &&
"no size for VLA!");
2294 assert(VlaSize->getType() ==
SizeTy);
2299 assert(
type->isVariablyModifiedType() &&
2300 "Must pass variably modified type to EmitVLASizes!");
2307 assert(
type->isVariablyModifiedType());
2309 const Type *ty =
type.getTypePtr();
2312#define TYPE(Class, Base)
2313#define ABSTRACT_TYPE(Class, Base)
2314#define NON_CANONICAL_TYPE(Class, Base)
2315#define DEPENDENT_TYPE(Class, Base) case Type::Class:
2316#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
2317#include "clang/AST/TypeNodes.inc"
2318 llvm_unreachable(
"unexpected dependent type!");
2324 case Type::ExtVector:
2325 case Type::ConstantMatrix:
2329 case Type::TemplateSpecialization:
2330 case Type::ObjCTypeParam:
2331 case Type::ObjCObject:
2332 case Type::ObjCInterface:
2333 case Type::ObjCObjectPointer:
2335 llvm_unreachable(
"type class is never variably-modified!");
2337 case Type::Elaborated:
2338 type = cast<ElaboratedType>(ty)->getNamedType();
2341 case Type::Adjusted:
2342 type = cast<AdjustedType>(ty)->getAdjustedType();
2346 type = cast<DecayedType>(ty)->getPointeeType();
2350 type = cast<PointerType>(ty)->getPointeeType();
2353 case Type::BlockPointer:
2354 type = cast<BlockPointerType>(ty)->getPointeeType();
2357 case Type::LValueReference:
2358 case Type::RValueReference:
2359 type = cast<ReferenceType>(ty)->getPointeeType();
2362 case Type::MemberPointer:
2363 type = cast<MemberPointerType>(ty)->getPointeeType();
2366 case Type::ArrayParameter:
2367 case Type::ConstantArray:
2368 case Type::IncompleteArray:
2370 type = cast<ArrayType>(ty)->getElementType();
2373 case Type::VariableArray: {
2382 llvm::Value *&entry = VLASizeMap[sizeExpr];
2391 SanitizerScope SanScope(
this);
2392 llvm::Value *
Zero = llvm::Constant::getNullValue(size->getType());
2394 llvm::Value *CheckCondition =
2396 ?
Builder.CreateICmpSGT(size, Zero)
2397 :
Builder.CreateICmpUGT(size, Zero);
2398 llvm::Constant *StaticArgs[] = {
2401 EmitCheck(std::make_pair(CheckCondition, SanitizerKind::VLABound),
2402 SanitizerHandler::VLABoundNotPositive, StaticArgs, size);
2415 case Type::FunctionProto:
2416 case Type::FunctionNoProto:
2417 type = cast<FunctionType>(ty)->getReturnType();
2422 case Type::UnaryTransform:
2423 case Type::Attributed:
2424 case Type::BTFTagAttributed:
2425 case Type::SubstTemplateTypeParm:
2426 case Type::MacroQualified:
2427 case Type::CountAttributed:
2433 case Type::Decltype:
2435 case Type::DeducedTemplateSpecialization:
2436 case Type::PackIndexing:
2440 case Type::TypeOfExpr:
2446 type = cast<AtomicType>(ty)->getValueType();
2450 type = cast<PipeType>(ty)->getElementType();
2453 }
while (
type->isVariablyModifiedType());
2457 if (
getContext().getBuiltinVaListType()->isArrayType())
2468 assert(
Init.hasValue() &&
"Invalid DeclRefExpr initializer!");
2474CodeGenFunction::PeepholeProtection
2480 if (!rvalue.
isScalar())
return PeepholeProtection();
2482 if (!isa<llvm::ZExtInst>(value))
return PeepholeProtection();
2486 llvm::Instruction *inst =
new llvm::BitCastInst(value, value->getType(),
"",
2489 PeepholeProtection protection;
2490 protection.Inst = inst;
2495 if (!protection.Inst)
return;
2498 protection.Inst->eraseFromParent();
2504 llvm::Value *Alignment,
2505 llvm::Value *OffsetValue) {
2506 if (Alignment->getType() !=
IntPtrTy)
2509 if (OffsetValue && OffsetValue->getType() !=
IntPtrTy)
2512 llvm::Value *TheCheck =
nullptr;
2514 llvm::Value *PtrIntValue =
2518 bool IsOffsetZero =
false;
2519 if (
const auto *CI = dyn_cast<llvm::ConstantInt>(OffsetValue))
2520 IsOffsetZero = CI->isZero();
2523 PtrIntValue =
Builder.CreateSub(PtrIntValue, OffsetValue,
"offsetptr");
2526 llvm::Value *
Zero = llvm::ConstantInt::get(
IntPtrTy, 0);
2529 llvm::Value *MaskedPtr =
Builder.CreateAnd(PtrIntValue, Mask,
"maskedptr");
2530 TheCheck =
Builder.CreateICmpEQ(MaskedPtr, Zero,
"maskcond");
2532 llvm::Instruction *Assumption =
Builder.CreateAlignmentAssumption(
2538 OffsetValue, TheCheck, Assumption);
2544 llvm::Value *Alignment,
2545 llvm::Value *OffsetValue) {
2554 llvm::Value *AnnotatedVal,
2555 StringRef AnnotationStr,
2557 const AnnotateAttr *
Attr) {
2566 return Builder.CreateCall(AnnotationFn, Args);
2570 assert(D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
2573 {V->getType(), CGM.ConstGlobalsPtrTy}),
2579 assert(D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
2581 llvm::Type *VTy =
V->getType();
2582 auto *PTy = dyn_cast<llvm::PointerType>(VTy);
2583 unsigned AS = PTy ? PTy->getAddressSpace() : 0;
2584 llvm::PointerType *IntrinTy =
2593 if (VTy != IntrinTy)
2611 CGF->IsSanitizerScope =
false;
2615 const llvm::Twine &Name,
2616 llvm::BasicBlock *BB,
2617 llvm::BasicBlock::iterator InsertPt)
const {
2620 I->setNoSanitizeMetadata();
2624 llvm::Instruction *I,
const llvm::Twine &Name, llvm::BasicBlock *BB,
2625 llvm::BasicBlock::iterator InsertPt)
const {
2626 llvm::IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt);
2628 CGF->InsertHelper(I, Name, BB, InsertPt);
2639 if (BuiltinID == X86::BI__builtin_ia32_cmpps ||
2640 BuiltinID == X86::BI__builtin_ia32_cmpss ||
2641 BuiltinID == X86::BI__builtin_ia32_cmppd ||
2642 BuiltinID == X86::BI__builtin_ia32_cmpsd) {
2644 llvm::StringMap<bool> TargetFetureMap;
2648 if (
Result.getSExtValue() > 7 && !TargetFetureMap.lookup(
"avx"))
2674 std::string MissingFeature;
2675 llvm::StringMap<bool> CallerFeatureMap;
2685 FeatureList, CallerFeatureMap) && !IsHipStdPar) {
2691 TargetDecl->
hasAttr<TargetAttr>()) {
2694 const TargetAttr *TD = TargetDecl->
getAttr<TargetAttr>();
2699 llvm::StringMap<bool> CalleeFeatureMap;
2703 if (F[0] ==
'+' && CalleeFeatureMap.lookup(F.substr(1)))
2704 ReqFeatures.push_back(StringRef(F).substr(1));
2707 for (
const auto &F : CalleeFeatureMap) {
2710 ReqFeatures.push_back(F.getKey());
2712 if (!llvm::all_of(ReqFeatures, [&](StringRef Feature) {
2713 if (!CallerFeatureMap.lookup(Feature)) {
2714 MissingFeature = Feature.str();
2722 llvm::StringMap<bool> CalleeFeatureMap;
2725 for (
const auto &F : CalleeFeatureMap) {
2726 if (F.getValue() && (!CallerFeatureMap.lookup(F.getKey()) ||
2727 !CallerFeatureMap.find(F.getKey())->getValue()) &&
2739 llvm::IRBuilder<> IRB(
Builder.GetInsertBlock(),
Builder.GetInsertPoint());
2740 IRB.SetCurrentDebugLocation(
Builder.getCurrentDebugLocation());
2747 Callee.getAbstractInfo().getCalleeFunctionProtoType();
2752llvm::Value *CodeGenFunction::FormAArch64ResolverCondition(
2753 const MultiVersionResolverOption &RO) {
2755 for (
const StringRef &Feature : RO.Conditions.Features) {
2758 CondFeatures.push_back(Feature);
2760 if (!CondFeatures.empty()) {
2761 return EmitAArch64CpuSupports(CondFeatures);
2766llvm::Value *CodeGenFunction::FormX86ResolverCondition(
2767 const MultiVersionResolverOption &RO) {
2770 if (!RO.Conditions.Architecture.empty()) {
2771 StringRef Arch = RO.Conditions.Architecture;
2774 if (Arch.starts_with(
"x86-64"))
2780 if (!RO.Conditions.Features.empty()) {
2781 llvm::Value *FeatureCond = EmitX86CpuSupports(RO.Conditions.Features);
2789 llvm::Function *Resolver,
2791 llvm::Function *FuncToReturn,
2792 bool SupportsIFunc) {
2793 if (SupportsIFunc) {
2794 Builder.CreateRet(FuncToReturn);
2799 llvm::make_pointer_range(Resolver->args()));
2801 llvm::CallInst *
Result =
Builder.CreateCall(FuncToReturn, Args);
2802 Result->setTailCallKind(llvm::CallInst::TCK_MustTail);
2804 if (Resolver->getReturnType()->isVoidTy())
2813 llvm::Triple::ArchType ArchType =
2817 case llvm::Triple::x86:
2818 case llvm::Triple::x86_64:
2821 case llvm::Triple::aarch64:
2826 assert(
false &&
"Only implemented for x86 and AArch64 targets");
2832 assert(!Options.empty() &&
"No multiversion resolver options found");
2833 assert(Options.back().Conditions.Features.size() == 0 &&
2834 "Default case must be last");
2836 assert(SupportsIFunc &&
2837 "Multiversion resolver requires target IFUNC support");
2838 bool AArch64CpuInitialized =
false;
2841 for (
const MultiVersionResolverOption &RO : Options) {
2842 Builder.SetInsertPoint(CurBlock);
2843 llvm::Value *
Condition = FormAArch64ResolverCondition(RO);
2852 if (!AArch64CpuInitialized) {
2853 Builder.SetInsertPoint(CurBlock, CurBlock->begin());
2854 EmitAArch64CpuInit();
2855 AArch64CpuInitialized =
true;
2856 Builder.SetInsertPoint(CurBlock);
2859 llvm::BasicBlock *RetBlock =
createBasicBlock(
"resolver_return", Resolver);
2868 Builder.SetInsertPoint(CurBlock);
2869 llvm::CallInst *TrapCall =
EmitTrapCall(llvm::Intrinsic::trap);
2870 TrapCall->setDoesNotReturn();
2871 TrapCall->setDoesNotThrow();
2873 Builder.ClearInsertionPoint();
2883 Builder.SetInsertPoint(CurBlock);
2886 for (
const MultiVersionResolverOption &RO : Options) {
2887 Builder.SetInsertPoint(CurBlock);
2888 llvm::Value *
Condition = FormX86ResolverCondition(RO);
2892 assert(&RO == Options.end() - 1 &&
2893 "Default or Generic case must be last");
2899 llvm::BasicBlock *RetBlock =
createBasicBlock(
"resolver_return", Resolver);
2908 Builder.SetInsertPoint(CurBlock);
2909 llvm::CallInst *TrapCall =
EmitTrapCall(llvm::Intrinsic::trap);
2910 TrapCall->setDoesNotReturn();
2911 TrapCall->setDoesNotThrow();
2913 Builder.ClearInsertionPoint();
2925 llvm::Value *OffsetValue, llvm::Value *TheCheck,
2926 llvm::Instruction *Assumption) {
2927 assert(Assumption && isa<llvm::CallInst>(Assumption) &&
2928 cast<llvm::CallInst>(Assumption)->getCalledOperand() ==
2929 llvm::Intrinsic::getDeclaration(
2930 Builder.GetInsertBlock()->getParent()->getParent(),
2931 llvm::Intrinsic::assume) &&
2932 "Assumption should be a call to llvm.assume().");
2933 assert(&(
Builder.GetInsertBlock()->back()) == Assumption &&
2934 "Assumption should be the last instruction of the basic block, "
2935 "since the basic block is still being generated.");
2947 Assumption->removeFromParent();
2950 SanitizerScope SanScope(
this);
2953 OffsetValue =
Builder.getInt1(
false);
2961 EmitCheck({std::make_pair(TheCheck, SanitizerKind::Alignment)},
2962 SanitizerHandler::AlignmentAssumption, StaticData, DynamicData);
2973 return DI->SourceLocToDebugLoc(Location);
2975 return llvm::DebugLoc();
2979CodeGenFunction::emitCondLikelihoodViaExpectIntrinsic(llvm::Value *Cond,
2990 llvm::Type *CondTy = Cond->getType();
2991 assert(CondTy->isIntegerTy(1) &&
"expecting condition to be a boolean");
2992 llvm::Function *FnExpect =
2994 llvm::Value *ExpectedValueOfCond =
2996 return Builder.CreateCall(FnExpect, {Cond, ExpectedValueOfCond},
2997 Cond->getName() +
".expval");
2999 llvm_unreachable(
"Unknown Likelihood");
3003 unsigned NumElementsDst,
3004 const llvm::Twine &Name) {
3005 auto *SrcTy = cast<llvm::FixedVectorType>(SrcVec->getType());
3006 unsigned NumElementsSrc = SrcTy->getNumElements();
3007 if (NumElementsSrc == NumElementsDst)
3010 std::vector<int> ShuffleMask(NumElementsDst, -1);
3011 for (
unsigned MaskIdx = 0;
3012 MaskIdx < std::min<>(NumElementsDst, NumElementsSrc); ++MaskIdx)
3013 ShuffleMask[MaskIdx] = MaskIdx;
3015 return Builder.CreateShuffleVector(SrcVec, ShuffleMask, Name);
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 CreateMultiVersionResolverReturn(CodeGenModule &CGM, llvm::Function *Resolver, CGBuilderTy &Builder, llvm::Function *FuncToReturn, bool SupportsIFunc)
static void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType, Address dest, Address src, llvm::Value *sizeInChars)
emitNonZeroVLAInit - Emit the "zero" initialization of a variable-length array whose elements have a ...
static void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB)
static void TryMarkNoThrow(llvm::Function *F)
Tries to mark the given function nounwind based on the non-existence of any throwing calls within it.
static llvm::Constant * getPrologueSignature(CodeGenModule &CGM, const FunctionDecl *FD)
Return the UBSan prologue signature for FD if one is available.
static bool endsWithReturn(const Decl *F)
Determine whether the function F ends with a return stmt.
static bool shouldEmitLifetimeMarkers(const CodeGenOptions &CGOpts, const LangOptions &LangOpts)
shouldEmitLifetimeMarkers - Decide whether we need emit the life-time markers.
static bool matchesStlAllocatorFn(const Decl *D, const ASTContext &Ctx)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
llvm::MachO::Target Target
static bool hasFeature(StringRef Feature, const LangOptions &LangOpts, const TargetInfo &Target)
Determine whether a translation unit built using the current language options has the given feature.
Defines the Objective-C statement AST node classes.
Enumerates target-specific builtins in their own namespaces within namespace clang.
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
ParsedTargetAttr filterFunctionTargetAttrs(const TargetAttr *TD) const
Parses the target attributes passed in, and returns only the ones that are valid feature names.
Builtin::Context & BuiltinInfo
QualType getFunctionTypeWithExceptionSpec(QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) const
Get a function type and produce the equivalent function type with the specified exception specificati...
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
const VariableArrayType * getAsVariableArrayType(QualType T) const
const TargetInfo & getTargetInfo() const
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *) const
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
Attr - This represents one attribute.
A builtin binary operation expression such as "x + y" or "x <= y".
static bool isLogicalOp(Opcode Opc)
const char * getRequiredFeatures(unsigned ID) const
Represents a C++ constructor within a class.
Represents a static or instance method of a struct/union/class.
bool isImplicitObjectMemberFunction() const
[C++2b][dcl.fct]/p7 An implicit object member function is a non-static member function without an exp...
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
QualType getThisType() const
Return the type of the this pointer.
Represents a C++ struct/union/class.
bool isLambda() const
Determine whether this class describes a lambda function object.
void getCaptureFields(llvm::DenseMap< const ValueDecl *, FieldDecl * > &Captures, FieldDecl *&ThisCapture) const
For a closure type, retrieve the mapping from captured variables and this to the non-static data memb...
bool isCapturelessLambda() const
A C++ throw-expression (C++ [except.throw]).
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
SourceLocation getBeginLoc() const LLVM_READONLY
CharUnits - This is an opaque type for sizes expressed in character units.
bool isZero() const
isZero - Test whether the quantity equals zero.
llvm::Align getAsAlign() const
getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
CharUnits alignmentOfArrayElement(CharUnits elementSize) const
Given that this is the alignment of the first element of an array, return the minimum alignment of an...
bool isOne() const
isOne - Test whether the quantity equals one.
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
std::string SampleProfileFile
Name of the profile file to use with -fprofile-sample-use.
bool hasProfileClangInstr() const
Check if Clang profile instrumenation is on.
XRayInstrSet XRayInstrumentationBundle
Set of XRay instrumentation kinds to emit.
bool hasSanitizeCoverage() const
bool hasReducedDebugInfo() const
Check if type and variable info should be emitted.
bool hasSanitizeBinaryMetadata() const
unsigned getInAllocaFieldIndex() const
bool getIndirectByVal() const
@ InAlloca
InAlloca - Pass the argument directly using the LLVM inalloca attribute.
@ Indirect
Indirect - Pass the argument indirectly via a hidden pointer with the specified alignment (0 indicate...
bool isSRetAfterThis() const
CharUnits getIndirectAlign() const
Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...
llvm::Value * emitRawPointer(CodeGenFunction &CGF) const
Return the pointer contained in this class after authenticating it and adding offset to it if necessa...
CharUnits getAlignment() const
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Address withElementType(llvm::Type *ElemTy) const
Return address with different element type, but same pointer and alignment.
llvm::PointerType * getType() const
Return the type of the pointer value.
A scoped helper to set the current debug location to the specified location or preferred location of ...
static ApplyDebugLocation CreateDefaultArtificial(CodeGenFunction &CGF, SourceLocation TemporaryLocation)
Apply TemporaryLocation if it is valid.
This is an IRBuilder insertion helper that forwards to CodeGenFunction::InsertHelper,...
void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB, llvm::BasicBlock::iterator InsertPt) const override
This forwards to CodeGenFunction::InsertHelper.
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
llvm::CallInst * CreateMemSet(Address Dest, llvm::Value *Value, llvm::Value *Size, bool IsVolatile=false)
Address CreateStructGEP(Address Addr, unsigned Index, const llvm::Twine &Name="")
llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)
llvm::LoadInst * CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Address CreateInBoundsGEP(Address Addr, ArrayRef< llvm::Value * > IdxList, llvm::Type *ElementType, CharUnits Align, const Twine &Name="")
virtual void emitDeviceStub(CodeGenFunction &CGF, FunctionArgList &Args)=0
Emits a kernel launch stub.
Implements C++ ABI-specific code generation functions.
virtual bool hasMostDerivedReturn(GlobalDecl GD) const
virtual bool HasThisReturn(GlobalDecl GD) const
Returns true if the given constructor or destructor is one of the kinds that the ABI says returns 'th...
virtual void EmitInstanceFunctionProlog(CodeGenFunction &CGF)=0
Emit the ABI-specific prolog for the function.
@ RAA_DirectInMemory
Pass it on the stack using its defined layout.
void buildThisParam(CodeGenFunction &CGF, FunctionArgList &Params)
Build a parameter variable suitable for 'this'.
virtual void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy, FunctionArgList &Params)=0
Insert any ABI-specific implicit parameters into the parameter list for a function.
virtual RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const =0
Returns how an argument of the given record type should be passed.
MangleContext & getMangleContext()
Gets the mangle context.
All available information about a concrete callee.
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
CGFunctionInfo - Class to encapsulate the information about a function definition.
ABIArgInfo & getReturnInfo()
bool isReturnsRetained() const
In ARC, whether this function retains its return value.
CanQualType getReturnType() const
bool isDelegateCall() const
unsigned getMaxVectorWidth() const
Return the maximum vector width in the arguments.
llvm::StructType * getArgStruct() const
Get the struct type used to represent all the arguments in memory.
void emitEntryFunction(const FunctionDecl *FD, llvm::Function *Fn)
virtual void functionFinished(CodeGenFunction &CGF)
Cleans up references to the objects in finished function.
llvm::OpenMPIRBuilder & getOMPBuilder()
virtual void emitFunctionProlog(CodeGenFunction &CGF, const Decl *D)
Emits OpenMP-specific function prolog.
virtual ~CGCapturedStmtInfo()
CGFPOptionsRAII(CodeGenFunction &CGF, FPOptions FPFeatures)
SanitizerScope(CodeGenFunction *CGF)
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
void EmitDestructorBody(FunctionArgList &Args)
void EmitBranchToCounterBlock(const Expr *Cond, BinaryOperator::Opcode LOp, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount=0, Stmt::Likelihood LH=Stmt::LH_None, const Expr *CntrIdx=nullptr)
EmitBranchToCounterBlock - Emit a conditional branch to a new block that increments a profile counter...
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
void EmitNullInitialization(Address DestPtr, QualType Ty)
EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts=false)
ContainsLabel - Return true if the statement contains a label in it.
void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount, Stmt::Likelihood LH=Stmt::LH_None, const Expr *ConditionalOp=nullptr)
EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g.
llvm::CallInst * EmitTrapCall(llvm::Intrinsic::ID IntrID)
Emit a call to trap or debugtrap and attach function attribute "trap-func-name" if specified.
JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target)
The given basic block lies in the current EH scope, but may be a target of a potentially scope-crossi...
void EmitSanitizerStatReport(llvm::SanitizerStatKind SSK)
SanitizerSet SanOpts
Sanitizers enabled for this function.
void unprotectFromPeepholes(PeepholeProtection protection)
void EmitLambdaStaticInvokeBody(const CXXMethodDecl *MD)
bool ShouldInstrumentFunction()
ShouldInstrumentFunction - Return true if the current function should be instrumented with __cyg_prof...
Address EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
static bool hasScalarEvaluationKind(QualType T)
FieldDecl * LambdaThisCaptureField
LValue MakeNaturalAlignPointeeRawAddrLValue(llvm::Value *V, QualType T)
Same as MakeNaturalAlignPointeeAddrLValue except that the pointer is known to be unsigned.
void EmitKCFIOperandBundle(const CGCallee &Callee, SmallVectorImpl< llvm::OperandBundleDef > &Bundles)
void emitAlignmentAssumptionCheck(llvm::Value *Ptr, QualType Ty, SourceLocation Loc, SourceLocation AssumptionLoc, llvm::Value *Alignment, llvm::Value *OffsetValue, llvm::Value *TheCheck, llvm::Instruction *Assumption)
llvm::BlockAddress * GetAddrOfLabel(const LabelDecl *L)
RawAddress CreateDefaultAlignTempAlloca(llvm::Type *Ty, const Twine &Name="tmp")
CreateDefaultAlignedTempAlloca - This creates an alloca with the default ABI alignment of the given L...
llvm::Value * emitArrayLength(const ArrayType *arrayType, QualType &baseType, Address &addr)
emitArrayLength - Compute the length of an array, even if it's a VLA, and drill down to the base elem...
VlaSizePair getVLASize(const VariableArrayType *vla)
Returns an LLVM value that corresponds to the size, in non-variably-sized elements,...
void EmitEndEHSpec(const Decl *D)
EmitEndEHSpec - Emit the end of the exception spec.
bool CurFuncIsThunk
In C++, whether we are code generating a thunk.
void EmitAArch64MultiVersionResolver(llvm::Function *Resolver, ArrayRef< MultiVersionResolverOption > Options)
LValue EmitLValue(const Expr *E, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
EmitLValue - Emit code to compute a designator that specifies the location of the expression.
void EmitVariablyModifiedType(QualType Ty)
EmitVLASize - Capture all the sizes for the VLA expressions in the given variably-modified type and s...
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB, llvm::BasicBlock::iterator InsertPt) const
CGBuilder insert helper.
const LangOptions & getLangOpts() const
void EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc, SourceLocation EndLoc)
EmitFunctionEpilog - Emit the target specific LLVM code to return the given temporary.
llvm::Constant * EmitCheckTypeDescriptor(QualType T)
Emit a description of a type in a format suitable for passing to a runtime sanitizer handler.
llvm::BasicBlock * EHResumeBlock
EHResumeBlock - Unified block containing a call to llvm.eh.resume.
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
static bool isInstrumentedCondition(const Expr *C)
isInstrumentedCondition - Determine whether the given condition is an instrumentable condition (i....
void EmitX86MultiVersionResolver(llvm::Function *Resolver, ArrayRef< MultiVersionResolverOption > Options)
void EmitFunctionBody(const Stmt *Body)
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.
RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)
EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...
@ TCK_ConstructorCall
Checking the 'this' pointer for a constructor call.
@ TCK_MemberCall
Checking the 'this' pointer for a call to a non-static member function.
void setCurrentProfileCount(uint64_t Count)
Set the profiler's current count.
void EmitIgnoredExpr(const Expr *E)
EmitIgnoredExpr - Emit an expression in a context which ignores the result.
void PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize, std::initializer_list< llvm::Value ** > ValuesToReload={})
Takes the old cleanup stack size and emits the cleanup blocks that have been added.
llvm::Type * ConvertTypeForMem(QualType T)
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
llvm::AssertingVH< llvm::Instruction > AllocaInsertPt
AllocaInsertPoint - This is an instruction in the entry block before which we prefer to insert alloca...
bool AlwaysEmitXRayCustomEvents() const
AlwaysEmitXRayCustomEvents - Return true if we must unconditionally emit XRay custom event handling c...
JumpDest ReturnBlock
ReturnBlock - Unified return block.
void EmitVarAnnotations(const VarDecl *D, llvm::Value *V)
Emit local annotations for the local variable V, declared by D.
static const Expr * stripCond(const Expr *C)
Ignore parentheses and logical-NOT to track conditions consistently.
PeepholeProtection protectFromPeepholes(RValue rvalue)
protectFromPeepholes - Protect a value that we're intending to store to the side, but which will prob...
const TargetInfo & getTarget() const
llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Location)
Converts Location to a DebugLoc, if debug information is enabled.
void EmitFunctionProlog(const CGFunctionInfo &FI, llvm::Function *Fn, const FunctionArgList &Args)
EmitFunctionProlog - Emit the target specific LLVM code to load the arguments for the given function.
Address EmitPointerWithAlignment(const Expr *Addr, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
EmitPointerWithAlignment - Given an expression with a pointer type, emit the value and compute our be...
void EmitCheck(ArrayRef< std::pair< llvm::Value *, SanitizerMask > > Checked, SanitizerHandler Check, ArrayRef< llvm::Constant * > StaticArgs, ArrayRef< llvm::Value * > DynamicArgs)
Create a basic block that will either trap or call a handler function in the UBSan runtime with the p...
void EmitBlockWithFallThrough(llvm::BasicBlock *BB, const Stmt *S)
bool ShouldSkipSanitizerInstrumentation()
ShouldSkipSanitizerInstrumentation - Return true if the current function should not be instrumented w...
uint64_t getCurrentProfileCount()
Get the profiler's current count.
SmallVector< const BinaryOperator *, 16 > MCDCLogOpStack
Stack to track the Logical Operator recursion nest for MC/DC.
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.
bool HaveInsertPoint() const
HaveInsertPoint - True if an insertion point is defined.
llvm::Constant * EmitCheckSourceLocation(SourceLocation Loc)
Emit a description of a source location in a format suitable for passing to a runtime sanitizer handl...
void markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn)
Annotate the function with an attribute that disables TSan checking at runtime.
void ErrorUnsupported(const Stmt *S, const char *Type)
ErrorUnsupported - Print out an error that codegen doesn't support the specified stmt yet.
CGDebugInfo * getDebugInfo()
Address EmitVAListRef(const Expr *E)
void EmitBranch(llvm::BasicBlock *Block)
EmitBranch - Emit a branch to the specified basic block from the current insert block,...
void maybeCreateMCDCCondBitmap()
Allocate a temp value on the stack that MCDC can use to track condition results.
void emitAlignmentAssumption(llvm::Value *PtrValue, QualType Ty, SourceLocation Loc, SourceLocation AssumptionLoc, llvm::Value *Alignment, llvm::Value *OffsetValue=nullptr)
llvm::Value * emitBoolVecConversion(llvm::Value *SrcVec, unsigned NumElementsDst, const llvm::Twine &Name="")
LValue MakeNaturalAlignRawAddrLValue(llvm::Value *V, QualType T)
bool ShouldXRayInstrumentFunction() const
ShouldXRayInstrument - Return true if the current function should be instrumented with XRay nop sleds...
void EmitStartEHSpec(const Decl *D)
EmitStartEHSpec - Emit the start of the exception spec.
void EmitMultiVersionResolver(llvm::Function *Resolver, ArrayRef< MultiVersionResolverOption > Options)
llvm::Value * EmitCheckValue(llvm::Value *V)
Convert a value into a format suitable for passing to a runtime sanitizer handler.
VlaSizePair getVLAElements1D(const VariableArrayType *vla)
Return the number of elements for a single dimension for the given array type.
bool AlwaysEmitXRayTypedEvents() const
AlwaysEmitXRayTypedEvents - Return true if clang must unconditionally emit XRay typed event handling ...
void EmitConstructorBody(FunctionArgList &Args)
void SetFastMathFlags(FPOptions FPFeatures)
Set the codegen fast-math flags.
ASTContext & getContext() const
const Decl * CurFuncDecl
CurFuncDecl - Holds the Decl for the current outermost non-closure context.
void maybeUpdateMCDCCondBitmap(const Expr *E, llvm::Value *Val)
Update the MCDC temp value with the condition's evaluated result.
void checkTargetFeatures(const CallExpr *E, const FunctionDecl *TargetDecl)
void EmitLambdaInAllocaCallOpBody(const CXXMethodDecl *MD)
llvm::SmallVector< char, 256 > LifetimeExtendedCleanupStack
void EmitDeclRefExprDbgValue(const DeclRefExpr *E, const APValue &Init)
void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)
bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result, bool AllowLabels=false)
ConstantFoldsToSimpleInteger - If the specified expression does not fold to a constant,...
Address ReturnValuePointer
ReturnValuePointer - The temporary alloca to hold a pointer to sret.
llvm::ConstantInt * getUBSanFunctionTypeHash(QualType T) const
Return a type hash constant for a function instrumented by -fsanitize=function.
JumpDest getJumpDestForLabel(const LabelDecl *S)
getBasicBlockForLabel - Return the LLVM basicblock that the specified label maps to.
llvm::DenseMap< const ValueDecl *, FieldDecl * > LambdaCaptureFields
bool AutoreleaseResult
In ARC, whether we should autorelease the return value.
llvm::Type * ConvertType(QualType T)
CodeGenTypes & getTypes() const
bool IsSanitizerScope
True if CodeGen currently emits code implementing sanitizer checks.
void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, LValue LV, QualType Type, SanitizerSet SkippedChecks=SanitizerSet(), llvm::Value *ArraySize=nullptr)
LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T)
llvm::SmallVector< const ParmVarDecl *, 4 > FnArgs
Save Parameter Decl for coroutine.
QualType BuildFunctionArgList(GlobalDecl GD, FunctionArgList &Args)
RawAddress NormalCleanupDest
i32s containing the indexes of the cleanup destinations.
llvm::Value * EvaluateExprAsBool(const Expr *E)
EvaluateExprAsBool - Perform the usual unary conversions on the specified expression and compare the ...
Address EmitMSVAListRef(const Expr *E)
Emit a "reference" to a __builtin_ms_va_list; this is always the value of the expression,...
VarBypassDetector Bypasses
EHScopeStack::stable_iterator PrologueCleanupDepth
PrologueCleanupDepth - The cleanup depth enclosing all the cleanups associated with the parameters.
static bool mightAddDeclToScope(const Stmt *S)
Determine if the given statement might introduce a declaration into the current scope,...
uint64_t getProfileCount(const Stmt *S)
Get the profiler's count for the given statement.
RawAddress CreateIRTemp(QualType T, const Twine &Name="tmp")
CreateIRTemp - Create a temporary IR object of the given type, with appropriate alignment.
void emitImplicitAssignmentOperatorBody(FunctionArgList &Args)
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
const CGFunctionInfo * CurFnInfo
Address EmitFieldAnnotations(const FieldDecl *D, Address V)
Emit field annotations for the given field & value.
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
void EmitStmt(const Stmt *S, ArrayRef< const Attr * > Attrs=std::nullopt)
EmitStmt - Emit the code for the statement.
void EnsureInsertPoint()
EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go.
LValue MakeNaturalAlignPointeeAddrLValue(llvm::Value *V, QualType T)
Given a value of type T* that may not be to a complete object, construct an l-value with the natural ...
llvm::LLVMContext & getLLVMContext()
bool SawAsmBlock
Whether we processed a Microsoft-style asm block during CodeGen.
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...
bool checkIfFunctionMustProgress()
Returns true if a function must make progress, which means the mustprogress attribute can be added.
void incrementProfileCounter(const Stmt *S, llvm::Value *StepV=nullptr)
Increment the profiler's counter for the given statement by StepV.
llvm::Value * EmitAnnotationCall(llvm::Function *AnnotationFn, llvm::Value *AnnotatedVal, StringRef AnnotationStr, SourceLocation Location, const AnnotateAttr *Attr)
Emit an annotation call (intrinsic).
llvm::BasicBlock * GetIndirectGotoBlock()
llvm::DebugLoc EmitReturnBlock()
Emit the unified return block, trying to avoid its emission when possible.
void GenerateCode(GlobalDecl GD, llvm::Function *Fn, const CGFunctionInfo &FnInfo)
LValue EmitLValueForLambdaField(const FieldDecl *Field)
static bool containsBreak(const Stmt *S)
containsBreak - Return true if the statement contains a break out of it.
This class organizes the cross-function state that is used while generating LLVM code.
CGHLSLRuntime & getHLSLRuntime()
Return a reference to the configured HLSL runtime.
llvm::Constant * EmitAnnotationArgs(const AnnotateAttr *Attr)
Emit additional args of the annotation.
llvm::Module & getModule() const
DiagnosticsEngine & getDiags() const
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn't support the specified stmt yet.
const LangOptions & getLangOpts() const
CGCUDARuntime & getCUDARuntime()
Return a reference to the configured CUDA runtime.
llvm::Constant * EmitAnnotationLineNo(SourceLocation L)
Emit the annotation line number.
CharUnits getNaturalTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, bool forPointeeType=false)
CodeGenTypes & getTypes()
const llvm::DataLayout & getDataLayout() const
CGCXXABI & getCXXABI() const
CGOpenMPRuntime & getOpenMPRuntime()
Return a reference to the configured OpenMP runtime.
bool imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc, StringRef Category=StringRef()) const
Imbue XRay attributes to a function, applying the always/never attribute lists in the process.
ProfileList::ExclusionType isFunctionBlockedFromProfileInstr(llvm::Function *Fn, SourceLocation Loc) const
ASTContext & getContext() const
llvm::SanitizerStatReport & getSanStats()
llvm::Constant * EmitAnnotationString(StringRef Str)
Emit an annotation string.
const TargetCodeGenInfo & getTargetCodeGenInfo()
const CodeGenOptions & getCodeGenOpts() const
llvm::LLVMContext & getLLVMContext()
void GenKernelArgMetadata(llvm::Function *FN, const FunctionDecl *FD=nullptr, CodeGenFunction *CGF=nullptr)
OpenCL v1.2 s5.6.4.6 allows the compiler to store kernel argument information in the program executab...
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
llvm::ConstantInt * CreateKCFITypeId(QualType T)
Generate a KCFI type identifier for T.
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys=std::nullopt)
bool MayDropFunctionReturn(const ASTContext &Context, QualType ReturnType) const
Whether this function's return type has no side effects, and thus may be trivially discarded if it is...
llvm::Constant * EmitAnnotationUnit(SourceLocation Loc)
Emit the annotation's translation unit.
llvm::ConstantInt * getSize(CharUnits numChars)
Emit the given number of characters as a value of type size_t.
void assignRegionCounters(GlobalDecl GD, llvm::Function *Fn)
Assign counters to regions and configure them for PGO of a given function.
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
bool inheritingCtorHasParams(const InheritedConstructor &Inherited, CXXCtorType Type)
Determine if a C++ inheriting constructor should have parameters matching those of its inherited cons...
bool isZeroInitializable(QualType T)
IsZeroInitializable - Return whether a type can be zero-initialized (in the C++ sense) with an LLVM z...
llvm::Type * ConvertTypeForMem(QualType T, bool ForBitField=false)
ConvertTypeForMem - Convert type T into a llvm::Type.
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
bool containsOnlyLifetimeMarkers(stable_iterator Old) const
bool empty() const
Determines whether the exception-scopes stack is empty.
FunctionArgList - Type for representing both the decl and type of parameters to a function.
LValue - This represents an lvalue references.
Address getAddress(CodeGenFunction &CGF) const
llvm::Value * getPointer(CodeGenFunction &CGF) const
void InsertHelper(llvm::Instruction *I) const
Function called by the CodeGenFunction when an instruction is created.
RValue - This trivial value class is used to represent the result of an expression that is evaluated.
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
llvm::Value * getPointer() const
virtual void checkFunctionABI(CodeGenModule &CGM, const FunctionDecl *Decl) const
Any further codegen related checks that need to be done on a function signature in a target specific ...
virtual llvm::Constant * getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const
Return a constant used by UBSan as a signature to identify functions possessing type information,...
void Init(const Stmt *Body)
Clear the object and pre-process for the given statement, usually function body statement.
CompoundStmt - This represents a group of statements like { stmt stmt }.
ConditionalOperator - The ?: ternary operator.
A reference to a declared variable, function, enum, etc.
Decl - This represents one declaration (or definition), e.g.
ASTContext & getASTContext() const LLVM_READONLY
Decl * getNonClosureContext()
Find the innermost non-closure ancestor of this declaration, walking up through blocks,...
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
SourceLocation getLocation() const
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
This represents one expression.
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const
Returns the set of floating point options that apply to this expression.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
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...
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
ExtVectorType - Extended vector type.
LangOptions::FPExceptionModeKind getExceptionMode() const
bool allowFPContractAcrossStatement() const
RoundingMode getRoundingMode() const
Represents a member of a struct/union/class.
Represents a function declaration or definition.
bool isMultiVersion() const
True if this function is considered a multiversioned function.
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
bool UsesFPIntrin() const
Determine whether the function was declared in source context that requires constrained FP intrinsics...
bool usesSEHTry() const
Indicates the function uses __try.
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
bool isMSVCRTEntryPoint() const
Determines whether this function is a MSVCRT user defined entry point.
bool isInlineBuiltinDeclaration() const
Determine if this function provides an inline implementation of a builtin.
bool hasImplicitReturnZero() const
Whether falling off this function implicitly returns null/zero.
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program.
bool isDefaulted() const
Whether this function is defaulted.
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
Represents a prototype with parameter type info, e.g.
GlobalDecl - represents a global declaration.
CXXCtorType getCtorType() const
const Decl * getDecl() const
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)
Create implicit parameter.
Represents the declaration of a label.
FPExceptionModeKind
Possible floating point exception behavior.
@ FPE_Strict
Strictly preserve the floating-point exception semantics.
@ FPE_MayTrap
Transformations do not cause new exceptions but may hide some.
@ FPE_Ignore
Assume that floating-point exceptions are masked.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
SanitizerSet Sanitize
Set of enabled sanitizers.
RoundingMode getDefaultRoundingMode() const
virtual void mangleCanonicalTypeName(QualType T, raw_ostream &, bool NormalizeIntegers=false)=0
Generates a unique string for an externally visible type for use with TBAA or type uniquing.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Represents a parameter to a function.
ParsedAttr - Represents a syntactic attribute.
PointerType - C99 6.7.5.1 - Pointer Declarators.
@ Forbid
Profiling is forbidden using the noprofile attribute.
@ Skip
Profiling is skipped using the skipprofile attribute.
@ Allow
Profiling is allowed.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
field_range fields() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Encodes a location in the source.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
StmtClass getStmtClass() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Likelihood
The likelihood of a branch being taken.
@ LH_Unlikely
Branch has the [[unlikely]] attribute.
@ LH_None
No attribute set or branches of the IfStmt have the same attribute.
@ LH_Likely
Branch has the [[likely]] attribute.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
bool supportsIFunc() const
Identify whether this target supports IFuncs.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
virtual std::optional< std::pair< unsigned, unsigned > > getVScaleRange(const LangOptions &LangOpts) const
Returns target-specific min and max values VScale_Range.
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
bool isPointerType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
TypeClass getTypeClass() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
bool isObjCRetainableType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
bool isFunctionNoProtoType() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Represents a variable declaration or definition.
Represents a C array with a specified size that is not an integer-constant-expression.
Expr * getSizeExpr() const
QualType getElementType() const
Defines the clang::TargetInfo interface.
bool evaluateRequiredTargetFeatures(llvm::StringRef RequiredFatures, const llvm::StringMap< bool > &TargetFetureMap)
Returns true if the required target features of a builtin function are enabled.
TypeEvaluationKind
The kind of evaluation to perform on values of a particular type.
constexpr XRayInstrMask Typed
constexpr XRayInstrMask FunctionExit
constexpr XRayInstrMask FunctionEntry
constexpr XRayInstrMask Custom
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< ArrayType > arrayType
Matches all kinds of arrays.
bool Zero(InterpState &S, CodePtr OpPC)
The JSON file list parser is used to communicate input to InstallAPI.
@ NonNull
Values of this type can never be null.
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Result
The result type of a method or function.
const FunctionProtoType * T
llvm::fp::ExceptionBehavior ToConstrainedExceptMD(LangOptions::FPExceptionModeKind Kind)
@ Other
Other implicit parameter.
@ EST_None
no exception specification
@ Implicit
An implicit conversion.
Diagnostic wrappers for TextAPI types for error reporting.
cl::opt< bool > EnableSingleByteCoverage
llvm::BasicBlock * getBlock() const
This structure provides a set of types that are commonly used during IR emission.
llvm::PointerType * ConstGlobalsPtrTy
void* in the address space for constant globals
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
llvm::IntegerType * SizeTy
llvm::IntegerType * Int32Ty
llvm::IntegerType * IntPtrTy
llvm::PointerType * Int8PtrTy
CharUnits getPointerAlign() const
EvalResult is a struct with detailed info about an evaluated expression.
Contains information gathered from parsing the contents of TargetAttr.
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.
SanitizerMask Mask
Bitmask of enabled sanitizers.
bool hasOneOf(SanitizerMask K) const
Check if one or more sanitizers are enabled.
bool has(XRayInstrMask K) const