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() {
95 "missed to deactivate a cleanup");
111llvm::fp::ExceptionBehavior
119 llvm_unreachable(
"Unsupported FP Exception Behavior");
124 llvm::FastMathFlags FMF;
125 FMF.setAllowReassoc(FPFeatures.getAllowFPReassociate());
126 FMF.setNoNaNs(FPFeatures.getNoHonorNaNs());
127 FMF.setNoInfs(FPFeatures.getNoHonorInfs());
128 FMF.setNoSignedZeros(FPFeatures.getNoSignedZero());
129 FMF.setAllowReciprocal(FPFeatures.getAllowReciprocal());
130 FMF.setApproxFunc(FPFeatures.getAllowApproxFunc());
144 ConstructorHelper(FPFeatures);
147void CodeGenFunction::CGFPOptionsRAII::ConstructorHelper(
FPOptions FPFeatures) {
148 OldFPFeatures = CGF.CurFPFeatures;
149 CGF.CurFPFeatures = FPFeatures;
151 OldExcept = CGF.Builder.getDefaultConstrainedExcept();
152 OldRounding = CGF.Builder.getDefaultConstrainedRounding();
154 if (OldFPFeatures == FPFeatures)
157 FMFGuard.emplace(CGF.Builder);
160 CGF.Builder.setDefaultConstrainedRounding(NewRoundingBehavior);
161 auto NewExceptionBehavior =
164 CGF.Builder.setDefaultConstrainedExcept(NewExceptionBehavior);
166 CGF.SetFastMathFlags(FPFeatures);
168 assert((CGF.CurFuncDecl ==
nullptr || CGF.Builder.getIsFPConstrained() ||
169 isa<CXXConstructorDecl>(CGF.CurFuncDecl) ||
170 isa<CXXDestructorDecl>(CGF.CurFuncDecl) ||
171 (NewExceptionBehavior == llvm::fp::ebIgnore &&
172 NewRoundingBehavior == llvm::RoundingMode::NearestTiesToEven)) &&
173 "FPConstrained should be enabled on entire function");
175 auto mergeFnAttrValue = [&](StringRef Name,
bool Value) {
177 CGF.CurFn->getFnAttribute(Name).getValueAsBool();
178 auto NewValue = OldValue &
Value;
179 if (OldValue != NewValue)
180 CGF.CurFn->addFnAttr(Name, llvm::toStringRef(NewValue));
182 mergeFnAttrValue(
"no-infs-fp-math", FPFeatures.getNoHonorInfs());
183 mergeFnAttrValue(
"no-nans-fp-math", FPFeatures.getNoHonorNaNs());
184 mergeFnAttrValue(
"no-signed-zeros-fp-math", FPFeatures.getNoSignedZero());
187 FPFeatures.getAllowFPReassociate() && FPFeatures.getAllowReciprocal() &&
188 FPFeatures.getAllowApproxFunc() && FPFeatures.getNoSignedZero() &&
193 CGF.CurFPFeatures = OldFPFeatures;
194 CGF.Builder.setDefaultConstrainedExcept(OldExcept);
195 CGF.Builder.setDefaultConstrainedRounding(OldRounding);
210 return ::MakeNaturalAlignAddrLValue(
V,
T,
false, *
this);
215 return ::MakeNaturalAlignAddrLValue(
V,
T,
true, *
this);
220 return ::MakeNaturalAlignAddrLValue(
V,
T,
false, *
this);
225 return ::MakeNaturalAlignAddrLValue(
V,
T,
true, *
this);
239 switch (
type->getTypeClass()) {
240#define TYPE(name, parent)
241#define ABSTRACT_TYPE(name, parent)
242#define NON_CANONICAL_TYPE(name, parent) case Type::name:
243#define DEPENDENT_TYPE(name, parent) case Type::name:
244#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(name, parent) case Type::name:
245#include "clang/AST/TypeNodes.inc"
246 llvm_unreachable(
"non-canonical or dependent type in IR-generation");
249 case Type::DeducedTemplateSpecialization:
250 llvm_unreachable(
"undeduced type in IR-generation");
255 case Type::BlockPointer:
256 case Type::LValueReference:
257 case Type::RValueReference:
258 case Type::MemberPointer:
260 case Type::ExtVector:
261 case Type::ConstantMatrix:
262 case Type::FunctionProto:
263 case Type::FunctionNoProto:
265 case Type::ObjCObjectPointer:
275 case Type::ConstantArray:
276 case Type::IncompleteArray:
277 case Type::VariableArray:
279 case Type::ObjCObject:
280 case Type::ObjCInterface:
281 case Type::ArrayParameter:
286 type = cast<AtomicType>(
type)->getValueType();
289 llvm_unreachable(
"unknown type kind!");
296 llvm::BasicBlock *CurBB =
Builder.GetInsertBlock();
299 assert(!CurBB->getTerminator() &&
"Unexpected terminated block.");
309 return llvm::DebugLoc();
316 llvm::BranchInst *BI =
318 if (BI && BI->isUnconditional() &&
322 llvm::DebugLoc
Loc = BI->getDebugLoc();
323 Builder.SetInsertPoint(BI->getParent());
324 BI->eraseFromParent();
336 return llvm::DebugLoc();
341 if (!BB->use_empty()) {
349 assert(BreakContinueStack.empty() &&
350 "mismatched push/pop in break/continue stack!");
352 "mismatched push/pop of cleanups in EHStack!");
354 "mismatched activate/deactivate of cleanups!");
359 "mismatched push/pop in convergence stack!");
362 bool OnlySimpleReturnStmts = NumSimpleReturnExprs > 0
363 && NumSimpleReturnExprs == NumReturnExprs
378 if (OnlySimpleReturnStmts)
379 DI->EmitLocation(
Builder, LastStopPoint);
381 DI->EmitLocation(
Builder, EndLoc);
389 bool HasOnlyLifetimeMarkers =
391 bool EmitRetDbgLoc = !HasCleanups || HasOnlyLifetimeMarkers;
393 std::optional<ApplyDebugLocation> OAL;
398 if (OnlySimpleReturnStmts)
399 DI->EmitLocation(
Builder, EndLoc);
414 CurFn->addFnAttr(
"instrument-function-exit",
"__cyg_profile_func_exit");
416 CurFn->addFnAttr(
"instrument-function-exit-inlined",
417 "__cyg_profile_func_exit");
431 "did not remove all scopes from cleanup stack!");
435 if (IndirectBranch) {
442 if (!EscapedLocals.empty()) {
446 EscapeArgs.resize(EscapedLocals.size());
447 for (
auto &Pair : EscapedLocals)
448 EscapeArgs[Pair.second] = Pair.first;
449 llvm::Function *FrameEscapeFn = llvm::Intrinsic::getDeclaration(
457 Ptr->eraseFromParent();
461 if (PostAllocaInsertPt) {
462 llvm::Instruction *PostPtr = PostAllocaInsertPt;
463 PostAllocaInsertPt =
nullptr;
464 PostPtr->eraseFromParent();
469 if (IndirectBranch) {
470 llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress());
471 if (PN->getNumIncomingValues() == 0) {
472 PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType()));
473 PN->eraseFromParent();
482 for (
const auto &FuncletAndParent : TerminateFunclets)
488 for (
const auto &R : DeferredReplacements) {
489 if (llvm::Value *Old = R.first) {
490 Old->replaceAllUsesWith(R.second);
491 cast<llvm::Instruction>(Old)->eraseFromParent();
494 DeferredReplacements.clear();
503 llvm::DominatorTree DT(*
CurFn);
504 llvm::PromoteMemToReg(
510 for (llvm::Argument &A :
CurFn->args())
511 if (
auto *VT = dyn_cast<llvm::VectorType>(A.getType()))
513 std::max((uint64_t)LargestVectorWidth,
514 VT->getPrimitiveSizeInBits().getKnownMinValue());
517 if (
auto *VT = dyn_cast<llvm::VectorType>(
CurFn->getReturnType()))
519 std::max((uint64_t)LargestVectorWidth,
520 VT->getPrimitiveSizeInBits().getKnownMinValue());
532 if (
getContext().getTargetInfo().getTriple().isX86())
533 CurFn->addFnAttr(
"min-legal-vector-width",
534 llvm::utostr(LargestVectorWidth));
537 std::optional<std::pair<unsigned, unsigned>> VScaleRange =
540 CurFn->addFnAttr(llvm::Attribute::getWithVScaleRangeArgs(
552 if (RetAlloca && RetAlloca->use_empty()) {
553 RetAlloca->eraseFromParent();
606 llvm::raw_string_ostream Out(Mangled);
608 return llvm::ConstantInt::get(
609 CGM.
Int32Ty,
static_cast<uint32_t
>(llvm::xxh3_64bits(Mangled)));
612void CodeGenFunction::EmitKernelMetadata(
const FunctionDecl *FD,
613 llvm::Function *Fn) {
614 if (!FD->
hasAttr<OpenCLKernelAttr>() && !FD->
hasAttr<CUDAGlobalAttr>())
624 if (
const VecTypeHintAttr *A = FD->
getAttr<VecTypeHintAttr>()) {
625 QualType HintQTy = A->getTypeHint();
627 bool IsSignedInteger =
630 llvm::Metadata *AttrMDArgs[] = {
631 llvm::ConstantAsMetadata::get(llvm::UndefValue::get(
633 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
634 llvm::IntegerType::get(Context, 32),
635 llvm::APInt(32, (uint64_t)(IsSignedInteger ? 1 : 0))))};
636 Fn->setMetadata(
"vec_type_hint", llvm::MDNode::get(Context, AttrMDArgs));
639 if (
const WorkGroupSizeHintAttr *A = FD->
getAttr<WorkGroupSizeHintAttr>()) {
640 llvm::Metadata *AttrMDArgs[] = {
641 llvm::ConstantAsMetadata::get(
Builder.getInt32(A->getXDim())),
642 llvm::ConstantAsMetadata::get(
Builder.getInt32(A->getYDim())),
643 llvm::ConstantAsMetadata::get(
Builder.getInt32(A->getZDim()))};
644 Fn->setMetadata(
"work_group_size_hint", llvm::MDNode::get(Context, AttrMDArgs));
647 if (
const ReqdWorkGroupSizeAttr *A = FD->
getAttr<ReqdWorkGroupSizeAttr>()) {
648 llvm::Metadata *AttrMDArgs[] = {
649 llvm::ConstantAsMetadata::get(
Builder.getInt32(A->getXDim())),
650 llvm::ConstantAsMetadata::get(
Builder.getInt32(A->getYDim())),
651 llvm::ConstantAsMetadata::get(
Builder.getInt32(A->getZDim()))};
652 Fn->setMetadata(
"reqd_work_group_size", llvm::MDNode::get(Context, AttrMDArgs));
655 if (
const OpenCLIntelReqdSubGroupSizeAttr *A =
656 FD->
getAttr<OpenCLIntelReqdSubGroupSizeAttr>()) {
657 llvm::Metadata *AttrMDArgs[] = {
658 llvm::ConstantAsMetadata::get(
Builder.getInt32(A->getSubGroupSize()))};
659 Fn->setMetadata(
"intel_reqd_sub_group_size",
660 llvm::MDNode::get(Context, AttrMDArgs));
666 const Stmt *Body =
nullptr;
667 if (
auto *FD = dyn_cast_or_null<FunctionDecl>(F))
669 else if (
auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(F))
670 Body = OMD->getBody();
672 if (
auto *CS = dyn_cast_or_null<CompoundStmt>(Body)) {
673 auto LastStmt = CS->body_rbegin();
674 if (LastStmt != CS->body_rend())
675 return isa<ReturnStmt>(*LastStmt);
682 Fn->addFnAttr(
"sanitize_thread_no_checking_at_run_time");
683 Fn->removeFnAttr(llvm::Attribute::SanitizeThread);
688bool CodeGenFunction::requiresReturnValueCheck()
const {
689 return requiresReturnValueNullabilityCheck() ||
695 auto *MD = dyn_cast_or_null<CXXMethodDecl>(D);
696 if (!MD || !MD->getDeclName().getAsIdentifierInfo() ||
697 !MD->getDeclName().getAsIdentifierInfo()->isStr(
"allocate") ||
698 (MD->getNumParams() != 1 && MD->getNumParams() != 2))
701 if (MD->parameters()[0]->getType().getCanonicalType() != Ctx.
getSizeType())
704 if (MD->getNumParams() == 2) {
705 auto *PT = MD->parameters()[1]->getType()->getAs<
PointerType>();
706 if (!PT || !PT->isVoidPointerType() ||
707 !PT->getPointeeType().isConstQualified())
719bool CodeGenFunction::hasInAllocaArg(
const CXXMethodDecl *MD) {
723 return isInAllocaArgument(CGM.getCXXABI(), P->getType());
730 if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD))
743 "Do not use a CodeGenFunction object for more than one function");
747 DidCallStackSave =
false;
749 const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
756 assert(
CurFn->isDeclaration() &&
"Function already has body?");
761#define SANITIZER(NAME, ID) \
762 if (SanOpts.empty()) \
764 if (SanOpts.has(SanitizerKind::ID)) \
765 if (CGM.isInNoSanitizeList(SanitizerKind::ID, Fn, Loc)) \
766 SanOpts.set(SanitizerKind::ID, false);
768#include "clang/Basic/Sanitizers.def"
775 bool NoSanitizeCoverage =
false;
778 no_sanitize_mask |=
Attr->getMask();
780 if (
Attr->hasCoverage())
781 NoSanitizeCoverage =
true;
786 if (no_sanitize_mask & SanitizerKind::Address)
787 SanOpts.
set(SanitizerKind::KernelAddress,
false);
788 if (no_sanitize_mask & SanitizerKind::KernelAddress)
790 if (no_sanitize_mask & SanitizerKind::HWAddress)
791 SanOpts.
set(SanitizerKind::KernelHWAddress,
false);
792 if (no_sanitize_mask & SanitizerKind::KernelHWAddress)
796 Fn->addFnAttr(llvm::Attribute::NoSanitizeBounds);
799 Fn->addFnAttr(llvm::Attribute::NoSanitizeCoverage);
803 if (no_sanitize_mask & SanitizerKind::Thread)
804 Fn->addFnAttr(
"no_sanitize_thread");
809 CurFn->addFnAttr(llvm::Attribute::DisableSanitizerInstrumentation);
812 if (
SanOpts.
hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress))
813 Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
815 SanitizerKind::KernelHWAddress))
816 Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
818 Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);
820 Fn->addFnAttr(llvm::Attribute::SanitizeThread);
821 if (
SanOpts.
hasOneOf(SanitizerKind::Memory | SanitizerKind::KernelMemory))
822 Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
825 Fn->addFnAttr(llvm::Attribute::SafeStack);
826 if (
SanOpts.
has(SanitizerKind::ShadowCallStack))
827 Fn->addFnAttr(llvm::Attribute::ShadowCallStack);
830 if (
SanOpts.
hasOneOf(SanitizerKind::Fuzzer | SanitizerKind::FuzzerNoLink))
831 Fn->addFnAttr(llvm::Attribute::OptForFuzzing);
836 if (
const auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(D)) {
837 const IdentifierInfo *II = OMD->getSelector().getIdentifierInfoForSlot(0);
840 (OMD->getSelector().isUnarySelector() && II->
isStr(
".cxx_destruct"))) {
849 if (D &&
SanOpts.
has(SanitizerKind::CFIUnrelatedCast)) {
863 bool AlwaysXRayAttr =
false;
864 if (
const auto *XRayAttr = D ? D->
getAttr<XRayInstrumentAttr>() :
nullptr) {
870 Fn->addFnAttr(
"function-instrument",
"xray-always");
871 AlwaysXRayAttr =
true;
873 if (XRayAttr->neverXRayInstrument())
874 Fn->addFnAttr(
"function-instrument",
"xray-never");
875 if (
const auto *LogArgs = D->
getAttr<XRayLogArgsAttr>())
877 Fn->addFnAttr(
"xray-log-args",
878 llvm::utostr(LogArgs->getArgumentCount()));
883 "xray-instruction-threshold",
889 Fn->addFnAttr(
"xray-ignore-loops");
893 Fn->addFnAttr(
"xray-skip-exit");
897 Fn->addFnAttr(
"xray-skip-entry");
900 if (FuncGroups > 1) {
902 CurFn->getName().bytes_end());
903 auto Group = crc32(FuncName) % FuncGroups;
906 Fn->addFnAttr(
"function-instrument",
"xray-never");
913 Fn->addFnAttr(llvm::Attribute::SkipProfile);
916 Fn->addFnAttr(llvm::Attribute::NoProfile);
923 unsigned Count, Offset;
924 if (
const auto *
Attr =
925 D ? D->
getAttr<PatchableFunctionEntryAttr>() :
nullptr) {
926 Count =
Attr->getCount();
927 Offset =
Attr->getOffset();
932 if (Count && Offset <= Count) {
933 Fn->addFnAttr(
"patchable-function-entry", std::to_string(Count - Offset));
935 Fn->addFnAttr(
"patchable-function-prefix", std::to_string(Offset));
942 getContext().getTargetInfo().getTriple().isX86() &&
943 getContext().getTargetInfo().getTriple().getEnvironment() !=
944 llvm::Triple::CODE16)
945 Fn->addFnAttr(
"patchable-function",
"prologue-short-redirect");
949 Fn->addFnAttr(
"no-jump-tables",
"true");
953 Fn->addFnAttr(
"no-inline-line-tables");
957 Fn->addFnAttr(
"profile-sample-accurate");
960 Fn->addFnAttr(
"use-sample-profile");
962 if (D && D->
hasAttr<CFICanonicalJumpTableAttr>())
963 Fn->addFnAttr(
"cfi-canonical-jump-table");
965 if (D && D->
hasAttr<NoProfileFunctionAttr>())
966 Fn->addFnAttr(llvm::Attribute::NoProfile);
970 if (
auto *A = D->
getAttr<FunctionReturnThunksAttr>()) {
971 switch (A->getThunkType()) {
972 case FunctionReturnThunksAttr::Kind::Keep:
974 case FunctionReturnThunksAttr::Kind::Extern:
975 Fn->addFnAttr(llvm::Attribute::FnRetThunkExtern);
979 Fn->addFnAttr(llvm::Attribute::FnRetThunkExtern);
985 EmitKernelMetadata(FD, Fn);
988 if (FD && FD->
hasAttr<ClspvLibclcBuiltinAttr>()) {
989 Fn->setMetadata(
"clspv_libclc_builtin",
995 if (FD &&
SanOpts.
has(SanitizerKind::Function)) {
997 llvm::LLVMContext &Ctx = Fn->getContext();
998 llvm::MDBuilder MDB(Ctx);
1000 llvm::LLVMContext::MD_func_sanitize,
1001 MDB.createRTTIPointerPrologue(
1008 if (
SanOpts.
has(SanitizerKind::NullabilityReturn)) {
1012 if (!(
SanOpts.
has(SanitizerKind::ReturnsNonnullAttribute) &&
1014 RetValNullabilityPrecondition =
1033 Fn->addFnAttr(llvm::Attribute::NoRecurse);
1036 llvm::fp::ExceptionBehavior FPExceptionBehavior =
1038 Builder.setDefaultConstrainedRounding(RM);
1039 Builder.setDefaultConstrainedExcept(FPExceptionBehavior);
1041 (!FD && (FPExceptionBehavior != llvm::fp::ebIgnore ||
1042 RM != llvm::RoundingMode::NearestTiesToEven))) {
1043 Builder.setIsFPConstrained(
true);
1044 Fn->addFnAttr(llvm::Attribute::StrictFP);
1051 Fn->addFnAttr(
"stackrealign");
1055 Fn->removeFnAttr(
"zero-call-used-regs");
1062 llvm::Value *Undef = llvm::UndefValue::get(
Int32Ty);
1067 Builder.SetInsertPoint(EntryBB);
1071 if (requiresReturnValueCheck()) {
1082 DI->emitFunctionStart(GD,
Loc, StartLoc,
1083 DI->getFunctionType(FD, RetTy, Args),
CurFn,
1089 CurFn->addFnAttr(
"instrument-function-entry",
"__cyg_profile_func_enter");
1091 CurFn->addFnAttr(
"instrument-function-entry-inlined",
1092 "__cyg_profile_func_enter");
1094 CurFn->addFnAttr(
"instrument-function-entry-inlined",
1095 "__cyg_profile_func_enter_bare");
1107 Fn->addFnAttr(
"fentry-call",
"true");
1109 Fn->addFnAttr(
"instrument-function-entry-inlined",
1115 <<
"-mnop-mcount" <<
"-mfentry";
1116 Fn->addFnAttr(
"mnop-mcount");
1122 <<
"-mrecord-mcount" <<
"-mfentry";
1123 Fn->addFnAttr(
"mrecord-mcount");
1129 if (
getContext().getTargetInfo().getTriple().getArch() !=
1130 llvm::Triple::systemz)
1132 <<
"-mpacked-stack";
1133 Fn->addFnAttr(
"packed-stack");
1138 Fn->addFnAttr(
"warn-stack-size",
1151 auto AI =
CurFn->arg_begin();
1167 llvm::Function::arg_iterator EI =
CurFn->arg_end();
1172 cast<llvm::GetElementPtrInst>(Addr)->getResultElementType();
1198 if (D && D->
hasAttr<HLSLShaderAttr>())
1203 if (
const CXXMethodDecl *MD = dyn_cast_if_present<CXXMethodDecl>(D);
1224 CXXThisValue = ThisFieldLValue.
getPointer(*
this);
1233 if (FD->hasCapturedVLAType()) {
1236 auto VAT = FD->getCapturedVLAType();
1237 VLASizeMap[VAT->getSizeExpr()] = ExprArg;
1244 CXXThisValue = CXXABIThisValue;
1248 if (CXXABIThisValue) {
1250 SkippedChecks.
set(SanitizerKind::ObjectSize,
true);
1257 SkippedChecks.
set(SanitizerKind::Null,
true);
1261 Loc, CXXABIThisValue, ThisTy, CXXABIThisAlignment, SkippedChecks);
1268 if (!FD || !FD->
hasAttr<NakedAttr>()) {
1269 for (
const VarDecl *VD : Args) {
1274 if (
const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD))
1275 Ty = PVD->getOriginalType();
1285 DI->EmitLocation(
Builder, StartLoc);
1290 LargestVectorWidth = VecWidth->getVectorWidth();
1299 if (
const CompoundStmt *S = dyn_cast<CompoundStmt>(Body))
1311 llvm::BasicBlock *SkipCountBB =
nullptr;
1336 if (F->isInterposable())
return;
1338 for (llvm::BasicBlock &BB : *F)
1339 for (llvm::Instruction &I : BB)
1343 F->setDoesNotThrow();
1363 bool PassedParams =
true;
1365 if (
auto Inherited = CD->getInheritedConstructor())
1371 Args.push_back(Param);
1372 if (!Param->hasAttr<PassObjectSizeAttr>())
1376 getContext(), Param->getDeclContext(), Param->getLocation(),
1383 if (MD && (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)))
1391 assert(Fn &&
"generating code for null Function");
1404 std::string FDInlineName = (Fn->getName() +
".inline").str();
1405 llvm::Module *M = Fn->getParent();
1406 llvm::Function *Clone = M->getFunction(FDInlineName);
1408 Clone = llvm::Function::Create(Fn->getFunctionType(),
1409 llvm::GlobalValue::InternalLinkage,
1410 Fn->getAddressSpace(), FDInlineName, M);
1411 Clone->addFnAttr(llvm::Attribute::AlwaysInline);
1413 Fn->setLinkage(llvm::GlobalValue::ExternalLinkage);
1423 if (LLVM_UNLIKELY(PD->isInlineBuiltinDeclaration())) {
1424 std::string FDInlineName = (Fn->getName() +
".inline").str();
1425 llvm::Module *M = Fn->getParent();
1426 if (llvm::Function *Clone = M->getFunction(FDInlineName)) {
1427 Clone->replaceAllUsesWith(Fn);
1428 Clone->eraseFromParent();
1436 if (FD->
hasAttr<NoDebugAttr>()) {
1439 Fn->setSubprogram(
nullptr);
1441 DebugInfo =
nullptr;
1451 CurEHLocation = BodyRange.
getEnd();
1463 if (SpecDecl->hasBody(SpecDecl))
1464 Loc = SpecDecl->getLocation();
1470 if (isa<CoroutineBodyStmt>(Body))
1471 ShouldEmitLifetimeMarkers =
true;
1475 if (ShouldEmitLifetimeMarkers)
1483 if (Body && isa_and_nonnull<CoroutineBodyStmt>(Body))
1491 CurFn->addFnAttr(llvm::Attribute::MustProgress);
1495 if (isa<CXXDestructorDecl>(FD))
1497 else if (isa<CXXConstructorDecl>(FD))
1501 FD->
hasAttr<CUDAGlobalAttr>())
1503 else if (isa<CXXMethodDecl>(FD) &&
1504 cast<CXXMethodDecl>(FD)->isLambdaStaticInvoker()) {
1508 }
else if (isa<CXXMethodDecl>(FD) &&
1511 cast<CXXMethodDecl>(FD)->getParent()->getLambdaStaticInvoker() &&
1512 hasInAllocaArg(cast<CXXMethodDecl>(FD))) {
1519 }
else if (FD->
isDefaulted() && isa<CXXMethodDecl>(FD) &&
1520 (cast<CXXMethodDecl>(FD)->isCopyAssignmentOperator() ||
1521 cast<CXXMethodDecl>(FD)->isMoveAssignmentOperator())) {
1528 llvm_unreachable(
"no definition for emitted function");
1538 bool ShouldEmitUnreachable =
1542 SanitizerScope SanScope(
this);
1543 llvm::Value *IsFalse =
Builder.getFalse();
1544 EmitCheck(std::make_pair(IsFalse, SanitizerKind::Return),
1545 SanitizerHandler::MissingReturn,
1547 }
else if (ShouldEmitUnreachable) {
1551 if (
SanOpts.
has(SanitizerKind::Return) || ShouldEmitUnreachable) {
1553 Builder.ClearInsertionPoint();
1562 if (!
CurFn->doesNotThrow())
1571 if (!S)
return false;
1578 if (isa<LabelStmt>(S))
1583 if (isa<SwitchCase>(S) && !IgnoreCaseStmts)
1587 if (isa<SwitchStmt>(S))
1588 IgnoreCaseStmts =
true;
1591 for (
const Stmt *SubStmt : S->children())
1603 if (!S)
return false;
1607 if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || isa<DoStmt>(S) ||
1611 if (isa<BreakStmt>(S))
1615 for (
const Stmt *SubStmt : S->children())
1623 if (!S)
return false;
1629 if (isa<IfStmt>(S) || isa<SwitchStmt>(S) || isa<WhileStmt>(S) ||
1630 isa<DoStmt>(S) || isa<ForStmt>(S) || isa<CompoundStmt>(S) ||
1631 isa<CXXForRangeStmt>(S) || isa<CXXTryStmt>(S) ||
1632 isa<ObjCForCollectionStmt>(S) || isa<ObjCAtTryStmt>(S))
1635 if (isa<DeclStmt>(S))
1638 for (
const Stmt *SubStmt : S->children())
1658 llvm::APSInt ResultInt;
1662 ResultBool = ResultInt.getBoolValue();
1670 llvm::APSInt &ResultInt,
1688 while (
const UnaryOperator *Op = dyn_cast<UnaryOperator>(
C->IgnoreParens())) {
1689 if (Op->getOpcode() != UO_LNot)
1691 C = Op->getSubExpr();
1693 return C->IgnoreParens();
1709 llvm::BasicBlock *FalseBlock, uint64_t TrueCount ,
1716 llvm::BasicBlock *ThenBlock =
nullptr;
1717 llvm::BasicBlock *ElseBlock =
nullptr;
1718 llvm::BasicBlock *NextBlock =
nullptr;
1735 if (LOp == BO_LAnd) {
1736 ThenBlock = CounterIncrBlock;
1737 ElseBlock = FalseBlock;
1738 NextBlock = TrueBlock;
1753 else if (LOp == BO_LOr) {
1754 ThenBlock = TrueBlock;
1755 ElseBlock = CounterIncrBlock;
1756 NextBlock = FalseBlock;
1758 llvm_unreachable(
"Expected Opcode must be that of a Logical Operator");
1782 const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock,
1786 if (
const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) {
1788 if (CondBOp->getOpcode() == BO_LAnd) {
1793 bool ConstantBool =
false;
1799 FalseBlock, TrueCount, LH);
1810 FalseBlock, TrueCount, LH, CondBOp);
1822 ConditionalEvaluation eval(*
this);
1839 FalseBlock, TrueCount, LH);
1845 if (CondBOp->getOpcode() == BO_LOr) {
1850 bool ConstantBool =
false;
1856 FalseBlock, TrueCount, LH);
1867 FalseBlock, TrueCount, LH, CondBOp);
1879 uint64_t RHSCount = TrueCount - LHSCount;
1881 ConditionalEvaluation eval(*
this);
1906 if (
const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) {
1914 if (CondUOp->getOpcode() == UO_LNot && !MCDCCondition) {
1932 ConditionalEvaluation cond(*
this);
1945 LHSScaledTrueCount = TrueCount * LHSRatio;
1954 LHSScaledTrueCount, LH, CondOp);
1961 TrueCount - LHSScaledTrueCount, LH, CondOp);
1967 if (
const CXXThrowExpr *Throw = dyn_cast<CXXThrowExpr>(Cond)) {
1987 const Expr *MCDCBaseExpr = Cond;
1994 MCDCBaseExpr = ConditionalOp;
1999 llvm::MDNode *Weights =
nullptr;
2000 llvm::MDNode *Unpredictable =
nullptr;
2007 auto *FD = dyn_cast_or_null<FunctionDecl>(
Call->getCalleeDecl());
2008 if (FD && FD->
getBuiltinID() == Builtin::BI__builtin_unpredictable) {
2010 Unpredictable = MDHelper.createUnpredictable();
2016 llvm::Value *NewCondV = emitCondLikelihoodViaExpectIntrinsic(CondV, LH);
2017 if (CondV != NewCondV)
2022 Weights = createProfileWeights(TrueCount, CurrentCount - TrueCount);
2025 Builder.CreateCondBr(CondV, TrueBlock, FalseBlock, Weights, Unpredictable);
2043 llvm::Value *sizeInChars) {
2047 llvm::Value *baseSizeInChars
2053 sizeInChars,
"vla.end");
2055 llvm::BasicBlock *originBB = CGF.
Builder.GetInsertBlock();
2063 llvm::PHINode *cur =
Builder.CreatePHI(begin.
getType(), 2,
"vla.cur");
2078 llvm::Value *done =
Builder.CreateICmpEQ(next, end,
"vla-init.isdone");
2079 Builder.CreateCondBr(done, contBB, loopBB);
2080 cur->addIncoming(next, loopBB);
2090 if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty())
2101 llvm::Value *SizeVal;
2108 dyn_cast_or_null<VariableArrayType>(
2111 SizeVal = VlaSize.NumElts;
2113 if (!eltSize.
isOne())
2134 llvm::GlobalVariable *NullVariable =
2135 new llvm::GlobalVariable(
CGM.
getModule(), NullConstant->getType(),
2137 llvm::GlobalVariable::PrivateLinkage,
2138 NullConstant, Twine());
2140 NullVariable->setAlignment(NullAlign.
getAsAlign());
2158 if (!IndirectBranch)
2164 IndirectBranch->addDestination(BB);
2165 return llvm::BlockAddress::get(
CurFn, BB);
2170 if (IndirectBranch)
return IndirectBranch->getParent();
2175 llvm::Value *DestVal = TmpBuilder.CreatePHI(
Int8PtrTy, 0,
2176 "indirect.goto.dest");
2179 IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal);
2180 return IndirectBranch->getParent();
2192 llvm::Value *numVLAElements =
nullptr;
2193 if (isa<VariableArrayType>(
arrayType)) {
2204 baseType = elementType;
2205 return numVLAElements;
2207 }
while (isa<VariableArrayType>(
arrayType));
2219 llvm::ConstantInt *zero =
Builder.getInt32(0);
2220 gepIndices.push_back(zero);
2225 llvm::ArrayType *llvmArrayType =
2227 while (llvmArrayType) {
2228 assert(isa<ConstantArrayType>(
arrayType));
2229 assert(cast<ConstantArrayType>(
arrayType)->getZExtSize() ==
2230 llvmArrayType->getNumElements());
2232 gepIndices.push_back(zero);
2233 countFromCLAs *= llvmArrayType->getNumElements();
2237 dyn_cast<llvm::ArrayType>(llvmArrayType->getElementType());
2240 "LLVM and Clang types are out-of-synch");
2248 countFromCLAs *= cast<ConstantArrayType>(
arrayType)->getZExtSize();
2259 gepIndices,
"array.begin"),
2265 llvm::Value *numElements
2266 = llvm::ConstantInt::get(
SizeTy, countFromCLAs);
2270 numElements =
Builder.CreateNUWMul(numVLAElements, numElements);
2277 assert(vla &&
"type was not a variable array type!");
2281CodeGenFunction::VlaSizePair
2284 llvm::Value *numElements =
nullptr;
2288 elementType =
type->getElementType();
2289 llvm::Value *vlaSize = VLASizeMap[
type->getSizeExpr()];
2290 assert(vlaSize &&
"no size for VLA!");
2291 assert(vlaSize->getType() ==
SizeTy);
2294 numElements = vlaSize;
2298 numElements =
Builder.CreateNUWMul(numElements, vlaSize);
2300 }
while ((
type =
getContext().getAsVariableArrayType(elementType)));
2302 return { numElements, elementType };
2305CodeGenFunction::VlaSizePair
2308 assert(vla &&
"type was not a variable array type!");
2312CodeGenFunction::VlaSizePair
2314 llvm::Value *VlaSize = VLASizeMap[Vla->
getSizeExpr()];
2315 assert(VlaSize &&
"no size for VLA!");
2316 assert(VlaSize->getType() ==
SizeTy);
2321 assert(
type->isVariablyModifiedType() &&
2322 "Must pass variably modified type to EmitVLASizes!");
2329 assert(
type->isVariablyModifiedType());
2331 const Type *ty =
type.getTypePtr();
2334#define TYPE(Class, Base)
2335#define ABSTRACT_TYPE(Class, Base)
2336#define NON_CANONICAL_TYPE(Class, Base)
2337#define DEPENDENT_TYPE(Class, Base) case Type::Class:
2338#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
2339#include "clang/AST/TypeNodes.inc"
2340 llvm_unreachable(
"unexpected dependent type!");
2346 case Type::ExtVector:
2347 case Type::ConstantMatrix:
2351 case Type::TemplateSpecialization:
2352 case Type::ObjCTypeParam:
2353 case Type::ObjCObject:
2354 case Type::ObjCInterface:
2355 case Type::ObjCObjectPointer:
2357 llvm_unreachable(
"type class is never variably-modified!");
2359 case Type::Elaborated:
2360 type = cast<ElaboratedType>(ty)->getNamedType();
2363 case Type::Adjusted:
2364 type = cast<AdjustedType>(ty)->getAdjustedType();
2368 type = cast<DecayedType>(ty)->getPointeeType();
2372 type = cast<PointerType>(ty)->getPointeeType();
2375 case Type::BlockPointer:
2376 type = cast<BlockPointerType>(ty)->getPointeeType();
2379 case Type::LValueReference:
2380 case Type::RValueReference:
2381 type = cast<ReferenceType>(ty)->getPointeeType();
2384 case Type::MemberPointer:
2385 type = cast<MemberPointerType>(ty)->getPointeeType();
2388 case Type::ArrayParameter:
2389 case Type::ConstantArray:
2390 case Type::IncompleteArray:
2392 type = cast<ArrayType>(ty)->getElementType();
2395 case Type::VariableArray: {
2404 llvm::Value *&entry = VLASizeMap[sizeExpr];
2413 SanitizerScope SanScope(
this);
2414 llvm::Value *
Zero = llvm::Constant::getNullValue(size->getType());
2416 llvm::Value *CheckCondition =
2418 ?
Builder.CreateICmpSGT(size, Zero)
2419 :
Builder.CreateICmpUGT(size, Zero);
2420 llvm::Constant *StaticArgs[] = {
2423 EmitCheck(std::make_pair(CheckCondition, SanitizerKind::VLABound),
2424 SanitizerHandler::VLABoundNotPositive, StaticArgs, size);
2437 case Type::FunctionProto:
2438 case Type::FunctionNoProto:
2439 type = cast<FunctionType>(ty)->getReturnType();
2444 case Type::UnaryTransform:
2445 case Type::Attributed:
2446 case Type::BTFTagAttributed:
2447 case Type::SubstTemplateTypeParm:
2448 case Type::MacroQualified:
2449 case Type::CountAttributed:
2455 case Type::Decltype:
2457 case Type::DeducedTemplateSpecialization:
2458 case Type::PackIndexing:
2462 case Type::TypeOfExpr:
2468 type = cast<AtomicType>(ty)->getValueType();
2472 type = cast<PipeType>(ty)->getElementType();
2475 }
while (
type->isVariablyModifiedType());
2479 if (
getContext().getBuiltinVaListType()->isArrayType())
2490 assert(
Init.hasValue() &&
"Invalid DeclRefExpr initializer!");
2496CodeGenFunction::PeepholeProtection
2502 if (!rvalue.
isScalar())
return PeepholeProtection();
2504 if (!isa<llvm::ZExtInst>(value))
return PeepholeProtection();
2508 llvm::Instruction *inst =
new llvm::BitCastInst(value, value->getType(),
"",
2511 PeepholeProtection protection;
2512 protection.Inst = inst;
2517 if (!protection.Inst)
return;
2520 protection.Inst->eraseFromParent();
2526 llvm::Value *Alignment,
2527 llvm::Value *OffsetValue) {
2528 if (Alignment->getType() !=
IntPtrTy)
2531 if (OffsetValue && OffsetValue->getType() !=
IntPtrTy)
2534 llvm::Value *TheCheck =
nullptr;
2536 llvm::Value *PtrIntValue =
2540 bool IsOffsetZero =
false;
2541 if (
const auto *CI = dyn_cast<llvm::ConstantInt>(OffsetValue))
2542 IsOffsetZero = CI->isZero();
2545 PtrIntValue =
Builder.CreateSub(PtrIntValue, OffsetValue,
"offsetptr");
2548 llvm::Value *
Zero = llvm::ConstantInt::get(
IntPtrTy, 0);
2551 llvm::Value *MaskedPtr =
Builder.CreateAnd(PtrIntValue, Mask,
"maskedptr");
2552 TheCheck =
Builder.CreateICmpEQ(MaskedPtr, Zero,
"maskcond");
2554 llvm::Instruction *Assumption =
Builder.CreateAlignmentAssumption(
2560 OffsetValue, TheCheck, Assumption);
2566 llvm::Value *Alignment,
2567 llvm::Value *OffsetValue) {
2576 llvm::Value *AnnotatedVal,
2577 StringRef AnnotationStr,
2579 const AnnotateAttr *
Attr) {
2588 return Builder.CreateCall(AnnotationFn, Args);
2592 assert(D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
2595 {V->getType(), CGM.ConstGlobalsPtrTy}),
2601 assert(D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
2603 llvm::Type *VTy =
V->getType();
2604 auto *PTy = dyn_cast<llvm::PointerType>(VTy);
2605 unsigned AS = PTy ? PTy->getAddressSpace() : 0;
2606 llvm::PointerType *IntrinTy =
2615 if (VTy != IntrinTy)
2633 CGF->IsSanitizerScope =
false;
2637 const llvm::Twine &Name,
2638 llvm::BasicBlock *BB,
2639 llvm::BasicBlock::iterator InsertPt)
const {
2642 I->setNoSanitizeMetadata();
2646 llvm::Instruction *I,
const llvm::Twine &Name, llvm::BasicBlock *BB,
2647 llvm::BasicBlock::iterator InsertPt)
const {
2648 llvm::IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt);
2650 CGF->InsertHelper(I, Name, BB, InsertPt);
2661 if (BuiltinID == X86::BI__builtin_ia32_cmpps ||
2662 BuiltinID == X86::BI__builtin_ia32_cmpss ||
2663 BuiltinID == X86::BI__builtin_ia32_cmppd ||
2664 BuiltinID == X86::BI__builtin_ia32_cmpsd) {
2666 llvm::StringMap<bool> TargetFetureMap;
2670 if (
Result.getSExtValue() > 7 && !TargetFetureMap.lookup(
"avx"))
2696 std::string MissingFeature;
2697 llvm::StringMap<bool> CallerFeatureMap;
2707 FeatureList, CallerFeatureMap) && !IsHipStdPar) {
2713 TargetDecl->
hasAttr<TargetAttr>()) {
2716 const TargetAttr *TD = TargetDecl->
getAttr<TargetAttr>();
2721 llvm::StringMap<bool> CalleeFeatureMap;
2725 if (F[0] ==
'+' && CalleeFeatureMap.lookup(F.substr(1)))
2726 ReqFeatures.push_back(StringRef(F).substr(1));
2729 for (
const auto &F : CalleeFeatureMap) {
2732 ReqFeatures.push_back(F.getKey());
2734 if (!llvm::all_of(ReqFeatures, [&](StringRef Feature) {
2735 if (!CallerFeatureMap.lookup(Feature)) {
2736 MissingFeature = Feature.str();
2744 llvm::StringMap<bool> CalleeFeatureMap;
2747 for (
const auto &F : CalleeFeatureMap) {
2748 if (F.getValue() && (!CallerFeatureMap.lookup(F.getKey()) ||
2749 !CallerFeatureMap.find(F.getKey())->getValue()) &&
2761 llvm::IRBuilder<> IRB(
Builder.GetInsertBlock(),
Builder.GetInsertPoint());
2762 IRB.SetCurrentDebugLocation(
Builder.getCurrentDebugLocation());
2769 Callee.getAbstractInfo().getCalleeFunctionProtoType();
2774llvm::Value *CodeGenFunction::FormAArch64ResolverCondition(
2775 const MultiVersionResolverOption &RO) {
2777 for (
const StringRef &Feature : RO.Conditions.Features) {
2783 Feature ==
"memtag" || Feature ==
"memtag2" || Feature ==
"memtag3" ||
2785 CondFeatures.push_back(Feature);
2787 if (!CondFeatures.empty()) {
2788 return EmitAArch64CpuSupports(CondFeatures);
2793llvm::Value *CodeGenFunction::FormX86ResolverCondition(
2794 const MultiVersionResolverOption &RO) {
2797 if (!RO.Conditions.Architecture.empty()) {
2798 StringRef Arch = RO.Conditions.Architecture;
2801 if (Arch.starts_with(
"x86-64"))
2807 if (!RO.Conditions.Features.empty()) {
2808 llvm::Value *FeatureCond = EmitX86CpuSupports(RO.Conditions.Features);
2816 llvm::Function *Resolver,
2818 llvm::Function *FuncToReturn,
2819 bool SupportsIFunc) {
2820 if (SupportsIFunc) {
2821 Builder.CreateRet(FuncToReturn);
2826 llvm::make_pointer_range(Resolver->args()));
2828 llvm::CallInst *
Result =
Builder.CreateCall(FuncToReturn, Args);
2829 Result->setTailCallKind(llvm::CallInst::TCK_MustTail);
2831 if (Resolver->getReturnType()->isVoidTy())
2840 llvm::Triple::ArchType ArchType =
2844 case llvm::Triple::x86:
2845 case llvm::Triple::x86_64:
2848 case llvm::Triple::aarch64:
2853 assert(
false &&
"Only implemented for x86 and AArch64 targets");
2859 assert(!Options.empty() &&
"No multiversion resolver options found");
2860 assert(Options.back().Conditions.Features.size() == 0 &&
2861 "Default case must be last");
2863 assert(SupportsIFunc &&
2864 "Multiversion resolver requires target IFUNC support");
2865 bool AArch64CpuInitialized =
false;
2868 for (
const MultiVersionResolverOption &RO : Options) {
2869 Builder.SetInsertPoint(CurBlock);
2870 llvm::Value *
Condition = FormAArch64ResolverCondition(RO);
2879 if (!AArch64CpuInitialized) {
2880 Builder.SetInsertPoint(CurBlock, CurBlock->begin());
2881 EmitAArch64CpuInit();
2882 AArch64CpuInitialized =
true;
2883 Builder.SetInsertPoint(CurBlock);
2886 llvm::BasicBlock *RetBlock =
createBasicBlock(
"resolver_return", Resolver);
2895 Builder.SetInsertPoint(CurBlock);
2896 llvm::CallInst *TrapCall =
EmitTrapCall(llvm::Intrinsic::trap);
2897 TrapCall->setDoesNotReturn();
2898 TrapCall->setDoesNotThrow();
2900 Builder.ClearInsertionPoint();
2910 Builder.SetInsertPoint(CurBlock);
2913 for (
const MultiVersionResolverOption &RO : Options) {
2914 Builder.SetInsertPoint(CurBlock);
2915 llvm::Value *
Condition = FormX86ResolverCondition(RO);
2919 assert(&RO == Options.end() - 1 &&
2920 "Default or Generic case must be last");
2926 llvm::BasicBlock *RetBlock =
createBasicBlock(
"resolver_return", Resolver);
2935 Builder.SetInsertPoint(CurBlock);
2936 llvm::CallInst *TrapCall =
EmitTrapCall(llvm::Intrinsic::trap);
2937 TrapCall->setDoesNotReturn();
2938 TrapCall->setDoesNotThrow();
2940 Builder.ClearInsertionPoint();
2952 llvm::Value *OffsetValue, llvm::Value *TheCheck,
2953 llvm::Instruction *Assumption) {
2954 assert(Assumption && isa<llvm::CallInst>(Assumption) &&
2955 cast<llvm::CallInst>(Assumption)->getCalledOperand() ==
2956 llvm::Intrinsic::getDeclaration(
2957 Builder.GetInsertBlock()->getParent()->getParent(),
2958 llvm::Intrinsic::assume) &&
2959 "Assumption should be a call to llvm.assume().");
2960 assert(&(
Builder.GetInsertBlock()->back()) == Assumption &&
2961 "Assumption should be the last instruction of the basic block, "
2962 "since the basic block is still being generated.");
2974 Assumption->removeFromParent();
2977 SanitizerScope SanScope(
this);
2980 OffsetValue =
Builder.getInt1(
false);
2988 EmitCheck({std::make_pair(TheCheck, SanitizerKind::Alignment)},
2989 SanitizerHandler::AlignmentAssumption, StaticData, DynamicData);
3000 return DI->SourceLocToDebugLoc(Location);
3002 return llvm::DebugLoc();
3006CodeGenFunction::emitCondLikelihoodViaExpectIntrinsic(llvm::Value *Cond,
3017 llvm::Type *CondTy = Cond->getType();
3018 assert(CondTy->isIntegerTy(1) &&
"expecting condition to be a boolean");
3019 llvm::Function *FnExpect =
3021 llvm::Value *ExpectedValueOfCond =
3023 return Builder.CreateCall(FnExpect, {Cond, ExpectedValueOfCond},
3024 Cond->getName() +
".expval");
3026 llvm_unreachable(
"Unknown Likelihood");
3030 unsigned NumElementsDst,
3031 const llvm::Twine &Name) {
3032 auto *SrcTy = cast<llvm::FixedVectorType>(SrcVec->getType());
3033 unsigned NumElementsSrc = SrcTy->getNumElements();
3034 if (NumElementsSrc == NumElementsDst)
3037 std::vector<int> ShuffleMask(NumElementsDst, -1);
3038 for (
unsigned MaskIdx = 0;
3039 MaskIdx < std::min<>(NumElementsDst, NumElementsSrc); ++MaskIdx)
3040 ShuffleMask[MaskIdx] = MaskIdx;
3042 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.
llvm::SmallVector< DeferredDeactivateCleanup > DeferredDeactivationCleanupStack
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.
SmallVector< llvm::IntrinsicInst *, 4 > ConvergenceTokenStack
Stack to track the controlled convergence tokens.
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
bool shouldEmitConvergenceTokens() 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