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);
770 assert(
CurFn->isDeclaration() &&
"Function already has body?");
775#define SANITIZER(NAME, ID) \
776 if (SanOpts.empty()) \
778 if (SanOpts.has(SanitizerKind::ID)) \
779 if (CGM.isInNoSanitizeList(SanitizerKind::ID, Fn, Loc)) \
780 SanOpts.set(SanitizerKind::ID, false);
782#include "clang/Basic/Sanitizers.def"
787 const bool SanitizeBounds =
SanOpts.hasOneOf(SanitizerKind::Bounds);
789 bool NoSanitizeCoverage =
false;
792 no_sanitize_mask |=
Attr->getMask();
794 if (
Attr->hasCoverage())
795 NoSanitizeCoverage =
true;
799 SanOpts.Mask &= ~no_sanitize_mask;
800 if (no_sanitize_mask & SanitizerKind::Address)
801 SanOpts.set(SanitizerKind::KernelAddress,
false);
802 if (no_sanitize_mask & SanitizerKind::KernelAddress)
803 SanOpts.set(SanitizerKind::Address,
false);
804 if (no_sanitize_mask & SanitizerKind::HWAddress)
805 SanOpts.set(SanitizerKind::KernelHWAddress,
false);
806 if (no_sanitize_mask & SanitizerKind::KernelHWAddress)
807 SanOpts.set(SanitizerKind::HWAddress,
false);
809 if (SanitizeBounds && !
SanOpts.hasOneOf(SanitizerKind::Bounds))
810 Fn->addFnAttr(llvm::Attribute::NoSanitizeBounds);
812 if (NoSanitizeCoverage &&
CGM.getCodeGenOpts().hasSanitizeCoverage())
813 Fn->addFnAttr(llvm::Attribute::NoSanitizeCoverage);
816 if (
CGM.getCodeGenOpts().hasSanitizeBinaryMetadata()) {
817 if (no_sanitize_mask & SanitizerKind::Thread)
818 Fn->addFnAttr(
"no_sanitize_thread");
823 CurFn->addFnAttr(llvm::Attribute::DisableSanitizerInstrumentation);
826 if (
SanOpts.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress))
827 Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
828 if (
SanOpts.hasOneOf(SanitizerKind::HWAddress |
829 SanitizerKind::KernelHWAddress))
830 Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
831 if (
SanOpts.has(SanitizerKind::MemtagStack))
832 Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);
833 if (
SanOpts.has(SanitizerKind::Thread))
834 Fn->addFnAttr(llvm::Attribute::SanitizeThread);
835 if (
SanOpts.has(SanitizerKind::Concurrency))
836 Fn->addFnAttr(llvm::Attribute::SanitizeConcurrency);
837 if (
SanOpts.has(SanitizerKind::Type))
838 Fn->addFnAttr(llvm::Attribute::SanitizeType);
839 if (
SanOpts.has(SanitizerKind::NumericalStability))
840 Fn->addFnAttr(llvm::Attribute::SanitizeNumericalStability);
841 if (
SanOpts.hasOneOf(SanitizerKind::Memory | SanitizerKind::KernelMemory))
842 Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
843 if (
SanOpts.has(SanitizerKind::AllocToken))
844 Fn->addFnAttr(llvm::Attribute::SanitizeAllocToken);
846 if (
SanOpts.has(SanitizerKind::SafeStack))
847 Fn->addFnAttr(llvm::Attribute::SafeStack);
848 if (
SanOpts.has(SanitizerKind::ShadowCallStack))
849 Fn->addFnAttr(llvm::Attribute::ShadowCallStack);
851 if (
SanOpts.has(SanitizerKind::Realtime))
855 Fn->addFnAttr(llvm::Attribute::SanitizeRealtime);
857 Fn->addFnAttr(llvm::Attribute::SanitizeRealtimeBlocking);
861 if (
SanOpts.hasOneOf(SanitizerKind::Fuzzer | SanitizerKind::FuzzerNoLink))
862 Fn->addFnAttr(llvm::Attribute::OptForFuzzing);
867 if (
SanOpts.hasOneOf(SanitizerKind::Thread | SanitizerKind::Concurrency)) {
868 if (
const auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(D)) {
869 const IdentifierInfo *II = OMD->getSelector().getIdentifierInfoForSlot(0);
872 (OMD->getSelector().isUnarySelector() && II->
isStr(
".cxx_destruct"))) {
881 if (D &&
SanOpts.has(SanitizerKind::CFIUnrelatedCast)) {
889 if (D &&
SanOpts.has(SanitizerKind::Null))
895 bool AlwaysXRayAttr =
false;
896 if (
const auto *XRayAttr = D ? D->
getAttr<XRayInstrumentAttr>() :
nullptr) {
897 if (
CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
899 CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
902 Fn->addFnAttr(
"function-instrument",
"xray-always");
903 AlwaysXRayAttr =
true;
905 if (XRayAttr->neverXRayInstrument())
906 Fn->addFnAttr(
"function-instrument",
"xray-never");
907 if (
const auto *LogArgs = D->
getAttr<XRayLogArgsAttr>())
909 Fn->addFnAttr(
"xray-log-args",
910 llvm::utostr(LogArgs->getArgumentCount()));
915 "xray-instruction-threshold",
916 llvm::itostr(
CGM.getCodeGenOpts().XRayInstructionThreshold));
920 if (
CGM.getCodeGenOpts().XRayIgnoreLoops)
921 Fn->addFnAttr(
"xray-ignore-loops");
923 if (!
CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
925 Fn->addFnAttr(
"xray-skip-exit");
927 if (!
CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
929 Fn->addFnAttr(
"xray-skip-entry");
931 auto FuncGroups =
CGM.getCodeGenOpts().XRayTotalFunctionGroups;
932 if (FuncGroups > 1) {
934 CurFn->getName().bytes_end());
935 auto Group = crc32(FuncName) % FuncGroups;
936 if (Group !=
CGM.getCodeGenOpts().XRaySelectedFunctionGroup &&
938 Fn->addFnAttr(
"function-instrument",
"xray-never");
942 if (
CGM.getCodeGenOpts().getProfileInstr() !=
943 llvm::driver::ProfileInstrKind::ProfileNone) {
944 switch (
CGM.isFunctionBlockedFromProfileInstr(Fn, Loc)) {
946 Fn->addFnAttr(llvm::Attribute::SkipProfile);
949 Fn->addFnAttr(llvm::Attribute::NoProfile);
956 unsigned Count, Offset;
958 if (
const auto *
Attr =
959 D ? D->
getAttr<PatchableFunctionEntryAttr>() :
nullptr) {
960 Count =
Attr->getCount();
961 Offset =
Attr->getOffset();
962 Section =
Attr->getSection();
964 Count =
CGM.getCodeGenOpts().PatchableFunctionEntryCount;
965 Offset =
CGM.getCodeGenOpts().PatchableFunctionEntryOffset;
968 Section =
CGM.getCodeGenOpts().PatchableFunctionEntrySection;
969 if (Count && Offset <= Count) {
970 Fn->addFnAttr(
"patchable-function-entry", std::to_string(Count - Offset));
972 Fn->addFnAttr(
"patchable-function-prefix", std::to_string(Offset));
973 if (!Section.empty())
974 Fn->addFnAttr(
"patchable-function-entry-section", Section);
980 if (
CGM.getCodeGenOpts().HotPatch &&
983 llvm::Triple::CODE16)
984 Fn->addFnAttr(
"patchable-function",
"prologue-short-redirect");
987 if (
CGM.getCodeGenOpts().NoUseJumpTables)
988 Fn->addFnAttr(
"no-jump-tables",
"true");
991 if (
CGM.getCodeGenOpts().NoInlineLineTables)
992 Fn->addFnAttr(
"no-inline-line-tables");
995 if (
CGM.getCodeGenOpts().ProfileSampleAccurate)
996 Fn->addFnAttr(
"profile-sample-accurate");
998 if (!
CGM.getCodeGenOpts().SampleProfileFile.empty())
999 Fn->addFnAttr(
"use-sample-profile");
1001 if (D && D->
hasAttr<CFICanonicalJumpTableAttr>())
1002 Fn->addFnAttr(
"cfi-canonical-jump-table");
1004 if (D && D->
hasAttr<NoProfileFunctionAttr>())
1005 Fn->addFnAttr(llvm::Attribute::NoProfile);
1007 if (D && D->
hasAttr<HybridPatchableAttr>())
1008 Fn->addFnAttr(llvm::Attribute::HybridPatchable);
1012 if (
auto *A = D->
getAttr<FunctionReturnThunksAttr>()) {
1013 switch (A->getThunkType()) {
1014 case FunctionReturnThunksAttr::Kind::Keep:
1016 case FunctionReturnThunksAttr::Kind::Extern:
1017 Fn->addFnAttr(llvm::Attribute::FnRetThunkExtern);
1020 }
else if (
CGM.getCodeGenOpts().FunctionReturnThunks)
1021 Fn->addFnAttr(llvm::Attribute::FnRetThunkExtern);
1030 EmitKernelMetadata(FD, Fn);
1033 if (FD && FD->
hasAttr<ClspvLibclcBuiltinAttr>()) {
1034 Fn->setMetadata(
"clspv_libclc_builtin",
1041 if (FD &&
SanOpts.has(SanitizerKind::Function) &&
1043 llvm::isCallableCC(Fn->getCallingConv())) {
1045 llvm::LLVMContext &Ctx = Fn->getContext();
1046 llvm::MDBuilder MDB(Ctx);
1048 llvm::LLVMContext::MD_func_sanitize,
1049 MDB.createRTTIPointerPrologue(
1056 if (
SanOpts.has(SanitizerKind::NullabilityReturn)) {
1057 auto Nullability =
FnRetTy->getNullability();
1060 if (!(
SanOpts.has(SanitizerKind::ReturnsNonnullAttribute) &&
1062 RetValNullabilityPrecondition =
1069 if (
CGM.getCodeGenOpts().CopyProf) {
1070 if (
const auto *MD = dyn_cast_or_null<CXXMethodDecl>(D)) {
1072 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
1073 if (!CD->isMoveConstructor())
1075 CD->isCopyConstructor() ?
"copyprof-copy-ctor" :
"copyprof-ctor";
1077 Attr =
"copyprof-dtor";
1079 Attr =
"copyprof-copy-assign-op";
1081 if (!
Attr.empty()) {
1088 CGM.getCodeGenOpts().CopyProfStaticSizeThreshold)
1112 Fn->addFnAttr(llvm::Attribute::NoRecurse);
1115 llvm::fp::ExceptionBehavior FPExceptionBehavior =
1117 Builder.setDefaultConstrainedRounding(RM);
1118 Builder.setDefaultConstrainedExcept(FPExceptionBehavior);
1120 (!FD && (FPExceptionBehavior != llvm::fp::ebIgnore ||
1121 RM != llvm::RoundingMode::NearestTiesToEven))) {
1122 Builder.setIsFPConstrained(
true);
1123 Fn->addFnAttr(llvm::Attribute::StrictFP);
1129 CGM.getCodeGenOpts().StackAlignment))
1130 Fn->addFnAttr(
"stackrealign");
1134 Fn->removeFnAttr(
"zero-call-used-regs");
1137 llvm::StringMap<bool> FeatureMap;
1142 if (
T->getAArch64SMEAttributes() &
1149 std::optional<std::pair<unsigned, unsigned>> VScaleRange =
1153 CurFn->addFnAttr(llvm::Attribute::getWithVScaleRangeArgs(
1162 llvm::Value *Poison = llvm::PoisonValue::get(
Int32Ty);
1167 Builder.SetInsertPoint(EntryBB);
1171 if (requiresReturnValueCheck()) {
1182 DI->emitFunctionStart(GD, Loc, StartLoc,
1183 DI->getFunctionType(FD, RetTy, Args),
CurFn,
1188 if (
CGM.getCodeGenOpts().InstrumentFunctions)
1189 CurFn->addFnAttr(
"instrument-function-entry",
"__cyg_profile_func_enter");
1190 if (
CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining)
1191 CurFn->addFnAttr(
"instrument-function-entry-inlined",
1192 "__cyg_profile_func_enter");
1193 if (
CGM.getCodeGenOpts().InstrumentFunctionEntryBare)
1194 CurFn->addFnAttr(
"instrument-function-entry-inlined",
1195 "__cyg_profile_func_enter_bare");
1202 if (
CGM.getCodeGenOpts().InstrumentForProfiling) {
1206 if (
CGM.getCodeGenOpts().CallFEntry)
1207 Fn->addFnAttr(
"fentry-call",
"true");
1209 Fn->addFnAttr(
"instrument-function-entry-inlined",
1212 if (
CGM.getCodeGenOpts().MNopMCount) {
1213 if (!
CGM.getCodeGenOpts().CallFEntry)
1214 CGM.getDiags().Report(diag::err_opt_not_valid_without_opt)
1215 <<
"-mnop-mcount" <<
"-mfentry";
1216 Fn->addFnAttr(
"mnop-mcount");
1219 if (
CGM.getCodeGenOpts().RecordMCount) {
1220 if (!
CGM.getCodeGenOpts().CallFEntry)
1221 CGM.getDiags().Report(diag::err_opt_not_valid_without_opt)
1222 <<
"-mrecord-mcount" <<
"-mfentry";
1223 Fn->addFnAttr(
"mrecord-mcount");
1228 if (
CGM.getCodeGenOpts().PackedStack) {
1230 llvm::Triple::systemz)
1231 CGM.getDiags().Report(diag::err_opt_not_valid_on_target)
1232 <<
"-mpacked-stack";
1233 Fn->addFnAttr(
"packed-stack");
1236 if (!
CGM.getCodeGenOpts().ZOSPPA1Name)
1237 Fn->addFnAttr(
"zos-ppa1-name",
"");
1239 FD->
hasAttr<AsmLabelAttr>()) {
1240 std::string SrcName =
CGM.getMangledNameIgnoringAsmLabel(GD, FD);
1241 Fn->addFnAttr(
"zos-ppa1-name", SrcName);
1244 if (
CGM.getCodeGenOpts().WarnStackSize !=
UINT_MAX &&
1245 !
CGM.getDiags().isIgnored(diag::warn_fe_backend_frame_larger_than, Loc))
1246 Fn->addFnAttr(
"warn-stack-size",
1247 std::to_string(
CGM.getCodeGenOpts().WarnStackSize));
1259 auto AI =
CurFn->arg_begin();
1260 if (
CurFnInfo->getReturnInfo().isSRetAfterThis())
1263 &*AI, RetTy,
CurFnInfo->getReturnInfo().getIndirectAlign(),
false,
1265 if (!
CurFnInfo->getReturnInfo().getIndirectByVal()) {
1274 unsigned Idx =
CurFnInfo->getReturnInfo().getInAllocaFieldIndex();
1275 llvm::Function::arg_iterator EI =
CurFn->arg_end();
1307 if (FD->
hasAttr<HLSLShaderAttr>()) {
1308 CGM.getHLSLRuntime().emitEntryFunction(FD, Fn);
1314 if (
const CXXMethodDecl *MD = dyn_cast_if_present<CXXMethodDecl>(D);
1319 CGM.getCXXABI().EmitInstanceFunctionProlog(*
this);
1335 CXXThisValue = ThisFieldLValue.
getPointer(*
this);
1344 if (FD->hasCapturedVLAType()) {
1347 auto VAT = FD->getCapturedVLAType();
1348 VLASizeMap[VAT->getSizeExpr()] = ExprArg;
1355 CXXThisValue = CXXABIThisValue;
1359 if (CXXABIThisValue) {
1361 SkippedChecks.
set(SanitizerKind::ObjectSize,
true);
1368 SkippedChecks.
set(SanitizerKind::Null,
true);
1372 Loc, CXXABIThisValue, ThisTy, CXXABIThisAlignment, SkippedChecks);
1379 if (!FD || !FD->
hasAttr<NakedAttr>()) {
1380 for (
const VarDecl *VD : Args) {
1385 if (
const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD))
1386 Ty = PVD->getOriginalType();
1396 DI->EmitLocation(
Builder, StartLoc);
1400 if (
const auto *VecWidth =
CurFuncDecl->getAttr<MinVectorWidthAttr>())
1401 LargestVectorWidth = VecWidth->getVectorWidth();
1403 if (
CGM.shouldEmitConvergenceTokens())
1410 if (
const CompoundStmt *S = dyn_cast<CompoundStmt>(Body))
1422 llvm::BasicBlock *SkipCountBB =
nullptr;
1444 if (F->isInterposable())
return;
1446 for (llvm::BasicBlock &BB : *F)
1447 for (llvm::Instruction &I : BB)
1451 F->setDoesNotThrow();
1461 if (
CGM.getCXXABI().HasThisReturn(GD))
1463 else if (
CGM.getCXXABI().hasMostDerivedReturn(GD))
1464 ResTy =
CGM.getContext().VoidPtrTy;
1465 CGM.getCXXABI().buildThisParam(*
this, Args);
1471 bool PassedParams =
true;
1473 if (
auto Inherited = CD->getInheritedConstructor())
1479 Args.push_back(Param);
1480 if (!Param->hasAttr<PassObjectSizeAttr>())
1484 getContext(), Param->getDeclContext(), Param->getLocation(),
1492 CGM.getCXXABI().addImplicitStructorParams(*
this, ResTy, Args);
1499 assert(Fn &&
"generating code for null Function");
1506 CGM.getTargetCodeGenInfo().checkFunctionABI(
CGM, FD);
1512 std::string FDInlineName = (Fn->getName() +
".inline").str();
1513 llvm::Module *M = Fn->getParent();
1514 llvm::Function *Clone = M->getFunction(FDInlineName);
1516 Clone = llvm::Function::Create(Fn->getFunctionType(),
1517 llvm::GlobalValue::InternalLinkage,
1518 Fn->getAddressSpace(), FDInlineName, M);
1519 Clone->setCallingConv(Fn->getCallingConv());
1520 Clone->setAttributes(Fn->getAttributes());
1521 Clone->addFnAttr(llvm::Attribute::AlwaysInline);
1523 Fn->setLinkage(llvm::GlobalValue::ExternalLinkage);
1533 if (LLVM_UNLIKELY(PD->isInlineBuiltinDeclaration())) {
1534 std::string FDInlineName = (Fn->getName() +
".inline").str();
1535 llvm::Module *M = Fn->getParent();
1536 if (llvm::Function *Clone = M->getFunction(FDInlineName)) {
1537 Clone->replaceAllUsesWith(Fn);
1538 Clone->eraseFromParent();
1546 if (FD->
hasAttr<NoDebugAttr>()) {
1549 Fn->setSubprogram(
nullptr);
1551 DebugInfo =
nullptr;
1554 llvm::scope_exit Cleanup([
this] {
1556 DI->completeFunction();
1563 BodyRange = Body->getSourceRange();
1566 CurEHLocation = BodyRange.getEnd();
1578 if (SpecDecl->hasBody(SpecDecl))
1579 Loc = SpecDecl->getLocation();
1586 ShouldEmitLifetimeMarkers =
true;
1589 bool NeedsBypassDetection =
1590 ShouldEmitLifetimeMarkers ||
1591 (
CGM.getLangOpts().getTrivialAutoVarInit() !=
1593 if (NeedsBypassDetection)
1598 StartFunction(GD, ResTy, Fn, FnInfo, Args, Loc, BodyRange.getBegin());
1601 if (Body && isa_and_nonnull<CoroutineBodyStmt>(Body))
1609 CurFn->addFnAttr(llvm::Attribute::MustProgress);
1612 PGO->assignRegionCounters(GD,
CurFn);
1619 FD->
hasAttr<CUDAGlobalAttr>())
1620 CGM.getCUDARuntime().emitDeviceStub(*
this, Args);
1643 }
else if (DeviceKernelAttr::isOpenCLSpelling(
1644 FD->
getAttr<DeviceKernelAttr>()) &&
1647 for (
unsigned i = 0; i < Args.size(); ++i) {
1649 QualType ArgQualType = Args[i]->getType();
1651 CallArgs.
add(ArgRValue, ArgQualType);
1655 CGM.getTargetCodeGenInfo().setOCLKernelStubCallingConvention(FT);
1658 llvm::FunctionType *FTy =
CGM.getTypes().GetFunctionType(FnInfo);
1659 llvm::Constant *GDStubFunctionPointer =
1660 CGM.getRawFunctionPointer(GDStub, FTy);
1667 llvm_unreachable(
"no definition for emitted function");
1677 bool ShouldEmitUnreachable =
1678 CGM.getCodeGenOpts().StrictReturn ||
1680 if (
SanOpts.has(SanitizerKind::Return)) {
1681 auto CheckOrdinal = SanitizerKind::SO_Return;
1682 auto CheckHandler = SanitizerHandler::MissingReturn;
1684 llvm::Value *IsFalse =
Builder.getFalse();
1685 EmitCheck(std::make_pair(IsFalse, CheckOrdinal), CheckHandler,
1687 }
else if (ShouldEmitUnreachable) {
1688 if (
CGM.getCodeGenOpts().OptimizationLevel == 0)
1691 if (
SanOpts.has(SanitizerKind::Return) || ShouldEmitUnreachable) {
1693 Builder.ClearInsertionPoint();
1700 PGO->verifyCounterMap();
1703 StringRef Identifier =
1704 CurCodeDecl->getAttr<PersonalityAttr>()->getRoutine()->getName();
1705 llvm::FunctionCallee PersonalityRoutine =
1706 CGM.CreateRuntimeFunction(llvm::FunctionType::get(
CGM.Int32Ty,
true),
1707 Identifier, {},
true);
1713 if (!
CurFn->doesNotThrow())
1722 if (!S)
return false;
1739 IgnoreCaseStmts =
true;
1754 if (!S)
return false;
1774 if (!S)
return false;
1805 if (!AllowLabels &&
CGM.getCodeGenOpts().hasProfileClangInstr() &&
1806 CGM.getCodeGenOpts().MCDCCoverage)
1809 llvm::APSInt ResultInt;
1813 ResultBool = ResultInt.getBoolValue();
1821 llvm::APSInt &ResultInt,
1833 PGO->markStmtMaybeUsed(Cond);
1834 ResultInt = std::move(
Int);
1863 llvm::BasicBlock *FalseBlock, uint64_t TrueCount ,
1866 bool InstrumentRegions =
CGM.getCodeGenOpts().hasProfileClangInstr();
1870 const Stmt *CntrStmt = (CntrIdx ? CntrIdx : Cond);
1872 llvm::BasicBlock *ThenBlock =
nullptr;
1873 llvm::BasicBlock *ElseBlock =
nullptr;
1874 llvm::BasicBlock *NextBlock =
nullptr;
1879 llvm::BasicBlock *SkipIncrBlock =
1881 llvm::BasicBlock *SkipNextBlock =
nullptr;
1895 if (LOp == BO_LAnd) {
1896 SkipNextBlock = FalseBlock;
1897 ThenBlock = CounterIncrBlock;
1898 ElseBlock = (SkipIncrBlock ? SkipIncrBlock : SkipNextBlock);
1899 NextBlock = TrueBlock;
1914 else if (LOp == BO_LOr) {
1915 SkipNextBlock = TrueBlock;
1916 ThenBlock = (SkipIncrBlock ? SkipIncrBlock : SkipNextBlock);
1917 ElseBlock = CounterIncrBlock;
1918 NextBlock = FalseBlock;
1920 llvm_unreachable(
"Expected Opcode must be that of a Logical Operator");
1926 if (SkipIncrBlock) {
1950 const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock,
1952 const VarDecl *ConditionalDecl) {
1955 if (
const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) {
1959 if (CondBOp->getOpcode() == BO_LAnd) {
1962 bool ConstantBool =
false;
1968 FalseBlock, TrueCount, LH);
1978 FalseBlock, TrueCount, LH, CondBOp);
1985 llvm::BasicBlock *LHSFalse =
2013 FalseBlock, TrueCount, LH);
2018 if (CondBOp->getOpcode() == BO_LOr) {
2021 bool ConstantBool =
false;
2027 FalseBlock, TrueCount, LH);
2037 FalseBlock, TrueCount, LH, CondBOp);
2042 llvm::BasicBlock *LHSTrue =
2050 uint64_t RHSCount = TrueCount - LHSCount;
2081 if (
const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) {
2086 bool MCDCCondition =
CGM.getCodeGenOpts().hasProfileClangInstr() &&
2087 CGM.getCodeGenOpts().MCDCCoverage &&
2089 if (CondUOp->getOpcode() == UO_LNot && !MCDCCondition) {
2116 uint64_t LHSScaledTrueCount = 0;
2120 LHSScaledTrueCount = TrueCount * LHSRatio;
2129 LHSScaledTrueCount, LH, CondOp);
2137 TrueCount - LHSScaledTrueCount, LH, CondOp);
2143 if (
const CXXThrowExpr *Throw = dyn_cast<CXXThrowExpr>(Cond)) {
2165 const Expr *MCDCBaseExpr = Cond;
2172 MCDCBaseExpr = ConditionalOp;
2179 llvm::MDNode *Weights =
nullptr;
2180 llvm::MDNode *Unpredictable =
nullptr;
2186 if (
Call &&
CGM.getCodeGenOpts().OptimizationLevel != 0) {
2187 auto *FD = dyn_cast_or_null<FunctionDecl>(
Call->getCalleeDecl());
2188 if (FD && FD->
getBuiltinID() == Builtin::BI__builtin_unpredictable) {
2190 Unpredictable = MDHelper.createUnpredictable();
2196 llvm::Value *NewCondV = emitCondLikelihoodViaExpectIntrinsic(CondV, LH);
2197 if (CondV != NewCondV)
2202 Weights = createProfileWeights(TrueCount, CurrentCount - TrueCount);
2205 llvm::Instruction *BrInst =
Builder.CreateCondBr(CondV, TrueBlock, FalseBlock,
2206 Weights, Unpredictable);
2210 case HLSLControlFlowHintAttr::Microsoft_branch:
2211 case HLSLControlFlowHintAttr::Microsoft_flatten: {
2212 llvm::MDBuilder MDHelper(
CGM.getLLVMContext());
2214 llvm::ConstantInt *BranchHintConstant =
2216 HLSLControlFlowHintAttr::Spelling::Microsoft_branch
2217 ? llvm::ConstantInt::get(
CGM.Int32Ty, 1)
2218 : llvm::ConstantInt::get(
CGM.Int32Ty, 2);
2221 {MDHelper.createString(
"hlsl.controlflow.hint"),
2222 MDHelper.createConstant(BranchHintConstant)});
2223 BrInst->setMetadata(
"hlsl.controlflow.hint",
2224 llvm::MDNode::get(
CGM.getLLVMContext(), Vals));
2228 case HLSLControlFlowHintAttr::SpellingNotCalculated:
2236 llvm::Value *Arg =
nullptr;
2237 if ((ICEArguments & (1 << Idx)) == 0) {
2242 std::optional<llvm::APSInt>
Result =
2244 assert(
Result &&
"Expected argument to be a constant");
2253 CGM.ErrorUnsupported(S,
Type);
2265 llvm::Value *sizeInChars) {
2269 llvm::Value *baseSizeInChars
2273 llvm::Value *end = Builder.CreateInBoundsGEP(begin.
getElementType(),
2275 sizeInChars,
"vla.end");
2277 llvm::BasicBlock *originBB = CGF.
Builder.GetInsertBlock();
2285 llvm::PHINode *cur = Builder.CreatePHI(begin.
getType(), 2,
"vla.cur");
2292 Builder.CreateMemCpy(
Address(cur, CGF.
Int8Ty, curAlign), src, baseSizeInChars,
2297 Builder.CreateInBoundsGEP(CGF.
Int8Ty, cur, baseSizeInChars,
"vla.next");
2300 llvm::Value *done = Builder.CreateICmpEQ(next, end,
"vla-init.isdone");
2301 Builder.CreateCondBr(done, contBB, loopBB);
2302 cur->addIncoming(next, loopBB);
2320 if (
CGM.getContext().arePFPFieldsTriviallyCopyable(Field->getParent())) {
2321 uint64_t FieldSignature =
2322 llvm::getPointerAuthStableSipHash(
CGM.getPFPFieldName(Field));
2323 Disc = llvm::ConstantInt::get(
CGM.Int64Ty, FieldSignature);
2327 llvm::GlobalValue *DS =
CGM.getPFPDeactivationSymbol(Field);
2328 llvm::OperandBundleDef DSBundle(
"deactivation-symbol", DS);
2331 Builder.CreateCall(
CGM.getIntrinsic(llvm::Intrinsic::protected_field_ptr,
2350 llvm::Value *SizeVal;
2357 dyn_cast_or_null<VariableArrayType>(
2360 SizeVal = VlaSize.NumElts;
2362 if (!eltSize.
isOne())
2363 SizeVal =
Builder.CreateNUWMul(SizeVal,
CGM.getSize(eltSize));
2369 SizeVal =
CGM.getSize(size);
2377 if (!
CGM.getTypes().isZeroInitializable(Ty)) {
2381 llvm::Constant *NullConstant =
CGM.EmitNullConstant(Ty);
2383 llvm::GlobalVariable *NullVariable =
2384 new llvm::GlobalVariable(
CGM.getModule(), NullConstant->getType(),
2386 llvm::GlobalVariable::PrivateLinkage,
2387 NullConstant, Twine());
2389 NullVariable->setAlignment(NullAlign.
getAsAlign());
2395 Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal,
false);
2401 Builder.CreateMemSet(DestPtr,
Builder.getInt8(0), SizeVal,
false);
2414 if (!IndirectBranch)
2420 IndirectBranch->addDestination(BB);
2421 return llvm::BlockAddress::get(
CurFn->getType(), BB);
2426 if (IndirectBranch)
return IndirectBranch->getParent();
2431 llvm::Value *DestVal = TmpBuilder.CreatePHI(
Int8PtrTy, 0,
2432 "indirect.goto.dest");
2435 IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal);
2436 return IndirectBranch->getParent();
2448 llvm::Value *numVLAElements =
nullptr;
2460 baseType = elementType;
2461 return numVLAElements;
2475 llvm::ConstantInt *zero =
Builder.getInt32(0);
2476 gepIndices.push_back(zero);
2478 uint64_t countFromCLAs = 1;
2481 llvm::ArrayType *llvmArrayType =
2483 while (llvmArrayType) {
2486 llvmArrayType->getNumElements());
2488 gepIndices.push_back(zero);
2489 countFromCLAs *= llvmArrayType->getNumElements();
2493 dyn_cast<llvm::ArrayType>(llvmArrayType->getElementType());
2496 "LLVM and Clang types are out-of-synch");
2515 gepIndices,
"array.begin"),
2521 llvm::Value *numElements
2522 = llvm::ConstantInt::get(
SizeTy, countFromCLAs);
2526 numElements =
Builder.CreateNUWMul(numVLAElements, numElements);
2533 assert(vla &&
"type was not a variable array type!");
2540 llvm::Value *numElements =
nullptr;
2544 elementType =
type->getElementType();
2545 llvm::Value *vlaSize = VLASizeMap[
type->getSizeExpr()];
2546 assert(vlaSize &&
"no size for VLA!");
2547 assert(vlaSize->getType() ==
SizeTy);
2550 numElements = vlaSize;
2554 numElements =
Builder.CreateNUWMul(numElements, vlaSize);
2556 }
while ((
type =
getContext().getAsVariableArrayType(elementType)));
2558 return { numElements, elementType };
2564 assert(vla &&
"type was not a variable array type!");
2570 llvm::Value *VlaSize = VLASizeMap[Vla->
getSizeExpr()];
2571 assert(VlaSize &&
"no size for VLA!");
2572 assert(VlaSize->getType() ==
SizeTy);
2577 assert(
type->isVariablyModifiedType() &&
2578 "Must pass variably modified type to EmitVLASizes!");
2585 assert(
type->isVariablyModifiedType());
2587 const Type *ty =
type.getTypePtr();
2590#define TYPE(Class, Base)
2591#define ABSTRACT_TYPE(Class, Base)
2592#define NON_CANONICAL_TYPE(Class, Base)
2593#define DEPENDENT_TYPE(Class, Base) case Type::Class:
2594#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
2595#include "clang/AST/TypeNodes.inc"
2596 llvm_unreachable(
"unexpected dependent type!");
2602 case Type::ExtVector:
2603 case Type::ConstantMatrix:
2607 case Type::TemplateSpecialization:
2608 case Type::ObjCTypeParam:
2609 case Type::ObjCObject:
2610 case Type::ObjCInterface:
2611 case Type::ObjCObjectPointer:
2613 case Type::HLSLInlineSpirv:
2614 case Type::PredefinedSugar:
2615 llvm_unreachable(
"type class is never variably-modified!");
2617 case Type::Adjusted:
2629 case Type::BlockPointer:
2633 case Type::LValueReference:
2634 case Type::RValueReference:
2638 case Type::MemberPointer:
2642 case Type::ArrayParameter:
2643 case Type::ConstantArray:
2644 case Type::IncompleteArray:
2649 case Type::VariableArray: {
2658 llvm::Value *&entry = VLASizeMap[sizeExpr];
2666 if (
SanOpts.has(SanitizerKind::VLABound)) {
2667 auto CheckOrdinal = SanitizerKind::SO_VLABound;
2668 auto CheckHandler = SanitizerHandler::VLABoundNotPositive;
2670 llvm::Value *
Zero = llvm::Constant::getNullValue(size->getType());
2672 llvm::Value *CheckCondition =
2676 llvm::Constant *StaticArgs[] = {
2679 EmitCheck(std::make_pair(CheckCondition, CheckOrdinal),
2680 CheckHandler, StaticArgs, size);
2693 case Type::FunctionProto:
2694 case Type::FunctionNoProto:
2700 case Type::UnaryTransform:
2701 case Type::Attributed:
2702 case Type::BTFTagAttributed:
2703 case Type::OverflowBehavior:
2704 case Type::HLSLAttributedResource:
2705 case Type::SubstTemplateTypeParm:
2706 case Type::MacroQualified:
2707 case Type::CountAttributed:
2708 case Type::LateParsedAttr:
2714 case Type::Decltype:
2716 case Type::DeducedTemplateSpecialization:
2717 case Type::PackIndexing:
2721 case Type::TypeOfExpr:
2734 }
while (
type->isVariablyModifiedType());
2738 if (
getContext().getBuiltinVaListType()->isArrayType())
2753 assert(
Init.hasValue() &&
"Invalid DeclRefExpr initializer!");
2755 if (
CGM.getCodeGenOpts().hasReducedDebugInfo())
2771 llvm::Instruction *inst =
new llvm::BitCastInst(value, value->getType(),
"",
2775 protection.Inst = inst;
2780 if (!protection.Inst)
return;
2783 protection.Inst->eraseFromParent();
2789 llvm::Value *Alignment,
2790 llvm::Value *OffsetValue) {
2791 if (Alignment->getType() !=
IntPtrTy)
2794 if (OffsetValue && OffsetValue->getType() !=
IntPtrTy)
2797 if (
SanOpts.has(SanitizerKind::Alignment))
2800 Builder.CreateAlignmentAssumption(
CGM.getDataLayout(), PtrValue, Alignment,
2807 llvm::Value *Alignment,
2808 llvm::Value *OffsetValue) {
2817 llvm::Value *AnnotatedVal,
2818 StringRef AnnotationStr,
2820 const AnnotateAttr *
Attr) {
2823 CGM.EmitAnnotationString(AnnotationStr),
2824 CGM.EmitAnnotationUnit(Location),
2825 CGM.EmitAnnotationLineNo(Location),
2828 Args.push_back(
CGM.EmitAnnotationArgs(
Attr));
2829 return Builder.CreateCall(AnnotationFn, Args);
2833 assert(D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
2836 {V->getType(), CGM.ConstGlobalsPtrTy}),
2842 assert(D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
2843 llvm::Value *
V =
Addr.emitRawPointer(*
this);
2844 llvm::Type *VTy =
V->getType();
2845 auto *PTy = dyn_cast<llvm::PointerType>(VTy);
2846 unsigned AS = PTy ? PTy->getAddressSpace() : 0;
2847 llvm::PointerType *IntrinTy =
2848 llvm::PointerType::get(
CGM.getLLVMContext(), AS);
2849 llvm::Function *F =
CGM.getIntrinsic(llvm::Intrinsic::ptr_annotation,
2850 {IntrinTy,
CGM.ConstGlobalsPtrTy});
2856 if (VTy != IntrinTy)
2869 assert(!CGF->IsSanitizerScope);
2870 CGF->IsSanitizerScope =
true;
2874 CGF->IsSanitizerScope =
false;
2878 const llvm::Twine &Name,
2879 llvm::BasicBlock::iterator InsertPt)
const {
2882 I->setNoSanitizeMetadata();
2886 llvm::Instruction *I,
const llvm::Twine &Name,
2887 llvm::BasicBlock::iterator InsertPt)
const {
2888 llvm::IRBuilderDefaultInserter::InsertHelper(I, Name, InsertPt);
2890 CGF->InsertHelper(I, Name, InsertPt);
2912 if (!
CGM.getCodeGenOpts().SanitizeStats)
2915 llvm::IRBuilder<> IRB(
Builder.GetInsertPoint());
2916 IRB.SetCurrentDebugLocation(
Builder.getCurrentDebugLocation());
2917 CGM.getSanStats().create(IRB, SSK);
2929 Salt = Info.CFISalt;
2931 Bundles.emplace_back(
"kcfi",
CGM.CreateKCFITypeId(FP->
desugar(), Salt));
2935CodeGenFunction::FormAArch64ResolverCondition(
const FMVResolverOption &RO) {
2936 return RO.Features.empty() ?
nullptr : EmitAArch64CpuSupports(RO.Features);
2940CodeGenFunction::FormX86ResolverCondition(
const FMVResolverOption &RO) {
2943 if (RO.Architecture) {
2944 StringRef
Arch = *RO.Architecture;
2947 if (
Arch.starts_with(
"x86-64"))
2953 if (!RO.Features.empty()) {
2954 llvm::Value *FeatureCond = EmitX86CpuSupports(RO.Features);
2962 llvm::Function *Resolver,
2964 llvm::Function *FuncToReturn,
2965 bool SupportsIFunc) {
2966 if (SupportsIFunc) {
2967 Builder.CreateRet(FuncToReturn);
2972 llvm::make_pointer_range(Resolver->args()));
2974 llvm::CallInst *
Result = Builder.CreateCall(FuncToReturn, Args);
2975 Result->setTailCallKind(llvm::CallInst::TCK_MustTail);
2977 if (Resolver->getReturnType()->isVoidTy())
2978 Builder.CreateRetVoid();
2980 Builder.CreateRet(
Result);
2986 llvm::Triple::ArchType ArchType =
2990 case llvm::Triple::x86:
2991 case llvm::Triple::x86_64:
2994 case llvm::Triple::aarch64:
2997 case llvm::Triple::riscv32:
2998 case llvm::Triple::riscv64:
2999 case llvm::Triple::riscv32be:
3000 case llvm::Triple::riscv64be:
3003 case llvm::Triple::ppc:
3004 case llvm::Triple::ppc64:
3012 "Only implemented for x86, AArch64, RISC-V, and PowerPC AIX");
3039 Builder.SetInsertPoint(CurBlock);
3041 if (!RO.Architecture && RO.Features.empty()) {
3044 assert(&RO == Options.end() - 1 &&
3045 "Default or Generic case must be last");
3046 Builder.CreateRet(RO.Function);
3055 assert(RO.Features.size() == 1 &&
3056 "for now one feature requirement per version");
3058 StringRef FeatureStr = RO.Features[0];
3059 StringRef BuiltinCpuSupportsArg;
3060 bool IsNegated =
false;
3062 if (FeatureStr.starts_with(
"cpu=")) {
3064 StringRef CPU = FeatureStr.split(
"=").second.trim();
3065 BuiltinCpuSupportsArg = llvm::StringSwitch<StringRef>(CPU)
3066#define PPC_AIX_CLONES_CPU(CPU_NAME, AIX_BUILTIN_CPU_SUPPORTS_NAME, _) \
3067 .Case(CPU_NAME, AIX_BUILTIN_CPU_SUPPORTS_NAME)
3068#include "llvm/TargetParser/PPCTargetParser.def"
3074 if (FeatureStr.starts_with(
"no-")) {
3076 FeatureStr = FeatureStr.drop_front(3);
3080 BuiltinCpuSupportsArg =
3081 llvm::StringSwitch<StringRef>(FeatureStr)
3082#define PPC_AIX_CLONES_FEATURE(FEATURE_NAME, AIX_BUILTIN_CPU_SUPPORTS_NAME, _, \
3084 .Case(FEATURE_NAME, AIX_BUILTIN_CPU_SUPPORTS_NAME)
3085#include "llvm/TargetParser/PPCTargetParser.def"
3090 assert(!BuiltinCpuSupportsArg.empty() &&
3091 "Feature without runtime detection should have been rejected in "
3095 assert(
getContext().getTargetInfo().validateCpuSupports(
3096 BuiltinCpuSupportsArg));
3100 Builder.getInt1Ty(), BuiltinCpuSupportsArg);
3111 Builder.SetInsertPoint(ThenBlock);
3112 Builder.CreateRet(RO.Function);
3115 llvm_unreachable(
"Default case missing");
3122 llvm::Triple::OSType::Linux) {
3123 CGM.getDiags().Report(diag::err_os_unsupport_riscv_fmv);
3128 Builder.SetInsertPoint(CurBlock);
3132 bool HasDefault =
false;
3133 unsigned DefaultIndex = 0;
3136 for (
unsigned Index = 0; Index < Options.size(); Index++) {
3138 if (Options[Index].Features.empty()) {
3140 DefaultIndex = Index;
3144 Builder.SetInsertPoint(CurBlock);
3170 for (StringRef Feat : Options[Index].Features) {
3171 std::vector<std::string> FeatStr =
3174 assert(FeatStr.size() == 1 &&
"Feature string not delimited");
3176 std::string &CurrFeat = FeatStr.front();
3177 if (CurrFeat[0] ==
'+')
3178 TargetAttrFeats.push_back(CurrFeat.substr(1));
3181 if (TargetAttrFeats.empty())
3184 for (std::string &Feat : TargetAttrFeats)
3185 CurrTargetAttrFeats.push_back(Feat);
3187 Builder.SetInsertPoint(CurBlock);
3190 llvm::BasicBlock *RetBlock =
createBasicBlock(
"resolver_return", Resolver);
3193 Options[Index].
Function, SupportsIFunc);
3196 Builder.SetInsertPoint(CurBlock);
3197 Builder.CreateCondBr(FeatsCondition, RetBlock, ElseBlock);
3199 CurBlock = ElseBlock;
3204 Builder.SetInsertPoint(CurBlock);
3211 Builder.SetInsertPoint(CurBlock);
3217 assert(!Options.empty() &&
"No multiversion resolver options found");
3218 assert(Options.back().Features.size() == 0 &&
"Default case must be last");
3220 assert(SupportsIFunc &&
3221 "Multiversion resolver requires target IFUNC support");
3222 bool AArch64CpuInitialized =
false;
3227 if (RO.Function ==
nullptr)
3230 Builder.SetInsertPoint(CurBlock);
3231 llvm::Value *
Condition = FormAArch64ResolverCondition(RO);
3240 if (!AArch64CpuInitialized) {
3241 Builder.SetInsertPoint(CurBlock->begin());
3242 EmitAArch64CpuInit();
3243 AArch64CpuInitialized =
true;
3244 Builder.SetInsertPoint(CurBlock);
3247 llvm::BasicBlock *RetBlock =
createBasicBlock(
"resolver_return", Resolver);
3256 Builder.SetInsertPoint(CurBlock);
3267 Builder.SetInsertPoint(CurBlock);
3271 Builder.SetInsertPoint(CurBlock);
3272 llvm::Value *
Condition = FormX86ResolverCondition(RO);
3276 assert(&RO == Options.end() - 1 &&
3277 "Default or Generic case must be last");
3283 llvm::BasicBlock *RetBlock =
createBasicBlock(
"resolver_return", Resolver);
3292 Builder.SetInsertPoint(CurBlock);
3304 llvm::Value *DynamicLoc,
3306 llvm::Value *Alignment,
3307 llvm::Value *OffsetValue) {
3308 if (!CGF.
SanOpts.
has(SanitizerKind::Alignment))
3313 if (Alignment->getType() !=
IntPtrTy)
3315 Builder.CreateIntCast(Alignment,
IntPtrTy,
false,
"casted.align");
3316 if (OffsetValue && OffsetValue->getType() !=
IntPtrTy)
3318 Builder.CreateIntCast(OffsetValue,
IntPtrTy,
true,
"casted.offset");
3320 llvm::Value *PtrIntValue = Builder.CreatePtrToInt(Ptr,
IntPtrTy,
"ptrint");
3323 bool IsOffsetZero =
false;
3324 if (
const auto *CI = dyn_cast<llvm::ConstantInt>(OffsetValue))
3325 IsOffsetZero = CI->isZero();
3328 PtrIntValue = Builder.CreateSub(PtrIntValue, OffsetValue,
"offsetptr");
3331 llvm::Value *
Zero = llvm::ConstantInt::get(
IntPtrTy, 0);
3333 Builder.CreateSub(Alignment, llvm::ConstantInt::get(
IntPtrTy, 1));
3334 llvm::Value *MaskedPtr = Builder.CreateAnd(PtrIntValue, Mask,
"maskedptr");
3335 llvm::Value *TheCheck = Builder.CreateICmpEQ(MaskedPtr,
Zero,
"maskcond");
3342 auto CheckOrdinal = SanitizerKind::SO_Alignment;
3343 auto CheckHandler = !DynamicLoc ? SanitizerHandler::AlignmentAssumption
3344 : SanitizerHandler::ReturnAlignmentAssumption;
3348 OffsetValue = Builder.getInt1(
false);
3354 llvm::Value *DynamicData[] = {Ptr, Alignment, OffsetValue};
3355 CGF.
EmitCheck({std::make_pair(TheCheck, CheckOrdinal)}, CheckHandler,
3356 StaticData, DynamicData);
3360 llvm::Value *DynamicData[] = {DynamicLoc, Ptr, Alignment, OffsetValue};
3361 CGF.
EmitCheck({std::make_pair(TheCheck, CheckOrdinal)}, CheckHandler,
3362 StaticData, DynamicData);
3370 llvm::Value *Alignment,
3371 llvm::Value *OffsetValue) {
3373 Alignment, OffsetValue);
3378 llvm::Value *Alignment, llvm::Value *OffsetValue) {
3379 llvm::Value *SLocPtr =
Builder.CreateLoad(ReturnLocation,
"return.sloc.load");
3381 AssumptionLoc, Alignment, OffsetValue);
3386 return DI->SourceLocToDebugLoc(Location);
3388 return llvm::DebugLoc();
3392CodeGenFunction::emitCondLikelihoodViaExpectIntrinsic(llvm::Value *Cond,
3403 llvm::Type *CondTy = Cond->getType();
3404 assert(CondTy->isIntegerTy(1) &&
"expecting condition to be a boolean");
3405 llvm::Function *FnExpect =
3407 llvm::Value *ExpectedValueOfCond =
3409 return Builder.CreateCall(FnExpect, {Cond, ExpectedValueOfCond},
3410 Cond->getName() +
".expval");
3412 llvm_unreachable(
"Unknown Likelihood");
3416 unsigned NumElementsDst,
3417 const llvm::Twine &Name) {
3419 unsigned NumElementsSrc = SrcTy->getNumElements();
3420 if (NumElementsSrc == NumElementsDst)
3423 std::vector<int> ShuffleMask(NumElementsDst, -1);
3424 for (
unsigned MaskIdx = 0;
3425 MaskIdx < std::min<>(NumElementsDst, NumElementsSrc); ++MaskIdx)
3426 ShuffleMask[MaskIdx] = MaskIdx;
3428 return Builder.CreateShuffleVector(SrcVec, ShuffleMask, Name);
3441 Discriminator =
Builder.getSize(0);
3443 llvm::Value *Args[] = {Key, Discriminator};
3444 Bundles.emplace_back(
"ptrauth", Args);
3450 unsigned IntrinsicID) {
3457 if (!Discriminator) {
3462 auto OrigType =
Pointer->getType();
3480 llvm::Intrinsic::ptrauth_sign);
3486 auto StripIntrinsic = CGF.
CGM.
getIntrinsic(llvm::Intrinsic::ptrauth_strip);
3490 auto OrigType =
Pointer->getType();
3507 llvm::Intrinsic::ptrauth_auth);
3511 llvm::Instruction *KeyInstruction, llvm::Value *Backup) {
3513 DI->addInstToCurrentSourceAtom(KeyInstruction, Backup);
3517 llvm::Instruction *KeyInstruction, llvm::Value *Backup, uint64_t Atom) {
3519 DI->addInstToSpecificSourceAtom(KeyInstruction, Backup, Atom);
3523 llvm::Value *Backup) {
3526 DI->addInstToCurrentSourceAtom(KeyInstruction, Backup);
3533 if (
getContext().arePFPFieldsTriviallyCopyable(Field.Field->getParent()))
3537 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 ...
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
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)
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
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.
virtual std::optional< std::pair< unsigned, unsigned > > getVScaleRange(const LangOptions &LangOpts, ArmStreamingKind Mode, llvm::StringMap< bool > *FeatureMap=nullptr) const
Returns target-specific min and max values VScale_Range.
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.