1206084Srdivacky//===--- CGRecordLayoutBuilder.cpp - CGRecordLayout builder ----*- C++ -*-===// 2198092Srdivacky// 3198092Srdivacky// The LLVM Compiler Infrastructure 4198092Srdivacky// 5198092Srdivacky// This file is distributed under the University of Illinois Open Source 6198092Srdivacky// License. See LICENSE.TXT for details. 7198092Srdivacky// 8198092Srdivacky//===----------------------------------------------------------------------===// 9198092Srdivacky// 10206084Srdivacky// Builder implementation for CGRecordLayout objects. 11198092Srdivacky// 12198092Srdivacky//===----------------------------------------------------------------------===// 13198092Srdivacky 14206084Srdivacky#include "CGRecordLayout.h" 15249423Sdim#include "CGCXXABI.h" 16249423Sdim#include "CodeGenTypes.h" 17198092Srdivacky#include "clang/AST/ASTContext.h" 18198092Srdivacky#include "clang/AST/Attr.h" 19218893Sdim#include "clang/AST/CXXInheritance.h" 20198092Srdivacky#include "clang/AST/DeclCXX.h" 21198092Srdivacky#include "clang/AST/Expr.h" 22198092Srdivacky#include "clang/AST/RecordLayout.h" 23224145Sdim#include "clang/Frontend/CodeGenOptions.h" 24249423Sdim#include "llvm/IR/DataLayout.h" 25249423Sdim#include "llvm/IR/DerivedTypes.h" 26249423Sdim#include "llvm/IR/Type.h" 27207619Srdivacky#include "llvm/Support/Debug.h" 28207619Srdivacky#include "llvm/Support/raw_ostream.h" 29198092Srdivackyusing namespace clang; 30198092Srdivackyusing namespace CodeGen; 31198092Srdivacky 32218893Sdimnamespace { 33206084Srdivacky 34206084Srdivackyclass CGRecordLayoutBuilder { 35206084Srdivackypublic: 36206084Srdivacky /// FieldTypes - Holds the LLVM types that the struct is created from. 37218893Sdim /// 38226633Sdim SmallVector<llvm::Type *, 16> FieldTypes; 39206084Srdivacky 40218893Sdim /// BaseSubobjectType - Holds the LLVM type for the non-virtual part 41218893Sdim /// of the struct. For example, consider: 42218893Sdim /// 43218893Sdim /// struct A { int i; }; 44218893Sdim /// struct B { void *v; }; 45218893Sdim /// struct C : virtual A, B { }; 46218893Sdim /// 47218893Sdim /// The LLVM type of C will be 48218893Sdim /// %struct.C = type { i32 (...)**, %struct.A, i32, %struct.B } 49218893Sdim /// 50218893Sdim /// And the LLVM type of the non-virtual base struct will be 51218893Sdim /// %struct.C.base = type { i32 (...)**, %struct.A, i32 } 52218893Sdim /// 53218893Sdim /// This only gets initialized if the base subobject type is 54218893Sdim /// different from the complete-object type. 55224145Sdim llvm::StructType *BaseSubobjectType; 56206084Srdivacky 57218893Sdim /// FieldInfo - Holds a field and its corresponding LLVM field number. 58218893Sdim llvm::DenseMap<const FieldDecl *, unsigned> Fields; 59206084Srdivacky 60218893Sdim /// BitFieldInfo - Holds location and size information about a bit field. 61218893Sdim llvm::DenseMap<const FieldDecl *, CGBitFieldInfo> BitFields; 62218893Sdim 63218893Sdim llvm::DenseMap<const CXXRecordDecl *, unsigned> NonVirtualBases; 64218893Sdim llvm::DenseMap<const CXXRecordDecl *, unsigned> VirtualBases; 65218893Sdim 66218893Sdim /// IndirectPrimaryBases - Virtual base classes, direct or indirect, that are 67218893Sdim /// primary base classes for some other direct or indirect base class. 68218893Sdim CXXIndirectPrimaryBaseSet IndirectPrimaryBases; 69218893Sdim 70218893Sdim /// LaidOutVirtualBases - A set of all laid out virtual bases, used to avoid 71218893Sdim /// avoid laying out virtual bases more than once. 72218893Sdim llvm::SmallPtrSet<const CXXRecordDecl *, 4> LaidOutVirtualBases; 73208600Srdivacky 74212904Sdim /// IsZeroInitializable - Whether this struct can be C++ 75212904Sdim /// zero-initialized with an LLVM zeroinitializer. 76212904Sdim bool IsZeroInitializable; 77218893Sdim bool IsZeroInitializableAsBase; 78206084Srdivacky 79206084Srdivacky /// Packed - Whether the resulting LLVM struct will be packed or not. 80206084Srdivacky bool Packed; 81206084Srdivacky 82206084Srdivackyprivate: 83206084Srdivacky CodeGenTypes &Types; 84206084Srdivacky 85221345Sdim /// LastLaidOutBaseInfo - Contains the offset and non-virtual size of the 86221345Sdim /// last base laid out. Used so that we can replace the last laid out base 87221345Sdim /// type with an i8 array if needed. 88221345Sdim struct LastLaidOutBaseInfo { 89221345Sdim CharUnits Offset; 90221345Sdim CharUnits NonVirtualSize; 91221345Sdim 92221345Sdim bool isValid() const { return !NonVirtualSize.isZero(); } 93221345Sdim void invalidate() { NonVirtualSize = CharUnits::Zero(); } 94221345Sdim 95221345Sdim } LastLaidOutBase; 96221345Sdim 97206084Srdivacky /// Alignment - Contains the alignment of the RecordDecl. 98218893Sdim CharUnits Alignment; 99206084Srdivacky 100218893Sdim /// NextFieldOffset - Holds the next field offset. 101218893Sdim CharUnits NextFieldOffset; 102206084Srdivacky 103207619Srdivacky /// LayoutUnionField - Will layout a field in an union and return the type 104207619Srdivacky /// that the field will have. 105224145Sdim llvm::Type *LayoutUnionField(const FieldDecl *Field, 106224145Sdim const ASTRecordLayout &Layout); 107207619Srdivacky 108206084Srdivacky /// LayoutUnion - Will layout a union RecordDecl. 109206084Srdivacky void LayoutUnion(const RecordDecl *D); 110206084Srdivacky 111249423Sdim /// Lay out a sequence of contiguous bitfields. 112249423Sdim bool LayoutBitfields(const ASTRecordLayout &Layout, 113249423Sdim unsigned &FirstFieldNo, 114249423Sdim RecordDecl::field_iterator &FI, 115249423Sdim RecordDecl::field_iterator FE); 116249423Sdim 117263508Sdim /// LayoutFields - try to layout all fields in the record decl. 118206084Srdivacky /// Returns false if the operation failed because the struct is not packed. 119206084Srdivacky bool LayoutFields(const RecordDecl *D); 120206084Srdivacky 121218893Sdim /// Layout a single base, virtual or non-virtual 122234353Sdim bool LayoutBase(const CXXRecordDecl *base, 123218893Sdim const CGRecordLayout &baseLayout, 124218893Sdim CharUnits baseOffset); 125218893Sdim 126218893Sdim /// LayoutVirtualBase - layout a single virtual base. 127234353Sdim bool LayoutVirtualBase(const CXXRecordDecl *base, 128218893Sdim CharUnits baseOffset); 129218893Sdim 130218893Sdim /// LayoutVirtualBases - layout the virtual bases of a record decl. 131234353Sdim bool LayoutVirtualBases(const CXXRecordDecl *RD, 132218893Sdim const ASTRecordLayout &Layout); 133234353Sdim 134234353Sdim /// MSLayoutVirtualBases - layout the virtual bases of a record decl, 135234353Sdim /// like MSVC. 136234353Sdim bool MSLayoutVirtualBases(const CXXRecordDecl *RD, 137234353Sdim const ASTRecordLayout &Layout); 138218893Sdim 139208600Srdivacky /// LayoutNonVirtualBase - layout a single non-virtual base. 140234353Sdim bool LayoutNonVirtualBase(const CXXRecordDecl *base, 141218893Sdim CharUnits baseOffset); 142208600Srdivacky 143218893Sdim /// LayoutNonVirtualBases - layout the virtual bases of a record decl. 144234353Sdim bool LayoutNonVirtualBases(const CXXRecordDecl *RD, 145208600Srdivacky const ASTRecordLayout &Layout); 146206084Srdivacky 147218893Sdim /// ComputeNonVirtualBaseType - Compute the non-virtual base field types. 148218893Sdim bool ComputeNonVirtualBaseType(const CXXRecordDecl *RD); 149218893Sdim 150206084Srdivacky /// LayoutField - layout a single field. Returns false if the operation failed 151206084Srdivacky /// because the current struct is not packed. 152206084Srdivacky bool LayoutField(const FieldDecl *D, uint64_t FieldOffset); 153206084Srdivacky 154206084Srdivacky /// LayoutBitField - layout a single bit field. 155206084Srdivacky void LayoutBitField(const FieldDecl *D, uint64_t FieldOffset); 156206084Srdivacky 157206084Srdivacky /// AppendField - Appends a field with the given offset and type. 158224145Sdim void AppendField(CharUnits fieldOffset, llvm::Type *FieldTy); 159206084Srdivacky 160206084Srdivacky /// AppendPadding - Appends enough padding bytes so that the total 161206084Srdivacky /// struct size is a multiple of the field alignment. 162218893Sdim void AppendPadding(CharUnits fieldOffset, CharUnits fieldAlignment); 163206084Srdivacky 164221345Sdim /// ResizeLastBaseFieldIfNecessary - Fields and bases can be laid out in the 165221345Sdim /// tail padding of a previous base. If this happens, the type of the previous 166221345Sdim /// base needs to be changed to an array of i8. Returns true if the last 167221345Sdim /// laid out base was resized. 168221345Sdim bool ResizeLastBaseFieldIfNecessary(CharUnits offset); 169221345Sdim 170218893Sdim /// getByteArrayType - Returns a byte array type with the given number of 171218893Sdim /// elements. 172224145Sdim llvm::Type *getByteArrayType(CharUnits NumBytes); 173218893Sdim 174206084Srdivacky /// AppendBytes - Append a given number of bytes to the record. 175218893Sdim void AppendBytes(CharUnits numBytes); 176206084Srdivacky 177206084Srdivacky /// AppendTailPadding - Append enough tail padding so that the type will have 178206084Srdivacky /// the passed size. 179221345Sdim void AppendTailPadding(CharUnits RecordSize); 180206084Srdivacky 181226633Sdim CharUnits getTypeAlignment(llvm::Type *Ty) const; 182206084Srdivacky 183218893Sdim /// getAlignmentAsLLVMStruct - Returns the maximum alignment of all the 184218893Sdim /// LLVM element types. 185218893Sdim CharUnits getAlignmentAsLLVMStruct() const; 186218893Sdim 187212904Sdim /// CheckZeroInitializable - Check if the given type contains a pointer 188206084Srdivacky /// to data member. 189212904Sdim void CheckZeroInitializable(QualType T); 190206084Srdivacky 191206084Srdivackypublic: 192206084Srdivacky CGRecordLayoutBuilder(CodeGenTypes &Types) 193218893Sdim : BaseSubobjectType(0), 194218893Sdim IsZeroInitializable(true), IsZeroInitializableAsBase(true), 195263508Sdim Packed(false), Types(Types) { } 196206084Srdivacky 197206084Srdivacky /// Layout - Will layout a RecordDecl. 198206084Srdivacky void Layout(const RecordDecl *D); 199206084Srdivacky}; 200206084Srdivacky 201206084Srdivacky} 202206084Srdivacky 203198092Srdivackyvoid CGRecordLayoutBuilder::Layout(const RecordDecl *D) { 204263508Sdim const ASTRecordLayout &Layout = Types.getContext().getASTRecordLayout(D); 205263508Sdim Alignment = Layout.getAlignment(); 206263508Sdim Packed = D->hasAttr<PackedAttr>() || Layout.getSize() % Alignment != 0; 207198092Srdivacky 208198092Srdivacky if (D->isUnion()) { 209198092Srdivacky LayoutUnion(D); 210198092Srdivacky return; 211198092Srdivacky } 212198092Srdivacky 213198092Srdivacky if (LayoutFields(D)) 214198092Srdivacky return; 215198092Srdivacky 216198092Srdivacky // We weren't able to layout the struct. Try again with a packed struct 217198092Srdivacky Packed = true; 218221345Sdim LastLaidOutBase.invalidate(); 219218893Sdim NextFieldOffset = CharUnits::Zero(); 220198092Srdivacky FieldTypes.clear(); 221218893Sdim Fields.clear(); 222218893Sdim BitFields.clear(); 223218893Sdim NonVirtualBases.clear(); 224218893Sdim VirtualBases.clear(); 225198092Srdivacky 226198092Srdivacky LayoutFields(D); 227198092Srdivacky} 228198092Srdivacky 229212904SdimCGBitFieldInfo CGBitFieldInfo::MakeInfo(CodeGenTypes &Types, 230249423Sdim const FieldDecl *FD, 231249423Sdim uint64_t Offset, uint64_t Size, 232249423Sdim uint64_t StorageSize, 233249423Sdim uint64_t StorageAlignment) { 234226633Sdim llvm::Type *Ty = Types.ConvertTypeForMem(FD->getType()); 235219077Sdim CharUnits TypeSizeInBytes = 236243830Sdim CharUnits::fromQuantity(Types.getDataLayout().getTypeAllocSize(Ty)); 237219077Sdim uint64_t TypeSizeInBits = Types.getContext().toBits(TypeSizeInBytes); 238207619Srdivacky 239223017Sdim bool IsSigned = FD->getType()->isSignedIntegerOrEnumerationType(); 240207619Srdivacky 241249423Sdim if (Size > TypeSizeInBits) { 242207619Srdivacky // We have a wide bit-field. The extra bits are only used for padding, so 243207619Srdivacky // if we have a bitfield of type T, with size N: 244207619Srdivacky // 245207619Srdivacky // T t : N; 246207619Srdivacky // 247207619Srdivacky // We can just assume that it's: 248207619Srdivacky // 249207619Srdivacky // T t : sizeof(T); 250207619Srdivacky // 251249423Sdim Size = TypeSizeInBits; 252207619Srdivacky } 253207619Srdivacky 254249423Sdim // Reverse the bit offsets for big endian machines. Because we represent 255249423Sdim // a bitfield as a single large integer load, we can imagine the bits 256249423Sdim // counting from the most-significant-bit instead of the 257249423Sdim // least-significant-bit. 258243830Sdim if (Types.getDataLayout().isBigEndian()) { 259249423Sdim Offset = StorageSize - (Offset + Size); 260218893Sdim } 261218893Sdim 262249423Sdim return CGBitFieldInfo(Offset, Size, IsSigned, StorageSize, StorageAlignment); 263249423Sdim} 264207619Srdivacky 265249423Sdim/// \brief Layout the range of bitfields from BFI to BFE as contiguous storage. 266249423Sdimbool CGRecordLayoutBuilder::LayoutBitfields(const ASTRecordLayout &Layout, 267249423Sdim unsigned &FirstFieldNo, 268249423Sdim RecordDecl::field_iterator &FI, 269249423Sdim RecordDecl::field_iterator FE) { 270249423Sdim assert(FI != FE); 271249423Sdim uint64_t FirstFieldOffset = Layout.getFieldOffset(FirstFieldNo); 272249423Sdim uint64_t NextFieldOffsetInBits = Types.getContext().toBits(NextFieldOffset); 273224145Sdim 274251662Sdim unsigned CharAlign = Types.getTarget().getCharAlign(); 275249423Sdim assert(FirstFieldOffset % CharAlign == 0 && 276249423Sdim "First field offset is misaligned"); 277249423Sdim CharUnits FirstFieldOffsetInBytes 278249423Sdim = Types.getContext().toCharUnitsFromBits(FirstFieldOffset); 279207619Srdivacky 280249423Sdim unsigned StorageAlignment 281249423Sdim = llvm::MinAlign(Alignment.getQuantity(), 282249423Sdim FirstFieldOffsetInBytes.getQuantity()); 283207619Srdivacky 284249423Sdim if (FirstFieldOffset < NextFieldOffsetInBits) { 285249423Sdim CharUnits FieldOffsetInCharUnits = 286249423Sdim Types.getContext().toCharUnitsFromBits(FirstFieldOffset); 287207619Srdivacky 288249423Sdim // Try to resize the last base field. 289249423Sdim if (!ResizeLastBaseFieldIfNecessary(FieldOffsetInCharUnits)) 290249423Sdim llvm_unreachable("We must be able to resize the last base if we need to " 291249423Sdim "pack bits into it."); 292207619Srdivacky 293249423Sdim NextFieldOffsetInBits = Types.getContext().toBits(NextFieldOffset); 294249423Sdim assert(FirstFieldOffset >= NextFieldOffsetInBits); 295249423Sdim } 296207619Srdivacky 297249423Sdim // Append padding if necessary. 298249423Sdim AppendPadding(Types.getContext().toCharUnitsFromBits(FirstFieldOffset), 299249423Sdim CharUnits::One()); 300218893Sdim 301249423Sdim // Find the last bitfield in a contiguous run of bitfields. 302249423Sdim RecordDecl::field_iterator BFI = FI; 303249423Sdim unsigned LastFieldNo = FirstFieldNo; 304249423Sdim uint64_t NextContiguousFieldOffset = FirstFieldOffset; 305249423Sdim for (RecordDecl::field_iterator FJ = FI; 306249423Sdim (FJ != FE && (*FJ)->isBitField() && 307249423Sdim NextContiguousFieldOffset == Layout.getFieldOffset(LastFieldNo) && 308249423Sdim (*FJ)->getBitWidthValue(Types.getContext()) != 0); FI = FJ++) { 309249423Sdim NextContiguousFieldOffset += (*FJ)->getBitWidthValue(Types.getContext()); 310249423Sdim ++LastFieldNo; 311207619Srdivacky 312249423Sdim // We must use packed structs for packed fields, and also unnamed bit 313249423Sdim // fields since they don't affect the struct alignment. 314249423Sdim if (!Packed && ((*FJ)->hasAttr<PackedAttr>() || !(*FJ)->getDeclName())) 315249423Sdim return false; 316207619Srdivacky } 317249423Sdim RecordDecl::field_iterator BFE = llvm::next(FI); 318249423Sdim --LastFieldNo; 319249423Sdim assert(LastFieldNo >= FirstFieldNo && "Empty run of contiguous bitfields"); 320249423Sdim FieldDecl *LastFD = *FI; 321207619Srdivacky 322249423Sdim // Find the last bitfield's offset, add its size, and round it up to the 323249423Sdim // character alignment to compute the storage required. 324249423Sdim uint64_t LastFieldOffset = Layout.getFieldOffset(LastFieldNo); 325249423Sdim uint64_t LastFieldSize = LastFD->getBitWidthValue(Types.getContext()); 326249423Sdim uint64_t TotalBits = (LastFieldOffset + LastFieldSize) - FirstFieldOffset; 327249423Sdim CharUnits StorageBytes = Types.getContext().toCharUnitsFromBits( 328249423Sdim llvm::RoundUpToAlignment(TotalBits, CharAlign)); 329249423Sdim uint64_t StorageBits = Types.getContext().toBits(StorageBytes); 330207619Srdivacky 331249423Sdim // Grow the storage to encompass any known padding in the layout when doing 332249423Sdim // so will make the storage a power-of-two. There are two cases when we can 333249423Sdim // do this. The first is when we have a subsequent field and can widen up to 334249423Sdim // its offset. The second is when the data size of the AST record layout is 335249423Sdim // past the end of the current storage. The latter is true when there is tail 336249423Sdim // padding on a struct and no members of a super class can be packed into it. 337249423Sdim // 338249423Sdim // Note that we widen the storage as much as possible here to express the 339249423Sdim // maximum latitude the language provides, and rely on the backend to lower 340249423Sdim // these in conjunction with shifts and masks to narrower operations where 341249423Sdim // beneficial. 342249423Sdim uint64_t EndOffset = Types.getContext().toBits(Layout.getDataSize()); 343249423Sdim if (BFE != FE) 344249423Sdim // If there are more fields to be laid out, the offset at the end of the 345249423Sdim // bitfield is the offset of the next field in the record. 346249423Sdim EndOffset = Layout.getFieldOffset(LastFieldNo + 1); 347249423Sdim assert(EndOffset >= (FirstFieldOffset + TotalBits) && 348249423Sdim "End offset is not past the end of the known storage bits."); 349249423Sdim uint64_t SpaceBits = EndOffset - FirstFieldOffset; 350251662Sdim uint64_t LongBits = Types.getTarget().getLongWidth(); 351249423Sdim uint64_t WidenedBits = (StorageBits / LongBits) * LongBits + 352249423Sdim llvm::NextPowerOf2(StorageBits % LongBits - 1); 353249423Sdim assert(WidenedBits >= StorageBits && "Widening shrunk the bits!"); 354249423Sdim if (WidenedBits <= SpaceBits) { 355249423Sdim StorageBits = WidenedBits; 356249423Sdim StorageBytes = Types.getContext().toCharUnitsFromBits(StorageBits); 357249423Sdim assert(StorageBits == (uint64_t)Types.getContext().toBits(StorageBytes)); 358221345Sdim } 359221345Sdim 360249423Sdim unsigned FieldIndex = FieldTypes.size(); 361249423Sdim AppendBytes(StorageBytes); 362198092Srdivacky 363249423Sdim // Now walk the bitfields associating them with this field of storage and 364249423Sdim // building up the bitfield specific info. 365249423Sdim unsigned FieldNo = FirstFieldNo; 366249423Sdim for (; BFI != BFE; ++BFI, ++FieldNo) { 367249423Sdim FieldDecl *FD = *BFI; 368249423Sdim uint64_t FieldOffset = Layout.getFieldOffset(FieldNo) - FirstFieldOffset; 369249423Sdim uint64_t FieldSize = FD->getBitWidthValue(Types.getContext()); 370249423Sdim Fields[FD] = FieldIndex; 371249423Sdim BitFields[FD] = CGBitFieldInfo::MakeInfo(Types, FD, FieldOffset, FieldSize, 372249423Sdim StorageBits, StorageAlignment); 373198092Srdivacky } 374249423Sdim FirstFieldNo = LastFieldNo; 375249423Sdim return true; 376198092Srdivacky} 377198092Srdivacky 378198092Srdivackybool CGRecordLayoutBuilder::LayoutField(const FieldDecl *D, 379218893Sdim uint64_t fieldOffset) { 380198092Srdivacky // If the field is packed, then we need a packed struct. 381198092Srdivacky if (!Packed && D->hasAttr<PackedAttr>()) 382198092Srdivacky return false; 383198092Srdivacky 384249423Sdim assert(!D->isBitField() && "Bitfields should be laid out seperately."); 385198092Srdivacky 386212904Sdim CheckZeroInitializable(D->getType()); 387206084Srdivacky 388219077Sdim assert(fieldOffset % Types.getTarget().getCharWidth() == 0 389219077Sdim && "field offset is not on a byte boundary!"); 390219077Sdim CharUnits fieldOffsetInBytes 391219077Sdim = Types.getContext().toCharUnitsFromBits(fieldOffset); 392198092Srdivacky 393224145Sdim llvm::Type *Ty = Types.ConvertTypeForMem(D->getType()); 394218893Sdim CharUnits typeAlignment = getTypeAlignment(Ty); 395198092Srdivacky 396198092Srdivacky // If the type alignment is larger then the struct alignment, we must use 397198092Srdivacky // a packed struct. 398218893Sdim if (typeAlignment > Alignment) { 399198092Srdivacky assert(!Packed && "Alignment is wrong even with packed struct!"); 400198092Srdivacky return false; 401198092Srdivacky } 402198092Srdivacky 403218893Sdim if (!Packed) { 404218893Sdim if (const RecordType *RT = D->getType()->getAs<RecordType>()) { 405218893Sdim const RecordDecl *RD = cast<RecordDecl>(RT->getDecl()); 406218893Sdim if (const MaxFieldAlignmentAttr *MFAA = 407218893Sdim RD->getAttr<MaxFieldAlignmentAttr>()) { 408219077Sdim if (MFAA->getAlignment() != Types.getContext().toBits(typeAlignment)) 409218893Sdim return false; 410218893Sdim } 411198092Srdivacky } 412198092Srdivacky } 413198092Srdivacky 414198092Srdivacky // Round up the field offset to the alignment of the field type. 415218893Sdim CharUnits alignedNextFieldOffsetInBytes = 416218893Sdim NextFieldOffset.RoundUpToAlignment(typeAlignment); 417198092Srdivacky 418218893Sdim if (fieldOffsetInBytes < alignedNextFieldOffsetInBytes) { 419221345Sdim // Try to resize the last base field. 420221345Sdim if (ResizeLastBaseFieldIfNecessary(fieldOffsetInBytes)) { 421221345Sdim alignedNextFieldOffsetInBytes = 422221345Sdim NextFieldOffset.RoundUpToAlignment(typeAlignment); 423221345Sdim } 424221345Sdim } 425221345Sdim 426221345Sdim if (fieldOffsetInBytes < alignedNextFieldOffsetInBytes) { 427198092Srdivacky assert(!Packed && "Could not place field even with packed struct!"); 428198092Srdivacky return false; 429198092Srdivacky } 430198092Srdivacky 431218893Sdim AppendPadding(fieldOffsetInBytes, typeAlignment); 432198092Srdivacky 433198092Srdivacky // Now append the field. 434218893Sdim Fields[D] = FieldTypes.size(); 435218893Sdim AppendField(fieldOffsetInBytes, Ty); 436198092Srdivacky 437221345Sdim LastLaidOutBase.invalidate(); 438198092Srdivacky return true; 439198092Srdivacky} 440198092Srdivacky 441224145Sdimllvm::Type * 442207619SrdivackyCGRecordLayoutBuilder::LayoutUnionField(const FieldDecl *Field, 443207619Srdivacky const ASTRecordLayout &Layout) { 444249423Sdim Fields[Field] = 0; 445207619Srdivacky if (Field->isBitField()) { 446226633Sdim uint64_t FieldSize = Field->getBitWidthValue(Types.getContext()); 447207619Srdivacky 448207619Srdivacky // Ignore zero sized bit fields. 449207619Srdivacky if (FieldSize == 0) 450207619Srdivacky return 0; 451207619Srdivacky 452249423Sdim unsigned StorageBits = llvm::RoundUpToAlignment( 453251662Sdim FieldSize, Types.getTarget().getCharAlign()); 454249423Sdim CharUnits NumBytesToAppend 455249423Sdim = Types.getContext().toCharUnitsFromBits(StorageBits); 456249423Sdim 457224145Sdim llvm::Type *FieldTy = llvm::Type::getInt8Ty(Types.getLLVMContext()); 458221345Sdim if (NumBytesToAppend > CharUnits::One()) 459221345Sdim FieldTy = llvm::ArrayType::get(FieldTy, NumBytesToAppend.getQuantity()); 460207619Srdivacky 461207619Srdivacky // Add the bit field info. 462249423Sdim BitFields[Field] = CGBitFieldInfo::MakeInfo(Types, Field, 0, FieldSize, 463249423Sdim StorageBits, 464249423Sdim Alignment.getQuantity()); 465207619Srdivacky return FieldTy; 466207619Srdivacky } 467207619Srdivacky 468207619Srdivacky // This is a regular union field. 469224145Sdim return Types.ConvertTypeForMem(Field->getType()); 470207619Srdivacky} 471207619Srdivacky 472198092Srdivackyvoid CGRecordLayoutBuilder::LayoutUnion(const RecordDecl *D) { 473198092Srdivacky assert(D->isUnion() && "Can't call LayoutUnion on a non-union record!"); 474198092Srdivacky 475218893Sdim const ASTRecordLayout &layout = Types.getContext().getASTRecordLayout(D); 476198092Srdivacky 477224145Sdim llvm::Type *unionType = 0; 478218893Sdim CharUnits unionSize = CharUnits::Zero(); 479218893Sdim CharUnits unionAlign = CharUnits::Zero(); 480198092Srdivacky 481218893Sdim bool hasOnlyZeroSizedBitFields = true; 482234353Sdim bool checkedFirstFieldZeroInit = false; 483206084Srdivacky 484218893Sdim unsigned fieldNo = 0; 485218893Sdim for (RecordDecl::field_iterator field = D->field_begin(), 486218893Sdim fieldEnd = D->field_end(); field != fieldEnd; ++field, ++fieldNo) { 487218893Sdim assert(layout.getFieldOffset(fieldNo) == 0 && 488198092Srdivacky "Union field offset did not start at the beginning of record!"); 489224145Sdim llvm::Type *fieldType = LayoutUnionField(*field, layout); 490198092Srdivacky 491218893Sdim if (!fieldType) 492207619Srdivacky continue; 493198092Srdivacky 494234353Sdim if (field->getDeclName() && !checkedFirstFieldZeroInit) { 495234353Sdim CheckZeroInitializable(field->getType()); 496234353Sdim checkedFirstFieldZeroInit = true; 497234353Sdim } 498234353Sdim 499218893Sdim hasOnlyZeroSizedBitFields = false; 500206084Srdivacky 501218893Sdim CharUnits fieldAlign = CharUnits::fromQuantity( 502243830Sdim Types.getDataLayout().getABITypeAlignment(fieldType)); 503218893Sdim CharUnits fieldSize = CharUnits::fromQuantity( 504243830Sdim Types.getDataLayout().getTypeAllocSize(fieldType)); 505198092Srdivacky 506218893Sdim if (fieldAlign < unionAlign) 507198092Srdivacky continue; 508198092Srdivacky 509218893Sdim if (fieldAlign > unionAlign || fieldSize > unionSize) { 510218893Sdim unionType = fieldType; 511218893Sdim unionAlign = fieldAlign; 512218893Sdim unionSize = fieldSize; 513198092Srdivacky } 514198092Srdivacky } 515198092Srdivacky 516198092Srdivacky // Now add our field. 517218893Sdim if (unionType) { 518218893Sdim AppendField(CharUnits::Zero(), unionType); 519198092Srdivacky 520218893Sdim if (getTypeAlignment(unionType) > layout.getAlignment()) { 521198092Srdivacky // We need a packed struct. 522198092Srdivacky Packed = true; 523218893Sdim unionAlign = CharUnits::One(); 524198092Srdivacky } 525198092Srdivacky } 526218893Sdim if (unionAlign.isZero()) { 527234353Sdim (void)hasOnlyZeroSizedBitFields; 528218893Sdim assert(hasOnlyZeroSizedBitFields && 529203955Srdivacky "0-align record did not have all zero-sized bit-fields!"); 530218893Sdim unionAlign = CharUnits::One(); 531199482Srdivacky } 532206084Srdivacky 533198092Srdivacky // Append tail padding. 534218893Sdim CharUnits recordSize = layout.getSize(); 535218893Sdim if (recordSize > unionSize) 536218893Sdim AppendPadding(recordSize, unionAlign); 537198092Srdivacky} 538198092Srdivacky 539234353Sdimbool CGRecordLayoutBuilder::LayoutBase(const CXXRecordDecl *base, 540218893Sdim const CGRecordLayout &baseLayout, 541218893Sdim CharUnits baseOffset) { 542221345Sdim ResizeLastBaseFieldIfNecessary(baseOffset); 543221345Sdim 544218893Sdim AppendPadding(baseOffset, CharUnits::One()); 545208600Srdivacky 546218893Sdim const ASTRecordLayout &baseASTLayout 547218893Sdim = Types.getContext().getASTRecordLayout(base); 548208600Srdivacky 549221345Sdim LastLaidOutBase.Offset = NextFieldOffset; 550221345Sdim LastLaidOutBase.NonVirtualSize = baseASTLayout.getNonVirtualSize(); 551221345Sdim 552234353Sdim llvm::StructType *subobjectType = baseLayout.getBaseSubobjectLLVMType(); 553234353Sdim if (getTypeAlignment(subobjectType) > Alignment) 554234353Sdim return false; 555218893Sdim 556221345Sdim AppendField(baseOffset, subobjectType); 557234353Sdim return true; 558218893Sdim} 559218893Sdim 560234353Sdimbool CGRecordLayoutBuilder::LayoutNonVirtualBase(const CXXRecordDecl *base, 561218893Sdim CharUnits baseOffset) { 562218893Sdim // Ignore empty bases. 563234353Sdim if (base->isEmpty()) return true; 564218893Sdim 565218893Sdim const CGRecordLayout &baseLayout = Types.getCGRecordLayout(base); 566218893Sdim if (IsZeroInitializableAsBase) { 567218893Sdim assert(IsZeroInitializable && 568218893Sdim "class zero-initializable as base but not as complete object"); 569218893Sdim 570218893Sdim IsZeroInitializable = IsZeroInitializableAsBase = 571218893Sdim baseLayout.isZeroInitializableAsBase(); 572208600Srdivacky } 573208600Srdivacky 574234353Sdim if (!LayoutBase(base, baseLayout, baseOffset)) 575234353Sdim return false; 576218893Sdim NonVirtualBases[base] = (FieldTypes.size() - 1); 577234353Sdim return true; 578218893Sdim} 579208600Srdivacky 580234353Sdimbool 581218893SdimCGRecordLayoutBuilder::LayoutVirtualBase(const CXXRecordDecl *base, 582218893Sdim CharUnits baseOffset) { 583218893Sdim // Ignore empty bases. 584234353Sdim if (base->isEmpty()) return true; 585208600Srdivacky 586218893Sdim const CGRecordLayout &baseLayout = Types.getCGRecordLayout(base); 587218893Sdim if (IsZeroInitializable) 588218893Sdim IsZeroInitializable = baseLayout.isZeroInitializableAsBase(); 589218893Sdim 590234353Sdim if (!LayoutBase(base, baseLayout, baseOffset)) 591234353Sdim return false; 592218893Sdim VirtualBases[base] = (FieldTypes.size() - 1); 593234353Sdim return true; 594208600Srdivacky} 595208600Srdivacky 596234353Sdimbool 597234353SdimCGRecordLayoutBuilder::MSLayoutVirtualBases(const CXXRecordDecl *RD, 598234353Sdim const ASTRecordLayout &Layout) { 599234353Sdim if (!RD->getNumVBases()) 600234353Sdim return true; 601234353Sdim 602234353Sdim // The vbases list is uniqued and ordered by a depth-first 603234353Sdim // traversal, which is what we need here. 604234353Sdim for (CXXRecordDecl::base_class_const_iterator I = RD->vbases_begin(), 605234353Sdim E = RD->vbases_end(); I != E; ++I) { 606234353Sdim 607234353Sdim const CXXRecordDecl *BaseDecl = 608234353Sdim cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl()); 609234353Sdim 610234353Sdim CharUnits vbaseOffset = Layout.getVBaseClassOffset(BaseDecl); 611234353Sdim if (!LayoutVirtualBase(BaseDecl, vbaseOffset)) 612234353Sdim return false; 613234353Sdim } 614234353Sdim return true; 615234353Sdim} 616234353Sdim 617218893Sdim/// LayoutVirtualBases - layout the non-virtual bases of a record decl. 618234353Sdimbool 619218893SdimCGRecordLayoutBuilder::LayoutVirtualBases(const CXXRecordDecl *RD, 620218893Sdim const ASTRecordLayout &Layout) { 621218893Sdim for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 622218893Sdim E = RD->bases_end(); I != E; ++I) { 623218893Sdim const CXXRecordDecl *BaseDecl = 624218893Sdim cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl()); 625218893Sdim 626218893Sdim // We only want to lay out virtual bases that aren't indirect primary bases 627218893Sdim // of some other base. 628218893Sdim if (I->isVirtual() && !IndirectPrimaryBases.count(BaseDecl)) { 629218893Sdim // Only lay out the base once. 630218893Sdim if (!LaidOutVirtualBases.insert(BaseDecl)) 631218893Sdim continue; 632218893Sdim 633218893Sdim CharUnits vbaseOffset = Layout.getVBaseClassOffset(BaseDecl); 634234353Sdim if (!LayoutVirtualBase(BaseDecl, vbaseOffset)) 635234353Sdim return false; 636218893Sdim } 637218893Sdim 638218893Sdim if (!BaseDecl->getNumVBases()) { 639218893Sdim // This base isn't interesting since it doesn't have any virtual bases. 640218893Sdim continue; 641218893Sdim } 642218893Sdim 643234353Sdim if (!LayoutVirtualBases(BaseDecl, Layout)) 644234353Sdim return false; 645218893Sdim } 646234353Sdim return true; 647218893Sdim} 648218893Sdim 649234353Sdimbool 650208600SrdivackyCGRecordLayoutBuilder::LayoutNonVirtualBases(const CXXRecordDecl *RD, 651208600Srdivacky const ASTRecordLayout &Layout) { 652208600Srdivacky const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase(); 653208600Srdivacky 654234353Sdim // If we have a primary base, lay it out first. 655234353Sdim if (PrimaryBase) { 656234353Sdim if (!Layout.isPrimaryBaseVirtual()) { 657234353Sdim if (!LayoutNonVirtualBase(PrimaryBase, CharUnits::Zero())) 658234353Sdim return false; 659208600Srdivacky } else { 660234353Sdim if (!LayoutVirtualBase(PrimaryBase, CharUnits::Zero())) 661234353Sdim return false; 662208600Srdivacky } 663234353Sdim 664234353Sdim // Otherwise, add a vtable / vf-table if the layout says to do so. 665239462Sdim } else if (Layout.hasOwnVFPtr()) { 666234353Sdim llvm::Type *FunctionType = 667234353Sdim llvm::FunctionType::get(llvm::Type::getInt32Ty(Types.getLLVMContext()), 668234353Sdim /*isVarArg=*/true); 669234353Sdim llvm::Type *VTableTy = FunctionType->getPointerTo(); 670239462Sdim 671239462Sdim if (getTypeAlignment(VTableTy) > Alignment) { 672239462Sdim // FIXME: Should we allow this to happen in Sema? 673239462Sdim assert(!Packed && "Alignment is wrong even with packed struct!"); 674239462Sdim return false; 675239462Sdim } 676239462Sdim 677234353Sdim assert(NextFieldOffset.isZero() && 678234353Sdim "VTable pointer must come first!"); 679234353Sdim AppendField(CharUnits::Zero(), VTableTy->getPointerTo()); 680201361Srdivacky } 681208600Srdivacky 682208600Srdivacky // Layout the non-virtual bases. 683208600Srdivacky for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 684208600Srdivacky E = RD->bases_end(); I != E; ++I) { 685208600Srdivacky if (I->isVirtual()) 686208600Srdivacky continue; 687208600Srdivacky 688208600Srdivacky const CXXRecordDecl *BaseDecl = 689208600Srdivacky cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl()); 690208600Srdivacky 691208600Srdivacky // We've already laid out the primary base. 692218893Sdim if (BaseDecl == PrimaryBase && !Layout.isPrimaryBaseVirtual()) 693208600Srdivacky continue; 694208600Srdivacky 695234353Sdim if (!LayoutNonVirtualBase(BaseDecl, Layout.getBaseClassOffset(BaseDecl))) 696234353Sdim return false; 697208600Srdivacky } 698234353Sdim 699234353Sdim // Add a vb-table pointer if the layout insists. 700263508Sdim if (Layout.hasOwnVBPtr()) { 701234353Sdim CharUnits VBPtrOffset = Layout.getVBPtrOffset(); 702234353Sdim llvm::Type *Vbptr = llvm::Type::getInt32PtrTy(Types.getLLVMContext()); 703234353Sdim AppendPadding(VBPtrOffset, getTypeAlignment(Vbptr)); 704234353Sdim AppendField(VBPtrOffset, Vbptr); 705234353Sdim } 706234353Sdim 707234353Sdim return true; 708201361Srdivacky} 709201361Srdivacky 710218893Sdimbool 711218893SdimCGRecordLayoutBuilder::ComputeNonVirtualBaseType(const CXXRecordDecl *RD) { 712218893Sdim const ASTRecordLayout &Layout = Types.getContext().getASTRecordLayout(RD); 713218893Sdim 714218893Sdim CharUnits NonVirtualSize = Layout.getNonVirtualSize(); 715218893Sdim CharUnits NonVirtualAlign = Layout.getNonVirtualAlign(); 716218893Sdim CharUnits AlignedNonVirtualTypeSize = 717218893Sdim NonVirtualSize.RoundUpToAlignment(NonVirtualAlign); 718218893Sdim 719218893Sdim // First check if we can use the same fields as for the complete class. 720218893Sdim CharUnits RecordSize = Layout.getSize(); 721218893Sdim if (AlignedNonVirtualTypeSize == RecordSize) 722218893Sdim return true; 723218893Sdim 724218893Sdim // Check if we need padding. 725218893Sdim CharUnits AlignedNextFieldOffset = 726218893Sdim NextFieldOffset.RoundUpToAlignment(getAlignmentAsLLVMStruct()); 727218893Sdim 728218893Sdim if (AlignedNextFieldOffset > AlignedNonVirtualTypeSize) { 729218893Sdim assert(!Packed && "cannot layout even as packed struct"); 730218893Sdim return false; // Needs packing. 731218893Sdim } 732218893Sdim 733218893Sdim bool needsPadding = (AlignedNonVirtualTypeSize != AlignedNextFieldOffset); 734218893Sdim if (needsPadding) { 735218893Sdim CharUnits NumBytes = AlignedNonVirtualTypeSize - AlignedNextFieldOffset; 736218893Sdim FieldTypes.push_back(getByteArrayType(NumBytes)); 737218893Sdim } 738224145Sdim 739226633Sdim BaseSubobjectType = llvm::StructType::create(Types.getLLVMContext(), 740226633Sdim FieldTypes, "", Packed); 741224145Sdim Types.addRecordTypeName(RD, BaseSubobjectType, ".base"); 742218893Sdim 743224145Sdim // Pull the padding back off. 744224145Sdim if (needsPadding) 745218893Sdim FieldTypes.pop_back(); 746218893Sdim 747218893Sdim return true; 748218893Sdim} 749218893Sdim 750198092Srdivackybool CGRecordLayoutBuilder::LayoutFields(const RecordDecl *D) { 751198092Srdivacky assert(!D->isUnion() && "Can't call LayoutFields on a union!"); 752218893Sdim assert(!Alignment.isZero() && "Did not set alignment!"); 753198092Srdivacky 754198092Srdivacky const ASTRecordLayout &Layout = Types.getContext().getASTRecordLayout(D); 755198092Srdivacky 756218893Sdim const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D); 757218893Sdim if (RD) 758234353Sdim if (!LayoutNonVirtualBases(RD, Layout)) 759234353Sdim return false; 760206084Srdivacky 761198092Srdivacky unsigned FieldNo = 0; 762221345Sdim 763249423Sdim for (RecordDecl::field_iterator FI = D->field_begin(), FE = D->field_end(); 764249423Sdim FI != FE; ++FI, ++FieldNo) { 765249423Sdim FieldDecl *FD = *FI; 766249423Sdim 767249423Sdim // If this field is a bitfield, layout all of the consecutive 768249423Sdim // non-zero-length bitfields and the last zero-length bitfield; these will 769249423Sdim // all share storage. 770249423Sdim if (FD->isBitField()) { 771249423Sdim // If all we have is a zero-width bitfield, skip it. 772249423Sdim if (FD->getBitWidthValue(Types.getContext()) == 0) 773249423Sdim continue; 774249423Sdim 775249423Sdim // Layout this range of bitfields. 776249423Sdim if (!LayoutBitfields(Layout, FieldNo, FI, FE)) { 777249423Sdim assert(!Packed && 778249423Sdim "Could not layout bitfields even with a packed LLVM struct!"); 779249423Sdim return false; 780249423Sdim } 781249423Sdim assert(FI != FE && "Advanced past the last bitfield"); 782249423Sdim continue; 783249423Sdim } 784249423Sdim 785249423Sdim if (!LayoutField(FD, Layout.getFieldOffset(FieldNo))) { 786198092Srdivacky assert(!Packed && 787198092Srdivacky "Could not layout fields even with a packed LLVM struct!"); 788198092Srdivacky return false; 789198092Srdivacky } 790198092Srdivacky } 791198092Srdivacky 792218893Sdim if (RD) { 793218893Sdim // We've laid out the non-virtual bases and the fields, now compute the 794218893Sdim // non-virtual base field types. 795218893Sdim if (!ComputeNonVirtualBaseType(RD)) { 796218893Sdim assert(!Packed && "Could not layout even with a packed LLVM struct!"); 797218893Sdim return false; 798218893Sdim } 799218893Sdim 800234353Sdim // Lay out the virtual bases. The MS ABI uses a different 801234353Sdim // algorithm here due to the lack of primary virtual bases. 802251662Sdim if (Types.getTarget().getCXXABI().hasPrimaryVBases()) { 803234353Sdim RD->getIndirectPrimaryBases(IndirectPrimaryBases); 804234353Sdim if (Layout.isPrimaryBaseVirtual()) 805234353Sdim IndirectPrimaryBases.insert(Layout.getPrimaryBase()); 806234353Sdim 807234353Sdim if (!LayoutVirtualBases(RD, Layout)) 808234353Sdim return false; 809234353Sdim } else { 810234353Sdim if (!MSLayoutVirtualBases(RD, Layout)) 811234353Sdim return false; 812234353Sdim } 813218893Sdim } 814218893Sdim 815198092Srdivacky // Append tail padding if necessary. 816221345Sdim AppendTailPadding(Layout.getSize()); 817198092Srdivacky 818198092Srdivacky return true; 819198092Srdivacky} 820198092Srdivacky 821221345Sdimvoid CGRecordLayoutBuilder::AppendTailPadding(CharUnits RecordSize) { 822221345Sdim ResizeLastBaseFieldIfNecessary(RecordSize); 823198092Srdivacky 824221345Sdim assert(NextFieldOffset <= RecordSize && "Size mismatch!"); 825198092Srdivacky 826218893Sdim CharUnits AlignedNextFieldOffset = 827218893Sdim NextFieldOffset.RoundUpToAlignment(getAlignmentAsLLVMStruct()); 828200583Srdivacky 829221345Sdim if (AlignedNextFieldOffset == RecordSize) { 830200583Srdivacky // We don't need any padding. 831200583Srdivacky return; 832200583Srdivacky } 833206084Srdivacky 834221345Sdim CharUnits NumPadBytes = RecordSize - NextFieldOffset; 835198092Srdivacky AppendBytes(NumPadBytes); 836198092Srdivacky} 837198092Srdivacky 838218893Sdimvoid CGRecordLayoutBuilder::AppendField(CharUnits fieldOffset, 839224145Sdim llvm::Type *fieldType) { 840218893Sdim CharUnits fieldSize = 841243830Sdim CharUnits::fromQuantity(Types.getDataLayout().getTypeAllocSize(fieldType)); 842198092Srdivacky 843218893Sdim FieldTypes.push_back(fieldType); 844198092Srdivacky 845218893Sdim NextFieldOffset = fieldOffset + fieldSize; 846198092Srdivacky} 847198092Srdivacky 848218893Sdimvoid CGRecordLayoutBuilder::AppendPadding(CharUnits fieldOffset, 849218893Sdim CharUnits fieldAlignment) { 850218893Sdim assert(NextFieldOffset <= fieldOffset && 851198092Srdivacky "Incorrect field layout!"); 852198092Srdivacky 853234353Sdim // Do nothing if we're already at the right offset. 854234353Sdim if (fieldOffset == NextFieldOffset) return; 855198092Srdivacky 856234353Sdim // If we're not emitting a packed LLVM type, try to avoid adding 857234353Sdim // unnecessary padding fields. 858234353Sdim if (!Packed) { 859234353Sdim // Round up the field offset to the alignment of the field type. 860234353Sdim CharUnits alignedNextFieldOffset = 861234353Sdim NextFieldOffset.RoundUpToAlignment(fieldAlignment); 862234353Sdim assert(alignedNextFieldOffset <= fieldOffset); 863198092Srdivacky 864234353Sdim // If that's the right offset, we're done. 865234353Sdim if (alignedNextFieldOffset == fieldOffset) return; 866198092Srdivacky } 867234353Sdim 868234353Sdim // Otherwise we need explicit padding. 869234353Sdim CharUnits padding = fieldOffset - NextFieldOffset; 870234353Sdim AppendBytes(padding); 871198092Srdivacky} 872198092Srdivacky 873221345Sdimbool CGRecordLayoutBuilder::ResizeLastBaseFieldIfNecessary(CharUnits offset) { 874221345Sdim // Check if we have a base to resize. 875221345Sdim if (!LastLaidOutBase.isValid()) 876221345Sdim return false; 877221345Sdim 878221345Sdim // This offset does not overlap with the tail padding. 879221345Sdim if (offset >= NextFieldOffset) 880221345Sdim return false; 881221345Sdim 882221345Sdim // Restore the field offset and append an i8 array instead. 883221345Sdim FieldTypes.pop_back(); 884221345Sdim NextFieldOffset = LastLaidOutBase.Offset; 885221345Sdim AppendBytes(LastLaidOutBase.NonVirtualSize); 886221345Sdim LastLaidOutBase.invalidate(); 887221345Sdim 888221345Sdim return true; 889221345Sdim} 890221345Sdim 891224145Sdimllvm::Type *CGRecordLayoutBuilder::getByteArrayType(CharUnits numBytes) { 892218893Sdim assert(!numBytes.isZero() && "Empty byte arrays aren't allowed."); 893198092Srdivacky 894224145Sdim llvm::Type *Ty = llvm::Type::getInt8Ty(Types.getLLVMContext()); 895218893Sdim if (numBytes > CharUnits::One()) 896218893Sdim Ty = llvm::ArrayType::get(Ty, numBytes.getQuantity()); 897198092Srdivacky 898218893Sdim return Ty; 899218893Sdim} 900218893Sdim 901218893Sdimvoid CGRecordLayoutBuilder::AppendBytes(CharUnits numBytes) { 902218893Sdim if (numBytes.isZero()) 903218893Sdim return; 904218893Sdim 905198092Srdivacky // Append the padding field 906218893Sdim AppendField(NextFieldOffset, getByteArrayType(numBytes)); 907198092Srdivacky} 908198092Srdivacky 909226633SdimCharUnits CGRecordLayoutBuilder::getTypeAlignment(llvm::Type *Ty) const { 910198092Srdivacky if (Packed) 911218893Sdim return CharUnits::One(); 912198092Srdivacky 913243830Sdim return CharUnits::fromQuantity(Types.getDataLayout().getABITypeAlignment(Ty)); 914198092Srdivacky} 915198092Srdivacky 916218893SdimCharUnits CGRecordLayoutBuilder::getAlignmentAsLLVMStruct() const { 917218893Sdim if (Packed) 918218893Sdim return CharUnits::One(); 919218893Sdim 920218893Sdim CharUnits maxAlignment = CharUnits::One(); 921218893Sdim for (size_t i = 0; i != FieldTypes.size(); ++i) 922218893Sdim maxAlignment = std::max(maxAlignment, getTypeAlignment(FieldTypes[i])); 923218893Sdim 924218893Sdim return maxAlignment; 925218893Sdim} 926218893Sdim 927218893Sdim/// Merge in whether a field of the given type is zero-initializable. 928212904Sdimvoid CGRecordLayoutBuilder::CheckZeroInitializable(QualType T) { 929198092Srdivacky // This record already contains a member pointer. 930218893Sdim if (!IsZeroInitializableAsBase) 931198092Srdivacky return; 932198092Srdivacky 933198092Srdivacky // Can only have member pointers if we're compiling C++. 934234353Sdim if (!Types.getContext().getLangOpts().CPlusPlus) 935198092Srdivacky return; 936198092Srdivacky 937218893Sdim const Type *elementType = T->getBaseElementTypeUnsafe(); 938198092Srdivacky 939218893Sdim if (const MemberPointerType *MPT = elementType->getAs<MemberPointerType>()) { 940212904Sdim if (!Types.getCXXABI().isZeroInitializable(MPT)) 941218893Sdim IsZeroInitializable = IsZeroInitializableAsBase = false; 942218893Sdim } else if (const RecordType *RT = elementType->getAs<RecordType>()) { 943203955Srdivacky const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 944218893Sdim const CGRecordLayout &Layout = Types.getCGRecordLayout(RD); 945218893Sdim if (!Layout.isZeroInitializable()) 946218893Sdim IsZeroInitializable = IsZeroInitializableAsBase = false; 947208600Srdivacky } 948208600Srdivacky} 949206084Srdivacky 950224145SdimCGRecordLayout *CodeGenTypes::ComputeRecordLayout(const RecordDecl *D, 951224145Sdim llvm::StructType *Ty) { 952206084Srdivacky CGRecordLayoutBuilder Builder(*this); 953198092Srdivacky 954198092Srdivacky Builder.Layout(D); 955198092Srdivacky 956224145Sdim Ty->setBody(Builder.FieldTypes, Builder.Packed); 957198092Srdivacky 958218893Sdim // If we're in C++, compute the base subobject type. 959224145Sdim llvm::StructType *BaseTy = 0; 960234353Sdim if (isa<CXXRecordDecl>(D) && !D->isUnion()) { 961218893Sdim BaseTy = Builder.BaseSubobjectType; 962218893Sdim if (!BaseTy) BaseTy = Ty; 963218893Sdim } 964218893Sdim 965206084Srdivacky CGRecordLayout *RL = 966218893Sdim new CGRecordLayout(Ty, BaseTy, Builder.IsZeroInitializable, 967218893Sdim Builder.IsZeroInitializableAsBase); 968206084Srdivacky 969218893Sdim RL->NonVirtualBases.swap(Builder.NonVirtualBases); 970218893Sdim RL->CompleteObjectVirtualBases.swap(Builder.VirtualBases); 971208600Srdivacky 972198092Srdivacky // Add all the field numbers. 973218893Sdim RL->FieldInfo.swap(Builder.Fields); 974198092Srdivacky 975198092Srdivacky // Add bitfield info. 976218893Sdim RL->BitFields.swap(Builder.BitFields); 977198092Srdivacky 978207619Srdivacky // Dump the layout, if requested. 979234353Sdim if (getContext().getLangOpts().DumpRecordLayouts) { 980263508Sdim llvm::outs() << "\n*** Dumping IRgen Record Layout\n"; 981263508Sdim llvm::outs() << "Record: "; 982263508Sdim D->dump(llvm::outs()); 983263508Sdim llvm::outs() << "\nLayout: "; 984263508Sdim RL->print(llvm::outs()); 985207619Srdivacky } 986207619Srdivacky 987207619Srdivacky#ifndef NDEBUG 988207619Srdivacky // Verify that the computed LLVM struct size matches the AST layout size. 989218893Sdim const ASTRecordLayout &Layout = getContext().getASTRecordLayout(D); 990218893Sdim 991218893Sdim uint64_t TypeSizeInBits = getContext().toBits(Layout.getSize()); 992243830Sdim assert(TypeSizeInBits == getDataLayout().getTypeAllocSizeInBits(Ty) && 993207619Srdivacky "Type size mismatch!"); 994207619Srdivacky 995218893Sdim if (BaseTy) { 996218893Sdim CharUnits NonVirtualSize = Layout.getNonVirtualSize(); 997218893Sdim CharUnits NonVirtualAlign = Layout.getNonVirtualAlign(); 998218893Sdim CharUnits AlignedNonVirtualTypeSize = 999218893Sdim NonVirtualSize.RoundUpToAlignment(NonVirtualAlign); 1000218893Sdim 1001218893Sdim uint64_t AlignedNonVirtualTypeSizeInBits = 1002218893Sdim getContext().toBits(AlignedNonVirtualTypeSize); 1003218893Sdim 1004218893Sdim assert(AlignedNonVirtualTypeSizeInBits == 1005243830Sdim getDataLayout().getTypeAllocSizeInBits(BaseTy) && 1006218893Sdim "Type size mismatch!"); 1007218893Sdim } 1008218893Sdim 1009207619Srdivacky // Verify that the LLVM and AST field offsets agree. 1010226633Sdim llvm::StructType *ST = 1011207619Srdivacky dyn_cast<llvm::StructType>(RL->getLLVMType()); 1012243830Sdim const llvm::StructLayout *SL = getDataLayout().getStructLayout(ST); 1013207619Srdivacky 1014207619Srdivacky const ASTRecordLayout &AST_RL = getContext().getASTRecordLayout(D); 1015207619Srdivacky RecordDecl::field_iterator it = D->field_begin(); 1016207619Srdivacky for (unsigned i = 0, e = AST_RL.getFieldCount(); i != e; ++i, ++it) { 1017207619Srdivacky const FieldDecl *FD = *it; 1018207619Srdivacky 1019207619Srdivacky // For non-bit-fields, just check that the LLVM struct offset matches the 1020207619Srdivacky // AST offset. 1021207619Srdivacky if (!FD->isBitField()) { 1022207619Srdivacky unsigned FieldNo = RL->getLLVMFieldNo(FD); 1023207619Srdivacky assert(AST_RL.getFieldOffset(i) == SL->getElementOffsetInBits(FieldNo) && 1024207619Srdivacky "Invalid field offset!"); 1025207619Srdivacky continue; 1026207619Srdivacky } 1027221345Sdim 1028207619Srdivacky // Ignore unnamed bit-fields. 1029263508Sdim if (!FD->getDeclName()) 1030207619Srdivacky continue; 1031249423Sdim 1032249423Sdim // Don't inspect zero-length bitfields. 1033249423Sdim if (FD->getBitWidthValue(getContext()) == 0) 1034249423Sdim continue; 1035249423Sdim 1036207619Srdivacky const CGBitFieldInfo &Info = RL->getBitFieldInfo(FD); 1037249423Sdim llvm::Type *ElementTy = ST->getTypeAtIndex(RL->getLLVMFieldNo(FD)); 1038207619Srdivacky 1039249423Sdim // Unions have overlapping elements dictating their layout, but for 1040249423Sdim // non-unions we can verify that this section of the layout is the exact 1041249423Sdim // expected size. 1042249423Sdim if (D->isUnion()) { 1043249423Sdim // For unions we verify that the start is zero and the size 1044249423Sdim // is in-bounds. However, on BE systems, the offset may be non-zero, but 1045249423Sdim // the size + offset should match the storage size in that case as it 1046249423Sdim // "starts" at the back. 1047249423Sdim if (getDataLayout().isBigEndian()) 1048249423Sdim assert(static_cast<unsigned>(Info.Offset + Info.Size) == 1049249423Sdim Info.StorageSize && 1050249423Sdim "Big endian union bitfield does not end at the back"); 1051249423Sdim else 1052249423Sdim assert(Info.Offset == 0 && 1053249423Sdim "Little endian union bitfield with a non-zero offset"); 1054249423Sdim assert(Info.StorageSize <= SL->getSizeInBits() && 1055249423Sdim "Union not large enough for bitfield storage"); 1056249423Sdim } else { 1057249423Sdim assert(Info.StorageSize == 1058249423Sdim getDataLayout().getTypeAllocSizeInBits(ElementTy) && 1059249423Sdim "Storage size does not match the element type size"); 1060207619Srdivacky } 1061249423Sdim assert(Info.Size > 0 && "Empty bitfield!"); 1062249423Sdim assert(static_cast<unsigned>(Info.Offset) + Info.Size <= Info.StorageSize && 1063249423Sdim "Bitfield outside of its allocated storage"); 1064207619Srdivacky } 1065207619Srdivacky#endif 1066207619Srdivacky 1067206084Srdivacky return RL; 1068198092Srdivacky} 1069207619Srdivacky 1070226633Sdimvoid CGRecordLayout::print(raw_ostream &OS) const { 1071207619Srdivacky OS << "<CGRecordLayout\n"; 1072218893Sdim OS << " LLVMType:" << *CompleteObjectType << "\n"; 1073218893Sdim if (BaseSubobjectType) 1074218893Sdim OS << " NonVirtualBaseLLVMType:" << *BaseSubobjectType << "\n"; 1075212904Sdim OS << " IsZeroInitializable:" << IsZeroInitializable << "\n"; 1076207619Srdivacky OS << " BitFields:[\n"; 1077207619Srdivacky 1078207619Srdivacky // Print bit-field infos in declaration order. 1079207619Srdivacky std::vector<std::pair<unsigned, const CGBitFieldInfo*> > BFIs; 1080207619Srdivacky for (llvm::DenseMap<const FieldDecl*, CGBitFieldInfo>::const_iterator 1081207619Srdivacky it = BitFields.begin(), ie = BitFields.end(); 1082207619Srdivacky it != ie; ++it) { 1083207619Srdivacky const RecordDecl *RD = it->first->getParent(); 1084207619Srdivacky unsigned Index = 0; 1085207619Srdivacky for (RecordDecl::field_iterator 1086207619Srdivacky it2 = RD->field_begin(); *it2 != it->first; ++it2) 1087207619Srdivacky ++Index; 1088207619Srdivacky BFIs.push_back(std::make_pair(Index, &it->second)); 1089207619Srdivacky } 1090207619Srdivacky llvm::array_pod_sort(BFIs.begin(), BFIs.end()); 1091207619Srdivacky for (unsigned i = 0, e = BFIs.size(); i != e; ++i) { 1092207619Srdivacky OS.indent(4); 1093207619Srdivacky BFIs[i].second->print(OS); 1094207619Srdivacky OS << "\n"; 1095207619Srdivacky } 1096207619Srdivacky 1097207619Srdivacky OS << "]>\n"; 1098207619Srdivacky} 1099207619Srdivacky 1100207619Srdivackyvoid CGRecordLayout::dump() const { 1101207619Srdivacky print(llvm::errs()); 1102207619Srdivacky} 1103207619Srdivacky 1104226633Sdimvoid CGBitFieldInfo::print(raw_ostream &OS) const { 1105249423Sdim OS << "<CGBitFieldInfo" 1106249423Sdim << " Offset:" << Offset 1107249423Sdim << " Size:" << Size 1108249423Sdim << " IsSigned:" << IsSigned 1109249423Sdim << " StorageSize:" << StorageSize 1110249423Sdim << " StorageAlignment:" << StorageAlignment << ">"; 1111207619Srdivacky} 1112207619Srdivacky 1113207619Srdivackyvoid CGBitFieldInfo::dump() const { 1114207619Srdivacky print(llvm::errs()); 1115207619Srdivacky} 1116