/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 | } |