Coverage Report

Created: 2018-11-16 02:38

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/CodeGen/ValueTypes.h
Line
Count
Source (jump to first uncovered line)
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
0
  struct EVT {
Unexecuted instantiation: llvm::EVT::operator=(llvm::EVT const&)
Unexecuted instantiation: llvm::EVT::operator=(llvm::EVT&&)
35
  private:
36
    MVT V = MVT::INVALID_SIMPLE_VALUE_TYPE;
37
    Type *LLVMTy = nullptr;
38
39
  public:
40
13.9M
    constexpr EVT() = default;
41
762M
    constexpr EVT(MVT::SimpleValueType SVT) : V(SVT) {}
42
1.23G
    constexpr EVT(MVT S) : V(S) {}
43
44
463M
    bool operator==(EVT VT) const {
45
463M
      return !(*this != VT);
46
463M
    }
47
664M
    bool operator!=(EVT VT) const {
48
664M
      if (V.SimpleTy != VT.V.SimpleTy)
49
467M
        return true;
50
196M
      if (V.SimpleTy == MVT::INVALID_SIMPLE_VALUE_TYPE)
51
41.8k
        return LLVMTy != VT.LLVMTy;
52
196M
      return false;
53
196M
    }
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
595
    static EVT getFloatingPointVT(unsigned BitWidth) {
59
595
      return MVT::getFloatingPointVT(BitWidth);
60
595
    }
61
62
    /// Returns the EVT that represents an integer with the given number of
63
    /// bits.
64
42.6M
    static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth) {
65
42.6M
      MVT M = MVT::getIntegerVT(BitWidth);
66
42.6M
      if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
67
41.9M
        return M;
68
627k
      return getExtendedIntegerVT(Context, BitWidth);
69
627k
    }
70
71
    /// Returns the EVT that represents a vector NumElements in length, where
72
    /// each element is of type VT.
73
    static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements,
74
8.25M
                           bool IsScalable = false) {
75
8.25M
      MVT M = MVT::getVectorVT(VT.V, NumElements, IsScalable);
76
8.25M
      if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
77
7.97M
        return M;
78
271k
79
271k
      assert(!IsScalable && "We don't support extended scalable types yet");
80
271k
      return getExtendedVectorVT(Context, VT, NumElements);
81
271k
    }
82
83
    /// Returns the EVT that represents a vector EC.Min elements in length,
84
    /// where each element is of type VT.
85
172k
    static EVT getVectorVT(LLVMContext &Context, EVT VT, MVT::ElementCount EC) {
86
172k
      MVT M = MVT::getVectorVT(VT.V, EC);
87
172k
      if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
88
164k
        return M;
89
8.26k
      assert (!EC.Scalable && "We don't support extended scalable types yet");
90
8.26k
      return getExtendedVectorVT(Context, VT, EC.Min);
91
8.26k
    }
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
102k
    EVT changeVectorElementTypeToInteger() const {
97
102k
      if (!isSimple()) {
98
286
        assert (!isScalableVector() &&
99
286
                "We don't support extended scalable types yet");
100
286
        return changeExtendedVectorElementTypeToInteger();
101
286
      }
102
101k
      MVT EltTy = getSimpleVT().getVectorElementType();
103
101k
      unsigned BitWidth = EltTy.getSizeInBits();
104
101k
      MVT IntTy = MVT::getIntegerVT(BitWidth);
105
101k
      MVT VecTy = MVT::getVectorVT(IntTy, getVectorNumElements(),
106
101k
                                   isScalableVector());
107
101k
      assert(VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE &&
108
101k
             "Simple vector VT not representable by simple integer vector VT!");
109
101k
      return VecTy;
110
101k
    }
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
2.52k
    EVT changeTypeToInteger() {
116
2.52k
      if (isVector())
117
254
        return changeVectorElementTypeToInteger();
118
2.26k
119
2.26k
      if (isSimple())
120
2.26k
        return MVT::getIntegerVT(getSizeInBits());
121
0
122
0
      return changeExtendedTypeToInteger();
123
0
    }
124
125
    /// Test if the given EVT is simple (as opposed to being extended).
126
2.16G
    bool isSimple() const {
127
2.16G
      return V.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE;
128
2.16G
    }
129
130
    /// Test if the given EVT is extended (as opposed to being simple).
131
261M
    bool isExtended() const {
132
261M
      return !isSimple();
133
261M
    }
134
135
    /// Return true if this is a FP or a vector FP type.
136
3.92M
    bool isFloatingPoint() const {
137
3.92M
      return isSimple() ? 
V.isFloatingPoint()3.92M
:
isExtendedFloatingPoint()6.91k
;
138
3.92M
    }
139
140
    /// Return true if this is an integer or a vector integer type.
141
33.9M
    bool isInteger() const {
142
33.9M
      return isSimple() ? 
V.isInteger()33.9M
:
isExtendedInteger()78.4k
;
143
33.9M
    }
144
145
    /// Return true if this is an integer, but not a vector.
