Line data Source code
1 : //===- CodeGen/ValueTypes.h - Low-Level Target independ. types --*- C++ -*-===//
2 : //
3 : // The LLVM Compiler Infrastructure
4 : //
5 : // This file is distributed under the University of Illinois Open Source
6 : // License. See LICENSE.TXT for details.
7 : //
8 : //===----------------------------------------------------------------------===//
9 : //
10 : // This file defines the set of low-level target independent types which various
11 : // values in the code generator are. This allows the target specific behavior
12 : // of instructions to be described to target independent passes.
13 : //
14 : //===----------------------------------------------------------------------===//
15 :
16 : #ifndef LLVM_CODEGEN_VALUETYPES_H
17 : #define LLVM_CODEGEN_VALUETYPES_H
18 :
19 : #include "llvm/Support/Compiler.h"
20 : #include "llvm/Support/MachineValueType.h"
21 : #include "llvm/Support/MathExtras.h"
22 : #include <cassert>
23 : #include <cstdint>
24 : #include <string>
25 :
26 : namespace llvm {
27 :
28 : class LLVMContext;
29 : class Type;
30 :
31 : /// Extended Value Type. Capable of holding value types which are not native
32 : /// for any processor (such as the i12345 type), as well as the types an MVT
33 : /// can represent.
34 : struct EVT {
35 : private:
36 : MVT V = MVT::INVALID_SIMPLE_VALUE_TYPE;
37 : Type *LLVMTy = nullptr;
38 :
39 : public:
40 354 : constexpr EVT() = default;
41 119669639 : constexpr EVT(MVT::SimpleValueType SVT) : V(SVT) {}
42 135210843 : constexpr EVT(MVT S) : V(S) {}
43 :
44 0 : bool operator==(EVT VT) const {
45 35706674 : return !(*this != VT);
46 : }
47 0 : bool operator!=(EVT VT) const {
48 662717170 : if (V.SimpleTy != VT.V.SimpleTy)
49 0 : return true;
50 27283236 : if (V.SimpleTy == MVT::INVALID_SIMPLE_VALUE_TYPE)
51 28552 : return LLVMTy != VT.LLVMTy;
52 : return false;
53 : }
54 :
55 : /// Returns the EVT that represents a floating-point type with the given
56 : /// number of bits. There are two floating-point types with 128 bits - this
57 : /// returns f128 rather than ppcf128.
58 : static EVT getFloatingPointVT(unsigned BitWidth) {
59 : return MVT::getFloatingPointVT(BitWidth);
60 : }
61 :
62 : /// Returns the EVT that represents an integer with the given number of
63 : /// bits.
64 22799704 : static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth) {
65 22799704 : MVT M = MVT::getIntegerVT(BitWidth);
66 22799704 : if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
67 22334732 : return M;
68 464972 : return getExtendedIntegerVT(Context, BitWidth);
69 : }
70 :
71 : /// Returns the EVT that represents a vector NumElements in length, where
72 : /// each element is of type VT.
73 2931729 : static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements,
74 : bool IsScalable = false) {
75 2931729 : MVT M = MVT::getVectorVT(VT.V, NumElements, IsScalable);
76 2931729 : if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
77 2776201 : return M;
78 :
79 : assert(!IsScalable && "We don't support extended scalable types yet");
80 155528 : return getExtendedVectorVT(Context, VT, NumElements);
81 : }
82 :
83 : /// Returns the EVT that represents a vector EC.Min elements in length,
84 : /// where each element is of type VT.
85 0 : static EVT getVectorVT(LLVMContext &Context, EVT VT, MVT::ElementCount EC) {
86 0 : MVT M = MVT::getVectorVT(VT.V, EC);
87 0 : if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
88 0 : return M;
89 : assert (!EC.Scalable && "We don't support extended scalable types yet");
90 0 : return getExtendedVectorVT(Context, VT, EC.Min);
91 : }
92 :
93 : /// Return a vector with the same number of elements as this vector, but
94 : /// with the element type converted to an integer type with the same
95 : /// bitwidth.
96 27874 : EVT changeVectorElementTypeToInteger() const {
97 27874 : if (!isSimple()) {
98 : assert (!isScalableVector() &&
99 : "We don't support extended scalable types yet");
100 272 : return changeExtendedVectorElementTypeToInteger();
101 : }
102 27602 : MVT EltTy = getSimpleVT().getVectorElementType();
103 27602 : unsigned BitWidth = EltTy.getSizeInBits();
104 27602 : MVT IntTy = MVT::getIntegerVT(BitWidth);
105 : MVT VecTy = MVT::getVectorVT(IntTy, getVectorNumElements(),
106 27602 : isScalableVector());
107 : assert(VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE &&
108 : "Simple vector VT not representable by simple integer vector VT!");
109 27602 : return VecTy;
110 : }
111 :
112 : /// Return the type converted to an equivalently sized integer or vector
113 : /// with integer element type. Similar to changeVectorElementTypeToInteger,
114 : /// but also handles scalars.
115 2426 : EVT changeTypeToInteger() {
116 2426 : if (isVector())
117 254 : return changeVectorElementTypeToInteger();
118 :
119 2172 : if (isSimple())
120 2172 : return MVT::getIntegerVT(getSizeInBits());
121 :
122 0 : return changeExtendedTypeToInteger();
123 : }
124 :
125 : /// Test if the given EVT is simple (as opposed to being extended).
126 0 : bool isSimple() const {
127 0 : return V.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE;
128 : }
129 :
130 : /// Test if the given EVT is extended (as opposed to being simple).
131 : bool isExtended() const {
132 136957437 : return !isSimple();
133 : }
134 :
135 : /// Return true if this is a FP or a vector FP type.
136 2681291 : bool isFloatingPoint() const {
137 2681291 : return isSimple() ? V.isFloatingPoint() : isExtendedFloatingPoint();
138 : }
139 :
140 : /// Return true if this is an integer or a vector integer type.
141 12616841 : bool isInteger() const {
142 12616841 : return isSimple() ? V.isInteger() : isExtendedInteger();
143 : }
144 :
145 : /// Return true if this is an integer, but not a vector.
146 : bool isScalarInteger() const {
147 3581650 : return isSimple() ? V.isScalarInteger() : isExtendedScalarInteger();
148 : }
149 :
150 : /// Return true if this is a vector value type.
151 : bool isVector() const {
152 201425533 : return isSimple() ? V.isVector() : isExtendedVector();
153 : }
154 :
155 : /// Return true if this is a vector type where the runtime
156 : /// length is machine dependent
157 : bool isScalableVector() const {
158 : // FIXME: We don't support extended scalable types yet, because the
159 : // matching IR type doesn't exist. Once it has been added, this can
160 : // be changed to call isExtendedScalableVector.
161 29365 : if (!isSimple())
162 : return false;
163 : return V.isScalableVector();
164 : }
165 :
166 : /// Return true if this is a 16-bit vector type.
167 : bool is16BitVector() const {
168 : return isSimple() ? V.is16BitVector() : isExtended16BitVector();
169 : }
170 :
171 : /// Return true if this is a 32-bit vector type.
172 : bool is32BitVector() const {
173 : return isSimple() ? V.is32BitVector() : isExtended32BitVector();
174 : }
175 :
176 : /// Return true if this is a 64-bit vector type.
177 11691 : bool is64BitVector() const {
178 11691 : return isSimple() ? V.is64BitVector() : isExtended64BitVector();
179 : }
180 :
181 : /// Return true if this is a 128-bit vector type.
182 3516349 : bool is128BitVector() const {
183 3516349 : return isSimple() ? V.is128BitVector() : isExtended128BitVector();
184 : }
185 :
186 : /// Return true if this is a 256-bit vector type.
187 15462436 : bool is256BitVector() const {
188 15462436 : return isSimple() ? V.is256BitVector() : isExtended256BitVector();
189 : }
190 :
191 : /// Return true if this is a 512-bit vector type.
192 2868858 : bool is512BitVector() const {
193 2868858 : return isSimple() ? V.is512BitVector() : isExtended512BitVector();
194 : }
195 :
196 : /// Return true if this is a 1024-bit vector type.
197 : bool is1024BitVector() const {
198 : return isSimple() ? V.is1024BitVector() : isExtended1024BitVector();
199 : }
200 :
201 : /// Return true if this is a 2048-bit vector type.
202 : bool is2048BitVector() const {
203 : return isSimple() ? V.is2048BitVector() : isExtended2048BitVector();
204 : }
205 :
206 : /// Return true if this is an overloaded type for TableGen.
207 : bool isOverloaded() const {
208 : return (V==MVT::iAny || V==MVT::fAny || V==MVT::vAny || V==MVT::iPTRAny);
209 : }
210 :
211 : /// Return true if the bit size is a multiple of 8.
212 : bool isByteSized() const {
213 57895 : return (getSizeInBits() & 7) == 0;
214 : }
215 :
216 : /// Return true if the size is a power-of-two number of bytes.
217 : bool isRound() const {
218 134188 : unsigned BitSize = getSizeInBits();
219 134188 : return BitSize >= 8 && !(BitSize & (BitSize - 1));
220 : }
221 :
222 : /// Return true if this has the same number of bits as VT.
223 1285411 : bool bitsEq(EVT VT) const {
224 1285426 : if (EVT::operator==(VT)) return true;
225 170140 : return getSizeInBits() == VT.getSizeInBits();
226 : }
227 :
228 : /// Return true if this has more bits than VT.
229 1736262 : bool bitsGT(EVT VT) const {
230 1736422 : if (EVT::operator==(VT)) return false;
231 691602 : return getSizeInBits() > VT.getSizeInBits();
232 : }
233 :
234 : /// Return true if this has no less bits than VT.
235 47704 : bool bitsGE(EVT VT) const {
236 47791 : if (EVT::operator==(VT)) return true;
237 35066 : return getSizeInBits() >= VT.getSizeInBits();
238 : }
239 :
240 : /// Return true if this has less bits than VT.
241 5267153 : bool bitsLT(EVT VT) const {
242 5269389 : if (EVT::operator==(VT)) return false;
243 2093066 : return getSizeInBits() < VT.getSizeInBits();
244 : }
245 :
246 : /// Return true if this has no more bits than VT.
247 256148 : bool bitsLE(EVT VT) const {
248 257913 : if (EVT::operator==(VT)) return true;
249 212936 : return getSizeInBits() <= VT.getSizeInBits();
250 : }
251 :
252 : /// Return the SimpleValueType held in the specified simple EVT.
253 0 : MVT getSimpleVT() const {
254 : assert(isSimple() && "Expected a SimpleValueType!");
255 0 : return V;
256 : }
257 :
258 : /// If this is a vector type, return the element type, otherwise return
259 : /// this.
260 123380324 : EVT getScalarType() const {
261 123380324 : return isVector() ? getVectorElementType() : *this;
262 : }
263 :
264 : /// Given a vector type, return the type of each element.
265 21563232 : EVT getVectorElementType() const {
266 : assert(isVector() && "Invalid vector type!");
267 21563232 : if (isSimple())
268 21293755 : return V.getVectorElementType();
269 269477 : return getExtendedVectorElementType();
270 : }
271 :
272 : /// Given a vector type, return the number of elements it contains.
273 : unsigned getVectorNumElements() const {
274 : assert(isVector() && "Invalid vector type!");
275 12727413 : if (isSimple())
276 : return V.getVectorNumElements();
277 434826 : return getExtendedVectorNumElements();
278 : }
279 :
280 : // Given a (possibly scalable) vector type, return the ElementCount
281 125786 : MVT::ElementCount getVectorElementCount() const {
282 : assert((isVector()) && "Invalid vector type!");
283 125786 : if (isSimple())
284 : return V.getVectorElementCount();
285 :
286 : assert(!isScalableVector() &&
287 : "We don't support extended scalable types yet");
288 5169 : return {getExtendedVectorNumElements(), false};
289 : }
290 :
291 : /// Return the size of the specified value type in bits.
292 147743673 : unsigned getSizeInBits() const {
293 147743673 : if (isSimple())
294 146432978 : return V.getSizeInBits();
295 1310695 : return getExtendedSizeInBits();
296 : }
297 :
298 : unsigned getScalarSizeInBits() const {
299 13022104 : return getScalarType().getSizeInBits();
300 : }
301 :
302 : /// Return the number of bytes overwritten by a store of the specified value
303 : /// type.
304 : unsigned getStoreSize() const {
305 12849421 : return (getSizeInBits() + 7) / 8;
306 : }
307 :
308 : /// Return the number of bits overwritten by a store of the specified value
309 : /// type.
310 : unsigned getStoreSizeInBits() const {
311 164701 : return getStoreSize() * 8;
312 : }
313 :
314 : /// Rounds the bit-width of the given integer EVT up to the nearest power of
315 : /// two (and at least to eight), and returns the integer EVT with that
316 : /// number of bits.
317 209888 : EVT getRoundIntegerType(LLVMContext &Context) const {
318 : assert(isInteger() && !isVector() && "Invalid integer type!");
319 209888 : unsigned BitWidth = getSizeInBits();
320 209888 : if (BitWidth <= 8)
321 33426 : return EVT(MVT::i8);
322 176462 : return getIntegerVT(Context, 1 << Log2_32_Ceil(BitWidth));
323 : }
324 :
325 : /// Finds the smallest simple value type that is greater than or equal to
326 : /// half the width of this EVT. If no simple value type can be found, an
327 : /// extended integer value type of half the size (rounded up) is returned.
328 1677 : EVT getHalfSizedIntegerVT(LLVMContext &Context) const {
329 : assert(isInteger() && !isVector() && "Invalid integer type!");
330 1677 : unsigned EVTSize = getSizeInBits();
331 3774 : for (unsigned IntVT = MVT::FIRST_INTEGER_VALUETYPE;
332 5451 : IntVT <= MVT::LAST_INTEGER_VALUETYPE; ++IntVT) {
333 5451 : EVT HalfVT = EVT((MVT::SimpleValueType)IntVT);
334 5451 : if (HalfVT.getSizeInBits() * 2 >= EVTSize)
335 1677 : return HalfVT;
336 : }
337 0 : return getIntegerVT(Context, (EVTSize + 1) / 2);
338 : }
339 :
340 : /// Return a VT for an integer vector type with the size of the
341 : /// elements doubled. The typed returned may be an extended type.
342 5089 : EVT widenIntegerVectorElementType(LLVMContext &Context) const {
343 5089 : EVT EltVT = getVectorElementType();
344 5089 : EltVT = EVT::getIntegerVT(Context, 2 * EltVT.getSizeInBits());
345 5089 : return EVT::getVectorVT(Context, EltVT, getVectorElementCount());
346 : }
347 :
348 : // Return a VT for a vector type with the same element type but
349 : // half the number of elements. The type returned may be an
350 : // extended type.
351 120651 : EVT getHalfNumVectorElementsVT(LLVMContext &Context) const {
352 120651 : EVT EltVT = getVectorElementType();
353 120651 : auto EltCnt = getVectorElementCount();
354 : assert(!(EltCnt.Min & 1) && "Splitting vector, but not in half!");
355 241302 : return EVT::getVectorVT(Context, EltVT, EltCnt / 2);
356 : }
357 :
358 : /// Returns true if the given vector is a power of 2.
359 60617 : bool isPow2VectorType() const {
360 : unsigned NElts = getVectorNumElements();
361 60617 : return !(NElts & (NElts - 1));
362 : }
363 :
364 : /// Widens the length of the given vector EVT up to the nearest power of 2
365 : /// and returns that type.
366 1758 : EVT getPow2VectorType(LLVMContext &Context) const {
367 1758 : if (!isPow2VectorType()) {
368 : unsigned NElts = getVectorNumElements();
369 1758 : unsigned Pow2NElts = 1 << Log2_32_Ceil(NElts);
370 : return EVT::getVectorVT(Context, getVectorElementType(), Pow2NElts,
371 1758 : isScalableVector());
372 : }
373 : else {
374 0 : return *this;
375 : }
376 : }
377 :
378 : /// This function returns value type as a string, e.g. "i32".
379 : std::string getEVTString() const;
380 :
381 : /// This method returns an LLVM type corresponding to the specified EVT.
382 : /// For integer types, this returns an unsigned type. Note that this will
383 : /// abort for types that cannot be represented.
384 : Type *getTypeForEVT(LLVMContext &Context) const;
385 :
386 : /// Return the value type corresponding to the specified type.
387 : /// This returns all pointers as iPTR. If HandleUnknown is true, unknown
388 : /// types are returned as Other, otherwise they are invalid.
389 : static EVT getEVT(Type *Ty, bool HandleUnknown = false);
390 :
391 : intptr_t getRawBits() const {
392 60271235 : if (isSimple())
393 60216109 : return V.SimpleTy;
394 : else
395 55126 : return (intptr_t)(LLVMTy);
396 : }
397 :
398 : /// A meaningless but well-behaved order, useful for constructing
399 : /// containers.
400 : struct compareRawBits {
401 0 : bool operator()(EVT L, EVT R) const {
402 398420 : if (L.V.SimpleTy == R.V.SimpleTy)
403 398420 : return L.LLVMTy < R.LLVMTy;
404 : else
405 0 : return L.V.SimpleTy < R.V.SimpleTy;
406 : }
407 : };
408 :
409 : private:
410 : // Methods for handling the Extended-type case in functions above.
411 : // These are all out-of-line to prevent users of this header file
412 : // from having a dependency on Type.h.
413 : EVT changeExtendedTypeToInteger() const;
414 : EVT changeExtendedVectorElementTypeToInteger() const;
415 : static EVT getExtendedIntegerVT(LLVMContext &C, unsigned BitWidth);
416 : static EVT getExtendedVectorVT(LLVMContext &C, EVT VT,
417 : unsigned NumElements);
418 : bool isExtendedFloatingPoint() const LLVM_READONLY;
419 : bool isExtendedInteger() const LLVM_READONLY;
420 : bool isExtendedScalarInteger() const LLVM_READONLY;
421 : bool isExtendedVector() const LLVM_READONLY;
422 : bool isExtended16BitVector() const LLVM_READONLY;
423 : bool isExtended32BitVector() const LLVM_READONLY;
424 : bool isExtended64BitVector() const LLVM_READONLY;
425 : bool isExtended128BitVector() const LLVM_READONLY;
426 : bool isExtended256BitVector() const LLVM_READONLY;
427 : bool isExtended512BitVector() const LLVM_READONLY;
428 : bool isExtended1024BitVector() const LLVM_READONLY;
429 : bool isExtended2048BitVector() const LLVM_READONLY;
430 : EVT getExtendedVectorElementType() const;
431 : unsigned getExtendedVectorNumElements() const LLVM_READONLY;
432 : unsigned getExtendedSizeInBits() const LLVM_READONLY;
433 : };
434 :
435 : } // end namespace llvm
436 :
437 : #endif // LLVM_CODEGEN_VALUETYPES_H
|
