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

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

clang: lib/CodeGen/SwiftCallingConv.cpp Source File

;

CodeGen;

swiftcall;

llvm::Type *

(llvm::Type *first, llvm::Type *second) {

assert(first != second);

(first->isIntegerTy()) {

(second->isPointerTy())

first;

}

(first->isPointerTy()) {

(second->isIntegerTy())

second;

(second->isPointerTy())

first;

}

(

firstVecTy = dyn_cast<llvm::VectorType>(first)) {

(

secondVecTy = dyn_cast<llvm::VectorType>(second)) {

(

commonTy =

(firstVecTy->getElementType(),

secondVecTy->getElementType())) {

(commonTy == firstVecTy->getElementType() ? first : second);

}

(

->isArrayType()) {

(uint64_t i = 0, e =

->getZExtSize(); i != e; ++i) {

(eltLLVMType, begin + eltSize, begin + 2 * eltSize);

atomicPadding = atomicSize - valueSize;

(

*field : record->

()) {

(field->isBitField()) {

addBitFieldData(field, begin, 0);

cxxRecord = dyn_cast<CXXRecordDecl>(record);

(

&baseSpecifier : cxxRecord->bases()) {

(baseSpecifier.isVirtual())

;

baseRecord = baseSpecifier.getType()->getAsCXXRecordDecl();

(

*field : record->

()) {

fieldOffsetInBits = layout.

(field->getFieldIndex());

(field->isBitField()) {

addBitFieldData(field, begin, fieldOffsetInBits);

(

&vbaseSpecifier : cxxRecord->vbases()) {

baseRecord = vbaseSpecifier.getType()->getAsCXXRecordDecl();

SwiftAggLowering::addBitFieldData(

*bitfield,

uint64_t bitfieldBitBegin) {

(width == 0)

;

bitfieldByteBegin = ctx.toCharUnitsFromBits(bitfieldBitBegin);

uint64_t bitfieldBitLast = bitfieldBitBegin + width - 1;

recordBegin + bitfieldByteEnd);

assert(

&&

);

assert(

&&

);

(

vecTy = dyn_cast<llvm::VectorType>(

)) {

assert(componentTys.size() >= 1);

(

i = 0, e = componentTys.size(); i != e - 1; ++i) {

llvm::Type *componentTy = componentTys[i];

assert(componentSize < end - begin);

addLegalTypedData(componentTy, begin, begin + componentSize);

begin += componentSize;

addLegalTypedData(componentTys.back(), begin, end);

(

intTy = dyn_cast<llvm::IntegerType>(

)) {

addLegalTypedData(

, begin, end);

SwiftAggLowering::addLegalTypedData(llvm::Type *

,

(

vecTy = dyn_cast<llvm::VectorType>(

)) {

eltTy = split.first;

numElts = split.second;

eltSize = (end - begin) / numElts;

(

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

addLegalTypedData(eltTy, begin, begin + eltSize);

assert(begin == end);

addEntry(

, begin, end);

SwiftAggLowering::addEntry(llvm::Type *

,

(!isa<llvm::StructType>(

) && !isa<llvm::ArrayType>(

))) &&

);

(Entries.empty() || Entries.back().End <= begin) {

Entries.push_back({begin, end,

});

index = Entries.size() - 1;

(Entries[index - 1].End <= begin)

;

(Entries[index].

>= end) {

Entries.insert(Entries.begin() + index, {begin, end, type});

(Entries[index].

== begin && Entries[index].End == end) {

(Entries[index].

==

)

;

(Entries[index].

==

) {

}

(

==

) {

Entries[index].Type =

;

Entries[index].Type = entryType;

Entries[index].Type =

;

(

vecTy = dyn_cast_or_null<llvm::VectorType>(

)) {

eltTy = vecTy->getElementType();

(end - begin) / cast<llvm::FixedVectorType>(vecTy)->getNumElements();

(

i = 0,

e = cast<llvm::FixedVectorType>(vecTy)->getNumElements();

addEntry(eltTy, begin, begin + eltSize);

assert(begin == end);

(Entries[index].

&& Entries[index].

->isVectorTy()) {

splitVectorEntry(index);

restartAfterSplit;

Entries[index].Type =

;

(begin < Entries[index].

) {

Entries[index].Begin = begin;

assert(index == 0 || begin >= Entries[index - 1].End);

(end > Entries[index].End) {

assert(Entries[index].

==

);

(index == Entries.size() - 1 || end <= Entries[index + 1].Begin) {

Entries[index].End = end;

Entries[index].End = Entries[index + 1].Begin;

(Entries[index].

==

)

(Entries[index].

->isVectorTy() &&

end < Entries[index].End) {

splitVectorEntry(index);

Entries[index].Type =

;

SwiftAggLowering::splitVectorEntry(

index) {

vecTy = cast<llvm::VectorType>(Entries[index].

);

eltTy = split.first;

numElts = split.second;

Entries.insert(Entries.begin() + index + 1, numElts - 1, StorageEntry());

(

i = 0; i != numElts; ++i) {

idx = index + i;

Entries[idx].Type = eltTy;

Entries[idx].Begin = begin;

Entries[idx].End = begin + eltSize;

(

==

)

;

(!

->isFloatingPointTy() && !

->isVectorTy());

SwiftAggLowering::shouldMergeEntries(

StorageEntry &first,

StorageEntry &second,

(Entries.empty()) {

hasOpaqueEntries = (Entries[0].Type ==

);

(

i = 1, e = Entries.size(); i != e; ++i) {

(shouldMergeEntries(Entries[i - 1], Entries[i], chunkSize)) {

Entries[i - 1].Type =

;

Entries[i].Type =

;

Entries[i - 1].End = Entries[i].Begin;

hasOpaqueEntries =

;

}

(Entries[i].

==

) {

hasOpaqueEntries =

;

(!hasOpaqueEntries) {

orig = std::move(Entries);

assert(Entries.empty());

(

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

(orig[i].

!=

) {

Entries.push_back(orig[i]);

begin = orig[i].Begin;

end = orig[i].End;

orig[i + 1].

==

&&

end == orig[i + 1].

) {

end = orig[i + 1].End;

chunkEnd = chunkBegin + chunkSize;

localEnd = std::min(end, chunkEnd);

(; ; unitSize *= 2) {

assert(unitSize <= chunkSize);

unitEnd = unitBegin + unitSize;

(unitEnd >= localEnd)

;

Entries.push_back({unitBegin, unitEnd, entryTy});

}

(begin != end);

assert(Finished &&

);

(

&entry : Entries) {

callback(entry.Begin, entry.End, entry.Type);

std::pair<llvm::StructType*, llvm::Type*>

assert(Finished &&

);

(Entries.empty()) {

= llvm::StructType::get(ctx);

hasPadding =

;

packed =

;

(

&entry : Entries) {

(entry.Begin != lastEnd) {

paddingSize = entry.Begin - lastEnd;

assert(!paddingSize.isNegative());

padding = llvm::ArrayType::get(llvm::Type::getInt8Ty(ctx),

paddingSize.getQuantity());

elts.push_back(padding);

elts.push_back(entry.Type);

assert(entry.End <= lastEnd);

coercionType = llvm::StructType::get(ctx, elts, packed);

llvm::Type *unpaddedType = coercionType;

(

&entry : Entries) {

elts.push_back(entry.Type);

(elts.size() == 1) {

unpaddedType = elts[0];

unpaddedType = llvm::StructType::get(ctx, elts,

);

}

(Entries.size() == 1) {

unpaddedType = Entries[0].Type;

{ coercionType, unpaddedType };

assert(Finished &&

);

(Entries.empty())

;

(Entries.size() == 1) {

componentTys.reserve(Entries.size());

(

&entry : Entries) {

componentTys.push_back(entry.Type);

asReturnValue) {

size = llvm::bit_ceil(size);

llvm::IntegerType *intTy) {

size = intTy->getBitWidth();

llvm::VectorType *vectorTy) {

CGM, vectorSize, vectorTy->getElementType(),

cast<llvm::FixedVectorType>(vectorTy)->getNumElements());

llvm::Type *eltTy,

numElts) {

assert(numElts > 1 &&

);

std::pair<llvm::Type*, unsigned>

llvm::VectorType *vectorTy) {

numElts = cast<llvm::FixedVectorType>(vectorTy)->getNumElements();

eltTy = vectorTy->getElementType();

{llvm::FixedVectorType::get(eltTy, numElts / 2), 2};

{eltTy, numElts};

llvm::VectorType *origVectorTy,

components.push_back(origVectorTy);

numElts = cast<llvm::FixedVectorType>(origVectorTy)->getNumElements();

eltTy = origVectorTy->getElementType();

assert(numElts != 1);

logCandidateNumElts = llvm::Log2_32(numElts);

candidateNumElts = 1U << logCandidateNumElts;

assert(candidateNumElts <= numElts && candidateNumElts * 2 > numElts);

(candidateNumElts == numElts) {

logCandidateNumElts--;

candidateNumElts >>= 1;

eltSize = (origVectorSize / numElts);

candidateSize = eltSize * candidateNumElts;

(logCandidateNumElts > 0) {

assert(candidateNumElts == 1U << logCandidateNumElts);

assert(candidateNumElts <= numElts);

assert(candidateSize == eltSize * candidateNumElts);

logCandidateNumElts--;

candidateNumElts /= 2;

numVecs = numElts >> logCandidateNumElts;

components.append(numVecs,

llvm::FixedVectorType::get(eltTy, candidateNumElts));

numElts -= (numVecs << logCandidateNumElts);

(numElts == 0)

;

components.push_back(llvm::FixedVectorType::get(eltTy, numElts));

logCandidateNumElts--;

candidateNumElts /= 2;

}

(candidateNumElts > numElts);

components.append(numElts, eltTy);

(lowering.

()) {

(isa<ComplexType>(

)) {

(isa<VectorType>(

)) {

(

->isVoidType()) {

(

i = 0, e = FI.

(); i != e; ++i) {

static ABIArgInfo classifyType(CodeGenModule &CGM, CanQualType type, bool forReturn)

static llvm::Type * getCommonType(llvm::Type *first, llvm::Type *second)

Given two types with the same size, try to find a common type.

static CharUnits getOffsetAtStartOfUnit(CharUnits offset, CharUnits unitSize)

Given a power-of-two unit size, return the offset of the aligned unit of that size which contains the...

static CharUnits getTypeAllocSize(CodeGenModule &CGM, llvm::Type *type)

static bool isPowerOf2(unsigned n)

static ABIArgInfo classifyExpandedType(SwiftAggLowering &lowering, bool forReturn, CharUnits alignmentForIndirect)

static CharUnits getTypeStoreSize(CodeGenModule &CGM, llvm::Type *type)

static bool areBytesInSameUnit(CharUnits first, CharUnits second, CharUnits chunkSize)

static const SwiftABIInfo & getSwiftABIInfo(CodeGenModule &CGM)

static bool isMergeableEntryType(llvm::Type *type)

const ConstantArrayType * getAsConstantArrayType(QualType T) const

CharUnits getTypeAlignInChars(QualType T) const

Return the ABI-specified alignment of a (complete) type T, in characters.

const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const

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

int64_t toBits(CharUnits CharSize) const

Convert a size in characters to a size in bits.

CharUnits getTypeSizeInChars(QualType T) const

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

const TargetInfo & getTargetInfo() const

CharUnits toCharUnitsFromBits(int64_t BitSize) const

Convert a size in bits to a size in characters.

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

bool hasOwnVFPtr() const

hasOwnVFPtr - Does this class provide its own virtual-function table pointer, rather than inheriting ...

bool hasOwnVBPtr() const

hasOwnVBPtr - Does this class provide its own virtual-base table pointer, rather than inheriting one ...

uint64_t getFieldOffset(unsigned FieldNo) const

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

CharUnits getVBPtrOffset() const

getVBPtrOffset - Get the offset for virtual base table pointer.

CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const

getBaseClassOffset - Get the offset, in chars, for the given base class.

CharUnits getVBaseClassOffset(const CXXRecordDecl *VBase) const

getVBaseClassOffset - Get the offset, in chars, for the given base class.

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

bool isZero() const

isZero - Test whether the quantity equals zero.

QuantityType getQuantity() const

getQuantity - Get the raw integer representation of this quantity.

static CharUnits One()

One - Construct a CharUnits quantity of one.

bool isMultipleOf(CharUnits N) const

Test whether this is a multiple of the other value.

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.

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

static ABIArgInfo getIgnore()

static ABIArgInfo getExpand()

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

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

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

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

ABIArgInfo & getReturnInfo()

const_arg_iterator arg_begin() const

CanQualType getReturnType() const

unsigned arg_size() const

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

CodeGenTypes & getTypes()

const llvm::DataLayout & getDataLayout() const

ASTContext & getContext() const

const TargetCodeGenInfo & getTargetCodeGenInfo()

llvm::LLVMContext & getLLVMContext()

llvm::Type * ConvertType(QualType T)

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

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.

bool isSwiftErrorInRegister() const

Returns true if swifterror is lowered to a register by the target ABI.

virtual bool shouldPassIndirectly(ArrayRef< llvm::Type * > ComponentTys, bool AsReturnValue) const

Returns true if an aggregate which expands to the given type sequence should be passed / returned ind...

const SwiftABIInfo & getSwiftABIInfo() const

Returns Swift ABI info helper for the target.

void addOpaqueData(CharUnits begin, CharUnits end)

std::pair< llvm::StructType *, llvm::Type * > getCoerceAndExpandTypes() const

Return the types for a coerce-and-expand operation.

void enumerateComponents(EnumerationCallback callback) const

Enumerate the expanded components of this type.

llvm::function_ref< void(CharUnits offset, CharUnits end, llvm::Type *type)> EnumerationCallback

bool empty() const

Does this lowering require passing any data?

void addTypedData(QualType type, CharUnits begin)

bool shouldPassIndirectly(bool asReturnValue) const

According to the target Swift ABI, should a value with this lowering be passed indirectly?

Complex values, per C99 6.2.5p11.

Represents a member of a struct/union/class.

bool isBitField() const

Determines whether this field is a bitfield.

unsigned getBitWidthValue() const

Computes the bit width of this field, if this is a bit field.

A pointer to member type per C++ 8.3.3 - Pointers to members.

A (possibly-)qualified type.

Represents a struct/union/class.

bool canPassInRegisters() const

Determine whether this class can be passed in registers.

field_range fields() const

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

uint64_t getPointerWidth(LangAS AddrSpace) const

Return the width of pointers on this target, for the specified address space.

virtual bool hasInt128Type() const

Determine whether the __int128 type is supported on this target.

The base class of the type hierarchy.

Defines the clang::TargetInfo interface.

bool isSwiftErrorLoweredInRegister(CodeGenModule &CGM)

Is swifterror lowered to a register by the target ABI?

bool shouldPassIndirectly(CodeGenModule &CGM, ArrayRef< llvm::Type * > types, bool asReturnValue)

Should an aggregate which expands to the given type sequence be passed/returned indirectly under swif...

ABIArgInfo classifyReturnType(CodeGenModule &CGM, CanQualType type)

Classify the rules for how to return a particular type.

bool mustPassRecordIndirectly(CodeGenModule &CGM, const RecordDecl *record)

Is the given record type required to be passed and returned indirectly because of language restrictio...

ABIArgInfo classifyArgumentType(CodeGenModule &CGM, CanQualType type)

Classify the rules for how to pass a particular type.

bool isLegalIntegerType(CodeGenModule &CGM, llvm::IntegerType *type)

Is the given integer type "legal" for Swift's perspective on the current platform?

void legalizeVectorType(CodeGenModule &CGM, CharUnits vectorSize, llvm::VectorType *vectorTy, llvm::SmallVectorImpl< llvm::Type * > &types)

Turn a vector type in a sequence of legal component vector types.

void computeABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI)

Compute the ABI information of a swiftcall function.

bool isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize, llvm::VectorType *vectorTy)

Is the given vector type "legal" for Swift's perspective on the current platform?

std::pair< llvm::Type *, unsigned > splitLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize, llvm::VectorType *vectorTy)

Minimally split a legal vector type.

CharUnits getNaturalAlignment(CodeGenModule &CGM, llvm::Type *type)

Return the Swift CC's notion of the natural alignment of a type.

CharUnits getMaximumVoluntaryIntegerSize(CodeGenModule &CGM)

Return the maximum voluntary integer size for the current target.

const internal::VariadicAllOfMatcher< Type > type

Matches Types in the clang AST.

const AstTypeMatcher< ArrayType > arrayType

Matches all kinds of arrays.

const AstTypeMatcher< AtomicType > atomicType

Matches atomic types.

const AstTypeMatcher< RecordType > recordType

Matches record types (e.g.

const AstTypeMatcher< ComplexType > complexType

Matches C99 complex types.

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

llvm::PointerType * Int8PtrTy

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