1 //===-- llvm/Target/TargetData.h - Data size & alignment info ---*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by the LLVM research group and is distributed under
6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines target properties related to datatype size/offset/alignment
11 // information. It uses lazy annotations to cache information about how
12 // structure types are laid out and used.
14 // This structure should be created once, filled in if the defaults are not
15 // correct and then passed around by const&. None of the members functions
16 // require modification to the object.
18 //===----------------------------------------------------------------------===//
20 #ifndef LLVM_TARGET_TARGETDATA_H
21 #define LLVM_TARGET_TARGETDATA_H
23 #include "llvm/Pass.h"
24 #include "llvm/Support/DataTypes.h"
34 class TargetData : public ImmutablePass {
35 bool LittleEndian; // Defaults to false
38 unsigned char BoolABIAlignment; // Defaults to 1 byte
39 unsigned char ByteABIAlignment; // Defaults to 1 byte
40 unsigned char ShortABIAlignment; // Defaults to 2 bytes
41 unsigned char IntABIAlignment; // Defaults to 4 bytes
42 unsigned char LongABIAlignment; // Defaults to 8 bytes
43 unsigned char FloatABIAlignment; // Defaults to 4 bytes
44 unsigned char DoubleABIAlignment; // Defaults to 8 bytes
45 unsigned char PointerMemSize; // Defaults to 8 bytes
46 unsigned char PointerABIAlignment; // Defaults to 8 bytes
48 // Preferred stack/global type alignments
49 unsigned char BoolPrefAlignment; // Defaults to BoolABIAlignment
50 unsigned char BytePrefAlignment; // Defaults to ByteABIAlignment
51 unsigned char ShortPrefAlignment; // Defaults to ShortABIAlignment
52 unsigned char IntPrefAlignment; // Defaults to IntABIAlignment
53 unsigned char LongPrefAlignment; // Defaults to LongABIAlignment
54 unsigned char FloatPrefAlignment; // Defaults to FloatABIAlignment
55 unsigned char DoublePrefAlignment; // Defaults to DoubleABIAlignment
56 unsigned char PointerPrefAlignment; // Defaults to PointerABIAlignment
57 unsigned char AggMinPrefAlignment; // Defaults to 0 bytes
60 /// Default ctor - This has to exist, because this is a pass, but it should
63 assert(0 && "ERROR: Bad TargetData ctor used. "
64 "Tool did not specify a TargetData to use?");
68 /// Constructs a TargetData from a string of the following format:
69 /// "E-p:64:64-d:64-f:32-l:64-i:32-s:16-b:8-B:8"
70 /// The above string is considered the default, and any values not specified
71 /// in the string will be assumed to be as above, with the caveat that unspecified
72 /// values are always assumed to be smaller than the size of a pointer.
73 TargetData(const std::string &TargetDescription) {
74 init(TargetDescription);
77 /// Initialize target data from properties stored in the module.
78 TargetData(const Module *M);
80 TargetData(const TargetData &TD) :
82 LittleEndian(TD.isLittleEndian()),
83 BoolABIAlignment(TD.getBoolABIAlignment()),
84 ByteABIAlignment(TD.getByteABIAlignment()),
85 ShortABIAlignment(TD.getShortABIAlignment()),
86 IntABIAlignment(TD.getIntABIAlignment()),
87 LongABIAlignment(TD.getLongABIAlignment()),
88 FloatABIAlignment(TD.getFloatABIAlignment()),
89 DoubleABIAlignment(TD.getDoubleABIAlignment()),
90 PointerMemSize(TD.getPointerSize()),
91 PointerABIAlignment(TD.getPointerABIAlignment()),
92 BoolPrefAlignment(TD.getBoolPrefAlignment()),
93 BytePrefAlignment(TD.getBytePrefAlignment()),
94 ShortPrefAlignment(TD.getShortPrefAlignment()),
95 IntPrefAlignment(TD.getIntPrefAlignment()),
96 LongPrefAlignment(TD.getLongPrefAlignment()),
97 FloatPrefAlignment(TD.getFloatPrefAlignment()),
98 DoublePrefAlignment(TD.getDoublePrefAlignment()),
99 PointerPrefAlignment(TD.getPointerPrefAlignment()),
100 AggMinPrefAlignment(TD.getAggMinPrefAlignment()) {
103 ~TargetData(); // Not virtual, do not subclass this class
105 /// Parse a target data layout string and initialize TargetData members.
107 /// Parse a target data layout string, initializing the various TargetData
108 /// members along the way. A TargetData specification string looks like
109 /// "E-p:64:64-d:64-f:32-l:64-i:32-s:16-b:8-B:8" and specifies the
110 /// target's endianess, the ABI alignments of various data types and
111 /// the size of pointers.
113 /// "-" is used as a separator and ":" separates a token from its argument.
115 /// Alignment is indicated in bits and internally converted to the
116 /// appropriate number of bytes.
118 /// The preferred stack/global alignment specifications (":[prefalign]") are
119 /// optional and default to the ABI alignment.
123 /// <em>E</em> specifies big endian architecture (1234) [default]<br>
124 /// <em>e</em> specifies little endian architecture (4321) <br>
125 /// <em>p:[ptr size]:[ptr align]</em> specifies pointer size and alignment
126 /// [default = 64:64] <br>
127 /// <em>d:[align]:[prefalign]</em> specifies double floating
128 /// point alignment [default = 64] <br>
129 /// <em>f:[align]:[prefalign]</em> specifies single floating
130 /// point alignment [default = 32] <br>
131 /// <em>l:[align]:[prefalign]:[globalign[</em> specifies long integer
132 /// alignment [default = 64] <br>
133 /// <em>i:[align]:[prefalign]</em> specifies integer alignment
134 /// [default = 32] <br>
135 /// <em>s:[align]:[prefalign]</em> specifies short integer
136 /// alignment [default = 16] <br>
137 /// <em>b:[align]:[prefalign]</em> specifies byte data type
138 /// alignment [default = 8] <br>
139 /// <em>B:[align]:[prefalign]</em> specifies boolean data type
140 /// alignment [default = 8] <br>
141 /// <em>A:[prefalign]</em> specifies an aggregates' minimum alignment
142 /// on the stack and when emitted as a global. The default minimum aggregate
143 /// alignment defaults to 0, which causes the aggregate's "natural" internal
144 /// alignment calculated by llvm to be preferred.
146 /// All other token types are silently ignored.
147 void init(const std::string &TargetDescription);
150 /// Target endianness...
151 bool isLittleEndian() const { return LittleEndian; }
152 bool isBigEndian() const { return !LittleEndian; }
154 /// Target boolean alignment
155 unsigned char getBoolABIAlignment() const { return BoolABIAlignment; }
156 /// Target byte alignment
157 unsigned char getByteABIAlignment() const { return ByteABIAlignment; }
158 /// Target short alignment
159 unsigned char getShortABIAlignment() const { return ShortABIAlignment; }
160 /// Target integer alignment
161 unsigned char getIntABIAlignment() const { return IntABIAlignment; }
162 /// Target long alignment
163 unsigned char getLongABIAlignment() const { return LongABIAlignment; }
164 /// Target single precision float alignment
165 unsigned char getFloatABIAlignment() const { return FloatABIAlignment; }
166 /// Target double precision float alignment
167 unsigned char getDoubleABIAlignment() const { return DoubleABIAlignment; }
168 /// Target pointer alignment
169 unsigned char getPointerABIAlignment() const { return PointerABIAlignment; }
170 /// Target pointer size
171 unsigned char getPointerSize() const { return PointerMemSize; }
172 /// Target pointer size, in bits
173 unsigned char getPointerSizeInBits() const { return 8*PointerMemSize; }
175 /// Return target's alignment for booleans on stack
176 unsigned char getBoolPrefAlignment() const {
177 return BoolPrefAlignment;
179 /// Return target's alignment for integers on stack
180 unsigned char getBytePrefAlignment() const {
181 return BytePrefAlignment;
183 /// Return target's alignment for shorts on stack
184 unsigned char getShortPrefAlignment() const {
185 return ShortPrefAlignment;
187 /// Return target's alignment for integers on stack
188 unsigned char getIntPrefAlignment() const {
189 return IntPrefAlignment;
191 /// Return target's alignment for longs on stack
192 unsigned char getLongPrefAlignment() const {
193 return LongPrefAlignment;
195 /// Return target's alignment for single precision floats on stack
196 unsigned char getFloatPrefAlignment() const {
197 return FloatPrefAlignment;
199 /// Return target's alignment for double preceision floats on stack
200 unsigned char getDoublePrefAlignment() const {
201 return DoublePrefAlignment;
203 /// Return target's alignment for stack-based pointers
204 unsigned char getPointerPrefAlignment() const {
205 return PointerPrefAlignment;
207 /// Return target's alignment for stack-based structures
208 unsigned char getAggMinPrefAlignment() const {
209 return AggMinPrefAlignment;
212 /// getStringRepresentation - Return the string representation of the
213 /// TargetData. This representation is in the same format accepted by the
214 /// string constructor above.
215 std::string getStringRepresentation() const;
217 /// getTypeSize - Return the number of bytes necessary to hold the specified
220 uint64_t getTypeSize(const Type *Ty) const;
222 /// getTypeSizeInBits - Return the number of bytes necessary to hold the
224 uint64_t getTypeSizeInBits(const Type* Ty) const;
226 /// getTypeAlignmentABI - Return the minimum ABI-required alignment for the
228 unsigned char getTypeAlignmentABI(const Type *Ty) const;
230 /// getTypeAlignmentPref - Return the preferred stack/global alignment for
231 /// the specified type.
232 unsigned char getTypeAlignmentPref(const Type *Ty) const;
234 /// getPreferredTypeAlignmentShift - Return the preferred alignment for the
235 /// specified type, returned as log2 of the value (a shift amount).
237 unsigned char getPreferredTypeAlignmentShift(const Type *Ty) const;
239 /// getIntPtrType - Return an unsigned integer type that is the same size or
240 /// greater to the host pointer size.
242 const Type *getIntPtrType() const;
244 /// getIndexOffset - return the offset from the beginning of the type for the
245 /// specified indices. This is used to implement getelementptr.
247 uint64_t getIndexedOffset(const Type *Ty,
248 Value* const* Indices, unsigned NumIndices) const;
250 /// getStructLayout - Return a StructLayout object, indicating the alignment
251 /// of the struct, its size, and the offsets of its fields. Note that this
252 /// information is lazily cached.
253 const StructLayout *getStructLayout(const StructType *Ty) const;
255 /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
256 /// objects. If a TargetData object is alive when types are being refined and
257 /// removed, this method must be called whenever a StructType is removed to
258 /// avoid a dangling pointer in this cache.
259 void InvalidateStructLayoutInfo(const StructType *Ty) const;
261 /// getPreferredAlignmentLog - Return the preferred alignment of the
262 /// specified global, returned in log form. This includes an explicitly
263 /// requested alignment (if the global has one).
264 unsigned getPreferredAlignmentLog(const GlobalVariable *GV) const;
267 /// StructLayout - used to lazily calculate structure layout information for a
268 /// target machine, based on the TargetData structure.
272 unsigned StructAlignment;
273 unsigned NumElements;
274 uint64_t MemberOffsets[1]; // variable sized array!
277 uint64_t getSizeInBytes() const {
281 unsigned getAlignment() const {
282 return StructAlignment;
285 /// getElementContainingOffset - Given a valid offset into the structure,
286 /// return the structure index that contains it.
288 unsigned getElementContainingOffset(uint64_t Offset) const;
290 uint64_t getElementOffset(unsigned Idx) const {
291 assert(Idx < NumElements && "Invalid element idx!");
292 return MemberOffsets[Idx];
296 friend class TargetData; // Only TargetData can create this class
297 StructLayout(const StructType *ST, const TargetData &TD);
300 } // End llvm namespace