brintos / llvm-project-archived public Read only

1//=== RecordLayoutBuilder.cpp - Helper class for building record layouts ---==//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#include "clang/AST/ASTContext.h"10#include "clang/AST/ASTDiagnostic.h"11#include "clang/AST/Attr.h"12#include "clang/AST/CXXInheritance.h"13#include "clang/AST/Decl.h"14#include "clang/AST/DeclCXX.h"15#include "clang/AST/DeclObjC.h"16#include "clang/AST/Expr.h"17#include "clang/AST/RecordLayout.h"18#include "clang/AST/VTableBuilder.h"19#include "clang/Basic/TargetInfo.h"20#include "llvm/Support/Format.h"21#include "llvm/Support/MathExtras.h"22 23using namespace clang;24 25namespace {26 27/// BaseSubobjectInfo - Represents a single base subobject in a complete class.28/// For a class hierarchy like29///30/// class A { };31/// class B : A { };32/// class C : A, B { };33///34/// The BaseSubobjectInfo graph for C will have three BaseSubobjectInfo35/// instances, one for B and two for A.36///37/// If a base is virtual, it will only have one BaseSubobjectInfo allocated.38struct BaseSubobjectInfo {39  /// Class - The class for this base info.40  const CXXRecordDecl *Class;41 42  /// IsVirtual - Whether the BaseInfo represents a virtual base or not.43  bool IsVirtual;44 45  /// Bases - Information about the base subobjects.46  SmallVector<BaseSubobjectInfo*, 4> Bases;47 48  /// PrimaryVirtualBaseInfo - Holds the base info for the primary virtual base49  /// of this base info (if one exists).50  BaseSubobjectInfo *PrimaryVirtualBaseInfo;51 52  // FIXME: Document.53  const BaseSubobjectInfo *Derived;54};55 56/// Externally provided layout. Typically used when the AST source, such57/// as DWARF, lacks all the information that was available at compile time, such58/// as alignment attributes on fields and pragmas in effect.59struct ExternalLayout {60  ExternalLayout() = default;61 62  /// Overall record size in bits.63  uint64_t Size = 0;64 65  /// Overall record alignment in bits.66  uint64_t Align = 0;67 68  /// Record field offsets in bits.69  llvm::DenseMap<const FieldDecl *, uint64_t> FieldOffsets;70 71  /// Direct, non-virtual base offsets.72  llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsets;73 74  /// Virtual base offsets.75  llvm::DenseMap<const CXXRecordDecl *, CharUnits> VirtualBaseOffsets;76 77  /// Get the offset of the given field. The external source must provide78  /// entries for all fields in the record.79  uint64_t getExternalFieldOffset(const FieldDecl *FD) {80    assert(FieldOffsets.count(FD) &&81           "Field does not have an external offset");82    return FieldOffsets[FD];83  }84 85  bool getExternalNVBaseOffset(const CXXRecordDecl *RD, CharUnits &BaseOffset) {86    auto Known = BaseOffsets.find(RD);87    if (Known == BaseOffsets.end())88      return false;89    BaseOffset = Known->second;90    return true;91  }92 93  bool getExternalVBaseOffset(const CXXRecordDecl *RD, CharUnits &BaseOffset) {94    auto Known = VirtualBaseOffsets.find(RD);95    if (Known == VirtualBaseOffsets.end())96      return false;97    BaseOffset = Known->second;98    return true;99  }100};101 102/// EmptySubobjectMap - Keeps track of which empty subobjects exist at different103/// offsets while laying out a C++ class.104class EmptySubobjectMap {105  const ASTContext &Context;106  uint64_t CharWidth;107 108  /// Class - The class whose empty entries we're keeping track of.109  const CXXRecordDecl *Class;110 111  /// EmptyClassOffsets - A map from offsets to empty record decls.112  typedef llvm::TinyPtrVector<const CXXRecordDecl *> ClassVectorTy;113  typedef llvm::DenseMap<CharUnits, ClassVectorTy> EmptyClassOffsetsMapTy;114  EmptyClassOffsetsMapTy EmptyClassOffsets;115 116  /// MaxEmptyClassOffset - The highest offset known to contain an empty117  /// base subobject.118  CharUnits MaxEmptyClassOffset;119 120  /// ComputeEmptySubobjectSizes - Compute the size of the largest base or121  /// member subobject that is empty.122  void ComputeEmptySubobjectSizes();123 124  void AddSubobjectAtOffset(const CXXRecordDecl *RD, CharUnits Offset);125 126  void UpdateEmptyBaseSubobjects(const BaseSubobjectInfo *Info,127                                 CharUnits Offset, bool PlacingEmptyBase);128 129  void UpdateEmptyFieldSubobjects(const CXXRecordDecl *RD,130                                  const CXXRecordDecl *Class, CharUnits Offset,131                                  bool PlacingOverlappingField);132  void UpdateEmptyFieldSubobjects(const FieldDecl *FD, CharUnits Offset,133                                  bool PlacingOverlappingField);134 135  /// AnyEmptySubobjectsBeyondOffset - Returns whether there are any empty136  /// subobjects beyond the given offset.137  bool AnyEmptySubobjectsBeyondOffset(CharUnits Offset) const {138    return Offset <= MaxEmptyClassOffset;139  }140 141  CharUnits getFieldOffset(const ASTRecordLayout &Layout,142                           const FieldDecl *Field) const {143    uint64_t FieldOffset = Layout.getFieldOffset(Field->getFieldIndex());144    assert(FieldOffset % CharWidth == 0 &&145           "Field offset not at char boundary!");146 147    return Context.toCharUnitsFromBits(FieldOffset);148  }149 150protected:151  bool CanPlaceSubobjectAtOffset(const CXXRecordDecl *RD,152                                 CharUnits Offset) const;153 154  bool CanPlaceBaseSubobjectAtOffset(const BaseSubobjectInfo *Info,155                                     CharUnits Offset);156 157  bool CanPlaceFieldSubobjectAtOffset(const CXXRecordDecl *RD,158                                      const CXXRecordDecl *Class,159                                      CharUnits Offset) const;160  bool CanPlaceFieldSubobjectAtOffset(const FieldDecl *FD,161                                      CharUnits Offset) const;162 163public:164  /// This holds the size of the largest empty subobject (either a base165  /// or a member). Will be zero if the record being built doesn't contain166  /// any empty classes.167  CharUnits SizeOfLargestEmptySubobject;168 169  EmptySubobjectMap(const ASTContext &Context, const CXXRecordDecl *Class)170  : Context(Context), CharWidth(Context.getCharWidth()), Class(Class) {171      ComputeEmptySubobjectSizes();172  }173 174  /// CanPlaceBaseAtOffset - Return whether the given base class can be placed175  /// at the given offset.176  /// Returns false if placing the record will result in two components177  /// (direct or indirect) of the same type having the same offset.178  bool CanPlaceBaseAtOffset(const BaseSubobjectInfo *Info,179                            CharUnits Offset);180 181  /// CanPlaceFieldAtOffset - Return whether a field can be placed at the given182  /// offset.183  bool CanPlaceFieldAtOffset(const FieldDecl *FD, CharUnits Offset);184};185 186void EmptySubobjectMap::ComputeEmptySubobjectSizes() {187  // Check the bases.188  for (const CXXBaseSpecifier &Base : Class->bases()) {189    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();190    assert(BaseDecl != Class && "Class cannot inherit from itself.");191 192    CharUnits EmptySize;193    const ASTRecordLayout &Layout = Context.getASTRecordLayout(BaseDecl);194    if (BaseDecl->isEmpty()) {195      // If the class decl is empty, get its size.196      EmptySize = Layout.getSize();197    } else {198      // Otherwise, we get the largest empty subobject for the decl.199      EmptySize = Layout.getSizeOfLargestEmptySubobject();200    }201 202    if (EmptySize > SizeOfLargestEmptySubobject)203      SizeOfLargestEmptySubobject = EmptySize;204  }205 206  // Check the fields.207  for (const FieldDecl *FD : Class->fields()) {208    // We only care about records.209    const auto *MemberDecl =210        Context.getBaseElementType(FD->getType())->getAsCXXRecordDecl();211    if (!MemberDecl)212      continue;213 214    CharUnits EmptySize;215    const ASTRecordLayout &Layout = Context.getASTRecordLayout(MemberDecl);216    if (MemberDecl->isEmpty()) {217      // If the class decl is empty, get its size.218      EmptySize = Layout.getSize();219    } else {220      // Otherwise, we get the largest empty subobject for the decl.221      EmptySize = Layout.getSizeOfLargestEmptySubobject();222    }223 224    if (EmptySize > SizeOfLargestEmptySubobject)225      SizeOfLargestEmptySubobject = EmptySize;226  }227}228 229bool230EmptySubobjectMap::CanPlaceSubobjectAtOffset(const CXXRecordDecl *RD,231                                             CharUnits Offset) const {232  // We only need to check empty bases.233  if (!RD->isEmpty())234    return true;235 236  EmptyClassOffsetsMapTy::const_iterator I = EmptyClassOffsets.find(Offset);237  if (I == EmptyClassOffsets.end())238    return true;239 240  const ClassVectorTy &Classes = I->second;241  if (!llvm::is_contained(Classes, RD))242    return true;243 244  // There is already an empty class of the same type at this offset.245  return false;246}247 248void EmptySubobjectMap::AddSubobjectAtOffset(const CXXRecordDecl *RD,249                                             CharUnits Offset) {250  // We only care about empty bases.251  if (!RD->isEmpty())252    return;253 254  // If we have empty structures inside a union, we can assign both255  // the same offset. Just avoid pushing them twice in the list.256  ClassVectorTy &Classes = EmptyClassOffsets[Offset];257  if (llvm::is_contained(Classes, RD))258    return;259 260  Classes.push_back(RD);261 262  // Update the empty class offset.263  if (Offset > MaxEmptyClassOffset)264    MaxEmptyClassOffset = Offset;265}266 267bool268EmptySubobjectMap::CanPlaceBaseSubobjectAtOffset(const BaseSubobjectInfo *Info,269                                                 CharUnits Offset) {270  // We don't have to keep looking past the maximum offset that's known to271  // contain an empty class.272  if (!AnyEmptySubobjectsBeyondOffset(Offset))273    return true;274 275  if (!CanPlaceSubobjectAtOffset(Info->Class, Offset))276    return false;277 278  // Traverse all non-virtual bases.279  const ASTRecordLayout &Layout = Context.getASTRecordLayout(Info->Class);280  for (const BaseSubobjectInfo *Base : Info->Bases) {281    if (Base->IsVirtual)282      continue;283 284    CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(Base->Class);285 286    if (!CanPlaceBaseSubobjectAtOffset(Base, BaseOffset))287      return false;288  }289 290  if (Info->PrimaryVirtualBaseInfo) {291    BaseSubobjectInfo *PrimaryVirtualBaseInfo = Info->PrimaryVirtualBaseInfo;292 293    if (Info == PrimaryVirtualBaseInfo->Derived) {294      if (!CanPlaceBaseSubobjectAtOffset(PrimaryVirtualBaseInfo, Offset))295        return false;296    }297  }298 299  // Traverse all member variables.300  for (const FieldDecl *Field : Info->Class->fields()) {301    if (Field->isBitField())302      continue;303 304    CharUnits FieldOffset = Offset + getFieldOffset(Layout, Field);305    if (!CanPlaceFieldSubobjectAtOffset(Field, FieldOffset))306      return false;307  }308 309  return true;310}311 312void EmptySubobjectMap::UpdateEmptyBaseSubobjects(const BaseSubobjectInfo *Info,313                                                  CharUnits Offset,314                                                  bool PlacingEmptyBase) {315  if (!PlacingEmptyBase && Offset >= SizeOfLargestEmptySubobject) {316    // We know that the only empty subobjects that can conflict with empty317    // subobject of non-empty bases, are empty bases that can be placed at318    // offset zero. Because of this, we only need to keep track of empty base319    // subobjects with offsets less than the size of the largest empty320    // subobject for our class.321    return;322  }323 324  AddSubobjectAtOffset(Info->Class, Offset);325 326  // Traverse all non-virtual bases.327  const ASTRecordLayout &Layout = Context.getASTRecordLayout(Info->Class);328  for (const BaseSubobjectInfo *Base : Info->Bases) {329    if (Base->IsVirtual)330      continue;331 332    CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(Base->Class);333    UpdateEmptyBaseSubobjects(Base, BaseOffset, PlacingEmptyBase);334  }335 336  if (Info->PrimaryVirtualBaseInfo) {337    BaseSubobjectInfo *PrimaryVirtualBaseInfo = Info->PrimaryVirtualBaseInfo;338 339    if (Info == PrimaryVirtualBaseInfo->Derived)340      UpdateEmptyBaseSubobjects(PrimaryVirtualBaseInfo, Offset,341                                PlacingEmptyBase);342  }343 344  // Traverse all member variables.345  for (const FieldDecl *Field : Info->Class->fields()) {346    if (Field->isBitField())347      continue;348 349    CharUnits FieldOffset = Offset + getFieldOffset(Layout, Field);350    UpdateEmptyFieldSubobjects(Field, FieldOffset, PlacingEmptyBase);351  }352}353 354bool EmptySubobjectMap::CanPlaceBaseAtOffset(const BaseSubobjectInfo *Info,355                                             CharUnits Offset) {356  // If we know this class doesn't have any empty subobjects we don't need to357  // bother checking.358  if (SizeOfLargestEmptySubobject.isZero())359    return true;360 361  if (!CanPlaceBaseSubobjectAtOffset(Info, Offset))362    return false;363 364  // We are able to place the base at this offset. Make sure to update the365  // empty base subobject map.366  UpdateEmptyBaseSubobjects(Info, Offset, Info->Class->isEmpty());367  return true;368}369 370bool371EmptySubobjectMap::CanPlaceFieldSubobjectAtOffset(const CXXRecordDecl *RD,372                                                  const CXXRecordDecl *Class,373                                                  CharUnits Offset) const {374  // We don't have to keep looking past the maximum offset that's known to375  // contain an empty class.376  if (!AnyEmptySubobjectsBeyondOffset(Offset))377    return true;378 379  if (!CanPlaceSubobjectAtOffset(RD, Offset))380    return false;381 382  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);383 384  // Traverse all non-virtual bases.385  for (const CXXBaseSpecifier &Base : RD->bases()) {386    if (Base.isVirtual())387      continue;388 389    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();390 391    CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(BaseDecl);392    if (!CanPlaceFieldSubobjectAtOffset(BaseDecl, Class, BaseOffset))393      return false;394  }395 396  if (RD == Class) {397    // This is the most derived class, traverse virtual bases as well.398    for (const CXXBaseSpecifier &Base : RD->vbases()) {399      const CXXRecordDecl *VBaseDecl = Base.getType()->getAsCXXRecordDecl();400 401      CharUnits VBaseOffset = Offset + Layout.getVBaseClassOffset(VBaseDecl);402      if (!CanPlaceFieldSubobjectAtOffset(VBaseDecl, Class, VBaseOffset))403        return false;404    }405  }406 407  // Traverse all member variables.408  for (const FieldDecl *Field : RD->fields()) {409    if (Field->isBitField())410      continue;411 412    CharUnits FieldOffset = Offset + getFieldOffset(Layout, Field);413    if (!CanPlaceFieldSubobjectAtOffset(Field, FieldOffset))414      return false;415  }416 417  return true;418}419 420bool421EmptySubobjectMap::CanPlaceFieldSubobjectAtOffset(const FieldDecl *FD,422                                                  CharUnits Offset) const {423  // We don't have to keep looking past the maximum offset that's known to424  // contain an empty class.425  if (!AnyEmptySubobjectsBeyondOffset(Offset))426    return true;427 428  QualType T = FD->getType();429  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())430    return CanPlaceFieldSubobjectAtOffset(RD, RD, Offset);431 432  // If we have an array type we need to look at every element.433  if (const ConstantArrayType *AT = Context.getAsConstantArrayType(T)) {434    QualType ElemTy = Context.getBaseElementType(AT);435    const auto *RD = ElemTy->getAsCXXRecordDecl();436    if (!RD)437      return true;438 439    const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);440 441    uint64_t NumElements = Context.getConstantArrayElementCount(AT);442    CharUnits ElementOffset = Offset;443    for (uint64_t I = 0; I != NumElements; ++I) {444      // We don't have to keep looking past the maximum offset that's known to445      // contain an empty class.446      if (!AnyEmptySubobjectsBeyondOffset(ElementOffset))447        return true;448 449      if (!CanPlaceFieldSubobjectAtOffset(RD, RD, ElementOffset))450        return false;451 452      ElementOffset += Layout.getSize();453    }454  }455 456  return true;457}458 459bool EmptySubobjectMap::CanPlaceFieldAtOffset(const FieldDecl *FD,460                                              CharUnits Offset) {461  if (!CanPlaceFieldSubobjectAtOffset(FD, Offset))462    return false;463 464  // We are able to place the member variable at this offset.465  // Make sure to update the empty field subobject map.466  UpdateEmptyFieldSubobjects(FD, Offset, FD->hasAttr<NoUniqueAddressAttr>());467  return true;468}469 470void EmptySubobjectMap::UpdateEmptyFieldSubobjects(471    const CXXRecordDecl *RD, const CXXRecordDecl *Class, CharUnits Offset,472    bool PlacingOverlappingField) {473  // We know that the only empty subobjects that can conflict with empty474  // field subobjects are subobjects of empty bases and potentially-overlapping475  // fields that can be placed at offset zero. Because of this, we only need to476  // keep track of empty field subobjects with offsets less than the size of477  // the largest empty subobject for our class.478  //479  // (Proof: we will only consider placing a subobject at offset zero or at480  // >= the current dsize. The only cases where the earlier subobject can be481  // placed beyond the end of dsize is if it's an empty base or a482  // potentially-overlapping field.)483  if (!PlacingOverlappingField && Offset >= SizeOfLargestEmptySubobject)484    return;485 486  AddSubobjectAtOffset(RD, Offset);487 488  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);489 490  // Traverse all non-virtual bases.491  for (const CXXBaseSpecifier &Base : RD->bases()) {492    if (Base.isVirtual())493      continue;494 495    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();496 497    CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(BaseDecl);498    UpdateEmptyFieldSubobjects(BaseDecl, Class, BaseOffset,499                               PlacingOverlappingField);500  }501 502  if (RD == Class) {503    // This is the most derived class, traverse virtual bases as well.504    for (const CXXBaseSpecifier &Base : RD->vbases()) {505      const CXXRecordDecl *VBaseDecl = Base.getType()->getAsCXXRecordDecl();506 507      CharUnits VBaseOffset = Offset + Layout.getVBaseClassOffset(VBaseDecl);508      UpdateEmptyFieldSubobjects(VBaseDecl, Class, VBaseOffset,509                                 PlacingOverlappingField);510    }511  }512 513  // Traverse all member variables.514  for (const FieldDecl *Field : RD->fields()) {515    if (Field->isBitField())516      continue;517 518    CharUnits FieldOffset = Offset + getFieldOffset(Layout, Field);519    UpdateEmptyFieldSubobjects(Field, FieldOffset, PlacingOverlappingField);520  }521}522 523void EmptySubobjectMap::UpdateEmptyFieldSubobjects(524    const FieldDecl *FD, CharUnits Offset, bool PlacingOverlappingField) {525  QualType T = FD->getType();526  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl()) {527    UpdateEmptyFieldSubobjects(RD, RD, Offset, PlacingOverlappingField);528    return;529  }530 531  // If we have an array type we need to update every element.532  if (const ConstantArrayType *AT = Context.getAsConstantArrayType(T)) {533    QualType ElemTy = Context.getBaseElementType(AT);534    const auto *RD = ElemTy->getAsCXXRecordDecl();535    if (!RD)536      return;537 538    const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);539 540    uint64_t NumElements = Context.getConstantArrayElementCount(AT);541    CharUnits ElementOffset = Offset;542 543    for (uint64_t I = 0; I != NumElements; ++I) {544      // We know that the only empty subobjects that can conflict with empty545      // field subobjects are subobjects of empty bases that can be placed at546      // offset zero. Because of this, we only need to keep track of empty field547      // subobjects with offsets less than the size of the largest empty548      // subobject for our class.549      if (!PlacingOverlappingField &&550          ElementOffset >= SizeOfLargestEmptySubobject)551        return;552 553      UpdateEmptyFieldSubobjects(RD, RD, ElementOffset,554                                 PlacingOverlappingField);555      ElementOffset += Layout.getSize();556    }557  }558}559 560typedef llvm::SmallPtrSet<const CXXRecordDecl*, 4> ClassSetTy;561 562class ItaniumRecordLayoutBuilder {563protected:564  // FIXME: Remove this and make the appropriate fields public.565  friend class clang::ASTContext;566 567  const ASTContext &Context;568 569  EmptySubobjectMap *EmptySubobjects;570 571  /// Size - The current size of the record layout.572  uint64_t Size;573 574  /// Alignment - The current alignment of the record layout.575  CharUnits Alignment;576 577  /// PreferredAlignment - The preferred alignment of the record layout.578  CharUnits PreferredAlignment;579 580  /// The alignment if attribute packed is not used.581  CharUnits UnpackedAlignment;582 583  /// \brief The maximum of the alignments of top-level members.584  CharUnits UnadjustedAlignment;585 586  SmallVector<uint64_t, 16> FieldOffsets;587 588  /// Whether the external AST source has provided a layout for this589  /// record.590  LLVM_PREFERRED_TYPE(bool)591  unsigned UseExternalLayout : 1;592 593  /// Whether we need to infer alignment, even when we have an594  /// externally-provided layout.595  LLVM_PREFERRED_TYPE(bool)596  unsigned InferAlignment : 1;597 598  /// Packed - Whether the record is packed or not.599  LLVM_PREFERRED_TYPE(bool)600  unsigned Packed : 1;601 602  LLVM_PREFERRED_TYPE(bool)603  unsigned IsUnion : 1;604 605  LLVM_PREFERRED_TYPE(bool)606  unsigned IsMac68kAlign : 1;607 608  LLVM_PREFERRED_TYPE(bool)609  unsigned IsNaturalAlign : 1;610 611  LLVM_PREFERRED_TYPE(bool)612  unsigned IsMsStruct : 1;613 614  /// UnfilledBitsInLastUnit - If the last field laid out was a bitfield,615  /// this contains the number of bits in the last unit that can be used for616  /// an adjacent bitfield if necessary.  The unit in question is usually617  /// a byte, but larger units are used if IsMsStruct.618  unsigned char UnfilledBitsInLastUnit;619 620  /// LastBitfieldStorageUnitSize - If IsMsStruct, represents the size of the621  /// storage unit of the previous field if it was a bitfield.622  unsigned char LastBitfieldStorageUnitSize;623 624  /// MaxFieldAlignment - The maximum allowed field alignment. This is set by625  /// #pragma pack.626  CharUnits MaxFieldAlignment;627 628  /// DataSize - The data size of the record being laid out.629  uint64_t DataSize;630 631  CharUnits NonVirtualSize;632  CharUnits NonVirtualAlignment;633  CharUnits PreferredNVAlignment;634 635  /// If we've laid out a field but not included its tail padding in Size yet,636  /// this is the size up to the end of that field.637  CharUnits PaddedFieldSize;638 639  /// PrimaryBase - the primary base class (if one exists) of the class640  /// we're laying out.641  const CXXRecordDecl *PrimaryBase;642 643  /// PrimaryBaseIsVirtual - Whether the primary base of the class we're laying644  /// out is virtual.645  bool PrimaryBaseIsVirtual;646 647  /// HasOwnVFPtr - Whether the class provides its own vtable/vftbl648  /// pointer, as opposed to inheriting one from a primary base class.649  bool HasOwnVFPtr;650 651  /// the flag of field offset changing due to packed attribute.652  bool HasPackedField;653 654  /// HandledFirstNonOverlappingEmptyField - An auxiliary field used for AIX.655  /// When there are OverlappingEmptyFields existing in the aggregate, the656  /// flag shows if the following first non-empty or empty-but-non-overlapping657  /// field has been handled, if any.658  bool HandledFirstNonOverlappingEmptyField;659 660  typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetsMapTy;661 662  /// Bases - base classes and their offsets in the record.663  BaseOffsetsMapTy Bases;664 665  // VBases - virtual base classes and their offsets in the record.666  ASTRecordLayout::VBaseOffsetsMapTy VBases;667 668  /// IndirectPrimaryBases - Virtual base classes, direct or indirect, that are669  /// primary base classes for some other direct or indirect base class.670  CXXIndirectPrimaryBaseSet IndirectPrimaryBases;671 672  /// FirstNearlyEmptyVBase - The first nearly empty virtual base class in673  /// inheritance graph order. Used for determining the primary base class.674  const CXXRecordDecl *FirstNearlyEmptyVBase;675 676  /// VisitedVirtualBases - A set of all the visited virtual bases, used to677  /// avoid visiting virtual bases more than once.678  llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBases;679 680  /// Valid if UseExternalLayout is true.681  ExternalLayout External;682 683  ItaniumRecordLayoutBuilder(const ASTContext &Context,684                             EmptySubobjectMap *EmptySubobjects)685      : Context(Context), EmptySubobjects(EmptySubobjects), Size(0),686        Alignment(CharUnits::One()), PreferredAlignment(CharUnits::One()),687        UnpackedAlignment(CharUnits::One()),688        UnadjustedAlignment(CharUnits::One()), UseExternalLayout(false),689        InferAlignment(false), Packed(false), IsUnion(false),690        IsMac68kAlign(false),691        IsNaturalAlign(!Context.getTargetInfo().getTriple().isOSAIX()),692        IsMsStruct(false), UnfilledBitsInLastUnit(0),693        LastBitfieldStorageUnitSize(0), MaxFieldAlignment(CharUnits::Zero()),694        DataSize(0), NonVirtualSize(CharUnits::Zero()),695        NonVirtualAlignment(CharUnits::One()),696        PreferredNVAlignment(CharUnits::One()),697        PaddedFieldSize(CharUnits::Zero()), PrimaryBase(nullptr),698        PrimaryBaseIsVirtual(false), HasOwnVFPtr(false), HasPackedField(false),699        HandledFirstNonOverlappingEmptyField(false),700        FirstNearlyEmptyVBase(nullptr) {}701 702  void Layout(const RecordDecl *D);703  void Layout(const CXXRecordDecl *D);704  void Layout(const ObjCInterfaceDecl *D);705 706  void LayoutFields(const RecordDecl *D);707  void LayoutField(const FieldDecl *D, bool InsertExtraPadding);708  void LayoutWideBitField(uint64_t FieldSize, uint64_t StorageUnitSize,709                          bool FieldPacked, const FieldDecl *D);710  void LayoutBitField(const FieldDecl *D);711 712  TargetCXXABI getCXXABI() const {713    return Context.getTargetInfo().getCXXABI();714  }715 716  /// BaseSubobjectInfoAllocator - Allocator for BaseSubobjectInfo objects.717  llvm::SpecificBumpPtrAllocator<BaseSubobjectInfo> BaseSubobjectInfoAllocator;718 719  typedef llvm::DenseMap<const CXXRecordDecl *, BaseSubobjectInfo *>720    BaseSubobjectInfoMapTy;721 722  /// VirtualBaseInfo - Map from all the (direct or indirect) virtual bases723  /// of the class we're laying out to their base subobject info.724  BaseSubobjectInfoMapTy VirtualBaseInfo;725 726  /// NonVirtualBaseInfo - Map from all the direct non-virtual bases of the727  /// class we're laying out to their base subobject info.728  BaseSubobjectInfoMapTy NonVirtualBaseInfo;729 730  /// ComputeBaseSubobjectInfo - Compute the base subobject information for the731  /// bases of the given class.732  void ComputeBaseSubobjectInfo(const CXXRecordDecl *RD);733 734  /// ComputeBaseSubobjectInfo - Compute the base subobject information for a735  /// single class and all of its base classes.736  BaseSubobjectInfo *ComputeBaseSubobjectInfo(const CXXRecordDecl *RD,737                                              bool IsVirtual,738                                              BaseSubobjectInfo *Derived);739 740  /// DeterminePrimaryBase - Determine the primary base of the given class.741  void DeterminePrimaryBase(const CXXRecordDecl *RD);742 743  void SelectPrimaryVBase(const CXXRecordDecl *RD);744 745  void EnsureVTablePointerAlignment(CharUnits UnpackedBaseAlign);746 747  /// LayoutNonVirtualBases - Determines the primary base class (if any) and748  /// lays it out. Will then proceed to lay out all non-virtual base clasess.749  void LayoutNonVirtualBases(const CXXRecordDecl *RD);750 751  /// LayoutNonVirtualBase - Lays out a single non-virtual base.752  void LayoutNonVirtualBase(const BaseSubobjectInfo *Base);753 754  void AddPrimaryVirtualBaseOffsets(const BaseSubobjectInfo *Info,755                                    CharUnits Offset);756 757  /// LayoutVirtualBases - Lays out all the virtual bases.758  void LayoutVirtualBases(const CXXRecordDecl *RD,759                          const CXXRecordDecl *MostDerivedClass);760 761  /// LayoutVirtualBase - Lays out a single virtual base.762  void LayoutVirtualBase(const BaseSubobjectInfo *Base);763 764  /// LayoutBase - Will lay out a base and return the offset where it was765  /// placed, in chars.766  CharUnits LayoutBase(const BaseSubobjectInfo *Base);767 768  /// InitializeLayout - Initialize record layout for the given record decl.769  void InitializeLayout(const Decl *D);770 771  /// FinishLayout - Finalize record layout. Adjust record size based on the772  /// alignment.773  void FinishLayout(const NamedDecl *D);774 775  void UpdateAlignment(CharUnits NewAlignment, CharUnits UnpackedNewAlignment,776                       CharUnits PreferredAlignment);777  void UpdateAlignment(CharUnits NewAlignment, CharUnits UnpackedNewAlignment) {778    UpdateAlignment(NewAlignment, UnpackedNewAlignment, NewAlignment);779  }780  void UpdateAlignment(CharUnits NewAlignment) {781    UpdateAlignment(NewAlignment, NewAlignment, NewAlignment);782  }783 784  /// Retrieve the externally-supplied field offset for the given785  /// field.786  ///787  /// \param Field The field whose offset is being queried.788  /// \param ComputedOffset The offset that we've computed for this field.789  uint64_t updateExternalFieldOffset(const FieldDecl *Field,790                                     uint64_t ComputedOffset);791 792  void CheckFieldPadding(uint64_t Offset, uint64_t UnpaddedOffset,793                          uint64_t UnpackedOffset, unsigned UnpackedAlign,794                          bool isPacked, const FieldDecl *D);795 796  DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID);797 798  CharUnits getSize() const {799    assert(Size % Context.getCharWidth() == 0);800    return Context.toCharUnitsFromBits(Size);801  }802  uint64_t getSizeInBits() const { return Size; }803 804  void setSize(CharUnits NewSize) { Size = Context.toBits(NewSize); }805  void setSize(uint64_t NewSize) { Size = NewSize; }806 807  CharUnits getAlignment() const { return Alignment; }808 809  CharUnits getDataSize() const {810    assert(DataSize % Context.getCharWidth() == 0);811    return Context.toCharUnitsFromBits(DataSize);812  }813  uint64_t getDataSizeInBits() const { return DataSize; }814 815  void setDataSize(CharUnits NewSize) { DataSize = Context.toBits(NewSize); }816  void setDataSize(uint64_t NewSize) { DataSize = NewSize; }817 818  ItaniumRecordLayoutBuilder(const ItaniumRecordLayoutBuilder &) = delete;819  void operator=(const ItaniumRecordLayoutBuilder &) = delete;820};821} // end anonymous namespace822 823void ItaniumRecordLayoutBuilder::SelectPrimaryVBase(const CXXRecordDecl *RD) {824  for (const auto &I : RD->bases()) {825    assert(!I.getType()->isDependentType() &&826           "Cannot layout class with dependent bases.");827 828    const CXXRecordDecl *Base = I.getType()->getAsCXXRecordDecl();829 830    // Check if this is a nearly empty virtual base.831    if (I.isVirtual() && Context.isNearlyEmpty(Base)) {832      // If it's not an indirect primary base, then we've found our primary833      // base.834      if (!IndirectPrimaryBases.count(Base)) {835        PrimaryBase = Base;836        PrimaryBaseIsVirtual = true;837        return;838      }839 840      // Is this the first nearly empty virtual base?841      if (!FirstNearlyEmptyVBase)842        FirstNearlyEmptyVBase = Base;843    }844 845    SelectPrimaryVBase(Base);846    if (PrimaryBase)847      return;848  }849}850 851/// DeterminePrimaryBase - Determine the primary base of the given class.852void ItaniumRecordLayoutBuilder::DeterminePrimaryBase(const CXXRecordDecl *RD) {853  // If the class isn't dynamic, it won't have a primary base.854  if (!RD->isDynamicClass())855    return;856 857  // Compute all the primary virtual bases for all of our direct and858  // indirect bases, and record all their primary virtual base classes.859  RD->getIndirectPrimaryBases(IndirectPrimaryBases);860 861  // If the record has a dynamic base class, attempt to choose a primary base862  // class. It is the first (in direct base class order) non-virtual dynamic863  // base class, if one exists.864  for (const auto &I : RD->bases()) {865    // Ignore virtual bases.866    if (I.isVirtual())867      continue;868 869    const CXXRecordDecl *Base = I.getType()->getAsCXXRecordDecl();870 871    if (Base->isDynamicClass()) {872      // We found it.873      PrimaryBase = Base;874      PrimaryBaseIsVirtual = false;875      return;876    }877  }878 879  // Under the Itanium ABI, if there is no non-virtual primary base class,880  // try to compute the primary virtual base.  The primary virtual base is881  // the first nearly empty virtual base that is not an indirect primary882  // virtual base class, if one exists.883  if (RD->getNumVBases() != 0) {884    SelectPrimaryVBase(RD);885    if (PrimaryBase)886      return;887  }888 889  // Otherwise, it is the first indirect primary base class, if one exists.890  if (FirstNearlyEmptyVBase) {891    PrimaryBase = FirstNearlyEmptyVBase;892    PrimaryBaseIsVirtual = true;893    return;894  }895 896  assert(!PrimaryBase && "Should not get here with a primary base!");897}898 899BaseSubobjectInfo *ItaniumRecordLayoutBuilder::ComputeBaseSubobjectInfo(900    const CXXRecordDecl *RD, bool IsVirtual, BaseSubobjectInfo *Derived) {901  BaseSubobjectInfo *Info;902 903  if (IsVirtual) {904    // Check if we already have info about this virtual base.905    BaseSubobjectInfo *&InfoSlot = VirtualBaseInfo[RD];906    if (InfoSlot) {907      assert(InfoSlot->Class == RD && "Wrong class for virtual base info!");908      return InfoSlot;909    }910 911    // We don't, create it.912    InfoSlot = new (BaseSubobjectInfoAllocator.Allocate()) BaseSubobjectInfo;913    Info = InfoSlot;914  } else {915    Info = new (BaseSubobjectInfoAllocator.Allocate()) BaseSubobjectInfo;916  }917 918  Info->Class = RD;919  Info->IsVirtual = IsVirtual;920  Info->Derived = nullptr;921  Info->PrimaryVirtualBaseInfo = nullptr;922 923  const CXXRecordDecl *PrimaryVirtualBase = nullptr;924  BaseSubobjectInfo *PrimaryVirtualBaseInfo = nullptr;925 926  // Check if this base has a primary virtual base.927  if (RD->getNumVBases()) {928    const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);929    if (Layout.isPrimaryBaseVirtual()) {930      // This base does have a primary virtual base.931      PrimaryVirtualBase = Layout.getPrimaryBase();932      assert(PrimaryVirtualBase && "Didn't have a primary virtual base!");933 934      // Now check if we have base subobject info about this primary base.935      PrimaryVirtualBaseInfo = VirtualBaseInfo.lookup(PrimaryVirtualBase);936 937      if (PrimaryVirtualBaseInfo) {938        if (PrimaryVirtualBaseInfo->Derived) {939          // We did have info about this primary base, and it turns out that it940          // has already been claimed as a primary virtual base for another941          // base.942          PrimaryVirtualBase = nullptr;943        } else {944          // We can claim this base as our primary base.945          Info->PrimaryVirtualBaseInfo = PrimaryVirtualBaseInfo;946          PrimaryVirtualBaseInfo->Derived = Info;947        }948      }949    }950  }951 952  // Now go through all direct bases.953  for (const auto &I : RD->bases()) {954    bool IsVirtual = I.isVirtual();955 956    const CXXRecordDecl *BaseDecl = I.getType()->getAsCXXRecordDecl();957 958    Info->Bases.push_back(ComputeBaseSubobjectInfo(BaseDecl, IsVirtual, Info));959  }960 961  if (PrimaryVirtualBase && !PrimaryVirtualBaseInfo) {962    // Traversing the bases must have created the base info for our primary963    // virtual base.964    PrimaryVirtualBaseInfo = VirtualBaseInfo.lookup(PrimaryVirtualBase);965    assert(PrimaryVirtualBaseInfo &&966           "Did not create a primary virtual base!");967 968    // Claim the primary virtual base as our primary virtual base.969    Info->PrimaryVirtualBaseInfo = PrimaryVirtualBaseInfo;970    PrimaryVirtualBaseInfo->Derived = Info;971  }972 973  return Info;974}975 976void ItaniumRecordLayoutBuilder::ComputeBaseSubobjectInfo(977    const CXXRecordDecl *RD) {978  for (const auto &I : RD->bases()) {979    bool IsVirtual = I.isVirtual();980 981    const CXXRecordDecl *BaseDecl = I.getType()->getAsCXXRecordDecl();982 983    // Compute the base subobject info for this base.984    BaseSubobjectInfo *Info = ComputeBaseSubobjectInfo(BaseDecl, IsVirtual,985                                                       nullptr);986 987    if (IsVirtual) {988      // ComputeBaseInfo has already added this base for us.989      assert(VirtualBaseInfo.count(BaseDecl) &&990             "Did not add virtual base!");991    } else {992      // Add the base info to the map of non-virtual bases.993      assert(!NonVirtualBaseInfo.count(BaseDecl) &&994             "Non-virtual base already exists!");995      NonVirtualBaseInfo.insert(std::make_pair(BaseDecl, Info));996    }997  }998}999 1000void ItaniumRecordLayoutBuilder::EnsureVTablePointerAlignment(1001    CharUnits UnpackedBaseAlign) {1002  CharUnits BaseAlign = Packed ? CharUnits::One() : UnpackedBaseAlign;1003 1004  // The maximum field alignment overrides base align.1005  if (!MaxFieldAlignment.isZero()) {1006    BaseAlign = std::min(BaseAlign, MaxFieldAlignment);1007    UnpackedBaseAlign = std::min(UnpackedBaseAlign, MaxFieldAlignment);1008  }1009 1010  // Round up the current record size to pointer alignment.1011  setSize(getSize().alignTo(BaseAlign));1012 1013  // Update the alignment.1014  UpdateAlignment(BaseAlign, UnpackedBaseAlign, BaseAlign);1015}1016 1017void ItaniumRecordLayoutBuilder::LayoutNonVirtualBases(1018    const CXXRecordDecl *RD) {1019  // Then, determine the primary base class.1020  DeterminePrimaryBase(RD);1021 1022  // Compute base subobject info.1023  ComputeBaseSubobjectInfo(RD);1024 1025  // If we have a primary base class, lay it out.1026  if (PrimaryBase) {1027    if (PrimaryBaseIsVirtual) {1028      // If the primary virtual base was a primary virtual base of some other1029      // base class we'll have to steal it.1030      BaseSubobjectInfo *PrimaryBaseInfo = VirtualBaseInfo.lookup(PrimaryBase);1031      PrimaryBaseInfo->Derived = nullptr;1032 1033      // We have a virtual primary base, insert it as an indirect primary base.1034      IndirectPrimaryBases.insert(PrimaryBase);1035 1036      assert(!VisitedVirtualBases.count(PrimaryBase) &&1037             "vbase already visited!");1038      VisitedVirtualBases.insert(PrimaryBase);1039 1040      LayoutVirtualBase(PrimaryBaseInfo);1041    } else {1042      BaseSubobjectInfo *PrimaryBaseInfo =1043        NonVirtualBaseInfo.lookup(PrimaryBase);1044      assert(PrimaryBaseInfo &&1045             "Did not find base info for non-virtual primary base!");1046 1047      LayoutNonVirtualBase(PrimaryBaseInfo);1048    }1049 1050  // If this class needs a vtable/vf-table and didn't get one from a1051  // primary base, add it in now.1052  } else if (RD->isDynamicClass()) {1053    assert(DataSize == 0 && "Vtable pointer must be at offset zero!");1054    CharUnits PtrWidth = Context.toCharUnitsFromBits(1055        Context.getTargetInfo().getPointerWidth(LangAS::Default));1056    CharUnits PtrAlign = Context.toCharUnitsFromBits(1057        Context.getTargetInfo().getPointerAlign(LangAS::Default));1058    EnsureVTablePointerAlignment(PtrAlign);1059    HasOwnVFPtr = true;1060 1061    assert(!IsUnion && "Unions cannot be dynamic classes.");1062    HandledFirstNonOverlappingEmptyField = true;1063 1064    setSize(getSize() + PtrWidth);1065    setDataSize(getSize());1066  }1067 1068  // Now lay out the non-virtual bases.1069  for (const auto &I : RD->bases()) {1070 1071    // Ignore virtual bases.1072    if (I.isVirtual())1073      continue;1074 1075    const CXXRecordDecl *BaseDecl = I.getType()->getAsCXXRecordDecl();1076 1077    // Skip the primary base, because we've already laid it out.  The1078    // !PrimaryBaseIsVirtual check is required because we might have a1079    // non-virtual base of the same type as a primary virtual base.1080    if (BaseDecl == PrimaryBase && !PrimaryBaseIsVirtual)1081      continue;1082 1083    // Lay out the base.1084    BaseSubobjectInfo *BaseInfo = NonVirtualBaseInfo.lookup(BaseDecl);1085    assert(BaseInfo && "Did not find base info for non-virtual base!");1086 1087    LayoutNonVirtualBase(BaseInfo);1088  }1089}1090 1091void ItaniumRecordLayoutBuilder::LayoutNonVirtualBase(1092    const BaseSubobjectInfo *Base) {1093  // Layout the base.1094  CharUnits Offset = LayoutBase(Base);1095 1096  // Add its base class offset.1097  assert(!Bases.count(Base->Class) && "base offset already exists!");1098  Bases.insert(std::make_pair(Base->Class, Offset));1099 1100  AddPrimaryVirtualBaseOffsets(Base, Offset);1101}1102 1103void ItaniumRecordLayoutBuilder::AddPrimaryVirtualBaseOffsets(1104    const BaseSubobjectInfo *Info, CharUnits Offset) {1105  // This base isn't interesting, it has no virtual bases.1106  if (!Info->Class->getNumVBases())1107    return;1108 1109  // First, check if we have a virtual primary base to add offsets for.1110  if (Info->PrimaryVirtualBaseInfo) {1111    assert(Info->PrimaryVirtualBaseInfo->IsVirtual &&1112           "Primary virtual base is not virtual!");1113    if (Info->PrimaryVirtualBaseInfo->Derived == Info) {1114      // Add the offset.1115      assert(!VBases.count(Info->PrimaryVirtualBaseInfo->Class) &&1116             "primary vbase offset already exists!");1117      VBases.insert(std::make_pair(Info->PrimaryVirtualBaseInfo->Class,1118                                   ASTRecordLayout::VBaseInfo(Offset, false)));1119 1120      // Traverse the primary virtual base.1121      AddPrimaryVirtualBaseOffsets(Info->PrimaryVirtualBaseInfo, Offset);1122    }1123  }1124 1125  // Now go through all direct non-virtual bases.1126  const ASTRecordLayout &Layout = Context.getASTRecordLayout(Info->Class);1127  for (const BaseSubobjectInfo *Base : Info->Bases) {1128    if (Base->IsVirtual)1129      continue;1130 1131    CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(Base->Class);1132    AddPrimaryVirtualBaseOffsets(Base, BaseOffset);1133  }1134}1135 1136void ItaniumRecordLayoutBuilder::LayoutVirtualBases(1137    const CXXRecordDecl *RD, const CXXRecordDecl *MostDerivedClass) {1138  const CXXRecordDecl *PrimaryBase;1139  bool PrimaryBaseIsVirtual;1140 1141  if (MostDerivedClass == RD) {1142    PrimaryBase = this->PrimaryBase;1143    PrimaryBaseIsVirtual = this->PrimaryBaseIsVirtual;1144  } else {1145    const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);1146    PrimaryBase = Layout.getPrimaryBase();1147    PrimaryBaseIsVirtual = Layout.isPrimaryBaseVirtual();1148  }1149 1150  for (const CXXBaseSpecifier &Base : RD->bases()) {1151    assert(!Base.getType()->isDependentType() &&1152           "Cannot layout class with dependent bases.");1153 1154    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();1155 1156    if (Base.isVirtual()) {1157      if (PrimaryBase != BaseDecl || !PrimaryBaseIsVirtual) {1158        bool IndirectPrimaryBase = IndirectPrimaryBases.count(BaseDecl);1159 1160        // Only lay out the virtual base if it's not an indirect primary base.1161        if (!IndirectPrimaryBase) {1162          // Only visit virtual bases once.1163          if (!VisitedVirtualBases.insert(BaseDecl).second)1164            continue;1165 1166          const BaseSubobjectInfo *BaseInfo = VirtualBaseInfo.lookup(BaseDecl);1167          assert(BaseInfo && "Did not find virtual base info!");1168          LayoutVirtualBase(BaseInfo);1169        }1170      }1171    }1172 1173    if (!BaseDecl->getNumVBases()) {1174      // This base isn't interesting since it doesn't have any virtual bases.1175      continue;1176    }1177 1178    LayoutVirtualBases(BaseDecl, MostDerivedClass);1179  }1180}1181 1182void ItaniumRecordLayoutBuilder::LayoutVirtualBase(1183    const BaseSubobjectInfo *Base) {1184  assert(!Base->Derived && "Trying to lay out a primary virtual base!");1185 1186  // Layout the base.1187  CharUnits Offset = LayoutBase(Base);1188 1189  // Add its base class offset.1190  assert(!VBases.count(Base->Class) && "vbase offset already exists!");1191  VBases.insert(std::make_pair(Base->Class,1192                       ASTRecordLayout::VBaseInfo(Offset, false)));1193 1194  AddPrimaryVirtualBaseOffsets(Base, Offset);1195}1196 1197CharUnits1198ItaniumRecordLayoutBuilder::LayoutBase(const BaseSubobjectInfo *Base) {1199  assert(!IsUnion && "Unions cannot have base classes.");1200 1201  const ASTRecordLayout &Layout = Context.getASTRecordLayout(Base->Class);1202  CharUnits Offset;1203 1204  // Query the external layout to see if it provides an offset.1205  bool HasExternalLayout = false;1206  if (UseExternalLayout) {1207    if (Base->IsVirtual)1208      HasExternalLayout = External.getExternalVBaseOffset(Base->Class, Offset);1209    else1210      HasExternalLayout = External.getExternalNVBaseOffset(Base->Class, Offset);1211  }1212 1213  auto getBaseOrPreferredBaseAlignFromUnpacked = [&](CharUnits UnpackedAlign) {1214    // Clang <= 6 incorrectly applied the 'packed' attribute to base classes.1215    // Per GCC's documentation, it only applies to non-static data members.1216    return (Packed && ((Context.getLangOpts().getClangABICompat() <=1217                        LangOptions::ClangABI::Ver6) ||1218                       Context.getTargetInfo().getTriple().isPS() ||1219                       Context.getTargetInfo().getTriple().isOSAIX()))1220               ? CharUnits::One()1221               : UnpackedAlign;1222  };1223 1224  CharUnits UnpackedBaseAlign = Layout.getNonVirtualAlignment();1225  CharUnits UnpackedPreferredBaseAlign = Layout.getPreferredNVAlignment();1226  CharUnits BaseAlign =1227      getBaseOrPreferredBaseAlignFromUnpacked(UnpackedBaseAlign);1228  CharUnits PreferredBaseAlign =1229      getBaseOrPreferredBaseAlignFromUnpacked(UnpackedPreferredBaseAlign);1230 1231  const bool DefaultsToAIXPowerAlignment =1232      Context.getTargetInfo().defaultsToAIXPowerAlignment();1233  if (DefaultsToAIXPowerAlignment) {1234    // AIX `power` alignment does not apply the preferred alignment for1235    // non-union classes if the source of the alignment (the current base in1236    // this context) follows introduction of the first subobject with1237    // exclusively allocated space or zero-extent array.1238    if (!Base->Class->isEmpty() && !HandledFirstNonOverlappingEmptyField) {1239      // By handling a base class that is not empty, we're handling the1240      // "first (inherited) member".1241      HandledFirstNonOverlappingEmptyField = true;1242    } else if (!IsNaturalAlign) {1243      UnpackedPreferredBaseAlign = UnpackedBaseAlign;1244      PreferredBaseAlign = BaseAlign;1245    }1246  }1247 1248  CharUnits UnpackedAlignTo = !DefaultsToAIXPowerAlignment1249                                  ? UnpackedBaseAlign1250                                  : UnpackedPreferredBaseAlign;1251  // If we have an empty base class, try to place it at offset 0.1252  if (Base->Class->isEmpty() &&1253      (!HasExternalLayout || Offset == CharUnits::Zero()) &&1254      EmptySubobjects->CanPlaceBaseAtOffset(Base, CharUnits::Zero())) {1255    setSize(std::max(getSize(), Layout.getSize()));1256    // On PS4/PS5, don't update the alignment, to preserve compatibility.1257    if (!Context.getTargetInfo().getTriple().isPS())1258      UpdateAlignment(BaseAlign, UnpackedAlignTo, PreferredBaseAlign);1259 1260    return CharUnits::Zero();1261  }1262 1263  // The maximum field alignment overrides the base align/(AIX-only) preferred1264  // base align.1265  if (!MaxFieldAlignment.isZero()) {1266    BaseAlign = std::min(BaseAlign, MaxFieldAlignment);1267    PreferredBaseAlign = std::min(PreferredBaseAlign, MaxFieldAlignment);1268    UnpackedAlignTo = std::min(UnpackedAlignTo, MaxFieldAlignment);1269  }1270 1271  CharUnits AlignTo =1272      !DefaultsToAIXPowerAlignment ? BaseAlign : PreferredBaseAlign;1273  if (!HasExternalLayout) {1274    // Round up the current record size to the base's alignment boundary.1275    Offset = getDataSize().alignTo(AlignTo);1276 1277    // Try to place the base.1278    while (!EmptySubobjects->CanPlaceBaseAtOffset(Base, Offset))1279      Offset += AlignTo;1280  } else {1281    bool Allowed = EmptySubobjects->CanPlaceBaseAtOffset(Base, Offset);1282    (void)Allowed;1283    assert(Allowed && "Base subobject externally placed at overlapping offset");1284 1285    if (InferAlignment && Offset < getDataSize().alignTo(AlignTo)) {1286      // The externally-supplied base offset is before the base offset we1287      // computed. Assume that the structure is packed.1288      Alignment = CharUnits::One();1289      InferAlignment = false;1290    }1291  }1292 1293  if (!Base->Class->isEmpty()) {1294    // Update the data size.1295    setDataSize(Offset + Layout.getNonVirtualSize());1296 1297    setSize(std::max(getSize(), getDataSize()));1298  } else1299    setSize(std::max(getSize(), Offset + Layout.getSize()));1300 1301  // Remember max struct/class alignment.1302  UnadjustedAlignment = std::max(UnadjustedAlignment, BaseAlign);1303  UpdateAlignment(BaseAlign, UnpackedAlignTo, PreferredBaseAlign);1304 1305  return Offset;1306}1307 1308void ItaniumRecordLayoutBuilder::InitializeLayout(const Decl *D) {1309  if (const RecordDecl *RD = dyn_cast<RecordDecl>(D)) {1310    IsUnion = RD->isUnion();1311    IsMsStruct = RD->isMsStruct(Context);1312  }1313 1314  Packed = D->hasAttr<PackedAttr>();1315 1316  // Honor the default struct packing maximum alignment flag.1317  if (unsigned DefaultMaxFieldAlignment = Context.getLangOpts().PackStruct) {1318    MaxFieldAlignment = CharUnits::fromQuantity(DefaultMaxFieldAlignment);1319  }1320 1321  // mac68k alignment supersedes maximum field alignment and attribute aligned,1322  // and forces all structures to have 2-byte alignment. The IBM docs on it1323  // allude to additional (more complicated) semantics, especially with regard1324  // to bit-fields, but gcc appears not to follow that.1325  if (D->hasAttr<AlignMac68kAttr>()) {1326    assert(1327        !D->hasAttr<AlignNaturalAttr>() &&1328        "Having both mac68k and natural alignment on a decl is not allowed.");1329    IsMac68kAlign = true;1330    MaxFieldAlignment = CharUnits::fromQuantity(2);1331    Alignment = CharUnits::fromQuantity(2);1332    PreferredAlignment = CharUnits::fromQuantity(2);1333  } else {1334    if (D->hasAttr<AlignNaturalAttr>())1335      IsNaturalAlign = true;1336 1337    if (const MaxFieldAlignmentAttr *MFAA = D->getAttr<MaxFieldAlignmentAttr>())1338      MaxFieldAlignment = Context.toCharUnitsFromBits(MFAA->getAlignment());1339 1340    if (unsigned MaxAlign = D->getMaxAlignment())1341      UpdateAlignment(Context.toCharUnitsFromBits(MaxAlign));1342  }1343 1344  HandledFirstNonOverlappingEmptyField =1345      !Context.getTargetInfo().defaultsToAIXPowerAlignment() || IsNaturalAlign;1346 1347  // If there is an external AST source, ask it for the various offsets.1348  if (const RecordDecl *RD = dyn_cast<RecordDecl>(D))1349    if (ExternalASTSource *Source = Context.getExternalSource()) {1350      UseExternalLayout = Source->layoutRecordType(1351          RD, External.Size, External.Align, External.FieldOffsets,1352          External.BaseOffsets, External.VirtualBaseOffsets);1353 1354      // Update based on external alignment.1355      if (UseExternalLayout) {1356        if (External.Align > 0) {1357          Alignment = Context.toCharUnitsFromBits(External.Align);1358          PreferredAlignment = Context.toCharUnitsFromBits(External.Align);1359        } else {1360          // The external source didn't have alignment information; infer it.1361          InferAlignment = true;1362        }1363      }1364    }1365}1366 1367void ItaniumRecordLayoutBuilder::Layout(const RecordDecl *D) {1368  InitializeLayout(D);1369  LayoutFields(D);1370 1371  // Finally, round the size of the total struct up to the alignment of the1372  // struct itself.1373  FinishLayout(D);1374}1375 1376void ItaniumRecordLayoutBuilder::Layout(const CXXRecordDecl *RD) {1377  InitializeLayout(RD);1378 1379  // Lay out the vtable and the non-virtual bases.1380  LayoutNonVirtualBases(RD);1381 1382  LayoutFields(RD);1383 1384  NonVirtualSize = Context.toCharUnitsFromBits(1385      llvm::alignTo(getSizeInBits(), Context.getTargetInfo().getCharAlign()));1386  NonVirtualAlignment = Alignment;1387  PreferredNVAlignment = PreferredAlignment;1388 1389  // Lay out the virtual bases and add the primary virtual base offsets.1390  LayoutVirtualBases(RD, RD);1391 1392  // Finally, round the size of the total struct up to the alignment1393  // of the struct itself.1394  FinishLayout(RD);1395 1396#ifndef NDEBUG1397  // Check that we have base offsets for all bases.1398  for (const CXXBaseSpecifier &Base : RD->bases()) {1399    if (Base.isVirtual())1400      continue;1401 1402    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();1403 1404    assert(Bases.count(BaseDecl) && "Did not find base offset!");1405  }1406 1407  // And all virtual bases.1408  for (const CXXBaseSpecifier &Base : RD->vbases()) {1409    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();1410 1411    assert(VBases.count(BaseDecl) && "Did not find base offset!");1412  }1413#endif1414}1415 1416void ItaniumRecordLayoutBuilder::Layout(const ObjCInterfaceDecl *D) {1417  if (ObjCInterfaceDecl *SD = D->getSuperClass()) {1418    const ASTRecordLayout &SL = Context.getASTObjCInterfaceLayout(SD);1419 1420    UpdateAlignment(SL.getAlignment());1421 1422    // We start laying out ivars not at the end of the superclass1423    // structure, but at the next byte following the last field.1424    setDataSize(SL.getDataSize());1425    setSize(getDataSize());1426  }1427 1428  InitializeLayout(D);1429  // Layout each ivar sequentially.1430  for (const ObjCIvarDecl *IVD = D->all_declared_ivar_begin(); IVD;1431       IVD = IVD->getNextIvar())1432    LayoutField(IVD, false);1433 1434  // Finally, round the size of the total struct up to the alignment of the1435  // struct itself.1436  FinishLayout(D);1437}1438 1439void ItaniumRecordLayoutBuilder::LayoutFields(const RecordDecl *D) {1440  // Layout each field, for now, just sequentially, respecting alignment.  In1441  // the future, this will need to be tweakable by targets.1442  bool InsertExtraPadding = D->mayInsertExtraPadding(/*EmitRemark=*/true);1443  bool HasFlexibleArrayMember = D->hasFlexibleArrayMember();1444  for (auto I = D->field_begin(), End = D->field_end(); I != End; ++I) {1445    LayoutField(*I, InsertExtraPadding &&1446                        (std::next(I) != End || !HasFlexibleArrayMember));1447  }1448}1449 1450// Rounds the specified size to have it a multiple of the char size.1451static uint64_t1452roundUpSizeToCharAlignment(uint64_t Size,1453                           const ASTContext &Context) {1454  uint64_t CharAlignment = Context.getTargetInfo().getCharAlign();1455  return llvm::alignTo(Size, CharAlignment);1456}1457 1458void ItaniumRecordLayoutBuilder::LayoutWideBitField(uint64_t FieldSize,1459                                                    uint64_t StorageUnitSize,1460                                                    bool FieldPacked,1461                                                    const FieldDecl *D) {1462  assert(Context.getLangOpts().CPlusPlus &&1463         "Can only have wide bit-fields in C++!");1464 1465  // Itanium C++ ABI 2.4:1466  //   If sizeof(T)*8 < n, let T' be the largest integral POD type with1467  //   sizeof(T')*8 <= n.1468 1469  QualType IntegralPODTypes[] = {1470      Context.UnsignedCharTy,     Context.UnsignedShortTy,1471      Context.UnsignedIntTy,      Context.UnsignedLongTy,1472      Context.UnsignedLongLongTy, Context.UnsignedInt128Ty,1473  };1474 1475  QualType Type;1476  uint64_t MaxSize =1477      Context.getTargetInfo().getLargestOverSizedBitfieldContainer();1478  for (const QualType &QT : IntegralPODTypes) {1479    uint64_t Size = Context.getTypeSize(QT);1480 1481    if (Size > FieldSize || Size > MaxSize)1482      break;1483 1484    Type = QT;1485  }1486  assert(!Type.isNull() && "Did not find a type!");1487 1488  CharUnits TypeAlign = Context.getTypeAlignInChars(Type);1489 1490  // We're not going to use any of the unfilled bits in the last byte.1491  UnfilledBitsInLastUnit = 0;1492  LastBitfieldStorageUnitSize = 0;1493 1494  uint64_t FieldOffset;1495  uint64_t UnpaddedFieldOffset = getDataSizeInBits() - UnfilledBitsInLastUnit;1496 1497  if (IsUnion) {1498    uint64_t RoundedFieldSize = roundUpSizeToCharAlignment(FieldSize,1499                                                           Context);1500    setDataSize(std::max(getDataSizeInBits(), RoundedFieldSize));1501    FieldOffset = 0;1502  } else {1503    // The bitfield is allocated starting at the next offset aligned1504    // appropriately for T', with length n bits.1505    FieldOffset = llvm::alignTo(getDataSizeInBits(), Context.toBits(TypeAlign));1506 1507    uint64_t NewSizeInBits = FieldOffset + FieldSize;1508 1509    setDataSize(1510        llvm::alignTo(NewSizeInBits, Context.getTargetInfo().getCharAlign()));1511    UnfilledBitsInLastUnit = getDataSizeInBits() - NewSizeInBits;1512  }1513 1514  // Place this field at the current location.1515  FieldOffsets.push_back(FieldOffset);1516 1517  CheckFieldPadding(FieldOffset, UnpaddedFieldOffset, FieldOffset,1518                    Context.toBits(TypeAlign), FieldPacked, D);1519 1520  // Update the size.1521  setSize(std::max(getSizeInBits(), getDataSizeInBits()));1522 1523  // Remember max struct/class alignment.1524  UnadjustedAlignment = std::max(UnadjustedAlignment, TypeAlign);1525  UpdateAlignment(TypeAlign);1526}1527 1528static bool isAIXLayout(const ASTContext &Context) {1529  return Context.getTargetInfo().getTriple().getOS() == llvm::Triple::AIX;1530}1531 1532void ItaniumRecordLayoutBuilder::LayoutBitField(const FieldDecl *D) {1533  bool FieldPacked = Packed || D->hasAttr<PackedAttr>();1534  uint64_t FieldSize = D->getBitWidthValue();1535  TypeInfo FieldInfo = Context.getTypeInfo(D->getType());1536  uint64_t StorageUnitSize = FieldInfo.Width;1537  unsigned FieldAlign = FieldInfo.Align;1538  bool AlignIsRequired = FieldInfo.isAlignRequired();1539  unsigned char PaddingInLastUnit = 0;1540 1541  // UnfilledBitsInLastUnit is the difference between the end of the1542  // last allocated bitfield (i.e. the first bit offset available for1543  // bitfields) and the end of the current data size in bits (i.e. the1544  // first bit offset available for non-bitfields).  The current data1545  // size in bits is always a multiple of the char size; additionally,1546  // for ms_struct records it's also a multiple of the1547  // LastBitfieldStorageUnitSize (if set).1548 1549  // The struct-layout algorithm is dictated by the platform ABI,1550  // which in principle could use almost any rules it likes.  In1551  // practice, UNIXy targets tend to inherit the algorithm described1552  // in the System V generic ABI.  The basic bitfield layout rule in1553  // System V is to place bitfields at the next available bit offset1554  // where the entire bitfield would fit in an aligned storage unit of1555  // the declared type; it's okay if an earlier or later non-bitfield1556  // is allocated in the same storage unit.  However, some targets1557  // (those that !useBitFieldTypeAlignment(), e.g. ARM APCS) don't1558  // require this storage unit to be aligned, and therefore always put1559  // the bitfield at the next available bit offset.1560 1561  // ms_struct basically requests a complete replacement of the1562  // platform ABI's struct-layout algorithm, with the high-level goal1563  // of duplicating MSVC's layout.  For non-bitfields, this follows1564  // the standard algorithm.  The basic bitfield layout rule is to1565  // allocate an entire unit of the bitfield's declared type1566  // (e.g. 'unsigned long'), then parcel it up among successive1567  // bitfields whose declared types have the same size, making a new1568  // unit as soon as the last can no longer store the whole value.1569  // Since it completely replaces the platform ABI's algorithm,1570  // settings like !useBitFieldTypeAlignment() do not apply.1571 1572  // A zero-width bitfield forces the use of a new storage unit for1573  // later bitfields.  In general, this occurs by rounding up the1574  // current size of the struct as if the algorithm were about to1575  // place a non-bitfield of the field's formal type.  Usually this1576  // does not change the alignment of the struct itself, but it does1577  // on some targets (those that useZeroLengthBitfieldAlignment(),1578  // e.g. ARM).  In ms_struct layout, zero-width bitfields are1579  // ignored unless they follow a non-zero-width bitfield.1580 1581  // A field alignment restriction (e.g. from #pragma pack) or1582  // specification (e.g. from __attribute__((aligned))) changes the1583  // formal alignment of the field.  For System V, this alters the1584  // required alignment of the notional storage unit that must contain1585  // the bitfield.  For ms_struct, this only affects the placement of1586  // new storage units.  In both cases, the effect of #pragma pack is1587  // ignored on zero-width bitfields.1588 1589  // On System V, a packed field (e.g. from #pragma pack or1590  // __attribute__((packed))) always uses the next available bit1591  // offset.1592 1593  // In an ms_struct struct, the alignment of a fundamental type is1594  // always equal to its size.  This is necessary in order to mimic1595  // the i386 alignment rules on targets which might not fully align1596  // all types (e.g. Darwin PPC32, where alignof(long long) == 4).1597 1598  // First, some simple bookkeeping to perform for ms_struct structs.1599  if (IsMsStruct) {1600    // The field alignment for integer types is always the size.1601    FieldAlign = StorageUnitSize;1602 1603    // If the previous field was not a bitfield, or was a bitfield1604    // with a different storage unit size, or if this field doesn't fit into1605    // the current storage unit, we're done with that storage unit.1606    if (LastBitfieldStorageUnitSize != StorageUnitSize ||1607        UnfilledBitsInLastUnit < FieldSize) {1608      // Also, ignore zero-length bitfields after non-bitfields.1609      if (!LastBitfieldStorageUnitSize && !FieldSize)1610        FieldAlign = 1;1611 1612      PaddingInLastUnit = UnfilledBitsInLastUnit;1613      UnfilledBitsInLastUnit = 0;1614      LastBitfieldStorageUnitSize = 0;1615    }1616  }1617 1618  if (isAIXLayout(Context)) {1619    if (StorageUnitSize < Context.getTypeSize(Context.UnsignedIntTy)) {1620      // On AIX, [bool, char, short] bitfields have the same alignment1621      // as [unsigned].1622      StorageUnitSize = Context.getTypeSize(Context.UnsignedIntTy);1623    } else if (StorageUnitSize > Context.getTypeSize(Context.UnsignedIntTy) &&1624               Context.getTargetInfo().getTriple().isArch32Bit() &&1625               FieldSize <= 32) {1626      // Under 32-bit compile mode, the bitcontainer is 32 bits if a single1627      // long long bitfield has length no greater than 32 bits.1628      StorageUnitSize = 32;1629 1630      if (!AlignIsRequired)1631        FieldAlign = 32;1632    }1633 1634    if (FieldAlign < StorageUnitSize) {1635      // The bitfield alignment should always be greater than or equal to1636      // bitcontainer size.1637      FieldAlign = StorageUnitSize;1638    }1639  }1640 1641  // If the field is wider than its declared type, it follows1642  // different rules in all cases, except on AIX.1643  // On AIX, wide bitfield follows the same rules as normal bitfield.1644  if (FieldSize > StorageUnitSize && !isAIXLayout(Context)) {1645    LayoutWideBitField(FieldSize, StorageUnitSize, FieldPacked, D);1646    return;1647  }1648 1649  // Compute the next available bit offset.1650  uint64_t FieldOffset =1651    IsUnion ? 0 : (getDataSizeInBits() - UnfilledBitsInLastUnit);1652 1653  // Handle targets that don't honor bitfield type alignment.1654  if (!IsMsStruct && !Context.getTargetInfo().useBitFieldTypeAlignment()) {1655    // Some such targets do honor it on zero-width bitfields.1656    if (FieldSize == 0 &&1657        Context.getTargetInfo().useZeroLengthBitfieldAlignment()) {1658      // Some targets don't honor leading zero-width bitfield.1659      if (!IsUnion && FieldOffset == 0 &&1660          !Context.getTargetInfo().useLeadingZeroLengthBitfield())1661        FieldAlign = 1;1662      else {1663        // The alignment to round up to is the max of the field's natural1664        // alignment and a target-specific fixed value (sometimes zero).1665        unsigned ZeroLengthBitfieldBoundary =1666            Context.getTargetInfo().getZeroLengthBitfieldBoundary();1667        FieldAlign = std::max(FieldAlign, ZeroLengthBitfieldBoundary);1668      }1669    // If that doesn't apply, just ignore the field alignment.1670    } else {1671      FieldAlign = 1;1672    }1673  }1674 1675  // Remember the alignment we would have used if the field were not packed.1676  unsigned UnpackedFieldAlign = FieldAlign;1677 1678  // Ignore the field alignment if the field is packed unless it has zero-size.1679  if (!IsMsStruct && FieldPacked && FieldSize != 0)1680    FieldAlign = 1;1681 1682  // But, if there's an 'aligned' attribute on the field, honor that.1683  unsigned ExplicitFieldAlign = D->getMaxAlignment();1684  if (ExplicitFieldAlign) {1685    FieldAlign = std::max(FieldAlign, ExplicitFieldAlign);1686    UnpackedFieldAlign = std::max(UnpackedFieldAlign, ExplicitFieldAlign);1687  }1688 1689  // But, if there's a #pragma pack in play, that takes precedent over1690  // even the 'aligned' attribute, for non-zero-width bitfields.1691  unsigned MaxFieldAlignmentInBits = Context.toBits(MaxFieldAlignment);1692  if (!MaxFieldAlignment.isZero() && FieldSize) {1693    UnpackedFieldAlign = std::min(UnpackedFieldAlign, MaxFieldAlignmentInBits);1694    if (FieldPacked)1695      FieldAlign = UnpackedFieldAlign;1696    else1697      FieldAlign = std::min(FieldAlign, MaxFieldAlignmentInBits);1698  }1699 1700  // But, ms_struct just ignores all of that in unions, even explicit1701  // alignment attributes.1702  if (IsMsStruct && IsUnion) {1703    FieldAlign = UnpackedFieldAlign = 1;1704  }1705 1706  // For purposes of diagnostics, we're going to simultaneously1707  // compute the field offsets that we would have used if we weren't1708  // adding any alignment padding or if the field weren't packed.1709  uint64_t UnpaddedFieldOffset = FieldOffset - PaddingInLastUnit;1710  uint64_t UnpackedFieldOffset = FieldOffset;1711 1712  // Check if we need to add padding to fit the bitfield within an1713  // allocation unit with the right size and alignment.  The rules are1714  // somewhat different here for ms_struct structs.1715  if (IsMsStruct) {1716    // If it's not a zero-width bitfield, and we can fit the bitfield1717    // into the active storage unit (and we haven't already decided to1718    // start a new storage unit), just do so, regardless of any other1719    // other consideration.  Otherwise, round up to the right alignment.1720    if (FieldSize == 0 || FieldSize > UnfilledBitsInLastUnit) {1721      FieldOffset = llvm::alignTo(FieldOffset, FieldAlign);1722      UnpackedFieldOffset =1723          llvm::alignTo(UnpackedFieldOffset, UnpackedFieldAlign);1724      UnfilledBitsInLastUnit = 0;1725    }1726 1727  } else {1728    // #pragma pack, with any value, suppresses the insertion of padding.1729    bool AllowPadding = MaxFieldAlignment.isZero();1730 1731    // Compute the real offset.1732    if (FieldSize == 0 ||1733        (AllowPadding &&1734         (FieldOffset & (FieldAlign - 1)) + FieldSize > StorageUnitSize)) {1735      FieldOffset = llvm::alignTo(FieldOffset, FieldAlign);1736    } else if (ExplicitFieldAlign &&1737               (MaxFieldAlignmentInBits == 0 ||1738                ExplicitFieldAlign <= MaxFieldAlignmentInBits) &&1739               Context.getTargetInfo().useExplicitBitFieldAlignment()) {1740      // TODO: figure it out what needs to be done on targets that don't honor1741      // bit-field type alignment like ARM APCS ABI.1742      FieldOffset = llvm::alignTo(FieldOffset, ExplicitFieldAlign);1743    }1744 1745    // Repeat the computation for diagnostic purposes.1746    if (FieldSize == 0 ||1747        (AllowPadding &&1748         (UnpackedFieldOffset & (UnpackedFieldAlign - 1)) + FieldSize >1749             StorageUnitSize))1750      UnpackedFieldOffset =1751          llvm::alignTo(UnpackedFieldOffset, UnpackedFieldAlign);1752    else if (ExplicitFieldAlign &&1753             (MaxFieldAlignmentInBits == 0 ||1754              ExplicitFieldAlign <= MaxFieldAlignmentInBits) &&1755             Context.getTargetInfo().useExplicitBitFieldAlignment())1756      UnpackedFieldOffset =1757          llvm::alignTo(UnpackedFieldOffset, ExplicitFieldAlign);1758  }1759 1760  // If we're using external layout, give the external layout a chance1761  // to override this information.1762  if (UseExternalLayout)1763    FieldOffset = updateExternalFieldOffset(D, FieldOffset);1764 1765  // Okay, place the bitfield at the calculated offset.1766  FieldOffsets.push_back(FieldOffset);1767 1768  // Bookkeeping:1769 1770  // Anonymous members don't affect the overall record alignment,1771  // except on targets where they do.1772  if (!IsMsStruct &&1773      !Context.getTargetInfo().useZeroLengthBitfieldAlignment() &&1774      !D->getIdentifier())1775    FieldAlign = UnpackedFieldAlign = 1;1776 1777  // On AIX, zero-width bitfields pad out to the natural alignment boundary,1778  // but do not increase the alignment greater than the MaxFieldAlignment, or 11779  // if packed.1780  if (isAIXLayout(Context) && !FieldSize) {1781    if (FieldPacked)1782      FieldAlign = 1;1783    if (!MaxFieldAlignment.isZero()) {1784      UnpackedFieldAlign =1785          std::min(UnpackedFieldAlign, MaxFieldAlignmentInBits);1786      FieldAlign = std::min(FieldAlign, MaxFieldAlignmentInBits);1787    }1788  }1789 1790  // Diagnose differences in layout due to padding or packing.1791  if (!UseExternalLayout)1792    CheckFieldPadding(FieldOffset, UnpaddedFieldOffset, UnpackedFieldOffset,1793                      UnpackedFieldAlign, FieldPacked, D);1794 1795  // Update DataSize to include the last byte containing (part of) the bitfield.1796 1797  // For unions, this is just a max operation, as usual.1798  if (IsUnion) {1799    // For ms_struct, allocate the entire storage unit --- unless this1800    // is a zero-width bitfield, in which case just use a size of 1.1801    uint64_t RoundedFieldSize;1802    if (IsMsStruct) {1803      RoundedFieldSize = (FieldSize ? StorageUnitSize1804                                    : Context.getTargetInfo().getCharWidth());1805 1806      // Otherwise, allocate just the number of bytes required to store1807      // the bitfield.1808    } else {1809      RoundedFieldSize = roundUpSizeToCharAlignment(FieldSize, Context);1810    }1811    setDataSize(std::max(getDataSizeInBits(), RoundedFieldSize));1812 1813  // For non-zero-width bitfields in ms_struct structs, allocate a new1814  // storage unit if necessary.1815  } else if (IsMsStruct && FieldSize) {1816    // We should have cleared UnfilledBitsInLastUnit in every case1817    // where we changed storage units.1818    if (!UnfilledBitsInLastUnit) {1819      setDataSize(FieldOffset + StorageUnitSize);1820      UnfilledBitsInLastUnit = StorageUnitSize;1821    }1822    UnfilledBitsInLastUnit -= FieldSize;1823    LastBitfieldStorageUnitSize = StorageUnitSize;1824 1825    // Otherwise, bump the data size up to include the bitfield,1826    // including padding up to char alignment, and then remember how1827    // bits we didn't use.1828  } else {1829    uint64_t NewSizeInBits = FieldOffset + FieldSize;1830    uint64_t CharAlignment = Context.getTargetInfo().getCharAlign();1831    setDataSize(llvm::alignTo(NewSizeInBits, CharAlignment));1832    UnfilledBitsInLastUnit = getDataSizeInBits() - NewSizeInBits;1833 1834    // The only time we can get here for an ms_struct is if this is a1835    // zero-width bitfield, which doesn't count as anything for the1836    // purposes of unfilled bits.1837    LastBitfieldStorageUnitSize = 0;1838  }1839 1840  // Update the size.1841  setSize(std::max(getSizeInBits(), getDataSizeInBits()));1842 1843  // Remember max struct/class alignment.1844  UnadjustedAlignment =1845      std::max(UnadjustedAlignment, Context.toCharUnitsFromBits(FieldAlign));1846  UpdateAlignment(Context.toCharUnitsFromBits(FieldAlign),1847                  Context.toCharUnitsFromBits(UnpackedFieldAlign));1848}1849 1850void ItaniumRecordLayoutBuilder::LayoutField(const FieldDecl *D,1851                                             bool InsertExtraPadding) {1852  auto *FieldClass = D->getType()->getAsCXXRecordDecl();1853  bool IsOverlappingEmptyField =1854      D->isPotentiallyOverlapping() && FieldClass->isEmpty();1855 1856  CharUnits FieldOffset =1857      (IsUnion || IsOverlappingEmptyField) ? CharUnits::Zero() : getDataSize();1858 1859  const bool DefaultsToAIXPowerAlignment =1860      Context.getTargetInfo().defaultsToAIXPowerAlignment();1861  bool FoundFirstNonOverlappingEmptyFieldForAIX = false;1862  if (DefaultsToAIXPowerAlignment && !HandledFirstNonOverlappingEmptyField) {1863    assert(FieldOffset == CharUnits::Zero() &&1864           "The first non-overlapping empty field should have been handled.");1865 1866    if (!IsOverlappingEmptyField) {1867      FoundFirstNonOverlappingEmptyFieldForAIX = true;1868 1869      // We're going to handle the "first member" based on1870      // `FoundFirstNonOverlappingEmptyFieldForAIX` during the current1871      // invocation of this function; record it as handled for future1872      // invocations (except for unions, because the current field does not1873      // represent all "firsts").1874      HandledFirstNonOverlappingEmptyField = !IsUnion;1875    }1876  }1877 1878  if (D->isBitField()) {1879    LayoutBitField(D);1880    return;1881  }1882 1883  uint64_t UnpaddedFieldOffset = getDataSizeInBits() - UnfilledBitsInLastUnit;1884  // Reset the unfilled bits.1885  UnfilledBitsInLastUnit = 0;1886  LastBitfieldStorageUnitSize = 0;1887 1888  llvm::Triple Target = Context.getTargetInfo().getTriple();1889 1890  AlignRequirementKind AlignRequirement = AlignRequirementKind::None;1891  CharUnits FieldSize;1892  CharUnits FieldAlign;1893  // The amount of this class's dsize occupied by the field.1894  // This is equal to FieldSize unless we're permitted to pack1895  // into the field's tail padding.1896  CharUnits EffectiveFieldSize;1897 1898  auto setDeclInfo = [&](bool IsIncompleteArrayType) {1899    auto TI = Context.getTypeInfoInChars(D->getType());1900    FieldAlign = TI.Align;1901    // Flexible array members don't have any size, but they have to be1902    // aligned appropriately for their element type.1903    EffectiveFieldSize = FieldSize =1904        IsIncompleteArrayType ? CharUnits::Zero() : TI.Width;1905    AlignRequirement = TI.AlignRequirement;1906  };1907 1908  if (D->getType()->isIncompleteArrayType()) {1909    setDeclInfo(true /* IsIncompleteArrayType */);1910  } else {1911    setDeclInfo(false /* IsIncompleteArrayType */);1912 1913    // A potentially-overlapping field occupies its dsize or nvsize, whichever1914    // is larger.1915    if (D->isPotentiallyOverlapping()) {1916      const ASTRecordLayout &Layout = Context.getASTRecordLayout(FieldClass);1917      EffectiveFieldSize =1918          std::max(Layout.getNonVirtualSize(), Layout.getDataSize());1919    }1920 1921    if (IsMsStruct) {1922      // If MS bitfield layout is required, figure out what type is being1923      // laid out and align the field to the width of that type.1924 1925      // Resolve all typedefs down to their base type and round up the field1926      // alignment if necessary.1927      QualType T = Context.getBaseElementType(D->getType());1928      if (const BuiltinType *BTy = T->getAs<BuiltinType>()) {1929        CharUnits TypeSize = Context.getTypeSizeInChars(BTy);1930 1931        if (!llvm::isPowerOf2_64(TypeSize.getQuantity())) {1932          assert(1933              !Context.getTargetInfo().getTriple().isWindowsMSVCEnvironment() &&1934              "Non PowerOf2 size in MSVC mode");1935          // Base types with sizes that aren't a power of two don't work1936          // with the layout rules for MS structs. This isn't an issue in1937          // MSVC itself since there are no such base data types there.1938          // On e.g. x86_32 mingw and linux, long double is 12 bytes though.1939          // Any structs involving that data type obviously can't be ABI1940          // compatible with MSVC regardless of how it is laid out.1941 1942          // Since ms_struct can be mass enabled (via a pragma or via the1943          // -mms-bitfields command line parameter), this can trigger for1944          // structs that don't actually need MSVC compatibility, so we1945          // need to be able to sidestep the ms_struct layout for these types.1946 1947          // Since the combination of -mms-bitfields together with structs1948          // like max_align_t (which contains a long double) for mingw is1949          // quite common (and GCC handles it silently), just handle it1950          // silently there. For other targets that have ms_struct enabled1951          // (most probably via a pragma or attribute), trigger a diagnostic1952          // that defaults to an error.1953          if (!Context.getTargetInfo().getTriple().isOSCygMing())1954            Diag(D->getLocation(), diag::warn_npot_ms_struct);1955        }1956        if (TypeSize > FieldAlign &&1957            llvm::isPowerOf2_64(TypeSize.getQuantity()))1958          FieldAlign = TypeSize;1959      }1960    }1961  }1962 1963  bool FieldPacked = (Packed && (!FieldClass || FieldClass->isPOD() ||1964                                 FieldClass->hasAttr<PackedAttr>() ||1965                                 Context.getLangOpts().getClangABICompat() <=1966                                     LangOptions::ClangABI::Ver15 ||1967                                 Target.isPS() || Target.isOSDarwin() ||1968                                 Target.isOSAIX())) ||1969                     D->hasAttr<PackedAttr>();1970 1971  // When used as part of a typedef, or together with a 'packed' attribute, the1972  // 'aligned' attribute can be used to decrease alignment. In that case, it1973  // overrides any computed alignment we have, and there is no need to upgrade1974  // the alignment.1975  auto alignedAttrCanDecreaseAIXAlignment = [AlignRequirement, FieldPacked] {1976    // Enum alignment sources can be safely ignored here, because this only1977    // helps decide whether we need the AIX alignment upgrade, which only1978    // applies to floating-point types.1979    return AlignRequirement == AlignRequirementKind::RequiredByTypedef ||1980           (AlignRequirement == AlignRequirementKind::RequiredByRecord &&1981            FieldPacked);1982  };1983 1984  // The AIX `power` alignment rules apply the natural alignment of the1985  // "first member" if it is of a floating-point data type (or is an aggregate1986  // whose recursively "first" member or element is such a type). The alignment1987  // associated with these types for subsequent members use an alignment value1988  // where the floating-point data type is considered to have 4-byte alignment.1989  //1990  // For the purposes of the foregoing: vtable pointers, non-empty base classes,1991  // and zero-width bit-fields count as prior members; members of empty class1992  // types marked `no_unique_address` are not considered to be prior members.1993  CharUnits PreferredAlign = FieldAlign;1994  if (DefaultsToAIXPowerAlignment && !alignedAttrCanDecreaseAIXAlignment() &&1995      (FoundFirstNonOverlappingEmptyFieldForAIX || IsNaturalAlign)) {1996    auto performBuiltinTypeAlignmentUpgrade = [&](const BuiltinType *BTy) {1997      if (BTy->getKind() == BuiltinType::Double ||1998          BTy->getKind() == BuiltinType::LongDouble) {1999        assert(PreferredAlign == CharUnits::fromQuantity(4) &&2000               "No need to upgrade the alignment value.");2001        PreferredAlign = CharUnits::fromQuantity(8);2002      }2003    };2004 2005    const Type *BaseTy = D->getType()->getBaseElementTypeUnsafe();2006    if (const ComplexType *CTy = BaseTy->getAs<ComplexType>()) {2007      performBuiltinTypeAlignmentUpgrade(2008          CTy->getElementType()->castAs<BuiltinType>());2009    } else if (const BuiltinType *BTy = BaseTy->getAs<BuiltinType>()) {2010      performBuiltinTypeAlignmentUpgrade(BTy);2011    } else if (const RecordType *RT = BaseTy->getAsCanonical<RecordType>()) {2012      const RecordDecl *RD = RT->getDecl();2013      const ASTRecordLayout &FieldRecord = Context.getASTRecordLayout(RD);2014      PreferredAlign = FieldRecord.getPreferredAlignment();2015    }2016  }2017 2018  // The align if the field is not packed. This is to check if the attribute2019  // was unnecessary (-Wpacked).2020  CharUnits UnpackedFieldAlign = FieldAlign;2021  CharUnits PackedFieldAlign = CharUnits::One();2022  CharUnits UnpackedFieldOffset = FieldOffset;2023  CharUnits OriginalFieldAlign = UnpackedFieldAlign;2024 2025  CharUnits MaxAlignmentInChars =2026      Context.toCharUnitsFromBits(D->getMaxAlignment());2027  PackedFieldAlign = std::max(PackedFieldAlign, MaxAlignmentInChars);2028  PreferredAlign = std::max(PreferredAlign, MaxAlignmentInChars);2029  UnpackedFieldAlign = std::max(UnpackedFieldAlign, MaxAlignmentInChars);2030 2031  // The maximum field alignment overrides the aligned attribute.2032  if (!MaxFieldAlignment.isZero()) {2033    PackedFieldAlign = std::min(PackedFieldAlign, MaxFieldAlignment);2034    PreferredAlign = std::min(PreferredAlign, MaxFieldAlignment);2035    UnpackedFieldAlign = std::min(UnpackedFieldAlign, MaxFieldAlignment);2036  }2037 2038 2039  if (!FieldPacked)2040    FieldAlign = UnpackedFieldAlign;2041  if (DefaultsToAIXPowerAlignment)2042    UnpackedFieldAlign = PreferredAlign;2043  if (FieldPacked) {2044    PreferredAlign = PackedFieldAlign;2045    FieldAlign = PackedFieldAlign;2046  }2047 2048  CharUnits AlignTo =2049      !DefaultsToAIXPowerAlignment ? FieldAlign : PreferredAlign;2050  // Round up the current record size to the field's alignment boundary.2051  FieldOffset = FieldOffset.alignTo(AlignTo);2052  UnpackedFieldOffset = UnpackedFieldOffset.alignTo(UnpackedFieldAlign);2053 2054  if (UseExternalLayout) {2055    FieldOffset = Context.toCharUnitsFromBits(2056        updateExternalFieldOffset(D, Context.toBits(FieldOffset)));2057 2058    if (!IsUnion && EmptySubobjects) {2059      // Record the fact that we're placing a field at this offset.2060      bool Allowed = EmptySubobjects->CanPlaceFieldAtOffset(D, FieldOffset);2061      (void)Allowed;2062      assert(Allowed && "Externally-placed field cannot be placed here");2063    }2064  } else {2065    if (!IsUnion && EmptySubobjects) {2066      // Check if we can place the field at this offset.2067      while (!EmptySubobjects->CanPlaceFieldAtOffset(D, FieldOffset)) {2068        // We couldn't place the field at the offset. Try again at a new offset.2069        // We try offset 0 (for an empty field) and then dsize(C) onwards.2070        if (FieldOffset == CharUnits::Zero() &&2071            getDataSize() != CharUnits::Zero())2072          FieldOffset = getDataSize().alignTo(AlignTo);2073        else2074          FieldOffset += AlignTo;2075      }2076    }2077  }2078 2079  // Place this field at the current location.2080  FieldOffsets.push_back(Context.toBits(FieldOffset));2081 2082  if (!UseExternalLayout)2083    CheckFieldPadding(Context.toBits(FieldOffset), UnpaddedFieldOffset,2084                      Context.toBits(UnpackedFieldOffset),2085                      Context.toBits(UnpackedFieldAlign), FieldPacked, D);2086 2087  if (InsertExtraPadding) {2088    CharUnits ASanAlignment = CharUnits::fromQuantity(8);2089    CharUnits ExtraSizeForAsan = ASanAlignment;2090    if (!FieldSize.isMultipleOf(ASanAlignment))2091      ExtraSizeForAsan += ASanAlignment - (FieldSize % ASanAlignment);2092    EffectiveFieldSize = FieldSize = FieldSize + ExtraSizeForAsan;2093  }2094 2095  // Reserve space for this field.2096  if (!IsOverlappingEmptyField) {2097    uint64_t EffectiveFieldSizeInBits = Context.toBits(EffectiveFieldSize);2098    if (IsUnion)2099      setDataSize(std::max(getDataSizeInBits(), EffectiveFieldSizeInBits));2100    else2101      setDataSize(FieldOffset + EffectiveFieldSize);2102 2103    PaddedFieldSize = std::max(PaddedFieldSize, FieldOffset + FieldSize);2104    setSize(std::max(getSizeInBits(), getDataSizeInBits()));2105  } else {2106    setSize(std::max(getSizeInBits(),2107                     (uint64_t)Context.toBits(FieldOffset + FieldSize)));2108  }2109 2110  // Remember max struct/class ABI-specified alignment.2111  UnadjustedAlignment = std::max(UnadjustedAlignment, FieldAlign);2112  UpdateAlignment(FieldAlign, UnpackedFieldAlign, PreferredAlign);2113 2114  // For checking the alignment of inner fields against2115  // the alignment of its parent record.2116  if (const RecordDecl *RD = D->getParent()) {2117    // Check if packed attribute or pragma pack is present.2118    if (RD->hasAttr<PackedAttr>() || !MaxFieldAlignment.isZero())2119      if (FieldAlign < OriginalFieldAlign)2120        if (D->getType()->isRecordType()) {2121          // If the offset is not a multiple of the alignment of2122          // the type, raise the warning.2123          // TODO: Takes no account the alignment of the outer struct2124          if (!FieldOffset.isMultipleOf(OriginalFieldAlign))2125            Diag(D->getLocation(), diag::warn_unaligned_access)2126                << Context.getCanonicalTagType(RD) << D->getName()2127                << D->getType();2128        }2129  }2130 2131  if (Packed && !FieldPacked && PackedFieldAlign < FieldAlign)2132    Diag(D->getLocation(), diag::warn_unpacked_field) << D;2133}2134 2135void ItaniumRecordLayoutBuilder::FinishLayout(const NamedDecl *D) {2136  // In C++, records cannot be of size 0.2137  if (Context.getLangOpts().CPlusPlus && getSizeInBits() == 0) {2138    if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {2139      // Compatibility with gcc requires a class (pod or non-pod)2140      // which is not empty but of size 0; such as having fields of2141      // array of zero-length, remains of Size 02142      if (RD->isEmpty())2143        setSize(CharUnits::One());2144    }2145    else2146      setSize(CharUnits::One());2147  }2148 2149  // If we have any remaining field tail padding, include that in the overall2150  // size.2151  setSize(std::max(getSizeInBits(), (uint64_t)Context.toBits(PaddedFieldSize)));2152 2153  // Finally, round the size of the record up to the alignment of the2154  // record itself.2155  uint64_t UnpaddedSize = getSizeInBits() - UnfilledBitsInLastUnit;2156  uint64_t UnpackedSizeInBits =2157      llvm::alignTo(getSizeInBits(), Context.toBits(UnpackedAlignment));2158 2159  uint64_t RoundedSize = llvm::alignTo(2160      getSizeInBits(),2161      Context.toBits(!Context.getTargetInfo().defaultsToAIXPowerAlignment()2162                         ? Alignment2163                         : PreferredAlignment));2164 2165  if (UseExternalLayout) {2166    // If we're inferring alignment, and the external size is smaller than2167    // our size after we've rounded up to alignment, conservatively set the2168    // alignment to 1.2169    if (InferAlignment && External.Size < RoundedSize) {2170      Alignment = CharUnits::One();2171      PreferredAlignment = CharUnits::One();2172      InferAlignment = false;2173    }2174    setSize(External.Size);2175    return;2176  }2177 2178  // Set the size to the final size.2179  setSize(RoundedSize);2180 2181  unsigned CharBitNum = Context.getTargetInfo().getCharWidth();2182  if (const RecordDecl *RD = dyn_cast<RecordDecl>(D)) {2183    // Warn if padding was introduced to the struct/class/union.2184    if (getSizeInBits() > UnpaddedSize) {2185      unsigned PadSize = getSizeInBits() - UnpaddedSize;2186      bool InBits = true;2187      if (PadSize % CharBitNum == 0) {2188        PadSize = PadSize / CharBitNum;2189        InBits = false;2190      }2191      Diag(RD->getLocation(), diag::warn_padded_struct_size)2192          << Context.getCanonicalTagType(RD) << PadSize2193          << (InBits ? 1 : 0); // (byte|bit)2194    }2195 2196    const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD);2197 2198    // Warn if we packed it unnecessarily, when the unpacked alignment is not2199    // greater than the one after packing, the size in bits doesn't change and2200    // the offset of each field is identical.2201    // Unless the type is non-POD (for Clang ABI > 15), where the packed2202    // attribute on such a type does allow the type to be packed into other2203    // structures that use the packed attribute.2204    if (Packed && UnpackedAlignment <= Alignment &&2205        UnpackedSizeInBits == getSizeInBits() && !HasPackedField &&2206        (!CXXRD || CXXRD->isPOD() ||2207         Context.getLangOpts().getClangABICompat() <=2208             LangOptions::ClangABI::Ver15))2209      Diag(D->getLocation(), diag::warn_unnecessary_packed)2210          << Context.getCanonicalTagType(RD);2211  }2212}2213 2214void ItaniumRecordLayoutBuilder::UpdateAlignment(2215    CharUnits NewAlignment, CharUnits UnpackedNewAlignment,2216    CharUnits PreferredNewAlignment) {2217  // The alignment is not modified when using 'mac68k' alignment or when2218  // we have an externally-supplied layout that also provides overall alignment.2219  if (IsMac68kAlign || (UseExternalLayout && !InferAlignment))2220    return;2221 2222  if (NewAlignment > Alignment) {2223    assert(llvm::isPowerOf2_64(NewAlignment.getQuantity()) &&2224           "Alignment not a power of 2");2225    Alignment = NewAlignment;2226  }2227 2228  if (UnpackedNewAlignment > UnpackedAlignment) {2229    assert(llvm::isPowerOf2_64(UnpackedNewAlignment.getQuantity()) &&2230           "Alignment not a power of 2");2231    UnpackedAlignment = UnpackedNewAlignment;2232  }2233 2234  if (PreferredNewAlignment > PreferredAlignment) {2235    assert(llvm::isPowerOf2_64(PreferredNewAlignment.getQuantity()) &&2236           "Alignment not a power of 2");2237    PreferredAlignment = PreferredNewAlignment;2238  }2239}2240 2241uint64_t2242ItaniumRecordLayoutBuilder::updateExternalFieldOffset(const FieldDecl *Field,2243                                                      uint64_t ComputedOffset) {2244  uint64_t ExternalFieldOffset = External.getExternalFieldOffset(Field);2245 2246  if (InferAlignment && ExternalFieldOffset < ComputedOffset) {2247    // The externally-supplied field offset is before the field offset we2248    // computed. Assume that the structure is packed.2249    Alignment = CharUnits::One();2250    PreferredAlignment = CharUnits::One();2251    InferAlignment = false;2252  }2253 2254  // Use the externally-supplied field offset.2255  return ExternalFieldOffset;2256}2257 2258/// Get diagnostic %select index for tag kind for2259/// field padding diagnostic message.2260/// WARNING: Indexes apply to particular diagnostics only!2261///2262/// \returns diagnostic %select index.2263static unsigned getPaddingDiagFromTagKind(TagTypeKind Tag) {2264  switch (Tag) {2265  case TagTypeKind::Struct:2266    return 0;2267  case TagTypeKind::Interface:2268    return 1;2269  case TagTypeKind::Class:2270    return 2;2271  default: llvm_unreachable("Invalid tag kind for field padding diagnostic!");2272  }2273}2274 2275static void CheckFieldPadding(const ASTContext &Context, bool IsUnion,2276                              uint64_t Offset, uint64_t UnpaddedOffset,2277                              const FieldDecl *D) {2278  // We let objc ivars without warning, objc interfaces generally are not used2279  // for padding tricks.2280  if (isa<ObjCIvarDecl>(D))2281    return;2282 2283  // Don't warn about structs created without a SourceLocation.  This can2284  // be done by clients of the AST, such as codegen.2285  if (D->getLocation().isInvalid())2286    return;2287 2288  unsigned CharBitNum = Context.getTargetInfo().getCharWidth();2289 2290  // Warn if padding was introduced to the struct/class.2291  if (!IsUnion && Offset > UnpaddedOffset) {2292    unsigned PadSize = Offset - UnpaddedOffset;2293    bool InBits = true;2294    if (PadSize % CharBitNum == 0) {2295      PadSize = PadSize / CharBitNum;2296      InBits = false;2297    }2298    if (D->getIdentifier()) {2299      auto Diagnostic = D->isBitField() ? diag::warn_padded_struct_bitfield2300                                        : diag::warn_padded_struct_field;2301      Context.getDiagnostics().Report(D->getLocation(),2302                                      Diagnostic)2303          << getPaddingDiagFromTagKind(D->getParent()->getTagKind())2304          << Context.getCanonicalTagType(D->getParent()) << PadSize2305          << (InBits ? 1 : 0) // (byte|bit)2306          << D->getIdentifier();2307    } else {2308      auto Diagnostic = D->isBitField() ? diag::warn_padded_struct_anon_bitfield2309                                        : diag::warn_padded_struct_anon_field;2310      Context.getDiagnostics().Report(D->getLocation(),2311                                      Diagnostic)2312          << getPaddingDiagFromTagKind(D->getParent()->getTagKind())2313          << Context.getCanonicalTagType(D->getParent()) << PadSize2314          << (InBits ? 1 : 0); // (byte|bit)2315    }2316  }2317}2318 2319void ItaniumRecordLayoutBuilder::CheckFieldPadding(2320    uint64_t Offset, uint64_t UnpaddedOffset, uint64_t UnpackedOffset,2321    unsigned UnpackedAlign, bool isPacked, const FieldDecl *D) {2322  ::CheckFieldPadding(Context, IsUnion, Offset, UnpaddedOffset, D);2323  if (isPacked && Offset != UnpackedOffset) {2324    HasPackedField = true;2325  }2326}2327 2328static const CXXMethodDecl *computeKeyFunction(ASTContext &Context,2329                                               const CXXRecordDecl *RD) {2330  // If a class isn't polymorphic it doesn't have a key function.2331  if (!RD->isPolymorphic())2332    return nullptr;2333 2334  // A class that is not externally visible doesn't have a key function. (Or2335  // at least, there's no point to assigning a key function to such a class;2336  // this doesn't affect the ABI.)2337  if (!RD->isExternallyVisible())2338    return nullptr;2339 2340  // Template instantiations don't have key functions per Itanium C++ ABI 5.2.6.2341  // Same behavior as GCC.2342  TemplateSpecializationKind TSK = RD->getTemplateSpecializationKind();2343  if (TSK == TSK_ImplicitInstantiation ||2344      TSK == TSK_ExplicitInstantiationDeclaration ||2345      TSK == TSK_ExplicitInstantiationDefinition)2346    return nullptr;2347 2348  bool allowInlineFunctions =2349    Context.getTargetInfo().getCXXABI().canKeyFunctionBeInline();2350 2351  for (const CXXMethodDecl *MD : RD->methods()) {2352    if (!MD->isVirtual())2353      continue;2354 2355    if (MD->isPureVirtual())2356      continue;2357 2358    // Ignore implicit member functions, they are always marked as inline, but2359    // they don't have a body until they're defined.2360    if (MD->isImplicit())2361      continue;2362 2363    if (MD->isInlineSpecified() || MD->isConstexpr())2364      continue;2365 2366    if (MD->hasInlineBody())2367      continue;2368 2369    // Ignore inline deleted or defaulted functions.2370    if (!MD->isUserProvided())2371      continue;2372 2373    // In certain ABIs, ignore functions with out-of-line inline definitions.2374    if (!allowInlineFunctions) {2375      const FunctionDecl *Def;2376      if (MD->hasBody(Def) && Def->isInlineSpecified())2377        continue;2378    }2379 2380    if (Context.getLangOpts().CUDA) {2381      // While compiler may see key method in this TU, during CUDA2382      // compilation we should ignore methods that are not accessible2383      // on this side of compilation.2384      if (Context.getLangOpts().CUDAIsDevice) {2385        // In device mode ignore methods without __device__ attribute.2386        if (!MD->hasAttr<CUDADeviceAttr>())2387          continue;2388      } else {2389        // In host mode ignore __device__-only methods.2390        if (!MD->hasAttr<CUDAHostAttr>() && MD->hasAttr<CUDADeviceAttr>())2391          continue;2392      }2393    }2394 2395    // If the key function is dllimport but the class isn't, then the class has2396    // no key function. The DLL that exports the key function won't export the2397    // vtable in this case.2398    if (MD->hasAttr<DLLImportAttr>() && !RD->hasAttr<DLLImportAttr>() &&2399        !Context.getTargetInfo().hasPS4DLLImportExport())2400      return nullptr;2401 2402    // We found it.2403    return MD;2404  }2405 2406  return nullptr;2407}2408 2409DiagnosticBuilder ItaniumRecordLayoutBuilder::Diag(SourceLocation Loc,2410                                                   unsigned DiagID) {2411  return Context.getDiagnostics().Report(Loc, DiagID);2412}2413 2414/// Does the target C++ ABI require us to skip over the tail-padding2415/// of the given class (considering it as a base class) when allocating2416/// objects?2417static bool mustSkipTailPadding(TargetCXXABI ABI, const CXXRecordDecl *RD) {2418  switch (ABI.getTailPaddingUseRules()) {2419  case TargetCXXABI::AlwaysUseTailPadding:2420    return false;2421 2422  case TargetCXXABI::UseTailPaddingUnlessPOD03:2423    // FIXME: To the extent that this is meant to cover the Itanium ABI2424    // rules, we should implement the restrictions about over-sized2425    // bitfields:2426    //2427    // http://itanium-cxx-abi.github.io/cxx-abi/abi.html#POD :2428    //   In general, a type is considered a POD for the purposes of2429    //   layout if it is a POD type (in the sense of ISO C++2430    //   [basic.types]). However, a POD-struct or POD-union (in the2431    //   sense of ISO C++ [class]) with a bitfield member whose2432    //   declared width is wider than the declared type of the2433    //   bitfield is not a POD for the purpose of layout.  Similarly,2434    //   an array type is not a POD for the purpose of layout if the2435    //   element type of the array is not a POD for the purpose of2436    //   layout.2437    //2438    //   Where references to the ISO C++ are made in this paragraph,2439    //   the Technical Corrigendum 1 version of the standard is2440    //   intended.2441    return RD->isPOD();2442 2443  case TargetCXXABI::UseTailPaddingUnlessPOD11:2444    // This is equivalent to RD->getTypeForDecl().isCXX11PODType(),2445    // but with a lot of abstraction penalty stripped off.  This does2446    // assume that these properties are set correctly even in C++982447    // mode; fortunately, that is true because we want to assign2448    // consistently semantics to the type-traits intrinsics (or at2449    // least as many of them as possible).2450    return RD->isTrivial() && RD->isCXX11StandardLayout();2451  }2452 2453  llvm_unreachable("bad tail-padding use kind");2454}2455 2456// This section contains an implementation of struct layout that is, up to the2457// included tests, compatible with cl.exe (2013).  The layout produced is2458// significantly different than those produced by the Itanium ABI.  Here we note2459// the most important differences.2460//2461// * The alignment of bitfields in unions is ignored when computing the2462//   alignment of the union.2463// * The existence of zero-width bitfield that occurs after anything other than2464//   a non-zero length bitfield is ignored.2465// * There is no explicit primary base for the purposes of layout.  All bases2466//   with vfptrs are laid out first, followed by all bases without vfptrs.2467// * The Itanium equivalent vtable pointers are split into a vfptr (virtual2468//   function pointer) and a vbptr (virtual base pointer).  They can each be2469//   shared with a, non-virtual bases. These bases need not be the same.  vfptrs2470//   always occur at offset 0.  vbptrs can occur at an arbitrary offset and are2471//   placed after the lexicographically last non-virtual base.  This placement2472//   is always before fields but can be in the middle of the non-virtual bases2473//   due to the two-pass layout scheme for non-virtual-bases.2474// * Virtual bases sometimes require a 'vtordisp' field that is laid out before2475//   the virtual base and is used in conjunction with virtual overrides during2476//   construction and destruction.  This is always a 4 byte value and is used as2477//   an alternative to constructor vtables.2478// * vtordisps are allocated in a block of memory with size and alignment equal2479//   to the alignment of the completed structure (before applying __declspec(2480//   align())).  The vtordisp always occur at the end of the allocation block,2481//   immediately prior to the virtual base.2482// * vfptrs are injected after all bases and fields have been laid out.  In2483//   order to guarantee proper alignment of all fields, the vfptr injection2484//   pushes all bases and fields back by the alignment imposed by those bases2485//   and fields.  This can potentially add a significant amount of padding.2486//   vfptrs are always injected at offset 0.2487// * vbptrs are injected after all bases and fields have been laid out.  In2488//   order to guarantee proper alignment of all fields, the vfptr injection2489//   pushes all bases and fields back by the alignment imposed by those bases2490//   and fields.  This can potentially add a significant amount of padding.2491//   vbptrs are injected immediately after the last non-virtual base as2492//   lexicographically ordered in the code.  If this site isn't pointer aligned2493//   the vbptr is placed at the next properly aligned location.  Enough padding2494//   is added to guarantee a fit.2495// * The last zero sized non-virtual base can be placed at the end of the2496//   struct (potentially aliasing another object), or may alias with the first2497//   field, even if they are of the same type.2498// * The last zero size virtual base may be placed at the end of the struct2499//   potentially aliasing another object.2500// * The ABI attempts to avoid aliasing of zero sized bases by adding padding2501//   between bases or vbases with specific properties.  The criteria for2502//   additional padding between two bases is that the first base is zero sized2503//   or ends with a zero sized subobject and the second base is zero sized or2504//   trails with a zero sized base or field (sharing of vfptrs can reorder the2505//   layout of the so the leading base is not always the first one declared).2506//   This rule does take into account fields that are not records, so padding2507//   will occur even if the last field is, e.g. an int. The padding added for2508//   bases is 1 byte.  The padding added between vbases depends on the alignment2509//   of the object but is at least 4 bytes (in both 32 and 64 bit modes).2510// * There is no concept of non-virtual alignment, non-virtual alignment and2511//   alignment are always identical.2512// * There is a distinction between alignment and required alignment.2513//   __declspec(align) changes the required alignment of a struct.  This2514//   alignment is _always_ obeyed, even in the presence of #pragma pack. A2515//   record inherits required alignment from all of its fields and bases.2516// * __declspec(align) on bitfields has the effect of changing the bitfield's2517//   alignment instead of its required alignment.  This is the only known way2518//   to make the alignment of a struct bigger than 8.  Interestingly enough2519//   this alignment is also immune to the effects of #pragma pack and can be2520//   used to create structures with large alignment under #pragma pack.2521//   However, because it does not impact required alignment, such a structure,2522//   when used as a field or base, will not be aligned if #pragma pack is2523//   still active at the time of use.2524//2525// Known incompatibilities:2526// * all: #pragma pack between fields in a record2527// * 2010 and back: If the last field in a record is a bitfield, every object2528//   laid out after the record will have extra padding inserted before it.  The2529//   extra padding will have size equal to the size of the storage class of the2530//   bitfield.  0 sized bitfields don't exhibit this behavior and the extra2531//   padding can be avoided by adding a 0 sized bitfield after the non-zero-2532//   sized bitfield.2533// * 2012 and back: In 64-bit mode, if the alignment of a record is 16 or2534//   greater due to __declspec(align()) then a second layout phase occurs after2535//   The locations of the vf and vb pointers are known.  This layout phase2536//   suffers from the "last field is a bitfield" bug in 2010 and results in2537//   _every_ field getting padding put in front of it, potentially including the2538//   vfptr, leaving the vfprt at a non-zero location which results in a fault if2539//   anything tries to read the vftbl.  The second layout phase also treats2540//   bitfields as separate entities and gives them each storage rather than2541//   packing them.  Additionally, because this phase appears to perform a2542//   (an unstable) sort on the members before laying them out and because merged2543//   bitfields have the same address, the bitfields end up in whatever order2544//   the sort left them in, a behavior we could never hope to replicate.2545 2546namespace {2547struct MicrosoftRecordLayoutBuilder {2548  struct ElementInfo {2549    CharUnits Size;2550    CharUnits Alignment;2551  };2552  typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetsMapTy;2553  MicrosoftRecordLayoutBuilder(const ASTContext &Context,2554                               EmptySubobjectMap *EmptySubobjects)2555      : Context(Context), EmptySubobjects(EmptySubobjects),2556        RemainingBitsInField(0) {}2557 2558private:2559  MicrosoftRecordLayoutBuilder(const MicrosoftRecordLayoutBuilder &) = delete;2560  void operator=(const MicrosoftRecordLayoutBuilder &) = delete;2561public:2562  void layout(const RecordDecl *RD);2563  void cxxLayout(const CXXRecordDecl *RD);2564  /// Initializes size and alignment and honors some flags.2565  void initializeLayout(const RecordDecl *RD);2566  /// Initialized C++ layout, compute alignment and virtual alignment and2567  /// existence of vfptrs and vbptrs.  Alignment is needed before the vfptr is2568  /// laid out.2569  void initializeCXXLayout(const CXXRecordDecl *RD);2570  void layoutNonVirtualBases(const CXXRecordDecl *RD);2571  void layoutNonVirtualBase(const CXXRecordDecl *RD,2572                            const CXXRecordDecl *BaseDecl,2573                            const ASTRecordLayout &BaseLayout,2574                            const ASTRecordLayout *&PreviousBaseLayout);2575  void injectVFPtr(const CXXRecordDecl *RD);2576  void injectVBPtr(const CXXRecordDecl *RD);2577  /// Lays out the fields of the record.  Also rounds size up to2578  /// alignment.2579  void layoutFields(const RecordDecl *RD);2580  void layoutField(const FieldDecl *FD);2581  void layoutBitField(const FieldDecl *FD);2582  /// Lays out a single zero-width bit-field in the record and handles2583  /// special cases associated with zero-width bit-fields.2584  void layoutZeroWidthBitField(const FieldDecl *FD);2585  void layoutVirtualBases(const CXXRecordDecl *RD);2586  void finalizeLayout(const RecordDecl *RD);2587  /// Gets the size and alignment of a base taking pragma pack and2588  /// __declspec(align) into account.2589  ElementInfo getAdjustedElementInfo(const ASTRecordLayout &Layout);2590  /// Gets the size and alignment of a field taking pragma  pack and2591  /// __declspec(align) into account.  It also updates RequiredAlignment as a2592  /// side effect because it is most convenient to do so here.2593  ElementInfo getAdjustedElementInfo(const FieldDecl *FD);2594  /// Places a field at an offset in CharUnits.2595  void placeFieldAtOffset(CharUnits FieldOffset) {2596    FieldOffsets.push_back(Context.toBits(FieldOffset));2597  }2598  /// Places a bitfield at a bit offset.2599  void placeFieldAtBitOffset(uint64_t FieldOffset) {2600    FieldOffsets.push_back(FieldOffset);2601  }2602  /// Compute the set of virtual bases for which vtordisps are required.2603  void computeVtorDispSet(2604      llvm::SmallPtrSetImpl<const CXXRecordDecl *> &HasVtorDispSet,2605      const CXXRecordDecl *RD) const;2606  const ASTContext &Context;2607  EmptySubobjectMap *EmptySubobjects;2608 2609  /// The size of the record being laid out.2610  CharUnits Size;2611  /// The non-virtual size of the record layout.2612  CharUnits NonVirtualSize;2613  /// The data size of the record layout.2614  CharUnits DataSize;2615  /// The current alignment of the record layout.2616  CharUnits Alignment;2617  /// The maximum allowed field alignment. This is set by #pragma pack.2618  CharUnits MaxFieldAlignment;2619  /// The alignment that this record must obey.  This is imposed by2620  /// __declspec(align()) on the record itself or one of its fields or bases.2621  CharUnits RequiredAlignment;2622  /// The size of the allocation of the currently active bitfield.2623  /// This value isn't meaningful unless LastFieldIsNonZeroWidthBitfield2624  /// is true.2625  CharUnits CurrentBitfieldSize;2626  /// Offset to the virtual base table pointer (if one exists).2627  CharUnits VBPtrOffset;2628  /// Minimum record size possible.2629  CharUnits MinEmptyStructSize;2630  /// The size and alignment info of a pointer.2631  ElementInfo PointerInfo;2632  /// The primary base class (if one exists).2633  const CXXRecordDecl *PrimaryBase;2634  /// The class we share our vb-pointer with.2635  const CXXRecordDecl *SharedVBPtrBase;2636  /// The collection of field offsets.2637  SmallVector<uint64_t, 16> FieldOffsets;2638  /// Base classes and their offsets in the record.2639  BaseOffsetsMapTy Bases;2640  /// virtual base classes and their offsets in the record.2641  ASTRecordLayout::VBaseOffsetsMapTy VBases;2642  /// The number of remaining bits in our last bitfield allocation.2643  unsigned RemainingBitsInField;2644  bool IsUnion : 1;2645  /// True if the last field laid out was a bitfield and was not 02646  /// width.2647  bool LastFieldIsNonZeroWidthBitfield : 1;2648  /// True if the class has its own vftable pointer.2649  bool HasOwnVFPtr : 1;2650  /// True if the class has a vbtable pointer.2651  bool HasVBPtr : 1;2652  /// True if the last sub-object within the type is zero sized or the2653  /// object itself is zero sized.  This *does not* count members that are not2654  /// records.  Only used for MS-ABI.2655  bool EndsWithZeroSizedObject : 1;2656  /// True if this class is zero sized or first base is zero sized or2657  /// has this property.  Only used for MS-ABI.2658  bool LeadsWithZeroSizedBase : 1;2659 2660  /// True if the external AST source provided a layout for this record.2661  bool UseExternalLayout : 1;2662 2663  /// The layout provided by the external AST source. Only active if2664  /// UseExternalLayout is true.2665  ExternalLayout External;2666};2667} // namespace2668 2669MicrosoftRecordLayoutBuilder::ElementInfo2670MicrosoftRecordLayoutBuilder::getAdjustedElementInfo(2671    const ASTRecordLayout &Layout) {2672  ElementInfo Info;2673  Info.Alignment = Layout.getAlignment();2674  // Respect pragma pack.2675  if (!MaxFieldAlignment.isZero())2676    Info.Alignment = std::min(Info.Alignment, MaxFieldAlignment);2677  // Track zero-sized subobjects here where it's already available.2678  EndsWithZeroSizedObject = Layout.endsWithZeroSizedObject();2679  // Respect required alignment, this is necessary because we may have adjusted2680  // the alignment in the case of pragma pack.  Note that the required alignment2681  // doesn't actually apply to the struct alignment at this point.2682  Alignment = std::max(Alignment, Info.Alignment);2683  RequiredAlignment = std::max(RequiredAlignment, Layout.getRequiredAlignment());2684  Info.Alignment = std::max(Info.Alignment, Layout.getRequiredAlignment());2685  Info.Size = Layout.getNonVirtualSize();2686  return Info;2687}2688 2689MicrosoftRecordLayoutBuilder::ElementInfo2690MicrosoftRecordLayoutBuilder::getAdjustedElementInfo(2691    const FieldDecl *FD) {2692  // Get the alignment of the field type's natural alignment, ignore any2693  // alignment attributes.2694  auto TInfo =2695      Context.getTypeInfoInChars(FD->getType()->getUnqualifiedDesugaredType());2696  ElementInfo Info{TInfo.Width, TInfo.Align};2697  // Respect align attributes on the field.2698  CharUnits FieldRequiredAlignment =2699      Context.toCharUnitsFromBits(FD->getMaxAlignment());2700  // Respect align attributes on the type.2701  if (Context.isAlignmentRequired(FD->getType()))2702    FieldRequiredAlignment = std::max(2703        Context.getTypeAlignInChars(FD->getType()), FieldRequiredAlignment);2704  // Respect attributes applied to subobjects of the field.2705  if (FD->isBitField())2706    // For some reason __declspec align impacts alignment rather than required2707    // alignment when it is applied to bitfields.2708    Info.Alignment = std::max(Info.Alignment, FieldRequiredAlignment);2709  else {2710    if (const auto *RT = FD->getType()2711                             ->getBaseElementTypeUnsafe()2712                             ->getAsCanonical<RecordType>()) {2713      auto const &Layout = Context.getASTRecordLayout(RT->getDecl());2714      EndsWithZeroSizedObject = Layout.endsWithZeroSizedObject();2715      FieldRequiredAlignment = std::max(FieldRequiredAlignment,2716                                        Layout.getRequiredAlignment());2717    }2718    // Capture required alignment as a side-effect.2719    RequiredAlignment = std::max(RequiredAlignment, FieldRequiredAlignment);2720  }2721  // Respect pragma pack, attribute pack and declspec align2722  if (!MaxFieldAlignment.isZero())2723    Info.Alignment = std::min(Info.Alignment, MaxFieldAlignment);2724  if (FD->hasAttr<PackedAttr>())2725    Info.Alignment = CharUnits::One();2726  Info.Alignment = std::max(Info.Alignment, FieldRequiredAlignment);2727  return Info;2728}2729 2730void MicrosoftRecordLayoutBuilder::layout(const RecordDecl *RD) {2731  // For C record layout, zero-sized records always have size 4.2732  MinEmptyStructSize = CharUnits::fromQuantity(4);2733  initializeLayout(RD);2734  layoutFields(RD);2735  DataSize = Size = Size.alignTo(Alignment);2736  RequiredAlignment = std::max(2737      RequiredAlignment, Context.toCharUnitsFromBits(RD->getMaxAlignment()));2738  finalizeLayout(RD);2739}2740 2741void MicrosoftRecordLayoutBuilder::cxxLayout(const CXXRecordDecl *RD) {2742  // The C++ standard says that empty structs have size 1.2743  MinEmptyStructSize = CharUnits::One();2744  initializeLayout(RD);2745  initializeCXXLayout(RD);2746  layoutNonVirtualBases(RD);2747  layoutFields(RD);2748  injectVBPtr(RD);2749  injectVFPtr(RD);2750  if (HasOwnVFPtr || (HasVBPtr && !SharedVBPtrBase))2751    Alignment = std::max(Alignment, PointerInfo.Alignment);2752  auto RoundingAlignment = Alignment;2753  if (!MaxFieldAlignment.isZero())2754    RoundingAlignment = std::min(RoundingAlignment, MaxFieldAlignment);2755  if (!UseExternalLayout)2756    Size = Size.alignTo(RoundingAlignment);2757  NonVirtualSize = Size;2758  RequiredAlignment = std::max(2759      RequiredAlignment, Context.toCharUnitsFromBits(RD->getMaxAlignment()));2760  layoutVirtualBases(RD);2761  finalizeLayout(RD);2762}2763 2764void MicrosoftRecordLayoutBuilder::initializeLayout(const RecordDecl *RD) {2765  IsUnion = RD->isUnion();2766  Size = CharUnits::Zero();2767  Alignment = CharUnits::One();2768  // In 64-bit mode we always perform an alignment step after laying out vbases.2769  // In 32-bit mode we do not.  The check to see if we need to perform alignment2770  // checks the RequiredAlignment field and performs alignment if it isn't 0.2771  RequiredAlignment = Context.getTargetInfo().getTriple().isArch64Bit()2772                          ? CharUnits::One()2773                          : CharUnits::Zero();2774  // Compute the maximum field alignment.2775  MaxFieldAlignment = CharUnits::Zero();2776  // Honor the default struct packing maximum alignment flag.2777  if (unsigned DefaultMaxFieldAlignment = Context.getLangOpts().PackStruct)2778      MaxFieldAlignment = CharUnits::fromQuantity(DefaultMaxFieldAlignment);2779  // Honor the packing attribute.  The MS-ABI ignores pragma pack if its larger2780  // than the pointer size.2781  if (const MaxFieldAlignmentAttr *MFAA = RD->getAttr<MaxFieldAlignmentAttr>()){2782    unsigned PackedAlignment = MFAA->getAlignment();2783    if (PackedAlignment <=2784        Context.getTargetInfo().getPointerWidth(LangAS::Default))2785      MaxFieldAlignment = Context.toCharUnitsFromBits(PackedAlignment);2786  }2787  // Packed attribute forces max field alignment to be 1.2788  if (RD->hasAttr<PackedAttr>())2789    MaxFieldAlignment = CharUnits::One();2790 2791  // Try to respect the external layout if present.2792  UseExternalLayout = false;2793  if (ExternalASTSource *Source = Context.getExternalSource())2794    UseExternalLayout = Source->layoutRecordType(2795        RD, External.Size, External.Align, External.FieldOffsets,2796        External.BaseOffsets, External.VirtualBaseOffsets);2797}2798 2799void2800MicrosoftRecordLayoutBuilder::initializeCXXLayout(const CXXRecordDecl *RD) {2801  EndsWithZeroSizedObject = false;2802  LeadsWithZeroSizedBase = false;2803  HasOwnVFPtr = false;2804  HasVBPtr = false;2805  PrimaryBase = nullptr;2806  SharedVBPtrBase = nullptr;2807  // Calculate pointer size and alignment.  These are used for vfptr and vbprt2808  // injection.2809  PointerInfo.Size = Context.toCharUnitsFromBits(2810      Context.getTargetInfo().getPointerWidth(LangAS::Default));2811  PointerInfo.Alignment = Context.toCharUnitsFromBits(2812      Context.getTargetInfo().getPointerAlign(LangAS::Default));2813  // Respect pragma pack.2814  if (!MaxFieldAlignment.isZero())2815    PointerInfo.Alignment = std::min(PointerInfo.Alignment, MaxFieldAlignment);2816}2817 2818void2819MicrosoftRecordLayoutBuilder::layoutNonVirtualBases(const CXXRecordDecl *RD) {2820  // The MS-ABI lays out all bases that contain leading vfptrs before it lays2821  // out any bases that do not contain vfptrs.  We implement this as two passes2822  // over the bases.  This approach guarantees that the primary base is laid out2823  // first.  We use these passes to calculate some additional aggregated2824  // information about the bases, such as required alignment and the presence of2825  // zero sized members.2826  const ASTRecordLayout *PreviousBaseLayout = nullptr;2827  bool HasPolymorphicBaseClass = false;2828  // Iterate through the bases and lay out the non-virtual ones.2829  for (const CXXBaseSpecifier &Base : RD->bases()) {2830    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();2831    HasPolymorphicBaseClass |= BaseDecl->isPolymorphic();2832    const ASTRecordLayout &BaseLayout = Context.getASTRecordLayout(BaseDecl);2833    // Mark and skip virtual bases.2834    if (Base.isVirtual()) {2835      HasVBPtr = true;2836      continue;2837    }2838    // Check for a base to share a VBPtr with.2839    if (!SharedVBPtrBase && BaseLayout.hasVBPtr()) {2840      SharedVBPtrBase = BaseDecl;2841      HasVBPtr = true;2842    }2843    // Only lay out bases with extendable VFPtrs on the first pass.2844    if (!BaseLayout.hasExtendableVFPtr())2845      continue;2846    // If we don't have a primary base, this one qualifies.2847    if (!PrimaryBase) {2848      PrimaryBase = BaseDecl;2849      LeadsWithZeroSizedBase = BaseLayout.leadsWithZeroSizedBase();2850    }2851    // Lay out the base.2852    layoutNonVirtualBase(RD, BaseDecl, BaseLayout, PreviousBaseLayout);2853  }2854  // Figure out if we need a fresh VFPtr for this class.2855  if (RD->isPolymorphic()) {2856    if (!HasPolymorphicBaseClass)2857      // This class introduces polymorphism, so we need a vftable to store the2858      // RTTI information.2859      HasOwnVFPtr = true;2860    else if (!PrimaryBase) {2861      // We have a polymorphic base class but can't extend its vftable. Add a2862      // new vfptr if we would use any vftable slots.2863      for (CXXMethodDecl *M : RD->methods()) {2864        if (MicrosoftVTableContext::hasVtableSlot(M) &&2865            M->size_overridden_methods() == 0) {2866          HasOwnVFPtr = true;2867          break;2868        }2869      }2870    }2871  }2872  // If we don't have a primary base then we have a leading object that could2873  // itself lead with a zero-sized object, something we track.2874  bool CheckLeadingLayout = !PrimaryBase;2875  // Iterate through the bases and lay out the non-virtual ones.2876  for (const CXXBaseSpecifier &Base : RD->bases()) {2877    if (Base.isVirtual())2878      continue;2879    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();2880    const ASTRecordLayout &BaseLayout = Context.getASTRecordLayout(BaseDecl);2881    // Only lay out bases without extendable VFPtrs on the second pass.2882    if (BaseLayout.hasExtendableVFPtr()) {2883      VBPtrOffset = Bases[BaseDecl] + BaseLayout.getNonVirtualSize();2884      continue;2885    }2886    // If this is the first layout, check to see if it leads with a zero sized2887    // object.  If it does, so do we.2888    if (CheckLeadingLayout) {2889      CheckLeadingLayout = false;2890      LeadsWithZeroSizedBase = BaseLayout.leadsWithZeroSizedBase();2891    }2892    // Lay out the base.2893    layoutNonVirtualBase(RD, BaseDecl, BaseLayout, PreviousBaseLayout);2894    VBPtrOffset = Bases[BaseDecl] + BaseLayout.getNonVirtualSize();2895  }2896  // Set our VBPtroffset if we know it at this point.2897  if (!HasVBPtr)2898    VBPtrOffset = CharUnits::fromQuantity(-1);2899  else if (SharedVBPtrBase) {2900    const ASTRecordLayout &Layout = Context.getASTRecordLayout(SharedVBPtrBase);2901    VBPtrOffset = Bases[SharedVBPtrBase] + Layout.getVBPtrOffset();2902  }2903}2904 2905static bool recordUsesEBO(const RecordDecl *RD) {2906  if (!isa<CXXRecordDecl>(RD))2907    return false;2908  if (RD->hasAttr<EmptyBasesAttr>())2909    return true;2910  if (auto *LVA = RD->getAttr<LayoutVersionAttr>())2911    // TODO: Double check with the next version of MSVC.2912    if (LVA->getVersion() <= LangOptions::MSVC2015)2913      return false;2914  // TODO: Some later version of MSVC will change the default behavior of the2915  // compiler to enable EBO by default.  When this happens, we will need an2916  // additional isCompatibleWithMSVC check.2917  return false;2918}2919 2920void MicrosoftRecordLayoutBuilder::layoutNonVirtualBase(2921    const CXXRecordDecl *RD, const CXXRecordDecl *BaseDecl,2922    const ASTRecordLayout &BaseLayout,2923    const ASTRecordLayout *&PreviousBaseLayout) {2924  // Insert padding between two bases if the left first one is zero sized or2925  // contains a zero sized subobject and the right is zero sized or one leads2926  // with a zero sized base.2927  bool MDCUsesEBO = recordUsesEBO(RD);2928  if (PreviousBaseLayout && PreviousBaseLayout->endsWithZeroSizedObject() &&2929      BaseLayout.leadsWithZeroSizedBase() && !MDCUsesEBO)2930    Size++;2931  ElementInfo Info = getAdjustedElementInfo(BaseLayout);2932  CharUnits BaseOffset;2933 2934  // Respect the external AST source base offset, if present.2935  bool FoundBase = false;2936  if (UseExternalLayout) {2937    FoundBase = External.getExternalNVBaseOffset(BaseDecl, BaseOffset);2938    if (BaseOffset > Size) {2939      Size = BaseOffset;2940    }2941  }2942 2943  if (!FoundBase) {2944    if (MDCUsesEBO && BaseDecl->isEmpty() &&2945        (BaseLayout.getNonVirtualSize() == CharUnits::Zero())) {2946      BaseOffset = CharUnits::Zero();2947    } else {2948      // Otherwise, lay the base out at the end of the MDC.2949      BaseOffset = Size = Size.alignTo(Info.Alignment);2950    }2951  }2952  Bases.insert(std::make_pair(BaseDecl, BaseOffset));2953  Size += BaseLayout.getNonVirtualSize();2954  DataSize = Size;2955  PreviousBaseLayout = &BaseLayout;2956}2957 2958void MicrosoftRecordLayoutBuilder::layoutFields(const RecordDecl *RD) {2959  LastFieldIsNonZeroWidthBitfield = false;2960  for (const FieldDecl *Field : RD->fields())2961    layoutField(Field);2962}2963 2964void MicrosoftRecordLayoutBuilder::layoutField(const FieldDecl *FD) {2965  if (FD->isBitField()) {2966    layoutBitField(FD);2967    return;2968  }2969  LastFieldIsNonZeroWidthBitfield = false;2970  ElementInfo Info = getAdjustedElementInfo(FD);2971  Alignment = std::max(Alignment, Info.Alignment);2972 2973  const CXXRecordDecl *FieldClass = FD->getType()->getAsCXXRecordDecl();2974  bool IsOverlappingEmptyField = FD->isPotentiallyOverlapping() &&2975                                 FieldClass->isEmpty() &&2976                                 FieldClass->fields().empty();2977  CharUnits FieldOffset = CharUnits::Zero();2978 2979  if (UseExternalLayout) {2980    FieldOffset =2981        Context.toCharUnitsFromBits(External.getExternalFieldOffset(FD));2982  } else if (IsUnion) {2983    FieldOffset = CharUnits::Zero();2984  } else if (EmptySubobjects) {2985    if (!IsOverlappingEmptyField)2986      FieldOffset = DataSize.alignTo(Info.Alignment);2987 2988    while (!EmptySubobjects->CanPlaceFieldAtOffset(FD, FieldOffset)) {2989      const CXXRecordDecl *ParentClass = cast<CXXRecordDecl>(FD->getParent());2990      bool HasBases = ParentClass && (!ParentClass->bases().empty() ||2991                                      !ParentClass->vbases().empty());2992      if (FieldOffset == CharUnits::Zero() && DataSize != CharUnits::Zero() &&2993          HasBases) {2994        // MSVC appears to only do this when there are base classes;2995        // otherwise it overlaps no_unique_address fields in non-zero offsets.2996        FieldOffset = DataSize.alignTo(Info.Alignment);2997      } else {2998        FieldOffset += Info.Alignment;2999      }3000    }3001  } else {3002    FieldOffset = Size.alignTo(Info.Alignment);3003  }3004 3005  uint64_t UnpaddedFielddOffsetInBits =3006      Context.toBits(DataSize) - RemainingBitsInField;3007 3008  ::CheckFieldPadding(Context, IsUnion, Context.toBits(FieldOffset),3009                      UnpaddedFielddOffsetInBits, FD);3010 3011  RemainingBitsInField = 0;3012 3013  placeFieldAtOffset(FieldOffset);3014 3015  if (!IsOverlappingEmptyField)3016    DataSize = std::max(DataSize, FieldOffset + Info.Size);3017 3018  Size = std::max(Size, FieldOffset + Info.Size);3019}3020 3021void MicrosoftRecordLayoutBuilder::layoutBitField(const FieldDecl *FD) {3022  unsigned Width = FD->getBitWidthValue();3023  if (Width == 0) {3024    layoutZeroWidthBitField(FD);3025    return;3026  }3027  ElementInfo Info = getAdjustedElementInfo(FD);3028  // Clamp the bitfield to a containable size for the sake of being able3029  // to lay them out.  Sema will throw an error.3030  if (Width > Context.toBits(Info.Size))3031    Width = Context.toBits(Info.Size);3032  // Check to see if this bitfield fits into an existing allocation.  Note:3033  // MSVC refuses to pack bitfields of formal types with different sizes3034  // into the same allocation.3035  if (!UseExternalLayout && !IsUnion && LastFieldIsNonZeroWidthBitfield &&3036      CurrentBitfieldSize == Info.Size && Width <= RemainingBitsInField) {3037    placeFieldAtBitOffset(Context.toBits(Size) - RemainingBitsInField);3038    RemainingBitsInField -= Width;3039    return;3040  }3041  LastFieldIsNonZeroWidthBitfield = true;3042  CurrentBitfieldSize = Info.Size;3043  if (UseExternalLayout) {3044    auto FieldBitOffset = External.getExternalFieldOffset(FD);3045    placeFieldAtBitOffset(FieldBitOffset);3046    auto NewSize = Context.toCharUnitsFromBits(3047        llvm::alignDown(FieldBitOffset, Context.toBits(Info.Alignment)) +3048        Context.toBits(Info.Size));3049    Size = std::max(Size, NewSize);3050    Alignment = std::max(Alignment, Info.Alignment);3051  } else if (IsUnion) {3052    placeFieldAtOffset(CharUnits::Zero());3053    Size = std::max(Size, Info.Size);3054    // TODO: Add a Sema warning that MS ignores bitfield alignment in unions.3055  } else {3056    // Allocate a new block of memory and place the bitfield in it.3057    CharUnits FieldOffset = Size.alignTo(Info.Alignment);3058    uint64_t UnpaddedFieldOffsetInBits =3059        Context.toBits(DataSize) - RemainingBitsInField;3060    placeFieldAtOffset(FieldOffset);3061    Size = FieldOffset + Info.Size;3062    Alignment = std::max(Alignment, Info.Alignment);3063    RemainingBitsInField = Context.toBits(Info.Size) - Width;3064    ::CheckFieldPadding(Context, IsUnion, Context.toBits(FieldOffset),3065                        UnpaddedFieldOffsetInBits, FD);3066  }3067  DataSize = Size;3068}3069 3070void3071MicrosoftRecordLayoutBuilder::layoutZeroWidthBitField(const FieldDecl *FD) {3072  // Zero-width bitfields are ignored unless they follow a non-zero-width3073  // bitfield.3074  if (!LastFieldIsNonZeroWidthBitfield) {3075    placeFieldAtOffset(IsUnion ? CharUnits::Zero() : Size);3076    // TODO: Add a Sema warning that MS ignores alignment for zero3077    // sized bitfields that occur after zero-size bitfields or non-bitfields.3078    return;3079  }3080  LastFieldIsNonZeroWidthBitfield = false;3081  ElementInfo Info = getAdjustedElementInfo(FD);3082  if (IsUnion) {3083    placeFieldAtOffset(CharUnits::Zero());3084    Size = std::max(Size, Info.Size);3085    // TODO: Add a Sema warning that MS ignores bitfield alignment in unions.3086  } else {3087    // Round up the current record size to the field's alignment boundary.3088    CharUnits FieldOffset = Size.alignTo(Info.Alignment);3089    uint64_t UnpaddedFieldOffsetInBits =3090        Context.toBits(DataSize) - RemainingBitsInField;3091    placeFieldAtOffset(FieldOffset);3092    RemainingBitsInField = 0;3093    Size = FieldOffset;3094    Alignment = std::max(Alignment, Info.Alignment);3095    ::CheckFieldPadding(Context, IsUnion, Context.toBits(FieldOffset),3096                        UnpaddedFieldOffsetInBits, FD);3097  }3098  DataSize = Size;3099}3100 3101void MicrosoftRecordLayoutBuilder::injectVBPtr(const CXXRecordDecl *RD) {3102  if (!HasVBPtr || SharedVBPtrBase)3103    return;3104  // Inject the VBPointer at the injection site.3105  CharUnits InjectionSite = VBPtrOffset;3106  // But before we do, make sure it's properly aligned.3107  VBPtrOffset = VBPtrOffset.alignTo(PointerInfo.Alignment);3108  // Determine where the first field should be laid out after the vbptr.3109  CharUnits FieldStart = VBPtrOffset + PointerInfo.Size;3110  // Shift everything after the vbptr down, unless we're using an external3111  // layout.3112  if (UseExternalLayout) {3113    // It is possible that there were no fields or bases located after vbptr,3114    // so the size was not adjusted before.3115    if (Size < FieldStart)3116      Size = FieldStart;3117    return;3118  }3119  // Make sure that the amount we push the fields back by is a multiple of the3120  // alignment.3121  CharUnits Offset = (FieldStart - InjectionSite)3122                         .alignTo(std::max(RequiredAlignment, Alignment));3123  Size += Offset;3124  for (uint64_t &FieldOffset : FieldOffsets)3125    FieldOffset += Context.toBits(Offset);3126  for (BaseOffsetsMapTy::value_type &Base : Bases)3127    if (Base.second >= InjectionSite)3128      Base.second += Offset;3129}3130 3131void MicrosoftRecordLayoutBuilder::injectVFPtr(const CXXRecordDecl *RD) {3132  if (!HasOwnVFPtr)3133    return;3134  // Make sure that the amount we push the struct back by is a multiple of the3135  // alignment.3136  CharUnits Offset =3137      PointerInfo.Size.alignTo(std::max(RequiredAlignment, Alignment));3138  // Push back the vbptr, but increase the size of the object and push back3139  // regular fields by the offset only if not using external record layout.3140  if (HasVBPtr)3141    VBPtrOffset += Offset;3142 3143  if (UseExternalLayout) {3144    // The class may have size 0 and a vfptr (e.g. it's an interface class). The3145    // size was not correctly set before in this case.3146    if (Size.isZero())3147      Size += Offset;3148    return;3149  }3150 3151  Size += Offset;3152 3153  // If we're using an external layout, the fields offsets have already3154  // accounted for this adjustment.3155  for (uint64_t &FieldOffset : FieldOffsets)3156    FieldOffset += Context.toBits(Offset);3157  for (BaseOffsetsMapTy::value_type &Base : Bases)3158    Base.second += Offset;3159}3160 3161void MicrosoftRecordLayoutBuilder::layoutVirtualBases(const CXXRecordDecl *RD) {3162  if (!HasVBPtr)3163    return;3164  // Vtordisps are always 4 bytes (even in 64-bit mode)3165  CharUnits VtorDispSize = CharUnits::fromQuantity(4);3166  CharUnits VtorDispAlignment = VtorDispSize;3167  // vtordisps respect pragma pack.3168  if (!MaxFieldAlignment.isZero())3169    VtorDispAlignment = std::min(VtorDispAlignment, MaxFieldAlignment);3170  // The alignment of the vtordisp is at least the required alignment of the3171  // entire record.  This requirement may be present to support vtordisp3172  // injection.3173  for (const CXXBaseSpecifier &VBase : RD->vbases()) {3174    const CXXRecordDecl *BaseDecl = VBase.getType()->getAsCXXRecordDecl();3175    const ASTRecordLayout &BaseLayout = Context.getASTRecordLayout(BaseDecl);3176    RequiredAlignment =3177        std::max(RequiredAlignment, BaseLayout.getRequiredAlignment());3178  }3179  VtorDispAlignment = std::max(VtorDispAlignment, RequiredAlignment);3180  // Compute the vtordisp set.3181  llvm::SmallPtrSet<const CXXRecordDecl *, 2> HasVtorDispSet;3182  computeVtorDispSet(HasVtorDispSet, RD);3183  // Iterate through the virtual bases and lay them out.3184  const ASTRecordLayout *PreviousBaseLayout = nullptr;3185  for (const CXXBaseSpecifier &VBase : RD->vbases()) {3186    const CXXRecordDecl *BaseDecl = VBase.getType()->getAsCXXRecordDecl();3187    const ASTRecordLayout &BaseLayout = Context.getASTRecordLayout(BaseDecl);3188    bool HasVtordisp = HasVtorDispSet.contains(BaseDecl);3189    // Insert padding between two bases if the left first one is zero sized or3190    // contains a zero sized subobject and the right is zero sized or one leads3191    // with a zero sized base.  The padding between virtual bases is 43192    // bytes (in both 32 and 64 bits modes) and always involves rounding up to3193    // the required alignment, we don't know why.3194    if ((PreviousBaseLayout && PreviousBaseLayout->endsWithZeroSizedObject() &&3195         BaseLayout.leadsWithZeroSizedBase() && !recordUsesEBO(RD)) ||3196        HasVtordisp) {3197      Size = Size.alignTo(VtorDispAlignment) + VtorDispSize;3198      Alignment = std::max(VtorDispAlignment, Alignment);3199    }3200    // Insert the virtual base.3201    ElementInfo Info = getAdjustedElementInfo(BaseLayout);3202    CharUnits BaseOffset;3203 3204    // Respect the external AST source base offset, if present.3205    if (UseExternalLayout) {3206      if (!External.getExternalVBaseOffset(BaseDecl, BaseOffset))3207        BaseOffset = Size;3208    } else3209      BaseOffset = Size.alignTo(Info.Alignment);3210 3211    assert(BaseOffset >= Size && "base offset already allocated");3212 3213    VBases.insert(std::make_pair(BaseDecl,3214        ASTRecordLayout::VBaseInfo(BaseOffset, HasVtordisp)));3215    Size = BaseOffset + BaseLayout.getNonVirtualSize();3216    PreviousBaseLayout = &BaseLayout;3217  }3218}3219 3220void MicrosoftRecordLayoutBuilder::finalizeLayout(const RecordDecl *RD) {3221  uint64_t UnpaddedSizeInBits = Context.toBits(DataSize);3222  UnpaddedSizeInBits -= RemainingBitsInField;3223 3224  // MS ABI allocates 1 byte for empty class3225  // (not padding)3226  if (Size.isZero())3227    UnpaddedSizeInBits += 8;3228 3229  // Respect required alignment.  Note that in 32-bit mode Required alignment3230  // may be 0 and cause size not to be updated.3231  DataSize = Size;3232  if (!RequiredAlignment.isZero()) {3233    Alignment = std::max(Alignment, RequiredAlignment);3234    auto RoundingAlignment = Alignment;3235    if (!MaxFieldAlignment.isZero())3236      RoundingAlignment = std::min(RoundingAlignment, MaxFieldAlignment);3237    RoundingAlignment = std::max(RoundingAlignment, RequiredAlignment);3238    Size = Size.alignTo(RoundingAlignment);3239  }3240  if (Size.isZero()) {3241    if (!recordUsesEBO(RD) || !cast<CXXRecordDecl>(RD)->isEmpty()) {3242      EndsWithZeroSizedObject = true;3243      LeadsWithZeroSizedBase = true;3244    }3245    // Zero-sized structures have size equal to their alignment if a3246    // __declspec(align) came into play.3247    if (RequiredAlignment >= MinEmptyStructSize)3248      Size = Alignment;3249    else3250      Size = MinEmptyStructSize;3251  }3252 3253  if (UseExternalLayout) {3254    Size = Context.toCharUnitsFromBits(External.Size);3255    if (External.Align)3256      Alignment = Context.toCharUnitsFromBits(External.Align);3257    return;3258  }3259  unsigned CharBitNum = Context.getTargetInfo().getCharWidth();3260  uint64_t SizeInBits = Context.toBits(Size);3261 3262  if (SizeInBits > UnpaddedSizeInBits) {3263    unsigned int PadSize = SizeInBits - UnpaddedSizeInBits;3264    bool InBits = true;3265    if (PadSize % CharBitNum == 0) {3266      PadSize = PadSize / CharBitNum;3267      InBits = false;3268    }3269 3270    Context.getDiagnostics().Report(RD->getLocation(),3271                                    diag::warn_padded_struct_size)3272        << Context.getCanonicalTagType(RD) << PadSize3273        << (InBits ? 1 : 0); // (byte|bit)3274  }3275}3276 3277// Recursively walks the non-virtual bases of a class and determines if any of3278// them are in the bases with overridden methods set.3279static bool3280RequiresVtordisp(const llvm::SmallPtrSetImpl<const CXXRecordDecl *> &3281                     BasesWithOverriddenMethods,3282                 const CXXRecordDecl *RD) {3283  if (BasesWithOverriddenMethods.count(RD))3284    return true;3285  // If any of a virtual bases non-virtual bases (recursively) requires a3286  // vtordisp than so does this virtual base.3287  for (const CXXBaseSpecifier &Base : RD->bases())3288    if (!Base.isVirtual() &&3289        RequiresVtordisp(BasesWithOverriddenMethods,3290                         Base.getType()->getAsCXXRecordDecl()))3291      return true;3292  return false;3293}3294 3295void MicrosoftRecordLayoutBuilder::computeVtorDispSet(3296    llvm::SmallPtrSetImpl<const CXXRecordDecl *> &HasVtordispSet,3297    const CXXRecordDecl *RD) const {3298  // /vd2 or #pragma vtordisp(2): Always use vtordisps for virtual bases with3299  // vftables.3300  if (RD->getMSVtorDispMode() == MSVtorDispMode::ForVFTable) {3301    for (const CXXBaseSpecifier &Base : RD->vbases()) {3302      const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();3303      const ASTRecordLayout &Layout = Context.getASTRecordLayout(BaseDecl);3304      if (Layout.hasExtendableVFPtr())3305        HasVtordispSet.insert(BaseDecl);3306    }3307    return;3308  }3309 3310  // If any of our bases need a vtordisp for this type, so do we.  Check our3311  // direct bases for vtordisp requirements.3312  for (const CXXBaseSpecifier &Base : RD->bases()) {3313    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();3314    const ASTRecordLayout &Layout = Context.getASTRecordLayout(BaseDecl);3315    for (const auto &bi : Layout.getVBaseOffsetsMap())3316      if (bi.second.hasVtorDisp())3317        HasVtordispSet.insert(bi.first);3318  }3319  // We don't introduce any additional vtordisps if either:3320  // * A user declared constructor or destructor aren't declared.3321  // * #pragma vtordisp(0) or the /vd0 flag are in use.3322  if ((!RD->hasUserDeclaredConstructor() && !RD->hasUserDeclaredDestructor()) ||3323      RD->getMSVtorDispMode() == MSVtorDispMode::Never)3324    return;3325  // /vd1 or #pragma vtordisp(1): Try to guess based on whether we think it's3326  // possible for a partially constructed object with virtual base overrides to3327  // escape a non-trivial constructor.3328  assert(RD->getMSVtorDispMode() == MSVtorDispMode::ForVBaseOverride);3329  // Compute a set of base classes which define methods we override.  A virtual3330  // base in this set will require a vtordisp.  A virtual base that transitively3331  // contains one of these bases as a non-virtual base will also require a3332  // vtordisp.3333  llvm::SmallPtrSet<const CXXMethodDecl *, 8> Work;3334  llvm::SmallPtrSet<const CXXRecordDecl *, 2> BasesWithOverriddenMethods;3335  // Seed the working set with our non-destructor, non-pure virtual methods.3336  for (const CXXMethodDecl *MD : RD->methods())3337    if (MicrosoftVTableContext::hasVtableSlot(MD) &&3338        !isa<CXXDestructorDecl>(MD) && !MD->isPureVirtual())3339      Work.insert(MD);3340  while (!Work.empty()) {3341    const CXXMethodDecl *MD = *Work.begin();3342    auto MethodRange = MD->overridden_methods();3343    // If a virtual method has no-overrides it lives in its parent's vtable.3344    if (MethodRange.begin() == MethodRange.end())3345      BasesWithOverriddenMethods.insert(MD->getParent());3346    else3347      Work.insert_range(MethodRange);3348    // We've finished processing this element, remove it from the working set.3349    Work.erase(MD);3350  }3351  // For each of our virtual bases, check if it is in the set of overridden3352  // bases or if it transitively contains a non-virtual base that is.3353  for (const CXXBaseSpecifier &Base : RD->vbases()) {3354    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();3355    if (!HasVtordispSet.count(BaseDecl) &&3356        RequiresVtordisp(BasesWithOverriddenMethods, BaseDecl))3357      HasVtordispSet.insert(BaseDecl);3358  }3359}3360 3361/// getASTRecordLayout - Get or compute information about the layout of the3362/// specified record (struct/union/class), which indicates its size and field3363/// position information.3364const ASTRecordLayout &3365ASTContext::getASTRecordLayout(const RecordDecl *D) const {3366  if (D->hasExternalLexicalStorage() && !D->getDefinition())3367    getExternalSource()->CompleteType(const_cast<RecordDecl*>(D));3368  // Complete the redecl chain (if necessary).3369  (void)D->getMostRecentDecl();3370 3371  // These asserts test different things.  A record has a definition3372  // as soon as we begin to parse the definition.  That definition is3373  // not a complete definition (which is what isCompleteDefinition() tests)3374  // until we *finish* parsing the definition.3375  D = D->getDefinition();3376  assert(D && "Cannot get layout of forward declarations!");3377  assert(!D->isInvalidDecl() && "Cannot get layout of invalid decl!");3378  assert(D->isCompleteDefinition() && "Cannot layout type before complete!");3379 3380  // Look up this layout, if already laid out, return what we have.3381  // Note that we can't save a reference to the entry because this function3382  // is recursive.3383  const ASTRecordLayout *Entry = ASTRecordLayouts[D];3384  if (Entry) return *Entry;3385 3386  const ASTRecordLayout *NewEntry = nullptr;3387 3388  if (getTargetInfo().hasMicrosoftRecordLayout()) {3389    if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {3390      EmptySubobjectMap EmptySubobjects(*this, RD);3391      MicrosoftRecordLayoutBuilder Builder(*this, &EmptySubobjects);3392      Builder.cxxLayout(RD);3393      NewEntry = new (*this) ASTRecordLayout(3394          *this, Builder.Size, Builder.Alignment, Builder.Alignment,3395          Builder.Alignment, Builder.RequiredAlignment, Builder.HasOwnVFPtr,3396          Builder.HasOwnVFPtr || Builder.PrimaryBase, Builder.VBPtrOffset,3397          Builder.DataSize, Builder.FieldOffsets, Builder.NonVirtualSize,3398          Builder.Alignment, Builder.Alignment, CharUnits::Zero(),3399          Builder.PrimaryBase, false, Builder.SharedVBPtrBase,3400          Builder.EndsWithZeroSizedObject, Builder.LeadsWithZeroSizedBase,3401          Builder.Bases, Builder.VBases);3402    } else {3403      MicrosoftRecordLayoutBuilder Builder(*this, /*EmptySubobjects=*/nullptr);3404      Builder.layout(D);3405      NewEntry = new (*this) ASTRecordLayout(3406          *this, Builder.Size, Builder.Alignment, Builder.Alignment,3407          Builder.Alignment, Builder.RequiredAlignment, Builder.Size,3408          Builder.FieldOffsets);3409    }3410  } else {3411    if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {3412      EmptySubobjectMap EmptySubobjects(*this, RD);3413      ItaniumRecordLayoutBuilder Builder(*this, &EmptySubobjects);3414      Builder.Layout(RD);3415 3416      // In certain situations, we are allowed to lay out objects in the3417      // tail-padding of base classes.  This is ABI-dependent.3418      // FIXME: this should be stored in the record layout.3419      bool skipTailPadding =3420          mustSkipTailPadding(getTargetInfo().getCXXABI(), RD);3421 3422      // FIXME: This should be done in FinalizeLayout.3423      CharUnits DataSize =3424          skipTailPadding ? Builder.getSize() : Builder.getDataSize();3425      CharUnits NonVirtualSize =3426          skipTailPadding ? DataSize : Builder.NonVirtualSize;3427      NewEntry = new (*this) ASTRecordLayout(3428          *this, Builder.getSize(), Builder.Alignment,3429          Builder.PreferredAlignment, Builder.UnadjustedAlignment,3430          /*RequiredAlignment : used by MS-ABI)*/3431          Builder.Alignment, Builder.HasOwnVFPtr, RD->isDynamicClass(),3432          CharUnits::fromQuantity(-1), DataSize, Builder.FieldOffsets,3433          NonVirtualSize, Builder.NonVirtualAlignment,3434          Builder.PreferredNVAlignment,3435          EmptySubobjects.SizeOfLargestEmptySubobject, Builder.PrimaryBase,3436          Builder.PrimaryBaseIsVirtual, nullptr, false, false, Builder.Bases,3437          Builder.VBases);3438    } else {3439      ItaniumRecordLayoutBuilder Builder(*this, /*EmptySubobjects=*/nullptr);3440      Builder.Layout(D);3441 3442      NewEntry = new (*this) ASTRecordLayout(3443          *this, Builder.getSize(), Builder.Alignment,3444          Builder.PreferredAlignment, Builder.UnadjustedAlignment,3445          /*RequiredAlignment : used by MS-ABI)*/3446          Builder.Alignment, Builder.getSize(), Builder.FieldOffsets);3447    }3448  }3449 3450  ASTRecordLayouts[D] = NewEntry;3451 3452  constexpr uint64_t MaxStructSizeInBytes = 1ULL << 60;3453  CharUnits StructSize = NewEntry->getSize();3454  if (static_cast<uint64_t>(StructSize.getQuantity()) >= MaxStructSizeInBytes) {3455    getDiagnostics().Report(D->getLocation(), diag::err_struct_too_large)3456        << D->getName() << MaxStructSizeInBytes;3457  }3458 3459  if (getLangOpts().DumpRecordLayouts) {3460    llvm::outs() << "\n*** Dumping AST Record Layout\n";3461    DumpRecordLayout(D, llvm::outs(), getLangOpts().DumpRecordLayoutsSimple);3462  }3463 3464  return *NewEntry;3465}3466 3467const CXXMethodDecl *ASTContext::getCurrentKeyFunction(const CXXRecordDecl *RD) {3468  if (!getTargetInfo().getCXXABI().hasKeyFunctions())3469    return nullptr;3470 3471  assert(RD->getDefinition() && "Cannot get key function for forward decl!");3472  RD = RD->getDefinition();3473 3474  // Beware:3475  //  1) computing the key function might trigger deserialization, which might3476  //     invalidate iterators into KeyFunctions3477  //  2) 'get' on the LazyDeclPtr might also trigger deserialization and3478  //     invalidate the LazyDeclPtr within the map itself3479  LazyDeclPtr Entry = KeyFunctions[RD];3480  const Decl *Result =3481      Entry ? Entry.get(getExternalSource()) : computeKeyFunction(*this, RD);3482 3483  // Store it back if it changed.3484  if (Entry.isOffset() || Entry.isValid() != bool(Result))3485    KeyFunctions[RD] = const_cast<Decl*>(Result);3486 3487  return cast_or_null<CXXMethodDecl>(Result);3488}3489 3490void ASTContext::setNonKeyFunction(const CXXMethodDecl *Method) {3491  assert(Method == Method->getFirstDecl() &&3492         "not working with method declaration from class definition");3493 3494  // Look up the cache entry.  Since we're working with the first3495  // declaration, its parent must be the class definition, which is3496  // the correct key for the KeyFunctions hash.3497  const auto &Map = KeyFunctions;3498  auto I = Map.find(Method->getParent());3499 3500  // If it's not cached, there's nothing to do.3501  if (I == Map.end()) return;3502 3503  // If it is cached, check whether it's the target method, and if so,3504  // remove it from the cache. Note, the call to 'get' might invalidate3505  // the iterator and the LazyDeclPtr object within the map.3506  LazyDeclPtr Ptr = I->second;3507  if (Ptr.get(getExternalSource()) == Method) {3508    // FIXME: remember that we did this for module / chained PCH state?3509    KeyFunctions.erase(Method->getParent());3510  }3511}3512 3513static uint64_t getFieldOffset(const ASTContext &C, const FieldDecl *FD) {3514  const ASTRecordLayout &Layout = C.getASTRecordLayout(FD->getParent());3515  return Layout.getFieldOffset(FD->getFieldIndex());3516}3517 3518uint64_t ASTContext::getFieldOffset(const ValueDecl *VD) const {3519  uint64_t OffsetInBits;3520  if (const FieldDecl *FD = dyn_cast<FieldDecl>(VD)) {3521    OffsetInBits = ::getFieldOffset(*this, FD);3522  } else {3523    const IndirectFieldDecl *IFD = cast<IndirectFieldDecl>(VD);3524 3525    OffsetInBits = 0;3526    for (const NamedDecl *ND : IFD->chain())3527      OffsetInBits += ::getFieldOffset(*this, cast<FieldDecl>(ND));3528  }3529 3530  return OffsetInBits;3531}3532 3533uint64_t ASTContext::lookupFieldBitOffset(const ObjCInterfaceDecl *OID,3534                                          const ObjCIvarDecl *Ivar) const {3535  Ivar = Ivar->getCanonicalDecl();3536  const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();3537  const ASTRecordLayout *RL = &getASTObjCInterfaceLayout(Container);3538 3539  // Compute field index.3540  //3541  // FIXME: The index here is closely tied to how ASTContext::getObjCLayout is3542  // implemented. This should be fixed to get the information from the layout3543  // directly.3544  unsigned Index = 0;3545 3546  for (const ObjCIvarDecl *IVD = Container->all_declared_ivar_begin();3547       IVD; IVD = IVD->getNextIvar()) {3548    if (Ivar == IVD)3549      break;3550    ++Index;3551  }3552  assert(Index < RL->getFieldCount() && "Ivar is not inside record layout!");3553 3554  return RL->getFieldOffset(Index);3555}3556 3557/// getObjCLayout - Get or compute information about the layout of the3558/// given interface.3559///3560/// \param Impl - If given, also include the layout of the interface's3561/// implementation. This may differ by including synthesized ivars.3562const ASTRecordLayout &3563ASTContext::getObjCLayout(const ObjCInterfaceDecl *D) const {3564  // Retrieve the definition3565  if (D->hasExternalLexicalStorage() && !D->getDefinition())3566    getExternalSource()->CompleteType(const_cast<ObjCInterfaceDecl*>(D));3567  D = D->getDefinition();3568  assert(D && !D->isInvalidDecl() && D->isThisDeclarationADefinition() &&3569         "Invalid interface decl!");3570 3571  // Look up this layout, if already laid out, return what we have.3572  if (const ASTRecordLayout *Entry = ObjCLayouts[D])3573    return *Entry;3574 3575  ItaniumRecordLayoutBuilder Builder(*this, /*EmptySubobjects=*/nullptr);3576  Builder.Layout(D);3577 3578  const ASTRecordLayout *NewEntry = new (*this) ASTRecordLayout(3579      *this, Builder.getSize(), Builder.Alignment, Builder.PreferredAlignment,3580      Builder.UnadjustedAlignment,3581      /*RequiredAlignment : used by MS-ABI)*/3582      Builder.Alignment, Builder.getDataSize(), Builder.FieldOffsets);3583 3584  ObjCLayouts[D] = NewEntry;3585 3586  return *NewEntry;3587}3588 3589static void PrintOffset(raw_ostream &OS,3590                        CharUnits Offset, unsigned IndentLevel) {3591  OS << llvm::format("%10" PRId64 " | ", (int64_t)Offset.getQuantity());3592  OS.indent(IndentLevel * 2);3593}3594 3595static void PrintBitFieldOffset(raw_ostream &OS, CharUnits Offset,3596                                unsigned Begin, unsigned Width,3597                                unsigned IndentLevel) {3598  llvm::SmallString<10> Buffer;3599  {3600    llvm::raw_svector_ostream BufferOS(Buffer);3601    BufferOS << Offset.getQuantity() << ':';3602    if (Width == 0) {3603      BufferOS << '-';3604    } else {3605      BufferOS << Begin << '-' << (Begin + Width - 1);3606    }3607  }3608 3609  OS << llvm::right_justify(Buffer, 10) << " | ";3610  OS.indent(IndentLevel * 2);3611}3612 3613static void PrintIndentNoOffset(raw_ostream &OS, unsigned IndentLevel) {3614  OS << "           | ";3615  OS.indent(IndentLevel * 2);3616}3617 3618static void DumpRecordLayout(raw_ostream &OS, const RecordDecl *RD,3619                             const ASTContext &C,3620                             CharUnits Offset,3621                             unsigned IndentLevel,3622                             const char* Description,3623                             bool PrintSizeInfo,3624                             bool IncludeVirtualBases) {3625  const ASTRecordLayout &Layout = C.getASTRecordLayout(RD);3626  auto CXXRD = dyn_cast<CXXRecordDecl>(RD);3627 3628  PrintOffset(OS, Offset, IndentLevel);3629  OS << C.getCanonicalTagType(const_cast<RecordDecl *>(RD));3630  if (Description)3631    OS << ' ' << Description;3632  if (CXXRD && CXXRD->isEmpty())3633    OS << " (empty)";3634  OS << '\n';3635 3636  IndentLevel++;3637 3638  // Dump bases.3639  if (CXXRD) {3640    const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();3641    bool HasOwnVFPtr = Layout.hasOwnVFPtr();3642    bool HasOwnVBPtr = Layout.hasOwnVBPtr();3643 3644    // Vtable pointer.3645    if (CXXRD->isDynamicClass() && !PrimaryBase &&3646        !C.getTargetInfo().hasMicrosoftRecordLayout()) {3647      PrintOffset(OS, Offset, IndentLevel);3648      OS << '(' << *RD << " vtable pointer)\n";3649    } else if (HasOwnVFPtr) {3650      PrintOffset(OS, Offset, IndentLevel);3651      // vfptr (for Microsoft C++ ABI)3652      OS << '(' << *RD << " vftable pointer)\n";3653    }3654 3655    // Collect nvbases.3656    SmallVector<const CXXRecordDecl *, 4> Bases;3657    for (const CXXBaseSpecifier &Base : CXXRD->bases()) {3658      assert(!Base.getType()->isDependentType() &&3659             "Cannot layout class with dependent bases.");3660      if (!Base.isVirtual())3661        Bases.push_back(Base.getType()->getAsCXXRecordDecl());3662    }3663 3664    // Sort nvbases by offset.3665    llvm::stable_sort(3666        Bases, [&](const CXXRecordDecl *L, const CXXRecordDecl *R) {3667          return Layout.getBaseClassOffset(L) < Layout.getBaseClassOffset(R);3668        });3669 3670    // Dump (non-virtual) bases3671    for (const CXXRecordDecl *Base : Bases) {3672      CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(Base);3673      DumpRecordLayout(OS, Base, C, BaseOffset, IndentLevel,3674                       Base == PrimaryBase ? "(primary base)" : "(base)",3675                       /*PrintSizeInfo=*/false,3676                       /*IncludeVirtualBases=*/false);3677    }3678 3679    // vbptr (for Microsoft C++ ABI)3680    if (HasOwnVBPtr) {3681      PrintOffset(OS, Offset + Layout.getVBPtrOffset(), IndentLevel);3682      OS << '(' << *RD << " vbtable pointer)\n";3683    }3684  }3685 3686  // Dump fields.3687  for (const FieldDecl *Field : RD->fields()) {3688    uint64_t LocalFieldOffsetInBits =3689        Layout.getFieldOffset(Field->getFieldIndex());3690    CharUnits FieldOffset =3691      Offset + C.toCharUnitsFromBits(LocalFieldOffsetInBits);3692 3693    // Recursively dump fields of record type.3694    if (const auto *RD = Field->getType()->getAsRecordDecl()) {3695      DumpRecordLayout(OS, RD, C, FieldOffset, IndentLevel,3696                       Field->getName().data(),3697                       /*PrintSizeInfo=*/false,3698                       /*IncludeVirtualBases=*/true);3699      continue;3700    }3701 3702    if (Field->isBitField()) {3703      uint64_t LocalFieldByteOffsetInBits = C.toBits(FieldOffset - Offset);3704      unsigned Begin = LocalFieldOffsetInBits - LocalFieldByteOffsetInBits;3705      unsigned Width = Field->getBitWidthValue();3706      PrintBitFieldOffset(OS, FieldOffset, Begin, Width, IndentLevel);3707    } else {3708      PrintOffset(OS, FieldOffset, IndentLevel);3709    }3710    const QualType &FieldType = C.getLangOpts().DumpRecordLayoutsCanonical3711                                    ? Field->getType().getCanonicalType()3712                                    : Field->getType();3713    OS << FieldType << ' ' << *Field << '\n';3714  }3715 3716  // Dump virtual bases.3717  if (CXXRD && IncludeVirtualBases) {3718    const ASTRecordLayout::VBaseOffsetsMapTy &VtorDisps =3719      Layout.getVBaseOffsetsMap();3720 3721    for (const CXXBaseSpecifier &Base : CXXRD->vbases()) {3722      assert(Base.isVirtual() && "Found non-virtual class!");3723      const CXXRecordDecl *VBase = Base.getType()->getAsCXXRecordDecl();3724 3725      CharUnits VBaseOffset = Offset + Layout.getVBaseClassOffset(VBase);3726 3727      if (VtorDisps.find(VBase)->second.hasVtorDisp()) {3728        PrintOffset(OS, VBaseOffset - CharUnits::fromQuantity(4), IndentLevel);3729        OS << "(vtordisp for vbase " << *VBase << ")\n";3730      }3731 3732      DumpRecordLayout(OS, VBase, C, VBaseOffset, IndentLevel,3733                       VBase == Layout.getPrimaryBase() ?3734                         "(primary virtual base)" : "(virtual base)",3735                       /*PrintSizeInfo=*/false,3736                       /*IncludeVirtualBases=*/false);3737    }3738  }3739 3740  if (!PrintSizeInfo) return;3741 3742  PrintIndentNoOffset(OS, IndentLevel - 1);3743  OS << "[sizeof=" << Layout.getSize().getQuantity();3744  if (CXXRD && !C.getTargetInfo().hasMicrosoftRecordLayout())3745    OS << ", dsize=" << Layout.getDataSize().getQuantity();3746  OS << ", align=" << Layout.getAlignment().getQuantity();3747  if (C.getTargetInfo().defaultsToAIXPowerAlignment())3748    OS << ", preferredalign=" << Layout.getPreferredAlignment().getQuantity();3749 3750  if (CXXRD) {3751    OS << ",\n";3752    PrintIndentNoOffset(OS, IndentLevel - 1);3753    OS << " nvsize=" << Layout.getNonVirtualSize().getQuantity();3754    OS << ", nvalign=" << Layout.getNonVirtualAlignment().getQuantity();3755    if (C.getTargetInfo().defaultsToAIXPowerAlignment())3756      OS << ", preferrednvalign="3757         << Layout.getPreferredNVAlignment().getQuantity();3758  }3759  OS << "]\n";3760}3761 3762void ASTContext::DumpRecordLayout(const RecordDecl *RD, raw_ostream &OS,3763                                  bool Simple) const {3764  if (!Simple) {3765    ::DumpRecordLayout(OS, RD, *this, CharUnits(), 0, nullptr,3766                       /*PrintSizeInfo*/ true,3767                       /*IncludeVirtualBases=*/true);3768    return;3769  }3770 3771  // The "simple" format is designed to be parsed by the3772  // layout-override testing code.  There shouldn't be any external3773  // uses of this format --- when LLDB overrides a layout, it sets up3774  // the data structures directly --- so feel free to adjust this as3775  // you like as long as you also update the rudimentary parser for it3776  // in libFrontend.3777 3778  const ASTRecordLayout &Info = getASTRecordLayout(RD);3779  OS << "Type: " << getCanonicalTagType(RD) << "\n";3780  OS << "\nLayout: ";3781  OS << "<ASTRecordLayout\n";3782  OS << "  Size:" << toBits(Info.getSize()) << "\n";3783  if (!getTargetInfo().hasMicrosoftRecordLayout())3784    OS << "  DataSize:" << toBits(Info.getDataSize()) << "\n";3785  OS << "  Alignment:" << toBits(Info.getAlignment()) << "\n";3786  if (Target->defaultsToAIXPowerAlignment())3787    OS << "  PreferredAlignment:" << toBits(Info.getPreferredAlignment())3788       << "\n";3789  if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {3790    OS << "  BaseOffsets: [";3791    const CXXRecordDecl *Base = nullptr;3792    for (auto I : CXXRD->bases()) {3793      if (I.isVirtual())3794        continue;3795      if (Base)3796        OS << ", ";3797      Base = I.getType()->getAsCXXRecordDecl();3798      OS << Info.CXXInfo->BaseOffsets[Base].getQuantity();3799    }3800    OS << "]>\n";3801    OS << "  VBaseOffsets: [";3802    const CXXRecordDecl *VBase = nullptr;3803    for (auto I : CXXRD->vbases()) {3804      if (VBase)3805        OS << ", ";3806      VBase = I.getType()->getAsCXXRecordDecl();3807      OS << Info.CXXInfo->VBaseOffsets[VBase].VBaseOffset.getQuantity();3808    }3809    OS << "]>\n";3810  }3811  OS << "  FieldOffsets: [";3812  for (unsigned i = 0, e = Info.getFieldCount(); i != e; ++i) {3813    if (i)3814      OS << ", ";3815    OS << Info.getFieldOffset(i);3816  }3817  OS << "]>\n";3818}3819