1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Machine Code Emitter *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9uint64_t AVRMCCodeEmitter::getBinaryCodeForInstr(const MCInst &MI,
10 SmallVectorImpl<MCFixup> &Fixups,
11 const MCSubtargetInfo &STI) const {
12 static const uint64_t InstBits[] = {
13 UINT64_C(7168), // ADCRdRr
14 UINT64_C(3072), // ADDRdRr
15 UINT64_C(38400), // ADIWRdK
16 UINT64_C(28672), // ANDIRdK
17 UINT64_C(8192), // ANDRdRr
18 UINT64_C(37893), // ASRRd
19 UINT64_C(38024), // BCLRs
20 UINT64_C(63488), // BLD
21 UINT64_C(62464), // BRBCsk
22 UINT64_C(61440), // BRBSsk
23 UINT64_C(38296), // BREAK
24 UINT64_C(61441), // BREQk
25 UINT64_C(62468), // BRGEk
26 UINT64_C(61440), // BRLOk
27 UINT64_C(61444), // BRLTk
28 UINT64_C(61442), // BRMIk
29 UINT64_C(62465), // BRNEk
30 UINT64_C(62466), // BRPLk
31 UINT64_C(62464), // BRSHk
32 UINT64_C(37896), // BSETs
33 UINT64_C(64000), // BST
34 UINT64_C(2483945472), // CALLk
35 UINT64_C(38912), // CBIAb
36 UINT64_C(37888), // COMRd
37 UINT64_C(1024), // CPCRdRr
38 UINT64_C(12288), // CPIRdK
39 UINT64_C(5120), // CPRdRr
40 UINT64_C(4096), // CPSE
41 UINT64_C(37898), // DECRd
42 UINT64_C(37899), // DESK
43 UINT64_C(38169), // EICALL
44 UINT64_C(37913), // EIJMP
45 UINT64_C(38360), // ELPM
46 UINT64_C(36870), // ELPMRdZ
47 UINT64_C(36871), // ELPMRdZPi
48 UINT64_C(9216), // EORRdRr
49 UINT64_C(776), // FMUL
50 UINT64_C(896), // FMULS
51 UINT64_C(904), // FMULSU
52 UINT64_C(38153), // ICALL
53 UINT64_C(37897), // IJMP
54 UINT64_C(37891), // INCRd
55 UINT64_C(45056), // INRdA
56 UINT64_C(2483814400), // JMPk
57 UINT64_C(37382), // LACZRd
58 UINT64_C(37381), // LASZRd
59 UINT64_C(37383), // LATZRd
60 UINT64_C(32768), // LDDRdPtrQ
61 UINT64_C(57344), // LDIRdK
62 UINT64_C(32768), // LDRdPtr
63 UINT64_C(32770), // LDRdPtrPd
64 UINT64_C(32769), // LDRdPtrPi
65 UINT64_C(2415919104), // LDSRdK
66 UINT64_C(40960), // LDSRdKTiny
67 UINT64_C(38344), // LPM
68 UINT64_C(36868), // LPMRdZ
69 UINT64_C(36869), // LPMRdZPi
70 UINT64_C(37894), // LSRRd
71 UINT64_C(11264), // MOVRdRr
72 UINT64_C(256), // MOVWRdRr
73 UINT64_C(39936), // MULRdRr
74 UINT64_C(512), // MULSRdRr
75 UINT64_C(768), // MULSURdRr
76 UINT64_C(37889), // NEGRd
77 UINT64_C(0), // NOP
78 UINT64_C(24576), // ORIRdK
79 UINT64_C(10240), // ORRdRr
80 UINT64_C(47104), // OUTARr
81 UINT64_C(36879), // POPRd
82 UINT64_C(37391), // PUSHRr
83 UINT64_C(53248), // RCALLk
84 UINT64_C(38152), // RET
85 UINT64_C(38168), // RETI
86 UINT64_C(49152), // RJMPk
87 UINT64_C(37895), // RORRd
88 UINT64_C(16384), // SBCIRdK
89 UINT64_C(2048), // SBCRdRr
90 UINT64_C(39424), // SBIAb
91 UINT64_C(39168), // SBICAb
92 UINT64_C(39680), // SBISAb
93 UINT64_C(38656), // SBIWRdK
94 UINT64_C(64512), // SBRCRrB
95 UINT64_C(65024), // SBRSRrB
96 UINT64_C(38280), // SLEEP
97 UINT64_C(38376), // SPM
98 UINT64_C(38392), // SPMZPi
99 UINT64_C(33280), // STDPtrQRr
100 UINT64_C(33282), // STPtrPdRr
101 UINT64_C(33281), // STPtrPiRr
102 UINT64_C(33280), // STPtrRr
103 UINT64_C(2449473536), // STSKRr
104 UINT64_C(43008), // STSKRrTiny
105 UINT64_C(20480), // SUBIRdK
106 UINT64_C(6144), // SUBRdRr
107 UINT64_C(37890), // SWAPRd
108 UINT64_C(38312), // WDR
109 UINT64_C(37380), // XCHZRd
110 };
111 constexpr unsigned FirstSupportedOpcode = 418;
112
113 const unsigned opcode = MI.getOpcode();
114 if (opcode < FirstSupportedOpcode)
115 reportUnsupportedInst(Inst: MI);
116 unsigned TableIndex = opcode - FirstSupportedOpcode;
117 uint64_t Value = InstBits[TableIndex];
118 uint64_t op = 0;
119 (void)op; // suppress warning
120 switch (opcode) {
121 case AVR::BREAK:
122 case AVR::EICALL:
123 case AVR::EIJMP:
124 case AVR::ELPM:
125 case AVR::ICALL:
126 case AVR::IJMP:
127 case AVR::LPM:
128 case AVR::NOP:
129 case AVR::RET:
130 case AVR::RETI:
131 case AVR::SLEEP:
132 case AVR::SPM:
133 case AVR::SPMZPi:
134 case AVR::WDR: {
135 break;
136 }
137 case AVR::OUTARr: {
138 // op: A
139 op = encodeImm<AVR::fixup_port6, 0>(MI, OpNo: 0, Fixups, STI);
140 Value |= (op & 0x30) << 5;
141 Value |= (op & 0xf);
142 // op: rr
143 op = getMachineOpValue(MI, MO: MI.getOperand(i: 1), Fixups, STI);
144 Value |= (op & 0x1f) << 4;
145 break;
146 }
147 case AVR::CBIAb:
148 case AVR::SBIAb:
149 case AVR::SBICAb:
150 case AVR::SBISAb: {
151 // op: addr
152 op = encodeImm<AVR::fixup_port5, 0>(MI, OpNo: 0, Fixups, STI);
153 Value |= (op & 0x1f) << 3;
154 // op: b
155 op = getMachineOpValue(MI, MO: MI.getOperand(i: 1), Fixups, STI);
156 Value |= (op & 0x7);
157 break;
158 }
159 case AVR::CALLk:
160 case AVR::JMPk: {
161 // op: k
162 op = encodeCallTarget(MI, OpNo: 0, Fixups, STI);
163 Value |= (op & 0x3e0000) << 3;
164 Value |= (op & 0x1ffff);
165 break;
166 }
167 case AVR::RCALLk:
168 case AVR::RJMPk: {
169 // op: k
170 op = encodeRelCondBrTarget<AVR::fixup_13_pcrel>(MI, OpNo: 0, Fixups, STI);
171 Value |= (op & 0xfff);
172 break;
173 }
174 case AVR::BREQk:
175 case AVR::BRGEk:
176 case AVR::BRLOk:
177 case AVR::BRLTk:
178 case AVR::BRMIk:
179 case AVR::BRNEk:
180 case AVR::BRPLk:
181 case AVR::BRSHk: {
182 // op: k
183 op = encodeRelCondBrTarget<AVR::fixup_7_pcrel>(MI, OpNo: 0, Fixups, STI);
184 Value |= (op & 0x7f) << 3;
185 break;
186 }
187 case AVR::BRBCsk:
188 case AVR::BRBSsk: {
189 // op: k
190 op = encodeRelCondBrTarget<AVR::fixup_7_pcrel>(MI, OpNo: 1, Fixups, STI);
191 Value |= (op & 0x7f) << 3;
192 // op: s
193 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
194 Value |= (op & 0x7);
195 break;
196 }
197 case AVR::DESK: {
198 // op: k
199 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
200 Value |= (op & 0xf) << 4;
201 break;
202 }
203 case AVR::STDPtrQRr: {
204 // op: memri
205 op = encodeMemri(MI, OpNo: 0, Fixups, STI);
206 Value |= (op & 0x20) << 8;
207 Value |= (op & 0x18) << 7;
208 Value |= (op & 0x40) >> 3;
209 Value |= (op & 0x7);
210 // op: reg
211 op = getMachineOpValue(MI, MO: MI.getOperand(i: 2), Fixups, STI);
212 Value |= (op & 0x1f) << 4;
213 break;
214 }
215 case AVR::LDDRdPtrQ: {
216 // op: memri
217 op = encodeMemri(MI, OpNo: 1, Fixups, STI);
218 Value |= (op & 0x20) << 8;
219 Value |= (op & 0x18) << 7;
220 Value |= (op & 0x40) >> 3;
221 Value |= (op & 0x7);
222 // op: reg
223 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
224 Value |= (op & 0x1f) << 4;
225 break;
226 }
227 case AVR::LDSRdK: {
228 // op: rd
229 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
230 Value |= (op & 0x1f) << 20;
231 // op: k
232 op = encodeImm<AVR::fixup_16, 2>(MI, OpNo: 1, Fixups, STI);
233 Value |= (op & 0xffff);
234 break;
235 }
236 case AVR::ASRRd:
237 case AVR::COMRd:
238 case AVR::DECRd:
239 case AVR::ELPMRdZ:
240 case AVR::ELPMRdZPi:
241 case AVR::INCRd:
242 case AVR::LACZRd:
243 case AVR::LASZRd:
244 case AVR::LATZRd:
245 case AVR::LPMRdZ:
246 case AVR::LPMRdZPi:
247 case AVR::LSRRd:
248 case AVR::NEGRd:
249 case AVR::POPRd:
250 case AVR::PUSHRr:
251 case AVR::RORRd:
252 case AVR::SWAPRd:
253 case AVR::XCHZRd: {
254 // op: rd
255 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
256 Value |= (op & 0x1f) << 4;
257 break;
258 }
259 case AVR::INRdA: {
260 // op: rd
261 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
262 Value |= (op & 0x1f) << 4;
263 // op: A
264 op = encodeImm<AVR::fixup_port6, 0>(MI, OpNo: 1, Fixups, STI);
265 Value |= (op & 0x30) << 5;
266 Value |= (op & 0xf);
267 break;
268 }
269 case AVR::BST:
270 case AVR::SBRCRrB:
271 case AVR::SBRSRrB: {
272 // op: rd
273 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
274 Value |= (op & 0x1f) << 4;
275 // op: b
276 op = getMachineOpValue(MI, MO: MI.getOperand(i: 1), Fixups, STI);
277 Value |= (op & 0x7);
278 break;
279 }
280 case AVR::BLD: {
281 // op: rd
282 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
283 Value |= (op & 0x1f) << 4;
284 // op: b
285 op = getMachineOpValue(MI, MO: MI.getOperand(i: 2), Fixups, STI);
286 Value |= (op & 0x7);
287 break;
288 }
289 case AVR::CPCRdRr:
290 case AVR::CPRdRr:
291 case AVR::CPSE:
292 case AVR::MOVRdRr:
293 case AVR::MULRdRr: {
294 // op: rd
295 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
296 Value |= (op & 0x1f) << 4;
297 // op: rr
298 op = getMachineOpValue(MI, MO: MI.getOperand(i: 1), Fixups, STI);
299 Value |= (op & 0x10) << 5;
300 Value |= (op & 0xf);
301 break;
302 }
303 case AVR::ADCRdRr:
304 case AVR::ADDRdRr:
305 case AVR::ANDRdRr:
306 case AVR::EORRdRr:
307 case AVR::ORRdRr:
308 case AVR::SBCRdRr:
309 case AVR::SUBRdRr: {
310 // op: rd
311 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
312 Value |= (op & 0x1f) << 4;
313 // op: rr
314 op = getMachineOpValue(MI, MO: MI.getOperand(i: 2), Fixups, STI);
315 Value |= (op & 0x10) << 5;
316 Value |= (op & 0xf);
317 break;
318 }
319 case AVR::ADIWRdK:
320 case AVR::SBIWRdK: {
321 // op: rd
322 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
323 Value |= (op & 0x3) << 4;
324 // op: k
325 op = encodeImm<AVR::fixup_6_adiw, 0>(MI, OpNo: 2, Fixups, STI);
326 Value |= (op & 0x30) << 2;
327 Value |= (op & 0xf);
328 break;
329 }
330 case AVR::FMUL:
331 case AVR::FMULS:
332 case AVR::FMULSU:
333 case AVR::MULSURdRr: {
334 // op: rd
335 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
336 Value |= (op & 0x7) << 4;
337 // op: rr
338 op = getMachineOpValue(MI, MO: MI.getOperand(i: 1), Fixups, STI);
339 Value |= (op & 0x7);
340 break;
341 }
342 case AVR::CPIRdK:
343 case AVR::LDIRdK: {
344 // op: rd
345 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
346 Value |= (op & 0xf) << 4;
347 // op: k
348 op = encodeImm<AVR::fixup_ldi, 0>(MI, OpNo: 1, Fixups, STI);
349 Value |= (op & 0xf0) << 4;
350 Value |= (op & 0xf);
351 break;
352 }
353 case AVR::ANDIRdK:
354 case AVR::ORIRdK:
355 case AVR::SBCIRdK:
356 case AVR::SUBIRdK: {
357 // op: rd
358 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
359 Value |= (op & 0xf) << 4;
360 // op: k
361 op = encodeImm<AVR::fixup_ldi, 0>(MI, OpNo: 2, Fixups, STI);
362 Value |= (op & 0xf0) << 4;
363 Value |= (op & 0xf);
364 break;
365 }
366 case AVR::LDSRdKTiny: {
367 // op: rd
368 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
369 Value |= (op & 0xf) << 4;
370 // op: k
371 op = encodeImm<AVR::fixup_lds_sts_16, 0>(MI, OpNo: 1, Fixups, STI);
372 Value |= (op & 0x70) << 4;
373 Value |= (op & 0xf);
374 break;
375 }
376 case AVR::MOVWRdRr:
377 case AVR::MULSRdRr: {
378 // op: rd
379 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
380 Value |= (op & 0xf) << 4;
381 // op: rr
382 op = getMachineOpValue(MI, MO: MI.getOperand(i: 1), Fixups, STI);
383 Value |= (op & 0xf);
384 break;
385 }
386 case AVR::STSKRr: {
387 // op: rd
388 op = getMachineOpValue(MI, MO: MI.getOperand(i: 1), Fixups, STI);
389 Value |= (op & 0x1f) << 20;
390 // op: k
391 op = encodeImm<AVR::fixup_16, 2>(MI, OpNo: 0, Fixups, STI);
392 Value |= (op & 0xffff);
393 break;
394 }
395 case AVR::STSKRrTiny: {
396 // op: rd
397 op = getMachineOpValue(MI, MO: MI.getOperand(i: 1), Fixups, STI);
398 Value |= (op & 0xf) << 4;
399 // op: k
400 op = encodeImm<AVR::fixup_lds_sts_16, 0>(MI, OpNo: 0, Fixups, STI);
401 Value |= (op & 0x70) << 4;
402 Value |= (op & 0xf);
403 break;
404 }
405 case AVR::LDRdPtr:
406 case AVR::LDRdPtrPd:
407 case AVR::LDRdPtrPi: {
408 // op: reg
409 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
410 Value |= (op & 0x1f) << 4;
411 Value = loadStorePostEncoder(MI, EncodedValue: Value, STI);
412 break;
413 }
414 case AVR::STPtrRr: {
415 // op: reg
416 op = getMachineOpValue(MI, MO: MI.getOperand(i: 1), Fixups, STI);
417 Value |= (op & 0x1f) << 4;
418 Value = loadStorePostEncoder(MI, EncodedValue: Value, STI);
419 break;
420 }
421 case AVR::STPtrPdRr:
422 case AVR::STPtrPiRr: {
423 // op: reg
424 op = getMachineOpValue(MI, MO: MI.getOperand(i: 2), Fixups, STI);
425 Value |= (op & 0x1f) << 4;
426 Value = loadStorePostEncoder(MI, EncodedValue: Value, STI);
427 break;
428 }
429 case AVR::BCLRs:
430 case AVR::BSETs: {
431 // op: s
432 op = getMachineOpValue(MI, MO: MI.getOperand(i: 0), Fixups, STI);
433 Value |= (op & 0x7) << 4;
434 break;
435 }
436 default:
437 reportUnsupportedInst(Inst: MI);
438 }
439 return Value;
440}
441
442#ifdef GET_OPERAND_BIT_OFFSET
443#undef GET_OPERAND_BIT_OFFSET
444
445uint32_t AVRMCCodeEmitter::getOperandBitOffset(const MCInst &MI,
446 unsigned OpNum,
447 const MCSubtargetInfo &STI) const {
448 switch (MI.getOpcode()) {
449 case AVR::BREAK:
450 case AVR::EICALL:
451 case AVR::EIJMP:
452 case AVR::ELPM:
453 case AVR::ICALL:
454 case AVR::IJMP:
455 case AVR::LPM:
456 case AVR::NOP:
457 case AVR::RET:
458 case AVR::RETI:
459 case AVR::SLEEP:
460 case AVR::SPM:
461 case AVR::SPMZPi:
462 case AVR::WDR: {
463 break;
464 }
465 case AVR::OUTARr: {
466 switch (OpNum) {
467 case 0:
468 // op: A
469 return 0;
470 case 1:
471 // op: rr
472 return 4;
473 }
474 break;
475 }
476 case AVR::CBIAb:
477 case AVR::SBIAb:
478 case AVR::SBICAb:
479 case AVR::SBISAb: {
480 switch (OpNum) {
481 case 0:
482 // op: addr
483 return 3;
484 case 1:
485 // op: b
486 return 0;
487 }
488 break;
489 }
490 case AVR::CALLk:
491 case AVR::JMPk:
492 case AVR::RCALLk:
493 case AVR::RJMPk: {
494 switch (OpNum) {
495 case 0:
496 // op: k
497 return 0;
498 }
499 break;
500 }
501 case AVR::BREQk:
502 case AVR::BRGEk:
503 case AVR::BRLOk:
504 case AVR::BRLTk:
505 case AVR::BRMIk:
506 case AVR::BRNEk:
507 case AVR::BRPLk:
508 case AVR::BRSHk: {
509 switch (OpNum) {
510 case 0:
511 // op: k
512 return 3;
513 }
514 break;
515 }
516 case AVR::DESK: {
517 switch (OpNum) {
518 case 0:
519 // op: k
520 return 4;
521 }
522 break;
523 }
524 case AVR::STDPtrQRr: {
525 switch (OpNum) {
526 case 0:
527 // op: memri
528 return 0;
529 case 2:
530 // op: reg
531 return 4;
532 }
533 break;
534 }
535 case AVR::LDSRdK: {
536 switch (OpNum) {
537 case 0:
538 // op: rd
539 return 20;
540 case 1:
541 // op: k
542 return 0;
543 }
544 break;
545 }
546 case AVR::INRdA: {
547 switch (OpNum) {
548 case 0:
549 // op: rd
550 return 4;
551 case 1:
552 // op: A
553 return 0;
554 }
555 break;
556 }
557 case AVR::BST:
558 case AVR::SBRCRrB:
559 case AVR::SBRSRrB: {
560 switch (OpNum) {
561 case 0:
562 // op: rd
563 return 4;
564 case 1:
565 // op: b
566 return 0;
567 }
568 break;
569 }
570 case AVR::CPIRdK:
571 case AVR::LDIRdK:
572 case AVR::LDSRdKTiny: {
573 switch (OpNum) {
574 case 0:
575 // op: rd
576 return 4;
577 case 1:
578 // op: k
579 return 0;
580 }
581 break;
582 }
583 case AVR::CPCRdRr:
584 case AVR::CPRdRr:
585 case AVR::CPSE:
586 case AVR::FMUL:
587 case AVR::FMULS:
588 case AVR::FMULSU:
589 case AVR::MOVRdRr:
590 case AVR::MOVWRdRr:
591 case AVR::MULRdRr:
592 case AVR::MULSRdRr:
593 case AVR::MULSURdRr: {
594 switch (OpNum) {
595 case 0:
596 // op: rd
597 return 4;
598 case 1:
599 // op: rr
600 return 0;
601 }
602 break;
603 }
604 case AVR::BLD: {
605 switch (OpNum) {
606 case 0:
607 // op: rd
608 return 4;
609 case 2:
610 // op: b
611 return 0;
612 }
613 break;
614 }
615 case AVR::ADIWRdK:
616 case AVR::ANDIRdK:
617 case AVR::ORIRdK:
618 case AVR::SBCIRdK:
619 case AVR::SBIWRdK:
620 case AVR::SUBIRdK: {
621 switch (OpNum) {
622 case 0:
623 // op: rd
624 return 4;
625 case 2:
626 // op: k
627 return 0;
628 }
629 break;
630 }
631 case AVR::ADCRdRr:
632 case AVR::ADDRdRr:
633 case AVR::ANDRdRr:
634 case AVR::EORRdRr:
635 case AVR::ORRdRr:
636 case AVR::SBCRdRr:
637 case AVR::SUBRdRr: {
638 switch (OpNum) {
639 case 0:
640 // op: rd
641 return 4;
642 case 2:
643 // op: rr
644 return 0;
645 }
646 break;
647 }
648 case AVR::ASRRd:
649 case AVR::COMRd:
650 case AVR::DECRd:
651 case AVR::ELPMRdZ:
652 case AVR::ELPMRdZPi:
653 case AVR::INCRd:
654 case AVR::LACZRd:
655 case AVR::LASZRd:
656 case AVR::LATZRd:
657 case AVR::LPMRdZ:
658 case AVR::LPMRdZPi:
659 case AVR::LSRRd:
660 case AVR::NEGRd:
661 case AVR::POPRd:
662 case AVR::PUSHRr:
663 case AVR::RORRd:
664 case AVR::SWAPRd:
665 case AVR::XCHZRd: {
666 switch (OpNum) {
667 case 0:
668 // op: rd
669 return 4;
670 }
671 break;
672 }
673 case AVR::LDRdPtr:
674 case AVR::LDRdPtrPd:
675 case AVR::LDRdPtrPi: {
676 switch (OpNum) {
677 case 0:
678 // op: reg
679 return 4;
680 }
681 break;
682 }
683 case AVR::BCLRs:
684 case AVR::BSETs: {
685 switch (OpNum) {
686 case 0:
687 // op: s
688 return 4;
689 }
690 break;
691 }
692 case AVR::BRBCsk:
693 case AVR::BRBSsk: {
694 switch (OpNum) {
695 case 1:
696 // op: k
697 return 3;
698 case 0:
699 // op: s
700 return 0;
701 }
702 break;
703 }
704 case AVR::LDDRdPtrQ: {
705 switch (OpNum) {
706 case 1:
707 // op: memri
708 return 0;
709 case 0:
710 // op: reg
711 return 4;
712 }
713 break;
714 }
715 case AVR::STSKRr: {
716 switch (OpNum) {
717 case 1:
718 // op: rd
719 return 20;
720 case 0:
721 // op: k
722 return 0;
723 }
724 break;
725 }
726 case AVR::STSKRrTiny: {
727 switch (OpNum) {
728 case 1:
729 // op: rd
730 return 4;
731 case 0:
732 // op: k
733 return 0;
734 }
735 break;
736 }
737 case AVR::STPtrRr: {
738 switch (OpNum) {
739 case 1:
740 // op: reg
741 return 4;
742 }
743 break;
744 }
745 case AVR::STPtrPdRr:
746 case AVR::STPtrPiRr: {
747 switch (OpNum) {
748 case 2:
749 // op: reg
750 return 4;
751 }
752 break;
753 }
754 default:
755 reportUnsupportedInst(MI);
756 }
757 reportUnsupportedOperand(MI, OpNum);
758}
759
760#endif // GET_OPERAND_BIT_OFFSET
761
762