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