146
4.33M
    bool isScalarInteger() const {
147
4.33M
      return isSimple() ? 
V.isScalarInteger()4.33M
:
isExtendedScalarInteger()5.49k
;
148
4.33M
    }
149
150
    /// Return true if this is a vector value type.
151
369M
    bool isVector() const {
152
369M
      return isSimple() ? 
V.isVector()368M
:
isExtendedVector()1.03M
;
153
369M
    }
154
155
    /// Return true if this is a vector type where the runtime
156
    /// length is machine dependent
157
107k
    bool isScalableVector() const {
158
107k
      // FIXME: We don't support extended scalable types yet, because the
159
107k
      // matching IR type doesn't exist. Once it has been added, this can
160
107k
      // be changed to call isExtendedScalableVector.
161
107k
      if (!isSimple())
162
5.35k
        return false;
163
101k
      return V.isScalableVector();
164
101k
    }
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
14.7k
    bool is64BitVector() const {
178
14.7k
      return isSimple() ? V.is64BitVector() : 
isExtended64BitVector()0
;
179
14.7k
    }
180
181
    /// Return true if this is a 128-bit vector type.
182
1.23M
    bool is128BitVector() const {
183
1.23M
      return isSimple() ? 
V.is128BitVector()1.23M
:
isExtended128BitVector()545
;
184
1.23M
    }
185
186
    /// Return true if this is a 256-bit vector type.
187
2.84M
    bool is256BitVector() const {
188
2.84M
      return isSimple() ? 
V.is256BitVector()2.84M
:
isExtended256BitVector()3.02k
;
189
2.84M
    }
190
191
    /// Return true if this is a 512-bit vector type.
192
1.17M
    bool is512BitVector() const {
193
1.17M
      return isSimple() ? 
V.is512BitVector()1.17M
:
isExtended512BitVector()445
;
194
1.17M
    }
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
252k
    bool isByteSized() const {
213
252k
      return (getSizeInBits() & 7) == 0;
214
252k
    }
215
216
    /// Return true if the size is a power-of-two number of bytes.
217
164k
    bool isRound() const {
218
164k
      unsigned BitSize = getSizeInBits();
219
164k
      return BitSize >= 8 && 
!(BitSize & (BitSize - 1))139k
;
220
164k
    }
221
222
    /// Return true if this has the same number of bits as VT.
223
8.60M
    bool bitsEq(EVT VT) const {
224
8.60M
      if (EVT::operator==(VT)) 
return true4.52M
;
225
4.07M
      return getSizeInBits() == VT.getSizeInBits();
226
4.07M
    }
227
228
    /// Return true if this has more bits than VT.
229
1.41M
    bool bitsGT(EVT VT) const {
230
1.41M
      if (EVT::operator==(VT)) 
return false1.11M
;
231
306k
      return getSizeInBits() > VT.getSizeInBits();
232
306k
    }
233
234
    /// Return true if this has no less bits than VT.
235
90.9k
    bool bitsGE(EVT VT) const {
236
90.9k
      if (EVT::operator==(VT)) 
return true55.7k
;
237
35.1k
      return getSizeInBits() >= VT.getSizeInBits();
238
35.1k
    }
239
240
    /// Return true if this has less bits than VT.
241
9.79M
    bool bitsLT(EVT VT) const {
242
9.79M
      if (EVT::operator==(VT)) 
return false6.58M
;
243
3.21M
      return getSizeInBits() < VT.getSizeInBits();
244
3.21M
    }
245
246
    /// Return true if this has no more bits than VT.
247
405k
    bool bitsLE(EVT VT) const {
248
405k
      if (EVT::operator==(VT)) 
return true28.4k
;
249
377k
      return getSizeInBits() <= VT.getSizeInBits();
250
377k
    }
251
252
    /// Return the SimpleValueType held in the specified simple EVT.
253
1.07G
    MVT getSimpleVT() const {
254
1.07G
      assert(isSimple() && "Expected a SimpleValueType!");
255
1.07G
      return V;
256
1.07G
    }
257
258
    /// If this is a vector type, return the element type, otherwise return
259
    /// this.
260
154M
    EVT getScalarType() const {
261
154M
      return isVector() ? 
getVectorElementType()15.0M
:
*this139M
;
262
154M
    }
263
264
    /// Given a vector type, return the type of each element.
265
18.1M
    EVT getVectorElementType() const {
266
18.1M
      assert(isVector() && "Invalid vector type!");
267
18.1M
      if (isSimple())
268
17.8M
        return V.getVectorElementType();
269
347k
      return getExtendedVectorElementType();
270
347k
    }
271
272
    /// Given a vector type, return the number of elements it contains.
273
13.1M
    unsigned getVectorNumElements() const {
274
13.1M
      assert(isVector() && "Invalid vector type!");
275
13.1M
      if (isSimple())
276
12.5M
        return V.getVectorNumElements();
277
623k
      return getExtendedVectorNumElements();
278
623k
    }
279
280
    // Given a (possibly scalable) vector type, return the ElementCount
