1 //===-- ARMInstPrinter.cpp - Convert ARM MCInst to assembly syntax --------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This class prints an ARM MCInst to a .s file.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "asm-printer"
15 #include "ARM.h" // FIXME: FACTOR ENUMS BETTER.
16 #include "ARMInstPrinter.h"
17 #include "ARMAddressingModes.h"
18 #include "llvm/MC/MCInst.h"
19 #include "llvm/MC/MCAsmInfo.h"
20 #include "llvm/MC/MCExpr.h"
21 #include "llvm/Support/raw_ostream.h"
24 // Include the auto-generated portion of the assembly writer.
25 #define MachineInstr MCInst
26 #define ARMAsmPrinter ARMInstPrinter // FIXME: REMOVE.
27 #include "ARMGenAsmWriter.inc"
31 static unsigned NextReg(unsigned Reg) {
34 assert(0 && "Unexpected register enum");
101 void ARMInstPrinter::printInst(const MCInst *MI) {
102 // Check for MOVs and print canonical forms, instead.
103 if (MI->getOpcode() == ARM::MOVs) {
104 const MCOperand &Dst = MI->getOperand(0);
105 const MCOperand &MO1 = MI->getOperand(1);
106 const MCOperand &MO2 = MI->getOperand(2);
107 const MCOperand &MO3 = MI->getOperand(3);
109 O << '\t' << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(MO3.getImm()));
110 printSBitModifierOperand(MI, 6);
111 printPredicateOperand(MI, 4);
113 O << '\t' << getRegisterName(Dst.getReg())
114 << ", " << getRegisterName(MO1.getReg());
116 if (ARM_AM::getSORegShOp(MO3.getImm()) == ARM_AM::rrx)
122 O << getRegisterName(MO2.getReg());
123 assert(ARM_AM::getSORegOffset(MO3.getImm()) == 0);
125 O << "#" << ARM_AM::getSORegOffset(MO3.getImm());
131 if ((MI->getOpcode() == ARM::STM_UPD || MI->getOpcode() == ARM::t2STM_UPD) &&
132 MI->getOperand(0).getReg() == ARM::SP) {
133 const MCOperand &MO1 = MI->getOperand(2);
134 if (ARM_AM::getAM4SubMode(MO1.getImm()) == ARM_AM::db) {
136 printPredicateOperand(MI, 3);
138 printRegisterList(MI, 5);
144 if ((MI->getOpcode() == ARM::LDM_UPD || MI->getOpcode() == ARM::t2LDM_UPD) &&
145 MI->getOperand(0).getReg() == ARM::SP) {
146 const MCOperand &MO1 = MI->getOperand(2);
147 if (ARM_AM::getAM4SubMode(MO1.getImm()) == ARM_AM::ia) {
149 printPredicateOperand(MI, 3);
151 printRegisterList(MI, 5);
157 if ((MI->getOpcode() == ARM::VSTMS_UPD || MI->getOpcode() ==ARM::VSTMD_UPD) &&
158 MI->getOperand(0).getReg() == ARM::SP) {
159 const MCOperand &MO1 = MI->getOperand(2);
160 if (ARM_AM::getAM5SubMode(MO1.getImm()) == ARM_AM::db) {
161 O << '\t' << "vpush";
162 printPredicateOperand(MI, 3);
164 printRegisterList(MI, 5);
170 if ((MI->getOpcode() == ARM::VLDMS_UPD || MI->getOpcode() ==ARM::VLDMD_UPD) &&
171 MI->getOperand(0).getReg() == ARM::SP) {
172 const MCOperand &MO1 = MI->getOperand(2);
173 if (ARM_AM::getAM5SubMode(MO1.getImm()) == ARM_AM::ia) {
175 printPredicateOperand(MI, 3);
177 printRegisterList(MI, 5);
182 printInstruction(MI);
185 void ARMInstPrinter::printOperand(const MCInst *MI, unsigned OpNo,
186 const char *Modifier) {
187 const MCOperand &Op = MI->getOperand(OpNo);
189 unsigned Reg = Op.getReg();
190 if (Modifier && strcmp(Modifier, "dregpair") == 0) {
191 O << '{' << getRegisterName(Reg) << ", "
192 << getRegisterName(NextReg(Reg)) << '}';
194 // FIXME: Breaks e.g. ARM/vmul.ll.
197 unsigned DRegLo = TRI->getSubReg(Reg, 5); // arm_dsubreg_0
198 unsigned DRegHi = TRI->getSubReg(Reg, 6); // arm_dsubreg_1
200 << getRegisterName(DRegLo) << ',' << getRegisterName(DRegHi)
203 } else if (Modifier && strcmp(Modifier, "lane") == 0) {
206 unsigned RegNum = ARMRegisterInfo::getRegisterNumbering(Reg);
207 unsigned DReg = TRI->getMatchingSuperReg(Reg, RegNum & 1 ? 2 : 1,
208 &ARM::DPR_VFP2RegClass);
209 O << getRegisterName(DReg) << '[' << (RegNum & 1) << ']';
212 O << getRegisterName(Reg);
214 } else if (Op.isImm()) {
215 assert((Modifier && !strcmp(Modifier, "call")) ||
216 ((Modifier == 0 || Modifier[0] == 0) && "No modifiers supported"));
217 O << '#' << Op.getImm();
219 assert((Modifier == 0 || Modifier[0] == 0) && "No modifiers supported");
220 assert(Op.isExpr() && "unknown operand kind in printOperand");
225 static void printSOImm(raw_ostream &O, int64_t V, bool VerboseAsm,
226 const MCAsmInfo *MAI) {
227 // Break it up into two parts that make up a shifter immediate.
228 V = ARM_AM::getSOImmVal(V);
229 assert(V != -1 && "Not a valid so_imm value!");
231 unsigned Imm = ARM_AM::getSOImmValImm(V);
232 unsigned Rot = ARM_AM::getSOImmValRot(V);
234 // Print low-level immediate formation info, per
235 // A5.1.3: "Data-processing operands - Immediate".
237 O << "#" << Imm << ", " << Rot;
238 // Pretty printed version.
240 O << ' ' << MAI->getCommentString()
241 << ' ' << (int)ARM_AM::rotr32(Imm, Rot);
248 /// printSOImmOperand - SOImm is 4-bit rotate amount in bits 8-11 with 8-bit
249 /// immediate in bits 0-7.
250 void ARMInstPrinter::printSOImmOperand(const MCInst *MI, unsigned OpNum) {
251 const MCOperand &MO = MI->getOperand(OpNum);
252 assert(MO.isImm() && "Not a valid so_imm value!");
253 printSOImm(O, MO.getImm(), VerboseAsm, &MAI);
256 /// printSOImm2PartOperand - SOImm is broken into two pieces using a 'mov'
257 /// followed by an 'orr' to materialize.
258 void ARMInstPrinter::printSOImm2PartOperand(const MCInst *MI, unsigned OpNum) {
259 // FIXME: REMOVE this method.
263 // so_reg is a 4-operand unit corresponding to register forms of the A5.1
264 // "Addressing Mode 1 - Data-processing operands" forms. This includes:
266 // REG REG 0,SH_OPC - e.g. R5, ROR R3
267 // REG 0 IMM,SH_OPC - e.g. R5, LSL #3
268 void ARMInstPrinter::printSORegOperand(const MCInst *MI, unsigned OpNum) {
269 const MCOperand &MO1 = MI->getOperand(OpNum);
270 const MCOperand &MO2 = MI->getOperand(OpNum+1);
271 const MCOperand &MO3 = MI->getOperand(OpNum+2);
273 O << getRegisterName(MO1.getReg());
275 // Print the shift opc.
277 << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(MO3.getImm()))
281 O << getRegisterName(MO2.getReg());
282 assert(ARM_AM::getSORegOffset(MO3.getImm()) == 0);
284 O << "#" << ARM_AM::getSORegOffset(MO3.getImm());
289 void ARMInstPrinter::printAddrMode2Operand(const MCInst *MI, unsigned Op) {
290 const MCOperand &MO1 = MI->getOperand(Op);
291 const MCOperand &MO2 = MI->getOperand(Op+1);
292 const MCOperand &MO3 = MI->getOperand(Op+2);
294 if (!MO1.isReg()) { // FIXME: This is for CP entries, but isn't right.
295 printOperand(MI, Op);
299 O << "[" << getRegisterName(MO1.getReg());
302 if (ARM_AM::getAM2Offset(MO3.getImm())) // Don't print +0.
304 << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO3.getImm()))
305 << ARM_AM::getAM2Offset(MO3.getImm());
311 << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO3.getImm()))
312 << getRegisterName(MO2.getReg());
314 if (unsigned ShImm = ARM_AM::getAM2Offset(MO3.getImm()))
316 << ARM_AM::getShiftOpcStr(ARM_AM::getAM2ShiftOpc(MO3.getImm()))
321 void ARMInstPrinter::printAddrMode2OffsetOperand(const MCInst *MI,
323 const MCOperand &MO1 = MI->getOperand(OpNum);
324 const MCOperand &MO2 = MI->getOperand(OpNum+1);
327 unsigned ImmOffs = ARM_AM::getAM2Offset(MO2.getImm());
328 assert(ImmOffs && "Malformed indexed load / store!");
330 << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO2.getImm()))
335 O << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO2.getImm()))
336 << getRegisterName(MO1.getReg());
338 if (unsigned ShImm = ARM_AM::getAM2Offset(MO2.getImm()))
340 << ARM_AM::getShiftOpcStr(ARM_AM::getAM2ShiftOpc(MO2.getImm()))
344 void ARMInstPrinter::printAddrMode3Operand(const MCInst *MI, unsigned OpNum) {
345 const MCOperand &MO1 = MI->getOperand(OpNum);
346 const MCOperand &MO2 = MI->getOperand(OpNum+1);
347 const MCOperand &MO3 = MI->getOperand(OpNum+2);
349 O << '[' << getRegisterName(MO1.getReg());
352 O << ", " << (char)ARM_AM::getAM3Op(MO3.getImm())
353 << getRegisterName(MO2.getReg()) << ']';
357 if (unsigned ImmOffs = ARM_AM::getAM3Offset(MO3.getImm()))
359 << ARM_AM::getAddrOpcStr(ARM_AM::getAM3Op(MO3.getImm()))
364 void ARMInstPrinter::printAddrMode3OffsetOperand(const MCInst *MI,
366 const MCOperand &MO1 = MI->getOperand(OpNum);
367 const MCOperand &MO2 = MI->getOperand(OpNum+1);
370 O << (char)ARM_AM::getAM3Op(MO2.getImm())
371 << getRegisterName(MO1.getReg());
375 unsigned ImmOffs = ARM_AM::getAM3Offset(MO2.getImm());
376 assert(ImmOffs && "Malformed indexed load / store!");
378 << ARM_AM::getAddrOpcStr(ARM_AM::getAM3Op(MO2.getImm()))
383 void ARMInstPrinter::printAddrMode4Operand(const MCInst *MI, unsigned OpNum,
384 const char *Modifier) {
385 const MCOperand &MO2 = MI->getOperand(OpNum+1);
386 ARM_AM::AMSubMode Mode = ARM_AM::getAM4SubMode(MO2.getImm());
387 if (Modifier && strcmp(Modifier, "submode") == 0) {
388 O << ARM_AM::getAMSubModeStr(Mode);
389 } else if (Modifier && strcmp(Modifier, "wide") == 0) {
390 ARM_AM::AMSubMode Mode = ARM_AM::getAM4SubMode(MO2.getImm());
391 if (Mode == ARM_AM::ia)
394 printOperand(MI, OpNum);
398 void ARMInstPrinter::printAddrMode5Operand(const MCInst *MI, unsigned OpNum,
399 const char *Modifier) {
400 const MCOperand &MO1 = MI->getOperand(OpNum);
401 const MCOperand &MO2 = MI->getOperand(OpNum+1);
403 if (!MO1.isReg()) { // FIXME: This is for CP entries, but isn't right.
404 printOperand(MI, OpNum);
408 if (Modifier && strcmp(Modifier, "submode") == 0) {
409 ARM_AM::AMSubMode Mode = ARM_AM::getAM5SubMode(MO2.getImm());
410 O << ARM_AM::getAMSubModeStr(Mode);
412 } else if (Modifier && strcmp(Modifier, "base") == 0) {
413 // Used for FSTM{D|S} and LSTM{D|S} operations.
414 O << getRegisterName(MO1.getReg());
418 O << "[" << getRegisterName(MO1.getReg());
420 if (unsigned ImmOffs = ARM_AM::getAM5Offset(MO2.getImm())) {
422 << ARM_AM::getAddrOpcStr(ARM_AM::getAM5Op(MO2.getImm()))
428 void ARMInstPrinter::printAddrMode6Operand(const MCInst *MI, unsigned OpNum) {
429 const MCOperand &MO1 = MI->getOperand(OpNum);
430 const MCOperand &MO2 = MI->getOperand(OpNum+1);
432 O << "[" << getRegisterName(MO1.getReg());
434 // FIXME: Both darwin as and GNU as violate ARM docs here.
435 O << ", :" << MO2.getImm();
440 void ARMInstPrinter::printAddrMode6OffsetOperand(const MCInst *MI,
442 const MCOperand &MO = MI->getOperand(OpNum);
443 if (MO.getReg() == 0)
446 O << ", " << getRegisterName(MO.getReg());
449 void ARMInstPrinter::printAddrModePCOperand(const MCInst *MI, unsigned OpNum,
450 const char *Modifier) {
451 assert(0 && "FIXME: Implement printAddrModePCOperand");
454 void ARMInstPrinter::printBitfieldInvMaskImmOperand (const MCInst *MI,
456 const MCOperand &MO = MI->getOperand(OpNum);
457 uint32_t v = ~MO.getImm();
458 int32_t lsb = CountTrailingZeros_32(v);
459 int32_t width = (32 - CountLeadingZeros_32 (v)) - lsb;
460 assert(MO.isImm() && "Not a valid bf_inv_mask_imm value!");
461 O << '#' << lsb << ", #" << width;
464 void ARMInstPrinter::printRegisterList(const MCInst *MI, unsigned OpNum) {
466 for (unsigned i = OpNum, e = MI->getNumOperands(); i != e; ++i) {
467 if (i != OpNum) O << ", ";
468 O << getRegisterName(MI->getOperand(i).getReg());
473 void ARMInstPrinter::printCPSOptionOperand(const MCInst *MI, unsigned OpNum) {
474 const MCOperand &Op = MI->getOperand(OpNum);
475 unsigned option = Op.getImm();
476 unsigned mode = option & 31;
477 bool changemode = option >> 5 & 1;
478 unsigned AIF = option >> 6 & 7;
479 unsigned imod = option >> 9 & 3;
486 if (AIF & 4) O << 'a';
487 if (AIF & 2) O << 'i';
488 if (AIF & 1) O << 'f';
489 if (AIF > 0 && changemode) O << ", ";
495 void ARMInstPrinter::printMSRMaskOperand(const MCInst *MI, unsigned OpNum) {
496 const MCOperand &Op = MI->getOperand(OpNum);
497 unsigned Mask = Op.getImm();
500 if (Mask & 8) O << 'f';
501 if (Mask & 4) O << 's';
502 if (Mask & 2) O << 'x';
503 if (Mask & 1) O << 'c';
507 void ARMInstPrinter::printNegZeroOperand(const MCInst *MI, unsigned OpNum){
508 const MCOperand &Op = MI->getOperand(OpNum);
511 O << '-' << (-Op.getImm() - 1);
516 void ARMInstPrinter::printPredicateOperand(const MCInst *MI, unsigned OpNum) {
517 ARMCC::CondCodes CC = (ARMCC::CondCodes)MI->getOperand(OpNum).getImm();
519 O << ARMCondCodeToString(CC);
522 void ARMInstPrinter::printMandatoryPredicateOperand(const MCInst *MI,
524 ARMCC::CondCodes CC = (ARMCC::CondCodes)MI->getOperand(OpNum).getImm();
525 O << ARMCondCodeToString(CC);
528 void ARMInstPrinter::printSBitModifierOperand(const MCInst *MI, unsigned OpNum){
529 if (MI->getOperand(OpNum).getReg()) {
530 assert(MI->getOperand(OpNum).getReg() == ARM::CPSR &&
531 "Expect ARM CPSR register!");
538 void ARMInstPrinter::printCPInstOperand(const MCInst *MI, unsigned OpNum,
539 const char *Modifier) {
540 // FIXME: remove this.
544 void ARMInstPrinter::printNoHashImmediate(const MCInst *MI, unsigned OpNum) {
545 O << MI->getOperand(OpNum).getImm();
549 void ARMInstPrinter::printPCLabel(const MCInst *MI, unsigned OpNum) {
550 // FIXME: remove this.
554 void ARMInstPrinter::printThumbS4ImmOperand(const MCInst *MI, unsigned OpNum) {
555 O << "#" << MI->getOperand(OpNum).getImm() * 4;
558 void ARMInstPrinter::printThumbITMask(const MCInst *MI, unsigned OpNum) {
559 // (3 - the number of trailing zeros) is the number of then / else.
560 unsigned Mask = MI->getOperand(OpNum).getImm();
561 unsigned CondBit0 = Mask >> 4 & 1;
562 unsigned NumTZ = CountTrailingZeros_32(Mask);
563 assert(NumTZ <= 3 && "Invalid IT mask!");
564 for (unsigned Pos = 3, e = NumTZ; Pos > e; --Pos) {
565 bool T = ((Mask >> Pos) & 1) == CondBit0;
573 void ARMInstPrinter::printThumbAddrModeRROperand(const MCInst *MI, unsigned Op)
575 const MCOperand &MO1 = MI->getOperand(Op);
576 const MCOperand &MO2 = MI->getOperand(Op+1);
577 O << "[" << getRegisterName(MO1.getReg());
578 O << ", " << getRegisterName(MO2.getReg()) << "]";
581 void ARMInstPrinter::printThumbAddrModeRI5Operand(const MCInst *MI, unsigned Op,
583 const MCOperand &MO1 = MI->getOperand(Op);
584 const MCOperand &MO2 = MI->getOperand(Op+1);
585 const MCOperand &MO3 = MI->getOperand(Op+2);
587 if (!MO1.isReg()) { // FIXME: This is for CP entries, but isn't right.
588 printOperand(MI, Op);
592 O << "[" << getRegisterName(MO1.getReg());
594 O << ", " << getRegisterName(MO3.getReg());
595 else if (unsigned ImmOffs = MO2.getImm())
596 O << ", #" << ImmOffs * Scale;
600 void ARMInstPrinter::printThumbAddrModeS1Operand(const MCInst *MI, unsigned Op)
602 printThumbAddrModeRI5Operand(MI, Op, 1);
605 void ARMInstPrinter::printThumbAddrModeS2Operand(const MCInst *MI, unsigned Op)
607 printThumbAddrModeRI5Operand(MI, Op, 2);
610 void ARMInstPrinter::printThumbAddrModeS4Operand(const MCInst *MI, unsigned Op)
612 printThumbAddrModeRI5Operand(MI, Op, 4);
615 void ARMInstPrinter::printThumbAddrModeSPOperand(const MCInst *MI,unsigned Op) {
616 const MCOperand &MO1 = MI->getOperand(Op);
617 const MCOperand &MO2 = MI->getOperand(Op+1);
618 O << "[" << getRegisterName(MO1.getReg());
619 if (unsigned ImmOffs = MO2.getImm())
620 O << ", #" << ImmOffs*4;
624 void ARMInstPrinter::printTBAddrMode(const MCInst *MI, unsigned OpNum) {
625 O << "[pc, " << getRegisterName(MI->getOperand(OpNum).getReg());
626 if (MI->getOpcode() == ARM::t2TBH)
631 // Constant shifts t2_so_reg is a 2-operand unit corresponding to the Thumb2
632 // register with shift forms.
634 // REG IMM, SH_OPC - e.g. R5, LSL #3
635 void ARMInstPrinter::printT2SOOperand(const MCInst *MI, unsigned OpNum) {
636 const MCOperand &MO1 = MI->getOperand(OpNum);
637 const MCOperand &MO2 = MI->getOperand(OpNum+1);
639 unsigned Reg = MO1.getReg();
640 O << getRegisterName(Reg);
642 // Print the shift opc.
644 << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(MO2.getImm()))
647 assert(MO2.isImm() && "Not a valid t2_so_reg value!");
648 O << "#" << ARM_AM::getSORegOffset(MO2.getImm());
651 void ARMInstPrinter::printT2AddrModeImm12Operand(const MCInst *MI,
653 const MCOperand &MO1 = MI->getOperand(OpNum);
654 const MCOperand &MO2 = MI->getOperand(OpNum+1);
656 O << "[" << getRegisterName(MO1.getReg());
658 unsigned OffImm = MO2.getImm();
659 if (OffImm) // Don't print +0.
660 O << ", #" << OffImm;
664 void ARMInstPrinter::printT2AddrModeImm8Operand(const MCInst *MI,
666 const MCOperand &MO1 = MI->getOperand(OpNum);
667 const MCOperand &MO2 = MI->getOperand(OpNum+1);
669 O << "[" << getRegisterName(MO1.getReg());
671 int32_t OffImm = (int32_t)MO2.getImm();
674 O << ", #-" << -OffImm;
676 O << ", #" << OffImm;
680 void ARMInstPrinter::printT2AddrModeImm8s4Operand(const MCInst *MI,
682 const MCOperand &MO1 = MI->getOperand(OpNum);
683 const MCOperand &MO2 = MI->getOperand(OpNum+1);
685 O << "[" << getRegisterName(MO1.getReg());
687 int32_t OffImm = (int32_t)MO2.getImm() / 4;
690 O << ", #-" << -OffImm * 4;
692 O << ", #" << OffImm * 4;
696 void ARMInstPrinter::printT2AddrModeImm8OffsetOperand(const MCInst *MI,
698 const MCOperand &MO1 = MI->getOperand(OpNum);
699 int32_t OffImm = (int32_t)MO1.getImm();
702 O << "#-" << -OffImm;
707 void ARMInstPrinter::printT2AddrModeImm8s4OffsetOperand(const MCInst *MI,
709 const MCOperand &MO1 = MI->getOperand(OpNum);
710 int32_t OffImm = (int32_t)MO1.getImm() / 4;
713 O << "#-" << -OffImm * 4;
715 O << "#" << OffImm * 4;
718 void ARMInstPrinter::printT2AddrModeSoRegOperand(const MCInst *MI,
720 const MCOperand &MO1 = MI->getOperand(OpNum);
721 const MCOperand &MO2 = MI->getOperand(OpNum+1);
722 const MCOperand &MO3 = MI->getOperand(OpNum+2);
724 O << "[" << getRegisterName(MO1.getReg());
726 assert(MO2.getReg() && "Invalid so_reg load / store address!");
727 O << ", " << getRegisterName(MO2.getReg());
729 unsigned ShAmt = MO3.getImm();
731 assert(ShAmt <= 3 && "Not a valid Thumb2 addressing mode!");
732 O << ", lsl #" << ShAmt;
737 void ARMInstPrinter::printVFPf32ImmOperand(const MCInst *MI, unsigned OpNum) {
738 O << '#' << MI->getOperand(OpNum).getImm();
741 void ARMInstPrinter::printVFPf64ImmOperand(const MCInst *MI, unsigned OpNum) {
742 O << '#' << MI->getOperand(OpNum).getImm();