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

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

clang: lib/CodeGen/CGRecordLayoutBuilder.cpp Source File

;

CodeGen;

CGRecordLowering {

MemberInfo(

Offset, InfoKind Kind, llvm::Type *Data,

MemberInfo(

Offset, InfoKind Kind, llvm::Type *Data,

(

MemberInfo& a)

{

Offset < a.Offset; }

MemberInfo StorageInfo(

Offset, llvm::Type *

) {

MemberInfo(Offset, MemberInfo::Field,

);

isDiscreteBitFieldABI()

{

->isMsStruct(Context);

isOverlappingVBaseABI()

{

llvm::Type *getIntNType(uint64_t NumBits)

{

AlignedBits = llvm::alignTo(NumBits, Context.

());

llvm::Type::getIntNTy(Types.getLLVMContext(), AlignedBits);

llvm::Type *getCharType()

{

llvm::Type::getIntNTy(Types.getLLVMContext(),

llvm::Type *getByteArrayType(

NumChars)

{

assert(!NumChars.

() &&

);

llvm::Type *

= getCharType();

llvm::Type *getStorageType(

*FD)

{

llvm::Type *

= Types.ConvertTypeForMem(FD->

());

(isDiscreteBitFieldABI())

;

(

)Context.

(getSize(

))));

Types.getCGRecordLayout(RD).getBaseSubobjectLLVMType();

bitsToCharUnits(uint64_t BitOffset)

{

isZeroInitializable(

*FD)

{

Types.isZeroInitializable(FD->

());

isZeroInitializable(

*RD)

{

Types.isZeroInitializable(RD);

appendPaddingBytes(

Size) {

(!

.isZero())

FieldTypes.push_back(getByteArrayType(Size));

llvm::Type *StorageType);

lower(

NonVirtualBaseType);

lowerUnion(

isNonVirtualBaseType);

accumulateFields(

isNonVirtualBaseType);

accumulateBitFields(

isNonVirtualBaseType,

computeVolatileBitfields();

accumulateBases();

accumulateVPtrs();

accumulateVBases();

calculateZeroInit();

calculateTailClippingOffset(

isNonVirtualBaseType)

;

checkBitfieldClipping(

isNonVirtualBaseType)

;

determinePacked(

NVBaseType);

insertPadding();

fillOutputFields();

llvm::DataLayout &DataLayout;

std::vector<MemberInfo> Members;

llvm::DenseMap<const FieldDecl *, unsigned> Fields;

llvm::DenseMap<const FieldDecl *, CGBitFieldInfo> BitFields;

llvm::DenseMap<const CXXRecordDecl *, unsigned> NonVirtualBases;

llvm::DenseMap<const CXXRecordDecl *, unsigned> VirtualBases;

IsZeroInitializable : 1;

IsZeroInitializableAsBase : 1;

CGRecordLowering(

CGRecordLowering &) =

;

operator =(

CGRecordLowering &) =

;

: Types(Types), Context(Types.getContext()),

(

),

Layout(Types.getContext().getASTRecordLayout(

)),

DataLayout(Types.getDataLayout()), IsZeroInitializable(

),

IsZeroInitializableAsBase(

), Packed(Packed) {}

CGRecordLowering::setBitFieldInfo(

(DataLayout.isBigEndian())

CGRecordLowering::lower(

NVBaseType) {

= NVBaseType ? Layout.getNonVirtualSize() : Layout.getSize();

(

->isUnion()) {

lowerUnion(NVBaseType);

computeVolatileBitfields();

accumulateFields(NVBaseType);

(Members.empty()) {

appendPaddingBytes(Size);

computeVolatileBitfields();

llvm::stable_sort(Members);

checkBitfieldClipping(NVBaseType);

Members.push_back(StorageInfo(Size, getIntNType(8)));

determinePacked(NVBaseType);

computeVolatileBitfields();

CGRecordLowering::lowerUnion(

isNonVirtualBaseType) {

isNonVirtualBaseType ? Layout.getDataSize() : Layout.getSize();

llvm::Type *StorageType =

;

SeenNamedMember =

;

(

*Field :

->fields()) {

(

->isBitField()) {

(

->isZeroLengthBitField())

llvm::Type *FieldType = getStorageType(Field);

(LayoutSize < getSize(FieldType))

FieldType = getByteArrayType(LayoutSize);

Fields[

->getCanonicalDecl()] = 0;

llvm::Type *FieldType = getStorageType(Field);

(!SeenNamedMember) {

SeenNamedMember =

->getIdentifier();

(!SeenNamedMember)

(

*FieldRD =

->getType()->getAsRecordDecl())

SeenNamedMember = FieldRD->findFirstNamedDataMember();

(SeenNamedMember && !isZeroInitializable(Field)) {

IsZeroInitializable = IsZeroInitializableAsBase =

;

StorageType = FieldType;

(!IsZeroInitializable)

getAlignment(FieldType) > getAlignment(StorageType) ||

(getAlignment(FieldType) == getAlignment(StorageType) &&

getSize(FieldType) > getSize(StorageType)))

StorageType = FieldType;

appendPaddingBytes(LayoutSize);

(LayoutSize < getSize(StorageType))

StorageType = getByteArrayType(LayoutSize);

FieldTypes.push_back(StorageType);

appendPaddingBytes(LayoutSize - getSize(StorageType));

StorageAlignment = getAlignment(StorageType);

assert((Layout.getSize() % StorageAlignment == 0 ||

Layout.getDataSize() % StorageAlignment) &&

(Layout.getDataSize() % StorageAlignment)

CGRecordLowering::accumulateFields(

isNonVirtualBaseType) {

FieldEnd =

->field_end();

Field != FieldEnd;) {

(

->isBitField()) {

= accumulateBitFields(isNonVirtualBaseType, Field, FieldEnd);

assert((Field == FieldEnd || !

->isBitField()) &&

);

Members.push_back(MemberInfo(

bitsToCharUnits(getFieldBitOffset(*Field)), MemberInfo::Field,

->isPotentiallyOverlapping()

? getStorageType(

->getType()->getAsCXXRecordDecl())

: getStorageType(*Field),

CGRecordLowering::accumulateBitFields(

isNonVirtualBaseType,

(isDiscreteBitFieldABI()) {

(

->isZeroLengthBitField()) {

BitOffset = getFieldBitOffset(*Field);

llvm::Type *

= Types.ConvertTypeForMem(

->getType());

(Run == FieldEnd || BitOffset >= Tail) {

StartBitOffset = BitOffset;

Tail = StartBitOffset + DataLayout.getTypeAllocSizeInBits(

);

Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset),

));

Members.push_back(MemberInfo(bitsToCharUnits(StartBitOffset),

MemberInfo::Field,

, *Field));

AtAlignedBoundary =

;

Barrier =

;

(Field != FieldEnd &&

->isBitField()) {

BitOffset = getFieldBitOffset(*Field);

(

== FieldEnd) {

assert((BitOffset % CharBits) == 0 &&

);

BeginOffset = bitsToCharUnits(BitOffset);

BitSizeSinceBegin = 0;

}

((BitOffset % CharBits) != 0) {

assert(BitOffset == Context.

(BeginOffset) + BitSizeSinceBegin &&

);

(

->isZeroLengthBitField())

AtAlignedBoundary =

;

(

== FieldEnd)

AtAlignedBoundary =

;

InstallBest =

;

(AtAlignedBoundary) {

AccessSize = bitsToCharUnits(BitSizeSinceBegin + CharBits - 1);

(BestEnd ==

) {

BestEndOffset = BeginOffset + AccessSize;

(!BitSizeSinceBegin)

}

(AccessSize > RegSize)

llvm::Type *

= getIntNType(Context.

(AccessSize));

(Align > Layout.getAlignment())

(InstallBest && BestEnd == Field)

(getSize(

) == AccessSize)

BestClipped =

;

(

Probe = Field; Probe != FieldEnd; ++Probe)

assert((getFieldBitOffset(*Probe) % CharBits) == 0 &&

);

LimitOffset = bitsToCharUnits(getFieldBitOffset(*Probe));

(ScissorOffset.

()) {

ScissorOffset = calculateTailClippingOffset(isNonVirtualBaseType);

assert(!ScissorOffset.

() &&

);

LimitOffset = ScissorOffset;

(BeginOffset + TypeSize <= LimitOffset) {

BestEndOffset = BeginOffset + TypeSize;

BestClipped =

;

(Types.getCodeGenOpts().FineGrainedBitfieldAccesses)

BitSizeSinceBegin = Context.

(LimitOffset - BeginOffset);

assert((Field == FieldEnd || !

->isBitField() ||

(getFieldBitOffset(*Field) % CharBits) == 0) &&

);

AccessSize = BestEndOffset - BeginOffset;

(!AccessSize.

()) {

assert(getSize(getIntNType(Context.

(AccessSize))) >

);

= getByteArrayType(AccessSize);

= getIntNType(Context.

(AccessSize));

assert(getSize(

) == AccessSize &&

);

Members.push_back(StorageInfo(BeginOffset,

));

(!

->isZeroLengthBitField())

MemberInfo(BeginOffset, MemberInfo::Field,

, *

));

assert(Field != FieldEnd &&

->isBitField() &&

);

assert(!Barrier &&

);

BitSizeSinceBegin +=

->getBitWidthValue();

CGRecordLowering::accumulateBases() {

(Layout.isPrimaryBaseVirtual()) {

getStorageType(BaseDecl), BaseDecl));

(

&

: RD->bases()) {

(

.isVirtual())

Members.push_back(MemberInfo(Layout.getBaseClassOffset(BaseDecl),

MemberInfo::Base, getStorageType(BaseDecl), BaseDecl));

CGRecordLowering::computeVolatileBitfields() {

(!

() || !Types.getCodeGenOpts().AAPCSBitfieldWidth)

(

&I : BitFields) {

llvm::Type *ResLTy = Types.ConvertTypeForMem(

->getType());

((uint64_t)(Context.

(Layout.getAlignment())) <

ResLTy->getPrimitiveSizeInBits())

OldOffset =

AbsoluteOffset =

StorageSize = ResLTy->getPrimitiveSizeInBits();

(Info.

== StorageSize && (OldOffset % StorageSize == 0))

Offset = AbsoluteOffset & (StorageSize - 1);

(Offset + Info.

> StorageSize)

Offset = StorageSize - (Offset + Info.

);

(End >= RecordSize)

Conflict =

;

(

*F :

->fields()) {

(F->isBitField() && !F->isZeroLengthBitField())

(F->isZeroLengthBitField()) {

(End > FOffset && StorageOffset < FOffset) {

Types.ConvertTypeForMem(F->getType())->getPrimitiveSizeInBits()) -

(End < FOffset || FEnd < StorageOffset)

CGRecordLowering::accumulateVPtrs() {

llvm::PointerType::getUnqual(Types.getLLVMContext())));

llvm::PointerType::getUnqual(Types.getLLVMContext())));

CGRecordLowering::calculateTailClippingOffset(

isNonVirtualBaseType)

{

(!isNonVirtualBaseType && isOverlappingVBaseABI())

(

&

: RD->vbases()) {

(Context.

(BaseDecl) && !hasOwnStorage(RD, BaseDecl))

ScissorOffset = std::min(ScissorOffset,

ScissorOffset;

CGRecordLowering::accumulateVBases() {

(

&

: RD->vbases()) {

(isOverlappingVBaseABI() &&

!hasOwnStorage(RD, BaseDecl)) {

Members.push_back(MemberInfo(Offset, MemberInfo::VBase,

,

Members.push_back(MemberInfo(Offset, MemberInfo::VBase,

getStorageType(BaseDecl), BaseDecl));

(

&

:

->bases())

(!hasOwnStorage(

.getType()->getAsCXXRecordDecl(), Query))

CGRecordLowering::calculateZeroInit() {

(std::vector<MemberInfo>::const_iterator

= Members.begin(),

MemberEnd = Members.end();

IsZeroInitializableAsBase &&

!= MemberEnd; ++

) {

(

->Kind == MemberInfo::Field) {

IsZeroInitializable = IsZeroInitializableAsBase =

;

}

(

->Kind == MemberInfo::Base ||

->Kind == MemberInfo::VBase) {

(isZeroInitializable(

->RD))

IsZeroInitializable =

;

(

->Kind == MemberInfo::Base)

IsZeroInitializableAsBase =

;

CGRecordLowering::checkBitfieldClipping(

IsNonVirtualBaseType)

{

ScissorOffset = calculateTailClippingOffset(IsNonVirtualBaseType);

(

&M : Members) {

assert(M.Offset >= Tail &&

);

Tail = M.Offset + getSize(M.Data);

assert((Tail <= ScissorOffset || M.Offset >= ScissorOffset) &&

);

CGRecordLowering::determinePacked(

NVBaseType) {

(std::vector<MemberInfo>::const_iterator

= Members.begin(),

MemberEnd = Members.end();

(

->Offset < NVSize)

NVAlignment = std::max(NVAlignment, getAlignment(

->Data));

Alignment = std::max(Alignment, getAlignment(

->Data));

(Members.back().Offset % Alignment)

(NVSize % NVAlignment)

Members.back().Data = getIntNType(Context.

(Alignment));

CGRecordLowering::insertPadding() {

std::vector<std::pair<CharUnits, CharUnits> > Padding;

(std::vector<MemberInfo>::const_iterator

= Members.begin(),

MemberEnd = Members.end();

assert(Offset >= Size);

Padding.push_back(std::make_pair(Size, Offset - Size));

(Padding.empty())

(std::vector<std::pair<CharUnits, CharUnits> >::const_iterator

Pad = Padding.begin(), PadEnd = Padding.end();

Pad != PadEnd; ++Pad)

Members.push_back(StorageInfo(Pad->first, getByteArrayType(Pad->second)));

llvm::stable_sort(Members);

CGRecordLowering::fillOutputFields() {

(std::vector<MemberInfo>::const_iterator

= Members.begin(),

MemberEnd = Members.end();

FieldTypes.push_back(

->Data);

(

->Kind == MemberInfo::Field) {

Fields[

->FD->getCanonicalDecl()] = FieldTypes.size() - 1;

setBitFieldInfo(

->FD,

->Offset, FieldTypes.back());

}

(

->Kind == MemberInfo::Base)

NonVirtualBases[

->RD] = FieldTypes.size() - 1;

(

->Kind == MemberInfo::VBase)

VirtualBases[

->RD] = FieldTypes.size() - 1;

uint64_t Offset, uint64_t Size,

uint64_t StorageSize,

llvm::Type *Ty = Types.ConvertTypeForMem(FD->

());

uint64_t TypeSizeInBits = Types.getContext().toBits(TypeSizeInBytes);

(

> TypeSizeInBits) {

= TypeSizeInBits;

(Types.getDataLayout().isBigEndian()) {

std::unique_ptr<CGRecordLayout>

CGRecordLowering Builder(*

,

,

);

Builder.lower(

);

llvm::StructType *BaseTy =

;

(isa<CXXRecordDecl>(

)) {

(Builder.Layout.getNonVirtualSize() != Builder.Layout.getSize()) {

CGRecordLowering BaseBuilder(*

,

,

Builder.Packed);

BaseBuilder.lower(

);

BaseTy = llvm::StructType::create(

(), BaseBuilder.FieldTypes,

, BaseBuilder.Packed);

assert(Builder.Packed == BaseBuilder.Packed &&

);

Ty->setBody(Builder.FieldTypes, Builder.Packed);

RL = std::make_unique<CGRecordLayout>(

Ty, BaseTy, (

)Builder.IsZeroInitializable,

(

)Builder.IsZeroInitializableAsBase);

RL->NonVirtualBases.swap(Builder.NonVirtualBases);

RL->CompleteObjectVirtualBases.swap(Builder.VirtualBases);

RL->FieldInfo.swap(Builder.Fields);

RL->BitFields.swap(Builder.BitFields);

(

().getLangOpts().DumpRecordLayouts) {

llvm::outs() <<

;

llvm::outs() <<

;

->

(llvm::outs());

llvm::outs() <<

;

RL->print(llvm::outs());

assert(TypeSizeInBits ==

().getTypeAllocSizeInBits(Ty) &&

);

uint64_t AlignedNonVirtualTypeSizeInBits =

assert(AlignedNonVirtualTypeSizeInBits ==

);

llvm::StructType *ST = RL->getLLVMType();

llvm::StructLayout *SL =

().getStructLayout(ST);

(

i = 0, e = AST_RL.

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

FieldNo = RL->getLLVMFieldNo(FD);

assert(AST_RL.

(i) == SL->getElementOffsetInBits(FieldNo) &&

);

llvm::Type *ElementTy = ST->getTypeAtIndex(RL->getLLVMFieldNo(FD));

(

->isUnion()) {

assert(

(Info.

+ Info.

) ==

);

assert(Info.

== 0 &&

);

assert(Info.

<= SL->getSizeInBits() &&

);

);

assert(Info.

> 0 &&

);

);

OS <<

;

OS <<

<< *CompleteObjectType <<

;

(BaseSubobjectType)

OS <<

<< *BaseSubobjectType <<

;

OS <<

<< IsZeroInitializable <<

;

OS <<

;

std::vector<std::pair<unsigned, const CGBitFieldInfo*> > BFIs;

(llvm::DenseMap<const FieldDecl*, CGBitFieldInfo>::const_iterator

it = BitFields.begin(), ie = BitFields.end();

it2 = RD->

(); *it2 != it->first; ++it2)

BFIs.push_back(std::make_pair(Index, &it->second));

llvm::array_pod_sort(BFIs.begin(), BFIs.end());

(

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

BFIs[i].second->print(OS);

(llvm::errs());

OS <<

(llvm::errs());

Defines the clang::ASTContext interface.

static bool isAAPCS(const TargetInfo &TargetInfo)

Helper method to check if the underlying ABI is AAPCS.

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

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

const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const

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

bool isNearlyEmpty(const CXXRecordDecl *RD) const

int64_t toBits(CharUnits CharSize) const

Convert a size in characters to a size in bits.

const TargetInfo & getTargetInfo() const

CharUnits toCharUnitsFromBits(int64_t BitSize) const

Convert a size in bits to a size in characters.

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

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

CharUnits getSize() const

getSize - Get the record size in characters.

unsigned getFieldCount() const

getFieldCount - Get the number of fields in the layout.

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 getDataSize() const

getDataSize() - Get the record data size, which is the record size without tail padding,...

CharUnits getVBaseClassOffset(const CXXRecordDecl *VBase) const

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

const VBaseOffsetsMapTy & getVBaseOffsetsMap() const

const CXXRecordDecl * getPrimaryBase() const

getPrimaryBase - Get the primary base for this record.

bool isPrimaryBaseVirtual() const

isPrimaryBaseVirtual - Get whether the primary base for this record is virtual or not.

CharUnits getNonVirtualSize() const

getNonVirtualSize - Get the non-virtual size (in chars) of an object, which is the size of the object...

Represents a C++ struct/union/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.

void print(raw_ostream &OS) const

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

ASTContext & getContext() const

std::unique_ptr< CGRecordLayout > ComputeRecordLayout(const RecordDecl *D, llvm::StructType *Ty)

Compute a new LLVM record layout object for the given record.

llvm::LLVMContext & getLLVMContext()

const llvm::DataLayout & getDataLayout() const

void addRecordTypeName(const RecordDecl *RD, llvm::StructType *Ty, StringRef suffix)

addRecordTypeName - Compute a name from the given record decl with an optional suffix and name the gi...

specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...

DeclContext * getParent()

getParent - Returns the containing DeclContext.

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

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.

unsigned getFieldIndex() const

Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...

FieldDecl * getCanonicalDecl() override

Retrieves the canonical declaration of this field.

DeclarationName getDeclName() const

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

Represents a struct/union/class.

specific_decl_iterator< FieldDecl > field_iterator

field_iterator field_begin() const

bool isMicrosoft() const

Is this ABI an MSVC-compatible ABI?

virtual unsigned getRegisterWidth() const

Return the "preferred" register width on this target.

bool hasCheapUnalignedBitFieldAccess() const

Return true iff unaligned accesses are cheap.

TargetCXXABI getCXXABI() const

Get the C++ ABI currently in use.

virtual StringRef getABI() const

Get the ABI currently in use.

The base class of the type hierarchy.

bool isSignedIntegerOrEnumerationType() const

Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...

bool isEmptyRecordForLayout(const ASTContext &Context, QualType T)

isEmptyRecordForLayout - Return true iff a structure contains only empty base classes (per isEmptyRec...

bool isEmptyFieldForLayout(const ASTContext &Context, const FieldDecl *FD)

isEmptyFieldForLayout - Return true iff the field is "empty", that is, either a zero-width bit-field ...

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

bool operator<(DeclarationName LHS, DeclarationName RHS)

Ordering on two declaration names.

Structure with information about how a bitfield should be accessed.

CharUnits StorageOffset

The offset of the bitfield storage from the start of the struct.

CharUnits VolatileStorageOffset

The offset of the bitfield storage from the start of the struct.

unsigned VolatileOffset

The offset within a contiguous run of bitfields that are represented as a single "field" within the L...

unsigned Offset

The offset within a contiguous run of bitfields that are represented as a single "field" within the L...

unsigned VolatileStorageSize

The storage size in bits which should be used when accessing this bitfield.

void print(raw_ostream &OS) const

unsigned Size

The total size of the bit-field, in bits.

unsigned StorageSize

The storage size in bits which should be used when accessing this bitfield.

unsigned IsSigned

Whether the bit-field is signed.

static CGBitFieldInfo MakeInfo(class CodeGenTypes &Types, const FieldDecl *FD, uint64_t Offset, uint64_t Size, uint64_t StorageSize, CharUnits StorageOffset)

Given a bit-field decl, build an appropriate helper object for accessing that field (which is expecte...

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