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