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