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