38#include "llvm/ADT/ArrayRef.h"
39#include "llvm/ADT/ScopeExit.h"
40#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
41#include "llvm/IR/DataLayout.h"
42#include "llvm/IR/Dominators.h"
43#include "llvm/IR/FPEnv.h"
44#include "llvm/IR/Instruction.h"
45#include "llvm/IR/IntrinsicInst.h"
46#include "llvm/IR/Intrinsics.h"
47#include "llvm/IR/MDBuilder.h"
48#include "llvm/Support/CRC.h"
49#include "llvm/Support/xxhash.h"
50#include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
51#include "llvm/Transforms/Utils/PromoteMemToReg.h"
65 if (CGOpts.DisableLifetimeMarkers)
69 if (CGOpts.SanitizeAddressUseAfterScope ||
75 return CGOpts.OptimizationLevel != 0;
78CodeGenFunction::CodeGenFunction(
CodeGenModule &cgm,
bool suppressNewContext)
83 DebugInfo(
CGM.getModuleDebugInfo()),
85 ShouldEmitLifetimeMarkers(
87 if (!suppressNewContext)
88 CGM.getCXXABI().getMangleContext().startNewFunction();
97 "missed to deactivate a cleanup");
100 CGM.getOpenMPRuntime().functionFinished(*
this);
107 if (
CGM.getLangOpts().OpenMPIRBuilder &&
CurFn)
108 CGM.getOpenMPRuntime().getOMPBuilder().finalize(
CurFn);
113llvm::fp::ExceptionBehavior
121 llvm_unreachable(
"Unsupported FP Exception Behavior");
126 llvm::FastMathFlags FMF;
127 FMF.setAllowReassoc(FPFeatures.getAllowFPReassociate());
128 FMF.setNoNaNs(FPFeatures.getNoHonorNaNs());
129 FMF.setNoInfs(FPFeatures.getNoHonorInfs());
130 FMF.setNoSignedZeros(FPFeatures.getNoSignedZero());
131 FMF.setAllowReciprocal(FPFeatures.getAllowReciprocal());
132 FMF.setApproxFunc(FPFeatures.getAllowApproxFunc());
146 ConstructorHelper(FPFeatures);
149void CodeGenFunction::CGFPOptionsRAII::ConstructorHelper(
FPOptions FPFeatures) {
150 OldFPFeatures = CGF.CurFPFeatures;
151 CGF.CurFPFeatures = FPFeatures;
153 OldExcept = CGF.Builder.getDefaultConstrainedExcept();
154 OldRounding = CGF.Builder.getDefaultConstrainedRounding();
156 if (OldFPFeatures == FPFeatures)
159 FMFGuard.emplace(CGF.Builder);
162 CGF.Builder.setDefaultConstrainedRounding(NewRoundingBehavior);
163 auto NewExceptionBehavior =
165 CGF.Builder.setDefaultConstrainedExcept(NewExceptionBehavior);
167 CGF.SetFastMathFlags(FPFeatures);
169 assert((CGF.CurFuncDecl ==
nullptr || CGF.Builder.getIsFPConstrained() ||
172 (NewExceptionBehavior == llvm::fp::ebIgnore &&
173 NewRoundingBehavior == llvm::RoundingMode::NearestTiesToEven)) &&
174 "FPConstrained should be enabled on entire function");
176 auto mergeFnAttrValue = [&](StringRef Name,
bool Value) {
178 CGF.CurFn->getFnAttribute(Name).getValueAsBool();
179 auto NewValue = OldValue &
Value;
180 if (OldValue != NewValue)
181 CGF.CurFn->addFnAttr(Name, llvm::toStringRef(NewValue));
183 mergeFnAttrValue(
"no-infs-fp-math", FPFeatures.getNoHonorInfs());
184 mergeFnAttrValue(
"no-nans-fp-math", FPFeatures.getNoHonorNaNs());
185 mergeFnAttrValue(
"no-signed-zeros-fp-math", FPFeatures.getNoSignedZero());
189 CGF.CurFPFeatures = OldFPFeatures;
190 CGF.Builder.setDefaultConstrainedExcept(OldExcept);
191 CGF.Builder.setDefaultConstrainedRounding(OldRounding);
205 nullptr, IsKnownNonNull)
213 return ::makeNaturalAlignAddrLValue(
V,
T,
false,
220 return ::makeNaturalAlignAddrLValue(
V,
T,
true,
226 return ::makeNaturalAlignAddrLValue(
V,
T,
false,
232 return ::makeNaturalAlignAddrLValue(
V,
T,
true,
237 return CGM.getTypes().ConvertTypeForMem(
T);
241 return CGM.getTypes().ConvertType(
T);
245 llvm::Type *LLVMTy) {
246 return CGM.getTypes().convertTypeForLoadStore(ASTTy, LLVMTy);
252 switch (
type->getTypeClass()) {
253#define TYPE(name, parent)
254#define ABSTRACT_TYPE(name, parent)
255#define NON_CANONICAL_TYPE(name, parent) case Type::name:
256#define DEPENDENT_TYPE(name, parent) case Type::name:
257#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(name, parent) case Type::name:
258#include "clang/AST/TypeNodes.inc"
259 llvm_unreachable(
"non-canonical or dependent type in IR-generation");
262 case Type::DeducedTemplateSpecialization:
263 llvm_unreachable(
"undeduced type in IR-generation");
268 case Type::BlockPointer:
269 case Type::LValueReference:
270 case Type::RValueReference:
271 case Type::MemberPointer:
273 case Type::ExtVector:
274 case Type::ConstantMatrix:
275 case Type::FunctionProto:
276 case Type::FunctionNoProto:
278 case Type::ObjCObjectPointer:
281 case Type::HLSLAttributedResource:
282 case Type::HLSLInlineSpirv:
290 case Type::ConstantArray:
291 case Type::IncompleteArray:
292 case Type::VariableArray:
294 case Type::ObjCObject:
295 case Type::ObjCInterface:
296 case Type::ArrayParameter:
304 llvm_unreachable(
"unknown type kind!");
311 llvm::BasicBlock *CurBB =
Builder.GetInsertBlock();
314 assert(!CurBB->getTerminator() &&
"Unexpected terminated block.");
318 if (CurBB->empty() ||
ReturnBlock.getBlock()->use_empty()) {
324 return llvm::DebugLoc();
331 llvm::BranchInst *BI =
332 dyn_cast<llvm::BranchInst>(*
ReturnBlock.getBlock()->user_begin());
333 if (BI && BI->isUnconditional() &&
337 llvm::DebugLoc Loc = BI->getDebugLoc();
338 Builder.SetInsertPoint(BI->getParent());
339 BI->eraseFromParent();
351 return llvm::DebugLoc();
356 if (!BB->use_empty()) {
364 assert(BreakContinueStack.empty() &&
365 "mismatched push/pop in break/continue stack!");
367 "mismatched push/pop of cleanups in EHStack!");
369 "mismatched activate/deactivate of cleanups!");
371 if (
CGM.shouldEmitConvergenceTokens()) {
374 "mismatched push/pop in convergence stack!");
377 bool OnlySimpleReturnStmts = NumSimpleReturnExprs > 0
378 && NumSimpleReturnExprs == NumReturnExprs
393 if (OnlySimpleReturnStmts)
394 DI->EmitLocation(
Builder, LastStopPoint);
396 DI->EmitLocation(
Builder, EndLoc);
404 bool HasOnlyNoopCleanups =
406 bool EmitRetDbgLoc = !HasCleanups || HasOnlyNoopCleanups;
408 std::optional<ApplyDebugLocation> OAL;
413 if (OnlySimpleReturnStmts)
414 DI->EmitLocation(
Builder, EndLoc);
428 if (
CGM.getCodeGenOpts().InstrumentFunctions)
429 CurFn->addFnAttr(
"instrument-function-exit",
"__cyg_profile_func_exit");
430 if (
CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining)
431 CurFn->addFnAttr(
"instrument-function-exit-inlined",
432 "__cyg_profile_func_exit");
441 uint64_t RetKeyInstructionsAtomGroup = Loc ? Loc->getAtomGroup() : 0;
444 RetKeyInstructionsAtomGroup);
448 "did not remove all scopes from cleanup stack!");
452 if (IndirectBranch) {
459 if (!EscapedLocals.empty()) {
463 EscapeArgs.resize(EscapedLocals.size());
464 for (
auto &Pair : EscapedLocals)
465 EscapeArgs[Pair.second] = Pair.first;
466 llvm::Function *FrameEscapeFn = llvm::Intrinsic::getOrInsertDeclaration(
467 &
CGM.getModule(), llvm::Intrinsic::localescape);
474 Ptr->eraseFromParent();
478 if (PostAllocaInsertPt) {
479 llvm::Instruction *PostPtr = PostAllocaInsertPt;
480 PostAllocaInsertPt =
nullptr;
481 PostPtr->eraseFromParent();
486 if (IndirectBranch) {
488 if (PN->getNumIncomingValues() == 0) {
489 PN->replaceAllUsesWith(llvm::PoisonValue::get(PN->getType()));
490 PN->eraseFromParent();
499 for (
const auto &FuncletAndParent : TerminateFunclets)
502 if (
CGM.getCodeGenOpts().EmitDeclMetadata)
505 for (
const auto &R : DeferredReplacements) {
506 if (llvm::Value *Old = R.first) {
507 Old->replaceAllUsesWith(R.second);
511 DeferredReplacements.clear();
520 llvm::DominatorTree DT(*
CurFn);
521 llvm::PromoteMemToReg(
527 for (llvm::Argument &A :
CurFn->args())
528 if (
auto *VT = dyn_cast<llvm::VectorType>(A.getType()))
530 std::max((uint64_t)LargestVectorWidth,
531 VT->getPrimitiveSizeInBits().getKnownMinValue());
534 if (
auto *VT = dyn_cast<llvm::VectorType>(
CurFn->getReturnType()))
536 std::max((uint64_t)LargestVectorWidth,
537 VT->getPrimitiveSizeInBits().getKnownMinValue());
539 if (
CurFnInfo->getMaxVectorWidth() > LargestVectorWidth)
540 LargestVectorWidth =
CurFnInfo->getMaxVectorWidth();
549 if (
getContext().getTargetInfo().getTriple().isX86())
550 CurFn->addFnAttr(
"min-legal-vector-width",
551 llvm::utostr(LargestVectorWidth));
560 dyn_cast<llvm::AllocaInst>(
ReturnValue.emitRawPointer(*
this));
561 if (RetAlloca && RetAlloca->use_empty()) {
562 RetAlloca->eraseFromParent();
571 if (!
CGM.getCodeGenOpts().InstrumentFunctions &&
572 !
CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining &&
573 !
CGM.getCodeGenOpts().InstrumentFunctionEntryBare)
583 return CurFuncDecl->hasAttr<DisableSanitizerInstrumentationAttr>();
589 return CGM.getCodeGenOpts().XRayInstrumentFunctions;
595 return CGM.getCodeGenOpts().XRayInstrumentFunctions &&
596 (
CGM.getCodeGenOpts().XRayAlwaysEmitCustomEvents ||
597 CGM.getCodeGenOpts().XRayInstrumentationBundle.Mask ==
602 return CGM.getCodeGenOpts().XRayInstrumentFunctions &&
603 (
CGM.getCodeGenOpts().XRayAlwaysEmitTypedEvents ||
604 CGM.getCodeGenOpts().XRayInstrumentationBundle.Mask ==
615 llvm::raw_string_ostream Out(Mangled);
616 CGM.getCXXABI().getMangleContext().mangleCanonicalTypeName(Ty, Out,
false);
617 return llvm::ConstantInt::get(
618 CGM.Int32Ty,
static_cast<uint32_t
>(llvm::xxh3_64bits(Mangled)));
621void CodeGenFunction::EmitKernelMetadata(
const FunctionDecl *FD,
622 llvm::Function *Fn) {
623 if (!FD->
hasAttr<DeviceKernelAttr>() && !FD->
hasAttr<CUDAGlobalAttr>())
632 getContext().getTargetInfo().getTriple().isSPIRV())))
635 if (
const VecTypeHintAttr *A = FD->
getAttr<VecTypeHintAttr>()) {
636 QualType HintQTy = A->getTypeHint();
638 bool IsSignedInteger =
640 (HintEltQTy && HintEltQTy->
getElementType()->isSignedIntegerType());
641 llvm::Metadata *AttrMDArgs[] = {
642 llvm::ConstantAsMetadata::get(llvm::PoisonValue::get(
644 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
645 llvm::IntegerType::get(Context, 32),
646 llvm::APInt(32, (uint64_t)(IsSignedInteger ? 1 : 0))))};
647 Fn->setMetadata(
"vec_type_hint", llvm::MDNode::get(Context, AttrMDArgs));
650 if (
const WorkGroupSizeHintAttr *A = FD->
getAttr<WorkGroupSizeHintAttr>()) {
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(
"work_group_size_hint", llvm::MDNode::get(Context, AttrMDArgs));
661 if (
const ReqdWorkGroupSizeAttr *A = FD->
getAttr<ReqdWorkGroupSizeAttr>()) {
662 auto Eval = [&](Expr *E) {
663 return E->EvaluateKnownConstInt(FD->
getASTContext()).getExtValue();
665 llvm::Metadata *AttrMDArgs[] = {
666 llvm::ConstantAsMetadata::get(
Builder.getInt32(Eval(A->getXDim()))),
667 llvm::ConstantAsMetadata::get(
Builder.getInt32(Eval(A->getYDim()))),
668 llvm::ConstantAsMetadata::get(
Builder.getInt32(Eval(A->getZDim())))};
669 Fn->setMetadata(
"reqd_work_group_size", llvm::MDNode::get(Context, AttrMDArgs));
672 if (
const OpenCLIntelReqdSubGroupSizeAttr *A =
673 FD->
getAttr<OpenCLIntelReqdSubGroupSizeAttr>()) {
674 llvm::Metadata *AttrMDArgs[] = {
675 llvm::ConstantAsMetadata::get(
Builder.getInt32(A->getSubGroupSize()))};
676 Fn->setMetadata(
"intel_reqd_sub_group_size",
677 llvm::MDNode::get(Context, AttrMDArgs));
683 const Stmt *Body =
nullptr;
684 if (
auto *FD = dyn_cast_or_null<FunctionDecl>(F))
686 else if (
auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(F))
687 Body = OMD->getBody();
689 if (
auto *CS = dyn_cast_or_null<CompoundStmt>(Body)) {
690 auto LastStmt = CS->body_rbegin();
691 if (LastStmt != CS->body_rend())
698 if (
SanOpts.has(SanitizerKind::Thread)) {
699 Fn->addFnAttr(
"sanitize_thread_no_checking_at_run_time");
700 Fn->removeFnAttr(llvm::Attribute::SanitizeThread);
705bool CodeGenFunction::requiresReturnValueCheck()
const {
706 return requiresReturnValueNullabilityCheck() ||
712 auto *MD = dyn_cast_or_null<CXXMethodDecl>(D);
713 if (!MD || !MD->getDeclName().getAsIdentifierInfo() ||
714 !MD->getDeclName().getAsIdentifierInfo()->isStr(
"allocate") ||
715 (MD->getNumParams() != 1 && MD->getNumParams() != 2))
721 if (MD->getNumParams() == 2) {
722 auto *PT = MD->parameters()[1]->getType()->getAs<
PointerType>();
723 if (!PT || !PT->isVoidPointerType() ||
724 !PT->getPointeeType().isConstQualified())
731bool CodeGenFunction::isInAllocaArgument(
CGCXXABI &ABI, QualType Ty) {
736bool CodeGenFunction::hasInAllocaArg(
const CXXMethodDecl *MD) {
739 llvm::any_of(MD->
parameters(), [&](ParmVarDecl *P) {
740 return isInAllocaArgument(CGM.getCXXABI(), P->getType());
747 if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD))
760 "Do not use a CodeGenFunction object for more than one function");
764 DidCallStackSave =
false;
766 const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
773 assert(
CurFn->isDeclaration() &&
"Function already has body?");
778#define SANITIZER(NAME, ID) \
779 if (SanOpts.empty()) \
781 if (SanOpts.has(SanitizerKind::ID)) \
782 if (CGM.isInNoSanitizeList(SanitizerKind::ID, Fn, Loc)) \
783 SanOpts.set(SanitizerKind::ID, false);
785#include "clang/Basic/Sanitizers.def"
790 const bool SanitizeBounds =
SanOpts.hasOneOf(SanitizerKind::Bounds);
792 bool NoSanitizeCoverage =
false;
795 no_sanitize_mask |=
Attr->getMask();
797 if (
Attr->hasCoverage())
798 NoSanitizeCoverage =
true;
802 SanOpts.Mask &= ~no_sanitize_mask;
803 if (no_sanitize_mask & SanitizerKind::Address)
804 SanOpts.set(SanitizerKind::KernelAddress,
false);
805 if (no_sanitize_mask & SanitizerKind::KernelAddress)
806 SanOpts.set(SanitizerKind::Address,
false);
807 if (no_sanitize_mask & SanitizerKind::HWAddress)
808 SanOpts.set(SanitizerKind::KernelHWAddress,
false);
809 if (no_sanitize_mask & SanitizerKind::KernelHWAddress)
810 SanOpts.set(SanitizerKind::HWAddress,
false);
812 if (SanitizeBounds && !
SanOpts.hasOneOf(SanitizerKind::Bounds))
813 Fn->addFnAttr(llvm::Attribute::NoSanitizeBounds);
815 if (NoSanitizeCoverage &&
CGM.getCodeGenOpts().hasSanitizeCoverage())
816 Fn->addFnAttr(llvm::Attribute::NoSanitizeCoverage);
819 if (
CGM.getCodeGenOpts().hasSanitizeBinaryMetadata()) {
820 if (no_sanitize_mask & SanitizerKind::Thread)
821 Fn->addFnAttr(
"no_sanitize_thread");
826 CurFn->addFnAttr(llvm::Attribute::DisableSanitizerInstrumentation);
829 if (
SanOpts.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress))
830 Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
831 if (
SanOpts.hasOneOf(SanitizerKind::HWAddress |
832 SanitizerKind::KernelHWAddress))
833 Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
834 if (
SanOpts.has(SanitizerKind::MemtagStack))
835 Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);
836 if (
SanOpts.has(SanitizerKind::Thread))
837 Fn->addFnAttr(llvm::Attribute::SanitizeThread);
838 if (
SanOpts.has(SanitizerKind::Type))
839 Fn->addFnAttr(llvm::Attribute::SanitizeType);
840 if (
SanOpts.has(SanitizerKind::NumericalStability))
841 Fn->addFnAttr(llvm::Attribute::SanitizeNumericalStability);
842 if (
SanOpts.hasOneOf(SanitizerKind::Memory | SanitizerKind::KernelMemory))
843 Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
844 if (
SanOpts.has(SanitizerKind::AllocToken))
845 Fn->addFnAttr(llvm::Attribute::SanitizeAllocToken);
847 if (
SanOpts.has(SanitizerKind::SafeStack))
848 Fn->addFnAttr(llvm::Attribute::SafeStack);
849 if (
SanOpts.has(SanitizerKind::ShadowCallStack))
850 Fn->addFnAttr(llvm::Attribute::ShadowCallStack);
852 if (
SanOpts.has(SanitizerKind::Realtime))
856 Fn->addFnAttr(llvm::Attribute::SanitizeRealtime);
858 Fn->addFnAttr(llvm::Attribute::SanitizeRealtimeBlocking);
862 if (
SanOpts.hasOneOf(SanitizerKind::Fuzzer | SanitizerKind::FuzzerNoLink))
863 Fn->addFnAttr(llvm::Attribute::OptForFuzzing);
867 if (
SanOpts.has(SanitizerKind::Thread)) {
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 &&
981 getContext().getTargetInfo().getTriple().isX86() &&
982 getContext().getTargetInfo().getTriple().getEnvironment() !=
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);
1026 getContext().getTargetInfo().getTriple().isSPIRV()) ||
1030 EmitKernelMetadata(FD, Fn);
1033 if (FD && FD->
hasAttr<ClspvLibclcBuiltinAttr>()) {
1034 Fn->setMetadata(
"clspv_libclc_builtin",
1040 if (FD &&
SanOpts.has(SanitizerKind::Function)) {
1042 llvm::LLVMContext &Ctx = Fn->getContext();
1043 llvm::MDBuilder MDB(Ctx);
1045 llvm::LLVMContext::MD_func_sanitize,
1046 MDB.createRTTIPointerPrologue(
1053 if (
SanOpts.has(SanitizerKind::NullabilityReturn)) {
1054 auto Nullability =
FnRetTy->getNullability();
1057 if (!(
SanOpts.has(SanitizerKind::ReturnsNonnullAttribute) &&
1059 RetValNullabilityPrecondition =
1082 Fn->addFnAttr(llvm::Attribute::NoRecurse);
1085 llvm::fp::ExceptionBehavior FPExceptionBehavior =
1087 Builder.setDefaultConstrainedRounding(RM);
1088 Builder.setDefaultConstrainedExcept(FPExceptionBehavior);
1090 (!FD && (FPExceptionBehavior != llvm::fp::ebIgnore ||
1091 RM != llvm::RoundingMode::NearestTiesToEven))) {
1092 Builder.setIsFPConstrained(
true);
1093 Fn->addFnAttr(llvm::Attribute::StrictFP);
1099 CGM.getCodeGenOpts().StackAlignment))
1100 Fn->addFnAttr(
"stackrealign");
1104 Fn->removeFnAttr(
"zero-call-used-regs");
1107 llvm::StringMap<bool> FeatureMap;
1112 if (
T->getAArch64SMEAttributes() &
1119 std::optional<std::pair<unsigned, unsigned>> VScaleRange =
1123 CurFn->addFnAttr(llvm::Attribute::getWithVScaleRangeArgs(
1132 llvm::Value *Poison = llvm::PoisonValue::get(
Int32Ty);
1137 Builder.SetInsertPoint(EntryBB);
1141 if (requiresReturnValueCheck()) {
1152 DI->emitFunctionStart(GD, Loc, StartLoc,
1153 DI->getFunctionType(FD, RetTy, Args),
CurFn,
1158 if (
CGM.getCodeGenOpts().InstrumentFunctions)
1159 CurFn->addFnAttr(
"instrument-function-entry",
"__cyg_profile_func_enter");
1160 if (
CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining)
1161 CurFn->addFnAttr(
"instrument-function-entry-inlined",
1162 "__cyg_profile_func_enter");
1163 if (
CGM.getCodeGenOpts().InstrumentFunctionEntryBare)
1164 CurFn->addFnAttr(
"instrument-function-entry-inlined",
1165 "__cyg_profile_func_enter_bare");
1172 if (
CGM.getCodeGenOpts().InstrumentForProfiling) {
1176 if (
CGM.getCodeGenOpts().CallFEntry)
1177 Fn->addFnAttr(
"fentry-call",
"true");
1179 Fn->addFnAttr(
"instrument-function-entry-inlined",
1182 if (
CGM.getCodeGenOpts().MNopMCount) {
1183 if (!
CGM.getCodeGenOpts().CallFEntry)
1184 CGM.getDiags().Report(diag::err_opt_not_valid_without_opt)
1185 <<
"-mnop-mcount" <<
"-mfentry";
1186 Fn->addFnAttr(
"mnop-mcount");
1189 if (
CGM.getCodeGenOpts().RecordMCount) {
1190 if (!
CGM.getCodeGenOpts().CallFEntry)
1191 CGM.getDiags().Report(diag::err_opt_not_valid_without_opt)
1192 <<
"-mrecord-mcount" <<
"-mfentry";
1193 Fn->addFnAttr(
"mrecord-mcount");
1198 if (
CGM.getCodeGenOpts().PackedStack) {
1199 if (
getContext().getTargetInfo().getTriple().getArch() !=
1200 llvm::Triple::systemz)
1201 CGM.getDiags().Report(diag::err_opt_not_valid_on_target)
1202 <<
"-mpacked-stack";
1203 Fn->addFnAttr(
"packed-stack");
1206 if (
CGM.getCodeGenOpts().WarnStackSize !=
UINT_MAX &&
1207 !
CGM.getDiags().isIgnored(diag::warn_fe_backend_frame_larger_than, Loc))
1208 Fn->addFnAttr(
"warn-stack-size",
1209 std::to_string(
CGM.getCodeGenOpts().WarnStackSize));
1221 auto AI =
CurFn->arg_begin();
1222 if (
CurFnInfo->getReturnInfo().isSRetAfterThis())
1225 &*AI, RetTy,
CurFnInfo->getReturnInfo().getIndirectAlign(),
false,
1227 if (!
CurFnInfo->getReturnInfo().getIndirectByVal()) {
1236 unsigned Idx =
CurFnInfo->getReturnInfo().getInAllocaFieldIndex();
1237 llvm::Function::arg_iterator EI =
CurFn->arg_end();
1269 if (FD->
hasAttr<HLSLShaderAttr>()) {
1270 CGM.getHLSLRuntime().emitEntryFunction(FD, Fn);
1276 if (
const CXXMethodDecl *MD = dyn_cast_if_present<CXXMethodDecl>(D);
1281 CGM.getCXXABI().EmitInstanceFunctionProlog(*
this);
1297 CXXThisValue = ThisFieldLValue.
getPointer(*
this);
1306 if (FD->hasCapturedVLAType()) {
1309 auto VAT = FD->getCapturedVLAType();
1310 VLASizeMap[VAT->getSizeExpr()] = ExprArg;
1317 CXXThisValue = CXXABIThisValue;
1321 if (CXXABIThisValue) {
1323 SkippedChecks.
set(SanitizerKind::ObjectSize,
true);
1330 SkippedChecks.
set(SanitizerKind::Null,
true);
1334 Loc, CXXABIThisValue, ThisTy, CXXABIThisAlignment, SkippedChecks);
1341 if (!FD || !FD->
hasAttr<NakedAttr>()) {
1342 for (
const VarDecl *VD : Args) {
1347 if (
const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD))
1348 Ty = PVD->getOriginalType();
1358 DI->EmitLocation(
Builder, StartLoc);
1362 if (
const auto *VecWidth =
CurFuncDecl->getAttr<MinVectorWidthAttr>())
1363 LargestVectorWidth = VecWidth->getVectorWidth();
1365 if (
CGM.shouldEmitConvergenceTokens())
1372 if (
const CompoundStmt *S = dyn_cast<CompoundStmt>(Body))
1384 llvm::BasicBlock *SkipCountBB =
nullptr;
1409 if (F->isInterposable())
return;
1411 for (llvm::BasicBlock &BB : *F)
1412 for (llvm::Instruction &I : BB)
1416 F->setDoesNotThrow();
1426 if (
CGM.getCXXABI().HasThisReturn(GD))
1428 else if (
CGM.getCXXABI().hasMostDerivedReturn(GD))
1429 ResTy =
CGM.getContext().VoidPtrTy;
1430 CGM.getCXXABI().buildThisParam(*
this, Args);
1436 bool PassedParams =
true;
1438 if (
auto Inherited = CD->getInheritedConstructor())
1444 Args.push_back(Param);
1445 if (!Param->hasAttr<PassObjectSizeAttr>())
1449 getContext(), Param->getDeclContext(), Param->getLocation(),
1457 CGM.getCXXABI().addImplicitStructorParams(*
this, ResTy, Args);
1464 assert(Fn &&
"generating code for null Function");
1471 CGM.getTargetCodeGenInfo().checkFunctionABI(
CGM, FD);
1477 std::string FDInlineName = (Fn->getName() +
".inline").str();
1478 llvm::Module *M = Fn->getParent();
1479 llvm::Function *Clone = M->getFunction(FDInlineName);
1481 Clone = llvm::Function::Create(Fn->getFunctionType(),
1482 llvm::GlobalValue::InternalLinkage,
1483 Fn->getAddressSpace(), FDInlineName, M);
1484 Clone->addFnAttr(llvm::Attribute::AlwaysInline);
1486 Fn->setLinkage(llvm::GlobalValue::ExternalLinkage);
1496 if (LLVM_UNLIKELY(PD->isInlineBuiltinDeclaration())) {
1497 std::string FDInlineName = (Fn->getName() +
".inline").str();
1498 llvm::Module *M = Fn->getParent();
1499 if (llvm::Function *Clone = M->getFunction(FDInlineName)) {
1500 Clone->replaceAllUsesWith(Fn);
1501 Clone->eraseFromParent();
1509 if (FD->
hasAttr<NoDebugAttr>()) {
1512 Fn->setSubprogram(
nullptr);
1514 DebugInfo =
nullptr;
1517 auto Cleanup = llvm::make_scope_exit([
this] {
1519 DI->completeFunction();
1526 BodyRange = Body->getSourceRange();
1529 CurEHLocation = BodyRange.getEnd();
1541 if (SpecDecl->hasBody(SpecDecl))
1542 Loc = SpecDecl->getLocation();
1549 ShouldEmitLifetimeMarkers =
true;
1553 if (ShouldEmitLifetimeMarkers)
1558 StartFunction(GD, ResTy, Fn, FnInfo, Args, Loc, BodyRange.getBegin());
1561 if (Body && isa_and_nonnull<CoroutineBodyStmt>(Body))
1569 CurFn->addFnAttr(llvm::Attribute::MustProgress);
1572 PGO->assignRegionCounters(GD,
CurFn);
1579 FD->
hasAttr<CUDAGlobalAttr>())
1580 CGM.getCUDARuntime().emitDeviceStub(*
this, Args);
1603 }
else if (DeviceKernelAttr::isOpenCLSpelling(
1604 FD->
getAttr<DeviceKernelAttr>()) &&
1607 for (
unsigned i = 0; i < Args.size(); ++i) {
1609 QualType ArgQualType = Args[i]->getType();
1611 CallArgs.
add(ArgRValue, ArgQualType);
1615 CGM.getTargetCodeGenInfo().setOCLKernelStubCallingConvention(FT);
1617 CallArgs, FT,
false);
1618 llvm::FunctionType *FTy =
CGM.getTypes().GetFunctionType(FnInfo);
1619 llvm::Constant *GDStubFunctionPointer =
1620 CGM.getRawFunctionPointer(GDStub, FTy);
1627 llvm_unreachable(
"no definition for emitted function");
1637 bool ShouldEmitUnreachable =
1638 CGM.getCodeGenOpts().StrictReturn ||
1640 if (
SanOpts.has(SanitizerKind::Return)) {
1641 auto CheckOrdinal = SanitizerKind::SO_Return;
1642 auto CheckHandler = SanitizerHandler::MissingReturn;
1644 llvm::Value *IsFalse =
Builder.getFalse();
1645 EmitCheck(std::make_pair(IsFalse, CheckOrdinal), CheckHandler,
1647 }
else if (ShouldEmitUnreachable) {
1648 if (
CGM.getCodeGenOpts().OptimizationLevel == 0)
1651 if (
SanOpts.has(SanitizerKind::Return) || ShouldEmitUnreachable) {
1653 Builder.ClearInsertionPoint();
1660 PGO->verifyCounterMap();
1664 if (!
CurFn->doesNotThrow())
1673 if (!S)
return false;
1690 IgnoreCaseStmts =
true;
1705 if (!S)
return false;
1725 if (!S)
return false;
1756 if (!AllowLabels &&
CGM.getCodeGenOpts().hasProfileClangInstr() &&
1757 CGM.getCodeGenOpts().MCDCCoverage)
1760 llvm::APSInt ResultInt;
1764 ResultBool = ResultInt.getBoolValue();
1772 llvm::APSInt &ResultInt,
1780 llvm::APSInt Int =
Result.Val.getInt();
1784 PGO->markStmtMaybeUsed(
Cond);
1791 while (
const UnaryOperator *Op = dyn_cast<UnaryOperator>(
C->IgnoreParens())) {
1792 if (Op->getOpcode() != UO_LNot)
1794 C = Op->getSubExpr();
1796 return C->IgnoreParens();
1812 llvm::BasicBlock *FalseBlock, uint64_t TrueCount ,
1815 bool InstrumentRegions =
CGM.getCodeGenOpts().hasProfileClangInstr();
1819 const Stmt *CntrStmt = (CntrIdx ? CntrIdx :
Cond);
1821 llvm::BasicBlock *ThenBlock =
nullptr;
1822 llvm::BasicBlock *ElseBlock =
nullptr;
1823 llvm::BasicBlock *NextBlock =
nullptr;
1840 if (LOp == BO_LAnd) {
1841 ThenBlock = CounterIncrBlock;
1842 ElseBlock = FalseBlock;
1843 NextBlock = TrueBlock;
1858 else if (LOp == BO_LOr) {
1859 ThenBlock = TrueBlock;
1860 ElseBlock = CounterIncrBlock;
1861 NextBlock = FalseBlock;
1863 llvm_unreachable(
"Expected Opcode must be that of a Logical Operator");
1887 const Expr *
Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock,
1889 const VarDecl *ConditionalDecl) {
1894 if (CondBOp->getOpcode() == BO_LAnd) {
1899 bool ConstantBool =
false;
1905 FalseBlock, TrueCount, LH);
1916 FalseBlock, TrueCount, LH, CondBOp);
1945 FalseBlock, TrueCount, LH);
1951 if (CondBOp->getOpcode() == BO_LOr) {
1956 bool ConstantBool =
false;
1962 FalseBlock, TrueCount, LH);
1973 FalseBlock, TrueCount, LH, CondBOp);
1985 uint64_t RHSCount = TrueCount - LHSCount;
2017 bool MCDCCondition =
CGM.getCodeGenOpts().hasProfileClangInstr() &&
2018 CGM.getCodeGenOpts().MCDCCoverage &&
2020 if (CondUOp->getOpcode() == UO_LNot && !MCDCCondition) {
2047 uint64_t LHSScaledTrueCount = 0;
2051 LHSScaledTrueCount = TrueCount * LHSRatio;
2060 LHSScaledTrueCount, LH, CondOp);
2067 TrueCount - LHSScaledTrueCount, LH, CondOp);
2102 MCDCBaseExpr = ConditionalOp;
2107 llvm::MDNode *Weights =
nullptr;
2108 llvm::MDNode *Unpredictable =
nullptr;
2113 auto *
Call = dyn_cast<CallExpr>(
Cond->IgnoreImpCasts());
2114 if (
Call &&
CGM.getCodeGenOpts().OptimizationLevel != 0) {
2115 auto *FD = dyn_cast_or_null<FunctionDecl>(
Call->getCalleeDecl());
2116 if (FD && FD->
getBuiltinID() == Builtin::BI__builtin_unpredictable) {
2118 Unpredictable = MDHelper.createUnpredictable();
2124 llvm::Value *NewCondV = emitCondLikelihoodViaExpectIntrinsic(CondV, LH);
2125 if (CondV != NewCondV)
2130 Weights = createProfileWeights(TrueCount, CurrentCount - TrueCount);
2133 llvm::Instruction *BrInst =
Builder.CreateCondBr(CondV, TrueBlock, FalseBlock,
2134 Weights, Unpredictable);
2138 case HLSLControlFlowHintAttr::Microsoft_branch:
2139 case HLSLControlFlowHintAttr::Microsoft_flatten: {
2140 llvm::MDBuilder MDHelper(
CGM.getLLVMContext());
2142 llvm::ConstantInt *BranchHintConstant =
2144 HLSLControlFlowHintAttr::Spelling::Microsoft_branch
2145 ? llvm::ConstantInt::get(
CGM.Int32Ty, 1)
2146 : llvm::ConstantInt::get(
CGM.Int32Ty, 2);
2149 {MDHelper.createString(
"hlsl.controlflow.hint"),
2150 MDHelper.createConstant(BranchHintConstant)});
2151 BrInst->setMetadata(
"hlsl.controlflow.hint",
2152 llvm::MDNode::get(
CGM.getLLVMContext(), Vals));
2156 case HLSLControlFlowHintAttr::SpellingNotCalculated:
2164 CGM.ErrorUnsupported(S,
Type);
2176 llvm::Value *sizeInChars) {
2180 llvm::Value *baseSizeInChars
2184 llvm::Value *end = Builder.CreateInBoundsGEP(begin.
getElementType(),
2186 sizeInChars,
"vla.end");
2188 llvm::BasicBlock *originBB = CGF.
Builder.GetInsertBlock();
2196 llvm::PHINode *cur = Builder.CreatePHI(begin.
getType(), 2,
"vla.cur");
2203 Builder.CreateMemCpy(
Address(cur, CGF.
Int8Ty, curAlign), src, baseSizeInChars,
2208 Builder.CreateInBoundsGEP(CGF.
Int8Ty, cur, baseSizeInChars,
"vla.next");
2211 llvm::Value *done = Builder.CreateICmpEQ(next, end,
"vla-init.isdone");
2212 Builder.CreateCondBr(done, contBB, loopBB);
2213 cur->addIncoming(next, loopBB);
2231 llvm::Value *SizeVal;
2238 dyn_cast_or_null<VariableArrayType>(
2241 SizeVal = VlaSize.NumElts;
2243 if (!eltSize.
isOne())
2244 SizeVal =
Builder.CreateNUWMul(SizeVal,
CGM.getSize(eltSize));
2250 SizeVal =
CGM.getSize(size);
2258 if (!
CGM.getTypes().isZeroInitializable(Ty)) {
2262 llvm::Constant *NullConstant =
CGM.EmitNullConstant(Ty);
2264 llvm::GlobalVariable *NullVariable =
2265 new llvm::GlobalVariable(
CGM.getModule(), NullConstant->getType(),
2267 llvm::GlobalVariable::PrivateLinkage,
2268 NullConstant, Twine());
2270 NullVariable->setAlignment(NullAlign.
getAsAlign());
2276 Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal,
false);
2283 Builder.CreateMemSet(DestPtr,
Builder.getInt8(0), SizeVal,
false);
2288 if (!IndirectBranch)
2294 IndirectBranch->addDestination(BB);
2295 return llvm::BlockAddress::get(
CurFn->getType(), BB);
2300 if (IndirectBranch)
return IndirectBranch->getParent();
2305 llvm::Value *DestVal = TmpBuilder.CreatePHI(
Int8PtrTy, 0,
2306 "indirect.goto.dest");
2309 IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal);
2310 return IndirectBranch->getParent();
2322 llvm::Value *numVLAElements =
nullptr;
2334 baseType = elementType;
2335 return numVLAElements;
2349 llvm::ConstantInt *zero =
Builder.getInt32(0);
2350 gepIndices.push_back(zero);
2352 uint64_t countFromCLAs = 1;
2355 llvm::ArrayType *llvmArrayType =
2357 while (llvmArrayType) {
2360 llvmArrayType->getNumElements());
2362 gepIndices.push_back(zero);
2363 countFromCLAs *= llvmArrayType->getNumElements();
2367 dyn_cast<llvm::ArrayType>(llvmArrayType->getElementType());
2370 "LLVM and Clang types are out-of-synch");
2389 gepIndices,
"array.begin"),
2395 llvm::Value *numElements
2396 = llvm::ConstantInt::get(
SizeTy, countFromCLAs);
2400 numElements =
Builder.CreateNUWMul(numVLAElements, numElements);
2407 assert(vla &&
"type was not a variable array type!");
2414 llvm::Value *numElements =
nullptr;
2418 elementType =
type->getElementType();
2419 llvm::Value *vlaSize = VLASizeMap[
type->getSizeExpr()];
2420 assert(vlaSize &&
"no size for VLA!");
2421 assert(vlaSize->getType() ==
SizeTy);
2424 numElements = vlaSize;
2428 numElements =
Builder.CreateNUWMul(numElements, vlaSize);
2430 }
while ((
type =
getContext().getAsVariableArrayType(elementType)));
2432 return { numElements, elementType };
2438 assert(vla &&
"type was not a variable array type!");
2444 llvm::Value *VlaSize = VLASizeMap[Vla->
getSizeExpr()];
2445 assert(VlaSize &&
"no size for VLA!");
2446 assert(VlaSize->getType() ==
SizeTy);
2451 assert(
type->isVariablyModifiedType() &&
2452 "Must pass variably modified type to EmitVLASizes!");
2459 assert(
type->isVariablyModifiedType());
2461 const Type *ty =
type.getTypePtr();
2464#define TYPE(Class, Base)
2465#define ABSTRACT_TYPE(Class, Base)
2466#define NON_CANONICAL_TYPE(Class, Base)
2467#define DEPENDENT_TYPE(Class, Base) case Type::Class:
2468#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
2469#include "clang/AST/TypeNodes.inc"
2470 llvm_unreachable(
"unexpected dependent type!");
2476 case Type::ExtVector:
2477 case Type::ConstantMatrix:
2481 case Type::TemplateSpecialization:
2482 case Type::ObjCTypeParam:
2483 case Type::ObjCObject:
2484 case Type::ObjCInterface:
2485 case Type::ObjCObjectPointer:
2487 case Type::HLSLInlineSpirv:
2488 case Type::PredefinedSugar:
2489 llvm_unreachable(
"type class is never variably-modified!");
2491 case Type::Adjusted:
2503 case Type::BlockPointer:
2507 case Type::LValueReference:
2508 case Type::RValueReference:
2512 case Type::MemberPointer:
2516 case Type::ArrayParameter:
2517 case Type::ConstantArray:
2518 case Type::IncompleteArray:
2523 case Type::VariableArray: {
2532 llvm::Value *&entry = VLASizeMap[sizeExpr];
2540 if (
SanOpts.has(SanitizerKind::VLABound)) {
2541 auto CheckOrdinal = SanitizerKind::SO_VLABound;
2542 auto CheckHandler = SanitizerHandler::VLABoundNotPositive;
2544 llvm::Value *
Zero = llvm::Constant::getNullValue(size->getType());
2546 llvm::Value *CheckCondition =
2550 llvm::Constant *StaticArgs[] = {
2553 EmitCheck(std::make_pair(CheckCondition, CheckOrdinal),
2554 CheckHandler, StaticArgs, size);
2567 case Type::FunctionProto:
2568 case Type::FunctionNoProto:
2574 case Type::UnaryTransform:
2575 case Type::Attributed:
2576 case Type::BTFTagAttributed:
2577 case Type::HLSLAttributedResource:
2578 case Type::SubstTemplateTypeParm:
2579 case Type::MacroQualified:
2580 case Type::CountAttributed:
2586 case Type::Decltype:
2588 case Type::DeducedTemplateSpecialization:
2589 case Type::PackIndexing:
2593 case Type::TypeOfExpr:
2606 }
while (
type->isVariablyModifiedType());
2610 if (
getContext().getBuiltinVaListType()->isArrayType())
2621 assert(
Init.hasValue() &&
"Invalid DeclRefExpr initializer!");
2623 if (
CGM.getCodeGenOpts().hasReducedDebugInfo())
2639 llvm::Instruction *inst =
new llvm::BitCastInst(value, value->getType(),
"",
2643 protection.Inst = inst;
2648 if (!protection.Inst)
return;
2651 protection.Inst->eraseFromParent();
2657 llvm::Value *Alignment,
2658 llvm::Value *OffsetValue) {
2659 if (Alignment->getType() !=
IntPtrTy)
2662 if (OffsetValue && OffsetValue->getType() !=
IntPtrTy)
2665 llvm::Value *TheCheck =
nullptr;
2666 if (
SanOpts.has(SanitizerKind::Alignment)) {
2667 llvm::Value *PtrIntValue =
2671 bool IsOffsetZero =
false;
2672 if (
const auto *CI = dyn_cast<llvm::ConstantInt>(OffsetValue))
2673 IsOffsetZero = CI->isZero();
2676 PtrIntValue =
Builder.CreateSub(PtrIntValue, OffsetValue,
"offsetptr");
2679 llvm::Value *
Zero = llvm::ConstantInt::get(
IntPtrTy, 0);
2682 llvm::Value *MaskedPtr =
Builder.CreateAnd(PtrIntValue, Mask,
"maskedptr");
2683 TheCheck =
Builder.CreateICmpEQ(MaskedPtr,
Zero,
"maskcond");
2685 llvm::Instruction *Assumption =
Builder.CreateAlignmentAssumption(
2686 CGM.getDataLayout(), PtrValue, Alignment, OffsetValue);
2688 if (!
SanOpts.has(SanitizerKind::Alignment))
2691 OffsetValue, TheCheck, Assumption);
2697 llvm::Value *Alignment,
2698 llvm::Value *OffsetValue) {
2707 llvm::Value *AnnotatedVal,
2708 StringRef AnnotationStr,
2710 const AnnotateAttr *
Attr) {
2713 CGM.EmitAnnotationString(AnnotationStr),
2714 CGM.EmitAnnotationUnit(Location),
2715 CGM.EmitAnnotationLineNo(Location),
2718 Args.push_back(
CGM.EmitAnnotationArgs(
Attr));
2719 return Builder.CreateCall(AnnotationFn, Args);
2723 assert(D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
2726 {V->getType(), CGM.ConstGlobalsPtrTy}),
2732 assert(D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
2733 llvm::Value *
V =
Addr.emitRawPointer(*
this);
2734 llvm::Type *VTy =
V->getType();
2735 auto *PTy = dyn_cast<llvm::PointerType>(VTy);
2736 unsigned AS = PTy ? PTy->getAddressSpace() : 0;
2737 llvm::PointerType *IntrinTy =
2738 llvm::PointerType::get(
CGM.getLLVMContext(), AS);
2739 llvm::Function *F =
CGM.getIntrinsic(llvm::Intrinsic::ptr_annotation,
2740 {IntrinTy,
CGM.ConstGlobalsPtrTy});
2746 if (VTy != IntrinTy)
2759 assert(!CGF->IsSanitizerScope);
2760 CGF->IsSanitizerScope =
true;
2764 CGF->IsSanitizerScope =
false;
2768 const llvm::Twine &Name,
2769 llvm::BasicBlock::iterator InsertPt)
const {
2772 I->setNoSanitizeMetadata();
2776 llvm::Instruction *I,
const llvm::Twine &Name,
2777 llvm::BasicBlock::iterator InsertPt)
const {
2778 llvm::IRBuilderDefaultInserter::InsertHelper(I, Name, InsertPt);
2780 CGF->InsertHelper(I, Name, InsertPt);
2789 if (
CGM.getContext().getTargetInfo().getTriple().isX86()) {
2791 if (BuiltinID == X86::BI__builtin_ia32_cmpps ||
2792 BuiltinID == X86::BI__builtin_ia32_cmpss ||
2793 BuiltinID == X86::BI__builtin_ia32_cmppd ||
2794 BuiltinID == X86::BI__builtin_ia32_cmpsd) {
2796 llvm::StringMap<bool> TargetFetureMap;
2797 CGM.getContext().getFunctionFeatureMap(TargetFetureMap, FD);
2799 *(E->
getArg(2)->getIntegerConstantExpr(
CGM.getContext()));
2800 if (
Result.getSExtValue() > 7 && !TargetFetureMap.lookup(
"avx"))
2801 CGM.getDiags().Report(E->
getBeginLoc(), diag::err_builtin_needs_feature)
2822 bool IsAlwaysInline = TargetDecl->
hasAttr<AlwaysInlineAttr>();
2823 bool IsFlatten = FD && FD->
hasAttr<FlattenAttr>();
2829 std::string MissingFeature;
2830 llvm::StringMap<bool> CallerFeatureMap;
2831 CGM.getContext().getFunctionFeatureMap(CallerFeatureMap, FD);
2838 StringRef FeatureList(
CGM.getContext().BuiltinInfo.getRequiredFeatures(BuiltinID));
2840 FeatureList, CallerFeatureMap) && !IsHipStdPar) {
2841 CGM.getDiags().Report(Loc, diag::err_builtin_needs_feature)
2846 TargetDecl->
hasAttr<TargetAttr>()) {
2849 const TargetAttr *TD = TargetDecl->
getAttr<TargetAttr>();
2851 CGM.getContext().filterFunctionTargetAttrs(TD);
2854 llvm::StringMap<bool> CalleeFeatureMap;
2855 CGM.getContext().getFunctionFeatureMap(CalleeFeatureMap, TargetDecl);
2858 if (F[0] ==
'+' && CalleeFeatureMap.lookup(F.substr(1)))
2859 ReqFeatures.push_back(StringRef(F).substr(1));
2862 for (
const auto &F : CalleeFeatureMap) {
2865 ReqFeatures.push_back(F.getKey());
2867 if (!llvm::all_of(ReqFeatures,
2869 if (!CallerFeatureMap.lookup(
Feature)) {
2870 MissingFeature =
Feature.str();
2877 CGM.getDiags().Report(Loc, diag::err_function_needs_feature)
2880 CGM.getDiags().Report(Loc, diag::err_flatten_function_needs_feature)
2885 llvm::StringMap<bool> CalleeFeatureMap;
2886 CGM.getContext().getFunctionFeatureMap(CalleeFeatureMap, TargetDecl);
2888 for (
const auto &F : CalleeFeatureMap) {
2890 (!CallerFeatureMap.lookup(F.getKey()) ||
2891 !CallerFeatureMap.find(F.getKey())->getValue()) &&
2894 CGM.getDiags().Report(Loc, diag::err_function_needs_feature)
2897 CGM.getDiags().Report(Loc, diag::err_flatten_function_needs_feature)
2905 if (!
CGM.getCodeGenOpts().SanitizeStats)
2908 llvm::IRBuilder<> IRB(
Builder.GetInsertBlock(),
Builder.GetInsertPoint());
2909 IRB.SetCurrentDebugLocation(
Builder.getCurrentDebugLocation());
2910 CGM.getSanStats().create(IRB, SSK);
2922 Salt = Info.CFISalt;
2924 Bundles.emplace_back(
"kcfi",
CGM.CreateKCFITypeId(FP->
desugar(), Salt));
2928CodeGenFunction::FormAArch64ResolverCondition(
const FMVResolverOption &RO) {
2929 return RO.Features.empty() ?
nullptr : EmitAArch64CpuSupports(RO.Features);
2933CodeGenFunction::FormX86ResolverCondition(
const FMVResolverOption &RO) {
2936 if (RO.Architecture) {
2937 StringRef
Arch = *RO.Architecture;
2940 if (
Arch.starts_with(
"x86-64"))
2946 if (!RO.Features.empty()) {
2947 llvm::Value *FeatureCond = EmitX86CpuSupports(RO.Features);
2955 llvm::Function *Resolver,
2957 llvm::Function *FuncToReturn,
2958 bool SupportsIFunc) {
2959 if (SupportsIFunc) {
2960 Builder.CreateRet(FuncToReturn);
2965 llvm::make_pointer_range(Resolver->args()));
2967 llvm::CallInst *Result = Builder.CreateCall(FuncToReturn, Args);
2968 Result->setTailCallKind(llvm::CallInst::TCK_MustTail);
2970 if (Resolver->getReturnType()->isVoidTy())
2971 Builder.CreateRetVoid();
2973 Builder.CreateRet(Result);
2979 llvm::Triple::ArchType ArchType =
2983 case llvm::Triple::x86:
2984 case llvm::Triple::x86_64:
2987 case llvm::Triple::aarch64:
2990 case llvm::Triple::riscv32:
2991 case llvm::Triple::riscv64:
2996 assert(
false &&
"Only implemented for x86, AArch64 and RISC-V targets");
3003 if (
getContext().getTargetInfo().getTriple().getOS() !=
3004 llvm::Triple::OSType::Linux) {
3005 CGM.getDiags().Report(diag::err_os_unsupport_riscv_fmv);
3010 Builder.SetInsertPoint(CurBlock);
3014 bool HasDefault =
false;
3015 unsigned DefaultIndex = 0;
3018 for (
unsigned Index = 0; Index < Options.size(); Index++) {
3020 if (Options[Index].Features.empty()) {
3022 DefaultIndex = Index;
3026 Builder.SetInsertPoint(CurBlock);
3052 for (StringRef Feat : Options[Index].Features) {
3053 std::vector<std::string> FeatStr =
3056 assert(FeatStr.size() == 1 &&
"Feature string not delimited");
3058 std::string &CurrFeat = FeatStr.front();
3059 if (CurrFeat[0] ==
'+')
3060 TargetAttrFeats.push_back(CurrFeat.substr(1));
3063 if (TargetAttrFeats.empty())
3066 for (std::string &Feat : TargetAttrFeats)
3067 CurrTargetAttrFeats.push_back(Feat);
3069 Builder.SetInsertPoint(CurBlock);
3072 llvm::BasicBlock *RetBlock =
createBasicBlock(
"resolver_return", Resolver);
3075 Options[Index].
Function, SupportsIFunc);
3078 Builder.SetInsertPoint(CurBlock);
3079 Builder.CreateCondBr(FeatsCondition, RetBlock, ElseBlock);
3081 CurBlock = ElseBlock;
3086 Builder.SetInsertPoint(CurBlock);
3093 Builder.SetInsertPoint(CurBlock);
3094 llvm::CallInst *TrapCall =
EmitTrapCall(llvm::Intrinsic::trap);
3095 TrapCall->setDoesNotReturn();
3096 TrapCall->setDoesNotThrow();
3098 Builder.ClearInsertionPoint();
3103 assert(!Options.empty() &&
"No multiversion resolver options found");
3104 assert(Options.back().Features.size() == 0 &&
"Default case must be last");
3106 assert(SupportsIFunc &&
3107 "Multiversion resolver requires target IFUNC support");
3108 bool AArch64CpuInitialized =
false;
3112 Builder.SetInsertPoint(CurBlock);
3113 llvm::Value *
Condition = FormAArch64ResolverCondition(RO);
3122 if (!AArch64CpuInitialized) {
3123 Builder.SetInsertPoint(CurBlock, CurBlock->begin());
3124 EmitAArch64CpuInit();
3125 AArch64CpuInitialized =
true;
3126 Builder.SetInsertPoint(CurBlock);
3129 llvm::BasicBlock *RetBlock =
createBasicBlock(
"resolver_return", Resolver);
3138 Builder.SetInsertPoint(CurBlock);
3139 llvm::CallInst *TrapCall =
EmitTrapCall(llvm::Intrinsic::trap);
3140 TrapCall->setDoesNotReturn();
3141 TrapCall->setDoesNotThrow();
3143 Builder.ClearInsertionPoint();
3153 Builder.SetInsertPoint(CurBlock);
3157 Builder.SetInsertPoint(CurBlock);
3158 llvm::Value *
Condition = FormX86ResolverCondition(RO);
3162 assert(&RO == Options.end() - 1 &&
3163 "Default or Generic case must be last");
3169 llvm::BasicBlock *RetBlock =
createBasicBlock(
"resolver_return", Resolver);
3178 Builder.SetInsertPoint(CurBlock);
3179 llvm::CallInst *TrapCall =
EmitTrapCall(llvm::Intrinsic::trap);
3180 TrapCall->setDoesNotReturn();
3181 TrapCall->setDoesNotThrow();
3183 Builder.ClearInsertionPoint();
3195 llvm::Value *OffsetValue, llvm::Value *TheCheck,
3196 llvm::Instruction *Assumption) {
3197 assert(isa_and_nonnull<llvm::CallInst>(Assumption) &&
3199 llvm::Intrinsic::getOrInsertDeclaration(
3200 Builder.GetInsertBlock()->getParent()->getParent(),
3201 llvm::Intrinsic::assume) &&
3202 "Assumption should be a call to llvm.assume().");
3203 assert(&(
Builder.GetInsertBlock()->back()) == Assumption &&
3204 "Assumption should be the last instruction of the basic block, "
3205 "since the basic block is still being generated.");
3207 if (!
SanOpts.has(SanitizerKind::Alignment))
3217 Assumption->removeFromParent();
3220 auto CheckOrdinal = SanitizerKind::SO_Alignment;
3221 auto CheckHandler = SanitizerHandler::AlignmentAssumption;
3225 OffsetValue =
Builder.getInt1(
false);
3230 llvm::Value *DynamicData[] = {Ptr, Alignment, OffsetValue};
3231 EmitCheck({std::make_pair(TheCheck, CheckOrdinal)}, CheckHandler,
3232 StaticData, DynamicData);
3243 return DI->SourceLocToDebugLoc(Location);
3245 return llvm::DebugLoc();
3249CodeGenFunction::emitCondLikelihoodViaExpectIntrinsic(llvm::Value *
Cond,
3260 llvm::Type *CondTy =
Cond->getType();
3261 assert(CondTy->isIntegerTy(1) &&
"expecting condition to be a boolean");
3262 llvm::Function *FnExpect =
3264 llvm::Value *ExpectedValueOfCond =
3266 return Builder.CreateCall(FnExpect, {
Cond, ExpectedValueOfCond},
3267 Cond->getName() +
".expval");
3269 llvm_unreachable(
"Unknown Likelihood");
3273 unsigned NumElementsDst,
3274 const llvm::Twine &Name) {
3276 unsigned NumElementsSrc = SrcTy->getNumElements();
3277 if (NumElementsSrc == NumElementsDst)
3280 std::vector<int> ShuffleMask(NumElementsDst, -1);
3281 for (
unsigned MaskIdx = 0;
3282 MaskIdx < std::min<>(NumElementsDst, NumElementsSrc); ++MaskIdx)
3283 ShuffleMask[MaskIdx] = MaskIdx;
3285 return Builder.CreateShuffleVector(SrcVec, ShuffleMask, Name);
3298 Discriminator =
Builder.getSize(0);
3300 llvm::Value *Args[] = {Key, Discriminator};
3301 Bundles.emplace_back(
"ptrauth", Args);
3307 unsigned IntrinsicID) {
3314 if (!Discriminator) {
3319 auto OrigType =
Pointer->getType();
3337 llvm::Intrinsic::ptrauth_sign);
3343 auto StripIntrinsic = CGF.
CGM.
getIntrinsic(llvm::Intrinsic::ptrauth_strip);
3347 auto OrigType =
Pointer->getType();
3364 llvm::Intrinsic::ptrauth_auth);
3368 llvm::Instruction *KeyInstruction, llvm::Value *Backup) {
3370 DI->addInstToCurrentSourceAtom(KeyInstruction, Backup);
3374 llvm::Instruction *KeyInstruction, llvm::Value *Backup, uint64_t Atom) {
3376 DI->addInstToSpecificSourceAtom(KeyInstruction, Backup, Atom);
3380 llvm::Value *Backup) {
3383 DI->addInstToCurrentSourceAtom(KeyInstruction, Backup);
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 shouldEmitLifetimeMarkers(const CodeGenOptions &CGOpts, const LangOptions &LangOpts)
shouldEmitLifetimeMarkers - Decide whether we need emit the life-time markers.
static bool matchesStlAllocatorFn(const Decl *D, const ASTContext &Ctx)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
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.
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.
SourceLocation getBeginLoc() const
CharUnits - This is an opaque type for sizes expressed in character units.
bool isZero() const
isZero - Test whether the quantity equals zero.
llvm::Align getAsAlign() const
getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
CharUnits alignmentOfArrayElement(CharUnits elementSize) const
Given that this is the alignment of the first element of an array, return the minimum alignment of an...
bool isOne() const
isOne - Test whether the quantity equals one.
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
@ 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 * 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 override
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::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...
SanitizerSet SanOpts
Sanitizers enabled for this function.
void EmitNullInitialization(Address DestPtr, QualType Ty)
EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...
RawAddress CreateIRTemp(QualType T, const Twine &Name="tmp")
CreateIRTemp - Create a temporary IR object of the given type, with appropriate alignment.
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.
bool ShouldSkipSanitizerInstrumentation()
ShouldSkipSanitizerInstrumentation - Return true if the current function should not be instrumented w...
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.
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 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.
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.
SmallVector< const BinaryOperator *, 16 > MCDCLogOpStack
Stack to track the Logical Operator recursion nest for MC/DC.
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.
void emitAlignmentAssumptionCheck(llvm::Value *Ptr, QualType Ty, SourceLocation Loc, SourceLocation AssumptionLoc, llvm::Value *Alignment, llvm::Value *OffsetValue, llvm::Value *TheCheck, llvm::Instruction *Assumption)
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 incrementProfileCounter(const Stmt *S, llvm::Value *StepV=nullptr)
Increment the profiler's counter for the given statement by StepV.
VlaSizePair getVLASize(const VariableArrayType *vla)
Returns an LLVM value that corresponds to the size, in non-variably-sized elements,...
ASTContext & getContext() 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.
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)
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,...
llvm::CallInst * EmitTrapCall(llvm::Intrinsic::ID IntrID)
Emit a call to trap or debugtrap and attach function attribute "trap-func-name" if specified.
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
void 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 emitAlignmentAssumption(llvm::Value *PtrValue, QualType Ty, SourceLocation Loc, SourceLocation AssumptionLoc, llvm::Value *Alignment, llvm::Value *OffsetValue=nullptr)
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.
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const
Returns the set of floating point options that apply to this expression.
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.
bool isMultiVersion() const
True if this function is considered a multiversioned function.
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
bool UsesFPIntrin() const
Determine whether the function was declared in source context that requires constrained FP intrinsics...
bool usesSEHTry() const
Indicates the function uses __try.
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
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, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)
Create implicit parameter.
Represents the declaration of a label.
FPExceptionModeKind
Possible floating point exception behavior.
@ FPE_Strict
Strictly preserve the floating-point exception semantics.
@ FPE_MayTrap
Transformations do not cause new exceptions but may hide some.
@ FPE_Ignore
Assume that floating-point exceptions are masked.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
SanitizerSet Sanitize
Set of enabled sanitizers.
RoundingMode getDefaultRoundingMode() const
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Represents a parameter to a function.
ParsedAttr - Represents a syntactic attribute.
PointerType - C99 6.7.5.1 - Pointer Declarators.
@ Forbid
Profiling is forbidden using the noprofile attribute.
@ Skip
Profiling is skipped using the skipprofile attribute.
@ Allow
Profiling is allowed.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
field_range fields() const
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
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Represents a variable declaration or definition.
Represents a C array with a specified size that is not an integer-constant-expression.
Expr * getSizeExpr() const
QualType getElementType() const
Defines the clang::TargetInfo interface.
bool evaluateRequiredTargetFeatures(llvm::StringRef RequiredFatures, const llvm::StringMap< bool > &TargetFetureMap)
Returns true if the required target features of a builtin function are enabled.
@ 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
The JSON file list parser is used to communicate input to InstallAPI.
bool isa(CodeGen::Address addr)
@ NonNull
Values of this type can never be null.
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
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.
Diagnostic wrappers for TextAPI types for error reporting.
cl::opt< bool > EnableSingleByteCoverage
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::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....
Contains information gathered from parsing the contents of TargetAttr.
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.