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