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 24 using namespace clang; 25 26 namespace { 27 28 /// BaseSubobjectInfo - Represents a single base subobject in a complete class. 29 /// For a class hierarchy like 30 /// 31 /// class A { }; 32 /// class B : A { }; 33 /// class C : A, B { }; 34 /// 35 /// The BaseSubobjectInfo graph for C will have three BaseSubobjectInfo 36 /// instances, one for B and two for A. 37 /// 38 /// If a base is virtual, it will only have one BaseSubobjectInfo allocated. 39 struct BaseSubobjectInfo { 40 /// Class - The class for this base info. 41 const CXXRecordDecl *Class; 42 43 /// IsVirtual - Whether the BaseInfo represents a virtual base or not. 44 bool IsVirtual; 45 46 /// Bases - Information about the base subobjects. 47 SmallVector<BaseSubobjectInfo*, 4> Bases; 48 49 /// PrimaryVirtualBaseInfo - Holds the base info for the primary virtual base 50 /// of this base info (if one exists). 51 BaseSubobjectInfo *PrimaryVirtualBaseInfo; 52 53 // FIXME: Document. 54 const BaseSubobjectInfo *Derived; 55 }; 56 57 /// EmptySubobjectMap - Keeps track of which empty subobjects exist at different 58 /// offsets while laying out a C++ class. 59 class 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 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 104 protected: 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 117 public: 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 140 void 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 189 bool 190 EmptySubobjectMap::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 208 void 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 227 bool 228 EmptySubobjectMap::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 276 void 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 322 bool 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 338 bool 339 EmptySubobjectMap::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 396 bool 397 EmptySubobjectMap::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 438 bool 439 EmptySubobjectMap::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 450 void 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 504 void 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 541 class RecordLayoutBuilder { 542 protected: 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 SmallVector<uint64_t, 16> FieldOffsets; 560 561 /// \brief Whether the external AST source has provided a layout for this 562 /// record. 563 unsigned ExternalLayout : 1; 564 565 /// \brief Whether we need to infer alignment, even when we have an 566 /// externally-provided layout. 567 unsigned InferAlignment : 1; 568 569 /// Packed - Whether the record is packed or not. 570 unsigned Packed : 1; 571 572 unsigned IsUnion : 1; 573 574 unsigned IsMac68kAlign : 1; 575 576 unsigned IsMsStruct : 1; 577 578 /// UnfilledBitsInLastByte - If the last field laid out was a bitfield, 579 /// this contains the number of bits in the last byte that can be used for 580 /// an adjacent bitfield if necessary. 581 unsigned char UnfilledBitsInLastByte; 582 583 /// MaxFieldAlignment - The maximum allowed field alignment. This is set by 584 /// #pragma pack. 585 CharUnits MaxFieldAlignment; 586 587 /// DataSize - The data size of the record being laid out. 588 uint64_t DataSize; 589 590 CharUnits NonVirtualSize; 591 CharUnits NonVirtualAlignment; 592 593 FieldDecl *ZeroLengthBitfield; 594 595 /// PrimaryBase - the primary base class (if one exists) of the class 596 /// we're laying out. 597 const CXXRecordDecl *PrimaryBase; 598 599 /// PrimaryBaseIsVirtual - Whether the primary base of the class we're laying 600 /// out is virtual. 601 bool PrimaryBaseIsVirtual; 602 603 /// VFPtrOffset - Virtual function table offset. Only for MS layout. 604 CharUnits VFPtrOffset; 605 606 /// VBPtrOffset - Virtual base table offset. Only for MS layout. 607 CharUnits VBPtrOffset; 608 609 typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetsMapTy; 610 611 /// Bases - base classes and their offsets in the record. 612 BaseOffsetsMapTy Bases; 613 614 // VBases - virtual base classes and their offsets in the record. 615 BaseOffsetsMapTy VBases; 616 617 /// IndirectPrimaryBases - Virtual base classes, direct or indirect, that are 618 /// primary base classes for some other direct or indirect base class. 619 CXXIndirectPrimaryBaseSet IndirectPrimaryBases; 620 621 /// FirstNearlyEmptyVBase - The first nearly empty virtual base class in 622 /// inheritance graph order. Used for determining the primary base class. 623 const CXXRecordDecl *FirstNearlyEmptyVBase; 624 625 /// VisitedVirtualBases - A set of all the visited virtual bases, used to 626 /// avoid visiting virtual bases more than once. 627 llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBases; 628 629 /// \brief Externally-provided size. 630 uint64_t ExternalSize; 631 632 /// \brief Externally-provided alignment. 633 uint64_t ExternalAlign; 634 635 /// \brief Externally-provided field offsets. 636 llvm::DenseMap<const FieldDecl *, uint64_t> ExternalFieldOffsets; 637 638 /// \brief Externally-provided direct, non-virtual base offsets. 639 llvm::DenseMap<const CXXRecordDecl *, CharUnits> ExternalBaseOffsets; 640 641 /// \brief Externally-provided virtual base offsets. 642 llvm::DenseMap<const CXXRecordDecl *, CharUnits> ExternalVirtualBaseOffsets; 643 644 RecordLayoutBuilder(const ASTContext &Context, 645 EmptySubobjectMap *EmptySubobjects) 646 : Context(Context), EmptySubobjects(EmptySubobjects), Size(0), 647 Alignment(CharUnits::One()), UnpackedAlignment(CharUnits::One()), 648 ExternalLayout(false), InferAlignment(false), 649 Packed(false), IsUnion(false), IsMac68kAlign(false), IsMsStruct(false), 650 UnfilledBitsInLastByte(0), MaxFieldAlignment(CharUnits::Zero()), 651 DataSize(0), NonVirtualSize(CharUnits::Zero()), 652 NonVirtualAlignment(CharUnits::One()), 653 ZeroLengthBitfield(0), PrimaryBase(0), 654 PrimaryBaseIsVirtual(false), 655 VFPtrOffset(CharUnits::fromQuantity(-1)), 656 VBPtrOffset(CharUnits::fromQuantity(-1)), 657 FirstNearlyEmptyVBase(0) { } 658 659 /// Reset this RecordLayoutBuilder to a fresh state, using the given 660 /// alignment as the initial alignment. This is used for the 661 /// correct layout of vb-table pointers in MSVC. 662 void resetWithTargetAlignment(CharUnits TargetAlignment) { 663 const ASTContext &Context = this->Context; 664 EmptySubobjectMap *EmptySubobjects = this->EmptySubobjects; 665 this->~RecordLayoutBuilder(); 666 new (this) RecordLayoutBuilder(Context, EmptySubobjects); 667 Alignment = UnpackedAlignment = TargetAlignment; 668 } 669 670 void Layout(const RecordDecl *D); 671 void Layout(const CXXRecordDecl *D); 672 void Layout(const ObjCInterfaceDecl *D); 673 674 void LayoutFields(const RecordDecl *D); 675 void LayoutField(const FieldDecl *D); 676 void LayoutWideBitField(uint64_t FieldSize, uint64_t TypeSize, 677 bool FieldPacked, const FieldDecl *D); 678 void LayoutBitField(const FieldDecl *D); 679 680 bool isMicrosoftCXXABI() const { 681 return Context.getTargetInfo().getCXXABI() == CXXABI_Microsoft; 682 } 683 684 void MSLayoutVirtualBases(const CXXRecordDecl *RD); 685 686 /// BaseSubobjectInfoAllocator - Allocator for BaseSubobjectInfo objects. 687 llvm::SpecificBumpPtrAllocator<BaseSubobjectInfo> BaseSubobjectInfoAllocator; 688 689 typedef llvm::DenseMap<const CXXRecordDecl *, BaseSubobjectInfo *> 690 BaseSubobjectInfoMapTy; 691 692 /// VirtualBaseInfo - Map from all the (direct or indirect) virtual bases 693 /// of the class we're laying out to their base subobject info. 694 BaseSubobjectInfoMapTy VirtualBaseInfo; 695 696 /// NonVirtualBaseInfo - Map from all the direct non-virtual bases of the 697 /// class we're laying out to their base subobject info. 698 BaseSubobjectInfoMapTy NonVirtualBaseInfo; 699 700 /// ComputeBaseSubobjectInfo - Compute the base subobject information for the 701 /// bases of the given class. 702 void ComputeBaseSubobjectInfo(const CXXRecordDecl *RD); 703 704 /// ComputeBaseSubobjectInfo - Compute the base subobject information for a 705 /// single class and all of its base classes. 706 BaseSubobjectInfo *ComputeBaseSubobjectInfo(const CXXRecordDecl *RD, 707 bool IsVirtual, 708 BaseSubobjectInfo *Derived); 709 710 /// DeterminePrimaryBase - Determine the primary base of the given class. 711 void DeterminePrimaryBase(const CXXRecordDecl *RD); 712 713 void SelectPrimaryVBase(const CXXRecordDecl *RD); 714 715 void EnsureVTablePointerAlignment(CharUnits UnpackedBaseAlign); 716 717 /// LayoutNonVirtualBases - Determines the primary base class (if any) and 718 /// lays it out. Will then proceed to lay out all non-virtual base clasess. 719 void LayoutNonVirtualBases(const CXXRecordDecl *RD); 720 721 /// LayoutNonVirtualBase - Lays out a single non-virtual base. 722 void LayoutNonVirtualBase(const BaseSubobjectInfo *Base); 723 724 void AddPrimaryVirtualBaseOffsets(const BaseSubobjectInfo *Info, 725 CharUnits Offset); 726 727 bool needsVFTable(const CXXRecordDecl *RD) const; 728 bool hasNewVirtualFunction(const CXXRecordDecl *RD) const; 729 bool isPossiblePrimaryBase(const CXXRecordDecl *Base) const; 730 731 /// LayoutVirtualBases - Lays out all the virtual bases. 732 void LayoutVirtualBases(const CXXRecordDecl *RD, 733 const CXXRecordDecl *MostDerivedClass); 734 735 /// LayoutVirtualBase - Lays out a single virtual base. 736 void LayoutVirtualBase(const BaseSubobjectInfo *Base); 737 738 /// LayoutBase - Will lay out a base and return the offset where it was 739 /// placed, in chars. 740 CharUnits LayoutBase(const BaseSubobjectInfo *Base); 741 742 /// InitializeLayout - Initialize record layout for the given record decl. 743 void InitializeLayout(const Decl *D); 744 745 /// FinishLayout - Finalize record layout. Adjust record size based on the 746 /// alignment. 747 void FinishLayout(const NamedDecl *D); 748 749 void UpdateAlignment(CharUnits NewAlignment, CharUnits UnpackedNewAlignment); 750 void UpdateAlignment(CharUnits NewAlignment) { 751 UpdateAlignment(NewAlignment, NewAlignment); 752 } 753 754 /// \brief Retrieve the externally-supplied field offset for the given 755 /// field. 756 /// 757 /// \param Field The field whose offset is being queried. 758 /// \param ComputedOffset The offset that we've computed for this field. 759 uint64_t updateExternalFieldOffset(const FieldDecl *Field, 760 uint64_t ComputedOffset); 761 762 void CheckFieldPadding(uint64_t Offset, uint64_t UnpaddedOffset, 763 uint64_t UnpackedOffset, unsigned UnpackedAlign, 764 bool isPacked, const FieldDecl *D); 765 766 DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID); 767 768 CharUnits getSize() const { 769 assert(Size % Context.getCharWidth() == 0); 770 return Context.toCharUnitsFromBits(Size); 771 } 772 uint64_t getSizeInBits() const { return Size; } 773 774 void setSize(CharUnits NewSize) { Size = Context.toBits(NewSize); } 775 void setSize(uint64_t NewSize) { Size = NewSize; } 776 777 CharUnits getAligment() const { return Alignment; } 778 779 CharUnits getDataSize() const { 780 assert(DataSize % Context.getCharWidth() == 0); 781 return Context.toCharUnitsFromBits(DataSize); 782 } 783 uint64_t getDataSizeInBits() const { return DataSize; } 784 785 void setDataSize(CharUnits NewSize) { DataSize = Context.toBits(NewSize); } 786 void setDataSize(uint64_t NewSize) { DataSize = NewSize; } 787 788 RecordLayoutBuilder(const RecordLayoutBuilder&); // DO NOT IMPLEMENT 789 void operator=(const RecordLayoutBuilder&); // DO NOT IMPLEMENT 790 public: 791 static const CXXMethodDecl *ComputeKeyFunction(const CXXRecordDecl *RD); 792 }; 793 } // end anonymous namespace 794 795 void 796 RecordLayoutBuilder::SelectPrimaryVBase(const CXXRecordDecl *RD) { 797 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 798 E = RD->bases_end(); I != E; ++I) { 799 assert(!I->getType()->isDependentType() && 800 "Cannot layout class with dependent bases."); 801 802 const CXXRecordDecl *Base = 803 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl()); 804 805 // Check if this is a nearly empty virtual base. 806 if (I->isVirtual() && Context.isNearlyEmpty(Base)) { 807 // If it's not an indirect primary base, then we've found our primary 808 // base. 809 if (!IndirectPrimaryBases.count(Base)) { 810 PrimaryBase = Base; 811 PrimaryBaseIsVirtual = true; 812 return; 813 } 814 815 // Is this the first nearly empty virtual base? 816 if (!FirstNearlyEmptyVBase) 817 FirstNearlyEmptyVBase = Base; 818 } 819 820 SelectPrimaryVBase(Base); 821 if (PrimaryBase) 822 return; 823 } 824 } 825 826 /// DeterminePrimaryBase - Determine the primary base of the given class. 827 void RecordLayoutBuilder::DeterminePrimaryBase(const CXXRecordDecl *RD) { 828 // If the class isn't dynamic, it won't have a primary base. 829 if (!RD->isDynamicClass()) 830 return; 831 832 // Compute all the primary virtual bases for all of our direct and 833 // indirect bases, and record all their primary virtual base classes. 834 RD->getIndirectPrimaryBases(IndirectPrimaryBases); 835 836 // If the record has a dynamic base class, attempt to choose a primary base 837 // class. It is the first (in direct base class order) non-virtual dynamic 838 // base class, if one exists. 839 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(), 840 e = RD->bases_end(); i != e; ++i) { 841 // Ignore virtual bases. 842 if (i->isVirtual()) 843 continue; 844 845 const CXXRecordDecl *Base = 846 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl()); 847 848 if (isPossiblePrimaryBase(Base)) { 849 // We found it. 850 PrimaryBase = Base; 851 PrimaryBaseIsVirtual = false; 852 return; 853 } 854 } 855 856 // The Microsoft ABI doesn't have primary virtual bases. 857 if (isMicrosoftCXXABI()) { 858 assert(!PrimaryBase && "Should not get here with a primary base!"); 859 return; 860 } 861 862 // Under the Itanium ABI, if there is no non-virtual primary base class, 863 // try to compute the primary virtual base. The primary virtual base is 864 // the first nearly empty virtual base that is not an indirect primary 865 // virtual base class, if one exists. 866 if (RD->getNumVBases() != 0) { 867 SelectPrimaryVBase(RD); 868 if (PrimaryBase) 869 return; 870 } 871 872 // Otherwise, it is the first indirect primary base class, if one exists. 873 if (FirstNearlyEmptyVBase) { 874 PrimaryBase = FirstNearlyEmptyVBase; 875 PrimaryBaseIsVirtual = true; 876 return; 877 } 878 879 assert(!PrimaryBase && "Should not get here with a primary base!"); 880 } 881 882 BaseSubobjectInfo * 883 RecordLayoutBuilder::ComputeBaseSubobjectInfo(const CXXRecordDecl *RD, 884 bool IsVirtual, 885 BaseSubobjectInfo *Derived) { 886 BaseSubobjectInfo *Info; 887 888 if (IsVirtual) { 889 // Check if we already have info about this virtual base. 890 BaseSubobjectInfo *&InfoSlot = VirtualBaseInfo[RD]; 891 if (InfoSlot) { 892 assert(InfoSlot->Class == RD && "Wrong class for virtual base info!"); 893 return InfoSlot; 894 } 895 896 // We don't, create it. 897 InfoSlot = new (BaseSubobjectInfoAllocator.Allocate()) BaseSubobjectInfo; 898 Info = InfoSlot; 899 } else { 900 Info = new (BaseSubobjectInfoAllocator.Allocate()) BaseSubobjectInfo; 901 } 902 903 Info->Class = RD; 904 Info->IsVirtual = IsVirtual; 905 Info->Derived = 0; 906 Info->PrimaryVirtualBaseInfo = 0; 907 908 const CXXRecordDecl *PrimaryVirtualBase = 0; 909 BaseSubobjectInfo *PrimaryVirtualBaseInfo = 0; 910 911 // Check if this base has a primary virtual base. 912 if (RD->getNumVBases()) { 913 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 914 if (Layout.isPrimaryBaseVirtual()) { 915 // This base does have a primary virtual base. 916 PrimaryVirtualBase = Layout.getPrimaryBase(); 917 assert(PrimaryVirtualBase && "Didn't have a primary virtual base!"); 918 919 // Now check if we have base subobject info about this primary base. 920 PrimaryVirtualBaseInfo = VirtualBaseInfo.lookup(PrimaryVirtualBase); 921 922 if (PrimaryVirtualBaseInfo) { 923 if (PrimaryVirtualBaseInfo->Derived) { 924 // We did have info about this primary base, and it turns out that it 925 // has already been claimed as a primary virtual base for another 926 // base. 927 PrimaryVirtualBase = 0; 928 } else { 929 // We can claim this base as our primary base. 930 Info->PrimaryVirtualBaseInfo = PrimaryVirtualBaseInfo; 931 PrimaryVirtualBaseInfo->Derived = Info; 932 } 933 } 934 } 935 } 936 937 // Now go through all direct bases. 938 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 939 E = RD->bases_end(); I != E; ++I) { 940 bool IsVirtual = I->isVirtual(); 941 942 const CXXRecordDecl *BaseDecl = 943 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl()); 944 945 Info->Bases.push_back(ComputeBaseSubobjectInfo(BaseDecl, IsVirtual, Info)); 946 } 947 948 if (PrimaryVirtualBase && !PrimaryVirtualBaseInfo) { 949 // Traversing the bases must have created the base info for our primary 950 // virtual base. 951 PrimaryVirtualBaseInfo = VirtualBaseInfo.lookup(PrimaryVirtualBase); 952 assert(PrimaryVirtualBaseInfo && 953 "Did not create a primary virtual base!"); 954 955 // Claim the primary virtual base as our primary virtual base. 956 Info->PrimaryVirtualBaseInfo = PrimaryVirtualBaseInfo; 957 PrimaryVirtualBaseInfo->Derived = Info; 958 } 959 960 return Info; 961 } 962 963 void RecordLayoutBuilder::ComputeBaseSubobjectInfo(const CXXRecordDecl *RD) { 964 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 965 E = RD->bases_end(); I != E; ++I) { 966 bool IsVirtual = I->isVirtual(); 967 968 const CXXRecordDecl *BaseDecl = 969 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl()); 970 971 // Compute the base subobject info for this base. 972 BaseSubobjectInfo *Info = ComputeBaseSubobjectInfo(BaseDecl, IsVirtual, 0); 973 974 if (IsVirtual) { 975 // ComputeBaseInfo has already added this base for us. 976 assert(VirtualBaseInfo.count(BaseDecl) && 977 "Did not add virtual base!"); 978 } else { 979 // Add the base info to the map of non-virtual bases. 980 assert(!NonVirtualBaseInfo.count(BaseDecl) && 981 "Non-virtual base already exists!"); 982 NonVirtualBaseInfo.insert(std::make_pair(BaseDecl, Info)); 983 } 984 } 985 } 986 987 void 988 RecordLayoutBuilder::EnsureVTablePointerAlignment(CharUnits UnpackedBaseAlign) { 989 CharUnits BaseAlign = (Packed) ? CharUnits::One() : UnpackedBaseAlign; 990 991 // The maximum field alignment overrides base align. 992 if (!MaxFieldAlignment.isZero()) { 993 BaseAlign = std::min(BaseAlign, MaxFieldAlignment); 994 UnpackedBaseAlign = std::min(UnpackedBaseAlign, MaxFieldAlignment); 995 } 996 997 // Round up the current record size to pointer alignment. 998 setSize(getSize().RoundUpToAlignment(BaseAlign)); 999 setDataSize(getSize()); 1000 1001 // Update the alignment. 1002 UpdateAlignment(BaseAlign, UnpackedBaseAlign); 1003 } 1004 1005 void 1006 RecordLayoutBuilder::LayoutNonVirtualBases(const CXXRecordDecl *RD) { 1007 // Then, determine the primary base class. 1008 DeterminePrimaryBase(RD); 1009 1010 // Compute base subobject info. 1011 ComputeBaseSubobjectInfo(RD); 1012 1013 // If we have a primary base class, lay it out. 1014 if (PrimaryBase) { 1015 if (PrimaryBaseIsVirtual) { 1016 // If the primary virtual base was a primary virtual base of some other 1017 // base class we'll have to steal it. 1018 BaseSubobjectInfo *PrimaryBaseInfo = VirtualBaseInfo.lookup(PrimaryBase); 1019 PrimaryBaseInfo->Derived = 0; 1020 1021 // We have a virtual primary base, insert it as an indirect primary base. 1022 IndirectPrimaryBases.insert(PrimaryBase); 1023 1024 assert(!VisitedVirtualBases.count(PrimaryBase) && 1025 "vbase already visited!"); 1026 VisitedVirtualBases.insert(PrimaryBase); 1027 1028 LayoutVirtualBase(PrimaryBaseInfo); 1029 } else { 1030 BaseSubobjectInfo *PrimaryBaseInfo = 1031 NonVirtualBaseInfo.lookup(PrimaryBase); 1032 assert(PrimaryBaseInfo && 1033 "Did not find base info for non-virtual primary base!"); 1034 1035 LayoutNonVirtualBase(PrimaryBaseInfo); 1036 } 1037 1038 // If this class needs a vtable/vf-table and didn't get one from a 1039 // primary base, add it in now. 1040 } else if (needsVFTable(RD)) { 1041 assert(DataSize == 0 && "Vtable pointer must be at offset zero!"); 1042 CharUnits PtrWidth = 1043 Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0)); 1044 CharUnits PtrAlign = 1045 Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerAlign(0)); 1046 EnsureVTablePointerAlignment(PtrAlign); 1047 if (isMicrosoftCXXABI()) 1048 VFPtrOffset = getSize(); 1049 setSize(getSize() + PtrWidth); 1050 setDataSize(getSize()); 1051 } 1052 1053 bool HasDirectVirtualBases = false; 1054 bool HasNonVirtualBaseWithVBTable = false; 1055 1056 // Now lay out the non-virtual bases. 1057 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 1058 E = RD->bases_end(); I != E; ++I) { 1059 1060 // Ignore virtual bases, but remember that we saw one. 1061 if (I->isVirtual()) { 1062 HasDirectVirtualBases = true; 1063 continue; 1064 } 1065 1066 const CXXRecordDecl *BaseDecl = 1067 cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl()); 1068 1069 // Remember if this base has virtual bases itself. 1070 if (BaseDecl->getNumVBases()) 1071 HasNonVirtualBaseWithVBTable = true; 1072 1073 // Skip the primary base, because we've already laid it out. The 1074 // !PrimaryBaseIsVirtual check is required because we might have a 1075 // non-virtual base of the same type as a primary virtual base. 1076 if (BaseDecl == PrimaryBase && !PrimaryBaseIsVirtual) 1077 continue; 1078 1079 // Lay out the base. 1080 BaseSubobjectInfo *BaseInfo = NonVirtualBaseInfo.lookup(BaseDecl); 1081 assert(BaseInfo && "Did not find base info for non-virtual base!"); 1082 1083 LayoutNonVirtualBase(BaseInfo); 1084 } 1085 1086 // In the MS ABI, add the vb-table pointer if we need one, which is 1087 // whenever we have a virtual base and we can't re-use a vb-table 1088 // pointer from a non-virtual base. 1089 if (isMicrosoftCXXABI() && 1090 HasDirectVirtualBases && !HasNonVirtualBaseWithVBTable) { 1091 CharUnits PtrWidth = 1092 Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0)); 1093 CharUnits PtrAlign = 1094 Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerAlign(0)); 1095 1096 // MSVC potentially over-aligns the vb-table pointer by giving it 1097 // the max alignment of all the non-virtual objects in the class. 1098 // This is completely unnecessary, but we're not here to pass 1099 // judgment. 1100 // 1101 // Note that we've only laid out the non-virtual bases, so on the 1102 // first pass Alignment won't be set correctly here, but if the 1103 // vb-table doesn't end up aligned correctly we'll come through 1104 // and redo the layout from scratch with the right alignment. 1105 // 1106 // TODO: Instead of doing this, just lay out the fields as if the 1107 // vb-table were at offset zero, then retroactively bump the field 1108 // offsets up. 1109 PtrAlign = std::max(PtrAlign, Alignment); 1110 1111 EnsureVTablePointerAlignment(PtrAlign); 1112 VBPtrOffset = getSize(); 1113 setSize(getSize() + PtrWidth); 1114 setDataSize(getSize()); 1115 } 1116 } 1117 1118 void RecordLayoutBuilder::LayoutNonVirtualBase(const BaseSubobjectInfo *Base) { 1119 // Layout the base. 1120 CharUnits Offset = LayoutBase(Base); 1121 1122 // Add its base class offset. 1123 assert(!Bases.count(Base->Class) && "base offset already exists!"); 1124 Bases.insert(std::make_pair(Base->Class, Offset)); 1125 1126 AddPrimaryVirtualBaseOffsets(Base, Offset); 1127 } 1128 1129 void 1130 RecordLayoutBuilder::AddPrimaryVirtualBaseOffsets(const BaseSubobjectInfo *Info, 1131 CharUnits Offset) { 1132 // This base isn't interesting, it has no virtual bases. 1133 if (!Info->Class->getNumVBases()) 1134 return; 1135 1136 // First, check if we have a virtual primary base to add offsets for. 1137 if (Info->PrimaryVirtualBaseInfo) { 1138 assert(Info->PrimaryVirtualBaseInfo->IsVirtual && 1139 "Primary virtual base is not virtual!"); 1140 if (Info->PrimaryVirtualBaseInfo->Derived == Info) { 1141 // Add the offset. 1142 assert(!VBases.count(Info->PrimaryVirtualBaseInfo->Class) && 1143 "primary vbase offset already exists!"); 1144 VBases.insert(std::make_pair(Info->PrimaryVirtualBaseInfo->Class, 1145 Offset)); 1146 1147 // Traverse the primary virtual base. 1148 AddPrimaryVirtualBaseOffsets(Info->PrimaryVirtualBaseInfo, Offset); 1149 } 1150 } 1151 1152 // Now go through all direct non-virtual bases. 1153 const ASTRecordLayout &Layout = Context.getASTRecordLayout(Info->Class); 1154 for (unsigned I = 0, E = Info->Bases.size(); I != E; ++I) { 1155 const BaseSubobjectInfo *Base = Info->Bases[I]; 1156 if (Base->IsVirtual) 1157 continue; 1158 1159 CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(Base->Class); 1160 AddPrimaryVirtualBaseOffsets(Base, BaseOffset); 1161 } 1162 } 1163 1164 /// needsVFTable - Return true if this class needs a vtable or vf-table 1165 /// when laid out as a base class. These are treated the same because 1166 /// they're both always laid out at offset zero. 1167 /// 1168 /// This function assumes that the class has no primary base. 1169 bool RecordLayoutBuilder::needsVFTable(const CXXRecordDecl *RD) const { 1170 assert(!PrimaryBase); 1171 1172 // In the Itanium ABI, every dynamic class needs a vtable: even if 1173 // this class has no virtual functions as a base class (i.e. it's 1174 // non-polymorphic or only has virtual functions from virtual 1175 // bases),x it still needs a vtable to locate its virtual bases. 1176 if (!isMicrosoftCXXABI()) 1177 return RD->isDynamicClass(); 1178 1179 // In the MS ABI, we need a vfptr if the class has virtual functions 1180 // other than those declared by its virtual bases. The AST doesn't 1181 // tell us that directly, and checking manually for virtual 1182 // functions that aren't overrides is expensive, but there are 1183 // some important shortcuts: 1184 1185 // - Non-polymorphic classes have no virtual functions at all. 1186 if (!RD->isPolymorphic()) return false; 1187 1188 // - Polymorphic classes with no virtual bases must either declare 1189 // virtual functions directly or inherit them, but in the latter 1190 // case we would have a primary base. 1191 if (RD->getNumVBases() == 0) return true; 1192 1193 return hasNewVirtualFunction(RD); 1194 } 1195 1196 /// hasNewVirtualFunction - Does the given polymorphic class declare a 1197 /// virtual function that does not override a method from any of its 1198 /// base classes? 1199 bool 1200 RecordLayoutBuilder::hasNewVirtualFunction(const CXXRecordDecl *RD) const { 1201 assert(RD->isPolymorphic()); 1202 if (!RD->getNumBases()) 1203 return true; 1204 1205 for (CXXRecordDecl::method_iterator method = RD->method_begin(); 1206 method != RD->method_end(); 1207 ++method) { 1208 if (method->isVirtual() && !method->size_overridden_methods()) { 1209 return true; 1210 } 1211 } 1212 return false; 1213 } 1214 1215 /// isPossiblePrimaryBase - Is the given base class an acceptable 1216 /// primary base class? 1217 bool 1218 RecordLayoutBuilder::isPossiblePrimaryBase(const CXXRecordDecl *Base) const { 1219 // In the Itanium ABI, a class can be a primary base class if it has 1220 // a vtable for any reason. 1221 if (!isMicrosoftCXXABI()) 1222 return Base->isDynamicClass(); 1223 1224 // In the MS ABI, a class can only be a primary base class if it 1225 // provides a vf-table at a static offset. That means it has to be 1226 // non-virtual base. The existence of a separate vb-table means 1227 // that it's possible to get virtual functions only from a virtual 1228 // base, which we have to guard against. 1229 1230 // First off, it has to have virtual functions. 1231 if (!Base->isPolymorphic()) return false; 1232 1233 // If it has no virtual bases, then everything is at a static offset. 1234 if (!Base->getNumVBases()) return true; 1235 1236 // Okay, just ask the base class's layout. 1237 return (Context.getASTRecordLayout(Base).getVFPtrOffset() 1238 != CharUnits::fromQuantity(-1)); 1239 } 1240 1241 void 1242 RecordLayoutBuilder::LayoutVirtualBases(const CXXRecordDecl *RD, 1243 const CXXRecordDecl *MostDerivedClass) { 1244 const CXXRecordDecl *PrimaryBase; 1245 bool PrimaryBaseIsVirtual; 1246 1247 if (MostDerivedClass == RD) { 1248 PrimaryBase = this->PrimaryBase; 1249 PrimaryBaseIsVirtual = this->PrimaryBaseIsVirtual; 1250 } else { 1251 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 1252 PrimaryBase = Layout.getPrimaryBase(); 1253 PrimaryBaseIsVirtual = Layout.isPrimaryBaseVirtual(); 1254 } 1255 1256 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 1257 E = RD->bases_end(); I != E; ++I) { 1258 assert(!I->getType()->isDependentType() && 1259 "Cannot layout class with dependent bases."); 1260 1261 const CXXRecordDecl *BaseDecl = 1262 cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl()); 1263 1264 if (I->isVirtual()) { 1265 if (PrimaryBase != BaseDecl || !PrimaryBaseIsVirtual) { 1266 bool IndirectPrimaryBase = IndirectPrimaryBases.count(BaseDecl); 1267 1268 // Only lay out the virtual base if it's not an indirect primary base. 1269 if (!IndirectPrimaryBase) { 1270 // Only visit virtual bases once. 1271 if (!VisitedVirtualBases.insert(BaseDecl)) 1272 continue; 1273 1274 const BaseSubobjectInfo *BaseInfo = VirtualBaseInfo.lookup(BaseDecl); 1275 assert(BaseInfo && "Did not find virtual base info!"); 1276 LayoutVirtualBase(BaseInfo); 1277 } 1278 } 1279 } 1280 1281 if (!BaseDecl->getNumVBases()) { 1282 // This base isn't interesting since it doesn't have any virtual bases. 1283 continue; 1284 } 1285 1286 LayoutVirtualBases(BaseDecl, MostDerivedClass); 1287 } 1288 } 1289 1290 void RecordLayoutBuilder::MSLayoutVirtualBases(const CXXRecordDecl *RD) { 1291 1292 if (!RD->getNumVBases()) 1293 return; 1294 1295 // This is substantially simplified because there are no virtual 1296 // primary bases. 1297 for (CXXRecordDecl::base_class_const_iterator I = RD->vbases_begin(), 1298 E = RD->vbases_end(); I != E; ++I) { 1299 const CXXRecordDecl *BaseDecl = I->getType()->getAsCXXRecordDecl(); 1300 const BaseSubobjectInfo *BaseInfo = VirtualBaseInfo.lookup(BaseDecl); 1301 assert(BaseInfo && "Did not find virtual base info!"); 1302 1303 LayoutVirtualBase(BaseInfo); 1304 } 1305 } 1306 1307 void RecordLayoutBuilder::LayoutVirtualBase(const BaseSubobjectInfo *Base) { 1308 assert(!Base->Derived && "Trying to lay out a primary virtual base!"); 1309 1310 // Layout the base. 1311 CharUnits Offset = LayoutBase(Base); 1312 1313 // Add its base class offset. 1314 assert(!VBases.count(Base->Class) && "vbase offset already exists!"); 1315 VBases.insert(std::make_pair(Base->Class, Offset)); 1316 1317 AddPrimaryVirtualBaseOffsets(Base, Offset); 1318 } 1319 1320 CharUnits RecordLayoutBuilder::LayoutBase(const BaseSubobjectInfo *Base) { 1321 const ASTRecordLayout &Layout = Context.getASTRecordLayout(Base->Class); 1322 1323 1324 CharUnits Offset; 1325 1326 // Query the external layout to see if it provides an offset. 1327 bool HasExternalLayout = false; 1328 if (ExternalLayout) { 1329 llvm::DenseMap<const CXXRecordDecl *, CharUnits>::iterator Known; 1330 if (Base->IsVirtual) { 1331 Known = ExternalVirtualBaseOffsets.find(Base->Class); 1332 if (Known != ExternalVirtualBaseOffsets.end()) { 1333 Offset = Known->second; 1334 HasExternalLayout = true; 1335 } 1336 } else { 1337 Known = ExternalBaseOffsets.find(Base->Class); 1338 if (Known != ExternalBaseOffsets.end()) { 1339 Offset = Known->second; 1340 HasExternalLayout = true; 1341 } 1342 } 1343 } 1344 1345 // If we have an empty base class, try to place it at offset 0. 1346 if (Base->Class->isEmpty() && 1347 (!HasExternalLayout || Offset == CharUnits::Zero()) && 1348 EmptySubobjects->CanPlaceBaseAtOffset(Base, CharUnits::Zero())) { 1349 setSize(std::max(getSize(), Layout.getSize())); 1350 1351 return CharUnits::Zero(); 1352 } 1353 1354 CharUnits UnpackedBaseAlign = Layout.getNonVirtualAlign(); 1355 CharUnits BaseAlign = (Packed) ? CharUnits::One() : UnpackedBaseAlign; 1356 1357 // The maximum field alignment overrides base align. 1358 if (!MaxFieldAlignment.isZero()) { 1359 BaseAlign = std::min(BaseAlign, MaxFieldAlignment); 1360 UnpackedBaseAlign = std::min(UnpackedBaseAlign, MaxFieldAlignment); 1361 } 1362 1363 if (!HasExternalLayout) { 1364 // Round up the current record size to the base's alignment boundary. 1365 Offset = getDataSize().RoundUpToAlignment(BaseAlign); 1366 1367 // Try to place the base. 1368 while (!EmptySubobjects->CanPlaceBaseAtOffset(Base, Offset)) 1369 Offset += BaseAlign; 1370 } else { 1371 bool Allowed = EmptySubobjects->CanPlaceBaseAtOffset(Base, Offset); 1372 (void)Allowed; 1373 assert(Allowed && "Base subobject externally placed at overlapping offset"); 1374 } 1375 1376 if (!Base->Class->isEmpty()) { 1377 // Update the data size. 1378 setDataSize(Offset + Layout.getNonVirtualSize()); 1379 1380 setSize(std::max(getSize(), getDataSize())); 1381 } else 1382 setSize(std::max(getSize(), Offset + Layout.getSize())); 1383 1384 // Remember max struct/class alignment. 1385 UpdateAlignment(BaseAlign, UnpackedBaseAlign); 1386 1387 return Offset; 1388 } 1389 1390 void RecordLayoutBuilder::InitializeLayout(const Decl *D) { 1391 if (const RecordDecl *RD = dyn_cast<RecordDecl>(D)) 1392 IsUnion = RD->isUnion(); 1393 1394 Packed = D->hasAttr<PackedAttr>(); 1395 1396 IsMsStruct = D->hasAttr<MsStructAttr>(); 1397 1398 // Honor the default struct packing maximum alignment flag. 1399 if (unsigned DefaultMaxFieldAlignment = Context.getLangOpts().PackStruct) { 1400 MaxFieldAlignment = CharUnits::fromQuantity(DefaultMaxFieldAlignment); 1401 } 1402 1403 // mac68k alignment supersedes maximum field alignment and attribute aligned, 1404 // and forces all structures to have 2-byte alignment. The IBM docs on it 1405 // allude to additional (more complicated) semantics, especially with regard 1406 // to bit-fields, but gcc appears not to follow that. 1407 if (D->hasAttr<AlignMac68kAttr>()) { 1408 IsMac68kAlign = true; 1409 MaxFieldAlignment = CharUnits::fromQuantity(2); 1410 Alignment = CharUnits::fromQuantity(2); 1411 } else { 1412 if (const MaxFieldAlignmentAttr *MFAA = D->getAttr<MaxFieldAlignmentAttr>()) 1413 MaxFieldAlignment = Context.toCharUnitsFromBits(MFAA->getAlignment()); 1414 1415 if (unsigned MaxAlign = D->getMaxAlignment()) 1416 UpdateAlignment(Context.toCharUnitsFromBits(MaxAlign)); 1417 } 1418 1419 // If there is an external AST source, ask it for the various offsets. 1420 if (const RecordDecl *RD = dyn_cast<RecordDecl>(D)) 1421 if (ExternalASTSource *External = Context.getExternalSource()) { 1422 ExternalLayout = External->layoutRecordType(RD, 1423 ExternalSize, 1424 ExternalAlign, 1425 ExternalFieldOffsets, 1426 ExternalBaseOffsets, 1427 ExternalVirtualBaseOffsets); 1428 1429 // Update based on external alignment. 1430 if (ExternalLayout) { 1431 if (ExternalAlign > 0) { 1432 Alignment = Context.toCharUnitsFromBits(ExternalAlign); 1433 UnpackedAlignment = Alignment; 1434 } else { 1435 // The external source didn't have alignment information; infer it. 1436 InferAlignment = true; 1437 } 1438 } 1439 } 1440 } 1441 1442 void RecordLayoutBuilder::Layout(const RecordDecl *D) { 1443 InitializeLayout(D); 1444 LayoutFields(D); 1445 1446 // Finally, round the size of the total struct up to the alignment of the 1447 // struct itself. 1448 FinishLayout(D); 1449 } 1450 1451 void RecordLayoutBuilder::Layout(const CXXRecordDecl *RD) { 1452 InitializeLayout(RD); 1453 1454 // Lay out the vtable and the non-virtual bases. 1455 LayoutNonVirtualBases(RD); 1456 1457 LayoutFields(RD); 1458 1459 NonVirtualSize = Context.toCharUnitsFromBits( 1460 llvm::RoundUpToAlignment(getSizeInBits(), 1461 Context.getTargetInfo().getCharAlign())); 1462 NonVirtualAlignment = Alignment; 1463 1464 if (isMicrosoftCXXABI() && 1465 NonVirtualSize != NonVirtualSize.RoundUpToAlignment(Alignment)) { 1466 CharUnits AlignMember = 1467 NonVirtualSize.RoundUpToAlignment(Alignment) - NonVirtualSize; 1468 1469 setSize(getSize() + AlignMember); 1470 setDataSize(getSize()); 1471 1472 NonVirtualSize = Context.toCharUnitsFromBits( 1473 llvm::RoundUpToAlignment(getSizeInBits(), 1474 Context.getTargetInfo().getCharAlign())); 1475 1476 MSLayoutVirtualBases(RD); 1477 1478 } else { 1479 // Lay out the virtual bases and add the primary virtual base offsets. 1480 LayoutVirtualBases(RD, RD); 1481 } 1482 1483 // Finally, round the size of the total struct up to the alignment 1484 // of the struct itself. 1485 FinishLayout(RD); 1486 1487 #ifndef NDEBUG 1488 // Check that we have base offsets for all bases. 1489 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 1490 E = RD->bases_end(); I != E; ++I) { 1491 if (I->isVirtual()) 1492 continue; 1493 1494 const CXXRecordDecl *BaseDecl = 1495 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl()); 1496 1497 assert(Bases.count(BaseDecl) && "Did not find base offset!"); 1498 } 1499 1500 // And all virtual bases. 1501 for (CXXRecordDecl::base_class_const_iterator I = RD->vbases_begin(), 1502 E = RD->vbases_end(); I != E; ++I) { 1503 const CXXRecordDecl *BaseDecl = 1504 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl()); 1505 1506 assert(VBases.count(BaseDecl) && "Did not find base offset!"); 1507 } 1508 #endif 1509 } 1510 1511 void RecordLayoutBuilder::Layout(const ObjCInterfaceDecl *D) { 1512 if (ObjCInterfaceDecl *SD = D->getSuperClass()) { 1513 const ASTRecordLayout &SL = Context.getASTObjCInterfaceLayout(SD); 1514 1515 UpdateAlignment(SL.getAlignment()); 1516 1517 // We start laying out ivars not at the end of the superclass 1518 // structure, but at the next byte following the last field. 1519 setSize(SL.getDataSize()); 1520 setDataSize(getSize()); 1521 } 1522 1523 InitializeLayout(D); 1524 // Layout each ivar sequentially. 1525 for (const ObjCIvarDecl *IVD = D->all_declared_ivar_begin(); IVD; 1526 IVD = IVD->getNextIvar()) 1527 LayoutField(IVD); 1528 1529 // Finally, round the size of the total struct up to the alignment of the 1530 // struct itself. 1531 FinishLayout(D); 1532 } 1533 1534 void RecordLayoutBuilder::LayoutFields(const RecordDecl *D) { 1535 // Layout each field, for now, just sequentially, respecting alignment. In 1536 // the future, this will need to be tweakable by targets. 1537 const FieldDecl *LastFD = 0; 1538 ZeroLengthBitfield = 0; 1539 unsigned RemainingInAlignment = 0; 1540 for (RecordDecl::field_iterator Field = D->field_begin(), 1541 FieldEnd = D->field_end(); Field != FieldEnd; ++Field) { 1542 if (IsMsStruct) { 1543 FieldDecl *FD = (*Field); 1544 if (Context.ZeroBitfieldFollowsBitfield(FD, LastFD)) 1545 ZeroLengthBitfield = FD; 1546 // Zero-length bitfields following non-bitfield members are 1547 // ignored: 1548 else if (Context.ZeroBitfieldFollowsNonBitfield(FD, LastFD)) 1549 continue; 1550 // FIXME. streamline these conditions into a simple one. 1551 else if (Context.BitfieldFollowsBitfield(FD, LastFD) || 1552 Context.BitfieldFollowsNonBitfield(FD, LastFD) || 1553 Context.NonBitfieldFollowsBitfield(FD, LastFD)) { 1554 // 1) Adjacent bit fields are packed into the same 1-, 2-, or 1555 // 4-byte allocation unit if the integral types are the same 1556 // size and if the next bit field fits into the current 1557 // allocation unit without crossing the boundary imposed by the 1558 // common alignment requirements of the bit fields. 1559 // 2) Establish a new alignment for a bitfield following 1560 // a non-bitfield if size of their types differ. 1561 // 3) Establish a new alignment for a non-bitfield following 1562 // a bitfield if size of their types differ. 1563 std::pair<uint64_t, unsigned> FieldInfo = 1564 Context.getTypeInfo(FD->getType()); 1565 uint64_t TypeSize = FieldInfo.first; 1566 unsigned FieldAlign = FieldInfo.second; 1567 // This check is needed for 'long long' in -m32 mode. 1568 if (TypeSize > FieldAlign && 1569 (Context.hasSameType(FD->getType(), 1570 Context.UnsignedLongLongTy) 1571 ||Context.hasSameType(FD->getType(), 1572 Context.LongLongTy))) 1573 FieldAlign = TypeSize; 1574 FieldInfo = Context.getTypeInfo(LastFD->getType()); 1575 uint64_t TypeSizeLastFD = FieldInfo.first; 1576 unsigned FieldAlignLastFD = FieldInfo.second; 1577 // This check is needed for 'long long' in -m32 mode. 1578 if (TypeSizeLastFD > FieldAlignLastFD && 1579 (Context.hasSameType(LastFD->getType(), 1580 Context.UnsignedLongLongTy) 1581 || Context.hasSameType(LastFD->getType(), 1582 Context.LongLongTy))) 1583 FieldAlignLastFD = TypeSizeLastFD; 1584 1585 if (TypeSizeLastFD != TypeSize) { 1586 if (RemainingInAlignment && 1587 LastFD && LastFD->isBitField() && 1588 LastFD->getBitWidthValue(Context)) { 1589 // If previous field was a bitfield with some remaining unfilled 1590 // bits, pad the field so current field starts on its type boundary. 1591 uint64_t FieldOffset = 1592 getDataSizeInBits() - UnfilledBitsInLastByte; 1593 uint64_t NewSizeInBits = RemainingInAlignment + FieldOffset; 1594 setDataSize(llvm::RoundUpToAlignment(NewSizeInBits, 1595 Context.getTargetInfo().getCharAlign())); 1596 setSize(std::max(getSizeInBits(), getDataSizeInBits())); 1597 RemainingInAlignment = 0; 1598 } 1599 1600 uint64_t UnpaddedFieldOffset = 1601 getDataSizeInBits() - UnfilledBitsInLastByte; 1602 FieldAlign = std::max(FieldAlign, FieldAlignLastFD); 1603 1604 // The maximum field alignment overrides the aligned attribute. 1605 if (!MaxFieldAlignment.isZero()) { 1606 unsigned MaxFieldAlignmentInBits = 1607 Context.toBits(MaxFieldAlignment); 1608 FieldAlign = std::min(FieldAlign, MaxFieldAlignmentInBits); 1609 } 1610 1611 uint64_t NewSizeInBits = 1612 llvm::RoundUpToAlignment(UnpaddedFieldOffset, FieldAlign); 1613 setDataSize(llvm::RoundUpToAlignment(NewSizeInBits, 1614 Context.getTargetInfo().getCharAlign())); 1615 UnfilledBitsInLastByte = getDataSizeInBits() - NewSizeInBits; 1616 setSize(std::max(getSizeInBits(), getDataSizeInBits())); 1617 } 1618 if (FD->isBitField()) { 1619 uint64_t FieldSize = FD->getBitWidthValue(Context); 1620 assert (FieldSize > 0 && "LayoutFields - ms_struct layout"); 1621 if (RemainingInAlignment < FieldSize) 1622 RemainingInAlignment = TypeSize - FieldSize; 1623 else 1624 RemainingInAlignment -= FieldSize; 1625 } 1626 } 1627 else if (FD->isBitField()) { 1628 uint64_t FieldSize = FD->getBitWidthValue(Context); 1629 std::pair<uint64_t, unsigned> FieldInfo = 1630 Context.getTypeInfo(FD->getType()); 1631 uint64_t TypeSize = FieldInfo.first; 1632 RemainingInAlignment = TypeSize - FieldSize; 1633 } 1634 LastFD = FD; 1635 } 1636 else if (!Context.getTargetInfo().useBitFieldTypeAlignment() && 1637 Context.getTargetInfo().useZeroLengthBitfieldAlignment()) { 1638 FieldDecl *FD = (*Field); 1639 if (FD->isBitField() && FD->getBitWidthValue(Context) == 0) 1640 ZeroLengthBitfield = FD; 1641 } 1642 LayoutField(*Field); 1643 } 1644 if (IsMsStruct && RemainingInAlignment && 1645 LastFD && LastFD->isBitField() && LastFD->getBitWidthValue(Context)) { 1646 // If we ended a bitfield before the full length of the type then 1647 // pad the struct out to the full length of the last type. 1648 uint64_t FieldOffset = 1649 getDataSizeInBits() - UnfilledBitsInLastByte; 1650 uint64_t NewSizeInBits = RemainingInAlignment + FieldOffset; 1651 setDataSize(llvm::RoundUpToAlignment(NewSizeInBits, 1652 Context.getTargetInfo().getCharAlign())); 1653 setSize(std::max(getSizeInBits(), getDataSizeInBits())); 1654 } 1655 } 1656 1657 void RecordLayoutBuilder::LayoutWideBitField(uint64_t FieldSize, 1658 uint64_t TypeSize, 1659 bool FieldPacked, 1660 const FieldDecl *D) { 1661 assert(Context.getLangOpts().CPlusPlus && 1662 "Can only have wide bit-fields in C++!"); 1663 1664 // Itanium C++ ABI 2.4: 1665 // If sizeof(T)*8 < n, let T' be the largest integral POD type with 1666 // sizeof(T')*8 <= n. 1667 1668 QualType IntegralPODTypes[] = { 1669 Context.UnsignedCharTy, Context.UnsignedShortTy, Context.UnsignedIntTy, 1670 Context.UnsignedLongTy, Context.UnsignedLongLongTy 1671 }; 1672 1673 QualType Type; 1674 for (unsigned I = 0, E = llvm::array_lengthof(IntegralPODTypes); 1675 I != E; ++I) { 1676 uint64_t Size = Context.getTypeSize(IntegralPODTypes[I]); 1677 1678 if (Size > FieldSize) 1679 break; 1680 1681 Type = IntegralPODTypes[I]; 1682 } 1683 assert(!Type.isNull() && "Did not find a type!"); 1684 1685 CharUnits TypeAlign = Context.getTypeAlignInChars(Type); 1686 1687 // We're not going to use any of the unfilled bits in the last byte. 1688 UnfilledBitsInLastByte = 0; 1689 1690 uint64_t FieldOffset; 1691 uint64_t UnpaddedFieldOffset = getDataSizeInBits() - UnfilledBitsInLastByte; 1692 1693 if (IsUnion) { 1694 setDataSize(std::max(getDataSizeInBits(), FieldSize)); 1695 FieldOffset = 0; 1696 } else { 1697 // The bitfield is allocated starting at the next offset aligned 1698 // appropriately for T', with length n bits. 1699 FieldOffset = llvm::RoundUpToAlignment(getDataSizeInBits(), 1700 Context.toBits(TypeAlign)); 1701 1702 uint64_t NewSizeInBits = FieldOffset + FieldSize; 1703 1704 setDataSize(llvm::RoundUpToAlignment(NewSizeInBits, 1705 Context.getTargetInfo().getCharAlign())); 1706 UnfilledBitsInLastByte = getDataSizeInBits() - NewSizeInBits; 1707 } 1708 1709 // Place this field at the current location. 1710 FieldOffsets.push_back(FieldOffset); 1711 1712 CheckFieldPadding(FieldOffset, UnpaddedFieldOffset, FieldOffset, 1713 Context.toBits(TypeAlign), FieldPacked, D); 1714 1715 // Update the size. 1716 setSize(std::max(getSizeInBits(), getDataSizeInBits())); 1717 1718 // Remember max struct/class alignment. 1719 UpdateAlignment(TypeAlign); 1720 } 1721 1722 void RecordLayoutBuilder::LayoutBitField(const FieldDecl *D) { 1723 bool FieldPacked = Packed || D->hasAttr<PackedAttr>(); 1724 uint64_t UnpaddedFieldOffset = getDataSizeInBits() - UnfilledBitsInLastByte; 1725 uint64_t FieldOffset = IsUnion ? 0 : UnpaddedFieldOffset; 1726 uint64_t FieldSize = D->getBitWidthValue(Context); 1727 1728 std::pair<uint64_t, unsigned> FieldInfo = Context.getTypeInfo(D->getType()); 1729 uint64_t TypeSize = FieldInfo.first; 1730 unsigned FieldAlign = FieldInfo.second; 1731 1732 // This check is needed for 'long long' in -m32 mode. 1733 if (IsMsStruct && (TypeSize > FieldAlign) && 1734 (Context.hasSameType(D->getType(), 1735 Context.UnsignedLongLongTy) 1736 || Context.hasSameType(D->getType(), Context.LongLongTy))) 1737 FieldAlign = TypeSize; 1738 1739 if (ZeroLengthBitfield) { 1740 std::pair<uint64_t, unsigned> FieldInfo; 1741 unsigned ZeroLengthBitfieldAlignment; 1742 if (IsMsStruct) { 1743 // If a zero-length bitfield is inserted after a bitfield, 1744 // and the alignment of the zero-length bitfield is 1745 // greater than the member that follows it, `bar', `bar' 1746 // will be aligned as the type of the zero-length bitfield. 1747 if (ZeroLengthBitfield != D) { 1748 FieldInfo = Context.getTypeInfo(ZeroLengthBitfield->getType()); 1749 ZeroLengthBitfieldAlignment = FieldInfo.second; 1750 // Ignore alignment of subsequent zero-length bitfields. 1751 if ((ZeroLengthBitfieldAlignment > FieldAlign) || (FieldSize == 0)) 1752 FieldAlign = ZeroLengthBitfieldAlignment; 1753 if (FieldSize) 1754 ZeroLengthBitfield = 0; 1755 } 1756 } else { 1757 // The alignment of a zero-length bitfield affects the alignment 1758 // of the next member. The alignment is the max of the zero 1759 // length bitfield's alignment and a target specific fixed value. 1760 unsigned ZeroLengthBitfieldBoundary = 1761 Context.getTargetInfo().getZeroLengthBitfieldBoundary(); 1762 if (ZeroLengthBitfieldBoundary > FieldAlign) 1763 FieldAlign = ZeroLengthBitfieldBoundary; 1764 } 1765 } 1766 1767 if (FieldSize > TypeSize) { 1768 LayoutWideBitField(FieldSize, TypeSize, FieldPacked, D); 1769 return; 1770 } 1771 1772 // The align if the field is not packed. This is to check if the attribute 1773 // was unnecessary (-Wpacked). 1774 unsigned UnpackedFieldAlign = FieldAlign; 1775 uint64_t UnpackedFieldOffset = FieldOffset; 1776 if (!Context.getTargetInfo().useBitFieldTypeAlignment() && !ZeroLengthBitfield) 1777 UnpackedFieldAlign = 1; 1778 1779 if (FieldPacked || 1780 (!Context.getTargetInfo().useBitFieldTypeAlignment() && !ZeroLengthBitfield)) 1781 FieldAlign = 1; 1782 FieldAlign = std::max(FieldAlign, D->getMaxAlignment()); 1783 UnpackedFieldAlign = std::max(UnpackedFieldAlign, D->getMaxAlignment()); 1784 1785 // The maximum field alignment overrides the aligned attribute. 1786 if (!MaxFieldAlignment.isZero() && FieldSize != 0) { 1787 unsigned MaxFieldAlignmentInBits = Context.toBits(MaxFieldAlignment); 1788 FieldAlign = std::min(FieldAlign, MaxFieldAlignmentInBits); 1789 UnpackedFieldAlign = std::min(UnpackedFieldAlign, MaxFieldAlignmentInBits); 1790 } 1791 1792 // Check if we need to add padding to give the field the correct alignment. 1793 if (FieldSize == 0 || 1794 (MaxFieldAlignment.isZero() && 1795 (FieldOffset & (FieldAlign-1)) + FieldSize > TypeSize)) 1796 FieldOffset = llvm::RoundUpToAlignment(FieldOffset, FieldAlign); 1797 1798 if (FieldSize == 0 || 1799 (MaxFieldAlignment.isZero() && 1800 (UnpackedFieldOffset & (UnpackedFieldAlign-1)) + FieldSize > TypeSize)) 1801 UnpackedFieldOffset = llvm::RoundUpToAlignment(UnpackedFieldOffset, 1802 UnpackedFieldAlign); 1803 1804 // Padding members don't affect overall alignment, unless zero length bitfield 1805 // alignment is enabled. 1806 if (!D->getIdentifier() && !Context.getTargetInfo().useZeroLengthBitfieldAlignment()) 1807 FieldAlign = UnpackedFieldAlign = 1; 1808 1809 if (!IsMsStruct) 1810 ZeroLengthBitfield = 0; 1811 1812 if (ExternalLayout) 1813 FieldOffset = updateExternalFieldOffset(D, FieldOffset); 1814 1815 // Place this field at the current location. 1816 FieldOffsets.push_back(FieldOffset); 1817 1818 if (!ExternalLayout) 1819 CheckFieldPadding(FieldOffset, UnpaddedFieldOffset, UnpackedFieldOffset, 1820 UnpackedFieldAlign, FieldPacked, D); 1821 1822 // Update DataSize to include the last byte containing (part of) the bitfield. 1823 if (IsUnion) { 1824 // FIXME: I think FieldSize should be TypeSize here. 1825 setDataSize(std::max(getDataSizeInBits(), FieldSize)); 1826 } else { 1827 uint64_t NewSizeInBits = FieldOffset + FieldSize; 1828 1829 setDataSize(llvm::RoundUpToAlignment(NewSizeInBits, 1830 Context.getTargetInfo().getCharAlign())); 1831 UnfilledBitsInLastByte = getDataSizeInBits() - NewSizeInBits; 1832 } 1833 1834 // Update the size. 1835 setSize(std::max(getSizeInBits(), getDataSizeInBits())); 1836 1837 // Remember max struct/class alignment. 1838 UpdateAlignment(Context.toCharUnitsFromBits(FieldAlign), 1839 Context.toCharUnitsFromBits(UnpackedFieldAlign)); 1840 } 1841 1842 void RecordLayoutBuilder::LayoutField(const FieldDecl *D) { 1843 if (D->isBitField()) { 1844 LayoutBitField(D); 1845 return; 1846 } 1847 1848 uint64_t UnpaddedFieldOffset = getDataSizeInBits() - UnfilledBitsInLastByte; 1849 1850 // Reset the unfilled bits. 1851 UnfilledBitsInLastByte = 0; 1852 1853 bool FieldPacked = Packed || D->hasAttr<PackedAttr>(); 1854 CharUnits FieldOffset = 1855 IsUnion ? CharUnits::Zero() : getDataSize(); 1856 CharUnits FieldSize; 1857 CharUnits FieldAlign; 1858 1859 if (D->getType()->isIncompleteArrayType()) { 1860 // This is a flexible array member; we can't directly 1861 // query getTypeInfo about these, so we figure it out here. 1862 // Flexible array members don't have any size, but they 1863 // have to be aligned appropriately for their element type. 1864 FieldSize = CharUnits::Zero(); 1865 const ArrayType* ATy = Context.getAsArrayType(D->getType()); 1866 FieldAlign = Context.getTypeAlignInChars(ATy->getElementType()); 1867 } else if (const ReferenceType *RT = D->getType()->getAs<ReferenceType>()) { 1868 unsigned AS = RT->getPointeeType().getAddressSpace(); 1869 FieldSize = 1870 Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(AS)); 1871 FieldAlign = 1872 Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerAlign(AS)); 1873 } else { 1874 std::pair<CharUnits, CharUnits> FieldInfo = 1875 Context.getTypeInfoInChars(D->getType()); 1876 FieldSize = FieldInfo.first; 1877 FieldAlign = FieldInfo.second; 1878 1879 if (ZeroLengthBitfield) { 1880 CharUnits ZeroLengthBitfieldBoundary = 1881 Context.toCharUnitsFromBits( 1882 Context.getTargetInfo().getZeroLengthBitfieldBoundary()); 1883 if (ZeroLengthBitfieldBoundary == CharUnits::Zero()) { 1884 // If a zero-length bitfield is inserted after a bitfield, 1885 // and the alignment of the zero-length bitfield is 1886 // greater than the member that follows it, `bar', `bar' 1887 // will be aligned as the type of the zero-length bitfield. 1888 std::pair<CharUnits, CharUnits> FieldInfo = 1889 Context.getTypeInfoInChars(ZeroLengthBitfield->getType()); 1890 CharUnits ZeroLengthBitfieldAlignment = FieldInfo.second; 1891 if (ZeroLengthBitfieldAlignment > FieldAlign) 1892 FieldAlign = ZeroLengthBitfieldAlignment; 1893 } else if (ZeroLengthBitfieldBoundary > FieldAlign) { 1894 // Align 'bar' based on a fixed alignment specified by the target. 1895 assert(Context.getTargetInfo().useZeroLengthBitfieldAlignment() && 1896 "ZeroLengthBitfieldBoundary should only be used in conjunction" 1897 " with useZeroLengthBitfieldAlignment."); 1898 FieldAlign = ZeroLengthBitfieldBoundary; 1899 } 1900 ZeroLengthBitfield = 0; 1901 } 1902 1903 if (Context.getLangOpts().MSBitfields || IsMsStruct) { 1904 // If MS bitfield layout is required, figure out what type is being 1905 // laid out and align the field to the width of that type. 1906 1907 // Resolve all typedefs down to their base type and round up the field 1908 // alignment if necessary. 1909 QualType T = Context.getBaseElementType(D->getType()); 1910 if (const BuiltinType *BTy = T->getAs<BuiltinType>()) { 1911 CharUnits TypeSize = Context.getTypeSizeInChars(BTy); 1912 if (TypeSize > FieldAlign) 1913 FieldAlign = TypeSize; 1914 } 1915 } 1916 } 1917 1918 // The align if the field is not packed. This is to check if the attribute 1919 // was unnecessary (-Wpacked). 1920 CharUnits UnpackedFieldAlign = FieldAlign; 1921 CharUnits UnpackedFieldOffset = FieldOffset; 1922 1923 if (FieldPacked) 1924 FieldAlign = CharUnits::One(); 1925 CharUnits MaxAlignmentInChars = 1926 Context.toCharUnitsFromBits(D->getMaxAlignment()); 1927 FieldAlign = std::max(FieldAlign, MaxAlignmentInChars); 1928 UnpackedFieldAlign = std::max(UnpackedFieldAlign, MaxAlignmentInChars); 1929 1930 // The maximum field alignment overrides the aligned attribute. 1931 if (!MaxFieldAlignment.isZero()) { 1932 FieldAlign = std::min(FieldAlign, MaxFieldAlignment); 1933 UnpackedFieldAlign = std::min(UnpackedFieldAlign, MaxFieldAlignment); 1934 } 1935 1936 // Round up the current record size to the field's alignment boundary. 1937 FieldOffset = FieldOffset.RoundUpToAlignment(FieldAlign); 1938 UnpackedFieldOffset = 1939 UnpackedFieldOffset.RoundUpToAlignment(UnpackedFieldAlign); 1940 1941 if (ExternalLayout) { 1942 FieldOffset = Context.toCharUnitsFromBits( 1943 updateExternalFieldOffset(D, Context.toBits(FieldOffset))); 1944 1945 if (!IsUnion && EmptySubobjects) { 1946 // Record the fact that we're placing a field at this offset. 1947 bool Allowed = EmptySubobjects->CanPlaceFieldAtOffset(D, FieldOffset); 1948 (void)Allowed; 1949 assert(Allowed && "Externally-placed field cannot be placed here"); 1950 } 1951 } else { 1952 if (!IsUnion && EmptySubobjects) { 1953 // Check if we can place the field at this offset. 1954 while (!EmptySubobjects->CanPlaceFieldAtOffset(D, FieldOffset)) { 1955 // We couldn't place the field at the offset. Try again at a new offset. 1956 FieldOffset += FieldAlign; 1957 } 1958 } 1959 } 1960 1961 // Place this field at the current location. 1962 FieldOffsets.push_back(Context.toBits(FieldOffset)); 1963 1964 if (!ExternalLayout) 1965 CheckFieldPadding(Context.toBits(FieldOffset), UnpaddedFieldOffset, 1966 Context.toBits(UnpackedFieldOffset), 1967 Context.toBits(UnpackedFieldAlign), FieldPacked, D); 1968 1969 // Reserve space for this field. 1970 uint64_t FieldSizeInBits = Context.toBits(FieldSize); 1971 if (IsUnion) 1972 setDataSize(std::max(getDataSizeInBits(), FieldSizeInBits)); 1973 else 1974 setDataSize(FieldOffset + FieldSize); 1975 1976 // Update the size. 1977 setSize(std::max(getSizeInBits(), getDataSizeInBits())); 1978 1979 // Remember max struct/class alignment. 1980 UpdateAlignment(FieldAlign, UnpackedFieldAlign); 1981 } 1982 1983 void RecordLayoutBuilder::FinishLayout(const NamedDecl *D) { 1984 if (ExternalLayout) { 1985 setSize(ExternalSize); 1986 return; 1987 } 1988 1989 // In C++, records cannot be of size 0. 1990 if (Context.getLangOpts().CPlusPlus && getSizeInBits() == 0) { 1991 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) { 1992 // Compatibility with gcc requires a class (pod or non-pod) 1993 // which is not empty but of size 0; such as having fields of 1994 // array of zero-length, remains of Size 0 1995 if (RD->isEmpty()) 1996 setSize(CharUnits::One()); 1997 } 1998 else 1999 setSize(CharUnits::One()); 2000 } 2001 2002 // MSVC doesn't round up to the alignment of the record with virtual bases. 2003 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) { 2004 if (isMicrosoftCXXABI() && RD->getNumVBases()) 2005 return; 2006 } 2007 2008 // Finally, round the size of the record up to the alignment of the 2009 // record itself. 2010 uint64_t UnpaddedSize = getSizeInBits() - UnfilledBitsInLastByte; 2011 uint64_t UnpackedSizeInBits = 2012 llvm::RoundUpToAlignment(getSizeInBits(), 2013 Context.toBits(UnpackedAlignment)); 2014 CharUnits UnpackedSize = Context.toCharUnitsFromBits(UnpackedSizeInBits); 2015 setSize(llvm::RoundUpToAlignment(getSizeInBits(), Context.toBits(Alignment))); 2016 2017 unsigned CharBitNum = Context.getTargetInfo().getCharWidth(); 2018 if (const RecordDecl *RD = dyn_cast<RecordDecl>(D)) { 2019 // Warn if padding was introduced to the struct/class/union. 2020 if (getSizeInBits() > UnpaddedSize) { 2021 unsigned PadSize = getSizeInBits() - UnpaddedSize; 2022 bool InBits = true; 2023 if (PadSize % CharBitNum == 0) { 2024 PadSize = PadSize / CharBitNum; 2025 InBits = false; 2026 } 2027 Diag(RD->getLocation(), diag::warn_padded_struct_size) 2028 << Context.getTypeDeclType(RD) 2029 << PadSize 2030 << (InBits ? 1 : 0) /*(byte|bit)*/ << (PadSize > 1); // plural or not 2031 } 2032 2033 // Warn if we packed it unnecessarily. If the alignment is 1 byte don't 2034 // bother since there won't be alignment issues. 2035 if (Packed && UnpackedAlignment > CharUnits::One() && 2036 getSize() == UnpackedSize) 2037 Diag(D->getLocation(), diag::warn_unnecessary_packed) 2038 << Context.getTypeDeclType(RD); 2039 } 2040 } 2041 2042 void RecordLayoutBuilder::UpdateAlignment(CharUnits NewAlignment, 2043 CharUnits UnpackedNewAlignment) { 2044 // The alignment is not modified when using 'mac68k' alignment or when 2045 // we have an externally-supplied layout that also provides overall alignment. 2046 if (IsMac68kAlign || (ExternalLayout && !InferAlignment)) 2047 return; 2048 2049 if (NewAlignment > Alignment) { 2050 assert(llvm::isPowerOf2_32(NewAlignment.getQuantity() && 2051 "Alignment not a power of 2")); 2052 Alignment = NewAlignment; 2053 } 2054 2055 if (UnpackedNewAlignment > UnpackedAlignment) { 2056 assert(llvm::isPowerOf2_32(UnpackedNewAlignment.getQuantity() && 2057 "Alignment not a power of 2")); 2058 UnpackedAlignment = UnpackedNewAlignment; 2059 } 2060 } 2061 2062 uint64_t 2063 RecordLayoutBuilder::updateExternalFieldOffset(const FieldDecl *Field, 2064 uint64_t ComputedOffset) { 2065 assert(ExternalFieldOffsets.find(Field) != ExternalFieldOffsets.end() && 2066 "Field does not have an external offset"); 2067 2068 uint64_t ExternalFieldOffset = ExternalFieldOffsets[Field]; 2069 2070 if (InferAlignment && ExternalFieldOffset < ComputedOffset) { 2071 // The externally-supplied field offset is before the field offset we 2072 // computed. Assume that the structure is packed. 2073 Alignment = CharUnits::fromQuantity(1); 2074 InferAlignment = false; 2075 } 2076 2077 // Use the externally-supplied field offset. 2078 return ExternalFieldOffset; 2079 } 2080 2081 void RecordLayoutBuilder::CheckFieldPadding(uint64_t Offset, 2082 uint64_t UnpaddedOffset, 2083 uint64_t UnpackedOffset, 2084 unsigned UnpackedAlign, 2085 bool isPacked, 2086 const FieldDecl *D) { 2087 // We let objc ivars without warning, objc interfaces generally are not used 2088 // for padding tricks. 2089 if (isa<ObjCIvarDecl>(D)) 2090 return; 2091 2092 // Don't warn about structs created without a SourceLocation. This can 2093 // be done by clients of the AST, such as codegen. 2094 if (D->getLocation().isInvalid()) 2095 return; 2096 2097 unsigned CharBitNum = Context.getTargetInfo().getCharWidth(); 2098 2099 // Warn if padding was introduced to the struct/class. 2100 if (!IsUnion && Offset > UnpaddedOffset) { 2101 unsigned PadSize = Offset - UnpaddedOffset; 2102 bool InBits = true; 2103 if (PadSize % CharBitNum == 0) { 2104 PadSize = PadSize / CharBitNum; 2105 InBits = false; 2106 } 2107 if (D->getIdentifier()) 2108 Diag(D->getLocation(), diag::warn_padded_struct_field) 2109 << (D->getParent()->isStruct() ? 0 : 1) // struct|class 2110 << Context.getTypeDeclType(D->getParent()) 2111 << PadSize 2112 << (InBits ? 1 : 0) /*(byte|bit)*/ << (PadSize > 1) // plural or not 2113 << D->getIdentifier(); 2114 else 2115 Diag(D->getLocation(), diag::warn_padded_struct_anon_field) 2116 << (D->getParent()->isStruct() ? 0 : 1) // struct|class 2117 << Context.getTypeDeclType(D->getParent()) 2118 << PadSize 2119 << (InBits ? 1 : 0) /*(byte|bit)*/ << (PadSize > 1); // plural or not 2120 } 2121 2122 // Warn if we packed it unnecessarily. If the alignment is 1 byte don't 2123 // bother since there won't be alignment issues. 2124 if (isPacked && UnpackedAlign > CharBitNum && Offset == UnpackedOffset) 2125 Diag(D->getLocation(), diag::warn_unnecessary_packed) 2126 << D->getIdentifier(); 2127 } 2128 2129 const CXXMethodDecl * 2130 RecordLayoutBuilder::ComputeKeyFunction(const CXXRecordDecl *RD) { 2131 // If a class isn't polymorphic it doesn't have a key function. 2132 if (!RD->isPolymorphic()) 2133 return 0; 2134 2135 // A class that is not externally visible doesn't have a key function. (Or 2136 // at least, there's no point to assigning a key function to such a class; 2137 // this doesn't affect the ABI.) 2138 if (RD->getLinkage() != ExternalLinkage) 2139 return 0; 2140 2141 // Template instantiations don't have key functions,see Itanium C++ ABI 5.2.6. 2142 // Same behavior as GCC. 2143 TemplateSpecializationKind TSK = RD->getTemplateSpecializationKind(); 2144 if (TSK == TSK_ImplicitInstantiation || 2145 TSK == TSK_ExplicitInstantiationDefinition) 2146 return 0; 2147 2148 for (CXXRecordDecl::method_iterator I = RD->method_begin(), 2149 E = RD->method_end(); I != E; ++I) { 2150 const CXXMethodDecl *MD = *I; 2151 2152 if (!MD->isVirtual()) 2153 continue; 2154 2155 if (MD->isPure()) 2156 continue; 2157 2158 // Ignore implicit member functions, they are always marked as inline, but 2159 // they don't have a body until they're defined. 2160 if (MD->isImplicit()) 2161 continue; 2162 2163 if (MD->isInlineSpecified()) 2164 continue; 2165 2166 if (MD->hasInlineBody()) 2167 continue; 2168 2169 // We found it. 2170 return MD; 2171 } 2172 2173 return 0; 2174 } 2175 2176 DiagnosticBuilder 2177 RecordLayoutBuilder::Diag(SourceLocation Loc, unsigned DiagID) { 2178 return Context.getDiagnostics().Report(Loc, DiagID); 2179 } 2180 2181 /// getASTRecordLayout - Get or compute information about the layout of the 2182 /// specified record (struct/union/class), which indicates its size and field 2183 /// position information. 2184 const ASTRecordLayout & 2185 ASTContext::getASTRecordLayout(const RecordDecl *D) const { 2186 // These asserts test different things. A record has a definition 2187 // as soon as we begin to parse the definition. That definition is 2188 // not a complete definition (which is what isDefinition() tests) 2189 // until we *finish* parsing the definition. 2190 2191 if (D->hasExternalLexicalStorage() && !D->getDefinition()) 2192 getExternalSource()->CompleteType(const_cast<RecordDecl*>(D)); 2193 2194 D = D->getDefinition(); 2195 assert(D && "Cannot get layout of forward declarations!"); 2196 assert(D->isCompleteDefinition() && "Cannot layout type before complete!"); 2197 2198 // Look up this layout, if already laid out, return what we have. 2199 // Note that we can't save a reference to the entry because this function 2200 // is recursive. 2201 const ASTRecordLayout *Entry = ASTRecordLayouts[D]; 2202 if (Entry) return *Entry; 2203 2204 const ASTRecordLayout *NewEntry; 2205 2206 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) { 2207 EmptySubobjectMap EmptySubobjects(*this, RD); 2208 RecordLayoutBuilder Builder(*this, &EmptySubobjects); 2209 Builder.Layout(RD); 2210 2211 // MSVC gives the vb-table pointer an alignment equal to that of 2212 // the non-virtual part of the structure. That's an inherently 2213 // multi-pass operation. If our first pass doesn't give us 2214 // adequate alignment, try again with the specified minimum 2215 // alignment. This is *much* more maintainable than computing the 2216 // alignment in advance in a separately-coded pass; it's also 2217 // significantly more efficient in the common case where the 2218 // vb-table doesn't need extra padding. 2219 if (Builder.VBPtrOffset != CharUnits::fromQuantity(-1) && 2220 (Builder.VBPtrOffset % Builder.NonVirtualAlignment) != 0) { 2221 Builder.resetWithTargetAlignment(Builder.NonVirtualAlignment); 2222 Builder.Layout(RD); 2223 } 2224 2225 // FIXME: This is not always correct. See the part about bitfields at 2226 // http://www.codesourcery.com/public/cxx-abi/abi.html#POD for more info. 2227 // FIXME: IsPODForThePurposeOfLayout should be stored in the record layout. 2228 // This does not affect the calculations of MSVC layouts 2229 bool IsPODForThePurposeOfLayout = 2230 (!Builder.isMicrosoftCXXABI() && cast<CXXRecordDecl>(D)->isPOD()); 2231 2232 // FIXME: This should be done in FinalizeLayout. 2233 CharUnits DataSize = 2234 IsPODForThePurposeOfLayout ? Builder.getSize() : Builder.getDataSize(); 2235 CharUnits NonVirtualSize = 2236 IsPODForThePurposeOfLayout ? DataSize : Builder.NonVirtualSize; 2237 2238 NewEntry = 2239 new (*this) ASTRecordLayout(*this, Builder.getSize(), 2240 Builder.Alignment, 2241 Builder.VFPtrOffset, 2242 Builder.VBPtrOffset, 2243 DataSize, 2244 Builder.FieldOffsets.data(), 2245 Builder.FieldOffsets.size(), 2246 NonVirtualSize, 2247 Builder.NonVirtualAlignment, 2248 EmptySubobjects.SizeOfLargestEmptySubobject, 2249 Builder.PrimaryBase, 2250 Builder.PrimaryBaseIsVirtual, 2251 Builder.Bases, Builder.VBases); 2252 } else { 2253 RecordLayoutBuilder Builder(*this, /*EmptySubobjects=*/0); 2254 Builder.Layout(D); 2255 2256 NewEntry = 2257 new (*this) ASTRecordLayout(*this, Builder.getSize(), 2258 Builder.Alignment, 2259 Builder.getSize(), 2260 Builder.FieldOffsets.data(), 2261 Builder.FieldOffsets.size()); 2262 } 2263 2264 ASTRecordLayouts[D] = NewEntry; 2265 2266 if (getLangOpts().DumpRecordLayouts) { 2267 llvm::errs() << "\n*** Dumping AST Record Layout\n"; 2268 DumpRecordLayout(D, llvm::errs(), getLangOpts().DumpRecordLayoutsSimple); 2269 } 2270 2271 return *NewEntry; 2272 } 2273 2274 const CXXMethodDecl *ASTContext::getKeyFunction(const CXXRecordDecl *RD) { 2275 RD = cast<CXXRecordDecl>(RD->getDefinition()); 2276 assert(RD && "Cannot get key function for forward declarations!"); 2277 2278 const CXXMethodDecl *&Entry = KeyFunctions[RD]; 2279 if (!Entry) 2280 Entry = RecordLayoutBuilder::ComputeKeyFunction(RD); 2281 2282 return Entry; 2283 } 2284 2285 static uint64_t getFieldOffset(const ASTContext &C, const FieldDecl *FD) { 2286 const ASTRecordLayout &Layout = C.getASTRecordLayout(FD->getParent()); 2287 return Layout.getFieldOffset(FD->getFieldIndex()); 2288 } 2289 2290 uint64_t ASTContext::getFieldOffset(const ValueDecl *VD) const { 2291 uint64_t OffsetInBits; 2292 if (const FieldDecl *FD = dyn_cast<FieldDecl>(VD)) { 2293 OffsetInBits = ::getFieldOffset(*this, FD); 2294 } else { 2295 const IndirectFieldDecl *IFD = cast<IndirectFieldDecl>(VD); 2296 2297 OffsetInBits = 0; 2298 for (IndirectFieldDecl::chain_iterator CI = IFD->chain_begin(), 2299 CE = IFD->chain_end(); 2300 CI != CE; ++CI) 2301 OffsetInBits += ::getFieldOffset(*this, cast<FieldDecl>(*CI)); 2302 } 2303 2304 return OffsetInBits; 2305 } 2306 2307 /// getObjCLayout - Get or compute information about the layout of the 2308 /// given interface. 2309 /// 2310 /// \param Impl - If given, also include the layout of the interface's 2311 /// implementation. This may differ by including synthesized ivars. 2312 const ASTRecordLayout & 2313 ASTContext::getObjCLayout(const ObjCInterfaceDecl *D, 2314 const ObjCImplementationDecl *Impl) const { 2315 // Retrieve the definition 2316 if (D->hasExternalLexicalStorage() && !D->getDefinition()) 2317 getExternalSource()->CompleteType(const_cast<ObjCInterfaceDecl*>(D)); 2318 D = D->getDefinition(); 2319 assert(D && D->isThisDeclarationADefinition() && "Invalid interface decl!"); 2320 2321 // Look up this layout, if already laid out, return what we have. 2322 ObjCContainerDecl *Key = 2323 Impl ? (ObjCContainerDecl*) Impl : (ObjCContainerDecl*) D; 2324 if (const ASTRecordLayout *Entry = ObjCLayouts[Key]) 2325 return *Entry; 2326 2327 // Add in synthesized ivar count if laying out an implementation. 2328 if (Impl) { 2329 unsigned SynthCount = CountNonClassIvars(D); 2330 // If there aren't any sythesized ivars then reuse the interface 2331 // entry. Note we can't cache this because we simply free all 2332 // entries later; however we shouldn't look up implementations 2333 // frequently. 2334 if (SynthCount == 0) 2335 return getObjCLayout(D, 0); 2336 } 2337 2338 RecordLayoutBuilder Builder(*this, /*EmptySubobjects=*/0); 2339 Builder.Layout(D); 2340 2341 const ASTRecordLayout *NewEntry = 2342 new (*this) ASTRecordLayout(*this, Builder.getSize(), 2343 Builder.Alignment, 2344 Builder.getDataSize(), 2345 Builder.FieldOffsets.data(), 2346 Builder.FieldOffsets.size()); 2347 2348 ObjCLayouts[Key] = NewEntry; 2349 2350 return *NewEntry; 2351 } 2352 2353 static void PrintOffset(raw_ostream &OS, 2354 CharUnits Offset, unsigned IndentLevel) { 2355 OS << llvm::format("%4" PRId64 " | ", (int64_t)Offset.getQuantity()); 2356 OS.indent(IndentLevel * 2); 2357 } 2358 2359 static void DumpCXXRecordLayout(raw_ostream &OS, 2360 const CXXRecordDecl *RD, const ASTContext &C, 2361 CharUnits Offset, 2362 unsigned IndentLevel, 2363 const char* Description, 2364 bool IncludeVirtualBases) { 2365 const ASTRecordLayout &Layout = C.getASTRecordLayout(RD); 2366 2367 PrintOffset(OS, Offset, IndentLevel); 2368 OS << C.getTypeDeclType(const_cast<CXXRecordDecl *>(RD)).getAsString(); 2369 if (Description) 2370 OS << ' ' << Description; 2371 if (RD->isEmpty()) 2372 OS << " (empty)"; 2373 OS << '\n'; 2374 2375 IndentLevel++; 2376 2377 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase(); 2378 bool HasVfptr = Layout.getVFPtrOffset() != CharUnits::fromQuantity(-1); 2379 bool HasVbptr = Layout.getVBPtrOffset() != CharUnits::fromQuantity(-1); 2380 2381 // Vtable pointer. 2382 if (RD->isDynamicClass() && !PrimaryBase && 2383 C.getTargetInfo().getCXXABI() != CXXABI_Microsoft) { 2384 PrintOffset(OS, Offset, IndentLevel); 2385 OS << '(' << *RD << " vtable pointer)\n"; 2386 } 2387 2388 // Dump (non-virtual) bases 2389 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 2390 E = RD->bases_end(); I != E; ++I) { 2391 assert(!I->getType()->isDependentType() && 2392 "Cannot layout class with dependent bases."); 2393 if (I->isVirtual()) 2394 continue; 2395 2396 const CXXRecordDecl *Base = 2397 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl()); 2398 2399 CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(Base); 2400 2401 DumpCXXRecordLayout(OS, Base, C, BaseOffset, IndentLevel, 2402 Base == PrimaryBase ? "(primary base)" : "(base)", 2403 /*IncludeVirtualBases=*/false); 2404 } 2405 2406 // vfptr and vbptr (for Microsoft C++ ABI) 2407 if (HasVfptr) { 2408 PrintOffset(OS, Offset + Layout.getVFPtrOffset(), IndentLevel); 2409 OS << '(' << *RD << " vftable pointer)\n"; 2410 } 2411 if (HasVbptr) { 2412 PrintOffset(OS, Offset + Layout.getVBPtrOffset(), IndentLevel); 2413 OS << '(' << *RD << " vbtable pointer)\n"; 2414 } 2415 2416 // Dump fields. 2417 uint64_t FieldNo = 0; 2418 for (CXXRecordDecl::field_iterator I = RD->field_begin(), 2419 E = RD->field_end(); I != E; ++I, ++FieldNo) { 2420 const FieldDecl *Field = *I; 2421 CharUnits FieldOffset = Offset + 2422 C.toCharUnitsFromBits(Layout.getFieldOffset(FieldNo)); 2423 2424 if (const RecordType *RT = Field->getType()->getAs<RecordType>()) { 2425 if (const CXXRecordDecl *D = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 2426 DumpCXXRecordLayout(OS, D, C, FieldOffset, IndentLevel, 2427 Field->getName().data(), 2428 /*IncludeVirtualBases=*/true); 2429 continue; 2430 } 2431 } 2432 2433 PrintOffset(OS, FieldOffset, IndentLevel); 2434 OS << Field->getType().getAsString() << ' ' << *Field << '\n'; 2435 } 2436 2437 if (!IncludeVirtualBases) 2438 return; 2439 2440 // Dump virtual bases. 2441 for (CXXRecordDecl::base_class_const_iterator I = RD->vbases_begin(), 2442 E = RD->vbases_end(); I != E; ++I) { 2443 assert(I->isVirtual() && "Found non-virtual class!"); 2444 const CXXRecordDecl *VBase = 2445 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl()); 2446 2447 CharUnits VBaseOffset = Offset + Layout.getVBaseClassOffset(VBase); 2448 DumpCXXRecordLayout(OS, VBase, C, VBaseOffset, IndentLevel, 2449 VBase == PrimaryBase ? 2450 "(primary virtual base)" : "(virtual base)", 2451 /*IncludeVirtualBases=*/false); 2452 } 2453 2454 OS << " sizeof=" << Layout.getSize().getQuantity(); 2455 OS << ", dsize=" << Layout.getDataSize().getQuantity(); 2456 OS << ", align=" << Layout.getAlignment().getQuantity() << '\n'; 2457 OS << " nvsize=" << Layout.getNonVirtualSize().getQuantity(); 2458 OS << ", nvalign=" << Layout.getNonVirtualAlign().getQuantity() << '\n'; 2459 OS << '\n'; 2460 } 2461 2462 void ASTContext::DumpRecordLayout(const RecordDecl *RD, 2463 raw_ostream &OS, 2464 bool Simple) const { 2465 const ASTRecordLayout &Info = getASTRecordLayout(RD); 2466 2467 if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) 2468 if (!Simple) 2469 return DumpCXXRecordLayout(OS, CXXRD, *this, CharUnits(), 0, 0, 2470 /*IncludeVirtualBases=*/true); 2471 2472 OS << "Type: " << getTypeDeclType(RD).getAsString() << "\n"; 2473 if (!Simple) { 2474 OS << "Record: "; 2475 RD->dump(); 2476 } 2477 OS << "\nLayout: "; 2478 OS << "<ASTRecordLayout\n"; 2479 OS << " Size:" << toBits(Info.getSize()) << "\n"; 2480 OS << " DataSize:" << toBits(Info.getDataSize()) << "\n"; 2481 OS << " Alignment:" << toBits(Info.getAlignment()) << "\n"; 2482 OS << " FieldOffsets: ["; 2483 for (unsigned i = 0, e = Info.getFieldCount(); i != e; ++i) { 2484 if (i) OS << ", "; 2485 OS << Info.getFieldOffset(i); 2486 } 2487 OS << "]>\n"; 2488 } 2489