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
18namespace llvm {
19 class StructType;
20}
21
22namespace clang {
23namespace 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///
65struct 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.
121class CGRecordLayout {
122 friend class CodeGenTypes;
123
124 CGRecordLayout(const CGRecordLayout &) = delete;
125 void operator=(const CGRecordLayout &) = delete;
126
127private:
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
161public:
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
239

source code of clang/lib/CodeGen/CGRecordLayout.h