LCOV - code coverage report
Current view: top level - lib/Target/ARM/InstPrinter - ARMInstPrinter.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 771 872 88.4 %
Date: 2017-09-14 15:23:50 Functions: 84 92 91.3 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13