Line data Source code
1 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2 : |* *|
3 : |* Pseudo-instruction MC lowering Source Fragment *|
4 : |* *|
5 : |* Automatically generated file, do not edit! *|
6 : |* *|
7 : \*===----------------------------------------------------------------------===*/
8 :
9 125121 : bool MipsAsmPrinter::
10 : emitPseudoExpansionLowering(MCStreamer &OutStreamer,
11 : const MachineInstr *MI) {
12 250242 : switch (MI->getOpcode()) {
13 : default: return false;
14 : case Mips::AND_V_D_PSEUDO: {
15 : MCInst TmpInst;
16 : MCOperand MCOp;
17 : TmpInst.setOpcode(Mips::AND_V);
18 : // Operand: wd
19 6 : lowerOperand(MI->getOperand(0), MCOp);
20 : TmpInst.addOperand(MCOp);
21 : // Operand: ws
22 6 : lowerOperand(MI->getOperand(1), MCOp);
23 : TmpInst.addOperand(MCOp);
24 : // Operand: wt
25 6 : lowerOperand(MI->getOperand(2), MCOp);
26 : TmpInst.addOperand(MCOp);
27 6 : EmitToStreamer(OutStreamer, TmpInst);
28 : break;
29 : }
30 : case Mips::AND_V_H_PSEUDO: {
31 : MCInst TmpInst;
32 : MCOperand MCOp;
33 : TmpInst.setOpcode(Mips::AND_V);
34 : // Operand: wd
35 6 : lowerOperand(MI->getOperand(0), MCOp);
36 : TmpInst.addOperand(MCOp);
37 : // Operand: ws
38 6 : lowerOperand(MI->getOperand(1), MCOp);
39 : TmpInst.addOperand(MCOp);
40 : // Operand: wt
41 6 : lowerOperand(MI->getOperand(2), MCOp);
42 : TmpInst.addOperand(MCOp);
43 6 : EmitToStreamer(OutStreamer, TmpInst);
44 : break;
45 : }
46 : case Mips::AND_V_W_PSEUDO: {
47 : MCInst TmpInst;
48 : MCOperand MCOp;
49 : TmpInst.setOpcode(Mips::AND_V);
50 : // Operand: wd
51 6 : lowerOperand(MI->getOperand(0), MCOp);
52 : TmpInst.addOperand(MCOp);
53 : // Operand: ws
54 6 : lowerOperand(MI->getOperand(1), MCOp);
55 : TmpInst.addOperand(MCOp);
56 : // Operand: wt
57 6 : lowerOperand(MI->getOperand(2), MCOp);
58 : TmpInst.addOperand(MCOp);
59 6 : EmitToStreamer(OutStreamer, TmpInst);
60 : break;
61 : }
62 : case Mips::B: {
63 : MCInst TmpInst;
64 : MCOperand MCOp;
65 : TmpInst.setOpcode(Mips::BEQ);
66 : // Operand: rs
67 66 : TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
68 : // Operand: rt
69 66 : TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
70 : // Operand: offset
71 66 : lowerOperand(MI->getOperand(0), MCOp);
72 : TmpInst.addOperand(MCOp);
73 66 : EmitToStreamer(OutStreamer, TmpInst);
74 : break;
75 : }
76 : case Mips::BAL_BR: {
77 : MCInst TmpInst;
78 : MCOperand MCOp;
79 : TmpInst.setOpcode(Mips::BGEZAL);
80 : // Operand: rs
81 10 : TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
82 : // Operand: offset
83 10 : lowerOperand(MI->getOperand(0), MCOp);
84 : TmpInst.addOperand(MCOp);
85 10 : EmitToStreamer(OutStreamer, TmpInst);
86 : break;
87 : }
88 : case Mips::BAL_BR_MM: {
89 : MCInst TmpInst;
90 : MCOperand MCOp;
91 : TmpInst.setOpcode(Mips::BGEZAL_MM);
92 : // Operand: rs
93 6 : TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
94 : // Operand: offset
95 6 : lowerOperand(MI->getOperand(0), MCOp);
96 : TmpInst.addOperand(MCOp);
97 6 : EmitToStreamer(OutStreamer, TmpInst);
98 : break;
99 : }
100 : case Mips::BSEL_D_PSEUDO: {
101 : MCInst TmpInst;
102 : MCOperand MCOp;
103 : TmpInst.setOpcode(Mips::BSEL_V);
104 : // Operand: wd
105 10 : lowerOperand(MI->getOperand(0), MCOp);
106 : TmpInst.addOperand(MCOp);
107 : // Operand: wd_in
108 10 : lowerOperand(MI->getOperand(1), MCOp);
109 : TmpInst.addOperand(MCOp);
110 : // Operand: ws
111 10 : lowerOperand(MI->getOperand(2), MCOp);
112 : TmpInst.addOperand(MCOp);
113 : // Operand: wt
114 10 : lowerOperand(MI->getOperand(3), MCOp);
115 : TmpInst.addOperand(MCOp);
116 10 : EmitToStreamer(OutStreamer, TmpInst);
117 : break;
118 : }
119 : case Mips::BSEL_FD_PSEUDO: {
120 : MCInst TmpInst;
121 : MCOperand MCOp;
122 : TmpInst.setOpcode(Mips::BSEL_V);
123 : // Operand: wd
124 4 : lowerOperand(MI->getOperand(0), MCOp);
125 : TmpInst.addOperand(MCOp);
126 : // Operand: wd_in
127 4 : lowerOperand(MI->getOperand(1), MCOp);
128 : TmpInst.addOperand(MCOp);
129 : // Operand: ws
130 4 : lowerOperand(MI->getOperand(2), MCOp);
131 : TmpInst.addOperand(MCOp);
132 : // Operand: wt
133 4 : lowerOperand(MI->getOperand(3), MCOp);
134 : TmpInst.addOperand(MCOp);
135 4 : EmitToStreamer(OutStreamer, TmpInst);
136 : break;
137 : }
138 : case Mips::BSEL_FW_PSEUDO: {
139 : MCInst TmpInst;
140 : MCOperand MCOp;
141 : TmpInst.setOpcode(Mips::BSEL_V);
142 : // Operand: wd
143 8 : lowerOperand(MI->getOperand(0), MCOp);
144 : TmpInst.addOperand(MCOp);
145 : // Operand: wd_in
146 8 : lowerOperand(MI->getOperand(1), MCOp);
147 : TmpInst.addOperand(MCOp);
148 : // Operand: ws
149 8 : lowerOperand(MI->getOperand(2), MCOp);
150 : TmpInst.addOperand(MCOp);
151 : // Operand: wt
152 8 : lowerOperand(MI->getOperand(3), MCOp);
153 : TmpInst.addOperand(MCOp);
154 8 : EmitToStreamer(OutStreamer, TmpInst);
155 : break;
156 : }
157 : case Mips::BSEL_H_PSEUDO: {
158 : MCInst TmpInst;
159 : MCOperand MCOp;
160 : TmpInst.setOpcode(Mips::BSEL_V);
161 : // Operand: wd
162 10 : lowerOperand(MI->getOperand(0), MCOp);
163 : TmpInst.addOperand(MCOp);
164 : // Operand: wd_in
165 10 : lowerOperand(MI->getOperand(1), MCOp);
166 : TmpInst.addOperand(MCOp);
167 : // Operand: ws
168 10 : lowerOperand(MI->getOperand(2), MCOp);
169 : TmpInst.addOperand(MCOp);
170 : // Operand: wt
171 10 : lowerOperand(MI->getOperand(3), MCOp);
172 : TmpInst.addOperand(MCOp);
173 10 : EmitToStreamer(OutStreamer, TmpInst);
174 : break;
175 : }
176 : case Mips::BSEL_W_PSEUDO: {
177 : MCInst TmpInst;
178 : MCOperand MCOp;
179 : TmpInst.setOpcode(Mips::BSEL_V);
180 : // Operand: wd
181 10 : lowerOperand(MI->getOperand(0), MCOp);
182 : TmpInst.addOperand(MCOp);
183 : // Operand: wd_in
184 10 : lowerOperand(MI->getOperand(1), MCOp);
185 : TmpInst.addOperand(MCOp);
186 : // Operand: ws
187 10 : lowerOperand(MI->getOperand(2), MCOp);
188 : TmpInst.addOperand(MCOp);
189 : // Operand: wt
190 10 : lowerOperand(MI->getOperand(3), MCOp);
191 : TmpInst.addOperand(MCOp);
192 10 : EmitToStreamer(OutStreamer, TmpInst);
193 : break;
194 : }
195 : case Mips::B_MM: {
196 : MCInst TmpInst;
197 : MCOperand MCOp;
198 : TmpInst.setOpcode(Mips::BEQ_MM);
199 : // Operand: rs
200 4 : TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
201 : // Operand: rt
202 4 : TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
203 : // Operand: offset
204 4 : lowerOperand(MI->getOperand(0), MCOp);
205 : TmpInst.addOperand(MCOp);
206 4 : EmitToStreamer(OutStreamer, TmpInst);
207 : break;
208 : }
209 : case Mips::FABS_D: {
210 : MCInst TmpInst;
211 : MCOperand MCOp;
212 : TmpInst.setOpcode(Mips::FMAX_A_D);
213 : // Operand: wd
214 2 : lowerOperand(MI->getOperand(0), MCOp);
215 : TmpInst.addOperand(MCOp);
216 : // Operand: ws
217 2 : lowerOperand(MI->getOperand(1), MCOp);
218 : TmpInst.addOperand(MCOp);
219 : // Operand: wt
220 2 : lowerOperand(MI->getOperand(1), MCOp);
221 : TmpInst.addOperand(MCOp);
222 2 : EmitToStreamer(OutStreamer, TmpInst);
223 : break;
224 : }
225 : case Mips::FABS_W: {
226 : MCInst TmpInst;
227 : MCOperand MCOp;
228 : TmpInst.setOpcode(Mips::FMAX_A_W);
229 : // Operand: wd
230 2 : lowerOperand(MI->getOperand(0), MCOp);
231 : TmpInst.addOperand(MCOp);
232 : // Operand: ws
233 2 : lowerOperand(MI->getOperand(1), MCOp);
234 : TmpInst.addOperand(MCOp);
235 : // Operand: wt
236 2 : lowerOperand(MI->getOperand(1), MCOp);
237 : TmpInst.addOperand(MCOp);
238 2 : EmitToStreamer(OutStreamer, TmpInst);
239 : break;
240 : }
241 : case Mips::JALR64Pseudo: {
242 : MCInst TmpInst;
243 : MCOperand MCOp;
244 : TmpInst.setOpcode(Mips::JALR);
245 : // Operand: rd
246 453 : TmpInst.addOperand(MCOperand::createReg(Mips::RA));
247 : // Operand: rs
248 453 : lowerOperand(MI->getOperand(0), MCOp);
249 : TmpInst.addOperand(MCOp);
250 453 : EmitToStreamer(OutStreamer, TmpInst);
251 : break;
252 : }
253 : case Mips::JALRHB64Pseudo: {
254 : MCInst TmpInst;
255 : MCOperand MCOp;
256 : TmpInst.setOpcode(Mips::JALR_HB64);
257 : // Operand: rd
258 6 : TmpInst.addOperand(MCOperand::createReg(Mips::RA_64));
259 : // Operand: rs
260 6 : lowerOperand(MI->getOperand(0), MCOp);
261 : TmpInst.addOperand(MCOp);
262 6 : EmitToStreamer(OutStreamer, TmpInst);
263 : break;
264 : }
265 : case Mips::JALRHBPseudo: {
266 : MCInst TmpInst;
267 : MCOperand MCOp;
268 : TmpInst.setOpcode(Mips::JALR_HB);
269 : // Operand: rd
270 8 : TmpInst.addOperand(MCOperand::createReg(Mips::RA));
271 : // Operand: rs
272 8 : lowerOperand(MI->getOperand(0), MCOp);
273 : TmpInst.addOperand(MCOp);
274 8 : EmitToStreamer(OutStreamer, TmpInst);
275 : break;
276 : }
277 : case Mips::JALRPseudo: {
278 : MCInst TmpInst;
279 : MCOperand MCOp;
280 : TmpInst.setOpcode(Mips::JALR);
281 : // Operand: rd
282 501 : TmpInst.addOperand(MCOperand::createReg(Mips::RA));
283 : // Operand: rs
284 501 : lowerOperand(MI->getOperand(0), MCOp);
285 : TmpInst.addOperand(MCOp);
286 501 : EmitToStreamer(OutStreamer, TmpInst);
287 : break;
288 : }
289 : case Mips::NOP: {
290 : MCInst TmpInst;
291 : MCOperand MCOp;
292 : TmpInst.setOpcode(Mips::SLL);
293 : // Operand: rd
294 3557 : TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
295 : // Operand: rt
296 3557 : TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
297 : // Operand: shamt
298 3557 : TmpInst.addOperand(MCOperand::createImm(0));
299 3557 : EmitToStreamer(OutStreamer, TmpInst);
300 : break;
301 : }
302 : case Mips::NOR_V_D_PSEUDO: {
303 : MCInst TmpInst;
304 : MCOperand MCOp;
305 : TmpInst.setOpcode(Mips::NOR_V);
306 : // Operand: wd
307 4 : lowerOperand(MI->getOperand(0), MCOp);
308 : TmpInst.addOperand(MCOp);
309 : // Operand: ws
310 4 : lowerOperand(MI->getOperand(1), MCOp);
311 : TmpInst.addOperand(MCOp);
312 : // Operand: wt
313 4 : lowerOperand(MI->getOperand(2), MCOp);
314 : TmpInst.addOperand(MCOp);
315 4 : EmitToStreamer(OutStreamer, TmpInst);
316 : break;
317 : }
318 : case Mips::NOR_V_H_PSEUDO: {
319 : MCInst TmpInst;
320 : MCOperand MCOp;
321 : TmpInst.setOpcode(Mips::NOR_V);
322 : // Operand: wd
323 4 : lowerOperand(MI->getOperand(0), MCOp);
324 : TmpInst.addOperand(MCOp);
325 : // Operand: ws
326 4 : lowerOperand(MI->getOperand(1), MCOp);
327 : TmpInst.addOperand(MCOp);
328 : // Operand: wt
329 4 : lowerOperand(MI->getOperand(2), MCOp);
330 : TmpInst.addOperand(MCOp);
331 4 : EmitToStreamer(OutStreamer, TmpInst);
332 : break;
333 : }
334 : case Mips::NOR_V_W_PSEUDO: {
335 : MCInst TmpInst;
336 : MCOperand MCOp;
337 : TmpInst.setOpcode(Mips::NOR_V);
338 : // Operand: wd
339 4 : lowerOperand(MI->getOperand(0), MCOp);
340 : TmpInst.addOperand(MCOp);
341 : // Operand: ws
342 4 : lowerOperand(MI->getOperand(1), MCOp);
343 : TmpInst.addOperand(MCOp);
344 : // Operand: wt
345 4 : lowerOperand(MI->getOperand(2), MCOp);
346 : TmpInst.addOperand(MCOp);
347 4 : EmitToStreamer(OutStreamer, TmpInst);
348 : break;
349 : }
350 : case Mips::OR_V_D_PSEUDO: {
351 : MCInst TmpInst;
352 : MCOperand MCOp;
353 : TmpInst.setOpcode(Mips::OR_V);
354 : // Operand: wd
355 6 : lowerOperand(MI->getOperand(0), MCOp);
356 : TmpInst.addOperand(MCOp);
357 : // Operand: ws
358 6 : lowerOperand(MI->getOperand(1), MCOp);
359 : TmpInst.addOperand(MCOp);
360 : // Operand: wt
361 6 : lowerOperand(MI->getOperand(2), MCOp);
362 : TmpInst.addOperand(MCOp);
363 6 : EmitToStreamer(OutStreamer, TmpInst);
364 : break;
365 : }
366 : case Mips::OR_V_H_PSEUDO: {
367 : MCInst TmpInst;
368 : MCOperand MCOp;
369 : TmpInst.setOpcode(Mips::OR_V);
370 : // Operand: wd
371 6 : lowerOperand(MI->getOperand(0), MCOp);
372 : TmpInst.addOperand(MCOp);
373 : // Operand: ws
374 6 : lowerOperand(MI->getOperand(1), MCOp);
375 : TmpInst.addOperand(MCOp);
376 : // Operand: wt
377 6 : lowerOperand(MI->getOperand(2), MCOp);
378 : TmpInst.addOperand(MCOp);
379 6 : EmitToStreamer(OutStreamer, TmpInst);
380 : break;
381 : }
382 : case Mips::OR_V_W_PSEUDO: {
383 : MCInst TmpInst;
384 : MCOperand MCOp;
385 : TmpInst.setOpcode(Mips::OR_V);
386 : // Operand: wd
387 6 : lowerOperand(MI->getOperand(0), MCOp);
388 : TmpInst.addOperand(MCOp);
389 : // Operand: ws
390 6 : lowerOperand(MI->getOperand(1), MCOp);
391 : TmpInst.addOperand(MCOp);
392 : // Operand: wt
393 6 : lowerOperand(MI->getOperand(2), MCOp);
394 : TmpInst.addOperand(MCOp);
395 6 : EmitToStreamer(OutStreamer, TmpInst);
396 : break;
397 : }
398 : case Mips::PseudoCMPU_EQ_QB: {
399 : MCInst TmpInst;
400 : MCOperand MCOp;
401 : TmpInst.setOpcode(Mips::CMPU_EQ_QB);
402 : // Operand: rs
403 4 : lowerOperand(MI->getOperand(1), MCOp);
404 : TmpInst.addOperand(MCOp);
405 : // Operand: rt
406 4 : lowerOperand(MI->getOperand(2), MCOp);
407 : TmpInst.addOperand(MCOp);
408 4 : EmitToStreamer(OutStreamer, TmpInst);
409 : break;
410 : }
411 : case Mips::PseudoCMPU_LE_QB: {
412 : MCInst TmpInst;
413 : MCOperand MCOp;
414 : TmpInst.setOpcode(Mips::CMPU_LE_QB);
415 : // Operand: rs
416 8 : lowerOperand(MI->getOperand(1), MCOp);
417 : TmpInst.addOperand(MCOp);
418 : // Operand: rt
419 4 : lowerOperand(MI->getOperand(2), MCOp);
420 : TmpInst.addOperand(MCOp);
421 4 : EmitToStreamer(OutStreamer, TmpInst);
422 : break;
423 : }
424 : case Mips::PseudoCMPU_LT_QB: {
425 : MCInst TmpInst;
426 : MCOperand MCOp;
427 : TmpInst.setOpcode(Mips::CMPU_LT_QB);
428 : // Operand: rs
429 4 : lowerOperand(MI->getOperand(1), MCOp);
430 : TmpInst.addOperand(MCOp);
431 : // Operand: rt
432 4 : lowerOperand(MI->getOperand(2), MCOp);
433 : TmpInst.addOperand(MCOp);
434 4 : EmitToStreamer(OutStreamer, TmpInst);
435 : break;
436 : }
437 : case Mips::PseudoCMP_EQ_PH: {
438 : MCInst TmpInst;
439 : MCOperand MCOp;
440 : TmpInst.setOpcode(Mips::CMP_EQ_PH);
441 : // Operand: rs
442 4 : lowerOperand(MI->getOperand(1), MCOp);
443 : TmpInst.addOperand(MCOp);
444 : // Operand: rt
445 4 : lowerOperand(MI->getOperand(2), MCOp);
446 : TmpInst.addOperand(MCOp);
447 4 : EmitToStreamer(OutStreamer, TmpInst);
448 : break;
449 : }
450 : case Mips::PseudoCMP_LE_PH: {
451 : MCInst TmpInst;
452 : MCOperand MCOp;
453 : TmpInst.setOpcode(Mips::CMP_LE_PH);
454 : // Operand: rs
455 4 : lowerOperand(MI->getOperand(1), MCOp);
456 : TmpInst.addOperand(MCOp);
457 : // Operand: rt
458 4 : lowerOperand(MI->getOperand(2), MCOp);
459 : TmpInst.addOperand(MCOp);
460 4 : EmitToStreamer(OutStreamer, TmpInst);
461 : break;
462 : }
463 : case Mips::PseudoCMP_LT_PH: {
464 : MCInst TmpInst;
465 : MCOperand MCOp;
466 : TmpInst.setOpcode(Mips::CMP_LT_PH);
467 : // Operand: rs
468 5 : lowerOperand(MI->getOperand(1), MCOp);
469 : TmpInst.addOperand(MCOp);
470 : // Operand: rt
471 5 : lowerOperand(MI->getOperand(2), MCOp);
472 : TmpInst.addOperand(MCOp);
473 5 : EmitToStreamer(OutStreamer, TmpInst);
474 : break;
475 : }
476 : case Mips::PseudoDMULT: {
477 : MCInst TmpInst;
478 : MCOperand MCOp;
479 : TmpInst.setOpcode(Mips::DMULT);
480 : // Operand: rs
481 54 : lowerOperand(MI->getOperand(1), MCOp);
482 : TmpInst.addOperand(MCOp);
483 : // Operand: rt
484 54 : lowerOperand(MI->getOperand(2), MCOp);
485 : TmpInst.addOperand(MCOp);
486 54 : EmitToStreamer(OutStreamer, TmpInst);
487 : break;
488 : }
489 : case Mips::PseudoDMULTu: {
490 : MCInst TmpInst;
491 : MCOperand MCOp;
492 : TmpInst.setOpcode(Mips::DMULTu);
493 : // Operand: rs
494 5 : lowerOperand(MI->getOperand(1), MCOp);
495 : TmpInst.addOperand(MCOp);
496 : // Operand: rt
497 5 : lowerOperand(MI->getOperand(2), MCOp);
498 : TmpInst.addOperand(MCOp);
499 5 : EmitToStreamer(OutStreamer, TmpInst);
500 : break;
501 : }
502 : case Mips::PseudoDSDIV: {
503 : MCInst TmpInst;
504 : MCOperand MCOp;
505 : TmpInst.setOpcode(Mips::DSDIV);
506 : // Operand: rs
507 36 : lowerOperand(MI->getOperand(1), MCOp);
508 : TmpInst.addOperand(MCOp);
509 : // Operand: rt
510 36 : lowerOperand(MI->getOperand(2), MCOp);
511 : TmpInst.addOperand(MCOp);
512 36 : EmitToStreamer(OutStreamer, TmpInst);
513 : break;
514 : }
515 : case Mips::PseudoDUDIV: {
516 : MCInst TmpInst;
517 : MCOperand MCOp;
518 : TmpInst.setOpcode(Mips::DUDIV);
519 : // Operand: rs
520 36 : lowerOperand(MI->getOperand(1), MCOp);
521 : TmpInst.addOperand(MCOp);
522 : // Operand: rt
523 36 : lowerOperand(MI->getOperand(2), MCOp);
524 : TmpInst.addOperand(MCOp);
525 36 : EmitToStreamer(OutStreamer, TmpInst);
526 : break;
527 : }
528 : case Mips::PseudoIndirectBranch: {
529 : MCInst TmpInst;
530 : MCOperand MCOp;
531 : TmpInst.setOpcode(Mips::JR);
532 : // Operand: rs
533 16 : lowerOperand(MI->getOperand(0), MCOp);
534 : TmpInst.addOperand(MCOp);
535 16 : EmitToStreamer(OutStreamer, TmpInst);
536 : break;
537 : }
538 : case Mips::PseudoIndirectBranch64: {
539 : MCInst TmpInst;
540 : MCOperand MCOp;
541 : TmpInst.setOpcode(Mips::JR64);
542 : // Operand: rs
543 13 : lowerOperand(MI->getOperand(0), MCOp);
544 : TmpInst.addOperand(MCOp);
545 13 : EmitToStreamer(OutStreamer, TmpInst);
546 : break;
547 : }
548 : case Mips::PseudoIndirectBranch64R6: {
549 : MCInst TmpInst;
550 : MCOperand MCOp;
551 : TmpInst.setOpcode(Mips::JALR64);
552 : // Operand: rd
553 0 : TmpInst.addOperand(MCOperand::createReg(Mips::ZERO_64));
554 : // Operand: rs
555 0 : lowerOperand(MI->getOperand(0), MCOp);
556 : TmpInst.addOperand(MCOp);
557 0 : EmitToStreamer(OutStreamer, TmpInst);
558 : break;
559 : }
560 : case Mips::PseudoIndirectBranchR6: {
561 : MCInst TmpInst;
562 : MCOperand MCOp;
563 : TmpInst.setOpcode(Mips::JALR);
564 : // Operand: rd
565 0 : TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
566 : // Operand: rs
567 0 : lowerOperand(MI->getOperand(0), MCOp);
568 : TmpInst.addOperand(MCOp);
569 0 : EmitToStreamer(OutStreamer, TmpInst);
570 : break;
571 : }
572 : case Mips::PseudoIndirectBranch_MM: {
573 : MCInst TmpInst;
574 : MCOperand MCOp;
575 : TmpInst.setOpcode(Mips::JR_MM);
576 : // Operand: rs
577 1 : lowerOperand(MI->getOperand(0), MCOp);
578 : TmpInst.addOperand(MCOp);
579 1 : EmitToStreamer(OutStreamer, TmpInst);
580 : break;
581 : }
582 : case Mips::PseudoIndirectBranch_MMR6: {
583 : MCInst TmpInst;
584 : MCOperand MCOp;
585 : TmpInst.setOpcode(Mips::JRC16_MMR6);
586 : // Operand: rs
587 0 : lowerOperand(MI->getOperand(0), MCOp);
588 : TmpInst.addOperand(MCOp);
589 0 : EmitToStreamer(OutStreamer, TmpInst);
590 : break;
591 : }
592 : case Mips::PseudoIndirectHazardBranch: {
593 : MCInst TmpInst;
594 : MCOperand MCOp;
595 : TmpInst.setOpcode(Mips::JR_HB);
596 : // Operand: rs
597 2 : lowerOperand(MI->getOperand(0), MCOp);
598 : TmpInst.addOperand(MCOp);
599 2 : EmitToStreamer(OutStreamer, TmpInst);
600 : break;
601 : }
602 : case Mips::PseudoIndirectHazardBranch64: {
603 : MCInst TmpInst;
604 : MCOperand MCOp;
605 : TmpInst.setOpcode(Mips::JR_HB64);
606 : // Operand: rs
607 2 : lowerOperand(MI->getOperand(0), MCOp);
608 : TmpInst.addOperand(MCOp);
609 2 : EmitToStreamer(OutStreamer, TmpInst);
610 : break;
611 : }
612 : case Mips::PseudoIndrectHazardBranch64R6: {
613 : MCInst TmpInst;
614 : MCOperand MCOp;
615 : TmpInst.setOpcode(Mips::JR_HB64_R6);
616 : // Operand: rs
617 2 : lowerOperand(MI->getOperand(0), MCOp);
618 : TmpInst.addOperand(MCOp);
619 2 : EmitToStreamer(OutStreamer, TmpInst);
620 : break;
621 : }
622 : case Mips::PseudoIndrectHazardBranchR6: {
623 : MCInst TmpInst;
624 : MCOperand MCOp;
625 : TmpInst.setOpcode(Mips::JR_HB_R6);
626 : // Operand: rs
627 2 : lowerOperand(MI->getOperand(0), MCOp);
628 : TmpInst.addOperand(MCOp);
629 2 : EmitToStreamer(OutStreamer, TmpInst);
630 : break;
631 : }
632 : case Mips::PseudoMADD: {
633 : MCInst TmpInst;
634 : MCOperand MCOp;
635 : TmpInst.setOpcode(Mips::MADD);
636 : // Operand: rs
637 4 : lowerOperand(MI->getOperand(1), MCOp);
638 : TmpInst.addOperand(MCOp);
639 : // Operand: rt
640 4 : lowerOperand(MI->getOperand(2), MCOp);
641 : TmpInst.addOperand(MCOp);
642 4 : EmitToStreamer(OutStreamer, TmpInst);
643 : break;
644 : }
645 : case Mips::PseudoMADDU: {
646 : MCInst TmpInst;
647 : MCOperand MCOp;
648 : TmpInst.setOpcode(Mips::MADDU);
649 : // Operand: rs
650 2 : lowerOperand(MI->getOperand(1), MCOp);
651 : TmpInst.addOperand(MCOp);
652 : // Operand: rt
653 2 : lowerOperand(MI->getOperand(2), MCOp);
654 : TmpInst.addOperand(MCOp);
655 2 : EmitToStreamer(OutStreamer, TmpInst);
656 : break;
657 : }
658 : case Mips::PseudoMADDU_MM: {
659 : MCInst TmpInst;
660 : MCOperand MCOp;
661 : TmpInst.setOpcode(Mips::MADDU);
662 : // Operand: rs
663 0 : lowerOperand(MI->getOperand(1), MCOp);
664 : TmpInst.addOperand(MCOp);
665 : // Operand: rt
666 0 : lowerOperand(MI->getOperand(2), MCOp);
667 : TmpInst.addOperand(MCOp);
668 0 : EmitToStreamer(OutStreamer, TmpInst);
669 : break;
670 : }
671 : case Mips::PseudoMADD_MM: {
672 : MCInst TmpInst;
673 : MCOperand MCOp;
674 : TmpInst.setOpcode(Mips::MADD);
675 : // Operand: rs
676 0 : lowerOperand(MI->getOperand(1), MCOp);
677 : TmpInst.addOperand(MCOp);
678 : // Operand: rt
679 0 : lowerOperand(MI->getOperand(2), MCOp);
680 : TmpInst.addOperand(MCOp);
681 0 : EmitToStreamer(OutStreamer, TmpInst);
682 : break;
683 : }
684 : case Mips::PseudoMSUB: {
685 : MCInst TmpInst;
686 : MCOperand MCOp;
687 : TmpInst.setOpcode(Mips::MSUB);
688 : // Operand: rs
689 4 : lowerOperand(MI->getOperand(1), MCOp);
690 : TmpInst.addOperand(MCOp);
691 : // Operand: rt
692 4 : lowerOperand(MI->getOperand(2), MCOp);
693 : TmpInst.addOperand(MCOp);
694 4 : EmitToStreamer(OutStreamer, TmpInst);
695 : break;
696 : }
697 : case Mips::PseudoMSUBU: {
698 : MCInst TmpInst;
699 : MCOperand MCOp;
700 : TmpInst.setOpcode(Mips::MSUBU);
701 : // Operand: rs
702 2 : lowerOperand(MI->getOperand(1), MCOp);
703 : TmpInst.addOperand(MCOp);
704 : // Operand: rt
705 2 : lowerOperand(MI->getOperand(2), MCOp);
706 : TmpInst.addOperand(MCOp);
707 2 : EmitToStreamer(OutStreamer, TmpInst);
708 : break;
709 : }
710 : case Mips::PseudoMSUBU_MM: {
711 : MCInst TmpInst;
712 : MCOperand MCOp;
713 : TmpInst.setOpcode(Mips::MSUBU);
714 : // Operand: rs
715 0 : lowerOperand(MI->getOperand(1), MCOp);
716 : TmpInst.addOperand(MCOp);
717 : // Operand: rt
718 0 : lowerOperand(MI->getOperand(2), MCOp);
719 : TmpInst.addOperand(MCOp);
720 0 : EmitToStreamer(OutStreamer, TmpInst);
721 : break;
722 : }
723 : case Mips::PseudoMSUB_MM: {
724 : MCInst TmpInst;
725 : MCOperand MCOp;
726 : TmpInst.setOpcode(Mips::MSUB);
727 : // Operand: rs
728 0 : lowerOperand(MI->getOperand(1), MCOp);
729 : TmpInst.addOperand(MCOp);
730 : // Operand: rt
731 0 : lowerOperand(MI->getOperand(2), MCOp);
732 : TmpInst.addOperand(MCOp);
733 0 : EmitToStreamer(OutStreamer, TmpInst);
734 : break;
735 : }
736 : case Mips::PseudoMULT: {
737 : MCInst TmpInst;
738 : MCOperand MCOp;
739 : TmpInst.setOpcode(Mips::MULT);
740 : // Operand: rs
741 11 : lowerOperand(MI->getOperand(1), MCOp);
742 : TmpInst.addOperand(MCOp);
743 : // Operand: rt
744 11 : lowerOperand(MI->getOperand(2), MCOp);
745 : TmpInst.addOperand(MCOp);
746 11 : EmitToStreamer(OutStreamer, TmpInst);
747 : break;
748 : }
749 : case Mips::PseudoMULT_MM: {
750 : MCInst TmpInst;
751 : MCOperand MCOp;
752 : TmpInst.setOpcode(Mips::MULT);
753 : // Operand: rs
754 0 : lowerOperand(MI->getOperand(1), MCOp);
755 : TmpInst.addOperand(MCOp);
756 : // Operand: rt
757 0 : lowerOperand(MI->getOperand(2), MCOp);
758 : TmpInst.addOperand(MCOp);
759 0 : EmitToStreamer(OutStreamer, TmpInst);
760 : break;
761 : }
762 : case Mips::PseudoMULTu: {
763 : MCInst TmpInst;
764 : MCOperand MCOp;
765 : TmpInst.setOpcode(Mips::MULTu);
766 : // Operand: rs
767 8 : lowerOperand(MI->getOperand(1), MCOp);
768 : TmpInst.addOperand(MCOp);
769 : // Operand: rt
770 8 : lowerOperand(MI->getOperand(2), MCOp);
771 : TmpInst.addOperand(MCOp);
772 8 : EmitToStreamer(OutStreamer, TmpInst);
773 : break;
774 : }
775 : case Mips::PseudoMULTu_MM: {
776 : MCInst TmpInst;
777 : MCOperand MCOp;
778 : TmpInst.setOpcode(Mips::MULTu);
779 : // Operand: rs
780 1 : lowerOperand(MI->getOperand(1), MCOp);
781 : TmpInst.addOperand(MCOp);
782 : // Operand: rt
783 1 : lowerOperand(MI->getOperand(2), MCOp);
784 : TmpInst.addOperand(MCOp);
785 1 : EmitToStreamer(OutStreamer, TmpInst);
786 : break;
787 : }
788 : case Mips::PseudoPICK_PH: {
789 : MCInst TmpInst;
790 : MCOperand MCOp;
791 : TmpInst.setOpcode(Mips::PICK_PH);
792 : // Operand: rd
793 14 : lowerOperand(MI->getOperand(0), MCOp);
794 : TmpInst.addOperand(MCOp);
795 : // Operand: rs
796 14 : lowerOperand(MI->getOperand(2), MCOp);
797 : TmpInst.addOperand(MCOp);
798 : // Operand: rt
799 14 : lowerOperand(MI->getOperand(3), MCOp);
800 : TmpInst.addOperand(MCOp);
801 14 : EmitToStreamer(OutStreamer, TmpInst);
802 : break;
803 : }
804 : case Mips::PseudoPICK_QB: {
805 : MCInst TmpInst;
806 : MCOperand MCOp;
807 : TmpInst.setOpcode(Mips::PICK_QB);
808 : // Operand: rd
809 12 : lowerOperand(MI->getOperand(0), MCOp);
810 : TmpInst.addOperand(MCOp);
811 : // Operand: rs
812 12 : lowerOperand(MI->getOperand(2), MCOp);
813 : TmpInst.addOperand(MCOp);
814 : // Operand: rt
815 12 : lowerOperand(MI->getOperand(3), MCOp);
816 : TmpInst.addOperand(MCOp);
817 12 : EmitToStreamer(OutStreamer, TmpInst);
818 : break;
819 : }
820 : case Mips::PseudoSDIV: {
821 : MCInst TmpInst;
822 : MCOperand MCOp;
823 : TmpInst.setOpcode(Mips::SDIV);
824 : // Operand: rs
825 124 : lowerOperand(MI->getOperand(1), MCOp);
826 : TmpInst.addOperand(MCOp);
827 : // Operand: rt
828 124 : lowerOperand(MI->getOperand(2), MCOp);
829 : TmpInst.addOperand(MCOp);
830 124 : EmitToStreamer(OutStreamer, TmpInst);
831 : break;
832 : }
833 : case Mips::PseudoUDIV: {
834 : MCInst TmpInst;
835 : MCOperand MCOp;
836 : TmpInst.setOpcode(Mips::UDIV);
837 : // Operand: rs
838 122 : lowerOperand(MI->getOperand(1), MCOp);
839 : TmpInst.addOperand(MCOp);
840 : // Operand: rt
841 122 : lowerOperand(MI->getOperand(2), MCOp);
842 : TmpInst.addOperand(MCOp);
843 122 : EmitToStreamer(OutStreamer, TmpInst);
844 : break;
845 : }
846 : case Mips::SDIV_MM_Pseudo: {
847 : MCInst TmpInst;
848 : MCOperand MCOp;
849 : TmpInst.setOpcode(Mips::SDIV_MM);
850 : // Operand: rs
851 8 : lowerOperand(MI->getOperand(1), MCOp);
852 : TmpInst.addOperand(MCOp);
853 : // Operand: rt
854 8 : lowerOperand(MI->getOperand(2), MCOp);
855 : TmpInst.addOperand(MCOp);
856 8 : EmitToStreamer(OutStreamer, TmpInst);
857 : break;
858 : }
859 : case Mips::TAILCALL: {
860 : MCInst TmpInst;
861 : MCOperand MCOp;
862 : TmpInst.setOpcode(Mips::J);
863 : // Operand: target
864 13 : lowerOperand(MI->getOperand(0), MCOp);
865 : TmpInst.addOperand(MCOp);
866 13 : EmitToStreamer(OutStreamer, TmpInst);
867 : break;
868 : }
869 : case Mips::TAILCALL64R6REG: {
870 : MCInst TmpInst;
871 : MCOperand MCOp;
872 : TmpInst.setOpcode(Mips::JALR64);
873 : // Operand: rd
874 1 : TmpInst.addOperand(MCOperand::createReg(Mips::ZERO_64));
875 : // Operand: rs
876 1 : lowerOperand(MI->getOperand(0), MCOp);
877 : TmpInst.addOperand(MCOp);
878 1 : EmitToStreamer(OutStreamer, TmpInst);
879 : break;
880 : }
881 : case Mips::TAILCALLHB64R6REG: {
882 : MCInst TmpInst;
883 : MCOperand MCOp;
884 : TmpInst.setOpcode(Mips::JR_HB64_R6);
885 : // Operand: rs
886 2 : lowerOperand(MI->getOperand(0), MCOp);
887 : TmpInst.addOperand(MCOp);
888 2 : EmitToStreamer(OutStreamer, TmpInst);
889 : break;
890 : }
891 : case Mips::TAILCALLHBR6REG: {
892 : MCInst TmpInst;
893 : MCOperand MCOp;
894 : TmpInst.setOpcode(Mips::JR_HB_R6);
895 : // Operand: rs
896 2 : lowerOperand(MI->getOperand(0), MCOp);
897 : TmpInst.addOperand(MCOp);
898 2 : EmitToStreamer(OutStreamer, TmpInst);
899 : break;
900 : }
901 : case Mips::TAILCALLR6REG: {
902 : MCInst TmpInst;
903 : MCOperand MCOp;
904 : TmpInst.setOpcode(Mips::JALR);
905 : // Operand: rd
906 1 : TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
907 : // Operand: rs
908 1 : lowerOperand(MI->getOperand(0), MCOp);
909 : TmpInst.addOperand(MCOp);
910 1 : EmitToStreamer(OutStreamer, TmpInst);
911 : break;
912 : }
913 : case Mips::TAILCALLREG: {
914 : MCInst TmpInst;
915 : MCOperand MCOp;
916 : TmpInst.setOpcode(Mips::JR);
917 : // Operand: rs
918 48 : lowerOperand(MI->getOperand(0), MCOp);
919 : TmpInst.addOperand(MCOp);
920 48 : EmitToStreamer(OutStreamer, TmpInst);
921 : break;
922 : }
923 : case Mips::TAILCALLREG64: {
924 : MCInst TmpInst;
925 : MCOperand MCOp;
926 : TmpInst.setOpcode(Mips::JR64);
927 : // Operand: rs
928 49 : lowerOperand(MI->getOperand(0), MCOp);
929 : TmpInst.addOperand(MCOp);
930 49 : EmitToStreamer(OutStreamer, TmpInst);
931 : break;
932 : }
933 : case Mips::TAILCALLREGHB: {
934 : MCInst TmpInst;
935 : MCOperand MCOp;
936 : TmpInst.setOpcode(Mips::JR_HB);
937 : // Operand: rs
938 2 : lowerOperand(MI->getOperand(0), MCOp);
939 : TmpInst.addOperand(MCOp);
940 2 : EmitToStreamer(OutStreamer, TmpInst);
941 : break;
942 : }
943 : case Mips::TAILCALLREGHB64: {
944 : MCInst TmpInst;
945 : MCOperand MCOp;
946 : TmpInst.setOpcode(Mips::JR_HB64);
947 : // Operand: rs
948 2 : lowerOperand(MI->getOperand(0), MCOp);
949 : TmpInst.addOperand(MCOp);
950 2 : EmitToStreamer(OutStreamer, TmpInst);
951 : break;
952 : }
953 : case Mips::TAILCALLREG_MM: {
954 : MCInst TmpInst;
955 : MCOperand MCOp;
956 : TmpInst.setOpcode(Mips::JRC16_MM);
957 : // Operand: rs
958 4 : lowerOperand(MI->getOperand(0), MCOp);
959 : TmpInst.addOperand(MCOp);
960 4 : EmitToStreamer(OutStreamer, TmpInst);
961 : break;
962 : }
963 : case Mips::TAILCALLREG_MMR6: {
964 : MCInst TmpInst;
965 : MCOperand MCOp;
966 : TmpInst.setOpcode(Mips::JRC16_MM);
967 : // Operand: rs
968 3 : lowerOperand(MI->getOperand(0), MCOp);
969 : TmpInst.addOperand(MCOp);
970 3 : EmitToStreamer(OutStreamer, TmpInst);
971 : break;
972 : }
973 : case Mips::TAILCALL_MM: {
974 : MCInst TmpInst;
975 : MCOperand MCOp;
976 : TmpInst.setOpcode(Mips::J_MM);
977 : // Operand: target
978 4 : lowerOperand(MI->getOperand(0), MCOp);
979 : TmpInst.addOperand(MCOp);
980 4 : EmitToStreamer(OutStreamer, TmpInst);
981 : break;
982 : }
983 : case Mips::TAILCALL_MMR6: {
984 : MCInst TmpInst;
985 : MCOperand MCOp;
986 : TmpInst.setOpcode(Mips::BC_MMR6);
987 : // Operand: offset
988 3 : lowerOperand(MI->getOperand(0), MCOp);
989 : TmpInst.addOperand(MCOp);
990 3 : EmitToStreamer(OutStreamer, TmpInst);
991 : break;
992 : }
993 : case Mips::TRAP: {
994 : MCInst TmpInst;
995 : MCOperand MCOp;
996 : TmpInst.setOpcode(Mips::BREAK);
997 : // Operand: code_1
998 13 : TmpInst.addOperand(MCOperand::createImm(0));
999 : // Operand: code_2
1000 13 : TmpInst.addOperand(MCOperand::createImm(0));
1001 13 : EmitToStreamer(OutStreamer, TmpInst);
1002 : break;
1003 : }
1004 : case Mips::TRAP_MM: {
1005 : MCInst TmpInst;
1006 : MCOperand MCOp;
1007 : TmpInst.setOpcode(Mips::BREAK_MM);
1008 : // Operand: code_1
1009 2 : TmpInst.addOperand(MCOperand::createImm(0));
1010 : // Operand: code_2
1011 2 : TmpInst.addOperand(MCOperand::createImm(0));
1012 2 : EmitToStreamer(OutStreamer, TmpInst);
1013 : break;
1014 : }
1015 : case Mips::UDIV_MM_Pseudo: {
1016 : MCInst TmpInst;
1017 : MCOperand MCOp;
1018 : TmpInst.setOpcode(Mips::UDIV_MM);
1019 : // Operand: rs
1020 8 : lowerOperand(MI->getOperand(1), MCOp);
1021 : TmpInst.addOperand(MCOp);
1022 : // Operand: rt
1023 8 : lowerOperand(MI->getOperand(2), MCOp);
1024 : TmpInst.addOperand(MCOp);
1025 8 : EmitToStreamer(OutStreamer, TmpInst);
1026 : break;
1027 : }
1028 : case Mips::XOR_V_D_PSEUDO: {
1029 : MCInst TmpInst;
1030 : MCOperand MCOp;
1031 : TmpInst.setOpcode(Mips::XOR_V);
1032 : // Operand: wd
1033 12 : lowerOperand(MI->getOperand(0), MCOp);
1034 : TmpInst.addOperand(MCOp);
1035 : // Operand: ws
1036 12 : lowerOperand(MI->getOperand(1), MCOp);
1037 : TmpInst.addOperand(MCOp);
1038 : // Operand: wt
1039 12 : lowerOperand(MI->getOperand(2), MCOp);
1040 : TmpInst.addOperand(MCOp);
1041 12 : EmitToStreamer(OutStreamer, TmpInst);
1042 : break;
1043 : }
1044 : case Mips::XOR_V_H_PSEUDO: {
1045 : MCInst TmpInst;
1046 : MCOperand MCOp;
1047 : TmpInst.setOpcode(Mips::XOR_V);
1048 : // Operand: wd
1049 8 : lowerOperand(MI->getOperand(0), MCOp);
1050 : TmpInst.addOperand(MCOp);
1051 : // Operand: ws
1052 8 : lowerOperand(MI->getOperand(1), MCOp);
1053 : TmpInst.addOperand(MCOp);
1054 : // Operand: wt
1055 8 : lowerOperand(MI->getOperand(2), MCOp);
1056 : TmpInst.addOperand(MCOp);
1057 8 : EmitToStreamer(OutStreamer, TmpInst);
1058 : break;
1059 : }
1060 : case Mips::XOR_V_W_PSEUDO: {
1061 : MCInst TmpInst;
1062 : MCOperand MCOp;
1063 : TmpInst.setOpcode(Mips::XOR_V);
1064 : // Operand: wd
1065 8 : lowerOperand(MI->getOperand(0), MCOp);
1066 : TmpInst.addOperand(MCOp);
1067 : // Operand: ws
1068 8 : lowerOperand(MI->getOperand(1), MCOp);
1069 : TmpInst.addOperand(MCOp);
1070 : // Operand: wt
1071 8 : lowerOperand(MI->getOperand(2), MCOp);
1072 : TmpInst.addOperand(MCOp);
1073 8 : EmitToStreamer(OutStreamer, TmpInst);
1074 : break;
1075 : }
1076 : }
1077 : return true;
1078 : }
1079 :
|
