clang/lib/CodeGen/CGRecordLayout.h

   1 //===--- CGRecordLayout.h - LLVM Record Layout Information ------*- 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 #ifndef LLVM_CLANG_LIB_CODEGEN_CGRECORDLAYOUT_H
  10 #define LLVM_CLANG_LIB_CODEGEN_CGRECORDLAYOUT_H
  11
  12 #include "clang/AST/CharUnits.h"
  13 #include "clang/AST/DeclCXX.h"
  14 #include "clang/Basic/LLVM.h"
  15 #include "llvm/ADT/DenseMap.h"
  16 #include "llvm/IR/DerivedTypes.h"
  17
  18 namespace llvm {
  19   class StructType;
  20 }
  21
  22 namespace clang {
  23 namespace CodeGen {
  24
  25 /// Structure with information about how a bitfield should be accessed.
  26 ///
  27 /// Often we layout a sequence of bitfields as a contiguous sequence of bits.
  28 /// When the AST record layout does this, we represent it in the LLVM IR's type
  29 /// as either a sequence of i8 members or a byte array to reserve the number of
  30 /// bytes touched without forcing any particular alignment beyond the basic
  31 /// character alignment.
  32 ///
  33 /// Then accessing a particular bitfield involves converting this byte array
  34 /// into a single integer of that size (i24 or i40 -- may not be power-of-two
  35 /// size), loading it, and shifting and masking to extract the particular
  36 /// subsequence of bits which make up that particular bitfield. This structure
  37 /// encodes the information used to construct the extraction code sequences.
  38 /// The CGRecordLayout also has a field index which encodes which byte-sequence
  39 /// this bitfield falls within. Let's assume the following C struct:
  40 ///
  41 ///   struct S {
  42 ///     char a, b, c;
  43 ///     unsigned bits : 3;
  44 ///     unsigned more_bits : 4;
  45 ///     unsigned still_more_bits : 7;
  46 ///   };
  47 ///
  48 /// This will end up as the following LLVM type. The first array is the
  49 /// bitfield, and the second is the padding out to a 4-byte alignment.
  50 ///
  51 ///   %t = type { i8, i8, i8, i8, i8, [3 x i8] }
  52 ///
  53 /// When generating code to access more_bits, we'll generate something
  54 /// essentially like this:
  55 ///
  56 ///   define i32 @foo(%t* %base) {
  57 ///     %0 = gep %t* %base, i32 0, i32 3
  58 ///     %2 = load i8* %1
  59 ///     %3 = lshr i8 %2, 3
  60 ///     %4 = and i8 %3, 15
  61 ///     %5 = zext i8 %4 to i32
  62 ///     ret i32 %i
  63 ///   }
  64 ///
  65 struct CGBitFieldInfo {
  66   /// The offset within a contiguous run of bitfields that are represented as
  67   /// a single "field" within the LLVM struct type. This offset is in bits.
  68   unsigned Offset : 16;
  69
  70   /// The total size of the bit-field, in bits.
  71   unsigned Size : 15;
  72
  73   /// Whether the bit-field is signed.
  74   unsigned IsSigned : 1;
  75
  76   /// The storage size in bits which should be used when accessing this
  77   /// bitfield.
  78   unsigned StorageSize;
  79
  80   /// The offset of the bitfield storage from the start of the struct.
  81   CharUnits StorageOffset;
  82
  83   /// The offset within a contiguous run of bitfields that are represented as a
  84   /// single "field" within the LLVM struct type, taking into account the AAPCS
  85   /// rules for volatile bitfields. This offset is in bits.
  86   unsigned VolatileOffset : 16;
  87
  88   /// The storage size in bits which should be used when accessing this
  89   /// bitfield.
  90   unsigned VolatileStorageSize;
  91
  92   /// The offset of the bitfield storage from the start of the struct.
  93   CharUnits VolatileStorageOffset;
  94
  95   CGBitFieldInfo()
  96       : Offset(), Size(), IsSigned(), StorageSize(), VolatileOffset(),
  97         VolatileStorageSize() {}
  98
  99   CGBitFieldInfo(unsigned Offset, unsigned Size, bool IsSigned,
 100                  unsigned StorageSize, CharUnits StorageOffset)
 101       : Offset(Offset), Size(Size), IsSigned(IsSigned),
 102         StorageSize(StorageSize), StorageOffset(StorageOffset) {}
 103
 104   void print(raw_ostream &OS) const;
 105   void dump() const;
 106
 107   /// Given a bit-field decl, build an appropriate helper object for
 108   /// accessing that field (which is expected to have the given offset and
 109   /// size).
 110   static CGBitFieldInfo MakeInfo(class CodeGenTypes &Types,
 111                                  const FieldDecl *FD,
 112                                  uint64_t Offset, uint64_t Size,
 113                                  uint64_t StorageSize,
 114                                  CharUnits StorageOffset);
 115 };
 116
 117 /// CGRecordLayout - This class handles struct and union layout info while
 118 /// lowering AST types to LLVM types.
 119 ///
 120 /// These layout objects are only created on demand as IR generation requires.
 121 class CGRecordLayout {
 122   friend class CodeGenTypes;
 123
 124   CGRecordLayout(const CGRecordLayout &) = delete;
 125   void operator=(const CGRecordLayout &) = delete;
 126
 127 private:
 128   /// The LLVM type corresponding to this record layout; used when
 129   /// laying it out as a complete object.
 130   llvm::StructType *CompleteObjectType;
 131
 132   /// The LLVM type for the non-virtual part of this record layout;
 133   /// used when laying it out as a base subobject.
 134   llvm::StructType *BaseSubobjectType;
 135
 136   /// Map from (non-bit-field) struct field to the corresponding llvm struct
 137   /// type field no. This info is populated by record builder.
 138   llvm::DenseMap<const FieldDecl *, unsigned> FieldInfo;
 139
 140   /// Map from (bit-field) struct field to the corresponding llvm struct type
 141   /// field no. This info is populated by record builder.
 142   llvm::DenseMap<const FieldDecl *, CGBitFieldInfo> BitFields;
 143
 144   // FIXME: Maybe we could use a CXXBaseSpecifier as the key and use a single
 145   // map for both virtual and non-virtual bases.
 146   llvm::DenseMap<const CXXRecordDecl *, unsigned> NonVirtualBases;
 147
 148   /// Map from virtual bases to their field index in the complete object.
 149   llvm::DenseMap<const CXXRecordDecl *, unsigned> CompleteObjectVirtualBases;
 150
 151   /// False if any direct or indirect subobject of this class, when
 152   /// considered as a complete object, requires a non-zero bitpattern
 153   /// when zero-initialized.
 154   bool IsZeroInitializable : 1;
 155
 156   /// False if any direct or indirect subobject of this class, when
 157   /// considered as a base subobject, requires a non-zero bitpattern
 158   /// when zero-initialized.
 159   bool IsZeroInitializableAsBase : 1;
 160
 161 public:
 162   CGRecordLayout(llvm::StructType *CompleteObjectType,
 163                  llvm::StructType *BaseSubobjectType,
 164                  bool IsZeroInitializable,
 165                  bool IsZeroInitializableAsBase)
 166     : CompleteObjectType(CompleteObjectType),
 167       BaseSubobjectType(BaseSubobjectType),
 168       IsZeroInitializable(IsZeroInitializable),
 169       IsZeroInitializableAsBase(IsZeroInitializableAsBase) {}
 170
 171   /// Return the "complete object" LLVM type associated with
 172   /// this record.
 173   llvm::StructType *getLLVMType() const {
 174     return CompleteObjectType;
 175   }
 176
 177   /// Return the "base subobject" LLVM type associated with
 178   /// this record.
 179   llvm::StructType *getBaseSubobjectLLVMType() const {
 180     return BaseSubobjectType;
 181   }
 182
 183   /// Check whether this struct can be C++ zero-initialized
 184   /// with a zeroinitializer.
 185   bool isZeroInitializable() const {
 186     return IsZeroInitializable;
 187   }
 188
 189   /// Check whether this struct can be C++ zero-initialized
 190   /// with a zeroinitializer when considered as a base subobject.
 191   bool isZeroInitializableAsBase() const {
 192     return IsZeroInitializableAsBase;
 193   }
 194
 195   /// Return llvm::StructType element number that corresponds to the
 196   /// field FD.
 197   unsigned getLLVMFieldNo(const FieldDecl *FD) const {
 198     FD = FD->getCanonicalDecl();
 199     assert(FieldInfo.count(FD) && "Invalid field for record!");
 200     return FieldInfo.lookup(FD);
 201   }
 202
 203   // Return whether the following non virtual base has a corresponding
 204   // entry in the LLVM struct.
 205   bool hasNonVirtualBaseLLVMField(const CXXRecordDecl *RD) const {
 206     return NonVirtualBases.count(RD);
 207   }
 208
 209   unsigned getNonVirtualBaseLLVMFieldNo(const CXXRecordDecl *RD) const {
 210     assert(NonVirtualBases.count(RD) && "Invalid non-virtual base!");
 211     return NonVirtualBases.lookup(RD);
 212   }
 213
 214   /// Return the LLVM field index corresponding to the given
 215   /// virtual base.  Only valid when operating on the complete object.
 216   unsigned getVirtualBaseIndex(const CXXRecordDecl *base) const {
 217     assert(CompleteObjectVirtualBases.count(base) && "Invalid virtual base!");
 218     return CompleteObjectVirtualBases.lookup(base);
 219   }
 220
 221   /// Return the BitFieldInfo that corresponds to the field FD.
 222   const CGBitFieldInfo &getBitFieldInfo(const FieldDecl *FD) const {
 223     FD = FD->getCanonicalDecl();
 224     assert(FD->isBitField() && "Invalid call for non-bit-field decl!");
 225     llvm::DenseMap<const FieldDecl *, CGBitFieldInfo>::const_iterator
 226       it = BitFields.find(FD);
 227     assert(it != BitFields.end() && "Unable to find bitfield info");
 228     return it->second;
 229   }
 230
 231   void print(raw_ostream &OS) const;
 232   void dump() const;
 233 };
 234
 235 }  // end namespace CodeGen
 236 }  // end namespace clang
 237
 238 #endif