CGRecordLayoutBuilder.cpp revision 208600
1//===--- CGRecordLayoutBuilder.cpp - CGRecordLayout builder ----*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// Builder implementation for CGRecordLayout objects. 11// 12//===----------------------------------------------------------------------===// 13 14#include "CGRecordLayout.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/Attr.h" 17#include "clang/AST/DeclCXX.h" 18#include "clang/AST/Expr.h" 19#include "clang/AST/RecordLayout.h" 20#include "CodeGenTypes.h" 21#include "llvm/DerivedTypes.h" 22#include "llvm/Type.h" 23#include "llvm/Support/Debug.h" 24#include "llvm/Support/raw_ostream.h" 25#include "llvm/Target/TargetData.h" 26using namespace clang; 27using namespace CodeGen; 28 29namespace clang { 30namespace CodeGen { 31 32class CGRecordLayoutBuilder { 33public: 34 /// FieldTypes - Holds the LLVM types that the struct is created from. 35 std::vector<const llvm::Type *> FieldTypes; 36 37 /// LLVMFieldInfo - Holds a field and its corresponding LLVM field number. 38 typedef std::pair<const FieldDecl *, unsigned> LLVMFieldInfo; 39 llvm::SmallVector<LLVMFieldInfo, 16> LLVMFields; 40 41 /// LLVMBitFieldInfo - Holds location and size information about a bit field. 42 typedef std::pair<const FieldDecl *, CGBitFieldInfo> LLVMBitFieldInfo; 43 llvm::SmallVector<LLVMBitFieldInfo, 16> LLVMBitFields; 44 45 typedef std::pair<const CXXRecordDecl *, unsigned> LLVMBaseInfo; 46 llvm::SmallVector<LLVMBaseInfo, 16> LLVMNonVirtualBases; 47 48 /// ContainsPointerToDataMember - Whether one of the fields in this record 49 /// layout is a pointer to data member, or a struct that contains pointer to 50 /// data member. 51 bool ContainsPointerToDataMember; 52 53 /// Packed - Whether the resulting LLVM struct will be packed or not. 54 bool Packed; 55 56private: 57 CodeGenTypes &Types; 58 59 /// Alignment - Contains the alignment of the RecordDecl. 60 // 61 // FIXME: This is not needed and should be removed. 62 unsigned Alignment; 63 64 /// AlignmentAsLLVMStruct - Will contain the maximum alignment of all the 65 /// LLVM types. 66 unsigned AlignmentAsLLVMStruct; 67 68 /// BitsAvailableInLastField - If a bit field spans only part of a LLVM field, 69 /// this will have the number of bits still available in the field. 70 char BitsAvailableInLastField; 71 72 /// NextFieldOffsetInBytes - Holds the next field offset in bytes. 73 uint64_t NextFieldOffsetInBytes; 74 75 /// LayoutUnionField - Will layout a field in an union and return the type 76 /// that the field will have. 77 const llvm::Type *LayoutUnionField(const FieldDecl *Field, 78 const ASTRecordLayout &Layout); 79 80 /// LayoutUnion - Will layout a union RecordDecl. 81 void LayoutUnion(const RecordDecl *D); 82 83 /// LayoutField - try to layout all fields in the record decl. 84 /// Returns false if the operation failed because the struct is not packed. 85 bool LayoutFields(const RecordDecl *D); 86 87 /// LayoutNonVirtualBase - layout a single non-virtual base. 88 void LayoutNonVirtualBase(const CXXRecordDecl *BaseDecl, 89 uint64_t BaseOffset); 90 91 /// LayoutNonVirtualBases - layout the non-virtual bases of a record decl. 92 void LayoutNonVirtualBases(const CXXRecordDecl *RD, 93 const ASTRecordLayout &Layout); 94 95 /// LayoutField - layout a single field. Returns false if the operation failed 96 /// because the current struct is not packed. 97 bool LayoutField(const FieldDecl *D, uint64_t FieldOffset); 98 99 /// LayoutBitField - layout a single bit field. 100 void LayoutBitField(const FieldDecl *D, uint64_t FieldOffset); 101 102 /// AppendField - Appends a field with the given offset and type. 103 void AppendField(uint64_t FieldOffsetInBytes, const llvm::Type *FieldTy); 104 105 /// AppendPadding - Appends enough padding bytes so that the total 106 /// struct size is a multiple of the field alignment. 107 void AppendPadding(uint64_t FieldOffsetInBytes, unsigned FieldAlignment); 108 109 /// AppendBytes - Append a given number of bytes to the record. 110 void AppendBytes(uint64_t NumBytes); 111 112 /// AppendTailPadding - Append enough tail padding so that the type will have 113 /// the passed size. 114 void AppendTailPadding(uint64_t RecordSize); 115 116 unsigned getTypeAlignment(const llvm::Type *Ty) const; 117 118 /// CheckForPointerToDataMember - Check if the given type contains a pointer 119 /// to data member. 120 void CheckForPointerToDataMember(QualType T); 121 void CheckForPointerToDataMember(const CXXRecordDecl *RD); 122 123public: 124 CGRecordLayoutBuilder(CodeGenTypes &Types) 125 : ContainsPointerToDataMember(false), Packed(false), Types(Types), 126 Alignment(0), AlignmentAsLLVMStruct(1), 127 BitsAvailableInLastField(0), NextFieldOffsetInBytes(0) { } 128 129 /// Layout - Will layout a RecordDecl. 130 void Layout(const RecordDecl *D); 131}; 132 133} 134} 135 136void CGRecordLayoutBuilder::Layout(const RecordDecl *D) { 137 Alignment = Types.getContext().getASTRecordLayout(D).getAlignment() / 8; 138 Packed = D->hasAttr<PackedAttr>(); 139 140 if (D->isUnion()) { 141 LayoutUnion(D); 142 return; 143 } 144 145 if (LayoutFields(D)) 146 return; 147 148 // We weren't able to layout the struct. Try again with a packed struct 149 Packed = true; 150 AlignmentAsLLVMStruct = 1; 151 NextFieldOffsetInBytes = 0; 152 FieldTypes.clear(); 153 LLVMFields.clear(); 154 LLVMBitFields.clear(); 155 LLVMNonVirtualBases.clear(); 156 157 LayoutFields(D); 158} 159 160static CGBitFieldInfo ComputeBitFieldInfo(CodeGenTypes &Types, 161 const FieldDecl *FD, 162 uint64_t FieldOffset, 163 uint64_t FieldSize) { 164 const RecordDecl *RD = FD->getParent(); 165 const ASTRecordLayout &RL = Types.getContext().getASTRecordLayout(RD); 166 uint64_t ContainingTypeSizeInBits = RL.getSize(); 167 unsigned ContainingTypeAlign = RL.getAlignment(); 168 169 const llvm::Type *Ty = Types.ConvertTypeForMemRecursive(FD->getType()); 170 uint64_t TypeSizeInBytes = Types.getTargetData().getTypeAllocSize(Ty); 171 uint64_t TypeSizeInBits = TypeSizeInBytes * 8; 172 173 bool IsSigned = FD->getType()->isSignedIntegerType(); 174 175 if (FieldSize > TypeSizeInBits) { 176 // We have a wide bit-field. The extra bits are only used for padding, so 177 // if we have a bitfield of type T, with size N: 178 // 179 // T t : N; 180 // 181 // We can just assume that it's: 182 // 183 // T t : sizeof(T); 184 // 185 FieldSize = TypeSizeInBits; 186 } 187 188 // Compute the access components. The policy we use is to start by attempting 189 // to access using the width of the bit-field type itself and to always access 190 // at aligned indices of that type. If such an access would fail because it 191 // extends past the bound of the type, then we reduce size to the next smaller 192 // power of two and retry. The current algorithm assumes pow2 sized types, 193 // although this is easy to fix. 194 // 195 // FIXME: This algorithm is wrong on big-endian systems, I think. 196 assert(llvm::isPowerOf2_32(TypeSizeInBits) && "Unexpected type size!"); 197 CGBitFieldInfo::AccessInfo Components[3]; 198 unsigned NumComponents = 0; 199 unsigned AccessedTargetBits = 0; // The tumber of target bits accessed. 200 unsigned AccessWidth = TypeSizeInBits; // The current access width to attempt. 201 202 // Round down from the field offset to find the first access position that is 203 // at an aligned offset of the initial access type. 204 uint64_t AccessStart = FieldOffset - (FieldOffset % AccessWidth); 205 206 // Adjust initial access size to fit within record. 207 while (AccessWidth > 8 && 208 AccessStart + AccessWidth > ContainingTypeSizeInBits) { 209 AccessWidth >>= 1; 210 AccessStart = FieldOffset - (FieldOffset % AccessWidth); 211 } 212 213 while (AccessedTargetBits < FieldSize) { 214 // Check that we can access using a type of this size, without reading off 215 // the end of the structure. This can occur with packed structures and 216 // -fno-bitfield-type-align, for example. 217 if (AccessStart + AccessWidth > ContainingTypeSizeInBits) { 218 // If so, reduce access size to the next smaller power-of-two and retry. 219 AccessWidth >>= 1; 220 assert(AccessWidth >= 8 && "Cannot access under byte size!"); 221 continue; 222 } 223 224 // Otherwise, add an access component. 225 226 // First, compute the bits inside this access which are part of the 227 // target. We are reading bits [AccessStart, AccessStart + AccessWidth); the 228 // intersection with [FieldOffset, FieldOffset + FieldSize) gives the bits 229 // in the target that we are reading. 230 assert(FieldOffset < AccessStart + AccessWidth && "Invalid access start!"); 231 assert(AccessStart < FieldOffset + FieldSize && "Invalid access start!"); 232 uint64_t AccessBitsInFieldStart = std::max(AccessStart, FieldOffset); 233 uint64_t AccessBitsInFieldSize = 234 std::min(AccessWidth + AccessStart, 235 FieldOffset + FieldSize) - AccessBitsInFieldStart; 236 237 assert(NumComponents < 3 && "Unexpected number of components!"); 238 CGBitFieldInfo::AccessInfo &AI = Components[NumComponents++]; 239 AI.FieldIndex = 0; 240 // FIXME: We still follow the old access pattern of only using the field 241 // byte offset. We should switch this once we fix the struct layout to be 242 // pretty. 243 AI.FieldByteOffset = AccessStart / 8; 244 AI.FieldBitStart = AccessBitsInFieldStart - AccessStart; 245 AI.AccessWidth = AccessWidth; 246 AI.AccessAlignment = llvm::MinAlign(ContainingTypeAlign, AccessStart) / 8; 247 AI.TargetBitOffset = AccessedTargetBits; 248 AI.TargetBitWidth = AccessBitsInFieldSize; 249 250 AccessStart += AccessWidth; 251 AccessedTargetBits += AI.TargetBitWidth; 252 } 253 254 assert(AccessedTargetBits == FieldSize && "Invalid bit-field access!"); 255 return CGBitFieldInfo(FieldSize, NumComponents, Components, IsSigned); 256} 257 258void CGRecordLayoutBuilder::LayoutBitField(const FieldDecl *D, 259 uint64_t FieldOffset) { 260 uint64_t FieldSize = 261 D->getBitWidth()->EvaluateAsInt(Types.getContext()).getZExtValue(); 262 263 if (FieldSize == 0) 264 return; 265 266 uint64_t NextFieldOffset = NextFieldOffsetInBytes * 8; 267 unsigned NumBytesToAppend; 268 269 if (FieldOffset < NextFieldOffset) { 270 assert(BitsAvailableInLastField && "Bitfield size mismatch!"); 271 assert(NextFieldOffsetInBytes && "Must have laid out at least one byte!"); 272 273 // The bitfield begins in the previous bit-field. 274 NumBytesToAppend = 275 llvm::RoundUpToAlignment(FieldSize - BitsAvailableInLastField, 8) / 8; 276 } else { 277 assert(FieldOffset % 8 == 0 && "Field offset not aligned correctly"); 278 279 // Append padding if necessary. 280 AppendBytes((FieldOffset - NextFieldOffset) / 8); 281 282 NumBytesToAppend = 283 llvm::RoundUpToAlignment(FieldSize, 8) / 8; 284 285 assert(NumBytesToAppend && "No bytes to append!"); 286 } 287 288 // Add the bit field info. 289 LLVMBitFields.push_back( 290 LLVMBitFieldInfo(D, ComputeBitFieldInfo(Types, D, FieldOffset, FieldSize))); 291 292 AppendBytes(NumBytesToAppend); 293 294 BitsAvailableInLastField = 295 NextFieldOffsetInBytes * 8 - (FieldOffset + FieldSize); 296} 297 298bool CGRecordLayoutBuilder::LayoutField(const FieldDecl *D, 299 uint64_t FieldOffset) { 300 // If the field is packed, then we need a packed struct. 301 if (!Packed && D->hasAttr<PackedAttr>()) 302 return false; 303 304 if (D->isBitField()) { 305 // We must use packed structs for unnamed bit fields since they 306 // don't affect the struct alignment. 307 if (!Packed && !D->getDeclName()) 308 return false; 309 310 LayoutBitField(D, FieldOffset); 311 return true; 312 } 313 314 // Check if we have a pointer to data member in this field. 315 CheckForPointerToDataMember(D->getType()); 316 317 assert(FieldOffset % 8 == 0 && "FieldOffset is not on a byte boundary!"); 318 uint64_t FieldOffsetInBytes = FieldOffset / 8; 319 320 const llvm::Type *Ty = Types.ConvertTypeForMemRecursive(D->getType()); 321 unsigned TypeAlignment = getTypeAlignment(Ty); 322 323 // If the type alignment is larger then the struct alignment, we must use 324 // a packed struct. 325 if (TypeAlignment > Alignment) { 326 assert(!Packed && "Alignment is wrong even with packed struct!"); 327 return false; 328 } 329 330 if (const RecordType *RT = D->getType()->getAs<RecordType>()) { 331 const RecordDecl *RD = cast<RecordDecl>(RT->getDecl()); 332 if (const MaxFieldAlignmentAttr *MFAA = 333 RD->getAttr<MaxFieldAlignmentAttr>()) { 334 if (MFAA->getAlignment() != TypeAlignment * 8 && !Packed) 335 return false; 336 } 337 } 338 339 // Round up the field offset to the alignment of the field type. 340 uint64_t AlignedNextFieldOffsetInBytes = 341 llvm::RoundUpToAlignment(NextFieldOffsetInBytes, TypeAlignment); 342 343 if (FieldOffsetInBytes < AlignedNextFieldOffsetInBytes) { 344 assert(!Packed && "Could not place field even with packed struct!"); 345 return false; 346 } 347 348 if (AlignedNextFieldOffsetInBytes < FieldOffsetInBytes) { 349 // Even with alignment, the field offset is not at the right place, 350 // insert padding. 351 uint64_t PaddingInBytes = FieldOffsetInBytes - NextFieldOffsetInBytes; 352 353 AppendBytes(PaddingInBytes); 354 } 355 356 // Now append the field. 357 LLVMFields.push_back(LLVMFieldInfo(D, FieldTypes.size())); 358 AppendField(FieldOffsetInBytes, Ty); 359 360 return true; 361} 362 363const llvm::Type * 364CGRecordLayoutBuilder::LayoutUnionField(const FieldDecl *Field, 365 const ASTRecordLayout &Layout) { 366 if (Field->isBitField()) { 367 uint64_t FieldSize = 368 Field->getBitWidth()->EvaluateAsInt(Types.getContext()).getZExtValue(); 369 370 // Ignore zero sized bit fields. 371 if (FieldSize == 0) 372 return 0; 373 374 const llvm::Type *FieldTy = llvm::Type::getInt8Ty(Types.getLLVMContext()); 375 unsigned NumBytesToAppend = 376 llvm::RoundUpToAlignment(FieldSize, 8) / 8; 377 378 if (NumBytesToAppend > 1) 379 FieldTy = llvm::ArrayType::get(FieldTy, NumBytesToAppend); 380 381 // Add the bit field info. 382 LLVMBitFields.push_back( 383 LLVMBitFieldInfo(Field, ComputeBitFieldInfo(Types, Field, 0, FieldSize))); 384 return FieldTy; 385 } 386 387 // This is a regular union field. 388 LLVMFields.push_back(LLVMFieldInfo(Field, 0)); 389 return Types.ConvertTypeForMemRecursive(Field->getType()); 390} 391 392void CGRecordLayoutBuilder::LayoutUnion(const RecordDecl *D) { 393 assert(D->isUnion() && "Can't call LayoutUnion on a non-union record!"); 394 395 const ASTRecordLayout &Layout = Types.getContext().getASTRecordLayout(D); 396 397 const llvm::Type *Ty = 0; 398 uint64_t Size = 0; 399 unsigned Align = 0; 400 401 bool HasOnlyZeroSizedBitFields = true; 402 403 unsigned FieldNo = 0; 404 for (RecordDecl::field_iterator Field = D->field_begin(), 405 FieldEnd = D->field_end(); Field != FieldEnd; ++Field, ++FieldNo) { 406 assert(Layout.getFieldOffset(FieldNo) == 0 && 407 "Union field offset did not start at the beginning of record!"); 408 const llvm::Type *FieldTy = LayoutUnionField(*Field, Layout); 409 410 if (!FieldTy) 411 continue; 412 413 HasOnlyZeroSizedBitFields = false; 414 415 unsigned FieldAlign = Types.getTargetData().getABITypeAlignment(FieldTy); 416 uint64_t FieldSize = Types.getTargetData().getTypeAllocSize(FieldTy); 417 418 if (FieldAlign < Align) 419 continue; 420 421 if (FieldAlign > Align || FieldSize > Size) { 422 Ty = FieldTy; 423 Align = FieldAlign; 424 Size = FieldSize; 425 } 426 } 427 428 // Now add our field. 429 if (Ty) { 430 AppendField(0, Ty); 431 432 if (getTypeAlignment(Ty) > Layout.getAlignment() / 8) { 433 // We need a packed struct. 434 Packed = true; 435 Align = 1; 436 } 437 } 438 if (!Align) { 439 assert(HasOnlyZeroSizedBitFields && 440 "0-align record did not have all zero-sized bit-fields!"); 441 Align = 1; 442 } 443 444 // Append tail padding. 445 if (Layout.getSize() / 8 > Size) 446 AppendPadding(Layout.getSize() / 8, Align); 447} 448 449void CGRecordLayoutBuilder::LayoutNonVirtualBase(const CXXRecordDecl *BaseDecl, 450 uint64_t BaseOffset) { 451 const ASTRecordLayout &Layout = 452 Types.getContext().getASTRecordLayout(BaseDecl); 453 454 uint64_t NonVirtualSize = Layout.getNonVirtualSize(); 455 456 if (BaseDecl->isEmpty()) { 457 // FIXME: Lay out empty bases. 458 return; 459 } 460 461 CheckForPointerToDataMember(BaseDecl); 462 463 // FIXME: Actually use a better type than [sizeof(BaseDecl) x i8] when we can. 464 AppendPadding(BaseOffset / 8, 1); 465 466 // Append the base field. 467 LLVMNonVirtualBases.push_back(LLVMBaseInfo(BaseDecl, FieldTypes.size())); 468 469 AppendBytes(NonVirtualSize / 8); 470} 471 472void 473CGRecordLayoutBuilder::LayoutNonVirtualBases(const CXXRecordDecl *RD, 474 const ASTRecordLayout &Layout) { 475 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase(); 476 477 // Check if we need to add a vtable pointer. 478 if (RD->isDynamicClass()) { 479 if (!PrimaryBase) { 480 const llvm::Type *FunctionType = 481 llvm::FunctionType::get(llvm::Type::getInt32Ty(Types.getLLVMContext()), 482 /*isVarArg=*/true); 483 const llvm::Type *VTableTy = FunctionType->getPointerTo(); 484 485 assert(NextFieldOffsetInBytes == 0 && 486 "VTable pointer must come first!"); 487 AppendField(NextFieldOffsetInBytes, VTableTy->getPointerTo()); 488 } else { 489 // FIXME: Handle a virtual primary base. 490 if (!Layout.getPrimaryBaseWasVirtual()) 491 LayoutNonVirtualBase(PrimaryBase, 0); 492 } 493 } 494 495 // Layout the non-virtual bases. 496 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 497 E = RD->bases_end(); I != E; ++I) { 498 if (I->isVirtual()) 499 continue; 500 501 const CXXRecordDecl *BaseDecl = 502 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl()); 503 504 // We've already laid out the primary base. 505 if (BaseDecl == PrimaryBase && !Layout.getPrimaryBaseWasVirtual()) 506 continue; 507 508 LayoutNonVirtualBase(BaseDecl, Layout.getBaseClassOffset(BaseDecl)); 509 } 510} 511 512bool CGRecordLayoutBuilder::LayoutFields(const RecordDecl *D) { 513 assert(!D->isUnion() && "Can't call LayoutFields on a union!"); 514 assert(Alignment && "Did not set alignment!"); 515 516 const ASTRecordLayout &Layout = Types.getContext().getASTRecordLayout(D); 517 518 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) 519 LayoutNonVirtualBases(RD, Layout); 520 521 unsigned FieldNo = 0; 522 523 for (RecordDecl::field_iterator Field = D->field_begin(), 524 FieldEnd = D->field_end(); Field != FieldEnd; ++Field, ++FieldNo) { 525 if (!LayoutField(*Field, Layout.getFieldOffset(FieldNo))) { 526 assert(!Packed && 527 "Could not layout fields even with a packed LLVM struct!"); 528 return false; 529 } 530 } 531 532 // Append tail padding if necessary. 533 AppendTailPadding(Layout.getSize()); 534 535 return true; 536} 537 538void CGRecordLayoutBuilder::AppendTailPadding(uint64_t RecordSize) { 539 assert(RecordSize % 8 == 0 && "Invalid record size!"); 540 541 uint64_t RecordSizeInBytes = RecordSize / 8; 542 assert(NextFieldOffsetInBytes <= RecordSizeInBytes && "Size mismatch!"); 543 544 uint64_t AlignedNextFieldOffset = 545 llvm::RoundUpToAlignment(NextFieldOffsetInBytes, AlignmentAsLLVMStruct); 546 547 if (AlignedNextFieldOffset == RecordSizeInBytes) { 548 // We don't need any padding. 549 return; 550 } 551 552 unsigned NumPadBytes = RecordSizeInBytes - NextFieldOffsetInBytes; 553 AppendBytes(NumPadBytes); 554} 555 556void CGRecordLayoutBuilder::AppendField(uint64_t FieldOffsetInBytes, 557 const llvm::Type *FieldTy) { 558 AlignmentAsLLVMStruct = std::max(AlignmentAsLLVMStruct, 559 getTypeAlignment(FieldTy)); 560 561 uint64_t FieldSizeInBytes = Types.getTargetData().getTypeAllocSize(FieldTy); 562 563 FieldTypes.push_back(FieldTy); 564 565 NextFieldOffsetInBytes = FieldOffsetInBytes + FieldSizeInBytes; 566 BitsAvailableInLastField = 0; 567} 568 569void CGRecordLayoutBuilder::AppendPadding(uint64_t FieldOffsetInBytes, 570 unsigned FieldAlignment) { 571 assert(NextFieldOffsetInBytes <= FieldOffsetInBytes && 572 "Incorrect field layout!"); 573 574 // Round up the field offset to the alignment of the field type. 575 uint64_t AlignedNextFieldOffsetInBytes = 576 llvm::RoundUpToAlignment(NextFieldOffsetInBytes, FieldAlignment); 577 578 if (AlignedNextFieldOffsetInBytes < FieldOffsetInBytes) { 579 // Even with alignment, the field offset is not at the right place, 580 // insert padding. 581 uint64_t PaddingInBytes = FieldOffsetInBytes - NextFieldOffsetInBytes; 582 583 AppendBytes(PaddingInBytes); 584 } 585} 586 587void CGRecordLayoutBuilder::AppendBytes(uint64_t NumBytes) { 588 if (NumBytes == 0) 589 return; 590 591 const llvm::Type *Ty = llvm::Type::getInt8Ty(Types.getLLVMContext()); 592 if (NumBytes > 1) 593 Ty = llvm::ArrayType::get(Ty, NumBytes); 594 595 // Append the padding field 596 AppendField(NextFieldOffsetInBytes, Ty); 597} 598 599unsigned CGRecordLayoutBuilder::getTypeAlignment(const llvm::Type *Ty) const { 600 if (Packed) 601 return 1; 602 603 return Types.getTargetData().getABITypeAlignment(Ty); 604} 605 606void CGRecordLayoutBuilder::CheckForPointerToDataMember(QualType T) { 607 // This record already contains a member pointer. 608 if (ContainsPointerToDataMember) 609 return; 610 611 // Can only have member pointers if we're compiling C++. 612 if (!Types.getContext().getLangOptions().CPlusPlus) 613 return; 614 615 T = Types.getContext().getBaseElementType(T); 616 617 if (const MemberPointerType *MPT = T->getAs<MemberPointerType>()) { 618 if (!MPT->getPointeeType()->isFunctionType()) { 619 // We have a pointer to data member. 620 ContainsPointerToDataMember = true; 621 } 622 } else if (const RecordType *RT = T->getAs<RecordType>()) { 623 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 624 625 return CheckForPointerToDataMember(RD); 626 } 627} 628 629void 630CGRecordLayoutBuilder::CheckForPointerToDataMember(const CXXRecordDecl *RD) { 631 // This record already contains a member pointer. 632 if (ContainsPointerToDataMember) 633 return; 634 635 // FIXME: It would be better if there was a way to explicitly compute the 636 // record layout instead of converting to a type. 637 Types.ConvertTagDeclType(RD); 638 639 const CGRecordLayout &Layout = Types.getCGRecordLayout(RD); 640 641 if (Layout.containsPointerToDataMember()) 642 ContainsPointerToDataMember = true; 643} 644 645CGRecordLayout *CodeGenTypes::ComputeRecordLayout(const RecordDecl *D) { 646 CGRecordLayoutBuilder Builder(*this); 647 648 Builder.Layout(D); 649 650 const llvm::Type *Ty = llvm::StructType::get(getLLVMContext(), 651 Builder.FieldTypes, 652 Builder.Packed); 653 654 CGRecordLayout *RL = 655 new CGRecordLayout(Ty, Builder.ContainsPointerToDataMember); 656 657 // Add all the non-virtual base field numbers. 658 RL->NonVirtualBaseFields.insert(Builder.LLVMNonVirtualBases.begin(), 659 Builder.LLVMNonVirtualBases.end()); 660 661 // Add all the field numbers. 662 RL->FieldInfo.insert(Builder.LLVMFields.begin(), 663 Builder.LLVMFields.end()); 664 665 // Add bitfield info. 666 RL->BitFields.insert(Builder.LLVMBitFields.begin(), 667 Builder.LLVMBitFields.end()); 668 669 // Dump the layout, if requested. 670 if (getContext().getLangOptions().DumpRecordLayouts) { 671 llvm::errs() << "\n*** Dumping IRgen Record Layout\n"; 672 llvm::errs() << "Record: "; 673 D->dump(); 674 llvm::errs() << "\nLayout: "; 675 RL->dump(); 676 } 677 678#ifndef NDEBUG 679 // Verify that the computed LLVM struct size matches the AST layout size. 680 uint64_t TypeSizeInBits = getContext().getASTRecordLayout(D).getSize(); 681 assert(TypeSizeInBits == getTargetData().getTypeAllocSizeInBits(Ty) && 682 "Type size mismatch!"); 683 684 // Verify that the LLVM and AST field offsets agree. 685 const llvm::StructType *ST = 686 dyn_cast<llvm::StructType>(RL->getLLVMType()); 687 const llvm::StructLayout *SL = getTargetData().getStructLayout(ST); 688 689 const ASTRecordLayout &AST_RL = getContext().getASTRecordLayout(D); 690 RecordDecl::field_iterator it = D->field_begin(); 691 for (unsigned i = 0, e = AST_RL.getFieldCount(); i != e; ++i, ++it) { 692 const FieldDecl *FD = *it; 693 694 // For non-bit-fields, just check that the LLVM struct offset matches the 695 // AST offset. 696 if (!FD->isBitField()) { 697 unsigned FieldNo = RL->getLLVMFieldNo(FD); 698 assert(AST_RL.getFieldOffset(i) == SL->getElementOffsetInBits(FieldNo) && 699 "Invalid field offset!"); 700 continue; 701 } 702 703 // Ignore unnamed bit-fields. 704 if (!FD->getDeclName()) 705 continue; 706 707 const CGBitFieldInfo &Info = RL->getBitFieldInfo(FD); 708 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) { 709 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i); 710 711 // Verify that every component access is within the structure. 712 uint64_t FieldOffset = SL->getElementOffsetInBits(AI.FieldIndex); 713 uint64_t AccessBitOffset = FieldOffset + AI.FieldByteOffset * 8; 714 assert(AccessBitOffset + AI.AccessWidth <= TypeSizeInBits && 715 "Invalid bit-field access (out of range)!"); 716 } 717 } 718#endif 719 720 return RL; 721} 722 723void CGRecordLayout::print(llvm::raw_ostream &OS) const { 724 OS << "<CGRecordLayout\n"; 725 OS << " LLVMType:" << *LLVMType << "\n"; 726 OS << " ContainsPointerToDataMember:" << ContainsPointerToDataMember << "\n"; 727 OS << " BitFields:[\n"; 728 729 // Print bit-field infos in declaration order. 730 std::vector<std::pair<unsigned, const CGBitFieldInfo*> > BFIs; 731 for (llvm::DenseMap<const FieldDecl*, CGBitFieldInfo>::const_iterator 732 it = BitFields.begin(), ie = BitFields.end(); 733 it != ie; ++it) { 734 const RecordDecl *RD = it->first->getParent(); 735 unsigned Index = 0; 736 for (RecordDecl::field_iterator 737 it2 = RD->field_begin(); *it2 != it->first; ++it2) 738 ++Index; 739 BFIs.push_back(std::make_pair(Index, &it->second)); 740 } 741 llvm::array_pod_sort(BFIs.begin(), BFIs.end()); 742 for (unsigned i = 0, e = BFIs.size(); i != e; ++i) { 743 OS.indent(4); 744 BFIs[i].second->print(OS); 745 OS << "\n"; 746 } 747 748 OS << "]>\n"; 749} 750 751void CGRecordLayout::dump() const { 752 print(llvm::errs()); 753} 754 755void CGBitFieldInfo::print(llvm::raw_ostream &OS) const { 756 OS << "<CGBitFieldInfo"; 757 OS << " Size:" << Size; 758 OS << " IsSigned:" << IsSigned << "\n"; 759 760 OS.indent(4 + strlen("<CGBitFieldInfo")); 761 OS << " NumComponents:" << getNumComponents(); 762 OS << " Components: ["; 763 if (getNumComponents()) { 764 OS << "\n"; 765 for (unsigned i = 0, e = getNumComponents(); i != e; ++i) { 766 const AccessInfo &AI = getComponent(i); 767 OS.indent(8); 768 OS << "<AccessInfo" 769 << " FieldIndex:" << AI.FieldIndex 770 << " FieldByteOffset:" << AI.FieldByteOffset 771 << " FieldBitStart:" << AI.FieldBitStart 772 << " AccessWidth:" << AI.AccessWidth << "\n"; 773 OS.indent(8 + strlen("<AccessInfo")); 774 OS << " AccessAlignment:" << AI.AccessAlignment 775 << " TargetBitOffset:" << AI.TargetBitOffset 776 << " TargetBitWidth:" << AI.TargetBitWidth 777 << ">\n"; 778 } 779 OS.indent(4); 780 } 781 OS << "]>"; 782} 783 784void CGBitFieldInfo::dump() const { 785 print(llvm::errs()); 786} 787