contrib/llvm/tools/clang/lib/AST/RecordLayoutBuilder.cpp

   1 //=== RecordLayoutBuilder.cpp - Helper class for building record layouts ---==//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "clang/AST/Attr.h"
  11 #include "clang/AST/CXXInheritance.h"
  12 #include "clang/AST/Decl.h"
  13 #include "clang/AST/DeclCXX.h"
  14 #include "clang/AST/DeclObjC.h"
  15 #include "clang/AST/Expr.h"
  16 #include "clang/AST/RecordLayout.h"
  17 #include "clang/Basic/TargetInfo.h"
  18 #include "clang/Sema/SemaDiagnostic.h"
  19 #include "llvm/Support/Format.h"
  20 #include "llvm/ADT/SmallSet.h"
  21 #include "llvm/Support/MathExtras.h"
  22 #include "llvm/Support/CrashRecoveryContext.h"
  23
  24 using namespace clang;
  25
  26 namespace {
  27
  28 /// BaseSubobjectInfo - Represents a single base subobject in a complete class.
  29 /// For a class hierarchy like
  30 ///
  31 /// class A { };
  32 /// class B : A { };
  33 /// class C : A, B { };
  34 ///
  35 /// The BaseSubobjectInfo graph for C will have three BaseSubobjectInfo
  36 /// instances, one for B and two for A.
  37 ///
  38 /// If a base is virtual, it will only have one BaseSubobjectInfo allocated.
  39 struct BaseSubobjectInfo {
  40   /// Class - The class for this base info.
  41   const CXXRecordDecl *Class;
  42
  43   /// IsVirtual - Whether the BaseInfo represents a virtual base or not.
  44   bool IsVirtual;
  45
  46   /// Bases - Information about the base subobjects.
  47   SmallVector<BaseSubobjectInfo*, 4> Bases;
  48
  49   /// PrimaryVirtualBaseInfo - Holds the base info for the primary virtual base
  50   /// of this base info (if one exists).
  51   BaseSubobjectInfo *PrimaryVirtualBaseInfo;
  52
  53   // FIXME: Document.
  54   const BaseSubobjectInfo *Derived;
  55 };
  56
  57 /// EmptySubobjectMap - Keeps track of which empty subobjects exist at different
  58 /// offsets while laying out a C++ class.
  59 class EmptySubobjectMap {
  60   const ASTContext &Context;
  61   uint64_t CharWidth;
  62
  63   /// Class - The class whose empty entries we're keeping track of.
  64   const CXXRecordDecl *Class;
  65
  66   /// EmptyClassOffsets - A map from offsets to empty record decls.
  67   typedef SmallVector<const CXXRecordDecl *, 1> ClassVectorTy;
  68   typedef llvm::DenseMap<CharUnits, ClassVectorTy> EmptyClassOffsetsMapTy;
  69   EmptyClassOffsetsMapTy EmptyClassOffsets;
  70
  71   /// MaxEmptyClassOffset - The highest offset known to contain an empty
  72   /// base subobject.
  73   CharUnits MaxEmptyClassOffset;
  74
  75   /// ComputeEmptySubobjectSizes - Compute the size of the largest base or
  76   /// member subobject that is empty.
  77   void ComputeEmptySubobjectSizes();
  78
  79   void AddSubobjectAtOffset(const CXXRecordDecl *RD, CharUnits Offset);
  80
  81   void UpdateEmptyBaseSubobjects(const BaseSubobjectInfo *Info,
  82                                  CharUnits Offset, bool PlacingEmptyBase);
  83
  84   void UpdateEmptyFieldSubobjects(const CXXRecordDecl *RD,
  85                                   const CXXRecordDecl *Class,
  86                                   CharUnits Offset);
  87   void UpdateEmptyFieldSubobjects(const FieldDecl *FD, CharUnits Offset);
  88
  89   /// AnyEmptySubobjectsBeyondOffset - Returns whether there are any empty
  90   /// subobjects beyond the given offset.
  91   bool AnyEmptySubobjectsBeyondOffset(CharUnits Offset) const {
  92     return Offset <= MaxEmptyClassOffset;
  93   }
  94
  95   CharUnits
  96   getFieldOffset(const ASTRecordLayout &Layout, unsigned FieldNo) const {
  97     uint64_t FieldOffset = Layout.getFieldOffset(FieldNo);
  98     assert(FieldOffset % CharWidth == 0 &&
  99            "Field offset not at char boundary!");
 100
 101     return Context.toCharUnitsFromBits(FieldOffset);
 102   }
 103
 104 protected:
 105   bool CanPlaceSubobjectAtOffset(const CXXRecordDecl *RD,
 106                                  CharUnits Offset) const;
 107
 108   bool CanPlaceBaseSubobjectAtOffset(const BaseSubobjectInfo *Info,
 109                                      CharUnits Offset);
 110
 111   bool CanPlaceFieldSubobjectAtOffset(const CXXRecordDecl *RD,
 112                                       const CXXRecordDecl *Class,
 113                                       CharUnits Offset) const;
 114   bool CanPlaceFieldSubobjectAtOffset(const FieldDecl *FD,
 115                                       CharUnits Offset) const;
 116
 117 public:
 118   /// This holds the size of the largest empty subobject (either a base
 119   /// or a member). Will be zero if the record being built doesn't contain
 120   /// any empty classes.
 121   CharUnits SizeOfLargestEmptySubobject;
 122
 123   EmptySubobjectMap(const ASTContext &Context, const CXXRecordDecl *Class)
 124   : Context(Context), CharWidth(Context.getCharWidth()), Class(Class) {
 125       ComputeEmptySubobjectSizes();
 126   }
 127
 128   /// CanPlaceBaseAtOffset - Return whether the given base class can be placed
 129   /// at the given offset.
 130   /// Returns false if placing the record will result in two components
 131   /// (direct or indirect) of the same type having the same offset.
 132   bool CanPlaceBaseAtOffset(const BaseSubobjectInfo *Info,
 133                             CharUnits Offset);
 134
 135   /// CanPlaceFieldAtOffset - Return whether a field can be placed at the given
 136   /// offset.
 137   bool CanPlaceFieldAtOffset(const FieldDecl *FD, CharUnits Offset);
 138 };
 139
 140 void EmptySubobjectMap::ComputeEmptySubobjectSizes() {
 141   // Check the bases.
 142   for (CXXRecordDecl::base_class_const_iterator I = Class->bases_begin(),
 143        E = Class->bases_end(); I != E; ++I) {
 144     const CXXRecordDecl *BaseDecl =
 145       cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
 146
 147     CharUnits EmptySize;
 148     const ASTRecordLayout &Layout = Context.getASTRecordLayout(BaseDecl);
 149     if (BaseDecl->isEmpty()) {
 150       // If the class decl is empty, get its size.
 151       EmptySize = Layout.getSize();
 152     } else {
 153       // Otherwise, we get the largest empty subobject for the decl.
 154       EmptySize = Layout.getSizeOfLargestEmptySubobject();
 155     }
 156
 157     if (EmptySize > SizeOfLargestEmptySubobject)
 158       SizeOfLargestEmptySubobject = EmptySize;
 159   }
 160
 161   // Check the fields.
 162   for (CXXRecordDecl::field_iterator I = Class->field_begin(),
 163        E = Class->field_end(); I != E; ++I) {
 164     const FieldDecl *FD = *I;
 165
 166     const RecordType *RT =
 167       Context.getBaseElementType(FD->getType())->getAs<RecordType>();
 168
 169     // We only care about record types.
 170     if (!RT)
 171       continue;
 172
 173     CharUnits EmptySize;
 174     const CXXRecordDecl *MemberDecl = cast<CXXRecordDecl>(RT->getDecl());
 175     const ASTRecordLayout &Layout = Context.getASTRecordLayout(MemberDecl);
 176     if (MemberDecl->isEmpty()) {
 177       // If the class decl is empty, get its size.
 178       EmptySize = Layout.getSize();
 179     } else {
 180       // Otherwise, we get the largest empty subobject for the decl.
 181       EmptySize = Layout.getSizeOfLargestEmptySubobject();
 182     }
 183
 184     if (EmptySize > SizeOfLargestEmptySubobject)
 185       SizeOfLargestEmptySubobject = EmptySize;
 186   }
 187 }
 188
 189 bool
 190 EmptySubobjectMap::CanPlaceSubobjectAtOffset(const CXXRecordDecl *RD,
 191                                              CharUnits Offset) const {
 192   // We only need to check empty bases.
 193   if (!RD->isEmpty())
 194     return true;
 195
 196   EmptyClassOffsetsMapTy::const_iterator I = EmptyClassOffsets.find(Offset);
 197   if (I == EmptyClassOffsets.end())
 198     return true;
 199
 200   const ClassVectorTy& Classes = I->second;
 201   if (std::find(Classes.begin(), Classes.end(), RD) == Classes.end())
 202     return true;
 203
 204   // There is already an empty class of the same type at this offset.
 205   return false;
 206 }
 207
 208 void EmptySubobjectMap::AddSubobjectAtOffset(const CXXRecordDecl *RD,
 209                                              CharUnits Offset) {
 210   // We only care about empty bases.
 211   if (!RD->isEmpty())
 212     return;
 213
 214   // If we have empty structures inside an union, we can assign both
 215   // the same offset. Just avoid pushing them twice in the list.
 216   ClassVectorTy& Classes = EmptyClassOffsets[Offset];
 217   if (std::find(Classes.begin(), Classes.end(), RD) != Classes.end())
 218     return;
 219
 220   Classes.push_back(RD);
 221
 222   // Update the empty class offset.
 223   if (Offset > MaxEmptyClassOffset)
 224     MaxEmptyClassOffset = Offset;
 225 }
 226
 227 bool
 228 EmptySubobjectMap::CanPlaceBaseSubobjectAtOffset(const BaseSubobjectInfo *Info,
 229                                                  CharUnits Offset) {
 230   // We don't have to keep looking past the maximum offset that's known to
 231   // contain an empty class.
 232   if (!AnyEmptySubobjectsBeyondOffset(Offset))
 233     return true;
 234
 235   if (!CanPlaceSubobjectAtOffset(Info->Class, Offset))
 236     return false;
 237
 238   // Traverse all non-virtual bases.
 239   const ASTRecordLayout &Layout = Context.getASTRecordLayout(Info->Class);
 240   for (unsigned I = 0, E = Info->Bases.size(); I != E; ++I) {
 241     BaseSubobjectInfo* Base = Info->Bases[I];
 242     if (Base->IsVirtual)
 243       continue;
 244
 245     CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(Base->Class);
 246
 247     if (!CanPlaceBaseSubobjectAtOffset(Base, BaseOffset))
 248       return false;
 249   }
 250
 251   if (Info->PrimaryVirtualBaseInfo) {
 252     BaseSubobjectInfo *PrimaryVirtualBaseInfo = Info->PrimaryVirtualBaseInfo;
 253
 254     if (Info == PrimaryVirtualBaseInfo->Derived) {
 255       if (!CanPlaceBaseSubobjectAtOffset(PrimaryVirtualBaseInfo, Offset))
 256         return false;
 257     }
 258   }
 259
 260   // Traverse all member variables.
 261   unsigned FieldNo = 0;
 262   for (CXXRecordDecl::field_iterator I = Info->Class->field_begin(),
 263        E = Info->Class->field_end(); I != E; ++I, ++FieldNo) {
 264     const FieldDecl *FD = *I;
 265     if (FD->isBitField())
 266       continue;
 267
 268     CharUnits FieldOffset = Offset + getFieldOffset(Layout, FieldNo);
 269     if (!CanPlaceFieldSubobjectAtOffset(FD, FieldOffset))
 270       return false;
 271   }
 272
 273   return true;
 274 }
 275
 276 void EmptySubobjectMap::UpdateEmptyBaseSubobjects(const BaseSubobjectInfo *Info,
 277                                                   CharUnits Offset,
 278                                                   bool PlacingEmptyBase) {
 279   if (!PlacingEmptyBase && Offset >= SizeOfLargestEmptySubobject) {
 280     // We know that the only empty subobjects that can conflict with empty
 281     // subobject of non-empty bases, are empty bases that can be placed at
 282     // offset zero. Because of this, we only need to keep track of empty base
 283     // subobjects with offsets less than the size of the largest empty
 284     // subobject for our class.
 285     return;
 286   }
 287
 288   AddSubobjectAtOffset(Info->Class, Offset);
 289
 290   // Traverse all non-virtual bases.
 291   const ASTRecordLayout &Layout = Context.getASTRecordLayout(Info->Class);
 292   for (unsigned I = 0, E = Info->Bases.size(); I != E; ++I) {
 293     BaseSubobjectInfo* Base = Info->Bases[I];
 294     if (Base->IsVirtual)
 295       continue;
 296
 297     CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(Base->Class);
 298     UpdateEmptyBaseSubobjects(Base, BaseOffset, PlacingEmptyBase);
 299   }
 300
 301   if (Info->PrimaryVirtualBaseInfo) {
 302     BaseSubobjectInfo *PrimaryVirtualBaseInfo = Info->PrimaryVirtualBaseInfo;
 303
 304     if (Info == PrimaryVirtualBaseInfo->Derived)
 305       UpdateEmptyBaseSubobjects(PrimaryVirtualBaseInfo, Offset,
 306                                 PlacingEmptyBase);
 307   }
 308
 309   // Traverse all member variables.
 310   unsigned FieldNo = 0;
 311   for (CXXRecordDecl::field_iterator I = Info->Class->field_begin(),
 312        E = Info->Class->field_end(); I != E; ++I, ++FieldNo) {
 313     const FieldDecl *FD = *I;
 314     if (FD->isBitField())
 315       continue;
 316
 317     CharUnits FieldOffset = Offset + getFieldOffset(Layout, FieldNo);
 318     UpdateEmptyFieldSubobjects(FD, FieldOffset);
 319   }
 320 }
 321
 322 bool EmptySubobjectMap::CanPlaceBaseAtOffset(const BaseSubobjectInfo *Info,
 323                                              CharUnits Offset) {
 324   // If we know this class doesn't have any empty subobjects we don't need to
 325   // bother checking.
 326   if (SizeOfLargestEmptySubobject.isZero())
 327     return true;
 328
 329   if (!CanPlaceBaseSubobjectAtOffset(Info, Offset))
 330     return false;
 331
 332   // We are able to place the base at this offset. Make sure to update the
 333   // empty base subobject map.
 334   UpdateEmptyBaseSubobjects(Info, Offset, Info->Class->isEmpty());
 335   return true;
 336 }
 337
 338 bool
 339 EmptySubobjectMap::CanPlaceFieldSubobjectAtOffset(const CXXRecordDecl *RD,
 340                                                   const CXXRecordDecl *Class,
 341                                                   CharUnits Offset) const {
 342   // We don't have to keep looking past the maximum offset that's known to
 343   // contain an empty class.
 344   if (!AnyEmptySubobjectsBeyondOffset(Offset))
 345     return true;
 346
 347   if (!CanPlaceSubobjectAtOffset(RD, Offset))
 348     return false;
 349
 350   const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
 351
 352   // Traverse all non-virtual bases.
 353   for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
 354        E = RD->bases_end(); I != E; ++I) {
 355     if (I->isVirtual())
 356       continue;
 357
 358     const CXXRecordDecl *BaseDecl =
 359       cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
 360
 361     CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(BaseDecl);
 362     if (!CanPlaceFieldSubobjectAtOffset(BaseDecl, Class, BaseOffset))
 363       return false;
 364   }
 365
 366   if (RD == Class) {
 367     // This is the most derived class, traverse virtual bases as well.
 368     for (CXXRecordDecl::base_class_const_iterator I = RD->vbases_begin(),
 369          E = RD->vbases_end(); I != E; ++I) {
 370       const CXXRecordDecl *VBaseDecl =
 371         cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
 372
 373       CharUnits VBaseOffset = Offset + Layout.getVBaseClassOffset(VBaseDecl);
 374       if (!CanPlaceFieldSubobjectAtOffset(VBaseDecl, Class, VBaseOffset))
 375         return false;
 376     }
 377   }
 378
 379   // Traverse all member variables.
 380   unsigned FieldNo = 0;
 381   for (CXXRecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end();
 382        I != E; ++I, ++FieldNo) {
 383     const FieldDecl *FD = *I;
 384     if (FD->isBitField())
 385       continue;
 386
 387     CharUnits FieldOffset = Offset + getFieldOffset(Layout, FieldNo);
 388
 389     if (!CanPlaceFieldSubobjectAtOffset(FD, FieldOffset))
 390       return false;
 391   }
 392
 393   return true;
 394 }
 395
 396 bool
 397 EmptySubobjectMap::CanPlaceFieldSubobjectAtOffset(const FieldDecl *FD,
 398                                                   CharUnits Offset) const {
 399   // We don't have to keep looking past the maximum offset that's known to
 400   // contain an empty class.
 401   if (!AnyEmptySubobjectsBeyondOffset(Offset))
 402     return true;
 403
 404   QualType T = FD->getType();
 405   if (const RecordType *RT = T->getAs<RecordType>()) {
 406     const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
 407     return CanPlaceFieldSubobjectAtOffset(RD, RD, Offset);
 408   }
 409
 410   // If we have an array type we need to look at every element.
 411   if (const ConstantArrayType *AT = Context.getAsConstantArrayType(T)) {
 412     QualType ElemTy = Context.getBaseElementType(AT);
 413     const RecordType *RT = ElemTy->getAs<RecordType>();
 414     if (!RT)
 415       return true;
 416
 417     const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
 418     const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
 419
 420     uint64_t NumElements = Context.getConstantArrayElementCount(AT);
 421     CharUnits ElementOffset = Offset;
 422     for (uint64_t I = 0; I != NumElements; ++I) {
 423       // We don't have to keep looking past the maximum offset that's known to
 424       // contain an empty class.
 425       if (!AnyEmptySubobjectsBeyondOffset(ElementOffset))
 426         return true;
 427
 428       if (!CanPlaceFieldSubobjectAtOffset(RD, RD, ElementOffset))
 429         return false;
 430
 431       ElementOffset += Layout.getSize();
 432     }
 433   }
 434
 435   return true;
 436 }
 437
 438 bool
 439 EmptySubobjectMap::CanPlaceFieldAtOffset(const FieldDecl *FD,
 440                                          CharUnits Offset) {
 441   if (!CanPlaceFieldSubobjectAtOffset(FD, Offset))
 442     return false;
 443
 444   // We are able to place the member variable at this offset.
 445   // Make sure to update the empty base subobject map.
 446   UpdateEmptyFieldSubobjects(FD, Offset);
 447   return true;
 448 }
 449
 450 void EmptySubobjectMap::UpdateEmptyFieldSubobjects(const CXXRecordDecl *RD,
 451                                                    const CXXRecordDecl *Class,
 452                                                    CharUnits Offset) {
 453   // We know that the only empty subobjects that can conflict with empty
 454   // field subobjects are subobjects of empty bases that can be placed at offset
 455   // zero. Because of this, we only need to keep track of empty field
 456   // subobjects with offsets less than the size of the largest empty
 457   // subobject for our class.
 458   if (Offset >= SizeOfLargestEmptySubobject)
 459     return;
 460
 461   AddSubobjectAtOffset(RD, Offset);
 462
 463   const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
 464
 465   // Traverse all non-virtual bases.
 466   for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
 467        E = RD->bases_end(); I != E; ++I) {
 468     if (I->isVirtual())
 469       continue;
 470
 471     const CXXRecordDecl *BaseDecl =
 472       cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
 473
 474     CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(BaseDecl);
 475     UpdateEmptyFieldSubobjects(BaseDecl, Class, BaseOffset);
 476   }
 477
 478   if (RD == Class) {
 479     // This is the most derived class, traverse virtual bases as well.
 480     for (CXXRecordDecl::base_class_const_iterator I = RD->vbases_begin(),
 481          E = RD->vbases_end(); I != E; ++I) {
 482       const CXXRecordDecl *VBaseDecl =
 483       cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
 484
 485       CharUnits VBaseOffset = Offset + Layout.getVBaseClassOffset(VBaseDecl);
 486       UpdateEmptyFieldSubobjects(VBaseDecl, Class, VBaseOffset);
 487     }
 488   }
 489
 490   // Traverse all member variables.
 491   unsigned FieldNo = 0;
 492   for (CXXRecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end();
 493        I != E; ++I, ++FieldNo) {
 494     const FieldDecl *FD = *I;
 495     if (FD->isBitField())
 496       continue;
 497
 498     CharUnits FieldOffset = Offset + getFieldOffset(Layout, FieldNo);
 499
 500     UpdateEmptyFieldSubobjects(FD, FieldOffset);
 501   }
 502 }
 503
 504 void EmptySubobjectMap::UpdateEmptyFieldSubobjects(const FieldDecl *FD,
 505                                                    CharUnits Offset) {
 506   QualType T = FD->getType();
 507   if (const RecordType *RT = T->getAs<RecordType>()) {
 508     const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
 509     UpdateEmptyFieldSubobjects(RD, RD, Offset);
 510     return;
 511   }
 512
 513   // If we have an array type we need to update every element.
 514   if (const ConstantArrayType *AT = Context.getAsConstantArrayType(T)) {
 515     QualType ElemTy = Context.getBaseElementType(AT);
 516     const RecordType *RT = ElemTy->getAs<RecordType>();
 517     if (!RT)
 518       return;
 519
 520     const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
 521     const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
 522
 523     uint64_t NumElements = Context.getConstantArrayElementCount(AT);
 524     CharUnits ElementOffset = Offset;
 525
 526     for (uint64_t I = 0; I != NumElements; ++I) {
 527       // We know that the only empty subobjects that can conflict with empty
 528       // field subobjects are subobjects of empty bases that can be placed at
 529       // offset zero. Because of this, we only need to keep track of empty field
 530       // subobjects with offsets less than the size of the largest empty
 531       // subobject for our class.
 532       if (ElementOffset >= SizeOfLargestEmptySubobject)
 533         return;
 534
 535       UpdateEmptyFieldSubobjects(RD, RD, ElementOffset);
 536       ElementOffset += Layout.getSize();
 537     }
 538   }
 539 }
 540
 541 class RecordLayoutBuilder {
 542 protected:
 543   // FIXME: Remove this and make the appropriate fields public.
 544   friend class clang::ASTContext;
 545
 546   const ASTContext &Context;
 547
 548   EmptySubobjectMap *EmptySubobjects;
 549
 550   /// Size - The current size of the record layout.
 551   uint64_t Size;
 552
 553   /// Alignment - The current alignment of the record layout.
 554   CharUnits Alignment;
 555
 556   /// \brief The alignment if attribute packed is not used.
 557   CharUnits UnpackedAlignment;
 558
 559   SmallVector<uint64_t, 16> FieldOffsets;
 560
 561   /// Packed - Whether the record is packed or not.
 562   unsigned Packed : 1;
 563
 564   unsigned IsUnion : 1;
 565
 566   unsigned IsMac68kAlign : 1;
 567
 568   unsigned IsMsStruct : 1;
 569
 570   /// UnfilledBitsInLastByte - If the last field laid out was a bitfield,
 571   /// this contains the number of bits in the last byte that can be used for
 572   /// an adjacent bitfield if necessary.
 573   unsigned char UnfilledBitsInLastByte;
 574
 575   /// MaxFieldAlignment - The maximum allowed field alignment. This is set by
 576   /// #pragma pack.
 577   CharUnits MaxFieldAlignment;
 578
 579   /// DataSize - The data size of the record being laid out.
 580   uint64_t DataSize;
 581
 582   CharUnits NonVirtualSize;
 583   CharUnits NonVirtualAlignment;
 584
 585   FieldDecl *ZeroLengthBitfield;
 586
 587   /// PrimaryBase - the primary base class (if one exists) of the class
 588   /// we're laying out.
 589   const CXXRecordDecl *PrimaryBase;
 590
 591   /// PrimaryBaseIsVirtual - Whether the primary base of the class we're laying
 592   /// out is virtual.
 593   bool PrimaryBaseIsVirtual;
 594
 595   /// VBPtrOffset - Virtual base table offset. Only for MS layout.
 596   CharUnits VBPtrOffset;
 597
 598   typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetsMapTy;
 599
 600   /// Bases - base classes and their offsets in the record.
 601   BaseOffsetsMapTy Bases;
 602
 603   // VBases - virtual base classes and their offsets in the record.
 604   BaseOffsetsMapTy VBases;
 605
 606   /// IndirectPrimaryBases - Virtual base classes, direct or indirect, that are
 607   /// primary base classes for some other direct or indirect base class.
 608   CXXIndirectPrimaryBaseSet IndirectPrimaryBases;
 609
 610   /// FirstNearlyEmptyVBase - The first nearly empty virtual base class in
 611   /// inheritance graph order. Used for determining the primary base class.
 612   const CXXRecordDecl *FirstNearlyEmptyVBase;
 613
 614   /// VisitedVirtualBases - A set of all the visited virtual bases, used to
 615   /// avoid visiting virtual bases more than once.
 616   llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBases;
 617
 618   RecordLayoutBuilder(const ASTContext &Context, EmptySubobjectMap
 619                       *EmptySubobjects, CharUnits Alignment)
 620     : Context(Context), EmptySubobjects(EmptySubobjects), Size(0),
 621       Alignment(Alignment), UnpackedAlignment(Alignment),
 622       Packed(false), IsUnion(false),
 623       IsMac68kAlign(false), IsMsStruct(false),
 624       UnfilledBitsInLastByte(0), MaxFieldAlignment(CharUnits::Zero()),
 625       DataSize(0), NonVirtualSize(CharUnits::Zero()),
 626       NonVirtualAlignment(CharUnits::One()),
 627       ZeroLengthBitfield(0), PrimaryBase(0),
 628       PrimaryBaseIsVirtual(false), VBPtrOffset(CharUnits::fromQuantity(-1)),
 629       FirstNearlyEmptyVBase(0) { }
 630
 631   void Layout(const RecordDecl *D);
 632   void Layout(const CXXRecordDecl *D);
 633   void Layout(const ObjCInterfaceDecl *D);
 634
 635   void LayoutFields(const RecordDecl *D);
 636   void LayoutField(const FieldDecl *D);
 637   void LayoutWideBitField(uint64_t FieldSize, uint64_t TypeSize,
 638                           bool FieldPacked, const FieldDecl *D);
 639   void LayoutBitField(const FieldDecl *D);
 640   void MSLayoutVirtualBases(const CXXRecordDecl *RD);
 641   void MSLayout(const CXXRecordDecl *RD);
 642
 643   /// BaseSubobjectInfoAllocator - Allocator for BaseSubobjectInfo objects.
 644   llvm::SpecificBumpPtrAllocator<BaseSubobjectInfo> BaseSubobjectInfoAllocator;
 645
 646   typedef llvm::DenseMap<const CXXRecordDecl *, BaseSubobjectInfo *>
 647     BaseSubobjectInfoMapTy;
 648
 649   /// VirtualBaseInfo - Map from all the (direct or indirect) virtual bases
 650   /// of the class we're laying out to their base subobject info.
 651   BaseSubobjectInfoMapTy VirtualBaseInfo;
 652
 653   /// NonVirtualBaseInfo - Map from all the direct non-virtual bases of the
 654   /// class we're laying out to their base subobject info.
 655   BaseSubobjectInfoMapTy NonVirtualBaseInfo;
 656
 657   /// ComputeBaseSubobjectInfo - Compute the base subobject information for the
 658   /// bases of the given class.
 659   void ComputeBaseSubobjectInfo(const CXXRecordDecl *RD);
 660
 661   /// ComputeBaseSubobjectInfo - Compute the base subobject information for a
 662   /// single class and all of its base classes.
 663   BaseSubobjectInfo *ComputeBaseSubobjectInfo(const CXXRecordDecl *RD,
 664                                               bool IsVirtual,
 665                                               BaseSubobjectInfo *Derived);
 666
 667   /// DeterminePrimaryBase - Determine the primary base of the given class.
 668   void DeterminePrimaryBase(const CXXRecordDecl *RD);
 669
 670   void SelectPrimaryVBase(const CXXRecordDecl *RD);
 671
 672   CharUnits GetVirtualPointersSize(const CXXRecordDecl *RD) const;
 673
 674   /// LayoutNonVirtualBases - Determines the primary base class (if any) and
 675   /// lays it out. Will then proceed to lay out all non-virtual base clasess.
 676   void LayoutNonVirtualBases(const CXXRecordDecl *RD);
 677
 678   /// LayoutNonVirtualBase - Lays out a single non-virtual base.
 679   void LayoutNonVirtualBase(const BaseSubobjectInfo *Base);
 680
 681   void AddPrimaryVirtualBaseOffsets(const BaseSubobjectInfo *Info,
 682                                     CharUnits Offset);
 683
 684   /// LayoutVirtualBases - Lays out all the virtual bases.
 685   void LayoutVirtualBases(const CXXRecordDecl *RD,
 686                           const CXXRecordDecl *MostDerivedClass);
 687
 688   /// LayoutVirtualBase - Lays out a single virtual base.
 689   void LayoutVirtualBase(const BaseSubobjectInfo *Base);
 690
 691   /// LayoutBase - Will lay out a base and return the offset where it was
 692   /// placed, in chars.
 693   CharUnits LayoutBase(const BaseSubobjectInfo *Base);
 694
 695   /// InitializeLayout - Initialize record layout for the given record decl.
 696   void InitializeLayout(const Decl *D);
 697
 698   /// FinishLayout - Finalize record layout. Adjust record size based on the
 699   /// alignment.
 700   void FinishLayout(const NamedDecl *D);
 701
 702   void UpdateAlignment(CharUnits NewAlignment, CharUnits UnpackedNewAlignment);
 703   void UpdateAlignment(CharUnits NewAlignment) {
 704     UpdateAlignment(NewAlignment, NewAlignment);
 705   }
 706
 707   void CheckFieldPadding(uint64_t Offset, uint64_t UnpaddedOffset,
 708                           uint64_t UnpackedOffset, unsigned UnpackedAlign,
 709                           bool isPacked, const FieldDecl *D);
 710
 711   DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID);
 712
 713   CharUnits getSize() const {
 714     assert(Size % Context.getCharWidth() == 0);
 715     return Context.toCharUnitsFromBits(Size);
 716   }
 717   uint64_t getSizeInBits() const { return Size; }
 718
 719   void setSize(CharUnits NewSize) { Size = Context.toBits(NewSize); }
 720   void setSize(uint64_t NewSize) { Size = NewSize; }
 721
 722   CharUnits getAligment() const { return Alignment; }
 723
 724   CharUnits getDataSize() const {
 725     assert(DataSize % Context.getCharWidth() == 0);
 726     return Context.toCharUnitsFromBits(DataSize);
 727   }
 728   uint64_t getDataSizeInBits() const { return DataSize; }
 729
 730   void setDataSize(CharUnits NewSize) { DataSize = Context.toBits(NewSize); }
 731   void setDataSize(uint64_t NewSize) { DataSize = NewSize; }
 732
 733   bool HasVBPtr(const CXXRecordDecl *RD) const;
 734   bool HasNewVirtualFunction(const CXXRecordDecl *RD) const;
 735
 736   /// Add vbptr or vfptr to layout.
 737   void AddVPointer();
 738
 739   RecordLayoutBuilder(const RecordLayoutBuilder&);   // DO NOT IMPLEMENT
 740   void operator=(const RecordLayoutBuilder&); // DO NOT IMPLEMENT
 741 public:
 742   static const CXXMethodDecl *ComputeKeyFunction(const CXXRecordDecl *RD);
 743
 744   virtual ~RecordLayoutBuilder() { }
 745
 746   CharUnits GetVBPtrOffset() const { return VBPtrOffset; }
 747 };
 748 } // end anonymous namespace
 749
 750 void
 751 RecordLayoutBuilder::SelectPrimaryVBase(const CXXRecordDecl *RD) {
 752   for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
 753          E = RD->bases_end(); I != E; ++I) {
 754     assert(!I->getType()->isDependentType() &&
 755            "Cannot layout class with dependent bases.");
 756
 757     const CXXRecordDecl *Base =
 758       cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
 759
 760     // Check if this is a nearly empty virtual base.
 761     if (I->isVirtual() && Context.isNearlyEmpty(Base)) {
 762       // If it's not an indirect primary base, then we've found our primary
 763       // base.
 764       if (!IndirectPrimaryBases.count(Base)) {
 765         PrimaryBase = Base;
 766         PrimaryBaseIsVirtual = true;
 767         return;
 768       }
 769
 770       // Is this the first nearly empty virtual base?
 771       if (!FirstNearlyEmptyVBase)
 772         FirstNearlyEmptyVBase = Base;
 773     }
 774
 775     SelectPrimaryVBase(Base);
 776     if (PrimaryBase)
 777       return;
 778   }
 779 }
 780
 781 CharUnits
 782 RecordLayoutBuilder::GetVirtualPointersSize(const CXXRecordDecl *RD) const {
 783   return Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
 784 }
 785
 786 /// DeterminePrimaryBase - Determine the primary base of the given class.
 787 void RecordLayoutBuilder::DeterminePrimaryBase(const CXXRecordDecl *RD) {
 788   // If the class isn't dynamic, it won't have a primary base.
 789   if (!RD->isDynamicClass())
 790     return;
 791
 792   // Compute all the primary virtual bases for all of our direct and
 793   // indirect bases, and record all their primary virtual base classes.
 794   RD->getIndirectPrimaryBases(IndirectPrimaryBases);
 795
 796   // If the record has a dynamic base class, attempt to choose a primary base
 797   // class. It is the first (in direct base class order) non-virtual dynamic
 798   // base class, if one exists.
 799   for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
 800          e = RD->bases_end(); i != e; ++i) {
 801     // Ignore virtual bases.
 802     if (i->isVirtual())
 803       continue;
 804
 805     const CXXRecordDecl *Base =
 806       cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
 807
 808     if (Base->isDynamicClass()) {
 809       // We found it.
 810       PrimaryBase = Base;
 811       PrimaryBaseIsVirtual = false;
 812       return;
 813     }
 814   }
 815
 816   // Otherwise, it is the first nearly empty virtual base that is not an
 817   // indirect primary virtual base class, if one exists.
 818   if (RD->getNumVBases() != 0) {
 819     SelectPrimaryVBase(RD);
 820     if (PrimaryBase)
 821       return;
 822   }
 823
 824   // Otherwise, it is the first nearly empty virtual base that is not an
 825   // indirect primary virtual base class, if one exists.
 826   if (FirstNearlyEmptyVBase) {
 827     PrimaryBase = FirstNearlyEmptyVBase;
 828     PrimaryBaseIsVirtual = true;
 829     return;
 830   }
 831
 832   // Otherwise there is no primary base class.
 833   assert(!PrimaryBase && "Should not get here with a primary base!");
 834
 835   // Allocate the virtual table pointer at offset zero.
 836   assert(DataSize == 0 && "Vtable pointer must be at offset zero!");
 837
 838   // Update the size.
 839   setSize(getSize() + GetVirtualPointersSize(RD));
 840   setDataSize(getSize());
 841
 842   CharUnits UnpackedBaseAlign =
 843     Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerAlign(0));
 844   CharUnits BaseAlign = (Packed) ? CharUnits::One() : UnpackedBaseAlign;
 845
 846   // The maximum field alignment overrides base align.
 847   if (!MaxFieldAlignment.isZero()) {
 848     BaseAlign = std::min(BaseAlign, MaxFieldAlignment);
 849     UnpackedBaseAlign = std::min(UnpackedBaseAlign, MaxFieldAlignment);
 850   }
 851
 852   // Update the alignment.
 853   UpdateAlignment(BaseAlign, UnpackedBaseAlign);
 854 }
 855
 856 BaseSubobjectInfo *
 857 RecordLayoutBuilder::ComputeBaseSubobjectInfo(const CXXRecordDecl *RD,
 858                                               bool IsVirtual,
 859                                               BaseSubobjectInfo *Derived) {
 860   BaseSubobjectInfo *Info;
 861
 862   if (IsVirtual) {
 863     // Check if we already have info about this virtual base.
 864     BaseSubobjectInfo *&InfoSlot = VirtualBaseInfo[RD];
 865     if (InfoSlot) {
 866       assert(InfoSlot->Class == RD && "Wrong class for virtual base info!");
 867       return InfoSlot;
 868     }
 869
 870     // We don't, create it.
 871     InfoSlot = new (BaseSubobjectInfoAllocator.Allocate()) BaseSubobjectInfo;
 872     Info = InfoSlot;
 873   } else {
 874     Info = new (BaseSubobjectInfoAllocator.Allocate()) BaseSubobjectInfo;
 875   }
 876
 877   Info->Class = RD;
 878   Info->IsVirtual = IsVirtual;
 879   Info->Derived = 0;
 880   Info->PrimaryVirtualBaseInfo = 0;
 881
 882   const CXXRecordDecl *PrimaryVirtualBase = 0;
 883   BaseSubobjectInfo *PrimaryVirtualBaseInfo = 0;
 884
 885   // Check if this base has a primary virtual base.
 886   if (RD->getNumVBases()) {
 887     const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
 888     if (Layout.isPrimaryBaseVirtual()) {
 889       // This base does have a primary virtual base.
 890       PrimaryVirtualBase = Layout.getPrimaryBase();
 891       assert(PrimaryVirtualBase && "Didn't have a primary virtual base!");
 892
 893       // Now check if we have base subobject info about this primary base.
 894       PrimaryVirtualBaseInfo = VirtualBaseInfo.lookup(PrimaryVirtualBase);
 895
 896       if (PrimaryVirtualBaseInfo) {
 897         if (PrimaryVirtualBaseInfo->Derived) {
 898           // We did have info about this primary base, and it turns out that it
 899           // has already been claimed as a primary virtual base for another
 900           // base.
 901           PrimaryVirtualBase = 0;
 902         } else {
 903           // We can claim this base as our primary base.
 904           Info->PrimaryVirtualBaseInfo = PrimaryVirtualBaseInfo;
 905           PrimaryVirtualBaseInfo->Derived = Info;
 906         }
 907       }
 908     }
 909   }
 910
 911   // Now go through all direct bases.
 912   for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
 913        E = RD->bases_end(); I != E; ++I) {
 914     bool IsVirtual = I->isVirtual();
 915
 916     const CXXRecordDecl *BaseDecl =
 917       cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
 918
 919     Info->Bases.push_back(ComputeBaseSubobjectInfo(BaseDecl, IsVirtual, Info));
 920   }
 921
 922   if (PrimaryVirtualBase && !PrimaryVirtualBaseInfo) {
 923     // Traversing the bases must have created the base info for our primary
 924     // virtual base.
 925     PrimaryVirtualBaseInfo = VirtualBaseInfo.lookup(PrimaryVirtualBase);
 926     assert(PrimaryVirtualBaseInfo &&
 927            "Did not create a primary virtual base!");
 928
 929     // Claim the primary virtual base as our primary virtual base.
 930     Info->PrimaryVirtualBaseInfo = PrimaryVirtualBaseInfo;
 931     PrimaryVirtualBaseInfo->Derived = Info;
 932   }
 933
 934   return Info;
 935 }
 936
 937 void RecordLayoutBuilder::ComputeBaseSubobjectInfo(const CXXRecordDecl *RD) {
 938   for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
 939        E = RD->bases_end(); I != E; ++I) {
 940     bool IsVirtual = I->isVirtual();
 941
 942     const CXXRecordDecl *BaseDecl =
 943       cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
 944
 945     // Compute the base subobject info for this base.
 946     BaseSubobjectInfo *Info = ComputeBaseSubobjectInfo(BaseDecl, IsVirtual, 0);
 947
 948     if (IsVirtual) {
 949       // ComputeBaseInfo has already added this base for us.
 950       assert(VirtualBaseInfo.count(BaseDecl) &&
 951              "Did not add virtual base!");
 952     } else {
 953       // Add the base info to the map of non-virtual bases.
 954       assert(!NonVirtualBaseInfo.count(BaseDecl) &&
 955              "Non-virtual base already exists!");
 956       NonVirtualBaseInfo.insert(std::make_pair(BaseDecl, Info));
 957     }
 958   }
 959 }
 960
 961 void
 962 RecordLayoutBuilder::LayoutNonVirtualBases(const CXXRecordDecl *RD) {
 963   // Then, determine the primary base class.
 964   DeterminePrimaryBase(RD);
 965
 966   // Compute base subobject info.
 967   ComputeBaseSubobjectInfo(RD);
 968
 969   // If we have a primary base class, lay it out.
 970   if (PrimaryBase) {
 971     if (PrimaryBaseIsVirtual) {
 972       // If the primary virtual base was a primary virtual base of some other
 973       // base class we'll have to steal it.
 974       BaseSubobjectInfo *PrimaryBaseInfo = VirtualBaseInfo.lookup(PrimaryBase);
 975       PrimaryBaseInfo->Derived = 0;
 976
 977       // We have a virtual primary base, insert it as an indirect primary base.
 978       IndirectPrimaryBases.insert(PrimaryBase);
 979
 980       assert(!VisitedVirtualBases.count(PrimaryBase) &&
 981              "vbase already visited!");
 982       VisitedVirtualBases.insert(PrimaryBase);
 983
 984       LayoutVirtualBase(PrimaryBaseInfo);
 985     } else {
 986       BaseSubobjectInfo *PrimaryBaseInfo =
 987         NonVirtualBaseInfo.lookup(PrimaryBase);
 988       assert(PrimaryBaseInfo &&
 989              "Did not find base info for non-virtual primary base!");
 990
 991       LayoutNonVirtualBase(PrimaryBaseInfo);
 992     }
 993   }
 994
 995   // Now lay out the non-virtual bases.
 996   for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
 997          E = RD->bases_end(); I != E; ++I) {
 998
 999     // Ignore virtual bases.
1000     if (I->isVirtual())
1001       continue;
1002
1003     const CXXRecordDecl *BaseDecl =
1004       cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1005
1006     // Skip the primary base.
1007     if (BaseDecl == PrimaryBase && !PrimaryBaseIsVirtual)
1008       continue;
1009
1010     // Lay out the base.
1011     BaseSubobjectInfo *BaseInfo = NonVirtualBaseInfo.lookup(BaseDecl);
1012     assert(BaseInfo && "Did not find base info for non-virtual base!");
1013
1014     LayoutNonVirtualBase(BaseInfo);
1015   }
1016 }
1017
1018 void RecordLayoutBuilder::LayoutNonVirtualBase(const BaseSubobjectInfo *Base) {
1019   // Layout the base.
1020   CharUnits Offset = LayoutBase(Base);
1021
1022   // Add its base class offset.
1023   assert(!Bases.count(Base->Class) && "base offset already exists!");
1024   Bases.insert(std::make_pair(Base->Class, Offset));
1025
1026   AddPrimaryVirtualBaseOffsets(Base, Offset);
1027 }
1028
1029 void
1030 RecordLayoutBuilder::AddPrimaryVirtualBaseOffsets(const BaseSubobjectInfo *Info,
1031                                                   CharUnits Offset) {
1032   // This base isn't interesting, it has no virtual bases.
1033   if (!Info->Class->getNumVBases())
1034     return;
1035
1036   // First, check if we have a virtual primary base to add offsets for.
1037   if (Info->PrimaryVirtualBaseInfo) {
1038     assert(Info->PrimaryVirtualBaseInfo->IsVirtual &&
1039            "Primary virtual base is not virtual!");
1040     if (Info->PrimaryVirtualBaseInfo->Derived == Info) {
1041       // Add the offset.
1042       assert(!VBases.count(Info->PrimaryVirtualBaseInfo->Class) &&
1043              "primary vbase offset already exists!");
1044       VBases.insert(std::make_pair(Info->PrimaryVirtualBaseInfo->Class,
1045                                    Offset));
1046
1047       // Traverse the primary virtual base.
1048       AddPrimaryVirtualBaseOffsets(Info->PrimaryVirtualBaseInfo, Offset);
1049     }
1050   }
1051
1052   // Now go through all direct non-virtual bases.
1053   const ASTRecordLayout &Layout = Context.getASTRecordLayout(Info->Class);
1054   for (unsigned I = 0, E = Info->Bases.size(); I != E; ++I) {
1055     const BaseSubobjectInfo *Base = Info->Bases[I];
1056     if (Base->IsVirtual)
1057       continue;
1058
1059     CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(Base->Class);
1060     AddPrimaryVirtualBaseOffsets(Base, BaseOffset);
1061   }
1062 }
1063
1064 void RecordLayoutBuilder::AddVPointer() {
1065   CharUnits PtrWidth =
1066     Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
1067   setSize(getSize() + PtrWidth);
1068   setDataSize(getSize());
1069
1070   if (Alignment > PtrWidth) {
1071     setSize(getSize() + (Alignment - PtrWidth));
1072     setDataSize(getSize());
1073   }
1074 }
1075
1076 bool
1077 RecordLayoutBuilder::HasNewVirtualFunction(const CXXRecordDecl *RD) const {
1078   for (CXXRecordDecl::method_iterator method = RD->method_begin();
1079        method != RD->method_end();
1080        ++method) {
1081     if (method->isVirtual() &&
1082       !method->size_overridden_methods()) {
1083       return true;
1084     }
1085   }
1086   return false;
1087 }
1088
1089 bool
1090 RecordLayoutBuilder::HasVBPtr(const CXXRecordDecl *RD) const {
1091   if (!RD->getNumBases())
1092     return false;
1093
1094   for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1095        E = RD->bases_end(); I != E; ++I) {
1096     if (!I->isVirtual()) {
1097       return false;
1098     }
1099   }
1100   return true;
1101 }
1102
1103 void
1104 RecordLayoutBuilder::LayoutVirtualBases(const CXXRecordDecl *RD,
1105                                         const CXXRecordDecl *MostDerivedClass) {
1106   const CXXRecordDecl *PrimaryBase;
1107   bool PrimaryBaseIsVirtual;
1108
1109   if (MostDerivedClass == RD) {
1110     PrimaryBase = this->PrimaryBase;
1111     PrimaryBaseIsVirtual = this->PrimaryBaseIsVirtual;
1112   } else {
1113     const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1114     PrimaryBase = Layout.getPrimaryBase();
1115     PrimaryBaseIsVirtual = Layout.isPrimaryBaseVirtual();
1116   }
1117
1118   for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1119          E = RD->bases_end(); I != E; ++I) {
1120     assert(!I->getType()->isDependentType() &&
1121            "Cannot layout class with dependent bases.");
1122
1123     const CXXRecordDecl *BaseDecl =
1124       cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1125
1126     if (I->isVirtual()) {
1127       if (PrimaryBase != BaseDecl || !PrimaryBaseIsVirtual) {
1128         bool IndirectPrimaryBase = IndirectPrimaryBases.count(BaseDecl);
1129
1130         // Only lay out the virtual base if it's not an indirect primary base.
1131         if (!IndirectPrimaryBase) {
1132           // Only visit virtual bases once.
1133           if (!VisitedVirtualBases.insert(BaseDecl))
1134             continue;
1135
1136           const BaseSubobjectInfo *BaseInfo = VirtualBaseInfo.lookup(BaseDecl);
1137           assert(BaseInfo && "Did not find virtual base info!");
1138           LayoutVirtualBase(BaseInfo);
1139         }
1140       }
1141     }
1142
1143     if (!BaseDecl->getNumVBases()) {
1144       // This base isn't interesting since it doesn't have any virtual bases.
1145       continue;
1146     }
1147
1148     LayoutVirtualBases(BaseDecl, MostDerivedClass);
1149   }
1150 }
1151
1152 void RecordLayoutBuilder::LayoutVirtualBase(const BaseSubobjectInfo *Base) {
1153   assert(!Base->Derived && "Trying to lay out a primary virtual base!");
1154
1155   // Layout the base.
1156   CharUnits Offset = LayoutBase(Base);
1157
1158   // Add its base class offset.
1159   assert(!VBases.count(Base->Class) && "vbase offset already exists!");
1160   VBases.insert(std::make_pair(Base->Class, Offset));
1161
1162   AddPrimaryVirtualBaseOffsets(Base, Offset);
1163 }
1164
1165 CharUnits RecordLayoutBuilder::LayoutBase(const BaseSubobjectInfo *Base) {
1166   const ASTRecordLayout &Layout = Context.getASTRecordLayout(Base->Class);
1167
1168   // If we have an empty base class, try to place it at offset 0.
1169   if (Base->Class->isEmpty() &&
1170       EmptySubobjects->CanPlaceBaseAtOffset(Base, CharUnits::Zero())) {
1171     setSize(std::max(getSize(), Layout.getSize()));
1172
1173     return CharUnits::Zero();
1174   }
1175
1176   CharUnits UnpackedBaseAlign = Layout.getNonVirtualAlign();
1177   CharUnits BaseAlign = (Packed) ? CharUnits::One() : UnpackedBaseAlign;
1178
1179   // The maximum field alignment overrides base align.
1180   if (!MaxFieldAlignment.isZero()) {
1181     BaseAlign = std::min(BaseAlign, MaxFieldAlignment);
1182     UnpackedBaseAlign = std::min(UnpackedBaseAlign, MaxFieldAlignment);
1183   }
1184
1185   // Round up the current record size to the base's alignment boundary.
1186   CharUnits Offset = getDataSize().RoundUpToAlignment(BaseAlign);
1187
1188   // Try to place the base.
1189   while (!EmptySubobjects->CanPlaceBaseAtOffset(Base, Offset))
1190     Offset += BaseAlign;
1191
1192   if (!Base->Class->isEmpty()) {
1193     // Update the data size.
1194     setDataSize(Offset + Layout.getNonVirtualSize());
1195
1196     setSize(std::max(getSize(), getDataSize()));
1197   } else
1198     setSize(std::max(getSize(), Offset + Layout.getSize()));
1199
1200   // Remember max struct/class alignment.
1201   UpdateAlignment(BaseAlign, UnpackedBaseAlign);
1202
1203   return Offset;
1204 }
1205
1206 void RecordLayoutBuilder::InitializeLayout(const Decl *D) {
1207   if (const RecordDecl *RD = dyn_cast<RecordDecl>(D))
1208     IsUnion = RD->isUnion();
1209
1210   Packed = D->hasAttr<PackedAttr>();
1211
1212   IsMsStruct = D->hasAttr<MsStructAttr>();
1213
1214   // Honor the default struct packing maximum alignment flag.
1215   if (unsigned DefaultMaxFieldAlignment = Context.getLangOptions().PackStruct) {
1216     MaxFieldAlignment = CharUnits::fromQuantity(DefaultMaxFieldAlignment);
1217   }
1218
1219   // mac68k alignment supersedes maximum field alignment and attribute aligned,
1220   // and forces all structures to have 2-byte alignment. The IBM docs on it
1221   // allude to additional (more complicated) semantics, especially with regard
1222   // to bit-fields, but gcc appears not to follow that.
1223   if (D->hasAttr<AlignMac68kAttr>()) {
1224     IsMac68kAlign = true;
1225     MaxFieldAlignment = CharUnits::fromQuantity(2);
1226     Alignment = CharUnits::fromQuantity(2);
1227   } else {
1228     if (const MaxFieldAlignmentAttr *MFAA = D->getAttr<MaxFieldAlignmentAttr>())
1229       MaxFieldAlignment = Context.toCharUnitsFromBits(MFAA->getAlignment());
1230
1231     if (unsigned MaxAlign = D->getMaxAlignment())
1232       UpdateAlignment(Context.toCharUnitsFromBits(MaxAlign));
1233   }
1234 }
1235
1236 void RecordLayoutBuilder::Layout(const RecordDecl *D) {
1237   InitializeLayout(D);
1238   LayoutFields(D);
1239
1240   // Finally, round the size of the total struct up to the alignment of the
1241   // struct itself.
1242   FinishLayout(D);
1243 }
1244
1245 void RecordLayoutBuilder::Layout(const CXXRecordDecl *RD) {
1246   if (Context.getTargetInfo().getCXXABI() == CXXABI_Microsoft) {
1247     MSLayout(RD);
1248     return ;
1249   }
1250
1251   InitializeLayout(RD);
1252
1253   // Lay out the vtable and the non-virtual bases.
1254   LayoutNonVirtualBases(RD);
1255
1256   LayoutFields(RD);
1257
1258   NonVirtualSize = Context.toCharUnitsFromBits(
1259         llvm::RoundUpToAlignment(getSizeInBits(),
1260                                  Context.getTargetInfo().getCharAlign()));
1261   NonVirtualAlignment = Alignment;
1262
1263   // Lay out the virtual bases and add the primary virtual base offsets.
1264   LayoutVirtualBases(RD, RD);
1265
1266   VisitedVirtualBases.clear();
1267
1268   // Finally, round the size of the total struct up to the alignment of the
1269   // struct itself.
1270   FinishLayout(RD);
1271
1272 #ifndef NDEBUG
1273   // Check that we have base offsets for all bases.
1274   for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1275        E = RD->bases_end(); I != E; ++I) {
1276     if (I->isVirtual())
1277       continue;
1278
1279     const CXXRecordDecl *BaseDecl =
1280       cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1281
1282     assert(Bases.count(BaseDecl) && "Did not find base offset!");
1283   }
1284
1285   // And all virtual bases.
1286   for (CXXRecordDecl::base_class_const_iterator I = RD->vbases_begin(),
1287        E = RD->vbases_end(); I != E; ++I) {
1288     const CXXRecordDecl *BaseDecl =
1289       cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1290
1291     assert(VBases.count(BaseDecl) && "Did not find base offset!");
1292   }
1293 #endif
1294 }
1295
1296 void RecordLayoutBuilder::Layout(const ObjCInterfaceDecl *D) {
1297   if (ObjCInterfaceDecl *SD = D->getSuperClass()) {
1298     const ASTRecordLayout &SL = Context.getASTObjCInterfaceLayout(SD);
1299
1300     UpdateAlignment(SL.getAlignment());
1301
1302     // We start laying out ivars not at the end of the superclass
1303     // structure, but at the next byte following the last field.
1304     setSize(SL.getDataSize());
1305     setDataSize(getSize());
1306   }
1307
1308   InitializeLayout(D);
1309   // Layout each ivar sequentially.
1310   for (const ObjCIvarDecl *IVD = D->all_declared_ivar_begin(); IVD;
1311        IVD = IVD->getNextIvar())
1312     LayoutField(IVD);
1313
1314   // Finally, round the size of the total struct up to the alignment of the
1315   // struct itself.
1316   FinishLayout(D);
1317 }
1318
1319 void RecordLayoutBuilder::LayoutFields(const RecordDecl *D) {
1320   // Layout each field, for now, just sequentially, respecting alignment.  In
1321   // the future, this will need to be tweakable by targets.
1322   const FieldDecl *LastFD = 0;
1323   ZeroLengthBitfield = 0;
1324   unsigned RemainingInAlignment = 0;
1325   for (RecordDecl::field_iterator Field = D->field_begin(),
1326        FieldEnd = D->field_end(); Field != FieldEnd; ++Field) {
1327     if (IsMsStruct) {
1328       FieldDecl *FD =  (*Field);
1329       if (Context.ZeroBitfieldFollowsBitfield(FD, LastFD))
1330         ZeroLengthBitfield = FD;
1331       // Zero-length bitfields following non-bitfield members are
1332       // ignored:
1333       else if (Context.ZeroBitfieldFollowsNonBitfield(FD, LastFD))
1334         continue;
1335       // FIXME. streamline these conditions into a simple one.
1336       else if (Context.BitfieldFollowsBitfield(FD, LastFD) ||
1337                Context.BitfieldFollowsNonBitfield(FD, LastFD) ||
1338                Context.NonBitfieldFollowsBitfield(FD, LastFD)) {
1339         // 1) Adjacent bit fields are packed into the same 1-, 2-, or
1340         // 4-byte allocation unit if the integral types are the same
1341         // size and if the next bit field fits into the current
1342         // allocation unit without crossing the boundary imposed by the
1343         // common alignment requirements of the bit fields.
1344         // 2) Establish a new alignment for a bitfield following
1345         // a non-bitfield if size of their types differ.
1346         // 3) Establish a new alignment for a non-bitfield following
1347         // a bitfield if size of their types differ.
1348         std::pair<uint64_t, unsigned> FieldInfo =
1349           Context.getTypeInfo(FD->getType());
1350         uint64_t TypeSize = FieldInfo.first;
1351         unsigned FieldAlign = FieldInfo.second;
1352         // This check is needed for 'long long' in -m32 mode.
1353         if (TypeSize > FieldAlign)
1354           FieldAlign = TypeSize;
1355         FieldInfo = Context.getTypeInfo(LastFD->getType());
1356         uint64_t TypeSizeLastFD = FieldInfo.first;
1357         unsigned FieldAlignLastFD = FieldInfo.second;
1358         // This check is needed for 'long long' in -m32 mode.
1359         if (TypeSizeLastFD > FieldAlignLastFD)
1360           FieldAlignLastFD = TypeSizeLastFD;
1361
1362         if (TypeSizeLastFD != TypeSize) {
1363           if (RemainingInAlignment &&
1364               LastFD && LastFD->isBitField() &&
1365               LastFD->getBitWidthValue(Context)) {
1366             // If previous field was a bitfield with some remaining unfilled
1367             // bits, pad the field so current field starts on its type boundary.
1368             uint64_t FieldOffset =
1369             getDataSizeInBits() - UnfilledBitsInLastByte;
1370             uint64_t NewSizeInBits = RemainingInAlignment + FieldOffset;
1371             setDataSize(llvm::RoundUpToAlignment(NewSizeInBits,
1372                                                  Context.getTargetInfo().getCharAlign()));
1373             setSize(std::max(getSizeInBits(), getDataSizeInBits()));
1374             RemainingInAlignment = 0;
1375           }
1376
1377           uint64_t UnpaddedFieldOffset =
1378             getDataSizeInBits() - UnfilledBitsInLastByte;
1379           FieldAlign = std::max(FieldAlign, FieldAlignLastFD);
1380
1381           // The maximum field alignment overrides the aligned attribute.
1382           if (!MaxFieldAlignment.isZero()) {
1383             unsigned MaxFieldAlignmentInBits =
1384               Context.toBits(MaxFieldAlignment);
1385             FieldAlign = std::min(FieldAlign, MaxFieldAlignmentInBits);
1386           }
1387
1388           uint64_t NewSizeInBits =
1389             llvm::RoundUpToAlignment(UnpaddedFieldOffset, FieldAlign);
1390           setDataSize(llvm::RoundUpToAlignment(NewSizeInBits,
1391                                                Context.getTargetInfo().getCharAlign()));
1392           UnfilledBitsInLastByte = getDataSizeInBits() - NewSizeInBits;
1393           setSize(std::max(getSizeInBits(), getDataSizeInBits()));
1394         }
1395         if (FD->isBitField()) {
1396           uint64_t FieldSize = FD->getBitWidthValue(Context);
1397           assert (FieldSize > 0 && "LayoutFields - ms_struct layout");
1398           if (RemainingInAlignment < FieldSize)
1399             RemainingInAlignment = TypeSize - FieldSize;
1400           else
1401             RemainingInAlignment -= FieldSize;
1402         }
1403       }
1404       else if (FD->isBitField()) {
1405         uint64_t FieldSize = FD->getBitWidthValue(Context);
1406         std::pair<uint64_t, unsigned> FieldInfo =
1407           Context.getTypeInfo(FD->getType());
1408         uint64_t TypeSize = FieldInfo.first;
1409         RemainingInAlignment = TypeSize - FieldSize;
1410       }
1411       LastFD = FD;
1412     }
1413     else if (!Context.getTargetInfo().useBitFieldTypeAlignment() &&
1414              Context.getTargetInfo().useZeroLengthBitfieldAlignment()) {
1415       FieldDecl *FD =  (*Field);
1416       if (FD->isBitField() && FD->getBitWidthValue(Context) == 0)
1417         ZeroLengthBitfield = FD;
1418     }
1419     LayoutField(*Field);
1420   }
1421   if (IsMsStruct && RemainingInAlignment &&
1422       LastFD && LastFD->isBitField() && LastFD->getBitWidthValue(Context)) {
1423     // If we ended a bitfield before the full length of the type then
1424     // pad the struct out to the full length of the last type.
1425     uint64_t FieldOffset =
1426       getDataSizeInBits() - UnfilledBitsInLastByte;
1427     uint64_t NewSizeInBits = RemainingInAlignment + FieldOffset;
1428     setDataSize(llvm::RoundUpToAlignment(NewSizeInBits,
1429                                          Context.getTargetInfo().getCharAlign()));
1430     setSize(std::max(getSizeInBits(), getDataSizeInBits()));
1431   }
1432 }
1433
1434 void RecordLayoutBuilder::LayoutWideBitField(uint64_t FieldSize,
1435                                              uint64_t TypeSize,
1436                                              bool FieldPacked,
1437                                              const FieldDecl *D) {
1438   assert(Context.getLangOptions().CPlusPlus &&
1439          "Can only have wide bit-fields in C++!");
1440
1441   // Itanium C++ ABI 2.4:
1442   //   If sizeof(T)*8 < n, let T' be the largest integral POD type with
1443   //   sizeof(T')*8 <= n.
1444
1445   QualType IntegralPODTypes[] = {
1446     Context.UnsignedCharTy, Context.UnsignedShortTy, Context.UnsignedIntTy,
1447     Context.UnsignedLongTy, Context.UnsignedLongLongTy
1448   };
1449
1450   QualType Type;
1451   for (unsigned I = 0, E = llvm::array_lengthof(IntegralPODTypes);
1452        I != E; ++I) {
1453     uint64_t Size = Context.getTypeSize(IntegralPODTypes[I]);
1454
1455     if (Size > FieldSize)
1456       break;
1457
1458     Type = IntegralPODTypes[I];
1459   }
1460   assert(!Type.isNull() && "Did not find a type!");
1461
1462   CharUnits TypeAlign = Context.getTypeAlignInChars(Type);
1463
1464   // We're not going to use any of the unfilled bits in the last byte.
1465   UnfilledBitsInLastByte = 0;
1466
1467   uint64_t FieldOffset;
1468   uint64_t UnpaddedFieldOffset = getDataSizeInBits() - UnfilledBitsInLastByte;
1469
1470   if (IsUnion) {
1471     setDataSize(std::max(getDataSizeInBits(), FieldSize));
1472     FieldOffset = 0;
1473   } else {
1474     // The bitfield is allocated starting at the next offset aligned
1475     // appropriately for T', with length n bits.
1476     FieldOffset = llvm::RoundUpToAlignment(getDataSizeInBits(),
1477                                            Context.toBits(TypeAlign));
1478
1479     uint64_t NewSizeInBits = FieldOffset + FieldSize;
1480
1481     setDataSize(llvm::RoundUpToAlignment(NewSizeInBits,
1482                                          Context.getTargetInfo().getCharAlign()));
1483     UnfilledBitsInLastByte = getDataSizeInBits() - NewSizeInBits;
1484   }
1485
1486   // Place this field at the current location.
1487   FieldOffsets.push_back(FieldOffset);
1488
1489   CheckFieldPadding(FieldOffset, UnpaddedFieldOffset, FieldOffset,
1490                     Context.toBits(TypeAlign), FieldPacked, D);
1491
1492   // Update the size.
1493   setSize(std::max(getSizeInBits(), getDataSizeInBits()));
1494
1495   // Remember max struct/class alignment.
1496   UpdateAlignment(TypeAlign);
1497 }
1498
1499 void RecordLayoutBuilder::LayoutBitField(const FieldDecl *D) {
1500   bool FieldPacked = Packed || D->hasAttr<PackedAttr>();
1501   uint64_t UnpaddedFieldOffset = getDataSizeInBits() - UnfilledBitsInLastByte;
1502   uint64_t FieldOffset = IsUnion ? 0 : UnpaddedFieldOffset;
1503   uint64_t FieldSize = D->getBitWidthValue(Context);
1504
1505   std::pair<uint64_t, unsigned> FieldInfo = Context.getTypeInfo(D->getType());
1506   uint64_t TypeSize = FieldInfo.first;
1507   unsigned FieldAlign = FieldInfo.second;
1508
1509   // This check is needed for 'long long' in -m32 mode.
1510   if (IsMsStruct && (TypeSize > FieldAlign))
1511     FieldAlign = TypeSize;
1512
1513   if (ZeroLengthBitfield) {
1514     std::pair<uint64_t, unsigned> FieldInfo;
1515     unsigned ZeroLengthBitfieldAlignment;
1516     if (IsMsStruct) {
1517       // If a zero-length bitfield is inserted after a bitfield,
1518       // and the alignment of the zero-length bitfield is
1519       // greater than the member that follows it, `bar', `bar'
1520       // will be aligned as the type of the zero-length bitfield.
1521       if (ZeroLengthBitfield != D) {
1522         FieldInfo = Context.getTypeInfo(ZeroLengthBitfield->getType());
1523         ZeroLengthBitfieldAlignment = FieldInfo.second;
1524         // Ignore alignment of subsequent zero-length bitfields.
1525         if ((ZeroLengthBitfieldAlignment > FieldAlign) || (FieldSize == 0))
1526           FieldAlign = ZeroLengthBitfieldAlignment;
1527         if (FieldSize)
1528           ZeroLengthBitfield = 0;
1529       }
1530     } else {
1531       // The alignment of a zero-length bitfield affects the alignment
1532       // of the next member.  The alignment is the max of the zero
1533       // length bitfield's alignment and a target specific fixed value.
1534       unsigned ZeroLengthBitfieldBoundary =
1535         Context.getTargetInfo().getZeroLengthBitfieldBoundary();
1536       if (ZeroLengthBitfieldBoundary > FieldAlign)
1537         FieldAlign = ZeroLengthBitfieldBoundary;
1538     }
1539   }
1540
1541   if (FieldSize > TypeSize) {
1542     LayoutWideBitField(FieldSize, TypeSize, FieldPacked, D);
1543     return;
1544   }
1545
1546   // The align if the field is not packed. This is to check if the attribute
1547   // was unnecessary (-Wpacked).
1548   unsigned UnpackedFieldAlign = FieldAlign;
1549   uint64_t UnpackedFieldOffset = FieldOffset;
1550   if (!Context.getTargetInfo().useBitFieldTypeAlignment() && !ZeroLengthBitfield)
1551     UnpackedFieldAlign = 1;
1552
1553   if (FieldPacked ||
1554       (!Context.getTargetInfo().useBitFieldTypeAlignment() && !ZeroLengthBitfield))
1555     FieldAlign = 1;
1556   FieldAlign = std::max(FieldAlign, D->getMaxAlignment());
1557   UnpackedFieldAlign = std::max(UnpackedFieldAlign, D->getMaxAlignment());
1558
1559   // The maximum field alignment overrides the aligned attribute.
1560   if (!MaxFieldAlignment.isZero()) {
1561     unsigned MaxFieldAlignmentInBits = Context.toBits(MaxFieldAlignment);
1562     FieldAlign = std::min(FieldAlign, MaxFieldAlignmentInBits);
1563     UnpackedFieldAlign = std::min(UnpackedFieldAlign, MaxFieldAlignmentInBits);
1564   }
1565
1566   // Check if we need to add padding to give the field the correct alignment.
1567   if (FieldSize == 0 || (FieldOffset & (FieldAlign-1)) + FieldSize > TypeSize)
1568     FieldOffset = llvm::RoundUpToAlignment(FieldOffset, FieldAlign);
1569
1570   if (FieldSize == 0 ||
1571       (UnpackedFieldOffset & (UnpackedFieldAlign-1)) + FieldSize > TypeSize)
1572     UnpackedFieldOffset = llvm::RoundUpToAlignment(UnpackedFieldOffset,
1573                                                    UnpackedFieldAlign);
1574
1575   // Padding members don't affect overall alignment, unless zero length bitfield
1576   // alignment is enabled.
1577   if (!D->getIdentifier() && !Context.getTargetInfo().useZeroLengthBitfieldAlignment())
1578     FieldAlign = UnpackedFieldAlign = 1;
1579
1580   if (!IsMsStruct)
1581     ZeroLengthBitfield = 0;
1582
1583   // Place this field at the current location.
1584   FieldOffsets.push_back(FieldOffset);
1585
1586   CheckFieldPadding(FieldOffset, UnpaddedFieldOffset, UnpackedFieldOffset,
1587                     UnpackedFieldAlign, FieldPacked, D);
1588
1589   // Update DataSize to include the last byte containing (part of) the bitfield.
1590   if (IsUnion) {
1591     // FIXME: I think FieldSize should be TypeSize here.
1592     setDataSize(std::max(getDataSizeInBits(), FieldSize));
1593   } else {
1594     uint64_t NewSizeInBits = FieldOffset + FieldSize;
1595
1596     setDataSize(llvm::RoundUpToAlignment(NewSizeInBits,
1597                                          Context.getTargetInfo().getCharAlign()));
1598     UnfilledBitsInLastByte = getDataSizeInBits() - NewSizeInBits;
1599   }
1600
1601   // Update the size.
1602   setSize(std::max(getSizeInBits(), getDataSizeInBits()));
1603
1604   // Remember max struct/class alignment.
1605   UpdateAlignment(Context.toCharUnitsFromBits(FieldAlign),
1606                   Context.toCharUnitsFromBits(UnpackedFieldAlign));
1607 }
1608
1609 void RecordLayoutBuilder::LayoutField(const FieldDecl *D) {
1610   if (D->isBitField()) {
1611     LayoutBitField(D);
1612     return;
1613   }
1614
1615   uint64_t UnpaddedFieldOffset = getDataSizeInBits() - UnfilledBitsInLastByte;
1616
1617   // Reset the unfilled bits.
1618   UnfilledBitsInLastByte = 0;
1619
1620   bool FieldPacked = Packed || D->hasAttr<PackedAttr>();
1621   CharUnits FieldOffset =
1622     IsUnion ? CharUnits::Zero() : getDataSize();
1623   CharUnits FieldSize;
1624   CharUnits FieldAlign;
1625
1626   if (D->getType()->isIncompleteArrayType()) {
1627     // This is a flexible array member; we can't directly
1628     // query getTypeInfo about these, so we figure it out here.
1629     // Flexible array members don't have any size, but they
1630     // have to be aligned appropriately for their element type.
1631     FieldSize = CharUnits::Zero();
1632     const ArrayType* ATy = Context.getAsArrayType(D->getType());
1633     FieldAlign = Context.getTypeAlignInChars(ATy->getElementType());
1634   } else if (const ReferenceType *RT = D->getType()->getAs<ReferenceType>()) {
1635     unsigned AS = RT->getPointeeType().getAddressSpace();
1636     FieldSize =
1637       Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(AS));
1638     FieldAlign =
1639       Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerAlign(AS));
1640   } else {
1641     std::pair<CharUnits, CharUnits> FieldInfo =
1642       Context.getTypeInfoInChars(D->getType());
1643     FieldSize = FieldInfo.first;
1644     FieldAlign = FieldInfo.second;
1645
1646     if (ZeroLengthBitfield) {
1647       CharUnits ZeroLengthBitfieldBoundary =
1648         Context.toCharUnitsFromBits(
1649           Context.getTargetInfo().getZeroLengthBitfieldBoundary());
1650       if (ZeroLengthBitfieldBoundary == CharUnits::Zero()) {
1651         // If a zero-length bitfield is inserted after a bitfield,
1652         // and the alignment of the zero-length bitfield is
1653         // greater than the member that follows it, `bar', `bar'
1654         // will be aligned as the type of the zero-length bitfield.
1655         std::pair<CharUnits, CharUnits> FieldInfo =
1656           Context.getTypeInfoInChars(ZeroLengthBitfield->getType());
1657         CharUnits ZeroLengthBitfieldAlignment = FieldInfo.second;
1658         if (ZeroLengthBitfieldAlignment > FieldAlign)
1659           FieldAlign = ZeroLengthBitfieldAlignment;
1660       } else if (ZeroLengthBitfieldBoundary > FieldAlign) {
1661         // Align 'bar' based on a fixed alignment specified by the target.
1662         assert(Context.getTargetInfo().useZeroLengthBitfieldAlignment() &&
1663                "ZeroLengthBitfieldBoundary should only be used in conjunction"
1664                " with useZeroLengthBitfieldAlignment.");
1665         FieldAlign = ZeroLengthBitfieldBoundary;
1666       }
1667       ZeroLengthBitfield = 0;
1668     }
1669
1670     if (Context.getLangOptions().MSBitfields || IsMsStruct) {
1671       // If MS bitfield layout is required, figure out what type is being
1672       // laid out and align the field to the width of that type.
1673
1674       // Resolve all typedefs down to their base type and round up the field
1675       // alignment if necessary.
1676       QualType T = Context.getBaseElementType(D->getType());
1677       if (const BuiltinType *BTy = T->getAs<BuiltinType>()) {
1678         CharUnits TypeSize = Context.getTypeSizeInChars(BTy);
1679         if (TypeSize > FieldAlign)
1680           FieldAlign = TypeSize;
1681       }
1682     }
1683   }
1684
1685   // The align if the field is not packed. This is to check if the attribute
1686   // was unnecessary (-Wpacked).
1687   CharUnits UnpackedFieldAlign = FieldAlign;
1688   CharUnits UnpackedFieldOffset = FieldOffset;
1689
1690   if (FieldPacked)
1691     FieldAlign = CharUnits::One();
1692   CharUnits MaxAlignmentInChars =
1693     Context.toCharUnitsFromBits(D->getMaxAlignment());
1694   FieldAlign = std::max(FieldAlign, MaxAlignmentInChars);
1695   UnpackedFieldAlign = std::max(UnpackedFieldAlign, MaxAlignmentInChars);
1696
1697   // The maximum field alignment overrides the aligned attribute.
1698   if (!MaxFieldAlignment.isZero()) {
1699     FieldAlign = std::min(FieldAlign, MaxFieldAlignment);
1700     UnpackedFieldAlign = std::min(UnpackedFieldAlign, MaxFieldAlignment);
1701   }
1702
1703   // Round up the current record size to the field's alignment boundary.
1704   FieldOffset = FieldOffset.RoundUpToAlignment(FieldAlign);
1705   UnpackedFieldOffset =
1706     UnpackedFieldOffset.RoundUpToAlignment(UnpackedFieldAlign);
1707
1708   if (!IsUnion && EmptySubobjects) {
1709     // Check if we can place the field at this offset.
1710     while (!EmptySubobjects->CanPlaceFieldAtOffset(D, FieldOffset)) {
1711       // We couldn't place the field at the offset. Try again at a new offset.
1712       FieldOffset += FieldAlign;
1713     }
1714   }
1715
1716   // Place this field at the current location.
1717   FieldOffsets.push_back(Context.toBits(FieldOffset));
1718
1719   CheckFieldPadding(Context.toBits(FieldOffset), UnpaddedFieldOffset,
1720                     Context.toBits(UnpackedFieldOffset),
1721                     Context.toBits(UnpackedFieldAlign), FieldPacked, D);
1722
1723   // Reserve space for this field.
1724   uint64_t FieldSizeInBits = Context.toBits(FieldSize);
1725   if (IsUnion)
1726     setSize(std::max(getSizeInBits(), FieldSizeInBits));
1727   else
1728     setSize(FieldOffset + FieldSize);
1729
1730   // Update the data size.
1731   setDataSize(getSizeInBits());
1732
1733   // Remember max struct/class alignment.
1734   UpdateAlignment(FieldAlign, UnpackedFieldAlign);
1735 }
1736
1737 void RecordLayoutBuilder::MSLayoutVirtualBases(const CXXRecordDecl *RD) {
1738
1739   if (!RD->getNumVBases())
1740     return;
1741
1742   for (CXXRecordDecl::base_class_const_iterator I = RD->vbases_begin(),
1743        E = RD->vbases_end(); I != E; ++I) {
1744
1745     const CXXRecordDecl* BaseDecl = I->getType()->getAsCXXRecordDecl();
1746     const BaseSubobjectInfo* BaseInfo = VirtualBaseInfo.lookup(BaseDecl);
1747
1748     assert(BaseInfo && "Did not find virtual base info!");
1749
1750     LayoutVirtualBase(BaseInfo);
1751   }
1752 }
1753
1754 void RecordLayoutBuilder::MSLayout(const CXXRecordDecl *RD) {
1755
1756   bool IsVBPtrAddedToLayout = false;
1757
1758   InitializeLayout(RD);
1759
1760   if (HasVBPtr(RD)) {
1761     // If all bases are virtual and the class declares a new virtual function,
1762     // MSVC builds a vfptr.
1763     if (HasNewVirtualFunction(RD)) {
1764       AddVPointer();
1765     }
1766
1767     VBPtrOffset = getSize();
1768     AddVPointer();
1769     IsVBPtrAddedToLayout = true;
1770
1771     ComputeBaseSubobjectInfo(RD);
1772   } else {
1773     LayoutNonVirtualBases(RD);
1774   }
1775
1776   if (RD->getNumVBases() &&
1777       !IsVBPtrAddedToLayout) {
1778     // Add vbptr.
1779     VBPtrOffset = getSize();
1780     AddVPointer();
1781   }
1782
1783   LayoutFields(RD);
1784
1785   NonVirtualSize = Context.toCharUnitsFromBits(
1786                            llvm::RoundUpToAlignment(getSizeInBits(),
1787                            Context.getTargetInfo().getCharAlign()));
1788   NonVirtualAlignment = Alignment;
1789
1790   if (NonVirtualSize != NonVirtualSize.RoundUpToAlignment(Alignment)) {
1791     CharUnits AlignMember =
1792       NonVirtualSize.RoundUpToAlignment(Alignment) - NonVirtualSize;
1793
1794     setSize(getSize() + AlignMember);
1795     setDataSize(getSize());
1796
1797     NonVirtualSize = Context.toCharUnitsFromBits(
1798                              llvm::RoundUpToAlignment(getSizeInBits(),
1799                              Context.getTargetInfo().getCharAlign()));
1800   }
1801
1802   MSLayoutVirtualBases(RD);
1803
1804   VisitedVirtualBases.clear();
1805
1806   // Finally, round the size of the total struct up to the alignment of the
1807   // struct itself.
1808   if (!RD->getNumVBases())
1809     FinishLayout(RD);
1810
1811 #ifndef NDEBUG
1812   // Check that we have base offsets for all bases.
1813   for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1814     E = RD->bases_end(); I != E; ++I) {
1815       if (I->isVirtual())
1816         continue;
1817
1818       const CXXRecordDecl *BaseDecl =
1819         cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1820
1821       assert(Bases.count(BaseDecl) && "Did not find base offset!");
1822   }
1823
1824   // And all virtual bases.
1825   for (CXXRecordDecl::base_class_const_iterator I = RD->vbases_begin(),
1826     E = RD->vbases_end(); I != E; ++I) {
1827       const CXXRecordDecl *BaseDecl =
1828         cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1829
1830       assert(VBases.count(BaseDecl) && "Did not find base offset!");
1831   }
1832 #endif
1833 }
1834
1835 void RecordLayoutBuilder::FinishLayout(const NamedDecl *D) {
1836   // In C++, records cannot be of size 0.
1837   if (Context.getLangOptions().CPlusPlus && getSizeInBits() == 0) {
1838     if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
1839       // Compatibility with gcc requires a class (pod or non-pod)
1840       // which is not empty but of size 0; such as having fields of
1841       // array of zero-length, remains of Size 0
1842       if (RD->isEmpty())
1843         setSize(CharUnits::One());
1844     }
1845     else
1846       setSize(CharUnits::One());
1847   }
1848   // Finally, round the size of the record up to the alignment of the
1849   // record itself.
1850   uint64_t UnpaddedSize = getSizeInBits() - UnfilledBitsInLastByte;
1851   uint64_t UnpackedSizeInBits =
1852     llvm::RoundUpToAlignment(getSizeInBits(),
1853                              Context.toBits(UnpackedAlignment));
1854   CharUnits UnpackedSize = Context.toCharUnitsFromBits(UnpackedSizeInBits);
1855   setSize(llvm::RoundUpToAlignment(getSizeInBits(), Context.toBits(Alignment)));
1856
1857   unsigned CharBitNum = Context.getTargetInfo().getCharWidth();
1858   if (const RecordDecl *RD = dyn_cast<RecordDecl>(D)) {
1859     // Warn if padding was introduced to the struct/class/union.
1860     if (getSizeInBits() > UnpaddedSize) {
1861       unsigned PadSize = getSizeInBits() - UnpaddedSize;
1862       bool InBits = true;
1863       if (PadSize % CharBitNum == 0) {
1864         PadSize = PadSize / CharBitNum;
1865         InBits = false;
1866       }
1867       Diag(RD->getLocation(), diag::warn_padded_struct_size)
1868           << Context.getTypeDeclType(RD)
1869           << PadSize
1870           << (InBits ? 1 : 0) /*(byte|bit)*/ << (PadSize > 1); // plural or not
1871     }
1872
1873     // Warn if we packed it unnecessarily. If the alignment is 1 byte don't
1874     // bother since there won't be alignment issues.
1875     if (Packed && UnpackedAlignment > CharUnits::One() &&
1876         getSize() == UnpackedSize)
1877       Diag(D->getLocation(), diag::warn_unnecessary_packed)
1878           << Context.getTypeDeclType(RD);
1879   }
1880 }
1881
1882 void RecordLayoutBuilder::UpdateAlignment(CharUnits NewAlignment,
1883                                           CharUnits UnpackedNewAlignment) {
1884   // The alignment is not modified when using 'mac68k' alignment.
1885   if (IsMac68kAlign)
1886     return;
1887
1888   if (NewAlignment > Alignment) {
1889     assert(llvm::isPowerOf2_32(NewAlignment.getQuantity() &&
1890            "Alignment not a power of 2"));
1891     Alignment = NewAlignment;
1892   }
1893
1894   if (UnpackedNewAlignment > UnpackedAlignment) {
1895     assert(llvm::isPowerOf2_32(UnpackedNewAlignment.getQuantity() &&
1896            "Alignment not a power of 2"));
1897     UnpackedAlignment = UnpackedNewAlignment;
1898   }
1899 }
1900
1901 void RecordLayoutBuilder::CheckFieldPadding(uint64_t Offset,
1902                                             uint64_t UnpaddedOffset,
1903                                             uint64_t UnpackedOffset,
1904                                             unsigned UnpackedAlign,
1905                                             bool isPacked,
1906                                             const FieldDecl *D) {
1907   // We let objc ivars without warning, objc interfaces generally are not used
1908   // for padding tricks.
1909   if (isa<ObjCIvarDecl>(D))
1910     return;
1911
1912   // Don't warn about structs created without a SourceLocation.  This can
1913   // be done by clients of the AST, such as codegen.
1914   if (D->getLocation().isInvalid())
1915     return;
1916
1917   unsigned CharBitNum = Context.getTargetInfo().getCharWidth();
1918
1919   // Warn if padding was introduced to the struct/class.
1920   if (!IsUnion && Offset > UnpaddedOffset) {
1921     unsigned PadSize = Offset - UnpaddedOffset;
1922     bool InBits = true;
1923     if (PadSize % CharBitNum == 0) {
1924       PadSize = PadSize / CharBitNum;
1925       InBits = false;
1926     }
1927     if (D->getIdentifier())
1928       Diag(D->getLocation(), diag::warn_padded_struct_field)
1929           << (D->getParent()->isStruct() ? 0 : 1) // struct|class
1930           << Context.getTypeDeclType(D->getParent())
1931           << PadSize
1932           << (InBits ? 1 : 0) /*(byte|bit)*/ << (PadSize > 1) // plural or not
1933           << D->getIdentifier();
1934     else
1935       Diag(D->getLocation(), diag::warn_padded_struct_anon_field)
1936           << (D->getParent()->isStruct() ? 0 : 1) // struct|class
1937           << Context.getTypeDeclType(D->getParent())
1938           << PadSize
1939           << (InBits ? 1 : 0) /*(byte|bit)*/ << (PadSize > 1); // plural or not
1940   }
1941
1942   // Warn if we packed it unnecessarily. If the alignment is 1 byte don't
1943   // bother since there won't be alignment issues.
1944   if (isPacked && UnpackedAlign > CharBitNum && Offset == UnpackedOffset)
1945     Diag(D->getLocation(), diag::warn_unnecessary_packed)
1946         << D->getIdentifier();
1947 }
1948
1949 const CXXMethodDecl *
1950 RecordLayoutBuilder::ComputeKeyFunction(const CXXRecordDecl *RD) {
1951   // If a class isn't polymorphic it doesn't have a key function.
1952   if (!RD->isPolymorphic())
1953     return 0;
1954
1955   // A class that is not externally visible doesn't have a key function. (Or
1956   // at least, there's no point to assigning a key function to such a class;
1957   // this doesn't affect the ABI.)
1958   if (RD->getLinkage() != ExternalLinkage)
1959     return 0;
1960
1961   // Template instantiations don't have key functions,see Itanium C++ ABI 5.2.6.
1962   // Same behavior as GCC.
1963   TemplateSpecializationKind TSK = RD->getTemplateSpecializationKind();
1964   if (TSK == TSK_ImplicitInstantiation ||
1965       TSK == TSK_ExplicitInstantiationDefinition)
1966     return 0;
1967
1968   for (CXXRecordDecl::method_iterator I = RD->method_begin(),
1969          E = RD->method_end(); I != E; ++I) {
1970     const CXXMethodDecl *MD = *I;
1971
1972     if (!MD->isVirtual())
1973       continue;
1974
1975     if (MD->isPure())
1976       continue;
1977
1978     // Ignore implicit member functions, they are always marked as inline, but
1979     // they don't have a body until they're defined.
1980     if (MD->isImplicit())
1981       continue;
1982
1983     if (MD->isInlineSpecified())
1984       continue;
1985
1986     if (MD->hasInlineBody())
1987       continue;
1988
1989     // We found it.
1990     return MD;
1991   }
1992
1993   return 0;
1994 }
1995
1996 DiagnosticBuilder
1997 RecordLayoutBuilder::Diag(SourceLocation Loc, unsigned DiagID) {
1998   return Context.getDiagnostics().Report(Loc, DiagID);
1999 }
2000
2001 /// getASTRecordLayout - Get or compute information about the layout of the
2002 /// specified record (struct/union/class), which indicates its size and field
2003 /// position information.
2004 const ASTRecordLayout &
2005 ASTContext::getASTRecordLayout(const RecordDecl *D) const {
2006   // These asserts test different things.  A record has a definition
2007   // as soon as we begin to parse the definition.  That definition is
2008   // not a complete definition (which is what isDefinition() tests)
2009   // until we *finish* parsing the definition.
2010   D = D->getDefinition();
2011   assert(D && "Cannot get layout of forward declarations!");
2012   assert(D->isCompleteDefinition() && "Cannot layout type before complete!");
2013
2014   // Look up this layout, if already laid out, return what we have.
2015   // Note that we can't save a reference to the entry because this function
2016   // is recursive.
2017   const ASTRecordLayout *Entry = ASTRecordLayouts[D];
2018   if (Entry) return *Entry;
2019
2020   const ASTRecordLayout *NewEntry;
2021
2022   if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
2023     EmptySubobjectMap EmptySubobjects(*this, RD);
2024
2025     llvm::OwningPtr<RecordLayoutBuilder> Builder;
2026     CharUnits TargetAlign = CharUnits::One();
2027
2028     Builder.reset(new RecordLayoutBuilder(*this,
2029                                           &EmptySubobjects,
2030                                           TargetAlign));
2031
2032     // Recover resources if we crash before exiting this method.
2033     llvm::CrashRecoveryContextCleanupRegistrar<RecordLayoutBuilder>
2034       RecordBuilderCleanup(Builder.get());
2035
2036     Builder->Layout(RD);
2037
2038     TargetAlign = Builder->getAligment();
2039
2040     if (getTargetInfo().getCXXABI() == CXXABI_Microsoft &&
2041         TargetAlign.getQuantity() > 4) {
2042       // MSVC rounds the vtable pointer to the struct alignment in what must
2043       // be a multi-pass operation. For now, let the builder figure out the
2044       // alignment and recalculate the layout once its known.
2045       Builder.reset(new RecordLayoutBuilder(*this,
2046                                             &EmptySubobjects,
2047                                             TargetAlign));
2048
2049       Builder->Layout(RD);
2050
2051       // Recover resources if we crash before exiting this method.
2052       llvm::CrashRecoveryContextCleanupRegistrar<RecordLayoutBuilder>
2053         RecordBuilderCleanup(Builder.get());
2054     }
2055
2056     // FIXME: This is not always correct. See the part about bitfields at
2057     // http://www.codesourcery.com/public/cxx-abi/abi.html#POD for more info.
2058     // FIXME: IsPODForThePurposeOfLayout should be stored in the record layout.
2059     // This does not affect the calculations of MSVC layouts
2060     bool IsPODForThePurposeOfLayout =
2061       (getTargetInfo().getCXXABI() == CXXABI_Microsoft) ||
2062       cast<CXXRecordDecl>(D)->isPOD();
2063
2064     // FIXME: This should be done in FinalizeLayout.
2065     CharUnits DataSize =
2066       IsPODForThePurposeOfLayout ? Builder->getSize() : Builder->getDataSize();
2067     CharUnits NonVirtualSize =
2068       IsPODForThePurposeOfLayout ? DataSize : Builder->NonVirtualSize;
2069
2070     NewEntry =
2071       new (*this) ASTRecordLayout(*this, Builder->getSize(),
2072                                   Builder->Alignment,
2073                                   Builder->GetVBPtrOffset(),
2074                                   DataSize,
2075                                   Builder->FieldOffsets.data(),
2076                                   Builder->FieldOffsets.size(),
2077                                   NonVirtualSize,
2078                                   Builder->NonVirtualAlignment,
2079                                   EmptySubobjects.SizeOfLargestEmptySubobject,
2080                                   Builder->PrimaryBase,
2081                                   Builder->PrimaryBaseIsVirtual,
2082                                   Builder->Bases, Builder->VBases);
2083   } else {
2084     RecordLayoutBuilder Builder(*this, /*EmptySubobjects=*/0, CharUnits::One());
2085     Builder.Layout(D);
2086
2087     NewEntry =
2088       new (*this) ASTRecordLayout(*this, Builder.getSize(),
2089                                   Builder.Alignment,
2090                                   Builder.getSize(),
2091                                   Builder.FieldOffsets.data(),
2092                                   Builder.FieldOffsets.size());
2093   }
2094
2095   ASTRecordLayouts[D] = NewEntry;
2096
2097   if (getLangOptions().DumpRecordLayouts) {
2098     llvm::errs() << "\n*** Dumping AST Record Layout\n";
2099     DumpRecordLayout(D, llvm::errs());
2100   }
2101
2102   return *NewEntry;
2103 }
2104
2105 const CXXMethodDecl *ASTContext::getKeyFunction(const CXXRecordDecl *RD) {
2106   RD = cast<CXXRecordDecl>(RD->getDefinition());
2107   assert(RD && "Cannot get key function for forward declarations!");
2108
2109   const CXXMethodDecl *&Entry = KeyFunctions[RD];
2110   if (!Entry)
2111     Entry = RecordLayoutBuilder::ComputeKeyFunction(RD);
2112
2113   return Entry;
2114 }
2115
2116 /// getObjCLayout - Get or compute information about the layout of the
2117 /// given interface.
2118 ///
2119 /// \param Impl - If given, also include the layout of the interface's
2120 /// implementation. This may differ by including synthesized ivars.
2121 const ASTRecordLayout &
2122 ASTContext::getObjCLayout(const ObjCInterfaceDecl *D,
2123                           const ObjCImplementationDecl *Impl) const {
2124   assert(!D->isForwardDecl() && "Invalid interface decl!");
2125
2126   // Look up this layout, if already laid out, return what we have.
2127   ObjCContainerDecl *Key =
2128     Impl ? (ObjCContainerDecl*) Impl : (ObjCContainerDecl*) D;
2129   if (const ASTRecordLayout *Entry = ObjCLayouts[Key])
2130     return *Entry;
2131
2132   // Add in synthesized ivar count if laying out an implementation.
2133   if (Impl) {
2134     unsigned SynthCount = CountNonClassIvars(D);
2135     // If there aren't any sythesized ivars then reuse the interface
2136     // entry. Note we can't cache this because we simply free all
2137     // entries later; however we shouldn't look up implementations
2138     // frequently.
2139     if (SynthCount == 0)
2140       return getObjCLayout(D, 0);
2141   }
2142
2143   RecordLayoutBuilder Builder(*this, /*EmptySubobjects=*/0, CharUnits::One());
2144   Builder.Layout(D);
2145
2146   const ASTRecordLayout *NewEntry =
2147     new (*this) ASTRecordLayout(*this, Builder.getSize(),
2148                                 Builder.Alignment,
2149                                 Builder.getDataSize(),
2150                                 Builder.FieldOffsets.data(),
2151                                 Builder.FieldOffsets.size());
2152
2153   ObjCLayouts[Key] = NewEntry;
2154
2155   return *NewEntry;
2156 }
2157
2158 static void PrintOffset(raw_ostream &OS,
2159                         CharUnits Offset, unsigned IndentLevel) {
2160   OS << llvm::format("%4d | ", Offset.getQuantity());
2161   OS.indent(IndentLevel * 2);
2162 }
2163
2164 static void DumpCXXRecordLayout(raw_ostream &OS,
2165                                 const CXXRecordDecl *RD, const ASTContext &C,
2166                                 CharUnits Offset,
2167                                 unsigned IndentLevel,
2168                                 const char* Description,
2169                                 bool IncludeVirtualBases) {
2170   const ASTRecordLayout &Layout = C.getASTRecordLayout(RD);
2171
2172   PrintOffset(OS, Offset, IndentLevel);
2173   OS << C.getTypeDeclType(const_cast<CXXRecordDecl *>(RD)).getAsString();
2174   if (Description)
2175     OS << ' ' << Description;
2176   if (RD->isEmpty())
2177     OS << " (empty)";
2178   OS << '\n';
2179
2180   IndentLevel++;
2181
2182   const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
2183   bool HasVbptr = Layout.getVBPtrOffset() != CharUnits::fromQuantity(-1);
2184
2185   // Vtable pointer.
2186   if (RD->isDynamicClass() && !PrimaryBase) {
2187     PrintOffset(OS, Offset, IndentLevel);
2188     OS << '(' << *RD << " vtable pointer)\n";
2189   }
2190
2191   if (HasVbptr && !PrimaryBase) {
2192     PrintOffset(OS, Offset + Layout.getVBPtrOffset(), IndentLevel);
2193     OS << '(' << *RD << " vbtable pointer)\n";
2194
2195     // one vbtable per class
2196     HasVbptr = false;
2197   }
2198
2199   // Dump (non-virtual) bases
2200   for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
2201          E = RD->bases_end(); I != E; ++I) {
2202     assert(!I->getType()->isDependentType() &&
2203            "Cannot layout class with dependent bases.");
2204     if (I->isVirtual())
2205       continue;
2206
2207     const CXXRecordDecl *Base =
2208       cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
2209
2210     CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(Base);
2211
2212     DumpCXXRecordLayout(OS, Base, C, BaseOffset, IndentLevel,
2213                         Base == PrimaryBase ? "(primary base)" : "(base)",
2214                         /*IncludeVirtualBases=*/false);
2215   }
2216   // vbptr
2217   if (HasVbptr) {
2218     PrintOffset(OS, Offset + Layout.getVBPtrOffset(), IndentLevel);
2219     OS << '(' << *RD << " vbtable pointer)\n";
2220   }
2221
2222   // Dump fields.
2223   uint64_t FieldNo = 0;
2224   for (CXXRecordDecl::field_iterator I = RD->field_begin(),
2225          E = RD->field_end(); I != E; ++I, ++FieldNo) {
2226     const FieldDecl *Field = *I;
2227     CharUnits FieldOffset = Offset +
2228       C.toCharUnitsFromBits(Layout.getFieldOffset(FieldNo));
2229
2230     if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
2231       if (const CXXRecordDecl *D = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
2232         DumpCXXRecordLayout(OS, D, C, FieldOffset, IndentLevel,
2233                             Field->getName().data(),
2234                             /*IncludeVirtualBases=*/true);
2235         continue;
2236       }
2237     }
2238
2239     PrintOffset(OS, FieldOffset, IndentLevel);
2240     OS << Field->getType().getAsString() << ' ' << *Field << '\n';
2241   }
2242
2243   if (!IncludeVirtualBases)
2244     return;
2245
2246   // Dump virtual bases.
2247   for (CXXRecordDecl::base_class_const_iterator I = RD->vbases_begin(),
2248          E = RD->vbases_end(); I != E; ++I) {
2249     assert(I->isVirtual() && "Found non-virtual class!");
2250     const CXXRecordDecl *VBase =
2251       cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
2252
2253     CharUnits VBaseOffset = Offset + Layout.getVBaseClassOffset(VBase);
2254     DumpCXXRecordLayout(OS, VBase, C, VBaseOffset, IndentLevel,
2255                         VBase == PrimaryBase ?
2256                         "(primary virtual base)" : "(virtual base)",
2257                         /*IncludeVirtualBases=*/false);
2258   }
2259
2260   OS << "  sizeof=" << Layout.getSize().getQuantity();
2261   OS << ", dsize=" << Layout.getDataSize().getQuantity();
2262   OS << ", align=" << Layout.getAlignment().getQuantity() << '\n';
2263   OS << "  nvsize=" << Layout.getNonVirtualSize().getQuantity();
2264   OS << ", nvalign=" << Layout.getNonVirtualAlign().getQuantity() << '\n';
2265   OS << '\n';
2266 }
2267
2268 void ASTContext::DumpRecordLayout(const RecordDecl *RD,
2269                                   raw_ostream &OS) const {
2270   const ASTRecordLayout &Info = getASTRecordLayout(RD);
2271
2272   if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
2273     return DumpCXXRecordLayout(OS, CXXRD, *this, CharUnits(), 0, 0,
2274                                /*IncludeVirtualBases=*/true);
2275
2276   OS << "Type: " << getTypeDeclType(RD).getAsString() << "\n";
2277   OS << "Record: ";
2278   RD->dump();
2279   OS << "\nLayout: ";
2280   OS << "<ASTRecordLayout\n";
2281   OS << "  Size:" << toBits(Info.getSize()) << "\n";
2282   OS << "  DataSize:" << toBits(Info.getDataSize()) << "\n";
2283   OS << "  Alignment:" << toBits(Info.getAlignment()) << "\n";
2284   OS << "  FieldOffsets: [";
2285   for (unsigned i = 0, e = Info.getFieldCount(); i != e; ++i) {
2286     if (i) OS << ", ";
2287     OS << Info.getFieldOffset(i);
2288   }
2289   OS << "]>\n";
2290 }