281
172k
    MVT::ElementCount getVectorElementCount() const {
282
172k
      assert((isVector()) && "Invalid vector type!");
283
172k
      if (isSimple())
284
165k
        return V.getVectorElementCount();
285
7.39k
286
7.39k
      assert(!isScalableVector() &&
287
7.39k
             "We don't support extended scalable types yet");
288
7.39k
      return {getExtendedVectorNumElements(), false};
289
7.39k
    }
290
291
    /// Return the size of the specified value type in bits.
292
201M
    unsigned getSizeInBits() const {
293
201M
      if (isSimple())
294
199M
        return V.getSizeInBits();
295
2.25M
      return getExtendedSizeInBits();
296
2.25M
    }
297
298
15.7M
    unsigned getScalarSizeInBits() const {
299
15.7M
      return getScalarType().getSizeInBits();
300
15.7M
    }
301
302
    /// Return the number of bytes overwritten by a store of the specified value
303
    /// type.
304
20.9M
    unsigned getStoreSize() const {
305
20.9M
      return (getSizeInBits() + 7) / 8;
306
20.9M
    }
307
308
    /// Return the number of bits overwritten by a store of the specified value
309
    /// type.
310
936k
    unsigned getStoreSizeInBits() const {
311
936k
      return getStoreSize() * 8;
312
936k
    }
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
289k
    EVT getRoundIntegerType(LLVMContext &Context) const {
318
289k
      assert(isInteger() && !isVector() && "Invalid integer type!");
319
289k
      unsigned BitWidth = getSizeInBits();
320
289k
      if (BitWidth <= 8)
321
34.6k
        return EVT(MVT::i8);
322
254k
      return getIntegerVT(Context, 1 << Log2_32_Ceil(BitWidth));
323
254k
    }
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
1.67k
    EVT getHalfSizedIntegerVT(LLVMContext &Context) const {
329
1.67k
      assert(isInteger() && !isVector() && "Invalid integer type!");
330
1.67k
      unsigned EVTSize = getSizeInBits();
331
1.67k
      for (unsigned IntVT = MVT::FIRST_INTEGER_VALUETYPE;
332
5.44k
          IntVT <= MVT::LAST_INTEGER_VALUETYPE; 
++IntVT3.76k
) {
333
5.44k
        EVT HalfVT = EVT((MVT::SimpleValueType)IntVT);
334
5.44k
        if (HalfVT.getSizeInBits() * 2 >= EVTSize)
335
1.67k
          return HalfVT;
336
5.44k
      }
337
1.67k
      
return getIntegerVT(Context, (EVTSize + 1) / 2)0
;
338
1.67k
    }
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
6.09k
    EVT widenIntegerVectorElementType(LLVMContext &Context) const {
343
6.09k
      EVT EltVT = getVectorElementType();
344
6.09k
      EltVT = EVT::getIntegerVT(Context, 2 * EltVT.getSizeInBits());
345
6.09k
      return EVT::getVectorVT(Context, EltVT, getVectorElementCount());
346
6.09k
    }
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
166k
    EVT getHalfNumVectorElementsVT(LLVMContext &Context) const {
352
166k
      EVT EltVT = getVectorElementType();
353
166k
      auto EltCnt = getVectorElementCount();
354
166k
      assert(!(EltCnt.Min & 1) && "Splitting vector, but not in half!");
355
166k
      return EVT::getVectorVT(Context, EltVT, EltCnt / 2);
356
166k
    }
357
358
    /// Returns true if the given vector is a power of 2.
359
121k
    bool isPow2VectorType() const {
360
121k
      unsigned NElts = getVectorNumElements();
361
121k
      return !(NElts & (NElts - 1));
362
121k
    }
363
364
    /// Widens the length of the given vector EVT up to the nearest power of 2
365
    /// and returns that type.
366
5.35k
    EVT getPow2VectorType(LLVMContext &Context) const {
367
5.35k
      if (!isPow2VectorType()) {
368
5.35k
        unsigned NElts = getVectorNumElements();
369
5.35k
        unsigned Pow2NElts = 1 <<  Log2_32_Ceil(NElts);
370
5.35k
        return EVT::getVectorVT(Context, getVectorElementType(), Pow2NElts,
371
5.35k
                                isScalableVector());
372
5.35k
      }
373
0
      else {
374
0
        return *this;
375
0
      }
376
5.35k
    }
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
50.5M
    intptr_t getRawBits() const {
392
50.5M
      if (isSimple())
393
50.5M
        return V.SimpleTy;
394
59.6k
      else
395
59.6k
        return (intptr_t)(LLVMTy);
396
50.5M
    }
397
398
    /// A meaningless but well-behaved order, useful for constructing
399
    /// containers.
400
    struct compareRawBits {
401
715k
      bool operator()(EVT L, EVT R) const {
402
715k
        if (L.V.SimpleTy == R.V.SimpleTy)
403
715k
          return L.LLVMTy < R.LLVMTy;
404
0
        else
405
0
          return L.V.SimpleTy < R.V.SimpleTy;
406
715k
      }
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