|
150
|
1 //===----------- ValueTypes.cpp - Implementation of EVT methods -----------===//
|
|
|
2 //
|
|
|
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
4 // See https://llvm.org/LICENSE.txt for license information.
|
|
|
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
6 //
|
|
|
7 //===----------------------------------------------------------------------===//
|
|
|
8
|
|
|
9 #include "llvm/CodeGen/ValueTypes.h"
|
|
|
10 #include "llvm/ADT/StringExtras.h"
|
|
|
11 #include "llvm/IR/DerivedTypes.h"
|
|
|
12 #include "llvm/IR/Type.h"
|
|
|
13 #include "llvm/Support/ErrorHandling.h"
|
|
|
14 #include "llvm/Support/TypeSize.h"
|
|
|
15 using namespace llvm;
|
|
|
16
|
|
|
17 EVT EVT::changeExtendedTypeToInteger() const {
|
|
|
18 LLVMContext &Context = LLVMTy->getContext();
|
|
|
19 return getIntegerVT(Context, getSizeInBits());
|
|
|
20 }
|
|
|
21
|
|
|
22 EVT EVT::changeExtendedVectorElementTypeToInteger() const {
|
|
|
23 LLVMContext &Context = LLVMTy->getContext();
|
|
|
24 EVT IntTy = getIntegerVT(Context, getScalarSizeInBits());
|
|
173
|
25 return getVectorVT(Context, IntTy, getVectorNumElements(),
|
|
|
26 isScalableVector());
|
|
150
|
27 }
|
|
|
28
|
|
|
29 EVT EVT::getExtendedIntegerVT(LLVMContext &Context, unsigned BitWidth) {
|
|
|
30 EVT VT;
|
|
|
31 VT.LLVMTy = IntegerType::get(Context, BitWidth);
|
|
|
32 assert(VT.isExtended() && "Type is not extended!");
|
|
|
33 return VT;
|
|
|
34 }
|
|
|
35
|
|
173
|
36 EVT EVT::getExtendedVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements,
|
|
|
37 bool IsScalable) {
|
|
150
|
38 EVT ResultVT;
|
|
173
|
39 ResultVT.LLVMTy =
|
|
|
40 VectorType::get(VT.getTypeForEVT(Context), NumElements, IsScalable);
|
|
|
41 assert(ResultVT.isExtended() && "Type is not extended!");
|
|
|
42 return ResultVT;
|
|
|
43 }
|
|
|
44
|
|
|
45 EVT EVT::getExtendedVectorVT(LLVMContext &Context, EVT VT, ElementCount EC) {
|
|
|
46 EVT ResultVT;
|
|
|
47 ResultVT.LLVMTy =
|
|
|
48 VectorType::get(VT.getTypeForEVT(Context), {EC.Min, EC.Scalable});
|
|
150
|
49 assert(ResultVT.isExtended() && "Type is not extended!");
|
|
|
50 return ResultVT;
|
|
|
51 }
|
|
|
52
|
|
|
53 bool EVT::isExtendedFloatingPoint() const {
|
|
|
54 assert(isExtended() && "Type is not extended!");
|
|
|
55 return LLVMTy->isFPOrFPVectorTy();
|
|
|
56 }
|
|
|
57
|
|
|
58 bool EVT::isExtendedInteger() const {
|
|
|
59 assert(isExtended() && "Type is not extended!");
|
|
|
60 return LLVMTy->isIntOrIntVectorTy();
|
|
|
61 }
|
|
|
62
|
|
|
63 bool EVT::isExtendedScalarInteger() const {
|
|
|
64 assert(isExtended() && "Type is not extended!");
|
|
|
65 return LLVMTy->isIntegerTy();
|
|
|
66 }
|
|
|
67
|
|
|
68 bool EVT::isExtendedVector() const {
|
|
|
69 assert(isExtended() && "Type is not extended!");
|
|
|
70 return LLVMTy->isVectorTy();
|
|
|
71 }
|
|
|
72
|
|
|
73 bool EVT::isExtended16BitVector() const {
|
|
|
74 return isExtendedVector() && getExtendedSizeInBits() == 16;
|
|
|
75 }
|
|
|
76
|
|
|
77 bool EVT::isExtended32BitVector() const {
|
|
|
78 return isExtendedVector() && getExtendedSizeInBits() == 32;
|
|
|
79 }
|
|
|
80
|
|
|
81 bool EVT::isExtended64BitVector() const {
|
|
|
82 return isExtendedVector() && getExtendedSizeInBits() == 64;
|
|
|
83 }
|
|
|
84
|
|
|
85 bool EVT::isExtended128BitVector() const {
|
|
|
86 return isExtendedVector() && getExtendedSizeInBits() == 128;
|
|
|
87 }
|
|
|
88
|
|
|
89 bool EVT::isExtended256BitVector() const {
|
|
|
90 return isExtendedVector() && getExtendedSizeInBits() == 256;
|
|
|
91 }
|
|
|
92
|
|
|
93 bool EVT::isExtended512BitVector() const {
|
|
|
94 return isExtendedVector() && getExtendedSizeInBits() == 512;
|
|
|
95 }
|
|
|
96
|
|
|
97 bool EVT::isExtended1024BitVector() const {
|
|
|
98 return isExtendedVector() && getExtendedSizeInBits() == 1024;
|
|
|
99 }
|
|
|
100
|
|
|
101 bool EVT::isExtended2048BitVector() const {
|
|
|
102 return isExtendedVector() && getExtendedSizeInBits() == 2048;
|
|
|
103 }
|
|
|
104
|
|
173
|
105 bool EVT::isExtendedFixedLengthVector() const {
|
|
|
106 return isExtendedVector() && isa<FixedVectorType>(LLVMTy);
|
|
|
107 }
|
|
|
108
|
|
|
109 bool EVT::isExtendedScalableVector() const {
|
|
|
110 return isExtendedVector() && isa<ScalableVectorType>(LLVMTy);
|
|
|
111 }
|
|
|
112
|
|
150
|
113 EVT EVT::getExtendedVectorElementType() const {
|
|
|
114 assert(isExtended() && "Type is not extended!");
|
|
|
115 return EVT::getEVT(cast<VectorType>(LLVMTy)->getElementType());
|
|
|
116 }
|
|
|
117
|
|
|
118 unsigned EVT::getExtendedVectorNumElements() const {
|
|
|
119 assert(isExtended() && "Type is not extended!");
|
|
|
120 return cast<VectorType>(LLVMTy)->getNumElements();
|
|
|
121 }
|
|
|
122
|
|
173
|
123 ElementCount EVT::getExtendedVectorElementCount() const {
|
|
|
124 assert(isExtended() && "Type is not extended!");
|
|
|
125 return cast<VectorType>(LLVMTy)->getElementCount();
|
|
|
126 }
|
|
|
127
|
|
150
|
128 TypeSize EVT::getExtendedSizeInBits() const {
|
|
|
129 assert(isExtended() && "Type is not extended!");
|
|
|
130 if (IntegerType *ITy = dyn_cast<IntegerType>(LLVMTy))
|
|
|
131 return TypeSize::Fixed(ITy->getBitWidth());
|
|
|
132 if (VectorType *VTy = dyn_cast<VectorType>(LLVMTy))
|
|
|
133 return VTy->getPrimitiveSizeInBits();
|
|
|
134 llvm_unreachable("Unrecognized extended type!");
|
|
|
135 }
|
|
|
136
|
|
|
137 /// getEVTString - This function returns value type as a string, e.g. "i32".
|
|
|
138 std::string EVT::getEVTString() const {
|
|
|
139 switch (V.SimpleTy) {
|
|
|
140 default:
|
|
|
141 if (isVector())
|
|
173
|
142 return (isScalableVector() ? "nxv" : "v")
|
|
|
143 + utostr(getVectorElementCount().Min)
|
|
150
|
144 + getVectorElementType().getEVTString();
|
|
|
145 if (isInteger())
|
|
|
146 return "i" + utostr(getSizeInBits());
|
|
|
147 if (isFloatingPoint())
|
|
|
148 return "f" + utostr(getSizeInBits());
|
|
|
149 llvm_unreachable("Invalid EVT!");
|
|
|
150 case MVT::ppcf128: return "ppcf128";
|
|
|
151 case MVT::isVoid: return "isVoid";
|
|
|
152 case MVT::Other: return "ch";
|
|
|
153 case MVT::Glue: return "glue";
|
|
|
154 case MVT::x86mmx: return "x86mmx";
|
|
|
155 case MVT::Metadata:return "Metadata";
|
|
|
156 case MVT::Untyped: return "Untyped";
|
|
|
157 case MVT::exnref : return "exnref";
|
|
|
158 }
|
|
|
159 }
|
|
|
160
|
|
|
161 /// getTypeForEVT - This method returns an LLVM type corresponding to the
|
|
|
162 /// specified EVT. For integer types, this returns an unsigned type. Note
|
|
|
163 /// that this will abort for types that cannot be represented.
|
|
|
164 Type *EVT::getTypeForEVT(LLVMContext &Context) const {
|
|
|
165 switch (V.SimpleTy) {
|
|
|
166 default:
|
|
|
167 assert(isExtended() && "Type is not extended!");
|
|
|
168 return LLVMTy;
|
|
|
169 case MVT::isVoid: return Type::getVoidTy(Context);
|
|
|
170 case MVT::i1: return Type::getInt1Ty(Context);
|
|
|
171 case MVT::i8: return Type::getInt8Ty(Context);
|
|
|
172 case MVT::i16: return Type::getInt16Ty(Context);
|
|
|
173 case MVT::i32: return Type::getInt32Ty(Context);
|
|
|
174 case MVT::i64: return Type::getInt64Ty(Context);
|
|
|
175 case MVT::i128: return IntegerType::get(Context, 128);
|
|
|
176 case MVT::f16: return Type::getHalfTy(Context);
|
|
|
177 case MVT::f32: return Type::getFloatTy(Context);
|
|
|
178 case MVT::f64: return Type::getDoubleTy(Context);
|
|
|
179 case MVT::f80: return Type::getX86_FP80Ty(Context);
|
|
|
180 case MVT::f128: return Type::getFP128Ty(Context);
|
|
|
181 case MVT::ppcf128: return Type::getPPC_FP128Ty(Context);
|
|
|
182 case MVT::x86mmx: return Type::getX86_MMXTy(Context);
|
|
|
183 case MVT::v1i1: return VectorType::get(Type::getInt1Ty(Context), 1);
|
|
|
184 case MVT::v2i1: return VectorType::get(Type::getInt1Ty(Context), 2);
|
|
|
185 case MVT::v4i1: return VectorType::get(Type::getInt1Ty(Context), 4);
|
|
|
186 case MVT::v8i1: return VectorType::get(Type::getInt1Ty(Context), 8);
|
|
|
187 case MVT::v16i1: return VectorType::get(Type::getInt1Ty(Context), 16);
|
|
|
188 case MVT::v32i1: return VectorType::get(Type::getInt1Ty(Context), 32);
|
|
|
189 case MVT::v64i1: return VectorType::get(Type::getInt1Ty(Context), 64);
|
|
|
190 case MVT::v128i1: return VectorType::get(Type::getInt1Ty(Context), 128);
|
|
|
191 case MVT::v256i1: return VectorType::get(Type::getInt1Ty(Context), 256);
|
|
|
192 case MVT::v512i1: return VectorType::get(Type::getInt1Ty(Context), 512);
|
|
|
193 case MVT::v1024i1: return VectorType::get(Type::getInt1Ty(Context), 1024);
|
|
|
194 case MVT::v1i8: return VectorType::get(Type::getInt8Ty(Context), 1);
|
|
|
195 case MVT::v2i8: return VectorType::get(Type::getInt8Ty(Context), 2);
|
|
|
196 case MVT::v4i8: return VectorType::get(Type::getInt8Ty(Context), 4);
|
|
|
197 case MVT::v8i8: return VectorType::get(Type::getInt8Ty(Context), 8);
|
|
|
198 case MVT::v16i8: return VectorType::get(Type::getInt8Ty(Context), 16);
|
|
|
199 case MVT::v32i8: return VectorType::get(Type::getInt8Ty(Context), 32);
|
|
|
200 case MVT::v64i8: return VectorType::get(Type::getInt8Ty(Context), 64);
|
|
|
201 case MVT::v128i8: return VectorType::get(Type::getInt8Ty(Context), 128);
|
|
|
202 case MVT::v256i8: return VectorType::get(Type::getInt8Ty(Context), 256);
|
|
|
203 case MVT::v1i16: return VectorType::get(Type::getInt16Ty(Context), 1);
|
|
|
204 case MVT::v2i16: return VectorType::get(Type::getInt16Ty(Context), 2);
|
|
|
205 case MVT::v3i16: return VectorType::get(Type::getInt16Ty(Context), 3);
|
|
|
206 case MVT::v4i16: return VectorType::get(Type::getInt16Ty(Context), 4);
|
|
|
207 case MVT::v8i16: return VectorType::get(Type::getInt16Ty(Context), 8);
|
|
|
208 case MVT::v16i16: return VectorType::get(Type::getInt16Ty(Context), 16);
|
|
|
209 case MVT::v32i16: return VectorType::get(Type::getInt16Ty(Context), 32);
|
|
|
210 case MVT::v64i16: return VectorType::get(Type::getInt16Ty(Context), 64);
|
|
|
211 case MVT::v128i16: return VectorType::get(Type::getInt16Ty(Context), 128);
|
|
|
212 case MVT::v1i32: return VectorType::get(Type::getInt32Ty(Context), 1);
|
|
|
213 case MVT::v2i32: return VectorType::get(Type::getInt32Ty(Context), 2);
|
|
|
214 case MVT::v3i32: return VectorType::get(Type::getInt32Ty(Context), 3);
|
|
|
215 case MVT::v4i32: return VectorType::get(Type::getInt32Ty(Context), 4);
|
|
|
216 case MVT::v5i32: return VectorType::get(Type::getInt32Ty(Context), 5);
|
|
|
217 case MVT::v8i32: return VectorType::get(Type::getInt32Ty(Context), 8);
|
|
|
218 case MVT::v16i32: return VectorType::get(Type::getInt32Ty(Context), 16);
|
|
|
219 case MVT::v32i32: return VectorType::get(Type::getInt32Ty(Context), 32);
|
|
|
220 case MVT::v64i32: return VectorType::get(Type::getInt32Ty(Context), 64);
|
|
|
221 case MVT::v128i32: return VectorType::get(Type::getInt32Ty(Context), 128);
|
|
|
222 case MVT::v256i32: return VectorType::get(Type::getInt32Ty(Context), 256);
|
|
|
223 case MVT::v512i32: return VectorType::get(Type::getInt32Ty(Context), 512);
|
|
|
224 case MVT::v1024i32:return VectorType::get(Type::getInt32Ty(Context), 1024);
|
|
|
225 case MVT::v2048i32:return VectorType::get(Type::getInt32Ty(Context), 2048);
|
|
|
226 case MVT::v1i64: return VectorType::get(Type::getInt64Ty(Context), 1);
|
|
|
227 case MVT::v2i64: return VectorType::get(Type::getInt64Ty(Context), 2);
|
|
|
228 case MVT::v4i64: return VectorType::get(Type::getInt64Ty(Context), 4);
|
|
|
229 case MVT::v8i64: return VectorType::get(Type::getInt64Ty(Context), 8);
|
|
|
230 case MVT::v16i64: return VectorType::get(Type::getInt64Ty(Context), 16);
|
|
|
231 case MVT::v32i64: return VectorType::get(Type::getInt64Ty(Context), 32);
|
|
|
232 case MVT::v1i128: return VectorType::get(Type::getInt128Ty(Context), 1);
|
|
|
233 case MVT::v2f16: return VectorType::get(Type::getHalfTy(Context), 2);
|
|
|
234 case MVT::v3f16: return VectorType::get(Type::getHalfTy(Context), 3);
|
|
|
235 case MVT::v4f16: return VectorType::get(Type::getHalfTy(Context), 4);
|
|
|
236 case MVT::v8f16: return VectorType::get(Type::getHalfTy(Context), 8);
|
|
|
237 case MVT::v16f16: return VectorType::get(Type::getHalfTy(Context), 16);
|
|
|
238 case MVT::v32f16: return VectorType::get(Type::getHalfTy(Context), 32);
|
|
|
239 case MVT::v1f32: return VectorType::get(Type::getFloatTy(Context), 1);
|
|
|
240 case MVT::v2f32: return VectorType::get(Type::getFloatTy(Context), 2);
|
|
|
241 case MVT::v3f32: return VectorType::get(Type::getFloatTy(Context), 3);
|
|
|
242 case MVT::v4f32: return VectorType::get(Type::getFloatTy(Context), 4);
|
|
|
243 case MVT::v5f32: return VectorType::get(Type::getFloatTy(Context), 5);
|
|
|
244 case MVT::v8f32: return VectorType::get(Type::getFloatTy(Context), 8);
|
|
|
245 case MVT::v16f32: return VectorType::get(Type::getFloatTy(Context), 16);
|
|
|
246 case MVT::v32f32: return VectorType::get(Type::getFloatTy(Context), 32);
|
|
|
247 case MVT::v64f32: return VectorType::get(Type::getFloatTy(Context), 64);
|
|
|
248 case MVT::v128f32: return VectorType::get(Type::getFloatTy(Context), 128);
|
|
|
249 case MVT::v256f32: return VectorType::get(Type::getFloatTy(Context), 256);
|
|
|
250 case MVT::v512f32: return VectorType::get(Type::getFloatTy(Context), 512);
|
|
|
251 case MVT::v1024f32:return VectorType::get(Type::getFloatTy(Context), 1024);
|
|
|
252 case MVT::v2048f32:return VectorType::get(Type::getFloatTy(Context), 2048);
|
|
|
253 case MVT::v1f64: return VectorType::get(Type::getDoubleTy(Context), 1);
|
|
|
254 case MVT::v2f64: return VectorType::get(Type::getDoubleTy(Context), 2);
|
|
|
255 case MVT::v4f64: return VectorType::get(Type::getDoubleTy(Context), 4);
|
|
|
256 case MVT::v8f64: return VectorType::get(Type::getDoubleTy(Context), 8);
|
|
173
|
257 case MVT::v16f64: return VectorType::get(Type::getDoubleTy(Context), 16);
|
|
|
258 case MVT::nxv1i1:
|
|
150
|
259 return VectorType::get(Type::getInt1Ty(Context), 1, /*Scalable=*/ true);
|
|
173
|
260 case MVT::nxv2i1:
|
|
150
|
261 return VectorType::get(Type::getInt1Ty(Context), 2, /*Scalable=*/ true);
|
|
173
|
262 case MVT::nxv4i1:
|
|
150
|
263 return VectorType::get(Type::getInt1Ty(Context), 4, /*Scalable=*/ true);
|
|
173
|
264 case MVT::nxv8i1:
|
|
150
|
265 return VectorType::get(Type::getInt1Ty(Context), 8, /*Scalable=*/ true);
|
|
173
|
266 case MVT::nxv16i1:
|
|
150
|
267 return VectorType::get(Type::getInt1Ty(Context), 16, /*Scalable=*/ true);
|
|
173
|
268 case MVT::nxv32i1:
|
|
150
|
269 return VectorType::get(Type::getInt1Ty(Context), 32, /*Scalable=*/ true);
|
|
173
|
270 case MVT::nxv1i8:
|
|
150
|
271 return VectorType::get(Type::getInt8Ty(Context), 1, /*Scalable=*/ true);
|
|
173
|
272 case MVT::nxv2i8:
|
|
150
|
273 return VectorType::get(Type::getInt8Ty(Context), 2, /*Scalable=*/ true);
|
|
173
|
274 case MVT::nxv4i8:
|
|
150
|
275 return VectorType::get(Type::getInt8Ty(Context), 4, /*Scalable=*/ true);
|
|
173
|
276 case MVT::nxv8i8:
|
|
150
|
277 return VectorType::get(Type::getInt8Ty(Context), 8, /*Scalable=*/ true);
|
|
173
|
278 case MVT::nxv16i8:
|
|
150
|
279 return VectorType::get(Type::getInt8Ty(Context), 16, /*Scalable=*/ true);
|
|
173
|
280 case MVT::nxv32i8:
|
|
150
|
281 return VectorType::get(Type::getInt8Ty(Context), 32, /*Scalable=*/ true);
|
|
173
|
282 case MVT::nxv1i16:
|
|
150
|
283 return VectorType::get(Type::getInt16Ty(Context), 1, /*Scalable=*/ true);
|
|
173
|
284 case MVT::nxv2i16:
|
|
150
|
285 return VectorType::get(Type::getInt16Ty(Context), 2, /*Scalable=*/ true);
|
|
173
|
286 case MVT::nxv4i16:
|
|
150
|
287 return VectorType::get(Type::getInt16Ty(Context), 4, /*Scalable=*/ true);
|
|
173
|
288 case MVT::nxv8i16:
|
|
150
|
289 return VectorType::get(Type::getInt16Ty(Context), 8, /*Scalable=*/ true);
|
|
|
290 case MVT::nxv16i16:
|
|
|
291 return VectorType::get(Type::getInt16Ty(Context), 16, /*Scalable=*/ true);
|
|
|
292 case MVT::nxv32i16:
|
|
|
293 return VectorType::get(Type::getInt16Ty(Context), 32, /*Scalable=*/ true);
|
|
173
|
294 case MVT::nxv1i32:
|
|
150
|
295 return VectorType::get(Type::getInt32Ty(Context), 1, /*Scalable=*/ true);
|
|
173
|
296 case MVT::nxv2i32:
|
|
150
|
297 return VectorType::get(Type::getInt32Ty(Context), 2, /*Scalable=*/ true);
|
|
173
|
298 case MVT::nxv4i32:
|
|
150
|
299 return VectorType::get(Type::getInt32Ty(Context), 4, /*Scalable=*/ true);
|
|
173
|
300 case MVT::nxv8i32:
|
|
150
|
301 return VectorType::get(Type::getInt32Ty(Context), 8, /*Scalable=*/ true);
|
|
|
302 case MVT::nxv16i32:
|
|
|
303 return VectorType::get(Type::getInt32Ty(Context), 16,/*Scalable=*/ true);
|
|
|
304 case MVT::nxv32i32:
|
|
|
305 return VectorType::get(Type::getInt32Ty(Context), 32,/*Scalable=*/ true);
|
|
173
|
306 case MVT::nxv1i64:
|
|
150
|
307 return VectorType::get(Type::getInt64Ty(Context), 1, /*Scalable=*/ true);
|
|
173
|
308 case MVT::nxv2i64:
|
|
150
|
309 return VectorType::get(Type::getInt64Ty(Context), 2, /*Scalable=*/ true);
|
|
173
|
310 case MVT::nxv4i64:
|
|
150
|
311 return VectorType::get(Type::getInt64Ty(Context), 4, /*Scalable=*/ true);
|
|
173
|
312 case MVT::nxv8i64:
|
|
150
|
313 return VectorType::get(Type::getInt64Ty(Context), 8, /*Scalable=*/ true);
|
|
|
314 case MVT::nxv16i64:
|
|
|
315 return VectorType::get(Type::getInt64Ty(Context), 16, /*Scalable=*/ true);
|
|
|
316 case MVT::nxv32i64:
|
|
|
317 return VectorType::get(Type::getInt64Ty(Context), 32, /*Scalable=*/ true);
|
|
173
|
318 case MVT::nxv2f16:
|
|
150
|
319 return VectorType::get(Type::getHalfTy(Context), 2, /*Scalable=*/ true);
|
|
173
|
320 case MVT::nxv4f16:
|
|
150
|
321 return VectorType::get(Type::getHalfTy(Context), 4, /*Scalable=*/ true);
|
|
173
|
322 case MVT::nxv8f16:
|
|
150
|
323 return VectorType::get(Type::getHalfTy(Context), 8, /*Scalable=*/ true);
|
|
173
|
324 case MVT::nxv1f32:
|
|
150
|
325 return VectorType::get(Type::getFloatTy(Context), 1, /*Scalable=*/ true);
|
|
173
|
326 case MVT::nxv2f32:
|
|
150
|
327 return VectorType::get(Type::getFloatTy(Context), 2, /*Scalable=*/ true);
|
|
173
|
328 case MVT::nxv4f32:
|
|
150
|
329 return VectorType::get(Type::getFloatTy(Context), 4, /*Scalable=*/ true);
|
|
173
|
330 case MVT::nxv8f32:
|
|
150
|
331 return VectorType::get(Type::getFloatTy(Context), 8, /*Scalable=*/ true);
|
|
|
332 case MVT::nxv16f32:
|
|
|
333 return VectorType::get(Type::getFloatTy(Context), 16, /*Scalable=*/ true);
|
|
173
|
334 case MVT::nxv1f64:
|
|
150
|
335 return VectorType::get(Type::getDoubleTy(Context), 1, /*Scalable=*/ true);
|
|
173
|
336 case MVT::nxv2f64:
|
|
150
|
337 return VectorType::get(Type::getDoubleTy(Context), 2, /*Scalable=*/ true);
|
|
173
|
338 case MVT::nxv4f64:
|
|
150
|
339 return VectorType::get(Type::getDoubleTy(Context), 4, /*Scalable=*/ true);
|
|
173
|
340 case MVT::nxv8f64:
|
|
150
|
341 return VectorType::get(Type::getDoubleTy(Context), 8, /*Scalable=*/ true);
|
|
|
342 case MVT::Metadata: return Type::getMetadataTy(Context);
|
|
|
343 }
|
|
|
344 }
|
|
|
345
|
|
|
346 /// Return the value type corresponding to the specified type. This returns all
|
|
|
347 /// pointers as MVT::iPTR. If HandleUnknown is true, unknown types are returned
|
|
|
348 /// as Other, otherwise they are invalid.
|
|
|
349 MVT MVT::getVT(Type *Ty, bool HandleUnknown){
|
|
|
350 switch (Ty->getTypeID()) {
|
|
|
351 default:
|
|
|
352 if (HandleUnknown) return MVT(MVT::Other);
|
|
|
353 llvm_unreachable("Unknown type!");
|
|
|
354 case Type::VoidTyID:
|
|
152
|
355 #ifndef noCbC
|
|
|
356 case Type::__CodeTyID:
|
|
|
357 #endif
|
|
150
|
358 return MVT::isVoid;
|
|
|
359 case Type::IntegerTyID:
|
|
|
360 return getIntegerVT(cast<IntegerType>(Ty)->getBitWidth());
|
|
|
361 case Type::HalfTyID: return MVT(MVT::f16);
|
|
|
362 case Type::FloatTyID: return MVT(MVT::f32);
|
|
|
363 case Type::DoubleTyID: return MVT(MVT::f64);
|
|
|
364 case Type::X86_FP80TyID: return MVT(MVT::f80);
|
|
|
365 case Type::X86_MMXTyID: return MVT(MVT::x86mmx);
|
|
|
366 case Type::FP128TyID: return MVT(MVT::f128);
|
|
|
367 case Type::PPC_FP128TyID: return MVT(MVT::ppcf128);
|
|
|
368 case Type::PointerTyID: return MVT(MVT::iPTR);
|
|
173
|
369 case Type::FixedVectorTyID:
|
|
|
370 case Type::ScalableVectorTyID: {
|
|
150
|
371 VectorType *VTy = cast<VectorType>(Ty);
|
|
|
372 return getVectorVT(
|
|
|
373 getVT(VTy->getElementType(), /*HandleUnknown=*/ false),
|
|
|
374 VTy->getElementCount());
|
|
|
375 }
|
|
|
376 }
|
|
|
377 }
|
|
|
378
|
|
|
379 /// getEVT - Return the value type corresponding to the specified type. This
|
|
|
380 /// returns all pointers as MVT::iPTR. If HandleUnknown is true, unknown types
|
|
|
381 /// are returned as Other, otherwise they are invalid.
|
|
|
382 EVT EVT::getEVT(Type *Ty, bool HandleUnknown){
|
|
|
383 switch (Ty->getTypeID()) {
|
|
|
384 default:
|
|
|
385 return MVT::getVT(Ty, HandleUnknown);
|
|
|
386 case Type::IntegerTyID:
|
|
|
387 return getIntegerVT(Ty->getContext(), cast<IntegerType>(Ty)->getBitWidth());
|
|
173
|
388 case Type::FixedVectorTyID:
|
|
|
389 case Type::ScalableVectorTyID: {
|
|
150
|
390 VectorType *VTy = cast<VectorType>(Ty);
|
|
|
391 return getVectorVT(Ty->getContext(),
|
|
|
392 getEVT(VTy->getElementType(), /*HandleUnknown=*/ false),
|
|
|
393 VTy->getElementCount());
|
|
|
394 }
|
|
|
395 }
|
|
|
396 }
|
