Bug Summary

File:llvm/lib/Target/AVR/AVRISelLowering.cpp
Warning:line 1124, column 13
1st function call argument is an uninitialized value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name AVRISelLowering.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/build-llvm -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I lib/Target/AVR -I /build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR -I include -I /build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-command-line-argument -Wno-unknown-warning-option -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/build-llvm -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-10-17-004846-21170-1 -x c++ /build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp

/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp

1//===-- AVRISelLowering.cpp - AVR DAG Lowering Implementation -------------===//
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// This file defines the interfaces that AVR uses to lower LLVM code into a
10// selection DAG.
11//
12//===----------------------------------------------------------------------===//
13
14#include "AVRISelLowering.h"
15
16#include "llvm/ADT/STLExtras.h"
17#include "llvm/ADT/StringSwitch.h"
18#include "llvm/CodeGen/CallingConvLower.h"
19#include "llvm/CodeGen/MachineFrameInfo.h"
20#include "llvm/CodeGen/MachineInstrBuilder.h"
21#include "llvm/CodeGen/MachineRegisterInfo.h"
22#include "llvm/CodeGen/SelectionDAG.h"
23#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
24#include "llvm/IR/Function.h"
25#include "llvm/Support/ErrorHandling.h"
26
27#include "AVR.h"
28#include "AVRMachineFunctionInfo.h"
29#include "AVRSubtarget.h"
30#include "AVRTargetMachine.h"
31#include "MCTargetDesc/AVRMCTargetDesc.h"
32
33namespace llvm {
34
35AVRTargetLowering::AVRTargetLowering(const AVRTargetMachine &TM,
36 const AVRSubtarget &STI)
37 : TargetLowering(TM), Subtarget(STI) {
38 // Set up the register classes.
39 addRegisterClass(MVT::i8, &AVR::GPR8RegClass);
40 addRegisterClass(MVT::i16, &AVR::DREGSRegClass);
41
42 // Compute derived properties from the register classes.
43 computeRegisterProperties(Subtarget.getRegisterInfo());
44
45 setBooleanContents(ZeroOrOneBooleanContent);
46 setBooleanVectorContents(ZeroOrOneBooleanContent);
47 setSchedulingPreference(Sched::RegPressure);
48 setStackPointerRegisterToSaveRestore(AVR::SP);
49 setSupportsUnalignedAtomics(true);
50
51 setOperationAction(ISD::GlobalAddress, MVT::i16, Custom);
52 setOperationAction(ISD::BlockAddress, MVT::i16, Custom);
53
54 setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
55 setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
56 setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i8, Expand);
57 setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i16, Expand);
58
59 for (MVT VT : MVT::integer_valuetypes()) {
60 for (auto N : {ISD::EXTLOAD, ISD::SEXTLOAD, ISD::ZEXTLOAD}) {
61 setLoadExtAction(N, VT, MVT::i1, Promote);
62 setLoadExtAction(N, VT, MVT::i8, Expand);
63 }
64 }
65
66 setTruncStoreAction(MVT::i16, MVT::i8, Expand);
67
68 for (MVT VT : MVT::integer_valuetypes()) {
69 setOperationAction(ISD::ADDC, VT, Legal);
70 setOperationAction(ISD::SUBC, VT, Legal);
71 setOperationAction(ISD::ADDE, VT, Legal);
72 setOperationAction(ISD::SUBE, VT, Legal);
73 }
74
75 // sub (x, imm) gets canonicalized to add (x, -imm), so for illegal types
76 // revert into a sub since we don't have an add with immediate instruction.
77 setOperationAction(ISD::ADD, MVT::i32, Custom);
78 setOperationAction(ISD::ADD, MVT::i64, Custom);
79
80 // our shift instructions are only able to shift 1 bit at a time, so handle
81 // this in a custom way.
82 setOperationAction(ISD::SRA, MVT::i8, Custom);
83 setOperationAction(ISD::SHL, MVT::i8, Custom);
84 setOperationAction(ISD::SRL, MVT::i8, Custom);
85 setOperationAction(ISD::SRA, MVT::i16, Custom);
86 setOperationAction(ISD::SHL, MVT::i16, Custom);
87 setOperationAction(ISD::SRL, MVT::i16, Custom);
88 setOperationAction(ISD::SHL_PARTS, MVT::i16, Expand);
89 setOperationAction(ISD::SRA_PARTS, MVT::i16, Expand);
90 setOperationAction(ISD::SRL_PARTS, MVT::i16, Expand);
91
92 setOperationAction(ISD::ROTL, MVT::i8, Custom);
93 setOperationAction(ISD::ROTL, MVT::i16, Expand);
94 setOperationAction(ISD::ROTR, MVT::i8, Custom);
95 setOperationAction(ISD::ROTR, MVT::i16, Expand);
96
97 setOperationAction(ISD::BR_CC, MVT::i8, Custom);
98 setOperationAction(ISD::BR_CC, MVT::i16, Custom);
99 setOperationAction(ISD::BR_CC, MVT::i32, Custom);
100 setOperationAction(ISD::BR_CC, MVT::i64, Custom);
101 setOperationAction(ISD::BRCOND, MVT::Other, Expand);
102
103 setOperationAction(ISD::SELECT_CC, MVT::i8, Custom);
104 setOperationAction(ISD::SELECT_CC, MVT::i16, Custom);
105 setOperationAction(ISD::SELECT_CC, MVT::i32, Expand);
106 setOperationAction(ISD::SELECT_CC, MVT::i64, Expand);
107 setOperationAction(ISD::SETCC, MVT::i8, Custom);
108 setOperationAction(ISD::SETCC, MVT::i16, Custom);
109 setOperationAction(ISD::SETCC, MVT::i32, Custom);
110 setOperationAction(ISD::SETCC, MVT::i64, Custom);
111 setOperationAction(ISD::SELECT, MVT::i8, Expand);
112 setOperationAction(ISD::SELECT, MVT::i16, Expand);
113
114 setOperationAction(ISD::BSWAP, MVT::i16, Expand);
115
116 // Add support for postincrement and predecrement load/stores.
117 setIndexedLoadAction(ISD::POST_INC, MVT::i8, Legal);
118 setIndexedLoadAction(ISD::POST_INC, MVT::i16, Legal);
119 setIndexedLoadAction(ISD::PRE_DEC, MVT::i8, Legal);
120 setIndexedLoadAction(ISD::PRE_DEC, MVT::i16, Legal);
121 setIndexedStoreAction(ISD::POST_INC, MVT::i8, Legal);
122 setIndexedStoreAction(ISD::POST_INC, MVT::i16, Legal);
123 setIndexedStoreAction(ISD::PRE_DEC, MVT::i8, Legal);
124 setIndexedStoreAction(ISD::PRE_DEC, MVT::i16, Legal);
125
126 setOperationAction(ISD::BR_JT, MVT::Other, Expand);
127
128 setOperationAction(ISD::VASTART, MVT::Other, Custom);
129 setOperationAction(ISD::VAEND, MVT::Other, Expand);
130 setOperationAction(ISD::VAARG, MVT::Other, Expand);
131 setOperationAction(ISD::VACOPY, MVT::Other, Expand);
132
133 // Atomic operations which must be lowered to rtlib calls
134 for (MVT VT : MVT::integer_valuetypes()) {
135 setOperationAction(ISD::ATOMIC_SWAP, VT, Expand);
136 setOperationAction(ISD::ATOMIC_CMP_SWAP, VT, Expand);
137 setOperationAction(ISD::ATOMIC_LOAD_NAND, VT, Expand);
138 setOperationAction(ISD::ATOMIC_LOAD_MAX, VT, Expand);
139 setOperationAction(ISD::ATOMIC_LOAD_MIN, VT, Expand);
140 setOperationAction(ISD::ATOMIC_LOAD_UMAX, VT, Expand);
141 setOperationAction(ISD::ATOMIC_LOAD_UMIN, VT, Expand);
142 }
143
144 // Division/remainder
145 setOperationAction(ISD::UDIV, MVT::i8, Expand);
146 setOperationAction(ISD::UDIV, MVT::i16, Expand);
147 setOperationAction(ISD::UREM, MVT::i8, Expand);
148 setOperationAction(ISD::UREM, MVT::i16, Expand);
149 setOperationAction(ISD::SDIV, MVT::i8, Expand);
150 setOperationAction(ISD::SDIV, MVT::i16, Expand);
151 setOperationAction(ISD::SREM, MVT::i8, Expand);
152 setOperationAction(ISD::SREM, MVT::i16, Expand);
153
154 // Make division and modulus custom
155 setOperationAction(ISD::UDIVREM, MVT::i8, Custom);
156 setOperationAction(ISD::UDIVREM, MVT::i16, Custom);
157 setOperationAction(ISD::UDIVREM, MVT::i32, Custom);
158 setOperationAction(ISD::SDIVREM, MVT::i8, Custom);
159 setOperationAction(ISD::SDIVREM, MVT::i16, Custom);
160 setOperationAction(ISD::SDIVREM, MVT::i32, Custom);
161
162 // Do not use MUL. The AVR instructions are closer to SMUL_LOHI &co.
163 setOperationAction(ISD::MUL, MVT::i8, Expand);
164 setOperationAction(ISD::MUL, MVT::i16, Expand);
165
166 // Expand 16 bit multiplications.
167 setOperationAction(ISD::SMUL_LOHI, MVT::i16, Expand);
168 setOperationAction(ISD::UMUL_LOHI, MVT::i16, Expand);
169
170 // Expand multiplications to libcalls when there is
171 // no hardware MUL.
172 if (!Subtarget.supportsMultiplication()) {
173 setOperationAction(ISD::SMUL_LOHI, MVT::i8, Expand);
174 setOperationAction(ISD::UMUL_LOHI, MVT::i8, Expand);
175 }
176
177 for (MVT VT : MVT::integer_valuetypes()) {
178 setOperationAction(ISD::MULHS, VT, Expand);
179 setOperationAction(ISD::MULHU, VT, Expand);
180 }
181
182 for (MVT VT : MVT::integer_valuetypes()) {
183 setOperationAction(ISD::CTPOP, VT, Expand);
184 setOperationAction(ISD::CTLZ, VT, Expand);
185 setOperationAction(ISD::CTTZ, VT, Expand);
186 }
187
188 for (MVT VT : MVT::integer_valuetypes()) {
189 setOperationAction(ISD::SIGN_EXTEND_INREG, VT, Expand);
190 // TODO: The generated code is pretty poor. Investigate using the
191 // same "shift and subtract with carry" trick that we do for
192 // extending 8-bit to 16-bit. This may require infrastructure
193 // improvements in how we treat 16-bit "registers" to be feasible.
194 }
195
196 // Division rtlib functions (not supported), use divmod functions instead
197 setLibcallName(RTLIB::SDIV_I8, nullptr);
198 setLibcallName(RTLIB::SDIV_I16, nullptr);
199 setLibcallName(RTLIB::SDIV_I32, nullptr);
200 setLibcallName(RTLIB::UDIV_I8, nullptr);
201 setLibcallName(RTLIB::UDIV_I16, nullptr);
202 setLibcallName(RTLIB::UDIV_I32, nullptr);
203
204 // Modulus rtlib functions (not supported), use divmod functions instead
205 setLibcallName(RTLIB::SREM_I8, nullptr);
206 setLibcallName(RTLIB::SREM_I16, nullptr);
207 setLibcallName(RTLIB::SREM_I32, nullptr);
208 setLibcallName(RTLIB::UREM_I8, nullptr);
209 setLibcallName(RTLIB::UREM_I16, nullptr);
210 setLibcallName(RTLIB::UREM_I32, nullptr);
211
212 // Division and modulus rtlib functions
213 setLibcallName(RTLIB::SDIVREM_I8, "__divmodqi4");
214 setLibcallName(RTLIB::SDIVREM_I16, "__divmodhi4");
215 setLibcallName(RTLIB::SDIVREM_I32, "__divmodsi4");
216 setLibcallName(RTLIB::UDIVREM_I8, "__udivmodqi4");
217 setLibcallName(RTLIB::UDIVREM_I16, "__udivmodhi4");
218 setLibcallName(RTLIB::UDIVREM_I32, "__udivmodsi4");
219
220 // Several of the runtime library functions use a special calling conv
221 setLibcallCallingConv(RTLIB::SDIVREM_I8, CallingConv::AVR_BUILTIN);
222 setLibcallCallingConv(RTLIB::SDIVREM_I16, CallingConv::AVR_BUILTIN);
223 setLibcallCallingConv(RTLIB::UDIVREM_I8, CallingConv::AVR_BUILTIN);
224 setLibcallCallingConv(RTLIB::UDIVREM_I16, CallingConv::AVR_BUILTIN);
225
226 // Trigonometric rtlib functions
227 setLibcallName(RTLIB::SIN_F32, "sin");
228 setLibcallName(RTLIB::COS_F32, "cos");
229
230 setMinFunctionAlignment(Align(2));
231 setMinimumJumpTableEntries(UINT_MAX(2147483647 *2U +1U));
232}
233
234const char *AVRTargetLowering::getTargetNodeName(unsigned Opcode) const {
235#define NODE(name) \
236 case AVRISD::name: \
237 return #name
238
239 switch (Opcode) {
240 default:
241 return nullptr;
242 NODE(RET_FLAG);
243 NODE(RETI_FLAG);
244 NODE(CALL);
245 NODE(WRAPPER);
246 NODE(LSL);
247 NODE(LSR);
248 NODE(ROL);
249 NODE(ROR);
250 NODE(ASR);
251 NODE(LSLLOOP);
252 NODE(LSRLOOP);
253 NODE(ROLLOOP);
254 NODE(RORLOOP);
255 NODE(ASRLOOP);
256 NODE(BRCOND);
257 NODE(CMP);
258 NODE(CMPC);
259 NODE(TST);
260 NODE(SELECT_CC);
261#undef NODE
262 }
263}
264
265EVT AVRTargetLowering::getSetCCResultType(const DataLayout &DL, LLVMContext &,
266 EVT VT) const {
267 assert(!VT.isVector() && "No AVR SetCC type for vectors!")(static_cast <bool> (!VT.isVector() && "No AVR SetCC type for vectors!"
) ? void (0) : __assert_fail ("!VT.isVector() && \"No AVR SetCC type for vectors!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 267, __extension__ __PRETTY_FUNCTION__))
;
268 return MVT::i8;
269}
270
271SDValue AVRTargetLowering::LowerShifts(SDValue Op, SelectionDAG &DAG) const {
272 //: TODO: this function has to be completely rewritten to produce optimal
273 // code, for now it's producing very long but correct code.
274 unsigned Opc8;
275 const SDNode *N = Op.getNode();
276 EVT VT = Op.getValueType();
277 SDLoc dl(N);
278 assert(isPowerOf2_32(VT.getSizeInBits()) &&(static_cast <bool> (isPowerOf2_32(VT.getSizeInBits()) &&
"Expected power-of-2 shift amount") ? void (0) : __assert_fail
("isPowerOf2_32(VT.getSizeInBits()) && \"Expected power-of-2 shift amount\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 279, __extension__ __PRETTY_FUNCTION__))
279 "Expected power-of-2 shift amount")(static_cast <bool> (isPowerOf2_32(VT.getSizeInBits()) &&
"Expected power-of-2 shift amount") ? void (0) : __assert_fail
("isPowerOf2_32(VT.getSizeInBits()) && \"Expected power-of-2 shift amount\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 279, __extension__ __PRETTY_FUNCTION__))
;
280
281 // Expand non-constant shifts to loops.
282 if (!isa<ConstantSDNode>(N->getOperand(1))) {
283 switch (Op.getOpcode()) {
284 default:
285 llvm_unreachable("Invalid shift opcode!")::llvm::llvm_unreachable_internal("Invalid shift opcode!", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 285)
;
286 case ISD::SHL:
287 return DAG.getNode(AVRISD::LSLLOOP, dl, VT, N->getOperand(0),
288 N->getOperand(1));
289 case ISD::SRL:
290 return DAG.getNode(AVRISD::LSRLOOP, dl, VT, N->getOperand(0),
291 N->getOperand(1));
292 case ISD::ROTL: {
293 SDValue Amt = N->getOperand(1);
294 EVT AmtVT = Amt.getValueType();
295 Amt = DAG.getNode(ISD::AND, dl, AmtVT, Amt,
296 DAG.getConstant(VT.getSizeInBits() - 1, dl, AmtVT));
297 return DAG.getNode(AVRISD::ROLLOOP, dl, VT, N->getOperand(0), Amt);
298 }
299 case ISD::ROTR: {
300 SDValue Amt = N->getOperand(1);
301 EVT AmtVT = Amt.getValueType();
302 Amt = DAG.getNode(ISD::AND, dl, AmtVT, Amt,
303 DAG.getConstant(VT.getSizeInBits() - 1, dl, AmtVT));
304 return DAG.getNode(AVRISD::RORLOOP, dl, VT, N->getOperand(0), Amt);
305 }
306 case ISD::SRA:
307 return DAG.getNode(AVRISD::ASRLOOP, dl, VT, N->getOperand(0),
308 N->getOperand(1));
309 }
310 }
311
312 uint64_t ShiftAmount = cast<ConstantSDNode>(N->getOperand(1))->getZExtValue();
313 SDValue Victim = N->getOperand(0);
314
315 switch (Op.getOpcode()) {
316 case ISD::SRA:
317 Opc8 = AVRISD::ASR;
318 break;
319 case ISD::ROTL:
320 Opc8 = AVRISD::ROL;
321 ShiftAmount = ShiftAmount % VT.getSizeInBits();
322 break;
323 case ISD::ROTR:
324 Opc8 = AVRISD::ROR;
325 ShiftAmount = ShiftAmount % VT.getSizeInBits();
326 break;
327 case ISD::SRL:
328 Opc8 = AVRISD::LSR;
329 break;
330 case ISD::SHL:
331 Opc8 = AVRISD::LSL;
332 break;
333 default:
334 llvm_unreachable("Invalid shift opcode")::llvm::llvm_unreachable_internal("Invalid shift opcode", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 334)
;
335 }
336
337 // Optimize int8/int16 shifts.
338 if (VT.getSizeInBits() == 8) {
339 if (Op.getOpcode() == ISD::SHL && 4 <= ShiftAmount && ShiftAmount < 7) {
340 // Optimize LSL when 4 <= ShiftAmount <= 6.
341 Victim = DAG.getNode(AVRISD::SWAP, dl, VT, Victim);
342 Victim =
343 DAG.getNode(ISD::AND, dl, VT, Victim, DAG.getConstant(0xf0, dl, VT));
344 ShiftAmount -= 4;
345 } else if (Op.getOpcode() == ISD::SRL && 4 <= ShiftAmount &&
346 ShiftAmount < 7) {
347 // Optimize LSR when 4 <= ShiftAmount <= 6.
348 Victim = DAG.getNode(AVRISD::SWAP, dl, VT, Victim);
349 Victim =
350 DAG.getNode(ISD::AND, dl, VT, Victim, DAG.getConstant(0x0f, dl, VT));
351 ShiftAmount -= 4;
352 } else if (Op.getOpcode() == ISD::SHL && ShiftAmount == 7) {
353 // Optimize LSL when ShiftAmount == 7.
354 Victim = DAG.getNode(AVRISD::LSLBN, dl, VT, Victim,
355 DAG.getConstant(7, dl, VT));
356 ShiftAmount = 0;
357 } else if (Op.getOpcode() == ISD::SRL && ShiftAmount == 7) {
358 // Optimize LSR when ShiftAmount == 7.
359 Victim = DAG.getNode(AVRISD::LSRBN, dl, VT, Victim,
360 DAG.getConstant(7, dl, VT));
361 ShiftAmount = 0;
362 } else if (Op.getOpcode() == ISD::SRA && ShiftAmount == 7) {
363 // Optimize ASR when ShiftAmount == 7.
364 Victim = DAG.getNode(AVRISD::ASRBN, dl, VT, Victim,
365 DAG.getConstant(7, dl, VT));
366 ShiftAmount = 0;
367 }
368 } else if (VT.getSizeInBits() == 16) {
369 if (4 <= ShiftAmount && ShiftAmount < 8)
370 switch (Op.getOpcode()) {
371 case ISD::SHL:
372 Victim = DAG.getNode(AVRISD::LSLWN, dl, VT, Victim,
373 DAG.getConstant(4, dl, VT));
374 ShiftAmount -= 4;
375 break;
376 case ISD::SRL:
377 Victim = DAG.getNode(AVRISD::LSRWN, dl, VT, Victim,
378 DAG.getConstant(4, dl, VT));
379 ShiftAmount -= 4;
380 break;
381 default:
382 break;
383 }
384 else if (8 <= ShiftAmount && ShiftAmount < 12)
385 switch (Op.getOpcode()) {
386 case ISD::SHL:
387 Victim = DAG.getNode(AVRISD::LSLWN, dl, VT, Victim,
388 DAG.getConstant(8, dl, VT));
389 ShiftAmount -= 8;
390 break;
391 case ISD::SRL:
392 Victim = DAG.getNode(AVRISD::LSRWN, dl, VT, Victim,
393 DAG.getConstant(8, dl, VT));
394 ShiftAmount -= 8;
395 break;
396 case ISD::SRA:
397 Victim = DAG.getNode(AVRISD::ASRWN, dl, VT, Victim,
398 DAG.getConstant(8, dl, VT));
399 ShiftAmount -= 8;
400 break;
401 default:
402 break;
403 }
404 else if (12 <= ShiftAmount)
405 switch (Op.getOpcode()) {
406 case ISD::SHL:
407 Victim = DAG.getNode(AVRISD::LSLWN, dl, VT, Victim,
408 DAG.getConstant(12, dl, VT));
409 ShiftAmount -= 12;
410 break;
411 case ISD::SRL:
412 Victim = DAG.getNode(AVRISD::LSRWN, dl, VT, Victim,
413 DAG.getConstant(12, dl, VT));
414 ShiftAmount -= 12;
415 break;
416 default:
417 break;
418 }
419 }
420
421 while (ShiftAmount--) {
422 Victim = DAG.getNode(Opc8, dl, VT, Victim);
423 }
424
425 return Victim;
426}
427
428SDValue AVRTargetLowering::LowerDivRem(SDValue Op, SelectionDAG &DAG) const {
429 unsigned Opcode = Op->getOpcode();
430 assert((Opcode == ISD::SDIVREM || Opcode == ISD::UDIVREM) &&(static_cast <bool> ((Opcode == ISD::SDIVREM || Opcode ==
ISD::UDIVREM) && "Invalid opcode for Div/Rem lowering"
) ? void (0) : __assert_fail ("(Opcode == ISD::SDIVREM || Opcode == ISD::UDIVREM) && \"Invalid opcode for Div/Rem lowering\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 431, __extension__ __PRETTY_FUNCTION__))
431 "Invalid opcode for Div/Rem lowering")(static_cast <bool> ((Opcode == ISD::SDIVREM || Opcode ==
ISD::UDIVREM) && "Invalid opcode for Div/Rem lowering"
) ? void (0) : __assert_fail ("(Opcode == ISD::SDIVREM || Opcode == ISD::UDIVREM) && \"Invalid opcode for Div/Rem lowering\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 431, __extension__ __PRETTY_FUNCTION__))
;
432 bool IsSigned = (Opcode == ISD::SDIVREM);
433 EVT VT = Op->getValueType(0);
434 Type *Ty = VT.getTypeForEVT(*DAG.getContext());
435
436 RTLIB::Libcall LC;
437 switch (VT.getSimpleVT().SimpleTy) {
438 default:
439 llvm_unreachable("Unexpected request for libcall!")::llvm::llvm_unreachable_internal("Unexpected request for libcall!"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 439)
;
440 case MVT::i8:
441 LC = IsSigned ? RTLIB::SDIVREM_I8 : RTLIB::UDIVREM_I8;
442 break;
443 case MVT::i16:
444 LC = IsSigned ? RTLIB::SDIVREM_I16 : RTLIB::UDIVREM_I16;
445 break;
446 case MVT::i32:
447 LC = IsSigned ? RTLIB::SDIVREM_I32 : RTLIB::UDIVREM_I32;
448 break;
449 }
450
451 SDValue InChain = DAG.getEntryNode();
452
453 TargetLowering::ArgListTy Args;
454 TargetLowering::ArgListEntry Entry;
455 for (SDValue const &Value : Op->op_values()) {
456 Entry.Node = Value;
457 Entry.Ty = Value.getValueType().getTypeForEVT(*DAG.getContext());
458 Entry.IsSExt = IsSigned;
459 Entry.IsZExt = !IsSigned;
460 Args.push_back(Entry);
461 }
462
463 SDValue Callee = DAG.getExternalSymbol(getLibcallName(LC),
464 getPointerTy(DAG.getDataLayout()));
465
466 Type *RetTy = (Type *)StructType::get(Ty, Ty);
467
468 SDLoc dl(Op);
469 TargetLowering::CallLoweringInfo CLI(DAG);
470 CLI.setDebugLoc(dl)
471 .setChain(InChain)
472 .setLibCallee(getLibcallCallingConv(LC), RetTy, Callee, std::move(Args))
473 .setInRegister()
474 .setSExtResult(IsSigned)
475 .setZExtResult(!IsSigned);
476
477 std::pair<SDValue, SDValue> CallInfo = LowerCallTo(CLI);
478 return CallInfo.first;
479}
480
481SDValue AVRTargetLowering::LowerGlobalAddress(SDValue Op,
482 SelectionDAG &DAG) const {
483 auto DL = DAG.getDataLayout();
484
485 const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
486 int64_t Offset = cast<GlobalAddressSDNode>(Op)->getOffset();
487
488 // Create the TargetGlobalAddress node, folding in the constant offset.
489 SDValue Result =
490 DAG.getTargetGlobalAddress(GV, SDLoc(Op), getPointerTy(DL), Offset);
491 return DAG.getNode(AVRISD::WRAPPER, SDLoc(Op), getPointerTy(DL), Result);
492}
493
494SDValue AVRTargetLowering::LowerBlockAddress(SDValue Op,
495 SelectionDAG &DAG) const {
496 auto DL = DAG.getDataLayout();
497 const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
498
499 SDValue Result = DAG.getTargetBlockAddress(BA, getPointerTy(DL));
500
501 return DAG.getNode(AVRISD::WRAPPER, SDLoc(Op), getPointerTy(DL), Result);
502}
503
504/// IntCCToAVRCC - Convert a DAG integer condition code to an AVR CC.
505static AVRCC::CondCodes intCCToAVRCC(ISD::CondCode CC) {
506 switch (CC) {
507 default:
508 llvm_unreachable("Unknown condition code!")::llvm::llvm_unreachable_internal("Unknown condition code!", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 508)
;
509 case ISD::SETEQ:
510 return AVRCC::COND_EQ;
511 case ISD::SETNE:
512 return AVRCC::COND_NE;
513 case ISD::SETGE:
514 return AVRCC::COND_GE;
515 case ISD::SETLT:
516 return AVRCC::COND_LT;
517 case ISD::SETUGE:
518 return AVRCC::COND_SH;
519 case ISD::SETULT:
520 return AVRCC::COND_LO;
521 }
522}
523
524/// Returns appropriate CP/CPI/CPC nodes code for the given 8/16-bit operands.
525SDValue AVRTargetLowering::getAVRCmp(SDValue LHS, SDValue RHS,
526 SelectionDAG &DAG, SDLoc DL) const {
527 assert((LHS.getSimpleValueType() == RHS.getSimpleValueType()) &&(static_cast <bool> ((LHS.getSimpleValueType() == RHS.getSimpleValueType
()) && "LHS and RHS have different types") ? void (0)
: __assert_fail ("(LHS.getSimpleValueType() == RHS.getSimpleValueType()) && \"LHS and RHS have different types\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 528, __extension__ __PRETTY_FUNCTION__))
528 "LHS and RHS have different types")(static_cast <bool> ((LHS.getSimpleValueType() == RHS.getSimpleValueType
()) && "LHS and RHS have different types") ? void (0)
: __assert_fail ("(LHS.getSimpleValueType() == RHS.getSimpleValueType()) && \"LHS and RHS have different types\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 528, __extension__ __PRETTY_FUNCTION__))
;
529 assert(((LHS.getSimpleValueType() == MVT::i16) ||(static_cast <bool> (((LHS.getSimpleValueType() == MVT::
i16) || (LHS.getSimpleValueType() == MVT::i8)) && "invalid comparison type"
) ? void (0) : __assert_fail ("((LHS.getSimpleValueType() == MVT::i16) || (LHS.getSimpleValueType() == MVT::i8)) && \"invalid comparison type\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 531, __extension__ __PRETTY_FUNCTION__))
530 (LHS.getSimpleValueType() == MVT::i8)) &&(static_cast <bool> (((LHS.getSimpleValueType() == MVT::
i16) || (LHS.getSimpleValueType() == MVT::i8)) && "invalid comparison type"
) ? void (0) : __assert_fail ("((LHS.getSimpleValueType() == MVT::i16) || (LHS.getSimpleValueType() == MVT::i8)) && \"invalid comparison type\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 531, __extension__ __PRETTY_FUNCTION__))
531 "invalid comparison type")(static_cast <bool> (((LHS.getSimpleValueType() == MVT::
i16) || (LHS.getSimpleValueType() == MVT::i8)) && "invalid comparison type"
) ? void (0) : __assert_fail ("((LHS.getSimpleValueType() == MVT::i16) || (LHS.getSimpleValueType() == MVT::i8)) && \"invalid comparison type\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 531, __extension__ __PRETTY_FUNCTION__))
;
532
533 SDValue Cmp;
534
535 if (LHS.getSimpleValueType() == MVT::i16 && isa<ConstantSDNode>(RHS)) {
536 // Generate a CPI/CPC pair if RHS is a 16-bit constant.
537 SDValue LHSlo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i8, LHS,
538 DAG.getIntPtrConstant(0, DL));
539 SDValue LHShi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i8, LHS,
540 DAG.getIntPtrConstant(1, DL));
541 SDValue RHSlo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i8, RHS,
542 DAG.getIntPtrConstant(0, DL));
543 SDValue RHShi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i8, RHS,
544 DAG.getIntPtrConstant(1, DL));
545 Cmp = DAG.getNode(AVRISD::CMP, DL, MVT::Glue, LHSlo, RHSlo);
546 Cmp = DAG.getNode(AVRISD::CMPC, DL, MVT::Glue, LHShi, RHShi, Cmp);
547 } else {
548 // Generate ordinary 16-bit comparison.
549 Cmp = DAG.getNode(AVRISD::CMP, DL, MVT::Glue, LHS, RHS);
550 }
551
552 return Cmp;
553}
554
555/// Returns appropriate AVR CMP/CMPC nodes and corresponding condition code for
556/// the given operands.
557SDValue AVRTargetLowering::getAVRCmp(SDValue LHS, SDValue RHS, ISD::CondCode CC,
558 SDValue &AVRcc, SelectionDAG &DAG,
559 SDLoc DL) const {
560 SDValue Cmp;
561 EVT VT = LHS.getValueType();
562 bool UseTest = false;
563
564 switch (CC) {
565 default:
566 break;
567 case ISD::SETLE: {
568 // Swap operands and reverse the branching condition.
569 std::swap(LHS, RHS);
570 CC = ISD::SETGE;
571 break;
572 }
573 case ISD::SETGT: {
574 if (const ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS)) {
575 switch (C->getSExtValue()) {
576 case -1: {
577 // When doing lhs > -1 use a tst instruction on the top part of lhs
578 // and use brpl instead of using a chain of cp/cpc.
579 UseTest = true;
580 AVRcc = DAG.getConstant(AVRCC::COND_PL, DL, MVT::i8);
581 break;
582 }
583 case 0: {
584 // Turn lhs > 0 into 0 < lhs since 0 can be materialized with
585 // __zero_reg__ in lhs.
586 RHS = LHS;
587 LHS = DAG.getConstant(0, DL, VT);
588 CC = ISD::SETLT;
589 break;
590 }
591 default: {
592 // Turn lhs < rhs with lhs constant into rhs >= lhs+1, this allows
593 // us to fold the constant into the cmp instruction.
594 RHS = DAG.getConstant(C->getSExtValue() + 1, DL, VT);
595 CC = ISD::SETGE;
596 break;
597 }
598 }
599 break;
600 }
601 // Swap operands and reverse the branching condition.
602 std::swap(LHS, RHS);
603 CC = ISD::SETLT;
604 break;
605 }
606 case ISD::SETLT: {
607 if (const ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS)) {
608 switch (C->getSExtValue()) {
609 case 1: {
610 // Turn lhs < 1 into 0 >= lhs since 0 can be materialized with
611 // __zero_reg__ in lhs.
612 RHS = LHS;
613 LHS = DAG.getConstant(0, DL, VT);
614 CC = ISD::SETGE;
615 break;
616 }
617 case 0: {
618 // When doing lhs < 0 use a tst instruction on the top part of lhs
619 // and use brmi instead of using a chain of cp/cpc.
620 UseTest = true;
621 AVRcc = DAG.getConstant(AVRCC::COND_MI, DL, MVT::i8);
622 break;
623 }
624 }
625 }
626 break;
627 }
628 case ISD::SETULE: {
629 // Swap operands and reverse the branching condition.
630 std::swap(LHS, RHS);
631 CC = ISD::SETUGE;
632 break;
633 }
634 case ISD::SETUGT: {
635 // Turn lhs < rhs with lhs constant into rhs >= lhs+1, this allows us to
636 // fold the constant into the cmp instruction.
637 if (const ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS)) {
638 RHS = DAG.getConstant(C->getSExtValue() + 1, DL, VT);
639 CC = ISD::SETUGE;
640 break;
641 }
642 // Swap operands and reverse the branching condition.
643 std::swap(LHS, RHS);
644 CC = ISD::SETULT;
645 break;
646 }
647 }
648
649 // Expand 32 and 64 bit comparisons with custom CMP and CMPC nodes instead of
650 // using the default and/or/xor expansion code which is much longer.
651 if (VT == MVT::i32) {
652 SDValue LHSlo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, LHS,
653 DAG.getIntPtrConstant(0, DL));
654 SDValue LHShi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, LHS,
655 DAG.getIntPtrConstant(1, DL));
656 SDValue RHSlo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, RHS,
657 DAG.getIntPtrConstant(0, DL));
658 SDValue RHShi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, RHS,
659 DAG.getIntPtrConstant(1, DL));
660
661 if (UseTest) {
662 // When using tst we only care about the highest part.
663 SDValue Top = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i8, LHShi,
664 DAG.getIntPtrConstant(1, DL));
665 Cmp = DAG.getNode(AVRISD::TST, DL, MVT::Glue, Top);
666 } else {
667 Cmp = getAVRCmp(LHSlo, RHSlo, DAG, DL);
668 Cmp = DAG.getNode(AVRISD::CMPC, DL, MVT::Glue, LHShi, RHShi, Cmp);
669 }
670 } else if (VT == MVT::i64) {
671 SDValue LHS_0 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, LHS,
672 DAG.getIntPtrConstant(0, DL));
673 SDValue LHS_1 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, LHS,
674 DAG.getIntPtrConstant(1, DL));
675
676 SDValue LHS0 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, LHS_0,
677 DAG.getIntPtrConstant(0, DL));
678 SDValue LHS1 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, LHS_0,
679 DAG.getIntPtrConstant(1, DL));
680 SDValue LHS2 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, LHS_1,
681 DAG.getIntPtrConstant(0, DL));
682 SDValue LHS3 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, LHS_1,
683 DAG.getIntPtrConstant(1, DL));
684
685 SDValue RHS_0 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, RHS,
686 DAG.getIntPtrConstant(0, DL));
687 SDValue RHS_1 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, RHS,
688 DAG.getIntPtrConstant(1, DL));
689
690 SDValue RHS0 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, RHS_0,
691 DAG.getIntPtrConstant(0, DL));
692 SDValue RHS1 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, RHS_0,
693 DAG.getIntPtrConstant(1, DL));
694 SDValue RHS2 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, RHS_1,
695 DAG.getIntPtrConstant(0, DL));
696 SDValue RHS3 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, RHS_1,
697 DAG.getIntPtrConstant(1, DL));
698
699 if (UseTest) {
700 // When using tst we only care about the highest part.
701 SDValue Top = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i8, LHS3,
702 DAG.getIntPtrConstant(1, DL));
703 Cmp = DAG.getNode(AVRISD::TST, DL, MVT::Glue, Top);
704 } else {
705 Cmp = getAVRCmp(LHS0, RHS0, DAG, DL);
706 Cmp = DAG.getNode(AVRISD::CMPC, DL, MVT::Glue, LHS1, RHS1, Cmp);
707 Cmp = DAG.getNode(AVRISD::CMPC, DL, MVT::Glue, LHS2, RHS2, Cmp);
708 Cmp = DAG.getNode(AVRISD::CMPC, DL, MVT::Glue, LHS3, RHS3, Cmp);
709 }
710 } else if (VT == MVT::i8 || VT == MVT::i16) {
711 if (UseTest) {
712 // When using tst we only care about the highest part.
713 Cmp = DAG.getNode(AVRISD::TST, DL, MVT::Glue,
714 (VT == MVT::i8)
715 ? LHS
716 : DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i8,
717 LHS, DAG.getIntPtrConstant(1, DL)));
718 } else {
719 Cmp = getAVRCmp(LHS, RHS, DAG, DL);
720 }
721 } else {
722 llvm_unreachable("Invalid comparison size")::llvm::llvm_unreachable_internal("Invalid comparison size", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 722)
;
723 }
724
725 // When using a test instruction AVRcc is already set.
726 if (!UseTest) {
727 AVRcc = DAG.getConstant(intCCToAVRCC(CC), DL, MVT::i8);
728 }
729
730 return Cmp;
731}
732
733SDValue AVRTargetLowering::LowerBR_CC(SDValue Op, SelectionDAG &DAG) const {
734 SDValue Chain = Op.getOperand(0);
735 ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(1))->get();
736 SDValue LHS = Op.getOperand(2);
737 SDValue RHS = Op.getOperand(3);
738 SDValue Dest = Op.getOperand(4);
739 SDLoc dl(Op);
740
741 SDValue TargetCC;
742 SDValue Cmp = getAVRCmp(LHS, RHS, CC, TargetCC, DAG, dl);
743
744 return DAG.getNode(AVRISD::BRCOND, dl, MVT::Other, Chain, Dest, TargetCC,
745 Cmp);
746}
747
748SDValue AVRTargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
749 SDValue LHS = Op.getOperand(0);
750 SDValue RHS = Op.getOperand(1);
751 SDValue TrueV = Op.getOperand(2);
752 SDValue FalseV = Op.getOperand(3);
753 ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get();
754 SDLoc dl(Op);
755
756 SDValue TargetCC;
757 SDValue Cmp = getAVRCmp(LHS, RHS, CC, TargetCC, DAG, dl);
758
759 SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::Glue);
760 SDValue Ops[] = {TrueV, FalseV, TargetCC, Cmp};
761
762 return DAG.getNode(AVRISD::SELECT_CC, dl, VTs, Ops);
763}
764
765SDValue AVRTargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const {
766 SDValue LHS = Op.getOperand(0);
767 SDValue RHS = Op.getOperand(1);
768 ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get();
769 SDLoc DL(Op);
770
771 SDValue TargetCC;
772 SDValue Cmp = getAVRCmp(LHS, RHS, CC, TargetCC, DAG, DL);
773
774 SDValue TrueV = DAG.getConstant(1, DL, Op.getValueType());
775 SDValue FalseV = DAG.getConstant(0, DL, Op.getValueType());
776 SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::Glue);
777 SDValue Ops[] = {TrueV, FalseV, TargetCC, Cmp};
778
779 return DAG.getNode(AVRISD::SELECT_CC, DL, VTs, Ops);
780}
781
782SDValue AVRTargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG) const {
783 const MachineFunction &MF = DAG.getMachineFunction();
784 const AVRMachineFunctionInfo *AFI = MF.getInfo<AVRMachineFunctionInfo>();
785 const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
786 auto DL = DAG.getDataLayout();
787 SDLoc dl(Op);
788
789 // Vastart just stores the address of the VarArgsFrameIndex slot into the
790 // memory location argument.
791 SDValue FI = DAG.getFrameIndex(AFI->getVarArgsFrameIndex(), getPointerTy(DL));
792
793 return DAG.getStore(Op.getOperand(0), dl, FI, Op.getOperand(1),
794 MachinePointerInfo(SV));
795}
796
797SDValue AVRTargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
798 switch (Op.getOpcode()) {
799 default:
800 llvm_unreachable("Don't know how to custom lower this!")::llvm::llvm_unreachable_internal("Don't know how to custom lower this!"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 800)
;
801 case ISD::SHL:
802 case ISD::SRA:
803 case ISD::SRL:
804 case ISD::ROTL:
805 case ISD::ROTR:
806 return LowerShifts(Op, DAG);
807 case ISD::GlobalAddress:
808 return LowerGlobalAddress(Op, DAG);
809 case ISD::BlockAddress:
810 return LowerBlockAddress(Op, DAG);
811 case ISD::BR_CC:
812 return LowerBR_CC(Op, DAG);
813 case ISD::SELECT_CC:
814 return LowerSELECT_CC(Op, DAG);
815 case ISD::SETCC:
816 return LowerSETCC(Op, DAG);
817 case ISD::VASTART:
818 return LowerVASTART(Op, DAG);
819 case ISD::SDIVREM:
820 case ISD::UDIVREM:
821 return LowerDivRem(Op, DAG);
822 }
823
824 return SDValue();
825}
826
827/// Replace a node with an illegal result type
828/// with a new node built out of custom code.
829void AVRTargetLowering::ReplaceNodeResults(SDNode *N,
830 SmallVectorImpl<SDValue> &Results,
831 SelectionDAG &DAG) const {
832 SDLoc DL(N);
833
834 switch (N->getOpcode()) {
835 case ISD::ADD: {
836 // Convert add (x, imm) into sub (x, -imm).
837 if (const ConstantSDNode *C = dyn_cast<ConstantSDNode>(N->getOperand(1))) {
838 SDValue Sub = DAG.getNode(
839 ISD::SUB, DL, N->getValueType(0), N->getOperand(0),
840 DAG.getConstant(-C->getAPIntValue(), DL, C->getValueType(0)));
841 Results.push_back(Sub);
842 }
843 break;
844 }
845 default: {
846 SDValue Res = LowerOperation(SDValue(N, 0), DAG);
847
848 for (unsigned I = 0, E = Res->getNumValues(); I != E; ++I)
849 Results.push_back(Res.getValue(I));
850
851 break;
852 }
853 }
854}
855
856/// Return true if the addressing mode represented
857/// by AM is legal for this target, for a load/store of the specified type.
858bool AVRTargetLowering::isLegalAddressingMode(const DataLayout &DL,
859 const AddrMode &AM, Type *Ty,
860 unsigned AS,
861 Instruction *I) const {
862 int64_t Offs = AM.BaseOffs;
863
864 // Allow absolute addresses.
865 if (AM.BaseGV && !AM.HasBaseReg && AM.Scale == 0 && Offs == 0) {
866 return true;
867 }
868
869 // Flash memory instructions only allow zero offsets.
870 if (isa<PointerType>(Ty) && AS == AVR::ProgramMemory) {
871 return false;
872 }
873
874 // Allow reg+<6bit> offset.
875 if (Offs < 0)
876 Offs = -Offs;
877 if (AM.BaseGV == 0 && AM.HasBaseReg && AM.Scale == 0 && isUInt<6>(Offs)) {
878 return true;
879 }
880
881 return false;
882}
883
884/// Returns true by value, base pointer and
885/// offset pointer and addressing mode by reference if the node's address
886/// can be legally represented as pre-indexed load / store address.
887bool AVRTargetLowering::getPreIndexedAddressParts(SDNode *N, SDValue &Base,
888 SDValue &Offset,
889 ISD::MemIndexedMode &AM,
890 SelectionDAG &DAG) const {
891 EVT VT;
892 const SDNode *Op;
893 SDLoc DL(N);
894
895 if (const LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) {
896 VT = LD->getMemoryVT();
897 Op = LD->getBasePtr().getNode();
898 if (LD->getExtensionType() != ISD::NON_EXTLOAD)
899 return false;
900 if (AVR::isProgramMemoryAccess(LD)) {
901 return false;
902 }
903 } else if (const StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
904 VT = ST->getMemoryVT();
905 Op = ST->getBasePtr().getNode();
906 if (AVR::isProgramMemoryAccess(ST)) {
907 return false;
908 }
909 } else {
910 return false;
911 }
912
913 if (VT != MVT::i8 && VT != MVT::i16) {
914 return false;
915 }
916
917 if (Op->getOpcode() != ISD::ADD && Op->getOpcode() != ISD::SUB) {
918 return false;
919 }
920
921 if (const ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(Op->getOperand(1))) {
922 int RHSC = RHS->getSExtValue();
923 if (Op->getOpcode() == ISD::SUB)
924 RHSC = -RHSC;
925
926 if ((VT == MVT::i16 && RHSC != -2) || (VT == MVT::i8 && RHSC != -1)) {
927 return false;
928 }
929
930 Base = Op->getOperand(0);
931 Offset = DAG.getConstant(RHSC, DL, MVT::i8);
932 AM = ISD::PRE_DEC;
933
934 return true;
935 }
936
937 return false;
938}
939
940/// Returns true by value, base pointer and
941/// offset pointer and addressing mode by reference if this node can be
942/// combined with a load / store to form a post-indexed load / store.
943bool AVRTargetLowering::getPostIndexedAddressParts(SDNode *N, SDNode *Op,
944 SDValue &Base,
945 SDValue &Offset,
946 ISD::MemIndexedMode &AM,
947 SelectionDAG &DAG) const {
948 EVT VT;
949 SDLoc DL(N);
950
951 if (const LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) {
952 VT = LD->getMemoryVT();
953 if (LD->getExtensionType() != ISD::NON_EXTLOAD)
954 return false;
955 } else if (const StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
956 VT = ST->getMemoryVT();
957 if (AVR::isProgramMemoryAccess(ST)) {
958 return false;
959 }
960 } else {
961 return false;
962 }
963
964 if (VT != MVT::i8 && VT != MVT::i16) {
965 return false;
966 }
967
968 if (Op->getOpcode() != ISD::ADD && Op->getOpcode() != ISD::SUB) {
969 return false;
970 }
971
972 if (const ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(Op->getOperand(1))) {
973 int RHSC = RHS->getSExtValue();
974 if (Op->getOpcode() == ISD::SUB)
975 RHSC = -RHSC;
976 if ((VT == MVT::i16 && RHSC != 2) || (VT == MVT::i8 && RHSC != 1)) {
977 return false;
978 }
979
980 Base = Op->getOperand(0);
981 Offset = DAG.getConstant(RHSC, DL, MVT::i8);
982 AM = ISD::POST_INC;
983
984 return true;
985 }
986
987 return false;
988}
989
990bool AVRTargetLowering::isOffsetFoldingLegal(
991 const GlobalAddressSDNode *GA) const {
992 return true;
993}
994
995//===----------------------------------------------------------------------===//
996// Formal Arguments Calling Convention Implementation
997//===----------------------------------------------------------------------===//
998
999#include "AVRGenCallingConv.inc"
1000
1001/// Registers for calling conventions, ordered in reverse as required by ABI.
1002/// Both arrays must be of the same length.
1003static const MCPhysReg RegList8[] = {
1004 AVR::R25, AVR::R24, AVR::R23, AVR::R22, AVR::R21, AVR::R20,
1005 AVR::R19, AVR::R18, AVR::R17, AVR::R16, AVR::R15, AVR::R14,
1006 AVR::R13, AVR::R12, AVR::R11, AVR::R10, AVR::R9, AVR::R8};
1007static const MCPhysReg RegList16[] = {
1008 AVR::R26R25, AVR::R25R24, AVR::R24R23, AVR::R23R22, AVR::R22R21,
1009 AVR::R21R20, AVR::R20R19, AVR::R19R18, AVR::R18R17, AVR::R17R16,
1010 AVR::R16R15, AVR::R15R14, AVR::R14R13, AVR::R13R12, AVR::R12R11,
1011 AVR::R11R10, AVR::R10R9, AVR::R9R8};
1012
1013static_assert(array_lengthof(RegList8) == array_lengthof(RegList16),
1014 "8-bit and 16-bit register arrays must be of equal length");
1015
1016/// Analyze incoming and outgoing function arguments. We need custom C++ code
1017/// to handle special constraints in the ABI.
1018/// In addition, all pieces of a certain argument have to be passed either
1019/// using registers or the stack but never mixing both.
1020template <typename ArgT>
1021static void
1022analyzeArguments(TargetLowering::CallLoweringInfo *CLI, const Function *F,
1023 const DataLayout *TD, const SmallVectorImpl<ArgT> &Args,
1024 SmallVectorImpl<CCValAssign> &ArgLocs, CCState &CCInfo) {
1025 unsigned NumArgs = Args.size();
1026 // This is the index of the last used register, in RegList*.
1027 // -1 means R26 (R26 is never actually used in CC).
1028 int RegLastIdx = -1;
1029 // Once a value is passed to the stack it will always be used
1030 bool UseStack = false;
1031 for (unsigned i = 0; i != NumArgs;) {
1032 MVT VT = Args[i].VT;
1033 // We have to count the number of bytes for each function argument, that is
1034 // those Args with the same OrigArgIndex. This is important in case the
1035 // function takes an aggregate type.
1036 // Current argument will be between [i..j).
1037 unsigned ArgIndex = Args[i].OrigArgIndex;
1038 unsigned TotalBytes = VT.getStoreSize();
1039 unsigned j = i + 1;
1040 for (; j != NumArgs; ++j) {
1041 if (Args[j].OrigArgIndex != ArgIndex)
1042 break;
1043 TotalBytes += Args[j].VT.getStoreSize();
1044 }
1045 // Round up to even number of bytes.
1046 TotalBytes = alignTo(TotalBytes, 2);
1047 // Skip zero sized arguments
1048 if (TotalBytes == 0)
1049 continue;
1050 // The index of the first register to be used
1051 unsigned RegIdx = RegLastIdx + TotalBytes;
1052 RegLastIdx = RegIdx;
1053 // If there are not enough registers, use the stack
1054 if (RegIdx >= array_lengthof(RegList8)) {
1055 UseStack = true;
1056 }
1057 for (; i != j; ++i) {
1058 MVT VT = Args[i].VT;
1059
1060 if (UseStack) {
1061 auto evt = EVT(VT).getTypeForEVT(CCInfo.getContext());
1062 unsigned Offset = CCInfo.AllocateStack(TD->getTypeAllocSize(evt),
1063 TD->getABITypeAlign(evt));
1064 CCInfo.addLoc(
1065 CCValAssign::getMem(i, VT, Offset, VT, CCValAssign::Full));
1066 } else {
1067 unsigned Reg;
1068 if (VT == MVT::i8) {
1069 Reg = CCInfo.AllocateReg(RegList8[RegIdx]);
1070 } else if (VT == MVT::i16) {
1071 Reg = CCInfo.AllocateReg(RegList16[RegIdx]);
1072 } else {
1073 llvm_unreachable(::llvm::llvm_unreachable_internal("calling convention can only manage i8 and i16 types"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1074)
1074 "calling convention can only manage i8 and i16 types")::llvm::llvm_unreachable_internal("calling convention can only manage i8 and i16 types"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1074)
;
1075 }
1076 assert(Reg && "register not available in calling convention")(static_cast <bool> (Reg && "register not available in calling convention"
) ? void (0) : __assert_fail ("Reg && \"register not available in calling convention\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1076, __extension__ __PRETTY_FUNCTION__))
;
1077 CCInfo.addLoc(CCValAssign::getReg(i, VT, Reg, VT, CCValAssign::Full));
1078 // Registers inside a particular argument are sorted in increasing order
1079 // (remember the array is reversed).
1080 RegIdx -= VT.getStoreSize();
1081 }
1082 }
1083 }
1084}
1085
1086/// Count the total number of bytes needed to pass or return these arguments.
1087template <typename ArgT>
1088static unsigned
1089getTotalArgumentsSizeInBytes(const SmallVectorImpl<ArgT> &Args) {
1090 unsigned TotalBytes = 0;
1091
1092 for (const ArgT &Arg : Args) {
1093 TotalBytes += Arg.VT.getStoreSize();
1094 }
1095 return TotalBytes;
1096}
1097
1098/// Analyze incoming and outgoing value of returning from a function.
1099/// The algorithm is similar to analyzeArguments, but there can only be
1100/// one value, possibly an aggregate, and it is limited to 8 bytes.
1101template <typename ArgT>
1102static void analyzeReturnValues(const SmallVectorImpl<ArgT> &Args,
1103 CCState &CCInfo) {
1104 unsigned NumArgs = Args.size();
1105 unsigned TotalBytes = getTotalArgumentsSizeInBytes(Args);
1106 // CanLowerReturn() guarantees this assertion.
1107 assert(TotalBytes <= 8 &&(static_cast <bool> (TotalBytes <= 8 && "return values greater than 8 bytes cannot be lowered"
) ? void (0) : __assert_fail ("TotalBytes <= 8 && \"return values greater than 8 bytes cannot be lowered\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1108, __extension__ __PRETTY_FUNCTION__))
4
'?' condition is true
1108 "return values greater than 8 bytes cannot be lowered")(static_cast <bool> (TotalBytes <= 8 && "return values greater than 8 bytes cannot be lowered"
) ? void (0) : __assert_fail ("TotalBytes <= 8 && \"return values greater than 8 bytes cannot be lowered\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1108, __extension__ __PRETTY_FUNCTION__))
;
1109
1110 // GCC-ABI says that the size is rounded up to the next even number,
1111 // but actually once it is more than 4 it will always round up to 8.
1112 if (TotalBytes
4.1
'TotalBytes' is <= 4
4.1
'TotalBytes' is <= 4
> 4) {
5
Taking false branch
1113 TotalBytes = 8;
1114 } else {
1115 TotalBytes = alignTo(TotalBytes, 2);
1116 }
1117
1118 // The index of the first register to use.
1119 int RegIdx = TotalBytes - 1;
6
'RegIdx' initialized to -1
1120 for (unsigned i = 0; i != NumArgs; ++i) {
7
Assuming 'i' is not equal to 'NumArgs'
8
Loop condition is true. Entering loop body
1121 MVT VT = Args[i].VT;
1122 unsigned Reg;
1123 if (VT == MVT::i8) {
9
Calling 'MVT::operator=='
12
Returning from 'MVT::operator=='
13
Taking true branch
1124 Reg = CCInfo.AllocateReg(RegList8[RegIdx]);
14
1st function call argument is an uninitialized value
1125 } else if (VT == MVT::i16) {
1126 Reg = CCInfo.AllocateReg(RegList16[RegIdx]);
1127 } else {
1128 llvm_unreachable("calling convention can only manage i8 and i16 types")::llvm::llvm_unreachable_internal("calling convention can only manage i8 and i16 types"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1128)
;
1129 }
1130 assert(Reg && "register not available in calling convention")(static_cast <bool> (Reg && "register not available in calling convention"
) ? void (0) : __assert_fail ("Reg && \"register not available in calling convention\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1130, __extension__ __PRETTY_FUNCTION__))
;
1131 CCInfo.addLoc(CCValAssign::getReg(i, VT, Reg, VT, CCValAssign::Full));
1132 // Registers sort in increasing order
1133 RegIdx -= VT.getStoreSize();
1134 }
1135}
1136
1137SDValue AVRTargetLowering::LowerFormalArguments(
1138 SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
1139 const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
1140 SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const {
1141 MachineFunction &MF = DAG.getMachineFunction();
1142 MachineFrameInfo &MFI = MF.getFrameInfo();
1143 auto DL = DAG.getDataLayout();
1144
1145 // Assign locations to all of the incoming arguments.
1146 SmallVector<CCValAssign, 16> ArgLocs;
1147 CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), ArgLocs,
1148 *DAG.getContext());
1149
1150 // Variadic functions do not need all the analysis below.
1151 if (isVarArg) {
1152 CCInfo.AnalyzeFormalArguments(Ins, ArgCC_AVR_Vararg);
1153 } else {
1154 analyzeArguments(nullptr, &MF.getFunction(), &DL, Ins, ArgLocs, CCInfo);
1155 }
1156
1157 SDValue ArgValue;
1158 for (CCValAssign &VA : ArgLocs) {
1159
1160 // Arguments stored on registers.
1161 if (VA.isRegLoc()) {
1162 EVT RegVT = VA.getLocVT();
1163 const TargetRegisterClass *RC;
1164 if (RegVT == MVT::i8) {
1165 RC = &AVR::GPR8RegClass;
1166 } else if (RegVT == MVT::i16) {
1167 RC = &AVR::DREGSRegClass;
1168 } else {
1169 llvm_unreachable("Unknown argument type!")::llvm::llvm_unreachable_internal("Unknown argument type!", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1169)
;
1170 }
1171
1172 unsigned Reg = MF.addLiveIn(VA.getLocReg(), RC);
1173 ArgValue = DAG.getCopyFromReg(Chain, dl, Reg, RegVT);
1174
1175 // :NOTE: Clang should not promote any i8 into i16 but for safety the
1176 // following code will handle zexts or sexts generated by other
1177 // front ends. Otherwise:
1178 // If this is an 8 bit value, it is really passed promoted
1179 // to 16 bits. Insert an assert[sz]ext to capture this, then
1180 // truncate to the right size.
1181 switch (VA.getLocInfo()) {
1182 default:
1183 llvm_unreachable("Unknown loc info!")::llvm::llvm_unreachable_internal("Unknown loc info!", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1183)
;
1184 case CCValAssign::Full:
1185 break;
1186 case CCValAssign::BCvt:
1187 ArgValue = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), ArgValue);
1188 break;
1189 case CCValAssign::SExt:
1190 ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
1191 DAG.getValueType(VA.getValVT()));
1192 ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
1193 break;
1194 case CCValAssign::ZExt:
1195 ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
1196 DAG.getValueType(VA.getValVT()));
1197 ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
1198 break;
1199 }
1200
1201 InVals.push_back(ArgValue);
1202 } else {
1203 // Sanity check.
1204 assert(VA.isMemLoc())(static_cast <bool> (VA.isMemLoc()) ? void (0) : __assert_fail
("VA.isMemLoc()", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1204, __extension__ __PRETTY_FUNCTION__))
;
1205
1206 EVT LocVT = VA.getLocVT();
1207
1208 // Create the frame index object for this incoming parameter.
1209 int FI = MFI.CreateFixedObject(LocVT.getSizeInBits() / 8,
1210 VA.getLocMemOffset(), true);
1211
1212 // Create the SelectionDAG nodes corresponding to a load
1213 // from this parameter.
1214 SDValue FIN = DAG.getFrameIndex(FI, getPointerTy(DL));
1215 InVals.push_back(DAG.getLoad(LocVT, dl, Chain, FIN,
1216 MachinePointerInfo::getFixedStack(MF, FI)));
1217 }
1218 }
1219
1220 // If the function takes variable number of arguments, make a frame index for
1221 // the start of the first vararg value... for expansion of llvm.va_start.
1222 if (isVarArg) {
1223 unsigned StackSize = CCInfo.getNextStackOffset();
1224 AVRMachineFunctionInfo *AFI = MF.getInfo<AVRMachineFunctionInfo>();
1225
1226 AFI->setVarArgsFrameIndex(MFI.CreateFixedObject(2, StackSize, true));
1227 }
1228
1229 return Chain;
1230}
1231
1232//===----------------------------------------------------------------------===//
1233// Call Calling Convention Implementation
1234//===----------------------------------------------------------------------===//
1235
1236SDValue AVRTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
1237 SmallVectorImpl<SDValue> &InVals) const {
1238 SelectionDAG &DAG = CLI.DAG;
1239 SDLoc &DL = CLI.DL;
1240 SmallVectorImpl<ISD::OutputArg> &Outs = CLI.Outs;
1241 SmallVectorImpl<SDValue> &OutVals = CLI.OutVals;
1242 SmallVectorImpl<ISD::InputArg> &Ins = CLI.Ins;
1243 SDValue Chain = CLI.Chain;
1244 SDValue Callee = CLI.Callee;
1245 bool &isTailCall = CLI.IsTailCall;
1246 CallingConv::ID CallConv = CLI.CallConv;
1247 bool isVarArg = CLI.IsVarArg;
1248
1249 MachineFunction &MF = DAG.getMachineFunction();
1250
1251 // AVR does not yet support tail call optimization.
1252 isTailCall = false;
1253
1254 // Analyze operands of the call, assigning locations to each operand.
1255 SmallVector<CCValAssign, 16> ArgLocs;
1256 CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), ArgLocs,
1257 *DAG.getContext());
1258
1259 // If the callee is a GlobalAddress/ExternalSymbol node (quite common, every
1260 // direct call is) turn it into a TargetGlobalAddress/TargetExternalSymbol
1261 // node so that legalize doesn't hack it.
1262 const Function *F = nullptr;
1263 if (const GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
1264 const GlobalValue *GV = G->getGlobal();
1265
1266 F = cast<Function>(GV);
1267 Callee =
1268 DAG.getTargetGlobalAddress(GV, DL, getPointerTy(DAG.getDataLayout()));
1269 } else if (const ExternalSymbolSDNode *ES =
1270 dyn_cast<ExternalSymbolSDNode>(Callee)) {
1271 Callee = DAG.getTargetExternalSymbol(ES->getSymbol(),
1272 getPointerTy(DAG.getDataLayout()));
1273 }
1274
1275 // Variadic functions do not need all the analysis below.
1276 if (isVarArg) {
1277 CCInfo.AnalyzeCallOperands(Outs, ArgCC_AVR_Vararg);
1278 } else {
1279 analyzeArguments(&CLI, F, &DAG.getDataLayout(), Outs, ArgLocs, CCInfo);
1280 }
1281
1282 // Get a count of how many bytes are to be pushed on the stack.
1283 unsigned NumBytes = CCInfo.getNextStackOffset();
1284
1285 Chain = DAG.getCALLSEQ_START(Chain, NumBytes, 0, DL);
1286
1287 SmallVector<std::pair<unsigned, SDValue>, 8> RegsToPass;
1288
1289 // First, walk the register assignments, inserting copies.
1290 unsigned AI, AE;
1291 bool HasStackArgs = false;
1292 for (AI = 0, AE = ArgLocs.size(); AI != AE; ++AI) {
1293 CCValAssign &VA = ArgLocs[AI];
1294 EVT RegVT = VA.getLocVT();
1295 SDValue Arg = OutVals[AI];
1296
1297 // Promote the value if needed. With Clang this should not happen.
1298 switch (VA.getLocInfo()) {
1299 default:
1300 llvm_unreachable("Unknown loc info!")::llvm::llvm_unreachable_internal("Unknown loc info!", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1300)
;
1301 case CCValAssign::Full:
1302 break;
1303 case CCValAssign::SExt:
1304 Arg = DAG.getNode(ISD::SIGN_EXTEND, DL, RegVT, Arg);
1305 break;
1306 case CCValAssign::ZExt:
1307 Arg = DAG.getNode(ISD::ZERO_EXTEND, DL, RegVT, Arg);
1308 break;
1309 case CCValAssign::AExt:
1310 Arg = DAG.getNode(ISD::ANY_EXTEND, DL, RegVT, Arg);
1311 break;
1312 case CCValAssign::BCvt:
1313 Arg = DAG.getNode(ISD::BITCAST, DL, RegVT, Arg);
1314 break;
1315 }
1316
1317 // Stop when we encounter a stack argument, we need to process them
1318 // in reverse order in the loop below.
1319 if (VA.isMemLoc()) {
1320 HasStackArgs = true;
1321 break;
1322 }
1323
1324 // Arguments that can be passed on registers must be kept in the RegsToPass
1325 // vector.
1326 RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
1327 }
1328
1329 // Second, stack arguments have to walked.
1330 // Previously this code created chained stores but those chained stores appear
1331 // to be unchained in the legalization phase. Therefore, do not attempt to
1332 // chain them here. In fact, chaining them here somehow causes the first and
1333 // second store to be reversed which is the exact opposite of the intended
1334 // effect.
1335 if (HasStackArgs) {
1336 SmallVector<SDValue, 8> MemOpChains;
1337 for (; AI != AE; AI++) {
1338 CCValAssign &VA = ArgLocs[AI];
1339 SDValue Arg = OutVals[AI];
1340
1341 assert(VA.isMemLoc())(static_cast <bool> (VA.isMemLoc()) ? void (0) : __assert_fail
("VA.isMemLoc()", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1341, __extension__ __PRETTY_FUNCTION__))
;
1342
1343 // SP points to one stack slot further so add one to adjust it.
1344 SDValue PtrOff = DAG.getNode(
1345 ISD::ADD, DL, getPointerTy(DAG.getDataLayout()),
1346 DAG.getRegister(AVR::SP, getPointerTy(DAG.getDataLayout())),
1347 DAG.getIntPtrConstant(VA.getLocMemOffset() + 1, DL));
1348
1349 MemOpChains.push_back(
1350 DAG.getStore(Chain, DL, Arg, PtrOff,
1351 MachinePointerInfo::getStack(MF, VA.getLocMemOffset())));
1352 }
1353
1354 if (!MemOpChains.empty())
1355 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOpChains);
1356 }
1357
1358 // Build a sequence of copy-to-reg nodes chained together with token chain and
1359 // flag operands which copy the outgoing args into registers. The InFlag in
1360 // necessary since all emited instructions must be stuck together.
1361 SDValue InFlag;
1362 for (auto Reg : RegsToPass) {
1363 Chain = DAG.getCopyToReg(Chain, DL, Reg.first, Reg.second, InFlag);
1364 InFlag = Chain.getValue(1);
1365 }
1366
1367 // Returns a chain & a flag for retval copy to use.
1368 SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
1369 SmallVector<SDValue, 8> Ops;
1370 Ops.push_back(Chain);
1371 Ops.push_back(Callee);
1372
1373 // Add argument registers to the end of the list so that they are known live
1374 // into the call.
1375 for (auto Reg : RegsToPass) {
1376 Ops.push_back(DAG.getRegister(Reg.first, Reg.second.getValueType()));
1377 }
1378
1379 // Add a register mask operand representing the call-preserved registers.
1380 const TargetRegisterInfo *TRI = Subtarget.getRegisterInfo();
1381 const uint32_t *Mask =
1382 TRI->getCallPreservedMask(DAG.getMachineFunction(), CallConv);
1383 assert(Mask && "Missing call preserved mask for calling convention")(static_cast <bool> (Mask && "Missing call preserved mask for calling convention"
) ? void (0) : __assert_fail ("Mask && \"Missing call preserved mask for calling convention\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1383, __extension__ __PRETTY_FUNCTION__))
;
1384 Ops.push_back(DAG.getRegisterMask(Mask));
1385
1386 if (InFlag.getNode()) {
1387 Ops.push_back(InFlag);
1388 }
1389
1390 Chain = DAG.getNode(AVRISD::CALL, DL, NodeTys, Ops);
1391 InFlag = Chain.getValue(1);
1392
1393 // Create the CALLSEQ_END node.
1394 Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(NumBytes, DL, true),
1395 DAG.getIntPtrConstant(0, DL, true), InFlag, DL);
1396
1397 if (!Ins.empty()) {
1398 InFlag = Chain.getValue(1);
1399 }
1400
1401 // Handle result values, copying them out of physregs into vregs that we
1402 // return.
1403 return LowerCallResult(Chain, InFlag, CallConv, isVarArg, Ins, DL, DAG,
1404 InVals);
1405}
1406
1407/// Lower the result values of a call into the
1408/// appropriate copies out of appropriate physical registers.
1409///
1410SDValue AVRTargetLowering::LowerCallResult(
1411 SDValue Chain, SDValue InFlag, CallingConv::ID CallConv, bool isVarArg,
1412 const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
1413 SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const {
1414
1415 // Assign locations to each value returned by this call.
1416 SmallVector<CCValAssign, 16> RVLocs;
1417 CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), RVLocs,
1418 *DAG.getContext());
1419
1420 // Handle runtime calling convs.
1421 if (CallConv == CallingConv::AVR_BUILTIN) {
1422 CCInfo.AnalyzeCallResult(Ins, RetCC_AVR_BUILTIN);
1423 } else {
1424 analyzeReturnValues(Ins, CCInfo);
1425 }
1426
1427 // Copy all of the result registers out of their specified physreg.
1428 for (CCValAssign const &RVLoc : RVLocs) {
1429 Chain = DAG.getCopyFromReg(Chain, dl, RVLoc.getLocReg(), RVLoc.getValVT(),
1430 InFlag)
1431 .getValue(1);
1432 InFlag = Chain.getValue(2);
1433 InVals.push_back(Chain.getValue(0));
1434 }
1435
1436 return Chain;
1437}
1438
1439//===----------------------------------------------------------------------===//
1440// Return Value Calling Convention Implementation
1441//===----------------------------------------------------------------------===//
1442
1443bool AVRTargetLowering::CanLowerReturn(
1444 CallingConv::ID CallConv, MachineFunction &MF, bool isVarArg,
1445 const SmallVectorImpl<ISD::OutputArg> &Outs, LLVMContext &Context) const {
1446 if (CallConv == CallingConv::AVR_BUILTIN) {
1447 SmallVector<CCValAssign, 16> RVLocs;
1448 CCState CCInfo(CallConv, isVarArg, MF, RVLocs, Context);
1449 return CCInfo.CheckReturn(Outs, RetCC_AVR_BUILTIN);
1450 }
1451
1452 unsigned TotalBytes = getTotalArgumentsSizeInBytes(Outs);
1453 return TotalBytes <= 8;
1454}
1455
1456SDValue
1457AVRTargetLowering::LowerReturn(SDValue Chain, CallingConv::ID CallConv,
1458 bool isVarArg,
1459 const SmallVectorImpl<ISD::OutputArg> &Outs,
1460 const SmallVectorImpl<SDValue> &OutVals,
1461 const SDLoc &dl, SelectionDAG &DAG) const {
1462 // CCValAssign - represent the assignment of the return value to locations.
1463 SmallVector<CCValAssign, 16> RVLocs;
1464
1465 // CCState - Info about the registers and stack slot.
1466 CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), RVLocs,
1467 *DAG.getContext());
1468
1469 MachineFunction &MF = DAG.getMachineFunction();
1470
1471 // Analyze return values.
1472 if (CallConv == CallingConv::AVR_BUILTIN) {
1
Assuming 'CallConv' is not equal to AVR_BUILTIN
2
Taking false branch
1473 CCInfo.AnalyzeReturn(Outs, RetCC_AVR_BUILTIN);
1474 } else {
1475 analyzeReturnValues(Outs, CCInfo);
3
Calling 'analyzeReturnValues<llvm::ISD::OutputArg>'
1476 }
1477
1478 SDValue Flag;
1479 SmallVector<SDValue, 4> RetOps(1, Chain);
1480 // Copy the result values into the output registers.
1481 for (unsigned i = 0, e = RVLocs.size(); i != e; ++i) {
1482 CCValAssign &VA = RVLocs[i];
1483 assert(VA.isRegLoc() && "Can only return in registers!")(static_cast <bool> (VA.isRegLoc() && "Can only return in registers!"
) ? void (0) : __assert_fail ("VA.isRegLoc() && \"Can only return in registers!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1483, __extension__ __PRETTY_FUNCTION__))
;
1484
1485 Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), OutVals[i], Flag);
1486
1487 // Guarantee that all emitted copies are stuck together with flags.
1488 Flag = Chain.getValue(1);
1489 RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
1490 }
1491
1492 // Don't emit the ret/reti instruction when the naked attribute is present in
1493 // the function being compiled.
1494 if (MF.getFunction().getAttributes().hasFnAttr(Attribute::Naked)) {
1495 return Chain;
1496 }
1497
1498 const AVRMachineFunctionInfo *AFI = MF.getInfo<AVRMachineFunctionInfo>();
1499
1500 unsigned RetOpc =
1501 AFI->isInterruptOrSignalHandler() ? AVRISD::RETI_FLAG : AVRISD::RET_FLAG;
1502
1503 RetOps[0] = Chain; // Update chain.
1504
1505 if (Flag.getNode()) {
1506 RetOps.push_back(Flag);
1507 }
1508
1509 return DAG.getNode(RetOpc, dl, MVT::Other, RetOps);
1510}
1511
1512//===----------------------------------------------------------------------===//
1513// Custom Inserters
1514//===----------------------------------------------------------------------===//
1515
1516MachineBasicBlock *AVRTargetLowering::insertShift(MachineInstr &MI,
1517 MachineBasicBlock *BB) const {
1518 unsigned Opc;
1519 const TargetRegisterClass *RC;
1520 bool HasRepeatedOperand = false;
1521 MachineFunction *F = BB->getParent();
1522 MachineRegisterInfo &RI = F->getRegInfo();
1523 const TargetInstrInfo &TII = *Subtarget.getInstrInfo();
1524 DebugLoc dl = MI.getDebugLoc();
1525
1526 switch (MI.getOpcode()) {
1527 default:
1528 llvm_unreachable("Invalid shift opcode!")::llvm::llvm_unreachable_internal("Invalid shift opcode!", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1528)
;
1529 case AVR::Lsl8:
1530 Opc = AVR::ADDRdRr; // LSL is an alias of ADD Rd, Rd
1531 RC = &AVR::GPR8RegClass;
1532 HasRepeatedOperand = true;
1533 break;
1534 case AVR::Lsl16:
1535 Opc = AVR::LSLWRd;
1536 RC = &AVR::DREGSRegClass;
1537 break;
1538 case AVR::Asr8:
1539 Opc = AVR::ASRRd;
1540 RC = &AVR::GPR8RegClass;
1541 break;
1542 case AVR::Asr16:
1543 Opc = AVR::ASRWRd;
1544 RC = &AVR::DREGSRegClass;
1545 break;
1546 case AVR::Lsr8:
1547 Opc = AVR::LSRRd;
1548 RC = &AVR::GPR8RegClass;
1549 break;
1550 case AVR::Lsr16:
1551 Opc = AVR::LSRWRd;
1552 RC = &AVR::DREGSRegClass;
1553 break;
1554 case AVR::Rol8:
1555 Opc = AVR::ROLBRd;
1556 RC = &AVR::GPR8RegClass;
1557 break;
1558 case AVR::Rol16:
1559 Opc = AVR::ROLWRd;
1560 RC = &AVR::DREGSRegClass;
1561 break;
1562 case AVR::Ror8:
1563 Opc = AVR::RORBRd;
1564 RC = &AVR::GPR8RegClass;
1565 break;
1566 case AVR::Ror16:
1567 Opc = AVR::RORWRd;
1568 RC = &AVR::DREGSRegClass;
1569 break;
1570 }
1571
1572 const BasicBlock *LLVM_BB = BB->getBasicBlock();
1573
1574 MachineFunction::iterator I;
1575 for (I = BB->getIterator(); I != F->end() && &(*I) != BB; ++I)
1576 ;
1577 if (I != F->end())
1578 ++I;
1579
1580 // Create loop block.
1581 MachineBasicBlock *LoopBB = F->CreateMachineBasicBlock(LLVM_BB);
1582 MachineBasicBlock *CheckBB = F->CreateMachineBasicBlock(LLVM_BB);
1583 MachineBasicBlock *RemBB = F->CreateMachineBasicBlock(LLVM_BB);
1584
1585 F->insert(I, LoopBB);
1586 F->insert(I, CheckBB);
1587 F->insert(I, RemBB);
1588
1589 // Update machine-CFG edges by transferring all successors of the current
1590 // block to the block containing instructions after shift.
1591 RemBB->splice(RemBB->begin(), BB, std::next(MachineBasicBlock::iterator(MI)),
1592 BB->end());
1593 RemBB->transferSuccessorsAndUpdatePHIs(BB);
1594
1595 // Add edges BB => LoopBB => CheckBB => RemBB, CheckBB => LoopBB.
1596 BB->addSuccessor(CheckBB);
1597 LoopBB->addSuccessor(CheckBB);
1598 CheckBB->addSuccessor(LoopBB);
1599 CheckBB->addSuccessor(RemBB);
1600
1601 Register ShiftAmtReg = RI.createVirtualRegister(&AVR::GPR8RegClass);
1602 Register ShiftAmtReg2 = RI.createVirtualRegister(&AVR::GPR8RegClass);
1603 Register ShiftReg = RI.createVirtualRegister(RC);
1604 Register ShiftReg2 = RI.createVirtualRegister(RC);
1605 Register ShiftAmtSrcReg = MI.getOperand(2).getReg();
1606 Register SrcReg = MI.getOperand(1).getReg();
1607 Register DstReg = MI.getOperand(0).getReg();
1608
1609 // BB:
1610 // rjmp CheckBB
1611 BuildMI(BB, dl, TII.get(AVR::RJMPk)).addMBB(CheckBB);
1612
1613 // LoopBB:
1614 // ShiftReg2 = shift ShiftReg
1615 auto ShiftMI = BuildMI(LoopBB, dl, TII.get(Opc), ShiftReg2).addReg(ShiftReg);
1616 if (HasRepeatedOperand)
1617 ShiftMI.addReg(ShiftReg);
1618
1619 // CheckBB:
1620 // ShiftReg = phi [%SrcReg, BB], [%ShiftReg2, LoopBB]
1621 // ShiftAmt = phi [%N, BB], [%ShiftAmt2, LoopBB]
1622 // DestReg = phi [%SrcReg, BB], [%ShiftReg, LoopBB]
1623 // ShiftAmt2 = ShiftAmt - 1;
1624 // if (ShiftAmt2 >= 0) goto LoopBB;
1625 BuildMI(CheckBB, dl, TII.get(AVR::PHI), ShiftReg)
1626 .addReg(SrcReg)
1627 .addMBB(BB)
1628 .addReg(ShiftReg2)
1629 .addMBB(LoopBB);
1630 BuildMI(CheckBB, dl, TII.get(AVR::PHI), ShiftAmtReg)
1631 .addReg(ShiftAmtSrcReg)
1632 .addMBB(BB)
1633 .addReg(ShiftAmtReg2)
1634 .addMBB(LoopBB);
1635 BuildMI(CheckBB, dl, TII.get(AVR::PHI), DstReg)
1636 .addReg(SrcReg)
1637 .addMBB(BB)
1638 .addReg(ShiftReg2)
1639 .addMBB(LoopBB);
1640
1641 BuildMI(CheckBB, dl, TII.get(AVR::DECRd), ShiftAmtReg2).addReg(ShiftAmtReg);
1642 BuildMI(CheckBB, dl, TII.get(AVR::BRPLk)).addMBB(LoopBB);
1643
1644 MI.eraseFromParent(); // The pseudo instruction is gone now.
1645 return RemBB;
1646}
1647
1648static bool isCopyMulResult(MachineBasicBlock::iterator const &I) {
1649 if (I->getOpcode() == AVR::COPY) {
1650 Register SrcReg = I->getOperand(1).getReg();
1651 return (SrcReg == AVR::R0 || SrcReg == AVR::R1);
1652 }
1653
1654 return false;
1655}
1656
1657// The mul instructions wreak havock on our zero_reg R1. We need to clear it
1658// after the result has been evacuated. This is probably not the best way to do
1659// it, but it works for now.
1660MachineBasicBlock *AVRTargetLowering::insertMul(MachineInstr &MI,
1661 MachineBasicBlock *BB) const {
1662 const TargetInstrInfo &TII = *Subtarget.getInstrInfo();
1663 MachineBasicBlock::iterator I(MI);
1664 ++I; // in any case insert *after* the mul instruction
1665 if (isCopyMulResult(I))
1666 ++I;
1667 if (isCopyMulResult(I))
1668 ++I;
1669 BuildMI(*BB, I, MI.getDebugLoc(), TII.get(AVR::EORRdRr), AVR::R1)
1670 .addReg(AVR::R1)
1671 .addReg(AVR::R1);
1672 return BB;
1673}
1674
1675MachineBasicBlock *
1676AVRTargetLowering::EmitInstrWithCustomInserter(MachineInstr &MI,
1677 MachineBasicBlock *MBB) const {
1678 int Opc = MI.getOpcode();
1679
1680 // Pseudo shift instructions with a non constant shift amount are expanded
1681 // into a loop.
1682 switch (Opc) {
1683 case AVR::Lsl8:
1684 case AVR::Lsl16:
1685 case AVR::Lsr8:
1686 case AVR::Lsr16:
1687 case AVR::Rol8:
1688 case AVR::Rol16:
1689 case AVR::Ror8:
1690 case AVR::Ror16:
1691 case AVR::Asr8:
1692 case AVR::Asr16:
1693 return insertShift(MI, MBB);
1694 case AVR::MULRdRr:
1695 case AVR::MULSRdRr:
1696 return insertMul(MI, MBB);
1697 }
1698
1699 assert((Opc == AVR::Select16 || Opc == AVR::Select8) &&(static_cast <bool> ((Opc == AVR::Select16 || Opc == AVR
::Select8) && "Unexpected instr type to insert") ? void
(0) : __assert_fail ("(Opc == AVR::Select16 || Opc == AVR::Select8) && \"Unexpected instr type to insert\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1700, __extension__ __PRETTY_FUNCTION__))
1700 "Unexpected instr type to insert")(static_cast <bool> ((Opc == AVR::Select16 || Opc == AVR
::Select8) && "Unexpected instr type to insert") ? void
(0) : __assert_fail ("(Opc == AVR::Select16 || Opc == AVR::Select8) && \"Unexpected instr type to insert\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/Target/AVR/AVRISelLowering.cpp"
, 1700, __extension__ __PRETTY_FUNCTION__))
;
1701
1702 const AVRInstrInfo &TII = (const AVRInstrInfo &)*MI.getParent()
1703 ->getParent()
1704 ->getSubtarget()
1705 .getInstrInfo();
1706 DebugLoc dl = MI.getDebugLoc();
1707
1708 // To "insert" a SELECT instruction, we insert the diamond
1709 // control-flow pattern. The incoming instruction knows the
1710 // destination vreg to set, the condition code register to branch
1711 // on, the true/false values to select between, and a branch opcode
1712 // to use.
1713
1714 MachineFunction *MF = MBB->getParent();
1715 const BasicBlock *LLVM_BB = MBB->getBasicBlock();
1716 MachineBasicBlock *FallThrough = MBB->getFallThrough();
1717
1718 // If the current basic block falls through to another basic block,
1719 // we must insert an unconditional branch to the fallthrough destination
1720 // if we are to insert basic blocks at the prior fallthrough point.
1721 if (FallThrough != nullptr) {
1722 BuildMI(MBB, dl, TII.get(AVR::RJMPk)).addMBB(FallThrough);
1723 }
1724
1725 MachineBasicBlock *trueMBB = MF->CreateMachineBasicBlock(LLVM_BB);
1726 MachineBasicBlock *falseMBB = MF->CreateMachineBasicBlock(LLVM_BB);
1727
1728 MachineFunction::iterator I;
1729 for (I = MF->begin(); I != MF->end() && &(*I) != MBB; ++I)
1730 ;
1731 if (I != MF->end())
1732 ++I;
1733 MF->insert(I, trueMBB);
1734 MF->insert(I, falseMBB);
1735
1736 // Transfer remaining instructions and all successors of the current
1737 // block to the block which will contain the Phi node for the
1738 // select.
1739 trueMBB->splice(trueMBB->begin(), MBB,
1740 std::next(MachineBasicBlock::iterator(MI)), MBB->end());
1741 trueMBB->transferSuccessorsAndUpdatePHIs(MBB);
1742
1743 AVRCC::CondCodes CC = (AVRCC::CondCodes)MI.getOperand(3).getImm();
1744 BuildMI(MBB, dl, TII.getBrCond(CC)).addMBB(trueMBB);
1745 BuildMI(MBB, dl, TII.get(AVR::RJMPk)).addMBB(falseMBB);
1746 MBB->addSuccessor(falseMBB);
1747 MBB->addSuccessor(trueMBB);
1748
1749 // Unconditionally flow back to the true block
1750 BuildMI(falseMBB, dl, TII.get(AVR::RJMPk)).addMBB(trueMBB);
1751 falseMBB->addSuccessor(trueMBB);
1752
1753 // Set up the Phi node to determine where we came from
1754 BuildMI(*trueMBB, trueMBB->begin(), dl, TII.get(AVR::PHI),
1755 MI.getOperand(0).getReg())
1756 .addReg(MI.getOperand(1).getReg())
1757 .addMBB(MBB)
1758 .addReg(MI.getOperand(2).getReg())
1759 .addMBB(falseMBB);
1760
1761 MI.eraseFromParent(); // The pseudo instruction is gone now.
1762 return trueMBB;
1763}
1764
1765//===----------------------------------------------------------------------===//
1766// Inline Asm Support
1767//===----------------------------------------------------------------------===//
1768
1769AVRTargetLowering::ConstraintType
1770AVRTargetLowering::getConstraintType(StringRef Constraint) const {
1771 if (Constraint.size() == 1) {
1772 // See http://www.nongnu.org/avr-libc/user-manual/inline_asm.html
1773 switch (Constraint[0]) {
1774 default:
1775 break;
1776 case 'a': // Simple upper registers
1777 case 'b': // Base pointer registers pairs
1778 case 'd': // Upper register
1779 case 'l': // Lower registers
1780 case 'e': // Pointer register pairs
1781 case 'q': // Stack pointer register
1782 case 'r': // Any register
1783 case 'w': // Special upper register pairs
1784 return C_RegisterClass;
1785 case 't': // Temporary register
1786 case 'x':
1787 case 'X': // Pointer register pair X
1788 case 'y':
1789 case 'Y': // Pointer register pair Y
1790 case 'z':
1791 case 'Z': // Pointer register pair Z
1792 return C_Register;
1793 case 'Q': // A memory address based on Y or Z pointer with displacement.
1794 return C_Memory;
1795 case 'G': // Floating point constant
1796 case 'I': // 6-bit positive integer constant
1797 case 'J': // 6-bit negative integer constant
1798 case 'K': // Integer constant (Range: 2)
1799 case 'L': // Integer constant (Range: 0)
1800 case 'M': // 8-bit integer constant
1801 case 'N': // Integer constant (Range: -1)
1802 case 'O': // Integer constant (Range: 8, 16, 24)
1803 case 'P': // Integer constant (Range: 1)
1804 case 'R': // Integer constant (Range: -6 to 5)x
1805 return C_Immediate;
1806 }
1807 }
1808
1809 return TargetLowering::getConstraintType(Constraint);
1810}
1811
1812unsigned
1813AVRTargetLowering::getInlineAsmMemConstraint(StringRef ConstraintCode) const {
1814 // Not sure if this is actually the right thing to do, but we got to do
1815 // *something* [agnat]
1816 switch (ConstraintCode[0]) {
1817 case 'Q':
1818 return InlineAsm::Constraint_Q;
1819 }
1820 return TargetLowering::getInlineAsmMemConstraint(ConstraintCode);
1821}
1822
1823AVRTargetLowering::ConstraintWeight
1824AVRTargetLowering::getSingleConstraintMatchWeight(
1825 AsmOperandInfo &info, const char *constraint) const {
1826 ConstraintWeight weight = CW_Invalid;
1827 Value *CallOperandVal = info.CallOperandVal;
1828
1829 // If we don't have a value, we can't do a match,
1830 // but allow it at the lowest weight.
1831 // (this behaviour has been copied from the ARM backend)
1832 if (!CallOperandVal) {
1833 return CW_Default;
1834 }
1835
1836 // Look at the constraint type.
1837 switch (*constraint) {
1838 default:
1839 weight = TargetLowering::getSingleConstraintMatchWeight(info, constraint);
1840 break;
1841 case 'd':
1842 case 'r':
1843 case 'l':
1844 weight = CW_Register;
1845 break;
1846 case 'a':
1847 case 'b':
1848 case 'e':
1849 case 'q':
1850 case 't':
1851 case 'w':
1852 case 'x':
1853 case 'X':
1854 case 'y':
1855 case 'Y':
1856 case 'z':
1857 case 'Z':
1858 weight = CW_SpecificReg;
1859 break;
1860 case 'G':
1861 if (const ConstantFP *C = dyn_cast<ConstantFP>(CallOperandVal)) {
1862 if (C->isZero()) {
1863 weight = CW_Constant;
1864 }
1865 }
1866 break;
1867 case 'I':
1868 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1869 if (isUInt<6>(C->getZExtValue())) {
1870 weight = CW_Constant;
1871 }
1872 }
1873 break;
1874 case 'J':
1875 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1876 if ((C->getSExtValue() >= -63) && (C->getSExtValue() <= 0)) {
1877 weight = CW_Constant;
1878 }
1879 }
1880 break;
1881 case 'K':
1882 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1883 if (C->getZExtValue() == 2) {
1884 weight = CW_Constant;
1885 }
1886 }
1887 break;
1888 case 'L':
1889 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1890 if (C->getZExtValue() == 0) {
1891 weight = CW_Constant;
1892 }
1893 }
1894 break;
1895 case 'M':
1896 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1897 if (isUInt<8>(C->getZExtValue())) {
1898 weight = CW_Constant;
1899 }
1900 }
1901 break;
1902 case 'N':
1903 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1904 if (C->getSExtValue() == -1) {
1905 weight = CW_Constant;
1906 }
1907 }
1908 break;
1909 case 'O':
1910 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1911 if ((C->getZExtValue() == 8) || (C->getZExtValue() == 16) ||
1912 (C->getZExtValue() == 24)) {
1913 weight = CW_Constant;
1914 }
1915 }
1916 break;
1917 case 'P':
1918 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1919 if (C->getZExtValue() == 1) {
1920 weight = CW_Constant;
1921 }
1922 }
1923 break;
1924 case 'R':
1925 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1926 if ((C->getSExtValue() >= -6) && (C->getSExtValue() <= 5)) {
1927 weight = CW_Constant;
1928 }
1929 }
1930 break;
1931 case 'Q':
1932 weight = CW_Memory;
1933 break;
1934 }
1935
1936 return weight;
1937}
1938
1939std::pair<unsigned, const TargetRegisterClass *>
1940AVRTargetLowering::getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI,
1941 StringRef Constraint,
1942 MVT VT) const {
1943 if (Constraint.size() == 1) {
1944 switch (Constraint[0]) {
1945 case 'a': // Simple upper registers r16..r23.
1946 if (VT == MVT::i8)
1947 return std::make_pair(0U, &AVR::LD8loRegClass);
1948 else if (VT == MVT::i16)
1949 return std::make_pair(0U, &AVR::DREGSLD8loRegClass);
1950 break;
1951 case 'b': // Base pointer registers: y, z.
1952 if (VT == MVT::i8 || VT == MVT::i16)
1953 return std::make_pair(0U, &AVR::PTRDISPREGSRegClass);
1954 break;
1955 case 'd': // Upper registers r16..r31.
1956 if (VT == MVT::i8)
1957 return std::make_pair(0U, &AVR::LD8RegClass);
1958 else if (VT == MVT::i16)
1959 return std::make_pair(0U, &AVR::DLDREGSRegClass);
1960 break;
1961 case 'l': // Lower registers r0..r15.
1962 if (VT == MVT::i8)
1963 return std::make_pair(0U, &AVR::GPR8loRegClass);
1964 else if (VT == MVT::i16)
1965 return std::make_pair(0U, &AVR::DREGSloRegClass);
1966 break;
1967 case 'e': // Pointer register pairs: x, y, z.
1968 if (VT == MVT::i8 || VT == MVT::i16)
1969 return std::make_pair(0U, &AVR::PTRREGSRegClass);
1970 break;
1971 case 'q': // Stack pointer register: SPH:SPL.
1972 return std::make_pair(0U, &AVR::GPRSPRegClass);
1973 case 'r': // Any register: r0..r31.
1974 if (VT == MVT::i8)
1975 return std::make_pair(0U, &AVR::GPR8RegClass);
1976 else if (VT == MVT::i16)
1977 return std::make_pair(0U, &AVR::DREGSRegClass);
1978 break;
1979 case 't': // Temporary register: r0.
1980 if (VT == MVT::i8)
1981 return std::make_pair(unsigned(AVR::R0), &AVR::GPR8RegClass);
1982 break;
1983 case 'w': // Special upper register pairs: r24, r26, r28, r30.
1984 if (VT == MVT::i8 || VT == MVT::i16)
1985 return std::make_pair(0U, &AVR::IWREGSRegClass);
1986 break;
1987 case 'x': // Pointer register pair X: r27:r26.
1988 case 'X':
1989 if (VT == MVT::i8 || VT == MVT::i16)
1990 return std::make_pair(unsigned(AVR::R27R26), &AVR::PTRREGSRegClass);
1991 break;
1992 case 'y': // Pointer register pair Y: r29:r28.
1993 case 'Y':
1994 if (VT == MVT::i8 || VT == MVT::i16)
1995 return std::make_pair(unsigned(AVR::R29R28), &AVR::PTRREGSRegClass);
1996 break;
1997 case 'z': // Pointer register pair Z: r31:r30.
1998 case 'Z':
1999 if (VT == MVT::i8 || VT == MVT::i16)
2000 return std::make_pair(unsigned(AVR::R31R30), &AVR::PTRREGSRegClass);
2001 break;
2002 default:
2003 break;
2004 }
2005 }
2006
2007 return TargetLowering::getRegForInlineAsmConstraint(
2008 Subtarget.getRegisterInfo(), Constraint, VT);
2009}
2010
2011void AVRTargetLowering::LowerAsmOperandForConstraint(SDValue Op,
2012 std::string &Constraint,
2013 std::vector<SDValue> &Ops,
2014 SelectionDAG &DAG) const {
2015 SDValue Result(0, 0);
2016 SDLoc DL(Op);
2017 EVT Ty = Op.getValueType();
2018
2019 // Currently only support length 1 constraints.
2020 if (Constraint.length() != 1) {
2021 return;
2022 }
2023
2024 char ConstraintLetter = Constraint[0];
2025 switch (ConstraintLetter) {
2026 default:
2027 break;
2028 // Deal with integers first:
2029 case 'I':
2030 case 'J':
2031 case 'K':
2032 case 'L':
2033 case 'M':
2034 case 'N':
2035 case 'O':
2036 case 'P':
2037 case 'R': {
2038 const ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op);
2039 if (!C) {
2040 return;
2041 }
2042
2043 int64_t CVal64 = C->getSExtValue();
2044 uint64_t CUVal64 = C->getZExtValue();
2045 switch (ConstraintLetter) {
2046 case 'I': // 0..63
2047 if (!isUInt<6>(CUVal64))
2048 return;
2049 Result = DAG.getTargetConstant(CUVal64, DL, Ty);
2050 break;
2051 case 'J': // -63..0
2052 if (CVal64 < -63 || CVal64 > 0)
2053 return;
2054 Result = DAG.getTargetConstant(CVal64, DL, Ty);
2055 break;
2056 case 'K': // 2
2057 if (CUVal64 != 2)
2058 return;
2059 Result = DAG.getTargetConstant(CUVal64, DL, Ty);
2060 break;
2061 case 'L': // 0
2062 if (CUVal64 != 0)
2063 return;
2064 Result = DAG.getTargetConstant(CUVal64, DL, Ty);
2065 break;
2066 case 'M': // 0..255
2067 if (!isUInt<8>(CUVal64))
2068 return;
2069 // i8 type may be printed as a negative number,
2070 // e.g. 254 would be printed as -2,
2071 // so we force it to i16 at least.
2072 if (Ty.getSimpleVT() == MVT::i8) {
2073 Ty = MVT::i16;
2074 }
2075 Result = DAG.getTargetConstant(CUVal64, DL, Ty);
2076 break;
2077 case 'N': // -1
2078 if (CVal64 != -1)
2079 return;
2080 Result = DAG.getTargetConstant(CVal64, DL, Ty);
2081 break;
2082 case 'O': // 8, 16, 24
2083 if (CUVal64 != 8 && CUVal64 != 16 && CUVal64 != 24)
2084 return;
2085 Result = DAG.getTargetConstant(CUVal64, DL, Ty);
2086 break;
2087 case 'P': // 1
2088 if (CUVal64 != 1)
2089 return;
2090 Result = DAG.getTargetConstant(CUVal64, DL, Ty);
2091 break;
2092 case 'R': // -6..5
2093 if (CVal64 < -6 || CVal64 > 5)
2094 return;
2095 Result = DAG.getTargetConstant(CVal64, DL, Ty);
2096 break;
2097 }
2098
2099 break;
2100 }
2101 case 'G':
2102 const ConstantFPSDNode *FC = dyn_cast<ConstantFPSDNode>(Op);
2103 if (!FC || !FC->isZero())
2104 return;
2105 // Soften float to i8 0
2106 Result = DAG.getTargetConstant(0, DL, MVT::i8);
2107 break;
2108 }
2109
2110 if (Result.getNode()) {
2111 Ops.push_back(Result);
2112 return;
2113 }
2114
2115 return TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
2116}
2117
2118Register AVRTargetLowering::getRegisterByName(const char *RegName, LLT VT,
2119 const MachineFunction &MF) const {
2120 Register Reg;
2121
2122 if (VT == LLT::scalar(8)) {
2123 Reg = StringSwitch<unsigned>(RegName)
2124 .Case("r0", AVR::R0)
2125 .Case("r1", AVR::R1)
2126 .Default(0);
2127 } else {
2128 Reg = StringSwitch<unsigned>(RegName)
2129 .Case("r0", AVR::R1R0)
2130 .Case("sp", AVR::SP)
2131 .Default(0);
2132 }
2133
2134 if (Reg)
2135 return Reg;
2136
2137 report_fatal_error(
2138 Twine("Invalid register name \"" + StringRef(RegName) + "\"."));
2139}
2140
2141} // end of namespace llvm

