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 24 using namespace clang; 25 26 namespace { 27 28 /// BaseSubobjectInfo - Represents a single base subobject in a complete class. 29 /// For a class hierarchy like 30 /// 31 /// class A { }; 32 /// class B : A { }; 33 /// class C : A, B { }; 34 /// 35 /// The BaseSubobjectInfo graph for C will have three BaseSubobjectInfo 36 /// instances, one for B and two for A. 37 /// 38 /// If a base is virtual, it will only have one BaseSubobjectInfo allocated. 39 struct BaseSubobjectInfo { 40 /// Class - The class for this base info. 41 const CXXRecordDecl *Class; 42 43 /// IsVirtual - Whether the BaseInfo represents a virtual base or not. 44 bool IsVirtual; 45 46 /// Bases - Information about the base subobjects. 47 SmallVector<BaseSubobjectInfo*, 4> Bases; 48 49 /// PrimaryVirtualBaseInfo - Holds the base info for the primary virtual base 50 /// of this base info (if one exists). 51 BaseSubobjectInfo *PrimaryVirtualBaseInfo; 52 53 // FIXME: Document. 54 const BaseSubobjectInfo *Derived; 55 }; 56 57 /// 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. 60 struct 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. 105 class 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 151 protected: 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 164 public: 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 187 void 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 231 bool 232 EmptySubobjectMap::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::is_contained(Classes, RD)) 244 return true; 245 246 // There is already an empty class of the same type at this offset. 247 return false; 248 } 249 250 void 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 269 bool 270 EmptySubobjectMap::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 316 void 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 360 bool 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 376 bool 377 EmptySubobjectMap::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 429 bool 430 EmptySubobjectMap::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 469 bool 470 EmptySubobjectMap::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 481 void 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 537 void 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 575 typedef llvm::SmallPtrSet<const CXXRecordDecl*, 4> ClassSetTy; 576 577 class ItaniumRecordLayoutBuilder { 578 protected: 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 831 void 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. 860 void 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 907 BaseSubobjectInfo *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 984 void 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 1008 void 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 1025 void 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 1099 void 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 1111 void 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 1144 void 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 1190 void 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 1205 CharUnits 1206 ItaniumRecordLayoutBuilder::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().isPS() || 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 // On PS4/PS5, don't update the alignment, to preserve compatibility. 1265 if (!Context.getTargetInfo().getTriple().isPS()) 1266 UpdateAlignment(BaseAlign, UnpackedAlignTo, PreferredBaseAlign); 1267 1268 return CharUnits::Zero(); 1269 } 1270 1271 // The maximum field alignment overrides the base align/(AIX-only) preferred 1272 // base align. 1273 if (!MaxFieldAlignment.isZero()) { 1274 BaseAlign = std::min(BaseAlign, MaxFieldAlignment); 1275 PreferredBaseAlign = std::min(PreferredBaseAlign, MaxFieldAlignment); 1276 UnpackedAlignTo = std::min(UnpackedAlignTo, MaxFieldAlignment); 1277 } 1278 1279 CharUnits AlignTo = 1280 !DefaultsToAIXPowerAlignment ? BaseAlign : PreferredBaseAlign; 1281 if (!HasExternalLayout) { 1282 // Round up the current record size to the base's alignment boundary. 1283 Offset = getDataSize().alignTo(AlignTo); 1284 1285 // Try to place the base. 1286 while (!EmptySubobjects->CanPlaceBaseAtOffset(Base, Offset)) 1287 Offset += AlignTo; 1288 } else { 1289 bool Allowed = EmptySubobjects->CanPlaceBaseAtOffset(Base, Offset); 1290 (void)Allowed; 1291 assert(Allowed && "Base subobject externally placed at overlapping offset"); 1292 1293 if (InferAlignment && Offset < getDataSize().alignTo(AlignTo)) { 1294 // The externally-supplied base offset is before the base offset we 1295 // computed. Assume that the structure is packed. 1296 Alignment = CharUnits::One(); 1297 InferAlignment = false; 1298 } 1299 } 1300 1301 if (!Base->Class->isEmpty()) { 1302 // Update the data size. 1303 setDataSize(Offset + Layout.getNonVirtualSize()); 1304 1305 setSize(std::max(getSize(), getDataSize())); 1306 } else 1307 setSize(std::max(getSize(), Offset + Layout.getSize())); 1308 1309 // Remember max struct/class alignment. 1310 UpdateAlignment(BaseAlign, UnpackedAlignTo, PreferredBaseAlign); 1311 1312 return Offset; 1313 } 1314 1315 void ItaniumRecordLayoutBuilder::InitializeLayout(const Decl *D) { 1316 if (const RecordDecl *RD = dyn_cast<RecordDecl>(D)) { 1317 IsUnion = RD->isUnion(); 1318 IsMsStruct = RD->isMsStruct(Context); 1319 } 1320 1321 Packed = D->hasAttr<PackedAttr>(); 1322 1323 // Honor the default struct packing maximum alignment flag. 1324 if (unsigned DefaultMaxFieldAlignment = Context.getLangOpts().PackStruct) { 1325 MaxFieldAlignment = CharUnits::fromQuantity(DefaultMaxFieldAlignment); 1326 } 1327 1328 // mac68k alignment supersedes maximum field alignment and attribute aligned, 1329 // and forces all structures to have 2-byte alignment. The IBM docs on it 1330 // allude to additional (more complicated) semantics, especially with regard 1331 // to bit-fields, but gcc appears not to follow that. 1332 if (D->hasAttr<AlignMac68kAttr>()) { 1333 assert( 1334 !D->hasAttr<AlignNaturalAttr>() && 1335 "Having both mac68k and natural alignment on a decl is not allowed."); 1336 IsMac68kAlign = true; 1337 MaxFieldAlignment = CharUnits::fromQuantity(2); 1338 Alignment = CharUnits::fromQuantity(2); 1339 PreferredAlignment = CharUnits::fromQuantity(2); 1340 } else { 1341 if (D->hasAttr<AlignNaturalAttr>()) 1342 IsNaturalAlign = true; 1343 1344 if (const MaxFieldAlignmentAttr *MFAA = D->getAttr<MaxFieldAlignmentAttr>()) 1345 MaxFieldAlignment = Context.toCharUnitsFromBits(MFAA->getAlignment()); 1346 1347 if (unsigned MaxAlign = D->getMaxAlignment()) 1348 UpdateAlignment(Context.toCharUnitsFromBits(MaxAlign)); 1349 } 1350 1351 HandledFirstNonOverlappingEmptyField = 1352 !Context.getTargetInfo().defaultsToAIXPowerAlignment() || IsNaturalAlign; 1353 1354 // If there is an external AST source, ask it for the various offsets. 1355 if (const RecordDecl *RD = dyn_cast<RecordDecl>(D)) 1356 if (ExternalASTSource *Source = Context.getExternalSource()) { 1357 UseExternalLayout = Source->layoutRecordType( 1358 RD, External.Size, External.Align, External.FieldOffsets, 1359 External.BaseOffsets, External.VirtualBaseOffsets); 1360 1361 // Update based on external alignment. 1362 if (UseExternalLayout) { 1363 if (External.Align > 0) { 1364 Alignment = Context.toCharUnitsFromBits(External.Align); 1365 PreferredAlignment = Context.toCharUnitsFromBits(External.Align); 1366 } else { 1367 // The external source didn't have alignment information; infer it. 1368 InferAlignment = true; 1369 } 1370 } 1371 } 1372 } 1373 1374 void ItaniumRecordLayoutBuilder::Layout(const RecordDecl *D) { 1375 InitializeLayout(D); 1376 LayoutFields(D); 1377 1378 // Finally, round the size of the total struct up to the alignment of the 1379 // struct itself. 1380 FinishLayout(D); 1381 } 1382 1383 void ItaniumRecordLayoutBuilder::Layout(const CXXRecordDecl *RD) { 1384 InitializeLayout(RD); 1385 1386 // Lay out the vtable and the non-virtual bases. 1387 LayoutNonVirtualBases(RD); 1388 1389 LayoutFields(RD); 1390 1391 NonVirtualSize = Context.toCharUnitsFromBits( 1392 llvm::alignTo(getSizeInBits(), Context.getTargetInfo().getCharAlign())); 1393 NonVirtualAlignment = Alignment; 1394 PreferredNVAlignment = PreferredAlignment; 1395 1396 // Lay out the virtual bases and add the primary virtual base offsets. 1397 LayoutVirtualBases(RD, RD); 1398 1399 // Finally, round the size of the total struct up to the alignment 1400 // of the struct itself. 1401 FinishLayout(RD); 1402 1403 #ifndef NDEBUG 1404 // Check that we have base offsets for all bases. 1405 for (const CXXBaseSpecifier &Base : RD->bases()) { 1406 if (Base.isVirtual()) 1407 continue; 1408 1409 const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); 1410 1411 assert(Bases.count(BaseDecl) && "Did not find base offset!"); 1412 } 1413 1414 // And all virtual bases. 1415 for (const CXXBaseSpecifier &Base : RD->vbases()) { 1416 const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); 1417 1418 assert(VBases.count(BaseDecl) && "Did not find base offset!"); 1419 } 1420 #endif 1421 } 1422 1423 void ItaniumRecordLayoutBuilder::Layout(const ObjCInterfaceDecl *D) { 1424 if (ObjCInterfaceDecl *SD = D->getSuperClass()) { 1425 const ASTRecordLayout &SL = Context.getASTObjCInterfaceLayout(SD); 1426 1427 UpdateAlignment(SL.getAlignment()); 1428 1429 // We start laying out ivars not at the end of the superclass 1430 // structure, but at the next byte following the last field. 1431 setDataSize(SL.getDataSize()); 1432 setSize(getDataSize()); 1433 } 1434 1435 InitializeLayout(D); 1436 // Layout each ivar sequentially. 1437 for (const ObjCIvarDecl *IVD = D->all_declared_ivar_begin(); IVD; 1438 IVD = IVD->getNextIvar()) 1439 LayoutField(IVD, false); 1440 1441 // Finally, round the size of the total struct up to the alignment of the 1442 // struct itself. 1443 FinishLayout(D); 1444 } 1445 1446 void ItaniumRecordLayoutBuilder::LayoutFields(const RecordDecl *D) { 1447 // Layout each field, for now, just sequentially, respecting alignment. In 1448 // the future, this will need to be tweakable by targets. 1449 bool InsertExtraPadding = D->mayInsertExtraPadding(/*EmitRemark=*/true); 1450 bool HasFlexibleArrayMember = D->hasFlexibleArrayMember(); 1451 for (auto I = D->field_begin(), End = D->field_end(); I != End; ++I) { 1452 auto Next(I); 1453 ++Next; 1454 LayoutField(*I, 1455 InsertExtraPadding && (Next != End || !HasFlexibleArrayMember)); 1456 } 1457 } 1458 1459 // Rounds the specified size to have it a multiple of the char size. 1460 static uint64_t 1461 roundUpSizeToCharAlignment(uint64_t Size, 1462 const ASTContext &Context) { 1463 uint64_t CharAlignment = Context.getTargetInfo().getCharAlign(); 1464 return llvm::alignTo(Size, CharAlignment); 1465 } 1466 1467 void ItaniumRecordLayoutBuilder::LayoutWideBitField(uint64_t FieldSize, 1468 uint64_t StorageUnitSize, 1469 bool FieldPacked, 1470 const FieldDecl *D) { 1471 assert(Context.getLangOpts().CPlusPlus && 1472 "Can only have wide bit-fields in C++!"); 1473 1474 // Itanium C++ ABI 2.4: 1475 // If sizeof(T)*8 < n, let T' be the largest integral POD type with 1476 // sizeof(T')*8 <= n. 1477 1478 QualType IntegralPODTypes[] = { 1479 Context.UnsignedCharTy, Context.UnsignedShortTy, Context.UnsignedIntTy, 1480 Context.UnsignedLongTy, Context.UnsignedLongLongTy 1481 }; 1482 1483 QualType Type; 1484 for (const QualType &QT : IntegralPODTypes) { 1485 uint64_t Size = Context.getTypeSize(QT); 1486 1487 if (Size > FieldSize) 1488 break; 1489 1490 Type = QT; 1491 } 1492 assert(!Type.isNull() && "Did not find a type!"); 1493 1494 CharUnits TypeAlign = Context.getTypeAlignInChars(Type); 1495 1496 // We're not going to use any of the unfilled bits in the last byte. 1497 UnfilledBitsInLastUnit = 0; 1498 LastBitfieldStorageUnitSize = 0; 1499 1500 uint64_t FieldOffset; 1501 uint64_t UnpaddedFieldOffset = getDataSizeInBits() - UnfilledBitsInLastUnit; 1502 1503 if (IsUnion) { 1504 uint64_t RoundedFieldSize = roundUpSizeToCharAlignment(FieldSize, 1505 Context); 1506 setDataSize(std::max(getDataSizeInBits(), RoundedFieldSize)); 1507 FieldOffset = 0; 1508 } else { 1509 // The bitfield is allocated starting at the next offset aligned 1510 // appropriately for T', with length n bits. 1511 FieldOffset = llvm::alignTo(getDataSizeInBits(), Context.toBits(TypeAlign)); 1512 1513 uint64_t NewSizeInBits = FieldOffset + FieldSize; 1514 1515 setDataSize( 1516 llvm::alignTo(NewSizeInBits, Context.getTargetInfo().getCharAlign())); 1517 UnfilledBitsInLastUnit = getDataSizeInBits() - NewSizeInBits; 1518 } 1519 1520 // Place this field at the current location. 1521 FieldOffsets.push_back(FieldOffset); 1522 1523 CheckFieldPadding(FieldOffset, UnpaddedFieldOffset, FieldOffset, 1524 Context.toBits(TypeAlign), FieldPacked, D); 1525 1526 // Update the size. 1527 setSize(std::max(getSizeInBits(), getDataSizeInBits())); 1528 1529 // Remember max struct/class alignment. 1530 UpdateAlignment(TypeAlign); 1531 } 1532 1533 static bool isAIXLayout(const ASTContext &Context) { 1534 return Context.getTargetInfo().getTriple().getOS() == llvm::Triple::AIX; 1535 } 1536 1537 void ItaniumRecordLayoutBuilder::LayoutBitField(const FieldDecl *D) { 1538 bool FieldPacked = Packed || D->hasAttr<PackedAttr>(); 1539 uint64_t FieldSize = D->getBitWidthValue(Context); 1540 TypeInfo FieldInfo = Context.getTypeInfo(D->getType()); 1541 uint64_t StorageUnitSize = FieldInfo.Width; 1542 unsigned FieldAlign = FieldInfo.Align; 1543 bool AlignIsRequired = FieldInfo.isAlignRequired(); 1544 1545 // UnfilledBitsInLastUnit is the difference between the end of the 1546 // last allocated bitfield (i.e. the first bit offset available for 1547 // bitfields) and the end of the current data size in bits (i.e. the 1548 // first bit offset available for non-bitfields). The current data 1549 // size in bits is always a multiple of the char size; additionally, 1550 // for ms_struct records it's also a multiple of the 1551 // LastBitfieldStorageUnitSize (if set). 1552 1553 // The struct-layout algorithm is dictated by the platform ABI, 1554 // which in principle could use almost any rules it likes. In 1555 // practice, UNIXy targets tend to inherit the algorithm described 1556 // in the System V generic ABI. The basic bitfield layout rule in 1557 // System V is to place bitfields at the next available bit offset 1558 // where the entire bitfield would fit in an aligned storage unit of 1559 // the declared type; it's okay if an earlier or later non-bitfield 1560 // is allocated in the same storage unit. However, some targets 1561 // (those that !useBitFieldTypeAlignment(), e.g. ARM APCS) don't 1562 // require this storage unit to be aligned, and therefore always put 1563 // the bitfield at the next available bit offset. 1564 1565 // ms_struct basically requests a complete replacement of the 1566 // platform ABI's struct-layout algorithm, with the high-level goal 1567 // of duplicating MSVC's layout. For non-bitfields, this follows 1568 // the standard algorithm. The basic bitfield layout rule is to 1569 // allocate an entire unit of the bitfield's declared type 1570 // (e.g. 'unsigned long'), then parcel it up among successive 1571 // bitfields whose declared types have the same size, making a new 1572 // unit as soon as the last can no longer store the whole value. 1573 // Since it completely replaces the platform ABI's algorithm, 1574 // settings like !useBitFieldTypeAlignment() do not apply. 1575 1576 // A zero-width bitfield forces the use of a new storage unit for 1577 // later bitfields. In general, this occurs by rounding up the 1578 // current size of the struct as if the algorithm were about to 1579 // place a non-bitfield of the field's formal type. Usually this 1580 // does not change the alignment of the struct itself, but it does 1581 // on some targets (those that useZeroLengthBitfieldAlignment(), 1582 // e.g. ARM). In ms_struct layout, zero-width bitfields are 1583 // ignored unless they follow a non-zero-width bitfield. 1584 1585 // A field alignment restriction (e.g. from #pragma pack) or 1586 // specification (e.g. from __attribute__((aligned))) changes the 1587 // formal alignment of the field. For System V, this alters the 1588 // required alignment of the notional storage unit that must contain 1589 // the bitfield. For ms_struct, this only affects the placement of 1590 // new storage units. In both cases, the effect of #pragma pack is 1591 // ignored on zero-width bitfields. 1592 1593 // On System V, a packed field (e.g. from #pragma pack or 1594 // __attribute__((packed))) always uses the next available bit 1595 // offset. 1596 1597 // In an ms_struct struct, the alignment of a fundamental type is 1598 // always equal to its size. This is necessary in order to mimic 1599 // the i386 alignment rules on targets which might not fully align 1600 // all types (e.g. Darwin PPC32, where alignof(long long) == 4). 1601 1602 // First, some simple bookkeeping to perform for ms_struct structs. 1603 if (IsMsStruct) { 1604 // The field alignment for integer types is always the size. 1605 FieldAlign = StorageUnitSize; 1606 1607 // If the previous field was not a bitfield, or was a bitfield 1608 // with a different storage unit size, or if this field doesn't fit into 1609 // the current storage unit, we're done with that storage unit. 1610 if (LastBitfieldStorageUnitSize != StorageUnitSize || 1611 UnfilledBitsInLastUnit < FieldSize) { 1612 // Also, ignore zero-length bitfields after non-bitfields. 1613 if (!LastBitfieldStorageUnitSize && !FieldSize) 1614 FieldAlign = 1; 1615 1616 UnfilledBitsInLastUnit = 0; 1617 LastBitfieldStorageUnitSize = 0; 1618 } 1619 } 1620 1621 if (isAIXLayout(Context)) { 1622 if (StorageUnitSize < Context.getTypeSize(Context.UnsignedIntTy)) { 1623 // On AIX, [bool, char, short] bitfields have the same alignment 1624 // as [unsigned]. 1625 StorageUnitSize = Context.getTypeSize(Context.UnsignedIntTy); 1626 } else if (StorageUnitSize > Context.getTypeSize(Context.UnsignedIntTy) && 1627 Context.getTargetInfo().getTriple().isArch32Bit() && 1628 FieldSize <= 32) { 1629 // Under 32-bit compile mode, the bitcontainer is 32 bits if a single 1630 // long long bitfield has length no greater than 32 bits. 1631 StorageUnitSize = 32; 1632 1633 if (!AlignIsRequired) 1634 FieldAlign = 32; 1635 } 1636 1637 if (FieldAlign < StorageUnitSize) { 1638 // The bitfield alignment should always be greater than or equal to 1639 // bitcontainer size. 1640 FieldAlign = StorageUnitSize; 1641 } 1642 } 1643 1644 // If the field is wider than its declared type, it follows 1645 // different rules in all cases, except on AIX. 1646 // On AIX, wide bitfield follows the same rules as normal bitfield. 1647 if (FieldSize > StorageUnitSize && !isAIXLayout(Context)) { 1648 LayoutWideBitField(FieldSize, StorageUnitSize, FieldPacked, D); 1649 return; 1650 } 1651 1652 // Compute the next available bit offset. 1653 uint64_t FieldOffset = 1654 IsUnion ? 0 : (getDataSizeInBits() - UnfilledBitsInLastUnit); 1655 1656 // Handle targets that don't honor bitfield type alignment. 1657 if (!IsMsStruct && !Context.getTargetInfo().useBitFieldTypeAlignment()) { 1658 // Some such targets do honor it on zero-width bitfields. 1659 if (FieldSize == 0 && 1660 Context.getTargetInfo().useZeroLengthBitfieldAlignment()) { 1661 // Some targets don't honor leading zero-width bitfield. 1662 if (!IsUnion && FieldOffset == 0 && 1663 !Context.getTargetInfo().useLeadingZeroLengthBitfield()) 1664 FieldAlign = 1; 1665 else { 1666 // The alignment to round up to is the max of the field's natural 1667 // alignment and a target-specific fixed value (sometimes zero). 1668 unsigned ZeroLengthBitfieldBoundary = 1669 Context.getTargetInfo().getZeroLengthBitfieldBoundary(); 1670 FieldAlign = std::max(FieldAlign, ZeroLengthBitfieldBoundary); 1671 } 1672 // If that doesn't apply, just ignore the field alignment. 1673 } else { 1674 FieldAlign = 1; 1675 } 1676 } 1677 1678 // Remember the alignment we would have used if the field were not packed. 1679 unsigned UnpackedFieldAlign = FieldAlign; 1680 1681 // Ignore the field alignment if the field is packed unless it has zero-size. 1682 if (!IsMsStruct && FieldPacked && FieldSize != 0) 1683 FieldAlign = 1; 1684 1685 // But, if there's an 'aligned' attribute on the field, honor that. 1686 unsigned ExplicitFieldAlign = D->getMaxAlignment(); 1687 if (ExplicitFieldAlign) { 1688 FieldAlign = std::max(FieldAlign, ExplicitFieldAlign); 1689 UnpackedFieldAlign = std::max(UnpackedFieldAlign, ExplicitFieldAlign); 1690 } 1691 1692 // But, if there's a #pragma pack in play, that takes precedent over 1693 // even the 'aligned' attribute, for non-zero-width bitfields. 1694 unsigned MaxFieldAlignmentInBits = Context.toBits(MaxFieldAlignment); 1695 if (!MaxFieldAlignment.isZero() && FieldSize) { 1696 UnpackedFieldAlign = std::min(UnpackedFieldAlign, MaxFieldAlignmentInBits); 1697 if (FieldPacked) 1698 FieldAlign = UnpackedFieldAlign; 1699 else 1700 FieldAlign = std::min(FieldAlign, MaxFieldAlignmentInBits); 1701 } 1702 1703 // But, ms_struct just ignores all of that in unions, even explicit 1704 // alignment attributes. 1705 if (IsMsStruct && IsUnion) { 1706 FieldAlign = UnpackedFieldAlign = 1; 1707 } 1708 1709 // For purposes of diagnostics, we're going to simultaneously 1710 // compute the field offsets that we would have used if we weren't 1711 // adding any alignment padding or if the field weren't packed. 1712 uint64_t UnpaddedFieldOffset = FieldOffset; 1713 uint64_t UnpackedFieldOffset = FieldOffset; 1714 1715 // Check if we need to add padding to fit the bitfield within an 1716 // allocation unit with the right size and alignment. The rules are 1717 // somewhat different here for ms_struct structs. 1718 if (IsMsStruct) { 1719 // If it's not a zero-width bitfield, and we can fit the bitfield 1720 // into the active storage unit (and we haven't already decided to 1721 // start a new storage unit), just do so, regardless of any other 1722 // other consideration. Otherwise, round up to the right alignment. 1723 if (FieldSize == 0 || FieldSize > UnfilledBitsInLastUnit) { 1724 FieldOffset = llvm::alignTo(FieldOffset, FieldAlign); 1725 UnpackedFieldOffset = 1726 llvm::alignTo(UnpackedFieldOffset, UnpackedFieldAlign); 1727 UnfilledBitsInLastUnit = 0; 1728 } 1729 1730 } else { 1731 // #pragma pack, with any value, suppresses the insertion of padding. 1732 bool AllowPadding = MaxFieldAlignment.isZero(); 1733 1734 // Compute the real offset. 1735 if (FieldSize == 0 || 1736 (AllowPadding && 1737 (FieldOffset & (FieldAlign - 1)) + FieldSize > StorageUnitSize)) { 1738 FieldOffset = llvm::alignTo(FieldOffset, FieldAlign); 1739 } else if (ExplicitFieldAlign && 1740 (MaxFieldAlignmentInBits == 0 || 1741 ExplicitFieldAlign <= MaxFieldAlignmentInBits) && 1742 Context.getTargetInfo().useExplicitBitFieldAlignment()) { 1743 // TODO: figure it out what needs to be done on targets that don't honor 1744 // bit-field type alignment like ARM APCS ABI. 1745 FieldOffset = llvm::alignTo(FieldOffset, ExplicitFieldAlign); 1746 } 1747 1748 // Repeat the computation for diagnostic purposes. 1749 if (FieldSize == 0 || 1750 (AllowPadding && 1751 (UnpackedFieldOffset & (UnpackedFieldAlign - 1)) + FieldSize > 1752 StorageUnitSize)) 1753 UnpackedFieldOffset = 1754 llvm::alignTo(UnpackedFieldOffset, UnpackedFieldAlign); 1755 else if (ExplicitFieldAlign && 1756 (MaxFieldAlignmentInBits == 0 || 1757 ExplicitFieldAlign <= MaxFieldAlignmentInBits) && 1758 Context.getTargetInfo().useExplicitBitFieldAlignment()) 1759 UnpackedFieldOffset = 1760 llvm::alignTo(UnpackedFieldOffset, ExplicitFieldAlign); 1761 } 1762 1763 // If we're using external layout, give the external layout a chance 1764 // to override this information. 1765 if (UseExternalLayout) 1766 FieldOffset = updateExternalFieldOffset(D, FieldOffset); 1767 1768 // Okay, place the bitfield at the calculated offset. 1769 FieldOffsets.push_back(FieldOffset); 1770 1771 // Bookkeeping: 1772 1773 // Anonymous members don't affect the overall record alignment, 1774 // except on targets where they do. 1775 if (!IsMsStruct && 1776 !Context.getTargetInfo().useZeroLengthBitfieldAlignment() && 1777 !D->getIdentifier()) 1778 FieldAlign = UnpackedFieldAlign = 1; 1779 1780 // On AIX, zero-width bitfields pad out to the natural alignment boundary, 1781 // but do not increase the alignment greater than the MaxFieldAlignment, or 1 1782 // if packed. 1783 if (isAIXLayout(Context) && !FieldSize) { 1784 if (FieldPacked) 1785 FieldAlign = 1; 1786 if (!MaxFieldAlignment.isZero()) { 1787 UnpackedFieldAlign = 1788 std::min(UnpackedFieldAlign, MaxFieldAlignmentInBits); 1789 FieldAlign = std::min(FieldAlign, MaxFieldAlignmentInBits); 1790 } 1791 } 1792 1793 // Diagnose differences in layout due to padding or packing. 1794 if (!UseExternalLayout) 1795 CheckFieldPadding(FieldOffset, UnpaddedFieldOffset, UnpackedFieldOffset, 1796 UnpackedFieldAlign, FieldPacked, D); 1797 1798 // Update DataSize to include the last byte containing (part of) the bitfield. 1799 1800 // For unions, this is just a max operation, as usual. 1801 if (IsUnion) { 1802 // For ms_struct, allocate the entire storage unit --- unless this 1803 // is a zero-width bitfield, in which case just use a size of 1. 1804 uint64_t RoundedFieldSize; 1805 if (IsMsStruct) { 1806 RoundedFieldSize = (FieldSize ? StorageUnitSize 1807 : Context.getTargetInfo().getCharWidth()); 1808 1809 // Otherwise, allocate just the number of bytes required to store 1810 // the bitfield. 1811 } else { 1812 RoundedFieldSize = roundUpSizeToCharAlignment(FieldSize, Context); 1813 } 1814 setDataSize(std::max(getDataSizeInBits(), RoundedFieldSize)); 1815 1816 // For non-zero-width bitfields in ms_struct structs, allocate a new 1817 // storage unit if necessary. 1818 } else if (IsMsStruct && FieldSize) { 1819 // We should have cleared UnfilledBitsInLastUnit in every case 1820 // where we changed storage units. 1821 if (!UnfilledBitsInLastUnit) { 1822 setDataSize(FieldOffset + StorageUnitSize); 1823 UnfilledBitsInLastUnit = StorageUnitSize; 1824 } 1825 UnfilledBitsInLastUnit -= FieldSize; 1826 LastBitfieldStorageUnitSize = StorageUnitSize; 1827 1828 // Otherwise, bump the data size up to include the bitfield, 1829 // including padding up to char alignment, and then remember how 1830 // bits we didn't use. 1831 } else { 1832 uint64_t NewSizeInBits = FieldOffset + FieldSize; 1833 uint64_t CharAlignment = Context.getTargetInfo().getCharAlign(); 1834 setDataSize(llvm::alignTo(NewSizeInBits, CharAlignment)); 1835 UnfilledBitsInLastUnit = getDataSizeInBits() - NewSizeInBits; 1836 1837 // The only time we can get here for an ms_struct is if this is a 1838 // zero-width bitfield, which doesn't count as anything for the 1839 // purposes of unfilled bits. 1840 LastBitfieldStorageUnitSize = 0; 1841 } 1842 1843 // Update the size. 1844 setSize(std::max(getSizeInBits(), getDataSizeInBits())); 1845 1846 // Remember max struct/class alignment. 1847 UnadjustedAlignment = 1848 std::max(UnadjustedAlignment, Context.toCharUnitsFromBits(FieldAlign)); 1849 UpdateAlignment(Context.toCharUnitsFromBits(FieldAlign), 1850 Context.toCharUnitsFromBits(UnpackedFieldAlign)); 1851 } 1852 1853 void ItaniumRecordLayoutBuilder::LayoutField(const FieldDecl *D, 1854 bool InsertExtraPadding) { 1855 auto *FieldClass = D->getType()->getAsCXXRecordDecl(); 1856 bool PotentiallyOverlapping = D->hasAttr<NoUniqueAddressAttr>() && FieldClass; 1857 bool IsOverlappingEmptyField = 1858 PotentiallyOverlapping && FieldClass->isEmpty(); 1859 1860 CharUnits FieldOffset = 1861 (IsUnion || IsOverlappingEmptyField) ? CharUnits::Zero() : getDataSize(); 1862 1863 const bool DefaultsToAIXPowerAlignment = 1864 Context.getTargetInfo().defaultsToAIXPowerAlignment(); 1865 bool FoundFirstNonOverlappingEmptyFieldForAIX = false; 1866 if (DefaultsToAIXPowerAlignment && !HandledFirstNonOverlappingEmptyField) { 1867 assert(FieldOffset == CharUnits::Zero() && 1868 "The first non-overlapping empty field should have been handled."); 1869 1870 if (!IsOverlappingEmptyField) { 1871 FoundFirstNonOverlappingEmptyFieldForAIX = true; 1872 1873 // We're going to handle the "first member" based on 1874 // `FoundFirstNonOverlappingEmptyFieldForAIX` during the current 1875 // invocation of this function; record it as handled for future 1876 // invocations (except for unions, because the current field does not 1877 // represent all "firsts"). 1878 HandledFirstNonOverlappingEmptyField = !IsUnion; 1879 } 1880 } 1881 1882 if (D->isBitField()) { 1883 LayoutBitField(D); 1884 return; 1885 } 1886 1887 uint64_t UnpaddedFieldOffset = getDataSizeInBits() - UnfilledBitsInLastUnit; 1888 // Reset the unfilled bits. 1889 UnfilledBitsInLastUnit = 0; 1890 LastBitfieldStorageUnitSize = 0; 1891 1892 bool FieldPacked = Packed || D->hasAttr<PackedAttr>(); 1893 1894 AlignRequirementKind AlignRequirement = AlignRequirementKind::None; 1895 CharUnits FieldSize; 1896 CharUnits FieldAlign; 1897 // The amount of this class's dsize occupied by the field. 1898 // This is equal to FieldSize unless we're permitted to pack 1899 // into the field's tail padding. 1900 CharUnits EffectiveFieldSize; 1901 1902 auto setDeclInfo = [&](bool IsIncompleteArrayType) { 1903 auto TI = Context.getTypeInfoInChars(D->getType()); 1904 FieldAlign = TI.Align; 1905 // Flexible array members don't have any size, but they have to be 1906 // aligned appropriately for their element type. 1907 EffectiveFieldSize = FieldSize = 1908 IsIncompleteArrayType ? CharUnits::Zero() : TI.Width; 1909 AlignRequirement = TI.AlignRequirement; 1910 }; 1911 1912 if (D->getType()->isIncompleteArrayType()) { 1913 setDeclInfo(true /* IsIncompleteArrayType */); 1914 } else if (const ReferenceType *RT = D->getType()->getAs<ReferenceType>()) { 1915 unsigned AS = Context.getTargetAddressSpace(RT->getPointeeType()); 1916 EffectiveFieldSize = FieldSize = Context.toCharUnitsFromBits( 1917 Context.getTargetInfo().getPointerWidth(AS)); 1918 FieldAlign = Context.toCharUnitsFromBits( 1919 Context.getTargetInfo().getPointerAlign(AS)); 1920 } else { 1921 setDeclInfo(false /* IsIncompleteArrayType */); 1922 1923 // A potentially-overlapping field occupies its dsize or nvsize, whichever 1924 // is larger. 1925 if (PotentiallyOverlapping) { 1926 const ASTRecordLayout &Layout = Context.getASTRecordLayout(FieldClass); 1927 EffectiveFieldSize = 1928 std::max(Layout.getNonVirtualSize(), Layout.getDataSize()); 1929 } 1930 1931 if (IsMsStruct) { 1932 // If MS bitfield layout is required, figure out what type is being 1933 // laid out and align the field to the width of that type. 1934 1935 // Resolve all typedefs down to their base type and round up the field 1936 // alignment if necessary. 1937 QualType T = Context.getBaseElementType(D->getType()); 1938 if (const BuiltinType *BTy = T->getAs<BuiltinType>()) { 1939 CharUnits TypeSize = Context.getTypeSizeInChars(BTy); 1940 1941 if (!llvm::isPowerOf2_64(TypeSize.getQuantity())) { 1942 assert( 1943 !Context.getTargetInfo().getTriple().isWindowsMSVCEnvironment() && 1944 "Non PowerOf2 size in MSVC mode"); 1945 // Base types with sizes that aren't a power of two don't work 1946 // with the layout rules for MS structs. This isn't an issue in 1947 // MSVC itself since there are no such base data types there. 1948 // On e.g. x86_32 mingw and linux, long double is 12 bytes though. 1949 // Any structs involving that data type obviously can't be ABI 1950 // compatible with MSVC regardless of how it is laid out. 1951 1952 // Since ms_struct can be mass enabled (via a pragma or via the 1953 // -mms-bitfields command line parameter), this can trigger for 1954 // structs that don't actually need MSVC compatibility, so we 1955 // need to be able to sidestep the ms_struct layout for these types. 1956 1957 // Since the combination of -mms-bitfields together with structs 1958 // like max_align_t (which contains a long double) for mingw is 1959 // quite common (and GCC handles it silently), just handle it 1960 // silently there. For other targets that have ms_struct enabled 1961 // (most probably via a pragma or attribute), trigger a diagnostic 1962 // that defaults to an error. 1963 if (!Context.getTargetInfo().getTriple().isWindowsGNUEnvironment()) 1964 Diag(D->getLocation(), diag::warn_npot_ms_struct); 1965 } 1966 if (TypeSize > FieldAlign && 1967 llvm::isPowerOf2_64(TypeSize.getQuantity())) 1968 FieldAlign = TypeSize; 1969 } 1970 } 1971 } 1972 1973 // When used as part of a typedef, or together with a 'packed' attribute, the 1974 // 'aligned' attribute can be used to decrease alignment. In that case, it 1975 // overrides any computed alignment we have, and there is no need to upgrade 1976 // the alignment. 1977 auto alignedAttrCanDecreaseAIXAlignment = [AlignRequirement, FieldPacked] { 1978 // Enum alignment sources can be safely ignored here, because this only 1979 // helps decide whether we need the AIX alignment upgrade, which only 1980 // applies to floating-point types. 1981 return AlignRequirement == AlignRequirementKind::RequiredByTypedef || 1982 (AlignRequirement == AlignRequirementKind::RequiredByRecord && 1983 FieldPacked); 1984 }; 1985 1986 // The AIX `power` alignment rules apply the natural alignment of the 1987 // "first member" if it is of a floating-point data type (or is an aggregate 1988 // whose recursively "first" member or element is such a type). The alignment 1989 // associated with these types for subsequent members use an alignment value 1990 // where the floating-point data type is considered to have 4-byte alignment. 1991 // 1992 // For the purposes of the foregoing: vtable pointers, non-empty base classes, 1993 // and zero-width bit-fields count as prior members; members of empty class 1994 // types marked `no_unique_address` are not considered to be prior members. 1995 CharUnits PreferredAlign = FieldAlign; 1996 if (DefaultsToAIXPowerAlignment && !alignedAttrCanDecreaseAIXAlignment() && 1997 (FoundFirstNonOverlappingEmptyFieldForAIX || IsNaturalAlign)) { 1998 auto performBuiltinTypeAlignmentUpgrade = [&](const BuiltinType *BTy) { 1999 if (BTy->getKind() == BuiltinType::Double || 2000 BTy->getKind() == BuiltinType::LongDouble) { 2001 assert(PreferredAlign == CharUnits::fromQuantity(4) && 2002 "No need to upgrade the alignment value."); 2003 PreferredAlign = CharUnits::fromQuantity(8); 2004 } 2005 }; 2006 2007 const Type *BaseTy = D->getType()->getBaseElementTypeUnsafe(); 2008 if (const ComplexType *CTy = BaseTy->getAs<ComplexType>()) { 2009 performBuiltinTypeAlignmentUpgrade( 2010 CTy->getElementType()->castAs<BuiltinType>()); 2011 } else if (const BuiltinType *BTy = BaseTy->getAs<BuiltinType>()) { 2012 performBuiltinTypeAlignmentUpgrade(BTy); 2013 } else if (const RecordType *RT = BaseTy->getAs<RecordType>()) { 2014 const RecordDecl *RD = RT->getDecl(); 2015 assert(RD && "Expected non-null RecordDecl."); 2016 const ASTRecordLayout &FieldRecord = Context.getASTRecordLayout(RD); 2017 PreferredAlign = FieldRecord.getPreferredAlignment(); 2018 } 2019 } 2020 2021 // The align if the field is not packed. This is to check if the attribute 2022 // was unnecessary (-Wpacked). 2023 CharUnits UnpackedFieldAlign = 2024 !DefaultsToAIXPowerAlignment ? FieldAlign : PreferredAlign; 2025 CharUnits UnpackedFieldOffset = FieldOffset; 2026 CharUnits OriginalFieldAlign = UnpackedFieldAlign; 2027 2028 if (FieldPacked) { 2029 FieldAlign = CharUnits::One(); 2030 PreferredAlign = CharUnits::One(); 2031 } 2032 CharUnits MaxAlignmentInChars = 2033 Context.toCharUnitsFromBits(D->getMaxAlignment()); 2034 FieldAlign = std::max(FieldAlign, MaxAlignmentInChars); 2035 PreferredAlign = std::max(PreferredAlign, MaxAlignmentInChars); 2036 UnpackedFieldAlign = std::max(UnpackedFieldAlign, MaxAlignmentInChars); 2037 2038 // The maximum field alignment overrides the aligned attribute. 2039 if (!MaxFieldAlignment.isZero()) { 2040 FieldAlign = std::min(FieldAlign, MaxFieldAlignment); 2041 PreferredAlign = std::min(PreferredAlign, MaxFieldAlignment); 2042 UnpackedFieldAlign = std::min(UnpackedFieldAlign, MaxFieldAlignment); 2043 } 2044 2045 CharUnits AlignTo = 2046 !DefaultsToAIXPowerAlignment ? FieldAlign : PreferredAlign; 2047 // Round up the current record size to the field's alignment boundary. 2048 FieldOffset = FieldOffset.alignTo(AlignTo); 2049 UnpackedFieldOffset = UnpackedFieldOffset.alignTo(UnpackedFieldAlign); 2050 2051 if (UseExternalLayout) { 2052 FieldOffset = Context.toCharUnitsFromBits( 2053 updateExternalFieldOffset(D, Context.toBits(FieldOffset))); 2054 2055 if (!IsUnion && EmptySubobjects) { 2056 // Record the fact that we're placing a field at this offset. 2057 bool Allowed = EmptySubobjects->CanPlaceFieldAtOffset(D, FieldOffset); 2058 (void)Allowed; 2059 assert(Allowed && "Externally-placed field cannot be placed here"); 2060 } 2061 } else { 2062 if (!IsUnion && EmptySubobjects) { 2063 // Check if we can place the field at this offset. 2064 while (!EmptySubobjects->CanPlaceFieldAtOffset(D, FieldOffset)) { 2065 // We couldn't place the field at the offset. Try again at a new offset. 2066 // We try offset 0 (for an empty field) and then dsize(C) onwards. 2067 if (FieldOffset == CharUnits::Zero() && 2068 getDataSize() != CharUnits::Zero()) 2069 FieldOffset = getDataSize().alignTo(AlignTo); 2070 else 2071 FieldOffset += AlignTo; 2072 } 2073 } 2074 } 2075 2076 // Place this field at the current location. 2077 FieldOffsets.push_back(Context.toBits(FieldOffset)); 2078 2079 if (!UseExternalLayout) 2080 CheckFieldPadding(Context.toBits(FieldOffset), UnpaddedFieldOffset, 2081 Context.toBits(UnpackedFieldOffset), 2082 Context.toBits(UnpackedFieldAlign), FieldPacked, D); 2083 2084 if (InsertExtraPadding) { 2085 CharUnits ASanAlignment = CharUnits::fromQuantity(8); 2086 CharUnits ExtraSizeForAsan = ASanAlignment; 2087 if (FieldSize % ASanAlignment) 2088 ExtraSizeForAsan += 2089 ASanAlignment - CharUnits::fromQuantity(FieldSize % ASanAlignment); 2090 EffectiveFieldSize = FieldSize = FieldSize + ExtraSizeForAsan; 2091 } 2092 2093 // Reserve space for this field. 2094 if (!IsOverlappingEmptyField) { 2095 uint64_t EffectiveFieldSizeInBits = Context.toBits(EffectiveFieldSize); 2096 if (IsUnion) 2097 setDataSize(std::max(getDataSizeInBits(), EffectiveFieldSizeInBits)); 2098 else 2099 setDataSize(FieldOffset + EffectiveFieldSize); 2100 2101 PaddedFieldSize = std::max(PaddedFieldSize, FieldOffset + FieldSize); 2102 setSize(std::max(getSizeInBits(), getDataSizeInBits())); 2103 } else { 2104 setSize(std::max(getSizeInBits(), 2105 (uint64_t)Context.toBits(FieldOffset + FieldSize))); 2106 } 2107 2108 // Remember max struct/class ABI-specified alignment. 2109 UnadjustedAlignment = std::max(UnadjustedAlignment, FieldAlign); 2110 UpdateAlignment(FieldAlign, UnpackedFieldAlign, PreferredAlign); 2111 2112 // For checking the alignment of inner fields against 2113 // the alignment of its parent record. 2114 if (const RecordDecl *RD = D->getParent()) { 2115 // Check if packed attribute or pragma pack is present. 2116 if (RD->hasAttr<PackedAttr>() || !MaxFieldAlignment.isZero()) 2117 if (FieldAlign < OriginalFieldAlign) 2118 if (D->getType()->isRecordType()) { 2119 // If the offset is a multiple of the alignment of 2120 // the type, raise the warning. 2121 // TODO: Takes no account the alignment of the outer struct 2122 if (FieldOffset % OriginalFieldAlign != 0) 2123 Diag(D->getLocation(), diag::warn_unaligned_access) 2124 << Context.getTypeDeclType(RD) << D->getName() << D->getType(); 2125 } 2126 } 2127 } 2128 2129 void ItaniumRecordLayoutBuilder::FinishLayout(const NamedDecl *D) { 2130 // In C++, records cannot be of size 0. 2131 if (Context.getLangOpts().CPlusPlus && getSizeInBits() == 0) { 2132 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) { 2133 // Compatibility with gcc requires a class (pod or non-pod) 2134 // which is not empty but of size 0; such as having fields of 2135 // array of zero-length, remains of Size 0 2136 if (RD->isEmpty()) 2137 setSize(CharUnits::One()); 2138 } 2139 else 2140 setSize(CharUnits::One()); 2141 } 2142 2143 // If we have any remaining field tail padding, include that in the overall 2144 // size. 2145 setSize(std::max(getSizeInBits(), (uint64_t)Context.toBits(PaddedFieldSize))); 2146 2147 // Finally, round the size of the record up to the alignment of the 2148 // record itself. 2149 uint64_t UnpaddedSize = getSizeInBits() - UnfilledBitsInLastUnit; 2150 uint64_t UnpackedSizeInBits = 2151 llvm::alignTo(getSizeInBits(), Context.toBits(UnpackedAlignment)); 2152 2153 uint64_t RoundedSize = llvm::alignTo( 2154 getSizeInBits(), 2155 Context.toBits(!Context.getTargetInfo().defaultsToAIXPowerAlignment() 2156 ? Alignment 2157 : PreferredAlignment)); 2158 2159 if (UseExternalLayout) { 2160 // If we're inferring alignment, and the external size is smaller than 2161 // our size after we've rounded up to alignment, conservatively set the 2162 // alignment to 1. 2163 if (InferAlignment && External.Size < RoundedSize) { 2164 Alignment = CharUnits::One(); 2165 PreferredAlignment = CharUnits::One(); 2166 InferAlignment = false; 2167 } 2168 setSize(External.Size); 2169 return; 2170 } 2171 2172 // Set the size to the final size. 2173 setSize(RoundedSize); 2174 2175 unsigned CharBitNum = Context.getTargetInfo().getCharWidth(); 2176 if (const RecordDecl *RD = dyn_cast<RecordDecl>(D)) { 2177 // Warn if padding was introduced to the struct/class/union. 2178 if (getSizeInBits() > UnpaddedSize) { 2179 unsigned PadSize = getSizeInBits() - UnpaddedSize; 2180 bool InBits = true; 2181 if (PadSize % CharBitNum == 0) { 2182 PadSize = PadSize / CharBitNum; 2183 InBits = false; 2184 } 2185 Diag(RD->getLocation(), diag::warn_padded_struct_size) 2186 << Context.getTypeDeclType(RD) 2187 << PadSize 2188 << (InBits ? 1 : 0); // (byte|bit) 2189 } 2190 2191 // Warn if we packed it unnecessarily, when the unpacked alignment is not 2192 // greater than the one after packing, the size in bits doesn't change and 2193 // the offset of each field is identical. 2194 if (Packed && UnpackedAlignment <= Alignment && 2195 UnpackedSizeInBits == getSizeInBits() && !HasPackedField) 2196 Diag(D->getLocation(), diag::warn_unnecessary_packed) 2197 << Context.getTypeDeclType(RD); 2198 } 2199 } 2200 2201 void ItaniumRecordLayoutBuilder::UpdateAlignment( 2202 CharUnits NewAlignment, CharUnits UnpackedNewAlignment, 2203 CharUnits PreferredNewAlignment) { 2204 // The alignment is not modified when using 'mac68k' alignment or when 2205 // we have an externally-supplied layout that also provides overall alignment. 2206 if (IsMac68kAlign || (UseExternalLayout && !InferAlignment)) 2207 return; 2208 2209 if (NewAlignment > Alignment) { 2210 assert(llvm::isPowerOf2_64(NewAlignment.getQuantity()) && 2211 "Alignment not a power of 2"); 2212 Alignment = NewAlignment; 2213 } 2214 2215 if (UnpackedNewAlignment > UnpackedAlignment) { 2216 assert(llvm::isPowerOf2_64(UnpackedNewAlignment.getQuantity()) && 2217 "Alignment not a power of 2"); 2218 UnpackedAlignment = UnpackedNewAlignment; 2219 } 2220 2221 if (PreferredNewAlignment > PreferredAlignment) { 2222 assert(llvm::isPowerOf2_64(PreferredNewAlignment.getQuantity()) && 2223 "Alignment not a power of 2"); 2224 PreferredAlignment = PreferredNewAlignment; 2225 } 2226 } 2227 2228 uint64_t 2229 ItaniumRecordLayoutBuilder::updateExternalFieldOffset(const FieldDecl *Field, 2230 uint64_t ComputedOffset) { 2231 uint64_t ExternalFieldOffset = External.getExternalFieldOffset(Field); 2232 2233 if (InferAlignment && ExternalFieldOffset < ComputedOffset) { 2234 // The externally-supplied field offset is before the field offset we 2235 // computed. Assume that the structure is packed. 2236 Alignment = CharUnits::One(); 2237 PreferredAlignment = CharUnits::One(); 2238 InferAlignment = false; 2239 } 2240 2241 // Use the externally-supplied field offset. 2242 return ExternalFieldOffset; 2243 } 2244 2245 /// Get diagnostic %select index for tag kind for 2246 /// field padding diagnostic message. 2247 /// WARNING: Indexes apply to particular diagnostics only! 2248 /// 2249 /// \returns diagnostic %select index. 2250 static unsigned getPaddingDiagFromTagKind(TagTypeKind Tag) { 2251 switch (Tag) { 2252 case TTK_Struct: return 0; 2253 case TTK_Interface: return 1; 2254 case TTK_Class: return 2; 2255 default: llvm_unreachable("Invalid tag kind for field padding diagnostic!"); 2256 } 2257 } 2258 2259 void ItaniumRecordLayoutBuilder::CheckFieldPadding( 2260 uint64_t Offset, uint64_t UnpaddedOffset, uint64_t UnpackedOffset, 2261 unsigned UnpackedAlign, bool isPacked, const FieldDecl *D) { 2262 // We let objc ivars without warning, objc interfaces generally are not used 2263 // for padding tricks. 2264 if (isa<ObjCIvarDecl>(D)) 2265 return; 2266 2267 // Don't warn about structs created without a SourceLocation. This can 2268 // be done by clients of the AST, such as codegen. 2269 if (D->getLocation().isInvalid()) 2270 return; 2271 2272 unsigned CharBitNum = Context.getTargetInfo().getCharWidth(); 2273 2274 // Warn if padding was introduced to the struct/class. 2275 if (!IsUnion && Offset > UnpaddedOffset) { 2276 unsigned PadSize = Offset - UnpaddedOffset; 2277 bool InBits = true; 2278 if (PadSize % CharBitNum == 0) { 2279 PadSize = PadSize / CharBitNum; 2280 InBits = false; 2281 } 2282 if (D->getIdentifier()) 2283 Diag(D->getLocation(), diag::warn_padded_struct_field) 2284 << getPaddingDiagFromTagKind(D->getParent()->getTagKind()) 2285 << Context.getTypeDeclType(D->getParent()) 2286 << PadSize 2287 << (InBits ? 1 : 0) // (byte|bit) 2288 << D->getIdentifier(); 2289 else 2290 Diag(D->getLocation(), diag::warn_padded_struct_anon_field) 2291 << getPaddingDiagFromTagKind(D->getParent()->getTagKind()) 2292 << Context.getTypeDeclType(D->getParent()) 2293 << PadSize 2294 << (InBits ? 1 : 0); // (byte|bit) 2295 } 2296 if (isPacked && Offset != UnpackedOffset) { 2297 HasPackedField = true; 2298 } 2299 } 2300 2301 static const CXXMethodDecl *computeKeyFunction(ASTContext &Context, 2302 const CXXRecordDecl *RD) { 2303 // If a class isn't polymorphic it doesn't have a key function. 2304 if (!RD->isPolymorphic()) 2305 return nullptr; 2306 2307 // A class that is not externally visible doesn't have a key function. (Or 2308 // at least, there's no point to assigning a key function to such a class; 2309 // this doesn't affect the ABI.) 2310 if (!RD->isExternallyVisible()) 2311 return nullptr; 2312 2313 // Template instantiations don't have key functions per Itanium C++ ABI 5.2.6. 2314 // Same behavior as GCC. 2315 TemplateSpecializationKind TSK = RD->getTemplateSpecializationKind(); 2316 if (TSK == TSK_ImplicitInstantiation || 2317 TSK == TSK_ExplicitInstantiationDeclaration || 2318 TSK == TSK_ExplicitInstantiationDefinition) 2319 return nullptr; 2320 2321 bool allowInlineFunctions = 2322 Context.getTargetInfo().getCXXABI().canKeyFunctionBeInline(); 2323 2324 for (const CXXMethodDecl *MD : RD->methods()) { 2325 if (!MD->isVirtual()) 2326 continue; 2327 2328 if (MD->isPure()) 2329 continue; 2330 2331 // Ignore implicit member functions, they are always marked as inline, but 2332 // they don't have a body until they're defined. 2333 if (MD->isImplicit()) 2334 continue; 2335 2336 if (MD->isInlineSpecified() || MD->isConstexpr()) 2337 continue; 2338 2339 if (MD->hasInlineBody()) 2340 continue; 2341 2342 // Ignore inline deleted or defaulted functions. 2343 if (!MD->isUserProvided()) 2344 continue; 2345 2346 // In certain ABIs, ignore functions with out-of-line inline definitions. 2347 if (!allowInlineFunctions) { 2348 const FunctionDecl *Def; 2349 if (MD->hasBody(Def) && Def->isInlineSpecified()) 2350 continue; 2351 } 2352 2353 if (Context.getLangOpts().CUDA) { 2354 // While compiler may see key method in this TU, during CUDA 2355 // compilation we should ignore methods that are not accessible 2356 // on this side of compilation. 2357 if (Context.getLangOpts().CUDAIsDevice) { 2358 // In device mode ignore methods without __device__ attribute. 2359 if (!MD->hasAttr<CUDADeviceAttr>()) 2360 continue; 2361 } else { 2362 // In host mode ignore __device__-only methods. 2363 if (!MD->hasAttr<CUDAHostAttr>() && MD->hasAttr<CUDADeviceAttr>()) 2364 continue; 2365 } 2366 } 2367 2368 // If the key function is dllimport but the class isn't, then the class has 2369 // no key function. The DLL that exports the key function won't export the 2370 // vtable in this case. 2371 if (MD->hasAttr<DLLImportAttr>() && !RD->hasAttr<DLLImportAttr>() && 2372 !Context.getTargetInfo().hasPS4DLLImportExport()) 2373 return nullptr; 2374 2375 // We found it. 2376 return MD; 2377 } 2378 2379 return nullptr; 2380 } 2381 2382 DiagnosticBuilder ItaniumRecordLayoutBuilder::Diag(SourceLocation Loc, 2383 unsigned DiagID) { 2384 return Context.getDiagnostics().Report(Loc, DiagID); 2385 } 2386 2387 /// Does the target C++ ABI require us to skip over the tail-padding 2388 /// of the given class (considering it as a base class) when allocating 2389 /// objects? 2390 static bool mustSkipTailPadding(TargetCXXABI ABI, const CXXRecordDecl *RD) { 2391 switch (ABI.getTailPaddingUseRules()) { 2392 case TargetCXXABI::AlwaysUseTailPadding: 2393 return false; 2394 2395 case TargetCXXABI::UseTailPaddingUnlessPOD03: 2396 // FIXME: To the extent that this is meant to cover the Itanium ABI 2397 // rules, we should implement the restrictions about over-sized 2398 // bitfields: 2399 // 2400 // http://itanium-cxx-abi.github.io/cxx-abi/abi.html#POD : 2401 // In general, a type is considered a POD for the purposes of 2402 // layout if it is a POD type (in the sense of ISO C++ 2403 // [basic.types]). However, a POD-struct or POD-union (in the 2404 // sense of ISO C++ [class]) with a bitfield member whose 2405 // declared width is wider than the declared type of the 2406 // bitfield is not a POD for the purpose of layout. Similarly, 2407 // an array type is not a POD for the purpose of layout if the 2408 // element type of the array is not a POD for the purpose of 2409 // layout. 2410 // 2411 // Where references to the ISO C++ are made in this paragraph, 2412 // the Technical Corrigendum 1 version of the standard is 2413 // intended. 2414 return RD->isPOD(); 2415 2416 case TargetCXXABI::UseTailPaddingUnlessPOD11: 2417 // This is equivalent to RD->getTypeForDecl().isCXX11PODType(), 2418 // but with a lot of abstraction penalty stripped off. This does 2419 // assume that these properties are set correctly even in C++98 2420 // mode; fortunately, that is true because we want to assign 2421 // consistently semantics to the type-traits intrinsics (or at 2422 // least as many of them as possible). 2423 return RD->isTrivial() && RD->isCXX11StandardLayout(); 2424 } 2425 2426 llvm_unreachable("bad tail-padding use kind"); 2427 } 2428 2429 static bool isMsLayout(const ASTContext &Context) { 2430 return Context.getTargetInfo().getCXXABI().isMicrosoft(); 2431 } 2432 2433 // This section contains an implementation of struct layout that is, up to the 2434 // included tests, compatible with cl.exe (2013). The layout produced is 2435 // significantly different than those produced by the Itanium ABI. Here we note 2436 // the most important differences. 2437 // 2438 // * The alignment of bitfields in unions is ignored when computing the 2439 // alignment of the union. 2440 // * The existence of zero-width bitfield that occurs after anything other than 2441 // a non-zero length bitfield is ignored. 2442 // * There is no explicit primary base for the purposes of layout. All bases 2443 // with vfptrs are laid out first, followed by all bases without vfptrs. 2444 // * The Itanium equivalent vtable pointers are split into a vfptr (virtual 2445 // function pointer) and a vbptr (virtual base pointer). They can each be 2446 // shared with a, non-virtual bases. These bases need not be the same. vfptrs 2447 // always occur at offset 0. vbptrs can occur at an arbitrary offset and are 2448 // placed after the lexicographically last non-virtual base. This placement 2449 // is always before fields but can be in the middle of the non-virtual bases 2450 // due to the two-pass layout scheme for non-virtual-bases. 2451 // * Virtual bases sometimes require a 'vtordisp' field that is laid out before 2452 // the virtual base and is used in conjunction with virtual overrides during 2453 // construction and destruction. This is always a 4 byte value and is used as 2454 // an alternative to constructor vtables. 2455 // * vtordisps are allocated in a block of memory with size and alignment equal 2456 // to the alignment of the completed structure (before applying __declspec( 2457 // align())). The vtordisp always occur at the end of the allocation block, 2458 // immediately prior to the virtual base. 2459 // * vfptrs are injected after all bases and fields have been laid out. In 2460 // order to guarantee proper alignment of all fields, the vfptr injection 2461 // pushes all bases and fields back by the alignment imposed by those bases 2462 // and fields. This can potentially add a significant amount of padding. 2463 // vfptrs are always injected at offset 0. 2464 // * vbptrs are injected after all bases and fields have been laid out. In 2465 // order to guarantee proper alignment of all fields, the vfptr injection 2466 // pushes all bases and fields back by the alignment imposed by those bases 2467 // and fields. This can potentially add a significant amount of padding. 2468 // vbptrs are injected immediately after the last non-virtual base as 2469 // lexicographically ordered in the code. If this site isn't pointer aligned 2470 // the vbptr is placed at the next properly aligned location. Enough padding 2471 // is added to guarantee a fit. 2472 // * The last zero sized non-virtual base can be placed at the end of the 2473 // struct (potentially aliasing another object), or may alias with the first 2474 // field, even if they are of the same type. 2475 // * The last zero size virtual base may be placed at the end of the struct 2476 // potentially aliasing another object. 2477 // * The ABI attempts to avoid aliasing of zero sized bases by adding padding 2478 // between bases or vbases with specific properties. The criteria for 2479 // additional padding between two bases is that the first base is zero sized 2480 // or ends with a zero sized subobject and the second base is zero sized or 2481 // trails with a zero sized base or field (sharing of vfptrs can reorder the 2482 // layout of the so the leading base is not always the first one declared). 2483 // This rule does take into account fields that are not records, so padding 2484 // will occur even if the last field is, e.g. an int. The padding added for 2485 // bases is 1 byte. The padding added between vbases depends on the alignment 2486 // of the object but is at least 4 bytes (in both 32 and 64 bit modes). 2487 // * There is no concept of non-virtual alignment, non-virtual alignment and 2488 // alignment are always identical. 2489 // * There is a distinction between alignment and required alignment. 2490 // __declspec(align) changes the required alignment of a struct. This 2491 // alignment is _always_ obeyed, even in the presence of #pragma pack. A 2492 // record inherits required alignment from all of its fields and bases. 2493 // * __declspec(align) on bitfields has the effect of changing the bitfield's 2494 // alignment instead of its required alignment. This is the only known way 2495 // to make the alignment of a struct bigger than 8. Interestingly enough 2496 // this alignment is also immune to the effects of #pragma pack and can be 2497 // used to create structures with large alignment under #pragma pack. 2498 // However, because it does not impact required alignment, such a structure, 2499 // when used as a field or base, will not be aligned if #pragma pack is 2500 // still active at the time of use. 2501 // 2502 // Known incompatibilities: 2503 // * all: #pragma pack between fields in a record 2504 // * 2010 and back: If the last field in a record is a bitfield, every object 2505 // laid out after the record will have extra padding inserted before it. The 2506 // extra padding will have size equal to the size of the storage class of the 2507 // bitfield. 0 sized bitfields don't exhibit this behavior and the extra 2508 // padding can be avoided by adding a 0 sized bitfield after the non-zero- 2509 // sized bitfield. 2510 // * 2012 and back: In 64-bit mode, if the alignment of a record is 16 or 2511 // greater due to __declspec(align()) then a second layout phase occurs after 2512 // The locations of the vf and vb pointers are known. This layout phase 2513 // suffers from the "last field is a bitfield" bug in 2010 and results in 2514 // _every_ field getting padding put in front of it, potentially including the 2515 // vfptr, leaving the vfprt at a non-zero location which results in a fault if 2516 // anything tries to read the vftbl. The second layout phase also treats 2517 // bitfields as separate entities and gives them each storage rather than 2518 // packing them. Additionally, because this phase appears to perform a 2519 // (an unstable) sort on the members before laying them out and because merged 2520 // bitfields have the same address, the bitfields end up in whatever order 2521 // the sort left them in, a behavior we could never hope to replicate. 2522 2523 namespace { 2524 struct MicrosoftRecordLayoutBuilder { 2525 struct ElementInfo { 2526 CharUnits Size; 2527 CharUnits Alignment; 2528 }; 2529 typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetsMapTy; 2530 MicrosoftRecordLayoutBuilder(const ASTContext &Context) : Context(Context) {} 2531 private: 2532 MicrosoftRecordLayoutBuilder(const MicrosoftRecordLayoutBuilder &) = delete; 2533 void operator=(const MicrosoftRecordLayoutBuilder &) = delete; 2534 public: 2535 void layout(const RecordDecl *RD); 2536 void cxxLayout(const CXXRecordDecl *RD); 2537 /// Initializes size and alignment and honors some flags. 2538 void initializeLayout(const RecordDecl *RD); 2539 /// Initialized C++ layout, compute alignment and virtual alignment and 2540 /// existence of vfptrs and vbptrs. Alignment is needed before the vfptr is 2541 /// laid out. 2542 void initializeCXXLayout(const CXXRecordDecl *RD); 2543 void layoutNonVirtualBases(const CXXRecordDecl *RD); 2544 void layoutNonVirtualBase(const CXXRecordDecl *RD, 2545 const CXXRecordDecl *BaseDecl, 2546 const ASTRecordLayout &BaseLayout, 2547 const ASTRecordLayout *&PreviousBaseLayout); 2548 void injectVFPtr(const CXXRecordDecl *RD); 2549 void injectVBPtr(const CXXRecordDecl *RD); 2550 /// Lays out the fields of the record. Also rounds size up to 2551 /// alignment. 2552 void layoutFields(const RecordDecl *RD); 2553 void layoutField(const FieldDecl *FD); 2554 void layoutBitField(const FieldDecl *FD); 2555 /// Lays out a single zero-width bit-field in the record and handles 2556 /// special cases associated with zero-width bit-fields. 2557 void layoutZeroWidthBitField(const FieldDecl *FD); 2558 void layoutVirtualBases(const CXXRecordDecl *RD); 2559 void finalizeLayout(const RecordDecl *RD); 2560 /// Gets the size and alignment of a base taking pragma pack and 2561 /// __declspec(align) into account. 2562 ElementInfo getAdjustedElementInfo(const ASTRecordLayout &Layout); 2563 /// Gets the size and alignment of a field taking pragma pack and 2564 /// __declspec(align) into account. It also updates RequiredAlignment as a 2565 /// side effect because it is most convenient to do so here. 2566 ElementInfo getAdjustedElementInfo(const FieldDecl *FD); 2567 /// Places a field at an offset in CharUnits. 2568 void placeFieldAtOffset(CharUnits FieldOffset) { 2569 FieldOffsets.push_back(Context.toBits(FieldOffset)); 2570 } 2571 /// Places a bitfield at a bit offset. 2572 void placeFieldAtBitOffset(uint64_t FieldOffset) { 2573 FieldOffsets.push_back(FieldOffset); 2574 } 2575 /// Compute the set of virtual bases for which vtordisps are required. 2576 void computeVtorDispSet( 2577 llvm::SmallPtrSetImpl<const CXXRecordDecl *> &HasVtorDispSet, 2578 const CXXRecordDecl *RD) const; 2579 const ASTContext &Context; 2580 /// The size of the record being laid out. 2581 CharUnits Size; 2582 /// The non-virtual size of the record layout. 2583 CharUnits NonVirtualSize; 2584 /// The data size of the record layout. 2585 CharUnits DataSize; 2586 /// The current alignment of the record layout. 2587 CharUnits Alignment; 2588 /// The maximum allowed field alignment. This is set by #pragma pack. 2589 CharUnits MaxFieldAlignment; 2590 /// The alignment that this record must obey. This is imposed by 2591 /// __declspec(align()) on the record itself or one of its fields or bases. 2592 CharUnits RequiredAlignment; 2593 /// The size of the allocation of the currently active bitfield. 2594 /// This value isn't meaningful unless LastFieldIsNonZeroWidthBitfield 2595 /// is true. 2596 CharUnits CurrentBitfieldSize; 2597 /// Offset to the virtual base table pointer (if one exists). 2598 CharUnits VBPtrOffset; 2599 /// Minimum record size possible. 2600 CharUnits MinEmptyStructSize; 2601 /// The size and alignment info of a pointer. 2602 ElementInfo PointerInfo; 2603 /// The primary base class (if one exists). 2604 const CXXRecordDecl *PrimaryBase; 2605 /// The class we share our vb-pointer with. 2606 const CXXRecordDecl *SharedVBPtrBase; 2607 /// The collection of field offsets. 2608 SmallVector<uint64_t, 16> FieldOffsets; 2609 /// Base classes and their offsets in the record. 2610 BaseOffsetsMapTy Bases; 2611 /// virtual base classes and their offsets in the record. 2612 ASTRecordLayout::VBaseOffsetsMapTy VBases; 2613 /// The number of remaining bits in our last bitfield allocation. 2614 /// This value isn't meaningful unless LastFieldIsNonZeroWidthBitfield is 2615 /// true. 2616 unsigned RemainingBitsInField; 2617 bool IsUnion : 1; 2618 /// True if the last field laid out was a bitfield and was not 0 2619 /// width. 2620 bool LastFieldIsNonZeroWidthBitfield : 1; 2621 /// True if the class has its own vftable pointer. 2622 bool HasOwnVFPtr : 1; 2623 /// True if the class has a vbtable pointer. 2624 bool HasVBPtr : 1; 2625 /// True if the last sub-object within the type is zero sized or the 2626 /// object itself is zero sized. This *does not* count members that are not 2627 /// records. Only used for MS-ABI. 2628 bool EndsWithZeroSizedObject : 1; 2629 /// True if this class is zero sized or first base is zero sized or 2630 /// has this property. Only used for MS-ABI. 2631 bool LeadsWithZeroSizedBase : 1; 2632 2633 /// True if the external AST source provided a layout for this record. 2634 bool UseExternalLayout : 1; 2635 2636 /// The layout provided by the external AST source. Only active if 2637 /// UseExternalLayout is true. 2638 ExternalLayout External; 2639 }; 2640 } // namespace 2641 2642 MicrosoftRecordLayoutBuilder::ElementInfo 2643 MicrosoftRecordLayoutBuilder::getAdjustedElementInfo( 2644 const ASTRecordLayout &Layout) { 2645 ElementInfo Info; 2646 Info.Alignment = Layout.getAlignment(); 2647 // Respect pragma pack. 2648 if (!MaxFieldAlignment.isZero()) 2649 Info.Alignment = std::min(Info.Alignment, MaxFieldAlignment); 2650 // Track zero-sized subobjects here where it's already available. 2651 EndsWithZeroSizedObject = Layout.endsWithZeroSizedObject(); 2652 // Respect required alignment, this is necessary because we may have adjusted 2653 // the alignment in the case of pragma pack. Note that the required alignment 2654 // doesn't actually apply to the struct alignment at this point. 2655 Alignment = std::max(Alignment, Info.Alignment); 2656 RequiredAlignment = std::max(RequiredAlignment, Layout.getRequiredAlignment()); 2657 Info.Alignment = std::max(Info.Alignment, Layout.getRequiredAlignment()); 2658 Info.Size = Layout.getNonVirtualSize(); 2659 return Info; 2660 } 2661 2662 MicrosoftRecordLayoutBuilder::ElementInfo 2663 MicrosoftRecordLayoutBuilder::getAdjustedElementInfo( 2664 const FieldDecl *FD) { 2665 // Get the alignment of the field type's natural alignment, ignore any 2666 // alignment attributes. 2667 auto TInfo = 2668 Context.getTypeInfoInChars(FD->getType()->getUnqualifiedDesugaredType()); 2669 ElementInfo Info{TInfo.Width, TInfo.Align}; 2670 // Respect align attributes on the field. 2671 CharUnits FieldRequiredAlignment = 2672 Context.toCharUnitsFromBits(FD->getMaxAlignment()); 2673 // Respect align attributes on the type. 2674 if (Context.isAlignmentRequired(FD->getType())) 2675 FieldRequiredAlignment = std::max( 2676 Context.getTypeAlignInChars(FD->getType()), FieldRequiredAlignment); 2677 // Respect attributes applied to subobjects of the field. 2678 if (FD->isBitField()) 2679 // For some reason __declspec align impacts alignment rather than required 2680 // alignment when it is applied to bitfields. 2681 Info.Alignment = std::max(Info.Alignment, FieldRequiredAlignment); 2682 else { 2683 if (auto RT = 2684 FD->getType()->getBaseElementTypeUnsafe()->getAs<RecordType>()) { 2685 auto const &Layout = Context.getASTRecordLayout(RT->getDecl()); 2686 EndsWithZeroSizedObject = Layout.endsWithZeroSizedObject(); 2687 FieldRequiredAlignment = std::max(FieldRequiredAlignment, 2688 Layout.getRequiredAlignment()); 2689 } 2690 // Capture required alignment as a side-effect. 2691 RequiredAlignment = std::max(RequiredAlignment, FieldRequiredAlignment); 2692 } 2693 // Respect pragma pack, attribute pack and declspec align 2694 if (!MaxFieldAlignment.isZero()) 2695 Info.Alignment = std::min(Info.Alignment, MaxFieldAlignment); 2696 if (FD->hasAttr<PackedAttr>()) 2697 Info.Alignment = CharUnits::One(); 2698 Info.Alignment = std::max(Info.Alignment, FieldRequiredAlignment); 2699 return Info; 2700 } 2701 2702 void MicrosoftRecordLayoutBuilder::layout(const RecordDecl *RD) { 2703 // For C record layout, zero-sized records always have size 4. 2704 MinEmptyStructSize = CharUnits::fromQuantity(4); 2705 initializeLayout(RD); 2706 layoutFields(RD); 2707 DataSize = Size = Size.alignTo(Alignment); 2708 RequiredAlignment = std::max( 2709 RequiredAlignment, Context.toCharUnitsFromBits(RD->getMaxAlignment())); 2710 finalizeLayout(RD); 2711 } 2712 2713 void MicrosoftRecordLayoutBuilder::cxxLayout(const CXXRecordDecl *RD) { 2714 // The C++ standard says that empty structs have size 1. 2715 MinEmptyStructSize = CharUnits::One(); 2716 initializeLayout(RD); 2717 initializeCXXLayout(RD); 2718 layoutNonVirtualBases(RD); 2719 layoutFields(RD); 2720 injectVBPtr(RD); 2721 injectVFPtr(RD); 2722 if (HasOwnVFPtr || (HasVBPtr && !SharedVBPtrBase)) 2723 Alignment = std::max(Alignment, PointerInfo.Alignment); 2724 auto RoundingAlignment = Alignment; 2725 if (!MaxFieldAlignment.isZero()) 2726 RoundingAlignment = std::min(RoundingAlignment, MaxFieldAlignment); 2727 if (!UseExternalLayout) 2728 Size = Size.alignTo(RoundingAlignment); 2729 NonVirtualSize = Size; 2730 RequiredAlignment = std::max( 2731 RequiredAlignment, Context.toCharUnitsFromBits(RD->getMaxAlignment())); 2732 layoutVirtualBases(RD); 2733 finalizeLayout(RD); 2734 } 2735 2736 void MicrosoftRecordLayoutBuilder::initializeLayout(const RecordDecl *RD) { 2737 IsUnion = RD->isUnion(); 2738 Size = CharUnits::Zero(); 2739 Alignment = CharUnits::One(); 2740 // In 64-bit mode we always perform an alignment step after laying out vbases. 2741 // In 32-bit mode we do not. The check to see if we need to perform alignment 2742 // checks the RequiredAlignment field and performs alignment if it isn't 0. 2743 RequiredAlignment = Context.getTargetInfo().getTriple().isArch64Bit() 2744 ? CharUnits::One() 2745 : CharUnits::Zero(); 2746 // Compute the maximum field alignment. 2747 MaxFieldAlignment = CharUnits::Zero(); 2748 // Honor the default struct packing maximum alignment flag. 2749 if (unsigned DefaultMaxFieldAlignment = Context.getLangOpts().PackStruct) 2750 MaxFieldAlignment = CharUnits::fromQuantity(DefaultMaxFieldAlignment); 2751 // Honor the packing attribute. The MS-ABI ignores pragma pack if its larger 2752 // than the pointer size. 2753 if (const MaxFieldAlignmentAttr *MFAA = RD->getAttr<MaxFieldAlignmentAttr>()){ 2754 unsigned PackedAlignment = MFAA->getAlignment(); 2755 if (PackedAlignment <= Context.getTargetInfo().getPointerWidth(0)) 2756 MaxFieldAlignment = Context.toCharUnitsFromBits(PackedAlignment); 2757 } 2758 // Packed attribute forces max field alignment to be 1. 2759 if (RD->hasAttr<PackedAttr>()) 2760 MaxFieldAlignment = CharUnits::One(); 2761 2762 // Try to respect the external layout if present. 2763 UseExternalLayout = false; 2764 if (ExternalASTSource *Source = Context.getExternalSource()) 2765 UseExternalLayout = Source->layoutRecordType( 2766 RD, External.Size, External.Align, External.FieldOffsets, 2767 External.BaseOffsets, External.VirtualBaseOffsets); 2768 } 2769 2770 void 2771 MicrosoftRecordLayoutBuilder::initializeCXXLayout(const CXXRecordDecl *RD) { 2772 EndsWithZeroSizedObject = false; 2773 LeadsWithZeroSizedBase = false; 2774 HasOwnVFPtr = false; 2775 HasVBPtr = false; 2776 PrimaryBase = nullptr; 2777 SharedVBPtrBase = nullptr; 2778 // Calculate pointer size and alignment. These are used for vfptr and vbprt 2779 // injection. 2780 PointerInfo.Size = 2781 Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0)); 2782 PointerInfo.Alignment = 2783 Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerAlign(0)); 2784 // Respect pragma pack. 2785 if (!MaxFieldAlignment.isZero()) 2786 PointerInfo.Alignment = std::min(PointerInfo.Alignment, MaxFieldAlignment); 2787 } 2788 2789 void 2790 MicrosoftRecordLayoutBuilder::layoutNonVirtualBases(const CXXRecordDecl *RD) { 2791 // The MS-ABI lays out all bases that contain leading vfptrs before it lays 2792 // out any bases that do not contain vfptrs. We implement this as two passes 2793 // over the bases. This approach guarantees that the primary base is laid out 2794 // first. We use these passes to calculate some additional aggregated 2795 // information about the bases, such as required alignment and the presence of 2796 // zero sized members. 2797 const ASTRecordLayout *PreviousBaseLayout = nullptr; 2798 bool HasPolymorphicBaseClass = false; 2799 // Iterate through the bases and lay out the non-virtual ones. 2800 for (const CXXBaseSpecifier &Base : RD->bases()) { 2801 const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); 2802 HasPolymorphicBaseClass |= BaseDecl->isPolymorphic(); 2803 const ASTRecordLayout &BaseLayout = Context.getASTRecordLayout(BaseDecl); 2804 // Mark and skip virtual bases. 2805 if (Base.isVirtual()) { 2806 HasVBPtr = true; 2807 continue; 2808 } 2809 // Check for a base to share a VBPtr with. 2810 if (!SharedVBPtrBase && BaseLayout.hasVBPtr()) { 2811 SharedVBPtrBase = BaseDecl; 2812 HasVBPtr = true; 2813 } 2814 // Only lay out bases with extendable VFPtrs on the first pass. 2815 if (!BaseLayout.hasExtendableVFPtr()) 2816 continue; 2817 // If we don't have a primary base, this one qualifies. 2818 if (!PrimaryBase) { 2819 PrimaryBase = BaseDecl; 2820 LeadsWithZeroSizedBase = BaseLayout.leadsWithZeroSizedBase(); 2821 } 2822 // Lay out the base. 2823 layoutNonVirtualBase(RD, BaseDecl, BaseLayout, PreviousBaseLayout); 2824 } 2825 // Figure out if we need a fresh VFPtr for this class. 2826 if (RD->isPolymorphic()) { 2827 if (!HasPolymorphicBaseClass) 2828 // This class introduces polymorphism, so we need a vftable to store the 2829 // RTTI information. 2830 HasOwnVFPtr = true; 2831 else if (!PrimaryBase) { 2832 // We have a polymorphic base class but can't extend its vftable. Add a 2833 // new vfptr if we would use any vftable slots. 2834 for (CXXMethodDecl *M : RD->methods()) { 2835 if (MicrosoftVTableContext::hasVtableSlot(M) && 2836 M->size_overridden_methods() == 0) { 2837 HasOwnVFPtr = true; 2838 break; 2839 } 2840 } 2841 } 2842 } 2843 // If we don't have a primary base then we have a leading object that could 2844 // itself lead with a zero-sized object, something we track. 2845 bool CheckLeadingLayout = !PrimaryBase; 2846 // Iterate through the bases and lay out the non-virtual ones. 2847 for (const CXXBaseSpecifier &Base : RD->bases()) { 2848 if (Base.isVirtual()) 2849 continue; 2850 const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); 2851 const ASTRecordLayout &BaseLayout = Context.getASTRecordLayout(BaseDecl); 2852 // Only lay out bases without extendable VFPtrs on the second pass. 2853 if (BaseLayout.hasExtendableVFPtr()) { 2854 VBPtrOffset = Bases[BaseDecl] + BaseLayout.getNonVirtualSize(); 2855 continue; 2856 } 2857 // If this is the first layout, check to see if it leads with a zero sized 2858 // object. If it does, so do we. 2859 if (CheckLeadingLayout) { 2860 CheckLeadingLayout = false; 2861 LeadsWithZeroSizedBase = BaseLayout.leadsWithZeroSizedBase(); 2862 } 2863 // Lay out the base. 2864 layoutNonVirtualBase(RD, BaseDecl, BaseLayout, PreviousBaseLayout); 2865 VBPtrOffset = Bases[BaseDecl] + BaseLayout.getNonVirtualSize(); 2866 } 2867 // Set our VBPtroffset if we know it at this point. 2868 if (!HasVBPtr) 2869 VBPtrOffset = CharUnits::fromQuantity(-1); 2870 else if (SharedVBPtrBase) { 2871 const ASTRecordLayout &Layout = Context.getASTRecordLayout(SharedVBPtrBase); 2872 VBPtrOffset = Bases[SharedVBPtrBase] + Layout.getVBPtrOffset(); 2873 } 2874 } 2875 2876 static bool recordUsesEBO(const RecordDecl *RD) { 2877 if (!isa<CXXRecordDecl>(RD)) 2878 return false; 2879 if (RD->hasAttr<EmptyBasesAttr>()) 2880 return true; 2881 if (auto *LVA = RD->getAttr<LayoutVersionAttr>()) 2882 // TODO: Double check with the next version of MSVC. 2883 if (LVA->getVersion() <= LangOptions::MSVC2015) 2884 return false; 2885 // TODO: Some later version of MSVC will change the default behavior of the 2886 // compiler to enable EBO by default. When this happens, we will need an 2887 // additional isCompatibleWithMSVC check. 2888 return false; 2889 } 2890 2891 void MicrosoftRecordLayoutBuilder::layoutNonVirtualBase( 2892 const CXXRecordDecl *RD, 2893 const CXXRecordDecl *BaseDecl, 2894 const ASTRecordLayout &BaseLayout, 2895 const ASTRecordLayout *&PreviousBaseLayout) { 2896 // Insert padding between two bases if the left first one is zero sized or 2897 // contains a zero sized subobject and the right is zero sized or one leads 2898 // with a zero sized base. 2899 bool MDCUsesEBO = recordUsesEBO(RD); 2900 if (PreviousBaseLayout && PreviousBaseLayout->endsWithZeroSizedObject() && 2901 BaseLayout.leadsWithZeroSizedBase() && !MDCUsesEBO) 2902 Size++; 2903 ElementInfo Info = getAdjustedElementInfo(BaseLayout); 2904 CharUnits BaseOffset; 2905 2906 // Respect the external AST source base offset, if present. 2907 bool FoundBase = false; 2908 if (UseExternalLayout) { 2909 FoundBase = External.getExternalNVBaseOffset(BaseDecl, BaseOffset); 2910 if (FoundBase) { 2911 assert(BaseOffset >= Size && "base offset already allocated"); 2912 Size = BaseOffset; 2913 } 2914 } 2915 2916 if (!FoundBase) { 2917 if (MDCUsesEBO && BaseDecl->isEmpty()) { 2918 assert(BaseLayout.getNonVirtualSize() == CharUnits::Zero()); 2919 BaseOffset = CharUnits::Zero(); 2920 } else { 2921 // Otherwise, lay the base out at the end of the MDC. 2922 BaseOffset = Size = Size.alignTo(Info.Alignment); 2923 } 2924 } 2925 Bases.insert(std::make_pair(BaseDecl, BaseOffset)); 2926 Size += BaseLayout.getNonVirtualSize(); 2927 PreviousBaseLayout = &BaseLayout; 2928 } 2929 2930 void MicrosoftRecordLayoutBuilder::layoutFields(const RecordDecl *RD) { 2931 LastFieldIsNonZeroWidthBitfield = false; 2932 for (const FieldDecl *Field : RD->fields()) 2933 layoutField(Field); 2934 } 2935 2936 void MicrosoftRecordLayoutBuilder::layoutField(const FieldDecl *FD) { 2937 if (FD->isBitField()) { 2938 layoutBitField(FD); 2939 return; 2940 } 2941 LastFieldIsNonZeroWidthBitfield = false; 2942 ElementInfo Info = getAdjustedElementInfo(FD); 2943 Alignment = std::max(Alignment, Info.Alignment); 2944 CharUnits FieldOffset; 2945 if (UseExternalLayout) 2946 FieldOffset = 2947 Context.toCharUnitsFromBits(External.getExternalFieldOffset(FD)); 2948 else if (IsUnion) 2949 FieldOffset = CharUnits::Zero(); 2950 else 2951 FieldOffset = Size.alignTo(Info.Alignment); 2952 placeFieldAtOffset(FieldOffset); 2953 Size = std::max(Size, FieldOffset + Info.Size); 2954 } 2955 2956 void MicrosoftRecordLayoutBuilder::layoutBitField(const FieldDecl *FD) { 2957 unsigned Width = FD->getBitWidthValue(Context); 2958 if (Width == 0) { 2959 layoutZeroWidthBitField(FD); 2960 return; 2961 } 2962 ElementInfo Info = getAdjustedElementInfo(FD); 2963 // Clamp the bitfield to a containable size for the sake of being able 2964 // to lay them out. Sema will throw an error. 2965 if (Width > Context.toBits(Info.Size)) 2966 Width = Context.toBits(Info.Size); 2967 // Check to see if this bitfield fits into an existing allocation. Note: 2968 // MSVC refuses to pack bitfields of formal types with different sizes 2969 // into the same allocation. 2970 if (!UseExternalLayout && !IsUnion && LastFieldIsNonZeroWidthBitfield && 2971 CurrentBitfieldSize == Info.Size && Width <= RemainingBitsInField) { 2972 placeFieldAtBitOffset(Context.toBits(Size) - RemainingBitsInField); 2973 RemainingBitsInField -= Width; 2974 return; 2975 } 2976 LastFieldIsNonZeroWidthBitfield = true; 2977 CurrentBitfieldSize = Info.Size; 2978 if (UseExternalLayout) { 2979 auto FieldBitOffset = External.getExternalFieldOffset(FD); 2980 placeFieldAtBitOffset(FieldBitOffset); 2981 auto NewSize = Context.toCharUnitsFromBits( 2982 llvm::alignDown(FieldBitOffset, Context.toBits(Info.Alignment)) + 2983 Context.toBits(Info.Size)); 2984 Size = std::max(Size, NewSize); 2985 Alignment = std::max(Alignment, Info.Alignment); 2986 } else if (IsUnion) { 2987 placeFieldAtOffset(CharUnits::Zero()); 2988 Size = std::max(Size, Info.Size); 2989 // TODO: Add a Sema warning that MS ignores bitfield alignment in unions. 2990 } else { 2991 // Allocate a new block of memory and place the bitfield in it. 2992 CharUnits FieldOffset = Size.alignTo(Info.Alignment); 2993 placeFieldAtOffset(FieldOffset); 2994 Size = FieldOffset + Info.Size; 2995 Alignment = std::max(Alignment, Info.Alignment); 2996 RemainingBitsInField = Context.toBits(Info.Size) - Width; 2997 } 2998 } 2999 3000 void 3001 MicrosoftRecordLayoutBuilder::layoutZeroWidthBitField(const FieldDecl *FD) { 3002 // Zero-width bitfields are ignored unless they follow a non-zero-width 3003 // bitfield. 3004 if (!LastFieldIsNonZeroWidthBitfield) { 3005 placeFieldAtOffset(IsUnion ? CharUnits::Zero() : Size); 3006 // TODO: Add a Sema warning that MS ignores alignment for zero 3007 // sized bitfields that occur after zero-size bitfields or non-bitfields. 3008 return; 3009 } 3010 LastFieldIsNonZeroWidthBitfield = false; 3011 ElementInfo Info = getAdjustedElementInfo(FD); 3012 if (IsUnion) { 3013 placeFieldAtOffset(CharUnits::Zero()); 3014 Size = std::max(Size, Info.Size); 3015 // TODO: Add a Sema warning that MS ignores bitfield alignment in unions. 3016 } else { 3017 // Round up the current record size to the field's alignment boundary. 3018 CharUnits FieldOffset = Size.alignTo(Info.Alignment); 3019 placeFieldAtOffset(FieldOffset); 3020 Size = FieldOffset; 3021 Alignment = std::max(Alignment, Info.Alignment); 3022 } 3023 } 3024 3025 void MicrosoftRecordLayoutBuilder::injectVBPtr(const CXXRecordDecl *RD) { 3026 if (!HasVBPtr || SharedVBPtrBase) 3027 return; 3028 // Inject the VBPointer at the injection site. 3029 CharUnits InjectionSite = VBPtrOffset; 3030 // But before we do, make sure it's properly aligned. 3031 VBPtrOffset = VBPtrOffset.alignTo(PointerInfo.Alignment); 3032 // Determine where the first field should be laid out after the vbptr. 3033 CharUnits FieldStart = VBPtrOffset + PointerInfo.Size; 3034 // Shift everything after the vbptr down, unless we're using an external 3035 // layout. 3036 if (UseExternalLayout) { 3037 // It is possible that there were no fields or bases located after vbptr, 3038 // so the size was not adjusted before. 3039 if (Size < FieldStart) 3040 Size = FieldStart; 3041 return; 3042 } 3043 // Make sure that the amount we push the fields back by is a multiple of the 3044 // alignment. 3045 CharUnits Offset = (FieldStart - InjectionSite) 3046 .alignTo(std::max(RequiredAlignment, Alignment)); 3047 Size += Offset; 3048 for (uint64_t &FieldOffset : FieldOffsets) 3049 FieldOffset += Context.toBits(Offset); 3050 for (BaseOffsetsMapTy::value_type &Base : Bases) 3051 if (Base.second >= InjectionSite) 3052 Base.second += Offset; 3053 } 3054 3055 void MicrosoftRecordLayoutBuilder::injectVFPtr(const CXXRecordDecl *RD) { 3056 if (!HasOwnVFPtr) 3057 return; 3058 // Make sure that the amount we push the struct back by is a multiple of the 3059 // alignment. 3060 CharUnits Offset = 3061 PointerInfo.Size.alignTo(std::max(RequiredAlignment, Alignment)); 3062 // Push back the vbptr, but increase the size of the object and push back 3063 // regular fields by the offset only if not using external record layout. 3064 if (HasVBPtr) 3065 VBPtrOffset += Offset; 3066 3067 if (UseExternalLayout) { 3068 // The class may have no bases or fields, but still have a vfptr 3069 // (e.g. it's an interface class). The size was not correctly set before 3070 // in this case. 3071 if (FieldOffsets.empty() && Bases.empty()) 3072 Size += Offset; 3073 return; 3074 } 3075 3076 Size += Offset; 3077 3078 // If we're using an external layout, the fields offsets have already 3079 // accounted for this adjustment. 3080 for (uint64_t &FieldOffset : FieldOffsets) 3081 FieldOffset += Context.toBits(Offset); 3082 for (BaseOffsetsMapTy::value_type &Base : Bases) 3083 Base.second += Offset; 3084 } 3085 3086 void MicrosoftRecordLayoutBuilder::layoutVirtualBases(const CXXRecordDecl *RD) { 3087 if (!HasVBPtr) 3088 return; 3089 // Vtordisps are always 4 bytes (even in 64-bit mode) 3090 CharUnits VtorDispSize = CharUnits::fromQuantity(4); 3091 CharUnits VtorDispAlignment = VtorDispSize; 3092 // vtordisps respect pragma pack. 3093 if (!MaxFieldAlignment.isZero()) 3094 VtorDispAlignment = std::min(VtorDispAlignment, MaxFieldAlignment); 3095 // The alignment of the vtordisp is at least the required alignment of the 3096 // entire record. This requirement may be present to support vtordisp 3097 // injection. 3098 for (const CXXBaseSpecifier &VBase : RD->vbases()) { 3099 const CXXRecordDecl *BaseDecl = VBase.getType()->getAsCXXRecordDecl(); 3100 const ASTRecordLayout &BaseLayout = Context.getASTRecordLayout(BaseDecl); 3101 RequiredAlignment = 3102 std::max(RequiredAlignment, BaseLayout.getRequiredAlignment()); 3103 } 3104 VtorDispAlignment = std::max(VtorDispAlignment, RequiredAlignment); 3105 // Compute the vtordisp set. 3106 llvm::SmallPtrSet<const CXXRecordDecl *, 2> HasVtorDispSet; 3107 computeVtorDispSet(HasVtorDispSet, RD); 3108 // Iterate through the virtual bases and lay them out. 3109 const ASTRecordLayout *PreviousBaseLayout = nullptr; 3110 for (const CXXBaseSpecifier &VBase : RD->vbases()) { 3111 const CXXRecordDecl *BaseDecl = VBase.getType()->getAsCXXRecordDecl(); 3112 const ASTRecordLayout &BaseLayout = Context.getASTRecordLayout(BaseDecl); 3113 bool HasVtordisp = HasVtorDispSet.contains(BaseDecl); 3114 // Insert padding between two bases if the left first one is zero sized or 3115 // contains a zero sized subobject and the right is zero sized or one leads 3116 // with a zero sized base. The padding between virtual bases is 4 3117 // bytes (in both 32 and 64 bits modes) and always involves rounding up to 3118 // the required alignment, we don't know why. 3119 if ((PreviousBaseLayout && PreviousBaseLayout->endsWithZeroSizedObject() && 3120 BaseLayout.leadsWithZeroSizedBase() && !recordUsesEBO(RD)) || 3121 HasVtordisp) { 3122 Size = Size.alignTo(VtorDispAlignment) + VtorDispSize; 3123 Alignment = std::max(VtorDispAlignment, Alignment); 3124 } 3125 // Insert the virtual base. 3126 ElementInfo Info = getAdjustedElementInfo(BaseLayout); 3127 CharUnits BaseOffset; 3128 3129 // Respect the external AST source base offset, if present. 3130 if (UseExternalLayout) { 3131 if (!External.getExternalVBaseOffset(BaseDecl, BaseOffset)) 3132 BaseOffset = Size; 3133 } else 3134 BaseOffset = Size.alignTo(Info.Alignment); 3135 3136 assert(BaseOffset >= Size && "base offset already allocated"); 3137 3138 VBases.insert(std::make_pair(BaseDecl, 3139 ASTRecordLayout::VBaseInfo(BaseOffset, HasVtordisp))); 3140 Size = BaseOffset + BaseLayout.getNonVirtualSize(); 3141 PreviousBaseLayout = &BaseLayout; 3142 } 3143 } 3144 3145 void MicrosoftRecordLayoutBuilder::finalizeLayout(const RecordDecl *RD) { 3146 // Respect required alignment. Note that in 32-bit mode Required alignment 3147 // may be 0 and cause size not to be updated. 3148 DataSize = Size; 3149 if (!RequiredAlignment.isZero()) { 3150 Alignment = std::max(Alignment, RequiredAlignment); 3151 auto RoundingAlignment = Alignment; 3152 if (!MaxFieldAlignment.isZero()) 3153 RoundingAlignment = std::min(RoundingAlignment, MaxFieldAlignment); 3154 RoundingAlignment = std::max(RoundingAlignment, RequiredAlignment); 3155 Size = Size.alignTo(RoundingAlignment); 3156 } 3157 if (Size.isZero()) { 3158 if (!recordUsesEBO(RD) || !cast<CXXRecordDecl>(RD)->isEmpty()) { 3159 EndsWithZeroSizedObject = true; 3160 LeadsWithZeroSizedBase = true; 3161 } 3162 // Zero-sized structures have size equal to their alignment if a 3163 // __declspec(align) came into play. 3164 if (RequiredAlignment >= MinEmptyStructSize) 3165 Size = Alignment; 3166 else 3167 Size = MinEmptyStructSize; 3168 } 3169 3170 if (UseExternalLayout) { 3171 Size = Context.toCharUnitsFromBits(External.Size); 3172 if (External.Align) 3173 Alignment = Context.toCharUnitsFromBits(External.Align); 3174 } 3175 } 3176 3177 // Recursively walks the non-virtual bases of a class and determines if any of 3178 // them are in the bases with overridden methods set. 3179 static bool 3180 RequiresVtordisp(const llvm::SmallPtrSetImpl<const CXXRecordDecl *> & 3181 BasesWithOverriddenMethods, 3182 const CXXRecordDecl *RD) { 3183 if (BasesWithOverriddenMethods.count(RD)) 3184 return true; 3185 // If any of a virtual bases non-virtual bases (recursively) requires a 3186 // vtordisp than so does this virtual base. 3187 for (const CXXBaseSpecifier &Base : RD->bases()) 3188 if (!Base.isVirtual() && 3189 RequiresVtordisp(BasesWithOverriddenMethods, 3190 Base.getType()->getAsCXXRecordDecl())) 3191 return true; 3192 return false; 3193 } 3194 3195 void MicrosoftRecordLayoutBuilder::computeVtorDispSet( 3196 llvm::SmallPtrSetImpl<const CXXRecordDecl *> &HasVtordispSet, 3197 const CXXRecordDecl *RD) const { 3198 // /vd2 or #pragma vtordisp(2): Always use vtordisps for virtual bases with 3199 // vftables. 3200 if (RD->getMSVtorDispMode() == MSVtorDispMode::ForVFTable) { 3201 for (const CXXBaseSpecifier &Base : RD->vbases()) { 3202 const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); 3203 const ASTRecordLayout &Layout = Context.getASTRecordLayout(BaseDecl); 3204 if (Layout.hasExtendableVFPtr()) 3205 HasVtordispSet.insert(BaseDecl); 3206 } 3207 return; 3208 } 3209 3210 // If any of our bases need a vtordisp for this type, so do we. Check our 3211 // direct bases for vtordisp requirements. 3212 for (const CXXBaseSpecifier &Base : RD->bases()) { 3213 const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); 3214 const ASTRecordLayout &Layout = Context.getASTRecordLayout(BaseDecl); 3215 for (const auto &bi : Layout.getVBaseOffsetsMap()) 3216 if (bi.second.hasVtorDisp()) 3217 HasVtordispSet.insert(bi.first); 3218 } 3219 // We don't introduce any additional vtordisps if either: 3220 // * A user declared constructor or destructor aren't declared. 3221 // * #pragma vtordisp(0) or the /vd0 flag are in use. 3222 if ((!RD->hasUserDeclaredConstructor() && !RD->hasUserDeclaredDestructor()) || 3223 RD->getMSVtorDispMode() == MSVtorDispMode::Never) 3224 return; 3225 // /vd1 or #pragma vtordisp(1): Try to guess based on whether we think it's 3226 // possible for a partially constructed object with virtual base overrides to 3227 // escape a non-trivial constructor. 3228 assert(RD->getMSVtorDispMode() == MSVtorDispMode::ForVBaseOverride); 3229 // Compute a set of base classes which define methods we override. A virtual 3230 // base in this set will require a vtordisp. A virtual base that transitively 3231 // contains one of these bases as a non-virtual base will also require a 3232 // vtordisp. 3233 llvm::SmallPtrSet<const CXXMethodDecl *, 8> Work; 3234 llvm::SmallPtrSet<const CXXRecordDecl *, 2> BasesWithOverriddenMethods; 3235 // Seed the working set with our non-destructor, non-pure virtual methods. 3236 for (const CXXMethodDecl *MD : RD->methods()) 3237 if (MicrosoftVTableContext::hasVtableSlot(MD) && 3238 !isa<CXXDestructorDecl>(MD) && !MD->isPure()) 3239 Work.insert(MD); 3240 while (!Work.empty()) { 3241 const CXXMethodDecl *MD = *Work.begin(); 3242 auto MethodRange = MD->overridden_methods(); 3243 // If a virtual method has no-overrides it lives in its parent's vtable. 3244 if (MethodRange.begin() == MethodRange.end()) 3245 BasesWithOverriddenMethods.insert(MD->getParent()); 3246 else 3247 Work.insert(MethodRange.begin(), MethodRange.end()); 3248 // We've finished processing this element, remove it from the working set. 3249 Work.erase(MD); 3250 } 3251 // For each of our virtual bases, check if it is in the set of overridden 3252 // bases or if it transitively contains a non-virtual base that is. 3253 for (const CXXBaseSpecifier &Base : RD->vbases()) { 3254 const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); 3255 if (!HasVtordispSet.count(BaseDecl) && 3256 RequiresVtordisp(BasesWithOverriddenMethods, BaseDecl)) 3257 HasVtordispSet.insert(BaseDecl); 3258 } 3259 } 3260 3261 /// getASTRecordLayout - Get or compute information about the layout of the 3262 /// specified record (struct/union/class), which indicates its size and field 3263 /// position information. 3264 const ASTRecordLayout & 3265 ASTContext::getASTRecordLayout(const RecordDecl *D) const { 3266 // These asserts test different things. A record has a definition 3267 // as soon as we begin to parse the definition. That definition is 3268 // not a complete definition (which is what isDefinition() tests) 3269 // until we *finish* parsing the definition. 3270 3271 if (D->hasExternalLexicalStorage() && !D->getDefinition()) 3272 getExternalSource()->CompleteType(const_cast<RecordDecl*>(D)); 3273 3274 D = D->getDefinition(); 3275 assert(D && "Cannot get layout of forward declarations!"); 3276 assert(!D->isInvalidDecl() && "Cannot get layout of invalid decl!"); 3277 assert(D->isCompleteDefinition() && "Cannot layout type before complete!"); 3278 3279 // Look up this layout, if already laid out, return what we have. 3280 // Note that we can't save a reference to the entry because this function 3281 // is recursive. 3282 const ASTRecordLayout *Entry = ASTRecordLayouts[D]; 3283 if (Entry) return *Entry; 3284 3285 const ASTRecordLayout *NewEntry = nullptr; 3286 3287 if (isMsLayout(*this)) { 3288 MicrosoftRecordLayoutBuilder Builder(*this); 3289 if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) { 3290 Builder.cxxLayout(RD); 3291 NewEntry = new (*this) ASTRecordLayout( 3292 *this, Builder.Size, Builder.Alignment, Builder.Alignment, 3293 Builder.Alignment, Builder.RequiredAlignment, Builder.HasOwnVFPtr, 3294 Builder.HasOwnVFPtr || Builder.PrimaryBase, Builder.VBPtrOffset, 3295 Builder.DataSize, Builder.FieldOffsets, Builder.NonVirtualSize, 3296 Builder.Alignment, Builder.Alignment, CharUnits::Zero(), 3297 Builder.PrimaryBase, false, Builder.SharedVBPtrBase, 3298 Builder.EndsWithZeroSizedObject, Builder.LeadsWithZeroSizedBase, 3299 Builder.Bases, Builder.VBases); 3300 } else { 3301 Builder.layout(D); 3302 NewEntry = new (*this) ASTRecordLayout( 3303 *this, Builder.Size, Builder.Alignment, Builder.Alignment, 3304 Builder.Alignment, Builder.RequiredAlignment, Builder.Size, 3305 Builder.FieldOffsets); 3306 } 3307 } else { 3308 if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) { 3309 EmptySubobjectMap EmptySubobjects(*this, RD); 3310 ItaniumRecordLayoutBuilder Builder(*this, &EmptySubobjects); 3311 Builder.Layout(RD); 3312 3313 // In certain situations, we are allowed to lay out objects in the 3314 // tail-padding of base classes. This is ABI-dependent. 3315 // FIXME: this should be stored in the record layout. 3316 bool skipTailPadding = 3317 mustSkipTailPadding(getTargetInfo().getCXXABI(), RD); 3318 3319 // FIXME: This should be done in FinalizeLayout. 3320 CharUnits DataSize = 3321 skipTailPadding ? Builder.getSize() : Builder.getDataSize(); 3322 CharUnits NonVirtualSize = 3323 skipTailPadding ? DataSize : Builder.NonVirtualSize; 3324 NewEntry = new (*this) ASTRecordLayout( 3325 *this, Builder.getSize(), Builder.Alignment, 3326 Builder.PreferredAlignment, Builder.UnadjustedAlignment, 3327 /*RequiredAlignment : used by MS-ABI)*/ 3328 Builder.Alignment, Builder.HasOwnVFPtr, RD->isDynamicClass(), 3329 CharUnits::fromQuantity(-1), DataSize, Builder.FieldOffsets, 3330 NonVirtualSize, Builder.NonVirtualAlignment, 3331 Builder.PreferredNVAlignment, 3332 EmptySubobjects.SizeOfLargestEmptySubobject, Builder.PrimaryBase, 3333 Builder.PrimaryBaseIsVirtual, nullptr, false, false, Builder.Bases, 3334 Builder.VBases); 3335 } else { 3336 ItaniumRecordLayoutBuilder Builder(*this, /*EmptySubobjects=*/nullptr); 3337 Builder.Layout(D); 3338 3339 NewEntry = new (*this) ASTRecordLayout( 3340 *this, Builder.getSize(), Builder.Alignment, 3341 Builder.PreferredAlignment, Builder.UnadjustedAlignment, 3342 /*RequiredAlignment : used by MS-ABI)*/ 3343 Builder.Alignment, Builder.getSize(), Builder.FieldOffsets); 3344 } 3345 } 3346 3347 ASTRecordLayouts[D] = NewEntry; 3348 3349 if (getLangOpts().DumpRecordLayouts) { 3350 llvm::outs() << "\n*** Dumping AST Record Layout\n"; 3351 DumpRecordLayout(D, llvm::outs(), getLangOpts().DumpRecordLayoutsSimple); 3352 } 3353 3354 return *NewEntry; 3355 } 3356 3357 const CXXMethodDecl *ASTContext::getCurrentKeyFunction(const CXXRecordDecl *RD) { 3358 if (!getTargetInfo().getCXXABI().hasKeyFunctions()) 3359 return nullptr; 3360 3361 assert(RD->getDefinition() && "Cannot get key function for forward decl!"); 3362 RD = RD->getDefinition(); 3363 3364 // Beware: 3365 // 1) computing the key function might trigger deserialization, which might 3366 // invalidate iterators into KeyFunctions 3367 // 2) 'get' on the LazyDeclPtr might also trigger deserialization and 3368 // invalidate the LazyDeclPtr within the map itself 3369 LazyDeclPtr Entry = KeyFunctions[RD]; 3370 const Decl *Result = 3371 Entry ? Entry.get(getExternalSource()) : computeKeyFunction(*this, RD); 3372 3373 // Store it back if it changed. 3374 if (Entry.isOffset() || Entry.isValid() != bool(Result)) 3375 KeyFunctions[RD] = const_cast<Decl*>(Result); 3376 3377 return cast_or_null<CXXMethodDecl>(Result); 3378 } 3379 3380 void ASTContext::setNonKeyFunction(const CXXMethodDecl *Method) { 3381 assert(Method == Method->getFirstDecl() && 3382 "not working with method declaration from class definition"); 3383 3384 // Look up the cache entry. Since we're working with the first 3385 // declaration, its parent must be the class definition, which is 3386 // the correct key for the KeyFunctions hash. 3387 const auto &Map = KeyFunctions; 3388 auto I = Map.find(Method->getParent()); 3389 3390 // If it's not cached, there's nothing to do. 3391 if (I == Map.end()) return; 3392 3393 // If it is cached, check whether it's the target method, and if so, 3394 // remove it from the cache. Note, the call to 'get' might invalidate 3395 // the iterator and the LazyDeclPtr object within the map. 3396 LazyDeclPtr Ptr = I->second; 3397 if (Ptr.get(getExternalSource()) == Method) { 3398 // FIXME: remember that we did this for module / chained PCH state? 3399 KeyFunctions.erase(Method->getParent()); 3400 } 3401 } 3402 3403 static uint64_t getFieldOffset(const ASTContext &C, const FieldDecl *FD) { 3404 const ASTRecordLayout &Layout = C.getASTRecordLayout(FD->getParent()); 3405 return Layout.getFieldOffset(FD->getFieldIndex()); 3406 } 3407 3408 uint64_t ASTContext::getFieldOffset(const ValueDecl *VD) const { 3409 uint64_t OffsetInBits; 3410 if (const FieldDecl *FD = dyn_cast<FieldDecl>(VD)) { 3411 OffsetInBits = ::getFieldOffset(*this, FD); 3412 } else { 3413 const IndirectFieldDecl *IFD = cast<IndirectFieldDecl>(VD); 3414 3415 OffsetInBits = 0; 3416 for (const NamedDecl *ND : IFD->chain()) 3417 OffsetInBits += ::getFieldOffset(*this, cast<FieldDecl>(ND)); 3418 } 3419 3420 return OffsetInBits; 3421 } 3422 3423 uint64_t ASTContext::lookupFieldBitOffset(const ObjCInterfaceDecl *OID, 3424 const ObjCImplementationDecl *ID, 3425 const ObjCIvarDecl *Ivar) const { 3426 Ivar = Ivar->getCanonicalDecl(); 3427 const ObjCInterfaceDecl *Container = Ivar->getContainingInterface(); 3428 3429 // FIXME: We should eliminate the need to have ObjCImplementationDecl passed 3430 // in here; it should never be necessary because that should be the lexical 3431 // decl context for the ivar. 3432 3433 // If we know have an implementation (and the ivar is in it) then 3434 // look up in the implementation layout. 3435 const ASTRecordLayout *RL; 3436 if (ID && declaresSameEntity(ID->getClassInterface(), Container)) 3437 RL = &getASTObjCImplementationLayout(ID); 3438 else 3439 RL = &getASTObjCInterfaceLayout(Container); 3440 3441 // Compute field index. 3442 // 3443 // FIXME: The index here is closely tied to how ASTContext::getObjCLayout is 3444 // implemented. This should be fixed to get the information from the layout 3445 // directly. 3446 unsigned Index = 0; 3447 3448 for (const ObjCIvarDecl *IVD = Container->all_declared_ivar_begin(); 3449 IVD; IVD = IVD->getNextIvar()) { 3450 if (Ivar == IVD) 3451 break; 3452 ++Index; 3453 } 3454 assert(Index < RL->getFieldCount() && "Ivar is not inside record layout!"); 3455 3456 return RL->getFieldOffset(Index); 3457 } 3458 3459 /// getObjCLayout - Get or compute information about the layout of the 3460 /// given interface. 3461 /// 3462 /// \param Impl - If given, also include the layout of the interface's 3463 /// implementation. This may differ by including synthesized ivars. 3464 const ASTRecordLayout & 3465 ASTContext::getObjCLayout(const ObjCInterfaceDecl *D, 3466 const ObjCImplementationDecl *Impl) const { 3467 // Retrieve the definition 3468 if (D->hasExternalLexicalStorage() && !D->getDefinition()) 3469 getExternalSource()->CompleteType(const_cast<ObjCInterfaceDecl*>(D)); 3470 D = D->getDefinition(); 3471 assert(D && !D->isInvalidDecl() && D->isThisDeclarationADefinition() && 3472 "Invalid interface decl!"); 3473 3474 // Look up this layout, if already laid out, return what we have. 3475 const ObjCContainerDecl *Key = 3476 Impl ? (const ObjCContainerDecl*) Impl : (const ObjCContainerDecl*) D; 3477 if (const ASTRecordLayout *Entry = ObjCLayouts[Key]) 3478 return *Entry; 3479 3480 // Add in synthesized ivar count if laying out an implementation. 3481 if (Impl) { 3482 unsigned SynthCount = CountNonClassIvars(D); 3483 // If there aren't any synthesized ivars then reuse the interface 3484 // entry. Note we can't cache this because we simply free all 3485 // entries later; however we shouldn't look up implementations 3486 // frequently. 3487 if (SynthCount == 0) 3488 return getObjCLayout(D, nullptr); 3489 } 3490 3491 ItaniumRecordLayoutBuilder Builder(*this, /*EmptySubobjects=*/nullptr); 3492 Builder.Layout(D); 3493 3494 const ASTRecordLayout *NewEntry = new (*this) ASTRecordLayout( 3495 *this, Builder.getSize(), Builder.Alignment, Builder.PreferredAlignment, 3496 Builder.UnadjustedAlignment, 3497 /*RequiredAlignment : used by MS-ABI)*/ 3498 Builder.Alignment, Builder.getDataSize(), Builder.FieldOffsets); 3499 3500 ObjCLayouts[Key] = NewEntry; 3501 3502 return *NewEntry; 3503 } 3504 3505 static void PrintOffset(raw_ostream &OS, 3506 CharUnits Offset, unsigned IndentLevel) { 3507 OS << llvm::format("%10" PRId64 " | ", (int64_t)Offset.getQuantity()); 3508 OS.indent(IndentLevel * 2); 3509 } 3510 3511 static void PrintBitFieldOffset(raw_ostream &OS, CharUnits Offset, 3512 unsigned Begin, unsigned Width, 3513 unsigned IndentLevel) { 3514 llvm::SmallString<10> Buffer; 3515 { 3516 llvm::raw_svector_ostream BufferOS(Buffer); 3517 BufferOS << Offset.getQuantity() << ':'; 3518 if (Width == 0) { 3519 BufferOS << '-'; 3520 } else { 3521 BufferOS << Begin << '-' << (Begin + Width - 1); 3522 } 3523 } 3524 3525 OS << llvm::right_justify(Buffer, 10) << " | "; 3526 OS.indent(IndentLevel * 2); 3527 } 3528 3529 static void PrintIndentNoOffset(raw_ostream &OS, unsigned IndentLevel) { 3530 OS << " | "; 3531 OS.indent(IndentLevel * 2); 3532 } 3533 3534 static void DumpRecordLayout(raw_ostream &OS, const RecordDecl *RD, 3535 const ASTContext &C, 3536 CharUnits Offset, 3537 unsigned IndentLevel, 3538 const char* Description, 3539 bool PrintSizeInfo, 3540 bool IncludeVirtualBases) { 3541 const ASTRecordLayout &Layout = C.getASTRecordLayout(RD); 3542 auto CXXRD = dyn_cast<CXXRecordDecl>(RD); 3543 3544 PrintOffset(OS, Offset, IndentLevel); 3545 OS << C.getTypeDeclType(const_cast<RecordDecl *>(RD)); 3546 if (Description) 3547 OS << ' ' << Description; 3548 if (CXXRD && CXXRD->isEmpty()) 3549 OS << " (empty)"; 3550 OS << '\n'; 3551 3552 IndentLevel++; 3553 3554 // Dump bases. 3555 if (CXXRD) { 3556 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase(); 3557 bool HasOwnVFPtr = Layout.hasOwnVFPtr(); 3558 bool HasOwnVBPtr = Layout.hasOwnVBPtr(); 3559 3560 // Vtable pointer. 3561 if (CXXRD->isDynamicClass() && !PrimaryBase && !isMsLayout(C)) { 3562 PrintOffset(OS, Offset, IndentLevel); 3563 OS << '(' << *RD << " vtable pointer)\n"; 3564 } else if (HasOwnVFPtr) { 3565 PrintOffset(OS, Offset, IndentLevel); 3566 // vfptr (for Microsoft C++ ABI) 3567 OS << '(' << *RD << " vftable pointer)\n"; 3568 } 3569 3570 // Collect nvbases. 3571 SmallVector<const CXXRecordDecl *, 4> Bases; 3572 for (const CXXBaseSpecifier &Base : CXXRD->bases()) { 3573 assert(!Base.getType()->isDependentType() && 3574 "Cannot layout class with dependent bases."); 3575 if (!Base.isVirtual()) 3576 Bases.push_back(Base.getType()->getAsCXXRecordDecl()); 3577 } 3578 3579 // Sort nvbases by offset. 3580 llvm::stable_sort( 3581 Bases, [&](const CXXRecordDecl *L, const CXXRecordDecl *R) { 3582 return Layout.getBaseClassOffset(L) < Layout.getBaseClassOffset(R); 3583 }); 3584 3585 // Dump (non-virtual) bases 3586 for (const CXXRecordDecl *Base : Bases) { 3587 CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(Base); 3588 DumpRecordLayout(OS, Base, C, BaseOffset, IndentLevel, 3589 Base == PrimaryBase ? "(primary base)" : "(base)", 3590 /*PrintSizeInfo=*/false, 3591 /*IncludeVirtualBases=*/false); 3592 } 3593 3594 // vbptr (for Microsoft C++ ABI) 3595 if (HasOwnVBPtr) { 3596 PrintOffset(OS, Offset + Layout.getVBPtrOffset(), IndentLevel); 3597 OS << '(' << *RD << " vbtable pointer)\n"; 3598 } 3599 } 3600 3601 // Dump fields. 3602 uint64_t FieldNo = 0; 3603 for (RecordDecl::field_iterator I = RD->field_begin(), 3604 E = RD->field_end(); I != E; ++I, ++FieldNo) { 3605 const FieldDecl &Field = **I; 3606 uint64_t LocalFieldOffsetInBits = Layout.getFieldOffset(FieldNo); 3607 CharUnits FieldOffset = 3608 Offset + C.toCharUnitsFromBits(LocalFieldOffsetInBits); 3609 3610 // Recursively dump fields of record type. 3611 if (auto RT = Field.getType()->getAs<RecordType>()) { 3612 DumpRecordLayout(OS, RT->getDecl(), C, FieldOffset, IndentLevel, 3613 Field.getName().data(), 3614 /*PrintSizeInfo=*/false, 3615 /*IncludeVirtualBases=*/true); 3616 continue; 3617 } 3618 3619 if (Field.isBitField()) { 3620 uint64_t LocalFieldByteOffsetInBits = C.toBits(FieldOffset - Offset); 3621 unsigned Begin = LocalFieldOffsetInBits - LocalFieldByteOffsetInBits; 3622 unsigned Width = Field.getBitWidthValue(C); 3623 PrintBitFieldOffset(OS, FieldOffset, Begin, Width, IndentLevel); 3624 } else { 3625 PrintOffset(OS, FieldOffset, IndentLevel); 3626 } 3627 const QualType &FieldType = C.getLangOpts().DumpRecordLayoutsCanonical 3628 ? Field.getType().getCanonicalType() 3629 : Field.getType(); 3630 OS << FieldType << ' ' << Field << '\n'; 3631 } 3632 3633 // Dump virtual bases. 3634 if (CXXRD && IncludeVirtualBases) { 3635 const ASTRecordLayout::VBaseOffsetsMapTy &VtorDisps = 3636 Layout.getVBaseOffsetsMap(); 3637 3638 for (const CXXBaseSpecifier &Base : CXXRD->vbases()) { 3639 assert(Base.isVirtual() && "Found non-virtual class!"); 3640 const CXXRecordDecl *VBase = Base.getType()->getAsCXXRecordDecl(); 3641 3642 CharUnits VBaseOffset = Offset + Layout.getVBaseClassOffset(VBase); 3643 3644 if (VtorDisps.find(VBase)->second.hasVtorDisp()) { 3645 PrintOffset(OS, VBaseOffset - CharUnits::fromQuantity(4), IndentLevel); 3646 OS << "(vtordisp for vbase " << *VBase << ")\n"; 3647 } 3648 3649 DumpRecordLayout(OS, VBase, C, VBaseOffset, IndentLevel, 3650 VBase == Layout.getPrimaryBase() ? 3651 "(primary virtual base)" : "(virtual base)", 3652 /*PrintSizeInfo=*/false, 3653 /*IncludeVirtualBases=*/false); 3654 } 3655 } 3656 3657 if (!PrintSizeInfo) return; 3658 3659 PrintIndentNoOffset(OS, IndentLevel - 1); 3660 OS << "[sizeof=" << Layout.getSize().getQuantity(); 3661 if (CXXRD && !isMsLayout(C)) 3662 OS << ", dsize=" << Layout.getDataSize().getQuantity(); 3663 OS << ", align=" << Layout.getAlignment().getQuantity(); 3664 if (C.getTargetInfo().defaultsToAIXPowerAlignment()) 3665 OS << ", preferredalign=" << Layout.getPreferredAlignment().getQuantity(); 3666 3667 if (CXXRD) { 3668 OS << ",\n"; 3669 PrintIndentNoOffset(OS, IndentLevel - 1); 3670 OS << " nvsize=" << Layout.getNonVirtualSize().getQuantity(); 3671 OS << ", nvalign=" << Layout.getNonVirtualAlignment().getQuantity(); 3672 if (C.getTargetInfo().defaultsToAIXPowerAlignment()) 3673 OS << ", preferrednvalign=" 3674 << Layout.getPreferredNVAlignment().getQuantity(); 3675 } 3676 OS << "]\n"; 3677 } 3678 3679 void ASTContext::DumpRecordLayout(const RecordDecl *RD, raw_ostream &OS, 3680 bool Simple) const { 3681 if (!Simple) { 3682 ::DumpRecordLayout(OS, RD, *this, CharUnits(), 0, nullptr, 3683 /*PrintSizeInfo*/ true, 3684 /*IncludeVirtualBases=*/true); 3685 return; 3686 } 3687 3688 // The "simple" format is designed to be parsed by the 3689 // layout-override testing code. There shouldn't be any external 3690 // uses of this format --- when LLDB overrides a layout, it sets up 3691 // the data structures directly --- so feel free to adjust this as 3692 // you like as long as you also update the rudimentary parser for it 3693 // in libFrontend. 3694 3695 const ASTRecordLayout &Info = getASTRecordLayout(RD); 3696 OS << "Type: " << getTypeDeclType(RD) << "\n"; 3697 OS << "\nLayout: "; 3698 OS << "<ASTRecordLayout\n"; 3699 OS << " Size:" << toBits(Info.getSize()) << "\n"; 3700 if (!isMsLayout(*this)) 3701 OS << " DataSize:" << toBits(Info.getDataSize()) << "\n"; 3702 OS << " Alignment:" << toBits(Info.getAlignment()) << "\n"; 3703 if (Target->defaultsToAIXPowerAlignment()) 3704 OS << " PreferredAlignment:" << toBits(Info.getPreferredAlignment()) 3705 << "\n"; 3706 OS << " FieldOffsets: ["; 3707 for (unsigned i = 0, e = Info.getFieldCount(); i != e; ++i) { 3708 if (i) 3709 OS << ", "; 3710 OS << Info.getFieldOffset(i); 3711 } 3712 OS << "]>\n"; 3713 } 3714