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