Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/lib/IR/ValueTypes.cpp
Line
Count
Source (jump to first uncovered line)
1
//===----------- ValueTypes.cpp - Implementation of EVT methods -----------===//
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 implements methods in the CodeGen/ValueTypes.h header.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#include "llvm/CodeGen/ValueTypes.h"
15
#include "llvm/ADT/StringExtras.h"
16
#include "llvm/IR/DerivedTypes.h"
17
#include "llvm/IR/LLVMContext.h"
18
#include "llvm/IR/Type.h"
19
#include "llvm/Support/ErrorHandling.h"
20
using namespace llvm;
21
22
0
EVT EVT::changeExtendedTypeToInteger() const {
23
0
  LLVMContext &Context = LLVMTy->getContext();
24
0
  return getIntegerVT(Context, getSizeInBits());
25
0
}
26
27
179
EVT EVT::changeExtendedVectorElementTypeToInteger() const {
28
179
  LLVMContext &Context = LLVMTy->getContext();
29
179
  EVT IntTy = getIntegerVT(Context, getScalarSizeInBits());
30
179
  return getVectorVT(Context, IntTy, getVectorNumElements());
31
179
}
32
33
1.14M
EVT EVT::getExtendedIntegerVT(LLVMContext &Context, unsigned BitWidth) {
34
1.14M
  EVT VT;
35
1.14M
  VT.LLVMTy = IntegerType::get(Context, BitWidth);
36
1.14M
  assert(VT.isExtended() && "Type is not extended!");
37
1.14M
  return VT;
38
1.14M
}
39
40
EVT EVT::getExtendedVectorVT(LLVMContext &Context, EVT VT,
41
14.3M
                             unsigned NumElements) {
42
14.3M
  EVT ResultVT;
43
14.3M
  ResultVT.LLVMTy = VectorType::get(VT.getTypeForEVT(Context), NumElements);
44
14.3M
  assert(ResultVT.isExtended() && "Type is not extended!");
45
14.3M
  return ResultVT;
46
14.3M
}
47
48
3.09k
bool EVT::isExtendedFloatingPoint() const {
49
3.09k
  assert(isExtended() && "Type is not extended!");
50
3.09k
  return LLVMTy->isFPOrFPVectorTy();
51
3.09k
}
52
53
60.8k
bool EVT::isExtendedInteger() const {
54
60.8k
  assert(isExtended() && "Type is not extended!");
55
60.8k
  return LLVMTy->isIntOrIntVectorTy();
56
60.8k
}
57
58
3.66k
bool EVT::isExtendedScalarInteger() const {
59
3.66k
  assert(isExtended() && "Type is not extended!");
60
3.66k
  return LLVMTy->isIntegerTy();
61
3.66k
}
62
63
1.17M
bool EVT::isExtendedVector() const {
64
1.17M
  assert(isExtended() && "Type is not extended!");
65
1.17M
  return LLVMTy->isVectorTy();
66
1.17M
}
67
68
0
bool EVT::isExtended16BitVector() const {
69
0
  return isExtendedVector() && getExtendedSizeInBits() == 16;
70
0
}
71
72
0
bool EVT::isExtended32BitVector() const {
73
0
  return isExtendedVector() && getExtendedSizeInBits() == 32;
74
0
}
75
76
0
bool EVT::isExtended64BitVector() const {
77
0
  return isExtendedVector() && getExtendedSizeInBits() == 64;
78
0
}
79
80
158
bool EVT::isExtended128BitVector() const {
81
84
  return isExtendedVector() && getExtendedSizeInBits() == 128;
82
158
}
83
84
2.58k
bool EVT::isExtended256BitVector() const {
85
612
  return isExtendedVector() && getExtendedSizeInBits() == 256;
86
2.58k
}
87
88
131
bool EVT::isExtended512BitVector() const {
89
57
  return isExtendedVector() && getExtendedSizeInBits() == 512;
90
131
}
91
92
0
bool EVT::isExtended1024BitVector() const {
93
0
  return isExtendedVector() && getExtendedSizeInBits() == 1024;
94
0
}
95
96
0
bool EVT::isExtended2048BitVector() const {
97
0
  return isExtendedVector() && getExtendedSizeInBits() == 2048;
98
0
}
99
100
184k
EVT EVT::getExtendedVectorElementType() const {
101
184k
  assert(isExtended() && "Type is not extended!");
102
184k
  return EVT::getEVT(cast<VectorType>(LLVMTy)->getElementType());
103
184k
}
104
105
437k
unsigned EVT::getExtendedVectorNumElements() const {
106
437k
  assert(isExtended() && "Type is not extended!");
107
437k
  return cast<VectorType>(LLVMTy)->getNumElements();
108
437k
}
109
110
2.13M
unsigned EVT::getExtendedSizeInBits() const {
111
2.13M
  assert(isExtended() && "Type is not extended!");
112
2.13M
  if (IntegerType *ITy = dyn_cast<IntegerType>(LLVMTy))
113
2.07M
    return ITy->getBitWidth();
114
55.2k
  
if (VectorType *55.2k
VTy55.2k
= dyn_cast<VectorType>(LLVMTy))
115
55.2k
    return VTy->getBitWidth();
116
0
  
llvm_unreachable0
("Unrecognized extended type!");
117
0
}
118
119
/// getEVTString - This function returns value type as a string, e.g. "i32".
120
2.77M
std::string EVT::getEVTString() const {
121
2.77M
  switch (V.SimpleTy) {
122
358
  default:
123
358
    if (isVector())
124
0
      return "v" + utostr(getVectorNumElements()) +
125
0
             getVectorElementType().getEVTString();
126
358
    
if (358
isInteger()358
)
127
358
      return "i" + utostr(getSizeInBits());
128
0
    
llvm_unreachable0
("Invalid EVT!");
129
278
  case MVT::i1:      return "i1";
130
982k
  case MVT::i8:      return "i8";
131
217k
  case MVT::i16:     return "i16";
132
299k
  case MVT::i32:     return "i32";
133
146k
  case MVT::i64:     return "i64";
134
85
  case MVT::i128:    return "i128";
135
5.13k
  case MVT::f16:     return "f16";
136
737k
  case MVT::f32:     return "f32";
137
384k
  case MVT::f64:     return "f64";
138
741
  case MVT::f80:     return "f80";
139
457
  case MVT::f128:    return "f128";
140
74
  case MVT::ppcf128: return "ppcf128";
141
561
  case MVT::isVoid:  return "isVoid";
142
0
  case MVT::Other:   return "ch";
143
0
  case MVT::Glue:    return "glue";
144
0
  case MVT::x86mmx:  return "x86mmx";
145
0
  case MVT::v1i1:    return "v1i1";
146
0
  case MVT::v2i1:    return "v2i1";
147
0
  case MVT::v4i1:    return "v4i1";
148
0
  case MVT::v8i1:    return "v8i1";
149
0
  case MVT::v16i1:   return "v16i1";
150
0
  case MVT::v32i1:   return "v32i1";
151
0
  case MVT::v64i1:   return "v64i1";
152
0
  case MVT::v512i1:  return "v512i1";
153
0
  case MVT::v1024i1: return "v1024i1";
154
0
  case MVT::v1i8:    return "v1i8";
155
0
  case MVT::v2i8:    return "v2i8";
156
0
  case MVT::v4i8:    return "v4i8";
157
0
  case MVT::v8i8:    return "v8i8";
158
0
  case MVT::v16i8:   return "v16i8";
159
0
  case MVT::v32i8:   return "v32i8";
160
0
  case MVT::v64i8:   return "v64i8";
161
0
  case MVT::v128i8:  return "v128i8";
162
0
  case MVT::v256i8:  return "v256i8";
163
0
  case MVT::v1i16:   return "v1i16";
164
0
  case MVT::v2i16:   return "v2i16";
165
0
  case MVT::v4i16:   return "v4i16";
166
0
  case MVT::v8i16:   return "v8i16";
167
0
  case MVT::v16i16:  return "v16i16";
168
0
  case MVT::v32i16:  return "v32i16";
169
0
  case MVT::v64i16:  return "v64i16";
170
0
  case MVT::v128i16: return "v128i16";
171
0
  case MVT::v1i32:   return "v1i32";
172
0
  case MVT::v2i32:   return "v2i32";
173
0
  case MVT::v4i32:   return "v4i32";
174
0
  case MVT::v8i32:   return "v8i32";
175
0
  case MVT::v16i32:  return "v16i32";
176
0
  case MVT::v32i32:  return "v32i32";
177
0
  case MVT::v64i32:  return "v64i32";
178
0
  case MVT::v1i64:   return "v1i64";
179
0
  case MVT::v2i64:   return "v2i64";
180
0
  case MVT::v4i64:   return "v4i64";
181
0
  case MVT::v8i64:   return "v8i64";
182
0
  case MVT::v16i64:  return "v16i64";
183
0
  case MVT::v32i64:  return "v32i64";
184
0
  case MVT::v1i128:  return "v1i128";
185
0
  case MVT::v1f32:   return "v1f32";
186
0
  case MVT::v2f32:   return "v2f32";
187
0
  case MVT::v2f16:   return "v2f16";
188
0
  case MVT::v4f16:   return "v4f16";
189
0
  case MVT::v8f16:   return "v8f16";
190
0
  case MVT::v4f32:   return "v4f32";
191
0
  case MVT::v8f32:   return "v8f32";
192
0
  case MVT::v16f32:  return "v16f32";
193
0
  case MVT::v1f64:   return "v1f64";
194
0
  case MVT::v2f64:   return "v2f64";
195
0
  case MVT::v4f64:   return "v4f64";
196
0
  case MVT::v8f64:   return "v8f64";
197
0
  case MVT::Metadata:return "Metadata";
198
0
  case MVT::Untyped: return "Untyped";
199
0
  }
200
0
}
201
202
/// getTypeForEVT - This method returns an LLVM type corresponding to the
203
/// specified EVT.  For integer types, this returns an unsigned type.  Note
204
/// that this will abort for types that cannot be represented.
205
35.1M
Type *EVT::getTypeForEVT(LLVMContext &Context) const {
206
35.1M
  switch (V.SimpleTy) {
207
21.8k
  default:
208
21.8k
    assert(isExtended() && "Type is not extended!");
209
21.8k
    return LLVMTy;
210
3.26k
  case MVT::isVoid:  return Type::getVoidTy(Context);
211
39.4k
  case MVT::i1:      return Type::getInt1Ty(Context);
212
1.32M
  case MVT::i8:      return Type::getInt8Ty(Context);
213
409k
  case MVT::i16:     return Type::getInt16Ty(Context);
214
4.35M
  case MVT::i32:     return Type::getInt32Ty(Context);
215
11.4M
  case MVT::i64:     return Type::getInt64Ty(Context);
216
7.95k
  case MVT::i128:    return IntegerType::get(Context, 128);
217
13.7k
  case MVT::f16:     return Type::getHalfTy(Context);
218
151k
  case MVT::f32:     return Type::getFloatTy(Context);
219
14.5M
  case MVT::f64:     return Type::getDoubleTy(Context);
220
6.43k
  case MVT::f80:     return Type::getX86_FP80Ty(Context);
221
37.5k
  case MVT::f128:    return Type::getFP128Ty(Context);
222
503
  case MVT::ppcf128: return Type::getPPC_FP128Ty(Context);
223
3.40k
  case MVT::x86mmx:  return Type::getX86_MMXTy(Context);
224
55
  case MVT::v1i1:    return VectorType::get(Type::getInt1Ty(Context), 1);
225
364
  case MVT::v2i1:    return VectorType::get(Type::getInt1Ty(Context), 2);
226
1.62k
  case MVT::v4i1:    return VectorType::get(Type::getInt1Ty(Context), 4);
227
669
  case MVT::v8i1:    return VectorType::get(Type::getInt1Ty(Context), 8);
228
3.68k
  case MVT::v16i1:   return VectorType::get(Type::getInt1Ty(Context), 16);
229
2.06k
  case MVT::v32i1:   return VectorType::get(Type::getInt1Ty(Context), 32);
230
544
  case MVT::v64i1:   return VectorType::get(Type::getInt1Ty(Context), 64);
231
155
  case MVT::v512i1:  return VectorType::get(Type::getInt1Ty(Context), 512);
232
4
  case MVT::v1024i1: return VectorType::get(Type::getInt1Ty(Context), 1024);
233
207
  case MVT::v1i8:    return VectorType::get(Type::getInt8Ty(Context), 1);
234
983
  case MVT::v2i8:    return VectorType::get(Type::getInt8Ty(Context), 2);
235
3.13k
  case MVT::v4i8:    return VectorType::get(Type::getInt8Ty(Context), 4);
236
14.1k
  case MVT::v8i8:    return VectorType::get(Type::getInt8Ty(Context), 8);
237
27.1k
  case MVT::v16i8:   return VectorType::get(Type::getInt8Ty(Context), 16);
238
7.73k
  case MVT::v32i8:   return VectorType::get(Type::getInt8Ty(Context), 32);
239
1.18k
  case MVT::v64i8:   return VectorType::get(Type::getInt8Ty(Context), 64);
240
38
  case MVT::v128i8:  return VectorType::get(Type::getInt8Ty(Context), 128);
241
2
  case MVT::v256i8:  return VectorType::get(Type::getInt8Ty(Context), 256);
242
285
  case MVT::v1i16:   return VectorType::get(Type::getInt16Ty(Context), 1);
243
1.94k
  case MVT::v2i16:   return VectorType::get(Type::getInt16Ty(Context), 2);
244
15.2k
  case MVT::v4i16:   return VectorType::get(Type::getInt16Ty(Context), 4);
245
23.2k
  case MVT::v8i16:   return VectorType::get(Type::getInt16Ty(Context), 8);
246
4.53k
  case MVT::v16i16:  return VectorType::get(Type::getInt16Ty(Context), 16);
247
1.63k
  case MVT::v32i16:  return VectorType::get(Type::getInt16Ty(Context), 32);
248
64
  case MVT::v64i16:  return VectorType::get(Type::getInt16Ty(Context), 64);
249
0
  case MVT::v128i16: return VectorType::get(Type::getInt16Ty(Context), 128);
250
1.10k
  case MVT::v1i32:   return VectorType::get(Type::getInt32Ty(Context), 1);
251
661k
  case MVT::v2i32:   return VectorType::get(Type::getInt32Ty(Context), 2);
252
100k
  case MVT::v4i32:   return VectorType::get(Type::getInt32Ty(Context), 4);
253
10.7k
  case MVT::v8i32:   return VectorType::get(Type::getInt32Ty(Context), 8);
254
6.78k
  case MVT::v16i32:  return VectorType::get(Type::getInt32Ty(Context), 16);
255
728
  case MVT::v32i32:  return VectorType::get(Type::getInt32Ty(Context), 32);
256
75
  case MVT::v64i32:  return VectorType::get(Type::getInt32Ty(Context), 64);
257
37.5k
  case MVT::v1i64:   return VectorType::get(Type::getInt64Ty(Context), 1);
258
158k
  case MVT::v2i64:   return VectorType::get(Type::getInt64Ty(Context), 2);
259
28.9k
  case MVT::v4i64:   return VectorType::get(Type::getInt64Ty(Context), 4);
260
7.54k
  case MVT::v8i64:   return VectorType::get(Type::getInt64Ty(Context), 8);
261
450
  case MVT::v16i64:  return VectorType::get(Type::getInt64Ty(Context), 16);
262
146
  case MVT::v32i64:  return VectorType::get(Type::getInt64Ty(Context), 32);
263
163
  case MVT::v1i128:  return VectorType::get(Type::getInt128Ty(Context), 1);
264
2.67k
  case MVT::v2f16:   return VectorType::get(Type::getHalfTy(Context), 2);
265
344
  case MVT::v4f16:   return VectorType::get(Type::getHalfTy(Context), 4);
266
336
  case MVT::v8f16:   return VectorType::get(Type::getHalfTy(Context), 8);
267
263
  case MVT::v1f32:   return VectorType::get(Type::getFloatTy(Context), 1);
268
2.39k
  case MVT::v2f32:   return VectorType::get(Type::getFloatTy(Context), 2);
269
19.7k
  case MVT::v4f32:   return VectorType::get(Type::getFloatTy(Context), 4);
270
7.98k
  case MVT::v8f32:   return VectorType::get(Type::getFloatTy(Context), 8);
271
3.07k
  case MVT::v16f32:   return VectorType::get(Type::getFloatTy(Context), 16);
272
942k
  case MVT::v1f64:   return VectorType::get(Type::getDoubleTy(Context), 1);
273
711k
  case MVT::v2f64:   return VectorType::get(Type::getDoubleTy(Context), 2);
274
6.97k
  case MVT::v4f64:   return VectorType::get(Type::getDoubleTy(Context), 4); 
275
2.88k
  case MVT::v8f64:   return VectorType::get(Type::getDoubleTy(Context), 8); 
276
0
  case MVT::Metadata: return Type::getMetadataTy(Context);
277
0
 }
278
0
}
279
280
/// Return the value type corresponding to the specified type.  This returns all
281
/// pointers as MVT::iPTR.  If HandleUnknown is true, unknown types are returned
282
/// as Other, otherwise they are invalid.
283
8.62M
MVT MVT::getVT(Type *Ty, bool HandleUnknown){
284
8.62M
  switch (Ty->getTypeID()) {
285
8.28k
  default:
286
8.28k
    if (
HandleUnknown8.28k
)
return MVT(MVT::Other)8.28k
;
287
0
    
llvm_unreachable0
("Unknown type!");
288
14.5k
  case Type::VoidTyID:
289
14.5k
    return MVT::isVoid;
290
4.35M
  case Type::IntegerTyID:
291
4.35M
    return getIntegerVT(cast<IntegerType>(Ty)->getBitWidth());
292
40.1k
  case Type::HalfTyID:      return MVT(MVT::f16);
293
1.80M
  case Type::FloatTyID:     return MVT(MVT::f32);
294
2.37M
  case Type::DoubleTyID:    return MVT(MVT::f64);
295
11.2k
  case Type::X86_FP80TyID:  return MVT(MVT::f80);
296
4.37k
  case Type::X86_MMXTyID:   return MVT(MVT::x86mmx);
297
7.13k
  case Type::FP128TyID:     return MVT(MVT::f128);
298
937
  case Type::PPC_FP128TyID: return MVT(MVT::ppcf128);
299
2
  case Type::PointerTyID:   return MVT(MVT::iPTR);
300
1.53k
  case Type::VectorTyID: {
301
1.53k
    VectorType *VTy = cast<VectorType>(Ty);
302
1.53k
    return getVectorVT(
303
1.53k
      getVT(VTy->getElementType(), false), VTy->getNumElements());
304
0
  }
305
8.62M
  }
306
8.62M
}
307
308
/// getEVT - Return the value type corresponding to the specified type.  This
309
/// returns all pointers as MVT::iPTR.  If HandleUnknown is true, unknown types
310
/// are returned as Other, otherwise they are invalid.
311
67.6M
EVT EVT::getEVT(Type *Ty, bool HandleUnknown){
312
67.6M
  switch (Ty->getTypeID()) {
313
4.22M
  default:
314
4.22M
    return MVT::getVT(Ty, HandleUnknown);
315
63.4M
  case Type::IntegerTyID:
316
63.4M
    return getIntegerVT(Ty->getContext(), cast<IntegerType>(Ty)->getBitWidth());
317
2.28k
  case Type::VectorTyID: {
318
2.28k
    VectorType *VTy = cast<VectorType>(Ty);
319
2.28k
    return getVectorVT(Ty->getContext(), getEVT(VTy->getElementType(), false),
320
2.28k
                       VTy->getNumElements());
321
0
  }
322
0
  }
323
0
}