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