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