Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/CGCall_8cpp_source.html below:

clang: lib/CodeGen/CGCall.cpp Source File

;

CodeGen;

:

llvm::CallingConv::C;

:

llvm::CallingConv::Win64;

:

llvm::CallingConv::ARM_AAPCS;

:

llvm::CallingConv::ARM_AAPCS_VFP;

:

llvm::CallingConv::Swift;

:

llvm::CallingConv::M68k_RTD;

totalArgs) {

assert(paramInfos.size() <= prefixArgs);

assert(proto->

() + prefixArgs <= totalArgs);

paramInfos.reserve(totalArgs);

paramInfos.resize(prefixArgs);

paramInfos.push_back(ParamInfo);

(ParamInfo.hasPassObjectSize())

paramInfos.emplace_back();

assert(paramInfos.size() <= totalArgs &&

);

paramInfos.resize(totalArgs);

(!FPT->hasExtParameterInfos()) {

assert(paramInfos.empty() &&

);

prefix.append(FPT->param_type_begin(), FPT->param_type_end());

PrefixSize = prefix.size();

prefix.reserve(prefix.size() + FPT->getNumParams());

ExtInfos = FPT->getExtParameterInfos();

assert(ExtInfos.size() == FPT->getNumParams());

(

I = 0,

= FPT->getNumParams(); I !=

; ++I) {

prefix.push_back(FPT->getParamType(I));

(ExtInfos[I].hasPassObjectSize())

FTP->getExtInfo(), paramInfos,

);

return ::arrangeLLVMFunctionInfo(*

,

, argTypes,

(

->

<VectorCallAttr>())

(PcsAttr *PCS =

->

<PcsAttr>())

(

->

<AArch64VectorPcsAttr>())

(

->

<AArch64SVEPcsAttr>())

(

->

<AMDGPUKernelCallAttr>())

(

->

<IntelOclBiccAttr>())

(

->

<PreserveMostAttr>())

(

->

<PreserveAllAttr>())

(

->

<PreserveNoneAttr>())

(

->

<RISCVVectorCCAttr>())

return ::arrangeLLVMFunctionInfo(

*

,

, argTypes,

(FD->

<CUDAGlobalAttr>()) {

assert(!isa<CXXConstructorDecl>(MD) &&

);

assert(!isa<CXXDestructorDecl>(MD) &&

);

!

.getCXXABI().hasConstructorVariants();

*MD = cast<CXXMethodDecl>(GD.

());

PassParams =

;

(

*CD = dyn_cast<CXXConstructorDecl>(MD)) {

(

Inherited = CD->getInheritedConstructor())

(!paramInfos.empty()) {

paramInfos.insert(paramInfos.begin() + 1, AddedArgs.

,

paramInfos.append(AddedArgs.

,

(PassParams && MD->isVariadic() ?

(argTypes.size())

argTypes, extInfo, paramInfos, required);

(

&arg : args)

(

&arg : args)

prefixArgs,

totalArgs) {

ExtraPrefixArgs,

ExtraSuffixArgs,

PassProtoArgs) {

(

&Arg : args)

TotalPrefixArgs = 1 + ExtraPrefixArgs;

FPT, TotalPrefixArgs + ExtraSuffixArgs)

(PassProtoArgs && FPT->hasExtParameterInfos()) {

ArgTypes, Info, ParamInfos,

);

(MD->isImplicitObjectMemberFunction())

assert(isa<FunctionType>(FTy));

{}, noProto->getExtInfo(), {},

I->hasAttr<NoEscapeAttr>());

extParamInfos.push_back(extParamInfo);

(

().getLangOpts().ObjCAutoRefCount &&

MD->

<NSReturnsRetainedAttr>())

(isa<CXXConstructorDecl>(GD.

()) ||

isa<CXXDestructorDecl>(GD.

()))

assert(MD->

() &&

);

ArgTys.push_back(*FTP->param_type_begin());

ArgTys.push_back(Context.

);

numExtraRequiredArgs,

assert(args.size() >= numExtraRequiredArgs);

(proto->isVariadic())

(proto->hasExtParameterInfos())

cast<FunctionNoProtoType>(fnType))) {

(

&arg : args)

paramInfos, required);

chainCall ? 1 : 0, chainCall);

(

&Arg : args)

numPrefixArgs) {

assert(numPrefixArgs + 1 <= args.size() &&

);

paramInfos, required);

assert(signature.

() <= args.size());

(signature.

() == args.size())

(!sigParamInfos.empty()) {

paramInfos.append(sigParamInfos.begin(), sigParamInfos.end());

paramInfos.resize(args.size());

assert(llvm::all_of(argTypes,

llvm::FoldingSetNodeID ID;

isDelegateCall =

info, paramInfos, required, resultType, argTypes);

*insertPos =

;

*FI = FunctionInfos.FindNodeOrInsertPos(ID, insertPos);

info, paramInfos, resultType, argTypes, required);

FunctionInfos.InsertNode(FI, insertPos);

inserted = FunctionsBeingProcessed.insert(FI).second;

assert(inserted &&

);

(CC == llvm::CallingConv::SPIR_KERNEL) {

(I.info.canHaveCoerceToType() && I.info.getCoerceToType() ==

)

erased = FunctionsBeingProcessed.erase(FI); (void)erased;

assert(erased &&

);

chainCall,

delegateCall,

assert(paramInfos.empty() || paramInfos.size() == argTypes.size());

(totalSizeToAlloc<ArgInfo, ExtParameterInfo>(

argTypes.size() + 1, paramInfos.size()));

FI->CallingConvention = llvmCC;

FI->EffectiveCallingConvention = llvmCC;

FI->ASTCallingConvention = info.

();

FI->InstanceMethod = instanceMethod;

FI->ChainCall = chainCall;

FI->DelegateCall = delegateCall;

FI->Required = required;

FI->ArgStruct =

;

FI->ArgStructAlign = 0;

FI->NumArgs = argTypes.size();

FI->HasExtParameterInfos = !paramInfos.empty();

FI->getArgsBuffer()[0].

= resultType;

FI->MaxVectorWidth = 0;

(

i = 0, e = argTypes.size(); i != e; ++i)

FI->getArgsBuffer()[i + 1].

= argTypes[i];

(

i = 0, e = paramInfos.size(); i != e; ++i)

FI->getExtParameterInfosBuffer()[i] = paramInfos[i];

TypeExpansion {

TypeExpansionKind {

TypeExpansionKind

;

TypeExpansion(TypeExpansionKind K) :

(K) {}

~TypeExpansion() {}

ConstantArrayExpansion : TypeExpansion {

ConstantArrayExpansion(

EltTy, uint64_t NumElts)

: TypeExpansion(TEK_ConstantArray), EltTy(EltTy), NumElts(NumElts) {}

classof(

TypeExpansion *TE) {

TE->Kind == TEK_ConstantArray;

RecordExpansion : TypeExpansion {

: TypeExpansion(TEK_Record), Bases(

::move(Bases)),

Fields(

::move(Fields)) {}

classof(

TypeExpansion *TE) {

TE->Kind == TEK_Record;

ComplexExpansion : TypeExpansion {

classof(

TypeExpansion *TE) {

NoExpansion : TypeExpansion {

NoExpansion() : TypeExpansion(TEK_None) {}

classof(

TypeExpansion *TE) {

TE->Kind == TEK_None;

std::unique_ptr<TypeExpansion>

std::make_unique<ConstantArrayExpansion>(AT->getElementType(),

);

(

*FD : RD->

()) {

(FD->isZeroLengthBitField())

assert(!FD->isBitField() &&

);

(UnionSize < FieldSize) {

UnionSize = FieldSize;

Fields.push_back(LargestFD);

(

*CXXRD = dyn_cast<CXXRecordDecl>(RD)) {

assert(!CXXRD->isDynamicClass() &&

);

llvm::append_range(Bases, llvm::make_pointer_range(CXXRD->bases()));

(

*FD : RD->

()) {

(FD->isZeroLengthBitField())

assert(!FD->isBitField() &&

);

Fields.push_back(FD);

std::make_unique<RecordExpansion>(std::move(Bases),

std::make_unique<ComplexExpansion>(CT->getElementType());

std::make_unique<NoExpansion>();

(

CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {

(

RExp = dyn_cast<RecordExpansion>(Exp.get())) {

(

BS : RExp->Bases)

(

FD : RExp->Fields)

(isa<ComplexExpansion>(Exp.get()))

assert(isa<NoExpansion>(Exp.get()));

(

CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {

(

i = 0, n = CAExp->NumElts; i < n; i++) {

}

(

RExp = dyn_cast<RecordExpansion>(Exp.get())) {

(

BS : RExp->Bases)

(

FD : RExp->Fields)

}

(

CExp = dyn_cast<ComplexExpansion>(Exp.get())) {

assert(isa<NoExpansion>(Exp.get()));

ConstantArrayExpansion *CAE,

llvm::function_ref<

(

)> Fn) {

(

i = 0, n = CAE->NumElts; i < n; i++) {

llvm::Function::arg_iterator &AI) {

);

(

CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {

LValue LV = MakeAddrLValue(EltAddr, CAExp->EltTy);

ExpandTypeFromArgs(CAExp->EltTy, LV, AI);

}

(

RExp = dyn_cast<RecordExpansion>(Exp.get())) {

ExpandTypeFromArgs(BS->

(), SubLV, AI);

(

FD : RExp->Fields) {

ExpandTypeFromArgs(FD->getType(), SubLV, AI);

}

(isa<ComplexExpansion>(Exp.get())) {

realValue = &*AI++;

imagValue = &*AI++;

assert(isa<NoExpansion>(Exp.get()));

llvm::Value *Arg = &*AI++;

(Arg->getType()->isPointerTy()) {

CodeGenFunction::ExpandTypeToArgs(

(

CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {

*

, CAExp, Addr, [&](

EltAddr) {

ExpandTypeToArgs(CAExp->EltTy, EltArg, IRFuncTy, IRCallArgs,

}

(

RExp = dyn_cast<RecordExpansion>(Exp.get())) {

ExpandTypeToArgs(BS->

(), BaseArg, IRFuncTy, IRCallArgs,

(

FD : RExp->Fields) {

ExpandTypeToArgs(FD->getType(), FldArg, IRFuncTy, IRCallArgs,

}

(isa<ComplexExpansion>(Exp.get())) {

IRCallArgs[IRCallArgPos++] = CV.first;

IRCallArgs[IRCallArgPos++] = CV.second;

assert(isa<NoExpansion>(Exp.get()));

assert(RV.isScalar() &&

);

llvm::Value *

= RV.getScalarVal();

(IRCallArgPos < IRFuncTy->getNumParams() &&

->getType() != IRFuncTy->getParamType(IRCallArgPos))

=

.CreateBitCast(

, IRFuncTy->getParamType(IRCallArgPos));

IRCallArgs[IRCallArgPos++] =

;

Twine &Name =

) {

llvm::StructType *SrcSTy,

(SrcSTy->getNumElements() == 0)

SrcPtr;

uint64_t FirstEltSize =

(FirstEltSize < DstSize &&

(llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy))

(Val->getType() == Ty)

(isa<llvm::PointerType>(Val->getType())) {

(isa<llvm::PointerType>(Ty))

CGF.

.CreateBitCast(Val, Ty,

);

Val = CGF.

.CreatePtrToInt(Val, CGF.

,

);

llvm::Type *DestIntTy = Ty;

(isa<llvm::PointerType>(DestIntTy))

(Val->getType() != DestIntTy) {

(DL.isBigEndian()) {

uint64_t SrcSize = DL.getTypeSizeInBits(Val->getType());

uint64_t DstSize = DL.getTypeSizeInBits(DestIntTy);

(SrcSize > DstSize) {

Val = CGF.

.CreateLShr(Val, SrcSize - DstSize,

);

Val = CGF.

.CreateTrunc(Val, DestIntTy,

);

Val = CGF.

.CreateZExt(Val, DestIntTy,

);

Val = CGF.

.CreateShl(Val, DstSize - SrcSize,

);

Val = CGF.

.CreateIntCast(Val, DestIntTy,

,

);

(isa<llvm::PointerType>(Ty))

Val = CGF.

.CreateIntToPtr(Val, Ty,

);

(llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy)) {

DstSize.getFixedValue(), CGF);

llvm::TypeSize SrcSize = CGF.

.

().getTypeAllocSize(SrcTy);

((isa<llvm::IntegerType>(Ty) || isa<llvm::PointerType>(Ty)) &&

(isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy))) {

(!SrcSize.isScalable() && !DstSize.isScalable() &&

SrcSize.getFixedValue() >= DstSize.getFixedValue()) {

(

*ScalableDstTy = dyn_cast<llvm::ScalableVectorType>(Ty)) {

(

*FixedSrcTy = dyn_cast<llvm::FixedVectorType>(SrcTy)) {

(ScalableDstTy->getElementType()->isIntegerTy(1) &&

ScalableDstTy->getElementCount().isKnownMultipleOf(8) &&

FixedSrcTy->getElementType()->isIntegerTy(8)) {

ScalableDstTy = llvm::ScalableVectorType::get(

FixedSrcTy->getElementType(),

ScalableDstTy->getElementCount().getKnownMinValue() / 8);

(ScalableDstTy->getElementType() == FixedSrcTy->getElementType()) {

*PoisonVec = llvm::PoisonValue::get(ScalableDstTy);

*Zero = llvm::Constant::getNullValue(CGF.

.

);

ScalableDstTy, PoisonVec, Load, Zero,

);

(ScalableDstTy != Ty)

llvm::ConstantInt::get(CGF.

, SrcSize.getKnownMinValue()));

llvm::TypeSize DstSize,

DstIsVolatile) {

llvm::Type *SrcTy = Src->getType();

(llvm::StructType *DstSTy =

assert(!SrcSize.isScalable());

SrcSize.getFixedValue(), *

);

(SrcSize.isScalable() || SrcSize <= DstSize) {

(SrcTy->isIntegerTy() && Dst.

()->isPointerTy() &&

}

(llvm::StructType *STy =

dyn_cast<llvm::StructType>(Src->getType())) {

(

i = 0, e = STy->getNumElements(); i != e; ++i) {

llvm::Value *Elt =

.CreateExtractValue(Src, i);

}

(SrcTy->isIntegerTy()) {

llvm::Type *DstIntTy =

.getIntNTy(DstSize.getFixedValue() * 8);

std::pair<llvm::Value *, bool>

llvm::ScalableVectorType *FromTy, llvm::Value *

,

StringRef Name =

) {

(FromTy->getElementType()->isIntegerTy(1) &&

FromTy->getElementCount().isKnownMultipleOf(8) &&

ToTy->getElementType() == CGF.

.getInt8Ty()) {

FromTy = llvm::ScalableVectorType::get(

ToTy->getElementType(),

FromTy->getElementCount().getKnownMinValue() / 8);

= CGF.

.CreateBitCast(

, FromTy);

(FromTy->getElementType() == ToTy->getElementType()) {

llvm::Value *Zero = llvm::Constant::getNullValue(CGF.

.

);

->setName(Name +

);

= CGF.

.CreateExtractVector(ToTy,

, Zero,

);

{

,

};

{

,

};

ClangToLLVMArgMapping {

InvalidIndex = ~0

;

InallocaArgNo;

TotalIRArgs;

PaddingArgIndex;

FirstArgIndex;

NumberOfArgs;

: PaddingArgIndex(InvalidIndex), FirstArgIndex(InvalidIndex),

OnlyRequiredArgs =

)

: InallocaArgNo(InvalidIndex), SRetArgNo(InvalidIndex), TotalIRArgs(0),

ArgInfo(OnlyRequiredArgs ? FI.getNumRequiredArgs() : FI.arg_size()) {

construct(Context, FI, OnlyRequiredArgs);

hasInallocaArg()

{

InallocaArgNo != InvalidIndex; }

getInallocaArgNo()

{

assert(hasInallocaArg());

InallocaArgNo;

hasSRetArg()

{

SRetArgNo != InvalidIndex; }

getSRetArgNo()

{

assert(hasSRetArg());

totalIRArgs()

{

TotalIRArgs; }

hasPaddingArg(

ArgNo)

{

assert(ArgNo < ArgInfo.size());

ArgInfo[ArgNo].PaddingArgIndex != InvalidIndex;

getPaddingArgNo(

ArgNo)

{

assert(hasPaddingArg(ArgNo));

ArgInfo[ArgNo].PaddingArgIndex;

std::pair<unsigned, unsigned> getIRArgs(

ArgNo)

{

assert(ArgNo < ArgInfo.size());

std::make_pair(ArgInfo[ArgNo].FirstArgIndex,

ArgInfo[ArgNo].NumberOfArgs);

OnlyRequiredArgs);

ClangToLLVMArgMapping::construct(

&Context,

OnlyRequiredArgs) {

IRArgNo = 0;

SwapThisWithSRet =

;

SRetArgNo = SwapThisWithSRet ? 1 : IRArgNo++;

&IRArgs = ArgInfo[ArgNo];

IRArgs.PaddingArgIndex = IRArgNo++;

llvm::StructType *STy = dyn_cast<llvm::StructType>(AI.

());

IRArgs.NumberOfArgs = STy->getNumElements();

IRArgs.NumberOfArgs = 1;

IRArgs.NumberOfArgs = 1;

IRArgs.NumberOfArgs = 0;

(IRArgs.NumberOfArgs > 0) {

IRArgs.FirstArgIndex = IRArgNo;

IRArgNo += IRArgs.NumberOfArgs;

(IRArgNo == 1 && SwapThisWithSRet)

assert(ArgNo == ArgInfo.size());

InallocaArgNo = IRArgNo++;

TotalIRArgs = IRArgNo;

RI.

() || (RI.isInAlloca() && RI.getInAllocaSRet());

(BT->getKind()) {

BuiltinType::Float:

BuiltinType::Double:

BuiltinType::LongDouble:

(BT->getKind() == BuiltinType::LongDouble)

llvm::FunctionType *

Inserted = FunctionsBeingProcessed.insert(&FI).second;

assert(Inserted &&

);

llvm::Type *resultType =

;

llvm_unreachable(

);

resultType = llvm::PointerType::get(

(), addressSpace);

ClangToLLVMArgMapping IRFunctionArgs(

(), FI,

);

(IRFunctionArgs.hasSRetArg()) {

ArgTypes[IRFunctionArgs.getSRetArgNo()] =

(IRFunctionArgs.hasInallocaArg())

ArgTypes[IRFunctionArgs.getInallocaArgNo()] =

(; it != ie; ++it, ++ArgNo) {

(IRFunctionArgs.hasPaddingArg(ArgNo))

ArgTypes[IRFunctionArgs.getPaddingArgNo(ArgNo)] =

FirstIRArg, NumIRArgs;

std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);

(ArgInfo.

()) {

assert(NumIRArgs == 0);

assert(NumIRArgs == 1);

ArgTypes[FirstIRArg] = llvm::PointerType::get(

assert(NumIRArgs == 1);

ArgTypes[FirstIRArg] = llvm::PointerType::get(

llvm::StructType *st = dyn_cast<llvm::StructType>(argType);

assert(NumIRArgs == st->getNumElements());

(

i = 0, e = st->getNumElements(); i != e; ++i)

ArgTypes[FirstIRArg + i] = st->getElementType(i);

assert(NumIRArgs == 1);

ArgTypes[FirstIRArg] = argType;

ArgTypesIter = ArgTypes.begin() + FirstIRArg;

*ArgTypesIter++ = EltTy;

assert(ArgTypesIter == ArgTypes.begin() + FirstIRArg + NumIRArgs);

ArgTypesIter = ArgTypes.begin() + FirstIRArg;

assert(ArgTypesIter == ArgTypes.begin() + FirstIRArg + NumIRArgs);

Erased = FunctionsBeingProcessed.erase(&FI); (void)Erased;

assert(Erased &&

);

llvm::FunctionType::get(resultType, ArgTypes, FI.

());

llvm::AttrBuilder &FuncAttrs,

FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);

FuncAttrs.addAttribute(

);

FuncAttrs.addAttribute(

);

FuncAttrs.addAttribute(

);

FuncAttrs.addAttribute(

);

FuncAttrs.addAttribute(

);

FuncAttrs.addAttribute(

);

FuncAttrs.addAttribute(

);

FuncAttrs.addAttribute(

);

FuncAttrs.addAttribute(

);

FuncAttrs.addAttribute(

);

FuncAttrs.addAttribute(

);

*Callee) {

(

OMPAssumeAttr *AA : Callee->specific_attrs<OMPAssumeAttr>())

AA->getAssumption().split(Attrs,

);

FuncAttrs.addAttribute(llvm::AssumptionAttrKey,

llvm::join(Attrs.begin(), Attrs.end(),

));

(

*ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl()))

ClassDecl->hasTrivialDestructor();

*TargetDecl) {

(

.getLangOpts().Sanitize.has(SanitizerKind::Memory))

(!

.getLangOpts().CPlusPlus)

(

*FDecl = dyn_cast<FunctionDecl>(TargetDecl)) {

(FDecl->isExternC())

}

(

*VDecl = dyn_cast<VarDecl>(TargetDecl)) {

(VDecl->isExternC())

.getCodeGenOpts().StrictReturn ||

!

.MayDropFunctionReturn(

.getContext(), RetTy) ||

.getLangOpts().Sanitize.has(SanitizerKind::Return);

llvm::DenormalMode FP32DenormalMode,

llvm::AttrBuilder &FuncAttrs) {

(FPDenormalMode != llvm::DenormalMode::getDefault())

FuncAttrs.addAttribute(

, FPDenormalMode.str());

(FP32DenormalMode != FPDenormalMode && FP32DenormalMode.isValid())

FuncAttrs.addAttribute(

, FP32DenormalMode.str());

llvm::AttrBuilder &FuncAttrs) {

StringRef Name,

HasOptnone,

&CodeGenOpts,

llvm::AttrBuilder &FuncAttrs) {

(CodeGenOpts.OptimizeSize)

FuncAttrs.addAttribute(llvm::Attribute::OptimizeForSize);

(CodeGenOpts.OptimizeSize == 2)

FuncAttrs.addAttribute(llvm::Attribute::MinSize);

(CodeGenOpts.DisableRedZone)

FuncAttrs.addAttribute(llvm::Attribute::NoRedZone);

(CodeGenOpts.IndirectTlsSegRefs)

FuncAttrs.addAttribute(

);

(CodeGenOpts.NoImplicitFloat)

FuncAttrs.addAttribute(llvm::Attribute::NoImplicitFloat);

(AttrOnCallSite) {

(!CodeGenOpts.SimplifyLibCalls || LangOpts.

(Name))

FuncAttrs.addAttribute(llvm::Attribute::NoBuiltin);

FuncAttrs.addAttribute(

, CodeGenOpts.

);

(CodeGenOpts.getFramePointer()) {

FuncAttrs.addAttribute(

,

CodeGenOpts.getFramePointer()));

(CodeGenOpts.LessPreciseFPMAD)

FuncAttrs.addAttribute(

,

);

(CodeGenOpts.NullPointerIsValid)

FuncAttrs.addAttribute(llvm::Attribute::NullPointerIsValid);

FuncAttrs.addAttribute(

,

);

(LangOpts.NoHonorInfs)

FuncAttrs.addAttribute(

,

);

(LangOpts.NoHonorNaNs)

FuncAttrs.addAttribute(

,

);

(LangOpts.ApproxFunc)

FuncAttrs.addAttribute(

,

);

(LangOpts.AllowFPReassoc && LangOpts.AllowRecip &&

LangOpts.NoSignedZero && LangOpts.ApproxFunc &&

(LangOpts.getDefaultFPContractMode() ==

LangOpts.getDefaultFPContractMode() ==

FuncAttrs.addAttribute(

,

);

(CodeGenOpts.SoftFloat)

FuncAttrs.addAttribute(

,

);

FuncAttrs.addAttribute(

,

llvm::utostr(CodeGenOpts.SSPBufferSize));

(LangOpts.NoSignedZero)

FuncAttrs.addAttribute(

,

);

std::vector<std::string> &Recips = CodeGenOpts.

;

(!Recips.empty())

FuncAttrs.addAttribute(

,

llvm::join(Recips,

));

FuncAttrs.addAttribute(

,

(CodeGenOpts.StackRealignment)

FuncAttrs.addAttribute(

);

(CodeGenOpts.Backchain)

FuncAttrs.addAttribute(

);

(CodeGenOpts.EnableSegmentedStacks)

FuncAttrs.addAttribute(

);

(CodeGenOpts.SpeculativeLoadHardening)

FuncAttrs.addAttribute(llvm::Attribute::SpeculativeLoadHardening);

(CodeGenOpts.getZeroCallUsedRegs()) {

llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::Skip:

FuncAttrs.removeAttribute(

);

llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::UsedGPRArg:

FuncAttrs.addAttribute(

,

);

llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::UsedGPR:

FuncAttrs.addAttribute(

,

);

llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::UsedArg:

FuncAttrs.addAttribute(

,

);

llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::Used:

FuncAttrs.addAttribute(

,

);

llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::AllGPRArg:

FuncAttrs.addAttribute(

,

);

llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::AllGPR:

FuncAttrs.addAttribute(

,

);

llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::AllArg:

FuncAttrs.addAttribute(

,

);

llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::All:

FuncAttrs.addAttribute(

,

);

FuncAttrs.addAttribute(llvm::Attribute::Convergent);

((LangOpts.CUDA && LangOpts.CUDAIsDevice) || LangOpts.OpenCL ||

LangOpts.SYCLIsDevice) {

FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);

(CodeGenOpts.SaveRegParams && !AttrOnCallSite)

FuncAttrs.addAttribute(

);

StringRef Var,

;

std::tie(Var,

) =

.split(

);

FuncAttrs.addAttribute(Var,

);

llvm::Function &F,

FFeatures = F.getFnAttribute(

);

llvm::StringSet<> MergedNames;

MergedFeatures.reserve(TargetOpts.

.size());

AddUnmergedFeatures = [&](

&&FeatureRange) {

(StringRef Feature : FeatureRange) {

(Feature.empty())

assert(Feature[0] ==

|| Feature[0] ==

);

StringRef Name = Feature.drop_front(1);

Merged = !MergedNames.insert(Name).second;

MergedFeatures.push_back(Feature);

(FFeatures.isValid())

AddUnmergedFeatures(llvm::split(FFeatures.getValueAsString(),

));

AddUnmergedFeatures(TargetOpts.

);

(!MergedFeatures.empty()) {

llvm::sort(MergedFeatures);

FuncAttr.addAttribute(

, llvm::join(MergedFeatures,

));

WillInternalize) {

llvm::AttrBuilder FuncAttrs(F.getContext());

(!TargetOpts.

.empty())

FuncAttrs.addAttribute(

, TargetOpts.

);

(!TargetOpts.

.empty())

FuncAttrs.addAttribute(

, TargetOpts.

);

CodeGenOpts, LangOpts,

(!WillInternalize && F.isInterposable()) {

F.addFnAttrs(FuncAttrs);

llvm::AttributeMask AttrsToRemove;

llvm::DenormalMode DenormModeToMerge = F.getDenormalModeRaw();

llvm::DenormalMode DenormModeToMergeF32 = F.getDenormalModeF32Raw();

llvm::DenormalMode Merged =

(DenormModeToMergeF32.isValid()) {

(Merged == llvm::DenormalMode::getDefault()) {

AttrsToRemove.addAttribute(

);

}

(Merged != DenormModeToMerge) {

FuncAttrs.addAttribute(

,

(MergedF32 == llvm::DenormalMode::getDefault()) {

AttrsToRemove.addAttribute(

);

}

(MergedF32 != DenormModeToMergeF32) {

FuncAttrs.addAttribute(

,

F.removeFnAttrs(AttrsToRemove);

F.addFnAttrs(FuncAttrs);

CodeGenModule::getTrivialDefaultFunctionAttributes(

StringRef Name,

HasOptnone,

AttrOnCallSite,

llvm::AttrBuilder &FuncAttrs) {

::getTrivialDefaultFunctionAttributes(Name, HasOptnone,

(),

CodeGenModule::getDefaultFunctionAttributes(StringRef Name,

AttrOnCallSite,

llvm::AttrBuilder &FuncAttrs) {

getTrivialDefaultFunctionAttributes(Name, HasOptnone, AttrOnCallSite,

(!AttrOnCallSite)

llvm::AttrBuilder &attrs) {

getDefaultFunctionAttributes(

,

,

GetCPUAndFeaturesAttributes(

(), attrs);

NoBuiltinAttr *NBA =

) {

AddNoBuiltinAttr = [&FuncAttrs](StringRef BuiltinName) {

AttributeName +=

;

AttributeName += BuiltinName;

FuncAttrs.addAttribute(AttributeName);

(LangOpts.NoBuiltin) {

FuncAttrs.addAttribute(

);

(llvm::is_contained(NBA->builtinNames(),

)) {

FuncAttrs.addAttribute(

);

llvm::for_each(NBA->builtinNames(), AddNoBuiltinAttr);

llvm::DataLayout &DL,

&AI,

CheckCoerce =

) {

llvm::Type *Ty = Types.ConvertTypeForMem(QTy);

(!DL.typeSizeEqualsStoreSize(Ty))

(llvm::TypeSize::isKnownGT(DL.getTypeSizeInBits(CoerceTy),

DL.getTypeSizeInBits(Ty)))

(

*Matrix = dyn_cast<MatrixType>(QTy))

(

*Array = dyn_cast<ArrayType>(QTy))

NumRequiredArgs,

ArgNo) {

*FD = dyn_cast_or_null<FunctionDecl>(TargetDecl);

(ArgNo >= NumRequiredArgs)

(ArgNo < FD->getNumParams()) {

*Param = FD->getParamDecl(ArgNo);

(Param && Param->

<MaybeUndefAttr>())

(llvm::AttributeFuncs::isNoFPClassCompatibleType(IRTy))

(llvm::StructType *ST = dyn_cast<llvm::StructType>(IRTy)) {

llvm::all_of(ST->elements(), [](llvm::Type *Ty) {

return llvm::AttributeFuncs::isNoFPClassCompatibleType(Ty);

llvm::FPClassTest Mask = llvm::fcNone;

(LangOpts.NoHonorInfs)

Mask |= llvm::fcInf;

(LangOpts.NoHonorNaNs)

Mask |= llvm::fcNan;

llvm::AttributeList &Attrs) {

(Attrs.getMemoryEffects().getModRef() == llvm::ModRefInfo::NoModRef) {

Attrs = Attrs.removeFnAttribute(

(), llvm::Attribute::Memory);

llvm::Attribute MemoryAttr = llvm::Attribute::getWithMemoryEffects(

llvm::AttributeList &AttrList,

AttrOnCallSite,

IsThunk) {

FuncAttrs.addAttribute(llvm::Attribute::NoReturn);

FuncAttrs.addAttribute(

);

HasOptnone =

;

NoBuiltinAttr *NBA =

;

AddPotentialArgAccess = [&]() {

llvm::Attribute A = FuncAttrs.getAttribute(llvm::Attribute::Memory);

FuncAttrs.addMemoryAttr(A.getMemoryEffects() |

llvm::MemoryEffects::argMemOnly());

(TargetDecl->

<ReturnsTwiceAttr>())

FuncAttrs.addAttribute(llvm::Attribute::ReturnsTwice);

(TargetDecl->

<NoThrowAttr>())

FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);

(TargetDecl->

<NoReturnAttr>())

FuncAttrs.addAttribute(llvm::Attribute::NoReturn);

(TargetDecl->

<ColdAttr>())

FuncAttrs.addAttribute(llvm::Attribute::Cold);

(TargetDecl->

<HotAttr>())

FuncAttrs.addAttribute(llvm::Attribute::Hot);

(TargetDecl->

<NoDuplicateAttr>())

FuncAttrs.addAttribute(llvm::Attribute::NoDuplicate);

(TargetDecl->

<ConvergentAttr>())

FuncAttrs.addAttribute(llvm::Attribute::Convergent);

(

*Fn = dyn_cast<FunctionDecl>(TargetDecl)) {

(AttrOnCallSite && Fn->isReplaceableGlobalAllocationFunction()) {

Kind = Fn->getDeclName().getCXXOverloadedOperator();

(Kind == OO_New || Kind == OO_Array_New))

RetAttrs.addAttribute(llvm::Attribute::NoAlias);

IsVirtualCall = MD && MD->

();

(!(AttrOnCallSite && IsVirtualCall)) {

(Fn->isNoReturn())

FuncAttrs.addAttribute(llvm::Attribute::NoReturn);

NBA = Fn->getAttr<NoBuiltinAttr>();

(isa<FunctionDecl>(TargetDecl) || isa<VarDecl>(TargetDecl)) {

(AttrOnCallSite && TargetDecl->

<NoMergeAttr>())

FuncAttrs.addAttribute(llvm::Attribute::NoMerge);

(TargetDecl->

<ConstAttr>()) {

FuncAttrs.addMemoryAttr(llvm::MemoryEffects::none());

FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);

FuncAttrs.addAttribute(llvm::Attribute::WillReturn);

}

(TargetDecl->

<PureAttr>()) {

FuncAttrs.addMemoryAttr(llvm::MemoryEffects::readOnly());

FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);

FuncAttrs.addAttribute(llvm::Attribute::WillReturn);

}

(TargetDecl->

<NoAliasAttr>()) {

FuncAttrs.addMemoryAttr(llvm::MemoryEffects::inaccessibleOrArgMemOnly());

FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);

(TargetDecl->

<RestrictAttr>())

RetAttrs.addAttribute(llvm::Attribute::NoAlias);

(TargetDecl->

<ReturnsNonNullAttr>() &&

!CodeGenOpts.NullPointerIsValid)

RetAttrs.addAttribute(llvm::Attribute::NonNull);

(TargetDecl->

<AnyX86NoCallerSavedRegistersAttr>())

FuncAttrs.addAttribute(

);

(TargetDecl->

<AnyX86NoCfCheckAttr>())

FuncAttrs.addAttribute(llvm::Attribute::NoCfCheck);

(TargetDecl->

<LeafAttr>())

FuncAttrs.addAttribute(llvm::Attribute::NoCallback);

(TargetDecl->

<BPFFastCallAttr>())

FuncAttrs.addAttribute(

);

HasOptnone = TargetDecl->

<OptimizeNoneAttr>();

(

*AllocSize = TargetDecl->

<AllocSizeAttr>()) {

std::optional<unsigned> NumElemsParam;

(AllocSize->getNumElemsParam().isValid())

NumElemsParam = AllocSize->getNumElemsParam().getLLVMIndex();

FuncAttrs.addAllocSizeAttr(AllocSize->getElemSizeParam().getLLVMIndex(),

(TargetDecl->

<OpenCLKernelAttr>()) {

FuncAttrs.addAttribute(

,

);

FuncAttrs.addAttribute(

,

llvm::toStringRef(

().OffloadUniformBlock));

(TargetDecl->

<CUDAGlobalAttr>() &&

FuncAttrs.addAttribute(

,

);

(TargetDecl->

<ArmLocallyStreamingAttr>())

FuncAttrs.addAttribute(

);

getDefaultFunctionAttributes(Name, HasOptnone, AttrOnCallSite, FuncAttrs);

(TargetDecl->

<NoSpeculativeLoadHardeningAttr>())

FuncAttrs.removeAttribute(llvm::Attribute::SpeculativeLoadHardening);

(TargetDecl->

<SpeculativeLoadHardeningAttr>())

FuncAttrs.addAttribute(llvm::Attribute::SpeculativeLoadHardening);

(TargetDecl->

<NoSplitStackAttr>())

FuncAttrs.removeAttribute(

);

(TargetDecl->

<ZeroCallUsedRegsAttr>()) {

TargetDecl->

<ZeroCallUsedRegsAttr>()->getZeroCallUsedRegs();

FuncAttrs.removeAttribute(

);

FuncAttrs.addAttribute(

,

ZeroCallUsedRegsAttr::ConvertZeroCallUsedRegsKindToStr(Kind));

(CodeGenOpts.NoPLT) {

(

*Fn = dyn_cast<FunctionDecl>(TargetDecl)) {

(!Fn->isDefined() && !AttrOnCallSite) {

FuncAttrs.addAttribute(llvm::Attribute::NonLazyBind);

(TargetDecl->

<NoConvergentAttr>())

FuncAttrs.removeAttribute(llvm::Attribute::Convergent);

(TargetDecl && CodeGenOpts.UniqueInternalLinkageNames) {

(

*FD = dyn_cast_or_null<FunctionDecl>(TargetDecl)) {

(!FD->isExternallyVisible())

FuncAttrs.addAttribute(

,

(!AttrOnCallSite) {

(TargetDecl && TargetDecl->

<CmseNSEntryAttr>())

FuncAttrs.addAttribute(

);

shouldDisableTailCalls = [&] {

(CodeGenOpts.DisableTailCalls)

(TargetDecl->

<DisableTailCallsAttr>() ||

TargetDecl->

<AnyX86InterruptAttr>())

(CodeGenOpts.NoEscapingBlockTailCalls) {

(

*BD = dyn_cast<BlockDecl>(TargetDecl))

(!BD->doesNotEscape())

(shouldDisableTailCalls())

FuncAttrs.addAttribute(

,

);

GetCPUAndFeaturesAttributes(CalleeInfo.

(), FuncAttrs);

ClangToLLVMArgMapping IRFunctionArgs(

(), FI);

(CodeGenOpts.EnableNoundefAttrs &&

RetAttrs.addAttribute(llvm::Attribute::NoUndef);

RetAttrs.addAttribute(llvm::Attribute::SExt);

RetAttrs.addAttribute(llvm::Attribute::ZExt);

RetAttrs.addAttribute(llvm::Attribute::NoExt);

RetAttrs.addAttribute(llvm::Attribute::InReg);

AddPotentialArgAccess();

llvm_unreachable(

);

RetAttrs.addDereferenceableAttr(

(

().getTargetAddressSpace(PTy) == 0 &&

!CodeGenOpts.NullPointerIsValid)

RetAttrs.addAttribute(llvm::Attribute::NonNull);

llvm::Align Alignment =

RetAttrs.addAlignmentAttr(Alignment);

hasUsedSRet =

;

(IRFunctionArgs.hasSRetArg()) {

SRETAttrs.addStructRetAttr(

().ConvertTypeForMem(RetTy));

SRETAttrs.addAttribute(llvm::Attribute::Writable);

SRETAttrs.addAttribute(llvm::Attribute::DeadOnUnwind);

hasUsedSRet =

;

SRETAttrs.addAttribute(llvm::Attribute::InReg);

ArgAttrs[IRFunctionArgs.getSRetArgNo()] =

(IRFunctionArgs.hasInallocaArg()) {

ArgAttrs[IRFunctionArgs.getInallocaArgNo()] =

!FI.

()->

->isVoidPointerType() && !IsThunk) {

IRArgs = IRFunctionArgs.getIRArgs(0);

assert(IRArgs.second == 1 &&

);

(!CodeGenOpts.NullPointerIsValid &&

Attrs.addAttribute(llvm::Attribute::NonNull);

Attrs.addDereferenceableOrNullAttr(

llvm::Align Alignment =

Attrs.addAlignmentAttr(Alignment);

ArgAttrs[IRArgs.first] = llvm::AttributeSet::get(

(), Attrs);

I !=

; ++I, ++ArgNo) {

(IRFunctionArgs.hasPaddingArg(ArgNo)) {

ArgAttrs[IRFunctionArgs.getPaddingArgNo(ArgNo)] =

llvm::AttributeSet::get(

llvm::AttrBuilder(

()).addAttribute(llvm::Attribute::InReg));

(CodeGenOpts.EnableNoundefAttrs &&

Attrs.addAttribute(llvm::Attribute::NoUndef);

Attrs.addAttribute(llvm::Attribute::SExt);

Attrs.addAttribute(llvm::Attribute::ZExt);

Attrs.addAttribute(llvm::Attribute::NoExt);

Attrs.addAttribute(llvm::Attribute::Nest);

Attrs.addAttribute(llvm::Attribute::InReg);

Attrs.addStackAlignmentAttr(llvm::MaybeAlign(AI.

()));

Attrs.addAttribute(llvm::Attribute::InReg);

Attrs.addByValAttr(

().ConvertTypeForMem(ParamType));

(CodeGenOpts.PassByValueIsNoAlias &&

&&

->getArgPassingRestrictions() ==

Attrs.addAttribute(llvm::Attribute::NoAlias);

assert(!Align.

());

AddPotentialArgAccess();

Attrs.addByRefAttr(

().ConvertTypeForMem(ParamType));

AddPotentialArgAccess();

Attrs.addDereferenceableAttr(

(

().getTargetAddressSpace(PTy) == 0 &&

!CodeGenOpts.NullPointerIsValid)

Attrs.addAttribute(llvm::Attribute::NonNull);

llvm::Align Alignment =

Attrs.addAlignmentAttr(Alignment);

(TargetDecl && TargetDecl->

<OpenCLKernelAttr>() &&

llvm::Align Alignment =

Attrs.addAlignmentAttr(Alignment);

Attrs.addAttribute(llvm::Attribute::NoAlias);

Attrs.addStructRetAttr(

().ConvertTypeForMem(ParamType));

hasUsedSRet =

;

Attrs.addAttribute(llvm::Attribute::NoAlias);

(!PTy->isIncompleteType() && PTy->isConstantSizeType()) {

Attrs.addDereferenceableAttr(info.Width.getQuantity());

Attrs.addAlignmentAttr(info.Align.getAsAlign());

Attrs.addAttribute(llvm::Attribute::SwiftError);

Attrs.addAttribute(llvm::Attribute::SwiftSelf);

Attrs.addAttribute(llvm::Attribute::SwiftAsync);

Attrs.addCapturesAttr(llvm::CaptureInfo::none());

(Attrs.hasAttributes()) {

FirstIRArg, NumIRArgs;

std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);

(

i = 0; i < NumIRArgs; i++)

ArgAttrs[FirstIRArg + i] = ArgAttrs[FirstIRArg + i].addAttributes(

AttrList = llvm::AttributeList::get(

llvm::AttributeSet::get(

(), RetAttrs), ArgAttrs);

llvm::Value *value) {

llvm::Type *varType = CGF.

(var->getType());

(value->getType() == varType)

value;

assert((varType->isIntegerTy() || varType->isFloatingPointTy())

&&

);

(isa<llvm::IntegerType>(varType))

CGF.

.CreateTrunc(value, varType,

);

CGF.

.CreateFPCast(value, varType,

);

ArgType,

ArgNo) {

(

ParmNNAttr = PVD->

<NonNullAttr>())

(

*NNAttr : FD->

<NonNullAttr>()) {

(NNAttr->isNonNull(ArgNo))

(FD->hasImplicitReturnZero()) {

RetTy = FD->getReturnType().getUnqualifiedType();

llvm::Constant*

= llvm::Constant::getNullValue(LLVMTy);

ClangToLLVMArgMapping IRFunctionArgs(

.

(), FI);

assert(

->arg_size() == IRFunctionArgs.totalIRArgs());

(IRFunctionArgs.hasInallocaArg())

ArgStruct =

(

->getArg(IRFunctionArgs.getInallocaArgNo()),

(IRFunctionArgs.hasSRetArg()) {

AI =

->getArg(IRFunctionArgs.getSRetArgNo());

AI->setName(

);

AI->addAttr(llvm::Attribute::NoAlias);

ArgVals.reserve(Args.size());

assert(FI.

() == Args.size() &&

);

(FunctionArgList::const_iterator i = Args.begin(), e = Args.end();

i != e; ++i, ++info_it, ++ArgNo) {

isa<ParmVarDecl>(Arg) && cast<ParmVarDecl>(Arg)->isKNRPromoted();

FirstIRArg, NumIRArgs;

std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);

assert(NumIRArgs == 0);

assert(NumIRArgs == 1);

llvm::ConstantInt::get(

,

.getQuantity()));

ParamAddr = AlignedTemp;

AI =

->getArg(FirstIRArg);

assert(NumIRArgs == 1);

(

*PVD = dyn_cast<ParmVarDecl>(Arg)) {

PVD->getFunctionScopeIndex()) &&

AI->addAttr(llvm::Attribute::NonNull);

OTy = PVD->getOriginalType();

(

*ArrTy =

ETy = ArrTy->getElementType();

llvm::Align Alignment =

AI->addAttrs(llvm::AttrBuilder(

()).addAlignmentAttr(Alignment));

ArrSize = ArrTy->getZExtSize();

Attrs.addDereferenceableAttr(

().getTypeSizeInChars(ETy).getQuantity() *

AI->addAttrs(Attrs);

}

(

().getTargetInfo().getNullPointerValue(

AI->addAttr(llvm::Attribute::NonNull);

}

(

*ArrTy =

ETy = ArrTy->getElementType();

llvm::Align Alignment =

AI->addAttrs(llvm::AttrBuilder(

()).addAlignmentAttr(Alignment));

(!

().getTargetAddressSpace(ETy) &&

AI->addAttr(llvm::Attribute::NonNull);

*AVAttr = PVD->getAttr<AlignValueAttr>();

AVAttr = TOTy->getDecl()->getAttr<AlignValueAttr>();

(AVAttr && !

.

(SanitizerKind::Alignment)) {

llvm::ConstantInt *AlignmentCI =

cast<llvm::ConstantInt>(

(AVAttr->getAlignment()));

AlignmentCI->getLimitedValue(llvm::Value::MaximumAlignment);

(AI->getParamAlign().valueOrOne() < AlignmentInt) {

AI->removeAttr(llvm::Attribute::AttrKind::Alignment);

AI->addAttrs(llvm::AttrBuilder(

()).addAlignmentAttr(

llvm::Align(AlignmentInt)));

AI->addAttr(llvm::Attribute::NoAlias);

assert(NumIRArgs == 1);

llvm::Value *

= AI;

, pointeeTy,

().getTypeAlignInChars(pointeeTy));

(

->getType() != LTy)

(

*VecTyTo = dyn_cast<llvm::FixedVectorType>(

(Ty))) {

llvm::Value *ArgVal =

->getArg(FirstIRArg);

(

*VecTyFrom =

dyn_cast<llvm::ScalableVectorType>(ArgVal->getType())) {

*

, VecTyTo, VecTyFrom, ArgVal, Arg->

());

assert(NumIRArgs == 1);

llvm::StructType *STy =

STy->getNumElements() > 1) {

llvm::TypeSize PtrElementSize =

(StructSize.isScalable()) {

assert(STy->containsHomogeneousScalableVectorTypes() &&

assert(StructSize == PtrElementSize &&

);

assert(STy->getNumElements() == NumIRArgs);

llvm::Value *LoadedStructValue = llvm::PoisonValue::get(STy);

(

i = 0, e = STy->getNumElements(); i != e; ++i) {

*AI =

->getArg(FirstIRArg + i);

AI->setName(Arg->

() +

+ Twine(i));

.CreateInsertValue(LoadedStructValue, AI, i);

SrcSize = StructSize.getFixedValue();

DstSize = PtrElementSize.getFixedValue();

(SrcSize <= DstSize) {

assert(STy->getNumElements() == NumIRArgs);

(

i = 0, e = STy->getNumElements(); i != e; ++i) {

AI =

->getArg(FirstIRArg + i);

AI->setName(Arg->

() +

+ Twine(i));

(SrcSize > DstSize) {

assert(NumIRArgs == 1);

AI =

->getArg(FirstIRArg);

AI->setName(Arg->

() +

);

llvm::TypeSize::getFixed(

().getTypeSizeInChars(Ty).getQuantity() -

*unpaddedStruct = dyn_cast<llvm::StructType>(unpaddedCoercionType);

argIndex = FirstIRArg;

unpaddedIndex = 0;

(

i = 0, e = coercionType->getNumElements(); i != e; ++i) {

llvm::Type *eltType = coercionType->getElementType(i);

llvm::Value *elt =

->getArg(argIndex++);

paramType = unpaddedStruct

? unpaddedStruct->getElementType(unpaddedIndex++)

: unpaddedCoercionType;

(

*VecTyTo = dyn_cast<llvm::FixedVectorType>(eltType)) {

(

*VecTyFrom = dyn_cast<llvm::ScalableVectorType>(paramType)) {

*

, VecTyTo, VecTyFrom, elt, elt->getName());

assert(Extracted &&

);

assert(argIndex == FirstIRArg + NumIRArgs);

FnArgIter =

->arg_begin() + FirstIRArg;

ExpandTypeFromArgs(Ty, LV, FnArgIter);

assert(FnArgIter ==

->arg_begin() + FirstIRArg + NumIRArgs);

(

i = 0, e = NumIRArgs; i != e; ++i) {

AI =

->getArg(FirstIRArg + i);

AI->setName(Arg->

() +

+ Twine(i));

assert(NumIRArgs == 0);

(

().getCXXABI().areArgsDestroyedLeftToRightInCallee()) {

(

I = Args.size() - 1; I >= 0; --I)

(

I = 0,

= Args.size(); I !=

; ++I)

(insn->use_empty()) {

llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(insn);

(!bitcast)

;

insn = cast<llvm::Instruction>(bitcast->getOperand(0));

bitcast->eraseFromParent();

llvm::Value *result) {

llvm::BasicBlock *BB = CGF.

.GetInsertBlock();

(BB->empty())

;

(&BB->back() != result)

;

llvm::Type *resultType = result->getType();

llvm::Instruction *generator = cast<llvm::Instruction>(result);

(llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(generator)) {

generator = cast<llvm::Instruction>(bitcast->getOperand(0));

(generator->getNextNode() != bitcast)

InstsToKill.push_back(bitcast);

llvm::CallInst *call = dyn_cast<llvm::CallInst>(generator);

(!call)

;

doRetainAutorelease;

doRetainAutorelease =

;

}

(call->getCalledOperand() ==

doRetainAutorelease =

;

llvm::Instruction *prev = call->getPrevNode();

(isa<llvm::BitCastInst>(prev)) {

prev = prev->getPrevNode();

assert(isa<llvm::CallInst>(prev));

assert(cast<llvm::CallInst>(prev)->getCalledOperand() ==

InstsToKill.push_back(prev);

result = call->getArgOperand(0);

InstsToKill.push_back(call);

(llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(result)) {

(!bitcast->hasOneUse())

;

InstsToKill.push_back(bitcast);

result = bitcast->getOperand(0);

(

*I : InstsToKill)

I->eraseFromParent();

(doRetainAutorelease)

CGF.

.CreateBitCast(result, resultType);

llvm::Value *result) {

dyn_cast_or_null<ObjCMethodDecl>(CGF.

);

(!method)

;

llvm::CallInst *retainCall = dyn_cast<llvm::CallInst>(result);

(!retainCall || retainCall->getCalledOperand() !=

llvm::Value *retainedValue = retainCall->getArgOperand(0);

llvm::LoadInst *load =

dyn_cast<llvm::LoadInst>(retainedValue->stripPointerCasts());

(!load || load->isAtomic() || load->isVolatile() ||

llvm::Type *resultType = result->getType();

assert(retainCall->use_empty());

retainCall->eraseFromParent();

CGF.

.CreateBitCast(load, resultType);

llvm::Value *result) {

GetStoreIfValid = [&CGF,

ReturnValuePtr](llvm::User *

) -> llvm::StoreInst * {

*SI = dyn_cast<llvm::StoreInst>(

);

(!SI || SI->getPointerOperand() != ReturnValuePtr ||

assert(!SI->isAtomic() &&

(!ReturnValuePtr->hasOneUse()) {

llvm::BasicBlock *IP = CGF.

.GetInsertBlock();

(IP->empty())

;

llvm::Instruction *LoadIntoFakeUse =

;

(llvm::Instruction &I : make_range(IP->rbegin(), IP->rend())) {

(LoadIntoFakeUse == &I)

(isa<llvm::BitCastInst>(&I))

(

*II = dyn_cast<llvm::IntrinsicInst>(&I)) {

(II->getIntrinsicID() == llvm::Intrinsic::lifetime_end)

(II->getIntrinsicID() == llvm::Intrinsic::fake_use) {

LoadIntoFakeUse = dyn_cast<llvm::Instruction>(II->getArgOperand(0));

GetStoreIfValid(&I);

llvm::StoreInst *store = GetStoreIfValid(ReturnValuePtr->user_back());

(!store)

;

llvm::BasicBlock *StoreBB = store->getParent();

llvm::BasicBlock *IP = CGF.

.GetInsertBlock();

(IP != StoreBB) {

(!SeenBBs.insert(IP).second || !(IP = IP->getSinglePredecessor()))

BitWidth,

CharWidth) {

assert(CharWidth <= 64);

assert(

(BitWidth) <= Bits.size() * CharWidth);

(BitOffset >= CharWidth) {

Pos += BitOffset / CharWidth;

BitOffset = BitOffset % CharWidth;

uint64_t

= (uint64_t(1) << CharWidth) - 1;

(BitOffset + BitWidth >= CharWidth) {

Bits[Pos++] |= (

<< BitOffset) &

;

BitWidth -= CharWidth - BitOffset;

(BitWidth >= CharWidth) {

Bits[Pos++] =

;

BitWidth -= CharWidth;

Bits[Pos++] |= (

>> (CharWidth - BitWidth)) << BitOffset;

StorageSize,

BitOffset,

BitWidth,

CharWidth,

BigEndian) {

(TmpBits, BitOffset, BitWidth, CharWidth);

std::reverse(TmpBits.begin(), TmpBits.end());

(uint64_t

: TmpBits)

Bits[StorageOffset++] |=

;

BFI.

, CharWidth,

Src = TmpBits.begin();

Dst = Bits.begin() + Offset + I * Size;

(

J = 0; J < Size; ++J)

std::fill_n(Bits.begin() + Offset, Size,

Pos,

Size,

CharWidth,

(

= Bits.begin() + Pos,

= Bits.begin() + Pos + Size;

!=

;

Mask = (Mask << CharWidth) | *

;

= Bits.begin() + Pos + Size, End = Bits.begin() + Pos;

Mask = (Mask << CharWidth) | *--

;

llvm::IntegerType *ITy,

assert(Src->getType() == ITy);

assert(ITy->getScalarSizeInBits() <= 64);

= DataLayout.getTypeStoreSize(ITy);

.CreateAnd(Src, Mask,

);

llvm::ArrayType *ATy,

= DataLayout.getTypeStoreSize(ATy);

ATy->getArrayElementType()->getScalarSizeInBits() / CharWidth;

llvm::Value *R = llvm::PoisonValue::get(ATy);

(

I = 0, N = ATy->getArrayNumElements(); I != N; ++I) {

DataLayout.isBigEndian());

MaskIndex += CharsPerElt;

llvm::Value *T0 =

.CreateExtractValue(Src, I);

llvm::Value *T1 =

.CreateAnd(T0, Mask,

);

R =

.CreateInsertValue(R, T1, I);

llvm::DebugLoc RetDbgLoc;

llvm::Value *RV =

;

llvm::Function::arg_iterator EI =

->arg_end();

llvm::Value *ArgStruct = &*EI;

cast<llvm::GetElementPtrInst>(SRet)->getResultElementType();

AI =

->arg_begin();

(llvm::StoreInst *SI =

RetDbgLoc = SI->getDebugLoc();

RV = SI->getValueOperand();

SI->eraseFromParent();

(

*FD = dyn_cast<FunctionDecl>(

))

RT = FD->getReturnType();

(

*MD = dyn_cast<ObjCMethodDecl>(

))

RT = MD->getReturnType();

llvm_unreachable(

);

*unpaddedStruct = dyn_cast<llvm::StructType>(unpaddedCoercionType);

unpaddedIndex = 0;

(

i = 0, e = coercionType->getNumElements(); i != e; ++i) {

coercedEltType = coercionType->getElementType(i);

unpaddedStruct ? unpaddedStruct->getElementType(unpaddedIndex++)

: unpaddedCoercionType,

results.push_back(elt);

(results.size() == 1) {

RV = llvm::PoisonValue::get(returnType);

(

i = 0, e = results.size(); i != e; ++i) {

RV =

.CreateInsertValue(RV, results[i], i);

llvm_unreachable(

);

llvm::Instruction *

;

*ITy = dyn_cast<llvm::IntegerType>(RV->getType());

->setDebugLoc(std::move(RetDbgLoc));

ReturnsNonNullAttr *RetNNAttr =

;

(

.

(SanitizerKind::ReturnsNonnullAttribute))

(!RetNNAttr && !requiresReturnValueNullabilityCheck())

assert(!requiresReturnValueNullabilityCheck() &&

);

AttrLoc = RetNNAttr->getLocation();

CheckKind = SanitizerKind::SO_ReturnsNonnullAttribute;

Handler = SanitizerHandler::NonnullReturn;

(

*DD = dyn_cast<DeclaratorDecl>(

))

(

*TSI = DD->getTypeSourceInfo())

AttrLoc = FTL.getReturnLoc().findNullabilityLoc();

CheckKind = SanitizerKind::SO_NullabilityReturn;

Handler = SanitizerHandler::NullabilityReturn;

SanitizerScope SanScope(

);

llvm::Value *SLocPtr =

.

(ReturnLocation,

);

llvm::Value *CanNullCheck =

.CreateIsNotNull(SLocPtr);

(requiresReturnValueNullabilityCheck())

.CreateAnd(CanNullCheck, RetValNullabilityPrecondition);

.CreateCondBr(CanNullCheck, Check, NoCheck);

llvm::Value *Cond =

.CreateIsNotNull(RV);

llvm::Value *DynamicData[] = {SLocPtr};

(std::make_pair(Cond, CheckKind), Handler, StaticData, DynamicData);

llvm::Type *IRPtrTy = llvm::PointerType::getUnqual(CGF.

());

llvm::Value *Placeholder = llvm::PoisonValue::get(IRPtrTy);

(

->isReferenceType()) {

param->

<NSConsumedAttr>() &&

->isObjCRetainableType()) {

llvm::ConstantPointerNull::get(cast<llvm::PointerType>(ptr->getType()));

CalleeDestructedParamCleanups.lookup(cast<ParmVarDecl>(param));

);

llvm::Instruction *isActive =

.CreateUnreachable();

llvm::isa_and_nonnull<llvm::ConstantPointerNull>(addr);

);

llvm::BasicBlock *contBB =

;

(!provablyNonNull) {

CGF.

.CreateCondBr(isNull, contBB, writebackBB);

);

(writeback.

) {

(!provablyNonNull)

(

&I : llvm::reverse(Cleanups)) {

I.IsActiveIP->eraseFromParent();

(uop->getOpcode() == UO_AddrOf)

uop->getSubExpr();

llvm::PointerType *destType =

llvm::Type *destElemType =

args.

(

(llvm::ConstantPointerNull::get(destType)),

CodeGenFunction::ConditionalEvaluation condEval(CGF);

llvm::ConstantPointerNull::get(cast<llvm::PointerType>(destElemType));

llvm::BasicBlock *contBB =

;

llvm::BasicBlock *originBB =

;

llvm::Value *finalArgument;

(provablyNonNull) {

finalArgument = CGF.

.CreateSelect(

isNull, llvm::ConstantPointerNull::get(destType),

originBB = CGF.

.GetInsertBlock();

CGF.

.CreateCondBr(isNull, contBB, copyBB);

condEval.begin(CGF);

llvm::Value *valueToUse =

;

src = CGF.

.CreateBitCast(src, destElemType,

);

(shouldCopy && !provablyNonNull) {

llvm::BasicBlock *copyBB = CGF.

.GetInsertBlock();

llvm::PHINode *phiToUse = CGF.

.CreatePHI(valueToUse->getType(), 2,

phiToUse->addIncoming(valueToUse, copyBB);

phiToUse->addIncoming(llvm::PoisonValue::get(valueToUse->getType()),

valueToUse = phiToUse;

StackBase = CGF.

.CreateStackSave(

);

CGF.

.CreateStackRestore(StackBase);

(!AC.getDecl() || !(

.

(SanitizerKind::NonnullAttribute) ||

.

(SanitizerKind::NullabilityArg)))

PVD = ParmNum < AC.getNumParams() ? AC.getParamDecl(ParmNum) :

;

ArgNo = PVD ? PVD->getFunctionScopeIndex() : ParmNum;

NonNullAttr *NNAttr =

;

(

.

(SanitizerKind::NonnullAttribute))

CanCheckNullability =

;

(

.

(SanitizerKind::NullabilityArg) && !NNAttr && PVD &&

!PVD->getType()->isRecordType()) {

Nullability = PVD->getType()->getNullability();

CanCheckNullability = Nullability &&

PVD->getTypeSourceInfo();

(!NNAttr && !CanCheckNullability)

AttrLoc = NNAttr->getLocation();

CheckKind = SanitizerKind::SO_NonnullAttribute;

Handler = SanitizerHandler::NonnullArg;

AttrLoc = PVD->getTypeSourceInfo()->getTypeLoc().findNullabilityLoc();

CheckKind = SanitizerKind::SO_NullabilityArg;

Handler = SanitizerHandler::NullabilityArg;

SanitizerScope SanScope(

);

llvm::Constant *StaticData[] = {

llvm::ConstantInt::get(

, ArgNo + 1),

(std::make_pair(Cond, CheckKind), Handler, StaticData, {});

AbstractCallee AC,

ParmNum) {

(!AC.getDecl() || !(

.

(SanitizerKind::NonnullAttribute) ||

.

(SanitizerKind::NullabilityArg)))

llvm::any_of(ArgTypes, [&](

Ty) {

classDecl->getTypeParamListAsWritten();

catDecl->getTypeParamList();

llvm::iterator_range<CallExpr::const_arg_iterator> ArgRange,

AbstractCallee AC,

ParamsToSkip, EvaluationOrder Order) {

assert((ParamsToSkip == 0 ||

.P) &&

);

IsVariadic =

;

*MD = dyn_cast<const ObjCMethodDecl *>(

.P);

IsVariadic = MD->isVariadic();

ArgTypes.assign(MD->param_type_begin() + ParamsToSkip,

MD->param_type_end());

*FPT = cast<const FunctionProtoType *>(

.P);

IsVariadic = FPT->isVariadic();

ExplicitCC = FPT->getExtInfo().getCC();

ArgTypes.assign(FPT->param_type_begin() + ParamsToSkip,

FPT->param_type_end());

assert(Arg != ArgRange.end() &&

);

(isGenericMethod || Ty->isVariablyModifiedType() ||

Ty.getNonReferenceType()->isObjCRetainableType() ||

.getCanonicalType(Ty.getNonReferenceType())

().getCanonicalType((*Arg)->getType()).getTypePtr()) &&

);

assert((Arg == ArgRange.end() || IsVariadic) &&

);

(

*A : llvm::drop_begin(ArgRange, ArgTypes.size()))

ArgTypes.push_back(IsVariadic ? getVarArgType(A) : A->getType());

assert((

)ArgTypes.size() == (ArgRange.end() - ArgRange.begin()));

MaybeEmitImplicitObjectSize = [&](

I,

*Arg,

(!AC.hasFunctionDecl() || I >= AC.getNumParams())

*PS = AC.getParamDecl(I)->getAttr<PassObjectSizeAttr>();

assert(EmittedArg.getScalarVal() &&

);

llvm::Value *

= evaluateOrEmitBuiltinObjectSize(Arg, PS->getType(),

,

EmittedArg.getScalarVal(),

std::swap(Args.back(), *(&Args.back() - 1));

assert(

().getTriple().getArch() == llvm::Triple::x86 &&

);

CallArgsStart = Args.size();

(

I = 0,

= ArgTypes.size(); I !=

; ++I) {

Idx = LeftToRight ? I :

- I - 1;

InitialArgSize = Args.size();

assert((!isa<ObjCIndirectCopyRestoreExpr>(*Arg) ||

().hasSameUnqualifiedType((*Arg)->getType(),

(isa<ObjCMethodDecl>(AC.getDecl()) &&

);

assert(InitialArgSize + 1 == Args.size() &&

);

(void)InitialArgSize;

(!Args.back().hasLValue()) {

RVArg = Args.back().getKnownRValue();

ParamsToSkip + Idx);

MaybeEmitImplicitObjectSize(Idx, *Arg, RVArg);

std::reverse(Args.begin() + CallArgsStart, Args.end());

: Addr(Addr), Ty(Ty) {}

DisableDebugLocationUpdates {

disabledDebugInfo;

((disabledDebugInfo = isa<CXXDefaultArgExpr>(

) && CGF.

()))

~DisableDebugLocationUpdates() {

(disabledDebugInfo)

DisableDebugLocationUpdates Dis(*

,

);

= dyn_cast<ObjCIndirectCopyRestoreExpr>(

)) {

);

(

->isRecordType() &&

DestroyedInCallee =

, NeedsCleanup =

;

(

*RD =

->getAsCXXRecordDecl())

DestroyedInCallee = RD->hasNonTrivialDestructor();

NeedsCleanup =

.isDestructedType();

(DestroyedInCallee)

(DestroyedInCallee && NeedsCleanup) {

llvm::Instruction *IsActive =

(HasAggregateEvalKind && isa<ImplicitCastExpr>(

) &&

cast<CastExpr>(

)->getCastKind() == CK_LValueToRValue &&

!

->isArrayParameterType()) {

CodeGenFunction::getVarArgType(

*Arg) {

(!

().getTriple().isOSWindows())

CodeGenFunction::AddObjCARCExceptionMetadata(llvm::Instruction *Inst) {

Inst->setMetadata(

,

llvm::Twine &name) {

llvm::Twine &name) {

(

arg : args)

values.push_back(

.emitRawPointer(*

));

llvm::Twine &name) {

call->setDoesNotThrow();

llvm::Twine &name) {

(

*CalleeFn = dyn_cast<llvm::Function>(

->stripPointerCasts())) {

(CalleeFn->isIntrinsic() && CalleeFn->doesNotThrow()) {

IID = CalleeFn->getIntrinsicID();

(!llvm::IntrinsicInst::mayLowerToFunctionCall(IID))

llvm::Twine &name) {

llvm::CallInst *call =

.CreateCall(

cast<llvm::CallInst>(addConvergenceControlToken(call));

llvm::InvokeInst *invoke =

invoke->setDoesNotReturn();

llvm::CallInst *call =

.CreateCall(callee, args, BundleList);

call->setDoesNotReturn();

Twine &name) {

Twine &name) {

Twine &Name) {

llvm::CallBase *Inst;

Inst =

.CreateCall(Callee, Args, BundleList, Name);

Inst =

.CreateInvoke(Callee, ContBB, InvokeDest, Args, BundleList,

AddObjCARCExceptionMetadata(Inst);

CodeGenFunction::deferPlaceholderReplacement(llvm::Instruction *Old,

DeferredReplacements.push_back(

std::make_pair(llvm::WeakTrackingVH(Old), New));

[[nodiscard]] llvm::AttributeList

maybeRaiseRetAlignmentAttribute(llvm::LLVMContext &Ctx,

llvm::AttributeList &Attrs,

llvm::Align NewAlign) {

llvm::Align CurAlign = Attrs.getRetAlignment().valueOrOne();

(CurAlign >= NewAlign)

llvm::Attribute AlignAttr = llvm::Attribute::getWithAlignment(Ctx, NewAlign);

Attrs.removeRetAttribute(Ctx, llvm::Attribute::AttrKind::Alignment)

.addRetAttribute(Ctx, AlignAttr);

<

AlignedAttrTy>

AbstractAssumeAlignedAttrEmitter {

AlignedAttrTy *AA =

;

llvm::Value *Alignment =

;

llvm::ConstantInt *OffsetCI =

;

AA = FuncDecl->

<AlignedAttrTy>();

[[nodiscard]] llvm::AttributeList

TryEmitAsCallSiteAttribute(

llvm::AttributeList &Attrs) {

(!AA || OffsetCI || CGF.

.

(SanitizerKind::Alignment))

*AlignmentCI = dyn_cast<llvm::ConstantInt>(Alignment);

(!AlignmentCI->getValue().isPowerOf2())

llvm::AttributeList NewAttrs = maybeRaiseRetAlignmentAttribute(

AlignmentCI->getLimitedValue(llvm::Value::MaximumAlignment)));

AA->getLocation(), Alignment, OffsetCI);

AssumeAlignedAttrEmitter final

:

AbstractAssumeAlignedAttrEmitter<AssumeAlignedAttr> {

: AbstractAssumeAlignedAttrEmitter(CGF_, FuncDecl) {

Alignment = cast<llvm::ConstantInt>(CGF.

(AA->getAlignment()));

(

*Offset = AA->getOffset()) {

OffsetCI = cast<llvm::ConstantInt>(CGF.

(Offset));

(OffsetCI->isNullValue())

OffsetCI =

;

AllocAlignAttrEmitter final

:

AbstractAssumeAlignedAttrEmitter<AllocAlignAttr> {

: AbstractAssumeAlignedAttrEmitter(CGF_, FuncDecl) {

Alignment = CallArgs[AA->getParamIndex().getLLVMIndex()]

(

*VT = dyn_cast<llvm::VectorType>(Ty))

VT->getPrimitiveSizeInBits().getKnownMinValue();

(

*AT = dyn_cast<llvm::ArrayType>(Ty))

MaxVectorWidth = 0;

(

*ST = dyn_cast<llvm::StructType>(Ty))

(

*I : ST->elements())

MaxVectorWidth;

llvm::CallBase **callOrInvoke,

IsMustTail,

IsVirtualFunctionPointerThunk) {

*TargetDecl =

.getAbstractInfo().getCalleeDecl().getDecl();

(

*FD = dyn_cast_or_null<FunctionDecl>(TargetDecl)) {

(TargetDecl->

<AlwaysInlineAttr>() &&

(TargetDecl->

<TargetAttr>() ||

*CalleeDecl = dyn_cast_or_null<FunctionDecl>(TargetDecl);

CalleeDecl, CallArgs, RetTy);

(llvm::StructType *ArgStruct = CallInfo.

()) {

llvm::AllocaInst *AI;

IP = IP->getNextNode();

AI =

llvm::AllocaInst(ArgStruct, DL.getAllocaAddrSpace(),

,

AI->setAlignment(Align.getAsAlign());

AI->setUsedWithInAlloca(

);

assert(AI->isUsedWithInAlloca() && !AI->isStaticAlloca());

ArgMemory =

(AI, ArgStruct, Align);

ClangToLLVMArgMapping IRFunctionArgs(

.

(), CallInfo);

llvm::Value *UnusedReturnSizePtr =

;

((IsVirtualFunctionPointerThunk || IsMustTail) && RetAI.

()) {

IRFunctionArgs.getSRetArgNo(),

llvm::TypeSize size =

(IRFunctionArgs.hasSRetArg()) {

IRCallArgs[IRFunctionArgs.getSRetArgNo()] =

assert(CallInfo.

() == CallArgs.size() &&

);

(CallArgList::const_iterator I = CallArgs.begin(),

= CallArgs.end();

I !=

; ++I, ++info_it, ++ArgNo) {

(IRFunctionArgs.hasPaddingArg(ArgNo))

IRCallArgs[IRFunctionArgs.getPaddingArgNo(ArgNo)] =

FirstIRArg, NumIRArgs;

std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);

ArgHasMaybeUndefAttr =

(ArgInfo.

()) {

assert(NumIRArgs == 0);

assert(

().getTriple().getArch() == llvm::Triple::x86);

(I->isAggregate()) {

? I->getKnownLValue().getAddress()

: I->getKnownRValue().getAggregateAddress();

llvm::Instruction *Placeholder =

cast<llvm::Instruction>(Addr.

());

CGBuilderTy::InsertPoint IP =

.saveIP();

.SetInsertPoint(Placeholder);

deferPlaceholderReplacement(Placeholder, Addr.

());

I->Ty,

().getTypeAlignInChars(I->Ty),

);

I->copyInto(*

, Addr);

I->copyInto(*

, Addr);

assert(NumIRArgs == 1);

(I->isAggregate()) {

? I->getKnownLValue().getAddress()

: I->getKnownRValue().getAggregateAddress();

assert((FirstIRArg >= IRFuncTy->getNumParams() ||

IRFuncTy->getParamType(FirstIRArg)->getPointerAddressSpace() ==

TD->getAllocaAddrSpace()) &&

);

NeedCopy =

;

}

(I->hasLValue()) {

LV = I->getKnownLValue();

(!isByValOrRef ||

((isByValOrRef &&

((isByValOrRef &&

Addr.

()->getAddressSpace() != IRFuncTy->

(FirstIRArg)->getPointerAddressSpace())) {

*

= llvm::PointerType::get(

(ArgHasMaybeUndefAttr)

Val =

.CreateFreeze(Val);

IRCallArgs[FirstIRArg] = Val;

}

(I->getType()->isArrayParameterType()) {

IRCallArgs[FirstIRArg] = I->getKnownRValue().getScalarVal();

(ArgHasMaybeUndefAttr)

Val =

.CreateFreeze(Val);

IRCallArgs[FirstIRArg] = Val;

llvm::TypeSize ByvalTempElementSize =

llvm::Value *LifetimeSize =

CallLifetimeEndAfterCall.emplace_back(AI, LifetimeSize);

I->copyInto(*

, AI);

assert(NumIRArgs == 0);

assert(NumIRArgs == 1);

(!I->isAggregate())

= I->getKnownRValue().getScalarVal();

I->hasLValue() ? I->getKnownLValue().getAddress()

: I->getKnownRValue().getAggregateAddress());

assert(!swiftErrorTemp.

() &&

);

, pointeeTy,

().getTypeAlignInChars(pointeeTy));

cast<llvm::AllocaInst>(

)->setSwiftError(

);

->getType()->isIntegerTy())

(FirstIRArg < IRFuncTy->getNumParams() &&

->getType() != IRFuncTy->getParamType(FirstIRArg))

=

.CreateBitCast(

, IRFuncTy->getParamType(FirstIRArg));

(ArgHasMaybeUndefAttr)

IRCallArgs[FirstIRArg] =

;

llvm::StructType *STy =

(!I->isAggregate()) {

I->copyInto(*

, Src);

Src = I->hasLValue() ? I->getKnownLValue().getAddress()

: I->getKnownRValue().getAggregateAddress();

llvm::TypeSize SrcTypeSize =

(SrcTypeSize.isScalable()) {

assert(STy->containsHomogeneousScalableVectorTypes() &&

assert(SrcTypeSize == DstTypeSize &&

);

assert(NumIRArgs == STy->getNumElements());

llvm::Value *StoredStructValue =

(

i = 0, e = STy->getNumElements(); i != e; ++i) {

llvm::Value *Extract =

.CreateExtractValue(

StoredStructValue, i, Src.

() +

+ Twine(i));

IRCallArgs[FirstIRArg + i] = Extract;

SrcSize = SrcTypeSize.getFixedValue();

DstSize = DstTypeSize.getFixedValue();

(SrcSize < DstSize) {

Src.

() +

);

assert(NumIRArgs == STy->getNumElements());

(

i = 0, e = STy->getNumElements(); i != e; ++i) {

(ArgHasMaybeUndefAttr)

LI =

.CreateFreeze(LI);

IRCallArgs[FirstIRArg + i] = LI;

assert(NumIRArgs == 1);

llvm::Value *

=

*ATy = dyn_cast<llvm::ArrayType>(

->getType());

(ATy !=

&& isa<RecordType>(I->Ty.getCanonicalType()))

(ArgHasMaybeUndefAttr)

IRCallArgs[FirstIRArg] =

;

*unpaddedStruct = dyn_cast<llvm::StructType>(unpaddedCoercionType);

llvm::Value *tempSize =

;

(I->isAggregate()) {

addr = I->hasLValue() ? I->getKnownLValue().getAddress()

: I->getKnownRValue().getAggregateAddress();

RV = I->getKnownRValue();

llvm::Type *scalarType = RV.

()->getType();

, &AllocaAddr);

IRArgPos = FirstIRArg;

unpaddedIndex = 0;

(

i = 0, e = coercionType->getNumElements(); i != e; ++i) {

llvm::Type *eltType = coercionType->getElementType(i);

unpaddedStruct ? unpaddedStruct->getElementType(unpaddedIndex++)

: unpaddedCoercionType,

(ArgHasMaybeUndefAttr)

elt =

.CreateFreeze(elt);

IRCallArgs[IRArgPos++] = elt;

assert(IRArgPos == FirstIRArg + NumIRArgs);

IRArgPos = FirstIRArg;

ExpandTypeToArgs(I->Ty, *I, IRFuncTy, IRCallArgs, IRArgPos);

assert(IRArgPos == FirstIRArg + NumIRArgs);

&ConcreteCallee =

.prepareConcreteCallee(*

);

assert(IRFunctionArgs.hasInallocaArg());

IRCallArgs[IRFunctionArgs.getInallocaArgNo()] = Arg;

simplifyVariadicCallee = [](llvm::FunctionType *CalleeFT,

llvm::Value *Ptr) -> llvm::Function * {

(!CalleeFT->isVarArg())

(llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Ptr)) {

(CE->getOpcode() == llvm::Instruction::BitCast)

Ptr = CE->getOperand(0);

llvm::Function *OrigFn = dyn_cast<llvm::Function>(Ptr);

llvm::FunctionType *OrigFT = OrigFn->getFunctionType();

(OrigFT->isVarArg() ||

OrigFT->getNumParams() != CalleeFT->getNumParams() ||

OrigFT->getReturnType() != CalleeFT->getReturnType())

(

i = 0, e = OrigFT->getNumParams(); i != e; ++i)

(OrigFT->getParamType(i) != CalleeFT->getParamType(i))

(llvm::Function *OrigFn = simplifyVariadicCallee(IRFuncTy, CalleePtr)) {

IRFuncTy = OrigFn->getFunctionType();

assert(IRCallArgs.size() == IRFuncTy->getNumParams() || IRFuncTy->isVarArg());

(

i = 0; i < IRCallArgs.size(); ++i) {

(IRFunctionArgs.hasInallocaArg() &&

i == IRFunctionArgs.getInallocaArgNo())

(i < IRFuncTy->getNumParams())

assert(IRCallArgs[i]->getType() == IRFuncTy->getParamType(i));

(

i = 0; i < IRCallArgs.size(); ++i)

LargestVectorWidth = std::max(LargestVectorWidth,

llvm::AttributeList Attrs;

(

== llvm::CallingConv::X86_VectorCall &&

().getTriple().isWindowsArm64EC()) {

.

(

,

(FD->hasAttr<StrictFPAttr>())

Attrs = Attrs.addFnAttribute(

(), llvm::Attribute::StrictFP);

(FD->hasAttr<OptimizeNoneAttr>() &&

().FastMath)

Attrs = Attrs.addFnAttribute(

(), llvm::Attribute::NoMerge);

Attrs = Attrs.addFnAttribute(

(), llvm::Attribute::NoInline);

CallerDecl, CalleeDecl))

Attrs.addFnAttribute(

(), llvm::Attribute::AlwaysInline);

Attrs.removeFnAttribute(

(), llvm::Attribute::Convergent);

!(TargetDecl && TargetDecl->

<NoInlineAttr>()) &&

CallerDecl, CalleeDecl)) {

Attrs.addFnAttribute(

(), llvm::Attribute::AlwaysInline);

Attrs = Attrs.addFnAttribute(

(), llvm::Attribute::NoInline);

CannotThrow =

;

CannotThrow =

;

CannotThrow = Attrs.hasFnAttr(llvm::Attribute::NoUnwind);

(

*FPtr = dyn_cast<llvm::Function>(CalleePtr))

(FPtr->hasFnAttribute(llvm::Attribute::NoUnwind))

CannotThrow =

;

(UnusedReturnSizePtr)

UnusedReturnSizePtr);

llvm::BasicBlock *InvokeDest = CannotThrow ? nullptr :

();

!isa_and_nonnull<FunctionDecl>(TargetDecl))

(FD->hasAttr<StrictFPAttr>())

Attrs = Attrs.addFnAttribute(

(), llvm::Attribute::StrictFP);

AssumeAlignedAttrEmitter AssumeAlignedAttrEmitter(*

, TargetDecl);

Attrs = AssumeAlignedAttrEmitter.TryEmitAsCallSiteAttribute(Attrs);

AllocAlignAttrEmitter AllocAlignAttrEmitter(*

, TargetDecl, CallArgs);

Attrs = AllocAlignAttrEmitter.TryEmitAsCallSiteAttribute(Attrs);

CI =

.CreateCall(IRFuncTy, CalleePtr, IRCallArgs, BundleList);

CI =

.CreateInvoke(IRFuncTy, CalleePtr, Cont, InvokeDest, IRCallArgs,

(CI->getCalledFunction() && CI->getCalledFunction()->hasName() &&

CI->getCalledFunction()->getName().starts_with(

)) {

(

*FD = dyn_cast_or_null<FunctionDecl>(

)) {

(

*A = FD->getAttr<CFGuardAttr>()) {

(A->getGuard() == CFGuardAttr::GuardArg::nocf && !CI->getCalledFunction())

CI->setAttributes(Attrs);

CI->setCallingConv(

llvm::CallingConv::ID

(

));

(!CI->getType()->isVoidTy())

CI->setName(

);

CI = addConvergenceControlToken(CI);

LargestVectorWidth =

(!CI->getCalledFunction())

AddObjCARCExceptionMetadata(CI);

(llvm::CallInst *

= dyn_cast<llvm::CallInst>(CI)) {

(TargetDecl && TargetDecl->

<NotTailCalledAttr>())

->setTailCallKind(llvm::CallInst::TCK_NoTail);

(IsMustTail) {

(

().getTriple().isPPC()) {

(

().getTriple().isOSAIX())

(

->isIndirectCall())

(isa_and_nonnull<FunctionDecl>(TargetDecl)) {

(!cast<FunctionDecl>(TargetDecl)->isDefined())

{cast<FunctionDecl>(TargetDecl),

});

(cast<FunctionDecl>(TargetDecl)));

(llvm::GlobalValue::isWeakForLinker(

) ||

llvm::GlobalValue::isDiscardableIfUnused(

))

->setTailCallKind(llvm::CallInst::TCK_MustTail);

TargetDecl->

<MSAllocatorAttr>())

(TargetDecl && TargetDecl->

<ErrorAttr>()) {

llvm::ConstantInt *

=

llvm::ConstantAsMetadata *MD = llvm::ConstantAsMetadata::get(

);

llvm::MDTuple *MDT = llvm::MDNode::get(

(), {MD});

CI->setMetadata(

, MDT);

(CI->doesNotReturn()) {

(UnusedReturnSizePtr)

(

.

(SanitizerKind::Unreachable)) {

(

*F = CI->getCalledFunction())

F->removeFnAttr(llvm::Attribute::NoReturn);

CI->removeFnAttr(llvm::Attribute::NoReturn);

SanitizerKind::KernelAddress)) {

SanitizerScope SanScope(

);

llvm::IRBuilder<>::InsertPointGuard IPGuard(

);

*FnType = llvm::FunctionType::get(

.

,

);

llvm::FunctionCallee

=

.ClearInsertionPoint();

(CI->getType()->isVoidTy())

.ClearInsertionPoint();

(swiftErrorTemp.

()) {

(IsVirtualFunctionPointerThunk) {

requiresExtract = isa<llvm::StructType>(CI->getType());

unpaddedIndex = 0;

(

i = 0, e = coercionType->getNumElements(); i != e; ++i) {

llvm::Type *eltType = coercionType->getElementType(i);

llvm::Value *elt = CI;

(requiresExtract)

elt =

.CreateExtractValue(elt, unpaddedIndex++);

assert(unpaddedIndex == 0);

(UnusedReturnSizePtr)

llvm::Value *Real =

.CreateExtractValue(CI, 0);

llvm::Value *Imag =

.CreateExtractValue(CI, 1);

llvm::Value *

= CI;

(

->getType() != RetIRTy)

=

.CreateBitCast(

, RetIRTy);

(

*FixedDstTy = dyn_cast<llvm::FixedVectorType>(RetIRTy)) {

llvm::Value *

= CI;

(

*ScalableSrcTy =

dyn_cast<llvm::ScalableVectorType>(

->getType())) {

(FixedDstTy->getElementType() ==

ScalableSrcTy->getElementType()) {

llvm::Value *

= llvm::Constant::getNullValue(

.

);

=

.CreateExtractVector(FixedDstTy,

, Zero,

DestIsVolatile =

;

llvm_unreachable(

);

llvm_unreachable(

);

(

.isScalar() && TargetDecl) {

AssumeAlignedAttrEmitter.EmitAsAnAssumption(

, RetTy, Ret);

AllocAlignAttrEmitter.EmitAsAnAssumption(

, RetTy, Ret);

(CallLifetimeEnd &LifetimeEnd : CallLifetimeEndAfterCall)

LifetimeEnd.Emit(*

,

{});

static void appendParameterTypes(const CodeGenTypes &CGT, SmallVectorImpl< CanQualType > &prefix, SmallVectorImpl< FunctionProtoType::ExtParameterInfo > &paramInfos, CanQual< FunctionProtoType > FPT)

Adds the formal parameters in FPT to the given prefix.

static bool isInAllocaArgument(CGCXXABI &ABI, QualType type)

static uint64_t buildMultiCharMask(const SmallVectorImpl< uint64_t > &Bits, int Pos, int Size, int CharWidth, bool BigEndian)

static llvm::Value * tryRemoveRetainOfSelf(CodeGenFunction &CGF, llvm::Value *result)

If this is a +1 of the value of an immutable 'self', remove it.

static CanQualType GetReturnType(QualType RetTy)

Returns the "extra-canonicalized" return type, which discards qualifiers on the return type.

static const NonNullAttr * getNonNullAttr(const Decl *FD, const ParmVarDecl *PVD, QualType ArgType, unsigned ArgNo)

Returns the attribute (either parameter attribute, or function attribute), which declares argument Ar...

static Address emitAddressAtOffset(CodeGenFunction &CGF, Address addr, const ABIArgInfo &info)

static AggValueSlot createPlaceholderSlot(CodeGenFunction &CGF, QualType Ty)

static void setBitRange(SmallVectorImpl< uint64_t > &Bits, int BitOffset, int BitWidth, int CharWidth)

static SmallVector< CanQualType, 16 > getArgTypesForCall(ASTContext &ctx, const CallArgList &args)

static bool isProvablyNull(llvm::Value *addr)

static void AddAttributesFromFunctionProtoType(ASTContext &Ctx, llvm::AttrBuilder &FuncAttrs, const FunctionProtoType *FPT)

static void eraseUnusedBitCasts(llvm::Instruction *insn)

static bool isObjCMethodWithTypeParams(const ObjCMethodDecl *method)

static void addNoBuiltinAttributes(llvm::AttrBuilder &FuncAttrs, const LangOptions &LangOpts, const NoBuiltinAttr *NBA=nullptr)

static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args, const ObjCIndirectCopyRestoreExpr *CRE)

Emit an argument that's being passed call-by-writeback.

static void overrideFunctionFeaturesWithTargetFeatures(llvm::AttrBuilder &FuncAttr, const llvm::Function &F, const TargetOptions &TargetOpts)

Merges target-features from \TargetOpts and \F, and sets the result in \FuncAttr.

static const CGFunctionInfo & arrangeFreeFunctionLikeCall(CodeGenTypes &CGT, CodeGenModule &CGM, const CallArgList &args, const FunctionType *fnType, unsigned numExtraRequiredArgs, bool chainCall)

Arrange a call as unto a free function, except possibly with an additional number of formal parameter...

static llvm::Value * CreateCoercedLoad(Address Src, llvm::Type *Ty, CodeGenFunction &CGF)

CreateCoercedLoad - Create a load from.

static llvm::SmallVector< FunctionProtoType::ExtParameterInfo, 16 > getExtParameterInfosForCall(const FunctionProtoType *proto, unsigned prefixArgs, unsigned totalArgs)

static CallingConv getCallingConventionForDecl(const ObjCMethodDecl *D, bool IsWindows)

static int getExpansionSize(QualType Ty, const ASTContext &Context)

static CanQual< FunctionProtoType > GetFormalType(const CXXMethodDecl *MD)

Returns the canonical formal type of the given C++ method.

static bool DetermineNoUndef(QualType QTy, CodeGenTypes &Types, const llvm::DataLayout &DL, const ABIArgInfo &AI, bool CheckCoerce=true)

static const Expr * maybeGetUnaryAddrOfOperand(const Expr *E)

static void addDenormalModeAttrs(llvm::DenormalMode FPDenormalMode, llvm::DenormalMode FP32DenormalMode, llvm::AttrBuilder &FuncAttrs)

Add denormal-fp-math and denormal-fp-math-f32 as appropriate for the requested denormal behavior,...

static void deactivateArgCleanupsBeforeCall(CodeGenFunction &CGF, const CallArgList &CallArgs)

static bool isProvablyNonNull(Address Addr, CodeGenFunction &CGF)

static llvm::Value * emitArgumentDemotion(CodeGenFunction &CGF, const VarDecl *var, llvm::Value *value)

An argument came in as a promoted argument; demote it back to its declared type.

static std::pair< llvm::Value *, bool > CoerceScalableToFixed(CodeGenFunction &CGF, llvm::FixedVectorType *ToTy, llvm::ScalableVectorType *FromTy, llvm::Value *V, StringRef Name="")

static SmallVector< CanQualType, 16 > getArgTypesForDeclaration(ASTContext &ctx, const FunctionArgList &args)

static const CGFunctionInfo & arrangeLLVMFunctionInfo(CodeGenTypes &CGT, bool instanceMethod, SmallVectorImpl< CanQualType > &prefix, CanQual< FunctionProtoType > FTP)

Arrange the LLVM function layout for a value of the given function type, on top of any implicit param...

static void addExtParameterInfosForCall(llvm::SmallVectorImpl< FunctionProtoType::ExtParameterInfo > &paramInfos, const FunctionProtoType *proto, unsigned prefixArgs, unsigned totalArgs)

static bool canApplyNoFPClass(const ABIArgInfo &AI, QualType ParamType, bool IsReturn)

Test if it's legal to apply nofpclass for the given parameter type and it's lowered IR type.

static void getTrivialDefaultFunctionAttributes(StringRef Name, bool HasOptnone, const CodeGenOptions &CodeGenOpts, const LangOptions &LangOpts, bool AttrOnCallSite, llvm::AttrBuilder &FuncAttrs)

static llvm::FPClassTest getNoFPClassTestMask(const LangOptions &LangOpts)

Return the nofpclass mask that can be applied to floating-point parameters.

static void forConstantArrayExpansion(CodeGenFunction &CGF, ConstantArrayExpansion *CAE, Address BaseAddr, llvm::function_ref< void(Address)> Fn)

static bool IsArgumentMaybeUndef(const Decl *TargetDecl, unsigned NumRequiredArgs, unsigned ArgNo)

Check if the argument of a function has maybe_undef attribute.

static bool hasInAllocaArgs(CodeGenModule &CGM, CallingConv ExplicitCC, ArrayRef< QualType > ArgTypes)

static std::unique_ptr< TypeExpansion > getTypeExpansion(QualType Ty, const ASTContext &Context)

static RawAddress CreateTempAllocaForCoercion(CodeGenFunction &CGF, llvm::Type *Ty, CharUnits MinAlign, const Twine &Name="tmp")

Create a temporary allocation for the purposes of coercion.

static void setUsedBits(CodeGenModule &, QualType, int, SmallVectorImpl< uint64_t > &)

static llvm::StoreInst * findDominatingStoreToReturnValue(CodeGenFunction &CGF)

Heuristically search for a dominating store to the return-value slot.

static void setCUDAKernelCallingConvention(CanQualType &FTy, CodeGenModule &CGM, const FunctionDecl *FD)

Set calling convention for CUDA/HIP kernel.

static llvm::Value * tryEmitFusedAutoreleaseOfResult(CodeGenFunction &CGF, llvm::Value *result)

Try to emit a fused autorelease of a return result.

static Address EnterStructPointerForCoercedAccess(Address SrcPtr, llvm::StructType *SrcSTy, uint64_t DstSize, CodeGenFunction &CGF)

EnterStructPointerForCoercedAccess - Given a struct pointer that we are accessing some number of byte...

static llvm::Value * emitAutoreleaseOfResult(CodeGenFunction &CGF, llvm::Value *result)

Emit an ARC autorelease of the result of a function.

static void emitWriteback(CodeGenFunction &CGF, const CallArgList::Writeback &writeback)

Emit the actual writing-back of a writeback.

static bool HasStrictReturn(const CodeGenModule &Module, QualType RetTy, const Decl *TargetDecl)

static void addMergableDefaultFunctionAttributes(const CodeGenOptions &CodeGenOpts, llvm::AttrBuilder &FuncAttrs)

Add default attributes to a function, which have merge semantics under -mlink-builtin-bitcode and sho...

static llvm::Value * CoerceIntOrPtrToIntOrPtr(llvm::Value *Val, llvm::Type *Ty, CodeGenFunction &CGF)

CoerceIntOrPtrToIntOrPtr - Convert a value Val to the specific Ty where both are either integers or p...

static void AddAttributesFromOMPAssumes(llvm::AttrBuilder &FuncAttrs, const Decl *Callee)

static unsigned getMaxVectorWidth(const llvm::Type *Ty)

CodeGenFunction::ComplexPairTy ComplexPairTy

enum clang::sema::@1704::IndirectLocalPathEntry::EntryKind Kind

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

llvm::MachO::Target Target

static bool hasFeature(StringRef Feature, const LangOptions &LangOpts, const TargetInfo &Target)

Determine whether a translation unit built using the current language options has the given feature.

static QualType getParamType(Sema &SemaRef, ArrayRef< ResultCandidate > Candidates, unsigned N)

Get the type of the Nth parameter from a given set of overload candidates.

static QualType getPointeeType(const MemRegion *R)

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

const ConstantArrayType * getAsConstantArrayType(QualType T) const

CanQualType getCanonicalParamType(QualType T) const

Return the canonical parameter type corresponding to the specific potentially non-canonical one.

QualType getTagDeclType(const TagDecl *Decl) const

Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.

const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const

Get or compute information about the layout of the specified record (struct/union/class) D,...

CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const

Retrieves the default calling convention for the current target.

QualType getPointerType(QualType T) const

Return the uniqued reference to the type for a pointer to the specified type.

QualType getBaseElementType(const ArrayType *VAT) const

Return the innermost element type of an array type.

QualType getObjCSelType() const

Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.

CanQualType getSizeType() const

Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.

TypeInfoChars getTypeInfoDataSizeInChars(QualType T) const

TypeInfoChars getTypeInfoInChars(const Type *T) const

uint64_t getTypeSize(QualType T) const

Return the size of the specified (complete) type T, in bits.

CharUnits getTypeSizeInChars(QualType T) const

Return the size of the specified (complete) type T, in characters.

const TargetInfo & getTargetInfo() const

QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const

Return the uniqued reference to the type for an address space qualified type with the specified type ...

uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const

Return number of constant array elements.

QualType getIntPtrType() const

Return a type compatible with "intptr_t" (C99 7.18.1.4), as defined by the target.

uint64_t getCharWidth() const

Return the size of the character type, in bits.

ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...

uint64_t getFieldOffset(unsigned FieldNo) const

getFieldOffset - Get the offset of the given field index, in bits.

Represents an array type, per C99 6.7.5.2 - Array Declarators.

Attr - This represents one attribute.

const FunctionProtoType * getFunctionType() const

getFunctionType - Return the underlying function type for this block.

This class is used for builtin types like 'int'.

Represents a base class of a C++ class.

QualType getType() const

Retrieves the type of the base class.

Represents a C++ constructor within a class.

Represents a C++ destructor 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.

Qualifiers getMethodQualifiers() const

Represents a C++ struct/union/class.

CXXDestructorDecl * getDestructor() const

Returns the destructor decl for this class.

unsigned getNumVBases() const

Retrieves the number of virtual base classes of this class.

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

SourceLocation getBeginLoc() const LLVM_READONLY

static CanQual< Type > CreateUnsafe(QualType Other)

Builds a canonical type from a QualType.

CanProxy< U > castAs() const

CanQual< T > getUnqualifiedType() const

Retrieve the unqualified form of this type.

CanProxy< U > getAs() const

Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed.

const T * getTypePtr() const

Retrieve the underlying type pointer, which refers to a canonical type.

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.

static CharUnits fromQuantity(QuantityType Quantity)

fromQuantity - Construct a CharUnits quantity from a raw integer type.

static CharUnits Zero()

Zero - Construct a CharUnits quantity of zero.

CodeGenOptions - Track various options which control how the code is optimized and passed to the back...

llvm::DenormalMode FPDenormalMode

The floating-point denormal mode to use.

static StringRef getFramePointerKindName(FramePointerKind Kind)

std::vector< std::string > Reciprocals

llvm::DenormalMode FP32DenormalMode

The floating-point denormal mode to use, for float.

std::string TrapFuncName

If not an empty string, trap intrinsics are lowered to calls to this function instead of to trap inst...

std::vector< std::string > DefaultFunctionAttrs

std::string PreferVectorWidth

The preferred width for auto-vectorization transforms.

ABIArgInfo - Helper class to encapsulate information about how a specific C type should be passed to ...

unsigned getInAllocaFieldIndex() const

bool getIndirectByVal() const

llvm::StructType * getCoerceAndExpandType() const

bool getIndirectRealign() const

void setCoerceToType(llvm::Type *T)

llvm::Type * getUnpaddedCoerceAndExpandType() const

bool getCanBeFlattened() const

unsigned getDirectOffset() const

static bool isPaddingForCoerceAndExpand(llvm::Type *eltType)

bool getInAllocaSRet() const

Return true if this field of an inalloca struct should be returned to implement a struct return calli...

llvm::Type * getPaddingType() const

bool getPaddingInReg() const

unsigned getDirectAlign() const

unsigned getIndirectAddrSpace() const

@ Extend

Extend - Valid only for integer argument types.

@ Ignore

Ignore - Ignore the argument (treat as void).

@ IndirectAliased

IndirectAliased - Similar to Indirect, but the pointer may be to an object that is otherwise referenc...

@ Expand

Expand - Only valid for aggregate argument types.

@ 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...

@ CoerceAndExpand

CoerceAndExpand - Only valid for aggregate argument types.

@ Direct

Direct - Pass the argument directly using the normal converted LLVM type, or by coercing to another s...

ArrayRef< llvm::Type * > getCoerceAndExpandTypeSequence() const

bool isCoerceAndExpand() const

unsigned getInAllocaIndirect() const

llvm::Type * getCoerceToType() const

bool isIndirectAliased() const

bool isSRetAfterThis() const

bool canHaveCoerceToType() const

CharUnits getIndirectAlign() const

virtual RValue EmitMSVAArg(CodeGen::CodeGenFunction &CGF, CodeGen::Address VAListAddr, QualType Ty, AggValueSlot Slot) const

Emit the target dependent code to load a value of.

virtual RValue EmitVAArg(CodeGen::CodeGenFunction &CGF, CodeGen::Address VAListAddr, QualType Ty, AggValueSlot Slot) const =0

EmitVAArg - Emit the target dependent code to load a value of.

virtual void computeInfo(CodeGen::CGFunctionInfo &FI) const =0

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::StringRef getName() const

Return the IR name of the pointer value.

llvm::PointerType * getType() const

Return the type of the pointer value.

Address getAddress() const

void setExternallyDestructed(bool destructed=true)

static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)

forAddr - Make a slot for an aggregate value.

const BlockExpr * BlockExpression

llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)

Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset, const llvm::Twine &Name="")

Given a pointer to i8, adjust it by a given constant offset.

llvm::Value * CreateIsNull(Address Addr, const Twine &Name="")

Address CreateConstGEP2_32(Address Addr, unsigned Idx0, unsigned Idx1, const llvm::Twine &Name="")

Address CreateStructGEP(Address Addr, unsigned Index, const llvm::Twine &Name="")

llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")

llvm::LoadInst * CreateFlagLoad(llvm::Value *Addr, const llvm::Twine &Name="")

Emit a load from an i1 flag variable.

llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)

llvm::LoadInst * CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")

Implements C++ ABI-specific code generation functions.

virtual bool hasMostDerivedReturn(GlobalDecl GD) const

virtual bool HasThisReturn(GlobalDecl GD) const

Returns true if the given constructor or destructor is one of the kinds that the ABI says returns 'th...

@ RAA_DirectInMemory

Pass it on the stack using its defined layout.

virtual CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD, Address This, llvm::Type *Ty, SourceLocation Loc)=0

Build a virtual function pointer in the ABI-specific way.

virtual RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const =0

Returns how an argument of the given record type should be passed.

virtual const CXXRecordDecl * getThisArgumentTypeForMethod(GlobalDecl GD)

Get the type of the implicit "this" parameter used by a method.

virtual AddedStructorArgCounts buildStructorSignature(GlobalDecl GD, SmallVectorImpl< CanQualType > &ArgTys)=0

Build the signature of the given constructor or destructor variant by adding any required parameters.

Abstract information about a function or function prototype.

const GlobalDecl getCalleeDecl() const

const FunctionProtoType * getCalleeFunctionProtoType() const

All available information about a concrete callee.

CGCallee prepareConcreteCallee(CodeGenFunction &CGF) const

If this is a delayed callee computation of some sort, prepare a concrete callee.

Address getThisAddress() const

const CallExpr * getVirtualCallExpr() const

llvm::Value * getFunctionPointer() const

llvm::FunctionType * getVirtualFunctionType() const

const CGPointerAuthInfo & getPointerAuthInfo() const

GlobalDecl getVirtualMethodDecl() const

void addHeapAllocSiteMetadata(llvm::CallBase *CallSite, QualType AllocatedTy, SourceLocation Loc)

Add heapallocsite metadata for MSAllocator calls.

CGFunctionInfo - Class to encapsulate the information about a function definition.

bool usesInAlloca() const

Return true if this function uses inalloca arguments.

FunctionType::ExtInfo getExtInfo() const

bool isInstanceMethod() const

ABIArgInfo & getReturnInfo()

bool isReturnsRetained() const

In ARC, whether this function retains its return value.

void Profile(llvm::FoldingSetNodeID &ID)

const_arg_iterator arg_begin() const

ArrayRef< ExtParameterInfo > getExtParameterInfos() const

CanQualType getReturnType() const

static CGFunctionInfo * create(unsigned llvmCC, bool instanceMethod, bool chainCall, bool delegateCall, const FunctionType::ExtInfo &extInfo, ArrayRef< ExtParameterInfo > paramInfos, CanQualType resultType, ArrayRef< CanQualType > argTypes, RequiredArgs required)

bool isCmseNSCall() const

bool isDelegateCall() const

MutableArrayRef< ArgInfo > arguments()

const_arg_iterator arg_end() const

unsigned getEffectiveCallingConvention() const

getEffectiveCallingConvention - Return the actual calling convention to use, which may depend on the ...

ExtParameterInfo getExtParameterInfo(unsigned argIndex) const

CharUnits getArgStructAlignment() const

unsigned arg_size() const

RequiredArgs getRequiredArgs() const

unsigned getNumRequiredArgs() const

llvm::StructType * getArgStruct() const

Get the struct type used to represent all the arguments in memory.

CGRecordLayout - This class handles struct and union layout info while lowering AST types to LLVM typ...

const CGBitFieldInfo & getBitFieldInfo(const FieldDecl *FD) const

Return the BitFieldInfo that corresponds to the field FD.

CallArgList - Type for representing both the value and type of arguments in a call.

llvm::Instruction * getStackBase() const

void addUncopiedAggregate(LValue LV, QualType type)

void addArgCleanupDeactivation(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *IsActiveIP)

ArrayRef< CallArgCleanup > getCleanupsToDeactivate() const

bool hasWritebacks() const

void add(RValue rvalue, QualType type)

bool isUsingInAlloca() const

Returns if we're using an inalloca struct to pass arguments in memory.

void allocateArgumentMemory(CodeGenFunction &CGF)

void freeArgumentMemory(CodeGenFunction &CGF) const

writeback_const_range writebacks() const

void addWriteback(LValue srcLV, Address temporary, llvm::Value *toUse, const Expr *writebackExpr=nullptr, llvm::Value *lifetimeSz=nullptr)

static ParamValue forIndirect(Address addr)

static ParamValue forDirect(llvm::Value *value)

CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...

EHScopeStack::stable_iterator CurrentCleanupScopeDepth

void CreateCoercedStore(llvm::Value *Src, Address Dst, llvm::TypeSize DstSize, bool DstIsVolatile)

Create a store to.

llvm::Value * EmitLifetimeStart(llvm::TypeSize Size, llvm::Value *Addr)

void EmitPointerAuthOperandBundle(const CGPointerAuthInfo &Info, SmallVectorImpl< llvm::OperandBundleDef > &Bundles)

void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)

DeactivateCleanupBlock - Deactivates the given cleanup block.

llvm::Value * EmitNonNullRValueCheck(RValue RV, QualType T)

Create a check that a scalar RValue is non-null.

static TypeEvaluationKind getEvaluationKind(QualType T)

getEvaluationKind - Return the TypeEvaluationKind of QualType T.

SanitizerSet SanOpts

Sanitizers enabled for this function.

void EmitNonNullArgCheck(RValue RV, QualType ArgType, SourceLocation ArgLoc, AbstractCallee AC, unsigned ParmNum)

Create a check for a function parameter that may potentially be declared as non-null.

void EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr)

void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)

EmitStoreThroughLValue - Store the specified rvalue into the specified lvalue, where both are guarant...

static bool hasScalarEvaluationKind(QualType T)

bool isCleanupPadScope() const

Returns true while emitting a cleanuppad.

void EmitCallArgs(CallArgList &Args, PrototypeWrapper Prototype, llvm::iterator_range< CallExpr::const_arg_iterator > ArgRange, AbstractCallee AC=AbstractCallee(), unsigned ParamsToSkip=0, EvaluationOrder Order=EvaluationOrder::Default)

void EmitKCFIOperandBundle(const CGCallee &Callee, SmallVectorImpl< llvm::OperandBundleDef > &Bundles)

LValue EmitHLSLOutArgExpr(const HLSLOutArgExpr *E, CallArgList &Args, QualType Ty)

bool shouldUseFusedARCCalls()

bool CurFuncIsThunk

In C++, whether we are code generating a thunk.

RValue EmitRValueForField(LValue LV, const FieldDecl *FD, SourceLocation Loc)

void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating, Address This, QualType ThisTy)

llvm::Value * EmitARCAutoreleaseReturnValue(llvm::Value *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 isSEHTryScope() const

Returns true inside SEH __try blocks.

llvm::Value * getAsNaturalPointerTo(Address Addr, QualType PointeeType)

void EmitVariablyModifiedType(QualType Ty)

EmitVLASize - Capture all the sizes for the VLA expressions in the given variably-modified type and s...

llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)

createBasicBlock - Create an LLVM basic block.

const LangOptions & getLangOpts() const

void EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc, SourceLocation EndLoc)

EmitFunctionEpilog - Emit the target specific LLVM code to return the given temporary.

LValue EmitLValueForFieldInitialization(LValue Base, const FieldDecl *Field)

EmitLValueForFieldInitialization - Like EmitLValueForField, except that if the Field is a reference,...

void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)

EmitBlock - Emit the given block.

bool InNoConvergentAttributedStmt

True if the current statement has noconvergent attribute.

void EmitUnreachable(SourceLocation Loc)

Emit a reached-unreachable diagnostic if Loc is valid and runtime checking is enabled.

llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)

CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...

const CodeGen::CGBlockInfo * BlockInfo

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.

SmallVector< llvm::OperandBundleDef, 1 > getBundlesForFunclet(llvm::Value *Callee)

void callCStructDestructor(LValue Dst)

RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)

EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...

RValue convertTempToRValue(Address addr, QualType type, SourceLocation Loc)

void EmitIgnoredExpr(const Expr *E)

EmitIgnoredExpr - Emit an expression in a context which ignores the result.

bool InNoMergeAttributedStmt

True if the current statement has nomerge attribute.

llvm::Type * ConvertTypeForMem(QualType T)

const Decl * CurCodeDecl

CurCodeDecl - This is the inner-most code context, which includes blocks.

llvm::BasicBlock * getUnreachableBlock()

bool currentFunctionUsesSEHTry() const

JumpDest ReturnBlock

ReturnBlock - Unified return block.

RawAddress CreateMemTemp(QualType T, const Twine &Name="tmp", RawAddress *Alloca=nullptr)

CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen and cas...

@ ForceLeftToRight

! Language semantics require left-to-right evaluation.

@ ForceRightToLeft

! Language semantics require right-to-left evaluation.

RawAddress CreateMemTempWithoutCast(QualType T, const Twine &Name="tmp")

CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen without...

const TargetInfo & getTarget() const

llvm::Value * EmitCMSEClearRecord(llvm::Value *V, llvm::IntegerType *ITy, QualType RTy)

llvm::Value * getTypeSize(QualType Ty)

Returns calculated size of the specified type.

void EmitFunctionProlog(const CGFunctionInfo &FI, llvm::Function *Fn, const FunctionArgList &Args)

EmitFunctionProlog - Emit the target specific LLVM code to load the arguments for the given function.

Address EmitPointerWithAlignment(const Expr *Addr, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)

EmitPointerWithAlignment - Given an expression with a pointer type, emit the value and compute our be...

void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)

RValue EmitAnyExprToTemp(const Expr *E)

EmitAnyExprToTemp - Similarly to EmitAnyExpr(), however, the result will always be accessible even if...

void EmitReturnValueCheck(llvm::Value *RV)

Emit a test that checks if the return value RV is nonnull.

llvm::BasicBlock * getInvokeDest()

llvm::Value * EmitARCRetainAutoreleaseReturnValue(llvm::Value *value)

void EmitCheck(ArrayRef< std::pair< llvm::Value *, SanitizerKind::SanitizerOrdinal > > Checked, SanitizerHandler Check, ArrayRef< llvm::Constant * > StaticArgs, ArrayRef< llvm::Value * > DynamicArgs)

Create a basic block that will either trap or call a handler function in the UBSan runtime with the p...

AggValueSlot CreateAggTemp(QualType T, const Twine &Name="tmp", RawAddress *Alloca=nullptr)

CreateAggTemp - Create a temporary memory object for the given aggregate type.

void EmitDelegateCallArg(CallArgList &args, const VarDecl *param, SourceLocation loc)

EmitDelegateCallArg - We are performing a delegate call; that is, the current function is delegating ...

ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc)

EmitLoadOfComplex - Load a complex number from the specified l-value.

bool HaveInsertPoint() const

HaveInsertPoint - True if an insertion point is defined.

llvm::Constant * EmitCheckSourceLocation(SourceLocation Loc)

Emit a description of a source location in a format suitable for passing to a runtime sanitizer handl...

CGDebugInfo * getDebugInfo()

Address EmitVAListRef(const Expr *E)

void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy, AggValueSlot::Overlap_t MayOverlap, bool isVolatile=false)

EmitAggregateCopy - Emit an aggregate copy.

void emitAlignmentAssumption(llvm::Value *PtrValue, QualType Ty, SourceLocation Loc, SourceLocation AssumptionLoc, llvm::Value *Alignment, llvm::Value *OffsetValue=nullptr)

const TargetCodeGenInfo & getTargetHooks() const

RValue EmitReferenceBindingToExpr(const Expr *E)

Emits a reference binding to the passed in expression.

void EmitAggExpr(const Expr *E, AggValueSlot AS)

EmitAggExpr - Emit the computation of the specified expression of aggregate type.

bool InNoInlineAttributedStmt

True if the current statement has noinline attribute.

void SetSqrtFPAccuracy(llvm::Value *Val)

Set the minimum required accuracy of the given sqrt operation based on CodeGenOpts.

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,...

RValue EmitVAArg(VAArgExpr *VE, Address &VAListAddr, AggValueSlot Slot=AggValueSlot::ignored())

Generate code to get an argument from the passed in pointer and update it accordingly.

llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")

ASTContext & getContext() const

llvm::Value * EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty, SourceLocation Loc, AlignmentSource Source=AlignmentSource::Type, bool isNontemporal=false)

EmitLoadOfScalar - Load a scalar value from an address, taking care to appropriately convert from the...

const Decl * CurFuncDecl

CurFuncDecl - Holds the Decl for the current outermost non-closure context.

void checkTargetFeatures(const CallExpr *E, const FunctionDecl *TargetDecl)

Address GetAddressOfBaseClass(Address Value, const CXXRecordDecl *Derived, CastExpr::path_const_iterator PathBegin, CastExpr::path_const_iterator PathEnd, bool NullCheckValue, SourceLocation Loc)

GetAddressOfBaseClass - This function will add the necessary delta to the load of 'this' and returns ...

void pushDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)

void PopCleanupBlock(bool FallThroughIsBranchThrough=false, bool ForDeactivation=false)

PopCleanupBlock - Will pop the cleanup entry on the stack and process all branch fixups.

bool AutoreleaseResult

In ARC, whether we should autorelease the return value.

llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")

llvm::Type * ConvertType(QualType T)

void EmitNoreturnRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args)

CodeGenTypes & getTypes() const

void EmitWritebacks(const CallArgList &Args)

EmitWriteback - Emit callbacks for function.

llvm::CallBase * EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args, const Twine &name="")

llvm::CallBase * EmitCallOrInvoke(llvm::FunctionCallee Callee, ArrayRef< llvm::Value * > Args, const Twine &Name="")

bool InAlwaysInlineAttributedStmt

True if the current statement has always_inline attribute.

void EmitCallArg(CallArgList &args, const Expr *E, QualType ArgType)

EmitCallArg - Emit a single call argument.

void EmitARCIntrinsicUse(ArrayRef< llvm::Value * > values)

Address EmitMSVAListRef(const Expr *E)

Emit a "reference" to a __builtin_ms_va_list; this is always the value of the expression,...

llvm::Value * EmitARCRetainNonBlock(llvm::Value *value)

static bool hasAggregateEvaluationKind(QualType T)

LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)

void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit)

EmitStoreOfComplex - Store a complex number into the specified l-value.

const CallExpr * MustTailCall

LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)

Address GetAddrOfLocalVar(const VarDecl *VD)

GetAddrOfLocalVar - Return the address of a local variable.

void EmitParmDecl(const VarDecl &D, ParamValue Arg, unsigned ArgNo)

EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.

std::pair< llvm::Value *, llvm::Value * > ComplexPairTy

Address ReturnValue

ReturnValue - The temporary alloca to hold the return value.

RValue GetUndefRValue(QualType Ty)

GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.

llvm::Instruction * CurrentFuncletPad

void EnsureInsertPoint()

EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go.

llvm::LLVMContext & getLLVMContext()

llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)

EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...

void EmitStoreOfScalar(llvm::Value *Value, Address Addr, bool Volatile, QualType Ty, AlignmentSource Source=AlignmentSource::Type, bool isInit=false, bool isNontemporal=false)

EmitStoreOfScalar - Store a scalar value to an address, taking care to appropriately convert from the...

This class organizes the cross-function state that is used while generating LLVM code.

llvm::MDNode * getNoObjCARCExceptionsMetadata()

llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false, bool AssumeConvergent=false)

Create or return a runtime function declaration with the specified type and name.

const ABIInfo & getABIInfo()

bool ReturnTypeUsesFPRet(QualType ResultType)

Return true iff the given type uses 'fpret' when used as a return type.

DiagnosticsEngine & getDiags() const

void ErrorUnsupported(const Stmt *S, const char *Type)

Print out an error that codegen doesn't support the specified stmt yet.

const LangOptions & getLangOpts() const

CharUnits getNaturalTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, bool forPointeeType=false)

CodeGenTypes & getTypes()

const TargetInfo & getTarget() const

const llvm::DataLayout & getDataLayout() const

void addUndefinedGlobalForTailCall(std::pair< const FunctionDecl *, SourceLocation > Global)

ObjCEntrypoints & getObjCEntrypoints() const

void Error(SourceLocation loc, StringRef error)

Emit a general error that something can't be done.

bool shouldEmitConvergenceTokens() const

CGCXXABI & getCXXABI() const

bool ReturnTypeUsesFP2Ret(QualType ResultType)

Return true iff the given type uses 'fp2ret' when used as a return type.

llvm::GlobalVariable::LinkageTypes getFunctionLinkage(GlobalDecl GD)

bool ReturnSlotInterferesWithArgs(const CGFunctionInfo &FI)

Return true iff the given type uses an argument slot when 'sret' is used as a return type.

bool ReturnTypeHasInReg(const CGFunctionInfo &FI)

Return true iff the given type has inreg set.

void AdjustMemoryAttribute(StringRef Name, CGCalleeInfo CalleeInfo, llvm::AttributeList &Attrs)

Adjust Memory attribute to ensure that the BE gets the right attribute.

void ConstructAttributeList(StringRef Name, const CGFunctionInfo &Info, CGCalleeInfo CalleeInfo, llvm::AttributeList &Attrs, unsigned &CallingConv, bool AttrOnCallSite, bool IsThunk)

Get the LLVM attributes and calling convention to use for a particular function type.

ASTContext & getContext() const

bool ReturnTypeUsesSRet(const CGFunctionInfo &FI)

Return true iff the given type uses 'sret' when used as a return type.

const TargetCodeGenInfo & getTargetCodeGenInfo()

const CodeGenOptions & getCodeGenOpts() const

void addDefaultFunctionDefinitionAttributes(llvm::AttrBuilder &attrs)

Like the overload taking a Function &, but intended specifically for frontends that want to build on ...

CharUnits getNaturalPointeeTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)

llvm::LLVMContext & getLLVMContext()

CharUnits getMinimumObjectSize(QualType Ty)

Returns the minimum object size for an object of the given type.

bool MayDropFunctionReturn(const ASTContext &Context, QualType ReturnType) const

Whether this function's return type has no side effects, and thus may be trivially discarded if it is...

void valueProfile(CGBuilderTy &Builder, uint32_t ValueKind, llvm::Instruction *ValueSite, llvm::Value *ValuePtr)

This class organizes the cross-module state that is used while lowering AST types to LLVM types.

const CGFunctionInfo & arrangeCXXMethodType(const CXXRecordDecl *RD, const FunctionProtoType *FTP, const CXXMethodDecl *MD)

Arrange the argument and result information for a call to an unknown C++ non-static member function o...

llvm::Type * ConvertType(QualType T)

ConvertType - Convert type T into a llvm::Type.

CGCXXABI & getCXXABI() const

const CGFunctionInfo & arrangeCXXMethodDeclaration(const CXXMethodDecl *MD)

C++ methods have some special rules and also have implicit parameters.

ASTContext & getContext() const

const CGFunctionInfo & arrangeLLVMFunctionInfo(CanQualType returnType, FnInfoOpts opts, ArrayRef< CanQualType > argTypes, FunctionType::ExtInfo info, ArrayRef< FunctionProtoType::ExtParameterInfo > paramInfos, RequiredArgs args)

"Arrange" the LLVM information for a call or type with the given signature.

const CGFunctionInfo & arrangeFreeFunctionType(CanQual< FunctionProtoType > Ty)

Arrange the argument and result information for a value of the given freestanding function type.

CanQualType DeriveThisType(const CXXRecordDecl *RD, const CXXMethodDecl *MD)

Derives the 'this' type for codegen purposes, i.e.

llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)

GetFunctionType - Get the LLVM function type for.

bool inheritingCtorHasParams(const InheritedConstructor &Inherited, CXXCtorType Type)

Determine if a C++ inheriting constructor should have parameters matching those of its inherited cons...

bool isFuncTypeConvertible(const FunctionType *FT)

isFuncTypeConvertible - Utility to check whether a function type can be converted to an LLVM type (i....

const CGFunctionInfo & arrangeBlockFunctionCall(const CallArgList &args, const FunctionType *type)

A block function is essentially a free function with an extra implicit argument.

const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)

A builtin function is a freestanding function using the default C conventions.

const CGFunctionInfo & arrangeUnprototypedObjCMessageSend(QualType returnType, const CallArgList &args)

const CGRecordLayout & getCGRecordLayout(const RecordDecl *)

getCGRecordLayout - Return record layout info for the given record decl.

unsigned getTargetAddressSpace(QualType T) const

void getExpandedTypes(QualType Ty, SmallVectorImpl< llvm::Type * >::iterator &TI)

getExpandedTypes - Expand the type

const CGFunctionInfo & arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD)

Objective-C methods are C functions with some implicit parameters.

llvm::LLVMContext & getLLVMContext()

const CGFunctionInfo & arrangeGlobalDeclaration(GlobalDecl GD)

const CGFunctionInfo & arrangeUnprototypedMustTailThunk(const CXXMethodDecl *MD)

Arrange a thunk that takes 'this' as the first parameter followed by varargs.

const CGFunctionInfo & arrangeCXXMethodCall(const CallArgList &args, const FunctionProtoType *type, RequiredArgs required, unsigned numPrefixArgs)

Arrange a call to a C++ method, passing the given arguments.

const CGFunctionInfo & arrangeFreeFunctionCall(const CallArgList &Args, const FunctionType *Ty, bool ChainCall)

Figure out the rules for calling a function with the given formal type using the given arguments.

const CGFunctionInfo & arrangeBuiltinFunctionCall(QualType resultType, const CallArgList &args)

const CGFunctionInfo & arrangeFunctionDeclaration(const FunctionDecl *FD)

Free functions are functions that are compatible with an ordinary C function pointer type.

const CGFunctionInfo & arrangeBlockFunctionDeclaration(const FunctionProtoType *type, const FunctionArgList &args)

Block invocation functions are C functions with an implicit parameter.

unsigned ClangCallConvToLLVMCallConv(CallingConv CC)

Convert clang calling convention to LLVM callilng convention.

llvm::Type * GetFunctionTypeForVTable(GlobalDecl GD)

GetFunctionTypeForVTable - Get the LLVM function type for use in a vtable, given a CXXMethodDecl.

const CGFunctionInfo & arrangeCXXConstructorCall(const CallArgList &Args, const CXXConstructorDecl *D, CXXCtorType CtorKind, unsigned ExtraPrefixArgs, unsigned ExtraSuffixArgs, bool PassProtoArgs=true)

Arrange a call to a C++ method, passing the given arguments.

const CGFunctionInfo & arrangeObjCMessageSendSignature(const ObjCMethodDecl *MD, QualType receiverType)

Arrange the argument and result information for the function type through which to perform a send to ...

const CGFunctionInfo & arrangeCXXStructorDeclaration(GlobalDecl GD)

const CGFunctionInfo & arrangeMSCtorClosure(const CXXConstructorDecl *CD, CXXCtorType CT)

const CGFunctionInfo & arrangeCall(const CGFunctionInfo &declFI, const CallArgList &args)

Given a function info for a declaration, return the function info for a call with the given arguments...

const CGFunctionInfo & arrangeNullaryFunction()

A nullary function is a freestanding function of type 'void ()'.

A cleanup scope which generates the cleanup blocks lazily.

EHScopeStack::Cleanup * getCleanup()

Information for lazily generating a cleanup.

virtual bool isRedundantBeforeReturn()

A saved depth on the scope stack.

stable_iterator stable_begin() const

Create a stable reference to the top of the EH stack.

iterator end() const

Returns an iterator pointing to the outermost EH scope.

iterator find(stable_iterator save) const

Turn a stable reference to a scope depth into a unstable pointer to the EH stack.

FunctionArgList - Type for representing both the decl and type of parameters to a function.

LValue - This represents an lvalue references.

bool isVolatileQualified() const

LangAS getAddressSpace() const

CharUnits getAlignment() const

static LValue MakeAddr(Address Addr, QualType type, ASTContext &Context, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)

Address getAddress() const

ARCPreciseLifetime_t isARCPreciseLifetime() const

Qualifiers::ObjCLifetime getObjCLifetime() const

RValue - This trivial value class is used to represent the result of an expression that is evaluated.

static RValue get(llvm::Value *V)

static RValue getAggregate(Address addr, bool isVolatile=false)

Convert an Address to an RValue.

static RValue getComplex(llvm::Value *V1, llvm::Value *V2)

Address getAggregateAddress() const

getAggregateAddr() - Return the Value* of the address of the aggregate.

llvm::Value * getScalarVal() const

getScalarVal() - Return the Value* of this scalar value.

bool isVolatileQualified() const

std::pair< llvm::Value *, llvm::Value * > getComplexVal() const

getComplexVal - Return the real/imag components of this complex value.

An abstract representation of an aligned address.

CharUnits getAlignment() const

Return the alignment of this pointer.

llvm::Type * getElementType() const

Return the type of the values stored in this address.

llvm::Value * getPointer() const

static RawAddress invalid()

A class for recording the number of arguments that a function signature requires.

bool allowsOptionalArgs() const

unsigned getNumRequiredArgs() const

static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype, unsigned additional)

Compute the arguments required by the given formal prototype, given that there may be some additional...

ReturnValueSlot - Contains the address where the return value of a function can be stored,...

virtual bool doesReturnSlotInterfereWithArgs() const

doesReturnSlotInterfereWithArgs - Return true if the target uses an argument slot for an 'sret' type.

virtual bool wouldInliningViolateFunctionCallABI(const FunctionDecl *Caller, const FunctionDecl *Callee) const

Returns true if inlining the function call would produce incorrect code for the current target and sh...

virtual void setCUDAKernelCallingConvention(const FunctionType *&FT) const

Address performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, Address Addr, LangAS SrcAddr, LangAS DestAddr, llvm::Type *DestTy, bool IsNonNull=false) const

virtual void checkFunctionCallABI(CodeGenModule &CGM, SourceLocation CallLoc, const FunctionDecl *Caller, const FunctionDecl *Callee, const CallArgList &Args, QualType ReturnType) const

Any further codegen related checks that need to be done on a function call in a target specific manne...

virtual unsigned getOpenCLKernelCallingConv() const

Get LLVM calling convention for OpenCL kernel.

static void initBranchProtectionFnAttributes(const TargetInfo::BranchProtectionInfo &BPI, llvm::AttrBuilder &FuncAttrs)

virtual bool isNoProtoCallVariadic(const CodeGen::CallArgList &args, const FunctionNoProtoType *fnType) const

Determine whether a call to an unprototyped functions under the given calling convention should use t...

Complex values, per C99 6.2.5p11.

Represents the canonical version of C arrays with a specified constant size.

bool constructsVirtualBase() const

Returns true if the constructed base class is a virtual base class subobject of this declaration's cl...

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

Decl - This represents one declaration (or definition), e.g.

llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const

DeclContext * getDeclContext()

SourceLocation getBeginLoc() const LLVM_READONLY

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

This represents one expression.

Expr * IgnoreParens() LLVM_READONLY

Skip past any parentheses which might surround this expression until reaching a fixed point.

@ NPC_ValueDependentIsNotNull

Specifies that a value-dependent expression should be considered to never be a null pointer constant.

ExprObjectKind getObjectKind() const

getObjectKind - The object kind that this expression produces.

NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const

isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.

Represents a member of a struct/union/class.

bool isBitField() const

Determines whether this field is a bitfield.

bool isUnnamedBitField() const

Determines whether this is an unnamed bitfield.

bool isZeroLengthBitField() const

Is this a zero-length bit-field? Such bit-fields aren't really bit-fields at all and instead act as a...

Represents a function declaration or definition.

bool isTrivial() const

Whether this function is "trivial" in some specialized C++ senses.

Represents a K&R-style 'int foo()' function, which has no information available about its arguments.

Represents a prototype with parameter type info, e.g.

ExceptionSpecificationType getExceptionSpecType() const

Get the kind of exception specification on this function.

unsigned getNumParams() const

unsigned getAArch64SMEAttributes() const

Return a bitmask describing the SME attributes on the function type, see AArch64SMETypeAttributes for...

bool isNothrow(bool ResultIfDependent=false) const

Determine whether this function type has a non-throwing exception specification.

ArrayRef< ExtParameterInfo > getExtParameterInfos() const

bool hasExtParameterInfos() const

Is there any interesting extra information for any of the parameters of this function type?

Wrapper for source info for functions.

A class which abstracts out some details necessary for making a call.

ExtInfo withCallingConv(CallingConv cc) const

CallingConv getCC() const

ExtInfo withProducesResult(bool producesResult) const

bool getCmseNSCall() const

bool getNoCfCheck() const

unsigned getRegParm() const

bool getNoCallerSavedRegs() const

bool getHasRegParm() const

bool getProducesResult() const

Interesting information about a specific parameter that can't simply be reflected in parameter's type...

ParameterABI getABI() const

Return the ABI treatment of this parameter.

ExtParameterInfo withIsNoEscape(bool NoEscape) const

FunctionType - C99 6.7.5.3 - Function Declarators.

ExtInfo getExtInfo() const

static ArmStateValue getArmZT0State(unsigned AttrBits)

static ArmStateValue getArmZAState(unsigned AttrBits)

QualType getReturnType() const

@ SME_PStateSMEnabledMask

@ SME_PStateSMCompatibleMask

@ SME_AgnosticZAStateMask

GlobalDecl - represents a global declaration.

CXXCtorType getCtorType() const

const Decl * getDecl() const

This class represents temporary values used to represent inout and out arguments in HLSL.

Description of a constructor that was inherited from a base class.

ConstructorUsingShadowDecl * getShadowDecl() const

@ 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...

std::vector< std::string > NoBuiltinFuncs

A list of all -fno-builtin-* function names (e.g., memset).

FPExceptionModeKind getDefaultExceptionMode() const

bool isNoBuiltinFunc(StringRef Name) const

Is this a libc/libm function that is no longer recognized as a builtin because a -fno-builtin-* optio...

bool assumeFunctionsAreConvergent() const

Represents a matrix type, as defined in the Matrix Types clang extensions.

Describes a module or submodule.

StringRef getName() const

Get the name of identifier for this declaration as a StringRef.

ObjCCategoryDecl - Represents a category declaration.

ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore ...

bool shouldCopy() const

shouldCopy - True if we should do the 'copy' part of the copy-restore.

Represents an ObjC class declaration.

ObjCMethodDecl - Represents an instance or class method declaration.

ImplicitParamDecl * getSelfDecl() const

ArrayRef< ParmVarDecl * > parameters() const

bool isDirectMethod() const

True if the method is tagged as objc_direct.