/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h

1//===- Support/MachineValueType.h - Machine-Level types ---------*- C++ -*-===//
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// This file defines the set of machine-level target independent types which
10// legal values in the code generator use.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_SUPPORT_MACHINEVALUETYPE_H
15#define LLVM_SUPPORT_MACHINEVALUETYPE_H
16
17#include "llvm/ADT/Sequence.h"
18#include "llvm/ADT/iterator_range.h"
19#include "llvm/Support/ErrorHandling.h"
20#include "llvm/Support/MathExtras.h"
21#include "llvm/Support/TypeSize.h"
22#include <cassert>
23
24namespace llvm {
25
26 class Type;
27
28 /// Machine Value Type. Every type that is supported natively by some
29 /// processor targeted by LLVM occurs here. This means that any legal value
30 /// type can be represented by an MVT.
31 class MVT {
32 public:
33 enum SimpleValueType : uint8_t {
34 // clang-format off
35
36 // Simple value types that aren't explicitly part of this enumeration
37 // are considered extended value types.
38 INVALID_SIMPLE_VALUE_TYPE = 0,
39
40 // If you change this numbering, you must change the values in
41 // ValueTypes.td as well!
42 Other = 1, // This is a non-standard value
43 i1 = 2, // This is a 1 bit integer value
44 i8 = 3, // This is an 8 bit integer value
45 i16 = 4, // This is a 16 bit integer value
46 i32 = 5, // This is a 32 bit integer value
47 i64 = 6, // This is a 64 bit integer value
48 i128 = 7, // This is a 128 bit integer value
49
50 FIRST_INTEGER_VALUETYPE = i1,
51 LAST_INTEGER_VALUETYPE = i128,
52
53 bf16 = 8, // This is a 16 bit brain floating point value
54 f16 = 9, // This is a 16 bit floating point value
55 f32 = 10, // This is a 32 bit floating point value
56 f64 = 11, // This is a 64 bit floating point value
57 f80 = 12, // This is a 80 bit floating point value
58 f128 = 13, // This is a 128 bit floating point value
59 ppcf128 = 14, // This is a PPC 128-bit floating point value
60
61 FIRST_FP_VALUETYPE = bf16,
62 LAST_FP_VALUETYPE = ppcf128,
63
64 v1i1 = 15, // 1 x i1
65 v2i1 = 16, // 2 x i1
66 v4i1 = 17, // 4 x i1
67 v8i1 = 18, // 8 x i1
68 v16i1 = 19, // 16 x i1
69 v32i1 = 20, // 32 x i1
70 v64i1 = 21, // 64 x i1
71 v128i1 = 22, // 128 x i1
72 v256i1 = 23, // 256 x i1
73 v512i1 = 24, // 512 x i1
74 v1024i1 = 25, // 1024 x i1
75
76 v1i8 = 26, // 1 x i8
77 v2i8 = 27, // 2 x i8
78 v4i8 = 28, // 4 x i8
79 v8i8 = 29, // 8 x i8
80 v16i8 = 30, // 16 x i8
81 v32i8 = 31, // 32 x i8
82 v64i8 = 32, // 64 x i8
83 v128i8 = 33, // 128 x i8
84 v256i8 = 34, // 256 x i8
85 v512i8 = 35, // 512 x i8
86 v1024i8 = 36, // 1024 x i8
87
88 v1i16 = 37, // 1 x i16
89 v2i16 = 38, // 2 x i16
90 v3i16 = 39, // 3 x i16
91 v4i16 = 40, // 4 x i16
92 v8i16 = 41, // 8 x i16
93 v16i16 = 42, // 16 x i16
94 v32i16 = 43, // 32 x i16
95 v64i16 = 44, // 64 x i16
96 v128i16 = 45, // 128 x i16
97 v256i16 = 46, // 256 x i16
98 v512i16 = 47, // 512 x i16
99
100 v1i32 = 48, // 1 x i32
101 v2i32 = 49, // 2 x i32
102 v3i32 = 50, // 3 x i32
103 v4i32 = 51, // 4 x i32
104 v5i32 = 52, // 5 x i32
105 v6i32 = 53, // 6 x i32
106 v7i32 = 54, // 7 x i32
107 v8i32 = 55, // 8 x i32
108 v16i32 = 56, // 16 x i32
109 v32i32 = 57, // 32 x i32
110 v64i32 = 58, // 64 x i32
111 v128i32 = 59, // 128 x i32
112 v256i32 = 60, // 256 x i32
113 v512i32 = 61, // 512 x i32
114 v1024i32 = 62, // 1024 x i32
115 v2048i32 = 63, // 2048 x i32
116
117 v1i64 = 64, // 1 x i64
118 v2i64 = 65, // 2 x i64
119 v3i64 = 66, // 3 x i64
120 v4i64 = 67, // 4 x i64
121 v8i64 = 68, // 8 x i64
122 v16i64 = 69, // 16 x i64
123 v32i64 = 70, // 32 x i64
124 v64i64 = 71, // 64 x i64
125 v128i64 = 72, // 128 x i64
126 v256i64 = 73, // 256 x i64
127
128 v1i128 = 74, // 1 x i128
129
130 FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE = v1i1,
131 LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE = v1i128,
132
133 v1f16 = 75, // 1 x f16
134 v2f16 = 76, // 2 x f16
135 v3f16 = 77, // 3 x f16
136 v4f16 = 78, // 4 x f16
137 v8f16 = 79, // 8 x f16
138 v16f16 = 80, // 16 x f16
139 v32f16 = 81, // 32 x f16
140 v64f16 = 82, // 64 x f16
141 v128f16 = 83, // 128 x f16
142 v256f16 = 84, // 256 x f16
143 v512f16 = 85, // 256 x f16
144
145 v2bf16 = 86, // 2 x bf16
146 v3bf16 = 87, // 3 x bf16
147 v4bf16 = 88, // 4 x bf16
148 v8bf16 = 89, // 8 x bf16
149 v16bf16 = 90, // 16 x bf16
150 v32bf16 = 91, // 32 x bf16
151 v64bf16 = 92, // 64 x bf16
152 v128bf16 = 93, // 128 x bf16
153
154 v1f32 = 94, // 1 x f32
155 v2f32 = 95, // 2 x f32
156 v3f32 = 96, // 3 x f32
157 v4f32 = 97, // 4 x f32
158 v5f32 = 98, // 5 x f32
159 v6f32 = 99, // 6 x f32
160 v7f32 = 100, // 7 x f32
161 v8f32 = 101, // 8 x f32
162 v16f32 = 102, // 16 x f32
163 v32f32 = 103, // 32 x f32
164 v64f32 = 104, // 64 x f32
165 v128f32 = 105, // 128 x f32
166 v256f32 = 106, // 256 x f32
167 v512f32 = 107, // 512 x f32
168 v1024f32 = 108, // 1024 x f32
169 v2048f32 = 109, // 2048 x f32
170
171 v1f64 = 110, // 1 x f64
172 v2f64 = 111, // 2 x f64
173 v3f64 = 112, // 3 x f64
174 v4f64 = 113, // 4 x f64
175 v8f64 = 114, // 8 x f64
176 v16f64 = 115, // 16 x f64
177 v32f64 = 116, // 32 x f64
178 v64f64 = 117, // 64 x f64
179 v128f64 = 118, // 128 x f64
180 v256f64 = 119, // 256 x f64
181
182 FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE = v1f16,
183 LAST_FP_FIXEDLEN_VECTOR_VALUETYPE = v256f64,
184
185 FIRST_FIXEDLEN_VECTOR_VALUETYPE = v1i1,
186 LAST_FIXEDLEN_VECTOR_VALUETYPE = v256f64,
187
188 nxv1i1 = 120, // n x 1 x i1
189 nxv2i1 = 121, // n x 2 x i1
190 nxv4i1 = 122, // n x 4 x i1
191 nxv8i1 = 123, // n x 8 x i1
192 nxv16i1 = 124, // n x 16 x i1
193 nxv32i1 = 125, // n x 32 x i1
194 nxv64i1 = 126, // n x 64 x i1
195
196 nxv1i8 = 127, // n x 1 x i8
197 nxv2i8 = 128, // n x 2 x i8
198 nxv4i8 = 129, // n x 4 x i8
199 nxv8i8 = 130, // n x 8 x i8
200 nxv16i8 = 131, // n x 16 x i8
201 nxv32i8 = 132, // n x 32 x i8
202 nxv64i8 = 133, // n x 64 x i8
203
204 nxv1i16 = 134, // n x 1 x i16
205 nxv2i16 = 135, // n x 2 x i16
206 nxv4i16 = 136, // n x 4 x i16
207 nxv8i16 = 137, // n x 8 x i16
208 nxv16i16 = 138, // n x 16 x i16
209 nxv32i16 = 139, // n x 32 x i16
210
211 nxv1i32 = 140, // n x 1 x i32
212 nxv2i32 = 141, // n x 2 x i32
213 nxv4i32 = 142, // n x 4 x i32
214 nxv8i32 = 143, // n x 8 x i32
215 nxv16i32 = 144, // n x 16 x i32
216 nxv32i32 = 145, // n x 32 x i32
217
218 nxv1i64 = 146, // n x 1 x i64
219 nxv2i64 = 147, // n x 2 x i64
220 nxv4i64 = 148, // n x 4 x i64
221 nxv8i64 = 149, // n x 8 x i64
222 nxv16i64 = 150, // n x 16 x i64
223 nxv32i64 = 151, // n x 32 x i64
224
225 FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE = nxv1i1,
226 LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE = nxv32i64,
227
228 nxv1f16 = 152, // n x 1 x f16
229 nxv2f16 = 153, // n x 2 x f16
230 nxv4f16 = 154, // n x 4 x f16
231 nxv8f16 = 155, // n x 8 x f16
232 nxv16f16 = 156, // n x 16 x f16
233 nxv32f16 = 157, // n x 32 x f16
234
235 nxv1bf16 = 158, // n x 1 x bf16
236 nxv2bf16 = 159, // n x 2 x bf16
237 nxv4bf16 = 160, // n x 4 x bf16
238 nxv8bf16 = 161, // n x 8 x bf16
239
240 nxv1f32 = 162, // n x 1 x f32
241 nxv2f32 = 163, // n x 2 x f32
242 nxv4f32 = 164, // n x 4 x f32
243 nxv8f32 = 165, // n x 8 x f32
244 nxv16f32 = 166, // n x 16 x f32
245
246 nxv1f64 = 167, // n x 1 x f64
247 nxv2f64 = 168, // n x 2 x f64
248 nxv4f64 = 169, // n x 4 x f64
249 nxv8f64 = 170, // n x 8 x f64
250
251 FIRST_FP_SCALABLE_VECTOR_VALUETYPE = nxv1f16,
252 LAST_FP_SCALABLE_VECTOR_VALUETYPE = nxv8f64,
253
254 FIRST_SCALABLE_VECTOR_VALUETYPE = nxv1i1,
255 LAST_SCALABLE_VECTOR_VALUETYPE = nxv8f64,
256
257 FIRST_VECTOR_VALUETYPE = v1i1,
258 LAST_VECTOR_VALUETYPE = nxv8f64,
259
260 x86mmx = 171, // This is an X86 MMX value
261
262 Glue = 172, // This glues nodes together during pre-RA sched
263
264 isVoid = 173, // This has no value
265
266 Untyped = 174, // This value takes a register, but has
267 // unspecified type. The register class
268 // will be determined by the opcode.
269
270 funcref = 175, // WebAssembly's funcref type
271 externref = 176, // WebAssembly's externref type
272 x86amx = 177, // This is an X86 AMX value
273 i64x8 = 178, // 8 Consecutive GPRs (AArch64)
274
275 FIRST_VALUETYPE = 1, // This is always the beginning of the list.
276 LAST_VALUETYPE = i64x8, // This always remains at the end of the list.
277 VALUETYPE_SIZE = LAST_VALUETYPE + 1,
278
279 // This is the current maximum for LAST_VALUETYPE.
280 // MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors
281 // This value must be a multiple of 32.
282 MAX_ALLOWED_VALUETYPE = 192,
283
284 // A value of type llvm::TokenTy
285 token = 248,
286
287 // This is MDNode or MDString.
288 Metadata = 249,
289
290 // An int value the size of the pointer of the current
291 // target to any address space. This must only be used internal to
292 // tblgen. Other than for overloading, we treat iPTRAny the same as iPTR.
293 iPTRAny = 250,
294
295 // A vector with any length and element size. This is used
296 // for intrinsics that have overloadings based on vector types.
297 // This is only for tblgen's consumption!
298 vAny = 251,
299
300 // Any floating-point or vector floating-point value. This is used
301 // for intrinsics that have overloadings based on floating-point types.
302 // This is only for tblgen's consumption!
303 fAny = 252,
304
305 // An integer or vector integer value of any bit width. This is
306 // used for intrinsics that have overloadings based on integer bit widths.
307 // This is only for tblgen's consumption!
308 iAny = 253,
309
310 // An int value the size of the pointer of the current
311 // target. This should only be used internal to tblgen!
312 iPTR = 254,
313
314 // Any type. This is used for intrinsics that have overloadings.
315 // This is only for tblgen's consumption!
316 Any = 255
317
318 // clang-format on
319 };
320
321 SimpleValueType SimpleTy = INVALID_SIMPLE_VALUE_TYPE;
322
323 constexpr MVT() = default;
324 constexpr MVT(SimpleValueType SVT) : SimpleTy(SVT) {}
325
326 bool operator>(const MVT& S) const { return SimpleTy > S.SimpleTy; }
327 bool operator<(const MVT& S) const { return SimpleTy < S.SimpleTy; }
328 bool operator==(const MVT& S) const { return SimpleTy == S.SimpleTy; }
10
Assuming 'SimpleTy' is equal to 'S.SimpleTy'
11
Returning the value 1, which participates in a condition later
329 bool operator!=(const MVT& S) const { return SimpleTy != S.SimpleTy; }
330 bool operator>=(const MVT& S) const { return SimpleTy >= S.SimpleTy; }
331 bool operator<=(const MVT& S) const { return SimpleTy <= S.SimpleTy; }
332
333 /// Return true if this is a valid simple valuetype.
334 bool isValid() const {
335 return (SimpleTy >= MVT::FIRST_VALUETYPE &&
336 SimpleTy <= MVT::LAST_VALUETYPE);
337 }
338
339 /// Return true if this is a FP or a vector FP type.
340 bool isFloatingPoint() const {
341 return ((SimpleTy >= MVT::FIRST_FP_VALUETYPE &&
342 SimpleTy <= MVT::LAST_FP_VALUETYPE) ||
343 (SimpleTy >= MVT::FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE &&
344 SimpleTy <= MVT::LAST_FP_FIXEDLEN_VECTOR_VALUETYPE) ||
345 (SimpleTy >= MVT::FIRST_FP_SCALABLE_VECTOR_VALUETYPE &&
346 SimpleTy <= MVT::LAST_FP_SCALABLE_VECTOR_VALUETYPE));
347 }
348
349 /// Return true if this is an integer or a vector integer type.
350 bool isInteger() const {
351 return ((SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE &&
352 SimpleTy <= MVT::LAST_INTEGER_VALUETYPE) ||
353 (SimpleTy >= MVT::FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE &&
354 SimpleTy <= MVT::LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE) ||
355 (SimpleTy >= MVT::FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE &&
356 SimpleTy <= MVT::LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE));
357 }
358
359 /// Return true if this is an integer, not including vectors.
360 bool isScalarInteger() const {
361 return (SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE &&
362 SimpleTy <= MVT::LAST_INTEGER_VALUETYPE);
363 }
364
365 /// Return true if this is a vector value type.
366 bool isVector() const {
367 return (SimpleTy >= MVT::FIRST_VECTOR_VALUETYPE &&
368 SimpleTy <= MVT::LAST_VECTOR_VALUETYPE);
369 }
370
371 /// Return true if this is a vector value type where the
372 /// runtime length is machine dependent
373 bool isScalableVector() const {
374 return (SimpleTy >= MVT::FIRST_SCALABLE_VECTOR_VALUETYPE &&
375 SimpleTy <= MVT::LAST_SCALABLE_VECTOR_VALUETYPE);
376 }
377
378 bool isFixedLengthVector() const {
379 return (SimpleTy >= MVT::FIRST_FIXEDLEN_VECTOR_VALUETYPE &&
380 SimpleTy <= MVT::LAST_FIXEDLEN_VECTOR_VALUETYPE);
381 }
382
383 /// Return true if this is a 16-bit vector type.
384 bool is16BitVector() const {
385 return (SimpleTy == MVT::v2i8 || SimpleTy == MVT::v1i16 ||
386 SimpleTy == MVT::v16i1 || SimpleTy == MVT::v1f16);
387 }
388
389 /// Return true if this is a 32-bit vector type.
390 bool is32BitVector() const {
391 return (SimpleTy == MVT::v32i1 || SimpleTy == MVT::v4i8 ||
392 SimpleTy == MVT::v2i16 || SimpleTy == MVT::v1i32 ||
393 SimpleTy == MVT::v2f16 || SimpleTy == MVT::v2bf16 ||
394 SimpleTy == MVT::v1f32);
395 }
396
397 /// Return true if this is a 64-bit vector type.
398 bool is64BitVector() const {
399 return (SimpleTy == MVT::v64i1 || SimpleTy == MVT::v8i8 ||
400 SimpleTy == MVT::v4i16 || SimpleTy == MVT::v2i32 ||
401 SimpleTy == MVT::v1i64 || SimpleTy == MVT::v4f16 ||
402 SimpleTy == MVT::v4bf16 ||SimpleTy == MVT::v2f32 ||
403 SimpleTy == MVT::v1f64);
404 }
405
406 /// Return true if this is a 128-bit vector type.
407 bool is128BitVector() const {
408 return (SimpleTy == MVT::v128i1 || SimpleTy == MVT::v16i8 ||
409 SimpleTy == MVT::v8i16 || SimpleTy == MVT::v4i32 ||
410 SimpleTy == MVT::v2i64 || SimpleTy == MVT::v1i128 ||
411 SimpleTy == MVT::v8f16 || SimpleTy == MVT::v8bf16 ||
412 SimpleTy == MVT::v4f32 || SimpleTy == MVT::v2f64);
413 }
414
415 /// Return true if this is a 256-bit vector type.
416 bool is256BitVector() const {
417 return (SimpleTy == MVT::v16f16 || SimpleTy == MVT::v16bf16 ||
418 SimpleTy == MVT::v8f32 || SimpleTy == MVT::v4f64 ||
419 SimpleTy == MVT::v32i8 || SimpleTy == MVT::v16i16 ||
420 SimpleTy == MVT::v8i32 || SimpleTy == MVT::v4i64 ||
421 SimpleTy == MVT::v256i1);
422 }
423
424 /// Return true if this is a 512-bit vector type.
425 bool is512BitVector() const {
426 return (SimpleTy == MVT::v32f16 || SimpleTy == MVT::v32bf16 ||
427 SimpleTy == MVT::v16f32 || SimpleTy == MVT::v8f64 ||
428 SimpleTy == MVT::v512i1 || SimpleTy == MVT::v64i8 ||
429 SimpleTy == MVT::v32i16 || SimpleTy == MVT::v16i32 ||
430 SimpleTy == MVT::v8i64);
431 }
432
433 /// Return true if this is a 1024-bit vector type.
434 bool is1024BitVector() const {
435 return (SimpleTy == MVT::v1024i1 || SimpleTy == MVT::v128i8 ||
436 SimpleTy == MVT::v64i16 || SimpleTy == MVT::v32i32 ||
437 SimpleTy == MVT::v16i64 || SimpleTy == MVT::v64f16 ||
438 SimpleTy == MVT::v32f32 || SimpleTy == MVT::v16f64 ||
439 SimpleTy == MVT::v64bf16);
440 }
441
442 /// Return true if this is a 2048-bit vector type.
443 bool is2048BitVector() const {
444 return (SimpleTy == MVT::v256i8 || SimpleTy == MVT::v128i16 ||
445 SimpleTy == MVT::v64i32 || SimpleTy == MVT::v32i64 ||
446 SimpleTy == MVT::v128f16 || SimpleTy == MVT::v64f32 ||
447 SimpleTy == MVT::v32f64 || SimpleTy == MVT::v128bf16);
448 }
449
450 /// Return true if this is an overloaded type for TableGen.
451 bool isOverloaded() const {
452 return (SimpleTy == MVT::Any || SimpleTy == MVT::iAny ||
453 SimpleTy == MVT::fAny || SimpleTy == MVT::vAny ||
454 SimpleTy == MVT::iPTRAny);
455 }
456
457 /// Return a vector with the same number of elements as this vector, but
458 /// with the element type converted to an integer type with the same
459 /// bitwidth.
460 MVT changeVectorElementTypeToInteger() const {
461 MVT EltTy = getVectorElementType();
462 MVT IntTy = MVT::getIntegerVT(EltTy.getSizeInBits());
463 MVT VecTy = MVT::getVectorVT(IntTy, getVectorElementCount());
464 assert(VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE &&(static_cast <bool> (VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE
&& "Simple vector VT not representable by simple integer vector VT!"
) ? void (0) : __assert_fail ("VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE && \"Simple vector VT not representable by simple integer vector VT!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 465, __extension__ __PRETTY_FUNCTION__))
465 "Simple vector VT not representable by simple integer vector VT!")(static_cast <bool> (VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE
&& "Simple vector VT not representable by simple integer vector VT!"
) ? void (0) : __assert_fail ("VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE && \"Simple vector VT not representable by simple integer vector VT!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 465, __extension__ __PRETTY_FUNCTION__))
;
466 return VecTy;
467 }
468
469 /// Return a VT for a vector type whose attributes match ourselves
470 /// with the exception of the element type that is chosen by the caller.
471 MVT changeVectorElementType(MVT EltVT) const {
472 MVT VecTy = MVT::getVectorVT(EltVT, getVectorElementCount());
473 assert(VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE &&(static_cast <bool> (VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE
&& "Simple vector VT not representable by simple integer vector VT!"
) ? void (0) : __assert_fail ("VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE && \"Simple vector VT not representable by simple integer vector VT!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 474, __extension__ __PRETTY_FUNCTION__))
474 "Simple vector VT not representable by simple integer vector VT!")(static_cast <bool> (VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE
&& "Simple vector VT not representable by simple integer vector VT!"
) ? void (0) : __assert_fail ("VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE && \"Simple vector VT not representable by simple integer vector VT!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 474, __extension__ __PRETTY_FUNCTION__))
;
475 return VecTy;
476 }
477
478 /// Return the type converted to an equivalently sized integer or vector
479 /// with integer element type. Similar to changeVectorElementTypeToInteger,
480 /// but also handles scalars.
481 MVT changeTypeToInteger() {
482 if (isVector())
483 return changeVectorElementTypeToInteger();
484 return MVT::getIntegerVT(getSizeInBits());
485 }
486
487 /// Return a VT for a vector type with the same element type but
488 /// half the number of elements.
489 MVT getHalfNumVectorElementsVT() const {
490 MVT EltVT = getVectorElementType();
491 auto EltCnt = getVectorElementCount();
492 assert(EltCnt.isKnownEven() && "Splitting vector, but not in half!")(static_cast <bool> (EltCnt.isKnownEven() && "Splitting vector, but not in half!"
) ? void (0) : __assert_fail ("EltCnt.isKnownEven() && \"Splitting vector, but not in half!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 492, __extension__ __PRETTY_FUNCTION__))
;
493 return getVectorVT(EltVT, EltCnt.divideCoefficientBy(2));
494 }
495
496 /// Returns true if the given vector is a power of 2.
497 bool isPow2VectorType() const {
498 unsigned NElts = getVectorMinNumElements();
499 return !(NElts & (NElts - 1));
500 }
501
502 /// Widens the length of the given vector MVT up to the nearest power of 2
503 /// and returns that type.
504 MVT getPow2VectorType() const {
505 if (isPow2VectorType())
506 return *this;
507
508 ElementCount NElts = getVectorElementCount();
509 unsigned NewMinCount = 1 << Log2_32_Ceil(NElts.getKnownMinValue());
510 NElts = ElementCount::get(NewMinCount, NElts.isScalable());
511 return MVT::getVectorVT(getVectorElementType(), NElts);
512 }
513
514 /// If this is a vector, return the element type, otherwise return this.
515 MVT getScalarType() const {
516 return isVector() ? getVectorElementType() : *this;
517 }
518
519 MVT getVectorElementType() const {
520 switch (SimpleTy) {
521 default:
522 llvm_unreachable("Not a vector MVT!")::llvm::llvm_unreachable_internal("Not a vector MVT!", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 522)
;
523 case v1i1:
524 case v2i1:
525 case v4i1:
526 case v8i1:
527 case v16i1:
528 case v32i1:
529 case v64i1:
530 case v128i1:
531 case v256i1:
532 case v512i1:
533 case v1024i1:
534 case nxv1i1:
535 case nxv2i1:
536 case nxv4i1:
537 case nxv8i1:
538 case nxv16i1:
539 case nxv32i1:
540 case nxv64i1: return i1;
541 case v1i8:
542 case v2i8:
543 case v4i8:
544 case v8i8:
545 case v16i8:
546 case v32i8:
547 case v64i8:
548 case v128i8:
549 case v256i8:
550 case v512i8:
551 case v1024i8:
552 case nxv1i8:
553 case nxv2i8:
554 case nxv4i8:
555 case nxv8i8:
556 case nxv16i8:
557 case nxv32i8:
558 case nxv64i8: return i8;
559 case v1i16:
560 case v2i16:
561 case v3i16:
562 case v4i16:
563 case v8i16:
564 case v16i16:
565 case v32i16:
566 case v64i16:
567 case v128i16:
568 case v256i16:
569 case v512i16:
570 case nxv1i16:
571 case nxv2i16:
572 case nxv4i16:
573 case nxv8i16:
574 case nxv16i16:
575 case nxv32i16: return i16;
576 case v1i32:
577 case v2i32:
578 case v3i32:
579 case v4i32:
580 case v5i32:
581 case v6i32:
582 case v7i32:
583 case v8i32:
584 case v16i32:
585 case v32i32:
586 case v64i32:
587 case v128i32:
588 case v256i32:
589 case v512i32:
590 case v1024i32:
591 case v2048i32:
592 case nxv1i32:
593 case nxv2i32:
594 case nxv4i32:
595 case nxv8i32:
596 case nxv16i32:
597 case nxv32i32: return i32;
598 case v1i64:
599 case v2i64:
600 case v3i64:
601 case v4i64:
602 case v8i64:
603 case v16i64:
604 case v32i64:
605 case v64i64:
606 case v128i64:
607 case v256i64:
608 case nxv1i64:
609 case nxv2i64:
610 case nxv4i64:
611 case nxv8i64:
612 case nxv16i64:
613 case nxv32i64: return i64;
614 case v1i128: return i128;
615 case v1f16:
616 case v2f16:
617 case v3f16:
618 case v4f16:
619 case v8f16:
620 case v16f16:
621 case v32f16:
622 case v64f16:
623 case v128f16:
624 case v256f16:
625 case v512f16:
626 case nxv1f16:
627 case nxv2f16:
628 case nxv4f16:
629 case nxv8f16:
630 case nxv16f16:
631 case nxv32f16: return f16;
632 case v2bf16:
633 case v3bf16:
634 case v4bf16:
635 case v8bf16:
636 case v16bf16:
637 case v32bf16:
638 case v64bf16:
639 case v128bf16:
640 case nxv1bf16:
641 case nxv2bf16:
642 case nxv4bf16:
643 case nxv8bf16: return bf16;
644 case v1f32:
645 case v2f32:
646 case v3f32:
647 case v4f32:
648 case v5f32:
649 case v6f32:
650 case v7f32:
651 case v8f32:
652 case v16f32:
653 case v32f32:
654 case v64f32:
655 case v128f32:
656 case v256f32:
657 case v512f32:
658 case v1024f32:
659 case v2048f32:
660 case nxv1f32:
661 case nxv2f32:
662 case nxv4f32:
663 case nxv8f32:
664 case nxv16f32: return f32;
665 case v1f64:
666 case v2f64:
667 case v3f64:
668 case v4f64:
669 case v8f64:
670 case v16f64:
671 case v32f64:
672 case v64f64:
673 case v128f64:
674 case v256f64:
675 case nxv1f64:
676 case nxv2f64:
677 case nxv4f64:
678 case nxv8f64: return f64;
679 }
680 }
681
682 /// Given a vector type, return the minimum number of elements it contains.
683 unsigned getVectorMinNumElements() const {
684 switch (SimpleTy) {
685 default:
686 llvm_unreachable("Not a vector MVT!")::llvm::llvm_unreachable_internal("Not a vector MVT!", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 686)
;
687 case v2048i32:
688 case v2048f32: return 2048;
689 case v1024i1:
690 case v1024i8:
691 case v1024i32:
692 case v1024f32: return 1024;
693 case v512i1:
694 case v512i8:
695 case v512i16:
696 case v512i32:
697 case v512f16:
698 case v512f32: return 512;
699 case v256i1:
700 case v256i8:
701 case v256i16:
702 case v256f16:
703 case v256i32:
704 case v256i64:
705 case v256f32:
706 case v256f64: return 256;
707 case v128i1:
708 case v128i8:
709 case v128i16:
710 case v128i32:
711 case v128i64:
712 case v128f16:
713 case v128bf16:
714 case v128f32:
715 case v128f64: return 128;
716 case v64i1:
717 case v64i8:
718 case v64i16:
719 case v64i32:
720 case v64i64:
721 case v64f16:
722 case v64bf16:
723 case v64f32:
724 case v64f64:
725 case nxv64i1:
726 case nxv64i8: return 64;
727 case v32i1:
728 case v32i8:
729 case v32i16:
730 case v32i32:
731 case v32i64:
732 case v32f16:
733 case v32bf16:
734 case v32f32:
735 case v32f64:
736 case nxv32i1:
737 case nxv32i8:
738 case nxv32i16:
739 case nxv32i32:
740 case nxv32i64:
741 case nxv32f16: return 32;
742 case v16i1:
743 case v16i8:
744 case v16i16:
745 case v16i32:
746 case v16i64:
747 case v16f16:
748 case v16bf16:
749 case v16f32:
750 case v16f64:
751 case nxv16i1:
752 case nxv16i8:
753 case nxv16i16:
754 case nxv16i32:
755 case nxv16i64:
756 case nxv16f16:
757 case nxv16f32: return 16;
758 case v8i1:
759 case v8i8:
760 case v8i16:
761 case v8i32:
762 case v8i64:
763 case v8f16:
764 case v8bf16:
765 case v8f32:
766 case v8f64:
767 case nxv8i1:
768 case nxv8i8:
769 case nxv8i16:
770 case nxv8i32:
771 case nxv8i64:
772 case nxv8f16:
773 case nxv8bf16:
774 case nxv8f32:
775 case nxv8f64: return 8;
776 case v7i32:
777 case v7f32: return 7;
778 case v6i32:
779 case v6f32: return 6;
780 case v5i32:
781 case v5f32: return 5;
782 case v4i1:
783 case v4i8:
784 case v4i16:
785 case v4i32:
786 case v4i64:
787 case v4f16:
788 case v4bf16:
789 case v4f32:
790 case v4f64:
791 case nxv4i1:
792 case nxv4i8:
793 case nxv4i16:
794 case nxv4i32:
795 case nxv4i64:
796 case nxv4f16:
797 case nxv4bf16:
798 case nxv4f32:
799 case nxv4f64: return 4;
800 case v3i16:
801 case v3i32:
802 case v3i64:
803 case v3f16:
804 case v3bf16:
805 case v3f32:
806 case v3f64: return 3;
807 case v2i1:
808 case v2i8:
809 case v2i16:
810 case v2i32:
811 case v2i64:
812 case v2f16:
813 case v2bf16:
814 case v2f32:
815 case v2f64:
816 case nxv2i1:
817 case nxv2i8:
818 case nxv2i16:
819 case nxv2i32:
820 case nxv2i64:
821 case nxv2f16:
822 case nxv2bf16:
823 case nxv2f32:
824 case nxv2f64: return 2;
825 case v1i1:
826 case v1i8:
827 case v1i16:
828 case v1i32:
829 case v1i64:
830 case v1i128:
831 case v1f16:
832 case v1f32:
833 case v1f64:
834 case nxv1i1:
835 case nxv1i8:
836 case nxv1i16:
837 case nxv1i32:
838 case nxv1i64:
839 case nxv1f16:
840 case nxv1bf16:
841 case nxv1f32:
842 case nxv1f64: return 1;
843 }
844 }
845
846 ElementCount getVectorElementCount() const {
847 return ElementCount::get(getVectorMinNumElements(), isScalableVector());
848 }
849
850 unsigned getVectorNumElements() const {
851 // TODO: Check that this isn't a scalable vector.
852 return getVectorMinNumElements();
853 }
854
855 /// Returns the size of the specified MVT in bits.
856 ///
857 /// If the value type is a scalable vector type, the scalable property will
858 /// be set and the runtime size will be a positive integer multiple of the
859 /// base size.
860 TypeSize getSizeInBits() const {
861 switch (SimpleTy) {
862 default:
863 llvm_unreachable("getSizeInBits called on extended MVT.")::llvm::llvm_unreachable_internal("getSizeInBits called on extended MVT."
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 863)
;
864 case Other:
865 llvm_unreachable("Value type is non-standard value, Other.")::llvm::llvm_unreachable_internal("Value type is non-standard value, Other."
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 865)
;
866 case iPTR:
867 llvm_unreachable("Value type size is target-dependent. Ask TLI.")::llvm::llvm_unreachable_internal("Value type size is target-dependent. Ask TLI."
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 867)
;
868 case iPTRAny:
869 case iAny:
870 case fAny:
871 case vAny:
872 case Any:
873 llvm_unreachable("Value type is overloaded.")::llvm::llvm_unreachable_internal("Value type is overloaded."
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 873)
;
874 case token:
875 llvm_unreachable("Token type is a sentinel that cannot be used "::llvm::llvm_unreachable_internal("Token type is a sentinel that cannot be used "
"in codegen and has no size", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 876)
876 "in codegen and has no size")::llvm::llvm_unreachable_internal("Token type is a sentinel that cannot be used "
"in codegen and has no size", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 876)
;
877 case Metadata:
878 llvm_unreachable("Value type is metadata.")::llvm::llvm_unreachable_internal("Value type is metadata.", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 878)
;
879 case i1:
880 case v1i1: return TypeSize::Fixed(1);
881 case nxv1i1: return TypeSize::Scalable(1);
882 case v2i1: return TypeSize::Fixed(2);
883 case nxv2i1: return TypeSize::Scalable(2);
884 case v4i1: return TypeSize::Fixed(4);
885 case nxv4i1: return TypeSize::Scalable(4);
886 case i8 :
887 case v1i8:
888 case v8i1: return TypeSize::Fixed(8);
889 case nxv1i8:
890 case nxv8i1: return TypeSize::Scalable(8);
891 case i16 :
892 case f16:
893 case bf16:
894 case v16i1:
895 case v2i8:
896 case v1i16:
897 case v1f16: return TypeSize::Fixed(16);
898 case nxv16i1:
899 case nxv2i8:
900 case nxv1i16:
901 case nxv1bf16:
902 case nxv1f16: return TypeSize::Scalable(16);
903 case f32 :
904 case i32 :
905 case v32i1:
906 case v4i8:
907 case v2i16:
908 case v2f16:
909 case v2bf16:
910 case v1f32:
911 case v1i32: return TypeSize::Fixed(32);
912 case nxv32i1:
913 case nxv4i8:
914 case nxv2i16:
915 case nxv1i32:
916 case nxv2f16:
917 case nxv2bf16:
918 case nxv1f32: return TypeSize::Scalable(32);
919 case v3i16:
920 case v3f16:
921 case v3bf16: return TypeSize::Fixed(48);
922 case x86mmx:
923 case f64 :
924 case i64 :
925 case v64i1:
926 case v8i8:
927 case v4i16:
928 case v2i32:
929 case v1i64:
930 case v4f16:
931 case v4bf16:
932 case v2f32:
933 case v1f64: return TypeSize::Fixed(64);
934 case nxv64i1:
935 case nxv8i8:
936 case nxv4i16:
937 case nxv2i32:
938 case nxv1i64:
939 case nxv4f16:
940 case nxv4bf16:
941 case nxv2f32:
942 case nxv1f64: return TypeSize::Scalable(64);
943 case f80 : return TypeSize::Fixed(80);
944 case v3i32:
945 case v3f32: return TypeSize::Fixed(96);
946 case f128:
947 case ppcf128:
948 case i128:
949 case v128i1:
950 case v16i8:
951 case v8i16:
952 case v4i32:
953 case v2i64:
954 case v1i128:
955 case v8f16:
956 case v8bf16:
957 case v4f32:
958 case v2f64: return TypeSize::Fixed(128);
959 case nxv16i8:
960 case nxv8i16:
961 case nxv4i32:
962 case nxv2i64:
963 case nxv8f16:
964 case nxv8bf16:
965 case nxv4f32:
966 case nxv2f64: return TypeSize::Scalable(128);
967 case v5i32:
968 case v5f32: return TypeSize::Fixed(160);
969 case v6i32:
970 case v3i64:
971 case v6f32:
972 case v3f64: return TypeSize::Fixed(192);
973 case v7i32:
974 case v7f32: return TypeSize::Fixed(224);
975 case v256i1:
976 case v32i8:
977 case v16i16:
978 case v8i32:
979 case v4i64:
980 case v16f16:
981 case v16bf16:
982 case v8f32:
983 case v4f64: return TypeSize::Fixed(256);
984 case nxv32i8:
985 case nxv16i16:
986 case nxv8i32:
987 case nxv4i64:
988 case nxv16f16:
989 case nxv8f32:
990 case nxv4f64: return TypeSize::Scalable(256);
991 case i64x8:
992 case v512i1:
993 case v64i8:
994 case v32i16:
995 case v16i32:
996 case v8i64:
997 case v32f16:
998 case v32bf16:
999 case v16f32:
1000 case v8f64: return TypeSize::Fixed(512);
1001 case nxv64i8:
1002 case nxv32i16:
1003 case nxv16i32:
1004 case nxv8i64:
1005 case nxv32f16:
1006 case nxv16f32:
1007 case nxv8f64: return TypeSize::Scalable(512);
1008 case v1024i1:
1009 case v128i8:
1010 case v64i16:
1011 case v32i32:
1012 case v16i64:
1013 case v64f16:
1014 case v64bf16:
1015 case v32f32:
1016 case v16f64: return TypeSize::Fixed(1024);
1017 case nxv32i32:
1018 case nxv16i64: return TypeSize::Scalable(1024);
1019 case v256i8:
1020 case v128i16:
1021 case v64i32:
1022 case v32i64:
1023 case v128f16:
1024 case v128bf16:
1025 case v64f32:
1026 case v32f64: return TypeSize::Fixed(2048);
1027 case nxv32i64: return TypeSize::Scalable(2048);
1028 case v512i8:
1029 case v256i16:
1030 case v128i32:
1031 case v64i64:
1032 case v256f16:
1033 case v128f32:
1034 case v64f64: return TypeSize::Fixed(4096);
1035 case v1024i8:
1036 case v512i16:
1037 case v256i32:
1038 case v128i64:
1039 case v512f16:
1040 case v256f32:
1041 case x86amx:
1042 case v128f64: return TypeSize::Fixed(8192);
1043 case v512i32:
1044 case v256i64:
1045 case v512f32:
1046 case v256f64: return TypeSize::Fixed(16384);
1047 case v1024i32:
1048 case v1024f32: return TypeSize::Fixed(32768);
1049 case v2048i32:
1050 case v2048f32: return TypeSize::Fixed(65536);
1051 case funcref:
1052 case externref: return TypeSize::Fixed(0); // opaque type
1053 }
1054 }
1055
1056 /// Return the size of the specified fixed width value type in bits. The
1057 /// function will assert if the type is scalable.
1058 uint64_t getFixedSizeInBits() const {
1059 return getSizeInBits().getFixedSize();
1060 }
1061
1062 uint64_t getScalarSizeInBits() const {
1063 return getScalarType().getSizeInBits().getFixedSize();
1064 }
1065
1066 /// Return the number of bytes overwritten by a store of the specified value
1067 /// type.
1068 ///
1069 /// If the value type is a scalable vector type, the scalable property will
1070 /// be set and the runtime size will be a positive integer multiple of the
1071 /// base size.
1072 TypeSize getStoreSize() const {
1073 TypeSize BaseSize = getSizeInBits();
1074 return {(BaseSize.getKnownMinSize() + 7) / 8, BaseSize.isScalable()};
1075 }
1076
1077 /// Return the number of bits overwritten by a store of the specified value
1078 /// type.
1079 ///
1080 /// If the value type is a scalable vector type, the scalable property will
1081 /// be set and the runtime size will be a positive integer multiple of the
1082 /// base size.
1083 TypeSize getStoreSizeInBits() const {
1084 return getStoreSize() * 8;
1085 }
1086
1087 /// Returns true if the number of bits for the type is a multiple of an
1088 /// 8-bit byte.
1089 bool isByteSized() const { return getSizeInBits().isKnownMultipleOf(8); }
1090
1091 /// Return true if we know at compile time this has more bits than VT.
1092 bool knownBitsGT(MVT VT) const {
1093 return TypeSize::isKnownGT(getSizeInBits(), VT.getSizeInBits());
1094 }
1095
1096 /// Return true if we know at compile time this has more than or the same
1097 /// bits as VT.
1098 bool knownBitsGE(MVT VT) const {
1099 return TypeSize::isKnownGE(getSizeInBits(), VT.getSizeInBits());
1100 }
1101
1102 /// Return true if we know at compile time this has fewer bits than VT.
1103 bool knownBitsLT(MVT VT) const {
1104 return TypeSize::isKnownLT(getSizeInBits(), VT.getSizeInBits());
1105 }
1106
1107 /// Return true if we know at compile time this has fewer than or the same
1108 /// bits as VT.
1109 bool knownBitsLE(MVT VT) const {
1110 return TypeSize::isKnownLE(getSizeInBits(), VT.getSizeInBits());
1111 }
1112
1113 /// Return true if this has more bits than VT.
1114 bool bitsGT(MVT VT) const {
1115 assert(isScalableVector() == VT.isScalableVector() &&(static_cast <bool> (isScalableVector() == VT.isScalableVector
() && "Comparison between scalable and fixed types") ?
void (0) : __assert_fail ("isScalableVector() == VT.isScalableVector() && \"Comparison between scalable and fixed types\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 1116, __extension__ __PRETTY_FUNCTION__))
1116 "Comparison between scalable and fixed types")(static_cast <bool> (isScalableVector() == VT.isScalableVector
() && "Comparison between scalable and fixed types") ?
void (0) : __assert_fail ("isScalableVector() == VT.isScalableVector() && \"Comparison between scalable and fixed types\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 1116, __extension__ __PRETTY_FUNCTION__))
;
1117 return knownBitsGT(VT);
1118 }
1119
1120 /// Return true if this has no less bits than VT.
1121 bool bitsGE(MVT VT) const {
1122 assert(isScalableVector() == VT.isScalableVector() &&(static_cast <bool> (isScalableVector() == VT.isScalableVector
() && "Comparison between scalable and fixed types") ?
void (0) : __assert_fail ("isScalableVector() == VT.isScalableVector() && \"Comparison between scalable and fixed types\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 1123, __extension__ __PRETTY_FUNCTION__))
1123 "Comparison between scalable and fixed types")(static_cast <bool> (isScalableVector() == VT.isScalableVector
() && "Comparison between scalable and fixed types") ?
void (0) : __assert_fail ("isScalableVector() == VT.isScalableVector() && \"Comparison between scalable and fixed types\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 1123, __extension__ __PRETTY_FUNCTION__))
;
1124 return knownBitsGE(VT);
1125 }
1126
1127 /// Return true if this has less bits than VT.
1128 bool bitsLT(MVT VT) const {
1129 assert(isScalableVector() == VT.isScalableVector() &&(static_cast <bool> (isScalableVector() == VT.isScalableVector
() && "Comparison between scalable and fixed types") ?
void (0) : __assert_fail ("isScalableVector() == VT.isScalableVector() && \"Comparison between scalable and fixed types\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 1130, __extension__ __PRETTY_FUNCTION__))
1130 "Comparison between scalable and fixed types")(static_cast <bool> (isScalableVector() == VT.isScalableVector
() && "Comparison between scalable and fixed types") ?
void (0) : __assert_fail ("isScalableVector() == VT.isScalableVector() && \"Comparison between scalable and fixed types\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 1130, __extension__ __PRETTY_FUNCTION__))
;
1131 return knownBitsLT(VT);
1132 }
1133
1134 /// Return true if this has no more bits than VT.
1135 bool bitsLE(MVT VT) const {
1136 assert(isScalableVector() == VT.isScalableVector() &&(static_cast <bool> (isScalableVector() == VT.isScalableVector
() && "Comparison between scalable and fixed types") ?
void (0) : __assert_fail ("isScalableVector() == VT.isScalableVector() && \"Comparison between scalable and fixed types\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 1137, __extension__ __PRETTY_FUNCTION__))
1137 "Comparison between scalable and fixed types")(static_cast <bool> (isScalableVector() == VT.isScalableVector
() && "Comparison between scalable and fixed types") ?
void (0) : __assert_fail ("isScalableVector() == VT.isScalableVector() && \"Comparison between scalable and fixed types\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 1137, __extension__ __PRETTY_FUNCTION__))
;
1138 return knownBitsLE(VT);
1139 }
1140
1141 static MVT getFloatingPointVT(unsigned BitWidth) {
1142 switch (BitWidth) {
1143 default:
1144 llvm_unreachable("Bad bit width!")::llvm::llvm_unreachable_internal("Bad bit width!", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include/llvm/Support/MachineValueType.h"
, 1144)
;
1145 case 16:
1146 return MVT::f16;
1147 case 32:
1148 return MVT::f32;
1149 case 64:
1150 return MVT::f64;
1151 case 80:
1152 return MVT::f80;
1153 case 128:
1154 return MVT::f128;
1155 }
1156 }
1157
1158 static MVT getIntegerVT(unsigned BitWidth) {
1159 switch (BitWidth) {
1160 default:
1161 return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
1162 case 1:
1163 return MVT::i1;
1164 case 8:
1165 return MVT::i8;
1166 case 16:
1167 return MVT::i16;
1168 case 32:
1169 return MVT::i32;
1170 case 64:
1171 return MVT::i64;
1172 case 128:
1173 return MVT::i128;
1174 }
1175 }
1176
1177 static MVT getVectorVT(MVT VT, unsigned NumElements) {
1178 switch (VT.SimpleTy) {
1179 default:
1180 break;
1181 case MVT::i1:
1182 if (NumElements == 1) return MVT::v1i1;
1183 if (NumElements == 2) return MVT::v2i1;
1184 if (NumElements == 4) return MVT::v4i1;
1185 if (NumElements == 8) return MVT::v8i1;
1186 if (NumElements == 16) return MVT::v16i1;
1187 if (NumElements == 32) return MVT::v32i1;
1188 if (NumElements == 64) return MVT::v64i1;
1189 if (NumElements == 128) return MVT::v128i1;
1190 if (NumElements == 256) return MVT::v256i1;
1191 if (NumElements == 512) return MVT::v512i1;
1192 if (NumElements == 1024) return MVT::v1024i1;
1193 break;
1194 case MVT::i8:
1195 if (NumElements == 1) return MVT::v1i8;
1196 if (NumElements == 2) return MVT::v2i8;
1197 if (NumElements == 4) return MVT::v4i8;
1198 if (NumElements == 8) return MVT::v8i8;
1199 if (NumElements == 16) return MVT::v16i8;
1200 if (NumElements == 32) return MVT::v32i8;
1201 if (NumElements == 64) return MVT::v64i8;
1202 if (NumElements == 128) return MVT::v128i8;
1203 if (NumElements == 256) return MVT::v256i8;
1204 if (NumElements == 512) return MVT::v512i8;
1205 if (NumElements == 1024) return MVT::v1024i8;
1206 break;
1207 case MVT::i16:
1208 if (NumElements == 1) return MVT::v1i16;
1209 if (NumElements == 2) return MVT::v2i16;
1210 if (NumElements == 3) return MVT::v3i16;
1211 if (NumElements == 4) return MVT::v4i16;
1212 if (NumElements == 8) return MVT::v8i16;
1213 if (NumElements == 16) return MVT::v16i16;
1214 if (NumElements == 32) return MVT::v32i16;
1215 if (NumElements == 64) return MVT::v64i16;
1216 if (NumElements == 128) return MVT::v128i16;
1217 if (NumElements == 256) return MVT::v256i16;
1218 if (NumElements == 512) return MVT::v512i16;
1219 break;
1220 case MVT::i32:
1221 if (NumElements == 1) return MVT::v1i32;
1222 if (NumElements == 2) return MVT::v2i32;
1223 if (NumElements == 3) return MVT::v3i32;
1224 if (NumElements == 4) return MVT::v4i32;
1225 if (NumElements == 5) return MVT::v5i32;
1226 if (NumElements == 6) return MVT::v6i32;
1227 if (NumElements == 7) return MVT::v7i32;
1228 if (NumElements == 8) return MVT::v8i32;
1229 if (NumElements == 16) return MVT::v16i32;
1230 if (NumElements == 32) return MVT::v32i32;
1231 if (NumElements == 64) return MVT::v64i32;
1232 if (NumElements == 128) return MVT::v128i32;
1233 if (NumElements == 256) return MVT::v256i32;
1234 if (NumElements == 512) return MVT::v512i32;
1235 if (NumElements == 1024) return MVT::v1024i32;
1236 if (NumElements == 2048) return MVT::v2048i32;
1237 break;
1238 case MVT::i64:
1239 if (NumElements == 1) return MVT::v1i64;
1240 if (NumElements == 2) return MVT::v2i64;
1241 if (NumElements == 3) return MVT::v3i64;
1242 if (NumElements == 4) return MVT::v4i64;
1243 if (NumElements == 8) return MVT::v8i64;
1244 if (NumElements == 16) return MVT::v16i64;
1245 if (NumElements == 32) return MVT::v32i64;
1246 if (NumElements == 64) return MVT::v64i64;
1247 if (NumElements == 128) return MVT::v128i64;
1248 if (NumElements == 256) return MVT::v256i64;
1249 break;
1250 case MVT::i128:
1251 if (NumElements == 1) return MVT::v1i128;
1252 break;
1253 case MVT::f16:
1254 if (NumElements == 1) return MVT::v1f16;
1255 if (NumElements == 2) return MVT::v2f16;
1256 if (NumElements == 3) return MVT::v3f16;
1257 if (NumElements == 4) return MVT::v4f16;
1258 if (NumElements == 8) return MVT::v8f16;
1259 if (NumElements == 16) return MVT::v16f16;
1260 if (NumElements == 32) return MVT::v32f16;
1261 if (NumElements == 64) return MVT::v64f16;
1262 if (NumElements == 128) return MVT::v128f16;
1263 if (NumElements == 256) return MVT::v256f16;
1264 if (NumElements == 512) return MVT::v512f16;
1265 break;
1266 case MVT::bf16:
1267 if (NumElements == 2) return MVT::v2bf16;
1268 if (NumElements == 3) return MVT::v3bf16;
1269 if (NumElements == 4) return MVT::v4bf16;
1270 if (NumElements == 8) return MVT::v8bf16;
1271 if (NumElements == 16) return MVT::v16bf16;
1272 if (NumElements == 32) return MVT::v32bf16;
1273 if (NumElements == 64) return MVT::v64bf16;
1274 if (NumElements == 128) return MVT::v128bf16;
1275 break;
1276 case MVT::f32:
1277 if (NumElements == 1) return MVT::v1f32;
1278 if (NumElements == 2) return MVT::v2f32;
1279 if (NumElements == 3) return MVT::v3f32;
1280 if (NumElements == 4) return MVT::v4f32;
1281 if (NumElements == 5) return MVT::v5f32;
1282 if (NumElements == 6) return MVT::v6f32;
1283 if (NumElements == 7) return MVT::v7f32;
1284 if (NumElements == 8) return MVT::v8f32;
1285 if (NumElements == 16) return MVT::v16f32;
1286 if (NumElements == 32) return MVT::v32f32;
1287 if (NumElements == 64) return MVT::v64f32;
1288 if (NumElements == 128) return MVT::v128f32;
1289 if (NumElements == 256) return MVT::v256f32;
1290 if (NumElements == 512) return MVT::v512f32;
1291 if (NumElements == 1024) return MVT::v1024f32;
1292 if (NumElements == 2048) return MVT::v2048f32;
1293 break;
1294 case MVT::f64:
1295 if (NumElements == 1) return MVT::v1f64;
1296 if (NumElements == 2) return MVT::v2f64;
1297 if (NumElements == 3) return MVT::v3f64;
1298 if (NumElements == 4) return MVT::v4f64;
1299 if (NumElements == 8) return MVT::v8f64;
1300 if (NumElements == 16) return MVT::v16f64;
1301 if (NumElements == 32) return MVT::v32f64;
1302 if (NumElements == 64) return MVT::v64f64;
1303 if (NumElements == 128) return MVT::v128f64;
1304 if (NumElements == 256) return MVT::v256f64;
1305 break;
1306 }
1307 return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
1308 }
1309
1310 static MVT getScalableVectorVT(MVT VT, unsigned NumElements) {
1311 switch(VT.SimpleTy) {
1312 default:
1313 break;
1314 case MVT::i1:
1315 if (NumElements == 1) return MVT::nxv1i1;
1316 if (NumElements == 2) return MVT::nxv2i1;
1317 if (NumElements == 4) return MVT::nxv4i1;
1318 if (NumElements == 8) return MVT::nxv8i1;
1319 if (NumElements == 16) return MVT::nxv16i1;
1320 if (NumElements == 32) return MVT::nxv32i1;
1321 if (NumElements == 64) return MVT::nxv64i1;
1322 break;
1323 case MVT::i8:
1324 if (NumElements == 1) return MVT::nxv1i8;
1325 if (NumElements == 2) return MVT::nxv2i8;
1326 if (NumElements == 4) return MVT::nxv4i8;
1327 if (NumElements == 8) return MVT::nxv8i8;
1328 if (NumElements == 16) return MVT::nxv16i8;
1329 if (NumElements == 32) return MVT::nxv32i8;
1330 if (NumElements == 64) return MVT::nxv64i8;
1331 break;
1332 case MVT::i16:
1333 if (NumElements == 1) return MVT::nxv1i16;
1334 if (NumElements == 2) return MVT::nxv2i16;
1335 if (NumElements == 4) return MVT::nxv4i16;
1336 if (NumElements == 8) return MVT::nxv8i16;
1337 if (NumElements == 16) return MVT::nxv16i16;
1338 if (NumElements == 32) return MVT::nxv32i16;
1339 break;
1340 case MVT::i32:
1341 if (NumElements == 1) return MVT::nxv1i32;
1342 if (NumElements == 2) return MVT::nxv2i32;
1343 if (NumElements == 4) return MVT::nxv4i32;
1344 if (NumElements == 8) return MVT::nxv8i32;
1345 if (NumElements == 16) return MVT::nxv16i32;
1346 if (NumElements == 32) return MVT::nxv32i32;
1347 break;
1348 case MVT::i64:
1349 if (NumElements == 1) return MVT::nxv1i64;
1350 if (NumElements == 2) return MVT::nxv2i64;
1351 if (NumElements == 4) return MVT::nxv4i64;
1352 if (NumElements == 8) return MVT::nxv8i64;
1353 if (NumElements == 16) return MVT::nxv16i64;
1354 if (NumElements == 32) return MVT::nxv32i64;
1355 break;
1356 case MVT::f16:
1357 if (NumElements == 1) return MVT::nxv1f16;
1358 if (NumElements == 2) return MVT::nxv2f16;
1359 if (NumElements == 4) return MVT::nxv4f16;
1360 if (NumElements == 8) return MVT::nxv8f16;
1361 if (NumElements == 16) return MVT::nxv16f16;
1362 if (NumElements == 32) return MVT::nxv32f16;
1363 break;
1364 case MVT::bf16:
1365 if (NumElements == 1) return MVT::nxv1bf16;
1366 if (NumElements == 2) return MVT::nxv2bf16;
1367 if (NumElements == 4) return MVT::nxv4bf16;
1368 if (NumElements == 8) return MVT::nxv8bf16;
1369 break;
1370 case MVT::f32:
1371 if (NumElements == 1) return MVT::nxv1f32;
1372 if (NumElements == 2) return MVT::nxv2f32;
1373 if (NumElements == 4) return MVT::nxv4f32;
1374 if (NumElements == 8) return MVT::nxv8f32;
1375 if (NumElements == 16) return MVT::nxv16f32;
1376 break;
1377 case MVT::f64:
1378 if (NumElements == 1) return MVT::nxv1f64;
1379 if (NumElements == 2) return MVT::nxv2f64;
1380 if (NumElements == 4) return MVT::nxv4f64;
1381 if (NumElements == 8) return MVT::nxv8f64;
1382 break;
1383 }
1384 return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
1385 }
1386
1387 static MVT getVectorVT(MVT VT, unsigned NumElements, bool IsScalable) {
1388 if (IsScalable)
1389 return getScalableVectorVT(VT, NumElements);
1390 return getVectorVT(VT, NumElements);
1391 }
1392
1393 static MVT getVectorVT(MVT VT, ElementCount EC) {
1394 if (EC.isScalable())
1395 return getScalableVectorVT(VT, EC.getKnownMinValue());
1396 return getVectorVT(VT, EC.getKnownMinValue());
1397 }
1398
1399 /// Return the value type corresponding to the specified type. This returns
1400 /// all pointers as iPTR. If HandleUnknown is true, unknown types are
1401 /// returned as Other, otherwise they are invalid.
1402 static MVT getVT(Type *Ty, bool HandleUnknown = false);
1403
1404 public:
1405 /// SimpleValueType Iteration
1406 /// @{
1407 static auto all_valuetypes() {
1408 return seq_inclusive(MVT::FIRST_VALUETYPE, MVT::LAST_VALUETYPE);
1409 }
1410
1411 static auto integer_valuetypes() {
1412 return seq_inclusive(MVT::FIRST_INTEGER_VALUETYPE,
1413 MVT::LAST_INTEGER_VALUETYPE);
1414 }
1415
1416 static auto fp_valuetypes() {
1417 return seq_inclusive(MVT::FIRST_FP_VALUETYPE, MVT::LAST_FP_VALUETYPE);
1418 }
1419
1420 static auto vector_valuetypes() {
1421 return seq_inclusive(MVT::FIRST_VECTOR_VALUETYPE,
1422 MVT::LAST_VECTOR_VALUETYPE);
1423 }
1424
1425 static auto fixedlen_vector_valuetypes() {
1426 return seq_inclusive(MVT::FIRST_FIXEDLEN_VECTOR_VALUETYPE,
1427 MVT::LAST_FIXEDLEN_VECTOR_VALUETYPE);
1428 }
1429
1430 static auto scalable_vector_valuetypes() {
1431 return seq_inclusive(MVT::FIRST_SCALABLE_VECTOR_VALUETYPE,
1432 MVT::LAST_SCALABLE_VECTOR_VALUETYPE);
1433 }
1434
1435 static auto integer_fixedlen_vector_valuetypes() {
1436 return seq_inclusive(MVT::FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE,
1437 MVT::LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE);
1438 }
1439
1440 static auto fp_fixedlen_vector_valuetypes() {
1441 return seq_inclusive(MVT::FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE,
1442 MVT::LAST_FP_FIXEDLEN_VECTOR_VALUETYPE);
1443 }
1444
1445 static auto integer_scalable_vector_valuetypes() {
1446 return seq_inclusive(MVT::FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE,
1447 MVT::LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE);
1448 }
1449
1450 static auto fp_scalable_vector_valuetypes() {
1451 return seq_inclusive(MVT::FIRST_FP_SCALABLE_VECTOR_VALUETYPE,
1452 MVT::LAST_FP_SCALABLE_VECTOR_VALUETYPE);
1453 }
1454 /// @}
1455 };
1456
1457} // end namespace llvm
1458
1459#endif // LLVM_SUPPORT_MACHINEVALUETYPE_H