clang  10.0.0svn
CGRecordLayoutBuilder.cpp
Go to the documentation of this file.
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"
19 #include "clang/AST/DeclCXX.h"
20 #include "clang/AST/Expr.h"
21 #include "clang/AST/RecordLayout.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"
29 using namespace clang;
30 using namespace CodeGen;
31 
32 namespace {
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.
73 struct 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 {
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  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.
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;
210 private:
211  CGRecordLowering(const CGRecordLowering &) = delete;
212  void operator =(const CGRecordLowering &) = delete;
213 };
214 } // namespace {
215 
216 CGRecordLowering::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 
224 void CGRecordLowering::setBitFieldInfo(
225  const FieldDecl *FD, CharUnits StartOffset, llvm::Type *StorageType) {
226  CGBitFieldInfo &Info = BitFields[FD->getCanonicalDecl()];
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 
242 void 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  llvm::stable_sort(Members);
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 
286 void 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 
347 void CGRecordLowering::accumulateFields() {
348  for (RecordDecl::field_iterator Field = D->field_begin(),
349  FieldEnd = D->field_end();
350  Field != FieldEnd;) {
351  if (Field->isBitField()) {
353  // Iterate to gather the list of bitfields.
354  for (++Field; Field != FieldEnd && Field->isBitField(); ++Field);
355  accumulateBitFields(Start, Field);
356  } else if (!Field->isZeroSize(Context)) {
357  Members.push_back(MemberInfo(
358  bitsToCharUnits(getFieldBitOffset(*Field)), MemberInfo::Field,
359  getStorageType(*Field), *Field));
360  ++Field;
361  } else {
362  ++Field;
363  }
364  }
365 }
366 
367 void
368 CGRecordLowering::accumulateBitFields(RecordDecl::field_iterator Field,
369  RecordDecl::field_iterator FieldEnd) {
370  // Run stores the first element of the current run of bitfields. FieldEnd is
371  // used as a special value to note that we don't have a current run. A
372  // bitfield run is a contiguous collection of bitfields that can be stored in
373  // the same storage block. Zero-sized bitfields and bitfields that would
374  // cross an alignment boundary break a run and start a new one.
375  RecordDecl::field_iterator Run = FieldEnd;
376  // Tail is the offset of the first bit off the end of the current run. It's
377  // used to determine if the ASTRecordLayout is treating these two bitfields as
378  // contiguous. StartBitOffset is offset of the beginning of the Run.
379  uint64_t StartBitOffset, Tail = 0;
380  if (isDiscreteBitFieldABI()) {
381  for (; Field != FieldEnd; ++Field) {
382  uint64_t BitOffset = getFieldBitOffset(*Field);
383  // Zero-width bitfields end runs.
384  if (Field->isZeroLengthBitField(Context)) {
385  Run = FieldEnd;
386  continue;
387  }
388  llvm::Type *Type = Types.ConvertTypeForMem(Field->getType());
389  // If we don't have a run yet, or don't live within the previous run's
390  // allocated storage then we allocate some storage and start a new run.
391  if (Run == FieldEnd || BitOffset >= Tail) {
392  Run = Field;
393  StartBitOffset = BitOffset;
394  Tail = StartBitOffset + DataLayout.getTypeAllocSizeInBits(Type);
395  // Add the storage member to the record. This must be added to the
396  // record before the bitfield members so that it gets laid out before
397  // the bitfields it contains get laid out.
398  Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset), Type));
399  }
400  // Bitfields get the offset of their storage but come afterward and remain
401  // there after a stable sort.
402  Members.push_back(MemberInfo(bitsToCharUnits(StartBitOffset),
403  MemberInfo::Field, nullptr, *Field));
404  }
405  return;
406  }
407 
408  // Check if OffsetInRecord is better as a single field run. When OffsetInRecord
409  // has legal integer width, and its bitfield offset is naturally aligned, it
410  // is better to make the bitfield a separate storage component so as it can be
411  // accessed directly with lower cost.
412  auto IsBetterAsSingleFieldRun = [&](uint64_t OffsetInRecord,
413  uint64_t StartBitOffset) {
414  if (!Types.getCodeGenOpts().FineGrainedBitfieldAccesses)
415  return false;
416  if (!DataLayout.isLegalInteger(OffsetInRecord))
417  return false;
418  // Make sure StartBitOffset is natually aligned if it is treated as an
419  // IType integer.
420  if (StartBitOffset %
421  Context.toBits(getAlignment(getIntNType(OffsetInRecord))) !=
422  0)
423  return false;
424  return true;
425  };
426 
427  // The start field is better as a single field run.
428  bool StartFieldAsSingleRun = false;
429  for (;;) {
430  // Check to see if we need to start a new run.
431  if (Run == FieldEnd) {
432  // If we're out of fields, return.
433  if (Field == FieldEnd)
434  break;
435  // Any non-zero-length bitfield can start a new run.
436  if (!Field->isZeroLengthBitField(Context)) {
437  Run = Field;
438  StartBitOffset = getFieldBitOffset(*Field);
439  Tail = StartBitOffset + Field->getBitWidthValue(Context);
440  StartFieldAsSingleRun = IsBetterAsSingleFieldRun(Tail - StartBitOffset,
441  StartBitOffset);
442  }
443  ++Field;
444  continue;
445  }
446 
447  // If the start field of a new run is better as a single run, or
448  // if current field (or consecutive fields) is better as a single run, or
449  // if current field has zero width bitfield and either
450  // UseZeroLengthBitfieldAlignment or UseBitFieldTypeAlignment is set to
451  // true, or
452  // if the offset of current field is inconsistent with the offset of
453  // previous field plus its offset,
454  // skip the block below and go ahead to emit the storage.
455  // Otherwise, try to add bitfields to the run.
456  if (!StartFieldAsSingleRun && Field != FieldEnd &&
457  !IsBetterAsSingleFieldRun(Tail - StartBitOffset, StartBitOffset) &&
458  (!Field->isZeroLengthBitField(Context) ||
460  !Context.getTargetInfo().useBitFieldTypeAlignment())) &&
461  Tail == getFieldBitOffset(*Field)) {
462  Tail += Field->getBitWidthValue(Context);
463  ++Field;
464  continue;
465  }
466 
467  // We've hit a break-point in the run and need to emit a storage field.
468  llvm::Type *Type = getIntNType(Tail - StartBitOffset);
469  // Add the storage member to the record and set the bitfield info for all of
470  // the bitfields in the run. Bitfields get the offset of their storage but
471  // come afterward and remain there after a stable sort.
472  Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset), Type));
473  for (; Run != Field; ++Run)
474  Members.push_back(MemberInfo(bitsToCharUnits(StartBitOffset),
475  MemberInfo::Field, nullptr, *Run));
476  Run = FieldEnd;
477  StartFieldAsSingleRun = false;
478  }
479 }
480 
481 void CGRecordLowering::accumulateBases() {
482  // If we've got a primary virtual base, we need to add it with the bases.
483  if (Layout.isPrimaryBaseVirtual()) {
484  const CXXRecordDecl *BaseDecl = Layout.getPrimaryBase();
485  Members.push_back(MemberInfo(CharUnits::Zero(), MemberInfo::Base,
486  getStorageType(BaseDecl), BaseDecl));
487  }
488  // Accumulate the non-virtual bases.
489  for (const auto &Base : RD->bases()) {
490  if (Base.isVirtual())
491  continue;
492 
493  // Bases can be zero-sized even if not technically empty if they
494  // contain only a trailing array member.
495  const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
496  if (!BaseDecl->isEmpty() &&
497  !Context.getASTRecordLayout(BaseDecl).getNonVirtualSize().isZero())
498  Members.push_back(MemberInfo(Layout.getBaseClassOffset(BaseDecl),
499  MemberInfo::Base, getStorageType(BaseDecl), BaseDecl));
500  }
501 }
502 
503 void CGRecordLowering::accumulateVPtrs() {
504  if (Layout.hasOwnVFPtr())
505  Members.push_back(MemberInfo(CharUnits::Zero(), MemberInfo::VFPtr,
506  llvm::FunctionType::get(getIntNType(32), /*isVarArg=*/true)->
507  getPointerTo()->getPointerTo()));
508  if (Layout.hasOwnVBPtr())
509  Members.push_back(MemberInfo(Layout.getVBPtrOffset(), MemberInfo::VBPtr,
510  llvm::Type::getInt32PtrTy(Types.getLLVMContext())));
511 }
512 
513 void CGRecordLowering::accumulateVBases() {
514  CharUnits ScissorOffset = Layout.getNonVirtualSize();
515  // In the itanium ABI, it's possible to place a vbase at a dsize that is
516  // smaller than the nvsize. Here we check to see if such a base is placed
517  // before the nvsize and set the scissor offset to that, instead of the
518  // nvsize.
519  if (isOverlappingVBaseABI())
520  for (const auto &Base : RD->vbases()) {
521  const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
522  if (BaseDecl->isEmpty())
523  continue;
524  // If the vbase is a primary virtual base of some base, then it doesn't
525  // get its own storage location but instead lives inside of that base.
526  if (Context.isNearlyEmpty(BaseDecl) && !hasOwnStorage(RD, BaseDecl))
527  continue;
528  ScissorOffset = std::min(ScissorOffset,
529  Layout.getVBaseClassOffset(BaseDecl));
530  }
531  Members.push_back(MemberInfo(ScissorOffset, MemberInfo::Scissor, nullptr,
532  RD));
533  for (const auto &Base : RD->vbases()) {
534  const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
535  if (BaseDecl->isEmpty())
536  continue;
537  CharUnits Offset = Layout.getVBaseClassOffset(BaseDecl);
538  // If the vbase is a primary virtual base of some base, then it doesn't
539  // get its own storage location but instead lives inside of that base.
540  if (isOverlappingVBaseABI() &&
541  Context.isNearlyEmpty(BaseDecl) &&
542  !hasOwnStorage(RD, BaseDecl)) {
543  Members.push_back(MemberInfo(Offset, MemberInfo::VBase, nullptr,
544  BaseDecl));
545  continue;
546  }
547  // If we've got a vtordisp, add it as a storage type.
548  if (Layout.getVBaseOffsetsMap().find(BaseDecl)->second.hasVtorDisp())
549  Members.push_back(StorageInfo(Offset - CharUnits::fromQuantity(4),
550  getIntNType(32)));
551  Members.push_back(MemberInfo(Offset, MemberInfo::VBase,
552  getStorageType(BaseDecl), BaseDecl));
553  }
554 }
555 
556 bool CGRecordLowering::hasOwnStorage(const CXXRecordDecl *Decl,
557  const CXXRecordDecl *Query) {
558  const ASTRecordLayout &DeclLayout = Context.getASTRecordLayout(Decl);
559  if (DeclLayout.isPrimaryBaseVirtual() && DeclLayout.getPrimaryBase() == Query)
560  return false;
561  for (const auto &Base : Decl->bases())
562  if (!hasOwnStorage(Base.getType()->getAsCXXRecordDecl(), Query))
563  return false;
564  return true;
565 }
566 
567 void CGRecordLowering::calculateZeroInit() {
568  for (std::vector<MemberInfo>::const_iterator Member = Members.begin(),
569  MemberEnd = Members.end();
570  IsZeroInitializableAsBase && Member != MemberEnd; ++Member) {
571  if (Member->Kind == MemberInfo::Field) {
572  if (!Member->FD || isZeroInitializable(Member->FD))
573  continue;
574  IsZeroInitializable = IsZeroInitializableAsBase = false;
575  } else if (Member->Kind == MemberInfo::Base ||
576  Member->Kind == MemberInfo::VBase) {
577  if (isZeroInitializable(Member->RD))
578  continue;
579  IsZeroInitializable = false;
580  if (Member->Kind == MemberInfo::Base)
581  IsZeroInitializableAsBase = false;
582  }
583  }
584 }
585 
586 void CGRecordLowering::clipTailPadding() {
587  std::vector<MemberInfo>::iterator Prior = Members.begin();
588  CharUnits Tail = getSize(Prior->Data);
589  for (std::vector<MemberInfo>::iterator Member = Prior + 1,
590  MemberEnd = Members.end();
591  Member != MemberEnd; ++Member) {
592  // Only members with data and the scissor can cut into tail padding.
593  if (!Member->Data && Member->Kind != MemberInfo::Scissor)
594  continue;
595  if (Member->Offset < Tail) {
596  assert(Prior->Kind == MemberInfo::Field &&
597  "Only storage fields have tail padding!");
598  if (!Prior->FD || Prior->FD->isBitField())
599  Prior->Data = getByteArrayType(bitsToCharUnits(llvm::alignTo(
600  cast<llvm::IntegerType>(Prior->Data)->getIntegerBitWidth(), 8)));
601  else {
602  assert(Prior->FD->hasAttr<NoUniqueAddressAttr>() &&
603  "should not have reused this field's tail padding");
604  Prior->Data = getByteArrayType(
605  Context.getTypeInfoDataSizeInChars(Prior->FD->getType()).first);
606  }
607  }
608  if (Member->Data)
609  Prior = Member;
610  Tail = Prior->Offset + getSize(Prior->Data);
611  }
612 }
613 
614 void CGRecordLowering::determinePacked(bool NVBaseType) {
615  if (Packed)
616  return;
617  CharUnits Alignment = CharUnits::One();
618  CharUnits NVAlignment = CharUnits::One();
619  CharUnits NVSize =
620  !NVBaseType && RD ? Layout.getNonVirtualSize() : CharUnits::Zero();
621  for (std::vector<MemberInfo>::const_iterator Member = Members.begin(),
622  MemberEnd = Members.end();
623  Member != MemberEnd; ++Member) {
624  if (!Member->Data)
625  continue;
626  // If any member falls at an offset that it not a multiple of its alignment,
627  // then the entire record must be packed.
628  if (Member->Offset % getAlignment(Member->Data))
629  Packed = true;
630  if (Member->Offset < NVSize)
631  NVAlignment = std::max(NVAlignment, getAlignment(Member->Data));
632  Alignment = std::max(Alignment, getAlignment(Member->Data));
633  }
634  // If the size of the record (the capstone's offset) is not a multiple of the
635  // record's alignment, it must be packed.
636  if (Members.back().Offset % Alignment)
637  Packed = true;
638  // If the non-virtual sub-object is not a multiple of the non-virtual
639  // sub-object's alignment, it must be packed. We cannot have a packed
640  // non-virtual sub-object and an unpacked complete object or vise versa.
641  if (NVSize % NVAlignment)
642  Packed = true;
643  // Update the alignment of the sentinel.
644  if (!Packed)
645  Members.back().Data = getIntNType(Context.toBits(Alignment));
646 }
647 
648 void CGRecordLowering::insertPadding() {
649  std::vector<std::pair<CharUnits, CharUnits> > Padding;
650  CharUnits Size = CharUnits::Zero();
651  for (std::vector<MemberInfo>::const_iterator Member = Members.begin(),
652  MemberEnd = Members.end();
653  Member != MemberEnd; ++Member) {
654  if (!Member->Data)
655  continue;
656  CharUnits Offset = Member->Offset;
657  assert(Offset >= Size);
658  // Insert padding if we need to.
659  if (Offset !=
660  Size.alignTo(Packed ? CharUnits::One() : getAlignment(Member->Data)))
661  Padding.push_back(std::make_pair(Size, Offset - Size));
662  Size = Offset + getSize(Member->Data);
663  }
664  if (Padding.empty())
665  return;
666  // Add the padding to the Members list and sort it.
667  for (std::vector<std::pair<CharUnits, CharUnits> >::const_iterator
668  Pad = Padding.begin(), PadEnd = Padding.end();
669  Pad != PadEnd; ++Pad)
670  Members.push_back(StorageInfo(Pad->first, getByteArrayType(Pad->second)));
671  llvm::stable_sort(Members);
672 }
673 
674 void CGRecordLowering::fillOutputFields() {
675  for (std::vector<MemberInfo>::const_iterator Member = Members.begin(),
676  MemberEnd = Members.end();
677  Member != MemberEnd; ++Member) {
678  if (Member->Data)
679  FieldTypes.push_back(Member->Data);
680  if (Member->Kind == MemberInfo::Field) {
681  if (Member->FD)
682  Fields[Member->FD->getCanonicalDecl()] = FieldTypes.size() - 1;
683  // A field without storage must be a bitfield.
684  if (!Member->Data)
685  setBitFieldInfo(Member->FD, Member->Offset, FieldTypes.back());
686  } else if (Member->Kind == MemberInfo::Base)
687  NonVirtualBases[Member->RD] = FieldTypes.size() - 1;
688  else if (Member->Kind == MemberInfo::VBase)
689  VirtualBases[Member->RD] = FieldTypes.size() - 1;
690  }
691 }
692 
694  const FieldDecl *FD,
695  uint64_t Offset, uint64_t Size,
696  uint64_t StorageSize,
697  CharUnits StorageOffset) {
698  // This function is vestigial from CGRecordLayoutBuilder days but is still
699  // used in GCObjCRuntime.cpp. That usage has a "fixme" attached to it that
700  // when addressed will allow for the removal of this function.
701  llvm::Type *Ty = Types.ConvertTypeForMem(FD->getType());
702  CharUnits TypeSizeInBytes =
703  CharUnits::fromQuantity(Types.getDataLayout().getTypeAllocSize(Ty));
704  uint64_t TypeSizeInBits = Types.getContext().toBits(TypeSizeInBytes);
705 
706  bool IsSigned = FD->getType()->isSignedIntegerOrEnumerationType();
707 
708  if (Size > TypeSizeInBits) {
709  // We have a wide bit-field. The extra bits are only used for padding, so
710  // if we have a bitfield of type T, with size N:
711  //
712  // T t : N;
713  //
714  // We can just assume that it's:
715  //
716  // T t : sizeof(T);
717  //
718  Size = TypeSizeInBits;
719  }
720 
721  // Reverse the bit offsets for big endian machines. Because we represent
722  // a bitfield as a single large integer load, we can imagine the bits
723  // counting from the most-significant-bit instead of the
724  // least-significant-bit.
725  if (Types.getDataLayout().isBigEndian()) {
726  Offset = StorageSize - (Offset + Size);
727  }
728 
729  return CGBitFieldInfo(Offset, Size, IsSigned, StorageSize, StorageOffset);
730 }
731 
733  llvm::StructType *Ty) {
734  CGRecordLowering Builder(*this, D, /*Packed=*/false);
735 
736  Builder.lower(/*NonVirtualBaseType=*/false);
737 
738  // If we're in C++, compute the base subobject type.
739  llvm::StructType *BaseTy = nullptr;
740  if (isa<CXXRecordDecl>(D) && !D->isUnion() && !D->hasAttr<FinalAttr>()) {
741  BaseTy = Ty;
742  if (Builder.Layout.getNonVirtualSize() != Builder.Layout.getSize()) {
743  CGRecordLowering BaseBuilder(*this, D, /*Packed=*/Builder.Packed);
744  BaseBuilder.lower(/*NonVirtualBaseType=*/true);
745  BaseTy = llvm::StructType::create(
746  getLLVMContext(), BaseBuilder.FieldTypes, "", BaseBuilder.Packed);
747  addRecordTypeName(D, BaseTy, ".base");
748  // BaseTy and Ty must agree on their packedness for getLLVMFieldNo to work
749  // on both of them with the same index.
750  assert(Builder.Packed == BaseBuilder.Packed &&
751  "Non-virtual and complete types must agree on packedness");
752  }
753  }
754 
755  // Fill in the struct *after* computing the base type. Filling in the body
756  // signifies that the type is no longer opaque and record layout is complete,
757  // but we may need to recursively layout D while laying D out as a base type.
758  Ty->setBody(Builder.FieldTypes, Builder.Packed);
759 
760  CGRecordLayout *RL =
761  new CGRecordLayout(Ty, BaseTy, Builder.IsZeroInitializable,
762  Builder.IsZeroInitializableAsBase);
763 
764  RL->NonVirtualBases.swap(Builder.NonVirtualBases);
765  RL->CompleteObjectVirtualBases.swap(Builder.VirtualBases);
766 
767  // Add all the field numbers.
768  RL->FieldInfo.swap(Builder.Fields);
769 
770  // Add bitfield info.
771  RL->BitFields.swap(Builder.BitFields);
772 
773  // Dump the layout, if requested.
774  if (getContext().getLangOpts().DumpRecordLayouts) {
775  llvm::outs() << "\n*** Dumping IRgen Record Layout\n";
776  llvm::outs() << "Record: ";
777  D->dump(llvm::outs());
778  llvm::outs() << "\nLayout: ";
779  RL->print(llvm::outs());
780  }
781 
782 #ifndef NDEBUG
783  // Verify that the computed LLVM struct size matches the AST layout size.
784  const ASTRecordLayout &Layout = getContext().getASTRecordLayout(D);
785 
786  uint64_t TypeSizeInBits = getContext().toBits(Layout.getSize());
787  assert(TypeSizeInBits == getDataLayout().getTypeAllocSizeInBits(Ty) &&
788  "Type size mismatch!");
789 
790  if (BaseTy) {
791  CharUnits NonVirtualSize = Layout.getNonVirtualSize();
792 
793  uint64_t AlignedNonVirtualTypeSizeInBits =
794  getContext().toBits(NonVirtualSize);
795 
796  assert(AlignedNonVirtualTypeSizeInBits ==
797  getDataLayout().getTypeAllocSizeInBits(BaseTy) &&
798  "Type size mismatch!");
799  }
800 
801  // Verify that the LLVM and AST field offsets agree.
802  llvm::StructType *ST = RL->getLLVMType();
803  const llvm::StructLayout *SL = getDataLayout().getStructLayout(ST);
804 
805  const ASTRecordLayout &AST_RL = getContext().getASTRecordLayout(D);
807  for (unsigned i = 0, e = AST_RL.getFieldCount(); i != e; ++i, ++it) {
808  const FieldDecl *FD = *it;
809 
810  // Ignore zero-sized fields.
811  if (FD->isZeroSize(getContext()))
812  continue;
813 
814  // For non-bit-fields, just check that the LLVM struct offset matches the
815  // AST offset.
816  if (!FD->isBitField()) {
817  unsigned FieldNo = RL->getLLVMFieldNo(FD);
818  assert(AST_RL.getFieldOffset(i) == SL->getElementOffsetInBits(FieldNo) &&
819  "Invalid field offset!");
820  continue;
821  }
822 
823  // Ignore unnamed bit-fields.
824  if (!FD->getDeclName())
825  continue;
826 
827  const CGBitFieldInfo &Info = RL->getBitFieldInfo(FD);
828  llvm::Type *ElementTy = ST->getTypeAtIndex(RL->getLLVMFieldNo(FD));
829 
830  // Unions have overlapping elements dictating their layout, but for
831  // non-unions we can verify that this section of the layout is the exact
832  // expected size.
833  if (D->isUnion()) {
834  // For unions we verify that the start is zero and the size
835  // is in-bounds. However, on BE systems, the offset may be non-zero, but
836  // the size + offset should match the storage size in that case as it
837  // "starts" at the back.
838  if (getDataLayout().isBigEndian())
839  assert(static_cast<unsigned>(Info.Offset + Info.Size) ==
840  Info.StorageSize &&
841  "Big endian union bitfield does not end at the back");
842  else
843  assert(Info.Offset == 0 &&
844  "Little endian union bitfield with a non-zero offset");
845  assert(Info.StorageSize <= SL->getSizeInBits() &&
846  "Union not large enough for bitfield storage");
847  } else {
848  assert(Info.StorageSize ==
849  getDataLayout().getTypeAllocSizeInBits(ElementTy) &&
850  "Storage size does not match the element type size");
851  }
852  assert(Info.Size > 0 && "Empty bitfield!");
853  assert(static_cast<unsigned>(Info.Offset) + Info.Size <= Info.StorageSize &&
854  "Bitfield outside of its allocated storage");
855  }
856 #endif
857 
858  return RL;
859 }
860 
861 void CGRecordLayout::print(raw_ostream &OS) const {
862  OS << "<CGRecordLayout\n";
863  OS << " LLVMType:" << *CompleteObjectType << "\n";
864  if (BaseSubobjectType)
865  OS << " NonVirtualBaseLLVMType:" << *BaseSubobjectType << "\n";
866  OS << " IsZeroInitializable:" << IsZeroInitializable << "\n";
867  OS << " BitFields:[\n";
868 
869  // Print bit-field infos in declaration order.
870  std::vector<std::pair<unsigned, const CGBitFieldInfo*> > BFIs;
871  for (llvm::DenseMap<const FieldDecl*, CGBitFieldInfo>::const_iterator
872  it = BitFields.begin(), ie = BitFields.end();
873  it != ie; ++it) {
874  const RecordDecl *RD = it->first->getParent();
875  unsigned Index = 0;
877  it2 = RD->field_begin(); *it2 != it->first; ++it2)
878  ++Index;
879  BFIs.push_back(std::make_pair(Index, &it->second));
880  }
881  llvm::array_pod_sort(BFIs.begin(), BFIs.end());
882  for (unsigned i = 0, e = BFIs.size(); i != e; ++i) {
883  OS.indent(4);
884  BFIs[i].second->print(OS);
885  OS << "\n";
886  }
887 
888  OS << "]>\n";
889 }
890 
891 LLVM_DUMP_METHOD void CGRecordLayout::dump() const {
892  print(llvm::errs());
893 }
894 
895 void CGBitFieldInfo::print(raw_ostream &OS) const {
896  OS << "<CGBitFieldInfo"
897  << " Offset:" << Offset
898  << " Size:" << Size
899  << " IsSigned:" << IsSigned
900  << " StorageSize:" << StorageSize
901  << " StorageOffset:" << StorageOffset.getQuantity() << ">";
902 }
903 
904 LLVM_DUMP_METHOD void CGBitFieldInfo::dump() const {
905  print(llvm::errs());
906 }
Defines the clang::ASTContext interface.
CharUnits alignTo(const CharUnits &Align) const
alignTo - Returns the next integer (mod 2**64) that is greater than or equal to this quantity and is ...
Definition: CharUnits.h:183
bool isPrimaryBaseVirtual() const
isPrimaryBaseVirtual - Get whether the primary base for this record is virtual or not...
Definition: RecordLayout.h:225
const CGBitFieldInfo & getBitFieldInfo(const FieldDecl *FD) const
Return the BitFieldInfo that corresponds to the field FD.
base_class_range bases()
Definition: DeclCXX.h:779
CGRecordLayout - This class handles struct and union layout info while lowering AST types to LLVM typ...
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
const llvm::DataLayout & getDataLayout() const
Definition: CodeGenTypes.h:113
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
Definition: Decl.cpp:3966
The base class of the type hierarchy.
Definition: Type.h:1436
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:115
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:703
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
Represents a struct/union/class.
Definition: Decl.h:3634
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Definition: DeclCXX.h:1286
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1060
FieldDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this field.
Definition: Decl.h:2815
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:160
Represents a member of a struct/union/class.
Definition: Decl.h:2615
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:52
__DEVICE__ int max(int __a, int __b)
unsigned Size
The total size of the bit-field, in bits.
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2693
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:37
CharUnits StorageOffset
The offset of the bitfield storage from the start of the struct.
field_iterator field_begin() const
Definition: Decl.cpp:4317
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:3923
unsigned Offset
The offset within a contiguous run of bitfields that are represented as a single "field" within the L...
bool useZeroLengthBitfieldAlignment() const
Check whether zero length bitfields should force alignment of the next member.
Definition: TargetInfo.h:700
bool isZeroInitializable() const
Check whether this struct can be C++ zero-initialized with a zeroinitializer.
bool hasAttr() const
Definition: DeclBase.h:542
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:57
static CGBitFieldInfo MakeInfo(class CodeGenTypes &Types, const FieldDecl *FD, uint64_t Offset, uint64_t Size, uint64_t StorageSize, CharUnits StorageOffset)
Given a bit-field decl, build an appropriate helper object for accessing that field (which is expecte...
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:178
unsigned Offset
Definition: Format.cpp:1751
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:38
bool isNearlyEmpty(const CXXRecordDecl *RD) const
const CXXRecordDecl * getPrimaryBase() const
getPrimaryBase - Get the primary base for this record.
Definition: RecordLayout.h:217
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:62
unsigned getFieldCount() const
getFieldCount - Get the number of fields in the layout.
Definition: RecordLayout.h:186
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1779
void print(raw_ostream &OS) const
std::pair< CharUnits, CharUnits > getTypeInfoDataSizeInChars(QualType T) const
The l-value was considered opaque, so the alignment was determined from a type.
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
Definition: RecordLayout.h:190
Kind
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
Definition: Type.cpp:1904
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
bool useBitFieldTypeAlignment() const
Check whether the alignment of bit-field types is respected when laying out structures.
Definition: TargetInfo.h:694
Dataflow Directional Tag Classes.
CharUnits getSize() const
getSize - Get the record size in characters.
Definition: RecordLayout.h:183
unsigned IsSigned
Whether the bit-field is signed.
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
unsigned StorageSize
The storage size in bits which should be used when accessing this bitfield.
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Definition: DeclBase.h:2048
void print(raw_ostream &OS) const
This class organizes the cross-module state that is used while lowering AST types to LLVM types...
Definition: CodeGenTypes.h:59
llvm::StructType * getLLVMType() const
Return the "complete object" LLVM type associated with this record.
ASTContext & getContext() const
Definition: CodeGenTypes.h:116
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
true
A convenience builder class for complex constant initializers, especially for anonymous global struct...
Represents a C++ struct/union/class.
Definition: DeclCXX.h:254
CharUnits getNonVirtualSize() const
getNonVirtualSize - Get the non-virtual size (in chars) of an object, which is the size of the object...
Definition: RecordLayout.h:202
__DEVICE__ int min(int __a, int __b)
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:153
void dump() const
Definition: ASTDumper.cpp:179
bool isUnion() const
Definition: Decl.h:3293
CGRecordLayout * ComputeRecordLayout(const RecordDecl *D, llvm::StructType *Ty)
Compute a new LLVM record layout object for the given record.
QualType getType() const
Definition: Decl.h:647
bool isZeroSize(const ASTContext &Ctx) const
Determine if this field is a subobject of zero size, that is, either a zero-length bit-field or a fie...
Definition: Decl.cpp:3933
bool isZeroInitializable(QualType T)
IsZeroInitializable - Return whether a type can be zero-initialized (in the C++ sense) with an LLVM z...
Structure with information about how a bitfield should be accessed.
unsigned getLLVMFieldNo(const FieldDecl *FD) const
Return llvm::StructType element number that corresponds to the field FD.