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

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

clang: lib/AST/RecordLayoutBuilder.cpp Source File

;

BaseSubobjectInfo {

BaseSubobjectInfo *PrimaryVirtualBaseInfo;

BaseSubobjectInfo *Derived;

ExternalLayout {

ExternalLayout() =

;

llvm::DenseMap<const FieldDecl *, uint64_t> FieldOffsets;

llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsets;

llvm::DenseMap<const CXXRecordDecl *, CharUnits> VirtualBaseOffsets;

assert(FieldOffsets.count(FD) &&

);

FieldOffsets[FD];

Known = BaseOffsets.find(RD);

(Known == BaseOffsets.end())

BaseOffset = Known->second;

Known = VirtualBaseOffsets.find(RD);

(Known == VirtualBaseOffsets.end())

BaseOffset = Known->second;

EmptySubobjectMap {

llvm::TinyPtrVector<const CXXRecordDecl *> ClassVectorTy;

llvm::DenseMap<CharUnits, ClassVectorTy> EmptyClassOffsetsMapTy;

EmptyClassOffsetsMapTy EmptyClassOffsets;

ComputeEmptySubobjectSizes();

UpdateEmptyBaseSubobjects(

BaseSubobjectInfo *Info,

Offset,

PlacingEmptyBase);

PlacingOverlappingField);

PlacingOverlappingField);

AnyEmptySubobjectsBeyondOffset(

Offset)

{

Offset <= MaxEmptyClassOffset;

assert(FieldOffset % CharWidth == 0 &&

);

CanPlaceBaseSubobjectAtOffset(

BaseSubobjectInfo *Info,

CanPlaceFieldSubobjectAtOffset(

*RD,

CanPlaceFieldSubobjectAtOffset(

*FD,

ComputeEmptySubobjectSizes();

CanPlaceBaseAtOffset(

BaseSubobjectInfo *Info,

EmptySubobjectMap::ComputeEmptySubobjectSizes() {

EmptySize = Layout.

();

(EmptySize > SizeOfLargestEmptySubobject)

SizeOfLargestEmptySubobject = EmptySize;

EmptySize = Layout.

();

(EmptySize > SizeOfLargestEmptySubobject)

SizeOfLargestEmptySubobject = EmptySize;

EmptySubobjectMap::CanPlaceSubobjectAtOffset(

*RD,

EmptyClassOffsetsMapTy::const_iterator I = EmptyClassOffsets.find(Offset);

(I == EmptyClassOffsets.end())

ClassVectorTy &Classes = I->second;

(!llvm::is_contained(Classes, RD))

EmptySubobjectMap::AddSubobjectAtOffset(

*RD,

ClassVectorTy &Classes = EmptyClassOffsets[Offset];

(llvm::is_contained(Classes, RD))

Classes.push_back(RD);

(Offset > MaxEmptyClassOffset)

MaxEmptyClassOffset = Offset;

EmptySubobjectMap::CanPlaceBaseSubobjectAtOffset(

BaseSubobjectInfo *Info,

(!AnyEmptySubobjectsBeyondOffset(Offset))

(!CanPlaceSubobjectAtOffset(Info->Class, Offset))

(

BaseSubobjectInfo *

: Info->Bases) {

(

->IsVirtual)

(!CanPlaceBaseSubobjectAtOffset(

, BaseOffset))

(Info->PrimaryVirtualBaseInfo) {

BaseSubobjectInfo *PrimaryVirtualBaseInfo = Info->PrimaryVirtualBaseInfo;

(Info == PrimaryVirtualBaseInfo->Derived) {

(!CanPlaceBaseSubobjectAtOffset(PrimaryVirtualBaseInfo, Offset))

(

*Field : Info->Class->fields()) {

(

->isBitField())

(!CanPlaceFieldSubobjectAtOffset(Field, FieldOffset))

EmptySubobjectMap::UpdateEmptyBaseSubobjects(

BaseSubobjectInfo *Info,

PlacingEmptyBase) {

(!PlacingEmptyBase && Offset >= SizeOfLargestEmptySubobject) {

AddSubobjectAtOffset(Info->Class, Offset);

(

BaseSubobjectInfo *

: Info->Bases) {

(

->IsVirtual)

UpdateEmptyBaseSubobjects(

, BaseOffset, PlacingEmptyBase);

(Info->PrimaryVirtualBaseInfo) {

BaseSubobjectInfo *PrimaryVirtualBaseInfo = Info->PrimaryVirtualBaseInfo;

(Info == PrimaryVirtualBaseInfo->Derived)

UpdateEmptyBaseSubobjects(PrimaryVirtualBaseInfo, Offset,

(

*Field : Info->Class->fields()) {

(

->isBitField())

UpdateEmptyFieldSubobjects(Field, FieldOffset, PlacingEmptyBase);

EmptySubobjectMap::CanPlaceBaseAtOffset(

BaseSubobjectInfo *Info,

(SizeOfLargestEmptySubobject.isZero())

(!CanPlaceBaseSubobjectAtOffset(Info, Offset))

UpdateEmptyBaseSubobjects(Info, Offset, Info->Class->isEmpty());

EmptySubobjectMap::CanPlaceFieldSubobjectAtOffset(

*RD,

(!AnyEmptySubobjectsBeyondOffset(Offset))

(!CanPlaceSubobjectAtOffset(RD, Offset))

(

.isVirtual())

(!CanPlaceFieldSubobjectAtOffset(BaseDecl, Class, BaseOffset))

(!CanPlaceFieldSubobjectAtOffset(VBaseDecl, Class, VBaseOffset))

(

->isBitField())

(!CanPlaceFieldSubobjectAtOffset(Field, FieldOffset))

EmptySubobjectMap::CanPlaceFieldSubobjectAtOffset(

*FD,

(!AnyEmptySubobjectsBeyondOffset(Offset))

CanPlaceFieldSubobjectAtOffset(RD, RD, Offset);

(uint64_t I = 0; I != NumElements; ++I) {

(!AnyEmptySubobjectsBeyondOffset(ElementOffset))

(!CanPlaceFieldSubobjectAtOffset(RD, RD, ElementOffset))

ElementOffset += Layout.

();

EmptySubobjectMap::CanPlaceFieldAtOffset(

*FD,

(!CanPlaceFieldSubobjectAtOffset(FD, Offset))

UpdateEmptyFieldSubobjects(FD, Offset, FD->

<NoUniqueAddressAttr>());

EmptySubobjectMap::UpdateEmptyFieldSubobjects(

PlacingOverlappingField) {

(!PlacingOverlappingField && Offset >= SizeOfLargestEmptySubobject)

AddSubobjectAtOffset(RD, Offset);

(

.isVirtual())

UpdateEmptyFieldSubobjects(BaseDecl, Class, BaseOffset,

PlacingOverlappingField);

UpdateEmptyFieldSubobjects(VBaseDecl, Class, VBaseOffset,

PlacingOverlappingField);

(

->isBitField())

UpdateEmptyFieldSubobjects(Field, FieldOffset, PlacingOverlappingField);

EmptySubobjectMap::UpdateEmptyFieldSubobjects(

UpdateEmptyFieldSubobjects(RD, RD, Offset, PlacingOverlappingField);

(uint64_t I = 0; I != NumElements; ++I) {

(!PlacingOverlappingField &&

ElementOffset >= SizeOfLargestEmptySubobject)

UpdateEmptyFieldSubobjects(RD, RD, ElementOffset,

PlacingOverlappingField);

ElementOffset += Layout.

();

ItaniumRecordLayoutBuilder {

EmptySubobjectMap *EmptySubobjects;

LLVM_PREFERRED_TYPE(

)

UseExternalLayout : 1;

LLVM_PREFERRED_TYPE(

)

InferAlignment : 1;

LLVM_PREFERRED_TYPE(

)

LLVM_PREFERRED_TYPE(

)

IsUnion : 1;

LLVM_PREFERRED_TYPE(

)

IsMac68kAlign : 1;

LLVM_PREFERRED_TYPE(

)

IsNaturalAlign : 1;

LLVM_PREFERRED_TYPE(

)

IsMsStruct : 1;

UnfilledBitsInLastUnit;

LastBitfieldStorageUnitSize;

PrimaryBaseIsVirtual;

HandledFirstNonOverlappingEmptyField;

llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetsMapTy;

BaseOffsetsMapTy Bases;

ItaniumRecordLayoutBuilder(

&Context,

EmptySubobjectMap *EmptySubobjects)

: Context(Context), EmptySubobjects(EmptySubobjects),

(0),

UnadjustedAlignment(

::One()), UseExternalLayout(

),

IsMac68kAlign(

),

IsNaturalAlign(!Context.getTargetInfo().getTriple().isOSAIX()),

IsMsStruct(

), UnfilledBitsInLastUnit(0),

LastBitfieldStorageUnitSize(0), MaxFieldAlignment(

::

()),

PreferredNVAlignment(

::One()),

PaddedFieldSize(

::

()), PrimaryBase(nullptr),

PrimaryBaseIsVirtual(

), HasOwnVFPtr(

), HasPackedField(

),

HandledFirstNonOverlappingEmptyField(

),

FirstNearlyEmptyVBase(nullptr) {}

LayoutField(

*

,

InsertExtraPadding);

LayoutWideBitField(uint64_t FieldSize, uint64_t StorageUnitSize,

llvm::SpecificBumpPtrAllocator<BaseSubobjectInfo> BaseSubobjectInfoAllocator;

llvm::DenseMap<const CXXRecordDecl *, BaseSubobjectInfo *>

BaseSubobjectInfoMapTy;

BaseSubobjectInfoMapTy NonVirtualBaseInfo;

BaseSubobjectInfo *ComputeBaseSubobjectInfo(

*RD,

BaseSubobjectInfo *Derived);

EnsureVTablePointerAlignment(

UnpackedBaseAlign);

LayoutNonVirtualBase(

BaseSubobjectInfo *

);

AddPrimaryVirtualBaseOffsets(

BaseSubobjectInfo *Info,

LayoutVirtualBase(

BaseSubobjectInfo *

);

InitializeLayout(

*

);

UpdateAlignment(NewAlignment, UnpackedNewAlignment, NewAlignment);

UpdateAlignment(

NewAlignment) {

UpdateAlignment(NewAlignment, NewAlignment, NewAlignment);

uint64_t ComputedOffset);

CheckFieldPadding(uint64_t Offset, uint64_t UnpaddedOffset,

uint64_t UnpackedOffset,

UnpackedAlign,

setSize(uint64_t NewSize) {

= NewSize; }

getAlignment()

{

Alignment; }

getDataSizeInBits()

{

DataSize; }

setDataSize(

NewSize) { DataSize = Context.

(NewSize); }

setDataSize(uint64_t NewSize) { DataSize = NewSize; }

ItaniumRecordLayoutBuilder(

ItaniumRecordLayoutBuilder &) =

;

operator=(

ItaniumRecordLayoutBuilder &) =

;

ItaniumRecordLayoutBuilder::SelectPrimaryVBase(

*RD) {

(

&I : RD->

()) {

assert(!I.getType()->isDependentType() &&

);

(!IndirectPrimaryBases.count(

)) {

PrimaryBaseIsVirtual =

;

(!FirstNearlyEmptyVBase)

FirstNearlyEmptyVBase =

;

SelectPrimaryVBase(

);

ItaniumRecordLayoutBuilder::DeterminePrimaryBase(

*RD) {

(

&I : RD->

()) {

(

->isDynamicClass()) {

PrimaryBaseIsVirtual =

;

SelectPrimaryVBase(RD);

(FirstNearlyEmptyVBase) {

PrimaryBase = FirstNearlyEmptyVBase;

PrimaryBaseIsVirtual =

;

assert(!PrimaryBase &&

);

BaseSubobjectInfo *ItaniumRecordLayoutBuilder::ComputeBaseSubobjectInfo(

*RD,

IsVirtual, BaseSubobjectInfo *Derived) {

BaseSubobjectInfo *Info;

assert(InfoSlot->Class == RD &&

);

InfoSlot =

(BaseSubobjectInfoAllocator.Allocate()) BaseSubobjectInfo;

Info =

(BaseSubobjectInfoAllocator.Allocate()) BaseSubobjectInfo;

Info->IsVirtual = IsVirtual;

Info->Derived =

;

Info->PrimaryVirtualBaseInfo =

;

BaseSubobjectInfo *PrimaryVirtualBaseInfo =

;

assert(PrimaryVirtualBase &&

);

(PrimaryVirtualBaseInfo) {

(PrimaryVirtualBaseInfo->Derived) {

PrimaryVirtualBase =

;

Info->PrimaryVirtualBaseInfo = PrimaryVirtualBaseInfo;

PrimaryVirtualBaseInfo->Derived = Info;

(

&I : RD->

()) {

IsVirtual = I.isVirtual();

*BaseDecl = I.getType()->getAsCXXRecordDecl();

Info->Bases.push_back(ComputeBaseSubobjectInfo(BaseDecl, IsVirtual, Info));

(PrimaryVirtualBase && !PrimaryVirtualBaseInfo) {

assert(PrimaryVirtualBaseInfo &&

);

Info->PrimaryVirtualBaseInfo = PrimaryVirtualBaseInfo;

PrimaryVirtualBaseInfo->Derived = Info;

ItaniumRecordLayoutBuilder::ComputeBaseSubobjectInfo(

(

&I : RD->

()) {

IsVirtual = I.isVirtual();

*BaseDecl = I.getType()->getAsCXXRecordDecl();

BaseSubobjectInfo *Info = ComputeBaseSubobjectInfo(BaseDecl, IsVirtual,

);

assert(!NonVirtualBaseInfo.count(BaseDecl) &&

);

NonVirtualBaseInfo.insert(std::make_pair(BaseDecl, Info));

ItaniumRecordLayoutBuilder::EnsureVTablePointerAlignment(

(!MaxFieldAlignment.

()) {

BaseAlign = std::min(BaseAlign, MaxFieldAlignment);

UnpackedBaseAlign = std::min(UnpackedBaseAlign, MaxFieldAlignment);

setSize(getSize().alignTo(BaseAlign));

UpdateAlignment(BaseAlign, UnpackedBaseAlign, BaseAlign);

ItaniumRecordLayoutBuilder::LayoutNonVirtualBases(

DeterminePrimaryBase(RD);

ComputeBaseSubobjectInfo(RD);

(PrimaryBaseIsVirtual) {

BaseSubobjectInfo *PrimaryBaseInfo =

.lookup(PrimaryBase);

PrimaryBaseInfo->Derived =

;

IndirectPrimaryBases.insert(PrimaryBase);

assert(!VisitedVirtualBases.count(PrimaryBase) &&

);

VisitedVirtualBases.insert(PrimaryBase);

LayoutVirtualBase(PrimaryBaseInfo);

BaseSubobjectInfo *PrimaryBaseInfo =

NonVirtualBaseInfo.lookup(PrimaryBase);

assert(PrimaryBaseInfo &&

);

LayoutNonVirtualBase(PrimaryBaseInfo);

assert(DataSize == 0 &&

);

EnsureVTablePointerAlignment(PtrAlign);

HasOwnVFPtr =

;

assert(!IsUnion &&

);

HandledFirstNonOverlappingEmptyField =

;

setSize(getSize() + PtrWidth);

setDataSize(getSize());

(

&I : RD->

()) {

*BaseDecl = I.getType()->getAsCXXRecordDecl();

(BaseDecl == PrimaryBase && !PrimaryBaseIsVirtual)

BaseSubobjectInfo *BaseInfo = NonVirtualBaseInfo.

(BaseDecl);

assert(BaseInfo &&

);

LayoutNonVirtualBase(BaseInfo);

ItaniumRecordLayoutBuilder::LayoutNonVirtualBase(

BaseSubobjectInfo *

) {

assert(!Bases.count(

->Class) &&

);

Bases.insert(std::make_pair(

->Class, Offset));

AddPrimaryVirtualBaseOffsets(

, Offset);

ItaniumRecordLayoutBuilder::AddPrimaryVirtualBaseOffsets(

BaseSubobjectInfo *Info,

Offset) {

(!Info->Class->getNumVBases())

(Info->PrimaryVirtualBaseInfo) {

assert(Info->PrimaryVirtualBaseInfo->IsVirtual &&

);

(Info->PrimaryVirtualBaseInfo->Derived == Info) {

assert(!VBases.count(Info->PrimaryVirtualBaseInfo->Class) &&

);

VBases.insert(std::make_pair(Info->PrimaryVirtualBaseInfo->Class,

AddPrimaryVirtualBaseOffsets(Info->PrimaryVirtualBaseInfo, Offset);

(

BaseSubobjectInfo *

: Info->Bases) {

(

->IsVirtual)

AddPrimaryVirtualBaseOffsets(

, BaseOffset);

ItaniumRecordLayoutBuilder::LayoutVirtualBases(

PrimaryBaseIsVirtual;

(MostDerivedClass == RD) {

PrimaryBase = this->PrimaryBase;

PrimaryBaseIsVirtual = this->PrimaryBaseIsVirtual;

assert(!

.getType()->isDependentType() &&

);

(

.isVirtual()) {

(PrimaryBase != BaseDecl || !PrimaryBaseIsVirtual) {

IndirectPrimaryBase = IndirectPrimaryBases.count(BaseDecl);

(!IndirectPrimaryBase) {

(!VisitedVirtualBases.insert(BaseDecl).second)

BaseSubobjectInfo *BaseInfo =

.lookup(BaseDecl);

assert(BaseInfo &&

);

LayoutVirtualBase(BaseInfo);

LayoutVirtualBases(BaseDecl, MostDerivedClass);

ItaniumRecordLayoutBuilder::LayoutVirtualBase(

BaseSubobjectInfo *

) {

assert(!

->Derived &&

);

assert(!VBases.count(

->Class) &&

);

VBases.insert(std::make_pair(

->Class,

AddPrimaryVirtualBaseOffsets(

, Offset);

ItaniumRecordLayoutBuilder::LayoutBase(

BaseSubobjectInfo *

) {

assert(!IsUnion &&

);

HasExternalLayout =

;

(UseExternalLayout) {

(

->IsVirtual)

HasExternalLayout =

.getExternalVBaseOffset(

->Class, Offset);

HasExternalLayout =

.getExternalNVBaseOffset(

->Class, Offset);

getBaseOrPreferredBaseAlignFromUnpacked = [&](

UnpackedAlign) {

(Packed && ((Context.

().getClangABICompat() <=

getBaseOrPreferredBaseAlignFromUnpacked(UnpackedBaseAlign);

getBaseOrPreferredBaseAlignFromUnpacked(UnpackedPreferredBaseAlign);

DefaultsToAIXPowerAlignment =

(DefaultsToAIXPowerAlignment) {

(!

->Class->isEmpty() && !HandledFirstNonOverlappingEmptyField) {

HandledFirstNonOverlappingEmptyField =

;

}

(!IsNaturalAlign) {

UnpackedPreferredBaseAlign = UnpackedBaseAlign;

PreferredBaseAlign = BaseAlign;

UnpackedAlignTo = !DefaultsToAIXPowerAlignment

: UnpackedPreferredBaseAlign;

(

->Class->isEmpty() &&

setSize(std::max(getSize(), Layout.

()));

UpdateAlignment(BaseAlign, UnpackedAlignTo, PreferredBaseAlign);

(!MaxFieldAlignment.

()) {

BaseAlign = std::min(BaseAlign, MaxFieldAlignment);

PreferredBaseAlign = std::min(PreferredBaseAlign, MaxFieldAlignment);

UnpackedAlignTo = std::min(UnpackedAlignTo, MaxFieldAlignment);

!DefaultsToAIXPowerAlignment ? BaseAlign : PreferredBaseAlign;

(!HasExternalLayout) {

Offset = getDataSize().alignTo(AlignTo);

(!EmptySubobjects->CanPlaceBaseAtOffset(

, Offset))

Allowed = EmptySubobjects->CanPlaceBaseAtOffset(

, Offset);

assert(Allowed &&

);

(InferAlignment && Offset < getDataSize().alignTo(AlignTo)) {

InferAlignment =

;

(!

->Class->isEmpty()) {

setSize(std::max(getSize(), getDataSize()));

setSize(std::max(getSize(), Offset + Layout.

()));

UpdateAlignment(BaseAlign, UnpackedAlignTo, PreferredBaseAlign);

ItaniumRecordLayoutBuilder::InitializeLayout(

*

) {

(

*RD = dyn_cast<RecordDecl>(

)) {

Packed =

->

<PackedAttr>();

(

DefaultMaxFieldAlignment = Context.

().PackStruct) {

(

->

<AlignMac68kAttr>()) {

!

->

<AlignNaturalAttr>() &&

);

IsMac68kAlign =

;

(

->

<AlignNaturalAttr>())

IsNaturalAlign =

;

(

MaxFieldAlignmentAttr *MFAA =

->

<MaxFieldAlignmentAttr>())

HandledFirstNonOverlappingEmptyField =

(

*RD = dyn_cast<RecordDecl>(

))

UseExternalLayout = Source->layoutRecordType(

(UseExternalLayout) {

InferAlignment =

;

ItaniumRecordLayoutBuilder::Layout(

*

) {

InitializeLayout(

);

ItaniumRecordLayoutBuilder::Layout(

*RD) {

InitializeLayout(RD);

LayoutNonVirtualBases(RD);

NonVirtualAlignment = Alignment;

PreferredNVAlignment = PreferredAlignment;

LayoutVirtualBases(RD, RD);

(

.isVirtual())

assert(Bases.count(BaseDecl) &&

);

assert(VBases.count(BaseDecl) &&

);

setSize(getDataSize());

InitializeLayout(

);

(

*IVD =

->all_declared_ivar_begin(); IVD;

IVD = IVD->getNextIvar())

LayoutField(IVD,

);

ItaniumRecordLayoutBuilder::LayoutFields(

*

) {

InsertExtraPadding =

->mayInsertExtraPadding(

);

HasFlexibleArrayMember =

->hasFlexibleArrayMember();

(

I =

->field_begin(), End =

->field_end(); I != End; ++I) {

LayoutField(*I, InsertExtraPadding &&

(std::next(I) != End || !HasFlexibleArrayMember));

llvm::alignTo(Size, CharAlignment);

ItaniumRecordLayoutBuilder::LayoutWideBitField(uint64_t FieldSize,

uint64_t StorageUnitSize,

);

(

&QT : IntegralPODTypes) {

(Size > FieldSize)

assert(!

.isNull() &&

);

UnfilledBitsInLastUnit = 0;

LastBitfieldStorageUnitSize = 0;

UnpaddedFieldOffset = getDataSizeInBits() - UnfilledBitsInLastUnit;

setDataSize(std::max(getDataSizeInBits(), RoundedFieldSize));

FieldOffset = llvm::alignTo(getDataSizeInBits(), Context.

(TypeAlign));

NewSizeInBits = FieldOffset + FieldSize;

UnfilledBitsInLastUnit = getDataSizeInBits() - NewSizeInBits;

FieldOffsets.push_back(FieldOffset);

CheckFieldPadding(FieldOffset, UnpaddedFieldOffset, FieldOffset,

Context.

(TypeAlign), FieldPacked,

);

setSize(std::max(getSizeInBits(), getDataSizeInBits()));

UpdateAlignment(TypeAlign);

ItaniumRecordLayoutBuilder::LayoutBitField(

*

) {

FieldPacked = Packed ||

->

<PackedAttr>();

FieldSize =

->getBitWidthValue();

FieldAlign = FieldInfo.

;

FieldAlign = StorageUnitSize;

(LastBitfieldStorageUnitSize != StorageUnitSize ||

UnfilledBitsInLastUnit < FieldSize) {

(!LastBitfieldStorageUnitSize && !FieldSize)

UnfilledBitsInLastUnit = 0;

LastBitfieldStorageUnitSize = 0;

StorageUnitSize = 32;

(!AlignIsRequired)

(FieldAlign < StorageUnitSize) {

FieldAlign = StorageUnitSize;

(FieldSize > StorageUnitSize && !

(Context)) {

LayoutWideBitField(FieldSize, StorageUnitSize, FieldPacked,

);

IsUnion ? 0 : (getDataSizeInBits() - UnfilledBitsInLastUnit);

(FieldSize == 0 &&

(!IsUnion && FieldOffset == 0 &&

ZeroLengthBitfieldBoundary =

FieldAlign = std::max(FieldAlign, ZeroLengthBitfieldBoundary);

UnpackedFieldAlign = FieldAlign;

(!IsMsStruct && FieldPacked && FieldSize != 0)

(ExplicitFieldAlign) {

FieldAlign = std::max(FieldAlign, ExplicitFieldAlign);

UnpackedFieldAlign = std::max(UnpackedFieldAlign, ExplicitFieldAlign);

MaxFieldAlignmentInBits = Context.

(MaxFieldAlignment);

(!MaxFieldAlignment.

() && FieldSize) {

UnpackedFieldAlign = std::min(UnpackedFieldAlign, MaxFieldAlignmentInBits);

FieldAlign = UnpackedFieldAlign;

FieldAlign = std::min(FieldAlign, MaxFieldAlignmentInBits);

(IsMsStruct && IsUnion) {

FieldAlign = UnpackedFieldAlign = 1;

UnpaddedFieldOffset = FieldOffset;

UnpackedFieldOffset = FieldOffset;

(FieldSize == 0 || FieldSize > UnfilledBitsInLastUnit) {

FieldOffset = llvm::alignTo(FieldOffset, FieldAlign);

UnpackedFieldOffset =

llvm::alignTo(UnpackedFieldOffset, UnpackedFieldAlign);

UnfilledBitsInLastUnit = 0;

AllowPadding = MaxFieldAlignment.

();

(FieldSize == 0 ||

(FieldOffset & (FieldAlign - 1)) + FieldSize > StorageUnitSize)) {

FieldOffset = llvm::alignTo(FieldOffset, FieldAlign);

}

(ExplicitFieldAlign &&

(MaxFieldAlignmentInBits == 0 ||

ExplicitFieldAlign <= MaxFieldAlignmentInBits) &&

FieldOffset = llvm::alignTo(FieldOffset, ExplicitFieldAlign);

(FieldSize == 0 ||

(UnpackedFieldOffset & (UnpackedFieldAlign - 1)) + FieldSize >

UnpackedFieldOffset =

llvm::alignTo(UnpackedFieldOffset, UnpackedFieldAlign);

(ExplicitFieldAlign &&

(MaxFieldAlignmentInBits == 0 ||

ExplicitFieldAlign <= MaxFieldAlignmentInBits) &&

UnpackedFieldOffset =

llvm::alignTo(UnpackedFieldOffset, ExplicitFieldAlign);

(UseExternalLayout)

FieldOffset = updateExternalFieldOffset(

, FieldOffset);

FieldOffsets.push_back(FieldOffset);

!

->getIdentifier())

FieldAlign = UnpackedFieldAlign = 1;

(!MaxFieldAlignment.

()) {

UnpackedFieldAlign =

std::min(UnpackedFieldAlign, MaxFieldAlignmentInBits);

FieldAlign = std::min(FieldAlign, MaxFieldAlignmentInBits);

(!UseExternalLayout)

CheckFieldPadding(FieldOffset, UnpaddedFieldOffset, UnpackedFieldOffset,

UnpackedFieldAlign, FieldPacked,

);

RoundedFieldSize = (FieldSize ? StorageUnitSize

setDataSize(std::max(getDataSizeInBits(), RoundedFieldSize));

}

(IsMsStruct && FieldSize) {

(!UnfilledBitsInLastUnit) {

setDataSize(FieldOffset + StorageUnitSize);

UnfilledBitsInLastUnit = StorageUnitSize;

UnfilledBitsInLastUnit -= FieldSize;

LastBitfieldStorageUnitSize = StorageUnitSize;

NewSizeInBits = FieldOffset + FieldSize;

setDataSize(llvm::alignTo(NewSizeInBits, CharAlignment));

UnfilledBitsInLastUnit = getDataSizeInBits() - NewSizeInBits;

LastBitfieldStorageUnitSize = 0;

setSize(std::max(getSizeInBits(), getDataSizeInBits()));

UnadjustedAlignment =

ItaniumRecordLayoutBuilder::LayoutField(

*

,

InsertExtraPadding) {

*FieldClass =

->getType()->getAsCXXRecordDecl();

IsOverlappingEmptyField =

->isPotentiallyOverlapping() && FieldClass->isEmpty();

(IsUnion || IsOverlappingEmptyField) ?

() : getDataSize();

DefaultsToAIXPowerAlignment =

FoundFirstNonOverlappingEmptyFieldForAIX =

;

(DefaultsToAIXPowerAlignment && !HandledFirstNonOverlappingEmptyField) {

);

(!IsOverlappingEmptyField) {

FoundFirstNonOverlappingEmptyFieldForAIX =

;

HandledFirstNonOverlappingEmptyField = !IsUnion;

(

->isBitField()) {

LayoutBitField(

);

UnpaddedFieldOffset = getDataSizeInBits() - UnfilledBitsInLastUnit;

UnfilledBitsInLastUnit = 0;

LastBitfieldStorageUnitSize = 0;

setDeclInfo = [&](

IsIncompleteArrayType) {

FieldAlign = TI.Align;

EffectiveFieldSize = FieldSize =

AlignRequirement = TI.AlignRequirement;

(

->getType()->isIncompleteArrayType()) {

setDeclInfo(

);

setDeclInfo(

);

(

->isPotentiallyOverlapping()) {

EffectiveFieldSize =

(!llvm::isPowerOf2_64(TypeSize.

())) {

);

(TypeSize > FieldAlign &&

FieldAlign = TypeSize;

FieldPacked = (Packed && (!FieldClass || FieldClass->isPOD() ||

FieldClass->hasAttr<PackedAttr>() ||

alignedAttrCanDecreaseAIXAlignment = [AlignRequirement, FieldPacked] {

(DefaultsToAIXPowerAlignment && !alignedAttrCanDecreaseAIXAlignment() &&

(FoundFirstNonOverlappingEmptyFieldForAIX || IsNaturalAlign)) {

performBuiltinTypeAlignmentUpgrade = [&](

*BTy) {

(BTy->getKind() == BuiltinType::Double ||

BTy->getKind() == BuiltinType::LongDouble) {

);

*BaseTy =

->getType()->getBaseElementTypeUnsafe();

performBuiltinTypeAlignmentUpgrade(

performBuiltinTypeAlignmentUpgrade(BTy);

assert(RD &&

);

UnpackedFieldAlign = FieldAlign;

UnpackedFieldOffset = FieldOffset;

OriginalFieldAlign = UnpackedFieldAlign;

PackedFieldAlign = std::max(PackedFieldAlign, MaxAlignmentInChars);

PreferredAlign = std::max(PreferredAlign, MaxAlignmentInChars);

UnpackedFieldAlign = std::max(UnpackedFieldAlign, MaxAlignmentInChars);

(!MaxFieldAlignment.

()) {

PackedFieldAlign = std::min(PackedFieldAlign, MaxFieldAlignment);

PreferredAlign = std::min(PreferredAlign, MaxFieldAlignment);

UnpackedFieldAlign = std::min(UnpackedFieldAlign, MaxFieldAlignment);

FieldAlign = UnpackedFieldAlign;

(DefaultsToAIXPowerAlignment)

UnpackedFieldAlign = PreferredAlign;

PreferredAlign = PackedFieldAlign;

FieldAlign = PackedFieldAlign;

!DefaultsToAIXPowerAlignment ? FieldAlign : PreferredAlign;

FieldOffset = FieldOffset.

(AlignTo);

UnpackedFieldOffset = UnpackedFieldOffset.

(UnpackedFieldAlign);

(UseExternalLayout) {

updateExternalFieldOffset(

, Context.

(FieldOffset)));

(!IsUnion && EmptySubobjects) {

Allowed = EmptySubobjects->CanPlaceFieldAtOffset(

, FieldOffset);

assert(Allowed &&

);

(!IsUnion && EmptySubobjects) {

(!EmptySubobjects->CanPlaceFieldAtOffset(

, FieldOffset)) {

FieldOffset = getDataSize().

(AlignTo);

FieldOffset += AlignTo;

FieldOffsets.push_back(Context.

(FieldOffset));

(!UseExternalLayout)

CheckFieldPadding(Context.

(FieldOffset), UnpaddedFieldOffset,

Context.

(UnpackedFieldOffset),

Context.

(UnpackedFieldAlign), FieldPacked,

);

(InsertExtraPadding) {

ExtraSizeForAsan = ASanAlignment;

(FieldSize % ASanAlignment)

EffectiveFieldSize = FieldSize = FieldSize + ExtraSizeForAsan;

(!IsOverlappingEmptyField) {

EffectiveFieldSizeInBits = Context.

(EffectiveFieldSize);

setDataSize(std::max(getDataSizeInBits(), EffectiveFieldSizeInBits));

setDataSize(FieldOffset + EffectiveFieldSize);

PaddedFieldSize = std::max(PaddedFieldSize, FieldOffset + FieldSize);

setSize(std::max(getSizeInBits(), getDataSizeInBits()));

setSize(std::max(getSizeInBits(),

(uint64_t)Context.

(FieldOffset + FieldSize)));

UnadjustedAlignment = std::max(UnadjustedAlignment, FieldAlign);

UpdateAlignment(FieldAlign, UnpackedFieldAlign, PreferredAlign);

(RD->

<PackedAttr>() || !MaxFieldAlignment.

())

(FieldAlign < OriginalFieldAlign)

(

->getType()->isRecordType()) {

(FieldOffset % OriginalFieldAlign != 0)

(Packed && !FieldPacked && PackedFieldAlign < FieldAlign)

ItaniumRecordLayoutBuilder::FinishLayout(

*

) {

(Context.

().CPlusPlus && getSizeInBits() == 0) {

setSize(std::max(getSizeInBits(), (uint64_t)Context.

(PaddedFieldSize)));

UnpaddedSize = getSizeInBits() - UnfilledBitsInLastUnit;

llvm::alignTo(getSizeInBits(), Context.

(UnpackedAlignment));

RoundedSize = llvm::alignTo(

: PreferredAlignment));

(UseExternalLayout) {

(InferAlignment &&

.Size < RoundedSize) {

InferAlignment =

;

setSize(RoundedSize);

(

*RD = dyn_cast<RecordDecl>(

)) {

(getSizeInBits() > UnpaddedSize) {

PadSize = getSizeInBits() - UnpaddedSize;

InBits =

;

(PadSize % CharBitNum == 0) {

PadSize = PadSize / CharBitNum;

<< (InBits ? 1 : 0);

*CXXRD = dyn_cast<CXXRecordDecl>(RD);

(Packed && UnpackedAlignment <= Alignment &&

UnpackedSizeInBits == getSizeInBits() && !HasPackedField &&

(!CXXRD || CXXRD->isPOD() ||

ItaniumRecordLayoutBuilder::UpdateAlignment(

(IsMac68kAlign || (UseExternalLayout && !InferAlignment))

(NewAlignment > Alignment) {

assert(llvm::isPowerOf2_64(NewAlignment.

()) &&

);

Alignment = NewAlignment;

(UnpackedNewAlignment > UnpackedAlignment) {

assert(llvm::isPowerOf2_64(UnpackedNewAlignment.

()) &&

);

UnpackedAlignment = UnpackedNewAlignment;

(PreferredNewAlignment > PreferredAlignment) {

assert(llvm::isPowerOf2_64(PreferredNewAlignment.

()) &&

);

PreferredAlignment = PreferredNewAlignment;

ItaniumRecordLayoutBuilder::updateExternalFieldOffset(

*Field,

uint64_t ComputedOffset) {

(InferAlignment && ExternalFieldOffset < ComputedOffset) {

InferAlignment =

;

ExternalFieldOffset;

: llvm_unreachable(

);

ItaniumRecordLayoutBuilder::CheckFieldPadding(

uint64_t Offset, uint64_t UnpaddedOffset, uint64_t UnpackedOffset,

UnpackedAlign,

isPacked,

*

) {

(isa<ObjCIvarDecl>(

))

(!IsUnion && Offset > UnpaddedOffset) {

PadSize = Offset - UnpaddedOffset;

InBits =

;

(PadSize % CharBitNum == 0) {

PadSize = PadSize / CharBitNum;

(

->getIdentifier()) {

=

->isBitField() ? diag::warn_padded_struct_bitfield

: diag::warn_padded_struct_field;

<<

->getIdentifier();

=

->isBitField() ? diag::warn_padded_struct_anon_bitfield

: diag::warn_padded_struct_anon_field;

<< (InBits ? 1 : 0);

(isPacked && Offset != UnpackedOffset) {

HasPackedField =

;

allowInlineFunctions =

(!MD->isVirtual())

(MD->isPureVirtual())

(MD->isImplicit())

(MD->isInlineSpecified() || MD->isConstexpr())

(MD->hasInlineBody())

(!MD->isUserProvided())

(!allowInlineFunctions) {

(!MD->hasAttr<CUDADeviceAttr>())

(!MD->hasAttr<CUDAHostAttr>() && MD->hasAttr<CUDADeviceAttr>())

(MD->hasAttr<DLLImportAttr>() && !RD->

<DLLImportAttr>() &&

RD->

();

llvm_unreachable(

);

MicrosoftRecordLayoutBuilder {

ElementInfo {

llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetsMapTy;

MicrosoftRecordLayoutBuilder(

&Context,

EmptySubobjectMap *EmptySubobjects)

: Context(Context), EmptySubobjects(EmptySubobjects) {}

MicrosoftRecordLayoutBuilder(

MicrosoftRecordLayoutBuilder &) =

;

operator=(

MicrosoftRecordLayoutBuilder &) =

;

initializeLayout(

*RD);

layoutBitField(

*FD);

layoutZeroWidthBitField(

*FD);

ElementInfo getAdjustedElementInfo(

*FD);

placeFieldAtOffset(

FieldOffset) {

FieldOffsets.push_back(Context.

(FieldOffset));

placeFieldAtBitOffset(uint64_t FieldOffset) {

FieldOffsets.push_back(FieldOffset);

computeVtorDispSet(

llvm::SmallPtrSetImpl<const CXXRecordDecl *> &HasVtorDispSet,

EmptySubobjectMap *EmptySubobjects;

ElementInfo PointerInfo;

BaseOffsetsMapTy Bases;

RemainingBitsInField;

LastFieldIsNonZeroWidthBitfield : 1;

HasOwnVFPtr : 1;

EndsWithZeroSizedObject : 1;

LeadsWithZeroSizedBase : 1;

UseExternalLayout : 1;

MicrosoftRecordLayoutBuilder::ElementInfo

MicrosoftRecordLayoutBuilder::getAdjustedElementInfo(

(!MaxFieldAlignment.

())

Info.Alignment = std::min(Info.Alignment, MaxFieldAlignment);

Alignment = std::max(Alignment, Info.Alignment);

MicrosoftRecordLayoutBuilder::ElementInfo

MicrosoftRecordLayoutBuilder::getAdjustedElementInfo(

ElementInfo Info{TInfo.

, TInfo.Align};

FieldRequiredAlignment = std::max(

Info.Alignment = std::max(Info.Alignment, FieldRequiredAlignment);

FieldRequiredAlignment = std::max(FieldRequiredAlignment,

RequiredAlignment = std::max(RequiredAlignment, FieldRequiredAlignment);

(!MaxFieldAlignment.

())

Info.Alignment = std::min(Info.Alignment, MaxFieldAlignment);

(FD->

<PackedAttr>())

Info.Alignment = std::max(Info.Alignment, FieldRequiredAlignment);

MicrosoftRecordLayoutBuilder::layout(

*RD) {

initializeLayout(RD);

DataSize =

=

.alignTo(Alignment);

RequiredAlignment = std::max(

MicrosoftRecordLayoutBuilder::cxxLayout(

*RD) {

initializeLayout(RD);

initializeCXXLayout(RD);

layoutNonVirtualBases(RD);

(HasOwnVFPtr || (HasVBPtr && !SharedVBPtrBase))

Alignment = std::max(Alignment, PointerInfo.Alignment);

RoundingAlignment = Alignment;

(!MaxFieldAlignment.

())

RoundingAlignment = std::min(RoundingAlignment, MaxFieldAlignment);

(!UseExternalLayout)

=

.alignTo(RoundingAlignment);

NonVirtualSize =

;

RequiredAlignment = std::max(

layoutVirtualBases(RD);

MicrosoftRecordLayoutBuilder::initializeLayout(

*RD) {

(

DefaultMaxFieldAlignment = Context.

().PackStruct)

(

MaxFieldAlignmentAttr *MFAA = RD->

<MaxFieldAlignmentAttr>()){

PackedAlignment = MFAA->getAlignment();

(PackedAlignment <=

(RD->

<PackedAttr>())

UseExternalLayout =

;

UseExternalLayout = Source->layoutRecordType(

MicrosoftRecordLayoutBuilder::initializeCXXLayout(

*RD) {

EndsWithZeroSizedObject =

;

LeadsWithZeroSizedBase =

;

HasOwnVFPtr =

;

PrimaryBase =

;

SharedVBPtrBase =

;

(!MaxFieldAlignment.

())

PointerInfo.Alignment = std::min(PointerInfo.Alignment, MaxFieldAlignment);

MicrosoftRecordLayoutBuilder::layoutNonVirtualBases(

*RD) {

HasPolymorphicBaseClass =

;

(

.isVirtual()) {

(!SharedVBPtrBase && BaseLayout.

()) {

SharedVBPtrBase = BaseDecl;

PrimaryBase = BaseDecl;

layoutNonVirtualBase(RD, BaseDecl, BaseLayout, PreviousBaseLayout);

(!HasPolymorphicBaseClass)

HasOwnVFPtr =

;

(!PrimaryBase) {

(MicrosoftVTableContext::hasVtableSlot(M) &&

M->size_overridden_methods() == 0) {

HasOwnVFPtr =

;

CheckLeadingLayout = !PrimaryBase;

(

.isVirtual())

(CheckLeadingLayout) {

CheckLeadingLayout =

;

layoutNonVirtualBase(RD, BaseDecl, BaseLayout, PreviousBaseLayout);

(SharedVBPtrBase) {

VBPtrOffset = Bases[SharedVBPtrBase] + Layout.

();

(!isa<CXXRecordDecl>(RD))

(RD->

<EmptyBasesAttr>())

(

*LVA = RD->

<LayoutVersionAttr>())

(LVA->getVersion() <= LangOptions::MSVC2015)

MicrosoftRecordLayoutBuilder::layoutNonVirtualBase(

ElementInfo Info = getAdjustedElementInfo(BaseLayout);

FoundBase =

;

(UseExternalLayout) {

FoundBase =

.getExternalNVBaseOffset(BaseDecl, BaseOffset);

(BaseOffset > Size) {

(MDCUsesEBO && BaseDecl->

() &&

BaseOffset =

=

.alignTo(Info.Alignment);

Bases.insert(std::make_pair(BaseDecl, BaseOffset));

PreviousBaseLayout = &BaseLayout;

MicrosoftRecordLayoutBuilder::layoutFields(

*RD) {

LastFieldIsNonZeroWidthBitfield =

;

MicrosoftRecordLayoutBuilder::layoutField(

*FD) {

LastFieldIsNonZeroWidthBitfield =

;

ElementInfo Info = getAdjustedElementInfo(FD);

Alignment = std::max(Alignment, Info.Alignment);

FieldClass->

().empty();

(UseExternalLayout) {

}

(IsUnion) {

}

(EmptySubobjects) {

(!IsOverlappingEmptyField)

FieldOffset = DataSize.

(Info.Alignment);

(!EmptySubobjects->CanPlaceFieldAtOffset(FD, FieldOffset)) {

HasBases = ParentClass && (!ParentClass->

().empty() ||

!ParentClass->

().empty());

FieldOffset = DataSize.

(Info.Alignment);

FieldOffset += Info.Alignment;

FieldOffset =

.alignTo(Info.Alignment);

placeFieldAtOffset(FieldOffset);

(!IsOverlappingEmptyField)

DataSize = std::max(DataSize, FieldOffset + Info.Size);

= std::max(Size, FieldOffset + Info.Size);

MicrosoftRecordLayoutBuilder::layoutBitField(

*FD) {

layoutZeroWidthBitField(FD);

ElementInfo Info = getAdjustedElementInfo(FD);

(Width > Context.

(Info.Size))

Width = Context.

(Info.Size);

(!UseExternalLayout && !IsUnion && LastFieldIsNonZeroWidthBitfield &&

CurrentBitfieldSize == Info.Size && Width <= RemainingBitsInField) {

placeFieldAtBitOffset(Context.

(Size) - RemainingBitsInField);

RemainingBitsInField -= Width;

LastFieldIsNonZeroWidthBitfield =

;

CurrentBitfieldSize = Info.Size;

(UseExternalLayout) {

FieldBitOffset =

.getExternalFieldOffset(FD);

placeFieldAtBitOffset(FieldBitOffset);

llvm::alignDown(FieldBitOffset, Context.

(Info.Alignment)) +

Context.

(Info.Size));

= std::max(Size, NewSize);

Alignment = std::max(Alignment, Info.Alignment);

}

(IsUnion) {

= std::max(Size, Info.Size);

placeFieldAtOffset(FieldOffset);

= FieldOffset + Info.Size;

Alignment = std::max(Alignment, Info.Alignment);

RemainingBitsInField = Context.

(Info.Size) - Width;

MicrosoftRecordLayoutBuilder::layoutZeroWidthBitField(

*FD) {

(!LastFieldIsNonZeroWidthBitfield) {

LastFieldIsNonZeroWidthBitfield =

;

ElementInfo Info = getAdjustedElementInfo(FD);

= std::max(Size, Info.Size);

placeFieldAtOffset(FieldOffset);

Alignment = std::max(Alignment, Info.Alignment);

MicrosoftRecordLayoutBuilder::injectVBPtr(

*RD) {

(!HasVBPtr || SharedVBPtrBase)

VBPtrOffset = VBPtrOffset.

(PointerInfo.Alignment);

FieldStart = VBPtrOffset + PointerInfo.Size;

(UseExternalLayout) {

(Size < FieldStart)

Offset = (FieldStart - InjectionSite)

.alignTo(std::max(RequiredAlignment, Alignment));

(uint64_t &FieldOffset : FieldOffsets)

FieldOffset += Context.

(Offset);

(BaseOffsetsMapTy::value_type &

: Bases)

(

.second >= InjectionSite)

.second += Offset;

MicrosoftRecordLayoutBuilder::injectVFPtr(

*RD) {

PointerInfo.Size.alignTo(std::max(RequiredAlignment, Alignment));

VBPtrOffset += Offset;

(UseExternalLayout) {

(

.isZero())

(uint64_t &FieldOffset : FieldOffsets)

FieldOffset += Context.

(Offset);

(BaseOffsetsMapTy::value_type &

: Bases)

.second += Offset;

MicrosoftRecordLayoutBuilder::layoutVirtualBases(

*RD) {

VtorDispAlignment = VtorDispSize;

(!MaxFieldAlignment.

())

VtorDispAlignment = std::min(VtorDispAlignment, MaxFieldAlignment);

*BaseDecl = VBase.getType()->getAsCXXRecordDecl();

VtorDispAlignment = std::max(VtorDispAlignment, RequiredAlignment);

computeVtorDispSet(HasVtorDispSet, RD);

*BaseDecl = VBase.getType()->getAsCXXRecordDecl();

HasVtordisp = HasVtorDispSet.contains(BaseDecl);

=

.alignTo(VtorDispAlignment) + VtorDispSize;

Alignment = std::max(VtorDispAlignment, Alignment);

ElementInfo Info = getAdjustedElementInfo(BaseLayout);

(UseExternalLayout) {

(!

.getExternalVBaseOffset(BaseDecl, BaseOffset))

BaseOffset =

.alignTo(Info.Alignment);

assert(BaseOffset >= Size &&

);

VBases.insert(std::make_pair(BaseDecl,

PreviousBaseLayout = &BaseLayout;

MicrosoftRecordLayoutBuilder::finalizeLayout(

*RD) {

(!RequiredAlignment.isZero()) {

Alignment = std::max(Alignment, RequiredAlignment);

RoundingAlignment = Alignment;

(!MaxFieldAlignment.

())

RoundingAlignment = std::min(RoundingAlignment, MaxFieldAlignment);

RoundingAlignment = std::max(RoundingAlignment, RequiredAlignment);

=

.alignTo(RoundingAlignment);

(

.isZero()) {

(!

(RD) || !cast<CXXRecordDecl>(RD)->isEmpty()) {

EndsWithZeroSizedObject =

;

LeadsWithZeroSizedBase =

;

(RequiredAlignment >= MinEmptyStructSize)

= MinEmptyStructSize;

(UseExternalLayout) {

BasesWithOverriddenMethods,

(BasesWithOverriddenMethods.count(RD))

(!

.isVirtual() &&

.getType()->getAsCXXRecordDecl()))

MicrosoftRecordLayoutBuilder::computeVtorDispSet(

llvm::SmallPtrSetImpl<const CXXRecordDecl *> &HasVtordispSet,

HasVtordispSet.insert(BaseDecl);

(bi.second.hasVtorDisp())

HasVtordispSet.insert(bi.first);

(MicrosoftVTableContext::hasVtableSlot(MD) &&

!isa<CXXDestructorDecl>(MD) && !MD->isPureVirtual())

(!Work.empty()) {

(MethodRange.begin() == MethodRange.end())

BasesWithOverriddenMethods.insert(MD->

());

Work.insert(MethodRange.begin(), MethodRange.end());

(!HasVtordispSet.count(BaseDecl) &&

HasVtordispSet.insert(BaseDecl);

(

->hasExternalLexicalStorage() && !

->getDefinition())

=

->getDefinition();

assert(

&&

);

assert(!

->

() &&

);

assert(

->isCompleteDefinition() &&

);

(Entry)

*Entry;

(

*RD = dyn_cast<CXXRecordDecl>(

)) {

EmptySubobjectMap EmptySubobjects(*

, RD);

MicrosoftRecordLayoutBuilder Builder(*

, &EmptySubobjects);

Builder.cxxLayout(RD);

*

, Builder.Size, Builder.Alignment, Builder.Alignment,

Builder.Alignment, Builder.RequiredAlignment, Builder.HasOwnVFPtr,

Builder.HasOwnVFPtr || Builder.PrimaryBase, Builder.VBPtrOffset,

Builder.DataSize, Builder.FieldOffsets, Builder.NonVirtualSize,

Builder.PrimaryBase,

, Builder.SharedVBPtrBase,

Builder.EndsWithZeroSizedObject, Builder.LeadsWithZeroSizedBase,

Builder.Bases, Builder.VBases);

MicrosoftRecordLayoutBuilder Builder(*

,

);

Builder.layout(

);

*

, Builder.Size, Builder.Alignment, Builder.Alignment,

Builder.Alignment, Builder.RequiredAlignment, Builder.Size,

Builder.FieldOffsets);

(

*RD = dyn_cast<CXXRecordDecl>(

)) {

EmptySubobjectMap EmptySubobjects(*

, RD);

ItaniumRecordLayoutBuilder Builder(*

, &EmptySubobjects);

skipTailPadding =

skipTailPadding ? Builder.getSize() : Builder.getDataSize();

skipTailPadding ? DataSize : Builder.NonVirtualSize;

*

, Builder.getSize(), Builder.Alignment,

Builder.PreferredAlignment, Builder.UnadjustedAlignment,

NonVirtualSize, Builder.NonVirtualAlignment,

Builder.PreferredNVAlignment,

EmptySubobjects.SizeOfLargestEmptySubobject, Builder.PrimaryBase,

Builder.PrimaryBaseIsVirtual,

,

,

, Builder.Bases,

ItaniumRecordLayoutBuilder Builder(*

,

);

Builder.Layout(

);

*

, Builder.getSize(), Builder.Alignment,

Builder.PreferredAlignment, Builder.UnadjustedAlignment,

Builder.Alignment, Builder.getSize(), Builder.FieldOffsets);

ASTRecordLayouts[

] = NewEntry;

llvm::outs() <<

;

assert(RD->

() &&

);

KeyFunctions[RD] =

*

(

);

cast_or_null<CXXMethodDecl>(

);

);

&Map = KeyFunctions;

I = Map.find(Method->

());

(I == Map.end())

;

KeyFunctions.erase(Method->

());

uint64_t OffsetInBits;

(

*FD = dyn_cast<FieldDecl>(VD)) {

OffsetInBits;

(

*IVD = Container->all_declared_ivar_begin();

IVD; IVD = IVD->getNextIvar()) {

assert(Index < RL->getFieldCount() &&

);

(

->hasExternalLexicalStorage() && !

->getDefinition())

=

->getDefinition();

assert(

&& !

->

() &&

->isThisDeclarationADefinition() &&

);

(SynthCount == 0)

getObjCLayout(

,

);

ItaniumRecordLayoutBuilder Builder(*

,

);

Builder.Layout(

);

*

, Builder.getSize(), Builder.Alignment, Builder.PreferredAlignment,

Builder.UnadjustedAlignment,

Builder.Alignment, Builder.getDataSize(), Builder.FieldOffsets);

ObjCLayouts[Key] = NewEntry;

Offset,

IndentLevel) {

OS << llvm::format(

PRId64

, (int64_t)Offset.getQuantity());

OS.indent(IndentLevel * 2);

,

Width,

IndentLevel) {

llvm::raw_svector_ostream BufferOS(Buffer);

BufferOS << Offset.getQuantity() <<

;

BufferOS <<

<<

<< (

+ Width - 1);

OS << llvm::right_justify(Buffer, 10) <<

;

OS.indent(IndentLevel * 2);

OS.indent(IndentLevel * 2);

IndentLevel,

* Description,

IncludeVirtualBases) {

CXXRD = dyn_cast<CXXRecordDecl>(RD);

OS <<

.getTypeDeclType(

*

(RD));

OS <<

<< Description;

(CXXRD && CXXRD->isEmpty())

(CXXRD->isDynamicClass() && !PrimaryBase && !

(

)) {

OS <<

<< *RD <<

;

}

(HasOwnVFPtr) {

OS <<

<< *RD <<

;

assert(!

.getType()->isDependentType() &&

);

(!

.isVirtual())

Bases.push_back(

.getType()->getAsCXXRecordDecl());

== PrimaryBase ?

:

,

OS <<

<< *RD <<

;

uint64_t LocalFieldOffsetInBits =

Offset +

.toCharUnitsFromBits(LocalFieldOffsetInBits);

(

RT = Field->getType()->getAs<

>()) {

Field->getName().data(),

(Field->isBitField()) {

uint64_t LocalFieldByteOffsetInBits =

.toBits(FieldOffset - Offset);

= LocalFieldOffsetInBits - LocalFieldByteOffsetInBits;

Width = Field->getBitWidthValue();

&FieldType =

.getLangOpts().DumpRecordLayoutsCanonical

? Field->getType().getCanonicalType()

OS << FieldType <<

<< *Field <<

;

(CXXRD && IncludeVirtualBases) {

assert(

.isVirtual() &&

);

(VtorDisps.find(VBase)->second.hasVtorDisp()) {

OS <<

<< *VBase <<

;

:

,

(!PrintSizeInfo)

;

(

.getTargetInfo().defaultsToAIXPowerAlignment())

(

.getTargetInfo().defaultsToAIXPowerAlignment())

OS <<

Simple)

{

OS <<

;

OS <<

;

(

->defaultsToAIXPowerAlignment())

(

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

OS <<

;

(

I : CXXRD->bases()) {

= I.getType()->getAsCXXRecordDecl();

OS << Info.CXXInfo->BaseOffsets[

].getQuantity();

OS <<

;

(

I : CXXRD->vbases()) {

VBase = I.getType()->getAsCXXRecordDecl();

OS << Info.CXXInfo->VBaseOffsets[VBase].VBaseOffset.getQuantity();

OS <<

;

(

i = 0, e = Info.

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

Defines the clang::ASTContext interface.

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

static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)

Produce a diagnostic highlighting some portion of a literal.

static unsigned getCharWidth(tok::TokenKind kind, const TargetInfo &Target)

llvm::MachO::Target Target

static const CXXMethodDecl * computeKeyFunction(ASTContext &Context, const CXXRecordDecl *RD)

static bool mustSkipTailPadding(TargetCXXABI ABI, const CXXRecordDecl *RD)

Does the target C++ ABI require us to skip over the tail-padding of the given class (considering it a...

static bool isAIXLayout(const ASTContext &Context)

static void PrintIndentNoOffset(raw_ostream &OS, unsigned IndentLevel)

static uint64_t roundUpSizeToCharAlignment(uint64_t Size, const ASTContext &Context)

static void PrintOffset(raw_ostream &OS, CharUnits Offset, unsigned IndentLevel)

static unsigned getPaddingDiagFromTagKind(TagTypeKind Tag)

Get diagnostic select index for tag kind for field padding diagnostic message.

static void DumpRecordLayout(raw_ostream &OS, const RecordDecl *RD, const ASTContext &C, CharUnits Offset, unsigned IndentLevel, const char *Description, bool PrintSizeInfo, bool IncludeVirtualBases)

static bool isMsLayout(const ASTContext &Context)

static uint64_t getFieldOffset(const ASTContext &C, const FieldDecl *FD)

static bool RequiresVtordisp(const llvm::SmallPtrSetImpl< const CXXRecordDecl * > &BasesWithOverriddenMethods, const CXXRecordDecl *RD)

static void PrintBitFieldOffset(raw_ostream &OS, CharUnits Offset, unsigned Begin, unsigned Width, unsigned IndentLevel)

static bool recordUsesEBO(const RecordDecl *RD)

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

const ConstantArrayType * getAsConstantArrayType(QualType T) const

CharUnits getTypeAlignInChars(QualType T) const

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

uint64_t getFieldOffset(const ValueDecl *FD) const

Get the offset of a FieldDecl or IndirectFieldDecl, in bits.

const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const

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

void DumpRecordLayout(const RecordDecl *RD, raw_ostream &OS, bool Simple=false) const

const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)

Get our current best idea for the key function of the given record decl, or nullptr if there isn't on...

const ASTRecordLayout & getASTObjCImplementationLayout(const ObjCImplementationDecl *D) const

Get or compute information about the layout of the specified Objective-C implementation.

QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const

Return the unique reference to the type for the specified type declaration.

const LangOptions & getLangOpts() const

const ASTRecordLayout & getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const

Get or compute information about the layout of the specified Objective-C interface.

QualType getBaseElementType(const ArrayType *VAT) const

Return the innermost element type of an array type.

unsigned CountNonClassIvars(const ObjCInterfaceDecl *OI) const

bool isNearlyEmpty(const CXXRecordDecl *RD) const

const TargetInfo * getAuxTargetInfo() const

CanQualType UnsignedLongTy

TypeInfo getTypeInfo(const Type *T) const

Get the size and alignment of the specified complete type in bits.

bool isAlignmentRequired(const Type *T) const

Determine if the alignment the type has was required using an alignment attribute.

void setNonKeyFunction(const CXXMethodDecl *method)

Observe that the given method cannot be a key function.

TypeInfoChars getTypeInfoInChars(const Type *T) const

int64_t toBits(CharUnits CharSize) const

Convert a size in characters to a size in bits.

uint64_t lookupFieldBitOffset(const ObjCInterfaceDecl *OID, const ObjCImplementationDecl *ID, const ObjCIvarDecl *Ivar) const

Get the offset of an ObjCIvarDecl in bits.

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.

CanQualType UnsignedCharTy

CanQualType UnsignedIntTy

CanQualType UnsignedLongLongTy

CanQualType UnsignedShortTy

DiagnosticsEngine & getDiagnostics() const

const TargetInfo & getTargetInfo() const

CharUnits toCharUnitsFromBits(int64_t BitSize) const

Convert a size in bits to a size in characters.

ExternalASTSource * getExternalSource() const

Retrieve a pointer to the external AST source associated with this AST context, if any.

uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const

Return number of constant array elements.

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

bool hasOwnVFPtr() const

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

CharUnits getAlignment() const

getAlignment - Get the record alignment in characters.

CharUnits getPreferredAlignment() const

getPreferredFieldAlignment - Get the record preferred alignment in characters.

bool hasOwnVBPtr() const

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

llvm::DenseMap< const CXXRecordDecl *, VBaseInfo > VBaseOffsetsMapTy

CharUnits getSize() const

getSize - Get the record size in characters.

unsigned getFieldCount() const

getFieldCount - Get the number of fields in the layout.

bool hasVBPtr() const

hasVBPtr - Does this class have a virtual function table pointer.

bool leadsWithZeroSizedBase() const

uint64_t getFieldOffset(unsigned FieldNo) const

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

CharUnits getNonVirtualAlignment() const

getNonVirtualAlignment - Get the non-virtual alignment (in chars) of an object, which is the alignmen...

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

CharUnits getSizeOfLargestEmptySubobject() const

CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const

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

CharUnits getPreferredNVAlignment() const

getPreferredNVAlignment - Get the preferred non-virtual alignment (in chars) of an object,...

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

hasVFPtr - Does this class have a virtual function table pointer that can be extended by a derived cl...

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

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

Represents a base class of a C++ class.

A set of all the primary bases for a class.

Represents a static or instance method of a struct/union/class.

overridden_method_range overridden_methods() const

const CXXRecordDecl * getParent() const

Return the parent of this method declaration, which is the class in which this method is defined.

Represents a C++ struct/union/class.

void getIndirectPrimaryBases(CXXIndirectPrimaryBaseSet &Bases) const

Get the indirect primary bases for this class.

bool hasUserDeclaredDestructor() const

Determine whether this class has a user-declared destructor.

method_range methods() const

CXXRecordDecl * getDefinition() const

bool isPolymorphic() const

Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...

TemplateSpecializationKind getTemplateSpecializationKind() const

Determine whether this particular class is a specialization or instantiation of a class template or m...

base_class_range vbases()

bool isDynamicClass() const

bool isCXX11StandardLayout() const

Determine whether this class was standard-layout per C++11 [class]p7, specifically using the C++11 ru...

bool hasUserDeclaredConstructor() const

Determine whether this class has any user-declared constructors.

bool isPOD() const

Whether this class is a POD-type (C++ [class]p4)

MSVtorDispMode getMSVtorDispMode() const

Controls when vtordisps will be emitted if this record is used as a virtual base.

bool isEmpty() const

Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).

bool isTrivial() const

Determine whether this class is considered trivial.

unsigned getNumVBases() const

Retrieves the number of virtual base classes of this 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.

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

static CharUnits Zero()

Zero - Construct a CharUnits quantity of zero.

Complex values, per C99 6.2.5p11.

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

lookup_result lookup(DeclarationName Name) const

lookup - Find the declarations (if any) with the given Name in this context.

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

Decl * getMostRecentDecl()

Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...

unsigned getMaxAlignment() const

getMaxAlignment - return the maximum alignment specified by attributes on this decl,...

bool isInvalidDecl() const

SourceLocation getLocation() const

A little helper class used to produce diagnostics.

A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine a...

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

Abstract interface for external sources of AST nodes.

virtual void CompleteType(TagDecl *Tag)

Gives the external AST source an opportunity to complete an incomplete type.

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

const RecordDecl * getParent() const

Returns the parent of this field declaration, which is the struct in which this field is defined.

bool isPotentiallyOverlapping() const

Determine if this field is of potentially-overlapping class type, that is, subobject with the [[no_un...

Represents a function declaration or definition.

bool isInlineSpecified() const

Determine whether the "inline" keyword was specified for this function.

Represents a field injected from an anonymous union/struct into the parent scope.

ArrayRef< NamedDecl * > chain() const

@ Ver6

Attempt to be ABI-compatible with code generated by Clang 6.0.x (SVN r321711).

@ Ver15

Attempt to be ABI-compatible with code generated by Clang 15.0.x.

This represents a decl that may have a name.

bool isExternallyVisible() const

ObjCContainerDecl - Represents a container for method declarations.

ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...

Represents an ObjC class declaration.

ObjCIvarDecl - Represents an ObjC instance variable.

ObjCInterfaceDecl * getContainingInterface()

Return the class interface that this ivar is logically contained in; this is either the interface whe...

ObjCIvarDecl * getCanonicalDecl() override

Retrieves the canonical declaration of this field.

A (possibly-)qualified type.

Represents a struct/union/class.

bool isMsStruct(const ASTContext &C) const

Get whether or not this is an ms_struct which can be turned on with an attribute, pragma,...

field_range fields() const

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

RecordDecl * getDecl() const

decl_type * getFirstDecl()

Return the first declaration of this declaration or itself if this is the only declaration.

Encodes a location in the source.

The basic abstraction for the target C++ ABI.

TailPaddingUseRules getTailPaddingUseRules() const

bool isMicrosoft() const

Is this ABI an MSVC-compatible ABI?

bool canKeyFunctionBeInline() const

Can an out-of-line inline function serve as a key function?

@ AlwaysUseTailPadding

The tail-padding of a base class is always theoretically available, even if it's POD.

@ UseTailPaddingUnlessPOD11

Only allocate objects in the tail padding of a base class if the base class is not POD according to t...

@ UseTailPaddingUnlessPOD03

Only allocate objects in the tail padding of a base class if the base class is not POD according to t...

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

bool useLeadingZeroLengthBitfield() const

Check whether zero length bitfield alignment is respected if they are leading members.

uint64_t getPointerWidth(LangAS AddrSpace) const

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

virtual bool hasPS4DLLImportExport() const

virtual bool defaultsToAIXPowerAlignment() const

Whether target defaults to the power alignment rules of AIX.

unsigned getCharAlign() const

unsigned getZeroLengthBitfieldBoundary() const

Get the fixed alignment value in bits for a member that follows a zero length bitfield.

bool useExplicitBitFieldAlignment() const

Check whether explicit bitfield alignment attributes should be.

uint64_t getPointerAlign(LangAS AddrSpace) const

TargetCXXABI getCXXABI() const

Get the C++ ABI currently in use.

unsigned getCharWidth() const

bool useZeroLengthBitfieldAlignment() const

Check whether zero length bitfields should force alignment of the next member.

bool useBitFieldTypeAlignment() const

Check whether the alignment of bit-field types is respected when laying out structures.

The base class of the type hierarchy.

CXXRecordDecl * getAsCXXRecordDecl() const

Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...

const Type * getBaseElementTypeUnsafe() const

Get the base element type of this type, potentially discarding type qualifiers.

const T * getAs() const

Member-template getAs<specific type>'.

const Type * getUnqualifiedDesugaredType() const

Return the specified type with any "sugar" removed from the type, removing any typedefs,...

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

Defines the clang::TargetInfo interface.

bool Zero(InterpState &S, CodePtr OpPC)

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

@ External

External linkage, which indicates that the entity can be referred to from other translation units.

@ Result

The result type of a method or function.

TagTypeKind

The kind of a tag type.

@ Interface

The "__interface" keyword.

@ Struct

The "struct" keyword.

@ Class

The "class" keyword.

const FunctionProtoType * T

bool declaresSameEntity(const Decl *D1, const Decl *D2)

Determine whether two declarations declare the same entity.

TemplateSpecializationKind

Describes the kind of template specialization that a particular template specialization declaration r...

@ TSK_ExplicitInstantiationDefinition

This template specialization was instantiated from a template due to an explicit instantiation defini...

@ TSK_ExplicitInstantiationDeclaration

This template specialization was instantiated from a template due to an explicit instantiation declar...

@ TSK_ImplicitInstantiation

This template specialization was implicitly instantiated from a template.

@ None

The alignment was not explicit in code.

@ RequiredByTypedef

The alignment comes from an alignment attribute on a typedef.

@ RequiredByRecord

The alignment comes from an alignment attribute on a record type.

@ Class

The "class" keyword introduces the elaborated-type-specifier.

bool isValid() const

Whether this pointer is non-NULL.

bool isOffset() const

Whether this pointer is currently stored as an offset.

T * get(ExternalASTSource *Source) const

Retrieve the pointer to the AST node that this lazy pointer points to.

All virtual base related information about a given record decl.

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