blob: 600d0bf0b483a6e193d45a7df7150cc47183db2d [file] [log] [blame]
Anders Carlsson79474332009-07-18 20:20:21 +00001//=== ASTRecordLayoutBuilder.cpp - Helper class for building record layouts ==//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "RecordLayoutBuilder.h"
11
12#include "clang/AST/Attr.h"
13#include "clang/AST/Decl.h"
Anders Carlsson6d9f6f32009-07-19 00:18:47 +000014#include "clang/AST/DeclCXX.h"
Anders Carlsson4f516282009-07-18 20:50:59 +000015#include "clang/AST/DeclObjC.h"
Anders Carlsson79474332009-07-18 20:20:21 +000016#include "clang/AST/Expr.h"
Anders Carlsson79474332009-07-18 20:20:21 +000017#include "clang/Basic/TargetInfo.h"
Daniel Dunbaraa423af2010-04-08 02:59:49 +000018#include "llvm/Support/Format.h"
19#include "llvm/ADT/SmallSet.h"
20#include "llvm/Support/MathExtras.h"
Anders Carlsson79474332009-07-18 20:20:21 +000021
22using namespace clang;
23
Mike Stump11289f42009-09-09 15:08:12 +000024ASTRecordLayoutBuilder::ASTRecordLayoutBuilder(ASTContext &Ctx)
Anders Carlssonba958402009-11-22 19:13:51 +000025 : Ctx(Ctx), Size(0), Alignment(8), Packed(false), UnfilledBitsInLastByte(0),
Daniel Dunbaraa423af2010-04-08 02:59:49 +000026 MaxFieldAlignment(0), DataSize(0), IsUnion(false), NonVirtualSize(0),
27 NonVirtualAlignment(8), FirstNearlyEmptyVBase(0) { }
Mike Stump3dc7eb92009-07-30 00:22:38 +000028
Mike Stumpd8fe7b22009-08-05 22:37:18 +000029/// IsNearlyEmpty - Indicates when a class has a vtable pointer, but
30/// no other data.
Anders Carlsson81430692009-09-22 03:02:06 +000031bool ASTRecordLayoutBuilder::IsNearlyEmpty(const CXXRecordDecl *RD) const {
Mike Stumpd8fe7b22009-08-05 22:37:18 +000032 // FIXME: Audit the corners
33 if (!RD->isDynamicClass())
34 return false;
35 const ASTRecordLayout &BaseInfo = Ctx.getASTRecordLayout(RD);
36 if (BaseInfo.getNonVirtualSize() == Ctx.Target.getPointerWidth(0))
37 return true;
38 return false;
39}
40
Anders Carlsson81430692009-09-22 03:02:06 +000041void ASTRecordLayoutBuilder::IdentifyPrimaryBases(const CXXRecordDecl *RD) {
Daniel Dunbaraa423af2010-04-08 02:59:49 +000042 const ASTRecordLayout::PrimaryBaseInfo &BaseInfo =
Anders Carlsson03ff3792009-11-27 22:05:05 +000043 Ctx.getASTRecordLayout(RD).getPrimaryBaseInfo();
Daniel Dunbaraa423af2010-04-08 02:59:49 +000044
Anders Carlsson81430692009-09-22 03:02:06 +000045 // If the record has a primary base class that is virtual, add it to the set
46 // of primary bases.
Anders Carlssona30c0d32009-11-27 22:14:40 +000047 if (BaseInfo.isVirtual())
48 IndirectPrimaryBases.insert(BaseInfo.getBase());
Daniel Dunbaraa423af2010-04-08 02:59:49 +000049
Anders Carlsson81430692009-09-22 03:02:06 +000050 // Now traverse all bases and find primary bases for them.
Mike Stumpd8fe7b22009-08-05 22:37:18 +000051 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
Daniel Dunbaraa423af2010-04-08 02:59:49 +000052 e = RD->bases_end(); i != e; ++i) {
Sebastian Redl1054fae2009-10-25 17:03:50 +000053 assert(!i->getType()->isDependentType() &&
54 "Cannot layout class with dependent bases.");
Mike Stump11289f42009-09-09 15:08:12 +000055 const CXXRecordDecl *Base =
Mike Stump78696a72009-08-11 04:03:59 +000056 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
Daniel Dunbaraa423af2010-04-08 02:59:49 +000057
Mike Stump78696a72009-08-11 04:03:59 +000058 // Only bases with virtual bases participate in computing the
59 // indirect primary virtual base classes.
Mike Stumpc2f591b2009-08-13 22:53:07 +000060 if (Base->getNumVBases())
Anders Carlsson81430692009-09-22 03:02:06 +000061 IdentifyPrimaryBases(Base);
Mike Stumpd8fe7b22009-08-05 22:37:18 +000062 }
63}
64
Anders Carlsson81430692009-09-22 03:02:06 +000065void
Anders Carlsson8630b5b2010-03-11 00:15:35 +000066ASTRecordLayoutBuilder::SelectPrimaryVBase(const CXXRecordDecl *RD) {
Anders Carlssonf2fa75b2010-03-11 03:39:12 +000067 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
Daniel Dunbaraa423af2010-04-08 02:59:49 +000068 E = RD->bases_end(); I != E; ++I) {
Anders Carlssonf2fa75b2010-03-11 03:39:12 +000069 assert(!I->getType()->isDependentType() &&
Sebastian Redl1054fae2009-10-25 17:03:50 +000070 "Cannot layout class with dependent bases.");
Daniel Dunbaraa423af2010-04-08 02:59:49 +000071
Mike Stump11289f42009-09-09 15:08:12 +000072 const CXXRecordDecl *Base =
Anders Carlssonf2fa75b2010-03-11 03:39:12 +000073 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
Anders Carlsson8630b5b2010-03-11 00:15:35 +000074
Anders Carlssonf2fa75b2010-03-11 03:39:12 +000075 // Check if this is a nearly empty virtual base.
76 if (I->isVirtual() && IsNearlyEmpty(Base)) {
77 // If it's not an indirect primary base, then we've found our primary
78 // base.
Anders Carlsson81430692009-09-22 03:02:06 +000079 if (!IndirectPrimaryBases.count(Base)) {
Anders Carlsson8630b5b2010-03-11 00:15:35 +000080 PrimaryBase = ASTRecordLayout::PrimaryBaseInfo(Base,
81 /*IsVirtual=*/true);
Mike Stump6f3793b2009-08-12 21:50:08 +000082 return;
83 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +000084
Anders Carlssonf2fa75b2010-03-11 03:39:12 +000085 // Is this the first nearly empty virtual base?
86 if (!FirstNearlyEmptyVBase)
87 FirstNearlyEmptyVBase = Base;
Mike Stump6f3793b2009-08-12 21:50:08 +000088 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +000089
Anders Carlsson8630b5b2010-03-11 00:15:35 +000090 SelectPrimaryVBase(Base);
Zhongxing Xuec345b72010-02-15 04:28:35 +000091 if (PrimaryBase.getBase())
92 return;
Mike Stump6f3793b2009-08-12 21:50:08 +000093 }
94}
95
Anders Carlsson8630b5b2010-03-11 00:15:35 +000096/// DeterminePrimaryBase - Determine the primary base of the given class.
97void ASTRecordLayoutBuilder::DeterminePrimaryBase(const CXXRecordDecl *RD) {
98 // If the class isn't dynamic, it won't have a primary base.
99 if (!RD->isDynamicClass())
100 return;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000101
Anders Carlsson81430692009-09-22 03:02:06 +0000102 // Compute all the primary virtual bases for all of our direct and
Mike Stump590a7c72009-08-13 23:26:06 +0000103 // indirect bases, and record all their primary virtual base classes.
Mike Stump590a7c72009-08-13 23:26:06 +0000104 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000105 e = RD->bases_end(); i != e; ++i) {
Sebastian Redl1054fae2009-10-25 17:03:50 +0000106 assert(!i->getType()->isDependentType() &&
Anders Carlsson8630b5b2010-03-11 00:15:35 +0000107 "Cannot lay out class with dependent bases.");
Mike Stump11289f42009-09-09 15:08:12 +0000108 const CXXRecordDecl *Base =
Mike Stump590a7c72009-08-13 23:26:06 +0000109 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
Anders Carlsson81430692009-09-22 03:02:06 +0000110 IdentifyPrimaryBases(Base);
Mike Stump590a7c72009-08-13 23:26:06 +0000111 }
112
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000113 // If the record has a dynamic base class, attempt to choose a primary base
114 // class. It is the first (in direct base class order) non-virtual dynamic
Anders Carlsson81430692009-09-22 03:02:06 +0000115 // base class, if one exists.
Mike Stumpd8fe7b22009-08-05 22:37:18 +0000116 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000117 e = RD->bases_end(); i != e; ++i) {
Anders Carlsson03ff3792009-11-27 22:05:05 +0000118 // Ignore virtual bases.
119 if (i->isVirtual())
120 continue;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000121
Anders Carlsson03ff3792009-11-27 22:05:05 +0000122 const CXXRecordDecl *Base =
123 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
124
125 if (Base->isDynamicClass()) {
126 // We found it.
127 PrimaryBase = ASTRecordLayout::PrimaryBaseInfo(Base, /*IsVirtual=*/false);
128 return;
Mike Stumpd8fe7b22009-08-05 22:37:18 +0000129 }
130 }
131
132 // Otherwise, it is the first nearly empty virtual base that is not an
Mike Stump78696a72009-08-11 04:03:59 +0000133 // indirect primary virtual base class, if one exists.
Anders Carlsson8630b5b2010-03-11 00:15:35 +0000134 if (RD->getNumVBases() != 0) {
135 SelectPrimaryVBase(RD);
136 if (PrimaryBase.getBase())
137 return;
138 }
Mike Stumpd8fe7b22009-08-05 22:37:18 +0000139
Anders Carlsson8630b5b2010-03-11 00:15:35 +0000140 // Otherwise, it is the first nearly empty virtual base that is not an
141 // indirect primary virtual base class, if one exists.
142 if (FirstNearlyEmptyVBase) {
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000143 PrimaryBase = ASTRecordLayout::PrimaryBaseInfo(FirstNearlyEmptyVBase,
Anders Carlssonf2fa75b2010-03-11 03:39:12 +0000144 /*IsVirtual=*/true);
Mike Stumpd8fe7b22009-08-05 22:37:18 +0000145 return;
Anders Carlsson8630b5b2010-03-11 00:15:35 +0000146 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000147
Anders Carlsson8630b5b2010-03-11 00:15:35 +0000148 // Otherwise there is no primary base class.
149 assert(!PrimaryBase.getBase() && "Should not get here with a primary base!");
Mike Stumpd8fe7b22009-08-05 22:37:18 +0000150
Anders Carlsson8630b5b2010-03-11 00:15:35 +0000151 // Allocate the virtual table pointer at offset zero.
152 assert(DataSize == 0 && "Vtable pointer must be at offset zero!");
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000153
Anders Carlsson8630b5b2010-03-11 00:15:35 +0000154 // Update the size.
155 Size += Ctx.Target.getPointerWidth(0);
156 DataSize = Size;
157
158 // Update the alignment.
159 UpdateAlignment(Ctx.Target.getPointerAlign(0));
Mike Stumpd8fe7b22009-08-05 22:37:18 +0000160}
161
Anders Carlsson09ffa322010-03-10 22:21:28 +0000162void
163ASTRecordLayoutBuilder::LayoutNonVirtualBases(const CXXRecordDecl *RD) {
Anders Carlsson8630b5b2010-03-11 00:15:35 +0000164 // First, determine the primary base class.
165 DeterminePrimaryBase(RD);
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000166
Anders Carlsson8630b5b2010-03-11 00:15:35 +0000167 // If we have a primary base class, lay it out.
168 if (const CXXRecordDecl *Base = PrimaryBase.getBase()) {
Anders Carlsson8630b5b2010-03-11 00:15:35 +0000169 if (PrimaryBase.isVirtual()) {
170 // We have a virtual primary base, insert it as an indirect primary base.
171 IndirectPrimaryBases.insert(Base);
Anders Carlssonfe900962010-03-11 05:42:17 +0000172
Anders Carlsson8630b5b2010-03-11 00:15:35 +0000173 LayoutVirtualBase(Base);
174 } else
175 LayoutNonVirtualBase(Base);
176 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000177
Anders Carlsson8630b5b2010-03-11 00:15:35 +0000178 // Now lay out the non-virtual bases.
179 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000180 E = RD->bases_end(); I != E; ++I) {
Anders Carlsson8630b5b2010-03-11 00:15:35 +0000181
182 // Ignore virtual bases.
183 if (I->isVirtual())
184 continue;
185
186 const CXXRecordDecl *Base =
187 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
188
189 // Skip the primary base.
190 if (Base == PrimaryBase.getBase() && !PrimaryBase.isVirtual())
191 continue;
192
193 // Lay out the base.
194 LayoutNonVirtualBase(Base);
Anders Carlsson09ffa322010-03-10 22:21:28 +0000195 }
196}
197
198void ASTRecordLayoutBuilder::LayoutNonVirtualBase(const CXXRecordDecl *RD) {
Anders Carlsson0d0b5882010-03-10 22:26:24 +0000199 // Layout the base.
200 uint64_t Offset = LayoutBase(RD);
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000201
Anders Carlsson0d0b5882010-03-10 22:26:24 +0000202 // Add its base class offset.
Anders Carlsson6a848892010-03-11 04:10:39 +0000203 if (!Bases.insert(std::make_pair(RD, Offset)).second)
204 assert(false && "Added same base offset more than once!");
Anders Carlsson09ffa322010-03-10 22:21:28 +0000205}
Mike Stump2b84dd32009-11-05 04:02:15 +0000206
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000207void
Anders Carlssonde710c92010-03-11 04:33:54 +0000208ASTRecordLayoutBuilder::LayoutVirtualBases(const CXXRecordDecl *RD,
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000209 uint64_t Offset,
210 const CXXRecordDecl *MostDerivedClass) {
Anders Carlssonde710c92010-03-11 04:33:54 +0000211 const CXXRecordDecl *PrimaryBase;
Anders Carlssonfe900962010-03-11 05:42:17 +0000212
Anders Carlssonde710c92010-03-11 04:33:54 +0000213 if (MostDerivedClass == RD)
214 PrimaryBase = this->PrimaryBase.getBase();
215 else {
216 const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD);
217 PrimaryBase = Layout.getPrimaryBase();
218 }
219
Anders Carlssonf7b7a1e2010-03-11 04:24:02 +0000220 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
221 E = RD->bases_end(); I != E; ++I) {
222 assert(!I->getType()->isDependentType() &&
Sebastian Redl1054fae2009-10-25 17:03:50 +0000223 "Cannot layout class with dependent bases.");
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000224
Mike Stump11289f42009-09-09 15:08:12 +0000225 const CXXRecordDecl *Base =
Anders Carlssonf7b7a1e2010-03-11 04:24:02 +0000226 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
227
228 if (I->isVirtual()) {
Anders Carlssonfe900962010-03-11 05:42:17 +0000229 bool IndirectPrimaryBase = IndirectPrimaryBases.count(Base);
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000230
231 // We only want to visit this virtual base if it's either a primary base,
Anders Carlssonfe900962010-03-11 05:42:17 +0000232 // or not an indirect primary base.
233 if (Base == PrimaryBase || !IndirectPrimaryBase) {
Mike Stump996576f32009-08-16 19:04:13 +0000234 // Only lay things out once.
Anders Carlssonfe900962010-03-11 05:42:17 +0000235 if (!VisitedVirtualBases.insert(Base))
Mike Stump996576f32009-08-16 19:04:13 +0000236 continue;
Anders Carlssonfe900962010-03-11 05:42:17 +0000237
238 if (Base == PrimaryBase) {
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000239 assert(IndirectPrimaryBase &&
Anders Carlssonfe900962010-03-11 05:42:17 +0000240 "Base is supposed to be an indirect primary base!");
241
242 // We only want to add a vbase offset if this primary base is not the
243 // primary base of the most derived class.
244 if (PrimaryBase != this->PrimaryBase.getBase() ||
245 !this->PrimaryBase.isVirtual()) {
246 if (!VBases.insert(std::make_pair(Base, Offset)).second)
247 assert(false && "Added same vbase offset more than once!");
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000248 }
Anders Carlssonfe900962010-03-11 05:42:17 +0000249 } else {
250 // We actually do want to lay out this base.
251 LayoutVirtualBase(Base);
Anders Carlsson6a848892010-03-11 04:10:39 +0000252 }
Mike Stump2b84dd32009-11-05 04:02:15 +0000253 }
Mike Stumpc2f591b2009-08-13 22:53:07 +0000254 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000255
Anders Carlssonf7b7a1e2010-03-11 04:24:02 +0000256 if (!Base->getNumVBases()) {
257 // This base isn't interesting since it doesn't have any virtual bases.
258 continue;
Mike Stump996576f32009-08-16 19:04:13 +0000259 }
Anders Carlssonf7b7a1e2010-03-11 04:24:02 +0000260
261 // Compute the offset of this base.
262 uint64_t BaseOffset;
263
264 if (I->isVirtual()) {
265 // We want the vbase offset from the class we're currently laying out.
266 assert(VBases.count(Base) && "Did not find virtual base!");
267 BaseOffset = VBases[Base];
Anders Carlssonde710c92010-03-11 04:33:54 +0000268 } else if (RD == MostDerivedClass) {
Anders Carlssonf7b7a1e2010-03-11 04:24:02 +0000269 // We want the base offset from the class we're currently laying out.
270 assert(Bases.count(Base) && "Did not find base!");
271 BaseOffset = Bases[Base];
272 } else {
273 const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD);
274 BaseOffset = Offset + Layout.getBaseClassOffset(Base);
275 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000276
Anders Carlssonde710c92010-03-11 04:33:54 +0000277 LayoutVirtualBases(Base, BaseOffset, MostDerivedClass);
Mike Stump6b2556f2009-08-06 13:41:24 +0000278 }
279}
280
Anders Carlsson09ffa322010-03-10 22:21:28 +0000281void ASTRecordLayoutBuilder::LayoutVirtualBase(const CXXRecordDecl *RD) {
Anders Carlsson0d0b5882010-03-10 22:26:24 +0000282 // Layout the base.
283 uint64_t Offset = LayoutBase(RD);
284
285 // Add its base class offset.
Anders Carlsson6a848892010-03-11 04:10:39 +0000286 if (!VBases.insert(std::make_pair(RD, Offset)).second)
287 assert(false && "Added same vbase offset more than once!");
Anders Carlsson09ffa322010-03-10 22:21:28 +0000288}
289
290uint64_t ASTRecordLayoutBuilder::LayoutBase(const CXXRecordDecl *RD) {
291 const ASTRecordLayout &BaseInfo = Ctx.getASTRecordLayout(RD);
292
293 // If we have an empty base class, try to place it at offset 0.
294 if (RD->isEmpty() && canPlaceRecordAtOffset(RD, 0)) {
295 // We were able to place the class at offset 0.
296 UpdateEmptyClassOffsets(RD, 0);
297
298 Size = std::max(Size, BaseInfo.getSize());
299
300 return 0;
301 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000302
Anders Carlsson09ffa322010-03-10 22:21:28 +0000303 unsigned BaseAlign = BaseInfo.getNonVirtualAlign();
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000304
Anders Carlsson09ffa322010-03-10 22:21:28 +0000305 // Round up the current record size to the base's alignment boundary.
306 uint64_t Offset = llvm::RoundUpToAlignment(DataSize, BaseAlign);
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000307
Anders Carlsson09ffa322010-03-10 22:21:28 +0000308 // Try to place the base.
309 while (true) {
310 if (canPlaceRecordAtOffset(RD, Offset))
311 break;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000312
Anders Carlsson09ffa322010-03-10 22:21:28 +0000313 Offset += BaseAlign;
314 }
315
316 if (!RD->isEmpty()) {
317 // Update the data size.
318 DataSize = Offset + BaseInfo.getNonVirtualSize();
319
320 Size = std::max(Size, DataSize);
321 } else
322 Size = std::max(Size, Offset + BaseInfo.getSize());
323
324 // Remember max struct/class alignment.
325 UpdateAlignment(BaseAlign);
326
327 UpdateEmptyClassOffsets(RD, Offset);
328 return Offset;
329}
330
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000331bool ASTRecordLayoutBuilder::canPlaceRecordAtOffset(const CXXRecordDecl *RD,
Anders Carlsson6522b052009-09-24 03:13:30 +0000332 uint64_t Offset) const {
Anders Carlssonf24b18f2009-09-24 03:22:10 +0000333 // Look for an empty class with the same type at the same offset.
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000334 for (EmptyClassOffsetsTy::const_iterator I =
335 EmptyClassOffsets.lower_bound(Offset),
336 E = EmptyClassOffsets.upper_bound(Offset); I != E; ++I) {
337
Anders Carlssonf24b18f2009-09-24 03:22:10 +0000338 if (I->second == RD)
339 return false;
340 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000341
Anders Carlssonbb66bc82009-09-24 05:21:31 +0000342 const ASTRecordLayout &Info = Ctx.getASTRecordLayout(RD);
343
344 // Check bases.
345 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000346 E = RD->bases_end(); I != E; ++I) {
Sebastian Redl1054fae2009-10-25 17:03:50 +0000347 assert(!I->getType()->isDependentType() &&
348 "Cannot layout class with dependent bases.");
Anders Carlssonbb66bc82009-09-24 05:21:31 +0000349 if (I->isVirtual())
350 continue;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000351
Anders Carlssonbb66bc82009-09-24 05:21:31 +0000352 const CXXRecordDecl *Base =
353 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
354
355 uint64_t BaseClassOffset = Info.getBaseClassOffset(Base);
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000356
Anders Carlssonbb66bc82009-09-24 05:21:31 +0000357 if (!canPlaceRecordAtOffset(Base, Offset + BaseClassOffset))
358 return false;
359 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000360
Anders Carlssond7d358a2009-09-25 15:39:00 +0000361 // Check fields.
362 unsigned FieldNo = 0;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000363 for (CXXRecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end();
Anders Carlssond7d358a2009-09-25 15:39:00 +0000364 I != E; ++I, ++FieldNo) {
365 const FieldDecl *FD = *I;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000366
Anders Carlssond7d358a2009-09-25 15:39:00 +0000367 uint64_t FieldOffset = Info.getFieldOffset(FieldNo);
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000368
Anders Carlssond7d358a2009-09-25 15:39:00 +0000369 if (!canPlaceFieldAtOffset(FD, Offset + FieldOffset))
370 return false;
371 }
372
Anders Carlssonbb66bc82009-09-24 05:21:31 +0000373 // FIXME: virtual bases.
Anders Carlsson6522b052009-09-24 03:13:30 +0000374 return true;
375}
376
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000377bool ASTRecordLayoutBuilder::canPlaceFieldAtOffset(const FieldDecl *FD,
Anders Carlsson6f95c702009-09-25 00:02:51 +0000378 uint64_t Offset) const {
Anders Carlsson4bf82142009-09-25 01:23:32 +0000379 QualType T = FD->getType();
380 if (const RecordType *RT = T->getAs<RecordType>()) {
Anders Carlsson6f95c702009-09-25 00:02:51 +0000381 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
382 return canPlaceRecordAtOffset(RD, Offset);
383 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000384
Anders Carlsson4bf82142009-09-25 01:23:32 +0000385 if (const ConstantArrayType *AT = Ctx.getAsConstantArrayType(T)) {
386 QualType ElemTy = Ctx.getBaseElementType(AT);
387 const RecordType *RT = ElemTy->getAs<RecordType>();
388 if (!RT)
389 return true;
390 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
391 if (!RD)
392 return true;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000393
Anders Carlsson4bf82142009-09-25 01:23:32 +0000394 const ASTRecordLayout &Info = Ctx.getASTRecordLayout(RD);
395
396 uint64_t NumElements = Ctx.getConstantArrayElementCount(AT);
Mike Stump2b84dd32009-11-05 04:02:15 +0000397 uint64_t ElementOffset = Offset;
Anders Carlsson4bf82142009-09-25 01:23:32 +0000398 for (uint64_t I = 0; I != NumElements; ++I) {
399 if (!canPlaceRecordAtOffset(RD, ElementOffset))
400 return false;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000401
Anders Carlsson4bf82142009-09-25 01:23:32 +0000402 ElementOffset += Info.getSize();
403 }
404 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000405
Anders Carlsson6f95c702009-09-25 00:02:51 +0000406 return true;
407}
408
Anders Carlsson6522b052009-09-24 03:13:30 +0000409void ASTRecordLayoutBuilder::UpdateEmptyClassOffsets(const CXXRecordDecl *RD,
410 uint64_t Offset) {
Anders Carlssonf24b18f2009-09-24 03:22:10 +0000411 if (RD->isEmpty())
412 EmptyClassOffsets.insert(std::make_pair(Offset, RD));
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000413
Anders Carlssonbb66bc82009-09-24 05:21:31 +0000414 const ASTRecordLayout &Info = Ctx.getASTRecordLayout(RD);
415
416 // Update bases.
417 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000418 E = RD->bases_end(); I != E; ++I) {
Sebastian Redl1054fae2009-10-25 17:03:50 +0000419 assert(!I->getType()->isDependentType() &&
420 "Cannot layout class with dependent bases.");
Anders Carlssonbb66bc82009-09-24 05:21:31 +0000421 if (I->isVirtual())
422 continue;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000423
Anders Carlssonbb66bc82009-09-24 05:21:31 +0000424 const CXXRecordDecl *Base =
425 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000426
Anders Carlssonbb66bc82009-09-24 05:21:31 +0000427 uint64_t BaseClassOffset = Info.getBaseClassOffset(Base);
428 UpdateEmptyClassOffsets(Base, Offset + BaseClassOffset);
429 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000430
Anders Carlssond7d358a2009-09-25 15:39:00 +0000431 // Update fields.
432 unsigned FieldNo = 0;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000433 for (CXXRecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end();
Anders Carlssond7d358a2009-09-25 15:39:00 +0000434 I != E; ++I, ++FieldNo) {
435 const FieldDecl *FD = *I;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000436
Anders Carlssond7d358a2009-09-25 15:39:00 +0000437 uint64_t FieldOffset = Info.getFieldOffset(FieldNo);
438 UpdateEmptyClassOffsets(FD, Offset + FieldOffset);
439 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000440
Anders Carlssond7d358a2009-09-25 15:39:00 +0000441 // FIXME: Update virtual bases.
Anders Carlsson6522b052009-09-24 03:13:30 +0000442}
443
Anders Carlssone1883102009-09-25 01:54:38 +0000444void
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000445ASTRecordLayoutBuilder::UpdateEmptyClassOffsets(const FieldDecl *FD,
Anders Carlssone1883102009-09-25 01:54:38 +0000446 uint64_t Offset) {
447 QualType T = FD->getType();
448
449 if (const RecordType *RT = T->getAs<RecordType>()) {
450 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
451 UpdateEmptyClassOffsets(RD, Offset);
452 return;
453 }
454 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000455
Anders Carlssone1883102009-09-25 01:54:38 +0000456 if (const ConstantArrayType *AT = Ctx.getAsConstantArrayType(T)) {
457 QualType ElemTy = Ctx.getBaseElementType(AT);
458 const RecordType *RT = ElemTy->getAs<RecordType>();
459 if (!RT)
460 return;
461 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
462 if (!RD)
463 return;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000464
Anders Carlssone1883102009-09-25 01:54:38 +0000465 const ASTRecordLayout &Info = Ctx.getASTRecordLayout(RD);
466
467 uint64_t NumElements = Ctx.getConstantArrayElementCount(AT);
Mike Stump2b84dd32009-11-05 04:02:15 +0000468 uint64_t ElementOffset = Offset;
Anders Carlssone1883102009-09-25 01:54:38 +0000469
470 for (uint64_t I = 0; I != NumElements; ++I) {
471 UpdateEmptyClassOffsets(RD, ElementOffset);
472 ElementOffset += Info.getSize();
473 }
474 }
475}
476
Anders Carlsson79474332009-07-18 20:20:21 +0000477void ASTRecordLayoutBuilder::Layout(const RecordDecl *D) {
478 IsUnion = D->isUnion();
Anders Carlsson68e0b682009-08-08 18:23:56 +0000479
Anders Carlsson28a5fa22009-08-08 19:38:24 +0000480 Packed = D->hasAttr<PackedAttr>();
481
482 // The #pragma pack attribute specifies the maximum field alignment.
Anders Carlsson68e0b682009-08-08 18:23:56 +0000483 if (const PragmaPackAttr *PPA = D->getAttr<PragmaPackAttr>())
Anders Carlsson28a5fa22009-08-08 19:38:24 +0000484 MaxFieldAlignment = PPA->getAlignment();
Mike Stump11289f42009-09-09 15:08:12 +0000485
Anders Carlsson79474332009-07-18 20:20:21 +0000486 if (const AlignedAttr *AA = D->getAttr<AlignedAttr>())
Alexis Hunt96d5c762009-11-21 08:43:09 +0000487 UpdateAlignment(AA->getMaxAlignment());
Anders Carlsson6d9f6f32009-07-19 00:18:47 +0000488
Mike Stump22ea1f82009-08-16 01:46:26 +0000489 // If this is a C++ class, lay out the vtable and the non-virtual bases.
Mike Stump6b2556f2009-08-06 13:41:24 +0000490 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D);
Anders Carlsson8630b5b2010-03-11 00:15:35 +0000491 if (RD)
Mike Stump3dc7eb92009-07-30 00:22:38 +0000492 LayoutNonVirtualBases(RD);
Anders Carlsson6d9f6f32009-07-19 00:18:47 +0000493
Anders Carlsson118ce162009-07-18 21:48:39 +0000494 LayoutFields(D);
Mike Stump11289f42009-09-09 15:08:12 +0000495
Anders Carlssonfc8cfa82009-07-28 19:24:15 +0000496 NonVirtualSize = Size;
497 NonVirtualAlignment = Alignment;
Mike Stump3dc7eb92009-07-30 00:22:38 +0000498
Anders Carlssonfe900962010-03-11 05:42:17 +0000499 // If this is a C++ class, lay out its virtual bases.
Anders Carlssonde710c92010-03-11 04:33:54 +0000500 if (RD)
501 LayoutVirtualBases(RD, 0, RD);
Mike Stump6b2556f2009-08-06 13:41:24 +0000502
Anders Carlsson79474332009-07-18 20:20:21 +0000503 // Finally, round the size of the total struct up to the alignment of the
504 // struct itself.
505 FinishLayout();
506}
507
Fariborz Jahanianaef66222010-02-19 00:31:17 +0000508// FIXME. Impl is no longer needed.
Anders Carlsson4f516282009-07-18 20:50:59 +0000509void ASTRecordLayoutBuilder::Layout(const ObjCInterfaceDecl *D,
510 const ObjCImplementationDecl *Impl) {
511 if (ObjCInterfaceDecl *SD = D->getSuperClass()) {
512 const ASTRecordLayout &SL = Ctx.getASTObjCInterfaceLayout(SD);
513
514 UpdateAlignment(SL.getAlignment());
Mike Stump11289f42009-09-09 15:08:12 +0000515
Anders Carlsson4f516282009-07-18 20:50:59 +0000516 // We start laying out ivars not at the end of the superclass
517 // structure, but at the next byte following the last field.
Anders Carlsson27b50132009-07-18 21:26:44 +0000518 Size = llvm::RoundUpToAlignment(SL.getDataSize(), 8);
Anders Carlsson47680d82009-09-26 01:34:51 +0000519 DataSize = Size;
Anders Carlsson4f516282009-07-18 20:50:59 +0000520 }
Mike Stump11289f42009-09-09 15:08:12 +0000521
Anders Carlsson28a5fa22009-08-08 19:38:24 +0000522 Packed = D->hasAttr<PackedAttr>();
Mike Stump11289f42009-09-09 15:08:12 +0000523
Anders Carlsson28a5fa22009-08-08 19:38:24 +0000524 // The #pragma pack attribute specifies the maximum field alignment.
525 if (const PragmaPackAttr *PPA = D->getAttr<PragmaPackAttr>())
526 MaxFieldAlignment = PPA->getAlignment();
Mike Stump11289f42009-09-09 15:08:12 +0000527
Anders Carlsson4f516282009-07-18 20:50:59 +0000528 if (const AlignedAttr *AA = D->getAttr<AlignedAttr>())
Alexis Hunt96d5c762009-11-21 08:43:09 +0000529 UpdateAlignment(AA->getMaxAlignment());
Anders Carlsson4f516282009-07-18 20:50:59 +0000530 // Layout each ivar sequentially.
531 llvm::SmallVector<ObjCIvarDecl*, 16> Ivars;
Fariborz Jahanianaef66222010-02-19 00:31:17 +0000532 Ctx.ShallowCollectObjCIvars(D, Ivars);
Anders Carlsson4f516282009-07-18 20:50:59 +0000533 for (unsigned i = 0, e = Ivars.size(); i != e; ++i)
534 LayoutField(Ivars[i]);
Mike Stump11289f42009-09-09 15:08:12 +0000535
Anders Carlsson4f516282009-07-18 20:50:59 +0000536 // Finally, round the size of the total struct up to the alignment of the
537 // struct itself.
538 FinishLayout();
539}
540
Anders Carlsson118ce162009-07-18 21:48:39 +0000541void ASTRecordLayoutBuilder::LayoutFields(const RecordDecl *D) {
542 // Layout each field, for now, just sequentially, respecting alignment. In
543 // the future, this will need to be tweakable by targets.
Mike Stump11289f42009-09-09 15:08:12 +0000544 for (RecordDecl::field_iterator Field = D->field_begin(),
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000545 FieldEnd = D->field_end(); Field != FieldEnd; ++Field)
Anders Carlsson118ce162009-07-18 21:48:39 +0000546 LayoutField(*Field);
547}
548
Anders Carlsson07209442009-11-22 17:37:31 +0000549void ASTRecordLayoutBuilder::LayoutBitField(const FieldDecl *D) {
550 bool FieldPacked = Packed || D->hasAttr<PackedAttr>();
Anders Carlssonba958402009-11-22 19:13:51 +0000551 uint64_t FieldOffset = IsUnion ? 0 : (DataSize - UnfilledBitsInLastByte);
Anders Carlsson07209442009-11-22 17:37:31 +0000552 uint64_t FieldSize = D->getBitWidth()->EvaluateAsInt(Ctx).getZExtValue();
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000553
Anders Carlsson07209442009-11-22 17:37:31 +0000554 std::pair<uint64_t, unsigned> FieldInfo = Ctx.getTypeInfo(D->getType());
555 uint64_t TypeSize = FieldInfo.first;
556 unsigned FieldAlign = FieldInfo.second;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000557
Anders Carlsson07209442009-11-22 17:37:31 +0000558 if (FieldPacked)
559 FieldAlign = 1;
560 if (const AlignedAttr *AA = D->getAttr<AlignedAttr>())
561 FieldAlign = std::max(FieldAlign, AA->getMaxAlignment());
562
563 // The maximum field alignment overrides the aligned attribute.
564 if (MaxFieldAlignment)
565 FieldAlign = std::min(FieldAlign, MaxFieldAlignment);
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000566
Anders Carlsson07209442009-11-22 17:37:31 +0000567 // Check if we need to add padding to give the field the correct
568 // alignment.
569 if (FieldSize == 0 || (FieldOffset & (FieldAlign-1)) + FieldSize > TypeSize)
570 FieldOffset = (FieldOffset + (FieldAlign-1)) & ~(FieldAlign-1);
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000571
Anders Carlsson07209442009-11-22 17:37:31 +0000572 // Padding members don't affect overall alignment
573 if (!D->getIdentifier())
574 FieldAlign = 1;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000575
Anders Carlsson07209442009-11-22 17:37:31 +0000576 // Place this field at the current location.
577 FieldOffsets.push_back(FieldOffset);
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000578
Anders Carlssonba958402009-11-22 19:13:51 +0000579 // Update DataSize to include the last byte containing (part of) the bitfield.
580 if (IsUnion) {
581 // FIXME: I think FieldSize should be TypeSize here.
582 DataSize = std::max(DataSize, FieldSize);
583 } else {
584 uint64_t NewSizeInBits = FieldOffset + FieldSize;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000585
Anders Carlssonba958402009-11-22 19:13:51 +0000586 DataSize = llvm::RoundUpToAlignment(NewSizeInBits, 8);
587 UnfilledBitsInLastByte = DataSize - NewSizeInBits;
588 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000589
Anders Carlssonba958402009-11-22 19:13:51 +0000590 // Update the size.
591 Size = std::max(Size, DataSize);
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000592
Anders Carlsson07209442009-11-22 17:37:31 +0000593 // Remember max struct/class alignment.
594 UpdateAlignment(FieldAlign);
595}
596
Anders Carlsson79474332009-07-18 20:20:21 +0000597void ASTRecordLayoutBuilder::LayoutField(const FieldDecl *D) {
Anders Carlsson07209442009-11-22 17:37:31 +0000598 if (D->isBitField()) {
599 LayoutBitField(D);
600 return;
601 }
602
Anders Carlssonba958402009-11-22 19:13:51 +0000603 // Reset the unfilled bits.
604 UnfilledBitsInLastByte = 0;
605
Anders Carlsson07209442009-11-22 17:37:31 +0000606 bool FieldPacked = Packed || D->hasAttr<PackedAttr>();
Anders Carlsson47680d82009-09-26 01:34:51 +0000607 uint64_t FieldOffset = IsUnion ? 0 : DataSize;
Anders Carlsson79474332009-07-18 20:20:21 +0000608 uint64_t FieldSize;
609 unsigned FieldAlign;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000610
Anders Carlsson07209442009-11-22 17:37:31 +0000611 if (D->getType()->isIncompleteArrayType()) {
612 // This is a flexible array member; we can't directly
613 // query getTypeInfo about these, so we figure it out here.
614 // Flexible array members don't have any size, but they
615 // have to be aligned appropriately for their element type.
616 FieldSize = 0;
617 const ArrayType* ATy = Ctx.getAsArrayType(D->getType());
618 FieldAlign = Ctx.getTypeAlign(ATy->getElementType());
619 } else if (const ReferenceType *RT = D->getType()->getAs<ReferenceType>()) {
620 unsigned AS = RT->getPointeeType().getAddressSpace();
621 FieldSize = Ctx.Target.getPointerWidth(AS);
622 FieldAlign = Ctx.Target.getPointerAlign(AS);
Anders Carlsson79474332009-07-18 20:20:21 +0000623 } else {
Anders Carlsson07209442009-11-22 17:37:31 +0000624 std::pair<uint64_t, unsigned> FieldInfo = Ctx.getTypeInfo(D->getType());
625 FieldSize = FieldInfo.first;
626 FieldAlign = FieldInfo.second;
Anders Carlsson79474332009-07-18 20:20:21 +0000627 }
Mike Stump11289f42009-09-09 15:08:12 +0000628
Anders Carlsson07209442009-11-22 17:37:31 +0000629 if (FieldPacked)
630 FieldAlign = 8;
631 if (const AlignedAttr *AA = D->getAttr<AlignedAttr>())
632 FieldAlign = std::max(FieldAlign, AA->getMaxAlignment());
633
634 // The maximum field alignment overrides the aligned attribute.
635 if (MaxFieldAlignment)
636 FieldAlign = std::min(FieldAlign, MaxFieldAlignment);
637
638 // Round up the current record size to the field's alignment boundary.
639 FieldOffset = llvm::RoundUpToAlignment(FieldOffset, FieldAlign);
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000640
Anders Carlsson07209442009-11-22 17:37:31 +0000641 if (!IsUnion) {
642 while (true) {
643 // Check if we can place the field at this offset.
644 if (canPlaceFieldAtOffset(D, FieldOffset))
645 break;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000646
Anders Carlsson07209442009-11-22 17:37:31 +0000647 // We couldn't place the field at the offset. Try again at a new offset.
648 FieldOffset += FieldAlign;
649 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000650
Anders Carlsson07209442009-11-22 17:37:31 +0000651 UpdateEmptyClassOffsets(D, FieldOffset);
652 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000653
Anders Carlsson79474332009-07-18 20:20:21 +0000654 // Place this field at the current location.
655 FieldOffsets.push_back(FieldOffset);
Mike Stump11289f42009-09-09 15:08:12 +0000656
Anders Carlsson79474332009-07-18 20:20:21 +0000657 // Reserve space for this field.
658 if (IsUnion)
659 Size = std::max(Size, FieldSize);
660 else
661 Size = FieldOffset + FieldSize;
Mike Stump11289f42009-09-09 15:08:12 +0000662
Anders Carlsson47680d82009-09-26 01:34:51 +0000663 // Update the data size.
664 DataSize = Size;
Mike Stump11289f42009-09-09 15:08:12 +0000665
Anders Carlsson79474332009-07-18 20:20:21 +0000666 // Remember max struct/class alignment.
667 UpdateAlignment(FieldAlign);
668}
669
670void ASTRecordLayoutBuilder::FinishLayout() {
671 // In C++, records cannot be of size 0.
672 if (Ctx.getLangOptions().CPlusPlus && Size == 0)
673 Size = 8;
674 // Finally, round the size of the record up to the alignment of the
675 // record itself.
Anders Carlsson07209442009-11-22 17:37:31 +0000676 Size = llvm::RoundUpToAlignment(Size, Alignment);
Anders Carlsson79474332009-07-18 20:20:21 +0000677}
678
679void ASTRecordLayoutBuilder::UpdateAlignment(unsigned NewAlignment) {
680 if (NewAlignment <= Alignment)
681 return;
Mike Stump11289f42009-09-09 15:08:12 +0000682
Anders Carlsson79474332009-07-18 20:20:21 +0000683 assert(llvm::isPowerOf2_32(NewAlignment && "Alignment not a power of 2"));
Mike Stump11289f42009-09-09 15:08:12 +0000684
Anders Carlsson79474332009-07-18 20:20:21 +0000685 Alignment = NewAlignment;
686}
Mike Stump11289f42009-09-09 15:08:12 +0000687
Anders Carlsson5ebf8b42009-12-07 04:35:11 +0000688const ASTRecordLayout *
689ASTRecordLayoutBuilder::ComputeLayout(ASTContext &Ctx,
690 const RecordDecl *D) {
691 ASTRecordLayoutBuilder Builder(Ctx);
692
693 Builder.Layout(D);
694
695 if (!isa<CXXRecordDecl>(D))
Ted Kremenekc3015a92010-03-08 20:56:29 +0000696 return new (Ctx) ASTRecordLayout(Ctx, Builder.Size, Builder.Alignment,
697 Builder.Size,
698 Builder.FieldOffsets.data(),
699 Builder.FieldOffsets.size());
Anders Carlsson5ebf8b42009-12-07 04:35:11 +0000700
701 // FIXME: This is not always correct. See the part about bitfields at
702 // http://www.codesourcery.com/public/cxx-abi/abi.html#POD for more info.
703 // FIXME: IsPODForThePurposeOfLayout should be stored in the record layout.
704 bool IsPODForThePurposeOfLayout = cast<CXXRecordDecl>(D)->isPOD();
705
706 // FIXME: This should be done in FinalizeLayout.
707 uint64_t DataSize =
708 IsPODForThePurposeOfLayout ? Builder.Size : Builder.DataSize;
709 uint64_t NonVirtualSize =
710 IsPODForThePurposeOfLayout ? DataSize : Builder.NonVirtualSize;
711
Ted Kremenekc3015a92010-03-08 20:56:29 +0000712 return new (Ctx) ASTRecordLayout(Ctx, Builder.Size, Builder.Alignment,
713 DataSize, Builder.FieldOffsets.data(),
714 Builder.FieldOffsets.size(),
715 NonVirtualSize,
716 Builder.NonVirtualAlignment,
717 Builder.PrimaryBase,
Anders Carlsson6a848892010-03-11 04:10:39 +0000718 Builder.Bases, Builder.VBases);
Anders Carlsson5ebf8b42009-12-07 04:35:11 +0000719}
720
721const ASTRecordLayout *
722ASTRecordLayoutBuilder::ComputeLayout(ASTContext &Ctx,
723 const ObjCInterfaceDecl *D,
724 const ObjCImplementationDecl *Impl) {
725 ASTRecordLayoutBuilder Builder(Ctx);
726
727 Builder.Layout(D, Impl);
728
Ted Kremenekc3015a92010-03-08 20:56:29 +0000729 return new (Ctx) ASTRecordLayout(Ctx, Builder.Size, Builder.Alignment,
730 Builder.DataSize,
731 Builder.FieldOffsets.data(),
732 Builder.FieldOffsets.size());
Anders Carlsson5ebf8b42009-12-07 04:35:11 +0000733}
734
735const CXXMethodDecl *
736ASTRecordLayoutBuilder::ComputeKeyFunction(const CXXRecordDecl *RD) {
737 assert(RD->isDynamicClass() && "Class does not have any virtual methods!");
738
739 // If a class isnt' polymorphic it doesn't have a key function.
740 if (!RD->isPolymorphic())
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +0000741 return 0;
Eli Friedmanf2c79b62009-12-08 03:56:49 +0000742
743 // A class inside an anonymous namespace doesn't have a key function. (Or
744 // at least, there's no point to assigning a key function to such a class;
745 // this doesn't affect the ABI.)
746 if (RD->isInAnonymousNamespace())
747 return 0;
748
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000749 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
750 E = RD->method_end(); I != E; ++I) {
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +0000751 const CXXMethodDecl *MD = *I;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000752
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +0000753 if (!MD->isVirtual())
754 continue;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000755
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +0000756 if (MD->isPure())
757 continue;
Eli Friedmanf2c79b62009-12-08 03:56:49 +0000758
Anders Carlssonf98849e2009-12-02 17:15:43 +0000759 // Ignore implicit member functions, they are always marked as inline, but
760 // they don't have a body until they're defined.
761 if (MD->isImplicit())
762 continue;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000763
Douglas Gregora318efd2010-01-05 19:06:31 +0000764 if (MD->isInlineSpecified())
765 continue;
Eli Friedman71a26d82009-12-06 20:50:05 +0000766
767 if (MD->hasInlineBody())
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +0000768 continue;
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000769
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +0000770 // We found it.
771 return MD;
772 }
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000773
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +0000774 return 0;
775}
776
Daniel Dunbaraa423af2010-04-08 02:59:49 +0000777static void PrintOffset(llvm::raw_ostream &OS,
778 uint64_t Offset, unsigned IndentLevel) {
779 OS << llvm::format("%4d | ", Offset);
780 OS.indent(IndentLevel * 2);
781}
782
783static void DumpCXXRecordLayout(llvm::raw_ostream &OS,
784 const CXXRecordDecl *RD, ASTContext &C,
785 uint64_t Offset,
786 unsigned IndentLevel,
787 const char* Description,
788 bool IncludeVirtualBases) {
789 const ASTRecordLayout &Info = C.getASTRecordLayout(RD);
790
791 PrintOffset(OS, Offset, IndentLevel);
792 OS << C.getTypeDeclType((CXXRecordDecl *)RD).getAsString();
793 if (Description)
794 OS << ' ' << Description;
795 if (RD->isEmpty())
796 OS << " (empty)";
797 OS << '\n';
798
799 IndentLevel++;
800
801 const CXXRecordDecl *PrimaryBase = Info.getPrimaryBase();
802
803 // Vtable pointer.
804 if (RD->isDynamicClass() && !PrimaryBase) {
805 PrintOffset(OS, Offset, IndentLevel);
806 OS << '(' << RD->getNameAsString() << " vtable pointer)\n";
807 }
808 // Dump (non-virtual) bases
809 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
810 E = RD->bases_end(); I != E; ++I) {
811 assert(!I->getType()->isDependentType() &&
812 "Cannot layout class with dependent bases.");
813 if (I->isVirtual())
814 continue;
815
816 const CXXRecordDecl *Base =
817 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
818
819 uint64_t BaseOffset = Offset + Info.getBaseClassOffset(Base) / 8;
820
821 DumpCXXRecordLayout(OS, Base, C, BaseOffset, IndentLevel,
822 Base == PrimaryBase ? "(primary base)" : "(base)",
823 /*IncludeVirtualBases=*/false);
824 }
825
826 // Dump fields.
827 uint64_t FieldNo = 0;
828 for (CXXRecordDecl::field_iterator I = RD->field_begin(),
829 E = RD->field_end(); I != E; ++I, ++FieldNo) {
830 const FieldDecl *Field = *I;
831 uint64_t FieldOffset = Offset + Info.getFieldOffset(FieldNo) / 8;
832
833 if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
834 if (const CXXRecordDecl *D = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
835 DumpCXXRecordLayout(OS, D, C, FieldOffset, IndentLevel,
836 Field->getNameAsCString(),
837 /*IncludeVirtualBases=*/true);
838 continue;
839 }
840 }
841
842 PrintOffset(OS, FieldOffset, IndentLevel);
843 OS << Field->getType().getAsString() << ' ';
844 OS << Field->getNameAsString() << '\n';
845 }
846
847 if (!IncludeVirtualBases)
848 return;
849
850 // Dump virtual bases.
851 for (CXXRecordDecl::base_class_const_iterator I = RD->vbases_begin(),
852 E = RD->vbases_end(); I != E; ++I) {
853 assert(I->isVirtual() && "Found non-virtual class!");
854 const CXXRecordDecl *VBase =
855 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
856
857 uint64_t VBaseOffset = Offset + Info.getVBaseClassOffset(VBase) / 8;
858 DumpCXXRecordLayout(OS, VBase, C, VBaseOffset, IndentLevel,
859 VBase == PrimaryBase ?
860 "(primary virtual base)" : "(virtual base)",
861 /*IncludeVirtualBases=*/false);
862 }
863}
864
865void ASTContext::DumpRecordLayout(const RecordDecl *RD,
866 llvm::raw_ostream &OS) {
867 const ASTRecordLayout &Info = getASTRecordLayout(RD);
868
869 if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
870 DumpCXXRecordLayout(OS, CXXRD, *this, 0, 0, 0,
871 /*IncludeVirtualBases=*/true);
872 else
873 OS << getTypeDeclType((RecordDecl *)RD).getAsString();
874
875 OS << " sizeof=" << Info.getSize() / 8;
876 OS << ", dsize=" << Info.getDataSize() / 8;
877 OS << ", align=" << Info.getAlignment() / 8 << '\n';
878 OS << " nvsize=" << Info.getNonVirtualSize() / 8;
879 OS << ", nvalign=" << Info.getNonVirtualAlign() / 8 << '\n';
880 OS << '\n';
881}