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

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

clang: lib/CodeGen/Targets/AArch64.cpp Source File

;

AArch64ABIInfo :

{

IsNamedArg,

CallingConvention,

&NSRN,

&NPRN)

;

llvm::Type *convertFixedToScalableVectorType(

*VT)

;

&NPRN)

;

coerceAndExpandPureScalableAggregate(

Ty,

IsNamedArg,

NVec,

NPred,

&NPRN)

;

uint64_t Members)

;

isIllegalVectorType(

Ty)

;

passAsAggregateType(

Ty)

;

passAsPureScalableType(

Ty,

&NV,

&NP,

flattenType(llvm::Type *Ty,

NSRN = 0, NPRN = 0;

IsNamedArg =

(isa<llvm::ScalableVectorType>(BaseTy))

llvm::report_fatal_error(

);

== AArch64ABIKind::Win64

: isDarwinPCS() ? EmitDarwinVAArg(VAListAddr, Ty, CGF, Slot)

: EmitAAPCSVAArg(VAListAddr, Ty, CGF,

, Slot);

raw_ostream &Out)

;

raw_ostream &Out)

;

NumElts)

;

SwiftInfo = std::make_unique<AArch64SwiftABIInfo>(CGT);

;

*FD = dyn_cast_or_null<FunctionDecl>(

);

(

*TA = FD->

<TargetAttr>()) {

(!

.BranchProtection.empty()) {

.CPU, BPI, Error);

assert(

.empty());

*

= cast<llvm::Function>(GV);

llvm::Type *Ty)

