lib/Target/ARM/InstPrinter/ARMInstPrinter.cpp

   1 //===-- ARMInstPrinter.cpp - Convert ARM MCInst to assembly syntax --------===//
   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 class prints an ARM MCInst to a .s file.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "asm-printer"
  15 #include "ARMInstPrinter.h"
  16 #include "MCTargetDesc/ARMAddressingModes.h"
  17 #include "MCTargetDesc/ARMBaseInfo.h"
  18 #include "llvm/MC/MCAsmInfo.h"
  19 #include "llvm/MC/MCExpr.h"
  20 #include "llvm/MC/MCInst.h"
  21 #include "llvm/MC/MCInstrInfo.h"
  22 #include "llvm/MC/MCRegisterInfo.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 using namespace llvm;
  25
  26 #include "ARMGenAsmWriter.inc"
  27
  28 /// translateShiftImm - Convert shift immediate from 0-31 to 1-32 for printing.
  29 ///
  30 /// getSORegOffset returns an integer from 0-31, representing '32' as 0.
  31 static unsigned translateShiftImm(unsigned imm) {
  32   // lsr #32 and asr #32 exist, but should be encoded as a 0.
  33   assert((imm & ~0x1f) == 0 && "Invalid shift encoding");
  34
  35   if (imm == 0)
  36     return 32;
  37   return imm;
  38 }
  39
  40 /// Prints the shift value with an immediate value.
  41 static void printRegImmShift(raw_ostream &O, ARM_AM::ShiftOpc ShOpc,
  42                           unsigned ShImm, bool UseMarkup) {
  43   if (ShOpc == ARM_AM::no_shift || (ShOpc == ARM_AM::lsl && !ShImm))
  44     return;
  45   O << ", ";
  46
  47   assert (!(ShOpc == ARM_AM::ror && !ShImm) && "Cannot have ror #0");
  48   O << getShiftOpcStr(ShOpc);
  49
  50   if (ShOpc != ARM_AM::rrx) {
  51     O << " ";
  52     if (UseMarkup)
  53       O << "<imm:";
  54     O << "#" << translateShiftImm(ShImm);
  55     if (UseMarkup)
  56       O << ">";
  57   }
  58 }
  59
  60 ARMInstPrinter::ARMInstPrinter(const MCAsmInfo &MAI,
  61                                const MCInstrInfo &MII,
  62                                const MCRegisterInfo &MRI,
  63                                const MCSubtargetInfo &STI) :
  64   MCInstPrinter(MAI, MII, MRI) {
  65   // Initialize the set of available features.
  66   setAvailableFeatures(STI.getFeatureBits());
  67 }
  68
  69 void ARMInstPrinter::printRegName(raw_ostream &OS, unsigned RegNo) const {
  70   OS << markup("<reg:")
  71      << getRegisterName(RegNo)
  72      << markup(">");
  73 }
  74
  75 void ARMInstPrinter::printInst(const MCInst *MI, raw_ostream &O,
  76                                StringRef Annot) {
  77   unsigned Opcode = MI->getOpcode();
  78
  79   // Check for HINT instructions w/ canonical names.
  80   if (Opcode == ARM::HINT || Opcode == ARM::tHINT || Opcode == ARM::t2HINT) {
  81     switch (MI->getOperand(0).getImm()) {
  82     case 0: O << "\tnop"; break;
  83     case 1: O << "\tyield"; break;
  84     case 2: O << "\twfe"; break;
  85     case 3: O << "\twfi"; break;
  86     case 4: O << "\tsev"; break;
  87     case 5:
  88       if ((getAvailableFeatures() & ARM::HasV8Ops)) {
  89         O << "\tsevl";
  90         break;
  91       } // Fallthrough for non-v8
  92     default:
  93       // Anything else should just print normally.
  94       printInstruction(MI, O);
  95       printAnnotation(O, Annot);
  96       return;
  97     }
  98     printPredicateOperand(MI, 1, O);
  99     if (Opcode == ARM::t2HINT)
 100       O << ".w";
 101     printAnnotation(O, Annot);
 102     return;
 103   }
 104
 105   // Check for MOVs and print canonical forms, instead.
 106   if (Opcode == ARM::MOVsr) {
 107     // FIXME: Thumb variants?
 108     const MCOperand &Dst = MI->getOperand(0);
 109     const MCOperand &MO1 = MI->getOperand(1);
 110     const MCOperand &MO2 = MI->getOperand(2);
 111     const MCOperand &MO3 = MI->getOperand(3);
 112
 113     O << '\t' << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(MO3.getImm()));
 114     printSBitModifierOperand(MI, 6, O);
 115     printPredicateOperand(MI, 4, O);
 116
 117     O << '\t';
 118     printRegName(O, Dst.getReg());
 119     O << ", ";
 120     printRegName(O, MO1.getReg());
 121
 122     O << ", ";
 123     printRegName(O, MO2.getReg());
 124     assert(ARM_AM::getSORegOffset(MO3.getImm()) == 0);
 125     printAnnotation(O, Annot);
 126     return;
 127   }
 128
 129   if (Opcode == ARM::MOVsi) {
 130     // FIXME: Thumb variants?
 131     const MCOperand &Dst = MI->getOperand(0);
 132     const MCOperand &MO1 = MI->getOperand(1);
 133     const MCOperand &MO2 = MI->getOperand(2);
 134
 135     O << '\t' << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(MO2.getImm()));
 136     printSBitModifierOperand(MI, 5, O);
 137     printPredicateOperand(MI, 3, O);
 138
 139     O << '\t';
 140     printRegName(O, Dst.getReg());
 141     O << ", ";
 142     printRegName(O, MO1.getReg());
 143
 144     if (ARM_AM::getSORegShOp(MO2.getImm()) == ARM_AM::rrx) {
 145       printAnnotation(O, Annot);
 146       return;
 147     }
 148
 149     O << ", "
 150       << markup("<imm:")
 151       << "#" << translateShiftImm(ARM_AM::getSORegOffset(MO2.getImm()))
 152       << markup(">");
 153     printAnnotation(O, Annot);
 154     return;
 155   }
 156
 157
 158   // A8.6.123 PUSH
 159   if ((Opcode == ARM::STMDB_UPD || Opcode == ARM::t2STMDB_UPD) &&
 160       MI->getOperand(0).getReg() == ARM::SP &&
 161       MI->getNumOperands() > 5) {
 162     // Should only print PUSH if there are at least two registers in the list.
 163     O << '\t' << "push";
 164     printPredicateOperand(MI, 2, O);
 165     if (Opcode == ARM::t2STMDB_UPD)
 166       O << ".w";
 167     O << '\t';
 168     printRegisterList(MI, 4, O);
 169     printAnnotation(O, Annot);
 170     return;
 171   }
 172   if (Opcode == ARM::STR_PRE_IMM && MI->getOperand(2).getReg() == ARM::SP &&
 173       MI->getOperand(3).getImm() == -4) {
 174     O << '\t' << "push";
 175     printPredicateOperand(MI, 4, O);
 176     O << "\t{";
 177     printRegName(O, MI->getOperand(1).getReg());
 178     O << "}";
 179     printAnnotation(O, Annot);
 180     return;
 181   }
 182
 183   // A8.6.122 POP
 184   if ((Opcode == ARM::LDMIA_UPD || Opcode == ARM::t2LDMIA_UPD) &&
 185       MI->getOperand(0).getReg() == ARM::SP &&
 186       MI->getNumOperands() > 5) {
 187     // Should only print POP if there are at least two registers in the list.
 188     O << '\t' << "pop";
 189     printPredicateOperand(MI, 2, O);
 190     if (Opcode == ARM::t2LDMIA_UPD)
 191       O << ".w";
 192     O << '\t';
 193     printRegisterList(MI, 4, O);
 194     printAnnotation(O, Annot);
 195     return;
 196   }
 197   if (Opcode == ARM::LDR_POST_IMM && MI->getOperand(2).getReg() == ARM::SP &&
 198       MI->getOperand(4).getImm() == 4) {
 199     O << '\t' << "pop";
 200     printPredicateOperand(MI, 5, O);
 201     O << "\t{";
 202     printRegName(O, MI->getOperand(0).getReg());
 203     O << "}";
 204     printAnnotation(O, Annot);
 205     return;
 206   }
 207
 208
 209   // A8.6.355 VPUSH
 210   if ((Opcode == ARM::VSTMSDB_UPD || Opcode == ARM::VSTMDDB_UPD) &&
 211       MI->getOperand(0).getReg() == ARM::SP) {
 212     O << '\t' << "vpush";
 213     printPredicateOperand(MI, 2, O);
 214     O << '\t';
 215     printRegisterList(MI, 4, O);
 216     printAnnotation(O, Annot);
 217     return;
 218   }
 219
 220   // A8.6.354 VPOP
 221   if ((Opcode == ARM::VLDMSIA_UPD || Opcode == ARM::VLDMDIA_UPD) &&
 222       MI->getOperand(0).getReg() == ARM::SP) {
 223     O << '\t' << "vpop";
 224     printPredicateOperand(MI, 2, O);
 225     O << '\t';
 226     printRegisterList(MI, 4, O);
 227     printAnnotation(O, Annot);
 228     return;
 229   }
 230
 231   if (Opcode == ARM::tLDMIA) {
 232     bool Writeback = true;
 233     unsigned BaseReg = MI->getOperand(0).getReg();
 234     for (unsigned i = 3; i < MI->getNumOperands(); ++i) {
 235       if (MI->getOperand(i).getReg() == BaseReg)
 236         Writeback = false;
 237     }
 238
 239     O << "\tldm";
 240
 241     printPredicateOperand(MI, 1, O);
 242     O << '\t';
 243     printRegName(O, BaseReg);
 244     if (Writeback) O << "!";
 245     O << ", ";
 246     printRegisterList(MI, 3, O);
 247     printAnnotation(O, Annot);
 248     return;
 249   }
 250
 251   // Combine 2 GPRs from disassember into a GPRPair to match with instr def.
 252   // ldrexd/strexd require even/odd GPR pair. To enforce this constraint,
 253   // a single GPRPair reg operand is used in the .td file to replace the two
 254   // GPRs. However, when decoding them, the two GRPs cannot be automatically
 255   // expressed as a GPRPair, so we have to manually merge them.
 256   // FIXME: We would really like to be able to tablegen'erate this.
 257   if (Opcode == ARM::LDREXD || Opcode == ARM::STREXD ||
 258       Opcode == ARM::LDAEXD || Opcode == ARM::STLEXD) {
 259     const MCRegisterClass& MRC = MRI.getRegClass(ARM::GPRRegClassID);
 260     bool isStore = Opcode == ARM::STREXD || Opcode == ARM::STLEXD;
 261     unsigned Reg = MI->getOperand(isStore ? 1 : 0).getReg();
 262     if (MRC.contains(Reg)) {
 263       MCInst NewMI;
 264       MCOperand NewReg;
 265       NewMI.setOpcode(Opcode);
 266
 267       if (isStore)
 268         NewMI.addOperand(MI->getOperand(0));
 269       NewReg = MCOperand::CreateReg(MRI.getMatchingSuperReg(Reg, ARM::gsub_0,
 270         &MRI.getRegClass(ARM::GPRPairRegClassID)));
 271       NewMI.addOperand(NewReg);
 272
 273       // Copy the rest operands into NewMI.
 274       for(unsigned i= isStore ? 3 : 2; i < MI->getNumOperands(); ++i)
 275         NewMI.addOperand(MI->getOperand(i));
 276       printInstruction(&NewMI, O);
 277       return;
 278     }
 279   }
 280
 281   printInstruction(MI, O);
 282   printAnnotation(O, Annot);
 283 }
 284
 285 void ARMInstPrinter::printOperand(const MCInst *MI, unsigned OpNo,
 286                                   raw_ostream &O) {
 287   const MCOperand &Op = MI->getOperand(OpNo);
 288   if (Op.isReg()) {
 289     unsigned Reg = Op.getReg();
 290     printRegName(O, Reg);
 291   } else if (Op.isImm()) {
 292     O << markup("<imm:")
 293       << '#' << formatImm(Op.getImm())
 294       << markup(">");
 295   } else {
 296     assert(Op.isExpr() && "unknown operand kind in printOperand");
 297     // If a symbolic branch target was added as a constant expression then print
 298     // that address in hex. And only print 32 unsigned bits for the address.
 299     const MCConstantExpr *BranchTarget = dyn_cast<MCConstantExpr>(Op.getExpr());
 300     int64_t Address;
 301     if (BranchTarget && BranchTarget->EvaluateAsAbsolute(Address)) {
 302       O << "0x";
 303       O.write_hex((uint32_t)Address);
 304     }
 305     else {
 306       // Otherwise, just print the expression.
 307       O << *Op.getExpr();
 308     }
 309   }
 310 }
 311
 312 void ARMInstPrinter::printThumbLdrLabelOperand(const MCInst *MI, unsigned OpNum,
 313                                                raw_ostream &O) {
 314   const MCOperand &MO1 = MI->getOperand(OpNum);
 315   if (MO1.isExpr()) {
 316     O << *MO1.getExpr();
 317     return;
 318   }
 319
 320   O << markup("<mem:") << "[pc, ";
 321
 322   int32_t OffImm = (int32_t)MO1.getImm();
 323   bool isSub = OffImm < 0;
 324
 325   // Special value for #-0. All others are normal.
 326   if (OffImm == INT32_MIN)
 327     OffImm = 0;
 328   if (isSub) {
 329     O << markup("<imm:")
 330       << "#-" << formatImm(-OffImm)
 331       << markup(">");
 332   } else {
 333     O << markup("<imm:")
 334       << "#" << formatImm(OffImm)
 335       << markup(">");
 336   }
 337   O << "]" << markup(">");
 338 }
 339
 340 // so_reg is a 4-operand unit corresponding to register forms of the A5.1
 341 // "Addressing Mode 1 - Data-processing operands" forms.  This includes:
 342 //    REG 0   0           - e.g. R5
 343 //    REG REG 0,SH_OPC    - e.g. R5, ROR R3
 344 //    REG 0   IMM,SH_OPC  - e.g. R5, LSL #3
 345 void ARMInstPrinter::printSORegRegOperand(const MCInst *MI, unsigned OpNum,
 346                                        raw_ostream &O) {
 347   const MCOperand &MO1 = MI->getOperand(OpNum);
 348   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 349   const MCOperand &MO3 = MI->getOperand(OpNum+2);
 350
 351   printRegName(O, MO1.getReg());
 352
 353   // Print the shift opc.
 354   ARM_AM::ShiftOpc ShOpc = ARM_AM::getSORegShOp(MO3.getImm());
 355   O << ", " << ARM_AM::getShiftOpcStr(ShOpc);
 356   if (ShOpc == ARM_AM::rrx)
 357     return;
 358
 359   O << ' ';
 360   printRegName(O, MO2.getReg());
 361   assert(ARM_AM::getSORegOffset(MO3.getImm()) == 0);
 362 }
 363
 364 void ARMInstPrinter::printSORegImmOperand(const MCInst *MI, unsigned OpNum,
 365                                        raw_ostream &O) {
 366   const MCOperand &MO1 = MI->getOperand(OpNum);
 367   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 368
 369   printRegName(O, MO1.getReg());
 370
 371   // Print the shift opc.
 372   printRegImmShift(O, ARM_AM::getSORegShOp(MO2.getImm()),
 373                    ARM_AM::getSORegOffset(MO2.getImm()), UseMarkup);
 374 }
 375
 376
 377 //===--------------------------------------------------------------------===//
 378 // Addressing Mode #2
 379 //===--------------------------------------------------------------------===//
 380
 381 void ARMInstPrinter::printAM2PreOrOffsetIndexOp(const MCInst *MI, unsigned Op,
 382                                                 raw_ostream &O) {
 383   const MCOperand &MO1 = MI->getOperand(Op);
 384   const MCOperand &MO2 = MI->getOperand(Op+1);
 385   const MCOperand &MO3 = MI->getOperand(Op+2);
 386
 387   O << markup("<mem:") << "[";
 388   printRegName(O, MO1.getReg());
 389
 390   if (!MO2.getReg()) {
 391     if (ARM_AM::getAM2Offset(MO3.getImm())) { // Don't print +0.
 392       O << ", "
 393         << markup("<imm:")
 394         << "#"
 395         << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO3.getImm()))
 396         << ARM_AM::getAM2Offset(MO3.getImm())
 397         << markup(">");
 398     }
 399     O << "]" << markup(">");
 400     return;
 401   }
 402
 403   O << ", ";
 404   O << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO3.getImm()));
 405   printRegName(O, MO2.getReg());
 406
 407   printRegImmShift(O, ARM_AM::getAM2ShiftOpc(MO3.getImm()),
 408                    ARM_AM::getAM2Offset(MO3.getImm()), UseMarkup);
 409   O << "]" << markup(">");
 410 }
 411
 412 void ARMInstPrinter::printAddrModeTBB(const MCInst *MI, unsigned Op,
 413                                            raw_ostream &O) {
 414   const MCOperand &MO1 = MI->getOperand(Op);
 415   const MCOperand &MO2 = MI->getOperand(Op+1);
 416   O << markup("<mem:") << "[";
 417   printRegName(O, MO1.getReg());
 418   O << ", ";
 419   printRegName(O, MO2.getReg());
 420   O << "]" << markup(">");
 421 }
 422
 423 void ARMInstPrinter::printAddrModeTBH(const MCInst *MI, unsigned Op,
 424                                            raw_ostream &O) {
 425   const MCOperand &MO1 = MI->getOperand(Op);
 426   const MCOperand &MO2 = MI->getOperand(Op+1);
 427   O << markup("<mem:") << "[";
 428   printRegName(O, MO1.getReg());
 429   O << ", ";
 430   printRegName(O, MO2.getReg());
 431   O << ", lsl " << markup("<imm:") << "#1" << markup(">") << "]" << markup(">");
 432 }
 433
 434 void ARMInstPrinter::printAddrMode2Operand(const MCInst *MI, unsigned Op,
 435                                            raw_ostream &O) {
 436   const MCOperand &MO1 = MI->getOperand(Op);
 437
 438   if (!MO1.isReg()) {   // FIXME: This is for CP entries, but isn't right.
 439     printOperand(MI, Op, O);
 440     return;
 441   }
 442
 443 #ifndef NDEBUG
 444   const MCOperand &MO3 = MI->getOperand(Op+2);
 445   unsigned IdxMode = ARM_AM::getAM2IdxMode(MO3.getImm());
 446   assert(IdxMode != ARMII::IndexModePost &&
 447          "Should be pre or offset index op");
 448 #endif
 449
 450   printAM2PreOrOffsetIndexOp(MI, Op, O);
 451 }
 452
 453 void ARMInstPrinter::printAddrMode2OffsetOperand(const MCInst *MI,
 454                                                  unsigned OpNum,
 455                                                  raw_ostream &O) {
 456   const MCOperand &MO1 = MI->getOperand(OpNum);
 457   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 458
 459   if (!MO1.getReg()) {
 460     unsigned ImmOffs = ARM_AM::getAM2Offset(MO2.getImm());
 461     O << markup("<imm:")
 462       << '#' << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO2.getImm()))
 463       << ImmOffs
 464       << markup(">");
 465     return;
 466   }
 467
 468   O << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO2.getImm()));
 469   printRegName(O, MO1.getReg());
 470
 471   printRegImmShift(O, ARM_AM::getAM2ShiftOpc(MO2.getImm()),
 472                    ARM_AM::getAM2Offset(MO2.getImm()), UseMarkup);
 473 }
 474
 475 //===--------------------------------------------------------------------===//
 476 // Addressing Mode #3
 477 //===--------------------------------------------------------------------===//
 478
 479 void ARMInstPrinter::printAM3PostIndexOp(const MCInst *MI, unsigned Op,
 480                                          raw_ostream &O) {
 481   const MCOperand &MO1 = MI->getOperand(Op);
 482   const MCOperand &MO2 = MI->getOperand(Op+1);
 483   const MCOperand &MO3 = MI->getOperand(Op+2);
 484
 485   O << markup("<mem:") << "[";
 486   printRegName(O, MO1.getReg());
 487   O << "], " << markup(">");
 488
 489   if (MO2.getReg()) {
 490     O << (char)ARM_AM::getAM3Op(MO3.getImm());
 491     printRegName(O, MO2.getReg());
 492     return;
 493   }
 494
 495   unsigned ImmOffs = ARM_AM::getAM3Offset(MO3.getImm());
 496   O << markup("<imm:")
 497     << '#'
 498     << ARM_AM::getAddrOpcStr(ARM_AM::getAM3Op(MO3.getImm()))
 499     << ImmOffs
 500     << markup(">");
 501 }
 502
 503 void ARMInstPrinter::printAM3PreOrOffsetIndexOp(const MCInst *MI, unsigned Op,
 504                                                 raw_ostream &O,
 505                                                 bool AlwaysPrintImm0) {
 506   const MCOperand &MO1 = MI->getOperand(Op);
 507   const MCOperand &MO2 = MI->getOperand(Op+1);
 508   const MCOperand &MO3 = MI->getOperand(Op+2);
 509
 510   O << markup("<mem:") << '[';
 511   printRegName(O, MO1.getReg());
 512
 513   if (MO2.getReg()) {
 514     O << ", " << getAddrOpcStr(ARM_AM::getAM3Op(MO3.getImm()));
 515     printRegName(O, MO2.getReg());
 516     O << ']' << markup(">");
 517     return;
 518   }
 519
 520   //If the op is sub we have to print the immediate even if it is 0
 521   unsigned ImmOffs = ARM_AM::getAM3Offset(MO3.getImm());
 522   ARM_AM::AddrOpc op = ARM_AM::getAM3Op(MO3.getImm());
 523
 524   if (AlwaysPrintImm0 || ImmOffs || (op == ARM_AM::sub)) {
 525     O << ", "
 526       << markup("<imm:")
 527       << "#"
 528       << ARM_AM::getAddrOpcStr(op)
 529       << ImmOffs
 530       << markup(">");
 531   }
 532   O << ']' << markup(">");
 533 }
 534
 535 template <bool AlwaysPrintImm0>
 536 void ARMInstPrinter::printAddrMode3Operand(const MCInst *MI, unsigned Op,
 537                                            raw_ostream &O) {
 538   const MCOperand &MO1 = MI->getOperand(Op);
 539   if (!MO1.isReg()) {   //  For label symbolic references.
 540     printOperand(MI, Op, O);
 541     return;
 542   }
 543
 544   const MCOperand &MO3 = MI->getOperand(Op+2);
 545   unsigned IdxMode = ARM_AM::getAM3IdxMode(MO3.getImm());
 546
 547   if (IdxMode == ARMII::IndexModePost) {
 548     printAM3PostIndexOp(MI, Op, O);
 549     return;
 550   }
 551   printAM3PreOrOffsetIndexOp(MI, Op, O, AlwaysPrintImm0);
 552 }
 553
 554 void ARMInstPrinter::printAddrMode3OffsetOperand(const MCInst *MI,
 555                                                  unsigned OpNum,
 556                                                  raw_ostream &O) {
 557   const MCOperand &MO1 = MI->getOperand(OpNum);
 558   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 559
 560   if (MO1.getReg()) {
 561     O << getAddrOpcStr(ARM_AM::getAM3Op(MO2.getImm()));
 562     printRegName(O, MO1.getReg());
 563     return;
 564   }
 565
 566   unsigned ImmOffs = ARM_AM::getAM3Offset(MO2.getImm());
 567   O << markup("<imm:")
 568     << '#' << ARM_AM::getAddrOpcStr(ARM_AM::getAM3Op(MO2.getImm())) << ImmOffs
 569     << markup(">");
 570 }
 571
 572 void ARMInstPrinter::printPostIdxImm8Operand(const MCInst *MI,
 573                                              unsigned OpNum,
 574                                              raw_ostream &O) {
 575   const MCOperand &MO = MI->getOperand(OpNum);
 576   unsigned Imm = MO.getImm();
 577   O << markup("<imm:")
 578     << '#' << ((Imm & 256) ? "" : "-") << (Imm & 0xff)
 579     << markup(">");
 580 }
 581
 582 void ARMInstPrinter::printPostIdxRegOperand(const MCInst *MI, unsigned OpNum,
 583                                             raw_ostream &O) {
 584   const MCOperand &MO1 = MI->getOperand(OpNum);
 585   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 586
 587   O << (MO2.getImm() ? "" : "-");
 588   printRegName(O, MO1.getReg());
 589 }
 590
 591 void ARMInstPrinter::printPostIdxImm8s4Operand(const MCInst *MI,
 592                                              unsigned OpNum,
 593                                              raw_ostream &O) {
 594   const MCOperand &MO = MI->getOperand(OpNum);
 595   unsigned Imm = MO.getImm();
 596   O << markup("<imm:")
 597     << '#' << ((Imm & 256) ? "" : "-") << ((Imm & 0xff) << 2)
 598     << markup(">");
 599 }
 600
 601
 602 void ARMInstPrinter::printLdStmModeOperand(const MCInst *MI, unsigned OpNum,
 603                                            raw_ostream &O) {
 604   ARM_AM::AMSubMode Mode = ARM_AM::getAM4SubMode(MI->getOperand(OpNum)
 605                                                  .getImm());
 606   O << ARM_AM::getAMSubModeStr(Mode);
 607 }
 608
 609 template <bool AlwaysPrintImm0>
 610 void ARMInstPrinter::printAddrMode5Operand(const MCInst *MI, unsigned OpNum,
 611                                            raw_ostream &O) {
 612   const MCOperand &MO1 = MI->getOperand(OpNum);
 613   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 614
 615   if (!MO1.isReg()) {   // FIXME: This is for CP entries, but isn't right.
 616     printOperand(MI, OpNum, O);
 617     return;
 618   }
 619
 620   O << markup("<mem:") << "[";
 621   printRegName(O, MO1.getReg());
 622
 623   unsigned ImmOffs = ARM_AM::getAM5Offset(MO2.getImm());
 624   unsigned Op = ARM_AM::getAM5Op(MO2.getImm());
 625   if (AlwaysPrintImm0 || ImmOffs || Op == ARM_AM::sub) {
 626     O << ", "
 627       << markup("<imm:")
 628       << "#"
 629       << ARM_AM::getAddrOpcStr(ARM_AM::getAM5Op(MO2.getImm()))
 630       << ImmOffs * 4
 631       << markup(">");
 632   }
 633   O << "]" << markup(">");
 634 }
 635
 636 void ARMInstPrinter::printAddrMode6Operand(const MCInst *MI, unsigned OpNum,
 637                                            raw_ostream &O) {
 638   const MCOperand &MO1 = MI->getOperand(OpNum);
 639   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 640
 641   O << markup("<mem:") << "[";
 642   printRegName(O, MO1.getReg());
 643   if (MO2.getImm()) {
 644     O << ":" << (MO2.getImm() << 3);
 645   }
 646   O << "]" << markup(">");
 647 }
 648
 649 void ARMInstPrinter::printAddrMode7Operand(const MCInst *MI, unsigned OpNum,
 650                                            raw_ostream &O) {
 651   const MCOperand &MO1 = MI->getOperand(OpNum);
 652   O << markup("<mem:") << "[";
 653   printRegName(O, MO1.getReg());
 654   O << "]" << markup(">");
 655 }
 656
 657 void ARMInstPrinter::printAddrMode6OffsetOperand(const MCInst *MI,
 658                                                  unsigned OpNum,
 659                                                  raw_ostream &O) {
 660   const MCOperand &MO = MI->getOperand(OpNum);
 661   if (MO.getReg() == 0)
 662     O << "!";
 663   else {
 664     O << ", ";
 665     printRegName(O, MO.getReg());
 666   }
 667 }
 668
 669 void ARMInstPrinter::printBitfieldInvMaskImmOperand(const MCInst *MI,
 670                                                     unsigned OpNum,
 671                                                     raw_ostream &O) {
 672   const MCOperand &MO = MI->getOperand(OpNum);
 673   uint32_t v = ~MO.getImm();
 674   int32_t lsb = countTrailingZeros(v);
 675   int32_t width = (32 - countLeadingZeros (v)) - lsb;
 676   assert(MO.isImm() && "Not a valid bf_inv_mask_imm value!");
 677   O << markup("<imm:") << '#' << lsb << markup(">")
 678     << ", "
 679     << markup("<imm:") << '#' << width << markup(">");
 680 }
 681
 682 void ARMInstPrinter::printMemBOption(const MCInst *MI, unsigned OpNum,
 683                                      raw_ostream &O) {
 684   unsigned val = MI->getOperand(OpNum).getImm();
 685   O << ARM_MB::MemBOptToString(val, (getAvailableFeatures() & ARM::HasV8Ops));
 686 }
 687
 688 void ARMInstPrinter::printInstSyncBOption(const MCInst *MI, unsigned OpNum,
 689                                           raw_ostream &O) {
 690   unsigned val = MI->getOperand(OpNum).getImm();
 691   O << ARM_ISB::InstSyncBOptToString(val);
 692 }
 693
 694 void ARMInstPrinter::printShiftImmOperand(const MCInst *MI, unsigned OpNum,
 695                                           raw_ostream &O) {
 696   unsigned ShiftOp = MI->getOperand(OpNum).getImm();
 697   bool isASR = (ShiftOp & (1 << 5)) != 0;
 698   unsigned Amt = ShiftOp & 0x1f;
 699   if (isASR) {
 700     O << ", asr "
 701       << markup("<imm:")
 702       << "#" << (Amt == 0 ? 32 : Amt)
 703       << markup(">");
 704   }
 705   else if (Amt) {
 706     O << ", lsl "
 707       << markup("<imm:")
 708       << "#" << Amt
 709       << markup(">");
 710   }
 711 }
 712
 713 void ARMInstPrinter::printPKHLSLShiftImm(const MCInst *MI, unsigned OpNum,
 714                                          raw_ostream &O) {
 715   unsigned Imm = MI->getOperand(OpNum).getImm();
 716   if (Imm == 0)
 717     return;
 718   assert(Imm > 0 && Imm < 32 && "Invalid PKH shift immediate value!");
 719   O << ", lsl " << markup("<imm:") << "#" << Imm << markup(">");
 720 }
 721
 722 void ARMInstPrinter::printPKHASRShiftImm(const MCInst *MI, unsigned OpNum,
 723                                          raw_ostream &O) {
 724   unsigned Imm = MI->getOperand(OpNum).getImm();
 725   // A shift amount of 32 is encoded as 0.
 726   if (Imm == 0)
 727     Imm = 32;
 728   assert(Imm > 0 && Imm <= 32 && "Invalid PKH shift immediate value!");
 729   O << ", asr " << markup("<imm:") << "#" << Imm << markup(">");
 730 }
 731
 732 void ARMInstPrinter::printRegisterList(const MCInst *MI, unsigned OpNum,
 733                                        raw_ostream &O) {
 734   O << "{";
 735   for (unsigned i = OpNum, e = MI->getNumOperands(); i != e; ++i) {
 736     if (i != OpNum) O << ", ";
 737     printRegName(O, MI->getOperand(i).getReg());
 738   }
 739   O << "}";
 740 }
 741
 742 void ARMInstPrinter::printGPRPairOperand(const MCInst *MI, unsigned OpNum,
 743                                          raw_ostream &O) {
 744   unsigned Reg = MI->getOperand(OpNum).getReg();
 745   printRegName(O, MRI.getSubReg(Reg, ARM::gsub_0));
 746   O << ", ";
 747   printRegName(O, MRI.getSubReg(Reg, ARM::gsub_1));
 748 }
 749
 750
 751 void ARMInstPrinter::printSetendOperand(const MCInst *MI, unsigned OpNum,
 752                                         raw_ostream &O) {
 753   const MCOperand &Op = MI->getOperand(OpNum);
 754   if (Op.getImm())
 755     O << "be";
 756   else
 757     O << "le";
 758 }
 759
 760 void ARMInstPrinter::printCPSIMod(const MCInst *MI, unsigned OpNum,
 761                                   raw_ostream &O) {
 762   const MCOperand &Op = MI->getOperand(OpNum);
 763   O << ARM_PROC::IModToString(Op.getImm());
 764 }
 765
 766 void ARMInstPrinter::printCPSIFlag(const MCInst *MI, unsigned OpNum,
 767                                    raw_ostream &O) {
 768   const MCOperand &Op = MI->getOperand(OpNum);
 769   unsigned IFlags = Op.getImm();
 770   for (int i=2; i >= 0; --i)
 771     if (IFlags & (1 << i))
 772       O << ARM_PROC::IFlagsToString(1 << i);
 773
 774   if (IFlags == 0)
 775     O << "none";
 776 }
 777
 778 void ARMInstPrinter::printMSRMaskOperand(const MCInst *MI, unsigned OpNum,
 779                                          raw_ostream &O) {
 780   const MCOperand &Op = MI->getOperand(OpNum);
 781   unsigned SpecRegRBit = Op.getImm() >> 4;
 782   unsigned Mask = Op.getImm() & 0xf;
 783
 784   if (getAvailableFeatures() & ARM::FeatureMClass) {
 785     unsigned SYSm = Op.getImm();
 786     unsigned Opcode = MI->getOpcode();
 787     // For reads of the special registers ignore the "mask encoding" bits
 788     // which are only for writes.
 789     if (Opcode == ARM::t2MRS_M)
 790       SYSm &= 0xff;
 791     switch (SYSm) {
 792     default: llvm_unreachable("Unexpected mask value!");
 793     case     0:
 794     case 0x800: O << "apsr"; return; // with _nzcvq bits is an alias for aspr
 795     case 0x400: O << "apsr_g"; return;
 796     case 0xc00: O << "apsr_nzcvqg"; return;
 797     case     1:
 798     case 0x801: O << "iapsr"; return; // with _nzcvq bits is an alias for iapsr
 799     case 0x401: O << "iapsr_g"; return;
 800     case 0xc01: O << "iapsr_nzcvqg"; return;
 801     case     2:
 802     case 0x802: O << "eapsr"; return; // with _nzcvq bits is an alias for eapsr
 803     case 0x402: O << "eapsr_g"; return;
 804     case 0xc02: O << "eapsr_nzcvqg"; return;
 805     case     3:
 806     case 0x803: O << "xpsr"; return; // with _nzcvq bits is an alias for xpsr
 807     case 0x403: O << "xpsr_g"; return;
 808     case 0xc03: O << "xpsr_nzcvqg"; return;
 809     case     5:
 810     case 0x805: O << "ipsr"; return;
 811     case     6:
 812     case 0x806: O << "epsr"; return;
 813     case     7:
 814     case 0x807: O << "iepsr"; return;
 815     case     8:
 816     case 0x808: O << "msp"; return;
 817     case     9:
 818     case 0x809: O << "psp"; return;
 819     case  0x10:
 820     case 0x810: O << "primask"; return;
 821     case  0x11:
 822     case 0x811: O << "basepri"; return;
 823     case  0x12:
 824     case 0x812: O << "basepri_max"; return;
 825     case  0x13:
 826     case 0x813: O << "faultmask"; return;
 827     case  0x14:
 828     case 0x814: O << "control"; return;
 829     }
 830   }
 831
 832   // As special cases, CPSR_f, CPSR_s and CPSR_fs prefer printing as
 833   // APSR_nzcvq, APSR_g and APSRnzcvqg, respectively.
 834   if (!SpecRegRBit && (Mask == 8 || Mask == 4 || Mask == 12)) {
 835     O << "APSR_";
 836     switch (Mask) {
 837     default: llvm_unreachable("Unexpected mask value!");
 838     case 4:  O << "g"; return;
 839     case 8:  O << "nzcvq"; return;
 840     case 12: O << "nzcvqg"; return;
 841     }
 842   }
 843
 844   if (SpecRegRBit)
 845     O << "SPSR";
 846   else
 847     O << "CPSR";
 848
 849   if (Mask) {
 850     O << '_';
 851     if (Mask & 8) O << 'f';
 852     if (Mask & 4) O << 's';
 853     if (Mask & 2) O << 'x';
 854     if (Mask & 1) O << 'c';
 855   }
 856 }
 857
 858 void ARMInstPrinter::printPredicateOperand(const MCInst *MI, unsigned OpNum,
 859                                            raw_ostream &O) {
 860   ARMCC::CondCodes CC = (ARMCC::CondCodes)MI->getOperand(OpNum).getImm();
 861   // Handle the undefined 15 CC value here for printing so we don't abort().
 862   if ((unsigned)CC == 15)
 863     O << "<und>";
 864   else if (CC != ARMCC::AL)
 865     O << ARMCondCodeToString(CC);
 866 }
 867
 868 void ARMInstPrinter::printMandatoryPredicateOperand(const MCInst *MI,
 869                                                     unsigned OpNum,
 870                                                     raw_ostream &O) {
 871   ARMCC::CondCodes CC = (ARMCC::CondCodes)MI->getOperand(OpNum).getImm();
 872   O << ARMCondCodeToString(CC);
 873 }
 874
 875 void ARMInstPrinter::printSBitModifierOperand(const MCInst *MI, unsigned OpNum,
 876                                               raw_ostream &O) {
 877   if (MI->getOperand(OpNum).getReg()) {
 878     assert(MI->getOperand(OpNum).getReg() == ARM::CPSR &&
 879            "Expect ARM CPSR register!");
 880     O << 's';
 881   }
 882 }
 883
 884 void ARMInstPrinter::printNoHashImmediate(const MCInst *MI, unsigned OpNum,
 885                                           raw_ostream &O) {
 886   O << MI->getOperand(OpNum).getImm();
 887 }
 888
 889 void ARMInstPrinter::printPImmediate(const MCInst *MI, unsigned OpNum,
 890                                      raw_ostream &O) {
 891   O << "p" << MI->getOperand(OpNum).getImm();
 892 }
 893
 894 void ARMInstPrinter::printCImmediate(const MCInst *MI, unsigned OpNum,
 895                                      raw_ostream &O) {
 896   O << "c" << MI->getOperand(OpNum).getImm();
 897 }
 898
 899 void ARMInstPrinter::printCoprocOptionImm(const MCInst *MI, unsigned OpNum,
 900                                           raw_ostream &O) {
 901   O << "{" << MI->getOperand(OpNum).getImm() << "}";
 902 }
 903
 904 void ARMInstPrinter::printPCLabel(const MCInst *MI, unsigned OpNum,
 905                                   raw_ostream &O) {
 906   llvm_unreachable("Unhandled PC-relative pseudo-instruction!");
 907 }
 908
 909 template<unsigned scale>
 910 void ARMInstPrinter::printAdrLabelOperand(const MCInst *MI, unsigned OpNum,
 911                                   raw_ostream &O) {
 912   const MCOperand &MO = MI->getOperand(OpNum);
 913
 914   if (MO.isExpr()) {
 915     O << *MO.getExpr();
 916     return;
 917   }
 918
 919   int32_t OffImm = (int32_t)MO.getImm() << scale;
 920
 921   O << markup("<imm:");
 922   if (OffImm == INT32_MIN)
 923     O << "#-0";
 924   else if (OffImm < 0)
 925     O << "#-" << -OffImm;
 926   else
 927     O << "#" << OffImm;
 928   O << markup(">");
 929 }
 930
 931 void ARMInstPrinter::printThumbS4ImmOperand(const MCInst *MI, unsigned OpNum,
 932                                             raw_ostream &O) {
 933   O << markup("<imm:")
 934     << "#" << formatImm(MI->getOperand(OpNum).getImm() * 4)
 935     << markup(">");
 936 }
 937
 938 void ARMInstPrinter::printThumbSRImm(const MCInst *MI, unsigned OpNum,
 939                                      raw_ostream &O) {
 940   unsigned Imm = MI->getOperand(OpNum).getImm();
 941   O << markup("<imm:")
 942     << "#" << formatImm((Imm == 0 ? 32 : Imm))
 943     << markup(">");
 944 }
 945
 946 void ARMInstPrinter::printThumbITMask(const MCInst *MI, unsigned OpNum,
 947                                       raw_ostream &O) {
 948   // (3 - the number of trailing zeros) is the number of then / else.
 949   unsigned Mask = MI->getOperand(OpNum).getImm();
 950   unsigned Firstcond = MI->getOperand(OpNum-1).getImm();
 951   unsigned CondBit0 = Firstcond & 1;
 952   unsigned NumTZ = countTrailingZeros(Mask);
 953   assert(NumTZ <= 3 && "Invalid IT mask!");
 954   for (unsigned Pos = 3, e = NumTZ; Pos > e; --Pos) {
 955     bool T = ((Mask >> Pos) & 1) == CondBit0;
 956     if (T)
 957       O << 't';
 958     else
 959       O << 'e';
 960   }
 961 }
 962
 963 void ARMInstPrinter::printThumbAddrModeRROperand(const MCInst *MI, unsigned Op,
 964                                                  raw_ostream &O) {
 965   const MCOperand &MO1 = MI->getOperand(Op);
 966   const MCOperand &MO2 = MI->getOperand(Op + 1);
 967
 968   if (!MO1.isReg()) {   // FIXME: This is for CP entries, but isn't right.
 969     printOperand(MI, Op, O);
 970     return;
 971   }
 972
 973   O << markup("<mem:") << "[";
 974   printRegName(O, MO1.getReg());
 975   if (unsigned RegNum = MO2.getReg()) {
 976     O << ", ";
 977     printRegName(O, RegNum);
 978   }
 979   O << "]" << markup(">");
 980 }
 981
 982 void ARMInstPrinter::printThumbAddrModeImm5SOperand(const MCInst *MI,
 983                                                     unsigned Op,
 984                                                     raw_ostream &O,
 985                                                     unsigned Scale) {
 986   const MCOperand &MO1 = MI->getOperand(Op);
 987   const MCOperand &MO2 = MI->getOperand(Op + 1);
 988
 989   if (!MO1.isReg()) {   // FIXME: This is for CP entries, but isn't right.
 990     printOperand(MI, Op, O);
 991     return;
 992   }
 993
 994   O << markup("<mem:") << "[";
 995   printRegName(O, MO1.getReg());
 996   if (unsigned ImmOffs = MO2.getImm()) {
 997     O << ", "
 998       << markup("<imm:")
 999       << "#" << formatImm(ImmOffs * Scale)
1000       << markup(">");
1001   }
1002   O << "]" << markup(">");
1003 }
1004
1005 void ARMInstPrinter::printThumbAddrModeImm5S1Operand(const MCInst *MI,
1006                                                      unsigned Op,
1007                                                      raw_ostream &O) {
1008   printThumbAddrModeImm5SOperand(MI, Op, O, 1);
1009 }
1010
1011 void ARMInstPrinter::printThumbAddrModeImm5S2Operand(const MCInst *MI,
1012                                                      unsigned Op,
1013                                                      raw_ostream &O) {
1014   printThumbAddrModeImm5SOperand(MI, Op, O, 2);
1015 }
1016
1017 void ARMInstPrinter::printThumbAddrModeImm5S4Operand(const MCInst *MI,
1018                                                      unsigned Op,
1019                                                      raw_ostream &O) {
1020   printThumbAddrModeImm5SOperand(MI, Op, O, 4);
1021 }
1022
1023 void ARMInstPrinter::printThumbAddrModeSPOperand(const MCInst *MI, unsigned Op,
1024                                                  raw_ostream &O) {
1025   printThumbAddrModeImm5SOperand(MI, Op, O, 4);
1026 }
1027
1028 // Constant shifts t2_so_reg is a 2-operand unit corresponding to the Thumb2
1029 // register with shift forms.
1030 // REG 0   0           - e.g. R5
1031 // REG IMM, SH_OPC     - e.g. R5, LSL #3
1032 void ARMInstPrinter::printT2SOOperand(const MCInst *MI, unsigned OpNum,
1033                                       raw_ostream &O) {
1034   const MCOperand &MO1 = MI->getOperand(OpNum);
1035   const MCOperand &MO2 = MI->getOperand(OpNum+1);
1036
1037   unsigned Reg = MO1.getReg();
1038   printRegName(O, Reg);
1039
1040   // Print the shift opc.
1041   assert(MO2.isImm() && "Not a valid t2_so_reg value!");
1042   printRegImmShift(O, ARM_AM::getSORegShOp(MO2.getImm()),
1043                    ARM_AM::getSORegOffset(MO2.getImm()), UseMarkup);
1044 }
1045
1046 template <bool AlwaysPrintImm0>
1047 void ARMInstPrinter::printAddrModeImm12Operand(const MCInst *MI, unsigned OpNum,
1048                                                raw_ostream &O) {
1049   const MCOperand &MO1 = MI->getOperand(OpNum);
1050   const MCOperand &MO2 = MI->getOperand(OpNum+1);
1051
1052   if (!MO1.isReg()) {   // FIXME: This is for CP entries, but isn't right.
1053     printOperand(MI, OpNum, O);
1054     return;
1055   }
1056
1057   O << markup("<mem:") << "[";
1058   printRegName(O, MO1.getReg());
1059
1060   int32_t OffImm = (int32_t)MO2.getImm();
1061   bool isSub = OffImm < 0;
1062   // Special value for #-0. All others are normal.
1063   if (OffImm == INT32_MIN)
1064     OffImm = 0;
1065   if (isSub) {
1066     O << ", "
1067       << markup("<imm:")
1068       << "#-" << -OffImm
1069       << markup(">");
1070   }
1071   else if (AlwaysPrintImm0 || OffImm > 0) {
1072     O << ", "
1073       << markup("<imm:")
1074       << "#" << OffImm
1075       << markup(">");
1076   }
1077   O << "]" << markup(">");
1078 }
1079
1080 template<bool AlwaysPrintImm0>
1081 void ARMInstPrinter::printT2AddrModeImm8Operand(const MCInst *MI,
1082                                                 unsigned OpNum,
1083                                                 raw_ostream &O) {
1084   const MCOperand &MO1 = MI->getOperand(OpNum);
1085   const MCOperand &MO2 = MI->getOperand(OpNum+1);
1086
1087   O << markup("<mem:") << "[";
1088   printRegName(O, MO1.getReg());
1089
1090   int32_t OffImm = (int32_t)MO2.getImm();
1091   bool isSub = OffImm < 0;
1092   // Don't print +0.
1093   if (OffImm == INT32_MIN)
1094     OffImm = 0;
1095   if (isSub) {
1096     O << ", "
1097       << markup("<imm:")
1098       << "#-" << -OffImm
1099       << markup(">");
1100   } else if (AlwaysPrintImm0 || OffImm > 0) {
1101     O << ", "
1102       << markup("<imm:")
1103       << "#" << OffImm
1104       << markup(">");
1105   }
1106   O << "]" << markup(">");
1107 }
1108
1109 template<bool AlwaysPrintImm0>
1110 void ARMInstPrinter::printT2AddrModeImm8s4Operand(const MCInst *MI,
1111                                                   unsigned OpNum,
1112                                                   raw_ostream &O) {
1113   const MCOperand &MO1 = MI->getOperand(OpNum);
1114   const MCOperand &MO2 = MI->getOperand(OpNum+1);
1115
1116   if (!MO1.isReg()) {   //  For label symbolic references.
1117     printOperand(MI, OpNum, O);
1118     return;
1119   }
1120
1121   O << markup("<mem:") << "[";
1122   printRegName(O, MO1.getReg());
1123
1124   int32_t OffImm = (int32_t)MO2.getImm();
1125   bool isSub = OffImm < 0;
1126
1127   assert(((OffImm & 0x3) == 0) && "Not a valid immediate!");
1128
1129   // Don't print +0.
1130   if (OffImm == INT32_MIN)
1131     OffImm = 0;
1132   if (isSub) {
1133     O << ", "
1134       << markup("<imm:")
1135       << "#-" << -OffImm
1136       << markup(">");
1137   } else if (AlwaysPrintImm0 || OffImm > 0) {
1138     O << ", "
1139       << markup("<imm:")
1140       << "#" << OffImm
1141       << markup(">");
1142   }
1143   O << "]" << markup(">");
1144 }
1145
1146 void ARMInstPrinter::printT2AddrModeImm0_1020s4Operand(const MCInst *MI,
1147                                                        unsigned OpNum,
1148                                                        raw_ostream &O) {
1149   const MCOperand &MO1 = MI->getOperand(OpNum);
1150   const MCOperand &MO2 = MI->getOperand(OpNum+1);
1151
1152   O << markup("<mem:") << "[";
1153   printRegName(O, MO1.getReg());
1154   if (MO2.getImm()) {
1155     O << ", "
1156       << markup("<imm:")
1157       << "#" << formatImm(MO2.getImm() * 4)
1158       << markup(">");
1159   }
1160   O << "]" << markup(">");
1161 }
1162
1163 void ARMInstPrinter::printT2AddrModeImm8OffsetOperand(const MCInst *MI,
1164                                                       unsigned OpNum,
1165                                                       raw_ostream &O) {
1166   const MCOperand &MO1 = MI->getOperand(OpNum);
1167   int32_t OffImm = (int32_t)MO1.getImm();
1168   O << ", " << markup("<imm:");
1169   if (OffImm == INT32_MIN)
1170     O << "#-0";
1171   else if (OffImm < 0)
1172     O << "#-" << -OffImm;
1173   else
1174     O << "#" << OffImm;
1175   O << markup(">");
1176 }
1177
1178 void ARMInstPrinter::printT2AddrModeImm8s4OffsetOperand(const MCInst *MI,
1179                                                         unsigned OpNum,
1180                                                         raw_ostream &O) {
1181   const MCOperand &MO1 = MI->getOperand(OpNum);
1182   int32_t OffImm = (int32_t)MO1.getImm();
1183
1184   assert(((OffImm & 0x3) == 0) && "Not a valid immediate!");
1185
1186   O << ", " << markup("<imm:");
1187   if (OffImm == INT32_MIN)
1188     O << "#-0";
1189   else if (OffImm < 0)
1190     O << "#-" << -OffImm;
1191   else
1192     O << "#" << OffImm;
1193   O << markup(">");
1194 }
1195
1196 void ARMInstPrinter::printT2AddrModeSoRegOperand(const MCInst *MI,
1197                                                  unsigned OpNum,
1198                                                  raw_ostream &O) {
1199   const MCOperand &MO1 = MI->getOperand(OpNum);
1200   const MCOperand &MO2 = MI->getOperand(OpNum+1);
1201   const MCOperand &MO3 = MI->getOperand(OpNum+2);
1202
1203   O << markup("<mem:") << "[";
1204   printRegName(O, MO1.getReg());
1205
1206   assert(MO2.getReg() && "Invalid so_reg load / store address!");
1207   O << ", ";
1208   printRegName(O, MO2.getReg());
1209
1210   unsigned ShAmt = MO3.getImm();
1211   if (ShAmt) {
1212     assert(ShAmt <= 3 && "Not a valid Thumb2 addressing mode!");
1213     O << ", lsl "
1214       << markup("<imm:")
1215       << "#" << ShAmt
1216       << markup(">");
1217   }
1218   O << "]" << markup(">");
1219 }
1220
1221 void ARMInstPrinter::printFPImmOperand(const MCInst *MI, unsigned OpNum,
1222                                        raw_ostream &O) {
1223   const MCOperand &MO = MI->getOperand(OpNum);
1224   O << markup("<imm:")
1225     << '#' << ARM_AM::getFPImmFloat(MO.getImm())
1226     << markup(">");
1227 }
1228
1229 void ARMInstPrinter::printNEONModImmOperand(const MCInst *MI, unsigned OpNum,
1230                                             raw_ostream &O) {
1231   unsigned EncodedImm = MI->getOperand(OpNum).getImm();
1232   unsigned EltBits;
1233   uint64_t Val = ARM_AM::decodeNEONModImm(EncodedImm, EltBits);
1234   O << markup("<imm:")
1235     << "#0x";
1236   O.write_hex(Val);
1237   O << markup(">");
1238 }
1239
1240 void ARMInstPrinter::printImmPlusOneOperand(const MCInst *MI, unsigned OpNum,
1241                                             raw_ostream &O) {
1242   unsigned Imm = MI->getOperand(OpNum).getImm();
1243   O << markup("<imm:")
1244     << "#" << formatImm(Imm + 1)
1245     << markup(">");
1246 }
1247
1248 void ARMInstPrinter::printRotImmOperand(const MCInst *MI, unsigned OpNum,
1249                                         raw_ostream &O) {
1250   unsigned Imm = MI->getOperand(OpNum).getImm();
1251   if (Imm == 0)
1252     return;
1253   O << ", ror "
1254     << markup("<imm:")
1255     << "#";
1256   switch (Imm) {
1257   default: assert (0 && "illegal ror immediate!");
1258   case 1: O << "8"; break;
1259   case 2: O << "16"; break;
1260   case 3: O << "24"; break;
1261   }
1262   O << markup(">");
1263 }
1264
1265 void ARMInstPrinter::printFBits16(const MCInst *MI, unsigned OpNum,
1266                                   raw_ostream &O) {
1267   O << markup("<imm:")
1268     << "#" << 16 - MI->getOperand(OpNum).getImm()
1269     << markup(">");
1270 }
1271
1272 void ARMInstPrinter::printFBits32(const MCInst *MI, unsigned OpNum,
1273                                   raw_ostream &O) {
1274   O << markup("<imm:")
1275     << "#" << 32 - MI->getOperand(OpNum).getImm()
1276     << markup(">");
1277 }
1278
1279 void ARMInstPrinter::printVectorIndex(const MCInst *MI, unsigned OpNum,
1280                                       raw_ostream &O) {
1281   O << "[" << MI->getOperand(OpNum).getImm() << "]";
1282 }
1283
1284 void ARMInstPrinter::printVectorListOne(const MCInst *MI, unsigned OpNum,
1285                                         raw_ostream &O) {
1286   O << "{";
1287   printRegName(O, MI->getOperand(OpNum).getReg());
1288   O << "}";
1289 }
1290
1291 void ARMInstPrinter::printVectorListTwo(const MCInst *MI, unsigned OpNum,
1292                                           raw_ostream &O) {
1293   unsigned Reg = MI->getOperand(OpNum).getReg();
1294   unsigned Reg0 = MRI.getSubReg(Reg, ARM::dsub_0);
1295   unsigned Reg1 = MRI.getSubReg(Reg, ARM::dsub_1);
1296   O << "{";
1297   printRegName(O, Reg0);
1298   O << ", ";
1299   printRegName(O, Reg1);
1300   O << "}";
1301 }
1302
1303 void ARMInstPrinter::printVectorListTwoSpaced(const MCInst *MI,
1304                                               unsigned OpNum,
1305                                               raw_ostream &O) {
1306   unsigned Reg = MI->getOperand(OpNum).getReg();
1307   unsigned Reg0 = MRI.getSubReg(Reg, ARM::dsub_0);
1308   unsigned Reg1 = MRI.getSubReg(Reg, ARM::dsub_2);
1309   O << "{";
1310   printRegName(O, Reg0);
1311   O << ", ";
1312   printRegName(O, Reg1);
1313   O << "}";
1314 }
1315
1316 void ARMInstPrinter::printVectorListThree(const MCInst *MI, unsigned OpNum,
1317                                           raw_ostream &O) {
1318   // Normally, it's not safe to use register enum values directly with
1319   // addition to get the next register, but for VFP registers, the
1320   // sort order is guaranteed because they're all of the form D<n>.
1321   O << "{";
1322   printRegName(O, MI->getOperand(OpNum).getReg());
1323   O << ", ";
1324   printRegName(O, MI->getOperand(OpNum).getReg() + 1);
1325   O << ", ";
1326   printRegName(O, MI->getOperand(OpNum).getReg() + 2);
1327   O << "}";
1328 }
1329
1330 void ARMInstPrinter::printVectorListFour(const MCInst *MI, unsigned OpNum,
1331                                          raw_ostream &O) {
1332   // Normally, it's not safe to use register enum values directly with
1333   // addition to get the next register, but for VFP registers, the
1334   // sort order is guaranteed because they're all of the form D<n>.
1335   O << "{";
1336   printRegName(O, MI->getOperand(OpNum).getReg());
1337   O << ", ";
1338   printRegName(O, MI->getOperand(OpNum).getReg() + 1);
1339   O << ", ";
1340   printRegName(O, MI->getOperand(OpNum).getReg() + 2);
1341   O << ", ";
1342   printRegName(O, MI->getOperand(OpNum).getReg() + 3);
1343   O << "}";
1344 }
1345
1346 void ARMInstPrinter::printVectorListOneAllLanes(const MCInst *MI,
1347                                                 unsigned OpNum,
1348                                                 raw_ostream &O) {
1349   O << "{";
1350   printRegName(O, MI->getOperand(OpNum).getReg());
1351   O << "[]}";
1352 }
1353
1354 void ARMInstPrinter::printVectorListTwoAllLanes(const MCInst *MI,
1355                                                 unsigned OpNum,
1356                                                 raw_ostream &O) {
1357   unsigned Reg = MI->getOperand(OpNum).getReg();
1358   unsigned Reg0 = MRI.getSubReg(Reg, ARM::dsub_0);
1359   unsigned Reg1 = MRI.getSubReg(Reg, ARM::dsub_1);
1360   O << "{";
1361   printRegName(O, Reg0);
1362   O << "[], ";
1363   printRegName(O, Reg1);
1364   O << "[]}";
1365 }
1366
1367 void ARMInstPrinter::printVectorListThreeAllLanes(const MCInst *MI,
1368                                                   unsigned OpNum,
1369                                                   raw_ostream &O) {
1370   // Normally, it's not safe to use register enum values directly with
1371   // addition to get the next register, but for VFP registers, the
1372   // sort order is guaranteed because they're all of the form D<n>.
1373   O << "{";
1374   printRegName(O, MI->getOperand(OpNum).getReg());
1375   O << "[], ";
1376   printRegName(O, MI->getOperand(OpNum).getReg() + 1);
1377   O << "[], ";
1378   printRegName(O, MI->getOperand(OpNum).getReg() + 2);
1379   O << "[]}";
1380 }
1381
1382 void ARMInstPrinter::printVectorListFourAllLanes(const MCInst *MI,
1383                                                   unsigned OpNum,
1384                                                   raw_ostream &O) {
1385   // Normally, it's not safe to use register enum values directly with
1386   // addition to get the next register, but for VFP registers, the
1387   // sort order is guaranteed because they're all of the form D<n>.
1388   O << "{";
1389   printRegName(O, MI->getOperand(OpNum).getReg());
1390   O << "[], ";
1391   printRegName(O, MI->getOperand(OpNum).getReg() + 1);
1392   O << "[], ";
1393   printRegName(O, MI->getOperand(OpNum).getReg() + 2);
1394   O << "[], ";
1395   printRegName(O, MI->getOperand(OpNum).getReg() + 3);
1396   O << "[]}";
1397 }
1398
1399 void ARMInstPrinter::printVectorListTwoSpacedAllLanes(const MCInst *MI,
1400                                                       unsigned OpNum,
1401                                                       raw_ostream &O) {
1402   unsigned Reg = MI->getOperand(OpNum).getReg();
1403   unsigned Reg0 = MRI.getSubReg(Reg, ARM::dsub_0);
1404   unsigned Reg1 = MRI.getSubReg(Reg, ARM::dsub_2);
1405   O << "{";
1406   printRegName(O, Reg0);
1407   O << "[], ";
1408   printRegName(O, Reg1);
1409   O << "[]}";
1410 }
1411
1412 void ARMInstPrinter::printVectorListThreeSpacedAllLanes(const MCInst *MI,
1413                                                         unsigned OpNum,
1414                                                         raw_ostream &O) {
1415   // Normally, it's not safe to use register enum values directly with
1416   // addition to get the next register, but for VFP registers, the
1417   // sort order is guaranteed because they're all of the form D<n>.
1418   O << "{";
1419   printRegName(O, MI->getOperand(OpNum).getReg());
1420   O  << "[], ";
1421   printRegName(O, MI->getOperand(OpNum).getReg() + 2);
1422   O << "[], ";
1423   printRegName(O, MI->getOperand(OpNum).getReg() + 4);
1424   O << "[]}";
1425 }
1426
1427 void ARMInstPrinter::printVectorListFourSpacedAllLanes(const MCInst *MI,
1428                                                        unsigned OpNum,
1429                                                        raw_ostream &O) {
1430   // Normally, it's not safe to use register enum values directly with
1431   // addition to get the next register, but for VFP registers, the
1432   // sort order is guaranteed because they're all of the form D<n>.
1433   O << "{";
1434   printRegName(O, MI->getOperand(OpNum).getReg());
1435   O << "[], ";
1436   printRegName(O, MI->getOperand(OpNum).getReg() + 2);
1437   O << "[], ";
1438   printRegName(O, MI->getOperand(OpNum).getReg() + 4);
1439   O << "[], ";
1440   printRegName(O, MI->getOperand(OpNum).getReg() + 6);
1441   O << "[]}";
1442 }
1443
1444 void ARMInstPrinter::printVectorListThreeSpaced(const MCInst *MI,
1445                                                 unsigned OpNum,
1446                                                 raw_ostream &O) {
1447   // Normally, it's not safe to use register enum values directly with
1448   // addition to get the next register, but for VFP registers, the
1449   // sort order is guaranteed because they're all of the form D<n>.
1450   O << "{";
1451   printRegName(O, MI->getOperand(OpNum).getReg());
1452   O << ", ";
1453   printRegName(O, MI->getOperand(OpNum).getReg() + 2);
1454   O << ", ";
1455   printRegName(O, MI->getOperand(OpNum).getReg() + 4);
1456   O << "}";
1457 }
1458
1459 void ARMInstPrinter::printVectorListFourSpaced(const MCInst *MI,
1460                                                 unsigned OpNum,
1461                                                 raw_ostream &O) {
1462   // Normally, it's not safe to use register enum values directly with
1463   // addition to get the next register, but for VFP registers, the
1464   // sort order is guaranteed because they're all of the form D<n>.
1465   O << "{";
1466   printRegName(O, MI->getOperand(OpNum).getReg());
1467   O << ", ";
1468   printRegName(O, MI->getOperand(OpNum).getReg() + 2);
1469   O << ", ";
1470   printRegName(O, MI->getOperand(OpNum).getReg() + 4);
1471   O << ", ";
1472   printRegName(O, MI->getOperand(OpNum).getReg() + 6);
1473   O << "}";
1474 }