lib/Target/ARM/ARMMCCodeEmitter.cpp

   1 //===-- ARM/ARMMCCodeEmitter.cpp - Convert ARM code to machine code -------===//
   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 file implements the ARMMCCodeEmitter class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "mccodeemitter"
  15 #include "ARM.h"
  16 #include "ARMAddressingModes.h"
  17 #include "ARMFixupKinds.h"
  18 #include "ARMInstrInfo.h"
  19 #include "llvm/MC/MCCodeEmitter.h"
  20 #include "llvm/MC/MCExpr.h"
  21 #include "llvm/MC/MCInst.h"
  22 #include "llvm/ADT/Statistic.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 using namespace llvm;
  25
  26 STATISTIC(MCNumEmitted, "Number of MC instructions emitted.");
  27 STATISTIC(MCNumCPRelocations, "Number of constant pool relocations created.");
  28
  29 namespace {
  30 class ARMMCCodeEmitter : public MCCodeEmitter {
  31   ARMMCCodeEmitter(const ARMMCCodeEmitter &); // DO NOT IMPLEMENT
  32   void operator=(const ARMMCCodeEmitter &); // DO NOT IMPLEMENT
  33   const TargetMachine &TM;
  34   const TargetInstrInfo &TII;
  35   MCContext &Ctx;
  36
  37 public:
  38   ARMMCCodeEmitter(TargetMachine &tm, MCContext &ctx)
  39     : TM(tm), TII(*TM.getInstrInfo()), Ctx(ctx) {
  40   }
  41
  42   ~ARMMCCodeEmitter() {}
  43
  44   unsigned getNumFixupKinds() const { return ARM::NumTargetFixupKinds; }
  45
  46   const MCFixupKindInfo &getFixupKindInfo(MCFixupKind Kind) const {
  47     const static MCFixupKindInfo Infos[] = {
  48       // name                     offset  bits  flags
  49       { "fixup_arm_pcrel_12",     1,      24,   MCFixupKindInfo::FKF_IsPCRel },
  50       { "fixup_arm_pcrel_10",     1,      24,   MCFixupKindInfo::FKF_IsPCRel },
  51       { "fixup_arm_branch",       1,      24,   MCFixupKindInfo::FKF_IsPCRel },
  52       { "fixup_arm_movt_hi16",    0,      16,   0 },
  53       { "fixup_arm_movw_lo16",    0,      16,   0 },
  54     };
  55
  56     if (Kind < FirstTargetFixupKind)
  57       return MCCodeEmitter::getFixupKindInfo(Kind);
  58
  59     assert(unsigned(Kind - FirstTargetFixupKind) < getNumFixupKinds() &&
  60            "Invalid kind!");
  61     return Infos[Kind - FirstTargetFixupKind];
  62   }
  63   unsigned getMachineSoImmOpValue(unsigned SoImm) const;
  64
  65   // getBinaryCodeForInstr - TableGen'erated function for getting the
  66   // binary encoding for an instruction.
  67   unsigned getBinaryCodeForInstr(const MCInst &MI,
  68                                  SmallVectorImpl<MCFixup> &Fixups) const;
  69
  70   /// getMachineOpValue - Return binary encoding of operand. If the machine
  71   /// operand requires relocation, record the relocation and return zero.
  72   unsigned getMachineOpValue(const MCInst &MI,const MCOperand &MO,
  73                              SmallVectorImpl<MCFixup> &Fixups) const;
  74
  75   /// getMovtImmOpValue - Return the encoding for the movw/movt pair
  76   uint32_t getMovtImmOpValue(const MCInst &MI, unsigned OpIdx,
  77                              SmallVectorImpl<MCFixup> &Fixups) const;
  78
  79   bool EncodeAddrModeOpValues(const MCInst &MI, unsigned OpIdx,
  80                               unsigned &Reg, unsigned &Imm,
  81                               SmallVectorImpl<MCFixup> &Fixups) const;
  82
  83   /// getBranchTargetOpValue - Return encoding info for 24-bit immediate
  84   /// branch target.
  85   uint32_t getBranchTargetOpValue(const MCInst &MI, unsigned OpIdx,
  86                                   SmallVectorImpl<MCFixup> &Fixups) const;
  87
  88   /// getAdrLabelOpValue - Return encoding info for 12-bit immediate
  89   /// ADR label target.
  90   uint32_t getAdrLabelOpValue(const MCInst &MI, unsigned OpIdx,
  91                               SmallVectorImpl<MCFixup> &Fixups) const;
  92
  93   /// getAddrModeImm12OpValue - Return encoding info for 'reg +/- imm12'
  94   /// operand.
  95   uint32_t getAddrModeImm12OpValue(const MCInst &MI, unsigned OpIdx,
  96                                    SmallVectorImpl<MCFixup> &Fixups) const;
  97
  98   /// getT2AddrModeImm8s4OpValue - Return encoding info for 'reg +/- imm8<<2'
  99   /// operand.
 100   uint32_t getT2AddrModeImm8s4OpValue(const MCInst &MI, unsigned OpIdx,
 101                                    SmallVectorImpl<MCFixup> &Fixups) const;
 102
 103
 104   /// getLdStSORegOpValue - Return encoding info for 'reg +/- reg shop imm'
 105   /// operand as needed by load/store instructions.
 106   uint32_t getLdStSORegOpValue(const MCInst &MI, unsigned OpIdx,
 107                                SmallVectorImpl<MCFixup> &Fixups) const;
 108
 109   /// getLdStmModeOpValue - Return encoding for load/store multiple mode.
 110   uint32_t getLdStmModeOpValue(const MCInst &MI, unsigned OpIdx,
 111                                SmallVectorImpl<MCFixup> &Fixups) const {
 112     ARM_AM::AMSubMode Mode = (ARM_AM::AMSubMode)MI.getOperand(OpIdx).getImm();
 113     switch (Mode) {
 114     default: assert(0 && "Unknown addressing sub-mode!");
 115     case ARM_AM::da: return 0;
 116     case ARM_AM::ia: return 1;
 117     case ARM_AM::db: return 2;
 118     case ARM_AM::ib: return 3;
 119     }
 120   }
 121   /// getShiftOp - Return the shift opcode (bit[6:5]) of the immediate value.
 122   ///
 123   unsigned getShiftOp(ARM_AM::ShiftOpc ShOpc) const {
 124     switch (ShOpc) {
 125     default: llvm_unreachable("Unknown shift opc!");
 126     case ARM_AM::no_shift:
 127     case ARM_AM::lsl: return 0;
 128     case ARM_AM::lsr: return 1;
 129     case ARM_AM::asr: return 2;
 130     case ARM_AM::ror:
 131     case ARM_AM::rrx: return 3;
 132     }
 133     return 0;
 134   }
 135
 136   /// getAddrMode2OpValue - Return encoding for addrmode2 operands.
 137   uint32_t getAddrMode2OpValue(const MCInst &MI, unsigned OpIdx,
 138                                SmallVectorImpl<MCFixup> &Fixups) const;
 139
 140   /// getAddrMode2OffsetOpValue - Return encoding for am2offset operands.
 141   uint32_t getAddrMode2OffsetOpValue(const MCInst &MI, unsigned OpIdx,
 142                                      SmallVectorImpl<MCFixup> &Fixups) const;
 143
 144   /// getAddrMode3OffsetOpValue - Return encoding for am3offset operands.
 145   uint32_t getAddrMode3OffsetOpValue(const MCInst &MI, unsigned OpIdx,
 146                                      SmallVectorImpl<MCFixup> &Fixups) const;
 147
 148   /// getAddrMode3OpValue - Return encoding for addrmode3 operands.
 149   uint32_t getAddrMode3OpValue(const MCInst &MI, unsigned OpIdx,
 150                                SmallVectorImpl<MCFixup> &Fixups) const;
 151
 152   /// getAddrModeS4OpValue - Return encoding for t_addrmode_s4 operands.
 153   uint32_t getAddrModeS4OpValue(const MCInst &MI, unsigned OpIdx,
 154                                 SmallVectorImpl<MCFixup> &Fixups) const;
 155
 156   /// getAddrModeS2OpValue - Return encoding for t_addrmode_s2 operands.
 157   uint32_t getAddrModeS2OpValue(const MCInst &MI, unsigned OpIdx,
 158                                 SmallVectorImpl<MCFixup> &Fixups) const;
 159
 160   /// getAddrModeS1OpValue - Return encoding for t_addrmode_s1 operands.
 161   uint32_t getAddrModeS1OpValue(const MCInst &MI, unsigned OpIdx,
 162                                 SmallVectorImpl<MCFixup> &Fixups) const;
 163
 164   /// getAddrMode5OpValue - Return encoding info for 'reg +/- imm8' operand.
 165   uint32_t getAddrMode5OpValue(const MCInst &MI, unsigned OpIdx,
 166                                SmallVectorImpl<MCFixup> &Fixups) const;
 167
 168   /// getCCOutOpValue - Return encoding of the 's' bit.
 169   unsigned getCCOutOpValue(const MCInst &MI, unsigned Op,
 170                            SmallVectorImpl<MCFixup> &Fixups) const {
 171     // The operand is either reg0 or CPSR. The 's' bit is encoded as '0' or
 172     // '1' respectively.
 173     return MI.getOperand(Op).getReg() == ARM::CPSR;
 174   }
 175
 176   /// getSOImmOpValue - Return an encoded 12-bit shifted-immediate value.
 177   unsigned getSOImmOpValue(const MCInst &MI, unsigned Op,
 178                            SmallVectorImpl<MCFixup> &Fixups) const {
 179     unsigned SoImm = MI.getOperand(Op).getImm();
 180     int SoImmVal = ARM_AM::getSOImmVal(SoImm);
 181     assert(SoImmVal != -1 && "Not a valid so_imm value!");
 182
 183     // Encode rotate_imm.
 184     unsigned Binary = (ARM_AM::getSOImmValRot((unsigned)SoImmVal) >> 1)
 185       << ARMII::SoRotImmShift;
 186
 187     // Encode immed_8.
 188     Binary |= ARM_AM::getSOImmValImm((unsigned)SoImmVal);
 189     return Binary;
 190   }
 191
 192   /// getT2SOImmOpValue - Return an encoded 12-bit shifted-immediate value.
 193   unsigned getT2SOImmOpValue(const MCInst &MI, unsigned Op,
 194                            SmallVectorImpl<MCFixup> &Fixups) const {
 195     unsigned SoImm = MI.getOperand(Op).getImm();
 196     unsigned Encoded =  ARM_AM::getT2SOImmVal(SoImm);
 197     assert(Encoded != ~0U && "Not a Thumb2 so_imm value?");
 198     return Encoded;
 199   }
 200
 201   unsigned getT2AddrModeSORegOpValue(const MCInst &MI, unsigned OpNum,
 202     SmallVectorImpl<MCFixup> &Fixups) const;
 203   unsigned getT2AddrModeImm8OpValue(const MCInst &MI, unsigned OpNum,
 204     SmallVectorImpl<MCFixup> &Fixups) const;
 205   unsigned getT2AddrModeImm8OffsetOpValue(const MCInst &MI, unsigned OpNum,
 206     SmallVectorImpl<MCFixup> &Fixups) const;
 207   unsigned getT2AddrModeImm12OffsetOpValue(const MCInst &MI, unsigned OpNum,
 208     SmallVectorImpl<MCFixup> &Fixups) const;
 209
 210   /// getSORegOpValue - Return an encoded so_reg shifted register value.
 211   unsigned getSORegOpValue(const MCInst &MI, unsigned Op,
 212                            SmallVectorImpl<MCFixup> &Fixups) const;
 213   unsigned getT2SORegOpValue(const MCInst &MI, unsigned Op,
 214                              SmallVectorImpl<MCFixup> &Fixups) const;
 215
 216   unsigned getRotImmOpValue(const MCInst &MI, unsigned Op,
 217                             SmallVectorImpl<MCFixup> &Fixups) const {
 218     switch (MI.getOperand(Op).getImm()) {
 219     default: assert (0 && "Not a valid rot_imm value!");
 220     case 0:  return 0;
 221     case 8:  return 1;
 222     case 16: return 2;
 223     case 24: return 3;
 224     }
 225   }
 226
 227   unsigned getImmMinusOneOpValue(const MCInst &MI, unsigned Op,
 228                                  SmallVectorImpl<MCFixup> &Fixups) const {
 229     return MI.getOperand(Op).getImm() - 1;
 230   }
 231
 232   unsigned getNEONVcvtImm32OpValue(const MCInst &MI, unsigned Op,
 233                                    SmallVectorImpl<MCFixup> &Fixups) const {
 234     return 64 - MI.getOperand(Op).getImm();
 235   }
 236
 237   unsigned getBitfieldInvertedMaskOpValue(const MCInst &MI, unsigned Op,
 238                                       SmallVectorImpl<MCFixup> &Fixups) const;
 239
 240   unsigned getRegisterListOpValue(const MCInst &MI, unsigned Op,
 241                                   SmallVectorImpl<MCFixup> &Fixups) const;
 242   unsigned getAddrMode6AddressOpValue(const MCInst &MI, unsigned Op,
 243                                       SmallVectorImpl<MCFixup> &Fixups) const;
 244   unsigned getAddrMode6DupAddressOpValue(const MCInst &MI, unsigned Op,
 245                                         SmallVectorImpl<MCFixup> &Fixups) const;
 246   unsigned getAddrMode6OffsetOpValue(const MCInst &MI, unsigned Op,
 247                                      SmallVectorImpl<MCFixup> &Fixups) const;
 248
 249   unsigned NEONThumb2DataIPostEncoder(const MCInst &MI,
 250                                       unsigned EncodedValue) const;
 251   unsigned NEONThumb2LoadStorePostEncoder(const MCInst &MI,
 252                                           unsigned EncodedValue) const;
 253   unsigned NEONThumb2DupPostEncoder(const MCInst &MI,
 254                                     unsigned EncodedValue) const;
 255
 256   unsigned VFPThumb2PostEncoder(const MCInst &MI,
 257                                 unsigned EncodedValue) const;
 258
 259   void EmitByte(unsigned char C, raw_ostream &OS) const {
 260     OS << (char)C;
 261   }
 262
 263   void EmitConstant(uint64_t Val, unsigned Size, raw_ostream &OS) const {
 264     // Output the constant in little endian byte order.
 265     for (unsigned i = 0; i != Size; ++i) {
 266       EmitByte(Val & 255, OS);
 267       Val >>= 8;
 268     }
 269   }
 270
 271   void EncodeInstruction(const MCInst &MI, raw_ostream &OS,
 272                          SmallVectorImpl<MCFixup> &Fixups) const;
 273 };
 274
 275 } // end anonymous namespace
 276
 277 MCCodeEmitter *llvm::createARMMCCodeEmitter(const Target &, TargetMachine &TM,
 278                                             MCContext &Ctx) {
 279   return new ARMMCCodeEmitter(TM, Ctx);
 280 }
 281
 282 /// NEONThumb2DataIPostEncoder - Post-process encoded NEON data-processing
 283 /// instructions, and rewrite them to their Thumb2 form if we are currently in
 284 /// Thumb2 mode.
 285 unsigned ARMMCCodeEmitter::NEONThumb2DataIPostEncoder(const MCInst &MI,
 286                                                  unsigned EncodedValue) const {
 287   const ARMSubtarget &Subtarget = TM.getSubtarget<ARMSubtarget>();
 288   if (Subtarget.isThumb2()) {
 289     // NEON Thumb2 data-processsing encodings are very simple: bit 24 is moved
 290     // to bit 12 of the high half-word (i.e. bit 28), and bits 27-24 are
 291     // set to 1111.
 292     unsigned Bit24 = EncodedValue & 0x01000000;
 293     unsigned Bit28 = Bit24 << 4;
 294     EncodedValue &= 0xEFFFFFFF;
 295     EncodedValue |= Bit28;
 296     EncodedValue |= 0x0F000000;
 297   }
 298
 299   return EncodedValue;
 300 }
 301
 302 /// NEONThumb2LoadStorePostEncoder - Post-process encoded NEON load/store
 303 /// instructions, and rewrite them to their Thumb2 form if we are currently in
 304 /// Thumb2 mode.
 305 unsigned ARMMCCodeEmitter::NEONThumb2LoadStorePostEncoder(const MCInst &MI,
 306                                                  unsigned EncodedValue) const {
 307   const ARMSubtarget &Subtarget = TM.getSubtarget<ARMSubtarget>();
 308   if (Subtarget.isThumb2()) {
 309     EncodedValue &= 0xF0FFFFFF;
 310     EncodedValue |= 0x09000000;
 311   }
 312
 313   return EncodedValue;
 314 }
 315
 316 /// NEONThumb2DupPostEncoder - Post-process encoded NEON vdup
 317 /// instructions, and rewrite them to their Thumb2 form if we are currently in
 318 /// Thumb2 mode.
 319 unsigned ARMMCCodeEmitter::NEONThumb2DupPostEncoder(const MCInst &MI,
 320                                                  unsigned EncodedValue) const {
 321   const ARMSubtarget &Subtarget = TM.getSubtarget<ARMSubtarget>();
 322   if (Subtarget.isThumb2()) {
 323     EncodedValue &= 0x00FFFFFF;
 324     EncodedValue |= 0xEE000000;
 325   }
 326
 327   return EncodedValue;
 328 }
 329
 330 /// VFPThumb2PostEncoder - Post-process encoded VFP instructions and rewrite
 331 /// them to their Thumb2 form if we are currently in Thumb2 mode.
 332 unsigned ARMMCCodeEmitter::
 333 VFPThumb2PostEncoder(const MCInst &MI, unsigned EncodedValue) const {
 334   if (TM.getSubtarget<ARMSubtarget>().isThumb2()) {
 335     EncodedValue &= 0x0FFFFFFF;
 336     EncodedValue |= 0xE0000000;
 337   }
 338   return EncodedValue;
 339 }
 340
 341 /// getMachineOpValue - Return binary encoding of operand. If the machine
 342 /// operand requires relocation, record the relocation and return zero.
 343 unsigned ARMMCCodeEmitter::
 344 getMachineOpValue(const MCInst &MI, const MCOperand &MO,
 345                   SmallVectorImpl<MCFixup> &Fixups) const {
 346   if (MO.isReg()) {
 347     unsigned Reg = MO.getReg();
 348     unsigned RegNo = getARMRegisterNumbering(Reg);
 349
 350     // Q registers are encoded as 2x their register number.
 351     switch (Reg) {
 352     default:
 353       return RegNo;
 354     case ARM::Q0:  case ARM::Q1:  case ARM::Q2:  case ARM::Q3:
 355     case ARM::Q4:  case ARM::Q5:  case ARM::Q6:  case ARM::Q7:
 356     case ARM::Q8:  case ARM::Q9:  case ARM::Q10: case ARM::Q11:
 357     case ARM::Q12: case ARM::Q13: case ARM::Q14: case ARM::Q15:
 358       return 2 * RegNo;
 359     }
 360   } else if (MO.isImm()) {
 361     return static_cast<unsigned>(MO.getImm());
 362   } else if (MO.isFPImm()) {
 363     return static_cast<unsigned>(APFloat(MO.getFPImm())
 364                      .bitcastToAPInt().getHiBits(32).getLimitedValue());
 365   }
 366
 367   llvm_unreachable("Unable to encode MCOperand!");
 368   return 0;
 369 }
 370
 371 /// getAddrModeImmOpValue - Return encoding info for 'reg +/- imm' operand.
 372 bool ARMMCCodeEmitter::
 373 EncodeAddrModeOpValues(const MCInst &MI, unsigned OpIdx, unsigned &Reg,
 374                        unsigned &Imm, SmallVectorImpl<MCFixup> &Fixups) const {
 375   const MCOperand &MO  = MI.getOperand(OpIdx);
 376   const MCOperand &MO1 = MI.getOperand(OpIdx + 1);
 377
 378   Reg = getARMRegisterNumbering(MO.getReg());
 379
 380   int32_t SImm = MO1.getImm();
 381   bool isAdd = true;
 382
 383   // Special value for #-0
 384   if (SImm == INT32_MIN)
 385     SImm = 0;
 386
 387   // Immediate is always encoded as positive. The 'U' bit controls add vs sub.
 388   if (SImm < 0) {
 389     SImm = -SImm;
 390     isAdd = false;
 391   }
 392
 393   Imm = SImm;
 394   return isAdd;
 395 }
 396
 397 /// getBranchTargetOpValue - Return encoding info for 24-bit immediate
 398 /// branch target.
 399 uint32_t ARMMCCodeEmitter::
 400 getBranchTargetOpValue(const MCInst &MI, unsigned OpIdx,
 401                         SmallVectorImpl<MCFixup> &Fixups) const {
 402   const MCOperand &MO = MI.getOperand(OpIdx);
 403
 404   // If the destination is an immediate, we have nothing to do.
 405   if (MO.isImm()) return MO.getImm();
 406   assert (MO.isExpr() && "Unexpected branch target type!");
 407   const MCExpr *Expr = MO.getExpr();
 408   MCFixupKind Kind = MCFixupKind(ARM::fixup_arm_branch);
 409   Fixups.push_back(MCFixup::Create(0, Expr, Kind));
 410
 411   // All of the information is in the fixup.
 412   return 0;
 413 }
 414
 415 /// getAdrLabelOpValue - Return encoding info for 12-bit immediate
 416 /// ADR label target.
 417 uint32_t ARMMCCodeEmitter::
 418 getAdrLabelOpValue(const MCInst &MI, unsigned OpIdx,
 419                    SmallVectorImpl<MCFixup> &Fixups) const {
 420   const MCOperand &MO = MI.getOperand(OpIdx);
 421
 422   // If the destination is an immediate, we have nothing to do.
 423   if (MO.isImm()) return MO.getImm();
 424   assert (MO.isExpr() && "Unexpected branch target type!");
 425   const MCExpr *Expr = MO.getExpr();
 426   MCFixupKind Kind = MCFixupKind(ARM::fixup_arm_pcrel_12);
 427   Fixups.push_back(MCFixup::Create(0, Expr, Kind));
 428
 429   // All of the information is in the fixup.
 430   return 0;
 431 }
 432
 433 /// getAddrModeImm12OpValue - Return encoding info for 'reg +/- imm12' operand.
 434 uint32_t ARMMCCodeEmitter::
 435 getAddrModeImm12OpValue(const MCInst &MI, unsigned OpIdx,
 436                         SmallVectorImpl<MCFixup> &Fixups) const {
 437   // {17-13} = reg
 438   // {12}    = (U)nsigned (add == '1', sub == '0')
 439   // {11-0}  = imm12
 440   unsigned Reg, Imm12;
 441   bool isAdd = true;
 442   // If The first operand isn't a register, we have a label reference.
 443   const MCOperand &MO = MI.getOperand(OpIdx);
 444   if (!MO.isReg()) {
 445     Reg = getARMRegisterNumbering(ARM::PC);   // Rn is PC.
 446     Imm12 = 0;
 447     isAdd = false ; // 'U' bit is set as part of the fixup.
 448
 449     assert(MO.isExpr() && "Unexpected machine operand type!");
 450     const MCExpr *Expr = MO.getExpr();
 451     MCFixupKind Kind = MCFixupKind(ARM::fixup_arm_pcrel_12);
 452     Fixups.push_back(MCFixup::Create(0, Expr, Kind));
 453
 454     ++MCNumCPRelocations;
 455   } else
 456     isAdd = EncodeAddrModeOpValues(MI, OpIdx, Reg, Imm12, Fixups);
 457
 458   uint32_t Binary = Imm12 & 0xfff;
 459   // Immediate is always encoded as positive. The 'U' bit controls add vs sub.
 460   if (isAdd)
 461     Binary |= (1 << 12);
 462   Binary |= (Reg << 13);
 463   return Binary;
 464 }
 465
 466 /// getT2AddrModeImm8s4OpValue - Return encoding info for
 467 /// 'reg +/- imm8<<2' operand.
 468 uint32_t ARMMCCodeEmitter::
 469 getT2AddrModeImm8s4OpValue(const MCInst &MI, unsigned OpIdx,
 470                         SmallVectorImpl<MCFixup> &Fixups) const {
 471   // {17-13} = reg
 472   // {12}    = (U)nsigned (add == '1', sub == '0')
 473   // {11-0}  = imm8
 474   unsigned Reg, Imm8;
 475   bool isAdd = true;
 476   // If The first operand isn't a register, we have a label reference.
 477   const MCOperand &MO = MI.getOperand(OpIdx);
 478   if (!MO.isReg()) {
 479     Reg = getARMRegisterNumbering(ARM::PC);   // Rn is PC.
 480     Imm8 = 0;
 481     isAdd = false ; // 'U' bit is set as part of the fixup.
 482
 483     assert(MO.isExpr() && "Unexpected machine operand type!");
 484     const MCExpr *Expr = MO.getExpr();
 485     MCFixupKind Kind = MCFixupKind(ARM::fixup_arm_pcrel_10);
 486     Fixups.push_back(MCFixup::Create(0, Expr, Kind));
 487
 488     ++MCNumCPRelocations;
 489   } else
 490     isAdd = EncodeAddrModeOpValues(MI, OpIdx, Reg, Imm8, Fixups);
 491
 492   uint32_t Binary = (Imm8 >> 2) & 0xff;
 493   // Immediate is always encoded as positive. The 'U' bit controls add vs sub.
 494   if (isAdd)
 495     Binary |= (1 << 9);
 496   Binary |= (Reg << 9);
 497   return Binary;
 498 }
 499
 500 uint32_t ARMMCCodeEmitter::
 501 getMovtImmOpValue(const MCInst &MI, unsigned OpIdx,
 502                   SmallVectorImpl<MCFixup> &Fixups) const {
 503   // {20-16} = imm{15-12}
 504   // {11-0}  = imm{11-0}
 505   const MCOperand &MO = MI.getOperand(OpIdx);
 506   if (MO.isImm()) {
 507     return static_cast<unsigned>(MO.getImm());
 508   } else if (const MCSymbolRefExpr *Expr =
 509              dyn_cast<MCSymbolRefExpr>(MO.getExpr())) {
 510     MCFixupKind Kind;
 511     switch (Expr->getKind()) {
 512     default: assert(0 && "Unsupported ARMFixup");
 513     case MCSymbolRefExpr::VK_ARM_HI16:
 514       Kind = MCFixupKind(ARM::fixup_arm_movt_hi16);
 515       break;
 516     case MCSymbolRefExpr::VK_ARM_LO16:
 517       Kind = MCFixupKind(ARM::fixup_arm_movw_lo16);
 518       break;
 519     }
 520     Fixups.push_back(MCFixup::Create(0, Expr, Kind));
 521     return 0;
 522   };
 523   llvm_unreachable("Unsupported MCExpr type in MCOperand!");
 524   return 0;
 525 }
 526
 527 uint32_t ARMMCCodeEmitter::
 528 getLdStSORegOpValue(const MCInst &MI, unsigned OpIdx,
 529                     SmallVectorImpl<MCFixup> &Fixups) const {
 530   const MCOperand &MO = MI.getOperand(OpIdx);
 531   const MCOperand &MO1 = MI.getOperand(OpIdx+1);
 532   const MCOperand &MO2 = MI.getOperand(OpIdx+2);
 533   unsigned Rn = getARMRegisterNumbering(MO.getReg());
 534   unsigned Rm = getARMRegisterNumbering(MO1.getReg());
 535   unsigned ShImm = ARM_AM::getAM2Offset(MO2.getImm());
 536   bool isAdd = ARM_AM::getAM2Op(MO2.getImm()) == ARM_AM::add;
 537   ARM_AM::ShiftOpc ShOp = ARM_AM::getAM2ShiftOpc(MO2.getImm());
 538   unsigned SBits = getShiftOp(ShOp);
 539
 540   // {16-13} = Rn
 541   // {12}    = isAdd
 542   // {11-0}  = shifter
 543   //  {3-0}  = Rm
 544   //  {4}    = 0
 545   //  {6-5}  = type
 546   //  {11-7} = imm
 547   uint32_t Binary = Rm;
 548   Binary |= Rn << 13;
 549   Binary |= SBits << 5;
 550   Binary |= ShImm << 7;
 551   if (isAdd)
 552     Binary |= 1 << 12;
 553   return Binary;
 554 }
 555
 556 uint32_t ARMMCCodeEmitter::
 557 getAddrMode2OpValue(const MCInst &MI, unsigned OpIdx,
 558                     SmallVectorImpl<MCFixup> &Fixups) const {
 559   // {17-14}  Rn
 560   // {13}     1 == imm12, 0 == Rm
 561   // {12}     isAdd
 562   // {11-0}   imm12/Rm
 563   const MCOperand &MO = MI.getOperand(OpIdx);
 564   unsigned Rn = getARMRegisterNumbering(MO.getReg());
 565   uint32_t Binary = getAddrMode2OffsetOpValue(MI, OpIdx + 1, Fixups);
 566   Binary |= Rn << 14;
 567   return Binary;
 568 }
 569
 570 uint32_t ARMMCCodeEmitter::
 571 getAddrMode2OffsetOpValue(const MCInst &MI, unsigned OpIdx,
 572                           SmallVectorImpl<MCFixup> &Fixups) const {
 573   // {13}     1 == imm12, 0 == Rm
 574   // {12}     isAdd
 575   // {11-0}   imm12/Rm
 576   const MCOperand &MO = MI.getOperand(OpIdx);
 577   const MCOperand &MO1 = MI.getOperand(OpIdx+1);
 578   unsigned Imm = MO1.getImm();
 579   bool isAdd = ARM_AM::getAM2Op(Imm) == ARM_AM::add;
 580   bool isReg = MO.getReg() != 0;
 581   uint32_t Binary = ARM_AM::getAM2Offset(Imm);
 582   // if reg +/- reg, Rm will be non-zero. Otherwise, we have reg +/- imm12
 583   if (isReg) {
 584     ARM_AM::ShiftOpc ShOp = ARM_AM::getAM2ShiftOpc(Imm);
 585     Binary <<= 7;                    // Shift amount is bits [11:7]
 586     Binary |= getShiftOp(ShOp) << 5; // Shift type is bits [6:5]
 587     Binary |= getARMRegisterNumbering(MO.getReg()); // Rm is bits [3:0]
 588   }
 589   return Binary | (isAdd << 12) | (isReg << 13);
 590 }
 591
 592 uint32_t ARMMCCodeEmitter::
 593 getAddrMode3OffsetOpValue(const MCInst &MI, unsigned OpIdx,
 594                           SmallVectorImpl<MCFixup> &Fixups) const {
 595   // {9}      1 == imm8, 0 == Rm
 596   // {8}      isAdd
 597   // {7-4}    imm7_4/zero
 598   // {3-0}    imm3_0/Rm
 599   const MCOperand &MO = MI.getOperand(OpIdx);
 600   const MCOperand &MO1 = MI.getOperand(OpIdx+1);
 601   unsigned Imm = MO1.getImm();
 602   bool isAdd = ARM_AM::getAM3Op(Imm) == ARM_AM::add;
 603   bool isImm = MO.getReg() == 0;
 604   uint32_t Imm8 = ARM_AM::getAM3Offset(Imm);
 605   // if reg +/- reg, Rm will be non-zero. Otherwise, we have reg +/- imm8
 606   if (!isImm)
 607     Imm8 = getARMRegisterNumbering(MO.getReg());
 608   return Imm8 | (isAdd << 8) | (isImm << 9);
 609 }
 610
 611 uint32_t ARMMCCodeEmitter::
 612 getAddrMode3OpValue(const MCInst &MI, unsigned OpIdx,
 613                     SmallVectorImpl<MCFixup> &Fixups) const {
 614   // {13}     1 == imm8, 0 == Rm
 615   // {12-9}   Rn
 616   // {8}      isAdd
 617   // {7-4}    imm7_4/zero
 618   // {3-0}    imm3_0/Rm
 619   const MCOperand &MO = MI.getOperand(OpIdx);
 620   const MCOperand &MO1 = MI.getOperand(OpIdx+1);
 621   const MCOperand &MO2 = MI.getOperand(OpIdx+2);
 622   unsigned Rn = getARMRegisterNumbering(MO.getReg());
 623   unsigned Imm = MO2.getImm();
 624   bool isAdd = ARM_AM::getAM3Op(Imm) == ARM_AM::add;
 625   bool isImm = MO1.getReg() == 0;
 626   uint32_t Imm8 = ARM_AM::getAM3Offset(Imm);
 627   // if reg +/- reg, Rm will be non-zero. Otherwise, we have reg +/- imm8
 628   if (!isImm)
 629     Imm8 = getARMRegisterNumbering(MO1.getReg());
 630   return (Rn << 9) | Imm8 | (isAdd << 8) | (isImm << 13);
 631 }
 632
 633 /// getAddrModeSOpValue - Encode the t_addrmode_s# operands.
 634 static unsigned getAddrModeSOpValue(const MCInst &MI, unsigned OpIdx,
 635                                     unsigned Scale) {
 636   // [Rn, Rm]
 637   //   {5-3} = Rm
 638   //   {2-0} = Rn
 639   //
 640   // [Rn, #imm]
 641   //   {7-3} = imm5
 642   //   {2-0} = Rn
 643   const MCOperand &MO = MI.getOperand(OpIdx);
 644   const MCOperand &MO1 = MI.getOperand(OpIdx + 1);
 645   const MCOperand &MO2 = MI.getOperand(OpIdx + 2);
 646   unsigned Rn = getARMRegisterNumbering(MO.getReg());
 647   unsigned Imm5 = (MO1.getImm() / Scale) & 0x1f;
 648   unsigned Rm = getARMRegisterNumbering(MO2.getReg());
 649   return (Rm << 3) | (Imm5 << 3) | Rn;
 650 }
 651
 652 /// getAddrModeS4OpValue - Return encoding for t_addrmode_s4 operands.
 653 uint32_t ARMMCCodeEmitter::
 654 getAddrModeS4OpValue(const MCInst &MI, unsigned OpIdx,
 655                      SmallVectorImpl<MCFixup> &) const {
 656   return getAddrModeSOpValue(MI, OpIdx, 4);
 657 }
 658
 659 /// getAddrModeS2OpValue - Return encoding for t_addrmode_s2 operands.
 660 uint32_t ARMMCCodeEmitter::
 661 getAddrModeS2OpValue(const MCInst &MI, unsigned OpIdx,
 662                      SmallVectorImpl<MCFixup> &) const {
 663   return getAddrModeSOpValue(MI, OpIdx, 2);
 664 }
 665
 666 /// getAddrModeS1OpValue - Return encoding for t_addrmode_s1 operands.
 667 uint32_t ARMMCCodeEmitter::
 668 getAddrModeS1OpValue(const MCInst &MI, unsigned OpIdx,
 669                      SmallVectorImpl<MCFixup> &) const {
 670   return getAddrModeSOpValue(MI, OpIdx, 1);
 671 }
 672
 673 /// getAddrMode5OpValue - Return encoding info for 'reg +/- imm10' operand.
 674 uint32_t ARMMCCodeEmitter::
 675 getAddrMode5OpValue(const MCInst &MI, unsigned OpIdx,
 676                     SmallVectorImpl<MCFixup> &Fixups) const {
 677   // {12-9} = reg
 678   // {8}    = (U)nsigned (add == '1', sub == '0')
 679   // {7-0}  = imm8
 680   unsigned Reg, Imm8;
 681   bool isAdd;
 682   // If The first operand isn't a register, we have a label reference.
 683   const MCOperand &MO = MI.getOperand(OpIdx);
 684   if (!MO.isReg()) {
 685     Reg = getARMRegisterNumbering(ARM::PC);   // Rn is PC.
 686     Imm8 = 0;
 687     isAdd = false; // 'U' bit is handled as part of the fixup.
 688
 689     assert(MO.isExpr() && "Unexpected machine operand type!");
 690     const MCExpr *Expr = MO.getExpr();
 691     MCFixupKind Kind = MCFixupKind(ARM::fixup_arm_pcrel_10);
 692     Fixups.push_back(MCFixup::Create(0, Expr, Kind));
 693
 694     ++MCNumCPRelocations;
 695   } else {
 696     EncodeAddrModeOpValues(MI, OpIdx, Reg, Imm8, Fixups);
 697     isAdd = ARM_AM::getAM5Op(Imm8) == ARM_AM::add;
 698   }
 699
 700   uint32_t Binary = ARM_AM::getAM5Offset(Imm8);
 701   // Immediate is always encoded as positive. The 'U' bit controls add vs sub.
 702   if (isAdd)
 703     Binary |= (1 << 8);
 704   Binary |= (Reg << 9);
 705   return Binary;
 706 }
 707
 708 unsigned ARMMCCodeEmitter::
 709 getSORegOpValue(const MCInst &MI, unsigned OpIdx,
 710                 SmallVectorImpl<MCFixup> &Fixups) const {
 711   // Sub-operands are [reg, reg, imm]. The first register is Rm, the reg to be
 712   // shifted. The second is either Rs, the amount to shift by, or reg0 in which
 713   // case the imm contains the amount to shift by.
 714   //
 715   // {3-0} = Rm.
 716   // {4}   = 1 if reg shift, 0 if imm shift
 717   // {6-5} = type
 718   //    If reg shift:
 719   //      {11-8} = Rs
 720   //      {7}    = 0
 721   //    else (imm shift)
 722   //      {11-7} = imm
 723
 724   const MCOperand &MO  = MI.getOperand(OpIdx);
 725   const MCOperand &MO1 = MI.getOperand(OpIdx + 1);
 726   const MCOperand &MO2 = MI.getOperand(OpIdx + 2);
 727   ARM_AM::ShiftOpc SOpc = ARM_AM::getSORegShOp(MO2.getImm());
 728
 729   // Encode Rm.
 730   unsigned Binary = getARMRegisterNumbering(MO.getReg());
 731
 732   // Encode the shift opcode.
 733   unsigned SBits = 0;
 734   unsigned Rs = MO1.getReg();
 735   if (Rs) {
 736     // Set shift operand (bit[7:4]).
 737     // LSL - 0001
 738     // LSR - 0011
 739     // ASR - 0101
 740     // ROR - 0111
 741     // RRX - 0110 and bit[11:8] clear.
 742     switch (SOpc) {
 743     default: llvm_unreachable("Unknown shift opc!");
 744     case ARM_AM::lsl: SBits = 0x1; break;
 745     case ARM_AM::lsr: SBits = 0x3; break;
 746     case ARM_AM::asr: SBits = 0x5; break;
 747     case ARM_AM::ror: SBits = 0x7; break;
 748     case ARM_AM::rrx: SBits = 0x6; break;
 749     }
 750   } else {
 751     // Set shift operand (bit[6:4]).
 752     // LSL - 000
 753     // LSR - 010
 754     // ASR - 100
 755     // ROR - 110
 756     switch (SOpc) {
 757     default: llvm_unreachable("Unknown shift opc!");
 758     case ARM_AM::lsl: SBits = 0x0; break;
 759     case ARM_AM::lsr: SBits = 0x2; break;
 760     case ARM_AM::asr: SBits = 0x4; break;
 761     case ARM_AM::ror: SBits = 0x6; break;
 762     }
 763   }
 764
 765   Binary |= SBits << 4;
 766   if (SOpc == ARM_AM::rrx)
 767     return Binary;
 768
 769   // Encode the shift operation Rs or shift_imm (except rrx).
 770   if (Rs) {
 771     // Encode Rs bit[11:8].
 772     assert(ARM_AM::getSORegOffset(MO2.getImm()) == 0);
 773     return Binary | (getARMRegisterNumbering(Rs) << ARMII::RegRsShift);
 774   }
 775
 776   // Encode shift_imm bit[11:7].
 777   return Binary | ARM_AM::getSORegOffset(MO2.getImm()) << 7;
 778 }
 779
 780 unsigned ARMMCCodeEmitter::
 781 getT2AddrModeSORegOpValue(const MCInst &MI, unsigned OpNum,
 782                 SmallVectorImpl<MCFixup> &Fixups) const {
 783   const MCOperand &MO1 = MI.getOperand(OpNum);
 784   const MCOperand &MO2 = MI.getOperand(OpNum+1);
 785   const MCOperand &MO3 = MI.getOperand(OpNum+2);
 786
 787   // Encoded as [Rn, Rm, imm].
 788   // FIXME: Needs fixup support.
 789   unsigned Value = getARMRegisterNumbering(MO1.getReg());
 790   Value <<= 4;
 791   Value |= getARMRegisterNumbering(MO2.getReg());
 792   Value <<= 2;
 793   Value |= MO3.getImm();
 794
 795   return Value;
 796 }
 797
 798 unsigned ARMMCCodeEmitter::
 799 getT2AddrModeImm8OpValue(const MCInst &MI, unsigned OpNum,
 800                          SmallVectorImpl<MCFixup> &Fixups) const {
 801   const MCOperand &MO1 = MI.getOperand(OpNum);
 802   const MCOperand &MO2 = MI.getOperand(OpNum+1);
 803
 804   // FIXME: Needs fixup support.
 805   unsigned Value = getARMRegisterNumbering(MO1.getReg());
 806
 807   // Even though the immediate is 8 bits long, we need 9 bits in order
 808   // to represent the (inverse of the) sign bit.
 809   Value <<= 9;
 810   int32_t tmp = (int32_t)MO2.getImm();
 811   if (tmp < 0)
 812     tmp = abs(tmp);
 813   else
 814     Value |= 256; // Set the ADD bit
 815   Value |= tmp & 255;
 816   return Value;
 817 }
 818
 819 unsigned ARMMCCodeEmitter::
 820 getT2AddrModeImm8OffsetOpValue(const MCInst &MI, unsigned OpNum,
 821                          SmallVectorImpl<MCFixup> &Fixups) const {
 822   const MCOperand &MO1 = MI.getOperand(OpNum);
 823
 824   // FIXME: Needs fixup support.
 825   unsigned Value = 0;
 826   int32_t tmp = (int32_t)MO1.getImm();
 827   if (tmp < 0)
 828     tmp = abs(tmp);
 829   else
 830     Value |= 256; // Set the ADD bit
 831   Value |= tmp & 255;
 832   return Value;
 833 }
 834
 835 unsigned ARMMCCodeEmitter::
 836 getT2AddrModeImm12OffsetOpValue(const MCInst &MI, unsigned OpNum,
 837                          SmallVectorImpl<MCFixup> &Fixups) const {
 838   const MCOperand &MO1 = MI.getOperand(OpNum);
 839
 840   // FIXME: Needs fixup support.
 841   unsigned Value = 0;
 842   int32_t tmp = (int32_t)MO1.getImm();
 843   if (tmp < 0)
 844     tmp = abs(tmp);
 845   else
 846     Value |= 4096; // Set the ADD bit
 847   Value |= tmp & 4095;
 848   return Value;
 849 }
 850
 851 unsigned ARMMCCodeEmitter::
 852 getT2SORegOpValue(const MCInst &MI, unsigned OpIdx,
 853                 SmallVectorImpl<MCFixup> &Fixups) const {
 854   // Sub-operands are [reg, imm]. The first register is Rm, the reg to be
 855   // shifted. The second is the amount to shift by.
 856   //
 857   // {3-0} = Rm.
 858   // {4}   = 0
 859   // {6-5} = type
 860   // {11-7} = imm
 861
 862   const MCOperand &MO  = MI.getOperand(OpIdx);
 863   const MCOperand &MO1 = MI.getOperand(OpIdx + 1);
 864   ARM_AM::ShiftOpc SOpc = ARM_AM::getSORegShOp(MO1.getImm());
 865
 866   // Encode Rm.
 867   unsigned Binary = getARMRegisterNumbering(MO.getReg());
 868
 869   // Encode the shift opcode.
 870   unsigned SBits = 0;
 871   // Set shift operand (bit[6:4]).
 872   // LSL - 000
 873   // LSR - 010
 874   // ASR - 100
 875   // ROR - 110
 876   switch (SOpc) {
 877   default: llvm_unreachable("Unknown shift opc!");
 878   case ARM_AM::lsl: SBits = 0x0; break;
 879   case ARM_AM::lsr: SBits = 0x2; break;
 880   case ARM_AM::asr: SBits = 0x4; break;
 881   case ARM_AM::ror: SBits = 0x6; break;
 882   }
 883
 884   Binary |= SBits << 4;
 885   if (SOpc == ARM_AM::rrx)
 886     return Binary;
 887
 888   // Encode shift_imm bit[11:7].
 889   return Binary | ARM_AM::getSORegOffset(MO1.getImm()) << 7;
 890 }
 891
 892 unsigned ARMMCCodeEmitter::
 893 getBitfieldInvertedMaskOpValue(const MCInst &MI, unsigned Op,
 894                                SmallVectorImpl<MCFixup> &Fixups) const {
 895   // 10 bits. lower 5 bits are are the lsb of the mask, high five bits are the
 896   // msb of the mask.
 897   const MCOperand &MO = MI.getOperand(Op);
 898   uint32_t v = ~MO.getImm();
 899   uint32_t lsb = CountTrailingZeros_32(v);
 900   uint32_t msb = (32 - CountLeadingZeros_32 (v)) - 1;
 901   assert (v != 0 && lsb < 32 && msb < 32 && "Illegal bitfield mask!");
 902   return lsb | (msb << 5);
 903 }
 904
 905 unsigned ARMMCCodeEmitter::
 906 getRegisterListOpValue(const MCInst &MI, unsigned Op,
 907                        SmallVectorImpl<MCFixup> &Fixups) const {
 908   // VLDM/VSTM:
 909   //   {12-8} = Vd
 910   //   {7-0}  = Number of registers
 911   //
 912   // LDM/STM:
 913   //   {15-0}  = Bitfield of GPRs.
 914   unsigned Reg = MI.getOperand(Op).getReg();
 915   bool SPRRegs = ARM::SPRRegClass.contains(Reg);
 916   bool DPRRegs = ARM::DPRRegClass.contains(Reg);
 917
 918   unsigned Binary = 0;
 919
 920   if (SPRRegs || DPRRegs) {
 921     // VLDM/VSTM
 922     unsigned RegNo = getARMRegisterNumbering(Reg);
 923     unsigned NumRegs = (MI.getNumOperands() - Op) & 0xff;
 924     Binary |= (RegNo & 0x1f) << 8;
 925     if (SPRRegs)
 926       Binary |= NumRegs;
 927     else
 928       Binary |= NumRegs * 2;
 929   } else {
 930     for (unsigned I = Op, E = MI.getNumOperands(); I < E; ++I) {
 931       unsigned RegNo = getARMRegisterNumbering(MI.getOperand(I).getReg());
 932       Binary |= 1 << RegNo;
 933     }
 934   }
 935
 936   return Binary;
 937 }
 938
 939 /// getAddrMode6AddressOpValue - Encode an addrmode6 register number along
 940 /// with the alignment operand.
 941 unsigned ARMMCCodeEmitter::
 942 getAddrMode6AddressOpValue(const MCInst &MI, unsigned Op,
 943                            SmallVectorImpl<MCFixup> &Fixups) const {
 944   const MCOperand &Reg = MI.getOperand(Op);
 945   const MCOperand &Imm = MI.getOperand(Op + 1);
 946
 947   unsigned RegNo = getARMRegisterNumbering(Reg.getReg());
 948   unsigned Align = 0;
 949
 950   switch (Imm.getImm()) {
 951   default: break;
 952   case 2:
 953   case 4:
 954   case 8:  Align = 0x01; break;
 955   case 16: Align = 0x02; break;
 956   case 32: Align = 0x03; break;
 957   }
 958
 959   return RegNo | (Align << 4);
 960 }
 961
 962 /// getAddrMode6DupAddressOpValue - Encode an addrmode6 register number and
 963 /// alignment operand for use in VLD-dup instructions.  This is the same as
 964 /// getAddrMode6AddressOpValue except for the alignment encoding, which is
 965 /// different for VLD4-dup.
 966 unsigned ARMMCCodeEmitter::
 967 getAddrMode6DupAddressOpValue(const MCInst &MI, unsigned Op,
 968                               SmallVectorImpl<MCFixup> &Fixups) const {
 969   const MCOperand &Reg = MI.getOperand(Op);
 970   const MCOperand &Imm = MI.getOperand(Op + 1);
 971
 972   unsigned RegNo = getARMRegisterNumbering(Reg.getReg());
 973   unsigned Align = 0;
 974
 975   switch (Imm.getImm()) {
 976   default: break;
 977   case 2:
 978   case 4:
 979   case 8:  Align = 0x01; break;
 980   case 16: Align = 0x03; break;
 981   }
 982
 983   return RegNo | (Align << 4);
 984 }
 985
 986 unsigned ARMMCCodeEmitter::
 987 getAddrMode6OffsetOpValue(const MCInst &MI, unsigned Op,
 988                           SmallVectorImpl<MCFixup> &Fixups) const {
 989   const MCOperand &MO = MI.getOperand(Op);
 990   if (MO.getReg() == 0) return 0x0D;
 991   return MO.getReg();
 992 }
 993
 994 void ARMMCCodeEmitter::
 995 EncodeInstruction(const MCInst &MI, raw_ostream &OS,
 996                   SmallVectorImpl<MCFixup> &Fixups) const {
 997   // Pseudo instructions don't get encoded.
 998   const TargetInstrDesc &Desc = TII.get(MI.getOpcode());
 999   uint64_t TSFlags = Desc.TSFlags;
1000   if ((TSFlags & ARMII::FormMask) == ARMII::Pseudo)
1001     return;
1002   int Size;
1003   // Basic size info comes from the TSFlags field.
1004   switch ((TSFlags & ARMII::SizeMask) >> ARMII::SizeShift) {
1005   default: llvm_unreachable("Unexpected instruction size!");
1006   case ARMII::Size2Bytes: Size = 2; break;
1007   case ARMII::Size4Bytes: Size = 4; break;
1008   }
1009   EmitConstant(getBinaryCodeForInstr(MI, Fixups), Size, OS);
1010   ++MCNumEmitted;  // Keep track of the # of mi's emitted.
1011 }
1012
1013 #include "ARMGenMCCodeEmitter.inc"