Clang Project

clang_source_code/lib/CodeGen/CGRecordLayoutBuilder.cpp
1//===--- CGRecordLayoutBuilder.cpp - CGRecordLayout builder  ----*- C++ -*-===//
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// Builder implementation for CGRecordLayout objects.
10//
11//===----------------------------------------------------------------------===//
12
13#include "CGRecordLayout.h"
14#include "CGCXXABI.h"
15#include "CodeGenTypes.h"
16#include "clang/AST/ASTContext.h"
17#include "clang/AST/Attr.h"
18#include "clang/AST/CXXInheritance.h"
19#include "clang/AST/DeclCXX.h"
20#include "clang/AST/Expr.h"
21#include "clang/AST/RecordLayout.h"
22#include "clang/Basic/CodeGenOptions.h"
23#include "llvm/IR/DataLayout.h"
24#include "llvm/IR/DerivedTypes.h"
25#include "llvm/IR/Type.h"
26#include "llvm/Support/Debug.h"
27#include "llvm/Support/MathExtras.h"
28#include "llvm/Support/raw_ostream.h"
29using namespace clang;
30using namespace CodeGen;
31
32namespace {
33/// The CGRecordLowering is responsible for lowering an ASTRecordLayout to an
34/// llvm::Type.  Some of the lowering is straightforward, some is not.  Here we
35/// detail some of the complexities and weirdnesses here.
36/// * LLVM does not have unions - Unions can, in theory be represented by any
37///   llvm::Type with correct size.  We choose a field via a specific heuristic
38///   and add padding if necessary.
39/// * LLVM does not have bitfields - Bitfields are collected into contiguous
40///   runs and allocated as a single storage type for the run.  ASTRecordLayout
41///   contains enough information to determine where the runs break.  Microsoft
42///   and Itanium follow different rules and use different codepaths.
43/// * It is desired that, when possible, bitfields use the appropriate iN type
44///   when lowered to llvm types.  For example unsigned x : 24 gets lowered to
45///   i24.  This isn't always possible because i24 has storage size of 32 bit
46///   and if it is possible to use that extra byte of padding we must use
47///   [i8 x 3] instead of i24.  The function clipTailPadding does this.
48///   C++ examples that require clipping:
49///   struct { int a : 24; char b; }; // a must be clipped, b goes at offset 3
50///   struct A { int a : 24; }; // a must be clipped because a struct like B
51//    could exist: struct B : A { char b; }; // b goes at offset 3
52/// * Clang ignores 0 sized bitfields and 0 sized bases but *not* zero sized
53///   fields.  The existing asserts suggest that LLVM assumes that *every* field
54///   has an underlying storage type.  Therefore empty structures containing
55///   zero sized subobjects such as empty records or zero sized arrays still get
56///   a zero sized (empty struct) storage type.
57/// * Clang reads the complete type rather than the base type when generating
58///   code to access fields.  Bitfields in tail position with tail padding may
59///   be clipped in the base class but not the complete class (we may discover
60///   that the tail padding is not used in the complete class.) However,
61///   because LLVM reads from the complete type it can generate incorrect code
62///   if we do not clip the tail padding off of the bitfield in the complete
63///   layout.  This introduces a somewhat awkward extra unnecessary clip stage.
64///   The location of the clip is stored internally as a sentinel of type
65///   SCISSOR.  If LLVM were updated to read base types (which it probably
66///   should because locations of things such as VBases are bogus in the llvm
67///   type anyway) then we could eliminate the SCISSOR.
68/// * Itanium allows nearly empty primary virtual bases.  These bases don't get
69///   get their own storage because they're laid out as part of another base
70///   or at the beginning of the structure.  Determining if a VBase actually
71///   gets storage awkwardly involves a walk of all bases.
72/// * VFPtrs and VBPtrs do *not* make a record NotZeroInitializable.
73struct CGRecordLowering {
74  // MemberInfo is a helper structure that contains information about a record
75  // member.  In additional to the standard member types, there exists a
76  // sentinel member type that ensures correct rounding.
77  struct MemberInfo {
78    CharUnits Offset;
79    enum InfoKind { VFPtr, VBPtr, Field, Base, VBase, Scissor } Kind;
80    llvm::Type *Data;
81    union {
82      const FieldDecl *FD;
83      const CXXRecordDecl *RD;
84    };
85    MemberInfo(CharUnits Offset, InfoKind Kind, llvm::Type *Data,
86               const FieldDecl *FD = nullptr)
87      : Offset(Offset), Kind(Kind), Data(Data), FD(FD) {}
88    MemberInfo(CharUnits Offset, InfoKind Kind, llvm::Type *Data,
89               const CXXRecordDecl *RD)
90      : Offset(Offset), Kind(Kind), Data(Data), RD(RD) {}
91    // MemberInfos are sorted so we define a < operator.
92    bool operator <(const MemberInfo& a) const { return Offset < a.Offset; }
93  };
94  // The constructor.
95  CGRecordLowering(CodeGenTypes &Types, const RecordDecl *D, bool Packed);
96  // Short helper routines.
97  /// Constructs a MemberInfo instance from an offset and llvm::Type *.
98  MemberInfo StorageInfo(CharUnits Offset, llvm::Type *Data) {
99    return MemberInfo(Offset, MemberInfo::Field, Data);
100  }
101
102  /// The Microsoft bitfield layout rule allocates discrete storage
103  /// units of the field's formal type and only combines adjacent
104  /// fields of the same formal type.  We want to emit a layout with
105  /// these discrete storage units instead of combining them into a
106  /// continuous run.
107  bool isDiscreteBitFieldABI() {
108    return Context.getTargetInfo().getCXXABI().isMicrosoft() ||
109           D->isMsStruct(Context);
110  }
111
112  /// The Itanium base layout rule allows virtual bases to overlap
113  /// other bases, which complicates layout in specific ways.
114  ///
115  /// Note specifically that the ms_struct attribute doesn't change this.
116  bool isOverlappingVBaseABI() {
117    return !Context.getTargetInfo().getCXXABI().isMicrosoft();
118  }
119
120  /// Wraps llvm::Type::getIntNTy with some implicit arguments.
121  llvm::Type *getIntNType(uint64_t NumBits) {
122    return llvm::Type::getIntNTy(Types.getLLVMContext(),
123                                 (unsigned)llvm::alignTo(NumBits, 8));
124  }
125  /// Gets an llvm type of size NumBytes and alignment 1.
126  llvm::Type *getByteArrayType(CharUnits NumBytes) {
127     (0) . __assert_fail ("!NumBytes.isZero() && \"Empty byte arrays aren't allowed.\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 127, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(!NumBytes.isZero() && "Empty byte arrays aren't allowed.");
128    llvm::Type *Type = llvm::Type::getInt8Ty(Types.getLLVMContext());
129    return NumBytes == CharUnits::One() ? Type :
130        (llvm::Type *)llvm::ArrayType::get(Type, NumBytes.getQuantity());
131  }
132  /// Gets the storage type for a field decl and handles storage
133  /// for itanium bitfields that are smaller than their declared type.
134  llvm::Type *getStorageType(const FieldDecl *FD) {
135    llvm::Type *Type = Types.ConvertTypeForMem(FD->getType());
136    if (!FD->isBitField()) return Type;
137    if (isDiscreteBitFieldABI()) return Type;
138    return getIntNType(std::min(FD->getBitWidthValue(Context),
139                             (unsigned)Context.toBits(getSize(Type))));
140  }
141  /// Gets the llvm Basesubobject type from a CXXRecordDecl.
142  llvm::Type *getStorageType(const CXXRecordDecl *RD) {
143    return Types.getCGRecordLayout(RD).getBaseSubobjectLLVMType();
144  }
145  CharUnits bitsToCharUnits(uint64_t BitOffset) {
146    return Context.toCharUnitsFromBits(BitOffset);
147  }
148  CharUnits getSize(llvm::Type *Type) {
149    return CharUnits::fromQuantity(DataLayout.getTypeAllocSize(Type));
150  }
151  CharUnits getAlignment(llvm::Type *Type) {
152    return CharUnits::fromQuantity(DataLayout.getABITypeAlignment(Type));
153  }
154  bool isZeroInitializable(const FieldDecl *FD) {
155    return Types.isZeroInitializable(FD->getType());
156  }
157  bool isZeroInitializable(const RecordDecl *RD) {
158    return Types.isZeroInitializable(RD);
159  }
160  void appendPaddingBytes(CharUnits Size) {
161    if (!Size.isZero())
162      FieldTypes.push_back(getByteArrayType(Size));
163  }
164  uint64_t getFieldBitOffset(const FieldDecl *FD) {
165    return Layout.getFieldOffset(FD->getFieldIndex());
166  }
167  // Layout routines.
168  void setBitFieldInfo(const FieldDecl *FD, CharUnits StartOffset,
169                       llvm::Type *StorageType);
170  /// Lowers an ASTRecordLayout to a llvm type.
171  void lower(bool NonVirtualBaseType);
172  void lowerUnion();
173  void accumulateFields();
174  void accumulateBitFields(RecordDecl::field_iterator Field,
175                        RecordDecl::field_iterator FieldEnd);
176  void accumulateBases();
177  void accumulateVPtrs();
178  void accumulateVBases();
179  /// Recursively searches all of the bases to find out if a vbase is
180  /// not the primary vbase of some base class.
181  bool hasOwnStorage(const CXXRecordDecl *Decl, const CXXRecordDecl *Query);
182  void calculateZeroInit();
183  /// Lowers bitfield storage types to I8 arrays for bitfields with tail
184  /// padding that is or can potentially be used.
185  void clipTailPadding();
186  /// Determines if we need a packed llvm struct.
187  void determinePacked(bool NVBaseType);
188  /// Inserts padding everywhere it's needed.
189  void insertPadding();
190  /// Fills out the structures that are ultimately consumed.
191  void fillOutputFields();
192  // Input memoization fields.
193  CodeGenTypes &Types;
194  const ASTContext &Context;
195  const RecordDecl *D;
196  const CXXRecordDecl *RD;
197  const ASTRecordLayout &Layout;
198  const llvm::DataLayout &DataLayout;
199  // Helpful intermediate data-structures.
200  std::vector<MemberInfo> Members;
201  // Output fields, consumed by CodeGenTypes::ComputeRecordLayout.
202  SmallVector<llvm::Type *, 16> FieldTypes;
203  llvm::DenseMap<const FieldDecl *, unsigned> Fields;
204  llvm::DenseMap<const FieldDecl *, CGBitFieldInfo> BitFields;
205  llvm::DenseMap<const CXXRecordDecl *, unsigned> NonVirtualBases;
206  llvm::DenseMap<const CXXRecordDecl *, unsigned> VirtualBases;
207  bool IsZeroInitializable : 1;
208  bool IsZeroInitializableAsBase : 1;
209  bool Packed : 1;
210private:
211  CGRecordLowering(const CGRecordLowering &) = delete;
212  void operator =(const CGRecordLowering &) = delete;
213};
214} // namespace {
215
216CGRecordLowering::CGRecordLowering(CodeGenTypes &Types, const RecordDecl *D,
217                                   bool Packed)
218    : Types(Types), Context(Types.getContext()), D(D),
219      RD(dyn_cast<CXXRecordDecl>(D)),
220      Layout(Types.getContext().getASTRecordLayout(D)),
221      DataLayout(Types.getDataLayout()), IsZeroInitializable(true),
222      IsZeroInitializableAsBase(true), Packed(Packed) {}
223
224void CGRecordLowering::setBitFieldInfo(
225    const FieldDecl *FD, CharUnits StartOffset, llvm::Type *StorageType) {
226  CGBitFieldInfo &Info = BitFields[FD->getCanonicalDecl()];
227  Info.IsSigned = FD->getType()->isSignedIntegerOrEnumerationType();
228  Info.Offset = (unsigned)(getFieldBitOffset(FD) - Context.toBits(StartOffset));
229  Info.Size = FD->getBitWidthValue(Context);
230  Info.StorageSize = (unsigned)DataLayout.getTypeAllocSizeInBits(StorageType);
231  Info.StorageOffset = StartOffset;
232  if (Info.Size > Info.StorageSize)
233    Info.Size = Info.StorageSize;
234  // Reverse the bit offsets for big endian machines. Because we represent
235  // a bitfield as a single large integer load, we can imagine the bits
236  // counting from the most-significant-bit instead of the
237  // least-significant-bit.
238  if (DataLayout.isBigEndian())
239    Info.Offset = Info.StorageSize - (Info.Offset + Info.Size);
240}
241
242void CGRecordLowering::lower(bool NVBaseType) {
243  // The lowering process implemented in this function takes a variety of
244  // carefully ordered phases.
245  // 1) Store all members (fields and bases) in a list and sort them by offset.
246  // 2) Add a 1-byte capstone member at the Size of the structure.
247  // 3) Clip bitfield storages members if their tail padding is or might be
248  //    used by another field or base.  The clipping process uses the capstone
249  //    by treating it as another object that occurs after the record.
250  // 4) Determine if the llvm-struct requires packing.  It's important that this
251  //    phase occur after clipping, because clipping changes the llvm type.
252  //    This phase reads the offset of the capstone when determining packedness
253  //    and updates the alignment of the capstone to be equal of the alignment
254  //    of the record after doing so.
255  // 5) Insert padding everywhere it is needed.  This phase requires 'Packed' to
256  //    have been computed and needs to know the alignment of the record in
257  //    order to understand if explicit tail padding is needed.
258  // 6) Remove the capstone, we don't need it anymore.
259  // 7) Determine if this record can be zero-initialized.  This phase could have
260  //    been placed anywhere after phase 1.
261  // 8) Format the complete list of members in a way that can be consumed by
262  //    CodeGenTypes::ComputeRecordLayout.
263  CharUnits Size = NVBaseType ? Layout.getNonVirtualSize() : Layout.getSize();
264  if (D->isUnion())
265    return lowerUnion();
266  accumulateFields();
267  // RD implies C++.
268  if (RD) {
269    accumulateVPtrs();
270    accumulateBases();
271    if (Members.empty())
272      return appendPaddingBytes(Size);
273    if (!NVBaseType)
274      accumulateVBases();
275  }
276  std::stable_sort(Members.begin(), Members.end());
277  Members.push_back(StorageInfo(Size, getIntNType(8)));
278  clipTailPadding();
279  determinePacked(NVBaseType);
280  insertPadding();
281  Members.pop_back();
282  calculateZeroInit();
283  fillOutputFields();
284}
285
286void CGRecordLowering::lowerUnion() {
287  CharUnits LayoutSize = Layout.getSize();
288  llvm::Type *StorageType = nullptr;
289  bool SeenNamedMember = false;
290  // Iterate through the fields setting bitFieldInfo and the Fields array. Also
291  // locate the "most appropriate" storage type.  The heuristic for finding the
292  // storage type isn't necessary, the first (non-0-length-bitfield) field's
293  // type would work fine and be simpler but would be different than what we've
294  // been doing and cause lit tests to change.
295  for (const auto *Field : D->fields()) {
296    if (Field->isBitField()) {
297      if (Field->isZeroLengthBitField(Context))
298        continue;
299      llvm::Type *FieldType = getStorageType(Field);
300      if (LayoutSize < getSize(FieldType))
301        FieldType = getByteArrayType(LayoutSize);
302      setBitFieldInfo(Field, CharUnits::Zero(), FieldType);
303    }
304    Fields[Field->getCanonicalDecl()] = 0;
305    llvm::Type *FieldType = getStorageType(Field);
306    // Compute zero-initializable status.
307    // This union might not be zero initialized: it may contain a pointer to
308    // data member which might have some exotic initialization sequence.
309    // If this is the case, then we aught not to try and come up with a "better"
310    // type, it might not be very easy to come up with a Constant which
311    // correctly initializes it.
312    if (!SeenNamedMember) {
313      SeenNamedMember = Field->getIdentifier();
314      if (!SeenNamedMember)
315        if (const auto *FieldRD = Field->getType()->getAsRecordDecl())
316          SeenNamedMember = FieldRD->findFirstNamedDataMember();
317      if (SeenNamedMember && !isZeroInitializable(Field)) {
318        IsZeroInitializable = IsZeroInitializableAsBase = false;
319        StorageType = FieldType;
320      }
321    }
322    // Because our union isn't zero initializable, we won't be getting a better
323    // storage type.
324    if (!IsZeroInitializable)
325      continue;
326    // Conditionally update our storage type if we've got a new "better" one.
327    if (!StorageType ||
328        getAlignment(FieldType) >  getAlignment(StorageType) ||
329        (getAlignment(FieldType) == getAlignment(StorageType) &&
330        getSize(FieldType) > getSize(StorageType)))
331      StorageType = FieldType;
332  }
333  // If we have no storage type just pad to the appropriate size and return.
334  if (!StorageType)
335    return appendPaddingBytes(LayoutSize);
336  // If our storage size was bigger than our required size (can happen in the
337  // case of packed bitfields on Itanium) then just use an I8 array.
338  if (LayoutSize < getSize(StorageType))
339    StorageType = getByteArrayType(LayoutSize);
340  FieldTypes.push_back(StorageType);
341  appendPaddingBytes(LayoutSize - getSize(StorageType));
342  // Set packed if we need it.
343  if (LayoutSize % getAlignment(StorageType))
344    Packed = true;
345}
346
347void CGRecordLowering::accumulateFields() {
348  for (RecordDecl::field_iterator Field = D->field_begin(),
349                                  FieldEnd = D->field_end();
350    Field != FieldEnd;)
351    if (Field->isBitField()) {
352      RecordDecl::field_iterator Start = Field;
353      // Iterate to gather the list of bitfields.
354      for (++Field; Field != FieldEnd && Field->isBitField(); ++Field);
355      accumulateBitFields(Start, Field);
356    } else {
357      Members.push_back(MemberInfo(
358          bitsToCharUnits(getFieldBitOffset(*Field)), MemberInfo::Field,
359          getStorageType(*Field), *Field));
360      ++Field;
361    }
362}
363
364void
365CGRecordLowering::accumulateBitFields(RecordDecl::field_iterator Field,
366                                      RecordDecl::field_iterator FieldEnd) {
367  // Run stores the first element of the current run of bitfields.  FieldEnd is
368  // used as a special value to note that we don't have a current run.  A
369  // bitfield run is a contiguous collection of bitfields that can be stored in
370  // the same storage block.  Zero-sized bitfields and bitfields that would
371  // cross an alignment boundary break a run and start a new one.
372  RecordDecl::field_iterator Run = FieldEnd;
373  // Tail is the offset of the first bit off the end of the current run.  It's
374  // used to determine if the ASTRecordLayout is treating these two bitfields as
375  // contiguous.  StartBitOffset is offset of the beginning of the Run.
376  uint64_t StartBitOffset, Tail = 0;
377  if (isDiscreteBitFieldABI()) {
378    for (; Field != FieldEnd; ++Field) {
379      uint64_t BitOffset = getFieldBitOffset(*Field);
380      // Zero-width bitfields end runs.
381      if (Field->isZeroLengthBitField(Context)) {
382        Run = FieldEnd;
383        continue;
384      }
385      llvm::Type *Type = Types.ConvertTypeForMem(Field->getType());
386      // If we don't have a run yet, or don't live within the previous run's
387      // allocated storage then we allocate some storage and start a new run.
388      if (Run == FieldEnd || BitOffset >= Tail) {
389        Run = Field;
390        StartBitOffset = BitOffset;
391        Tail = StartBitOffset + DataLayout.getTypeAllocSizeInBits(Type);
392        // Add the storage member to the record.  This must be added to the
393        // record before the bitfield members so that it gets laid out before
394        // the bitfields it contains get laid out.
395        Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset), Type));
396      }
397      // Bitfields get the offset of their storage but come afterward and remain
398      // there after a stable sort.
399      Members.push_back(MemberInfo(bitsToCharUnits(StartBitOffset),
400                                   MemberInfo::Field, nullptr, *Field));
401    }
402    return;
403  }
404
405  // Check if OffsetInRecord is better as a single field run. When OffsetInRecord
406  // has legal integer width, and its bitfield offset is naturally aligned, it
407  // is better to make the bitfield a separate storage component so as it can be
408  // accessed directly with lower cost.
409  auto IsBetterAsSingleFieldRun = [&](uint64_t OffsetInRecord,
410                                      uint64_t StartBitOffset) {
411    if (!Types.getCodeGenOpts().FineGrainedBitfieldAccesses)
412      return false;
413    if (!DataLayout.isLegalInteger(OffsetInRecord))
414      return false;
415    // Make sure StartBitOffset is natually aligned if it is treated as an
416    // IType integer.
417     if (StartBitOffset %
418            Context.toBits(getAlignment(getIntNType(OffsetInRecord))) !=
419        0)
420      return false;
421    return true;
422  };
423
424  // The start field is better as a single field run.
425  bool StartFieldAsSingleRun = false;
426  for (;;) {
427    // Check to see if we need to start a new run.
428    if (Run == FieldEnd) {
429      // If we're out of fields, return.
430      if (Field == FieldEnd)
431        break;
432      // Any non-zero-length bitfield can start a new run.
433      if (!Field->isZeroLengthBitField(Context)) {
434        Run = Field;
435        StartBitOffset = getFieldBitOffset(*Field);
436        Tail = StartBitOffset + Field->getBitWidthValue(Context);
437        StartFieldAsSingleRun = IsBetterAsSingleFieldRun(Tail - StartBitOffset,
438                                                         StartBitOffset);
439      }
440      ++Field;
441      continue;
442    }
443
444    // If the start field of a new run is better as a single run, or
445    // if current field (or consecutive fields) is better as a single run, or
446    // if current field has zero width bitfield and either
447    // UseZeroLengthBitfieldAlignment or UseBitFieldTypeAlignment is set to
448    // true, or
449    // if the offset of current field is inconsistent with the offset of
450    // previous field plus its offset,
451    // skip the block below and go ahead to emit the storage.
452    // Otherwise, try to add bitfields to the run.
453    if (!StartFieldAsSingleRun && Field != FieldEnd &&
454        !IsBetterAsSingleFieldRun(Tail - StartBitOffset, StartBitOffset) &&
455        (!Field->isZeroLengthBitField(Context) ||
456         (!Context.getTargetInfo().useZeroLengthBitfieldAlignment() &&
457          !Context.getTargetInfo().useBitFieldTypeAlignment())) &&
458        Tail == getFieldBitOffset(*Field)) {
459      Tail += Field->getBitWidthValue(Context);
460      ++Field;
461      continue;
462    }
463
464    // We've hit a break-point in the run and need to emit a storage field.
465    llvm::Type *Type = getIntNType(Tail - StartBitOffset);
466    // Add the storage member to the record and set the bitfield info for all of
467    // the bitfields in the run.  Bitfields get the offset of their storage but
468    // come afterward and remain there after a stable sort.
469    Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset), Type));
470    for (; Run != Field; ++Run)
471      Members.push_back(MemberInfo(bitsToCharUnits(StartBitOffset),
472                                   MemberInfo::Field, nullptr, *Run));
473    Run = FieldEnd;
474    StartFieldAsSingleRun = false;
475  }
476}
477
478void CGRecordLowering::accumulateBases() {
479  // If we've got a primary virtual base, we need to add it with the bases.
480  if (Layout.isPrimaryBaseVirtual()) {
481    const CXXRecordDecl *BaseDecl = Layout.getPrimaryBase();
482    Members.push_back(MemberInfo(CharUnits::Zero(), MemberInfo::Base,
483                                 getStorageType(BaseDecl), BaseDecl));
484  }
485  // Accumulate the non-virtual bases.
486  for (const auto &Base : RD->bases()) {
487    if (Base.isVirtual())
488      continue;
489
490    // Bases can be zero-sized even if not technically empty if they
491    // contain only a trailing array member.
492    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
493    if (!BaseDecl->isEmpty() &&
494        !Context.getASTRecordLayout(BaseDecl).getNonVirtualSize().isZero())
495      Members.push_back(MemberInfo(Layout.getBaseClassOffset(BaseDecl),
496          MemberInfo::Base, getStorageType(BaseDecl), BaseDecl));
497  }
498}
499
500void CGRecordLowering::accumulateVPtrs() {
501  if (Layout.hasOwnVFPtr())
502    Members.push_back(MemberInfo(CharUnits::Zero(), MemberInfo::VFPtr,
503        llvm::FunctionType::get(getIntNType(32), /*isVarArg=*/true)->
504            getPointerTo()->getPointerTo()));
505  if (Layout.hasOwnVBPtr())
506    Members.push_back(MemberInfo(Layout.getVBPtrOffset(), MemberInfo::VBPtr,
507        llvm::Type::getInt32PtrTy(Types.getLLVMContext())));
508}
509
510void CGRecordLowering::accumulateVBases() {
511  CharUnits ScissorOffset = Layout.getNonVirtualSize();
512  // In the itanium ABI, it's possible to place a vbase at a dsize that is
513  // smaller than the nvsize.  Here we check to see if such a base is placed
514  // before the nvsize and set the scissor offset to that, instead of the
515  // nvsize.
516  if (isOverlappingVBaseABI())
517    for (const auto &Base : RD->vbases()) {
518      const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
519      if (BaseDecl->isEmpty())
520        continue;
521      // If the vbase is a primary virtual base of some base, then it doesn't
522      // get its own storage location but instead lives inside of that base.
523      if (Context.isNearlyEmpty(BaseDecl) && !hasOwnStorage(RD, BaseDecl))
524        continue;
525      ScissorOffset = std::min(ScissorOffset,
526                               Layout.getVBaseClassOffset(BaseDecl));
527    }
528  Members.push_back(MemberInfo(ScissorOffset, MemberInfo::Scissor, nullptr,
529                               RD));
530  for (const auto &Base : RD->vbases()) {
531    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
532    if (BaseDecl->isEmpty())
533      continue;
534    CharUnits Offset = Layout.getVBaseClassOffset(BaseDecl);
535    // If the vbase is a primary virtual base of some base, then it doesn't
536    // get its own storage location but instead lives inside of that base.
537    if (isOverlappingVBaseABI() &&
538        Context.isNearlyEmpty(BaseDecl) &&
539        !hasOwnStorage(RD, BaseDecl)) {
540      Members.push_back(MemberInfo(Offset, MemberInfo::VBase, nullptr,
541                                   BaseDecl));
542      continue;
543    }
544    // If we've got a vtordisp, add it as a storage type.
545    if (Layout.getVBaseOffsetsMap().find(BaseDecl)->second.hasVtorDisp())
546      Members.push_back(StorageInfo(Offset - CharUnits::fromQuantity(4),
547                                    getIntNType(32)));
548    Members.push_back(MemberInfo(Offset, MemberInfo::VBase,
549                                 getStorageType(BaseDecl), BaseDecl));
550  }
551}
552
553bool CGRecordLowering::hasOwnStorage(const CXXRecordDecl *Decl,
554                                     const CXXRecordDecl *Query) {
555  const ASTRecordLayout &DeclLayout = Context.getASTRecordLayout(Decl);
556  if (DeclLayout.isPrimaryBaseVirtual() && DeclLayout.getPrimaryBase() == Query)
557    return false;
558  for (const auto &Base : Decl->bases())
559    if (!hasOwnStorage(Base.getType()->getAsCXXRecordDecl(), Query))
560      return false;
561  return true;
562}
563
564void CGRecordLowering::calculateZeroInit() {
565  for (std::vector<MemberInfo>::const_iterator Member = Members.begin(),
566                                               MemberEnd = Members.end();
567       IsZeroInitializableAsBase && Member != MemberEnd; ++Member) {
568    if (Member->Kind == MemberInfo::Field) {
569      if (!Member->FD || isZeroInitializable(Member->FD))
570        continue;
571      IsZeroInitializable = IsZeroInitializableAsBase = false;
572    } else if (Member->Kind == MemberInfo::Base ||
573               Member->Kind == MemberInfo::VBase) {
574      if (isZeroInitializable(Member->RD))
575        continue;
576      IsZeroInitializable = false;
577      if (Member->Kind == MemberInfo::Base)
578        IsZeroInitializableAsBase = false;
579    }
580  }
581}
582
583void CGRecordLowering::clipTailPadding() {
584  std::vector<MemberInfo>::iterator Prior = Members.begin();
585  CharUnits Tail = getSize(Prior->Data);
586  for (std::vector<MemberInfo>::iterator Member = Prior + 1,
587                                         MemberEnd = Members.end();
588       Member != MemberEnd; ++Member) {
589    // Only members with data and the scissor can cut into tail padding.
590    if (!Member->Data && Member->Kind != MemberInfo::Scissor)
591      continue;
592    if (Member->Offset < Tail) {
593       (0) . __assert_fail ("Prior->Kind == MemberInfo..Field && !Prior->FD && \"Only storage fields have tail padding!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 594, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Prior->Kind == MemberInfo::Field && !Prior->FD &&
594 (0) . __assert_fail ("Prior->Kind == MemberInfo..Field && !Prior->FD && \"Only storage fields have tail padding!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 594, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">             "Only storage fields have tail padding!");
595      Prior->Data = getByteArrayType(bitsToCharUnits(llvm::alignTo(
596          cast<llvm::IntegerType>(Prior->Data)->getIntegerBitWidth(), 8)));
597    }
598    if (Member->Data)
599      Prior = Member;
600    Tail = Prior->Offset + getSize(Prior->Data);
601  }
602}
603
604void CGRecordLowering::determinePacked(bool NVBaseType) {
605  if (Packed)
606    return;
607  CharUnits Alignment = CharUnits::One();
608  CharUnits NVAlignment = CharUnits::One();
609  CharUnits NVSize =
610      !NVBaseType && RD ? Layout.getNonVirtualSize() : CharUnits::Zero();
611  for (std::vector<MemberInfo>::const_iterator Member = Members.begin(),
612                                               MemberEnd = Members.end();
613       Member != MemberEnd; ++Member) {
614    if (!Member->Data)
615      continue;
616    // If any member falls at an offset that it not a multiple of its alignment,
617    // then the entire record must be packed.
618    if (Member->Offset % getAlignment(Member->Data))
619      Packed = true;
620    if (Member->Offset < NVSize)
621      NVAlignment = std::max(NVAlignment, getAlignment(Member->Data));
622    Alignment = std::max(Alignment, getAlignment(Member->Data));
623  }
624  // If the size of the record (the capstone's offset) is not a multiple of the
625  // record's alignment, it must be packed.
626  if (Members.back().Offset % Alignment)
627    Packed = true;
628  // If the non-virtual sub-object is not a multiple of the non-virtual
629  // sub-object's alignment, it must be packed.  We cannot have a packed
630  // non-virtual sub-object and an unpacked complete object or vise versa.
631  if (NVSize % NVAlignment)
632    Packed = true;
633  // Update the alignment of the sentinel.
634  if (!Packed)
635    Members.back().Data = getIntNType(Context.toBits(Alignment));
636}
637
638void CGRecordLowering::insertPadding() {
639  std::vector<std::pair<CharUnits, CharUnits> > Padding;
640  CharUnits Size = CharUnits::Zero();
641  for (std::vector<MemberInfo>::const_iterator Member = Members.begin(),
642                                               MemberEnd = Members.end();
643       Member != MemberEnd; ++Member) {
644    if (!Member->Data)
645      continue;
646    CharUnits Offset = Member->Offset;
647    = Size", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 647, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Offset >= Size);
648    // Insert padding if we need to.
649    if (Offset !=
650        Size.alignTo(Packed ? CharUnits::One() : getAlignment(Member->Data)))
651      Padding.push_back(std::make_pair(Size, Offset - Size));
652    Size = Offset + getSize(Member->Data);
653  }
654  if (Padding.empty())
655    return;
656  // Add the padding to the Members list and sort it.
657  for (std::vector<std::pair<CharUnits, CharUnits> >::const_iterator
658        Pad = Padding.begin(), PadEnd = Padding.end();
659        Pad != PadEnd; ++Pad)
660    Members.push_back(StorageInfo(Pad->first, getByteArrayType(Pad->second)));
661  std::stable_sort(Members.begin(), Members.end());
662}
663
664void CGRecordLowering::fillOutputFields() {
665  for (std::vector<MemberInfo>::const_iterator Member = Members.begin(),
666                                               MemberEnd = Members.end();
667       Member != MemberEnd; ++Member) {
668    if (Member->Data)
669      FieldTypes.push_back(Member->Data);
670    if (Member->Kind == MemberInfo::Field) {
671      if (Member->FD)
672        Fields[Member->FD->getCanonicalDecl()] = FieldTypes.size() - 1;
673      // A field without storage must be a bitfield.
674      if (!Member->Data)
675        setBitFieldInfo(Member->FD, Member->Offset, FieldTypes.back());
676    } else if (Member->Kind == MemberInfo::Base)
677      NonVirtualBases[Member->RD] = FieldTypes.size() - 1;
678    else if (Member->Kind == MemberInfo::VBase)
679      VirtualBases[Member->RD] = FieldTypes.size() - 1;
680  }
681}
682
683CGBitFieldInfo CGBitFieldInfo::MakeInfo(CodeGenTypes &Types,
684                                        const FieldDecl *FD,
685                                        uint64_t Offset, uint64_t Size,
686                                        uint64_t StorageSize,
687                                        CharUnits StorageOffset) {
688  // This function is vestigial from CGRecordLayoutBuilder days but is still
689  // used in GCObjCRuntime.cpp.  That usage has a "fixme" attached to it that
690  // when addressed will allow for the removal of this function.
691  llvm::Type *Ty = Types.ConvertTypeForMem(FD->getType());
692  CharUnits TypeSizeInBytes =
693    CharUnits::fromQuantity(Types.getDataLayout().getTypeAllocSize(Ty));
694  uint64_t TypeSizeInBits = Types.getContext().toBits(TypeSizeInBytes);
695
696  bool IsSigned = FD->getType()->isSignedIntegerOrEnumerationType();
697
698  if (Size > TypeSizeInBits) {
699    // We have a wide bit-field. The extra bits are only used for padding, so
700    // if we have a bitfield of type T, with size N:
701    //
702    // T t : N;
703    //
704    // We can just assume that it's:
705    //
706    // T t : sizeof(T);
707    //
708    Size = TypeSizeInBits;
709  }
710
711  // Reverse the bit offsets for big endian machines. Because we represent
712  // a bitfield as a single large integer load, we can imagine the bits
713  // counting from the most-significant-bit instead of the
714  // least-significant-bit.
715  if (Types.getDataLayout().isBigEndian()) {
716    Offset = StorageSize - (Offset + Size);
717  }
718
719  return CGBitFieldInfo(Offset, Size, IsSigned, StorageSize, StorageOffset);
720}
721
722CGRecordLayout *CodeGenTypes::ComputeRecordLayout(const RecordDecl *D,
723                                                  llvm::StructType *Ty) {
724  CGRecordLowering Builder(*this, D, /*Packed=*/false);
725
726  Builder.lower(/*NonVirtualBaseType=*/false);
727
728  // If we're in C++, compute the base subobject type.
729  llvm::StructType *BaseTy = nullptr;
730  if (isa<CXXRecordDecl>(D) && !D->isUnion() && !D->hasAttr<FinalAttr>()) {
731    BaseTy = Ty;
732    if (Builder.Layout.getNonVirtualSize() != Builder.Layout.getSize()) {
733      CGRecordLowering BaseBuilder(*this, D, /*Packed=*/Builder.Packed);
734      BaseBuilder.lower(/*NonVirtualBaseType=*/true);
735      BaseTy = llvm::StructType::create(
736          getLLVMContext(), BaseBuilder.FieldTypes, "", BaseBuilder.Packed);
737      addRecordTypeName(D, BaseTy, ".base");
738      // BaseTy and Ty must agree on their packedness for getLLVMFieldNo to work
739      // on both of them with the same index.
740       (0) . __assert_fail ("Builder.Packed == BaseBuilder.Packed && \"Non-virtual and complete types must agree on packedness\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 741, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Builder.Packed == BaseBuilder.Packed &&
741 (0) . __assert_fail ("Builder.Packed == BaseBuilder.Packed && \"Non-virtual and complete types must agree on packedness\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 741, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">             "Non-virtual and complete types must agree on packedness");
742    }
743  }
744
745  // Fill in the struct *after* computing the base type.  Filling in the body
746  // signifies that the type is no longer opaque and record layout is complete,
747  // but we may need to recursively layout D while laying D out as a base type.
748  Ty->setBody(Builder.FieldTypes, Builder.Packed);
749
750  CGRecordLayout *RL =
751    new CGRecordLayout(Ty, BaseTy, Builder.IsZeroInitializable,
752                        Builder.IsZeroInitializableAsBase);
753
754  RL->NonVirtualBases.swap(Builder.NonVirtualBases);
755  RL->CompleteObjectVirtualBases.swap(Builder.VirtualBases);
756
757  // Add all the field numbers.
758  RL->FieldInfo.swap(Builder.Fields);
759
760  // Add bitfield info.
761  RL->BitFields.swap(Builder.BitFields);
762
763  // Dump the layout, if requested.
764  if (getContext().getLangOpts().DumpRecordLayouts) {
765    llvm::outs() << "\n*** Dumping IRgen Record Layout\n";
766    llvm::outs() << "Record: ";
767    D->dump(llvm::outs());
768    llvm::outs() << "\nLayout: ";
769    RL->print(llvm::outs());
770  }
771
772#ifndef NDEBUG
773  // Verify that the computed LLVM struct size matches the AST layout size.
774  const ASTRecordLayout &Layout = getContext().getASTRecordLayout(D);
775
776  uint64_t TypeSizeInBits = getContext().toBits(Layout.getSize());
777   (0) . __assert_fail ("TypeSizeInBits == getDataLayout().getTypeAllocSizeInBits(Ty) && \"Type size mismatch!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 778, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(TypeSizeInBits == getDataLayout().getTypeAllocSizeInBits(Ty) &&
778 (0) . __assert_fail ("TypeSizeInBits == getDataLayout().getTypeAllocSizeInBits(Ty) && \"Type size mismatch!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 778, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">         "Type size mismatch!");
779
780  if (BaseTy) {
781    CharUnits NonVirtualSize  = Layout.getNonVirtualSize();
782
783    uint64_t AlignedNonVirtualTypeSizeInBits =
784      getContext().toBits(NonVirtualSize);
785
786     (0) . __assert_fail ("AlignedNonVirtualTypeSizeInBits == getDataLayout().getTypeAllocSizeInBits(BaseTy) && \"Type size mismatch!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 788, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(AlignedNonVirtualTypeSizeInBits ==
787 (0) . __assert_fail ("AlignedNonVirtualTypeSizeInBits == getDataLayout().getTypeAllocSizeInBits(BaseTy) && \"Type size mismatch!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 788, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">           getDataLayout().getTypeAllocSizeInBits(BaseTy) &&
788 (0) . __assert_fail ("AlignedNonVirtualTypeSizeInBits == getDataLayout().getTypeAllocSizeInBits(BaseTy) && \"Type size mismatch!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 788, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">           "Type size mismatch!");
789  }
790
791  // Verify that the LLVM and AST field offsets agree.
792  llvm::StructType *ST = RL->getLLVMType();
793  const llvm::StructLayout *SL = getDataLayout().getStructLayout(ST);
794
795  const ASTRecordLayout &AST_RL = getContext().getASTRecordLayout(D);
796  RecordDecl::field_iterator it = D->field_begin();
797  for (unsigned i = 0, e = AST_RL.getFieldCount(); i != e; ++i, ++it) {
798    const FieldDecl *FD = *it;
799
800    // For non-bit-fields, just check that the LLVM struct offset matches the
801    // AST offset.
802    if (!FD->isBitField()) {
803      unsigned FieldNo = RL->getLLVMFieldNo(FD);
804       (0) . __assert_fail ("AST_RL.getFieldOffset(i) == SL->getElementOffsetInBits(FieldNo) && \"Invalid field offset!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 805, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(AST_RL.getFieldOffset(i) == SL->getElementOffsetInBits(FieldNo) &&
805 (0) . __assert_fail ("AST_RL.getFieldOffset(i) == SL->getElementOffsetInBits(FieldNo) && \"Invalid field offset!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 805, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">             "Invalid field offset!");
806      continue;
807    }
808
809    // Ignore unnamed bit-fields.
810    if (!FD->getDeclName())
811      continue;
812
813    // Don't inspect zero-length bitfields.
814    if (FD->isZeroLengthBitField(getContext()))
815      continue;
816
817    const CGBitFieldInfo &Info = RL->getBitFieldInfo(FD);
818    llvm::Type *ElementTy = ST->getTypeAtIndex(RL->getLLVMFieldNo(FD));
819
820    // Unions have overlapping elements dictating their layout, but for
821    // non-unions we can verify that this section of the layout is the exact
822    // expected size.
823    if (D->isUnion()) {
824      // For unions we verify that the start is zero and the size
825      // is in-bounds. However, on BE systems, the offset may be non-zero, but
826      // the size + offset should match the storage size in that case as it
827      // "starts" at the back.
828      if (getDataLayout().isBigEndian())
829         (0) . __assert_fail ("static_cast(Info.Offset + Info.Size) == Info.StorageSize && \"Big endian union bitfield does not end at the back\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 831, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(static_cast<unsigned>(Info.Offset + Info.Size) ==
830 (0) . __assert_fail ("static_cast(Info.Offset + Info.Size) == Info.StorageSize && \"Big endian union bitfield does not end at the back\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 831, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">               Info.StorageSize &&
831 (0) . __assert_fail ("static_cast(Info.Offset + Info.Size) == Info.StorageSize && \"Big endian union bitfield does not end at the back\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 831, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">               "Big endian union bitfield does not end at the back");
832      else
833         (0) . __assert_fail ("Info.Offset == 0 && \"Little endian union bitfield with a non-zero offset\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 834, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Info.Offset == 0 &&
834 (0) . __assert_fail ("Info.Offset == 0 && \"Little endian union bitfield with a non-zero offset\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 834, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">               "Little endian union bitfield with a non-zero offset");
835       (0) . __assert_fail ("Info.StorageSize <= SL->getSizeInBits() && \"Union not large enough for bitfield storage\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 836, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Info.StorageSize <= SL->getSizeInBits() &&
836 (0) . __assert_fail ("Info.StorageSize <= SL->getSizeInBits() && \"Union not large enough for bitfield storage\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 836, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">             "Union not large enough for bitfield storage");
837    } else {
838       (0) . __assert_fail ("Info.StorageSize == getDataLayout().getTypeAllocSizeInBits(ElementTy) && \"Storage size does not match the element type size\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 840, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Info.StorageSize ==
839 (0) . __assert_fail ("Info.StorageSize == getDataLayout().getTypeAllocSizeInBits(ElementTy) && \"Storage size does not match the element type size\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 840, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">             getDataLayout().getTypeAllocSizeInBits(ElementTy) &&
840 (0) . __assert_fail ("Info.StorageSize == getDataLayout().getTypeAllocSizeInBits(ElementTy) && \"Storage size does not match the element type size\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 840, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">             "Storage size does not match the element type size");
841    }
842     (0) . __assert_fail ("Info.Size > 0 && \"Empty bitfield!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 842, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Info.Size > 0 && "Empty bitfield!");
843     (0) . __assert_fail ("static_cast(Info.Offset) + Info.Size <= Info.StorageSize && \"Bitfield outside of its allocated storage\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 844, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(static_cast<unsigned>(Info.Offset) + Info.Size <= Info.StorageSize &&
844 (0) . __assert_fail ("static_cast(Info.Offset) + Info.Size <= Info.StorageSize && \"Bitfield outside of its allocated storage\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp", 844, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">           "Bitfield outside of its allocated storage");
845  }
846#endif
847
848  return RL;
849}
850
851void CGRecordLayout::print(raw_ostream &OS) const {
852  OS << "<CGRecordLayout\n";
853  OS << "  LLVMType:" << *CompleteObjectType << "\n";
854  if (BaseSubobjectType)
855    OS << "  NonVirtualBaseLLVMType:" << *BaseSubobjectType << "\n";
856  OS << "  IsZeroInitializable:" << IsZeroInitializable << "\n";
857  OS << "  BitFields:[\n";
858
859  // Print bit-field infos in declaration order.
860  std::vector<std::pair<unsigned, const CGBitFieldInfo*> > BFIs;
861  for (llvm::DenseMap<const FieldDecl*, CGBitFieldInfo>::const_iterator
862         it = BitFields.begin(), ie = BitFields.end();
863       it != ie; ++it) {
864    const RecordDecl *RD = it->first->getParent();
865    unsigned Index = 0;
866    for (RecordDecl::field_iterator
867           it2 = RD->field_begin(); *it2 != it->first; ++it2)
868      ++Index;
869    BFIs.push_back(std::make_pair(Index, &it->second));
870  }
871  llvm::array_pod_sort(BFIs.begin(), BFIs.end());
872  for (unsigned i = 0, e = BFIs.size(); i != e; ++i) {
873    OS.indent(4);
874    BFIs[i].second->print(OS);
875    OS << "\n";
876  }
877
878  OS << "]>\n";
879}
880
881LLVM_DUMP_METHOD void CGRecordLayout::dump() const {
882  print(llvm::errs());
883}
884
885void CGBitFieldInfo::print(raw_ostream &OS) const {
886  OS << "<CGBitFieldInfo"
887     << " Offset:" << Offset
888     << " Size:" << Size
889     << " IsSigned:" << IsSigned
890     << " StorageSize:" << StorageSize
891     << " StorageOffset:" << StorageOffset.getQuantity() << ">";
892}
893
894LLVM_DUMP_METHOD void CGBitFieldInfo::dump() const {
895  print(llvm::errs());
896}
897
clang::CodeGen::CGBitFieldInfo::MakeInfo
clang::CodeGen::CodeGenTypes::ComputeRecordLayout
clang::CodeGen::CGRecordLayout::print
clang::CodeGen::CGRecordLayout::dump
clang::CodeGen::CGBitFieldInfo::print
clang::CodeGen::CGBitFieldInfo::dump
CodeThinker, Enjoy your reading code