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/ADT/StringExtras.h"
  22 #include "llvm/Support/raw_ostream.h"
  23 using namespace llvm;
  24
  25 #define GET_INSTRUCTION_NAME
  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, but '0' should actually be printed
  31 /// 32 as the immediate shouldbe within the range 1-32.
  32 static unsigned translateShiftImm(unsigned imm) {
  33   if (imm == 0)
  34     return 32;
  35   return imm;
  36 }
  37
  38
  39 ARMInstPrinter::ARMInstPrinter(const MCAsmInfo &MAI,
  40                                const MCSubtargetInfo &STI) :
  41   MCInstPrinter(MAI) {
  42   // Initialize the set of available features.
  43   setAvailableFeatures(STI.getFeatureBits());
  44 }
  45
  46 StringRef ARMInstPrinter::getOpcodeName(unsigned Opcode) const {
  47   return getInstructionName(Opcode);
  48 }
  49
  50 void ARMInstPrinter::printRegName(raw_ostream &OS, unsigned RegNo) const {
  51   OS << getRegisterName(RegNo);
  52 }
  53
  54 void ARMInstPrinter::printInst(const MCInst *MI, raw_ostream &O) {
  55   unsigned Opcode = MI->getOpcode();
  56
  57   // Check for MOVs and print canonical forms, instead.
  58   if (Opcode == ARM::MOVsr) {
  59     // FIXME: Thumb variants?
  60     const MCOperand &Dst = MI->getOperand(0);
  61     const MCOperand &MO1 = MI->getOperand(1);
  62     const MCOperand &MO2 = MI->getOperand(2);
  63     const MCOperand &MO3 = MI->getOperand(3);
  64
  65     O << '\t' << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(MO3.getImm()));
  66     printSBitModifierOperand(MI, 6, O);
  67     printPredicateOperand(MI, 4, O);
  68
  69     O << '\t' << getRegisterName(Dst.getReg())
  70       << ", " << getRegisterName(MO1.getReg());
  71
  72     O << ", " << getRegisterName(MO2.getReg());
  73     assert(ARM_AM::getSORegOffset(MO3.getImm()) == 0);
  74     return;
  75   }
  76
  77   if (Opcode == ARM::MOVsi) {
  78     // FIXME: Thumb variants?
  79     const MCOperand &Dst = MI->getOperand(0);
  80     const MCOperand &MO1 = MI->getOperand(1);
  81     const MCOperand &MO2 = MI->getOperand(2);
  82
  83     O << '\t' << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(MO2.getImm()));
  84     printSBitModifierOperand(MI, 5, O);
  85     printPredicateOperand(MI, 3, O);
  86
  87     O << '\t' << getRegisterName(Dst.getReg())
  88       << ", " << getRegisterName(MO1.getReg());
  89
  90     if (ARM_AM::getSORegShOp(MO2.getImm()) == ARM_AM::rrx)
  91       return;
  92
  93     O << ", #" << translateShiftImm(ARM_AM::getSORegOffset(MO2.getImm()));
  94     return;
  95   }
  96
  97
  98   // A8.6.123 PUSH
  99   if ((Opcode == ARM::STMDB_UPD || Opcode == ARM::t2STMDB_UPD) &&
 100       MI->getOperand(0).getReg() == ARM::SP) {
 101     O << '\t' << "push";
 102     printPredicateOperand(MI, 2, O);
 103     if (Opcode == ARM::t2STMDB_UPD)
 104       O << ".w";
 105     O << '\t';
 106     printRegisterList(MI, 4, O);
 107     return;
 108   }
 109   if (Opcode == ARM::STR_PRE_IMM && MI->getOperand(2).getReg() == ARM::SP &&
 110       MI->getOperand(3).getImm() == -4) {
 111     O << '\t' << "push";
 112     printPredicateOperand(MI, 4, O);
 113     O << "\t{" << getRegisterName(MI->getOperand(1).getReg()) << "}";
 114     return;
 115   }
 116
 117   // A8.6.122 POP
 118   if ((Opcode == ARM::LDMIA_UPD || Opcode == ARM::t2LDMIA_UPD) &&
 119       MI->getOperand(0).getReg() == ARM::SP) {
 120     O << '\t' << "pop";
 121     printPredicateOperand(MI, 2, O);
 122     if (Opcode == ARM::t2LDMIA_UPD)
 123       O << ".w";
 124     O << '\t';
 125     printRegisterList(MI, 4, O);
 126     return;
 127   }
 128   if (Opcode == ARM::LDR_POST_IMM && MI->getOperand(2).getReg() == ARM::SP &&
 129       MI->getOperand(4).getImm() == 4) {
 130     O << '\t' << "pop";
 131     printPredicateOperand(MI, 5, O);
 132     O << "\t{" << getRegisterName(MI->getOperand(0).getReg()) << "}";
 133     return;
 134   }
 135
 136
 137   // A8.6.355 VPUSH
 138   if ((Opcode == ARM::VSTMSDB_UPD || Opcode == ARM::VSTMDDB_UPD) &&
 139       MI->getOperand(0).getReg() == ARM::SP) {
 140     O << '\t' << "vpush";
 141     printPredicateOperand(MI, 2, O);
 142     O << '\t';
 143     printRegisterList(MI, 4, O);
 144     return;
 145   }
 146
 147   // A8.6.354 VPOP
 148   if ((Opcode == ARM::VLDMSIA_UPD || Opcode == ARM::VLDMDIA_UPD) &&
 149       MI->getOperand(0).getReg() == ARM::SP) {
 150     O << '\t' << "vpop";
 151     printPredicateOperand(MI, 2, O);
 152     O << '\t';
 153     printRegisterList(MI, 4, O);
 154     return;
 155   }
 156
 157   if (Opcode == ARM::tLDMIA) {
 158     bool Writeback = true;
 159     unsigned BaseReg = MI->getOperand(0).getReg();
 160     for (unsigned i = 3; i < MI->getNumOperands(); ++i) {
 161       if (MI->getOperand(i).getReg() == BaseReg)
 162         Writeback = false;
 163     }
 164
 165     O << "\tldm";
 166
 167     printPredicateOperand(MI, 1, O);
 168     O << '\t' << getRegisterName(BaseReg);
 169     if (Writeback) O << "!";
 170     O << ", ";
 171     printRegisterList(MI, 3, O);
 172     return;
 173   }
 174
 175   // Thumb1 NOP
 176   if (Opcode == ARM::tMOVr && MI->getOperand(0).getReg() == ARM::R8 &&
 177       MI->getOperand(1).getReg() == ARM::R8) {
 178     O << "\tnop";
 179     printPredicateOperand(MI, 2, O);
 180     return;
 181   }
 182
 183   printInstruction(MI, O);
 184 }
 185
 186 void ARMInstPrinter::printOperand(const MCInst *MI, unsigned OpNo,
 187                                   raw_ostream &O) {
 188   const MCOperand &Op = MI->getOperand(OpNo);
 189   if (Op.isReg()) {
 190     unsigned Reg = Op.getReg();
 191     O << getRegisterName(Reg);
 192   } else if (Op.isImm()) {
 193     O << '#' << Op.getImm();
 194   } else {
 195     assert(Op.isExpr() && "unknown operand kind in printOperand");
 196     O << *Op.getExpr();
 197   }
 198 }
 199
 200 // so_reg is a 4-operand unit corresponding to register forms of the A5.1
 201 // "Addressing Mode 1 - Data-processing operands" forms.  This includes:
 202 //    REG 0   0           - e.g. R5
 203 //    REG REG 0,SH_OPC    - e.g. R5, ROR R3
 204 //    REG 0   IMM,SH_OPC  - e.g. R5, LSL #3
 205 void ARMInstPrinter::printSORegRegOperand(const MCInst *MI, unsigned OpNum,
 206                                        raw_ostream &O) {
 207   const MCOperand &MO1 = MI->getOperand(OpNum);
 208   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 209   const MCOperand &MO3 = MI->getOperand(OpNum+2);
 210
 211   O << getRegisterName(MO1.getReg());
 212
 213   // Print the shift opc.
 214   ARM_AM::ShiftOpc ShOpc = ARM_AM::getSORegShOp(MO3.getImm());
 215   O << ", " << ARM_AM::getShiftOpcStr(ShOpc);
 216   if (ShOpc == ARM_AM::rrx)
 217     return;
 218
 219   O << ' ' << getRegisterName(MO2.getReg());
 220   assert(ARM_AM::getSORegOffset(MO3.getImm()) == 0);
 221 }
 222
 223 void ARMInstPrinter::printSORegImmOperand(const MCInst *MI, unsigned OpNum,
 224                                        raw_ostream &O) {
 225   const MCOperand &MO1 = MI->getOperand(OpNum);
 226   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 227
 228   O << getRegisterName(MO1.getReg());
 229
 230   // Print the shift opc.
 231   ARM_AM::ShiftOpc ShOpc = ARM_AM::getSORegShOp(MO2.getImm());
 232   O << ", " << ARM_AM::getShiftOpcStr(ShOpc);
 233   if (ShOpc == ARM_AM::rrx)
 234     return;
 235   O << " #" << translateShiftImm(ARM_AM::getSORegOffset(MO2.getImm()));
 236 }
 237
 238
 239 //===--------------------------------------------------------------------===//
 240 // Addressing Mode #2
 241 //===--------------------------------------------------------------------===//
 242
 243 void ARMInstPrinter::printAM2PreOrOffsetIndexOp(const MCInst *MI, unsigned Op,
 244                                                 raw_ostream &O) {
 245   const MCOperand &MO1 = MI->getOperand(Op);
 246   const MCOperand &MO2 = MI->getOperand(Op+1);
 247   const MCOperand &MO3 = MI->getOperand(Op+2);
 248
 249   O << "[" << getRegisterName(MO1.getReg());
 250
 251   if (!MO2.getReg()) {
 252     if (ARM_AM::getAM2Offset(MO3.getImm())) // Don't print +0.
 253       O << ", #"
 254         << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO3.getImm()))
 255         << ARM_AM::getAM2Offset(MO3.getImm());
 256     O << "]";
 257     return;
 258   }
 259
 260   O << ", "
 261     << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO3.getImm()))
 262     << getRegisterName(MO2.getReg());
 263
 264   if (unsigned ShImm = ARM_AM::getAM2Offset(MO3.getImm()))
 265     O << ", "
 266     << ARM_AM::getShiftOpcStr(ARM_AM::getAM2ShiftOpc(MO3.getImm()))
 267     << " #" << ShImm;
 268   O << "]";
 269 }
 270
 271 void ARMInstPrinter::printAM2PostIndexOp(const MCInst *MI, unsigned Op,
 272                                          raw_ostream &O) {
 273   const MCOperand &MO1 = MI->getOperand(Op);
 274   const MCOperand &MO2 = MI->getOperand(Op+1);
 275   const MCOperand &MO3 = MI->getOperand(Op+2);
 276
 277   O << "[" << getRegisterName(MO1.getReg()) << "], ";
 278
 279   if (!MO2.getReg()) {
 280     unsigned ImmOffs = ARM_AM::getAM2Offset(MO3.getImm());
 281     O << '#'
 282       << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO3.getImm()))
 283       << ImmOffs;
 284     return;
 285   }
 286
 287   O << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO3.getImm()))
 288     << getRegisterName(MO2.getReg());
 289
 290   if (unsigned ShImm = ARM_AM::getAM2Offset(MO3.getImm()))
 291     O << ", "
 292     << ARM_AM::getShiftOpcStr(ARM_AM::getAM2ShiftOpc(MO3.getImm()))
 293     << " #" << ShImm;
 294 }
 295
 296 void ARMInstPrinter::printAddrMode2Operand(const MCInst *MI, unsigned Op,
 297                                            raw_ostream &O) {
 298   const MCOperand &MO1 = MI->getOperand(Op);
 299
 300   if (!MO1.isReg()) {   // FIXME: This is for CP entries, but isn't right.
 301     printOperand(MI, Op, O);
 302     return;
 303   }
 304
 305   const MCOperand &MO3 = MI->getOperand(Op+2);
 306   unsigned IdxMode = ARM_AM::getAM2IdxMode(MO3.getImm());
 307
 308   if (IdxMode == ARMII::IndexModePost) {
 309     printAM2PostIndexOp(MI, Op, O);
 310     return;
 311   }
 312   printAM2PreOrOffsetIndexOp(MI, Op, O);
 313 }
 314
 315 void ARMInstPrinter::printAddrMode2OffsetOperand(const MCInst *MI,
 316                                                  unsigned OpNum,
 317                                                  raw_ostream &O) {
 318   const MCOperand &MO1 = MI->getOperand(OpNum);
 319   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 320
 321   if (!MO1.getReg()) {
 322     unsigned ImmOffs = ARM_AM::getAM2Offset(MO2.getImm());
 323     O << '#'
 324       << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO2.getImm()))
 325       << ImmOffs;
 326     return;
 327   }
 328
 329   O << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO2.getImm()))
 330     << getRegisterName(MO1.getReg());
 331
 332   if (unsigned ShImm = ARM_AM::getAM2Offset(MO2.getImm()))
 333     O << ", "
 334     << ARM_AM::getShiftOpcStr(ARM_AM::getAM2ShiftOpc(MO2.getImm()))
 335     << " #" << ShImm;
 336 }
 337
 338 //===--------------------------------------------------------------------===//
 339 // Addressing Mode #3
 340 //===--------------------------------------------------------------------===//
 341
 342 void ARMInstPrinter::printAM3PostIndexOp(const MCInst *MI, unsigned Op,
 343                                          raw_ostream &O) {
 344   const MCOperand &MO1 = MI->getOperand(Op);
 345   const MCOperand &MO2 = MI->getOperand(Op+1);
 346   const MCOperand &MO3 = MI->getOperand(Op+2);
 347
 348   O << "[" << getRegisterName(MO1.getReg()) << "], ";
 349
 350   if (MO2.getReg()) {
 351     O << (char)ARM_AM::getAM3Op(MO3.getImm())
 352     << getRegisterName(MO2.getReg());
 353     return;
 354   }
 355
 356   unsigned ImmOffs = ARM_AM::getAM3Offset(MO3.getImm());
 357   O << '#'
 358     << ARM_AM::getAddrOpcStr(ARM_AM::getAM3Op(MO3.getImm()))
 359     << ImmOffs;
 360 }
 361
 362 void ARMInstPrinter::printAM3PreOrOffsetIndexOp(const MCInst *MI, unsigned Op,
 363                                                 raw_ostream &O) {
 364   const MCOperand &MO1 = MI->getOperand(Op);
 365   const MCOperand &MO2 = MI->getOperand(Op+1);
 366   const MCOperand &MO3 = MI->getOperand(Op+2);
 367
 368   O << '[' << getRegisterName(MO1.getReg());
 369
 370   if (MO2.getReg()) {
 371     O << ", " << getAddrOpcStr(ARM_AM::getAM3Op(MO3.getImm()))
 372       << getRegisterName(MO2.getReg()) << ']';
 373     return;
 374   }
 375
 376   if (unsigned ImmOffs = ARM_AM::getAM3Offset(MO3.getImm()))
 377     O << ", #"
 378       << ARM_AM::getAddrOpcStr(ARM_AM::getAM3Op(MO3.getImm()))
 379       << ImmOffs;
 380   O << ']';
 381 }
 382
 383 void ARMInstPrinter::printAddrMode3Operand(const MCInst *MI, unsigned Op,
 384                                            raw_ostream &O) {
 385   const MCOperand &MO3 = MI->getOperand(Op+2);
 386   unsigned IdxMode = ARM_AM::getAM3IdxMode(MO3.getImm());
 387
 388   if (IdxMode == ARMII::IndexModePost) {
 389     printAM3PostIndexOp(MI, Op, O);
 390     return;
 391   }
 392   printAM3PreOrOffsetIndexOp(MI, Op, O);
 393 }
 394
 395 void ARMInstPrinter::printAddrMode3OffsetOperand(const MCInst *MI,
 396                                                  unsigned OpNum,
 397                                                  raw_ostream &O) {
 398   const MCOperand &MO1 = MI->getOperand(OpNum);
 399   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 400
 401   if (MO1.getReg()) {
 402     O << getAddrOpcStr(ARM_AM::getAM3Op(MO2.getImm()))
 403       << getRegisterName(MO1.getReg());
 404     return;
 405   }
 406
 407   unsigned ImmOffs = ARM_AM::getAM3Offset(MO2.getImm());
 408   O << '#'
 409     << ARM_AM::getAddrOpcStr(ARM_AM::getAM3Op(MO2.getImm()))
 410     << ImmOffs;
 411 }
 412
 413 void ARMInstPrinter::printPostIdxImm8Operand(const MCInst *MI,
 414                                              unsigned OpNum,
 415                                              raw_ostream &O) {
 416   const MCOperand &MO = MI->getOperand(OpNum);
 417   unsigned Imm = MO.getImm();
 418   O << '#' << ((Imm & 256) ? "" : "-") << (Imm & 0xff);
 419 }
 420
 421 void ARMInstPrinter::printPostIdxRegOperand(const MCInst *MI, unsigned OpNum,
 422                                             raw_ostream &O) {
 423   const MCOperand &MO1 = MI->getOperand(OpNum);
 424   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 425
 426   O << (MO2.getImm() ? "" : "-") << getRegisterName(MO1.getReg());
 427 }
 428
 429 void ARMInstPrinter::printPostIdxImm8s4Operand(const MCInst *MI,
 430                                              unsigned OpNum,
 431                                              raw_ostream &O) {
 432   const MCOperand &MO = MI->getOperand(OpNum);
 433   unsigned Imm = MO.getImm();
 434   O << '#' << ((Imm & 256) ? "" : "-") << ((Imm & 0xff) << 2);
 435 }
 436
 437
 438 void ARMInstPrinter::printLdStmModeOperand(const MCInst *MI, unsigned OpNum,
 439                                            raw_ostream &O) {
 440   ARM_AM::AMSubMode Mode = ARM_AM::getAM4SubMode(MI->getOperand(OpNum)
 441                                                  .getImm());
 442   O << ARM_AM::getAMSubModeStr(Mode);
 443 }
 444
 445 void ARMInstPrinter::printAddrMode5Operand(const MCInst *MI, unsigned OpNum,
 446                                            raw_ostream &O) {
 447   const MCOperand &MO1 = MI->getOperand(OpNum);
 448   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 449
 450   if (!MO1.isReg()) {   // FIXME: This is for CP entries, but isn't right.
 451     printOperand(MI, OpNum, O);
 452     return;
 453   }
 454
 455   O << "[" << getRegisterName(MO1.getReg());
 456
 457   unsigned ImmOffs = ARM_AM::getAM5Offset(MO2.getImm());
 458   unsigned Op = ARM_AM::getAM5Op(MO2.getImm());
 459   if (ImmOffs || Op == ARM_AM::sub) {
 460     O << ", #"
 461       << ARM_AM::getAddrOpcStr(ARM_AM::getAM5Op(MO2.getImm()))
 462       << ImmOffs * 4;
 463   }
 464   O << "]";
 465 }
 466
 467 void ARMInstPrinter::printAddrMode6Operand(const MCInst *MI, unsigned OpNum,
 468                                            raw_ostream &O) {
 469   const MCOperand &MO1 = MI->getOperand(OpNum);
 470   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 471
 472   O << "[" << getRegisterName(MO1.getReg());
 473   if (MO2.getImm()) {
 474     // FIXME: Both darwin as and GNU as violate ARM docs here.
 475     O << ", :" << (MO2.getImm() << 3);
 476   }
 477   O << "]";
 478 }
 479
 480 void ARMInstPrinter::printAddrMode7Operand(const MCInst *MI, unsigned OpNum,
 481                                            raw_ostream &O) {
 482   const MCOperand &MO1 = MI->getOperand(OpNum);
 483   O << "[" << getRegisterName(MO1.getReg()) << "]";
 484 }
 485
 486 void ARMInstPrinter::printAddrMode6OffsetOperand(const MCInst *MI,
 487                                                  unsigned OpNum,
 488                                                  raw_ostream &O) {
 489   const MCOperand &MO = MI->getOperand(OpNum);
 490   if (MO.getReg() == 0)
 491     O << "!";
 492   else
 493     O << ", " << getRegisterName(MO.getReg());
 494 }
 495
 496 void ARMInstPrinter::printBitfieldInvMaskImmOperand(const MCInst *MI,
 497                                                     unsigned OpNum,
 498                                                     raw_ostream &O) {
 499   const MCOperand &MO = MI->getOperand(OpNum);
 500   uint32_t v = ~MO.getImm();
 501   int32_t lsb = CountTrailingZeros_32(v);
 502   int32_t width = (32 - CountLeadingZeros_32 (v)) - lsb;
 503   assert(MO.isImm() && "Not a valid bf_inv_mask_imm value!");
 504   O << '#' << lsb << ", #" << width;
 505 }
 506
 507 void ARMInstPrinter::printMemBOption(const MCInst *MI, unsigned OpNum,
 508                                      raw_ostream &O) {
 509   unsigned val = MI->getOperand(OpNum).getImm();
 510   O << ARM_MB::MemBOptToString(val);
 511 }
 512
 513 void ARMInstPrinter::printShiftImmOperand(const MCInst *MI, unsigned OpNum,
 514                                           raw_ostream &O) {
 515   unsigned ShiftOp = MI->getOperand(OpNum).getImm();
 516   bool isASR = (ShiftOp & (1 << 5)) != 0;
 517   unsigned Amt = ShiftOp & 0x1f;
 518   if (isASR)
 519     O << ", asr #" << (Amt == 0 ? 32 : Amt);
 520   else if (Amt)
 521     O << ", lsl #" << Amt;
 522 }
 523
 524 void ARMInstPrinter::printPKHLSLShiftImm(const MCInst *MI, unsigned OpNum,
 525                                          raw_ostream &O) {
 526   unsigned Imm = MI->getOperand(OpNum).getImm();
 527   if (Imm == 0)
 528     return;
 529   assert(Imm > 0 && Imm < 32 && "Invalid PKH shift immediate value!");
 530   O << ", lsl #" << Imm;
 531 }
 532
 533 void ARMInstPrinter::printPKHASRShiftImm(const MCInst *MI, unsigned OpNum,
 534                                          raw_ostream &O) {
 535   unsigned Imm = MI->getOperand(OpNum).getImm();
 536   // A shift amount of 32 is encoded as 0.
 537   if (Imm == 0)
 538     Imm = 32;
 539   assert(Imm > 0 && Imm <= 32 && "Invalid PKH shift immediate value!");
 540   O << ", asr #" << Imm;
 541 }
 542
 543 void ARMInstPrinter::printRegisterList(const MCInst *MI, unsigned OpNum,
 544                                        raw_ostream &O) {
 545   O << "{";
 546   for (unsigned i = OpNum, e = MI->getNumOperands(); i != e; ++i) {
 547     if (i != OpNum) O << ", ";
 548     O << getRegisterName(MI->getOperand(i).getReg());
 549   }
 550   O << "}";
 551 }
 552
 553 void ARMInstPrinter::printSetendOperand(const MCInst *MI, unsigned OpNum,
 554                                         raw_ostream &O) {
 555   const MCOperand &Op = MI->getOperand(OpNum);
 556   if (Op.getImm())
 557     O << "be";
 558   else
 559     O << "le";
 560 }
 561
 562 void ARMInstPrinter::printCPSIMod(const MCInst *MI, unsigned OpNum,
 563                                   raw_ostream &O) {
 564   const MCOperand &Op = MI->getOperand(OpNum);
 565   O << ARM_PROC::IModToString(Op.getImm());
 566 }
 567
 568 void ARMInstPrinter::printCPSIFlag(const MCInst *MI, unsigned OpNum,
 569                                    raw_ostream &O) {
 570   const MCOperand &Op = MI->getOperand(OpNum);
 571   unsigned IFlags = Op.getImm();
 572   for (int i=2; i >= 0; --i)
 573     if (IFlags & (1 << i))
 574       O << ARM_PROC::IFlagsToString(1 << i);
 575 }
 576
 577 void ARMInstPrinter::printMSRMaskOperand(const MCInst *MI, unsigned OpNum,
 578                                          raw_ostream &O) {
 579   const MCOperand &Op = MI->getOperand(OpNum);
 580   unsigned SpecRegRBit = Op.getImm() >> 4;
 581   unsigned Mask = Op.getImm() & 0xf;
 582
 583   // As special cases, CPSR_f, CPSR_s and CPSR_fs prefer printing as
 584   // APSR_nzcvq, APSR_g and APSRnzcvqg, respectively.
 585   if (!SpecRegRBit && (Mask == 8 || Mask == 4 || Mask == 12)) {
 586     O << "APSR_";
 587     switch (Mask) {
 588     default: assert(0);
 589     case 4:  O << "g"; return;
 590     case 8:  O << "nzcvq"; return;
 591     case 12: O << "nzcvqg"; return;
 592     }
 593     llvm_unreachable("Unexpected mask value!");
 594   }
 595
 596   if (SpecRegRBit)
 597     O << "SPSR";
 598   else
 599     O << "CPSR";
 600
 601   if (Mask) {
 602     O << '_';
 603     if (Mask & 8) O << 'f';
 604     if (Mask & 4) O << 's';
 605     if (Mask & 2) O << 'x';
 606     if (Mask & 1) O << 'c';
 607   }
 608 }
 609
 610 void ARMInstPrinter::printPredicateOperand(const MCInst *MI, unsigned OpNum,
 611                                            raw_ostream &O) {
 612   ARMCC::CondCodes CC = (ARMCC::CondCodes)MI->getOperand(OpNum).getImm();
 613   if (CC != ARMCC::AL)
 614     O << ARMCondCodeToString(CC);
 615 }
 616
 617 void ARMInstPrinter::printMandatoryPredicateOperand(const MCInst *MI,
 618                                                     unsigned OpNum,
 619                                                     raw_ostream &O) {
 620   ARMCC::CondCodes CC = (ARMCC::CondCodes)MI->getOperand(OpNum).getImm();
 621   O << ARMCondCodeToString(CC);
 622 }
 623
 624 void ARMInstPrinter::printSBitModifierOperand(const MCInst *MI, unsigned OpNum,
 625                                               raw_ostream &O) {
 626   if (MI->getOperand(OpNum).getReg()) {
 627     assert(MI->getOperand(OpNum).getReg() == ARM::CPSR &&
 628            "Expect ARM CPSR register!");
 629     O << 's';
 630   }
 631 }
 632
 633 void ARMInstPrinter::printNoHashImmediate(const MCInst *MI, unsigned OpNum,
 634                                           raw_ostream &O) {
 635   O << MI->getOperand(OpNum).getImm();
 636 }
 637
 638 void ARMInstPrinter::printPImmediate(const MCInst *MI, unsigned OpNum,
 639                                           raw_ostream &O) {
 640   O << "p" << MI->getOperand(OpNum).getImm();
 641 }
 642
 643 void ARMInstPrinter::printCImmediate(const MCInst *MI, unsigned OpNum,
 644                                           raw_ostream &O) {
 645   O << "c" << MI->getOperand(OpNum).getImm();
 646 }
 647
 648 void ARMInstPrinter::printPCLabel(const MCInst *MI, unsigned OpNum,
 649                                   raw_ostream &O) {
 650   llvm_unreachable("Unhandled PC-relative pseudo-instruction!");
 651 }
 652
 653 void ARMInstPrinter::printThumbS4ImmOperand(const MCInst *MI, unsigned OpNum,
 654                                             raw_ostream &O) {
 655   O << "#" << MI->getOperand(OpNum).getImm() * 4;
 656 }
 657
 658 void ARMInstPrinter::printThumbSRImm(const MCInst *MI, unsigned OpNum,
 659                                      raw_ostream &O) {
 660   unsigned Imm = MI->getOperand(OpNum).getImm();
 661   O << "#" << (Imm == 0 ? 32 : Imm);
 662 }
 663
 664 void ARMInstPrinter::printThumbITMask(const MCInst *MI, unsigned OpNum,
 665                                       raw_ostream &O) {
 666   // (3 - the number of trailing zeros) is the number of then / else.
 667   unsigned Mask = MI->getOperand(OpNum).getImm();
 668   unsigned CondBit0 = Mask >> 4 & 1;
 669   unsigned NumTZ = CountTrailingZeros_32(Mask);
 670   assert(NumTZ <= 3 && "Invalid IT mask!");
 671   for (unsigned Pos = 3, e = NumTZ; Pos > e; --Pos) {
 672     bool T = ((Mask >> Pos) & 1) == CondBit0;
 673     if (T)
 674       O << 't';
 675     else
 676       O << 'e';
 677   }
 678 }
 679
 680 void ARMInstPrinter::printThumbAddrModeRROperand(const MCInst *MI, unsigned Op,
 681                                                  raw_ostream &O) {
 682   const MCOperand &MO1 = MI->getOperand(Op);
 683   const MCOperand &MO2 = MI->getOperand(Op + 1);
 684
 685   if (!MO1.isReg()) {   // FIXME: This is for CP entries, but isn't right.
 686     printOperand(MI, Op, O);
 687     return;
 688   }
 689
 690   O << "[" << getRegisterName(MO1.getReg());
 691   if (unsigned RegNum = MO2.getReg())
 692     O << ", " << getRegisterName(RegNum);
 693   O << "]";
 694 }
 695
 696 void ARMInstPrinter::printThumbAddrModeImm5SOperand(const MCInst *MI,
 697                                                     unsigned Op,
 698                                                     raw_ostream &O,
 699                                                     unsigned Scale) {
 700   const MCOperand &MO1 = MI->getOperand(Op);
 701   const MCOperand &MO2 = MI->getOperand(Op + 1);
 702
 703   if (!MO1.isReg()) {   // FIXME: This is for CP entries, but isn't right.
 704     printOperand(MI, Op, O);
 705     return;
 706   }
 707
 708   O << "[" << getRegisterName(MO1.getReg());
 709   if (unsigned ImmOffs = MO2.getImm())
 710     O << ", #" << ImmOffs * Scale;
 711   O << "]";
 712 }
 713
 714 void ARMInstPrinter::printThumbAddrModeImm5S1Operand(const MCInst *MI,
 715                                                      unsigned Op,
 716                                                      raw_ostream &O) {
 717   printThumbAddrModeImm5SOperand(MI, Op, O, 1);
 718 }
 719
 720 void ARMInstPrinter::printThumbAddrModeImm5S2Operand(const MCInst *MI,
 721                                                      unsigned Op,
 722                                                      raw_ostream &O) {
 723   printThumbAddrModeImm5SOperand(MI, Op, O, 2);
 724 }
 725
 726 void ARMInstPrinter::printThumbAddrModeImm5S4Operand(const MCInst *MI,
 727                                                      unsigned Op,
 728                                                      raw_ostream &O) {
 729   printThumbAddrModeImm5SOperand(MI, Op, O, 4);
 730 }
 731
 732 void ARMInstPrinter::printThumbAddrModeSPOperand(const MCInst *MI, unsigned Op,
 733                                                  raw_ostream &O) {
 734   printThumbAddrModeImm5SOperand(MI, Op, O, 4);
 735 }
 736
 737 // Constant shifts t2_so_reg is a 2-operand unit corresponding to the Thumb2
 738 // register with shift forms.
 739 // REG 0   0           - e.g. R5
 740 // REG IMM, SH_OPC     - e.g. R5, LSL #3
 741 void ARMInstPrinter::printT2SOOperand(const MCInst *MI, unsigned OpNum,
 742                                       raw_ostream &O) {
 743   const MCOperand &MO1 = MI->getOperand(OpNum);
 744   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 745
 746   unsigned Reg = MO1.getReg();
 747   O << getRegisterName(Reg);
 748
 749   // Print the shift opc.
 750   assert(MO2.isImm() && "Not a valid t2_so_reg value!");
 751   ARM_AM::ShiftOpc ShOpc = ARM_AM::getSORegShOp(MO2.getImm());
 752   O << ", " << ARM_AM::getShiftOpcStr(ShOpc);
 753   if (ShOpc != ARM_AM::rrx)
 754     O << " #" << translateShiftImm(ARM_AM::getSORegOffset(MO2.getImm()));
 755 }
 756
 757 void ARMInstPrinter::printAddrModeImm12Operand(const MCInst *MI, unsigned OpNum,
 758                                                raw_ostream &O) {
 759   const MCOperand &MO1 = MI->getOperand(OpNum);
 760   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 761
 762   if (!MO1.isReg()) {   // FIXME: This is for CP entries, but isn't right.
 763     printOperand(MI, OpNum, O);
 764     return;
 765   }
 766
 767   O << "[" << getRegisterName(MO1.getReg());
 768
 769   int32_t OffImm = (int32_t)MO2.getImm();
 770   bool isSub = OffImm < 0;
 771   // Special value for #-0. All others are normal.
 772   if (OffImm == INT32_MIN)
 773     OffImm = 0;
 774   if (isSub)
 775     O << ", #-" << -OffImm;
 776   else if (OffImm > 0)
 777     O << ", #" << OffImm;
 778   O << "]";
 779 }
 780
 781 void ARMInstPrinter::printT2AddrModeImm8Operand(const MCInst *MI,
 782                                                 unsigned OpNum,
 783                                                 raw_ostream &O) {
 784   const MCOperand &MO1 = MI->getOperand(OpNum);
 785   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 786
 787   O << "[" << getRegisterName(MO1.getReg());
 788
 789   int32_t OffImm = (int32_t)MO2.getImm();
 790   // Don't print +0.
 791   if (OffImm < 0)
 792     O << ", #-" << -OffImm;
 793   else if (OffImm > 0)
 794     O << ", #" << OffImm;
 795   O << "]";
 796 }
 797
 798 void ARMInstPrinter::printT2AddrModeImm8s4Operand(const MCInst *MI,
 799                                                   unsigned OpNum,
 800                                                   raw_ostream &O) {
 801   const MCOperand &MO1 = MI->getOperand(OpNum);
 802   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 803
 804   O << "[" << getRegisterName(MO1.getReg());
 805
 806   int32_t OffImm = (int32_t)MO2.getImm() / 4;
 807   // Don't print +0.
 808   if (OffImm < 0)
 809     O << ", #-" << -OffImm * 4;
 810   else if (OffImm > 0)
 811     O << ", #" << OffImm * 4;
 812   O << "]";
 813 }
 814
 815 void ARMInstPrinter::printT2AddrModeImm0_1020s4Operand(const MCInst *MI,
 816                                                        unsigned OpNum,
 817                                                        raw_ostream &O) {
 818   const MCOperand &MO1 = MI->getOperand(OpNum);
 819   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 820
 821   O << "[" << getRegisterName(MO1.getReg());
 822   if (MO2.getImm())
 823     O << ", #" << MO2.getImm() * 4;
 824   O << "]";
 825 }
 826
 827 void ARMInstPrinter::printT2AddrModeImm8OffsetOperand(const MCInst *MI,
 828                                                       unsigned OpNum,
 829                                                       raw_ostream &O) {
 830   const MCOperand &MO1 = MI->getOperand(OpNum);
 831   int32_t OffImm = (int32_t)MO1.getImm();
 832   // Don't print +0.
 833   if (OffImm < 0)
 834     O << "#-" << -OffImm;
 835   else if (OffImm > 0)
 836     O << "#" << OffImm;
 837 }
 838
 839 void ARMInstPrinter::printT2AddrModeImm8s4OffsetOperand(const MCInst *MI,
 840                                                         unsigned OpNum,
 841                                                         raw_ostream &O) {
 842   const MCOperand &MO1 = MI->getOperand(OpNum);
 843   int32_t OffImm = (int32_t)MO1.getImm() / 4;
 844   // Don't print +0.
 845   if (OffImm != 0) {
 846     O << ", ";
 847     if (OffImm < 0)
 848       O << "#-" << -OffImm * 4;
 849     else if (OffImm > 0)
 850       O << "#" << OffImm * 4;
 851   }
 852 }
 853
 854 void ARMInstPrinter::printT2AddrModeSoRegOperand(const MCInst *MI,
 855                                                  unsigned OpNum,
 856                                                  raw_ostream &O) {
 857   const MCOperand &MO1 = MI->getOperand(OpNum);
 858   const MCOperand &MO2 = MI->getOperand(OpNum+1);
 859   const MCOperand &MO3 = MI->getOperand(OpNum+2);
 860
 861   O << "[" << getRegisterName(MO1.getReg());
 862
 863   assert(MO2.getReg() && "Invalid so_reg load / store address!");
 864   O << ", " << getRegisterName(MO2.getReg());
 865
 866   unsigned ShAmt = MO3.getImm();
 867   if (ShAmt) {
 868     assert(ShAmt <= 3 && "Not a valid Thumb2 addressing mode!");
 869     O << ", lsl #" << ShAmt;
 870   }
 871   O << "]";
 872 }
 873
 874 void ARMInstPrinter::printVFPf32ImmOperand(const MCInst *MI, unsigned OpNum,
 875                                            raw_ostream &O) {
 876   const MCOperand &MO = MI->getOperand(OpNum);
 877   O << '#';
 878   if (MO.isFPImm()) {
 879     O << (float)MO.getFPImm();
 880   } else {
 881     union {
 882       uint32_t I;
 883       float F;
 884     } FPUnion;
 885
 886     FPUnion.I = MO.getImm();
 887     O << FPUnion.F;
 888   }
 889 }
 890
 891 void ARMInstPrinter::printVFPf64ImmOperand(const MCInst *MI, unsigned OpNum,
 892                                            raw_ostream &O) {
 893   const MCOperand &MO = MI->getOperand(OpNum);
 894   O << '#';
 895   if (MO.isFPImm()) {
 896     O << MO.getFPImm();
 897   } else {
 898     // We expect the binary encoding of a floating point number here.
 899     union {
 900       uint64_t I;
 901       double D;
 902     } FPUnion;
 903
 904     FPUnion.I = MO.getImm();
 905     O << FPUnion.D;
 906   }
 907 }
 908
 909 void ARMInstPrinter::printNEONModImmOperand(const MCInst *MI, unsigned OpNum,
 910                                             raw_ostream &O) {
 911   unsigned EncodedImm = MI->getOperand(OpNum).getImm();
 912   unsigned EltBits;
 913   uint64_t Val = ARM_AM::decodeNEONModImm(EncodedImm, EltBits);
 914   O << "#0x" << utohexstr(Val);
 915 }
 916
 917 void ARMInstPrinter::printImmPlusOneOperand(const MCInst *MI, unsigned OpNum,
 918                                             raw_ostream &O) {
 919   unsigned Imm = MI->getOperand(OpNum).getImm();
 920   O << "#" << Imm + 1;
 921 }
 922
 923 void ARMInstPrinter::printRotImmOperand(const MCInst *MI, unsigned OpNum,
 924                                         raw_ostream &O) {
 925   unsigned Imm = MI->getOperand(OpNum).getImm();
 926   if (Imm == 0)
 927     return;
 928   O << ", ror #";
 929   switch (Imm) {
 930   default: assert (0 && "illegal ror immediate!");
 931   case 1: O << "8"; break;
 932   case 2: O << "16"; break;
 933   case 3: O << "24"; break;
 934   }
 935 }