head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.11 netbsd-11-0-RC3:1.1.1.11 netbsd-11-0-RC2:1.1.1.11 netbsd-11-0-RC1:1.1.1.11 perseant-exfatfs-base-20250801:1.1.1.11 netbsd-11:1.1.1.11.0.10 netbsd-11-base:1.1.1.11 netbsd-10-1-RELEASE:1.1.1.11 perseant-exfatfs-base-20240630:1.1.1.11 perseant-exfatfs:1.1.1.11.0.8 perseant-exfatfs-base:1.1.1.11 netbsd-8-3-RELEASE:1.1.1.9 netbsd-9-4-RELEASE:1.1.1.10 netbsd-10-0-RELEASE:1.1.1.11 netbsd-10-0-RC6:1.1.1.11 netbsd-10-0-RC5:1.1.1.11 netbsd-10-0-RC4:1.1.1.11 netbsd-10-0-RC3:1.1.1.11 netbsd-10-0-RC2:1.1.1.11 netbsd-10-0-RC1:1.1.1.11 netbsd-10:1.1.1.11.0.6 netbsd-10-base:1.1.1.11 netbsd-9-3-RELEASE:1.1.1.10 cjep_sun2x:1.1.1.11.0.4 cjep_sun2x-base:1.1.1.11 cjep_staticlib_x-base1:1.1.1.11 netbsd-9-2-RELEASE:1.1.1.10 cjep_staticlib_x:1.1.1.11.0.2 cjep_staticlib_x-base:1.1.1.11 netbsd-9-1-RELEASE:1.1.1.10 phil-wifi-20200421:1.1.1.11 phil-wifi-20200411:1.1.1.11 phil-wifi-20200406:1.1.1.11 netbsd-8-2-RELEASE:1.1.1.9 netbsd-9-0-RELEASE:1.1.1.10 netbsd-9-0-RC2:1.1.1.10 netbsd-9-0-RC1:1.1.1.10 netbsd-9:1.1.1.10.0.2 netbsd-9-base:1.1.1.10 phil-wifi-20190609:1.1.1.10 netbsd-8-1-RELEASE:1.1.1.9 netbsd-8-1-RC1:1.1.1.9 pgoyette-compat-merge-20190127:1.1.1.9.12.1 pgoyette-compat-20190127:1.1.1.10 pgoyette-compat-20190118:1.1.1.10 pgoyette-compat-1226:1.1.1.10 pgoyette-compat-1126:1.1.1.10 pgoyette-compat-1020:1.1.1.10 pgoyette-compat-0930:1.1.1.10 pgoyette-compat-0906:1.1.1.10 netbsd-7-2-RELEASE:1.1.1.6.2.1 pgoyette-compat-0728:1.1.1.10 clang-337282:1.1.1.10 netbsd-8-0-RELEASE:1.1.1.9 phil-wifi:1.1.1.9.0.14 phil-wifi-base:1.1.1.9 pgoyette-compat-0625:1.1.1.9 netbsd-8-0-RC2:1.1.1.9 pgoyette-compat-0521:1.1.1.9 pgoyette-compat-0502:1.1.1.9 pgoyette-compat-0422:1.1.1.9 netbsd-8-0-RC1:1.1.1.9 pgoyette-compat-0415:1.1.1.9 pgoyette-compat-0407:1.1.1.9 pgoyette-compat-0330:1.1.1.9 pgoyette-compat-0322:1.1.1.9 pgoyette-compat-0315:1.1.1.9 netbsd-7-1-2-RELEASE:1.1.1.6.2.1 pgoyette-compat:1.1.1.9.0.12 pgoyette-compat-base:1.1.1.9 netbsd-7-1-1-RELEASE:1.1.1.6.2.1 clang-319952:1.1.1.9 matt-nb8-mediatek:1.1.1.9.0.10 matt-nb8-mediatek-base:1.1.1.9 clang-309604:1.1.1.9 perseant-stdc-iso10646:1.1.1.9.0.8 perseant-stdc-iso10646-base:1.1.1.9 netbsd-8:1.1.1.9.0.6 netbsd-8-base:1.1.1.9 prg-localcount2-base3:1.1.1.9 prg-localcount2-base2:1.1.1.9 prg-localcount2-base1:1.1.1.9 prg-localcount2:1.1.1.9.0.4 prg-localcount2-base:1.1.1.9 pgoyette-localcount-20170426:1.1.1.9 bouyer-socketcan-base1:1.1.1.9 pgoyette-localcount-20170320:1.1.1.9 netbsd-7-1:1.1.1.6.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.6.2.1 netbsd-7-1-RC2:1.1.1.6.2.1 clang-294123:1.1.1.9 netbsd-7-nhusb-base-20170116:1.1.1.6.2.1 bouyer-socketcan:1.1.1.9.0.2 bouyer-socketcan-base:1.1.1.9 clang-291444:1.1.1.9 pgoyette-localcount-20170107:1.1.1.8 netbsd-7-1-RC1:1.1.1.6.2.1 pgoyette-localcount-20161104:1.1.1.8 netbsd-7-0-2-RELEASE:1.1.1.6.2.1 localcount-20160914:1.1.1.8 netbsd-7-nhusb:1.1.1.6.2.1.0.4 netbsd-7-nhusb-base:1.1.1.6.2.1 clang-280599:1.1.1.8 pgoyette-localcount-20160806:1.1.1.8 pgoyette-localcount-20160726:1.1.1.8 pgoyette-localcount:1.1.1.8.0.2 pgoyette-localcount-base:1.1.1.8 netbsd-7-0-1-RELEASE:1.1.1.6.2.1 clang-261930:1.1.1.8 netbsd-7-0:1.1.1.6.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.6.2.1 netbsd-7-0-RC3:1.1.1.6.2.1 netbsd-7-0-RC2:1.1.1.6.2.1 netbsd-7-0-RC1:1.1.1.6.2.1 clang-237755:1.1.1.7 clang-232565:1.1.1.7 clang-227398:1.1.1.7 tls-maxphys-base:1.1.1.6 tls-maxphys:1.1.1.6.0.4 netbsd-7:1.1.1.6.0.2 netbsd-7-base:1.1.1.6 clang-215315:1.1.1.6 clang-209886:1.1.1.6 yamt-pagecache:1.1.1.5.0.4 yamt-pagecache-base9:1.1.1.5 tls-earlyentropy:1.1.1.5.0.2 tls-earlyentropy-base:1.1.1.6 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.5 riastradh-drm2-base3:1.1.1.5 clang-202566:1.1.1.5 clang-201163:1.1.1.4 clang-199312:1.1.1.3 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.04; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.01.15.21.26.25; author joerg; state Exp; branches; next 1.1.1.4; commitid NQXlzzA0SPkc5glx; 1.1.1.4 date 2014.02.14.20.07.08; author joerg; state Exp; branches; next 1.1.1.5; commitid annVkZ1sc17rF6px; 1.1.1.5 date 2014.03.04.19.53.56; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid 29z1hJonZISIXprx; 1.1.1.6 date 2014.05.30.18.14.41; author joerg; state Exp; branches 1.1.1.6.2.1 1.1.1.6.4.1; next 1.1.1.7; commitid 8q0kdlBlCn09GACx; 1.1.1.7 date 2015.01.29.19.57.31; author joerg; state Exp; branches; next 1.1.1.8; commitid mlISSizlPKvepX7y; 1.1.1.8 date 2016.02.27.22.12.08; author joerg; state Exp; branches 1.1.1.8.2.1; next 1.1.1.9; commitid tIimz3oDlh1NpBWy; 1.1.1.9 date 2017.01.11.10.33.31; author joerg; state Exp; branches 1.1.1.9.12.1 1.1.1.9.14.1; next 1.1.1.10; commitid CNnUNfII1jgNmxBz; 1.1.1.10 date 2018.07.17.18.31.01; author joerg; state Exp; branches; next 1.1.1.11; commitid wDzL46ALjrCZgwKA; 1.1.1.11 date 2019.11.13.22.19.21; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.5.2.1 date 2014.08.10.07.08.07; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.5.4.1 date 2014.03.04.19.53.56; author yamt; state dead; branches; next 1.1.1.5.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.4.2 date 2014.05.22.16.18.27; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.6.2.1 date 2015.06.04.20.04.28; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.6.4.1 date 2014.05.30.18.14.41; author tls; state dead; branches; next 1.1.1.6.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.6.4.2 date 2014.08.19.23.47.27; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.8.2.1 date 2017.03.20.06.52.37; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.9.12.1 date 2018.07.28.04.33.18; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.9.14.1 date 2019.06.10.21.45.21; author christos; state Exp; branches; next 1.1.1.9.14.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.9.14.2 date 2020.04.13.07.46.32; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- CGRecordLayoutBuilder.cpp - CGRecordLayout builder ----*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // Builder implementation for CGRecordLayout objects. // //===----------------------------------------------------------------------===// #include "CGRecordLayout.h" #include "CGCXXABI.h" #include "CodeGenTypes.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Attr.h" #include "clang/AST/CXXInheritance.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/Expr.h" #include "clang/AST/RecordLayout.h" #include "clang/Frontend/CodeGenOptions.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/Type.h" #include "llvm/Support/Debug.h" #include "llvm/Support/raw_ostream.h" using namespace clang; using namespace CodeGen; namespace { class CGRecordLayoutBuilder { public: /// FieldTypes - Holds the LLVM types that the struct is created from. /// SmallVector FieldTypes; /// BaseSubobjectType - Holds the LLVM type for the non-virtual part /// of the struct. For example, consider: /// /// struct A { int i; }; /// struct B { void *v; }; /// struct C : virtual A, B { }; /// /// The LLVM type of C will be /// %struct.C = type { i32 (...)**, %struct.A, i32, %struct.B } /// /// And the LLVM type of the non-virtual base struct will be /// %struct.C.base = type { i32 (...)**, %struct.A, i32 } /// /// This only gets initialized if the base subobject type is /// different from the complete-object type. llvm::StructType *BaseSubobjectType; /// FieldInfo - Holds a field and its corresponding LLVM field number. llvm::DenseMap Fields; /// BitFieldInfo - Holds location and size information about a bit field. llvm::DenseMap BitFields; llvm::DenseMap NonVirtualBases; llvm::DenseMap VirtualBases; /// IndirectPrimaryBases - Virtual base classes, direct or indirect, that are /// primary base classes for some other direct or indirect base class. CXXIndirectPrimaryBaseSet IndirectPrimaryBases; /// LaidOutVirtualBases - A set of all laid out virtual bases, used to avoid /// avoid laying out virtual bases more than once. llvm::SmallPtrSet LaidOutVirtualBases; /// IsZeroInitializable - Whether this struct can be C++ /// zero-initialized with an LLVM zeroinitializer. bool IsZeroInitializable; bool IsZeroInitializableAsBase; /// Packed - Whether the resulting LLVM struct will be packed or not. bool Packed; private: CodeGenTypes &Types; /// LastLaidOutBaseInfo - Contains the offset and non-virtual size of the /// last base laid out. Used so that we can replace the last laid out base /// type with an i8 array if needed. struct LastLaidOutBaseInfo { CharUnits Offset; CharUnits NonVirtualSize; bool isValid() const { return !NonVirtualSize.isZero(); } void invalidate() { NonVirtualSize = CharUnits::Zero(); } } LastLaidOutBase; /// Alignment - Contains the alignment of the RecordDecl. CharUnits Alignment; /// NextFieldOffset - Holds the next field offset. CharUnits NextFieldOffset; /// LayoutUnionField - Will layout a field in an union and return the type /// that the field will have. llvm::Type *LayoutUnionField(const FieldDecl *Field, const ASTRecordLayout &Layout); /// LayoutUnion - Will layout a union RecordDecl. void LayoutUnion(const RecordDecl *D); /// Lay out a sequence of contiguous bitfields. bool LayoutBitfields(const ASTRecordLayout &Layout, unsigned &FirstFieldNo, RecordDecl::field_iterator &FI, RecordDecl::field_iterator FE); /// LayoutFields - try to layout all fields in the record decl. /// Returns false if the operation failed because the struct is not packed. bool LayoutFields(const RecordDecl *D); /// Layout a single base, virtual or non-virtual bool LayoutBase(const CXXRecordDecl *base, const CGRecordLayout &baseLayout, CharUnits baseOffset); /// LayoutVirtualBase - layout a single virtual base. bool LayoutVirtualBase(const CXXRecordDecl *base, CharUnits baseOffset); /// LayoutVirtualBases - layout the virtual bases of a record decl. bool LayoutVirtualBases(const CXXRecordDecl *RD, const ASTRecordLayout &Layout); /// MSLayoutVirtualBases - layout the virtual bases of a record decl, /// like MSVC. bool MSLayoutVirtualBases(const CXXRecordDecl *RD, const ASTRecordLayout &Layout); /// LayoutNonVirtualBase - layout a single non-virtual base. bool LayoutNonVirtualBase(const CXXRecordDecl *base, CharUnits baseOffset); /// LayoutNonVirtualBases - layout the virtual bases of a record decl. bool LayoutNonVirtualBases(const CXXRecordDecl *RD, const ASTRecordLayout &Layout); /// ComputeNonVirtualBaseType - Compute the non-virtual base field types. bool ComputeNonVirtualBaseType(const CXXRecordDecl *RD); /// LayoutField - layout a single field. Returns false if the operation failed /// because the current struct is not packed. bool LayoutField(const FieldDecl *D, uint64_t FieldOffset); /// LayoutBitField - layout a single bit field. void LayoutBitField(const FieldDecl *D, uint64_t FieldOffset); /// AppendField - Appends a field with the given offset and type. void AppendField(CharUnits fieldOffset, llvm::Type *FieldTy); /// AppendPadding - Appends enough padding bytes so that the total /// struct size is a multiple of the field alignment. void AppendPadding(CharUnits fieldOffset, CharUnits fieldAlignment); /// ResizeLastBaseFieldIfNecessary - Fields and bases can be laid out in the /// tail padding of a previous base. If this happens, the type of the previous /// base needs to be changed to an array of i8. Returns true if the last /// laid out base was resized. bool ResizeLastBaseFieldIfNecessary(CharUnits offset); /// getByteArrayType - Returns a byte array type with the given number of /// elements. llvm::Type *getByteArrayType(CharUnits NumBytes); /// AppendBytes - Append a given number of bytes to the record. void AppendBytes(CharUnits numBytes); /// AppendTailPadding - Append enough tail padding so that the type will have /// the passed size. void AppendTailPadding(CharUnits RecordSize); CharUnits getTypeAlignment(llvm::Type *Ty) const; /// getAlignmentAsLLVMStruct - Returns the maximum alignment of all the /// LLVM element types. CharUnits getAlignmentAsLLVMStruct() const; /// CheckZeroInitializable - Check if the given type contains a pointer /// to data member. void CheckZeroInitializable(QualType T); public: CGRecordLayoutBuilder(CodeGenTypes &Types) : BaseSubobjectType(0), IsZeroInitializable(true), IsZeroInitializableAsBase(true), Packed(false), Types(Types) { } /// Layout - Will layout a RecordDecl. void Layout(const RecordDecl *D); }; } void CGRecordLayoutBuilder::Layout(const RecordDecl *D) { const ASTRecordLayout &Layout = Types.getContext().getASTRecordLayout(D); Alignment = Layout.getAlignment(); Packed = D->hasAttr() || Layout.getSize() % Alignment != 0; if (D->isUnion()) { LayoutUnion(D); return; } if (LayoutFields(D)) return; // We weren't able to layout the struct. Try again with a packed struct Packed = true; LastLaidOutBase.invalidate(); NextFieldOffset = CharUnits::Zero(); FieldTypes.clear(); Fields.clear(); BitFields.clear(); NonVirtualBases.clear(); VirtualBases.clear(); LayoutFields(D); } CGBitFieldInfo CGBitFieldInfo::MakeInfo(CodeGenTypes &Types, const FieldDecl *FD, uint64_t Offset, uint64_t Size, uint64_t StorageSize, uint64_t StorageAlignment) { llvm::Type *Ty = Types.ConvertTypeForMem(FD->getType()); CharUnits TypeSizeInBytes = CharUnits::fromQuantity(Types.getDataLayout().getTypeAllocSize(Ty)); uint64_t TypeSizeInBits = Types.getContext().toBits(TypeSizeInBytes); bool IsSigned = FD->getType()->isSignedIntegerOrEnumerationType(); if (Size > TypeSizeInBits) { // We have a wide bit-field. The extra bits are only used for padding, so // if we have a bitfield of type T, with size N: // // T t : N; // // We can just assume that it's: // // T t : sizeof(T); // Size = TypeSizeInBits; } // Reverse the bit offsets for big endian machines. Because we represent // a bitfield as a single large integer load, we can imagine the bits // counting from the most-significant-bit instead of the // least-significant-bit. if (Types.getDataLayout().isBigEndian()) { Offset = StorageSize - (Offset + Size); } return CGBitFieldInfo(Offset, Size, IsSigned, StorageSize, StorageAlignment); } /// \brief Layout the range of bitfields from BFI to BFE as contiguous storage. bool CGRecordLayoutBuilder::LayoutBitfields(const ASTRecordLayout &Layout, unsigned &FirstFieldNo, RecordDecl::field_iterator &FI, RecordDecl::field_iterator FE) { assert(FI != FE); uint64_t FirstFieldOffset = Layout.getFieldOffset(FirstFieldNo); uint64_t NextFieldOffsetInBits = Types.getContext().toBits(NextFieldOffset); unsigned CharAlign = Types.getTarget().getCharAlign(); assert(FirstFieldOffset % CharAlign == 0 && "First field offset is misaligned"); CharUnits FirstFieldOffsetInBytes = Types.getContext().toCharUnitsFromBits(FirstFieldOffset); unsigned StorageAlignment = llvm::MinAlign(Alignment.getQuantity(), FirstFieldOffsetInBytes.getQuantity()); if (FirstFieldOffset < NextFieldOffsetInBits) { CharUnits FieldOffsetInCharUnits = Types.getContext().toCharUnitsFromBits(FirstFieldOffset); // Try to resize the last base field. if (!ResizeLastBaseFieldIfNecessary(FieldOffsetInCharUnits)) llvm_unreachable("We must be able to resize the last base if we need to " "pack bits into it."); NextFieldOffsetInBits = Types.getContext().toBits(NextFieldOffset); assert(FirstFieldOffset >= NextFieldOffsetInBits); } // Append padding if necessary. AppendPadding(Types.getContext().toCharUnitsFromBits(FirstFieldOffset), CharUnits::One()); // Find the last bitfield in a contiguous run of bitfields. RecordDecl::field_iterator BFI = FI; unsigned LastFieldNo = FirstFieldNo; uint64_t NextContiguousFieldOffset = FirstFieldOffset; for (RecordDecl::field_iterator FJ = FI; (FJ != FE && (*FJ)->isBitField() && NextContiguousFieldOffset == Layout.getFieldOffset(LastFieldNo) && (*FJ)->getBitWidthValue(Types.getContext()) != 0); FI = FJ++) { NextContiguousFieldOffset += (*FJ)->getBitWidthValue(Types.getContext()); ++LastFieldNo; // We must use packed structs for packed fields, and also unnamed bit // fields since they don't affect the struct alignment. if (!Packed && ((*FJ)->hasAttr() || !(*FJ)->getDeclName())) return false; } RecordDecl::field_iterator BFE = llvm::next(FI); --LastFieldNo; assert(LastFieldNo >= FirstFieldNo && "Empty run of contiguous bitfields"); FieldDecl *LastFD = *FI; // Find the last bitfield's offset, add its size, and round it up to the // character alignment to compute the storage required. uint64_t LastFieldOffset = Layout.getFieldOffset(LastFieldNo); uint64_t LastFieldSize = LastFD->getBitWidthValue(Types.getContext()); uint64_t TotalBits = (LastFieldOffset + LastFieldSize) - FirstFieldOffset; CharUnits StorageBytes = Types.getContext().toCharUnitsFromBits( llvm::RoundUpToAlignment(TotalBits, CharAlign)); uint64_t StorageBits = Types.getContext().toBits(StorageBytes); // Grow the storage to encompass any known padding in the layout when doing // so will make the storage a power-of-two. There are two cases when we can // do this. The first is when we have a subsequent field and can widen up to // its offset. The second is when the data size of the AST record layout is // past the end of the current storage. The latter is true when there is tail // padding on a struct and no members of a super class can be packed into it. // // Note that we widen the storage as much as possible here to express the // maximum latitude the language provides, and rely on the backend to lower // these in conjunction with shifts and masks to narrower operations where // beneficial. uint64_t EndOffset = Types.getContext().toBits(Layout.getDataSize()); if (BFE != FE) // If there are more fields to be laid out, the offset at the end of the // bitfield is the offset of the next field in the record. EndOffset = Layout.getFieldOffset(LastFieldNo + 1); assert(EndOffset >= (FirstFieldOffset + TotalBits) && "End offset is not past the end of the known storage bits."); uint64_t SpaceBits = EndOffset - FirstFieldOffset; uint64_t LongBits = Types.getTarget().getLongWidth(); uint64_t WidenedBits = (StorageBits / LongBits) * LongBits + llvm::NextPowerOf2(StorageBits % LongBits - 1); assert(WidenedBits >= StorageBits && "Widening shrunk the bits!"); if (WidenedBits <= SpaceBits) { StorageBits = WidenedBits; StorageBytes = Types.getContext().toCharUnitsFromBits(StorageBits); assert(StorageBits == (uint64_t)Types.getContext().toBits(StorageBytes)); } unsigned FieldIndex = FieldTypes.size(); AppendBytes(StorageBytes); // Now walk the bitfields associating them with this field of storage and // building up the bitfield specific info. unsigned FieldNo = FirstFieldNo; for (; BFI != BFE; ++BFI, ++FieldNo) { FieldDecl *FD = *BFI; uint64_t FieldOffset = Layout.getFieldOffset(FieldNo) - FirstFieldOffset; uint64_t FieldSize = FD->getBitWidthValue(Types.getContext()); Fields[FD] = FieldIndex; BitFields[FD] = CGBitFieldInfo::MakeInfo(Types, FD, FieldOffset, FieldSize, StorageBits, StorageAlignment); } FirstFieldNo = LastFieldNo; return true; } bool CGRecordLayoutBuilder::LayoutField(const FieldDecl *D, uint64_t fieldOffset) { // If the field is packed, then we need a packed struct. if (!Packed && D->hasAttr()) return false; assert(!D->isBitField() && "Bitfields should be laid out seperately."); CheckZeroInitializable(D->getType()); assert(fieldOffset % Types.getTarget().getCharWidth() == 0 && "field offset is not on a byte boundary!"); CharUnits fieldOffsetInBytes = Types.getContext().toCharUnitsFromBits(fieldOffset); llvm::Type *Ty = Types.ConvertTypeForMem(D->getType()); CharUnits typeAlignment = getTypeAlignment(Ty); // If the type alignment is larger then the struct alignment, we must use // a packed struct. if (typeAlignment > Alignment) { assert(!Packed && "Alignment is wrong even with packed struct!"); return false; } if (!Packed) { if (const RecordType *RT = D->getType()->getAs()) { const RecordDecl *RD = cast(RT->getDecl()); if (const MaxFieldAlignmentAttr *MFAA = RD->getAttr()) { if (MFAA->getAlignment() != Types.getContext().toBits(typeAlignment)) return false; } } } // Round up the field offset to the alignment of the field type. CharUnits alignedNextFieldOffsetInBytes = NextFieldOffset.RoundUpToAlignment(typeAlignment); if (fieldOffsetInBytes < alignedNextFieldOffsetInBytes) { // Try to resize the last base field. if (ResizeLastBaseFieldIfNecessary(fieldOffsetInBytes)) { alignedNextFieldOffsetInBytes = NextFieldOffset.RoundUpToAlignment(typeAlignment); } } if (fieldOffsetInBytes < alignedNextFieldOffsetInBytes) { assert(!Packed && "Could not place field even with packed struct!"); return false; } AppendPadding(fieldOffsetInBytes, typeAlignment); // Now append the field. Fields[D] = FieldTypes.size(); AppendField(fieldOffsetInBytes, Ty); LastLaidOutBase.invalidate(); return true; } llvm::Type * CGRecordLayoutBuilder::LayoutUnionField(const FieldDecl *Field, const ASTRecordLayout &Layout) { Fields[Field] = 0; if (Field->isBitField()) { uint64_t FieldSize = Field->getBitWidthValue(Types.getContext()); // Ignore zero sized bit fields. if (FieldSize == 0) return 0; unsigned StorageBits = llvm::RoundUpToAlignment( FieldSize, Types.getTarget().getCharAlign()); CharUnits NumBytesToAppend = Types.getContext().toCharUnitsFromBits(StorageBits); llvm::Type *FieldTy = llvm::Type::getInt8Ty(Types.getLLVMContext()); if (NumBytesToAppend > CharUnits::One()) FieldTy = llvm::ArrayType::get(FieldTy, NumBytesToAppend.getQuantity()); // Add the bit field info. BitFields[Field] = CGBitFieldInfo::MakeInfo(Types, Field, 0, FieldSize, StorageBits, Alignment.getQuantity()); return FieldTy; } // This is a regular union field. return Types.ConvertTypeForMem(Field->getType()); } void CGRecordLayoutBuilder::LayoutUnion(const RecordDecl *D) { assert(D->isUnion() && "Can't call LayoutUnion on a non-union record!"); const ASTRecordLayout &layout = Types.getContext().getASTRecordLayout(D); llvm::Type *unionType = 0; CharUnits unionSize = CharUnits::Zero(); CharUnits unionAlign = CharUnits::Zero(); bool hasOnlyZeroSizedBitFields = true; bool checkedFirstFieldZeroInit = false; unsigned fieldNo = 0; for (RecordDecl::field_iterator field = D->field_begin(), fieldEnd = D->field_end(); field != fieldEnd; ++field, ++fieldNo) { assert(layout.getFieldOffset(fieldNo) == 0 && "Union field offset did not start at the beginning of record!"); llvm::Type *fieldType = LayoutUnionField(*field, layout); if (!fieldType) continue; if (field->getDeclName() && !checkedFirstFieldZeroInit) { CheckZeroInitializable(field->getType()); checkedFirstFieldZeroInit = true; } hasOnlyZeroSizedBitFields = false; CharUnits fieldAlign = CharUnits::fromQuantity( Types.getDataLayout().getABITypeAlignment(fieldType)); CharUnits fieldSize = CharUnits::fromQuantity( Types.getDataLayout().getTypeAllocSize(fieldType)); if (fieldAlign < unionAlign) continue; if (fieldAlign > unionAlign || fieldSize > unionSize) { unionType = fieldType; unionAlign = fieldAlign; unionSize = fieldSize; } } // Now add our field. if (unionType) { AppendField(CharUnits::Zero(), unionType); if (getTypeAlignment(unionType) > layout.getAlignment()) { // We need a packed struct. Packed = true; unionAlign = CharUnits::One(); } } if (unionAlign.isZero()) { (void)hasOnlyZeroSizedBitFields; assert(hasOnlyZeroSizedBitFields && "0-align record did not have all zero-sized bit-fields!"); unionAlign = CharUnits::One(); } // Append tail padding. CharUnits recordSize = layout.getSize(); if (recordSize > unionSize) AppendPadding(recordSize, unionAlign); } bool CGRecordLayoutBuilder::LayoutBase(const CXXRecordDecl *base, const CGRecordLayout &baseLayout, CharUnits baseOffset) { ResizeLastBaseFieldIfNecessary(baseOffset); AppendPadding(baseOffset, CharUnits::One()); const ASTRecordLayout &baseASTLayout = Types.getContext().getASTRecordLayout(base); LastLaidOutBase.Offset = NextFieldOffset; LastLaidOutBase.NonVirtualSize = baseASTLayout.getNonVirtualSize(); llvm::StructType *subobjectType = baseLayout.getBaseSubobjectLLVMType(); if (getTypeAlignment(subobjectType) > Alignment) return false; AppendField(baseOffset, subobjectType); return true; } bool CGRecordLayoutBuilder::LayoutNonVirtualBase(const CXXRecordDecl *base, CharUnits baseOffset) { // Ignore empty bases. if (base->isEmpty()) return true; const CGRecordLayout &baseLayout = Types.getCGRecordLayout(base); if (IsZeroInitializableAsBase) { assert(IsZeroInitializable && "class zero-initializable as base but not as complete object"); IsZeroInitializable = IsZeroInitializableAsBase = baseLayout.isZeroInitializableAsBase(); } if (!LayoutBase(base, baseLayout, baseOffset)) return false; NonVirtualBases[base] = (FieldTypes.size() - 1); return true; } bool CGRecordLayoutBuilder::LayoutVirtualBase(const CXXRecordDecl *base, CharUnits baseOffset) { // Ignore empty bases. if (base->isEmpty()) return true; const CGRecordLayout &baseLayout = Types.getCGRecordLayout(base); if (IsZeroInitializable) IsZeroInitializable = baseLayout.isZeroInitializableAsBase(); if (!LayoutBase(base, baseLayout, baseOffset)) return false; VirtualBases[base] = (FieldTypes.size() - 1); return true; } bool CGRecordLayoutBuilder::MSLayoutVirtualBases(const CXXRecordDecl *RD, const ASTRecordLayout &Layout) { if (!RD->getNumVBases()) return true; // The vbases list is uniqued and ordered by a depth-first // traversal, which is what we need here. for (CXXRecordDecl::base_class_const_iterator I = RD->vbases_begin(), E = RD->vbases_end(); I != E; ++I) { const CXXRecordDecl *BaseDecl = cast(I->getType()->castAs()->getDecl()); CharUnits vbaseOffset = Layout.getVBaseClassOffset(BaseDecl); if (!LayoutVirtualBase(BaseDecl, vbaseOffset)) return false; } return true; } /// LayoutVirtualBases - layout the non-virtual bases of a record decl. bool CGRecordLayoutBuilder::LayoutVirtualBases(const CXXRecordDecl *RD, const ASTRecordLayout &Layout) { for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), E = RD->bases_end(); I != E; ++I) { const CXXRecordDecl *BaseDecl = cast(I->getType()->getAs()->getDecl()); // We only want to lay out virtual bases that aren't indirect primary bases // of some other base. if (I->isVirtual() && !IndirectPrimaryBases.count(BaseDecl)) { // Only lay out the base once. if (!LaidOutVirtualBases.insert(BaseDecl)) continue; CharUnits vbaseOffset = Layout.getVBaseClassOffset(BaseDecl); if (!LayoutVirtualBase(BaseDecl, vbaseOffset)) return false; } if (!BaseDecl->getNumVBases()) { // This base isn't interesting since it doesn't have any virtual bases. continue; } if (!LayoutVirtualBases(BaseDecl, Layout)) return false; } return true; } bool CGRecordLayoutBuilder::LayoutNonVirtualBases(const CXXRecordDecl *RD, const ASTRecordLayout &Layout) { const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase(); // If we have a primary base, lay it out first. if (PrimaryBase) { if (!Layout.isPrimaryBaseVirtual()) { if (!LayoutNonVirtualBase(PrimaryBase, CharUnits::Zero())) return false; } else { if (!LayoutVirtualBase(PrimaryBase, CharUnits::Zero())) return false; } // Otherwise, add a vtable / vf-table if the layout says to do so. } else if (Layout.hasOwnVFPtr()) { llvm::Type *FunctionType = llvm::FunctionType::get(llvm::Type::getInt32Ty(Types.getLLVMContext()), /*isVarArg=*/true); llvm::Type *VTableTy = FunctionType->getPointerTo(); if (getTypeAlignment(VTableTy) > Alignment) { // FIXME: Should we allow this to happen in Sema? assert(!Packed && "Alignment is wrong even with packed struct!"); return false; } assert(NextFieldOffset.isZero() && "VTable pointer must come first!"); AppendField(CharUnits::Zero(), VTableTy->getPointerTo()); } // Layout the non-virtual bases. for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), E = RD->bases_end(); I != E; ++I) { if (I->isVirtual()) continue; const CXXRecordDecl *BaseDecl = cast(I->getType()->getAs()->getDecl()); // We've already laid out the primary base. if (BaseDecl == PrimaryBase && !Layout.isPrimaryBaseVirtual()) continue; if (!LayoutNonVirtualBase(BaseDecl, Layout.getBaseClassOffset(BaseDecl))) return false; } // Add a vb-table pointer if the layout insists. if (Layout.hasOwnVBPtr()) { CharUnits VBPtrOffset = Layout.getVBPtrOffset(); llvm::Type *Vbptr = llvm::Type::getInt32PtrTy(Types.getLLVMContext()); AppendPadding(VBPtrOffset, getTypeAlignment(Vbptr)); AppendField(VBPtrOffset, Vbptr); } return true; } bool CGRecordLayoutBuilder::ComputeNonVirtualBaseType(const CXXRecordDecl *RD) { const ASTRecordLayout &Layout = Types.getContext().getASTRecordLayout(RD); CharUnits NonVirtualSize = Layout.getNonVirtualSize(); CharUnits NonVirtualAlign = Layout.getNonVirtualAlign(); CharUnits AlignedNonVirtualTypeSize = NonVirtualSize.RoundUpToAlignment(NonVirtualAlign); // First check if we can use the same fields as for the complete class. CharUnits RecordSize = Layout.getSize(); if (AlignedNonVirtualTypeSize == RecordSize) return true; // Check if we need padding. CharUnits AlignedNextFieldOffset = NextFieldOffset.RoundUpToAlignment(getAlignmentAsLLVMStruct()); if (AlignedNextFieldOffset > AlignedNonVirtualTypeSize) { assert(!Packed && "cannot layout even as packed struct"); return false; // Needs packing. } bool needsPadding = (AlignedNonVirtualTypeSize != AlignedNextFieldOffset); if (needsPadding) { CharUnits NumBytes = AlignedNonVirtualTypeSize - AlignedNextFieldOffset; FieldTypes.push_back(getByteArrayType(NumBytes)); } BaseSubobjectType = llvm::StructType::create(Types.getLLVMContext(), FieldTypes, "", Packed); Types.addRecordTypeName(RD, BaseSubobjectType, ".base"); // Pull the padding back off. if (needsPadding) FieldTypes.pop_back(); return true; } bool CGRecordLayoutBuilder::LayoutFields(const RecordDecl *D) { assert(!D->isUnion() && "Can't call LayoutFields on a union!"); assert(!Alignment.isZero() && "Did not set alignment!"); const ASTRecordLayout &Layout = Types.getContext().getASTRecordLayout(D); const CXXRecordDecl *RD = dyn_cast(D); if (RD) if (!LayoutNonVirtualBases(RD, Layout)) return false; unsigned FieldNo = 0; for (RecordDecl::field_iterator FI = D->field_begin(), FE = D->field_end(); FI != FE; ++FI, ++FieldNo) { FieldDecl *FD = *FI; // If this field is a bitfield, layout all of the consecutive // non-zero-length bitfields and the last zero-length bitfield; these will // all share storage. if (FD->isBitField()) { // If all we have is a zero-width bitfield, skip it. if (FD->getBitWidthValue(Types.getContext()) == 0) continue; // Layout this range of bitfields. if (!LayoutBitfields(Layout, FieldNo, FI, FE)) { assert(!Packed && "Could not layout bitfields even with a packed LLVM struct!"); return false; } assert(FI != FE && "Advanced past the last bitfield"); continue; } if (!LayoutField(FD, Layout.getFieldOffset(FieldNo))) { assert(!Packed && "Could not layout fields even with a packed LLVM struct!"); return false; } } if (RD) { // We've laid out the non-virtual bases and the fields, now compute the // non-virtual base field types. if (!ComputeNonVirtualBaseType(RD)) { assert(!Packed && "Could not layout even with a packed LLVM struct!"); return false; } // Lay out the virtual bases. The MS ABI uses a different // algorithm here due to the lack of primary virtual bases. if (Types.getTarget().getCXXABI().hasPrimaryVBases()) { RD->getIndirectPrimaryBases(IndirectPrimaryBases); if (Layout.isPrimaryBaseVirtual()) IndirectPrimaryBases.insert(Layout.getPrimaryBase()); if (!LayoutVirtualBases(RD, Layout)) return false; } else { if (!MSLayoutVirtualBases(RD, Layout)) return false; } } // Append tail padding if necessary. AppendTailPadding(Layout.getSize()); return true; } void CGRecordLayoutBuilder::AppendTailPadding(CharUnits RecordSize) { ResizeLastBaseFieldIfNecessary(RecordSize); assert(NextFieldOffset <= RecordSize && "Size mismatch!"); CharUnits AlignedNextFieldOffset = NextFieldOffset.RoundUpToAlignment(getAlignmentAsLLVMStruct()); if (AlignedNextFieldOffset == RecordSize) { // We don't need any padding. return; } CharUnits NumPadBytes = RecordSize - NextFieldOffset; AppendBytes(NumPadBytes); } void CGRecordLayoutBuilder::AppendField(CharUnits fieldOffset, llvm::Type *fieldType) { CharUnits fieldSize = CharUnits::fromQuantity(Types.getDataLayout().getTypeAllocSize(fieldType)); FieldTypes.push_back(fieldType); NextFieldOffset = fieldOffset + fieldSize; } void CGRecordLayoutBuilder::AppendPadding(CharUnits fieldOffset, CharUnits fieldAlignment) { assert(NextFieldOffset <= fieldOffset && "Incorrect field layout!"); // Do nothing if we're already at the right offset. if (fieldOffset == NextFieldOffset) return; // If we're not emitting a packed LLVM type, try to avoid adding // unnecessary padding fields. if (!Packed) { // Round up the field offset to the alignment of the field type. CharUnits alignedNextFieldOffset = NextFieldOffset.RoundUpToAlignment(fieldAlignment); assert(alignedNextFieldOffset <= fieldOffset); // If that's the right offset, we're done. if (alignedNextFieldOffset == fieldOffset) return; } // Otherwise we need explicit padding. CharUnits padding = fieldOffset - NextFieldOffset; AppendBytes(padding); } bool CGRecordLayoutBuilder::ResizeLastBaseFieldIfNecessary(CharUnits offset) { // Check if we have a base to resize. if (!LastLaidOutBase.isValid()) return false; // This offset does not overlap with the tail padding. if (offset >= NextFieldOffset) return false; // Restore the field offset and append an i8 array instead. FieldTypes.pop_back(); NextFieldOffset = LastLaidOutBase.Offset; AppendBytes(LastLaidOutBase.NonVirtualSize); LastLaidOutBase.invalidate(); return true; } llvm::Type *CGRecordLayoutBuilder::getByteArrayType(CharUnits numBytes) { assert(!numBytes.isZero() && "Empty byte arrays aren't allowed."); llvm::Type *Ty = llvm::Type::getInt8Ty(Types.getLLVMContext()); if (numBytes > CharUnits::One()) Ty = llvm::ArrayType::get(Ty, numBytes.getQuantity()); return Ty; } void CGRecordLayoutBuilder::AppendBytes(CharUnits numBytes) { if (numBytes.isZero()) return; // Append the padding field AppendField(NextFieldOffset, getByteArrayType(numBytes)); } CharUnits CGRecordLayoutBuilder::getTypeAlignment(llvm::Type *Ty) const { if (Packed) return CharUnits::One(); return CharUnits::fromQuantity(Types.getDataLayout().getABITypeAlignment(Ty)); } CharUnits CGRecordLayoutBuilder::getAlignmentAsLLVMStruct() const { if (Packed) return CharUnits::One(); CharUnits maxAlignment = CharUnits::One(); for (size_t i = 0; i != FieldTypes.size(); ++i) maxAlignment = std::max(maxAlignment, getTypeAlignment(FieldTypes[i])); return maxAlignment; } /// Merge in whether a field of the given type is zero-initializable. void CGRecordLayoutBuilder::CheckZeroInitializable(QualType T) { // This record already contains a member pointer. if (!IsZeroInitializableAsBase) return; // Can only have member pointers if we're compiling C++. if (!Types.getContext().getLangOpts().CPlusPlus) return; const Type *elementType = T->getBaseElementTypeUnsafe(); if (const MemberPointerType *MPT = elementType->getAs()) { if (!Types.getCXXABI().isZeroInitializable(MPT)) IsZeroInitializable = IsZeroInitializableAsBase = false; } else if (const RecordType *RT = elementType->getAs()) { const CXXRecordDecl *RD = cast(RT->getDecl()); const CGRecordLayout &Layout = Types.getCGRecordLayout(RD); if (!Layout.isZeroInitializable()) IsZeroInitializable = IsZeroInitializableAsBase = false; } } CGRecordLayout *CodeGenTypes::ComputeRecordLayout(const RecordDecl *D, llvm::StructType *Ty) { CGRecordLayoutBuilder Builder(*this); Builder.Layout(D); Ty->setBody(Builder.FieldTypes, Builder.Packed); // If we're in C++, compute the base subobject type. llvm::StructType *BaseTy = 0; if (isa(D) && !D->isUnion()) { BaseTy = Builder.BaseSubobjectType; if (!BaseTy) BaseTy = Ty; } CGRecordLayout *RL = new CGRecordLayout(Ty, BaseTy, Builder.IsZeroInitializable, Builder.IsZeroInitializableAsBase); RL->NonVirtualBases.swap(Builder.NonVirtualBases); RL->CompleteObjectVirtualBases.swap(Builder.VirtualBases); // Add all the field numbers. RL->FieldInfo.swap(Builder.Fields); // Add bitfield info. RL->BitFields.swap(Builder.BitFields); // Dump the layout, if requested. if (getContext().getLangOpts().DumpRecordLayouts) { llvm::outs() << "\n*** Dumping IRgen Record Layout\n"; llvm::outs() << "Record: "; D->dump(llvm::outs()); llvm::outs() << "\nLayout: "; RL->print(llvm::outs()); } #ifndef NDEBUG // Verify that the computed LLVM struct size matches the AST layout size. const ASTRecordLayout &Layout = getContext().getASTRecordLayout(D); uint64_t TypeSizeInBits = getContext().toBits(Layout.getSize()); assert(TypeSizeInBits == getDataLayout().getTypeAllocSizeInBits(Ty) && "Type size mismatch!"); if (BaseTy) { CharUnits NonVirtualSize = Layout.getNonVirtualSize(); CharUnits NonVirtualAlign = Layout.getNonVirtualAlign(); CharUnits AlignedNonVirtualTypeSize = NonVirtualSize.RoundUpToAlignment(NonVirtualAlign); uint64_t AlignedNonVirtualTypeSizeInBits = getContext().toBits(AlignedNonVirtualTypeSize); assert(AlignedNonVirtualTypeSizeInBits == getDataLayout().getTypeAllocSizeInBits(BaseTy) && "Type size mismatch!"); } // Verify that the LLVM and AST field offsets agree. llvm::StructType *ST = dyn_cast(RL->getLLVMType()); const llvm::StructLayout *SL = getDataLayout().getStructLayout(ST); const ASTRecordLayout &AST_RL = getContext().getASTRecordLayout(D); RecordDecl::field_iterator it = D->field_begin(); for (unsigned i = 0, e = AST_RL.getFieldCount(); i != e; ++i, ++it) { const FieldDecl *FD = *it; // For non-bit-fields, just check that the LLVM struct offset matches the // AST offset. if (!FD->isBitField()) { unsigned FieldNo = RL->getLLVMFieldNo(FD); assert(AST_RL.getFieldOffset(i) == SL->getElementOffsetInBits(FieldNo) && "Invalid field offset!"); continue; } // Ignore unnamed bit-fields. if (!FD->getDeclName()) continue; // Don't inspect zero-length bitfields. if (FD->getBitWidthValue(getContext()) == 0) continue; const CGBitFieldInfo &Info = RL->getBitFieldInfo(FD); llvm::Type *ElementTy = ST->getTypeAtIndex(RL->getLLVMFieldNo(FD)); // Unions have overlapping elements dictating their layout, but for // non-unions we can verify that this section of the layout is the exact // expected size. if (D->isUnion()) { // For unions we verify that the start is zero and the size // is in-bounds. However, on BE systems, the offset may be non-zero, but // the size + offset should match the storage size in that case as it // "starts" at the back. if (getDataLayout().isBigEndian()) assert(static_cast(Info.Offset + Info.Size) == Info.StorageSize && "Big endian union bitfield does not end at the back"); else assert(Info.Offset == 0 && "Little endian union bitfield with a non-zero offset"); assert(Info.StorageSize <= SL->getSizeInBits() && "Union not large enough for bitfield storage"); } else { assert(Info.StorageSize == getDataLayout().getTypeAllocSizeInBits(ElementTy) && "Storage size does not match the element type size"); } assert(Info.Size > 0 && "Empty bitfield!"); assert(static_cast(Info.Offset) + Info.Size <= Info.StorageSize && "Bitfield outside of its allocated storage"); } #endif return RL; } void CGRecordLayout::print(raw_ostream &OS) const { OS << " > BFIs; for (llvm::DenseMap::const_iterator it = BitFields.begin(), ie = BitFields.end(); it != ie; ++it) { const RecordDecl *RD = it->first->getParent(); unsigned Index = 0; for (RecordDecl::field_iterator it2 = RD->field_begin(); *it2 != it->first; ++it2) ++Index; BFIs.push_back(std::make_pair(Index, &it->second)); } llvm::array_pod_sort(BFIs.begin(), BFIs.end()); for (unsigned i = 0, e = BFIs.size(); i != e; ++i) { OS.indent(4); BFIs[i].second->print(OS); OS << "\n"; } OS << "]>\n"; } void CGRecordLayout::dump() const { print(llvm::errs()); } void CGBitFieldInfo::print(raw_ostream &OS) const { OS << ""; } void CGBitFieldInfo::dump() const { print(llvm::errs()); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d384 1 a384 1 assert(!D->isBitField() && "Bitfields should be laid out separately."); @ 1.1.1.3 log @Import Clang 3.5svn r199312 @ text @a146 5 /// MSLayoutNonVirtualBases - layout the virtual bases of a record decl, /// like MSVC. bool MSLayoutNonVirtualBases(const CXXRecordDecl *RD, const ASTRecordLayout &Layout); a710 66 CGRecordLayoutBuilder::MSLayoutNonVirtualBases(const CXXRecordDecl *RD, const ASTRecordLayout &Layout) { // Add a vfptr if the layout says to do so. if (Layout.hasOwnVFPtr()) { llvm::Type *FunctionType = llvm::FunctionType::get(llvm::Type::getInt32Ty(Types.getLLVMContext()), /*isVarArg=*/true); llvm::Type *VTableTy = FunctionType->getPointerTo(); if (getTypeAlignment(VTableTy) > Alignment) { // FIXME: Should we allow this to happen in Sema? assert(!Packed && "Alignment is wrong even with packed struct!"); return false; } assert(NextFieldOffset.isZero() && "VTable pointer must come first!"); AppendField(CharUnits::Zero(), VTableTy->getPointerTo()); } // Layout the non-virtual bases that have leading vfptrs. for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), E = RD->bases_end(); I != E; ++I) { if (I->isVirtual()) continue; const CXXRecordDecl *BaseDecl = cast(I->getType()->getAs()->getDecl()); const ASTRecordLayout &BaseLayout = Types.getContext().getASTRecordLayout(BaseDecl); if (!BaseLayout.hasExtendableVFPtr()) continue; if (!LayoutNonVirtualBase(BaseDecl, Layout.getBaseClassOffset(BaseDecl))) return false; } // Layout the non-virtual bases that don't have leading vfptrs. for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), E = RD->bases_end(); I != E; ++I) { if (I->isVirtual()) continue; const CXXRecordDecl *BaseDecl = cast(I->getType()->getAs()->getDecl()); const ASTRecordLayout &BaseLayout = Types.getContext().getASTRecordLayout(BaseDecl); if (BaseLayout.hasExtendableVFPtr()) continue; if (!LayoutNonVirtualBase(BaseDecl, Layout.getBaseClassOffset(BaseDecl))) return false; } // Add a vb-table pointer if the layout insists. if (Layout.hasOwnVBPtr()) { CharUnits VBPtrOffset = Layout.getVBPtrOffset(); llvm::Type *Vbptr = llvm::Type::getInt32PtrTy(Types.getLLVMContext()); AppendPadding(VBPtrOffset, getTypeAlignment(Vbptr)); AppendField(VBPtrOffset, Vbptr); } return true; } bool d715 1 a715 1 CharUnits NonVirtualAlign = Layout.getNonVirtualAlignment(); d757 2 a758 5 if (RD) { if (Types.getTarget().getCXXABI().isMicrosoft()) { if (!MSLayoutNonVirtualBases(RD, Layout)) return false; } else if (!LayoutNonVirtualBases(RD, Layout)) a759 1 } d997 1 a997 1 CharUnits NonVirtualAlign = Layout.getNonVirtualAlignment(); @ 1.1.1.4 log @Import Clang 3.5svn r201163. @ text @d347 1 a347 6 uint64_t EndOffset; if (Types.getContext().getLangOpts().CPlusPlus) // Do not grow the bitfield storage into the following virtual base. EndOffset = Types.getContext().toBits(Layout.getNonVirtualSize()); else EndOffset = Types.getContext().toBits(Layout.getDataSize()); d561 1 a561 6 if (LastLaidOutBase.NonVirtualSize < CharUnits::fromQuantity( Types.getDataLayout().getStructLayout(subobjectType)->getSizeInBytes())) AppendBytes(LastLaidOutBase.NonVirtualSize); else AppendField(baseOffset, subobjectType); @ 1.1.1.5 log @Import Clang 3.5svn r202566. @ text @a27 1 #include "llvm/Support/MathExtras.h" d33 5 a37 158 /// The CGRecordLowering is responsible for lowering an ASTRecordLayout to an /// llvm::Type. Some of the lowering is straightforward, some is not. Here we /// detail some of the complexities and weirdnesses here. /// * LLVM does not have unions - Unions can, in theory be represented by any /// llvm::Type with correct size. We choose a field via a specific heuristic /// and add padding if necessary. /// * LLVM does not have bitfields - Bitfields are collected into contiguous /// runs and allocated as a single storage type for the run. ASTRecordLayout /// contains enough information to determine where the runs break. Microsoft /// and Itanium follow different rules and use different codepaths. /// * It is desired that, when possible, bitfields use the appropriate iN type /// when lowered to llvm types. For example unsigned x : 24 gets lowered to /// i24. This isn't always possible because i24 has storage size of 32 bit /// and if it is possible to use that extra byte of padding we must use /// [i8 x 3] instead of i24. The function clipTailPadding does this. /// C++ examples that require clipping: /// struct { int a : 24; char b; }; // a must be clipped, b goes at offset 3 /// struct A { int a : 24; }; // a must be clipped because a struct like B // could exist: struct B : A { char b; }; // b goes at offset 3 /// * Clang ignores 0 sized bitfields and 0 sized bases but *not* zero sized /// fields. The existing asserts suggest that LLVM assumes that *every* field /// has an underlying storage type. Therefore empty structures containing /// zero sized subobjects such as empty records or zero sized arrays still get /// a zero sized (empty struct) storage type. /// * Clang reads the complete type rather than the base type when generating /// code to access fields. Bitfields in tail position with tail padding may /// be clipped in the base class but not the complete class (we may discover /// that the tail padding is not used in the complete class.) However, /// because LLVM reads from the complete type it can generate incorrect code /// if we do not clip the tail padding off of the bitfield in the complete /// layout. This introduces a somewhat awkward extra unnecessary clip stage. /// The location of the clip is stored internally as a sentinal of type /// SCISSOR. If LLVM were updated to read base types (which it probably /// should because locations of things such as VBases are bogus in the llvm /// type anyway) then we could eliminate the SCISSOR. /// * Itanium allows nearly empty primary virtual bases. These bases don't get /// get their own storage because they're laid out as part of another base /// or at the beginning of the structure. Determining if a VBase actually /// gets storage awkwardly involves a walk of all bases. /// * VFPtrs and VBPtrs do *not* make a record NotZeroInitializable. struct CGRecordLowering { // MemberInfo is a helper structure that contains information about a record // member. In additional to the standard member types, there exists a // sentinal member type that ensures correct rounding. struct MemberInfo { CharUnits Offset; enum InfoKind { VFPtr, VBPtr, Field, Base, VBase, Scissor } Kind; llvm::Type *Data; union { const FieldDecl *FD; const CXXRecordDecl *RD; }; MemberInfo(CharUnits Offset, InfoKind Kind, llvm::Type *Data, const FieldDecl *FD = 0) : Offset(Offset), Kind(Kind), Data(Data), FD(FD) {} MemberInfo(CharUnits Offset, InfoKind Kind, llvm::Type *Data, const CXXRecordDecl *RD) : Offset(Offset), Kind(Kind), Data(Data), RD(RD) {} // MemberInfos are sorted so we define a < operator. bool operator <(const MemberInfo& a) const { return Offset < a.Offset; } }; // The constructor. CGRecordLowering(CodeGenTypes &Types, const RecordDecl *D); // Short helper routines. /// \brief Constructs a MemberInfo instance from an offset and llvm::Type *. MemberInfo StorageInfo(CharUnits Offset, llvm::Type *Data) { return MemberInfo(Offset, MemberInfo::Field, Data); } bool useMSABI() { return Context.getTargetInfo().getCXXABI().isMicrosoft() || D->isMsStruct(Context); } /// \brief Wraps llvm::Type::getIntNTy with some implicit arguments. llvm::Type *getIntNType(uint64_t NumBits) { return llvm::Type::getIntNTy(Types.getLLVMContext(), (unsigned)llvm::RoundUpToAlignment(NumBits, 8)); } /// \brief Gets an llvm type of size NumBytes and alignment 1. llvm::Type *getByteArrayType(CharUnits NumBytes) { assert(!NumBytes.isZero() && "Empty byte arrays aren't allowed."); llvm::Type *Type = llvm::Type::getInt8Ty(Types.getLLVMContext()); return NumBytes == CharUnits::One() ? Type : (llvm::Type *)llvm::ArrayType::get(Type, NumBytes.getQuantity()); } /// \brief Gets the storage type for a field decl and handles storage /// for itanium bitfields that are smaller than their declared type. llvm::Type *getStorageType(const FieldDecl *FD) { llvm::Type *Type = Types.ConvertTypeForMem(FD->getType()); return useMSABI() || !FD->isBitField() ? Type : getIntNType(std::min(FD->getBitWidthValue(Context), (unsigned)Context.toBits(getSize(Type)))); } /// \brief Gets the llvm Basesubobject type from a CXXRecordDecl. llvm::Type *getStorageType(const CXXRecordDecl *RD) { return Types.getCGRecordLayout(RD).getBaseSubobjectLLVMType(); } CharUnits bitsToCharUnits(uint64_t BitOffset) { return Context.toCharUnitsFromBits(BitOffset); } CharUnits getSize(llvm::Type *Type) { return CharUnits::fromQuantity(DataLayout.getTypeAllocSize(Type)); } CharUnits getAlignment(llvm::Type *Type) { return CharUnits::fromQuantity(DataLayout.getABITypeAlignment(Type)); } bool isZeroInitializable(const FieldDecl *FD) { const Type *Type = FD->getType()->getBaseElementTypeUnsafe(); if (const MemberPointerType *MPT = Type->getAs()) return Types.getCXXABI().isZeroInitializable(MPT); if (const RecordType *RT = Type->getAs()) return isZeroInitializable(RT->getDecl()); return true; } bool isZeroInitializable(const RecordDecl *RD) { return Types.getCGRecordLayout(RD).isZeroInitializable(); } void appendPaddingBytes(CharUnits Size) { if (!Size.isZero()) FieldTypes.push_back(getByteArrayType(Size)); } uint64_t getFieldBitOffset(const FieldDecl *FD) { return Layout.getFieldOffset(FD->getFieldIndex()); } // Layout routines. void setBitFieldInfo(const FieldDecl *FD, CharUnits StartOffset, llvm::Type *StorageType); /// \brief Lowers an ASTRecordLayout to a llvm type. void lower(bool NonVirtualBaseType); void lowerUnion(); void accumulateFields(); void accumulateBitFields(RecordDecl::field_iterator Field, RecordDecl::field_iterator FieldEnd); void accumulateBases(); void accumulateVPtrs(); void accumulateVBases(); /// \brief Recursively searches all of the bases to find out if a vbase is /// not the primary vbase of some base class. bool hasOwnStorage(const CXXRecordDecl *Decl, const CXXRecordDecl *Query); void calculateZeroInit(); /// \brief Lowers bitfield storage types to I8 arrays for bitfields with tail /// padding that is or can potentially be used. void clipTailPadding(); /// \brief Determines if we need a packed llvm struct. void determinePacked(); /// \brief Inserts padding everwhere it's needed. void insertPadding(); /// \brief Fills out the structures that are ultimately consumed. void fillOutputFields(); // Input memoization fields. CodeGenTypes &Types; const ASTContext &Context; const RecordDecl *D; const CXXRecordDecl *RD; const ASTRecordLayout &Layout; const llvm::DataLayout &DataLayout; // Helpful intermediate data-structures. std::vector Members; // Output fields, consumed by CodeGenTypes::ComputeRecordLayout. d39 19 d59 2 d62 1 d65 17 a81 3 bool IsZeroInitializable : 1; bool IsZeroInitializableAsBase : 1; bool Packed : 1; d83 121 a203 2 CGRecordLowering(const CGRecordLowering &) LLVM_DELETED_FUNCTION; void operator =(const CGRecordLowering &) LLVM_DELETED_FUNCTION; a204 1 } // namespace { a205 27 CGRecordLowering::CGRecordLowering(CodeGenTypes &Types, const RecordDecl *D) : Types(Types), Context(Types.getContext()), D(D), RD(dyn_cast(D)), Layout(Types.getContext().getASTRecordLayout(D)), DataLayout(Types.getDataLayout()), IsZeroInitializable(true), IsZeroInitializableAsBase(true), Packed(false) {} void CGRecordLowering::setBitFieldInfo( const FieldDecl *FD, CharUnits StartOffset, llvm::Type *StorageType) { CGBitFieldInfo &Info = BitFields[FD]; Info.IsSigned = FD->getType()->isSignedIntegerOrEnumerationType(); Info.Offset = (unsigned)(getFieldBitOffset(FD) - Context.toBits(StartOffset)); Info.Size = FD->getBitWidthValue(Context); Info.StorageSize = (unsigned)DataLayout.getTypeAllocSizeInBits(StorageType); // Here we calculate the actual storage alignment of the bits. E.g if we've // got an alignment >= 2 and the bitfield starts at offset 6 we've got an // alignment of 2. Info.StorageAlignment = Layout.getAlignment().alignmentAtOffset(StartOffset).getQuantity(); if (Info.Size > Info.StorageSize) Info.Size = Info.StorageSize; // Reverse the bit offsets for big endian machines. Because we represent // a bitfield as a single large integer load, we can imagine the bits // counting from the most-significant-bit instead of the // least-significant-bit. if (DataLayout.isBigEndian()) Info.Offset = Info.StorageSize - (Info.Offset + Info.Size); d208 4 a211 106 void CGRecordLowering::lower(bool NVBaseType) { // The lowering process implemented in this function takes a variety of // carefully ordered phases. // 1) Store all members (fields and bases) in a list and sort them by offset. // 2) Add a 1-byte capstone member at the Size of the structure. // 3) Clip bitfield storages members if their tail padding is or might be // used by another field or base. The clipping process uses the capstone // by treating it as another object that occurs after the record. // 4) Determine if the llvm-struct requires packing. It's important that this // phase occur after clipping, because clipping changes the llvm type. // This phase reads the offset of the capstone when determining packedness // and updates the alignment of the capstone to be equal of the alignment // of the record after doing so. // 5) Insert padding everywhere it is needed. This phase requires 'Packed' to // have been computed and needs to know the alignment of the record in // order to understand if explicit tail padding is needed. // 6) Remove the capstone, we don't need it anymore. // 7) Determine if this record can be zero-initialized. This phase could have // been placed anywhere after phase 1. // 8) Format the complete list of members in a way that can be consumed by // CodeGenTypes::ComputeRecordLayout. CharUnits Size = NVBaseType ? Layout.getNonVirtualSize() : Layout.getSize(); if (D->isUnion()) return lowerUnion(); accumulateFields(); // RD implies C++. if (RD) { accumulateVPtrs(); accumulateBases(); if (Members.empty()) return appendPaddingBytes(Size); if (!NVBaseType) accumulateVBases(); } std::stable_sort(Members.begin(), Members.end()); Members.push_back(StorageInfo(Size, getIntNType(8))); clipTailPadding(); determinePacked(); insertPadding(); Members.pop_back(); calculateZeroInit(); fillOutputFields(); } void CGRecordLowering::lowerUnion() { CharUnits LayoutSize = Layout.getSize(); llvm::Type *StorageType = 0; // Compute zero-initializable status. if (!D->field_empty() && !isZeroInitializable(*D->field_begin())) IsZeroInitializable = IsZeroInitializableAsBase = false; // Iterate through the fields setting bitFieldInfo and the Fields array. Also // locate the "most appropriate" storage type. The heuristic for finding the // storage type isn't necessary, the first (non-0-length-bitfield) field's // type would work fine and be simpler but would be differen than what we've // been doing and cause lit tests to change. for (RecordDecl::field_iterator Field = D->field_begin(), FieldEnd = D->field_end(); Field != FieldEnd; ++Field) { if (Field->isBitField()) { // Skip 0 sized bitfields. if (Field->getBitWidthValue(Context) == 0) continue; llvm::Type *FieldType = getStorageType(*Field); if (LayoutSize < getSize(FieldType)) FieldType = getByteArrayType(LayoutSize); setBitFieldInfo(*Field, CharUnits::Zero(), FieldType); } Fields[*Field] = 0; llvm::Type *FieldType = getStorageType(*Field); // Conditionally update our storage type if we've got a new "better" one. if (!StorageType || getAlignment(FieldType) > getAlignment(StorageType) || (getAlignment(FieldType) == getAlignment(StorageType) && getSize(FieldType) > getSize(StorageType))) StorageType = FieldType; } // If we have no storage type just pad to the appropriate size and return. if (!StorageType) return appendPaddingBytes(LayoutSize); // If our storage size was bigger than our required size (can happen in the // case of packed bitfields on Itanium) then just use an I8 array. if (LayoutSize < getSize(StorageType)) StorageType = getByteArrayType(LayoutSize); FieldTypes.push_back(StorageType); appendPaddingBytes(LayoutSize - getSize(StorageType)); // Set packed if we need it. if (LayoutSize % getAlignment(StorageType)) Packed = true; } void CGRecordLowering::accumulateFields() { for (RecordDecl::field_iterator Field = D->field_begin(), FieldEnd = D->field_end(); Field != FieldEnd;) if (Field->isBitField()) { RecordDecl::field_iterator Start = Field; // Iterate to gather the list of bitfields. for (++Field; Field != FieldEnd && Field->isBitField(); ++Field); accumulateBitFields(Start, Field); } else { Members.push_back(MemberInfo( bitsToCharUnits(getFieldBitOffset(*Field)), MemberInfo::Field, getStorageType(*Field), *Field)); ++Field; } } d213 2 a214 38 void CGRecordLowering::accumulateBitFields(RecordDecl::field_iterator Field, RecordDecl::field_iterator FieldEnd) { // Run stores the first element of the current run of bitfields. FieldEnd is // used as a special value to note that we don't have a current run. A // bitfield run is a contiguous collection of bitfields that can be stored in // the same storage block. Zero-sized bitfields and bitfields that would // cross an alignment boundary break a run and start a new one. RecordDecl::field_iterator Run = FieldEnd; // Tail is the offset of the first bit off the end of the current run. It's // used to determine if the ASTRecordLayout is treating these two bitfields as // contiguous. StartBitOffset is offset of the beginning of the Run. uint64_t StartBitOffset, Tail = 0; if (useMSABI()) { for (; Field != FieldEnd; ++Field) { uint64_t BitOffset = getFieldBitOffset(*Field); // Zero-width bitfields end runs. if (Field->getBitWidthValue(Context) == 0) { Run = FieldEnd; continue; } llvm::Type *Type = Types.ConvertTypeForMem(Field->getType()); // If we don't have a run yet, or don't live within the previous run's // allocated storage then we allocate some storage and start a new run. if (Run == FieldEnd || BitOffset >= Tail) { Run = Field; StartBitOffset = BitOffset; Tail = StartBitOffset + DataLayout.getTypeAllocSizeInBits(Type); // Add the storage member to the record. This must be added to the // record before the bitfield members so that it gets laid out before // the bitfields it contains get laid out. Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset), Type)); } // Bitfields get the offset of their storage but come afterward and remain // there after a stable sort. Members.push_back(MemberInfo(bitsToCharUnits(StartBitOffset), MemberInfo::Field, 0, *Field)); } a216 102 for (;;) { // Check to see if we need to start a new run. if (Run == FieldEnd) { // If we're out of fields, return. if (Field == FieldEnd) break; // Any non-zero-length bitfield can start a new run. if (Field->getBitWidthValue(Context) != 0) { Run = Field; StartBitOffset = getFieldBitOffset(*Field); Tail = StartBitOffset + Field->getBitWidthValue(Context); } ++Field; continue; } // Add bitfields to the run as long as they qualify. if (Field != FieldEnd && Field->getBitWidthValue(Context) != 0 && Tail == getFieldBitOffset(*Field)) { Tail += Field->getBitWidthValue(Context); ++Field; continue; } // We've hit a break-point in the run and need to emit a storage field. llvm::Type *Type = getIntNType(Tail - StartBitOffset); // Add the storage member to the record and set the bitfield info for all of // the bitfields in the run. Bitfields get the offset of their storage but // come afterward and remain there after a stable sort. Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset), Type)); for (; Run != Field; ++Run) Members.push_back(MemberInfo(bitsToCharUnits(StartBitOffset), MemberInfo::Field, 0, *Run)); Run = FieldEnd; } } void CGRecordLowering::accumulateBases() { // If we've got a primary virtual base, we need to add it with the bases. if (Layout.isPrimaryBaseVirtual()) Members.push_back(StorageInfo( CharUnits::Zero(), getStorageType(Layout.getPrimaryBase()))); // Accumulate the non-virtual bases. for (CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(), BaseEnd = RD->bases_end(); Base != BaseEnd; ++Base) { if (Base->isVirtual()) continue; const CXXRecordDecl *BaseDecl = Base->getType()->getAsCXXRecordDecl(); if (!BaseDecl->isEmpty()) Members.push_back(MemberInfo(Layout.getBaseClassOffset(BaseDecl), MemberInfo::Base, getStorageType(BaseDecl), BaseDecl)); } } void CGRecordLowering::accumulateVPtrs() { if (Layout.hasOwnVFPtr()) Members.push_back(MemberInfo(CharUnits::Zero(), MemberInfo::VFPtr, llvm::FunctionType::get(getIntNType(32), /*isVarArg=*/true)-> getPointerTo()->getPointerTo())); if (Layout.hasOwnVBPtr()) Members.push_back(MemberInfo(Layout.getVBPtrOffset(), MemberInfo::VBPtr, llvm::Type::getInt32PtrTy(Types.getLLVMContext()))); } void CGRecordLowering::accumulateVBases() { Members.push_back(MemberInfo(Layout.getNonVirtualSize(), MemberInfo::Scissor, 0, RD)); for (CXXRecordDecl::base_class_const_iterator Base = RD->vbases_begin(), BaseEnd = RD->vbases_end(); Base != BaseEnd; ++Base) { const CXXRecordDecl *BaseDecl = Base->getType()->getAsCXXRecordDecl(); if (BaseDecl->isEmpty()) continue; CharUnits Offset = Layout.getVBaseClassOffset(BaseDecl); // If the vbase is a primary virtual base of some base, then it doesn't // get its own storage location but instead lives inside of that base. if (!useMSABI() && Context.isNearlyEmpty(BaseDecl) && !hasOwnStorage(RD, BaseDecl)) { Members.push_back(MemberInfo(Offset, MemberInfo::VBase, 0, BaseDecl)); continue; } // If we've got a vtordisp, add it as a storage type. if (Layout.getVBaseOffsetsMap().find(BaseDecl)->second.hasVtorDisp()) Members.push_back(StorageInfo(Offset - CharUnits::fromQuantity(4), getIntNType(32))); Members.push_back(MemberInfo(Offset, MemberInfo::VBase, getStorageType(BaseDecl), BaseDecl)); } } bool CGRecordLowering::hasOwnStorage(const CXXRecordDecl *Decl, const CXXRecordDecl *Query) { const ASTRecordLayout &DeclLayout = Context.getASTRecordLayout(Decl); if (DeclLayout.isPrimaryBaseVirtual() && DeclLayout.getPrimaryBase() == Query) return false; for (CXXRecordDecl::base_class_const_iterator Base = Decl->bases_begin(), BaseEnd = Decl->bases_end(); Base != BaseEnd; ++Base) if (!hasOwnStorage(Base->getType()->getAsCXXRecordDecl(), Query)) return false; return true; } d218 2 a219 18 void CGRecordLowering::calculateZeroInit() { for (std::vector::const_iterator Member = Members.begin(), MemberEnd = Members.end(); IsZeroInitializableAsBase && Member != MemberEnd; ++Member) { if (Member->Kind == MemberInfo::Field) { if (!Member->FD || isZeroInitializable(Member->FD)) continue; IsZeroInitializable = IsZeroInitializableAsBase = false; } else if (Member->Kind == MemberInfo::Base || Member->Kind == MemberInfo::VBase) { if (isZeroInitializable(Member->RD)) continue; IsZeroInitializable = false; if (Member->Kind == MemberInfo::Base) IsZeroInitializableAsBase = false; } } } d221 9 a229 20 void CGRecordLowering::clipTailPadding() { std::vector::iterator Prior = Members.begin(); CharUnits Tail = getSize(Prior->Data); for (std::vector::iterator Member = Prior + 1, MemberEnd = Members.end(); Member != MemberEnd; ++Member) { // Only members with data and the scissor can cut into tail padding. if (!Member->Data && Member->Kind != MemberInfo::Scissor) continue; if (Member->Offset < Tail) { assert(Prior->Kind == MemberInfo::Field && !Prior->FD && "Only storage fields have tail padding!"); Prior->Data = getByteArrayType(bitsToCharUnits(llvm::RoundUpToAlignment( cast(Prior->Data)->getIntegerBitWidth(), 8))); } if (Member->Data) Prior = Member; Tail = Prior->Offset + getSize(Prior->Data); } } d231 1 a231 65 void CGRecordLowering::determinePacked() { CharUnits Alignment = CharUnits::One(); for (std::vector::const_iterator Member = Members.begin(), MemberEnd = Members.end(); Member != MemberEnd; ++Member) { if (!Member->Data) continue; // If any member falls at an offset that it not a multiple of its alignment, // then the entire record must be packed. if (Member->Offset % getAlignment(Member->Data)) Packed = true; Alignment = std::max(Alignment, getAlignment(Member->Data)); } // If the size of the record (the capstone's offset) is not a multiple of the // record's alignment, it must be packed. if (Members.back().Offset % Alignment) Packed = true; // Update the alignment of the sentinal. if (!Packed) Members.back().Data = getIntNType(Context.toBits(Alignment)); } void CGRecordLowering::insertPadding() { std::vector > Padding; CharUnits Size = CharUnits::Zero(); for (std::vector::const_iterator Member = Members.begin(), MemberEnd = Members.end(); Member != MemberEnd; ++Member) { if (!Member->Data) continue; CharUnits Offset = Member->Offset; assert(Offset >= Size); // Insert padding if we need to. if (Offset != Size.RoundUpToAlignment(Packed ? CharUnits::One() : getAlignment(Member->Data))) Padding.push_back(std::make_pair(Size, Offset - Size)); Size = Offset + getSize(Member->Data); } if (Padding.empty()) return; // Add the padding to the Members list and sort it. for (std::vector >::const_iterator Pad = Padding.begin(), PadEnd = Padding.end(); Pad != PadEnd; ++Pad) Members.push_back(StorageInfo(Pad->first, getByteArrayType(Pad->second))); std::stable_sort(Members.begin(), Members.end()); } void CGRecordLowering::fillOutputFields() { for (std::vector::const_iterator Member = Members.begin(), MemberEnd = Members.end(); Member != MemberEnd; ++Member) { if (Member->Data) FieldTypes.push_back(Member->Data); if (Member->Kind == MemberInfo::Field) { if (Member->FD) Fields[Member->FD] = FieldTypes.size() - 1; // A field without storage must be a bitfield. if (!Member->Data) setBitFieldInfo(Member->FD, Member->Offset, FieldTypes.back()); } else if (Member->Kind == MemberInfo::Base) NonVirtualBases[Member->RD] = FieldTypes.size() - 1; else if (Member->Kind == MemberInfo::VBase) VirtualBases[Member->RD] = FieldTypes.size() - 1; } a238 3 // This function is vestigial from CGRecordLayoutBuilder days but is still // used in GCObjCRuntime.cpp. That usage has a "fixme" attached to it that // when addressed will allow for the removal of this function. d270 765 d1037 3 a1039 1 CGRecordLowering Builder(*this, D); d1041 1 a1041 1 Builder.lower(false); d1045 3 a1047 9 if (isa(D) && !D->isUnion() && !D->hasAttr()) { BaseTy = Ty; if (Builder.Layout.getNonVirtualSize() != Builder.Layout.getSize()) { CGRecordLowering BaseBuilder(*this, D); BaseBuilder.lower(true); BaseTy = llvm::StructType::create( getLLVMContext(), BaseBuilder.FieldTypes, "", BaseBuilder.Packed); addRecordTypeName(D, BaseTy, ".base"); } a1049 5 // Fill in the struct *after* computing the base type. Filling in the body // signifies that the type is no longer opaque and record layout is complete, // but we may need to recursively layout D while laying D out as a base type. Ty->setBody(Builder.FieldTypes, Builder.Packed); d1052 1 a1052 1 Builder.IsZeroInitializableAsBase); d1082 3 d1087 1 a1087 1 getContext().toBits(NonVirtualSize); @ 1.1.1.5.2.1 log @Rebase. @ text @d87 1 a87 1 const FieldDecl *FD = nullptr) d215 1 a215 1 CGBitFieldInfo &Info = BitFields[FD->getCanonicalDecl()]; d281 1 a281 1 llvm::Type *StorageType = nullptr; d290 3 a292 1 for (const auto *Field : D->fields()) { d297 1 a297 1 llvm::Type *FieldType = getStorageType(Field); d300 1 a300 1 setBitFieldInfo(Field, CharUnits::Zero(), FieldType); d302 2 a303 2 Fields[Field->getCanonicalDecl()] = 0; llvm::Type *FieldType = getStorageType(Field); d378 1 a378 1 MemberInfo::Field, nullptr, *Field)); d412 1 a412 1 MemberInfo::Field, nullptr, *Run)); d419 4 a422 5 if (Layout.isPrimaryBaseVirtual()) { const CXXRecordDecl *BaseDecl = Layout.getPrimaryBase(); Members.push_back(MemberInfo(CharUnits::Zero(), MemberInfo::Base, getStorageType(BaseDecl), BaseDecl)); } d424 4 a427 2 for (const auto &Base : RD->bases()) { if (Base.isVirtual()) d429 1 a429 1 const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); d447 6 a452 21 CharUnits ScissorOffset = Layout.getNonVirtualSize(); // In the itanium ABI, it's possible to place a vbase at a dsize that is // smaller than the nvsize. Here we check to see if such a base is placed // before the nvsize and set the scissor offset to that, instead of the // nvsize. if (!useMSABI()) for (const auto &Base : RD->vbases()) { const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); if (BaseDecl->isEmpty()) continue; // If the vbase is a primary virtual base of some base, then it doesn't // get its own storage location but instead lives inside of that base. if (Context.isNearlyEmpty(BaseDecl) && !hasOwnStorage(RD, BaseDecl)) continue; ScissorOffset = std::min(ScissorOffset, Layout.getVBaseClassOffset(BaseDecl)); } Members.push_back(MemberInfo(ScissorOffset, MemberInfo::Scissor, nullptr, RD)); for (const auto &Base : RD->vbases()) { const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); d460 1 a460 2 Members.push_back(MemberInfo(Offset, MemberInfo::VBase, nullptr, BaseDecl)); d477 4 a480 2 for (const auto &Base : Decl->bases()) if (!hasOwnStorage(Base.getType()->getAsCXXRecordDecl(), Query)) d581 1 a581 1 Fields[Member->FD->getCanonicalDecl()] = FieldTypes.size() - 1; d638 1 a638 1 llvm::StructType *BaseTy = nullptr; @ 1.1.1.6 log @Import Clang 3.5svn r209886. @ text @d87 1 a87 1 const FieldDecl *FD = nullptr) d215 1 a215 1 CGBitFieldInfo &Info = BitFields[FD->getCanonicalDecl()]; d281 1 a281 1 llvm::Type *StorageType = nullptr; d290 3 a292 1 for (const auto *Field : D->fields()) { d297 1 a297 1 llvm::Type *FieldType = getStorageType(Field); d300 1 a300 1 setBitFieldInfo(Field, CharUnits::Zero(), FieldType); d302 2 a303 2 Fields[Field->getCanonicalDecl()] = 0; llvm::Type *FieldType = getStorageType(Field); d378 1 a378 1 MemberInfo::Field, nullptr, *Field)); d412 1 a412 1 MemberInfo::Field, nullptr, *Run)); d419 4 a422 5 if (Layout.isPrimaryBaseVirtual()) { const CXXRecordDecl *BaseDecl = Layout.getPrimaryBase(); Members.push_back(MemberInfo(CharUnits::Zero(), MemberInfo::Base, getStorageType(BaseDecl), BaseDecl)); } d424 4 a427 2 for (const auto &Base : RD->bases()) { if (Base.isVirtual()) d429 1 a429 1 const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); d447 6 a452 21 CharUnits ScissorOffset = Layout.getNonVirtualSize(); // In the itanium ABI, it's possible to place a vbase at a dsize that is // smaller than the nvsize. Here we check to see if such a base is placed // before the nvsize and set the scissor offset to that, instead of the // nvsize. if (!useMSABI()) for (const auto &Base : RD->vbases()) { const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); if (BaseDecl->isEmpty()) continue; // If the vbase is a primary virtual base of some base, then it doesn't // get its own storage location but instead lives inside of that base. if (Context.isNearlyEmpty(BaseDecl) && !hasOwnStorage(RD, BaseDecl)) continue; ScissorOffset = std::min(ScissorOffset, Layout.getVBaseClassOffset(BaseDecl)); } Members.push_back(MemberInfo(ScissorOffset, MemberInfo::Scissor, nullptr, RD)); for (const auto &Base : RD->vbases()) { const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); d460 1 a460 2 Members.push_back(MemberInfo(Offset, MemberInfo::VBase, nullptr, BaseDecl)); d477 4 a480 2 for (const auto &Base : Decl->bases()) if (!hasOwnStorage(Base.getType()->getAsCXXRecordDecl(), Query)) d581 1 a581 1 Fields[Member->FD->getCanonicalDecl()] = FieldTypes.size() - 1; d638 1 a638 1 llvm::StructType *BaseTy = nullptr; @ 1.1.1.6.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d96 1 a96 1 CGRecordLowering(CodeGenTypes &Types, const RecordDecl *D, bool Packed); d177 1 a177 1 void determinePacked(bool NVBaseType); d206 1 a206 1 CGRecordLowering::CGRecordLowering(CodeGenTypes &Types, const RecordDecl *D, bool Packed) d211 1 a211 1 IsZeroInitializableAsBase(true), Packed(Packed) {} d272 1 a272 1 determinePacked(NVBaseType); d282 3 a284 1 bool SeenNamedMember = false; d288 1 a288 1 // type would work fine and be simpler but would be different than what we've a301 17 // Compute zero-initializable status. // This union might not be zero initialized: it may contain a pointer to // data member which might have some exotic initialization sequence. // If this is the case, then we aught not to try and come up with a "better" // type, it might not be very easy to come up with a Constant which // correctly initializes it. if (!SeenNamedMember && Field->getDeclName()) { SeenNamedMember = true; if (!isZeroInitializable(Field)) { IsZeroInitializable = IsZeroInitializableAsBase = false; StorageType = FieldType; } } // Because our union isn't zero initializable, we won't be getting a better // storage type. if (!IsZeroInitializable) continue; d536 1 a536 3 void CGRecordLowering::determinePacked(bool NVBaseType) { if (Packed) return; a537 3 CharUnits NVAlignment = CharUnits::One(); CharUnits NVSize = !NVBaseType && RD ? Layout.getNonVirtualSize() : CharUnits::Zero(); a546 2 if (Member->Offset < NVSize) NVAlignment = std::max(NVAlignment, getAlignment(Member->Data)); a552 5 // If the non-virtual sub-object is not a multiple of the non-virtual // sub-object's alignment, it must be packed. We cannot have a packed // non-virtual sub-object and an unpacked complete object or vise versa. if (NVSize % NVAlignment) Packed = true; d644 1 a644 1 CGRecordLowering Builder(*this, D, /*Packed=*/false); d646 1 a646 1 Builder.lower(/*NonVirtualBaseType=*/false); d653 2 a654 2 CGRecordLowering BaseBuilder(*this, D, /*Packed=*/Builder.Packed); BaseBuilder.lower(/*NonVirtualBaseType=*/true); a657 4 // BaseTy and Ty must agree on their packedness for getLLVMFieldNo to work // on both of them with the same index. assert(Builder.Packed == BaseBuilder.Packed && "Non-virtual and complete types must agree on packedness"); @ 1.1.1.7 log @Import Clang 3.6RC1 r227398. @ text @d96 1 a96 1 CGRecordLowering(CodeGenTypes &Types, const RecordDecl *D, bool Packed); d177 1 a177 1 void determinePacked(bool NVBaseType); d206 1 a206 1 CGRecordLowering::CGRecordLowering(CodeGenTypes &Types, const RecordDecl *D, bool Packed) d211 1 a211 1 IsZeroInitializableAsBase(true), Packed(Packed) {} d272 1 a272 1 determinePacked(NVBaseType); d282 3 a284 1 bool SeenNamedMember = false; d288 1 a288 1 // type would work fine and be simpler but would be different than what we've a301 17 // Compute zero-initializable status. // This union might not be zero initialized: it may contain a pointer to // data member which might have some exotic initialization sequence. // If this is the case, then we aught not to try and come up with a "better" // type, it might not be very easy to come up with a Constant which // correctly initializes it. if (!SeenNamedMember && Field->getDeclName()) { SeenNamedMember = true; if (!isZeroInitializable(Field)) { IsZeroInitializable = IsZeroInitializableAsBase = false; StorageType = FieldType; } } // Because our union isn't zero initializable, we won't be getting a better // storage type. if (!IsZeroInitializable) continue; d536 1 a536 3 void CGRecordLowering::determinePacked(bool NVBaseType) { if (Packed) return; a537 3 CharUnits NVAlignment = CharUnits::One(); CharUnits NVSize = !NVBaseType && RD ? Layout.getNonVirtualSize() : CharUnits::Zero(); a546 2 if (Member->Offset < NVSize) NVAlignment = std::max(NVAlignment, getAlignment(Member->Data)); a552 5 // If the non-virtual sub-object is not a multiple of the non-virtual // sub-object's alignment, it must be packed. We cannot have a packed // non-virtual sub-object and an unpacked complete object or vise versa. if (NVSize % NVAlignment) Packed = true; d644 1 a644 1 CGRecordLowering Builder(*this, D, /*Packed=*/false); d646 1 a646 1 Builder.lower(/*NonVirtualBaseType=*/false); d653 2 a654 2 CGRecordLowering BaseBuilder(*this, D, /*Packed=*/Builder.Packed); BaseBuilder.lower(/*NonVirtualBaseType=*/true); a657 4 // BaseTy and Ty must agree on their packedness for getLLVMFieldNo to work // on both of them with the same index. assert(Builder.Packed == BaseBuilder.Packed && "Non-virtual and complete types must agree on packedness"); @ 1.1.1.8 log @Import Clang 3.8.0rc3 r261930. @ text @d102 1 a102 7 /// The Microsoft bitfield layout rule allocates discrete storage /// units of the field's formal type and only combines adjacent /// fields of the same formal type. We want to emit a layout with /// these discrete storage units instead of combining them into a /// continuous run. bool isDiscreteBitFieldABI() { a105 9 /// The Itanium base layout rule allows virtual bases to overlap /// other bases, which complicates layout in specific ways. /// /// Note specifically that the ms_struct attribute doesn't change this. bool isOverlappingVBaseABI() { return !Context.getTargetInfo().getCXXABI().isMicrosoft(); } d122 2 a123 3 if (!FD->isBitField()) return Type; if (isDiscreteBitFieldABI()) return Type; return getIntNType(std::min(FD->getBitWidthValue(Context), d140 6 a145 1 return Types.isZeroInitializable(FD->getType()); d148 1 a148 1 return Types.isZeroInitializable(RD); d201 2 a202 2 CGRecordLowering(const CGRecordLowering &) = delete; void operator =(const CGRecordLowering &) = delete; d220 5 a224 1 Info.StorageOffset = StartOffset; d306 3 a308 7 if (!SeenNamedMember) { SeenNamedMember = Field->getIdentifier(); if (!SeenNamedMember) if (const auto *FieldRD = dyn_cast_or_null(Field->getType()->getAsTagDecl())) SeenNamedMember = FieldRD->findFirstNamedDataMember(); if (SeenNamedMember && !isZeroInitializable(Field)) { d368 1 a368 1 if (isDiscreteBitFieldABI()) { a440 3 // Bases can be zero-sized even if not technically empty if they // contain only a trailing array member. d442 1 a442 2 if (!BaseDecl->isEmpty() && !Context.getASTRecordLayout(BaseDecl).getNonVirtualSize().isZero()) d464 1 a464 1 if (isOverlappingVBaseABI()) d485 1 a485 2 if (isOverlappingVBaseABI() && Context.isNearlyEmpty(BaseDecl) && d634 1 a634 1 CharUnits StorageOffset) { d666 1 a666 1 return CGBitFieldInfo(Offset, Size, IsSigned, StorageSize, StorageOffset); d839 1 a839 1 << " StorageOffset:" << StorageOffset.getQuantity() << ">"; @ 1.1.1.8.2.1 log @Sync with HEAD @ text @d124 1 a124 1 (unsigned)llvm::alignTo(NumBits, 8)); d558 1 a558 1 Prior->Data = getByteArrayType(bitsToCharUnits(llvm::alignTo( d612 2 a613 2 if (Offset != Size.alignTo(Packed ? CharUnits::One() : getAlignment(Member->Data))) d845 1 a845 1 LLVM_DUMP_METHOD void CGRecordLayout::dump() const { d858 1 a858 1 LLVM_DUMP_METHOD void CGBitFieldInfo::dump() const { @ 1.1.1.9 log @Import Clang pre-4.0.0 r291444. @ text @d124 1 a124 1 (unsigned)llvm::alignTo(NumBits, 8)); d558 1 a558 1 Prior->Data = getByteArrayType(bitsToCharUnits(llvm::alignTo( d612 2 a613 2 if (Offset != Size.alignTo(Packed ? CharUnits::One() : getAlignment(Member->Data))) d845 1 a845 1 LLVM_DUMP_METHOD void CGRecordLayout::dump() const { d858 1 a858 1 LLVM_DUMP_METHOD void CGBitFieldInfo::dump() const { @ 1.1.1.9.14.1 log @Sync with HEAD @ text @d65 1 a65 1 /// The location of the clip is stored internally as a sentinel of type d77 1 a77 1 // sentinel member type that ensures correct rounding. d98 1 a98 1 /// Constructs a MemberInfo instance from an offset and llvm::Type *. d121 1 a121 1 /// Wraps llvm::Type::getIntNTy with some implicit arguments. d126 1 a126 1 /// Gets an llvm type of size NumBytes and alignment 1. d133 1 a133 1 /// Gets the storage type for a field decl and handles storage d142 1 a142 1 /// Gets the llvm Basesubobject type from a CXXRecordDecl. d171 1 a171 1 /// Lowers an ASTRecordLayout to a llvm type. d180 1 a180 1 /// Recursively searches all of the bases to find out if a vbase is d184 1 a184 1 /// Lowers bitfield storage types to I8 arrays for bitfields with tail d187 1 a187 1 /// Determines if we need a packed llvm struct. d189 1 a189 1 /// Inserts padding everywhere it's needed. d191 1 a191 1 /// Fills out the structures that are ultimately consumed. d217 6 a222 7 CGRecordLowering::CGRecordLowering(CodeGenTypes &Types, const RecordDecl *D, bool Packed) : Types(Types), Context(Types.getContext()), D(D), RD(dyn_cast(D)), Layout(Types.getContext().getASTRecordLayout(D)), DataLayout(Types.getDataLayout()), IsZeroInitializable(true), IsZeroInitializableAsBase(true), Packed(Packed) {} d297 2 a298 1 if (Field->isZeroLengthBitField(Context)) d383 1 a383 1 if (Field->isZeroLengthBitField(Context)) { a405 22 // Check if OffsetInRecord is better as a single field run. When OffsetInRecord // has legal integer width, and its bitfield offset is naturally aligned, it // is better to make the bitfield a separate storage component so as it can be // accessed directly with lower cost. auto IsBetterAsSingleFieldRun = [&](uint64_t OffsetInRecord, uint64_t StartBitOffset) { if (!Types.getCodeGenOpts().FineGrainedBitfieldAccesses) return false; if (!DataLayout.isLegalInteger(OffsetInRecord)) return false; // Make sure StartBitOffset is natually aligned if it is treated as an // IType integer. if (StartBitOffset % Context.toBits(getAlignment(getIntNType(OffsetInRecord))) != 0) return false; return true; }; // The start field is better as a single field run. bool StartFieldAsSingleRun = false; d413 1 a413 1 if (!Field->isZeroLengthBitField(Context)) { a416 2 StartFieldAsSingleRun = IsBetterAsSingleFieldRun(Tail - StartBitOffset, StartBitOffset); d421 2 a422 15 // If the start field of a new run is better as a single run, or // if current field (or consecutive fields) is better as a single run, or // if current field has zero width bitfield and either // UseZeroLengthBitfieldAlignment or UseBitFieldTypeAlignment is set to // true, or // if the offset of current field is inconsistent with the offset of // previous field plus its offset, // skip the block below and go ahead to emit the storage. // Otherwise, try to add bitfields to the run. if (!StartFieldAsSingleRun && Field != FieldEnd && !IsBetterAsSingleFieldRun(Tail - StartBitOffset, StartBitOffset) && (!Field->isZeroLengthBitField(Context) || (!Context.getTargetInfo().useZeroLengthBitfieldAlignment() && !Context.getTargetInfo().useBitFieldTypeAlignment())) && a427 1 a437 1 StartFieldAsSingleRun = false; d596 1 a596 1 // Update the alignment of the sentinel. d755 2 a756 1 llvm::StructType *ST = RL->getLLVMType(); d778 1 a778 1 if (FD->isZeroLengthBitField(getContext())) @ 1.1.1.9.14.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.9.12.1 log @Sync with HEAD @ text @d65 1 a65 1 /// The location of the clip is stored internally as a sentinel of type d77 1 a77 1 // sentinel member type that ensures correct rounding. d98 1 a98 1 /// Constructs a MemberInfo instance from an offset and llvm::Type *. d121 1 a121 1 /// Wraps llvm::Type::getIntNTy with some implicit arguments. d126 1 a126 1 /// Gets an llvm type of size NumBytes and alignment 1. d133 1 a133 1 /// Gets the storage type for a field decl and handles storage d142 1 a142 1 /// Gets the llvm Basesubobject type from a CXXRecordDecl. d171 1 a171 1 /// Lowers an ASTRecordLayout to a llvm type. d180 1 a180 1 /// Recursively searches all of the bases to find out if a vbase is d184 1 a184 1 /// Lowers bitfield storage types to I8 arrays for bitfields with tail d187 1 a187 1 /// Determines if we need a packed llvm struct. d189 1 a189 1 /// Inserts padding everywhere it's needed. d191 1 a191 1 /// Fills out the structures that are ultimately consumed. d217 6 a222 7 CGRecordLowering::CGRecordLowering(CodeGenTypes &Types, const RecordDecl *D, bool Packed) : Types(Types), Context(Types.getContext()), D(D), RD(dyn_cast(D)), Layout(Types.getContext().getASTRecordLayout(D)), DataLayout(Types.getDataLayout()), IsZeroInitializable(true), IsZeroInitializableAsBase(true), Packed(Packed) {} d297 2 a298 1 if (Field->isZeroLengthBitField(Context)) d383 1 a383 1 if (Field->isZeroLengthBitField(Context)) { a405 22 // Check if OffsetInRecord is better as a single field run. When OffsetInRecord // has legal integer width, and its bitfield offset is naturally aligned, it // is better to make the bitfield a separate storage component so as it can be // accessed directly with lower cost. auto IsBetterAsSingleFieldRun = [&](uint64_t OffsetInRecord, uint64_t StartBitOffset) { if (!Types.getCodeGenOpts().FineGrainedBitfieldAccesses) return false; if (!DataLayout.isLegalInteger(OffsetInRecord)) return false; // Make sure StartBitOffset is natually aligned if it is treated as an // IType integer. if (StartBitOffset % Context.toBits(getAlignment(getIntNType(OffsetInRecord))) != 0) return false; return true; }; // The start field is better as a single field run. bool StartFieldAsSingleRun = false; d413 1 a413 1 if (!Field->isZeroLengthBitField(Context)) { a416 2 StartFieldAsSingleRun = IsBetterAsSingleFieldRun(Tail - StartBitOffset, StartBitOffset); d421 2 a422 15 // If the start field of a new run is better as a single run, or // if current field (or consecutive fields) is better as a single run, or // if current field has zero width bitfield and either // UseZeroLengthBitfieldAlignment or UseBitFieldTypeAlignment is set to // true, or // if the offset of current field is inconsistent with the offset of // previous field plus its offset, // skip the block below and go ahead to emit the storage. // Otherwise, try to add bitfields to the run. if (!StartFieldAsSingleRun && Field != FieldEnd && !IsBetterAsSingleFieldRun(Tail - StartBitOffset, StartBitOffset) && (!Field->isZeroLengthBitField(Context) || (!Context.getTargetInfo().useZeroLengthBitfieldAlignment() && !Context.getTargetInfo().useBitFieldTypeAlignment())) && a427 1 a437 1 StartFieldAsSingleRun = false; d596 1 a596 1 // Update the alignment of the sentinel. d755 2 a756 1 llvm::StructType *ST = RL->getLLVMType(); d778 1 a778 1 if (FD->isZeroLengthBitField(getContext())) @ 1.1.1.10 log @Import clang r337282 from trunk @ text @d65 1 a65 1 /// The location of the clip is stored internally as a sentinel of type d77 1 a77 1 // sentinel member type that ensures correct rounding. d98 1 a98 1 /// Constructs a MemberInfo instance from an offset and llvm::Type *. d121 1 a121 1 /// Wraps llvm::Type::getIntNTy with some implicit arguments. d126 1 a126 1 /// Gets an llvm type of size NumBytes and alignment 1. d133 1 a133 1 /// Gets the storage type for a field decl and handles storage d142 1 a142 1 /// Gets the llvm Basesubobject type from a CXXRecordDecl. d171 1 a171 1 /// Lowers an ASTRecordLayout to a llvm type. d180 1 a180 1 /// Recursively searches all of the bases to find out if a vbase is d184 1 a184 1 /// Lowers bitfield storage types to I8 arrays for bitfields with tail d187 1 a187 1 /// Determines if we need a packed llvm struct. d189 1 a189 1 /// Inserts padding everywhere it's needed. d191 1 a191 1 /// Fills out the structures that are ultimately consumed. d217 6 a222 7 CGRecordLowering::CGRecordLowering(CodeGenTypes &Types, const RecordDecl *D, bool Packed) : Types(Types), Context(Types.getContext()), D(D), RD(dyn_cast(D)), Layout(Types.getContext().getASTRecordLayout(D)), DataLayout(Types.getDataLayout()), IsZeroInitializable(true), IsZeroInitializableAsBase(true), Packed(Packed) {} d297 2 a298 1 if (Field->isZeroLengthBitField(Context)) d383 1 a383 1 if (Field->isZeroLengthBitField(Context)) { a405 22 // Check if OffsetInRecord is better as a single field run. When OffsetInRecord // has legal integer width, and its bitfield offset is naturally aligned, it // is better to make the bitfield a separate storage component so as it can be // accessed directly with lower cost. auto IsBetterAsSingleFieldRun = [&](uint64_t OffsetInRecord, uint64_t StartBitOffset) { if (!Types.getCodeGenOpts().FineGrainedBitfieldAccesses) return false; if (!DataLayout.isLegalInteger(OffsetInRecord)) return false; // Make sure StartBitOffset is natually aligned if it is treated as an // IType integer. if (StartBitOffset % Context.toBits(getAlignment(getIntNType(OffsetInRecord))) != 0) return false; return true; }; // The start field is better as a single field run. bool StartFieldAsSingleRun = false; d413 1 a413 1 if (!Field->isZeroLengthBitField(Context)) { a416 2 StartFieldAsSingleRun = IsBetterAsSingleFieldRun(Tail - StartBitOffset, StartBitOffset); d421 2 a422 15 // If the start field of a new run is better as a single run, or // if current field (or consecutive fields) is better as a single run, or // if current field has zero width bitfield and either // UseZeroLengthBitfieldAlignment or UseBitFieldTypeAlignment is set to // true, or // if the offset of current field is inconsistent with the offset of // previous field plus its offset, // skip the block below and go ahead to emit the storage. // Otherwise, try to add bitfields to the run. if (!StartFieldAsSingleRun && Field != FieldEnd && !IsBetterAsSingleFieldRun(Tail - StartBitOffset, StartBitOffset) && (!Field->isZeroLengthBitField(Context) || (!Context.getTargetInfo().useZeroLengthBitfieldAlignment() && !Context.getTargetInfo().useBitFieldTypeAlignment())) && a427 1 a437 1 StartFieldAsSingleRun = false; d596 1 a596 1 // Update the alignment of the sentinel. d755 2 a756 1 llvm::StructType *ST = RL->getLLVMType(); d778 1 a778 1 if (FD->isZeroLengthBitField(getContext())) @ 1.1.1.11 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.6.4.1 log @file CGRecordLayoutBuilder.cpp was added on branch tls-maxphys on 2014-08-19 23:47:27 +0000 @ text @d1 813 @ 1.1.1.6.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 813 //===--- CGRecordLayoutBuilder.cpp - CGRecordLayout builder ----*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // Builder implementation for CGRecordLayout objects. // //===----------------------------------------------------------------------===// #include "CGRecordLayout.h" #include "CGCXXABI.h" #include "CodeGenTypes.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Attr.h" #include "clang/AST/CXXInheritance.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/Expr.h" #include "clang/AST/RecordLayout.h" #include "clang/Frontend/CodeGenOptions.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/Type.h" #include "llvm/Support/Debug.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/raw_ostream.h" using namespace clang; using namespace CodeGen; namespace { /// The CGRecordLowering is responsible for lowering an ASTRecordLayout to an /// llvm::Type. Some of the lowering is straightforward, some is not. Here we /// detail some of the complexities and weirdnesses here. /// * LLVM does not have unions - Unions can, in theory be represented by any /// llvm::Type with correct size. We choose a field via a specific heuristic /// and add padding if necessary. /// * LLVM does not have bitfields - Bitfields are collected into contiguous /// runs and allocated as a single storage type for the run. ASTRecordLayout /// contains enough information to determine where the runs break. Microsoft /// and Itanium follow different rules and use different codepaths. /// * It is desired that, when possible, bitfields use the appropriate iN type /// when lowered to llvm types. For example unsigned x : 24 gets lowered to /// i24. This isn't always possible because i24 has storage size of 32 bit /// and if it is possible to use that extra byte of padding we must use /// [i8 x 3] instead of i24. The function clipTailPadding does this. /// C++ examples that require clipping: /// struct { int a : 24; char b; }; // a must be clipped, b goes at offset 3 /// struct A { int a : 24; }; // a must be clipped because a struct like B // could exist: struct B : A { char b; }; // b goes at offset 3 /// * Clang ignores 0 sized bitfields and 0 sized bases but *not* zero sized /// fields. The existing asserts suggest that LLVM assumes that *every* field /// has an underlying storage type. Therefore empty structures containing /// zero sized subobjects such as empty records or zero sized arrays still get /// a zero sized (empty struct) storage type. /// * Clang reads the complete type rather than the base type when generating /// code to access fields. Bitfields in tail position with tail padding may /// be clipped in the base class but not the complete class (we may discover /// that the tail padding is not used in the complete class.) However, /// because LLVM reads from the complete type it can generate incorrect code /// if we do not clip the tail padding off of the bitfield in the complete /// layout. This introduces a somewhat awkward extra unnecessary clip stage. /// The location of the clip is stored internally as a sentinal of type /// SCISSOR. If LLVM were updated to read base types (which it probably /// should because locations of things such as VBases are bogus in the llvm /// type anyway) then we could eliminate the SCISSOR. /// * Itanium allows nearly empty primary virtual bases. These bases don't get /// get their own storage because they're laid out as part of another base /// or at the beginning of the structure. Determining if a VBase actually /// gets storage awkwardly involves a walk of all bases. /// * VFPtrs and VBPtrs do *not* make a record NotZeroInitializable. struct CGRecordLowering { // MemberInfo is a helper structure that contains information about a record // member. In additional to the standard member types, there exists a // sentinal member type that ensures correct rounding. struct MemberInfo { CharUnits Offset; enum InfoKind { VFPtr, VBPtr, Field, Base, VBase, Scissor } Kind; llvm::Type *Data; union { const FieldDecl *FD; const CXXRecordDecl *RD; }; MemberInfo(CharUnits Offset, InfoKind Kind, llvm::Type *Data, const FieldDecl *FD = nullptr) : Offset(Offset), Kind(Kind), Data(Data), FD(FD) {} MemberInfo(CharUnits Offset, InfoKind Kind, llvm::Type *Data, const CXXRecordDecl *RD) : Offset(Offset), Kind(Kind), Data(Data), RD(RD) {} // MemberInfos are sorted so we define a < operator. bool operator <(const MemberInfo& a) const { return Offset < a.Offset; } }; // The constructor. CGRecordLowering(CodeGenTypes &Types, const RecordDecl *D); // Short helper routines. /// \brief Constructs a MemberInfo instance from an offset and llvm::Type *. MemberInfo StorageInfo(CharUnits Offset, llvm::Type *Data) { return MemberInfo(Offset, MemberInfo::Field, Data); } bool useMSABI() { return Context.getTargetInfo().getCXXABI().isMicrosoft() || D->isMsStruct(Context); } /// \brief Wraps llvm::Type::getIntNTy with some implicit arguments. llvm::Type *getIntNType(uint64_t NumBits) { return llvm::Type::getIntNTy(Types.getLLVMContext(), (unsigned)llvm::RoundUpToAlignment(NumBits, 8)); } /// \brief Gets an llvm type of size NumBytes and alignment 1. llvm::Type *getByteArrayType(CharUnits NumBytes) { assert(!NumBytes.isZero() && "Empty byte arrays aren't allowed."); llvm::Type *Type = llvm::Type::getInt8Ty(Types.getLLVMContext()); return NumBytes == CharUnits::One() ? Type : (llvm::Type *)llvm::ArrayType::get(Type, NumBytes.getQuantity()); } /// \brief Gets the storage type for a field decl and handles storage /// for itanium bitfields that are smaller than their declared type. llvm::Type *getStorageType(const FieldDecl *FD) { llvm::Type *Type = Types.ConvertTypeForMem(FD->getType()); return useMSABI() || !FD->isBitField() ? Type : getIntNType(std::min(FD->getBitWidthValue(Context), (unsigned)Context.toBits(getSize(Type)))); } /// \brief Gets the llvm Basesubobject type from a CXXRecordDecl. llvm::Type *getStorageType(const CXXRecordDecl *RD) { return Types.getCGRecordLayout(RD).getBaseSubobjectLLVMType(); } CharUnits bitsToCharUnits(uint64_t BitOffset) { return Context.toCharUnitsFromBits(BitOffset); } CharUnits getSize(llvm::Type *Type) { return CharUnits::fromQuantity(DataLayout.getTypeAllocSize(Type)); } CharUnits getAlignment(llvm::Type *Type) { return CharUnits::fromQuantity(DataLayout.getABITypeAlignment(Type)); } bool isZeroInitializable(const FieldDecl *FD) { const Type *Type = FD->getType()->getBaseElementTypeUnsafe(); if (const MemberPointerType *MPT = Type->getAs()) return Types.getCXXABI().isZeroInitializable(MPT); if (const RecordType *RT = Type->getAs()) return isZeroInitializable(RT->getDecl()); return true; } bool isZeroInitializable(const RecordDecl *RD) { return Types.getCGRecordLayout(RD).isZeroInitializable(); } void appendPaddingBytes(CharUnits Size) { if (!Size.isZero()) FieldTypes.push_back(getByteArrayType(Size)); } uint64_t getFieldBitOffset(const FieldDecl *FD) { return Layout.getFieldOffset(FD->getFieldIndex()); } // Layout routines. void setBitFieldInfo(const FieldDecl *FD, CharUnits StartOffset, llvm::Type *StorageType); /// \brief Lowers an ASTRecordLayout to a llvm type. void lower(bool NonVirtualBaseType); void lowerUnion(); void accumulateFields(); void accumulateBitFields(RecordDecl::field_iterator Field, RecordDecl::field_iterator FieldEnd); void accumulateBases(); void accumulateVPtrs(); void accumulateVBases(); /// \brief Recursively searches all of the bases to find out if a vbase is /// not the primary vbase of some base class. bool hasOwnStorage(const CXXRecordDecl *Decl, const CXXRecordDecl *Query); void calculateZeroInit(); /// \brief Lowers bitfield storage types to I8 arrays for bitfields with tail /// padding that is or can potentially be used. void clipTailPadding(); /// \brief Determines if we need a packed llvm struct. void determinePacked(); /// \brief Inserts padding everwhere it's needed. void insertPadding(); /// \brief Fills out the structures that are ultimately consumed. void fillOutputFields(); // Input memoization fields. CodeGenTypes &Types; const ASTContext &Context; const RecordDecl *D; const CXXRecordDecl *RD; const ASTRecordLayout &Layout; const llvm::DataLayout &DataLayout; // Helpful intermediate data-structures. std::vector Members; // Output fields, consumed by CodeGenTypes::ComputeRecordLayout. SmallVector FieldTypes; llvm::DenseMap Fields; llvm::DenseMap BitFields; llvm::DenseMap NonVirtualBases; llvm::DenseMap VirtualBases; bool IsZeroInitializable : 1; bool IsZeroInitializableAsBase : 1; bool Packed : 1; private: CGRecordLowering(const CGRecordLowering &) LLVM_DELETED_FUNCTION; void operator =(const CGRecordLowering &) LLVM_DELETED_FUNCTION; }; } // namespace { CGRecordLowering::CGRecordLowering(CodeGenTypes &Types, const RecordDecl *D) : Types(Types), Context(Types.getContext()), D(D), RD(dyn_cast(D)), Layout(Types.getContext().getASTRecordLayout(D)), DataLayout(Types.getDataLayout()), IsZeroInitializable(true), IsZeroInitializableAsBase(true), Packed(false) {} void CGRecordLowering::setBitFieldInfo( const FieldDecl *FD, CharUnits StartOffset, llvm::Type *StorageType) { CGBitFieldInfo &Info = BitFields[FD->getCanonicalDecl()]; Info.IsSigned = FD->getType()->isSignedIntegerOrEnumerationType(); Info.Offset = (unsigned)(getFieldBitOffset(FD) - Context.toBits(StartOffset)); Info.Size = FD->getBitWidthValue(Context); Info.StorageSize = (unsigned)DataLayout.getTypeAllocSizeInBits(StorageType); // Here we calculate the actual storage alignment of the bits. E.g if we've // got an alignment >= 2 and the bitfield starts at offset 6 we've got an // alignment of 2. Info.StorageAlignment = Layout.getAlignment().alignmentAtOffset(StartOffset).getQuantity(); if (Info.Size > Info.StorageSize) Info.Size = Info.StorageSize; // Reverse the bit offsets for big endian machines. Because we represent // a bitfield as a single large integer load, we can imagine the bits // counting from the most-significant-bit instead of the // least-significant-bit. if (DataLayout.isBigEndian()) Info.Offset = Info.StorageSize - (Info.Offset + Info.Size); } void CGRecordLowering::lower(bool NVBaseType) { // The lowering process implemented in this function takes a variety of // carefully ordered phases. // 1) Store all members (fields and bases) in a list and sort them by offset. // 2) Add a 1-byte capstone member at the Size of the structure. // 3) Clip bitfield storages members if their tail padding is or might be // used by another field or base. The clipping process uses the capstone // by treating it as another object that occurs after the record. // 4) Determine if the llvm-struct requires packing. It's important that this // phase occur after clipping, because clipping changes the llvm type. // This phase reads the offset of the capstone when determining packedness // and updates the alignment of the capstone to be equal of the alignment // of the record after doing so. // 5) Insert padding everywhere it is needed. This phase requires 'Packed' to // have been computed and needs to know the alignment of the record in // order to understand if explicit tail padding is needed. // 6) Remove the capstone, we don't need it anymore. // 7) Determine if this record can be zero-initialized. This phase could have // been placed anywhere after phase 1. // 8) Format the complete list of members in a way that can be consumed by // CodeGenTypes::ComputeRecordLayout. CharUnits Size = NVBaseType ? Layout.getNonVirtualSize() : Layout.getSize(); if (D->isUnion()) return lowerUnion(); accumulateFields(); // RD implies C++. if (RD) { accumulateVPtrs(); accumulateBases(); if (Members.empty()) return appendPaddingBytes(Size); if (!NVBaseType) accumulateVBases(); } std::stable_sort(Members.begin(), Members.end()); Members.push_back(StorageInfo(Size, getIntNType(8))); clipTailPadding(); determinePacked(); insertPadding(); Members.pop_back(); calculateZeroInit(); fillOutputFields(); } void CGRecordLowering::lowerUnion() { CharUnits LayoutSize = Layout.getSize(); llvm::Type *StorageType = nullptr; // Compute zero-initializable status. if (!D->field_empty() && !isZeroInitializable(*D->field_begin())) IsZeroInitializable = IsZeroInitializableAsBase = false; // Iterate through the fields setting bitFieldInfo and the Fields array. Also // locate the "most appropriate" storage type. The heuristic for finding the // storage type isn't necessary, the first (non-0-length-bitfield) field's // type would work fine and be simpler but would be differen than what we've // been doing and cause lit tests to change. for (const auto *Field : D->fields()) { if (Field->isBitField()) { // Skip 0 sized bitfields. if (Field->getBitWidthValue(Context) == 0) continue; llvm::Type *FieldType = getStorageType(Field); if (LayoutSize < getSize(FieldType)) FieldType = getByteArrayType(LayoutSize); setBitFieldInfo(Field, CharUnits::Zero(), FieldType); } Fields[Field->getCanonicalDecl()] = 0; llvm::Type *FieldType = getStorageType(Field); // Conditionally update our storage type if we've got a new "better" one. if (!StorageType || getAlignment(FieldType) > getAlignment(StorageType) || (getAlignment(FieldType) == getAlignment(StorageType) && getSize(FieldType) > getSize(StorageType))) StorageType = FieldType; } // If we have no storage type just pad to the appropriate size and return. if (!StorageType) return appendPaddingBytes(LayoutSize); // If our storage size was bigger than our required size (can happen in the // case of packed bitfields on Itanium) then just use an I8 array. if (LayoutSize < getSize(StorageType)) StorageType = getByteArrayType(LayoutSize); FieldTypes.push_back(StorageType); appendPaddingBytes(LayoutSize - getSize(StorageType)); // Set packed if we need it. if (LayoutSize % getAlignment(StorageType)) Packed = true; } void CGRecordLowering::accumulateFields() { for (RecordDecl::field_iterator Field = D->field_begin(), FieldEnd = D->field_end(); Field != FieldEnd;) if (Field->isBitField()) { RecordDecl::field_iterator Start = Field; // Iterate to gather the list of bitfields. for (++Field; Field != FieldEnd && Field->isBitField(); ++Field); accumulateBitFields(Start, Field); } else { Members.push_back(MemberInfo( bitsToCharUnits(getFieldBitOffset(*Field)), MemberInfo::Field, getStorageType(*Field), *Field)); ++Field; } } void CGRecordLowering::accumulateBitFields(RecordDecl::field_iterator Field, RecordDecl::field_iterator FieldEnd) { // Run stores the first element of the current run of bitfields. FieldEnd is // used as a special value to note that we don't have a current run. A // bitfield run is a contiguous collection of bitfields that can be stored in // the same storage block. Zero-sized bitfields and bitfields that would // cross an alignment boundary break a run and start a new one. RecordDecl::field_iterator Run = FieldEnd; // Tail is the offset of the first bit off the end of the current run. It's // used to determine if the ASTRecordLayout is treating these two bitfields as // contiguous. StartBitOffset is offset of the beginning of the Run. uint64_t StartBitOffset, Tail = 0; if (useMSABI()) { for (; Field != FieldEnd; ++Field) { uint64_t BitOffset = getFieldBitOffset(*Field); // Zero-width bitfields end runs. if (Field->getBitWidthValue(Context) == 0) { Run = FieldEnd; continue; } llvm::Type *Type = Types.ConvertTypeForMem(Field->getType()); // If we don't have a run yet, or don't live within the previous run's // allocated storage then we allocate some storage and start a new run. if (Run == FieldEnd || BitOffset >= Tail) { Run = Field; StartBitOffset = BitOffset; Tail = StartBitOffset + DataLayout.getTypeAllocSizeInBits(Type); // Add the storage member to the record. This must be added to the // record before the bitfield members so that it gets laid out before // the bitfields it contains get laid out. Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset), Type)); } // Bitfields get the offset of their storage but come afterward and remain // there after a stable sort. Members.push_back(MemberInfo(bitsToCharUnits(StartBitOffset), MemberInfo::Field, nullptr, *Field)); } return; } for (;;) { // Check to see if we need to start a new run. if (Run == FieldEnd) { // If we're out of fields, return. if (Field == FieldEnd) break; // Any non-zero-length bitfield can start a new run. if (Field->getBitWidthValue(Context) != 0) { Run = Field; StartBitOffset = getFieldBitOffset(*Field); Tail = StartBitOffset + Field->getBitWidthValue(Context); } ++Field; continue; } // Add bitfields to the run as long as they qualify. if (Field != FieldEnd && Field->getBitWidthValue(Context) != 0 && Tail == getFieldBitOffset(*Field)) { Tail += Field->getBitWidthValue(Context); ++Field; continue; } // We've hit a break-point in the run and need to emit a storage field. llvm::Type *Type = getIntNType(Tail - StartBitOffset); // Add the storage member to the record and set the bitfield info for all of // the bitfields in the run. Bitfields get the offset of their storage but // come afterward and remain there after a stable sort. Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset), Type)); for (; Run != Field; ++Run) Members.push_back(MemberInfo(bitsToCharUnits(StartBitOffset), MemberInfo::Field, nullptr, *Run)); Run = FieldEnd; } } void CGRecordLowering::accumulateBases() { // If we've got a primary virtual base, we need to add it with the bases. if (Layout.isPrimaryBaseVirtual()) { const CXXRecordDecl *BaseDecl = Layout.getPrimaryBase(); Members.push_back(MemberInfo(CharUnits::Zero(), MemberInfo::Base, getStorageType(BaseDecl), BaseDecl)); } // Accumulate the non-virtual bases. for (const auto &Base : RD->bases()) { if (Base.isVirtual()) continue; const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); if (!BaseDecl->isEmpty()) Members.push_back(MemberInfo(Layout.getBaseClassOffset(BaseDecl), MemberInfo::Base, getStorageType(BaseDecl), BaseDecl)); } } void CGRecordLowering::accumulateVPtrs() { if (Layout.hasOwnVFPtr()) Members.push_back(MemberInfo(CharUnits::Zero(), MemberInfo::VFPtr, llvm::FunctionType::get(getIntNType(32), /*isVarArg=*/true)-> getPointerTo()->getPointerTo())); if (Layout.hasOwnVBPtr()) Members.push_back(MemberInfo(Layout.getVBPtrOffset(), MemberInfo::VBPtr, llvm::Type::getInt32PtrTy(Types.getLLVMContext()))); } void CGRecordLowering::accumulateVBases() { CharUnits ScissorOffset = Layout.getNonVirtualSize(); // In the itanium ABI, it's possible to place a vbase at a dsize that is // smaller than the nvsize. Here we check to see if such a base is placed // before the nvsize and set the scissor offset to that, instead of the // nvsize. if (!useMSABI()) for (const auto &Base : RD->vbases()) { const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); if (BaseDecl->isEmpty()) continue; // If the vbase is a primary virtual base of some base, then it doesn't // get its own storage location but instead lives inside of that base. if (Context.isNearlyEmpty(BaseDecl) && !hasOwnStorage(RD, BaseDecl)) continue; ScissorOffset = std::min(ScissorOffset, Layout.getVBaseClassOffset(BaseDecl)); } Members.push_back(MemberInfo(ScissorOffset, MemberInfo::Scissor, nullptr, RD)); for (const auto &Base : RD->vbases()) { const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); if (BaseDecl->isEmpty()) continue; CharUnits Offset = Layout.getVBaseClassOffset(BaseDecl); // If the vbase is a primary virtual base of some base, then it doesn't // get its own storage location but instead lives inside of that base. if (!useMSABI() && Context.isNearlyEmpty(BaseDecl) && !hasOwnStorage(RD, BaseDecl)) { Members.push_back(MemberInfo(Offset, MemberInfo::VBase, nullptr, BaseDecl)); continue; } // If we've got a vtordisp, add it as a storage type. if (Layout.getVBaseOffsetsMap().find(BaseDecl)->second.hasVtorDisp()) Members.push_back(StorageInfo(Offset - CharUnits::fromQuantity(4), getIntNType(32))); Members.push_back(MemberInfo(Offset, MemberInfo::VBase, getStorageType(BaseDecl), BaseDecl)); } } bool CGRecordLowering::hasOwnStorage(const CXXRecordDecl *Decl, const CXXRecordDecl *Query) { const ASTRecordLayout &DeclLayout = Context.getASTRecordLayout(Decl); if (DeclLayout.isPrimaryBaseVirtual() && DeclLayout.getPrimaryBase() == Query) return false; for (const auto &Base : Decl->bases()) if (!hasOwnStorage(Base.getType()->getAsCXXRecordDecl(), Query)) return false; return true; } void CGRecordLowering::calculateZeroInit() { for (std::vector::const_iterator Member = Members.begin(), MemberEnd = Members.end(); IsZeroInitializableAsBase && Member != MemberEnd; ++Member) { if (Member->Kind == MemberInfo::Field) { if (!Member->FD || isZeroInitializable(Member->FD)) continue; IsZeroInitializable = IsZeroInitializableAsBase = false; } else if (Member->Kind == MemberInfo::Base || Member->Kind == MemberInfo::VBase) { if (isZeroInitializable(Member->RD)) continue; IsZeroInitializable = false; if (Member->Kind == MemberInfo::Base) IsZeroInitializableAsBase = false; } } } void CGRecordLowering::clipTailPadding() { std::vector::iterator Prior = Members.begin(); CharUnits Tail = getSize(Prior->Data); for (std::vector::iterator Member = Prior + 1, MemberEnd = Members.end(); Member != MemberEnd; ++Member) { // Only members with data and the scissor can cut into tail padding. if (!Member->Data && Member->Kind != MemberInfo::Scissor) continue; if (Member->Offset < Tail) { assert(Prior->Kind == MemberInfo::Field && !Prior->FD && "Only storage fields have tail padding!"); Prior->Data = getByteArrayType(bitsToCharUnits(llvm::RoundUpToAlignment( cast(Prior->Data)->getIntegerBitWidth(), 8))); } if (Member->Data) Prior = Member; Tail = Prior->Offset + getSize(Prior->Data); } } void CGRecordLowering::determinePacked() { CharUnits Alignment = CharUnits::One(); for (std::vector::const_iterator Member = Members.begin(), MemberEnd = Members.end(); Member != MemberEnd; ++Member) { if (!Member->Data) continue; // If any member falls at an offset that it not a multiple of its alignment, // then the entire record must be packed. if (Member->Offset % getAlignment(Member->Data)) Packed = true; Alignment = std::max(Alignment, getAlignment(Member->Data)); } // If the size of the record (the capstone's offset) is not a multiple of the // record's alignment, it must be packed. if (Members.back().Offset % Alignment) Packed = true; // Update the alignment of the sentinal. if (!Packed) Members.back().Data = getIntNType(Context.toBits(Alignment)); } void CGRecordLowering::insertPadding() { std::vector > Padding; CharUnits Size = CharUnits::Zero(); for (std::vector::const_iterator Member = Members.begin(), MemberEnd = Members.end(); Member != MemberEnd; ++Member) { if (!Member->Data) continue; CharUnits Offset = Member->Offset; assert(Offset >= Size); // Insert padding if we need to. if (Offset != Size.RoundUpToAlignment(Packed ? CharUnits::One() : getAlignment(Member->Data))) Padding.push_back(std::make_pair(Size, Offset - Size)); Size = Offset + getSize(Member->Data); } if (Padding.empty()) return; // Add the padding to the Members list and sort it. for (std::vector >::const_iterator Pad = Padding.begin(), PadEnd = Padding.end(); Pad != PadEnd; ++Pad) Members.push_back(StorageInfo(Pad->first, getByteArrayType(Pad->second))); std::stable_sort(Members.begin(), Members.end()); } void CGRecordLowering::fillOutputFields() { for (std::vector::const_iterator Member = Members.begin(), MemberEnd = Members.end(); Member != MemberEnd; ++Member) { if (Member->Data) FieldTypes.push_back(Member->Data); if (Member->Kind == MemberInfo::Field) { if (Member->FD) Fields[Member->FD->getCanonicalDecl()] = FieldTypes.size() - 1; // A field without storage must be a bitfield. if (!Member->Data) setBitFieldInfo(Member->FD, Member->Offset, FieldTypes.back()); } else if (Member->Kind == MemberInfo::Base) NonVirtualBases[Member->RD] = FieldTypes.size() - 1; else if (Member->Kind == MemberInfo::VBase) VirtualBases[Member->RD] = FieldTypes.size() - 1; } } CGBitFieldInfo CGBitFieldInfo::MakeInfo(CodeGenTypes &Types, const FieldDecl *FD, uint64_t Offset, uint64_t Size, uint64_t StorageSize, uint64_t StorageAlignment) { // This function is vestigial from CGRecordLayoutBuilder days but is still // used in GCObjCRuntime.cpp. That usage has a "fixme" attached to it that // when addressed will allow for the removal of this function. llvm::Type *Ty = Types.ConvertTypeForMem(FD->getType()); CharUnits TypeSizeInBytes = CharUnits::fromQuantity(Types.getDataLayout().getTypeAllocSize(Ty)); uint64_t TypeSizeInBits = Types.getContext().toBits(TypeSizeInBytes); bool IsSigned = FD->getType()->isSignedIntegerOrEnumerationType(); if (Size > TypeSizeInBits) { // We have a wide bit-field. The extra bits are only used for padding, so // if we have a bitfield of type T, with size N: // // T t : N; // // We can just assume that it's: // // T t : sizeof(T); // Size = TypeSizeInBits; } // Reverse the bit offsets for big endian machines. Because we represent // a bitfield as a single large integer load, we can imagine the bits // counting from the most-significant-bit instead of the // least-significant-bit. if (Types.getDataLayout().isBigEndian()) { Offset = StorageSize - (Offset + Size); } return CGBitFieldInfo(Offset, Size, IsSigned, StorageSize, StorageAlignment); } CGRecordLayout *CodeGenTypes::ComputeRecordLayout(const RecordDecl *D, llvm::StructType *Ty) { CGRecordLowering Builder(*this, D); Builder.lower(false); // If we're in C++, compute the base subobject type. llvm::StructType *BaseTy = nullptr; if (isa(D) && !D->isUnion() && !D->hasAttr()) { BaseTy = Ty; if (Builder.Layout.getNonVirtualSize() != Builder.Layout.getSize()) { CGRecordLowering BaseBuilder(*this, D); BaseBuilder.lower(true); BaseTy = llvm::StructType::create( getLLVMContext(), BaseBuilder.FieldTypes, "", BaseBuilder.Packed); addRecordTypeName(D, BaseTy, ".base"); } } // Fill in the struct *after* computing the base type. Filling in the body // signifies that the type is no longer opaque and record layout is complete, // but we may need to recursively layout D while laying D out as a base type. Ty->setBody(Builder.FieldTypes, Builder.Packed); CGRecordLayout *RL = new CGRecordLayout(Ty, BaseTy, Builder.IsZeroInitializable, Builder.IsZeroInitializableAsBase); RL->NonVirtualBases.swap(Builder.NonVirtualBases); RL->CompleteObjectVirtualBases.swap(Builder.VirtualBases); // Add all the field numbers. RL->FieldInfo.swap(Builder.Fields); // Add bitfield info. RL->BitFields.swap(Builder.BitFields); // Dump the layout, if requested. if (getContext().getLangOpts().DumpRecordLayouts) { llvm::outs() << "\n*** Dumping IRgen Record Layout\n"; llvm::outs() << "Record: "; D->dump(llvm::outs()); llvm::outs() << "\nLayout: "; RL->print(llvm::outs()); } #ifndef NDEBUG // Verify that the computed LLVM struct size matches the AST layout size. const ASTRecordLayout &Layout = getContext().getASTRecordLayout(D); uint64_t TypeSizeInBits = getContext().toBits(Layout.getSize()); assert(TypeSizeInBits == getDataLayout().getTypeAllocSizeInBits(Ty) && "Type size mismatch!"); if (BaseTy) { CharUnits NonVirtualSize = Layout.getNonVirtualSize(); uint64_t AlignedNonVirtualTypeSizeInBits = getContext().toBits(NonVirtualSize); assert(AlignedNonVirtualTypeSizeInBits == getDataLayout().getTypeAllocSizeInBits(BaseTy) && "Type size mismatch!"); } // Verify that the LLVM and AST field offsets agree. llvm::StructType *ST = dyn_cast(RL->getLLVMType()); const llvm::StructLayout *SL = getDataLayout().getStructLayout(ST); const ASTRecordLayout &AST_RL = getContext().getASTRecordLayout(D); RecordDecl::field_iterator it = D->field_begin(); for (unsigned i = 0, e = AST_RL.getFieldCount(); i != e; ++i, ++it) { const FieldDecl *FD = *it; // For non-bit-fields, just check that the LLVM struct offset matches the // AST offset. if (!FD->isBitField()) { unsigned FieldNo = RL->getLLVMFieldNo(FD); assert(AST_RL.getFieldOffset(i) == SL->getElementOffsetInBits(FieldNo) && "Invalid field offset!"); continue; } // Ignore unnamed bit-fields. if (!FD->getDeclName()) continue; // Don't inspect zero-length bitfields. if (FD->getBitWidthValue(getContext()) == 0) continue; const CGBitFieldInfo &Info = RL->getBitFieldInfo(FD); llvm::Type *ElementTy = ST->getTypeAtIndex(RL->getLLVMFieldNo(FD)); // Unions have overlapping elements dictating their layout, but for // non-unions we can verify that this section of the layout is the exact // expected size. if (D->isUnion()) { // For unions we verify that the start is zero and the size // is in-bounds. However, on BE systems, the offset may be non-zero, but // the size + offset should match the storage size in that case as it // "starts" at the back. if (getDataLayout().isBigEndian()) assert(static_cast(Info.Offset + Info.Size) == Info.StorageSize && "Big endian union bitfield does not end at the back"); else assert(Info.Offset == 0 && "Little endian union bitfield with a non-zero offset"); assert(Info.StorageSize <= SL->getSizeInBits() && "Union not large enough for bitfield storage"); } else { assert(Info.StorageSize == getDataLayout().getTypeAllocSizeInBits(ElementTy) && "Storage size does not match the element type size"); } assert(Info.Size > 0 && "Empty bitfield!"); assert(static_cast(Info.Offset) + Info.Size <= Info.StorageSize && "Bitfield outside of its allocated storage"); } #endif return RL; } void CGRecordLayout::print(raw_ostream &OS) const { OS << " > BFIs; for (llvm::DenseMap::const_iterator it = BitFields.begin(), ie = BitFields.end(); it != ie; ++it) { const RecordDecl *RD = it->first->getParent(); unsigned Index = 0; for (RecordDecl::field_iterator it2 = RD->field_begin(); *it2 != it->first; ++it2) ++Index; BFIs.push_back(std::make_pair(Index, &it->second)); } llvm::array_pod_sort(BFIs.begin(), BFIs.end()); for (unsigned i = 0, e = BFIs.size(); i != e; ++i) { OS.indent(4); BFIs[i].second->print(OS); OS << "\n"; } OS << "]>\n"; } void CGRecordLayout::dump() const { print(llvm::errs()); } void CGBitFieldInfo::print(raw_ostream &OS) const { OS << ""; } void CGBitFieldInfo::dump() const { print(llvm::errs()); } @ 1.1.1.5.4.1 log @file CGRecordLayoutBuilder.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:27 +0000 @ text @d1 802 @ 1.1.1.5.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 802 //===--- CGRecordLayoutBuilder.cpp - CGRecordLayout builder ----*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // Builder implementation for CGRecordLayout objects. // //===----------------------------------------------------------------------===// #include "CGRecordLayout.h" #include "CGCXXABI.h" #include "CodeGenTypes.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Attr.h" #include "clang/AST/CXXInheritance.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/Expr.h" #include "clang/AST/RecordLayout.h" #include "clang/Frontend/CodeGenOptions.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/Type.h" #include "llvm/Support/Debug.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/raw_ostream.h" using namespace clang; using namespace CodeGen; namespace { /// The CGRecordLowering is responsible for lowering an ASTRecordLayout to an /// llvm::Type. Some of the lowering is straightforward, some is not. Here we /// detail some of the complexities and weirdnesses here. /// * LLVM does not have unions - Unions can, in theory be represented by any /// llvm::Type with correct size. We choose a field via a specific heuristic /// and add padding if necessary. /// * LLVM does not have bitfields - Bitfields are collected into contiguous /// runs and allocated as a single storage type for the run. ASTRecordLayout /// contains enough information to determine where the runs break. Microsoft /// and Itanium follow different rules and use different codepaths. /// * It is desired that, when possible, bitfields use the appropriate iN type /// when lowered to llvm types. For example unsigned x : 24 gets lowered to /// i24. This isn't always possible because i24 has storage size of 32 bit /// and if it is possible to use that extra byte of padding we must use /// [i8 x 3] instead of i24. The function clipTailPadding does this. /// C++ examples that require clipping: /// struct { int a : 24; char b; }; // a must be clipped, b goes at offset 3 /// struct A { int a : 24; }; // a must be clipped because a struct like B // could exist: struct B : A { char b; }; // b goes at offset 3 /// * Clang ignores 0 sized bitfields and 0 sized bases but *not* zero sized /// fields. The existing asserts suggest that LLVM assumes that *every* field /// has an underlying storage type. Therefore empty structures containing /// zero sized subobjects such as empty records or zero sized arrays still get /// a zero sized (empty struct) storage type. /// * Clang reads the complete type rather than the base type when generating /// code to access fields. Bitfields in tail position with tail padding may /// be clipped in the base class but not the complete class (we may discover /// that the tail padding is not used in the complete class.) However, /// because LLVM reads from the complete type it can generate incorrect code /// if we do not clip the tail padding off of the bitfield in the complete /// layout. This introduces a somewhat awkward extra unnecessary clip stage. /// The location of the clip is stored internally as a sentinal of type /// SCISSOR. If LLVM were updated to read base types (which it probably /// should because locations of things such as VBases are bogus in the llvm /// type anyway) then we could eliminate the SCISSOR. /// * Itanium allows nearly empty primary virtual bases. These bases don't get /// get their own storage because they're laid out as part of another base /// or at the beginning of the structure. Determining if a VBase actually /// gets storage awkwardly involves a walk of all bases. /// * VFPtrs and VBPtrs do *not* make a record NotZeroInitializable. struct CGRecordLowering { // MemberInfo is a helper structure that contains information about a record // member. In additional to the standard member types, there exists a // sentinal member type that ensures correct rounding. struct MemberInfo { CharUnits Offset; enum InfoKind { VFPtr, VBPtr, Field, Base, VBase, Scissor } Kind; llvm::Type *Data; union { const FieldDecl *FD; const CXXRecordDecl *RD; }; MemberInfo(CharUnits Offset, InfoKind Kind, llvm::Type *Data, const FieldDecl *FD = 0) : Offset(Offset), Kind(Kind), Data(Data), FD(FD) {} MemberInfo(CharUnits Offset, InfoKind Kind, llvm::Type *Data, const CXXRecordDecl *RD) : Offset(Offset), Kind(Kind), Data(Data), RD(RD) {} // MemberInfos are sorted so we define a < operator. bool operator <(const MemberInfo& a) const { return Offset < a.Offset; } }; // The constructor. CGRecordLowering(CodeGenTypes &Types, const RecordDecl *D); // Short helper routines. /// \brief Constructs a MemberInfo instance from an offset and llvm::Type *. MemberInfo StorageInfo(CharUnits Offset, llvm::Type *Data) { return MemberInfo(Offset, MemberInfo::Field, Data); } bool useMSABI() { return Context.getTargetInfo().getCXXABI().isMicrosoft() || D->isMsStruct(Context); } /// \brief Wraps llvm::Type::getIntNTy with some implicit arguments. llvm::Type *getIntNType(uint64_t NumBits) { return llvm::Type::getIntNTy(Types.getLLVMContext(), (unsigned)llvm::RoundUpToAlignment(NumBits, 8)); } /// \brief Gets an llvm type of size NumBytes and alignment 1. llvm::Type *getByteArrayType(CharUnits NumBytes) { assert(!NumBytes.isZero() && "Empty byte arrays aren't allowed."); llvm::Type *Type = llvm::Type::getInt8Ty(Types.getLLVMContext()); return NumBytes == CharUnits::One() ? Type : (llvm::Type *)llvm::ArrayType::get(Type, NumBytes.getQuantity()); } /// \brief Gets the storage type for a field decl and handles storage /// for itanium bitfields that are smaller than their declared type. llvm::Type *getStorageType(const FieldDecl *FD) { llvm::Type *Type = Types.ConvertTypeForMem(FD->getType()); return useMSABI() || !FD->isBitField() ? Type : getIntNType(std::min(FD->getBitWidthValue(Context), (unsigned)Context.toBits(getSize(Type)))); } /// \brief Gets the llvm Basesubobject type from a CXXRecordDecl. llvm::Type *getStorageType(const CXXRecordDecl *RD) { return Types.getCGRecordLayout(RD).getBaseSubobjectLLVMType(); } CharUnits bitsToCharUnits(uint64_t BitOffset) { return Context.toCharUnitsFromBits(BitOffset); } CharUnits getSize(llvm::Type *Type) { return CharUnits::fromQuantity(DataLayout.getTypeAllocSize(Type)); } CharUnits getAlignment(llvm::Type *Type) { return CharUnits::fromQuantity(DataLayout.getABITypeAlignment(Type)); } bool isZeroInitializable(const FieldDecl *FD) { const Type *Type = FD->getType()->getBaseElementTypeUnsafe(); if (const MemberPointerType *MPT = Type->getAs()) return Types.getCXXABI().isZeroInitializable(MPT); if (const RecordType *RT = Type->getAs()) return isZeroInitializable(RT->getDecl()); return true; } bool isZeroInitializable(const RecordDecl *RD) { return Types.getCGRecordLayout(RD).isZeroInitializable(); } void appendPaddingBytes(CharUnits Size) { if (!Size.isZero()) FieldTypes.push_back(getByteArrayType(Size)); } uint64_t getFieldBitOffset(const FieldDecl *FD) { return Layout.getFieldOffset(FD->getFieldIndex()); } // Layout routines. void setBitFieldInfo(const FieldDecl *FD, CharUnits StartOffset, llvm::Type *StorageType); /// \brief Lowers an ASTRecordLayout to a llvm type. void lower(bool NonVirtualBaseType); void lowerUnion(); void accumulateFields(); void accumulateBitFields(RecordDecl::field_iterator Field, RecordDecl::field_iterator FieldEnd); void accumulateBases(); void accumulateVPtrs(); void accumulateVBases(); /// \brief Recursively searches all of the bases to find out if a vbase is /// not the primary vbase of some base class. bool hasOwnStorage(const CXXRecordDecl *Decl, const CXXRecordDecl *Query); void calculateZeroInit(); /// \brief Lowers bitfield storage types to I8 arrays for bitfields with tail /// padding that is or can potentially be used. void clipTailPadding(); /// \brief Determines if we need a packed llvm struct. void determinePacked(); /// \brief Inserts padding everwhere it's needed. void insertPadding(); /// \brief Fills out the structures that are ultimately consumed. void fillOutputFields(); // Input memoization fields. CodeGenTypes &Types; const ASTContext &Context; const RecordDecl *D; const CXXRecordDecl *RD; const ASTRecordLayout &Layout; const llvm::DataLayout &DataLayout; // Helpful intermediate data-structures. std::vector Members; // Output fields, consumed by CodeGenTypes::ComputeRecordLayout. SmallVector FieldTypes; llvm::DenseMap Fields; llvm::DenseMap BitFields; llvm::DenseMap NonVirtualBases; llvm::DenseMap VirtualBases; bool IsZeroInitializable : 1; bool IsZeroInitializableAsBase : 1; bool Packed : 1; private: CGRecordLowering(const CGRecordLowering &) LLVM_DELETED_FUNCTION; void operator =(const CGRecordLowering &) LLVM_DELETED_FUNCTION; }; } // namespace { CGRecordLowering::CGRecordLowering(CodeGenTypes &Types, const RecordDecl *D) : Types(Types), Context(Types.getContext()), D(D), RD(dyn_cast(D)), Layout(Types.getContext().getASTRecordLayout(D)), DataLayout(Types.getDataLayout()), IsZeroInitializable(true), IsZeroInitializableAsBase(true), Packed(false) {} void CGRecordLowering::setBitFieldInfo( const FieldDecl *FD, CharUnits StartOffset, llvm::Type *StorageType) { CGBitFieldInfo &Info = BitFields[FD]; Info.IsSigned = FD->getType()->isSignedIntegerOrEnumerationType(); Info.Offset = (unsigned)(getFieldBitOffset(FD) - Context.toBits(StartOffset)); Info.Size = FD->getBitWidthValue(Context); Info.StorageSize = (unsigned)DataLayout.getTypeAllocSizeInBits(StorageType); // Here we calculate the actual storage alignment of the bits. E.g if we've // got an alignment >= 2 and the bitfield starts at offset 6 we've got an // alignment of 2. Info.StorageAlignment = Layout.getAlignment().alignmentAtOffset(StartOffset).getQuantity(); if (Info.Size > Info.StorageSize) Info.Size = Info.StorageSize; // Reverse the bit offsets for big endian machines. Because we represent // a bitfield as a single large integer load, we can imagine the bits // counting from the most-significant-bit instead of the // least-significant-bit. if (DataLayout.isBigEndian()) Info.Offset = Info.StorageSize - (Info.Offset + Info.Size); } void CGRecordLowering::lower(bool NVBaseType) { // The lowering process implemented in this function takes a variety of // carefully ordered phases. // 1) Store all members (fields and bases) in a list and sort them by offset. // 2) Add a 1-byte capstone member at the Size of the structure. // 3) Clip bitfield storages members if their tail padding is or might be // used by another field or base. The clipping process uses the capstone // by treating it as another object that occurs after the record. // 4) Determine if the llvm-struct requires packing. It's important that this // phase occur after clipping, because clipping changes the llvm type. // This phase reads the offset of the capstone when determining packedness // and updates the alignment of the capstone to be equal of the alignment // of the record after doing so. // 5) Insert padding everywhere it is needed. This phase requires 'Packed' to // have been computed and needs to know the alignment of the record in // order to understand if explicit tail padding is needed. // 6) Remove the capstone, we don't need it anymore. // 7) Determine if this record can be zero-initialized. This phase could have // been placed anywhere after phase 1. // 8) Format the complete list of members in a way that can be consumed by // CodeGenTypes::ComputeRecordLayout. CharUnits Size = NVBaseType ? Layout.getNonVirtualSize() : Layout.getSize(); if (D->isUnion()) return lowerUnion(); accumulateFields(); // RD implies C++. if (RD) { accumulateVPtrs(); accumulateBases(); if (Members.empty()) return appendPaddingBytes(Size); if (!NVBaseType) accumulateVBases(); } std::stable_sort(Members.begin(), Members.end()); Members.push_back(StorageInfo(Size, getIntNType(8))); clipTailPadding(); determinePacked(); insertPadding(); Members.pop_back(); calculateZeroInit(); fillOutputFields(); } void CGRecordLowering::lowerUnion() { CharUnits LayoutSize = Layout.getSize(); llvm::Type *StorageType = 0; // Compute zero-initializable status. if (!D->field_empty() && !isZeroInitializable(*D->field_begin())) IsZeroInitializable = IsZeroInitializableAsBase = false; // Iterate through the fields setting bitFieldInfo and the Fields array. Also // locate the "most appropriate" storage type. The heuristic for finding the // storage type isn't necessary, the first (non-0-length-bitfield) field's // type would work fine and be simpler but would be differen than what we've // been doing and cause lit tests to change. for (RecordDecl::field_iterator Field = D->field_begin(), FieldEnd = D->field_end(); Field != FieldEnd; ++Field) { if (Field->isBitField()) { // Skip 0 sized bitfields. if (Field->getBitWidthValue(Context) == 0) continue; llvm::Type *FieldType = getStorageType(*Field); if (LayoutSize < getSize(FieldType)) FieldType = getByteArrayType(LayoutSize); setBitFieldInfo(*Field, CharUnits::Zero(), FieldType); } Fields[*Field] = 0; llvm::Type *FieldType = getStorageType(*Field); // Conditionally update our storage type if we've got a new "better" one. if (!StorageType || getAlignment(FieldType) > getAlignment(StorageType) || (getAlignment(FieldType) == getAlignment(StorageType) && getSize(FieldType) > getSize(StorageType))) StorageType = FieldType; } // If we have no storage type just pad to the appropriate size and return. if (!StorageType) return appendPaddingBytes(LayoutSize); // If our storage size was bigger than our required size (can happen in the // case of packed bitfields on Itanium) then just use an I8 array. if (LayoutSize < getSize(StorageType)) StorageType = getByteArrayType(LayoutSize); FieldTypes.push_back(StorageType); appendPaddingBytes(LayoutSize - getSize(StorageType)); // Set packed if we need it. if (LayoutSize % getAlignment(StorageType)) Packed = true; } void CGRecordLowering::accumulateFields() { for (RecordDecl::field_iterator Field = D->field_begin(), FieldEnd = D->field_end(); Field != FieldEnd;) if (Field->isBitField()) { RecordDecl::field_iterator Start = Field; // Iterate to gather the list of bitfields. for (++Field; Field != FieldEnd && Field->isBitField(); ++Field); accumulateBitFields(Start, Field); } else { Members.push_back(MemberInfo( bitsToCharUnits(getFieldBitOffset(*Field)), MemberInfo::Field, getStorageType(*Field), *Field)); ++Field; } } void CGRecordLowering::accumulateBitFields(RecordDecl::field_iterator Field, RecordDecl::field_iterator FieldEnd) { // Run stores the first element of the current run of bitfields. FieldEnd is // used as a special value to note that we don't have a current run. A // bitfield run is a contiguous collection of bitfields that can be stored in // the same storage block. Zero-sized bitfields and bitfields that would // cross an alignment boundary break a run and start a new one. RecordDecl::field_iterator Run = FieldEnd; // Tail is the offset of the first bit off the end of the current run. It's // used to determine if the ASTRecordLayout is treating these two bitfields as // contiguous. StartBitOffset is offset of the beginning of the Run. uint64_t StartBitOffset, Tail = 0; if (useMSABI()) { for (; Field != FieldEnd; ++Field) { uint64_t BitOffset = getFieldBitOffset(*Field); // Zero-width bitfields end runs. if (Field->getBitWidthValue(Context) == 0) { Run = FieldEnd; continue; } llvm::Type *Type = Types.ConvertTypeForMem(Field->getType()); // If we don't have a run yet, or don't live within the previous run's // allocated storage then we allocate some storage and start a new run. if (Run == FieldEnd || BitOffset >= Tail) { Run = Field; StartBitOffset = BitOffset; Tail = StartBitOffset + DataLayout.getTypeAllocSizeInBits(Type); // Add the storage member to the record. This must be added to the // record before the bitfield members so that it gets laid out before // the bitfields it contains get laid out. Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset), Type)); } // Bitfields get the offset of their storage but come afterward and remain // there after a stable sort. Members.push_back(MemberInfo(bitsToCharUnits(StartBitOffset), MemberInfo::Field, 0, *Field)); } return; } for (;;) { // Check to see if we need to start a new run. if (Run == FieldEnd) { // If we're out of fields, return. if (Field == FieldEnd) break; // Any non-zero-length bitfield can start a new run. if (Field->getBitWidthValue(Context) != 0) { Run = Field; StartBitOffset = getFieldBitOffset(*Field); Tail = StartBitOffset + Field->getBitWidthValue(Context); } ++Field; continue; } // Add bitfields to the run as long as they qualify. if (Field != FieldEnd && Field->getBitWidthValue(Context) != 0 && Tail == getFieldBitOffset(*Field)) { Tail += Field->getBitWidthValue(Context); ++Field; continue; } // We've hit a break-point in the run and need to emit a storage field. llvm::Type *Type = getIntNType(Tail - StartBitOffset); // Add the storage member to the record and set the bitfield info for all of // the bitfields in the run. Bitfields get the offset of their storage but // come afterward and remain there after a stable sort. Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset), Type)); for (; Run != Field; ++Run) Members.push_back(MemberInfo(bitsToCharUnits(StartBitOffset), MemberInfo::Field, 0, *Run)); Run = FieldEnd; } } void CGRecordLowering::accumulateBases() { // If we've got a primary virtual base, we need to add it with the bases. if (Layout.isPrimaryBaseVirtual()) Members.push_back(StorageInfo( CharUnits::Zero(), getStorageType(Layout.getPrimaryBase()))); // Accumulate the non-virtual bases. for (CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(), BaseEnd = RD->bases_end(); Base != BaseEnd; ++Base) { if (Base->isVirtual()) continue; const CXXRecordDecl *BaseDecl = Base->getType()->getAsCXXRecordDecl(); if (!BaseDecl->isEmpty()) Members.push_back(MemberInfo(Layout.getBaseClassOffset(BaseDecl), MemberInfo::Base, getStorageType(BaseDecl), BaseDecl)); } } void CGRecordLowering::accumulateVPtrs() { if (Layout.hasOwnVFPtr()) Members.push_back(MemberInfo(CharUnits::Zero(), MemberInfo::VFPtr, llvm::FunctionType::get(getIntNType(32), /*isVarArg=*/true)-> getPointerTo()->getPointerTo())); if (Layout.hasOwnVBPtr()) Members.push_back(MemberInfo(Layout.getVBPtrOffset(), MemberInfo::VBPtr, llvm::Type::getInt32PtrTy(Types.getLLVMContext()))); } void CGRecordLowering::accumulateVBases() { Members.push_back(MemberInfo(Layout.getNonVirtualSize(), MemberInfo::Scissor, 0, RD)); for (CXXRecordDecl::base_class_const_iterator Base = RD->vbases_begin(), BaseEnd = RD->vbases_end(); Base != BaseEnd; ++Base) { const CXXRecordDecl *BaseDecl = Base->getType()->getAsCXXRecordDecl(); if (BaseDecl->isEmpty()) continue; CharUnits Offset = Layout.getVBaseClassOffset(BaseDecl); // If the vbase is a primary virtual base of some base, then it doesn't // get its own storage location but instead lives inside of that base. if (!useMSABI() && Context.isNearlyEmpty(BaseDecl) && !hasOwnStorage(RD, BaseDecl)) { Members.push_back(MemberInfo(Offset, MemberInfo::VBase, 0, BaseDecl)); continue; } // If we've got a vtordisp, add it as a storage type. if (Layout.getVBaseOffsetsMap().find(BaseDecl)->second.hasVtorDisp()) Members.push_back(StorageInfo(Offset - CharUnits::fromQuantity(4), getIntNType(32))); Members.push_back(MemberInfo(Offset, MemberInfo::VBase, getStorageType(BaseDecl), BaseDecl)); } } bool CGRecordLowering::hasOwnStorage(const CXXRecordDecl *Decl, const CXXRecordDecl *Query) { const ASTRecordLayout &DeclLayout = Context.getASTRecordLayout(Decl); if (DeclLayout.isPrimaryBaseVirtual() && DeclLayout.getPrimaryBase() == Query) return false; for (CXXRecordDecl::base_class_const_iterator Base = Decl->bases_begin(), BaseEnd = Decl->bases_end(); Base != BaseEnd; ++Base) if (!hasOwnStorage(Base->getType()->getAsCXXRecordDecl(), Query)) return false; return true; } void CGRecordLowering::calculateZeroInit() { for (std::vector::const_iterator Member = Members.begin(), MemberEnd = Members.end(); IsZeroInitializableAsBase && Member != MemberEnd; ++Member) { if (Member->Kind == MemberInfo::Field) { if (!Member->FD || isZeroInitializable(Member->FD)) continue; IsZeroInitializable = IsZeroInitializableAsBase = false; } else if (Member->Kind == MemberInfo::Base || Member->Kind == MemberInfo::VBase) { if (isZeroInitializable(Member->RD)) continue; IsZeroInitializable = false; if (Member->Kind == MemberInfo::Base) IsZeroInitializableAsBase = false; } } } void CGRecordLowering::clipTailPadding() { std::vector::iterator Prior = Members.begin(); CharUnits Tail = getSize(Prior->Data); for (std::vector::iterator Member = Prior + 1, MemberEnd = Members.end(); Member != MemberEnd; ++Member) { // Only members with data and the scissor can cut into tail padding. if (!Member->Data && Member->Kind != MemberInfo::Scissor) continue; if (Member->Offset < Tail) { assert(Prior->Kind == MemberInfo::Field && !Prior->FD && "Only storage fields have tail padding!"); Prior->Data = getByteArrayType(bitsToCharUnits(llvm::RoundUpToAlignment( cast(Prior->Data)->getIntegerBitWidth(), 8))); } if (Member->Data) Prior = Member; Tail = Prior->Offset + getSize(Prior->Data); } } void CGRecordLowering::determinePacked() { CharUnits Alignment = CharUnits::One(); for (std::vector::const_iterator Member = Members.begin(), MemberEnd = Members.end(); Member != MemberEnd; ++Member) { if (!Member->Data) continue; // If any member falls at an offset that it not a multiple of its alignment, // then the entire record must be packed. if (Member->Offset % getAlignment(Member->Data)) Packed = true; Alignment = std::max(Alignment, getAlignment(Member->Data)); } // If the size of the record (the capstone's offset) is not a multiple of the // record's alignment, it must be packed. if (Members.back().Offset % Alignment) Packed = true; // Update the alignment of the sentinal. if (!Packed) Members.back().Data = getIntNType(Context.toBits(Alignment)); } void CGRecordLowering::insertPadding() { std::vector > Padding; CharUnits Size = CharUnits::Zero(); for (std::vector::const_iterator Member = Members.begin(), MemberEnd = Members.end(); Member != MemberEnd; ++Member) { if (!Member->Data) continue; CharUnits Offset = Member->Offset; assert(Offset >= Size); // Insert padding if we need to. if (Offset != Size.RoundUpToAlignment(Packed ? CharUnits::One() : getAlignment(Member->Data))) Padding.push_back(std::make_pair(Size, Offset - Size)); Size = Offset + getSize(Member->Data); } if (Padding.empty()) return; // Add the padding to the Members list and sort it. for (std::vector >::const_iterator Pad = Padding.begin(), PadEnd = Padding.end(); Pad != PadEnd; ++Pad) Members.push_back(StorageInfo(Pad->first, getByteArrayType(Pad->second))); std::stable_sort(Members.begin(), Members.end()); } void CGRecordLowering::fillOutputFields() { for (std::vector::const_iterator Member = Members.begin(), MemberEnd = Members.end(); Member != MemberEnd; ++Member) { if (Member->Data) FieldTypes.push_back(Member->Data); if (Member->Kind == MemberInfo::Field) { if (Member->FD) Fields[Member->FD] = FieldTypes.size() - 1; // A field without storage must be a bitfield. if (!Member->Data) setBitFieldInfo(Member->FD, Member->Offset, FieldTypes.back()); } else if (Member->Kind == MemberInfo::Base) NonVirtualBases[Member->RD] = FieldTypes.size() - 1; else if (Member->Kind == MemberInfo::VBase) VirtualBases[Member->RD] = FieldTypes.size() - 1; } } CGBitFieldInfo CGBitFieldInfo::MakeInfo(CodeGenTypes &Types, const FieldDecl *FD, uint64_t Offset, uint64_t Size, uint64_t StorageSize, uint64_t StorageAlignment) { // This function is vestigial from CGRecordLayoutBuilder days but is still // used in GCObjCRuntime.cpp. That usage has a "fixme" attached to it that // when addressed will allow for the removal of this function. llvm::Type *Ty = Types.ConvertTypeForMem(FD->getType()); CharUnits TypeSizeInBytes = CharUnits::fromQuantity(Types.getDataLayout().getTypeAllocSize(Ty)); uint64_t TypeSizeInBits = Types.getContext().toBits(TypeSizeInBytes); bool IsSigned = FD->getType()->isSignedIntegerOrEnumerationType(); if (Size > TypeSizeInBits) { // We have a wide bit-field. The extra bits are only used for padding, so // if we have a bitfield of type T, with size N: // // T t : N; // // We can just assume that it's: // // T t : sizeof(T); // Size = TypeSizeInBits; } // Reverse the bit offsets for big endian machines. Because we represent // a bitfield as a single large integer load, we can imagine the bits // counting from the most-significant-bit instead of the // least-significant-bit. if (Types.getDataLayout().isBigEndian()) { Offset = StorageSize - (Offset + Size); } return CGBitFieldInfo(Offset, Size, IsSigned, StorageSize, StorageAlignment); } CGRecordLayout *CodeGenTypes::ComputeRecordLayout(const RecordDecl *D, llvm::StructType *Ty) { CGRecordLowering Builder(*this, D); Builder.lower(false); // If we're in C++, compute the base subobject type. llvm::StructType *BaseTy = 0; if (isa(D) && !D->isUnion() && !D->hasAttr()) { BaseTy = Ty; if (Builder.Layout.getNonVirtualSize() != Builder.Layout.getSize()) { CGRecordLowering BaseBuilder(*this, D); BaseBuilder.lower(true); BaseTy = llvm::StructType::create( getLLVMContext(), BaseBuilder.FieldTypes, "", BaseBuilder.Packed); addRecordTypeName(D, BaseTy, ".base"); } } // Fill in the struct *after* computing the base type. Filling in the body // signifies that the type is no longer opaque and record layout is complete, // but we may need to recursively layout D while laying D out as a base type. Ty->setBody(Builder.FieldTypes, Builder.Packed); CGRecordLayout *RL = new CGRecordLayout(Ty, BaseTy, Builder.IsZeroInitializable, Builder.IsZeroInitializableAsBase); RL->NonVirtualBases.swap(Builder.NonVirtualBases); RL->CompleteObjectVirtualBases.swap(Builder.VirtualBases); // Add all the field numbers. RL->FieldInfo.swap(Builder.Fields); // Add bitfield info. RL->BitFields.swap(Builder.BitFields); // Dump the layout, if requested. if (getContext().getLangOpts().DumpRecordLayouts) { llvm::outs() << "\n*** Dumping IRgen Record Layout\n"; llvm::outs() << "Record: "; D->dump(llvm::outs()); llvm::outs() << "\nLayout: "; RL->print(llvm::outs()); } #ifndef NDEBUG // Verify that the computed LLVM struct size matches the AST layout size. const ASTRecordLayout &Layout = getContext().getASTRecordLayout(D); uint64_t TypeSizeInBits = getContext().toBits(Layout.getSize()); assert(TypeSizeInBits == getDataLayout().getTypeAllocSizeInBits(Ty) && "Type size mismatch!"); if (BaseTy) { CharUnits NonVirtualSize = Layout.getNonVirtualSize(); uint64_t AlignedNonVirtualTypeSizeInBits = getContext().toBits(NonVirtualSize); assert(AlignedNonVirtualTypeSizeInBits == getDataLayout().getTypeAllocSizeInBits(BaseTy) && "Type size mismatch!"); } // Verify that the LLVM and AST field offsets agree. llvm::StructType *ST = dyn_cast(RL->getLLVMType()); const llvm::StructLayout *SL = getDataLayout().getStructLayout(ST); const ASTRecordLayout &AST_RL = getContext().getASTRecordLayout(D); RecordDecl::field_iterator it = D->field_begin(); for (unsigned i = 0, e = AST_RL.getFieldCount(); i != e; ++i, ++it) { const FieldDecl *FD = *it; // For non-bit-fields, just check that the LLVM struct offset matches the // AST offset. if (!FD->isBitField()) { unsigned FieldNo = RL->getLLVMFieldNo(FD); assert(AST_RL.getFieldOffset(i) == SL->getElementOffsetInBits(FieldNo) && "Invalid field offset!"); continue; } // Ignore unnamed bit-fields. if (!FD->getDeclName()) continue; // Don't inspect zero-length bitfields. if (FD->getBitWidthValue(getContext()) == 0) continue; const CGBitFieldInfo &Info = RL->getBitFieldInfo(FD); llvm::Type *ElementTy = ST->getTypeAtIndex(RL->getLLVMFieldNo(FD)); // Unions have overlapping elements dictating their layout, but for // non-unions we can verify that this section of the layout is the exact // expected size. if (D->isUnion()) { // For unions we verify that the start is zero and the size // is in-bounds. However, on BE systems, the offset may be non-zero, but // the size + offset should match the storage size in that case as it // "starts" at the back. if (getDataLayout().isBigEndian()) assert(static_cast(Info.Offset + Info.Size) == Info.StorageSize && "Big endian union bitfield does not end at the back"); else assert(Info.Offset == 0 && "Little endian union bitfield with a non-zero offset"); assert(Info.StorageSize <= SL->getSizeInBits() && "Union not large enough for bitfield storage"); } else { assert(Info.StorageSize == getDataLayout().getTypeAllocSizeInBits(ElementTy) && "Storage size does not match the element type size"); } assert(Info.Size > 0 && "Empty bitfield!"); assert(static_cast(Info.Offset) + Info.Size <= Info.StorageSize && "Bitfield outside of its allocated storage"); } #endif return RL; } void CGRecordLayout::print(raw_ostream &OS) const { OS << " > BFIs; for (llvm::DenseMap::const_iterator it = BitFields.begin(), ie = BitFields.end(); it != ie; ++it) { const RecordDecl *RD = it->first->getParent(); unsigned Index = 0; for (RecordDecl::field_iterator it2 = RD->field_begin(); *it2 != it->first; ++it2) ++Index; BFIs.push_back(std::make_pair(Index, &it->second)); } llvm::array_pod_sort(BFIs.begin(), BFIs.end()); for (unsigned i = 0, e = BFIs.size(); i != e; ++i) { OS.indent(4); BFIs[i].second->print(OS); OS << "\n"; } OS << "]>\n"; } void CGRecordLayout::dump() const { print(llvm::errs()); } void CGBitFieldInfo::print(raw_ostream &OS) const { OS << ""; } void CGBitFieldInfo::dump() const { print(llvm::errs()); } @