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

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

clang: include/clang/CodeGen/CGFunctionInfo.h Source File

DirectAttrInfo {

IndirectAttrInfo {

PaddingInReg : 1;

InAllocaSRet : 1;

InAllocaIndirect : 1;

IndirectByVal : 1;

IndirectRealign : 1;

SRetAfterThis : 1;

CanBeFlattened: 1;

canHavePaddingType()

{

setPaddingType(llvm::Type *

) {

assert(canHavePaddingType());

setUnpaddedCoerceToType(llvm::Type *

) {

InAllocaIndirect(

), IndirectByVal(

), IndirectRealign(

),

llvm::Type *Padding =

,

CanBeFlattened =

,

Align = 0) {

AI.setCoerceToType(

);

AI.setPaddingType(Padding);

AI.setDirectOffset(Offset);

AI.setDirectAlign(Align);

AI.setCanBeFlattened(CanBeFlattened);

AI.setCoerceToType(

);

AI.setPaddingType(

);

AI.setDirectOffset(0);

AI.setDirectAlign(0);

AI.setSignExt(

);

AI.setCoerceToType(

);

AI.setPaddingType(

);

AI.setDirectOffset(0);

AI.setDirectAlign(0);

AI.setZeroExt(

);

AI.setCoerceToType(

);

AI.setPaddingType(

);

AI.setDirectOffset(0);

AI.setDirectAlign(0);

Realign =

,

llvm::Type *Padding =

) {

AI.setIndirectAlign(Alignment);

AI.setIndirectByVal(ByVal);

AI.setIndirectRealign(Realign);

AI.setSRetAfterThis(

);

AI.setPaddingType(Padding);

Realign =

,

llvm::Type *Padding =

) {

AI.setIndirectAlign(Alignment);

AI.setIndirectRealign(Realign);

AI.setPaddingType(Padding);

AI.setIndirectAddrSpace(AddrSpace);

Realign =

) {

AI.setInAllocaFieldIndex(FieldIndex);

AI.setPaddingType(

);

llvm::Type *Padding) {

AI.setPaddingInReg(PaddingInReg);

AI.setPaddingType(Padding);

llvm::Type *unpaddedCoerceToType) {

unpaddedStruct = dyn_cast<llvm::StructType>(unpaddedCoerceToType);

assert(!unpaddedStruct || unpaddedStruct->getNumElements() != 1);

unpaddedIndex = 0;

(

eltType : coerceToType->elements()) {

(unpaddedStruct) {

assert(unpaddedStruct->getNumElements() == unpaddedIndex);

assert(unpaddedIndex == 1);

AI.setCoerceToType(coerceToType);

AI.setUnpaddedCoerceToType(unpaddedCoerceToType);

eltType->isArrayTy() &&

eltType->getArrayElementType()->isIntegerTy(8);

assert(

() && (SignExt + ZeroExt <= 1) &&

);

assert(

() &&

);

assert(

() && (SignExt + ZeroExt <= 1) &&

);

assert(

() &&

);

assert(

() && (SignExt + ZeroExt <= 1) &&

);

!SignExt && !ZeroExt;

(canHavePaddingType() ?

:

);

cast<llvm::StructType>(TypeData);

structTy->elements();

IndirectByVal;

IndirectRealign;

IndirectRealign = IR;

SRetAfterThis;

SRetAfterThis = AfterThis;

InAllocaIndirect;

assert(

() &&

);

CanBeFlattened;

assert(

() &&

);

CanBeFlattened = Flatten;

NumRequired;

additional) {

additional += llvm::count_if(

return ExtInfo.hasPassObjectSize();

additional) {

argIdx == ~0

|| argIdx < NumRequired;

(value == ~0

)

;

:

llvm::FoldingSetNode,

llvm::TrailingObjects<CGFunctionInfo, CGFunctionInfoArgInfo,

FunctionProtoType::ExtParameterInfo> {

CallingConvention : 8;

EffectiveCallingConvention : 8;

ASTCallingConvention : 6;

LLVM_PREFERRED_TYPE(

)

InstanceMethod : 1;

LLVM_PREFERRED_TYPE(

)

ChainCall : 1;

LLVM_PREFERRED_TYPE(

)

DelegateCall : 1;

LLVM_PREFERRED_TYPE(

)

CmseNSCall : 1;

LLVM_PREFERRED_TYPE(

)

NoReturn : 1;

LLVM_PREFERRED_TYPE(

)

ReturnsRetained : 1;

LLVM_PREFERRED_TYPE(

)

NoCallerSavedRegs : 1;

LLVM_PREFERRED_TYPE(

)

HasRegParm : 1;

RegParm : 3;

LLVM_PREFERRED_TYPE(

)

NoCfCheck : 1;

MaxVectorWidth : 4;

llvm::StructType *ArgStruct;

ArgStructAlign : 31;

LLVM_PREFERRED_TYPE(

)

HasExtParameterInfos : 1;

getTrailingObjects<ArgInfo>();

*getArgsBuffer()

{

getTrailingObjects<ArgInfo>();

getTrailingObjects<ExtParameterInfo>();

getTrailingObjects<ExtParameterInfo>();

(

llvmCC,

instanceMethod,

chainCall,

(

*p) { ::operator

(p); }

(HasExtParameterInfos ? NumArgs : 0);

EffectiveCallingConvention;

EffectiveCallingConvention =

;

(!HasExtParameterInfos)

{};

assert(argIndex <= NumArgs);

MaxVectorWidth ? 1U << (MaxVectorWidth - 1) : 0;

assert(llvm::isPowerOf2_32(Width) &&

);

MaxVectorWidth = llvm::countr_zero(Width) + 1;

.AddBoolean(InstanceMethod);

.AddBoolean(ChainCall);

.AddBoolean(DelegateCall);

.AddBoolean(NoReturn);

.AddBoolean(ReturnsRetained);

.AddBoolean(NoCallerSavedRegs);

.AddBoolean(HasRegParm);

.AddInteger(RegParm);

.AddBoolean(NoCfCheck);

.AddBoolean(CmseNSCall);

.AddBoolean(HasExtParameterInfos);

(HasExtParameterInfos) {

.AddInteger(paramInfo.getOpaqueValue());

I.type.Profile(

);

(llvm::FoldingSetNodeID &

,

InstanceMethod,

.AddInteger(info.

());

.AddBoolean(InstanceMethod);

.AddBoolean(ChainCall);

.AddBoolean(!paramInfos.empty());

(!paramInfos.empty()) {

(

paramInfo : paramInfos)

.AddInteger(paramInfo.getOpaqueValue());

i = argTypes.begin(), e = argTypes.end(); i != e; ++i) {

C Language Family Type Representation.

Represents a canonical, potentially-qualified type.

void Profile(llvm::FoldingSetNodeID &ID) const

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.

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.

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

void setZeroExt(bool ZExt)

unsigned getInAllocaFieldIndex() const

void setIndirectAddrSpace(unsigned AddrSpace)

static ABIArgInfo getNoExtend(llvm::IntegerType *T)

bool getIndirectByVal() const

llvm::StructType * getCoerceAndExpandType() const

bool getIndirectRealign() const

static ABIArgInfo getInAlloca(unsigned FieldIndex, bool Indirect=false)

static ABIArgInfo getIgnore()

static ABIArgInfo getExpand()

void setCoerceToType(llvm::Type *T)

llvm::Type * getUnpaddedCoerceAndExpandType() const

bool getCanBeFlattened() const

unsigned getDirectOffset() const

static bool isPaddingForCoerceAndExpand(llvm::Type *eltType)

void setDirectOffset(unsigned Offset)

void setPaddingInReg(bool PIR)

bool getInAllocaSRet() const

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

void setIndirectAlign(CharUnits IA)

llvm::Type * getPaddingType() const

void setIndirectByVal(bool IBV)

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

bool getPaddingInReg() const

static ABIArgInfo getExpandWithPadding(bool PaddingInReg, llvm::Type *Padding)

unsigned getDirectAlign() const

unsigned getIndirectAddrSpace() const

ABIArgInfo(Kind K=Direct)

static ABIArgInfo getIndirectInReg(CharUnits Alignment, bool ByVal=true, bool Realign=false)

static ABIArgInfo getIndirect(CharUnits Alignment, bool ByVal=true, bool Realign=false, llvm::Type *Padding=nullptr)

void setIndirectRealign(bool IR)

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

@ 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

static ABIArgInfo getIndirectAliased(CharUnits Alignment, unsigned AddrSpace, bool Realign=false, llvm::Type *Padding=nullptr)

Pass this in memory using the IR byref attribute.

void setSRetAfterThis(bool AfterThis)

void setInAllocaIndirect(bool Indirect)

void setInAllocaSRet(bool SRet)

bool isCoerceAndExpand() const

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

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

DirectAttrInfo DirectAttr

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

unsigned AllocaFieldIndex

unsigned getInAllocaIndirect() const

llvm::Type * getCoerceToType() const

bool isIndirectAliased() const

void setInAllocaFieldIndex(unsigned FieldIndex)

bool isSRetAfterThis() const

IndirectAttrInfo IndirectAttr

bool canHaveCoerceToType() const

llvm::Type * UnpaddedCoerceAndExpandType

void setSignExt(bool SExt)

void setCanBeFlattened(bool Flatten)

void setDirectAlign(unsigned Align)

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

CharUnits getIndirectAlign() const

static ABIArgInfo getDirectInReg(llvm::Type *T=nullptr)

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.

unsigned getCallingConvention() const

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

void Profile(llvm::FoldingSetNodeID &ID)

const_arg_iterator arg_begin() const

bool isNoCallerSavedRegs() const

Whether this function no longer saves caller registers.

unsigned getRegParm() const

ArrayRef< ExtParameterInfo > getExtParameterInfos() const

CanQualType getReturnType() const

bool isNoCfCheck() const

Whether this function has nocf_check attribute.

CallingConv getASTCallingConvention() const

getASTCallingConvention() - Return the AST-specified calling convention.

const ABIArgInfo & getReturnInfo() const

bool getHasRegParm() const

ArrayRef< ArgInfo > arguments() const

const ArgInfo * const_arg_iterator

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)

static void Profile(llvm::FoldingSetNodeID &ID, bool InstanceMethod, bool ChainCall, bool IsDelegateCall, const FunctionType::ExtInfo &info, ArrayRef< ExtParameterInfo > paramInfos, RequiredArgs required, CanQualType resultType, ArrayRef< CanQualType > argTypes)

friend class TrailingObjects

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

void setArgStruct(llvm::StructType *Ty, CharUnits Align)

size_t numTrailingObjects(OverloadToken< ArgInfo >) const

ExtParameterInfo getExtParameterInfo(unsigned argIndex) const

unsigned getMaxVectorWidth() const

Return the maximum vector width in the arguments.

CharUnits getArgStructAlignment() const

size_t numTrailingObjects(OverloadToken< ExtParameterInfo >) const

unsigned arg_size() const

RequiredArgs getRequiredArgs() const

void setEffectiveCallingConvention(unsigned Value)

unsigned getNumRequiredArgs() const

llvm::StructType * getArgStruct() const

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

void setMaxVectorWidth(unsigned Width)

Set the maximum vector width in the arguments.

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

static RequiredArgs forPrototypePlus(CanQual< FunctionProtoType > prototype, unsigned additional)

bool allowsOptionalArgs() const

unsigned getNumRequiredArgs() const

static RequiredArgs forPrototype(CanQual< FunctionProtoType > prototype)

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

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

static RequiredArgs getFromOpaqueData(unsigned value)

bool isRequiredArg(unsigned argIdx) const

Return true if the argument at a given index is required.

static RequiredArgs forPrototype(const FunctionProtoType *prototype)

unsigned getOpaqueData() const

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

unsigned getNumParams() const

bool isVariadic() const

Whether this function prototype is variadic.

ArrayRef< ExtParameterInfo > getExtParameterInfos() const

bool hasExtParameterInfos() const

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

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

CallingConv getCC() 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...

A (possibly-)qualified type.

bool isIntegralOrEnumerationType() const

Determine whether this type is an integral or enumeration type.

bool hasSignedIntegerRepresentation() const

Determine whether this type has an signed integer representation of some sort, e.g....

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

const FunctionProtoType * T

CallingConv

CallingConv - Specifies the calling convention that a function uses.

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