{

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

(ST && ST->getNumElements() == 1) {

*AT = dyn_cast<llvm::ArrayType>(ST->getElementType(0));

(AT && AT->getNumElements() == 8 &&

AT->getElementType()->isIntegerTy(64))

ReturnType)

;

WindowsAArch64TargetCodeGenInfo :

AArch64TargetCodeGenInfo {

: AArch64TargetCodeGenInfo(CGT, K) {}

setTargetAttributes(

*

, llvm::GlobalValue *GV,

getDependentLibraryOption(llvm::StringRef Lib,

Opt =

+ qualifyWindowsLibrary(Lib);

getDetectMismatchOption(llvm::StringRef Name, llvm::StringRef

,

Opt =

+ Name.str() +

+

.str() +

;

WindowsAArch64TargetCodeGenInfo::setTargetAttributes(

AArch64TargetCodeGenInfo::setTargetAttributes(

, GV, CGM);

(GV->isDeclaration())

addStackProbeTargetAttributes(

, GV, CGM);

AArch64ABIInfo::convertFixedToScalableVectorType(

*VT)

{

(VT->

() == VectorKind::SveFixedLengthPredicate) {

BuiltinType::UChar &&

);

llvm::ScalableVectorType::get(llvm::Type::getInt1Ty(getVMContext()),

(VT->

() == VectorKind::SveFixedLengthData) {

(BT->getKind()) {

llvm_unreachable(

);

BuiltinType::SChar:

BuiltinType::UChar:

BuiltinType::MFloat8:

llvm::ScalableVectorType::get(

llvm::Type::getInt8Ty(getVMContext()), 16);

BuiltinType::Short:

BuiltinType::UShort:

llvm::ScalableVectorType::get(

llvm::Type::getInt16Ty(getVMContext()), 8);

BuiltinType::Int:

BuiltinType::UInt:

llvm::ScalableVectorType::get(

llvm::Type::getInt32Ty(getVMContext()), 4);

BuiltinType::Long:

BuiltinType::ULong:

llvm::ScalableVectorType::get(

llvm::Type::getInt64Ty(getVMContext()), 2);

BuiltinType::Half:

llvm::ScalableVectorType::get(

llvm::Type::getHalfTy(getVMContext()), 8);

BuiltinType::Float:

llvm::ScalableVectorType::get(

llvm::Type::getFloatTy(getVMContext()), 4);

BuiltinType::Double:

llvm::ScalableVectorType::get(

llvm::Type::getDoubleTy(getVMContext()), 2);

BuiltinType::BFloat16:

llvm::ScalableVectorType::get(

llvm::Type::getBFloatTy(getVMContext()), 8);

llvm_unreachable(

);

&NPRN)

{

assert(Ty->

() &&

);

(VT->

() == VectorKind::SveFixedLengthPredicate) {

BuiltinType::UChar &&

);

NPRN = std::min(NPRN + 1, 4u);

llvm::Type::getInt1Ty(getVMContext()), 16));

(VT->

() == VectorKind::SveFixedLengthData) {

NSRN = std::min(NSRN + 1, 8u);

((isAndroid() || isOHOSFamily()) && (Size <= 16)) {

llvm::Type *ResType = llvm::Type::getInt16Ty(getVMContext());

llvm::Type *ResType = llvm::Type::getInt32Ty(getVMContext());

NSRN = std::min(NSRN + 1, 8u);

llvm::FixedVectorType::get(llvm::Type::getInt32Ty(getVMContext()), 2);

NSRN = std::min(NSRN + 1, 8u);

llvm::FixedVectorType::get(llvm::Type::getInt32Ty(getVMContext()), 4);

getNaturalAlignIndirect(Ty,

);

AArch64ABIInfo::coerceAndExpandPureScalableAggregate(

Ty,

IsNamedArg,

NVec,

NPred,

&NPRN)

{

(!IsNamedArg || NSRN + NVec > 8 || NPRN + NPred > 4)

getNaturalAlignIndirect(Ty,

);

llvm::Type *UnpaddedCoerceToType =

UnpaddedCoerceToSeq.size() == 1

? UnpaddedCoerceToSeq[0]

: llvm::StructType::get(CGT.getLLVMContext(), UnpaddedCoerceToSeq,

flattenType(CGT.ConvertType(Ty), CoerceToSeq);

llvm::StructType::get(CGT.getLLVMContext(), CoerceToSeq,

);

CallingConvention,

&NPRN)

{

(isIllegalVectorType(Ty))

coerceIllegalVector(Ty, NSRN, NPRN);

(!passAsAggregateType(Ty)) {

Ty = EnumTy->getDecl()->getIntegerType();

(EIT->getNumBits() > 128)

getNaturalAlignIndirect(Ty,

);

NSRN = std::min(NSRN + 1, 8u);

(BT->isFloatingPoint())

NSRN = std::min(NSRN + 1, 8u);

(BT->getKind()) {

BuiltinType::SveBool:

BuiltinType::SveCount:

NPRN = std::min(NPRN + 1, 4u);

BuiltinType::SveBoolx2:

NPRN = std::min(NPRN + 2, 4u);

BuiltinType::SveBoolx4:

NPRN = std::min(NPRN + 4, 4u);

(BT->isSVESizelessBuiltinType())

NSRN + getContext().getBuiltinVectorTypeInfo(BT).NumVectors,

(isPromotableIntegerTypeForABI(Ty) && isDarwinPCS()

getNaturalAlignIndirect(Ty,

RAA ==

(!getContext().getLangOpts().

|| isDarwinPCS())

IsWin64 =

== AArch64ABIKind::Win64 ||

CallingConvention == llvm::CallingConv::Win64;

IsWinVariadic = IsWin64 && IsVariadicFn;

(!IsWinVariadic && isHomogeneousAggregate(Ty,

, Members)) {

NSRN = std::min(NSRN + Members,

(8));

(Kind != AArch64ABIKind::AAPCS)

llvm::ArrayType::get(CGT.ConvertType(

(

, 0)), Members));

getContext().getTypeUnadjustedAlignInChars(Ty).getQuantity();

Align = (Align >= 16) ? 16 : 8;

llvm::ArrayType::get(CGT.ConvertType(

(

, 0)), Members), 0,

,

, Align);

(Kind == AArch64ABIKind::AAPCS) {

NVec = 0, NPred = 0;

(passAsPureScalableType(Ty, NVec, NPred, UnpaddedCoerceToSeq) &&

coerceAndExpandPureScalableAggregate(

Ty, IsNamedArg, NVec, NPred, UnpaddedCoerceToSeq, NSRN, NPRN);

(Kind == AArch64ABIKind::AAPCS) {

Alignment = getContext().getTypeUnadjustedAlign(Ty);

Alignment = Alignment < 128 ? 64 : 128;

std::max(getContext().getTypeAlign(Ty),

(

)getTarget().getPointerWidth(LangAS::Default));

= llvm::alignTo(Size, Alignment);

llvm::Type *BaseTy = llvm::Type::getIntNTy(getVMContext(), Alignment);

Size == Alignment ? BaseTy

: llvm::ArrayType::get(BaseTy, Size / Alignment));

getNaturalAlignIndirect(Ty,

);

IsVariadicFn)

{

(VT->

() == VectorKind::SveFixedLengthData ||

VT->

() == VectorKind::SveFixedLengthPredicate) {

NSRN = 0, NPRN = 0;

coerceIllegalVector(RetTy, NSRN, NPRN);

(RetTy->

() && getContext().getTypeSize(RetTy) > 128)

getNaturalAlignIndirect(RetTy);

(!passAsAggregateType(RetTy)) {

RetTy = EnumTy->getDecl()->getIntegerType();

(EIT->getNumBits() > 128)

getNaturalAlignIndirect(RetTy);

(isPromotableIntegerTypeForABI(RetTy) && isDarwinPCS()

(isHomogeneousAggregate(RetTy,

, Members) &&

!(getTarget().getTriple().getArch() == llvm::Triple::aarch64_32 &&

(Kind == AArch64ABIKind::AAPCS) {

NSRN = 0, NPRN = 0;

NVec = 0, NPred = 0;

(passAsPureScalableType(RetTy, NVec, NPred, UnpaddedCoerceToSeq) &&

coerceAndExpandPureScalableAggregate(

RetTy,

, NVec, NPred, UnpaddedCoerceToSeq, NSRN,

(Size <= 64 && getDataLayout().isLittleEndian()) {

llvm::IntegerType::get(getVMContext(), Size));

Alignment = getContext().getTypeAlign(RetTy);

= llvm::alignTo(Size, 64);

(Alignment < 128 && Size == 128) {

llvm::Type *BaseTy = llvm::Type::getInt64Ty(getVMContext());

getNaturalAlignIndirect(RetTy);

AArch64ABIInfo::isIllegalVectorType(

Ty)

{

(VT->

() == VectorKind::SveFixedLengthData ||

VT->

() == VectorKind::SveFixedLengthPredicate)

(!llvm::isPowerOf2_32(NumElements))

llvm::Triple Triple = getTarget().getTriple();

(Triple.getArch() == llvm::Triple::aarch64_32 &&

Triple.isOSBinFormatMachO())

!= 64 && (

!= 128 || NumElements == 1);

AArch64SwiftABIInfo::isLegalVectorType(

VectorSize,

NumElts)

{

(!llvm::isPowerOf2_32(NumElts))

(VectorSize.

() != 16 || NumElts == 1))

AArch64ABIInfo::isHomogeneousAggregateBaseType(

Ty)

{

(BT->isFloatingPoint())

Kind == VectorKind::SveFixedLengthData ||

Kind == VectorKind::SveFixedLengthPredicate)

VecSize = getContext().getTypeSize(VT);

(VecSize == 64 || VecSize == 128)

AArch64ABIInfo::isHomogeneousAggregateSmallEnough(

*

,

uint64_t Members)

{

AArch64ABIInfo::isZeroLengthBitfieldPermittedInHomogeneousAggregate()

AArch64ABIInfo::passAsAggregateType(

Ty)

{

getContext().getBuiltinVectorTypeInfo(BT).NumVectors > 1;

AArch64ABIInfo::passAsPureScalableType(

Ty,

&NVec,

&NPred,

NV = 0, NP = 0;

(!passAsPureScalableType(AT->getElementType(), NV, NP, EltCoerceToSeq))

(CoerceToSeq.size() + NElt * EltCoerceToSeq.size() > 12)

(uint64_t I = 0; I < NElt; ++I)

llvm::copy(EltCoerceToSeq, std::back_inserter(CoerceToSeq));

(

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

(

&I : CXXRD->bases()) {

(!passAsPureScalableType(I.getType(), NVec, NPred, CoerceToSeq))

(

*FD : RD->

()) {

(!passAsPureScalableType(FT, NVec, NPred, CoerceToSeq))

(VT->

() == VectorKind::SveFixedLengthPredicate) {

(CoerceToSeq.size() + 1 > 12)

CoerceToSeq.push_back(convertFixedToScalableVectorType(VT));

(VT->

() == VectorKind::SveFixedLengthData) {

(CoerceToSeq.size() + 1 > 12)

CoerceToSeq.push_back(convertFixedToScalableVectorType(VT));

getContext().getBuiltinVectorTypeInfo(cast<BuiltinType>(Ty));

);

? llvm::Type::getInt8Ty(getVMContext())

: CGT.ConvertType(Info.ElementType);

*VTy = llvm::ScalableVectorType::get(EltTy, Info.

.getKnownMinValue());

(CoerceToSeq.size() + Info.

> 12)

std::fill_n(std::back_inserter(CoerceToSeq), Info.

, VTy);

AArch64ABIInfo::flattenType(

Flattened.push_back(Ty);

(

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

NElt = AT->getNumElements();

flattenType(AT->getElementType(), EltFlattened);

(uint64_t I = 0; I < NElt; ++I)

llvm::copy(EltFlattened, std::back_inserter(Flattened));

(

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

(

*ET : ST->elements())

flattenType(ET, Flattened);

Flattened.push_back(Ty);

NSRN = 0, NPRN = 0;

BaseTy = llvm::PointerType::getUnqual(BaseTy);

NumRegs = 1;

(llvm::ArrayType *ArrTy = dyn_cast<llvm::ArrayType>(BaseTy)) {

BaseTy = ArrTy->getElementType();

NumRegs = ArrTy->getNumElements();

!isSoftFloat() && (BaseTy->isFloatingPointTy() || BaseTy->isVectorTy());

llvm::BasicBlock *MaybeRegBlock = CGF.

(

);

llvm::BasicBlock *OnStackBlock = CGF.

(

);

TySize = getContext().getTypeSizeInChars(Ty);

TyAlign = getContext().getTypeUnadjustedAlignInChars(Ty);

llvm::Value *reg_offs =

;

RegSize = IsIndirect ? 8 : TySize.

();

RegSize = llvm::alignTo(RegSize, 8);

RegSize = 16 * NumRegs;

llvm::Value *UsingStack =

;

UsingStack = CGF.

.CreateICmpSGE(

reg_offs, llvm::ConstantInt::get(CGF.

, 0));

CGF.

.CreateCondBr(UsingStack, OnStackBlock, MaybeRegBlock);

(!IsFPR && !IsIndirect && TyAlign.

() > 8) {

reg_offs = CGF.

.CreateAdd(

reg_offs, llvm::ConstantInt::get(CGF.

, Align - 1),

reg_offs = CGF.

.CreateAnd(

reg_offs, llvm::ConstantInt::get(CGF.

, -Align),

llvm::Value *NewOffset =

;

NewOffset = CGF.

.CreateAdd(

reg_offs, llvm::ConstantInt::get(CGF.

, RegSize),

);

llvm::Value *InRegs =

;

InRegs = CGF.

.CreateICmpSLE(

NewOffset, llvm::ConstantInt::get(CGF.

, 0),

);

CGF.

.CreateCondBr(InRegs, InRegBlock, OnStackBlock);

llvm::Value *reg_top =

;

MemTy = llvm::PointerType::getUnqual(MemTy);

IsHFA = isHomogeneousAggregate(Ty,

, NumMembers);

(IsHFA && NumMembers > 1) {

assert(!IsIndirect &&

);

BaseTyInfo = getContext().getTypeInfoInChars(

(

, 0));

llvm::Type *HFATy = llvm::ArrayType::get(BaseTy, NumMembers);

std::max(TyAlign, BaseTyInfo.Align));

BaseTyInfo.Width.getQuantity() < 16)

Offset = 16 - BaseTyInfo.Width.getQuantity();

(

i = 0; i < NumMembers; ++i) {

SlotSize = BaseAddr.getAlignment();

TySize < SlotSize) {

StackSize = StackSlotSize;

StackSize = TySize.

(StackSlotSize);

CGF.

, OnStackPtr, StackSizeC,

);

TySize < StackSlotSize) {

Offset = StackSlotSize - TySize;

OnStackBlock,

);

PointerSize = getTarget().getPointerWidth(LangAS::Default) / 8;

TyInfo = getContext().getTypeInfoInChars(Ty);

IsIndirect =

;

(TyInfo.Width.getQuantity() > 16) {

IsIndirect = !isHomogeneousAggregate(Ty,

, Members);

(CGF, VAListAddr, Ty, IsIndirect, TyInfo, SlotSize,

IsIndirect =

;

StringRef ABIName,

AArch64ABIInfo &

,

*HABase =

;

uint64_t HAMembers = 0;

Diags.

(loc, diag::err_target_unsupported_type_for_abi)

<<

->getDeclName() << Ty << ABIName;

AArch64TargetCodeGenInfo::checkFunctionABI(

AArch64ABIInfo &

= getABIInfo<AArch64ABIInfo>();

CallerIsStreaming =

CalleeIsStreaming =

(!CalleeIsStreamingCompatible &&

(CallerIsStreaming != CalleeIsStreaming || CallerIsStreamingCompatible)) {

(CalleeIsStreaming)

(

*NewAttr = Callee->getAttr<ArmNewAttr>()) {

(NewAttr->isNewZA())

(NewAttr->isNewZT0())

Inlinability;

AArch64TargetCodeGenInfo::checkFunctionCallABIStreaming(

(!Caller || !Callee || !

->hasAttr<AlwaysInlineAttr>())

? diag::err_function_always_inline_attribute_mismatch

: diag::warn_function_always_inline_attribute_mismatch)

CGM.

().

(CallLoc, diag::err_function_always_inline_new_za)

<<

->getDeclName();

CGM.

().

(CallLoc, diag::err_function_always_inline_new_zt0)

<<

->getDeclName();

AArch64TargetCodeGenInfo::checkFunctionCallABISoftFloat(

AArch64ABIInfo &

= getABIInfo<AArch64ABIInfo>();

Callee ? Callee : Caller, CallLoc);

(

&Arg : Args)

Callee ? Callee : Caller, CallLoc);

AArch64TargetCodeGenInfo::checkFunctionCallABI(

&CGM,

checkFunctionCallABIStreaming(CGM, CallLoc, Caller, Callee);

checkFunctionCallABISoftFloat(CGM, CallLoc, Caller, Callee, Args, ReturnType);

AArch64TargetCodeGenInfo::wouldInliningViolateFunctionCallABI(

Caller &&

&&

AArch64ABIInfo::appendAttributeMangling(TargetClonesAttr *

,

raw_ostream &Out)

{

appendAttributeMangling(

->getFeatureStr(Index), Out);

AArch64ABIInfo::appendAttributeMangling(StringRef AttrStr,

raw_ostream &Out)

{

(AttrStr ==

) {

AttrStr.split(Features,

);

(

&Feat : Features)

llvm::sort(Features, [](

StringRef LHS,

StringRef RHS) {

LHS.compare(RHS) < 0;

llvm::SmallDenseSet<StringRef, 8> UniqueFeats;

(

&Feat : Features)

(

Ext = llvm::AArch64::parseFMVExtension(Feat))

(UniqueFeats.insert(Ext->Name).second)

Out <<

<< Ext->Name;

std::unique_ptr<TargetCodeGenInfo>

std::make_unique<AArch64TargetCodeGenInfo>(CGM.

(), Kind);

std::unique_ptr<TargetCodeGenInfo>

std::make_unique<WindowsAArch64TargetCodeGenInfo>(CGM.

(), K);

static bool isStreamingCompatible(const FunctionDecl *F)

@ ErrorCalleeRequiresNewZA

@ WarnIncompatibleStreamingModes

@ ErrorCalleeRequiresNewZT0

@ IncompatibleStreamingModes

@ LLVM_MARK_AS_BITMASK_ENUM

@ ErrorIncompatibleStreamingModes

static ArmSMEInlinability GetArmSMEInlinability(const FunctionDecl *Caller, const FunctionDecl *Callee)

Determines if there are any Arm SME ABI issues with inlining Callee into Caller.

static void diagnoseIfNeedsFPReg(DiagnosticsEngine &Diags, const StringRef ABIName, const AArch64ABIInfo &ABIInfo, const QualType &Ty, const NamedDecl *D, SourceLocation loc)

TypeInfoChars getTypeInfoInChars(const Type *T) const

const TargetInfo & getTargetInfo() const

Attr - This represents one attribute.

A fixed int type of a specified bitwidth.

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

Represents a C++ struct/union/class.

CharUnits - This is an opaque type for sizes expressed in character units.

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.

CharUnits alignTo(const CharUnits &Align) const

alignTo - Returns the next integer (mod 2**64) that is greater than or equal to this quantity and is ...

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

static ABIArgInfo getIgnore()

static bool isPaddingForCoerceAndExpand(llvm::Type *eltType)

static ABIArgInfo getDirect(llvm::Type *T=nullptr, unsigned Offset=0, llvm::Type *Padding=nullptr, bool CanBeFlattened=true, unsigned Align=0)

static ABIArgInfo getExtend(QualType Ty, llvm::Type *T=nullptr)

static ABIArgInfo getCoerceAndExpand(llvm::StructType *coerceToType, llvm::Type *unpaddedCoerceToType)

llvm::Type * getCoerceToType() const

ABIInfo - Target specific hooks for defining how a type should be passed or returned from functions.

virtual bool allowBFloatArgsAndRet() const

bool isHomogeneousAggregate(QualType Ty, const Type *&Base, uint64_t &Members) const

isHomogeneousAggregate - Return true if a type is an ELFv2 homogeneous aggregate.

CodeGen::CGCXXABI & getCXXABI() const

ASTContext & getContext() const

virtual bool isHomogeneousAggregateBaseType(QualType Ty) const

virtual void appendAttributeMangling(TargetAttr *Attr, raw_ostream &Out) 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 bool isHomogeneousAggregateSmallEnough(const Type *Base, uint64_t Members) const

const TargetInfo & getTarget() const

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 bool isZeroLengthBitfieldPermittedInHomogeneousAggregate() const

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

Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...

Address withElementType(llvm::Type *ElemTy) const

Return address with different element type, but same pointer and alignment.

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.

Address CreateConstArrayGEP(Address Addr, uint64_t Index, const llvm::Twine &Name="")

Given addr = [n x T]* ... produce name = getelementptr inbounds addr, i64 0, i64 index where i64 is a...

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

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

llvm::ConstantInt * getSize(CharUnits N)

Address CreateInBoundsGEP(Address Addr, ArrayRef< llvm::Value * > IdxList, llvm::Type *ElementType, CharUnits Align, const Twine &Name="")

RecordArgABI

Specify how one should pass an argument of a record type.

@ RAA_Default

Pass it using the normal C aggregate rules for the ABI, potentially introducing extra copies and pass...

@ RAA_DirectInMemory

Pass it on the stack using its defined layout.

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

ABIArgInfo & getReturnInfo()

unsigned getCallingConvention() const

getCallingConvention - Return the user specified calling convention, which has been translated into a...

CanQualType getReturnType() const

MutableArrayRef< ArgInfo > arguments()

RequiredArgs getRequiredArgs() const

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

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

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

createBasicBlock - Create an LLVM basic block.

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

EmitBlock - Emit the given block.

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

llvm::Type * ConvertTypeForMem(QualType T)

const TargetInfo & getTarget() const

void EmitBranch(llvm::BasicBlock *Block)

EmitBranch - Emit a branch to the specified basic block from the current insert block,...

ASTContext & getContext() const

llvm::Type * ConvertType(QualType T)

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

const CGFunctionInfo * CurFnInfo

RValue EmitLoadOfAnyValue(LValue V, AggValueSlot Slot=AggValueSlot::ignored(), SourceLocation Loc={})

Like EmitLoadOfLValue but also handles complex and aggregate types.

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

DiagnosticsEngine & getDiags() const

const LangOptions & getLangOpts() const

CodeGenTypes & getTypes()

const TargetInfo & getTarget() const

const llvm::DataLayout & getDataLayout() const

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

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

unsigned getNumRequiredArgs() const

Target specific hooks for defining how a type should be passed or returned from functions with one of...

virtual bool isLegalVectorType(CharUnits VectorSize, llvm::Type *EltTy, unsigned NumElts) const

Returns true if the given vector type is legal from Swift's calling convention perspective.

TargetCodeGenInfo - This class organizes various target-specific codegeneration issues,...

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

Retrieve the address of a function to call immediately before calling objc_retainAutoreleasedReturnVa...

static void setBranchProtectionFnAttributes(const TargetInfo::BranchProtectionInfo &BPI, llvm::Function &F)

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 void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &M) const

setTargetAttributes - Provides a convenient hook to handle extra target-specific attributes for the g...

virtual void checkFunctionABI(CodeGenModule &CGM, const FunctionDecl *Decl) const

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

virtual bool isScalarizableAsmOperand(CodeGen::CodeGenFunction &CGF, llvm::Type *Ty) const

Target hook to decide whether an inline asm operand can be passed by value.

virtual int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const

Determines the DWARF register number for the stack pointer, for exception-handling purposes.

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

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

SourceLocation getLocation() const

Concrete class used by the front-end to report problems and issues.

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.

Represents a function declaration or definition.

QualType getReturnType() const

ArrayRef< ParmVarDecl * > parameters() const

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

unsigned getAArch64SMEAttributes() const

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

@ SME_PStateSMCompatibleMask

This represents a decl that may have a name.

DeclarationName getDeclName() const

Get the actual, stored name of the declaration, which may be a special name.

Represents a parameter to a function.

A (possibly-)qualified type.

Represents a struct/union/class.

field_range fields() const

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...

Encodes a location in the source.

Exposes information about the current target.

virtual StringRef getABI() const

Get the ABI currently in use.

virtual ParsedTargetAttr parseTargetAttr(StringRef Str) const

virtual bool hasBFloat16Type() const

Determine whether the _BFloat16 type is supported on this target.

virtual bool hasFeature(StringRef Feature) const

Determine whether the given target has the given feature.

virtual bool validateBranchProtection(StringRef Spec, StringRef Arch, BranchProtectionInfo &BPI, StringRef &Err) const

Determine if this TargetInfo supports the given branch protection specification.

The base class of the type hierarchy.

bool isMFloat8Type() const

bool isSVESizelessBuiltinType() const

Returns true for SVE scalable vector types.

const T * castAs() const

Member-template castAs<specific type>.

bool isBuiltinType() const

Helper methods to distinguish type categories.

bool isVectorType() const

bool isFloatingType() const

const T * getAs() const

Member-template getAs<specific type>'.

Represents a GCC generic vector type.

unsigned getNumElements() const

VectorKind getVectorKind() const

QualType getElementType() const

ABIArgInfo classifyArgumentType(CodeGenModule &CGM, CanQualType type)

Classify the rules for how to pass a particular type.

CGCXXABI::RecordArgABI getRecordArgABI(const RecordType *RT, CGCXXABI &CXXABI)

bool classifyReturnType(const CGCXXABI &CXXABI, CGFunctionInfo &FI, const ABIInfo &Info)

Address EmitVAArgInstr(CodeGenFunction &CGF, Address VAListAddr, QualType Ty, const ABIArgInfo &AI)

RValue emitVoidPtrVAArg(CodeGenFunction &CGF, Address VAListAddr, QualType ValueTy, bool IsIndirect, TypeInfoChars ValueInfo, CharUnits SlotSizeAndAlign, bool AllowHigherAlign, AggValueSlot Slot, bool ForceRightAdjust=false)

Emit va_arg for a platform using the common void* representation, where arguments are simply emitted ...

Address emitMergePHI(CodeGenFunction &CGF, Address Addr1, llvm::BasicBlock *Block1, Address Addr2, llvm::BasicBlock *Block2, const llvm::Twine &Name="")

bool isEmptyField(ASTContext &Context, const FieldDecl *FD, bool AllowArrays, bool AsIfNoUniqueAddr=false)

isEmptyField - Return true iff a the field is "empty", that is it is an unnamed bit-field or an (arra...

llvm::Value * emitRoundPointerUpToAlignment(CodeGenFunction &CGF, llvm::Value *Ptr, CharUnits Align)

bool isAggregateTypeForABI(QualType T)

std::unique_ptr< TargetCodeGenInfo > createAArch64TargetCodeGenInfo(CodeGenModule &CGM, AArch64ABIKind Kind)

QualType useFirstFieldIfTransparentUnion(QualType Ty)

Pass transparent unions as if they were the type of the first element.

std::unique_ptr< TargetCodeGenInfo > createWindowsAArch64TargetCodeGenInfo(CodeGenModule &CGM, AArch64ABIKind K)

bool isEmptyRecord(ASTContext &Context, QualType T, bool AllowArrays, bool AsIfNoUniqueAddr=false)

isEmptyRecord - Return true iff a structure contains only empty fields.

The JSON file list parser is used to communicate input to InstallAPI.

const FunctionProtoType * T

bool IsArmStreamingFunction(const FunctionDecl *FD, bool IncludeLocallyStreaming)

Returns whether the given FunctionDecl has an __arm[_locally]_streaming attribute.

llvm::IntegerType * Int8Ty

i8, i16, i32, and i64

llvm::IntegerType * Int32Ty

Contains information gathered from parsing the contents of TargetAttr.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4