40#include "llvm/ADT/ArrayRef.h"
41#include "llvm/ADT/ScopeExit.h"
42#include "llvm/ADT/StringExtras.h"
43#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
44#include "llvm/IR/DataLayout.h"
45#include "llvm/IR/Dominators.h"
46#include "llvm/IR/FPEnv.h"
47#include "llvm/IR/Instruction.h"
48#include "llvm/IR/IntrinsicInst.h"
49#include "llvm/IR/Intrinsics.h"
50#include "llvm/IR/IntrinsicsPowerPC.h"
51#include "llvm/IR/MDBuilder.h"
52#include "llvm/Support/CRC.h"
53#include "llvm/Support/SaveAndRestore.h"
54#include "llvm/Support/SipHash.h"
55#include "llvm/Support/xxhash.h"
56#include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
57#include "llvm/Transforms/Utils/PromoteMemToReg.h"
63CodeGenFunction::CodeGenFunction(
CodeGenModule &cgm,
bool suppressNewContext)
67 DebugInfo(
CGM.getModuleDebugInfo()),
69 ShouldEmitLifetimeMarkers(
CodeGenUtils::shouldEmitLifetimeMarkers(
71 if (!suppressNewContext)
72 CGM.getCXXABI().getMangleContext().startNewFunction();
79 const auto *FD = dyn_cast_or_null<FunctionDecl>(
CurCodeDecl);
88 "missed to deactivate a cleanup");
91 CGM.getOpenMPRuntime().functionFinished(*
this);
98 if (
CGM.getLangOpts().OpenMPIRBuilder &&
CurFn)
99 CGM.getOpenMPRuntime().getOMPBuilder().finalize(
CurFn);
104llvm::fp::ExceptionBehavior
112 llvm_unreachable(
"Unsupported FP Exception Behavior");
117 llvm::FastMathFlags FMF;
118 FMF.setAllowReassoc(FPFeatures.getAllowFPReassociate());
119 FMF.setNoNaNs(FPFeatures.getNoHonorNaNs());
120 FMF.setNoInfs(FPFeatures.getNoHonorInfs());
121 FMF.setNoSignedZeros(FPFeatures.getNoSignedZero());
122 FMF.setAllowReciprocal(FPFeatures.getAllowReciprocal());
123 FMF.setApproxFunc(FPFeatures.getAllowApproxFunc());
137 ConstructorHelper(FPFeatures);
140void CodeGenFunction::CGFPOptionsRAII::ConstructorHelper(
FPOptions FPFeatures) {
141 OldFPFeatures = CGF.CurFPFeatures;
142 CGF.CurFPFeatures = FPFeatures;
144 OldExcept = CGF.Builder.getDefaultConstrainedExcept();
145 OldRounding = CGF.Builder.getDefaultConstrainedRounding();
147 if (OldFPFeatures == FPFeatures)
150 FMFGuard.emplace(CGF.Builder);
153 CGF.Builder.setDefaultConstrainedRounding(NewRoundingBehavior);
154 auto NewExceptionBehavior =
156 CGF.Builder.setDefaultConstrainedExcept(NewExceptionBehavior);
158 CGF.SetFastMathFlags(FPFeatures);
160 assert((CGF.CurFuncDecl ==
nullptr || CGF.Builder.getIsFPConstrained() ||
163 (NewExceptionBehavior == llvm::fp::ebIgnore &&
164 NewRoundingBehavior == llvm::RoundingMode::NearestTiesToEven)) &&
165 "FPConstrained should be enabled on entire function");
167 auto mergeFnAttrValue = [&](StringRef Name,
bool Value) {
169 CGF.CurFn->getFnAttribute(Name).getValueAsBool();
170 auto NewValue = OldValue &
Value;
171 if (OldValue != NewValue)
172 CGF.CurFn->addFnAttr(Name, llvm::toStringRef(NewValue));
174 mergeFnAttrValue(
"no-signed-zeros-fp-math", FPFeatures.getNoSignedZero());
178 CGF.CurFPFeatures = OldFPFeatures;
179 CGF.Builder.setDefaultConstrainedExcept(OldExcept);
180 CGF.Builder.setDefaultConstrainedRounding(OldRounding);
194 nullptr, IsKnownNonNull)
202 return ::makeNaturalAlignAddrLValue(
V,
T,
false,
209 return ::makeNaturalAlignAddrLValue(
V,
T,
true,
215 return ::makeNaturalAlignAddrLValue(
V,
T,
false,
221 return ::makeNaturalAlignAddrLValue(
V,
T,
true,
226 return CGM.getTypes().ConvertTypeForMem(
T);
230 return CGM.getTypes().ConvertType(
T);
234 llvm::Type *LLVMTy) {
235 return CGM.getTypes().convertTypeForLoadStore(ASTTy, LLVMTy);
241 switch (
type->getTypeClass()) {
242#define TYPE(name, parent)
243#define ABSTRACT_TYPE(name, parent)
244#define NON_CANONICAL_TYPE(name, parent) case Type::name:
245#define DEPENDENT_TYPE(name, parent) case Type::name:
246#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(name, parent) case Type::name:
247#include "clang/AST/TypeNodes.inc"
248 llvm_unreachable(
"non-canonical or dependent type in IR-generation");
251 case Type::DeducedTemplateSpecialization:
252 llvm_unreachable(
"undeduced type in IR-generation");
257 case Type::BlockPointer:
258 case Type::LValueReference:
259 case Type::RValueReference:
260 case Type::MemberPointer:
262 case Type::ExtVector:
263 case Type::ConstantMatrix:
264 case Type::FunctionProto:
265 case Type::FunctionNoProto:
267 case Type::ObjCObjectPointer:
270 case Type::HLSLAttributedResource:
271 case Type::HLSLInlineSpirv:
272 case Type::OverflowBehavior:
280 case Type::ConstantArray:
281 case Type::IncompleteArray:
282 case Type::VariableArray:
284 case Type::ObjCObject:
285 case Type::ObjCInterface:
286 case Type::ArrayParameter:
294 llvm_unreachable(
"unknown type kind!");
301 llvm::BasicBlock *CurBB =
Builder.GetInsertBlock();
304 assert(!CurBB->hasTerminator() &&
"Unexpected terminated block.");
308 if (CurBB->empty() ||
ReturnBlock.getBlock()->use_empty()) {
314 return llvm::DebugLoc();
322 dyn_cast<llvm::UncondBrInst>(*
ReturnBlock.getBlock()->user_begin());
323 if (BI && BI->getSuccessor(0) ==
ReturnBlock.getBlock()) {
326 llvm::DebugLoc Loc = BI->getDebugLoc();
327 Builder.SetInsertPoint(BI->getParent());
328 BI->eraseFromParent();
340 return llvm::DebugLoc();
345 if (!BB->use_empty()) {
353 assert(BreakContinueStack.empty() &&
354 "mismatched push/pop in break/continue stack!");
356 "mismatched push/pop of cleanups in EHStack!");
358 "mismatched activate/deactivate of cleanups!");
360 if (
CGM.shouldEmitConvergenceTokens()) {
363 "mismatched push/pop in convergence stack!");
366 bool OnlySimpleReturnStmts = NumSimpleReturnExprs > 0
367 && NumSimpleReturnExprs == NumReturnExprs
382 if (OnlySimpleReturnStmts)
383 DI->EmitLocation(
Builder, LastStopPoint);
385 DI->EmitLocation(
Builder, EndLoc);
393 bool HasOnlyNoopCleanups =
395 bool EmitRetDbgLoc = !HasCleanups || HasOnlyNoopCleanups;
397 std::optional<ApplyDebugLocation> OAL;
402 if (OnlySimpleReturnStmts)
403 DI->EmitLocation(
Builder, EndLoc);
417 if (
CGM.getCodeGenOpts().InstrumentFunctions)
418 CurFn->addFnAttr(
"instrument-function-exit",
"__cyg_profile_func_exit");
419 if (
CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining)
420 CurFn->addFnAttr(
"instrument-function-exit-inlined",
421 "__cyg_profile_func_exit");
430 uint64_t RetKeyInstructionsAtomGroup = Loc ? Loc->getAtomGroup() : 0;
433 RetKeyInstructionsAtomGroup);
437 "did not remove all scopes from cleanup stack!");
441 if (IndirectBranch) {
448 if (!EscapedLocals.empty()) {
452 EscapeArgs.resize(EscapedLocals.size());
453 for (
auto &Pair : EscapedLocals)
454 EscapeArgs[Pair.second] = Pair.first;
455 llvm::Function *FrameEscapeFn = llvm::Intrinsic::getOrInsertDeclaration(
456 &
CGM.getModule(), llvm::Intrinsic::localescape);
463 Ptr->eraseFromParent();
467 if (PostAllocaInsertPt) {
468 llvm::Instruction *PostPtr = PostAllocaInsertPt;
469 PostAllocaInsertPt =
nullptr;
470 PostPtr->eraseFromParent();
475 if (IndirectBranch) {
477 if (PN->getNumIncomingValues() == 0) {
478 PN->replaceAllUsesWith(llvm::PoisonValue::get(PN->getType()));
479 PN->eraseFromParent();
488 for (
const auto &FuncletAndParent : TerminateFunclets)
491 if (
CGM.getCodeGenOpts().EmitDeclMetadata)
494 for (
const auto &R : DeferredReplacements) {
495 if (llvm::Value *Old = R.first) {
496 Old->replaceAllUsesWith(R.second);
500 DeferredReplacements.clear();
509 llvm::DominatorTree DT(*
CurFn);
510 llvm::PromoteMemToReg(
516 for (llvm::Argument &A :
CurFn->args())
517 if (
auto *VT = dyn_cast<llvm::VectorType>(A.getType()))
519 std::max((uint64_t)LargestVectorWidth,
520 VT->getPrimitiveSizeInBits().getKnownMinValue());
523 if (
auto *VT = dyn_cast<llvm::VectorType>(
CurFn->getReturnType()))
525 std::max((uint64_t)LargestVectorWidth,
526 VT->getPrimitiveSizeInBits().getKnownMinValue());
528 if (
CurFnInfo->getMaxVectorWidth() > LargestVectorWidth)
529 LargestVectorWidth =
CurFnInfo->getMaxVectorWidth();
539 CurFn->addFnAttr(
"min-legal-vector-width",
540 llvm::utostr(LargestVectorWidth));
549 dyn_cast<llvm::AllocaInst>(
ReturnValue.emitRawPointer(*
this));
550 if (RetAlloca && RetAlloca->use_empty()) {
551 RetAlloca->eraseFromParent();
560 if (!
CGM.getCodeGenOpts().InstrumentFunctions &&
561 !
CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining &&
562 !
CGM.getCodeGenOpts().InstrumentFunctionEntryBare)
572 return CurFuncDecl->hasAttr<DisableSanitizerInstrumentationAttr>();
578 return CGM.getCodeGenOpts().XRayInstrumentFunctions;
584 return CGM.getCodeGenOpts().XRayInstrumentFunctions &&
585 (
CGM.getCodeGenOpts().XRayAlwaysEmitCustomEvents ||
586 CGM.getCodeGenOpts().XRayInstrumentationBundle.Mask ==
591 return CGM.getCodeGenOpts().XRayInstrumentFunctions &&
592 (
CGM.getCodeGenOpts().XRayAlwaysEmitTypedEvents ||
593 CGM.getCodeGenOpts().XRayInstrumentationBundle.Mask ==
604 llvm::raw_string_ostream Out(Mangled);
605 CGM.getCXXABI().getMangleContext().mangleCanonicalTypeName(Ty, Out,
false);
606 return llvm::ConstantInt::get(
607 CGM.Int32Ty,
static_cast<uint32_t
>(llvm::xxh3_64bits(Mangled)));
610void CodeGenFunction::EmitKernelMetadata(
const FunctionDecl *FD,
611 llvm::Function *Fn) {
612 if (!FD->
hasAttr<DeviceKernelAttr>() && !FD->
hasAttr<CUDAGlobalAttr>())
624 if (
const VecTypeHintAttr *A = FD->
getAttr<VecTypeHintAttr>()) {
625 QualType HintQTy = A->getTypeHint();
627 bool IsSignedInteger =
629 (HintEltQTy && HintEltQTy->
getElementType()->isSignedIntegerType());
630 llvm::Metadata *AttrMDArgs[] = {
631 llvm::ConstantAsMetadata::get(llvm::PoisonValue::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 auto Eval = [&](
Expr *E) {
641 return E->EvaluateKnownConstInt(FD->
getASTContext()).getExtValue();
643 llvm::Metadata *AttrMDArgs[] = {
644 llvm::ConstantAsMetadata::get(
Builder.getInt32(Eval(A->getXDim()))),
645 llvm::ConstantAsMetadata::get(
Builder.getInt32(Eval(A->getYDim()))),
646 llvm::ConstantAsMetadata::get(
Builder.getInt32(Eval(A->getZDim())))};
647 Fn->setMetadata(
"work_group_size_hint", llvm::MDNode::get(Context, AttrMDArgs));
650 if (
const ReqdWorkGroupSizeAttr *A = FD->
getAttr<ReqdWorkGroupSizeAttr>()) {
651 auto Eval = [&](Expr *E) {
652 return E->EvaluateKnownConstInt(FD->
getASTContext()).getExtValue();
654 llvm::Metadata *AttrMDArgs[] = {
655 llvm::ConstantAsMetadata::get(
Builder.getInt32(Eval(A->getXDim()))),
656 llvm::ConstantAsMetadata::get(
Builder.getInt32(Eval(A->getYDim()))),
657 llvm::ConstantAsMetadata::get(
Builder.getInt32(Eval(A->getZDim())))};
658 Fn->setMetadata(
"reqd_work_group_size", llvm::MDNode::get(Context, AttrMDArgs));
661 if (
const OpenCLIntelReqdSubGroupSizeAttr *A =
662 FD->
getAttr<OpenCLIntelReqdSubGroupSizeAttr>()) {
663 llvm::Metadata *AttrMDArgs[] = {
664 llvm::ConstantAsMetadata::get(
Builder.getInt32(A->getSubGroupSize()))};
665 Fn->setMetadata(
"intel_reqd_sub_group_size",
666 llvm::MDNode::get(Context, AttrMDArgs));
672 const Stmt *Body =
nullptr;
673 if (
auto *FD = dyn_cast_or_null<FunctionDecl>(F))
675 else if (
auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(F))
676 Body = OMD->getBody();
678 if (
auto *CS = dyn_cast_or_null<CompoundStmt>(Body)) {
679 auto LastStmt = CS->body_rbegin();
680 if (LastStmt != CS->body_rend())
687 if (
SanOpts.has(SanitizerKind::Thread)) {
688 Fn->addFnAttr(
"sanitize_thread_no_checking_at_run_time");
689 Fn->removeFnAttr(llvm::Attribute::SanitizeThread);
691 if (
SanOpts.has(SanitizerKind::Concurrency)) {
692 Fn->addFnAttr(
"sanitize_concurrency_no_checking_at_run_time");
693 Fn->removeFnAttr(llvm::Attribute::SanitizeConcurrency);
698bool CodeGenFunction::requiresReturnValueCheck()
const {
699 return requiresReturnValueNullabilityCheck() ||
709 auto *MD = dyn_cast_or_null<CXXMethodDecl>(D);
710 if (!MD || !MD->getDeclName().getAsIdentifierInfo() ||
711 !MD->getDeclName().getAsIdentifierInfo()->isStr(
"allocate") ||
712 (MD->getNumParams() != 1 && MD->getNumParams() != 2))
718 if (MD->getNumParams() == 2) {
719 auto *PT = MD->parameters()[1]->getType()->getAs<
PointerType>();
720 if (!PT || !PT->isVoidPointerType() ||
721 !PT->getPointeeType().isConstQualified())
728bool CodeGenFunction::isInAllocaArgument(
CGCXXABI &ABI, QualType Ty) {
733bool CodeGenFunction::hasInAllocaArg(
const CXXMethodDecl *MD) {
736 llvm::any_of(MD->
parameters(), [&](ParmVarDecl *P) {
737 return isInAllocaArgument(CGM.getCXXABI(), P->getType());
744 if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD))
757 "Do not use a CodeGenFunction object for more than one function");
761 DidCallStackSave =
false;
763 const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
766 if (
const Stmt *Body = D ? D->
getBody() :
nullptr) {
769 ShouldEmitLifetimeMarkers =
true;
772 bool NeedsBypassDetection =
773 ShouldEmitLifetimeMarkers ||
774 (
CGM.getLangOpts().getTrivialAutoVarInit() !=
776 if (NeedsBypassDetection)
783 assert(
CurFn->isDeclaration() &&
"Function already has body?");
788#define SANITIZER(NAME, ID) \
789 if (SanOpts.empty()) \
791 if (SanOpts.has(SanitizerKind::ID)) \
792 if (CGM.isInNoSanitizeList(SanitizerKind::ID, Fn, Loc)) \
793 SanOpts.set(SanitizerKind::ID, false);
795#include "clang/Basic/Sanitizers.def"
800 const bool SanitizeBounds =
SanOpts.hasOneOf(SanitizerKind::Bounds);
802 bool NoSanitizeCoverage =
false;
805 no_sanitize_mask |=
Attr->getMask();
807 if (
Attr->hasCoverage())
808 NoSanitizeCoverage =
true;
812 SanOpts.Mask &= ~no_sanitize_mask;
813 if (no_sanitize_mask & SanitizerKind::Address)
814 SanOpts.set(SanitizerKind::KernelAddress,
false);
815 if (no_sanitize_mask & SanitizerKind::KernelAddress)
816 SanOpts.set(SanitizerKind::Address,
false);
817 if (no_sanitize_mask & SanitizerKind::HWAddress)
818 SanOpts.set(SanitizerKind::KernelHWAddress,
false);
819 if (no_sanitize_mask & SanitizerKind::KernelHWAddress)
820 SanOpts.set(SanitizerKind::HWAddress,
false);
822 if (SanitizeBounds && !
SanOpts.hasOneOf(SanitizerKind::Bounds))
823 Fn->addFnAttr(llvm::Attribute::NoSanitizeBounds);
825 if (NoSanitizeCoverage &&
CGM.getCodeGenOpts().hasSanitizeCoverage())
826 Fn->addFnAttr(llvm::Attribute::NoSanitizeCoverage);
829 if (
CGM.getCodeGenOpts().hasSanitizeBinaryMetadata()) {
830 if (no_sanitize_mask & SanitizerKind::Thread)
831 Fn->addFnAttr(
"no_sanitize_thread");
836 CurFn->addFnAttr(llvm::Attribute::DisableSanitizerInstrumentation);
839 if (
SanOpts.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress))
840 Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
841 if (
SanOpts.hasOneOf(SanitizerKind::HWAddress |
842 SanitizerKind::KernelHWAddress))
843 Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
844 if (
SanOpts.has(SanitizerKind::MemtagStack))
845 Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);
846 if (
SanOpts.has(SanitizerKind::Thread))
847 Fn->addFnAttr(llvm::Attribute::SanitizeThread);
848 if (
SanOpts.has(SanitizerKind::Concurrency))
849 Fn->addFnAttr(llvm::Attribute::SanitizeConcurrency);
850 if (
SanOpts.has(SanitizerKind::Type))
851 Fn->addFnAttr(llvm::Attribute::SanitizeType);
852 if (
SanOpts.has(SanitizerKind::NumericalStability))
853 Fn->addFnAttr(llvm::Attribute::SanitizeNumericalStability);
854 if (
SanOpts.hasOneOf(SanitizerKind::Memory | SanitizerKind::KernelMemory))
855 Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
856 if (
SanOpts.has(SanitizerKind::AllocToken))
857 Fn->addFnAttr(llvm::Attribute::SanitizeAllocToken);
859 if (
SanOpts.has(SanitizerKind::SafeStack))
860 Fn->addFnAttr(llvm::Attribute::SafeStack);
861 if (
SanOpts.has(SanitizerKind::ShadowCallStack))
862 Fn->addFnAttr(llvm::Attribute::ShadowCallStack);
864 if (
SanOpts.has(SanitizerKind::Realtime))
868 Fn->addFnAttr(llvm::Attribute::SanitizeRealtime);
870 Fn->addFnAttr(llvm::Attribute::SanitizeRealtimeBlocking);
874 if (
SanOpts.hasOneOf(SanitizerKind::Fuzzer | SanitizerKind::FuzzerNoLink))
875 Fn->addFnAttr(llvm::Attribute::OptForFuzzing);
880 if (
SanOpts.hasOneOf(SanitizerKind::Thread | SanitizerKind::Concurrency)) {
881 if (
const auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(D)) {
882 const IdentifierInfo *II = OMD->getSelector().getIdentifierInfoForSlot(0);
885 (OMD->getSelector().isUnarySelector() && II->
isStr(
".cxx_destruct"))) {
894 if (D &&
SanOpts.has(SanitizerKind::CFIUnrelatedCast)) {
902 if (D &&
SanOpts.has(SanitizerKind::Null))
908 bool AlwaysXRayAttr =
false;
909 if (
const auto *XRayAttr = D ? D->
getAttr<XRayInstrumentAttr>() :
nullptr) {
910 if (
CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
912 CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
915 Fn->addFnAttr(
"function-instrument",
"xray-always");
916 AlwaysXRayAttr =
true;
918 if (XRayAttr->neverXRayInstrument())
919 Fn->addFnAttr(
"function-instrument",
"xray-never");
920 if (
const auto *LogArgs = D->
getAttr<XRayLogArgsAttr>())
922 Fn->addFnAttr(
"xray-log-args",
923 llvm::utostr(LogArgs->getArgumentCount()));
928 "xray-instruction-threshold",
929 llvm::itostr(
CGM.getCodeGenOpts().XRayInstructionThreshold));
933 if (
CGM.getCodeGenOpts().XRayIgnoreLoops)
934 Fn->addFnAttr(
"xray-ignore-loops");
936 if (!
CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
938 Fn->addFnAttr(
"xray-skip-exit");
940 if (!
CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
942 Fn->addFnAttr(
"xray-skip-entry");
944 auto FuncGroups =
CGM.getCodeGenOpts().XRayTotalFunctionGroups;
945 if (FuncGroups > 1) {
947 CurFn->getName().bytes_end());
948 auto Group = crc32(FuncName) % FuncGroups;
949 if (Group !=
CGM.getCodeGenOpts().XRaySelectedFunctionGroup &&
951 Fn->addFnAttr(
"function-instrument",
"xray-never");
955 if (
CGM.getCodeGenOpts().getProfileInstr() !=
956 llvm::driver::ProfileInstrKind::ProfileNone) {
957 switch (
CGM.isFunctionBlockedFromProfileInstr(Fn, Loc)) {
959 Fn->addFnAttr(llvm::Attribute::SkipProfile);
962 Fn->addFnAttr(llvm::Attribute::NoProfile);
969 unsigned Count, Offset;
971 if (
const auto *
Attr =
972 D ? D->
getAttr<PatchableFunctionEntryAttr>() :
nullptr) {
973 Count =
Attr->getCount();
974 Offset =
Attr->getOffset();
975 Section =
Attr->getSection();
977 Count =
CGM.getCodeGenOpts().PatchableFunctionEntryCount;
978 Offset =
CGM.getCodeGenOpts().PatchableFunctionEntryOffset;
981 Section =
CGM.getCodeGenOpts().PatchableFunctionEntrySection;
982 if (Count && Offset <= Count) {
983 Fn->addFnAttr(
"patchable-function-entry", std::to_string(Count - Offset));
985 Fn->addFnAttr(
"patchable-function-prefix", std::to_string(Offset));
986 if (!Section.empty())
987 Fn->addFnAttr(
"patchable-function-entry-section", Section);
993 if (
CGM.getCodeGenOpts().HotPatch &&
996 llvm::Triple::CODE16)
997 Fn->addFnAttr(
"patchable-function",
"prologue-short-redirect");
1000 if (
CGM.getCodeGenOpts().NoUseJumpTables)
1001 Fn->addFnAttr(
"no-jump-tables",
"true");
1004 if (
CGM.getCodeGenOpts().NoInlineLineTables)
1005 Fn->addFnAttr(
"no-inline-line-tables");
1008 if (
CGM.getCodeGenOpts().ProfileSampleAccurate)
1009 Fn->addFnAttr(
"profile-sample-accurate");
1011 if (!
CGM.getCodeGenOpts().SampleProfileFile.empty())
1012 Fn->addFnAttr(
"use-sample-profile");
1014 if (D && D->
hasAttr<CFICanonicalJumpTableAttr>())
1015 Fn->addFnAttr(
"cfi-canonical-jump-table");
1017 if (D && D->
hasAttr<NoProfileFunctionAttr>())
1018 Fn->addFnAttr(llvm::Attribute::NoProfile);
1020 if (D && D->
hasAttr<HybridPatchableAttr>())
1021 Fn->addFnAttr(llvm::Attribute::HybridPatchable);
1025 if (
auto *A = D->
getAttr<FunctionReturnThunksAttr>()) {
1026 switch (A->getThunkType()) {
1027 case FunctionReturnThunksAttr::Kind::Keep:
1029 case FunctionReturnThunksAttr::Kind::Extern:
1030 Fn->addFnAttr(llvm::Attribute::FnRetThunkExtern);
1033 }
else if (
CGM.getCodeGenOpts().FunctionReturnThunks)
1034 Fn->addFnAttr(llvm::Attribute::FnRetThunkExtern);
1043 EmitKernelMetadata(FD, Fn);
1046 if (FD && FD->
hasAttr<ClspvLibclcBuiltinAttr>()) {
1047 Fn->setMetadata(
"clspv_libclc_builtin",
1054 if (FD &&
SanOpts.has(SanitizerKind::Function) &&
1056 llvm::isCallableCC(Fn->getCallingConv())) {
1058 llvm::LLVMContext &Ctx = Fn->getContext();
1059 llvm::MDBuilder MDB(Ctx);
1061 llvm::LLVMContext::MD_func_sanitize,
1062 MDB.createRTTIPointerPrologue(
1069 if (
SanOpts.has(SanitizerKind::NullabilityReturn)) {
1070 auto Nullability =
FnRetTy->getNullability();
1073 if (!(
SanOpts.has(SanitizerKind::ReturnsNonnullAttribute) &&
1075 RetValNullabilityPrecondition =
1082 if (
CGM.getCodeGenOpts().CopyProf) {
1083 if (
const auto *MD = dyn_cast_or_null<CXXMethodDecl>(D)) {
1085 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
1086 if (!CD->isMoveConstructor())
1088 CD->isCopyConstructor() ?
"copyprof-copy-ctor" :
"copyprof-ctor";
1090 Attr =
"copyprof-dtor";
1092 Attr =
"copyprof-copy-assign-op";
1094 if (!
Attr.empty()) {
1101 CGM.getCodeGenOpts().CopyProfStaticSizeThreshold)
1125 Fn->addFnAttr(llvm::Attribute::NoRecurse);
1128 llvm::fp::ExceptionBehavior FPExceptionBehavior =
1130 Builder.setDefaultConstrainedRounding(RM);
1131 Builder.setDefaultConstrainedExcept(FPExceptionBehavior);
1133 (!FD && (FPExceptionBehavior != llvm::fp::ebIgnore ||
1134 RM != llvm::RoundingMode::NearestTiesToEven))) {
1135 Builder.setIsFPConstrained(
true);
1136 Fn->addFnAttr(llvm::Attribute::StrictFP);
1142 CGM.getCodeGenOpts().StackAlignment))
1143 Fn->addFnAttr(
"stackrealign");
1147 Fn->removeFnAttr(
"zero-call-used-regs");
1153 if (
T->getAArch64SMEAttributes() &
1160 const auto *FeatureMap =
1162 if (
auto VScaleRange =
getContext().getTargetInfo().getVScaleRange(
1164 CurFn->addFnAttr(llvm::Attribute::getWithVScaleRangeArgs(
1172 llvm::Value *Poison = llvm::PoisonValue::get(
Int32Ty);
1177 Builder.SetInsertPoint(EntryBB);
1181 if (requiresReturnValueCheck()) {
1192 DI->emitFunctionStart(GD, Loc, StartLoc,
1193 DI->getFunctionType(FD, RetTy, Args),
CurFn,
1198 if (
CGM.getCodeGenOpts().InstrumentFunctions)
1199 CurFn->addFnAttr(
"instrument-function-entry",
"__cyg_profile_func_enter");
1200 if (
CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining)
1201 CurFn->addFnAttr(
"instrument-function-entry-inlined",
1202 "__cyg_profile_func_enter");
1203 if (
CGM.getCodeGenOpts().InstrumentFunctionEntryBare)
1204 CurFn->addFnAttr(
"instrument-function-entry-inlined",
1205 "__cyg_profile_func_enter_bare");
1212 if (
CGM.getCodeGenOpts().InstrumentForProfiling) {
1216 if (
CGM.getCodeGenOpts().CallFEntry)
1217 Fn->addFnAttr(
"fentry-call",
"true");
1219 Fn->addFnAttr(
"instrument-function-entry-inlined",
1222 if (
CGM.getCodeGenOpts().MNopMCount) {
1223 if (!
CGM.getCodeGenOpts().CallFEntry)
1224 CGM.getDiags().Report(diag::err_opt_not_valid_without_opt)
1225 <<
"-mnop-mcount" <<
"-mfentry";
1226 Fn->addFnAttr(
"mnop-mcount");
1229 if (
CGM.getCodeGenOpts().RecordMCount) {
1230 if (!
CGM.getCodeGenOpts().CallFEntry)
1231 CGM.getDiags().Report(diag::err_opt_not_valid_without_opt)
1232 <<
"-mrecord-mcount" <<
"-mfentry";
1233 Fn->addFnAttr(
"mrecord-mcount");
1238 if (
CGM.getCodeGenOpts().PackedStack) {
1240 llvm::Triple::systemz)
1241 CGM.getDiags().Report(diag::err_opt_not_valid_on_target)
1242 <<
"-mpacked-stack";
1243 Fn->addFnAttr(
"packed-stack");
1246 if (!
CGM.getCodeGenOpts().ZOSPPA1Name)
1247 Fn->addFnAttr(
"zos-ppa1-name",
"");
1249 FD->
hasAttr<AsmLabelAttr>()) {
1250 std::string SrcName =
CGM.getMangledNameIgnoringAsmLabel(GD, FD);
1251 Fn->addFnAttr(
"zos-ppa1-name", SrcName);
1254 if (
CGM.getCodeGenOpts().WarnStackSize !=
UINT_MAX &&
1255 !
CGM.getDiags().isIgnored(diag::warn_fe_backend_frame_larger_than, Loc))
1256 Fn->addFnAttr(
"warn-stack-size",
1257 std::to_string(
CGM.getCodeGenOpts().WarnStackSize));
1269 auto AI =
CurFn->arg_begin();
1270 if (
CurFnInfo->getReturnInfo().isSRetAfterThis())
1273 &*AI, RetTy,
CurFnInfo->getReturnInfo().getIndirectAlign(),
false,
1275 if (!
CurFnInfo->getReturnInfo().getIndirectByVal()) {
1284 unsigned Idx =
CurFnInfo->getReturnInfo().getInAllocaFieldIndex();
1285 llvm::Function::arg_iterator EI =
CurFn->arg_end();
1317 if (FD->
hasAttr<HLSLShaderAttr>()) {
1318 CGM.getHLSLRuntime().emitEntryFunction(FD, Fn);
1324 if (
const CXXMethodDecl *MD = dyn_cast_if_present<CXXMethodDecl>(D);
1329 CGM.getCXXABI().EmitInstanceFunctionProlog(*
this);
1345 CXXThisValue = ThisFieldLValue.
getPointer(*
this);
1354 if (FD->hasCapturedVLAType()) {
1357 auto VAT = FD->getCapturedVLAType();
1358 VLASizeMap[VAT->getSizeExpr()] = ExprArg;
1365 CXXThisValue = CXXABIThisValue;
1369 if (CXXABIThisValue) {
1371 SkippedChecks.
set(SanitizerKind::ObjectSize,
true);
1378 SkippedChecks.
set(SanitizerKind::Null,
true);
1382 Loc, CXXABIThisValue, ThisTy, CXXABIThisAlignment, SkippedChecks);
1389 if (!FD || !FD->
hasAttr<NakedAttr>()) {
1390 for (
const VarDecl *VD : Args) {
1395 if (
const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD))
1396 Ty = PVD->getOriginalType();
1406 DI->EmitLocation(
Builder, StartLoc);
1410 if (
const auto *VecWidth =
CurFuncDecl->getAttr<MinVectorWidthAttr>())
1411 LargestVectorWidth = VecWidth->getVectorWidth();
1413 if (
CGM.shouldEmitConvergenceTokens())
1420 if (
const CompoundStmt *S = dyn_cast<CompoundStmt>(Body))
1432 llvm::BasicBlock *SkipCountBB =
nullptr;
1454 if (F->isInterposable())
return;
1456 for (llvm::BasicBlock &BB : *F)
1457 for (llvm::Instruction &I : BB)
1461 F->setDoesNotThrow();
1471 if (
CGM.getCXXABI().HasThisReturn(GD))
1473 else if (
CGM.getCXXABI().hasMostDerivedReturn(GD))
1474 ResTy =
CGM.getContext().VoidPtrTy;
1475 CGM.getCXXABI().buildThisParam(*
this, Args);
1481 bool PassedParams =
true;
1483 if (
auto Inherited = CD->getInheritedConstructor())
1489 Args.push_back(Param);
1490 if (!Param->hasAttr<PassObjectSizeAttr>())
1494 getContext(), Param->getDeclContext(), Param->getLocation(),
1502 CGM.getCXXABI().addImplicitStructorParams(*
this, ResTy, Args);
1509 assert(Fn &&
"generating code for null Function");
1516 CGM.getTargetCodeGenInfo().checkFunctionABI(
CGM, FD);
1522 std::string FDInlineName = (Fn->getName() +
".inline").str();
1523 llvm::Module *M = Fn->getParent();
1524 llvm::Function *Clone = M->getFunction(FDInlineName);
1526 Clone = llvm::Function::Create(Fn->getFunctionType(),
1527 llvm::GlobalValue::InternalLinkage,
1528 Fn->getAddressSpace(), FDInlineName, M);
1529 Clone->setCallingConv(Fn->getCallingConv());
1530 Clone->setAttributes(Fn->getAttributes());
1531 Clone->addFnAttr(llvm::Attribute::AlwaysInline);
1533 Fn->setLinkage(llvm::GlobalValue::ExternalLinkage);
1543 if (LLVM_UNLIKELY(PD->isInlineBuiltinDeclaration())) {
1544 std::string FDInlineName = (Fn->getName() +
".inline").str();
1545 llvm::Module *M = Fn->getParent();
1546 if (llvm::Function *Clone = M->getFunction(FDInlineName)) {
1547 Clone->replaceAllUsesWith(Fn);
1548 Clone->eraseFromParent();
1556 if (FD->
hasAttr<NoDebugAttr>()) {
1559 Fn->setSubprogram(
nullptr);
1561 DebugInfo =
nullptr;
1564 llvm::scope_exit Cleanup([
this] {
1566 DI->completeFunction();
1573 BodyRange = Body->getSourceRange();
1576 CurEHLocation = BodyRange.getEnd();
1588 if (SpecDecl->hasBody(SpecDecl))
1589 Loc = SpecDecl->getLocation();
1594 StartFunction(GD, ResTy, Fn, FnInfo, Args, Loc, BodyRange.getBegin());
1597 if (Body && isa_and_nonnull<CoroutineBodyStmt>(Body))
1605 CurFn->addFnAttr(llvm::Attribute::MustProgress);
1608 PGO->assignRegionCounters(GD,
CurFn);
1615 FD->
hasAttr<CUDAGlobalAttr>())
1616 CGM.getCUDARuntime().emitDeviceStub(*
this, Args);
1639 }
else if (DeviceKernelAttr::isOpenCLSpelling(
1640 FD->
getAttr<DeviceKernelAttr>()) &&
1643 for (
unsigned i = 0; i < Args.size(); ++i) {
1645 QualType ArgQualType = Args[i]->getType();
1647 CallArgs.
add(ArgRValue, ArgQualType);
1651 CGM.getTargetCodeGenInfo().setOCLKernelStubCallingConvention(FT);
1654 llvm::FunctionType *FTy =
CGM.getTypes().GetFunctionType(FnInfo);
1655 llvm::Constant *GDStubFunctionPointer =
1656 CGM.getRawFunctionPointer(GDStub, FTy);
1663 llvm_unreachable(
"no definition for emitted function");
1673 bool ShouldEmitUnreachable =
1674 CGM.getCodeGenOpts().StrictReturn ||
1676 if (
SanOpts.has(SanitizerKind::Return)) {
1677 auto CheckOrdinal = SanitizerKind::SO_Return;
1678 auto CheckHandler = SanitizerHandler::MissingReturn;
1680 llvm::Value *IsFalse =
Builder.getFalse();
1681 EmitCheck(std::make_pair(IsFalse, CheckOrdinal), CheckHandler,
1683 }
else if (ShouldEmitUnreachable) {
1684 if (
CGM.getCodeGenOpts().OptimizationLevel == 0)
1687 if (
SanOpts.has(SanitizerKind::Return) || ShouldEmitUnreachable) {
1689 Builder.ClearInsertionPoint();
1696 PGO->verifyCounterMap();
1699 StringRef Identifier =
1700 CurCodeDecl->getAttr<PersonalityAttr>()->getRoutine()->getName();
1701 llvm::FunctionCallee PersonalityRoutine =
1702 CGM.CreateRuntimeFunction(llvm::FunctionType::get(
CGM.Int32Ty,
true),
1703 Identifier, {},
true);
1709 if (!
CurFn->doesNotThrow())
1718 if (!S)
return false;
1735 IgnoreCaseStmts =
true;
1750 if (!S)
return false;
1770 if (!S)
return false;
1801 if (!AllowLabels &&
CGM.getCodeGenOpts().hasProfileClangInstr() &&
1802 CGM.getCodeGenOpts().MCDCCoverage)
1805 llvm::APSInt ResultInt;
1809 ResultBool = ResultInt.getBoolValue();
1817 llvm::APSInt &ResultInt,
1829 PGO->markStmtMaybeUsed(Cond);
1830 ResultInt = std::move(
Int);
1859 llvm::BasicBlock *FalseBlock, uint64_t TrueCount ,
1862 bool InstrumentRegions =
CGM.getCodeGenOpts().hasProfileClangInstr();
1866 const Stmt *CntrStmt = (CntrIdx ? CntrIdx : Cond);
1868 llvm::BasicBlock *ThenBlock =
nullptr;
1869 llvm::BasicBlock *ElseBlock =
nullptr;
1870 llvm::BasicBlock *NextBlock =
nullptr;
1875 llvm::BasicBlock *SkipIncrBlock =
1877 llvm::BasicBlock *SkipNextBlock =
nullptr;
1891 if (LOp == BO_LAnd) {
1892 SkipNextBlock = FalseBlock;
1893 ThenBlock = CounterIncrBlock;
1894 ElseBlock = (SkipIncrBlock ? SkipIncrBlock : SkipNextBlock);
1895 NextBlock = TrueBlock;
1910 else if (LOp == BO_LOr) {
1911 SkipNextBlock = TrueBlock;
1912 ThenBlock = (SkipIncrBlock ? SkipIncrBlock : SkipNextBlock);
1913 ElseBlock = CounterIncrBlock;
1914 NextBlock = FalseBlock;
1916 llvm_unreachable(
"Expected Opcode must be that of a Logical Operator");
1922 if (SkipIncrBlock) {
1946 const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock,
1948 const VarDecl *ConditionalDecl) {
1951 if (
const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) {
1955 if (CondBOp->getOpcode() == BO_LAnd) {
1958 bool ConstantBool =
false;
1964 FalseBlock, TrueCount, LH);
1974 FalseBlock, TrueCount, LH, CondBOp);
1981 llvm::BasicBlock *LHSFalse =
2009 FalseBlock, TrueCount, LH);
2014 if (CondBOp->getOpcode() == BO_LOr) {
2017 bool ConstantBool =
false;
2023 FalseBlock, TrueCount, LH);
2033 FalseBlock, TrueCount, LH, CondBOp);
2038 llvm::BasicBlock *LHSTrue =
2046 uint64_t RHSCount = TrueCount - LHSCount;
2077 if (
const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) {
2082 bool MCDCCondition =
CGM.getCodeGenOpts().hasProfileClangInstr() &&
2083 CGM.getCodeGenOpts().MCDCCoverage &&
2085 if (CondUOp->getOpcode() == UO_LNot && !MCDCCondition) {
2112 uint64_t LHSScaledTrueCount = 0;
2116 LHSScaledTrueCount = TrueCount * LHSRatio;
2125 LHSScaledTrueCount, LH, CondOp);
2133 TrueCount - LHSScaledTrueCount, LH, CondOp);
2139 if (
const CXXThrowExpr *Throw = dyn_cast<CXXThrowExpr>(Cond)) {
2161 const Expr *MCDCBaseExpr = Cond;
2168 MCDCBaseExpr = ConditionalOp;
2175 llvm::MDNode *Weights =
nullptr;
2176 llvm::MDNode *Unpredictable =
nullptr;
2182 if (
Call &&
CGM.getCodeGenOpts().OptimizationLevel != 0) {
2183 auto *FD = dyn_cast_or_null<FunctionDecl>(
Call->getCalleeDecl());
2184 if (FD && FD->
getBuiltinID() == Builtin::BI__builtin_unpredictable) {
2186 Unpredictable = MDHelper.createUnpredictable();
2192 llvm::Value *NewCondV = emitCondLikelihoodViaExpectIntrinsic(CondV, LH);
2193 if (CondV != NewCondV)
2198 Weights = createProfileWeights(TrueCount, CurrentCount - TrueCount);
2201 llvm::Instruction *BrInst =
Builder.CreateCondBr(CondV, TrueBlock, FalseBlock,
2202 Weights, Unpredictable);
2206 case HLSLControlFlowHintAttr::Microsoft_branch:
2207 case HLSLControlFlowHintAttr::Microsoft_flatten: {
2208 llvm::MDBuilder MDHelper(
CGM.getLLVMContext());
2210 llvm::ConstantInt *BranchHintConstant =
2212 HLSLControlFlowHintAttr::Spelling::Microsoft_branch
2213 ? llvm::ConstantInt::get(
CGM.Int32Ty, 1)
2214 : llvm::ConstantInt::get(
CGM.Int32Ty, 2);
2217 {MDHelper.createString(
"hlsl.controlflow.hint"),
2218 MDHelper.createConstant(BranchHintConstant)});
2219 BrInst->setMetadata(
"hlsl.controlflow.hint",
2220 llvm::MDNode::get(
CGM.getLLVMContext(), Vals));
2224 case HLSLControlFlowHintAttr::SpellingNotCalculated:
2232 llvm::Value *Arg =
nullptr;
2233 if ((ICEArguments & (1 << Idx)) == 0) {
2238 std::optional<llvm::APSInt>
Result =
2240 assert(
Result &&
"Expected argument to be a constant");
2249 CGM.ErrorUnsupported(S,
Type);
2261 llvm::Value *sizeInChars) {
2265 llvm::Value *baseSizeInChars
2269 llvm::Value *end = Builder.CreateInBoundsGEP(begin.
getElementType(),
2271 sizeInChars,
"vla.end");
2273 llvm::BasicBlock *originBB = CGF.
Builder.GetInsertBlock();
2281 llvm::PHINode *cur = Builder.CreatePHI(begin.
getType(), 2,
"vla.cur");
2288 Builder.CreateMemCpy(
Address(cur, CGF.
Int8Ty, curAlign), src, baseSizeInChars,
2293 Builder.CreateInBoundsGEP(CGF.
Int8Ty, cur, baseSizeInChars,
"vla.next");
2296 llvm::Value *done = Builder.CreateICmpEQ(next, end,
"vla-init.isdone");
2297 Builder.CreateCondBr(done, contBB, loopBB);
2298 cur->addIncoming(next, loopBB);
2316 if (
CGM.getContext().arePFPFieldsTriviallyCopyable(Field->getParent())) {
2317 uint64_t FieldSignature =
2318 llvm::getPointerAuthStableSipHash(
CGM.getPFPFieldName(Field));
2319 Disc = llvm::ConstantInt::get(
CGM.Int64Ty, FieldSignature);
2323 llvm::GlobalValue *DS =
CGM.getPFPDeactivationSymbol(Field);
2324 llvm::OperandBundleDef DSBundle(
"deactivation-symbol", DS);
2327 Builder.CreateCall(
CGM.getIntrinsic(llvm::Intrinsic::protected_field_ptr,
2346 llvm::Value *SizeVal;
2353 dyn_cast_or_null<VariableArrayType>(
2356 SizeVal = VlaSize.NumElts;
2358 if (!eltSize.
isOne())
2359 SizeVal =
Builder.CreateNUWMul(SizeVal,
CGM.getSize(eltSize));
2365 SizeVal =
CGM.getSize(size);
2373 if (!
CGM.getTypes().isZeroInitializable(Ty)) {
2377 llvm::Constant *NullConstant =
CGM.EmitNullConstant(Ty);
2379 llvm::GlobalVariable *NullVariable =
2380 new llvm::GlobalVariable(
CGM.getModule(), NullConstant->getType(),
2382 llvm::GlobalVariable::PrivateLinkage,
2383 NullConstant, Twine());
2385 NullVariable->setAlignment(NullAlign.
getAsAlign());
2391 Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal,
false);
2397 Builder.CreateMemSet(DestPtr,
Builder.getInt8(0), SizeVal,
false);
2410 if (!IndirectBranch)
2416 IndirectBranch->addDestination(BB);
2417 return llvm::BlockAddress::get(
CurFn->getType(), BB);
2422 if (IndirectBranch)
return IndirectBranch->getParent();
2427 llvm::Value *DestVal = TmpBuilder.CreatePHI(
Int8PtrTy, 0,
2428 "indirect.goto.dest");
2431 IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal);
2432 return IndirectBranch->getParent();
2444 llvm::Value *numVLAElements =
nullptr;
2456 baseType = elementType;
2457 return numVLAElements;
2471 llvm::ConstantInt *zero =
Builder.getInt32(0);
2472 gepIndices.push_back(zero);
2474 uint64_t countFromCLAs = 1;
2477 llvm::ArrayType *llvmArrayType =
2479 while (llvmArrayType) {
2482 llvmArrayType->getNumElements());
2484 gepIndices.push_back(zero);
2485 countFromCLAs *= llvmArrayType->getNumElements();
2489 dyn_cast<llvm::ArrayType>(llvmArrayType->getElementType());
2492 "LLVM and Clang types are out-of-synch");
2511 gepIndices,
"array.begin"),
2517 llvm::Value *numElements
2518 = llvm::ConstantInt::get(
SizeTy, countFromCLAs);
2522 numElements =
Builder.CreateNUWMul(numVLAElements, numElements);
2529 assert(vla &&
"type was not a variable array type!");
2536 llvm::Value *numElements =
nullptr;
2540 elementType =
type->getElementType();
2541 llvm::Value *vlaSize = VLASizeMap[
type->getSizeExpr()];
2542 assert(vlaSize &&
"no size for VLA!");
2543 assert(vlaSize->getType() ==
SizeTy);
2546 numElements = vlaSize;
2550 numElements =
Builder.CreateNUWMul(numElements, vlaSize);
2552 }
while ((
type =
getContext().getAsVariableArrayType(elementType)));
2554 return { numElements, elementType };
2560 assert(vla &&
"type was not a variable array type!");
2566 llvm::Value *VlaSize = VLASizeMap[Vla->
getSizeExpr()];
2567 assert(VlaSize &&
"no size for VLA!");
2568 assert(VlaSize->getType() ==
SizeTy);
2573 assert(
type->isVariablyModifiedType() &&
2574 "Must pass variably modified type to EmitVLASizes!");
2581 assert(
type->isVariablyModifiedType());
2583 const Type *ty =
type.getTypePtr();
2586#define TYPE(Class, Base)
2587#define ABSTRACT_TYPE(Class, Base)
2588#define NON_CANONICAL_TYPE(Class, Base)
2589#define DEPENDENT_TYPE(Class, Base) case Type::Class:
2590#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
2591#include "clang/AST/TypeNodes.inc"
2592 llvm_unreachable(
"unexpected dependent type!");
2598 case Type::ExtVector:
2599 case Type::ConstantMatrix:
2603 case Type::TemplateSpecialization:
2604 case Type::ObjCTypeParam:
2605 case Type::ObjCObject:
2606 case Type::ObjCInterface:
2607 case Type::ObjCObjectPointer:
2609 case Type::HLSLInlineSpirv:
2610 case Type::PredefinedSugar:
2611 llvm_unreachable(
"type class is never variably-modified!");
2613 case Type::Adjusted:
2625 case Type::BlockPointer:
2629 case Type::LValueReference:
2630 case Type::RValueReference:
2634 case Type::MemberPointer:
2638 case Type::ArrayParameter:
2639 case Type::ConstantArray:
2640 case Type::IncompleteArray:
2645 case Type::VariableArray: {
2654 llvm::Value *&entry = VLASizeMap[sizeExpr];
2662 if (
SanOpts.has(SanitizerKind::VLABound)) {
2663 auto CheckOrdinal = SanitizerKind::SO_VLABound;
2664 auto CheckHandler = SanitizerHandler::VLABoundNotPositive;
2666 llvm::Value *
Zero = llvm::Constant::getNullValue(size->getType());
2668 llvm::Value *CheckCondition =
2672 llvm::Constant *StaticArgs[] = {
2675 EmitCheck(std::make_pair(CheckCondition, CheckOrdinal),
2676 CheckHandler, StaticArgs, size);
2689 case Type::FunctionProto:
2690 case Type::FunctionNoProto:
2696 case Type::UnaryTransform:
2697 case Type::Attributed:
2698 case Type::BTFTagAttributed:
2699 case Type::OverflowBehavior:
2700 case Type::HLSLAttributedResource:
2701 case Type::SubstTemplateTypeParm:
2702 case Type::MacroQualified:
2703 case Type::CountAttributed:
2704 case Type::LateParsedAttr:
2710 case Type::Decltype:
2712 case Type::DeducedTemplateSpecialization:
2713 case Type::PackIndexing:
2717 case Type::TypeOfExpr:
2730 }
while (
type->isVariablyModifiedType());
2734 if (
getContext().getBuiltinVaListType()->isArrayType())
2749 assert(
Init.hasValue() &&
"Invalid DeclRefExpr initializer!");
2751 if (
CGM.getCodeGenOpts().hasReducedDebugInfo())
2767 llvm::Instruction *inst =
new llvm::BitCastInst(value, value->getType(),
"",
2771 protection.Inst = inst;
2776 if (!protection.Inst)
return;
2779 protection.Inst->eraseFromParent();
2785 llvm::Value *Alignment,
2786 llvm::Value *OffsetValue) {
2787 if (Alignment->getType() !=
IntPtrTy)
2790 if (OffsetValue && OffsetValue->getType() !=
IntPtrTy)
2793 if (
SanOpts.has(SanitizerKind::Alignment))
2796 Builder.CreateAlignmentAssumption(
CGM.getDataLayout(), PtrValue, Alignment,
2803 llvm::Value *Alignment,
2804 llvm::Value *OffsetValue) {
2813 llvm::Value *AnnotatedVal,
2814 StringRef AnnotationStr,
2816 const AnnotateAttr *
Attr) {
2819 CGM.EmitAnnotationString(AnnotationStr),
2820 CGM.EmitAnnotationUnit(Location),
2821 CGM.EmitAnnotationLineNo(Location),
2824 Args.push_back(
CGM.EmitAnnotationArgs(
Attr));
2825 return Builder.CreateCall(AnnotationFn, Args);
2829 assert(D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
2832 {V->getType(), CGM.ConstGlobalsPtrTy}),
2838 assert(D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
2839 llvm::Value *
V =
Addr.emitRawPointer(*
this);
2840 llvm::Type *VTy =
V->getType();
2841 auto *PTy = dyn_cast<llvm::PointerType>(VTy);
2842 unsigned AS = PTy ? PTy->getAddressSpace() : 0;
2843 llvm::PointerType *IntrinTy =
2844 llvm::PointerType::get(
CGM.getLLVMContext(), AS);
2845 llvm::Function *F =
CGM.getIntrinsic(llvm::Intrinsic::ptr_annotation,
2846 {IntrinTy,
CGM.ConstGlobalsPtrTy});
2852 if (VTy != IntrinTy)
2865 assert(!CGF->IsSanitizerScope);
2866 CGF->IsSanitizerScope =
true;
2870 CGF->IsSanitizerScope =
false;
2874 const llvm::Twine &Name,
2875 llvm::BasicBlock::iterator InsertPt)
const {
2878 I->setNoSanitizeMetadata();
2882 llvm::Instruction *I,
const llvm::Twine &Name,
2883 llvm::BasicBlock::iterator InsertPt)
const {
2884 llvm::IRBuilderDefaultInserter::InsertHelper(I, Name, InsertPt);
2886 CGF->InsertHelper(I, Name, InsertPt);
2908 if (!
CGM.getCodeGenOpts().SanitizeStats)
2911 llvm::IRBuilder<> IRB(
Builder.GetInsertPoint());
2912 IRB.SetCurrentDebugLocation(
Builder.getCurrentDebugLocation());
2913 CGM.getSanStats().create(IRB, SSK);
2925 Salt = Info.CFISalt;
2927 Bundles.emplace_back(
"kcfi",
CGM.CreateKCFITypeId(FP->
desugar(), Salt));
2931CodeGenFunction::FormAArch64ResolverCondition(
const FMVResolverOption &RO) {
2932 return RO.Features.empty() ?
nullptr : EmitAArch64CpuSupports(RO.Features);
2936CodeGenFunction::FormX86ResolverCondition(
const FMVResolverOption &RO) {
2939 if (RO.Architecture) {
2940 StringRef
Arch = *RO.Architecture;
2943 if (
Arch.starts_with(
"x86-64"))
2949 if (!RO.Features.empty()) {
2950 llvm::Value *FeatureCond = EmitX86CpuSupports(RO.Features);
2958 llvm::Function *Resolver,
2960 llvm::Function *FuncToReturn,
2961 bool SupportsIFunc) {
2962 if (SupportsIFunc) {
2963 Builder.CreateRet(FuncToReturn);
2968 llvm::make_pointer_range(Resolver->args()));
2970 llvm::CallInst *
Result = Builder.CreateCall(FuncToReturn, Args);
2971 Result->setTailCallKind(llvm::CallInst::TCK_MustTail);
2973 if (Resolver->getReturnType()->isVoidTy())
2974 Builder.CreateRetVoid();
2976 Builder.CreateRet(
Result);
2982 llvm::Triple::ArchType ArchType =
2986 case llvm::Triple::x86:
2987 case llvm::Triple::x86_64:
2990 case llvm::Triple::aarch64:
2993 case llvm::Triple::riscv32:
2994 case llvm::Triple::riscv64:
2995 case llvm::Triple::riscv32be:
2996 case llvm::Triple::riscv64be:
2999 case llvm::Triple::ppc:
3000 case llvm::Triple::ppc64:
3008 "Only implemented for x86, AArch64, RISC-V, and PowerPC AIX");
3035 Builder.SetInsertPoint(CurBlock);
3037 if (!RO.Architecture && RO.Features.empty()) {
3040 assert(&RO == Options.end() - 1 &&
3041 "Default or Generic case must be last");
3042 Builder.CreateRet(RO.Function);
3051 assert(RO.Features.size() == 1 &&
3052 "for now one feature requirement per version");
3054 StringRef FeatureStr = RO.Features[0];
3055 StringRef BuiltinCpuSupportsArg;
3056 bool IsNegated =
false;
3058 if (FeatureStr.starts_with(
"cpu=")) {
3060 StringRef CPU = FeatureStr.split(
"=").second.trim();
3061 BuiltinCpuSupportsArg = llvm::StringSwitch<StringRef>(CPU)
3062#define PPC_AIX_CLONES_CPU(CPU_NAME, AIX_BUILTIN_CPU_SUPPORTS_NAME, _) \
3063 .Case(CPU_NAME, AIX_BUILTIN_CPU_SUPPORTS_NAME)
3064#include "llvm/TargetParser/PPCTargetParser.def"
3070 if (FeatureStr.starts_with(
"no-")) {
3072 FeatureStr = FeatureStr.drop_front(3);
3076 BuiltinCpuSupportsArg =
3077 llvm::StringSwitch<StringRef>(FeatureStr)
3078#define PPC_AIX_CLONES_FEATURE(FEATURE_NAME, AIX_BUILTIN_CPU_SUPPORTS_NAME, _, \
3080 .Case(FEATURE_NAME, AIX_BUILTIN_CPU_SUPPORTS_NAME)
3081#include "llvm/TargetParser/PPCTargetParser.def"
3086 assert(!BuiltinCpuSupportsArg.empty() &&
3087 "Feature without runtime detection should have been rejected in "
3091 assert(
getContext().getTargetInfo().validateCpuSupports(
3092 BuiltinCpuSupportsArg));
3096 Builder.getInt1Ty(), BuiltinCpuSupportsArg);
3107 Builder.SetInsertPoint(ThenBlock);
3108 Builder.CreateRet(RO.Function);
3111 llvm_unreachable(
"Default case missing");
3118 llvm::Triple::OSType::Linux) {
3119 CGM.getDiags().Report(diag::err_os_unsupport_riscv_fmv);
3124 Builder.SetInsertPoint(CurBlock);
3128 bool HasDefault =
false;
3129 unsigned DefaultIndex = 0;
3132 for (
unsigned Index = 0; Index < Options.size(); Index++) {
3134 if (Options[Index].Features.empty()) {
3136 DefaultIndex = Index;
3140 Builder.SetInsertPoint(CurBlock);
3166 for (StringRef Feat : Options[Index].Features) {
3167 std::vector<std::string> FeatStr =
3170 assert(FeatStr.size() == 1 &&
"Feature string not delimited");
3172 std::string &CurrFeat = FeatStr.front();
3173 if (CurrFeat[0] ==
'+')
3174 TargetAttrFeats.push_back(CurrFeat.substr(1));
3177 if (TargetAttrFeats.empty())
3180 for (std::string &Feat : TargetAttrFeats)
3181 CurrTargetAttrFeats.push_back(Feat);
3183 Builder.SetInsertPoint(CurBlock);
3186 llvm::BasicBlock *RetBlock =
createBasicBlock(
"resolver_return", Resolver);
3189 Options[Index].
Function, SupportsIFunc);
3192 Builder.SetInsertPoint(CurBlock);
3193 Builder.CreateCondBr(FeatsCondition, RetBlock, ElseBlock);
3195 CurBlock = ElseBlock;
3200 Builder.SetInsertPoint(CurBlock);
3207 Builder.SetInsertPoint(CurBlock);
3213 assert(!Options.empty() &&
"No multiversion resolver options found");
3214 assert(Options.back().Features.size() == 0 &&
"Default case must be last");
3216 assert(SupportsIFunc &&
3217 "Multiversion resolver requires target IFUNC support");
3218 bool AArch64CpuInitialized =
false;
3223 if (RO.Function ==
nullptr)
3226 Builder.SetInsertPoint(CurBlock);
3227 llvm::Value *
Condition = FormAArch64ResolverCondition(RO);
3236 if (!AArch64CpuInitialized) {
3237 Builder.SetInsertPoint(CurBlock->begin());
3238 EmitAArch64CpuInit();
3239 AArch64CpuInitialized =
true;
3240 Builder.SetInsertPoint(CurBlock);
3243 llvm::BasicBlock *RetBlock =
createBasicBlock(
"resolver_return", Resolver);
3252 Builder.SetInsertPoint(CurBlock);
3263 Builder.SetInsertPoint(CurBlock);
3267 Builder.SetInsertPoint(CurBlock);
3268 llvm::Value *
Condition = FormX86ResolverCondition(RO);
3272 assert(&RO == Options.end() - 1 &&
3273 "Default or Generic case must be last");
3279 llvm::BasicBlock *RetBlock =
createBasicBlock(
"resolver_return", Resolver);
3288 Builder.SetInsertPoint(CurBlock);
3300 llvm::Value *DynamicLoc,
3302 llvm::Value *Alignment,
3303 llvm::Value *OffsetValue) {
3304 if (!CGF.
SanOpts.
has(SanitizerKind::Alignment))
3309 if (Alignment->getType() !=
IntPtrTy)
3311 Builder.CreateIntCast(Alignment,
IntPtrTy,
false,
"casted.align");
3312 if (OffsetValue && OffsetValue->getType() !=
IntPtrTy)
3314 Builder.CreateIntCast(OffsetValue,
IntPtrTy,
true,
"casted.offset");
3316 llvm::Value *PtrIntValue = Builder.CreatePtrToInt(Ptr,
IntPtrTy,
"ptrint");
3319 bool IsOffsetZero =
false;
3320 if (
const auto *CI = dyn_cast<llvm::ConstantInt>(OffsetValue))
3321 IsOffsetZero = CI->isZero();
3324 PtrIntValue = Builder.CreateSub(PtrIntValue, OffsetValue,
"offsetptr");
3327 llvm::Value *
Zero = llvm::ConstantInt::get(
IntPtrTy, 0);
3329 Builder.CreateSub(Alignment, llvm::ConstantInt::get(
IntPtrTy, 1));
3330 llvm::Value *MaskedPtr = Builder.CreateAnd(PtrIntValue, Mask,
"maskedptr");
3331 llvm::Value *TheCheck = Builder.CreateICmpEQ(MaskedPtr,
Zero,
"maskcond");
3338 auto CheckOrdinal = SanitizerKind::SO_Alignment;
3339 auto CheckHandler = !DynamicLoc ? SanitizerHandler::AlignmentAssumption
3340 : SanitizerHandler::ReturnAlignmentAssumption;
3344 OffsetValue = Builder.getInt1(
false);
3350 llvm::Value *DynamicData[] = {Ptr, Alignment, OffsetValue};
3351 CGF.
EmitCheck({std::make_pair(TheCheck, CheckOrdinal)}, CheckHandler,
3352 StaticData, DynamicData);
3356 llvm::Value *DynamicData[] = {DynamicLoc, Ptr, Alignment, OffsetValue};
3357 CGF.
EmitCheck({std::make_pair(TheCheck, CheckOrdinal)}, CheckHandler,
3358 StaticData, DynamicData);
3366 llvm::Value *Alignment,
3367 llvm::Value *OffsetValue) {
3369 Alignment, OffsetValue);
3374 llvm::Value *Alignment, llvm::Value *OffsetValue) {
3375 llvm::Value *SLocPtr =
Builder.CreateLoad(ReturnLocation,
"return.sloc.load");
3377 AssumptionLoc, Alignment, OffsetValue);
3382 return DI->SourceLocToDebugLoc(Location);
3384 return llvm::DebugLoc();
3388CodeGenFunction::emitCondLikelihoodViaExpectIntrinsic(llvm::Value *Cond,
3399 llvm::Type *CondTy = Cond->getType();
3400 assert(CondTy->isIntegerTy(1) &&
"expecting condition to be a boolean");
3401 llvm::Function *FnExpect =
3403 llvm::Value *ExpectedValueOfCond =
3405 return Builder.CreateCall(FnExpect, {Cond, ExpectedValueOfCond},
3406 Cond->getName() +
".expval");
3408 llvm_unreachable(
"Unknown Likelihood");
3412 unsigned NumElementsDst,
3413 const llvm::Twine &Name) {
3415 unsigned NumElementsSrc = SrcTy->getNumElements();
3416 if (NumElementsSrc == NumElementsDst)
3419 std::vector<int> ShuffleMask(NumElementsDst, -1);
3420 for (
unsigned MaskIdx = 0;
3421 MaskIdx < std::min<>(NumElementsDst, NumElementsSrc); ++MaskIdx)
3422 ShuffleMask[MaskIdx] = MaskIdx;
3424 return Builder.CreateShuffleVector(SrcVec, ShuffleMask, Name);
3437 Discriminator =
Builder.getSize(0);
3439 llvm::Value *Args[] = {Key, Discriminator};
3440 Bundles.emplace_back(
"ptrauth", Args);
3446 unsigned IntrinsicID) {
3453 if (!Discriminator) {
3458 auto OrigType =
Pointer->getType();
3476 llvm::Intrinsic::ptrauth_sign);
3482 auto StripIntrinsic = CGF.
CGM.
getIntrinsic(llvm::Intrinsic::ptrauth_strip);
3486 auto OrigType =
Pointer->getType();
3503 llvm::Intrinsic::ptrauth_auth);
3507 llvm::Instruction *KeyInstruction, llvm::Value *Backup) {
3509 DI->addInstToCurrentSourceAtom(KeyInstruction, Backup);
3513 llvm::Instruction *KeyInstruction, llvm::Value *Backup, uint64_t Atom) {
3515 DI->addInstToSpecificSourceAtom(KeyInstruction, Backup, Atom);
3519 llvm::Value *Backup) {
3522 DI->addInstToCurrentSourceAtom(KeyInstruction, Backup);
3529 if (
getContext().arePFPFieldsTriviallyCopyable(Field.Field->getParent()))
3533 Builder.CreateStore(
Builder.CreateLoad(SrcFieldPtr), DestFieldPtr);
static void findPFPFields(const ASTContext &Ctx, QualType Ty, CharUnits Offset, std::vector< PFPField > &Fields, bool IncludeVBases)
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 llvm::Value * EmitPointerAuthCommon(CodeGenFunction &CGF, const CGPointerAuthInfo &PointerAuth, llvm::Value *Pointer, unsigned IntrinsicID)
static void CreateMultiVersionResolverReturn(CodeGenModule &CGM, llvm::Function *Resolver, CGBuilderTy &Builder, llvm::Function *FuncToReturn, bool SupportsIFunc)
static llvm::Value * EmitStrip(CodeGenFunction &CGF, const CGPointerAuthInfo &PointerAuth, llvm::Value *Pointer)
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 LValue makeNaturalAlignAddrLValue(llvm::Value *V, QualType T, bool ForPointeeType, bool MightBeSigned, CodeGenFunction &CGF, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
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 matchesStlAllocatorFn(const Decl *D, const ASTContext &Ctx)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Result
Implement __builtin_bit_cast and related operations.
static StringRef getTriple(const Command &Job)
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 ...
const llvm::StringMap< bool > & getFunctionFeatureMap(const FunctionDecl *FD) const
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.
bool hasAnyFunctionEffects() const
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.
static bool hasSameType(QualType T1, QualType T2)
Determine whether the given types T1 and T2 are equivalent.
const VariableArrayType * getAsVariableArrayType(QualType T) const
QualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
const TargetInfo & getTargetInfo() 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)
BinaryOperatorKind Opcode
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.
QualType getFunctionObjectParameterType() const
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
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
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
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.
This is an opaque type for sizes expressed in character units.
bool isZero() const
Test whether the quantity equals zero.
llvm::Align getAsAlign() const
Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit bytes.
QuantityType getQuantity() const
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
Test whether the quantity equals one.
@ 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...
Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...
llvm::Value * getBasePointer() const
llvm::Value * emitRawPointer(CodeGenFunction &CGF) const
Return the pointer contained in this class after authenticating it and adding offset to it if necessa...
CharUnits getAlignment() const
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Address 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 source atom group for CGDebugInfo::addInstToCurrentSourceAtom.
A scoped helper to set the current debug location to the specified location or preferred location of ...
static ApplyDebugLocation CreateDefaultArtificial(CodeGenFunction &CGF, SourceLocation TemporaryLocation)
Apply TemporaryLocation if it is valid.
void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock::iterator InsertPt) const
This forwards to CodeGenFunction::InsertHelper.
llvm::ConstantInt * getSize(CharUnits N)
@ RAA_DirectInMemory
Pass it on the stack using its defined layout.
virtual RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const =0
Returns how an argument of the given record type should be passed.
Abstract information about a function or function prototype.
const FunctionProtoType * getCalleeFunctionProtoType() const
All available information about a concrete callee.
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
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.
bool isDelegateCall() const
llvm::Value * getDiscriminator() const
CallArgList - Type for representing both the value and type of arguments in a call.
void add(RValue rvalue, QualType type)
virtual ~CGCapturedStmtInfo()
CGFPOptionsRAII(CodeGenFunction &CGF, FPOptions FPFeatures)
An object to manage conditionally-evaluated expressions.
void begin(CodeGenFunction &CGF)
void end(CodeGenFunction &CGF)
An object which temporarily prevents a value from being destroyed by aggressive peephole optimization...
SanitizerScope(CodeGenFunction *CGF)
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
void EmitRISCVMultiVersionResolver(llvm::Function *Resolver, ArrayRef< FMVResolverOption > Options)
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount, Stmt::Likelihood LH=Stmt::LH_None, const Expr *ConditionalOp=nullptr, const VarDecl *ConditionalDecl=nullptr)
EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g.
void setCurrentProfileCount(uint64_t Count)
Set the profiler's current count.
llvm::CallInst * EmitTrapCall(llvm::Intrinsic::ID IntrID, bool EnsureInsertPoint=true)
Emit a call to trap or debugtrap.
llvm::Value * emitBoolVecConversion(llvm::Value *SrcVec, unsigned NumElementsDst, const llvm::Twine &Name="")
void EmitAArch64MultiVersionResolver(llvm::Function *Resolver, ArrayRef< FMVResolverOption > Options)
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...
llvm::Value * EmitScalarOrConstFoldImmArg(unsigned ICEArguments, unsigned Idx, const CallExpr *E)
SanitizerSet SanOpts
Sanitizers enabled for this function.
@ UseSkipPath
Skip (false)
void EmitNullInitialization(Address DestPtr, QualType Ty)
EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...
void checkTargetFeatures(const CallExpr *E, const FunctionDecl *TargetDecl)
static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts=false)
ContainsLabel - Return true if the statement contains a label in it.
void EmitPPCAIXMultiVersionResolver(llvm::Function *Resolver, ArrayRef< FMVResolverOption > Options)
define internal ptr @foo.resolver() { entry: is_version_1 = __builtin_cpu_supports(version_1) br i1 %...
bool ShouldSkipSanitizerInstrumentation()
ShouldSkipSanitizerInstrumentation - Return true if the current function should not be instrumented w...
llvm::Value * EmitPPCBuiltinCpu(unsigned BuiltinID, llvm::Type *ReturnType, StringRef CPUStr)
llvm::BlockAddress * GetAddrOfLabel(const LabelDecl *L)
llvm::Value * EmitRISCVCpuSupports(const CallExpr *E)
llvm::Value * EmitRISCVCpuInit()
static bool hasScalarEvaluationKind(QualType T)
llvm::Type * ConvertType(QualType T)
void GenerateCode(GlobalDecl GD, llvm::Function *Fn, const CGFunctionInfo &FnInfo)
void EmitSanitizerStatReport(llvm::SanitizerStatKind SSK)
void addInstToNewSourceAtom(llvm::Instruction *KeyInstruction, llvm::Value *Backup)
Add KeyInstruction and an optional Backup instruction to a new atom group (See ApplyAtomGroup for mor...
FieldDecl * LambdaThisCaptureField
PeepholeProtection protectFromPeepholes(RValue rvalue)
protectFromPeepholes - Protect a value that we're intending to store to the side, but which will prob...
void EmitLambdaStaticInvokeBody(const CXXMethodDecl *MD)
bool CurFuncIsThunk
In C++, whether we are code generating a thunk.
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 ...
JumpDest getJumpDestForLabel(const LabelDecl *S)
getBasicBlockForLabel - Return the LLVM basicblock that the specified label maps to.
void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)
SmallVector< llvm::ConvergenceControlInst *, 4 > ConvergenceTokenStack
Stack to track the controlled convergence tokens.
void unprotectFromPeepholes(PeepholeProtection protection)
RValue convertTempToRValue(Address addr, QualType type, SourceLocation Loc)
Given the address of a temporary variable, produce an r-value of its type.
llvm::Constant * EmitCheckSourceLocation(SourceLocation Loc)
Emit a description of a source location in a format suitable for passing to a runtime sanitizer handl...
llvm::SmallVector< DeferredDeactivateCleanup > DeferredDeactivationCleanupStack
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
void addInstToCurrentSourceAtom(llvm::Instruction *KeyInstruction, llvm::Value *Backup)
See CGDebugInfo::addInstToCurrentSourceAtom.
const LangOptions & getLangOpts() const
void addInstToSpecificSourceAtom(llvm::Instruction *KeyInstruction, llvm::Value *Backup, uint64_t Atom)
See CGDebugInfo::addInstToSpecificSourceAtom.
LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
void EmitVarAnnotations(const VarDecl *D, llvm::Value *V)
Emit local annotations for the local variable V, declared by D.
llvm::BasicBlock * EHResumeBlock
EHResumeBlock - Unified block containing a call to llvm.eh.resume.
Address EmitFieldAnnotations(const FieldDecl *D, Address V)
Emit field annotations for the given field & value.
void EmitConstructorBody(FunctionArgList &Args)
EmitConstructorBody - Emits the body of the current constructor.
void EmitKCFIOperandBundle(const CGCallee &Callee, SmallVectorImpl< llvm::OperandBundleDef > &Bundles)
void EmitDeclRefExprDbgValue(const DeclRefExpr *E, const APValue &Init)
Address makeNaturalAddressForPointer(llvm::Value *Ptr, QualType T, CharUnits Alignment=CharUnits::Zero(), bool ForPointeeType=false, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
Construct an address with the natural alignment of T.
LValue MakeNaturalAlignPointeeRawAddrLValue(llvm::Value *V, QualType T)
Same as MakeNaturalAlignPointeeAddrLValue except that the pointer is known to be unsigned.
@ 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.
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
bool hasSkipCounter(const Stmt *S) const
llvm::AssertingVH< llvm::Instruction > AllocaInsertPt
AllocaInsertPoint - This is an instruction in the entry block before which we prefer to insert alloca...
void EmitFunctionBody(const Stmt *Body)
JumpDest ReturnBlock
ReturnBlock - Unified return block.
llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Location)
Converts Location to a DebugLoc, if debug information is enabled.
llvm::Constant * EmitCheckTypeDescriptor(QualType T)
Emit a description of a type in a format suitable for passing to a runtime sanitizer handler.
llvm::DebugLoc EmitReturnBlock()
Emit the unified return block, trying to avoid its emission when possible.
RawAddress CreateDefaultAlignTempAlloca(llvm::Type *Ty, const Twine &Name="tmp")
CreateDefaultAlignedTempAlloca - This creates an alloca with the default ABI alignment of the given L...
const TargetInfo & getTarget() const
llvm::Value * EmitAnnotationCall(llvm::Function *AnnotationFn, llvm::Value *AnnotatedVal, StringRef AnnotationStr, SourceLocation Location, const AnnotateAttr *Attr)
Emit an annotation call (intrinsic).
Address EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
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.
void maybeCreateMCDCCondBitmap()
Allocate a temp value on the stack that MCDC can use to track condition results.
void emitReturnAlignmentAssumptionCheck(llvm::Value *Ptr, QualType Ty, SourceLocation AssumptionLoc, llvm::Value *Alignment, llvm::Value *OffsetValue=nullptr)
void EmitIgnoredExpr(const Expr *E)
EmitIgnoredExpr - Emit an expression in a context which ignores the result.
RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)
EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...
static bool isInstrumentedCondition(const Expr *C)
isInstrumentedCondition - Determine whether the given condition is an instrumentable condition (i....
VlaSizePair getVLAElements1D(const VariableArrayType *vla)
Return the number of elements for a single dimension for the given array type.
RawAddress CreateIRTempWithoutCast(QualType T, const Twine &Name="tmp")
CreateIRTempWithoutCast - Create a temporary IR object of the given type, with appropriate alignment.
bool AlwaysEmitXRayCustomEvents() const
AlwaysEmitXRayCustomEvents - Return true if we must unconditionally emit XRay custom event handling c...
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.
llvm::Value * EmitPointerAuthSign(const CGPointerAuthInfo &Info, llvm::Value *Pointer)
void markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn)
Annotate the function with an attribute that disables TSan checking at runtime.
llvm::Value * EvaluateExprAsBool(const Expr *E)
EvaluateExprAsBool - Perform the usual unary conversions on the specified expression and compare the ...
void EmitPointerAuthOperandBundle(const CGPointerAuthInfo &Info, SmallVectorImpl< llvm::OperandBundleDef > &Bundles)
void EmitCheck(ArrayRef< std::pair< llvm::Value *, SanitizerKind::SanitizerOrdinal > > Checked, SanitizerHandler Check, ArrayRef< llvm::Constant * > StaticArgs, ArrayRef< llvm::Value * > DynamicArgs, const TrapReason *TR=nullptr)
Create a basic block that will either trap or call a handler function in the UBSan runtime with the p...
void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock::iterator InsertPt) const
CGBuilder insert helper.
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...
bool HaveInsertPoint() const
HaveInsertPoint - True if an insertion point is defined.
bool AlwaysEmitXRayTypedEvents() const
AlwaysEmitXRayTypedEvents - Return true if clang must unconditionally emit XRay typed event handling ...
CGDebugInfo * getDebugInfo()
void EmitStartEHSpec(const Decl *D)
EmitStartEHSpec - Emit the start of the exception spec.
void EmitDestructorBody(FunctionArgList &Args)
EmitDestructorBody - Emits the body of the current destructor.
void EmitX86MultiVersionResolver(llvm::Function *Resolver, ArrayRef< FMVResolverOption > Options)
bool ShouldInstrumentFunction()
ShouldInstrumentFunction - Return true if the current function should be instrumented with __cyg_prof...
void maybeUpdateMCDCCondBitmap(const Expr *E, llvm::Value *Val)
Update the MCDC temp value with the condition's evaluated result.
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **CallOrInvoke, bool IsMustTail, SourceLocation Loc, bool IsVirtualFunctionPointerThunk=false)
EmitCall - Generate a call of the given function, expecting the given result type,...
llvm::ConstantInt * getUBSanFunctionTypeHash(QualType T) const
Return a type hash constant for a function instrumented by -fsanitize=function.
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 emitAlignmentAssumptionCheck(llvm::Value *Ptr, QualType Ty, SourceLocation Loc, SourceLocation AssumptionLoc, llvm::Value *Alignment, llvm::Value *OffsetValue=nullptr)
VlaSizePair getVLASize(const VariableArrayType *vla)
Returns an LLVM value that corresponds to the size, in non-variably-sized elements,...
ASTContext & getContext() const
bool isMCDCBranchExpr(const Expr *E) const
void EmitMultiVersionResolver(llvm::Function *Resolver, ArrayRef< FMVResolverOption > Options)
const Decl * CurFuncDecl
CurFuncDecl - Holds the Decl for the current outermost non-closure context.
static const Expr * stripCond(const Expr *C)
Ignore parentheses and logical-NOT to track conditions consistently.
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 EmitAddressOfPFPField(Address RecordPtr, const PFPField &Field)
void SetFastMathFlags(FPOptions FPFeatures)
Set the codegen fast-math flags.
llvm::SmallVector< char, 256 > LifetimeExtendedCleanupStack
Address EmitVAListRef(const Expr *E)
void EmitLambdaInAllocaCallOpBody(const CXXMethodDecl *MD)
Address ReturnValuePointer
ReturnValuePointer - The temporary alloca to hold a pointer to sret.
static bool mightAddDeclToScope(const Stmt *S)
Determine if the given statement might introduce a declaration into the current scope,...
void EmitStmt(const Stmt *S, ArrayRef< const Attr * > Attrs={})
EmitStmt - Emit the code for the statement.
llvm::DenseMap< const ValueDecl *, FieldDecl * > LambdaCaptureFields
bool AutoreleaseResult
In ARC, whether we should autorelease the return value.
llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
uint64_t getCurrentProfileCount()
Get the profiler's current count.
llvm::Type * ConvertTypeForMem(QualType T)
void EmitEndEHSpec(const Decl *D)
EmitEndEHSpec - Emit the end of the exception spec.
LValue EmitLValueForLambdaField(const FieldDecl *Field)
void emitPFPPostCopyUpdates(Address DestPtr, Address SrcPtr, QualType Ty)
Copy all PFP fields from SrcPtr to DestPtr while updating signatures, assuming that DestPtr was alrea...
Address EmitZOSVAListRef(const Expr *E)
Emit a "reference" to a __builtin_zos_va_list; this is always the address of the expression,...
CodeGenTypes & getTypes() const
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
bool IsSanitizerScope
True if CodeGen currently emits code implementing sanitizer checks.
static bool containsBreak(const Stmt *S)
containsBreak - Return true if the statement contains a break out of it.
void emitImplicitAssignmentOperatorBody(FunctionArgList &Args)
HLSLControlFlowHintAttr::Spelling HLSLControlFlowAttr
HLSL Branch attribute.
void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, LValue LV, QualType Type, SanitizerSet SkippedChecks=SanitizerSet(), llvm::Value *ArraySize=nullptr)
llvm::SmallVector< const ParmVarDecl *, 4 > FnArgs
Save Parameter Decl for coroutine.
const TargetInfo & Target
void EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc, SourceLocation EndLoc, uint64_t RetKeyInstructionsSourceAtom)
EmitFunctionEpilog - Emit the target specific LLVM code to return the given temporary.
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 EmitBranch(llvm::BasicBlock *Block)
EmitBranch - Emit a branch to the specified basic block from the current insert block,...
RawAddress NormalCleanupDest
i32s containing the indexes of the cleanup destinations.
llvm::Type * convertTypeForLoadStore(QualType ASTTy, llvm::Type *LLVMTy=nullptr)
VarBypassDetector Bypasses
llvm::BasicBlock * GetIndirectGotoBlock()
EHScopeStack::stable_iterator PrologueCleanupDepth
PrologueCleanupDepth - The cleanup depth enclosing all the cleanups associated with the parameters.
Address EmitMSVAListRef(const Expr *E)
Emit a "reference" to a __builtin_ms_va_list; this is always the value of the expression,...
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...
const FunctionDecl * getCurrentFunctionDecl() const
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
void EmitTrapCallAndMakeUnreachable()
Emit a call to '@llvm.trap()' and clear the current insert point.
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
const CGFunctionInfo * CurFnInfo
uint64_t getProfileCount(const Stmt *S)
Get the profiler's count for the given statement.
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result, bool AllowLabels=false)
ConstantFoldsToSimpleInteger - If the specified expression does not fold to a constant,...
void ErrorUnsupported(const Stmt *S, const char *Type)
ErrorUnsupported - Print out an error that codegen doesn't support the specified stmt yet.
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
LValue EmitLValue(const Expr *E, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
EmitLValue - Emit code to compute a designator that specifies the location of the expression.
bool ShouldXRayInstrumentFunction() const
ShouldXRayInstrument - Return true if the current function should be instrumented with XRay nop sleds...
void EnsureInsertPoint()
EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go.
llvm::LLVMContext & getLLVMContext()
bool SawAsmBlock
Whether we processed a Microsoft-style asm block during CodeGen.
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.
void emitAlignmentAssumption(llvm::Value *PtrValue, QualType Ty, SourceLocation Loc, SourceLocation AssumptionLoc, llvm::Value *Alignment, llvm::Value *OffsetValue=nullptr)
bool isMCDCDecisionExpr(const Expr *E) const
void EmitVariablyModifiedType(QualType Ty)
EmitVLASize - Capture all the sizes for the VLA expressions in the given variably-modified type and s...
void MaybeEmitDeferredVarDeclInit(const VarDecl *var)
void EmitBlockWithFallThrough(llvm::BasicBlock *BB, const Stmt *S)
When instrumenting to collect profile data, the counts for some blocks such as switch cases need to n...
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
LValue MakeNaturalAlignRawAddrLValue(llvm::Value *V, QualType T)
QualType BuildFunctionArgList(GlobalDecl GD, FunctionArgList &Args)
llvm::Value * EmitPointerAuthAuth(const CGPointerAuthInfo &Info, llvm::Value *Pointer)
This class organizes the cross-function state that is used while generating LLVM code.
CharUnits getNaturalTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, bool forPointeeType=false)
CodeGenTypes & getTypes()
const TargetCodeGenInfo & getTargetCodeGenInfo()
const CodeGenOptions & getCodeGenOpts() const
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::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys={})
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...
FunctionArgList - Type for representing both the decl and type of parameters to a function.
LValue - This represents an lvalue references.
llvm::Value * getPointer(CodeGenFunction &CGF) const
Address getAddress() const
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.
ReturnValueSlot - Contains the address where the return value of a function can be stored,...
virtual llvm::Constant * getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const
Return a constant used by UBSan as a signature to identify functions possessing type information,...
CompoundStmt - This represents a group of statements like { stmt stmt }.
ConditionalOperator - The ?
A reference to a declared variable, function, enum, etc.
Decl - This represents one declaration (or definition), e.g.
ASTContext & getASTContext() const LLVM_READONLY
virtual Stmt * getBody() const
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
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
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.
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, bool AllowRelaxedEval=false) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
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...
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.
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...
FunctionEffectsRef getFunctionEffects() const
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.
FunctionDecl * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Represents a prototype with parameter type info, e.g.
FunctionTypeExtraAttributeInfo getExtraAttributeInfo() const
Return the extra attribute information.
FunctionType - C99 6.7.5.3 - Function Declarators.
@ SME_PStateSMCompatibleMask
GlobalDecl - represents a global declaration.
CXXCtorType getCtorType() const
KernelReferenceKind getKernelReferenceKind() 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, const 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.
RoundingMode getDefaultRoundingMode() const
Represents a parameter to a function.
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
Encodes a location in the source.
A trivial tuple used to represent a source range.
Stmt - This represents one statement.
StmtClass getStmtClass() const
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 ParsedTargetAttr parseTargetAttr(StringRef Str) const
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
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 isObjCRetainableType() const
bool isFunctionNoProtoType() const
bool isCFIUncheckedCalleeFunctionType() 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.
void checkTargetFeatures(ASTContext &Ctx, DiagnosticsEngine &Diags, const LangOptions &LangOpts, const CallExpr *E, const FunctionDecl *Caller, const FunctionDecl *TargetDecl)
Check that a call to a target-specific builtin has the required target features enabled in the caller...
@ Type
The l-value was considered opaque, so the alignment was determined from a type.
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
TypeEvaluationKind
The kind of evaluation to perform on values of a particular type.
CGBuilderInserter CGBuilderInserterTy
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
Top level wrappers for InstallAPI frontend operations.
bool isa(CodeGen::Address addr)
Expr * IgnoreBuiltinExpectSingleStep(Expr *E)
@ NonNull
Values of this type can never be null.
Expr * IgnoreExprNodes(Expr *E, FnTys &&... Fns)
Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *, Recursively apply each of the f...
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Result
The result type of a method or function.
const FunctionProtoType * T
Expr * IgnoreImplicitCastsSingleStep(Expr *E)
Expr * IgnoreUOpLNotSingleStep(Expr *E)
Expr * IgnoreParensSingleStep(Expr *E)
llvm::fp::ExceptionBehavior ToConstrainedExceptMD(LangOptions::FPExceptionModeKind Kind)
U cast(CodeGen::Address addr)
bool IsArmStreamingFunction(const FunctionDecl *FD, bool IncludeLocallyStreaming)
Returns whether the given FunctionDecl has an __arm[_locally]_streaming attribute.
@ Other
Other implicit parameter.
@ EST_None
no exception specification
@ Implicit
An implicit conversion.
A jump destination is an abstract label, branching to which may require a jump out through normal cle...
llvm::BasicBlock * getBlock() const
This structure provides a set of types that are commonly used during IR emission.
llvm::PointerType * VoidPtrTy
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.
A FunctionEffect plus a potential boolean expression determining whether the effect is declared (e....
std::vector< std::string > Features
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.