lib/Target/ARM/AsmParser/ARMAsmParser.cpp

   1 //===-- ARMAsmParser.cpp - Parse ARM assembly to MCInst instructions ------===//
   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 #include "MCTargetDesc/ARMBaseInfo.h"
  11 #include "MCTargetDesc/ARMAddressingModes.h"
  12 #include "MCTargetDesc/ARMMCExpr.h"
  13 #include "llvm/MC/MCParser/MCAsmLexer.h"
  14 #include "llvm/MC/MCParser/MCAsmParser.h"
  15 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  16 #include "llvm/MC/MCAsmInfo.h"
  17 #include "llvm/MC/MCContext.h"
  18 #include "llvm/MC/MCStreamer.h"
  19 #include "llvm/MC/MCExpr.h"
  20 #include "llvm/MC/MCInst.h"
  21 #include "llvm/MC/MCInstrDesc.h"
  22 #include "llvm/MC/MCRegisterInfo.h"
  23 #include "llvm/MC/MCSubtargetInfo.h"
  24 #include "llvm/MC/MCTargetAsmParser.h"
  25 #include "llvm/Support/MathExtras.h"
  26 #include "llvm/Support/SourceMgr.h"
  27 #include "llvm/Support/TargetRegistry.h"
  28 #include "llvm/Support/raw_ostream.h"
  29 #include "llvm/ADT/BitVector.h"
  30 #include "llvm/ADT/OwningPtr.h"
  31 #include "llvm/ADT/STLExtras.h"
  32 #include "llvm/ADT/SmallVector.h"
  33 #include "llvm/ADT/StringExtras.h"
  34 #include "llvm/ADT/StringSwitch.h"
  35 #include "llvm/ADT/Twine.h"
  36
  37 using namespace llvm;
  38
  39 namespace {
  40
  41 class ARMOperand;
  42
  43 class ARMAsmParser : public MCTargetAsmParser {
  44   MCSubtargetInfo &STI;
  45   MCAsmParser &Parser;
  46
  47   struct {
  48     ARMCC::CondCodes Cond;    // Condition for IT block.
  49     unsigned Mask:4;          // Condition mask for instructions.
  50                               // Starting at first 1 (from lsb).
  51                               //   '1'  condition as indicated in IT.
  52                               //   '0'  inverse of condition (else).
  53                               // Count of instructions in IT block is
  54                               // 4 - trailingzeroes(mask)
  55
  56     bool FirstCond;           // Explicit flag for when we're parsing the
  57                               // First instruction in the IT block. It's
  58                               // implied in the mask, so needs special
  59                               // handling.
  60
  61     unsigned CurPosition;     // Current position in parsing of IT
  62                               // block. In range [0,3]. Initialized
  63                               // according to count of instructions in block.
  64                               // ~0U if no active IT block.
  65   } ITState;
  66   bool inITBlock() { return ITState.CurPosition != ~0U;}
  67   void forwardITPosition() {
  68     if (!inITBlock()) return;
  69     // Move to the next instruction in the IT block, if there is one. If not,
  70     // mark the block as done.
  71     unsigned TZ = CountTrailingZeros_32(ITState.Mask);
  72     if (++ITState.CurPosition == 5 - TZ)
  73       ITState.CurPosition = ~0U; // Done with the IT block after this.
  74   }
  75
  76
  77   MCAsmParser &getParser() const { return Parser; }
  78   MCAsmLexer &getLexer() const { return Parser.getLexer(); }
  79
  80   void Warning(SMLoc L, const Twine &Msg) { Parser.Warning(L, Msg); }
  81   bool Error(SMLoc L, const Twine &Msg) { return Parser.Error(L, Msg); }
  82
  83   int tryParseRegister();
  84   bool tryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &);
  85   int tryParseShiftRegister(SmallVectorImpl<MCParsedAsmOperand*> &);
  86   bool parseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &);
  87   bool parseMemory(SmallVectorImpl<MCParsedAsmOperand*> &);
  88   bool parseOperand(SmallVectorImpl<MCParsedAsmOperand*> &, StringRef Mnemonic);
  89   bool parsePrefix(ARMMCExpr::VariantKind &RefKind);
  90   const MCExpr *applyPrefixToExpr(const MCExpr *E,
  91                                   MCSymbolRefExpr::VariantKind Variant);
  92
  93
  94   bool parseMemRegOffsetShift(ARM_AM::ShiftOpc &ShiftType,
  95                               unsigned &ShiftAmount);
  96   bool parseDirectiveWord(unsigned Size, SMLoc L);
  97   bool parseDirectiveThumb(SMLoc L);
  98   bool parseDirectiveThumbFunc(SMLoc L);
  99   bool parseDirectiveCode(SMLoc L);
 100   bool parseDirectiveSyntax(SMLoc L);
 101
 102   StringRef splitMnemonic(StringRef Mnemonic, unsigned &PredicationCode,
 103                           bool &CarrySetting, unsigned &ProcessorIMod,
 104                           StringRef &ITMask);
 105   void getMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet,
 106                              bool &CanAcceptPredicationCode);
 107
 108   bool isThumb() const {
 109     // FIXME: Can tablegen auto-generate this?
 110     return (STI.getFeatureBits() & ARM::ModeThumb) != 0;
 111   }
 112   bool isThumbOne() const {
 113     return isThumb() && (STI.getFeatureBits() & ARM::FeatureThumb2) == 0;
 114   }
 115   bool isThumbTwo() const {
 116     return isThumb() && (STI.getFeatureBits() & ARM::FeatureThumb2);
 117   }
 118   bool hasV6Ops() const {
 119     return STI.getFeatureBits() & ARM::HasV6Ops;
 120   }
 121   void SwitchMode() {
 122     unsigned FB = ComputeAvailableFeatures(STI.ToggleFeature(ARM::ModeThumb));
 123     setAvailableFeatures(FB);
 124   }
 125
 126   /// @name Auto-generated Match Functions
 127   /// {
 128
 129 #define GET_ASSEMBLER_HEADER
 130 #include "ARMGenAsmMatcher.inc"
 131
 132   /// }
 133
 134   OperandMatchResultTy parseITCondCode(SmallVectorImpl<MCParsedAsmOperand*>&);
 135   OperandMatchResultTy parseCoprocNumOperand(
 136     SmallVectorImpl<MCParsedAsmOperand*>&);
 137   OperandMatchResultTy parseCoprocRegOperand(
 138     SmallVectorImpl<MCParsedAsmOperand*>&);
 139   OperandMatchResultTy parseMemBarrierOptOperand(
 140     SmallVectorImpl<MCParsedAsmOperand*>&);
 141   OperandMatchResultTy parseProcIFlagsOperand(
 142     SmallVectorImpl<MCParsedAsmOperand*>&);
 143   OperandMatchResultTy parseMSRMaskOperand(
 144     SmallVectorImpl<MCParsedAsmOperand*>&);
 145   OperandMatchResultTy parsePKHImm(SmallVectorImpl<MCParsedAsmOperand*> &O,
 146                                    StringRef Op, int Low, int High);
 147   OperandMatchResultTy parsePKHLSLImm(SmallVectorImpl<MCParsedAsmOperand*> &O) {
 148     return parsePKHImm(O, "lsl", 0, 31);
 149   }
 150   OperandMatchResultTy parsePKHASRImm(SmallVectorImpl<MCParsedAsmOperand*> &O) {
 151     return parsePKHImm(O, "asr", 1, 32);
 152   }
 153   OperandMatchResultTy parseSetEndImm(SmallVectorImpl<MCParsedAsmOperand*>&);
 154   OperandMatchResultTy parseShifterImm(SmallVectorImpl<MCParsedAsmOperand*>&);
 155   OperandMatchResultTy parseRotImm(SmallVectorImpl<MCParsedAsmOperand*>&);
 156   OperandMatchResultTy parseBitfield(SmallVectorImpl<MCParsedAsmOperand*>&);
 157   OperandMatchResultTy parsePostIdxReg(SmallVectorImpl<MCParsedAsmOperand*>&);
 158   OperandMatchResultTy parseAM3Offset(SmallVectorImpl<MCParsedAsmOperand*>&);
 159
 160   // Asm Match Converter Methods
 161   bool cvtT2LdrdPre(MCInst &Inst, unsigned Opcode,
 162                     const SmallVectorImpl<MCParsedAsmOperand*> &);
 163   bool cvtT2StrdPre(MCInst &Inst, unsigned Opcode,
 164                     const SmallVectorImpl<MCParsedAsmOperand*> &);
 165   bool cvtLdWriteBackRegT2AddrModeImm8(MCInst &Inst, unsigned Opcode,
 166                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 167   bool cvtLdWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
 168                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 169   bool cvtLdWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
 170                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 171   bool cvtStWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
 172                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 173   bool cvtStWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
 174                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 175   bool cvtStWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
 176                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 177   bool cvtLdExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
 178                              const SmallVectorImpl<MCParsedAsmOperand*> &);
 179   bool cvtLdExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
 180                              const SmallVectorImpl<MCParsedAsmOperand*> &);
 181   bool cvtStExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
 182                              const SmallVectorImpl<MCParsedAsmOperand*> &);
 183   bool cvtStExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
 184                              const SmallVectorImpl<MCParsedAsmOperand*> &);
 185   bool cvtLdrdPre(MCInst &Inst, unsigned Opcode,
 186                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 187   bool cvtStrdPre(MCInst &Inst, unsigned Opcode,
 188                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 189   bool cvtLdWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
 190                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 191   bool cvtThumbMultiply(MCInst &Inst, unsigned Opcode,
 192                         const SmallVectorImpl<MCParsedAsmOperand*> &);
 193
 194   bool validateInstruction(MCInst &Inst,
 195                            const SmallVectorImpl<MCParsedAsmOperand*> &Ops);
 196   void processInstruction(MCInst &Inst,
 197                           const SmallVectorImpl<MCParsedAsmOperand*> &Ops);
 198   bool shouldOmitCCOutOperand(StringRef Mnemonic,
 199                               SmallVectorImpl<MCParsedAsmOperand*> &Operands);
 200
 201 public:
 202   enum ARMMatchResultTy {
 203     Match_RequiresITBlock = FIRST_TARGET_MATCH_RESULT_TY,
 204     Match_RequiresNotITBlock,
 205     Match_RequiresV6,
 206     Match_RequiresThumb2
 207   };
 208
 209   ARMAsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser)
 210     : MCTargetAsmParser(), STI(_STI), Parser(_Parser) {
 211     MCAsmParserExtension::Initialize(_Parser);
 212
 213     // Initialize the set of available features.
 214     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
 215
 216     // Not in an ITBlock to start with.
 217     ITState.CurPosition = ~0U;
 218   }
 219
 220   // Implementation of the MCTargetAsmParser interface:
 221   bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc);
 222   bool ParseInstruction(StringRef Name, SMLoc NameLoc,
 223                         SmallVectorImpl<MCParsedAsmOperand*> &Operands);
 224   bool ParseDirective(AsmToken DirectiveID);
 225
 226   unsigned checkTargetMatchPredicate(MCInst &Inst);
 227
 228   bool MatchAndEmitInstruction(SMLoc IDLoc,
 229                                SmallVectorImpl<MCParsedAsmOperand*> &Operands,
 230                                MCStreamer &Out);
 231 };
 232 } // end anonymous namespace
 233
 234 namespace {
 235
 236 /// ARMOperand - Instances of this class represent a parsed ARM machine
 237 /// instruction.
 238 class ARMOperand : public MCParsedAsmOperand {
 239   enum KindTy {
 240     CondCode,
 241     CCOut,
 242     ITCondMask,
 243     CoprocNum,
 244     CoprocReg,
 245     Immediate,
 246     MemBarrierOpt,
 247     Memory,
 248     PostIndexRegister,
 249     MSRMask,
 250     ProcIFlags,
 251     Register,
 252     RegisterList,
 253     DPRRegisterList,
 254     SPRRegisterList,
 255     ShiftedRegister,
 256     ShiftedImmediate,
 257     ShifterImmediate,
 258     RotateImmediate,
 259     BitfieldDescriptor,
 260     Token
 261   } Kind;
 262
 263   SMLoc StartLoc, EndLoc;
 264   SmallVector<unsigned, 8> Registers;
 265
 266   union {
 267     struct {
 268       ARMCC::CondCodes Val;
 269     } CC;
 270
 271     struct {
 272       unsigned Val;
 273     } Cop;
 274
 275     struct {
 276       unsigned Mask:4;
 277     } ITMask;
 278
 279     struct {
 280       ARM_MB::MemBOpt Val;
 281     } MBOpt;
 282
 283     struct {
 284       ARM_PROC::IFlags Val;
 285     } IFlags;
 286
 287     struct {
 288       unsigned Val;
 289     } MMask;
 290
 291     struct {
 292       const char *Data;
 293       unsigned Length;
 294     } Tok;
 295
 296     struct {
 297       unsigned RegNum;
 298     } Reg;
 299
 300     struct {
 301       const MCExpr *Val;
 302     } Imm;
 303
 304     /// Combined record for all forms of ARM address expressions.
 305     struct {
 306       unsigned BaseRegNum;
 307       // Offset is in OffsetReg or OffsetImm. If both are zero, no offset
 308       // was specified.
 309       const MCConstantExpr *OffsetImm;  // Offset immediate value
 310       unsigned OffsetRegNum;    // Offset register num, when OffsetImm == NULL
 311       ARM_AM::ShiftOpc ShiftType; // Shift type for OffsetReg
 312       unsigned ShiftImm;      // shift for OffsetReg.
 313       unsigned isNegative : 1;  // Negated OffsetReg? (~'U' bit)
 314     } Mem;
 315
 316     struct {
 317       unsigned RegNum;
 318       bool isAdd;
 319       ARM_AM::ShiftOpc ShiftTy;
 320       unsigned ShiftImm;
 321     } PostIdxReg;
 322
 323     struct {
 324       bool isASR;
 325       unsigned Imm;
 326     } ShifterImm;
 327     struct {
 328       ARM_AM::ShiftOpc ShiftTy;
 329       unsigned SrcReg;
 330       unsigned ShiftReg;
 331       unsigned ShiftImm;
 332     } RegShiftedReg;
 333     struct {
 334       ARM_AM::ShiftOpc ShiftTy;
 335       unsigned SrcReg;
 336       unsigned ShiftImm;
 337     } RegShiftedImm;
 338     struct {
 339       unsigned Imm;
 340     } RotImm;
 341     struct {
 342       unsigned LSB;
 343       unsigned Width;
 344     } Bitfield;
 345   };
 346
 347   ARMOperand(KindTy K) : MCParsedAsmOperand(), Kind(K) {}
 348 public:
 349   ARMOperand(const ARMOperand &o) : MCParsedAsmOperand() {
 350     Kind = o.Kind;
 351     StartLoc = o.StartLoc;
 352     EndLoc = o.EndLoc;
 353     switch (Kind) {
 354     case CondCode:
 355       CC = o.CC;
 356       break;
 357     case ITCondMask:
 358       ITMask = o.ITMask;
 359       break;
 360     case Token:
 361       Tok = o.Tok;
 362       break;
 363     case CCOut:
 364     case Register:
 365       Reg = o.Reg;
 366       break;
 367     case RegisterList:
 368     case DPRRegisterList:
 369     case SPRRegisterList:
 370       Registers = o.Registers;
 371       break;
 372     case CoprocNum:
 373     case CoprocReg:
 374       Cop = o.Cop;
 375       break;
 376     case Immediate:
 377       Imm = o.Imm;
 378       break;
 379     case MemBarrierOpt:
 380       MBOpt = o.MBOpt;
 381       break;
 382     case Memory:
 383       Mem = o.Mem;
 384       break;
 385     case PostIndexRegister:
 386       PostIdxReg = o.PostIdxReg;
 387       break;
 388     case MSRMask:
 389       MMask = o.MMask;
 390       break;
 391     case ProcIFlags:
 392       IFlags = o.IFlags;
 393       break;
 394     case ShifterImmediate:
 395       ShifterImm = o.ShifterImm;
 396       break;
 397     case ShiftedRegister:
 398       RegShiftedReg = o.RegShiftedReg;
 399       break;
 400     case ShiftedImmediate:
 401       RegShiftedImm = o.RegShiftedImm;
 402       break;
 403     case RotateImmediate:
 404       RotImm = o.RotImm;
 405       break;
 406     case BitfieldDescriptor:
 407       Bitfield = o.Bitfield;
 408       break;
 409     }
 410   }
 411
 412   /// getStartLoc - Get the location of the first token of this operand.
 413   SMLoc getStartLoc() const { return StartLoc; }
 414   /// getEndLoc - Get the location of the last token of this operand.
 415   SMLoc getEndLoc() const { return EndLoc; }
 416
 417   ARMCC::CondCodes getCondCode() const {
 418     assert(Kind == CondCode && "Invalid access!");
 419     return CC.Val;
 420   }
 421
 422   unsigned getCoproc() const {
 423     assert((Kind == CoprocNum || Kind == CoprocReg) && "Invalid access!");
 424     return Cop.Val;
 425   }
 426
 427   StringRef getToken() const {
 428     assert(Kind == Token && "Invalid access!");
 429     return StringRef(Tok.Data, Tok.Length);
 430   }
 431
 432   unsigned getReg() const {
 433     assert((Kind == Register || Kind == CCOut) && "Invalid access!");
 434     return Reg.RegNum;
 435   }
 436
 437   const SmallVectorImpl<unsigned> &getRegList() const {
 438     assert((Kind == RegisterList || Kind == DPRRegisterList ||
 439             Kind == SPRRegisterList) && "Invalid access!");
 440     return Registers;
 441   }
 442
 443   const MCExpr *getImm() const {
 444     assert(Kind == Immediate && "Invalid access!");
 445     return Imm.Val;
 446   }
 447
 448   ARM_MB::MemBOpt getMemBarrierOpt() const {
 449     assert(Kind == MemBarrierOpt && "Invalid access!");
 450     return MBOpt.Val;
 451   }
 452
 453   ARM_PROC::IFlags getProcIFlags() const {
 454     assert(Kind == ProcIFlags && "Invalid access!");
 455     return IFlags.Val;
 456   }
 457
 458   unsigned getMSRMask() const {
 459     assert(Kind == MSRMask && "Invalid access!");
 460     return MMask.Val;
 461   }
 462
 463   bool isCoprocNum() const { return Kind == CoprocNum; }
 464   bool isCoprocReg() const { return Kind == CoprocReg; }
 465   bool isCondCode() const { return Kind == CondCode; }
 466   bool isCCOut() const { return Kind == CCOut; }
 467   bool isITMask() const { return Kind == ITCondMask; }
 468   bool isITCondCode() const { return Kind == CondCode; }
 469   bool isImm() const { return Kind == Immediate; }
 470   bool isImm8s4() const {
 471     if (Kind != Immediate)
 472       return false;
 473     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 474     if (!CE) return false;
 475     int64_t Value = CE->getValue();
 476     return ((Value & 3) == 0) && Value >= -1020 && Value <= 1020;
 477   }
 478   bool isImm0_1020s4() const {
 479     if (Kind != Immediate)
 480       return false;
 481     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 482     if (!CE) return false;
 483     int64_t Value = CE->getValue();
 484     return ((Value & 3) == 0) && Value >= 0 && Value <= 1020;
 485   }
 486   bool isImm0_508s4() const {
 487     if (Kind != Immediate)
 488       return false;
 489     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 490     if (!CE) return false;
 491     int64_t Value = CE->getValue();
 492     return ((Value & 3) == 0) && Value >= 0 && Value <= 508;
 493   }
 494   bool isImm0_255() const {
 495     if (Kind != Immediate)
 496       return false;
 497     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 498     if (!CE) return false;
 499     int64_t Value = CE->getValue();
 500     return Value >= 0 && Value < 256;
 501   }
 502   bool isImm0_7() const {
 503     if (Kind != Immediate)
 504       return false;
 505     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 506     if (!CE) return false;
 507     int64_t Value = CE->getValue();
 508     return Value >= 0 && Value < 8;
 509   }
 510   bool isImm0_15() const {
 511     if (Kind != Immediate)
 512       return false;
 513     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 514     if (!CE) return false;
 515     int64_t Value = CE->getValue();
 516     return Value >= 0 && Value < 16;
 517   }
 518   bool isImm0_31() const {
 519     if (Kind != Immediate)
 520       return false;
 521     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 522     if (!CE) return false;
 523     int64_t Value = CE->getValue();
 524     return Value >= 0 && Value < 32;
 525   }
 526   bool isImm1_16() const {
 527     if (Kind != Immediate)
 528       return false;
 529     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 530     if (!CE) return false;
 531     int64_t Value = CE->getValue();
 532     return Value > 0 && Value < 17;
 533   }
 534   bool isImm1_32() const {
 535     if (Kind != Immediate)
 536       return false;
 537     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 538     if (!CE) return false;
 539     int64_t Value = CE->getValue();
 540     return Value > 0 && Value < 33;
 541   }
 542   bool isImm0_65535() const {
 543     if (Kind != Immediate)
 544       return false;
 545     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 546     if (!CE) return false;
 547     int64_t Value = CE->getValue();
 548     return Value >= 0 && Value < 65536;
 549   }
 550   bool isImm0_65535Expr() const {
 551     if (Kind != Immediate)
 552       return false;
 553     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 554     // If it's not a constant expression, it'll generate a fixup and be
 555     // handled later.
 556     if (!CE) return true;
 557     int64_t Value = CE->getValue();
 558     return Value >= 0 && Value < 65536;
 559   }
 560   bool isImm24bit() const {
 561     if (Kind != Immediate)
 562       return false;
 563     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 564     if (!CE) return false;
 565     int64_t Value = CE->getValue();
 566     return Value >= 0 && Value <= 0xffffff;
 567   }
 568   bool isImmThumbSR() const {
 569     if (Kind != Immediate)
 570       return false;
 571     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 572     if (!CE) return false;
 573     int64_t Value = CE->getValue();
 574     return Value > 0 && Value < 33;
 575   }
 576   bool isPKHLSLImm() const {
 577     if (Kind != Immediate)
 578       return false;
 579     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 580     if (!CE) return false;
 581     int64_t Value = CE->getValue();
 582     return Value >= 0 && Value < 32;
 583   }
 584   bool isPKHASRImm() const {
 585     if (Kind != Immediate)
 586       return false;
 587     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 588     if (!CE) return false;
 589     int64_t Value = CE->getValue();
 590     return Value > 0 && Value <= 32;
 591   }
 592   bool isARMSOImm() const {
 593     if (Kind != Immediate)
 594       return false;
 595     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 596     if (!CE) return false;
 597     int64_t Value = CE->getValue();
 598     return ARM_AM::getSOImmVal(Value) != -1;
 599   }
 600   bool isT2SOImm() const {
 601     if (Kind != Immediate)
 602       return false;
 603     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 604     if (!CE) return false;
 605     int64_t Value = CE->getValue();
 606     return ARM_AM::getT2SOImmVal(Value) != -1;
 607   }
 608   bool isSetEndImm() const {
 609     if (Kind != Immediate)
 610       return false;
 611     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 612     if (!CE) return false;
 613     int64_t Value = CE->getValue();
 614     return Value == 1 || Value == 0;
 615   }
 616   bool isReg() const { return Kind == Register; }
 617   bool isRegList() const { return Kind == RegisterList; }
 618   bool isDPRRegList() const { return Kind == DPRRegisterList; }
 619   bool isSPRRegList() const { return Kind == SPRRegisterList; }
 620   bool isToken() const { return Kind == Token; }
 621   bool isMemBarrierOpt() const { return Kind == MemBarrierOpt; }
 622   bool isMemory() const { return Kind == Memory; }
 623   bool isShifterImm() const { return Kind == ShifterImmediate; }
 624   bool isRegShiftedReg() const { return Kind == ShiftedRegister; }
 625   bool isRegShiftedImm() const { return Kind == ShiftedImmediate; }
 626   bool isRotImm() const { return Kind == RotateImmediate; }
 627   bool isBitfield() const { return Kind == BitfieldDescriptor; }
 628   bool isPostIdxRegShifted() const { return Kind == PostIndexRegister; }
 629   bool isPostIdxReg() const {
 630     return Kind == PostIndexRegister && PostIdxReg.ShiftTy == ARM_AM::no_shift;
 631   }
 632   bool isMemNoOffset() const {
 633     if (Kind != Memory)
 634       return false;
 635     // No offset of any kind.
 636     return Mem.OffsetRegNum == 0 && Mem.OffsetImm == 0;
 637   }
 638   bool isAddrMode2() const {
 639     if (Kind != Memory)
 640       return false;
 641     // Check for register offset.
 642     if (Mem.OffsetRegNum) return true;
 643     // Immediate offset in range [-4095, 4095].
 644     if (!Mem.OffsetImm) return true;
 645     int64_t Val = Mem.OffsetImm->getValue();
 646     return Val > -4096 && Val < 4096;
 647   }
 648   bool isAM2OffsetImm() const {
 649     if (Kind != Immediate)
 650       return false;
 651     // Immediate offset in range [-4095, 4095].
 652     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 653     if (!CE) return false;
 654     int64_t Val = CE->getValue();
 655     return Val > -4096 && Val < 4096;
 656   }
 657   bool isAddrMode3() const {
 658     if (Kind != Memory)
 659       return false;
 660     // No shifts are legal for AM3.
 661     if (Mem.ShiftType != ARM_AM::no_shift) return false;
 662     // Check for register offset.
 663     if (Mem.OffsetRegNum) return true;
 664     // Immediate offset in range [-255, 255].
 665     if (!Mem.OffsetImm) return true;
 666     int64_t Val = Mem.OffsetImm->getValue();
 667     return Val > -256 && Val < 256;
 668   }
 669   bool isAM3Offset() const {
 670     if (Kind != Immediate && Kind != PostIndexRegister)
 671       return false;
 672     if (Kind == PostIndexRegister)
 673       return PostIdxReg.ShiftTy == ARM_AM::no_shift;
 674     // Immediate offset in range [-255, 255].
 675     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 676     if (!CE) return false;
 677     int64_t Val = CE->getValue();
 678     // Special case, #-0 is INT32_MIN.
 679     return (Val > -256 && Val < 256) || Val == INT32_MIN;
 680   }
 681   bool isAddrMode5() const {
 682     if (Kind != Memory)
 683       return false;
 684     // Check for register offset.
 685     if (Mem.OffsetRegNum) return false;
 686     // Immediate offset in range [-1020, 1020] and a multiple of 4.
 687     if (!Mem.OffsetImm) return true;
 688     int64_t Val = Mem.OffsetImm->getValue();
 689     return (Val >= -1020 && Val <= 1020 && ((Val & 3) == 0)) ||
 690            Val == INT32_MIN;
 691   }
 692   bool isMemRegOffset() const {
 693     if (Kind != Memory || !Mem.OffsetRegNum)
 694       return false;
 695     return true;
 696   }
 697   bool isT2MemRegOffset() const {
 698     if (Kind != Memory || !Mem.OffsetRegNum || Mem.isNegative)
 699       return false;
 700     // Only lsl #{0, 1, 2, 3} allowed.
 701     if (Mem.ShiftType == ARM_AM::no_shift)
 702       return true;
 703     if (Mem.ShiftType != ARM_AM::lsl || Mem.ShiftImm > 3)
 704       return false;
 705     return true;
 706   }
 707   bool isMemThumbRR() const {
 708     // Thumb reg+reg addressing is simple. Just two registers, a base and
 709     // an offset. No shifts, negations or any other complicating factors.
 710     if (Kind != Memory || !Mem.OffsetRegNum || Mem.isNegative ||
 711         Mem.ShiftType != ARM_AM::no_shift)
 712       return false;
 713     return isARMLowRegister(Mem.BaseRegNum) &&
 714       (!Mem.OffsetRegNum || isARMLowRegister(Mem.OffsetRegNum));
 715   }
 716   bool isMemThumbRIs4() const {
 717     if (Kind != Memory || Mem.OffsetRegNum != 0 ||
 718         !isARMLowRegister(Mem.BaseRegNum))
 719       return false;
 720     // Immediate offset, multiple of 4 in range [0, 124].
 721     if (!Mem.OffsetImm) return true;
 722     int64_t Val = Mem.OffsetImm->getValue();
 723     return Val >= 0 && Val <= 124 && (Val % 4) == 0;
 724   }
 725   bool isMemThumbRIs2() const {
 726     if (Kind != Memory || Mem.OffsetRegNum != 0 ||
 727         !isARMLowRegister(Mem.BaseRegNum))
 728       return false;
 729     // Immediate offset, multiple of 4 in range [0, 62].
 730     if (!Mem.OffsetImm) return true;
 731     int64_t Val = Mem.OffsetImm->getValue();
 732     return Val >= 0 && Val <= 62 && (Val % 2) == 0;
 733   }
 734   bool isMemThumbRIs1() const {
 735     if (Kind != Memory || Mem.OffsetRegNum != 0 ||
 736         !isARMLowRegister(Mem.BaseRegNum))
 737       return false;
 738     // Immediate offset in range [0, 31].
 739     if (!Mem.OffsetImm) return true;
 740     int64_t Val = Mem.OffsetImm->getValue();
 741     return Val >= 0 && Val <= 31;
 742   }
 743   bool isMemThumbSPI() const {
 744     if (Kind != Memory || Mem.OffsetRegNum != 0 || Mem.BaseRegNum != ARM::SP)
 745       return false;
 746     // Immediate offset, multiple of 4 in range [0, 1020].
 747     if (!Mem.OffsetImm) return true;
 748     int64_t Val = Mem.OffsetImm->getValue();
 749     return Val >= 0 && Val <= 1020 && (Val % 4) == 0;
 750   }
 751   bool isMemImm8s4Offset() const {
 752     if (Kind != Memory || Mem.OffsetRegNum != 0)
 753       return false;
 754     // Immediate offset a multiple of 4 in range [-1020, 1020].
 755     if (!Mem.OffsetImm) return true;
 756     int64_t Val = Mem.OffsetImm->getValue();
 757     return Val >= -1020 && Val <= 1020 && (Val & 3) == 0;
 758   }
 759   bool isMemImm8Offset() const {
 760     if (Kind != Memory || Mem.OffsetRegNum != 0)
 761       return false;
 762     // Immediate offset in range [-255, 255].
 763     if (!Mem.OffsetImm) return true;
 764     int64_t Val = Mem.OffsetImm->getValue();
 765     return Val > -256 && Val < 256;
 766   }
 767   bool isMemPosImm8Offset() const {
 768     if (Kind != Memory || Mem.OffsetRegNum != 0)
 769       return false;
 770     // Immediate offset in range [0, 255].
 771     if (!Mem.OffsetImm) return true;
 772     int64_t Val = Mem.OffsetImm->getValue();
 773     return Val >= 0 && Val < 256;
 774   }
 775   bool isMemNegImm8Offset() const {
 776     if (Kind != Memory || Mem.OffsetRegNum != 0)
 777       return false;
 778     // Immediate offset in range [-255, -1].
 779     if (!Mem.OffsetImm) return true;
 780     int64_t Val = Mem.OffsetImm->getValue();
 781     return Val > -256 && Val < 0;
 782   }
 783   bool isMemUImm12Offset() const {
 784     // If we have an immediate that's not a constant, treat it as a label
 785     // reference needing a fixup. If it is a constant, it's something else
 786     // and we reject it.
 787     if (Kind == Immediate && !isa<MCConstantExpr>(getImm()))
 788       return true;
 789
 790     if (Kind != Memory || Mem.OffsetRegNum != 0)
 791       return false;
 792     // Immediate offset in range [0, 4095].
 793     if (!Mem.OffsetImm) return true;
 794     int64_t Val = Mem.OffsetImm->getValue();
 795     return (Val >= 0 && Val < 4096);
 796   }
 797   bool isMemImm12Offset() const {
 798     // If we have an immediate that's not a constant, treat it as a label
 799     // reference needing a fixup. If it is a constant, it's something else
 800     // and we reject it.
 801     if (Kind == Immediate && !isa<MCConstantExpr>(getImm()))
 802       return true;
 803
 804     if (Kind != Memory || Mem.OffsetRegNum != 0)
 805       return false;
 806     // Immediate offset in range [-4095, 4095].
 807     if (!Mem.OffsetImm) return true;
 808     int64_t Val = Mem.OffsetImm->getValue();
 809     return (Val > -4096 && Val < 4096) || (Val == INT32_MIN);
 810   }
 811   bool isPostIdxImm8() const {
 812     if (Kind != Immediate)
 813       return false;
 814     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 815     if (!CE) return false;
 816     int64_t Val = CE->getValue();
 817     return (Val > -256 && Val < 256) || (Val == INT32_MIN);
 818   }
 819
 820   bool isMSRMask() const { return Kind == MSRMask; }
 821   bool isProcIFlags() const { return Kind == ProcIFlags; }
 822
 823   void addExpr(MCInst &Inst, const MCExpr *Expr) const {
 824     // Add as immediates when possible.  Null MCExpr = 0.
 825     if (Expr == 0)
 826       Inst.addOperand(MCOperand::CreateImm(0));
 827     else if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr))
 828       Inst.addOperand(MCOperand::CreateImm(CE->getValue()));
 829     else
 830       Inst.addOperand(MCOperand::CreateExpr(Expr));
 831   }
 832
 833   void addCondCodeOperands(MCInst &Inst, unsigned N) const {
 834     assert(N == 2 && "Invalid number of operands!");
 835     Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode())));
 836     unsigned RegNum = getCondCode() == ARMCC::AL ? 0: ARM::CPSR;
 837     Inst.addOperand(MCOperand::CreateReg(RegNum));
 838   }
 839
 840   void addCoprocNumOperands(MCInst &Inst, unsigned N) const {
 841     assert(N == 1 && "Invalid number of operands!");
 842     Inst.addOperand(MCOperand::CreateImm(getCoproc()));
 843   }
 844
 845   void addITMaskOperands(MCInst &Inst, unsigned N) const {
 846     assert(N == 1 && "Invalid number of operands!");
 847     Inst.addOperand(MCOperand::CreateImm(ITMask.Mask));
 848   }
 849
 850   void addITCondCodeOperands(MCInst &Inst, unsigned N) const {
 851     assert(N == 1 && "Invalid number of operands!");
 852     Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode())));
 853   }
 854
 855   void addCoprocRegOperands(MCInst &Inst, unsigned N) const {
 856     assert(N == 1 && "Invalid number of operands!");
 857     Inst.addOperand(MCOperand::CreateImm(getCoproc()));
 858   }
 859
 860   void addCCOutOperands(MCInst &Inst, unsigned N) const {
 861     assert(N == 1 && "Invalid number of operands!");
 862     Inst.addOperand(MCOperand::CreateReg(getReg()));
 863   }
 864
 865   void addRegOperands(MCInst &Inst, unsigned N) const {
 866     assert(N == 1 && "Invalid number of operands!");
 867     Inst.addOperand(MCOperand::CreateReg(getReg()));
 868   }
 869
 870   void addRegShiftedRegOperands(MCInst &Inst, unsigned N) const {
 871     assert(N == 3 && "Invalid number of operands!");
 872     assert(isRegShiftedReg() && "addRegShiftedRegOperands() on non RegShiftedReg!");
 873     Inst.addOperand(MCOperand::CreateReg(RegShiftedReg.SrcReg));
 874     Inst.addOperand(MCOperand::CreateReg(RegShiftedReg.ShiftReg));
 875     Inst.addOperand(MCOperand::CreateImm(
 876       ARM_AM::getSORegOpc(RegShiftedReg.ShiftTy, RegShiftedReg.ShiftImm)));
 877   }
 878
 879   void addRegShiftedImmOperands(MCInst &Inst, unsigned N) const {
 880     assert(N == 2 && "Invalid number of operands!");
 881     assert(isRegShiftedImm() && "addRegShiftedImmOperands() on non RegShiftedImm!");
 882     Inst.addOperand(MCOperand::CreateReg(RegShiftedImm.SrcReg));
 883     Inst.addOperand(MCOperand::CreateImm(
 884       ARM_AM::getSORegOpc(RegShiftedImm.ShiftTy, RegShiftedImm.ShiftImm)));
 885   }
 886
 887   void addShifterImmOperands(MCInst &Inst, unsigned N) const {
 888     assert(N == 1 && "Invalid number of operands!");
 889     Inst.addOperand(MCOperand::CreateImm((ShifterImm.isASR << 5) |
 890                                          ShifterImm.Imm));
 891   }
 892
 893   void addRegListOperands(MCInst &Inst, unsigned N) const {
 894     assert(N == 1 && "Invalid number of operands!");
 895     const SmallVectorImpl<unsigned> &RegList = getRegList();
 896     for (SmallVectorImpl<unsigned>::const_iterator
 897            I = RegList.begin(), E = RegList.end(); I != E; ++I)
 898       Inst.addOperand(MCOperand::CreateReg(*I));
 899   }
 900
 901   void addDPRRegListOperands(MCInst &Inst, unsigned N) const {
 902     addRegListOperands(Inst, N);
 903   }
 904
 905   void addSPRRegListOperands(MCInst &Inst, unsigned N) const {
 906     addRegListOperands(Inst, N);
 907   }
 908
 909   void addRotImmOperands(MCInst &Inst, unsigned N) const {
 910     assert(N == 1 && "Invalid number of operands!");
 911     // Encoded as val>>3. The printer handles display as 8, 16, 24.
 912     Inst.addOperand(MCOperand::CreateImm(RotImm.Imm >> 3));
 913   }
 914
 915   void addBitfieldOperands(MCInst &Inst, unsigned N) const {
 916     assert(N == 1 && "Invalid number of operands!");
 917     // Munge the lsb/width into a bitfield mask.
 918     unsigned lsb = Bitfield.LSB;
 919     unsigned width = Bitfield.Width;
 920     // Make a 32-bit mask w/ the referenced bits clear and all other bits set.
 921     uint32_t Mask = ~(((uint32_t)0xffffffff >> lsb) << (32 - width) >>
 922                       (32 - (lsb + width)));
 923     Inst.addOperand(MCOperand::CreateImm(Mask));
 924   }
 925
 926   void addImmOperands(MCInst &Inst, unsigned N) const {
 927     assert(N == 1 && "Invalid number of operands!");
 928     addExpr(Inst, getImm());
 929   }
 930
 931   void addImm8s4Operands(MCInst &Inst, unsigned N) const {
 932     assert(N == 1 && "Invalid number of operands!");
 933     // FIXME: We really want to scale the value here, but the LDRD/STRD
 934     // instruction don't encode operands that way yet.
 935     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 936     Inst.addOperand(MCOperand::CreateImm(CE->getValue()));
 937   }
 938
 939   void addImm0_1020s4Operands(MCInst &Inst, unsigned N) const {
 940     assert(N == 1 && "Invalid number of operands!");
 941     // The immediate is scaled by four in the encoding and is stored
 942     // in the MCInst as such. Lop off the low two bits here.
 943     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 944     Inst.addOperand(MCOperand::CreateImm(CE->getValue() / 4));
 945   }
 946
 947   void addImm0_508s4Operands(MCInst &Inst, unsigned N) const {
 948     assert(N == 1 && "Invalid number of operands!");
 949     // The immediate is scaled by four in the encoding and is stored
 950     // in the MCInst as such. Lop off the low two bits here.
 951     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 952     Inst.addOperand(MCOperand::CreateImm(CE->getValue() / 4));
 953   }
 954
 955   void addImm0_255Operands(MCInst &Inst, unsigned N) const {
 956     assert(N == 1 && "Invalid number of operands!");
 957     addExpr(Inst, getImm());
 958   }
 959
 960   void addImm0_7Operands(MCInst &Inst, unsigned N) const {
 961     assert(N == 1 && "Invalid number of operands!");
 962     addExpr(Inst, getImm());
 963   }
 964
 965   void addImm0_15Operands(MCInst &Inst, unsigned N) const {
 966     assert(N == 1 && "Invalid number of operands!");
 967     addExpr(Inst, getImm());
 968   }
 969
 970   void addImm0_31Operands(MCInst &Inst, unsigned N) const {
 971     assert(N == 1 && "Invalid number of operands!");
 972     addExpr(Inst, getImm());
 973   }
 974
 975   void addImm1_16Operands(MCInst &Inst, unsigned N) const {
 976     assert(N == 1 && "Invalid number of operands!");
 977     // The constant encodes as the immediate-1, and we store in the instruction
 978     // the bits as encoded, so subtract off one here.
 979     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 980     Inst.addOperand(MCOperand::CreateImm(CE->getValue() - 1));
 981   }
 982
 983   void addImm1_32Operands(MCInst &Inst, unsigned N) const {
 984     assert(N == 1 && "Invalid number of operands!");
 985     // The constant encodes as the immediate-1, and we store in the instruction
 986     // the bits as encoded, so subtract off one here.
 987     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 988     Inst.addOperand(MCOperand::CreateImm(CE->getValue() - 1));
 989   }
 990
 991   void addImm0_65535Operands(MCInst &Inst, unsigned N) const {
 992     assert(N == 1 && "Invalid number of operands!");
 993     addExpr(Inst, getImm());
 994   }
 995
 996   void addImm0_65535ExprOperands(MCInst &Inst, unsigned N) const {
 997     assert(N == 1 && "Invalid number of operands!");
 998     addExpr(Inst, getImm());
 999   }
1000
1001   void addImm24bitOperands(MCInst &Inst, unsigned N) const {
1002     assert(N == 1 && "Invalid number of operands!");
1003     addExpr(Inst, getImm());
1004   }
1005
1006   void addImmThumbSROperands(MCInst &Inst, unsigned N) const {
1007     assert(N == 1 && "Invalid number of operands!");
1008     // The constant encodes as the immediate, except for 32, which encodes as
1009     // zero.
1010     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1011     unsigned Imm = CE->getValue();
1012     Inst.addOperand(MCOperand::CreateImm((Imm == 32 ? 0 : Imm)));
1013   }
1014
1015   void addPKHLSLImmOperands(MCInst &Inst, unsigned N) const {
1016     assert(N == 1 && "Invalid number of operands!");
1017     addExpr(Inst, getImm());
1018   }
1019
1020   void addPKHASRImmOperands(MCInst &Inst, unsigned N) const {
1021     assert(N == 1 && "Invalid number of operands!");
1022     // An ASR value of 32 encodes as 0, so that's how we want to add it to
1023     // the instruction as well.
1024     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1025     int Val = CE->getValue();
1026     Inst.addOperand(MCOperand::CreateImm(Val == 32 ? 0 : Val));
1027   }
1028
1029   void addARMSOImmOperands(MCInst &Inst, unsigned N) const {
1030     assert(N == 1 && "Invalid number of operands!");
1031     addExpr(Inst, getImm());
1032   }
1033
1034   void addT2SOImmOperands(MCInst &Inst, unsigned N) const {
1035     assert(N == 1 && "Invalid number of operands!");
1036     addExpr(Inst, getImm());
1037   }
1038
1039   void addSetEndImmOperands(MCInst &Inst, unsigned N) const {
1040     assert(N == 1 && "Invalid number of operands!");
1041     addExpr(Inst, getImm());
1042   }
1043
1044   void addMemBarrierOptOperands(MCInst &Inst, unsigned N) const {
1045     assert(N == 1 && "Invalid number of operands!");
1046     Inst.addOperand(MCOperand::CreateImm(unsigned(getMemBarrierOpt())));
1047   }
1048
1049   void addMemNoOffsetOperands(MCInst &Inst, unsigned N) const {
1050     assert(N == 1 && "Invalid number of operands!");
1051     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1052   }
1053
1054   void addAddrMode2Operands(MCInst &Inst, unsigned N) const {
1055     assert(N == 3 && "Invalid number of operands!");
1056     int32_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() : 0;
1057     if (!Mem.OffsetRegNum) {
1058       ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1059       // Special case for #-0
1060       if (Val == INT32_MIN) Val = 0;
1061       if (Val < 0) Val = -Val;
1062       Val = ARM_AM::getAM2Opc(AddSub, Val, ARM_AM::no_shift);
1063     } else {
1064       // For register offset, we encode the shift type and negation flag
1065       // here.
1066       Val = ARM_AM::getAM2Opc(Mem.isNegative ? ARM_AM::sub : ARM_AM::add,
1067                               Mem.ShiftImm, Mem.ShiftType);
1068     }
1069     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1070     Inst.addOperand(MCOperand::CreateReg(Mem.OffsetRegNum));
1071     Inst.addOperand(MCOperand::CreateImm(Val));
1072   }
1073
1074   void addAM2OffsetImmOperands(MCInst &Inst, unsigned N) const {
1075     assert(N == 2 && "Invalid number of operands!");
1076     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1077     assert(CE && "non-constant AM2OffsetImm operand!");
1078     int32_t Val = CE->getValue();
1079     ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1080     // Special case for #-0
1081     if (Val == INT32_MIN) Val = 0;
1082     if (Val < 0) Val = -Val;
1083     Val = ARM_AM::getAM2Opc(AddSub, Val, ARM_AM::no_shift);
1084     Inst.addOperand(MCOperand::CreateReg(0));
1085     Inst.addOperand(MCOperand::CreateImm(Val));
1086   }
1087
1088   void addAddrMode3Operands(MCInst &Inst, unsigned N) const {
1089     assert(N == 3 && "Invalid number of operands!");
1090     int32_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() : 0;
1091     if (!Mem.OffsetRegNum) {
1092       ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1093       // Special case for #-0
1094       if (Val == INT32_MIN) Val = 0;
1095       if (Val < 0) Val = -Val;
1096       Val = ARM_AM::getAM3Opc(AddSub, Val);
1097     } else {
1098       // For register offset, we encode the shift type and negation flag
1099       // here.
1100       Val = ARM_AM::getAM3Opc(Mem.isNegative ? ARM_AM::sub : ARM_AM::add, 0);
1101     }
1102     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1103     Inst.addOperand(MCOperand::CreateReg(Mem.OffsetRegNum));
1104     Inst.addOperand(MCOperand::CreateImm(Val));
1105   }
1106
1107   void addAM3OffsetOperands(MCInst &Inst, unsigned N) const {
1108     assert(N == 2 && "Invalid number of operands!");
1109     if (Kind == PostIndexRegister) {
1110       int32_t Val =
1111         ARM_AM::getAM3Opc(PostIdxReg.isAdd ? ARM_AM::add : ARM_AM::sub, 0);
1112       Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum));
1113       Inst.addOperand(MCOperand::CreateImm(Val));
1114       return;
1115     }
1116
1117     // Constant offset.
1118     const MCConstantExpr *CE = static_cast<const MCConstantExpr*>(getImm());
1119     int32_t Val = CE->getValue();
1120     ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1121     // Special case for #-0
1122     if (Val == INT32_MIN) Val = 0;
1123     if (Val < 0) Val = -Val;
1124     Val = ARM_AM::getAM3Opc(AddSub, Val);
1125     Inst.addOperand(MCOperand::CreateReg(0));
1126     Inst.addOperand(MCOperand::CreateImm(Val));
1127   }
1128
1129   void addAddrMode5Operands(MCInst &Inst, unsigned N) const {
1130     assert(N == 2 && "Invalid number of operands!");
1131     // The lower two bits are always zero and as such are not encoded.
1132     int32_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() / 4 : 0;
1133     ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1134     // Special case for #-0
1135     if (Val == INT32_MIN) Val = 0;
1136     if (Val < 0) Val = -Val;
1137     Val = ARM_AM::getAM5Opc(AddSub, Val);
1138     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1139     Inst.addOperand(MCOperand::CreateImm(Val));
1140   }
1141
1142   void addMemImm8s4OffsetOperands(MCInst &Inst, unsigned N) const {
1143     assert(N == 2 && "Invalid number of operands!");
1144     int64_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() : 0;
1145     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1146     Inst.addOperand(MCOperand::CreateImm(Val));
1147   }
1148
1149   void addMemImm8OffsetOperands(MCInst &Inst, unsigned N) const {
1150     assert(N == 2 && "Invalid number of operands!");
1151     int64_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() : 0;
1152     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1153     Inst.addOperand(MCOperand::CreateImm(Val));
1154   }
1155
1156   void addMemPosImm8OffsetOperands(MCInst &Inst, unsigned N) const {
1157     addMemImm8OffsetOperands(Inst, N);
1158   }
1159
1160   void addMemNegImm8OffsetOperands(MCInst &Inst, unsigned N) const {
1161     addMemImm8OffsetOperands(Inst, N);
1162   }
1163
1164   void addMemUImm12OffsetOperands(MCInst &Inst, unsigned N) const {
1165     assert(N == 2 && "Invalid number of operands!");
1166     // If this is an immediate, it's a label reference.
1167     if (Kind == Immediate) {
1168       addExpr(Inst, getImm());
1169       Inst.addOperand(MCOperand::CreateImm(0));
1170       return;
1171     }
1172
1173     // Otherwise, it's a normal memory reg+offset.
1174     int64_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() : 0;
1175     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1176     Inst.addOperand(MCOperand::CreateImm(Val));
1177   }
1178
1179   void addMemImm12OffsetOperands(MCInst &Inst, unsigned N) const {
1180     assert(N == 2 && "Invalid number of operands!");
1181     // If this is an immediate, it's a label reference.
1182     if (Kind == Immediate) {
1183       addExpr(Inst, getImm());
1184       Inst.addOperand(MCOperand::CreateImm(0));
1185       return;
1186     }
1187
1188     // Otherwise, it's a normal memory reg+offset.
1189     int64_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() : 0;
1190     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1191     Inst.addOperand(MCOperand::CreateImm(Val));
1192   }
1193
1194   void addMemRegOffsetOperands(MCInst &Inst, unsigned N) const {
1195     assert(N == 3 && "Invalid number of operands!");
1196     unsigned Val = ARM_AM::getAM2Opc(Mem.isNegative ? ARM_AM::sub : ARM_AM::add,
1197                                      Mem.ShiftImm, Mem.ShiftType);
1198     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1199     Inst.addOperand(MCOperand::CreateReg(Mem.OffsetRegNum));
1200     Inst.addOperand(MCOperand::CreateImm(Val));
1201   }
1202
1203   void addT2MemRegOffsetOperands(MCInst &Inst, unsigned N) const {
1204     assert(N == 3 && "Invalid number of operands!");
1205     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1206     Inst.addOperand(MCOperand::CreateReg(Mem.OffsetRegNum));
1207     Inst.addOperand(MCOperand::CreateImm(Mem.ShiftImm));
1208   }
1209
1210   void addMemThumbRROperands(MCInst &Inst, unsigned N) const {
1211     assert(N == 2 && "Invalid number of operands!");
1212     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1213     Inst.addOperand(MCOperand::CreateReg(Mem.OffsetRegNum));
1214   }
1215
1216   void addMemThumbRIs4Operands(MCInst &Inst, unsigned N) const {
1217     assert(N == 2 && "Invalid number of operands!");
1218     int64_t Val = Mem.OffsetImm ? (Mem.OffsetImm->getValue() / 4) : 0;
1219     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1220     Inst.addOperand(MCOperand::CreateImm(Val));
1221   }
1222
1223   void addMemThumbRIs2Operands(MCInst &Inst, unsigned N) const {
1224     assert(N == 2 && "Invalid number of operands!");
1225     int64_t Val = Mem.OffsetImm ? (Mem.OffsetImm->getValue() / 2) : 0;
1226     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1227     Inst.addOperand(MCOperand::CreateImm(Val));
1228   }
1229
1230   void addMemThumbRIs1Operands(MCInst &Inst, unsigned N) const {
1231     assert(N == 2 && "Invalid number of operands!");
1232     int64_t Val = Mem.OffsetImm ? (Mem.OffsetImm->getValue()) : 0;
1233     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1234     Inst.addOperand(MCOperand::CreateImm(Val));
1235   }
1236
1237   void addMemThumbSPIOperands(MCInst &Inst, unsigned N) const {
1238     assert(N == 2 && "Invalid number of operands!");
1239     int64_t Val = Mem.OffsetImm ? (Mem.OffsetImm->getValue() / 4) : 0;
1240     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1241     Inst.addOperand(MCOperand::CreateImm(Val));
1242   }
1243
1244   void addPostIdxImm8Operands(MCInst &Inst, unsigned N) const {
1245     assert(N == 1 && "Invalid number of operands!");
1246     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1247     assert(CE && "non-constant post-idx-imm8 operand!");
1248     int Imm = CE->getValue();
1249     bool isAdd = Imm >= 0;
1250     if (Imm == INT32_MIN) Imm = 0;
1251     Imm = (Imm < 0 ? -Imm : Imm) | (int)isAdd << 8;
1252     Inst.addOperand(MCOperand::CreateImm(Imm));
1253   }
1254
1255   void addPostIdxRegOperands(MCInst &Inst, unsigned N) const {
1256     assert(N == 2 && "Invalid number of operands!");
1257     Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum));
1258     Inst.addOperand(MCOperand::CreateImm(PostIdxReg.isAdd));
1259   }
1260
1261   void addPostIdxRegShiftedOperands(MCInst &Inst, unsigned N) const {
1262     assert(N == 2 && "Invalid number of operands!");
1263     Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum));
1264     // The sign, shift type, and shift amount are encoded in a single operand
1265     // using the AM2 encoding helpers.
1266     ARM_AM::AddrOpc opc = PostIdxReg.isAdd ? ARM_AM::add : ARM_AM::sub;
1267     unsigned Imm = ARM_AM::getAM2Opc(opc, PostIdxReg.ShiftImm,
1268                                      PostIdxReg.ShiftTy);
1269     Inst.addOperand(MCOperand::CreateImm(Imm));
1270   }
1271
1272   void addMSRMaskOperands(MCInst &Inst, unsigned N) const {
1273     assert(N == 1 && "Invalid number of operands!");
1274     Inst.addOperand(MCOperand::CreateImm(unsigned(getMSRMask())));
1275   }
1276
1277   void addProcIFlagsOperands(MCInst &Inst, unsigned N) const {
1278     assert(N == 1 && "Invalid number of operands!");
1279     Inst.addOperand(MCOperand::CreateImm(unsigned(getProcIFlags())));
1280   }
1281
1282   virtual void print(raw_ostream &OS) const;
1283
1284   static ARMOperand *CreateITMask(unsigned Mask, SMLoc S) {
1285     ARMOperand *Op = new ARMOperand(ITCondMask);
1286     Op->ITMask.Mask = Mask;
1287     Op->StartLoc = S;
1288     Op->EndLoc = S;
1289     return Op;
1290   }
1291
1292   static ARMOperand *CreateCondCode(ARMCC::CondCodes CC, SMLoc S) {
1293     ARMOperand *Op = new ARMOperand(CondCode);
1294     Op->CC.Val = CC;
1295     Op->StartLoc = S;
1296     Op->EndLoc = S;
1297     return Op;
1298   }
1299
1300   static ARMOperand *CreateCoprocNum(unsigned CopVal, SMLoc S) {
1301     ARMOperand *Op = new ARMOperand(CoprocNum);
1302     Op->Cop.Val = CopVal;
1303     Op->StartLoc = S;
1304     Op->EndLoc = S;
1305     return Op;
1306   }
1307
1308   static ARMOperand *CreateCoprocReg(unsigned CopVal, SMLoc S) {
1309     ARMOperand *Op = new ARMOperand(CoprocReg);
1310     Op->Cop.Val = CopVal;
1311     Op->StartLoc = S;
1312     Op->EndLoc = S;
1313     return Op;
1314   }
1315
1316   static ARMOperand *CreateCCOut(unsigned RegNum, SMLoc S) {
1317     ARMOperand *Op = new ARMOperand(CCOut);
1318     Op->Reg.RegNum = RegNum;
1319     Op->StartLoc = S;
1320     Op->EndLoc = S;
1321     return Op;
1322   }
1323
1324   static ARMOperand *CreateToken(StringRef Str, SMLoc S) {
1325     ARMOperand *Op = new ARMOperand(Token);
1326     Op->Tok.Data = Str.data();
1327     Op->Tok.Length = Str.size();
1328     Op->StartLoc = S;
1329     Op->EndLoc = S;
1330     return Op;
1331   }
1332
1333   static ARMOperand *CreateReg(unsigned RegNum, SMLoc S, SMLoc E) {
1334     ARMOperand *Op = new ARMOperand(Register);
1335     Op->Reg.RegNum = RegNum;
1336     Op->StartLoc = S;
1337     Op->EndLoc = E;
1338     return Op;
1339   }
1340
1341   static ARMOperand *CreateShiftedRegister(ARM_AM::ShiftOpc ShTy,
1342                                            unsigned SrcReg,
1343                                            unsigned ShiftReg,
1344                                            unsigned ShiftImm,
1345                                            SMLoc S, SMLoc E) {
1346     ARMOperand *Op = new ARMOperand(ShiftedRegister);
1347     Op->RegShiftedReg.ShiftTy = ShTy;
1348     Op->RegShiftedReg.SrcReg = SrcReg;
1349     Op->RegShiftedReg.ShiftReg = ShiftReg;
1350     Op->RegShiftedReg.ShiftImm = ShiftImm;
1351     Op->StartLoc = S;
1352     Op->EndLoc = E;
1353     return Op;
1354   }
1355
1356   static ARMOperand *CreateShiftedImmediate(ARM_AM::ShiftOpc ShTy,
1357                                             unsigned SrcReg,
1358                                             unsigned ShiftImm,
1359                                             SMLoc S, SMLoc E) {
1360     ARMOperand *Op = new ARMOperand(ShiftedImmediate);
1361     Op->RegShiftedImm.ShiftTy = ShTy;
1362     Op->RegShiftedImm.SrcReg = SrcReg;
1363     Op->RegShiftedImm.ShiftImm = ShiftImm;
1364     Op->StartLoc = S;
1365     Op->EndLoc = E;
1366     return Op;
1367   }
1368
1369   static ARMOperand *CreateShifterImm(bool isASR, unsigned Imm,
1370                                    SMLoc S, SMLoc E) {
1371     ARMOperand *Op = new ARMOperand(ShifterImmediate);
1372     Op->ShifterImm.isASR = isASR;
1373     Op->ShifterImm.Imm = Imm;
1374     Op->StartLoc = S;
1375     Op->EndLoc = E;
1376     return Op;
1377   }
1378
1379   static ARMOperand *CreateRotImm(unsigned Imm, SMLoc S, SMLoc E) {
1380     ARMOperand *Op = new ARMOperand(RotateImmediate);
1381     Op->RotImm.Imm = Imm;
1382     Op->StartLoc = S;
1383     Op->EndLoc = E;
1384     return Op;
1385   }
1386
1387   static ARMOperand *CreateBitfield(unsigned LSB, unsigned Width,
1388                                     SMLoc S, SMLoc E) {
1389     ARMOperand *Op = new ARMOperand(BitfieldDescriptor);
1390     Op->Bitfield.LSB = LSB;
1391     Op->Bitfield.Width = Width;
1392     Op->StartLoc = S;
1393     Op->EndLoc = E;
1394     return Op;
1395   }
1396
1397   static ARMOperand *
1398   CreateRegList(const SmallVectorImpl<std::pair<unsigned, SMLoc> > &Regs,
1399                 SMLoc StartLoc, SMLoc EndLoc) {
1400     KindTy Kind = RegisterList;
1401
1402     if (llvm::ARMMCRegisterClasses[ARM::DPRRegClassID].
1403         contains(Regs.front().first))
1404       Kind = DPRRegisterList;
1405     else if (llvm::ARMMCRegisterClasses[ARM::SPRRegClassID].
1406              contains(Regs.front().first))
1407       Kind = SPRRegisterList;
1408
1409     ARMOperand *Op = new ARMOperand(Kind);
1410     for (SmallVectorImpl<std::pair<unsigned, SMLoc> >::const_iterator
1411            I = Regs.begin(), E = Regs.end(); I != E; ++I)
1412       Op->Registers.push_back(I->first);
1413     array_pod_sort(Op->Registers.begin(), Op->Registers.end());
1414     Op->StartLoc = StartLoc;
1415     Op->EndLoc = EndLoc;
1416     return Op;
1417   }
1418
1419   static ARMOperand *CreateImm(const MCExpr *Val, SMLoc S, SMLoc E) {
1420     ARMOperand *Op = new ARMOperand(Immediate);
1421     Op->Imm.Val = Val;
1422     Op->StartLoc = S;
1423     Op->EndLoc = E;
1424     return Op;
1425   }
1426
1427   static ARMOperand *CreateMem(unsigned BaseRegNum,
1428                                const MCConstantExpr *OffsetImm,
1429                                unsigned OffsetRegNum,
1430                                ARM_AM::ShiftOpc ShiftType,
1431                                unsigned ShiftImm,
1432                                bool isNegative,
1433                                SMLoc S, SMLoc E) {
1434     ARMOperand *Op = new ARMOperand(Memory);
1435     Op->Mem.BaseRegNum = BaseRegNum;
1436     Op->Mem.OffsetImm = OffsetImm;
1437     Op->Mem.OffsetRegNum = OffsetRegNum;
1438     Op->Mem.ShiftType = ShiftType;
1439     Op->Mem.ShiftImm = ShiftImm;
1440     Op->Mem.isNegative = isNegative;
1441     Op->StartLoc = S;
1442     Op->EndLoc = E;
1443     return Op;
1444   }
1445
1446   static ARMOperand *CreatePostIdxReg(unsigned RegNum, bool isAdd,
1447                                       ARM_AM::ShiftOpc ShiftTy,
1448                                       unsigned ShiftImm,
1449                                       SMLoc S, SMLoc E) {
1450     ARMOperand *Op = new ARMOperand(PostIndexRegister);
1451     Op->PostIdxReg.RegNum = RegNum;
1452     Op->PostIdxReg.isAdd = isAdd;
1453     Op->PostIdxReg.ShiftTy = ShiftTy;
1454     Op->PostIdxReg.ShiftImm = ShiftImm;
1455     Op->StartLoc = S;
1456     Op->EndLoc = E;
1457     return Op;
1458   }
1459
1460   static ARMOperand *CreateMemBarrierOpt(ARM_MB::MemBOpt Opt, SMLoc S) {
1461     ARMOperand *Op = new ARMOperand(MemBarrierOpt);
1462     Op->MBOpt.Val = Opt;
1463     Op->StartLoc = S;
1464     Op->EndLoc = S;
1465     return Op;
1466   }
1467
1468   static ARMOperand *CreateProcIFlags(ARM_PROC::IFlags IFlags, SMLoc S) {
1469     ARMOperand *Op = new ARMOperand(ProcIFlags);
1470     Op->IFlags.Val = IFlags;
1471     Op->StartLoc = S;
1472     Op->EndLoc = S;
1473     return Op;
1474   }
1475
1476   static ARMOperand *CreateMSRMask(unsigned MMask, SMLoc S) {
1477     ARMOperand *Op = new ARMOperand(MSRMask);
1478     Op->MMask.Val = MMask;
1479     Op->StartLoc = S;
1480     Op->EndLoc = S;
1481     return Op;
1482   }
1483 };
1484
1485 } // end anonymous namespace.
1486
1487 void ARMOperand::print(raw_ostream &OS) const {
1488   switch (Kind) {
1489   case CondCode:
1490     OS << "<ARMCC::" << ARMCondCodeToString(getCondCode()) << ">";
1491     break;
1492   case CCOut:
1493     OS << "<ccout " << getReg() << ">";
1494     break;
1495   case ITCondMask: {
1496     static char MaskStr[][6] = { "()", "(t)", "(e)", "(tt)", "(et)", "(te)",
1497       "(ee)", "(ttt)", "(ett)", "(tet)", "(eet)", "(tte)", "(ete)",
1498       "(tee)", "(eee)" };
1499     assert((ITMask.Mask & 0xf) == ITMask.Mask);
1500     OS << "<it-mask " << MaskStr[ITMask.Mask] << ">";
1501     break;
1502   }
1503   case CoprocNum:
1504     OS << "<coprocessor number: " << getCoproc() << ">";
1505     break;
1506   case CoprocReg:
1507     OS << "<coprocessor register: " << getCoproc() << ">";
1508     break;
1509   case MSRMask:
1510     OS << "<mask: " << getMSRMask() << ">";
1511     break;
1512   case Immediate:
1513     getImm()->print(OS);
1514     break;
1515   case MemBarrierOpt:
1516     OS << "<ARM_MB::" << MemBOptToString(getMemBarrierOpt()) << ">";
1517     break;
1518   case Memory:
1519     OS << "<memory "
1520        << " base:" << Mem.BaseRegNum;
1521     OS << ">";
1522     break;
1523   case PostIndexRegister:
1524     OS << "post-idx register " << (PostIdxReg.isAdd ? "" : "-")
1525        << PostIdxReg.RegNum;
1526     if (PostIdxReg.ShiftTy != ARM_AM::no_shift)
1527       OS << ARM_AM::getShiftOpcStr(PostIdxReg.ShiftTy) << " "
1528          << PostIdxReg.ShiftImm;
1529     OS << ">";
1530     break;
1531   case ProcIFlags: {
1532     OS << "<ARM_PROC::";
1533     unsigned IFlags = getProcIFlags();
1534     for (int i=2; i >= 0; --i)
1535       if (IFlags & (1 << i))
1536         OS << ARM_PROC::IFlagsToString(1 << i);
1537     OS << ">";
1538     break;
1539   }
1540   case Register:
1541     OS << "<register " << getReg() << ">";
1542     break;
1543   case ShifterImmediate:
1544     OS << "<shift " << (ShifterImm.isASR ? "asr" : "lsl")
1545        << " #" << ShifterImm.Imm << ">";
1546     break;
1547   case ShiftedRegister:
1548     OS << "<so_reg_reg "
1549        << RegShiftedReg.SrcReg
1550        << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(RegShiftedReg.ShiftImm))
1551        << ", " << RegShiftedReg.ShiftReg << ", "
1552        << ARM_AM::getSORegOffset(RegShiftedReg.ShiftImm)
1553        << ">";
1554     break;
1555   case ShiftedImmediate:
1556     OS << "<so_reg_imm "
1557        << RegShiftedImm.SrcReg
1558        << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(RegShiftedImm.ShiftImm))
1559        << ", " << ARM_AM::getSORegOffset(RegShiftedImm.ShiftImm)
1560        << ">";
1561     break;
1562   case RotateImmediate:
1563     OS << "<ror " << " #" << (RotImm.Imm * 8) << ">";
1564     break;
1565   case BitfieldDescriptor:
1566     OS << "<bitfield " << "lsb: " << Bitfield.LSB
1567        << ", width: " << Bitfield.Width << ">";
1568     break;
1569   case RegisterList:
1570   case DPRRegisterList:
1571   case SPRRegisterList: {
1572     OS << "<register_list ";
1573
1574     const SmallVectorImpl<unsigned> &RegList = getRegList();
1575     for (SmallVectorImpl<unsigned>::const_iterator
1576            I = RegList.begin(), E = RegList.end(); I != E; ) {
1577       OS << *I;
1578       if (++I < E) OS << ", ";
1579     }
1580
1581     OS << ">";
1582     break;
1583   }
1584   case Token:
1585     OS << "'" << getToken() << "'";
1586     break;
1587   }
1588 }
1589
1590 /// @name Auto-generated Match Functions
1591 /// {
1592
1593 static unsigned MatchRegisterName(StringRef Name);
1594
1595 /// }
1596
1597 bool ARMAsmParser::ParseRegister(unsigned &RegNo,
1598                                  SMLoc &StartLoc, SMLoc &EndLoc) {
1599   RegNo = tryParseRegister();
1600
1601   return (RegNo == (unsigned)-1);
1602 }
1603
1604 /// Try to parse a register name.  The token must be an Identifier when called,
1605 /// and if it is a register name the token is eaten and the register number is
1606 /// returned.  Otherwise return -1.
1607 ///
1608 int ARMAsmParser::tryParseRegister() {
1609   const AsmToken &Tok = Parser.getTok();
1610   if (Tok.isNot(AsmToken::Identifier)) return -1;
1611
1612   // FIXME: Validate register for the current architecture; we have to do
1613   // validation later, so maybe there is no need for this here.
1614   std::string upperCase = Tok.getString().str();
1615   std::string lowerCase = LowercaseString(upperCase);
1616   unsigned RegNum = MatchRegisterName(lowerCase);
1617   if (!RegNum) {
1618     RegNum = StringSwitch<unsigned>(lowerCase)
1619       .Case("r13", ARM::SP)
1620       .Case("r14", ARM::LR)
1621       .Case("r15", ARM::PC)
1622       .Case("ip", ARM::R12)
1623       .Default(0);
1624   }
1625   if (!RegNum) return -1;
1626
1627   Parser.Lex(); // Eat identifier token.
1628   return RegNum;
1629 }
1630
1631 // Try to parse a shifter  (e.g., "lsl <amt>"). On success, return 0.
1632 // If a recoverable error occurs, return 1. If an irrecoverable error
1633 // occurs, return -1. An irrecoverable error is one where tokens have been
1634 // consumed in the process of trying to parse the shifter (i.e., when it is
1635 // indeed a shifter operand, but malformed).
1636 int ARMAsmParser::tryParseShiftRegister(
1637                                SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1638   SMLoc S = Parser.getTok().getLoc();
1639   const AsmToken &Tok = Parser.getTok();
1640   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1641
1642   std::string upperCase = Tok.getString().str();
1643   std::string lowerCase = LowercaseString(upperCase);
1644   ARM_AM::ShiftOpc ShiftTy = StringSwitch<ARM_AM::ShiftOpc>(lowerCase)
1645       .Case("lsl", ARM_AM::lsl)
1646       .Case("lsr", ARM_AM::lsr)
1647       .Case("asr", ARM_AM::asr)
1648       .Case("ror", ARM_AM::ror)
1649       .Case("rrx", ARM_AM::rrx)
1650       .Default(ARM_AM::no_shift);
1651
1652   if (ShiftTy == ARM_AM::no_shift)
1653     return 1;
1654
1655   Parser.Lex(); // Eat the operator.
1656
1657   // The source register for the shift has already been added to the
1658   // operand list, so we need to pop it off and combine it into the shifted
1659   // register operand instead.
1660   OwningPtr<ARMOperand> PrevOp((ARMOperand*)Operands.pop_back_val());
1661   if (!PrevOp->isReg())
1662     return Error(PrevOp->getStartLoc(), "shift must be of a register");
1663   int SrcReg = PrevOp->getReg();
1664   int64_t Imm = 0;
1665   int ShiftReg = 0;
1666   if (ShiftTy == ARM_AM::rrx) {
1667     // RRX Doesn't have an explicit shift amount. The encoder expects
1668     // the shift register to be the same as the source register. Seems odd,
1669     // but OK.
1670     ShiftReg = SrcReg;
1671   } else {
1672     // Figure out if this is shifted by a constant or a register (for non-RRX).
1673     if (Parser.getTok().is(AsmToken::Hash)) {
1674       Parser.Lex(); // Eat hash.
1675       SMLoc ImmLoc = Parser.getTok().getLoc();
1676       const MCExpr *ShiftExpr = 0;
1677       if (getParser().ParseExpression(ShiftExpr)) {
1678         Error(ImmLoc, "invalid immediate shift value");
1679         return -1;
1680       }
1681       // The expression must be evaluatable as an immediate.
1682       const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftExpr);
1683       if (!CE) {
1684         Error(ImmLoc, "invalid immediate shift value");
1685         return -1;
1686       }
1687       // Range check the immediate.
1688       // lsl, ror: 0 <= imm <= 31
1689       // lsr, asr: 0 <= imm <= 32
1690       Imm = CE->getValue();
1691       if (Imm < 0 ||
1692           ((ShiftTy == ARM_AM::lsl || ShiftTy == ARM_AM::ror) && Imm > 31) ||
1693           ((ShiftTy == ARM_AM::lsr || ShiftTy == ARM_AM::asr) && Imm > 32)) {
1694         Error(ImmLoc, "immediate shift value out of range");
1695         return -1;
1696       }
1697     } else if (Parser.getTok().is(AsmToken::Identifier)) {
1698       ShiftReg = tryParseRegister();
1699       SMLoc L = Parser.getTok().getLoc();
1700       if (ShiftReg == -1) {
1701         Error (L, "expected immediate or register in shift operand");
1702         return -1;
1703       }
1704     } else {
1705       Error (Parser.getTok().getLoc(),
1706                     "expected immediate or register in shift operand");
1707       return -1;
1708     }
1709   }
1710
1711   if (ShiftReg && ShiftTy != ARM_AM::rrx)
1712     Operands.push_back(ARMOperand::CreateShiftedRegister(ShiftTy, SrcReg,
1713                                                          ShiftReg, Imm,
1714                                                S, Parser.getTok().getLoc()));
1715   else
1716     Operands.push_back(ARMOperand::CreateShiftedImmediate(ShiftTy, SrcReg, Imm,
1717                                                S, Parser.getTok().getLoc()));
1718
1719   return 0;
1720 }
1721
1722
1723 /// Try to parse a register name.  The token must be an Identifier when called.
1724 /// If it's a register, an AsmOperand is created. Another AsmOperand is created
1725 /// if there is a "writeback". 'true' if it's not a register.
1726 ///
1727 /// TODO this is likely to change to allow different register types and or to
1728 /// parse for a specific register type.
1729 bool ARMAsmParser::
1730 tryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1731   SMLoc S = Parser.getTok().getLoc();
1732   int RegNo = tryParseRegister();
1733   if (RegNo == -1)
1734     return true;
1735
1736   Operands.push_back(ARMOperand::CreateReg(RegNo, S, Parser.getTok().getLoc()));
1737
1738   const AsmToken &ExclaimTok = Parser.getTok();
1739   if (ExclaimTok.is(AsmToken::Exclaim)) {
1740     Operands.push_back(ARMOperand::CreateToken(ExclaimTok.getString(),
1741                                                ExclaimTok.getLoc()));
1742     Parser.Lex(); // Eat exclaim token
1743   }
1744
1745   return false;
1746 }
1747
1748 /// MatchCoprocessorOperandName - Try to parse an coprocessor related
1749 /// instruction with a symbolic operand name. Example: "p1", "p7", "c3",
1750 /// "c5", ...
1751 static int MatchCoprocessorOperandName(StringRef Name, char CoprocOp) {
1752   // Use the same layout as the tablegen'erated register name matcher. Ugly,
1753   // but efficient.
1754   switch (Name.size()) {
1755   default: break;
1756   case 2:
1757     if (Name[0] != CoprocOp)
1758       return -1;
1759     switch (Name[1]) {
1760     default:  return -1;
1761     case '0': return 0;
1762     case '1': return 1;
1763     case '2': return 2;
1764     case '3': return 3;
1765     case '4': return 4;
1766     case '5': return 5;
1767     case '6': return 6;
1768     case '7': return 7;
1769     case '8': return 8;
1770     case '9': return 9;
1771     }
1772     break;
1773   case 3:
1774     if (Name[0] != CoprocOp || Name[1] != '1')
1775       return -1;
1776     switch (Name[2]) {
1777     default:  return -1;
1778     case '0': return 10;
1779     case '1': return 11;
1780     case '2': return 12;
1781     case '3': return 13;
1782     case '4': return 14;
1783     case '5': return 15;
1784     }
1785     break;
1786   }
1787
1788   return -1;
1789 }
1790
1791 /// parseITCondCode - Try to parse a condition code for an IT instruction.
1792 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1793 parseITCondCode(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1794   SMLoc S = Parser.getTok().getLoc();
1795   const AsmToken &Tok = Parser.getTok();
1796   if (!Tok.is(AsmToken::Identifier))
1797     return MatchOperand_NoMatch;
1798   unsigned CC = StringSwitch<unsigned>(Tok.getString())
1799     .Case("eq", ARMCC::EQ)
1800     .Case("ne", ARMCC::NE)
1801     .Case("hs", ARMCC::HS)
1802     .Case("cs", ARMCC::HS)
1803     .Case("lo", ARMCC::LO)
1804     .Case("cc", ARMCC::LO)
1805     .Case("mi", ARMCC::MI)
1806     .Case("pl", ARMCC::PL)
1807     .Case("vs", ARMCC::VS)
1808     .Case("vc", ARMCC::VC)
1809     .Case("hi", ARMCC::HI)
1810     .Case("ls", ARMCC::LS)
1811     .Case("ge", ARMCC::GE)
1812     .Case("lt", ARMCC::LT)
1813     .Case("gt", ARMCC::GT)
1814     .Case("le", ARMCC::LE)
1815     .Case("al", ARMCC::AL)
1816     .Default(~0U);
1817   if (CC == ~0U)
1818     return MatchOperand_NoMatch;
1819   Parser.Lex(); // Eat the token.
1820
1821   Operands.push_back(ARMOperand::CreateCondCode(ARMCC::CondCodes(CC), S));
1822
1823   return MatchOperand_Success;
1824 }
1825
1826 /// parseCoprocNumOperand - Try to parse an coprocessor number operand. The
1827 /// token must be an Identifier when called, and if it is a coprocessor
1828 /// number, the token is eaten and the operand is added to the operand list.
1829 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1830 parseCoprocNumOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1831   SMLoc S = Parser.getTok().getLoc();
1832   const AsmToken &Tok = Parser.getTok();
1833   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1834
1835   int Num = MatchCoprocessorOperandName(Tok.getString(), 'p');
1836   if (Num == -1)
1837     return MatchOperand_NoMatch;
1838
1839   Parser.Lex(); // Eat identifier token.
1840   Operands.push_back(ARMOperand::CreateCoprocNum(Num, S));
1841   return MatchOperand_Success;
1842 }
1843
1844 /// parseCoprocRegOperand - Try to parse an coprocessor register operand. The
1845 /// token must be an Identifier when called, and if it is a coprocessor
1846 /// number, the token is eaten and the operand is added to the operand list.
1847 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1848 parseCoprocRegOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1849   SMLoc S = Parser.getTok().getLoc();
1850   const AsmToken &Tok = Parser.getTok();
1851   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1852
1853   int Reg = MatchCoprocessorOperandName(Tok.getString(), 'c');
1854   if (Reg == -1)
1855     return MatchOperand_NoMatch;
1856
1857   Parser.Lex(); // Eat identifier token.
1858   Operands.push_back(ARMOperand::CreateCoprocReg(Reg, S));
1859   return MatchOperand_Success;
1860 }
1861
1862 /// Parse a register list, return it if successful else return null.  The first
1863 /// token must be a '{' when called.
1864 bool ARMAsmParser::
1865 parseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1866   assert(Parser.getTok().is(AsmToken::LCurly) &&
1867          "Token is not a Left Curly Brace");
1868   SMLoc S = Parser.getTok().getLoc();
1869
1870   // Read the rest of the registers in the list.
1871   unsigned PrevRegNum = 0;
1872   SmallVector<std::pair<unsigned, SMLoc>, 32> Registers;
1873
1874   do {
1875     bool IsRange = Parser.getTok().is(AsmToken::Minus);
1876     Parser.Lex(); // Eat non-identifier token.
1877
1878     const AsmToken &RegTok = Parser.getTok();
1879     SMLoc RegLoc = RegTok.getLoc();
1880     if (RegTok.isNot(AsmToken::Identifier)) {
1881       Error(RegLoc, "register expected");
1882       return true;
1883     }
1884
1885     int RegNum = tryParseRegister();
1886     if (RegNum == -1) {
1887       Error(RegLoc, "register expected");
1888       return true;
1889     }
1890
1891     if (IsRange) {
1892       int Reg = PrevRegNum;
1893       do {
1894         ++Reg;
1895         Registers.push_back(std::make_pair(Reg, RegLoc));
1896       } while (Reg != RegNum);
1897     } else {
1898       Registers.push_back(std::make_pair(RegNum, RegLoc));
1899     }
1900
1901     PrevRegNum = RegNum;
1902   } while (Parser.getTok().is(AsmToken::Comma) ||
1903            Parser.getTok().is(AsmToken::Minus));
1904
1905   // Process the right curly brace of the list.
1906   const AsmToken &RCurlyTok = Parser.getTok();
1907   if (RCurlyTok.isNot(AsmToken::RCurly)) {
1908     Error(RCurlyTok.getLoc(), "'}' expected");
1909     return true;
1910   }
1911
1912   SMLoc E = RCurlyTok.getLoc();
1913   Parser.Lex(); // Eat right curly brace token.
1914
1915   // Verify the register list.
1916   bool EmittedWarning = false;
1917   unsigned HighRegNum = 0;
1918   BitVector RegMap(32);
1919   for (unsigned i = 0, e = Registers.size(); i != e; ++i) {
1920     const std::pair<unsigned, SMLoc> &RegInfo = Registers[i];
1921     unsigned Reg = getARMRegisterNumbering(RegInfo.first);
1922
1923     if (RegMap[Reg]) {
1924       Error(RegInfo.second, "register duplicated in register list");
1925       return true;
1926     }
1927
1928     if (!EmittedWarning && Reg < HighRegNum)
1929       Warning(RegInfo.second,
1930               "register not in ascending order in register list");
1931
1932     RegMap.set(Reg);
1933     HighRegNum = std::max(Reg, HighRegNum);
1934   }
1935
1936   Operands.push_back(ARMOperand::CreateRegList(Registers, S, E));
1937   return false;
1938 }
1939
1940 /// parseMemBarrierOptOperand - Try to parse DSB/DMB data barrier options.
1941 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1942 parseMemBarrierOptOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1943   SMLoc S = Parser.getTok().getLoc();
1944   const AsmToken &Tok = Parser.getTok();
1945   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1946   StringRef OptStr = Tok.getString();
1947
1948   unsigned Opt = StringSwitch<unsigned>(OptStr.slice(0, OptStr.size()))
1949     .Case("sy",    ARM_MB::SY)
1950     .Case("st",    ARM_MB::ST)
1951     .Case("sh",    ARM_MB::ISH)
1952     .Case("ish",   ARM_MB::ISH)
1953     .Case("shst",  ARM_MB::ISHST)
1954     .Case("ishst", ARM_MB::ISHST)
1955     .Case("nsh",   ARM_MB::NSH)
1956     .Case("un",    ARM_MB::NSH)
1957     .Case("nshst", ARM_MB::NSHST)
1958     .Case("unst",  ARM_MB::NSHST)
1959     .Case("osh",   ARM_MB::OSH)
1960     .Case("oshst", ARM_MB::OSHST)
1961     .Default(~0U);
1962
1963   if (Opt == ~0U)
1964     return MatchOperand_NoMatch;
1965
1966   Parser.Lex(); // Eat identifier token.
1967   Operands.push_back(ARMOperand::CreateMemBarrierOpt((ARM_MB::MemBOpt)Opt, S));
1968   return MatchOperand_Success;
1969 }
1970
1971 /// parseProcIFlagsOperand - Try to parse iflags from CPS instruction.
1972 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1973 parseProcIFlagsOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1974   SMLoc S = Parser.getTok().getLoc();
1975   const AsmToken &Tok = Parser.getTok();
1976   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1977   StringRef IFlagsStr = Tok.getString();
1978
1979   unsigned IFlags = 0;
1980   for (int i = 0, e = IFlagsStr.size(); i != e; ++i) {
1981     unsigned Flag = StringSwitch<unsigned>(IFlagsStr.substr(i, 1))
1982     .Case("a", ARM_PROC::A)
1983     .Case("i", ARM_PROC::I)
1984     .Case("f", ARM_PROC::F)
1985     .Default(~0U);
1986
1987     // If some specific iflag is already set, it means that some letter is
1988     // present more than once, this is not acceptable.
1989     if (Flag == ~0U || (IFlags & Flag))
1990       return MatchOperand_NoMatch;
1991
1992     IFlags |= Flag;
1993   }
1994
1995   Parser.Lex(); // Eat identifier token.
1996   Operands.push_back(ARMOperand::CreateProcIFlags((ARM_PROC::IFlags)IFlags, S));
1997   return MatchOperand_Success;
1998 }
1999
2000 /// parseMSRMaskOperand - Try to parse mask flags from MSR instruction.
2001 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2002 parseMSRMaskOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2003   SMLoc S = Parser.getTok().getLoc();
2004   const AsmToken &Tok = Parser.getTok();
2005   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
2006   StringRef Mask = Tok.getString();
2007
2008   // Split spec_reg from flag, example: CPSR_sxf => "CPSR" and "sxf"
2009   size_t Start = 0, Next = Mask.find('_');
2010   StringRef Flags = "";
2011   std::string SpecReg = LowercaseString(Mask.slice(Start, Next));
2012   if (Next != StringRef::npos)
2013     Flags = Mask.slice(Next+1, Mask.size());
2014
2015   // FlagsVal contains the complete mask:
2016   // 3-0: Mask
2017   // 4: Special Reg (cpsr, apsr => 0; spsr => 1)
2018   unsigned FlagsVal = 0;
2019
2020   if (SpecReg == "apsr") {
2021     FlagsVal = StringSwitch<unsigned>(Flags)
2022     .Case("nzcvq",  0x8) // same as CPSR_f
2023     .Case("g",      0x4) // same as CPSR_s
2024     .Case("nzcvqg", 0xc) // same as CPSR_fs
2025     .Default(~0U);
2026
2027     if (FlagsVal == ~0U) {
2028       if (!Flags.empty())
2029         return MatchOperand_NoMatch;
2030       else
2031         FlagsVal = 0; // No flag
2032     }
2033   } else if (SpecReg == "cpsr" || SpecReg == "spsr") {
2034     if (Flags == "all") // cpsr_all is an alias for cpsr_fc
2035       Flags = "fc";
2036     for (int i = 0, e = Flags.size(); i != e; ++i) {
2037       unsigned Flag = StringSwitch<unsigned>(Flags.substr(i, 1))
2038       .Case("c", 1)
2039       .Case("x", 2)
2040       .Case("s", 4)
2041       .Case("f", 8)
2042       .Default(~0U);
2043
2044       // If some specific flag is already set, it means that some letter is
2045       // present more than once, this is not acceptable.
2046       if (FlagsVal == ~0U || (FlagsVal & Flag))
2047         return MatchOperand_NoMatch;
2048       FlagsVal |= Flag;
2049     }
2050   } else // No match for special register.
2051     return MatchOperand_NoMatch;
2052
2053   // Special register without flags are equivalent to "fc" flags.
2054   if (!FlagsVal)
2055     FlagsVal = 0x9;
2056
2057   // Bit 4: Special Reg (cpsr, apsr => 0; spsr => 1)
2058   if (SpecReg == "spsr")
2059     FlagsVal |= 16;
2060
2061   Parser.Lex(); // Eat identifier token.
2062   Operands.push_back(ARMOperand::CreateMSRMask(FlagsVal, S));
2063   return MatchOperand_Success;
2064 }
2065
2066 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2067 parsePKHImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands, StringRef Op,
2068             int Low, int High) {
2069   const AsmToken &Tok = Parser.getTok();
2070   if (Tok.isNot(AsmToken::Identifier)) {
2071     Error(Parser.getTok().getLoc(), Op + " operand expected.");
2072     return MatchOperand_ParseFail;
2073   }
2074   StringRef ShiftName = Tok.getString();
2075   std::string LowerOp = LowercaseString(Op);
2076   std::string UpperOp = UppercaseString(Op);
2077   if (ShiftName != LowerOp && ShiftName != UpperOp) {
2078     Error(Parser.getTok().getLoc(), Op + " operand expected.");
2079     return MatchOperand_ParseFail;
2080   }
2081   Parser.Lex(); // Eat shift type token.
2082
2083   // There must be a '#' and a shift amount.
2084   if (Parser.getTok().isNot(AsmToken::Hash)) {
2085     Error(Parser.getTok().getLoc(), "'#' expected");
2086     return MatchOperand_ParseFail;
2087   }
2088   Parser.Lex(); // Eat hash token.
2089
2090   const MCExpr *ShiftAmount;
2091   SMLoc Loc = Parser.getTok().getLoc();
2092   if (getParser().ParseExpression(ShiftAmount)) {
2093     Error(Loc, "illegal expression");
2094     return MatchOperand_ParseFail;
2095   }
2096   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount);
2097   if (!CE) {
2098     Error(Loc, "constant expression expected");
2099     return MatchOperand_ParseFail;
2100   }
2101   int Val = CE->getValue();
2102   if (Val < Low || Val > High) {
2103     Error(Loc, "immediate value out of range");
2104     return MatchOperand_ParseFail;
2105   }
2106
2107   Operands.push_back(ARMOperand::CreateImm(CE, Loc, Parser.getTok().getLoc()));
2108
2109   return MatchOperand_Success;
2110 }
2111
2112 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2113 parseSetEndImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2114   const AsmToken &Tok = Parser.getTok();
2115   SMLoc S = Tok.getLoc();
2116   if (Tok.isNot(AsmToken::Identifier)) {
2117     Error(Tok.getLoc(), "'be' or 'le' operand expected");
2118     return MatchOperand_ParseFail;
2119   }
2120   int Val = StringSwitch<int>(Tok.getString())
2121     .Case("be", 1)
2122     .Case("le", 0)
2123     .Default(-1);
2124   Parser.Lex(); // Eat the token.
2125
2126   if (Val == -1) {
2127     Error(Tok.getLoc(), "'be' or 'le' operand expected");
2128     return MatchOperand_ParseFail;
2129   }
2130   Operands.push_back(ARMOperand::CreateImm(MCConstantExpr::Create(Val,
2131                                                                   getContext()),
2132                                            S, Parser.getTok().getLoc()));
2133   return MatchOperand_Success;
2134 }
2135
2136 /// parseShifterImm - Parse the shifter immediate operand for SSAT/USAT
2137 /// instructions. Legal values are:
2138 ///     lsl #n  'n' in [0,31]
2139 ///     asr #n  'n' in [1,32]
2140 ///             n == 32 encoded as n == 0.
2141 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2142 parseShifterImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2143   const AsmToken &Tok = Parser.getTok();
2144   SMLoc S = Tok.getLoc();
2145   if (Tok.isNot(AsmToken::Identifier)) {
2146     Error(S, "shift operator 'asr' or 'lsl' expected");
2147     return MatchOperand_ParseFail;
2148   }
2149   StringRef ShiftName = Tok.getString();
2150   bool isASR;
2151   if (ShiftName == "lsl" || ShiftName == "LSL")
2152     isASR = false;
2153   else if (ShiftName == "asr" || ShiftName == "ASR")
2154     isASR = true;
2155   else {
2156     Error(S, "shift operator 'asr' or 'lsl' expected");
2157     return MatchOperand_ParseFail;
2158   }
2159   Parser.Lex(); // Eat the operator.
2160
2161   // A '#' and a shift amount.
2162   if (Parser.getTok().isNot(AsmToken::Hash)) {
2163     Error(Parser.getTok().getLoc(), "'#' expected");
2164     return MatchOperand_ParseFail;
2165   }
2166   Parser.Lex(); // Eat hash token.
2167
2168   const MCExpr *ShiftAmount;
2169   SMLoc E = Parser.getTok().getLoc();
2170   if (getParser().ParseExpression(ShiftAmount)) {
2171     Error(E, "malformed shift expression");
2172     return MatchOperand_ParseFail;
2173   }
2174   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount);
2175   if (!CE) {
2176     Error(E, "shift amount must be an immediate");
2177     return MatchOperand_ParseFail;
2178   }
2179
2180   int64_t Val = CE->getValue();
2181   if (isASR) {
2182     // Shift amount must be in [1,32]
2183     if (Val < 1 || Val > 32) {
2184       Error(E, "'asr' shift amount must be in range [1,32]");
2185       return MatchOperand_ParseFail;
2186     }
2187     // asr #32 encoded as asr #0.
2188     if (Val == 32) Val = 0;
2189   } else {
2190     // Shift amount must be in [1,32]
2191     if (Val < 0 || Val > 31) {
2192       Error(E, "'lsr' shift amount must be in range [0,31]");
2193       return MatchOperand_ParseFail;
2194     }
2195   }
2196
2197   E = Parser.getTok().getLoc();
2198   Operands.push_back(ARMOperand::CreateShifterImm(isASR, Val, S, E));
2199
2200   return MatchOperand_Success;
2201 }
2202
2203 /// parseRotImm - Parse the shifter immediate operand for SXTB/UXTB family
2204 /// of instructions. Legal values are:
2205 ///     ror #n  'n' in {0, 8, 16, 24}
2206 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2207 parseRotImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2208   const AsmToken &Tok = Parser.getTok();
2209   SMLoc S = Tok.getLoc();
2210   if (Tok.isNot(AsmToken::Identifier)) {
2211     Error(S, "rotate operator 'ror' expected");
2212     return MatchOperand_ParseFail;
2213   }
2214   StringRef ShiftName = Tok.getString();
2215   if (ShiftName != "ror" && ShiftName != "ROR") {
2216     Error(S, "rotate operator 'ror' expected");
2217     return MatchOperand_ParseFail;
2218   }
2219   Parser.Lex(); // Eat the operator.
2220
2221   // A '#' and a rotate amount.
2222   if (Parser.getTok().isNot(AsmToken::Hash)) {
2223     Error(Parser.getTok().getLoc(), "'#' expected");
2224     return MatchOperand_ParseFail;
2225   }
2226   Parser.Lex(); // Eat hash token.
2227
2228   const MCExpr *ShiftAmount;
2229   SMLoc E = Parser.getTok().getLoc();
2230   if (getParser().ParseExpression(ShiftAmount)) {
2231     Error(E, "malformed rotate expression");
2232     return MatchOperand_ParseFail;
2233   }
2234   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount);
2235   if (!CE) {
2236     Error(E, "rotate amount must be an immediate");
2237     return MatchOperand_ParseFail;
2238   }
2239
2240   int64_t Val = CE->getValue();
2241   // Shift amount must be in {0, 8, 16, 24} (0 is undocumented extension)
2242   // normally, zero is represented in asm by omitting the rotate operand
2243   // entirely.
2244   if (Val != 8 && Val != 16 && Val != 24 && Val != 0) {
2245     Error(E, "'ror' rotate amount must be 8, 16, or 24");
2246     return MatchOperand_ParseFail;
2247   }
2248
2249   E = Parser.getTok().getLoc();
2250   Operands.push_back(ARMOperand::CreateRotImm(Val, S, E));
2251
2252   return MatchOperand_Success;
2253 }
2254
2255 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2256 parseBitfield(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2257   SMLoc S = Parser.getTok().getLoc();
2258   // The bitfield descriptor is really two operands, the LSB and the width.
2259   if (Parser.getTok().isNot(AsmToken::Hash)) {
2260     Error(Parser.getTok().getLoc(), "'#' expected");
2261     return MatchOperand_ParseFail;
2262   }
2263   Parser.Lex(); // Eat hash token.
2264
2265   const MCExpr *LSBExpr;
2266   SMLoc E = Parser.getTok().getLoc();
2267   if (getParser().ParseExpression(LSBExpr)) {
2268     Error(E, "malformed immediate expression");
2269     return MatchOperand_ParseFail;
2270   }
2271   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(LSBExpr);
2272   if (!CE) {
2273     Error(E, "'lsb' operand must be an immediate");
2274     return MatchOperand_ParseFail;
2275   }
2276
2277   int64_t LSB = CE->getValue();
2278   // The LSB must be in the range [0,31]
2279   if (LSB < 0 || LSB > 31) {
2280     Error(E, "'lsb' operand must be in the range [0,31]");
2281     return MatchOperand_ParseFail;
2282   }
2283   E = Parser.getTok().getLoc();
2284
2285   // Expect another immediate operand.
2286   if (Parser.getTok().isNot(AsmToken::Comma)) {
2287     Error(Parser.getTok().getLoc(), "too few operands");
2288     return MatchOperand_ParseFail;
2289   }
2290   Parser.Lex(); // Eat hash token.
2291   if (Parser.getTok().isNot(AsmToken::Hash)) {
2292     Error(Parser.getTok().getLoc(), "'#' expected");
2293     return MatchOperand_ParseFail;
2294   }
2295   Parser.Lex(); // Eat hash token.
2296
2297   const MCExpr *WidthExpr;
2298   if (getParser().ParseExpression(WidthExpr)) {
2299     Error(E, "malformed immediate expression");
2300     return MatchOperand_ParseFail;
2301   }
2302   CE = dyn_cast<MCConstantExpr>(WidthExpr);
2303   if (!CE) {
2304     Error(E, "'width' operand must be an immediate");
2305     return MatchOperand_ParseFail;
2306   }
2307
2308   int64_t Width = CE->getValue();
2309   // The LSB must be in the range [1,32-lsb]
2310   if (Width < 1 || Width > 32 - LSB) {
2311     Error(E, "'width' operand must be in the range [1,32-lsb]");
2312     return MatchOperand_ParseFail;
2313   }
2314   E = Parser.getTok().getLoc();
2315
2316   Operands.push_back(ARMOperand::CreateBitfield(LSB, Width, S, E));
2317
2318   return MatchOperand_Success;
2319 }
2320
2321 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2322 parsePostIdxReg(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2323   // Check for a post-index addressing register operand. Specifically:
2324   // postidx_reg := '+' register {, shift}
2325   //              | '-' register {, shift}
2326   //              | register {, shift}
2327
2328   // This method must return MatchOperand_NoMatch without consuming any tokens
2329   // in the case where there is no match, as other alternatives take other
2330   // parse methods.
2331   AsmToken Tok = Parser.getTok();
2332   SMLoc S = Tok.getLoc();
2333   bool haveEaten = false;
2334   bool isAdd = true;
2335   int Reg = -1;
2336   if (Tok.is(AsmToken::Plus)) {
2337     Parser.Lex(); // Eat the '+' token.
2338     haveEaten = true;
2339   } else if (Tok.is(AsmToken::Minus)) {
2340     Parser.Lex(); // Eat the '-' token.
2341     isAdd = false;
2342     haveEaten = true;
2343   }
2344   if (Parser.getTok().is(AsmToken::Identifier))
2345     Reg = tryParseRegister();
2346   if (Reg == -1) {
2347     if (!haveEaten)
2348       return MatchOperand_NoMatch;
2349     Error(Parser.getTok().getLoc(), "register expected");
2350     return MatchOperand_ParseFail;
2351   }
2352   SMLoc E = Parser.getTok().getLoc();
2353
2354   ARM_AM::ShiftOpc ShiftTy = ARM_AM::no_shift;
2355   unsigned ShiftImm = 0;
2356   if (Parser.getTok().is(AsmToken::Comma)) {
2357     Parser.Lex(); // Eat the ','.
2358     if (parseMemRegOffsetShift(ShiftTy, ShiftImm))
2359       return MatchOperand_ParseFail;
2360   }
2361
2362   Operands.push_back(ARMOperand::CreatePostIdxReg(Reg, isAdd, ShiftTy,
2363                                                   ShiftImm, S, E));
2364
2365   return MatchOperand_Success;
2366 }
2367
2368 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2369 parseAM3Offset(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2370   // Check for a post-index addressing register operand. Specifically:
2371   // am3offset := '+' register
2372   //              | '-' register
2373   //              | register
2374   //              | # imm
2375   //              | # + imm
2376   //              | # - imm
2377
2378   // This method must return MatchOperand_NoMatch without consuming any tokens
2379   // in the case where there is no match, as other alternatives take other
2380   // parse methods.
2381   AsmToken Tok = Parser.getTok();
2382   SMLoc S = Tok.getLoc();
2383
2384   // Do immediates first, as we always parse those if we have a '#'.
2385   if (Parser.getTok().is(AsmToken::Hash)) {
2386     Parser.Lex(); // Eat the '#'.
2387     // Explicitly look for a '-', as we need to encode negative zero
2388     // differently.
2389     bool isNegative = Parser.getTok().is(AsmToken::Minus);
2390     const MCExpr *Offset;
2391     if (getParser().ParseExpression(Offset))
2392       return MatchOperand_ParseFail;
2393     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Offset);
2394     if (!CE) {
2395       Error(S, "constant expression expected");
2396       return MatchOperand_ParseFail;
2397     }
2398     SMLoc E = Tok.getLoc();
2399     // Negative zero is encoded as the flag value INT32_MIN.
2400     int32_t Val = CE->getValue();
2401     if (isNegative && Val == 0)
2402       Val = INT32_MIN;
2403
2404     Operands.push_back(
2405       ARMOperand::CreateImm(MCConstantExpr::Create(Val, getContext()), S, E));
2406
2407     return MatchOperand_Success;
2408   }
2409
2410
2411   bool haveEaten = false;
2412   bool isAdd = true;
2413   int Reg = -1;
2414   if (Tok.is(AsmToken::Plus)) {
2415     Parser.Lex(); // Eat the '+' token.
2416     haveEaten = true;
2417   } else if (Tok.is(AsmToken::Minus)) {
2418     Parser.Lex(); // Eat the '-' token.
2419     isAdd = false;
2420     haveEaten = true;
2421   }
2422   if (Parser.getTok().is(AsmToken::Identifier))
2423     Reg = tryParseRegister();
2424   if (Reg == -1) {
2425     if (!haveEaten)
2426       return MatchOperand_NoMatch;
2427     Error(Parser.getTok().getLoc(), "register expected");
2428     return MatchOperand_ParseFail;
2429   }
2430   SMLoc E = Parser.getTok().getLoc();
2431
2432   Operands.push_back(ARMOperand::CreatePostIdxReg(Reg, isAdd, ARM_AM::no_shift,
2433                                                   0, S, E));
2434
2435   return MatchOperand_Success;
2436 }
2437
2438 /// cvtT2LdrdPre - Convert parsed operands to MCInst.
2439 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2440 /// when they refer multiple MIOperands inside a single one.
2441 bool ARMAsmParser::
2442 cvtT2LdrdPre(MCInst &Inst, unsigned Opcode,
2443              const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2444   // Rt, Rt2
2445   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2446   ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
2447   // Create a writeback register dummy placeholder.
2448   Inst.addOperand(MCOperand::CreateReg(0));
2449   // addr
2450   ((ARMOperand*)Operands[4])->addMemImm8s4OffsetOperands(Inst, 2);
2451   // pred
2452   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2453   return true;
2454 }
2455
2456 /// cvtT2StrdPre - Convert parsed operands to MCInst.
2457 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2458 /// when they refer multiple MIOperands inside a single one.
2459 bool ARMAsmParser::
2460 cvtT2StrdPre(MCInst &Inst, unsigned Opcode,
2461              const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2462   // Create a writeback register dummy placeholder.
2463   Inst.addOperand(MCOperand::CreateReg(0));
2464   // Rt, Rt2
2465   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2466   ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
2467   // addr
2468   ((ARMOperand*)Operands[4])->addMemImm8s4OffsetOperands(Inst, 2);
2469   // pred
2470   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2471   return true;
2472 }
2473
2474 /// cvtLdWriteBackRegT2AddrModeImm8 - Convert parsed operands to MCInst.
2475 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2476 /// when they refer multiple MIOperands inside a single one.
2477 bool ARMAsmParser::
2478 cvtLdWriteBackRegT2AddrModeImm8(MCInst &Inst, unsigned Opcode,
2479                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2480   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2481
2482   // Create a writeback register dummy placeholder.
2483   Inst.addOperand(MCOperand::CreateImm(0));
2484
2485   ((ARMOperand*)Operands[3])->addMemImm8OffsetOperands(Inst, 2);
2486   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2487   return true;
2488 }
2489
2490 /// cvtLdWriteBackRegAddrMode2 - Convert parsed operands to MCInst.
2491 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2492 /// when they refer multiple MIOperands inside a single one.
2493 bool ARMAsmParser::
2494 cvtLdWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
2495                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2496   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2497
2498   // Create a writeback register dummy placeholder.
2499   Inst.addOperand(MCOperand::CreateImm(0));
2500
2501   ((ARMOperand*)Operands[3])->addAddrMode2Operands(Inst, 3);
2502   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2503   return true;
2504 }
2505
2506 /// cvtLdWriteBackRegAddrModeImm12 - Convert parsed operands to MCInst.
2507 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2508 /// when they refer multiple MIOperands inside a single one.
2509 bool ARMAsmParser::
2510 cvtLdWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
2511                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2512   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2513
2514   // Create a writeback register dummy placeholder.
2515   Inst.addOperand(MCOperand::CreateImm(0));
2516
2517   ((ARMOperand*)Operands[3])->addMemImm12OffsetOperands(Inst, 2);
2518   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2519   return true;
2520 }
2521
2522
2523 /// cvtStWriteBackRegAddrModeImm12 - Convert parsed operands to MCInst.
2524 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2525 /// when they refer multiple MIOperands inside a single one.
2526 bool ARMAsmParser::
2527 cvtStWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
2528                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2529   // Create a writeback register dummy placeholder.
2530   Inst.addOperand(MCOperand::CreateImm(0));
2531   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2532   ((ARMOperand*)Operands[3])->addMemImm12OffsetOperands(Inst, 2);
2533   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2534   return true;
2535 }
2536
2537 /// cvtStWriteBackRegAddrMode2 - Convert parsed operands to MCInst.
2538 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2539 /// when they refer multiple MIOperands inside a single one.
2540 bool ARMAsmParser::
2541 cvtStWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
2542                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2543   // Create a writeback register dummy placeholder.
2544   Inst.addOperand(MCOperand::CreateImm(0));
2545   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2546   ((ARMOperand*)Operands[3])->addAddrMode2Operands(Inst, 3);
2547   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2548   return true;
2549 }
2550
2551 /// cvtStWriteBackRegAddrMode3 - Convert parsed operands to MCInst.
2552 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2553 /// when they refer multiple MIOperands inside a single one.
2554 bool ARMAsmParser::
2555 cvtStWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
2556                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2557   // Create a writeback register dummy placeholder.
2558   Inst.addOperand(MCOperand::CreateImm(0));
2559   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2560   ((ARMOperand*)Operands[3])->addAddrMode3Operands(Inst, 3);
2561   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2562   return true;
2563 }
2564
2565 /// cvtLdExtTWriteBackImm - Convert parsed operands to MCInst.
2566 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2567 /// when they refer multiple MIOperands inside a single one.
2568 bool ARMAsmParser::
2569 cvtLdExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
2570                       const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2571   // Rt
2572   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2573   // Create a writeback register dummy placeholder.
2574   Inst.addOperand(MCOperand::CreateImm(0));
2575   // addr
2576   ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
2577   // offset
2578   ((ARMOperand*)Operands[4])->addPostIdxImm8Operands(Inst, 1);
2579   // pred
2580   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2581   return true;
2582 }
2583
2584 /// cvtLdExtTWriteBackReg - Convert parsed operands to MCInst.
2585 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2586 /// when they refer multiple MIOperands inside a single one.
2587 bool ARMAsmParser::
2588 cvtLdExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
2589                       const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2590   // Rt
2591   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2592   // Create a writeback register dummy placeholder.
2593   Inst.addOperand(MCOperand::CreateImm(0));
2594   // addr
2595   ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
2596   // offset
2597   ((ARMOperand*)Operands[4])->addPostIdxRegOperands(Inst, 2);
2598   // pred
2599   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2600   return true;
2601 }
2602
2603 /// cvtStExtTWriteBackImm - Convert parsed operands to MCInst.
2604 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2605 /// when they refer multiple MIOperands inside a single one.
2606 bool ARMAsmParser::
2607 cvtStExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
2608                       const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2609   // Create a writeback register dummy placeholder.
2610   Inst.addOperand(MCOperand::CreateImm(0));
2611   // Rt
2612   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2613   // addr
2614   ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
2615   // offset
2616   ((ARMOperand*)Operands[4])->addPostIdxImm8Operands(Inst, 1);
2617   // pred
2618   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2619   return true;
2620 }
2621
2622 /// cvtStExtTWriteBackReg - Convert parsed operands to MCInst.
2623 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2624 /// when they refer multiple MIOperands inside a single one.
2625 bool ARMAsmParser::
2626 cvtStExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
2627                       const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2628   // Create a writeback register dummy placeholder.
2629   Inst.addOperand(MCOperand::CreateImm(0));
2630   // Rt
2631   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2632   // addr
2633   ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
2634   // offset
2635   ((ARMOperand*)Operands[4])->addPostIdxRegOperands(Inst, 2);
2636   // pred
2637   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2638   return true;
2639 }
2640
2641 /// cvtLdrdPre - Convert parsed operands to MCInst.
2642 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2643 /// when they refer multiple MIOperands inside a single one.
2644 bool ARMAsmParser::
2645 cvtLdrdPre(MCInst &Inst, unsigned Opcode,
2646            const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2647   // Rt, Rt2
2648   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2649   ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
2650   // Create a writeback register dummy placeholder.
2651   Inst.addOperand(MCOperand::CreateImm(0));
2652   // addr
2653   ((ARMOperand*)Operands[4])->addAddrMode3Operands(Inst, 3);
2654   // pred
2655   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2656   return true;
2657 }
2658
2659 /// cvtStrdPre - Convert parsed operands to MCInst.
2660 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2661 /// when they refer multiple MIOperands inside a single one.
2662 bool ARMAsmParser::
2663 cvtStrdPre(MCInst &Inst, unsigned Opcode,
2664            const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2665   // Create a writeback register dummy placeholder.
2666   Inst.addOperand(MCOperand::CreateImm(0));
2667   // Rt, Rt2
2668   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2669   ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
2670   // addr
2671   ((ARMOperand*)Operands[4])->addAddrMode3Operands(Inst, 3);
2672   // pred
2673   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2674   return true;
2675 }
2676
2677 /// cvtLdWriteBackRegAddrMode3 - Convert parsed operands to MCInst.
2678 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2679 /// when they refer multiple MIOperands inside a single one.
2680 bool ARMAsmParser::
2681 cvtLdWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
2682                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2683   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2684   // Create a writeback register dummy placeholder.
2685   Inst.addOperand(MCOperand::CreateImm(0));
2686   ((ARMOperand*)Operands[3])->addAddrMode3Operands(Inst, 3);
2687   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2688   return true;
2689 }
2690
2691 /// cvtThumbMultiple- Convert parsed operands to MCInst.
2692 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2693 /// when they refer multiple MIOperands inside a single one.
2694 bool ARMAsmParser::
2695 cvtThumbMultiply(MCInst &Inst, unsigned Opcode,
2696            const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2697   // The second source operand must be the same register as the destination
2698   // operand.
2699   if (Operands.size() == 6 &&
2700       (((ARMOperand*)Operands[3])->getReg() !=
2701        ((ARMOperand*)Operands[5])->getReg()) &&
2702       (((ARMOperand*)Operands[3])->getReg() !=
2703        ((ARMOperand*)Operands[4])->getReg())) {
2704     Error(Operands[3]->getStartLoc(),
2705           "destination register must match source register");
2706     return false;
2707   }
2708   ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
2709   ((ARMOperand*)Operands[1])->addCCOutOperands(Inst, 1);
2710   ((ARMOperand*)Operands[4])->addRegOperands(Inst, 1);
2711   // If we have a three-operand form, use that, else the second source operand
2712   // is just the destination operand again.
2713   if (Operands.size() == 6)
2714     ((ARMOperand*)Operands[5])->addRegOperands(Inst, 1);
2715   else
2716     Inst.addOperand(Inst.getOperand(0));
2717   ((ARMOperand*)Operands[2])->addCondCodeOperands(Inst, 2);
2718
2719   return true;
2720 }
2721
2722 /// Parse an ARM memory expression, return false if successful else return true
2723 /// or an error.  The first token must be a '[' when called.
2724 bool ARMAsmParser::
2725 parseMemory(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2726   SMLoc S, E;
2727   assert(Parser.getTok().is(AsmToken::LBrac) &&
2728          "Token is not a Left Bracket");
2729   S = Parser.getTok().getLoc();
2730   Parser.Lex(); // Eat left bracket token.
2731
2732   const AsmToken &BaseRegTok = Parser.getTok();
2733   int BaseRegNum = tryParseRegister();
2734   if (BaseRegNum == -1)
2735     return Error(BaseRegTok.getLoc(), "register expected");
2736
2737   // The next token must either be a comma or a closing bracket.
2738   const AsmToken &Tok = Parser.getTok();
2739   if (!Tok.is(AsmToken::Comma) && !Tok.is(AsmToken::RBrac))
2740     return Error(Tok.getLoc(), "malformed memory operand");
2741
2742   if (Tok.is(AsmToken::RBrac)) {
2743     E = Tok.getLoc();
2744     Parser.Lex(); // Eat right bracket token.
2745
2746     Operands.push_back(ARMOperand::CreateMem(BaseRegNum, 0, 0, ARM_AM::no_shift,
2747                                              0, false, S, E));
2748
2749     return false;
2750   }
2751
2752   assert(Tok.is(AsmToken::Comma) && "Lost comma in memory operand?!");
2753   Parser.Lex(); // Eat the comma.
2754
2755   // If we have a '#' it's an immediate offset, else assume it's a register
2756   // offset.
2757   if (Parser.getTok().is(AsmToken::Hash)) {
2758     Parser.Lex(); // Eat the '#'.
2759     E = Parser.getTok().getLoc();
2760
2761     bool isNegative = getParser().getTok().is(AsmToken::Minus);
2762     const MCExpr *Offset;
2763     if (getParser().ParseExpression(Offset))
2764      return true;
2765
2766     // The expression has to be a constant. Memory references with relocations
2767     // don't come through here, as they use the <label> forms of the relevant
2768     // instructions.
2769     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Offset);
2770     if (!CE)
2771       return Error (E, "constant expression expected");
2772
2773     // If the constant was #-0, represent it as INT32_MIN.
2774     int32_t Val = CE->getValue();
2775     if (isNegative && Val == 0)
2776       CE = MCConstantExpr::Create(INT32_MIN, getContext());
2777
2778     // Now we should have the closing ']'
2779     E = Parser.getTok().getLoc();
2780     if (Parser.getTok().isNot(AsmToken::RBrac))
2781       return Error(E, "']' expected");
2782     Parser.Lex(); // Eat right bracket token.
2783
2784     // Don't worry about range checking the value here. That's handled by
2785     // the is*() predicates.
2786     Operands.push_back(ARMOperand::CreateMem(BaseRegNum, CE, 0,
2787                                              ARM_AM::no_shift, 0, false, S,E));
2788
2789     // If there's a pre-indexing writeback marker, '!', just add it as a token
2790     // operand.
2791     if (Parser.getTok().is(AsmToken::Exclaim)) {
2792       Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc()));
2793       Parser.Lex(); // Eat the '!'.
2794     }
2795
2796     return false;
2797   }
2798
2799   // The register offset is optionally preceded by a '+' or '-'
2800   bool isNegative = false;
2801   if (Parser.getTok().is(AsmToken::Minus)) {
2802     isNegative = true;
2803     Parser.Lex(); // Eat the '-'.
2804   } else if (Parser.getTok().is(AsmToken::Plus)) {
2805     // Nothing to do.
2806     Parser.Lex(); // Eat the '+'.
2807   }
2808
2809   E = Parser.getTok().getLoc();
2810   int OffsetRegNum = tryParseRegister();
2811   if (OffsetRegNum == -1)
2812     return Error(E, "register expected");
2813
2814   // If there's a shift operator, handle it.
2815   ARM_AM::ShiftOpc ShiftType = ARM_AM::no_shift;
2816   unsigned ShiftImm = 0;
2817   if (Parser.getTok().is(AsmToken::Comma)) {
2818     Parser.Lex(); // Eat the ','.
2819     if (parseMemRegOffsetShift(ShiftType, ShiftImm))
2820       return true;
2821   }
2822
2823   // Now we should have the closing ']'
2824   E = Parser.getTok().getLoc();
2825   if (Parser.getTok().isNot(AsmToken::RBrac))
2826     return Error(E, "']' expected");
2827   Parser.Lex(); // Eat right bracket token.
2828
2829   Operands.push_back(ARMOperand::CreateMem(BaseRegNum, 0, OffsetRegNum,
2830                                            ShiftType, ShiftImm, isNegative,
2831                                            S, E));
2832
2833   // If there's a pre-indexing writeback marker, '!', just add it as a token
2834   // operand.
2835   if (Parser.getTok().is(AsmToken::Exclaim)) {
2836     Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc()));
2837     Parser.Lex(); // Eat the '!'.
2838   }
2839
2840   return false;
2841 }
2842
2843 /// parseMemRegOffsetShift - one of these two:
2844 ///   ( lsl | lsr | asr | ror ) , # shift_amount
2845 ///   rrx
2846 /// return true if it parses a shift otherwise it returns false.
2847 bool ARMAsmParser::parseMemRegOffsetShift(ARM_AM::ShiftOpc &St,
2848                                           unsigned &Amount) {
2849   SMLoc Loc = Parser.getTok().getLoc();
2850   const AsmToken &Tok = Parser.getTok();
2851   if (Tok.isNot(AsmToken::Identifier))
2852     return true;
2853   StringRef ShiftName = Tok.getString();
2854   if (ShiftName == "lsl" || ShiftName == "LSL")
2855     St = ARM_AM::lsl;
2856   else if (ShiftName == "lsr" || ShiftName == "LSR")
2857     St = ARM_AM::lsr;
2858   else if (ShiftName == "asr" || ShiftName == "ASR")
2859     St = ARM_AM::asr;
2860   else if (ShiftName == "ror" || ShiftName == "ROR")
2861     St = ARM_AM::ror;
2862   else if (ShiftName == "rrx" || ShiftName == "RRX")
2863     St = ARM_AM::rrx;
2864   else
2865     return Error(Loc, "illegal shift operator");
2866   Parser.Lex(); // Eat shift type token.
2867
2868   // rrx stands alone.
2869   Amount = 0;
2870   if (St != ARM_AM::rrx) {
2871     Loc = Parser.getTok().getLoc();
2872     // A '#' and a shift amount.
2873     const AsmToken &HashTok = Parser.getTok();
2874     if (HashTok.isNot(AsmToken::Hash))
2875       return Error(HashTok.getLoc(), "'#' expected");
2876     Parser.Lex(); // Eat hash token.
2877
2878     const MCExpr *Expr;
2879     if (getParser().ParseExpression(Expr))
2880       return true;
2881     // Range check the immediate.
2882     // lsl, ror: 0 <= imm <= 31
2883     // lsr, asr: 0 <= imm <= 32
2884     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr);
2885     if (!CE)
2886       return Error(Loc, "shift amount must be an immediate");
2887     int64_t Imm = CE->getValue();
2888     if (Imm < 0 ||
2889         ((St == ARM_AM::lsl || St == ARM_AM::ror) && Imm > 31) ||
2890         ((St == ARM_AM::lsr || St == ARM_AM::asr) && Imm > 32))
2891       return Error(Loc, "immediate shift value out of range");
2892     Amount = Imm;
2893   }
2894
2895   return false;
2896 }
2897
2898 /// Parse a arm instruction operand.  For now this parses the operand regardless
2899 /// of the mnemonic.
2900 bool ARMAsmParser::parseOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands,
2901                                 StringRef Mnemonic) {
2902   SMLoc S, E;
2903
2904   // Check if the current operand has a custom associated parser, if so, try to
2905   // custom parse the operand, or fallback to the general approach.
2906   OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic);
2907   if (ResTy == MatchOperand_Success)
2908     return false;
2909   // If there wasn't a custom match, try the generic matcher below. Otherwise,
2910   // there was a match, but an error occurred, in which case, just return that
2911   // the operand parsing failed.
2912   if (ResTy == MatchOperand_ParseFail)
2913     return true;
2914
2915   switch (getLexer().getKind()) {
2916   default:
2917     Error(Parser.getTok().getLoc(), "unexpected token in operand");
2918     return true;
2919   case AsmToken::Identifier: {
2920     if (!tryParseRegisterWithWriteBack(Operands))
2921       return false;
2922     int Res = tryParseShiftRegister(Operands);
2923     if (Res == 0) // success
2924       return false;
2925     else if (Res == -1) // irrecoverable error
2926       return true;
2927
2928     // Fall though for the Identifier case that is not a register or a
2929     // special name.
2930   }
2931   case AsmToken::Integer: // things like 1f and 2b as a branch targets
2932   case AsmToken::Dot: {   // . as a branch target
2933     // This was not a register so parse other operands that start with an
2934     // identifier (like labels) as expressions and create them as immediates.
2935     const MCExpr *IdVal;
2936     S = Parser.getTok().getLoc();
2937     if (getParser().ParseExpression(IdVal))
2938       return true;
2939     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2940     Operands.push_back(ARMOperand::CreateImm(IdVal, S, E));
2941     return false;
2942   }
2943   case AsmToken::LBrac:
2944     return parseMemory(Operands);
2945   case AsmToken::LCurly:
2946     return parseRegisterList(Operands);
2947   case AsmToken::Hash: {
2948     // #42 -> immediate.
2949     // TODO: ":lower16:" and ":upper16:" modifiers after # before immediate
2950     S = Parser.getTok().getLoc();
2951     Parser.Lex();
2952     bool isNegative = Parser.getTok().is(AsmToken::Minus);
2953     const MCExpr *ImmVal;
2954     if (getParser().ParseExpression(ImmVal))
2955       return true;
2956     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ImmVal);
2957     if (!CE) {
2958       Error(S, "constant expression expected");
2959       return MatchOperand_ParseFail;
2960     }
2961     int32_t Val = CE->getValue();
2962     if (isNegative && Val == 0)
2963       ImmVal = MCConstantExpr::Create(INT32_MIN, getContext());
2964     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2965     Operands.push_back(ARMOperand::CreateImm(ImmVal, S, E));
2966     return false;
2967   }
2968   case AsmToken::Colon: {
2969     // ":lower16:" and ":upper16:" expression prefixes
2970     // FIXME: Check it's an expression prefix,
2971     // e.g. (FOO - :lower16:BAR) isn't legal.
2972     ARMMCExpr::VariantKind RefKind;
2973     if (parsePrefix(RefKind))
2974       return true;
2975
2976     const MCExpr *SubExprVal;
2977     if (getParser().ParseExpression(SubExprVal))
2978       return true;
2979
2980     const MCExpr *ExprVal = ARMMCExpr::Create(RefKind, SubExprVal,
2981                                                    getContext());
2982     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2983     Operands.push_back(ARMOperand::CreateImm(ExprVal, S, E));
2984     return false;
2985   }
2986   }
2987 }
2988
2989 // parsePrefix - Parse ARM 16-bit relocations expression prefix, i.e.
2990 //  :lower16: and :upper16:.
2991 bool ARMAsmParser::parsePrefix(ARMMCExpr::VariantKind &RefKind) {
2992   RefKind = ARMMCExpr::VK_ARM_None;
2993
2994   // :lower16: and :upper16: modifiers
2995   assert(getLexer().is(AsmToken::Colon) && "expected a :");
2996   Parser.Lex(); // Eat ':'
2997
2998   if (getLexer().isNot(AsmToken::Identifier)) {
2999     Error(Parser.getTok().getLoc(), "expected prefix identifier in operand");
3000     return true;
3001   }
3002
3003   StringRef IDVal = Parser.getTok().getIdentifier();
3004   if (IDVal == "lower16") {
3005     RefKind = ARMMCExpr::VK_ARM_LO16;
3006   } else if (IDVal == "upper16") {
3007     RefKind = ARMMCExpr::VK_ARM_HI16;
3008   } else {
3009     Error(Parser.getTok().getLoc(), "unexpected prefix in operand");
3010     return true;
3011   }
3012   Parser.Lex();
3013
3014   if (getLexer().isNot(AsmToken::Colon)) {
3015     Error(Parser.getTok().getLoc(), "unexpected token after prefix");
3016     return true;
3017   }
3018   Parser.Lex(); // Eat the last ':'
3019   return false;
3020 }
3021
3022 const MCExpr *
3023 ARMAsmParser::applyPrefixToExpr(const MCExpr *E,
3024                                 MCSymbolRefExpr::VariantKind Variant) {
3025   // Recurse over the given expression, rebuilding it to apply the given variant
3026   // to the leftmost symbol.
3027   if (Variant == MCSymbolRefExpr::VK_None)
3028     return E;
3029
3030   switch (E->getKind()) {
3031   case MCExpr::Target:
3032     llvm_unreachable("Can't handle target expr yet");
3033   case MCExpr::Constant:
3034     llvm_unreachable("Can't handle lower16/upper16 of constant yet");
3035
3036   case MCExpr::SymbolRef: {
3037     const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(E);
3038
3039     if (SRE->getKind() != MCSymbolRefExpr::VK_None)
3040       return 0;
3041
3042     return MCSymbolRefExpr::Create(&SRE->getSymbol(), Variant, getContext());
3043   }
3044
3045   case MCExpr::Unary:
3046     llvm_unreachable("Can't handle unary expressions yet");
3047
3048   case MCExpr::Binary: {
3049     const MCBinaryExpr *BE = cast<MCBinaryExpr>(E);
3050     const MCExpr *LHS = applyPrefixToExpr(BE->getLHS(), Variant);
3051     const MCExpr *RHS = BE->getRHS();
3052     if (!LHS)
3053       return 0;
3054
3055     return MCBinaryExpr::Create(BE->getOpcode(), LHS, RHS, getContext());
3056   }
3057   }
3058
3059   assert(0 && "Invalid expression kind!");
3060   return 0;
3061 }
3062
3063 /// \brief Given a mnemonic, split out possible predication code and carry
3064 /// setting letters to form a canonical mnemonic and flags.
3065 //
3066 // FIXME: Would be nice to autogen this.
3067 // FIXME: This is a bit of a maze of special cases.
3068 StringRef ARMAsmParser::splitMnemonic(StringRef Mnemonic,
3069                                       unsigned &PredicationCode,
3070                                       bool &CarrySetting,
3071                                       unsigned &ProcessorIMod,
3072                                       StringRef &ITMask) {
3073   PredicationCode = ARMCC::AL;
3074   CarrySetting = false;
3075   ProcessorIMod = 0;
3076
3077   // Ignore some mnemonics we know aren't predicated forms.
3078   //
3079   // FIXME: Would be nice to autogen this.
3080   if ((Mnemonic == "movs" && isThumb()) ||
3081       Mnemonic == "teq"   || Mnemonic == "vceq"   || Mnemonic == "svc"   ||
3082       Mnemonic == "mls"   || Mnemonic == "smmls"  || Mnemonic == "vcls"  ||
3083       Mnemonic == "vmls"  || Mnemonic == "vnmls"  || Mnemonic == "vacge" ||
3084       Mnemonic == "vcge"  || Mnemonic == "vclt"   || Mnemonic == "vacgt" ||
3085       Mnemonic == "vcgt"  || Mnemonic == "vcle"   || Mnemonic == "smlal" ||
3086       Mnemonic == "umaal" || Mnemonic == "umlal"  || Mnemonic == "vabal" ||
3087       Mnemonic == "vmlal" || Mnemonic == "vpadal" || Mnemonic == "vqdmlal")
3088     return Mnemonic;
3089
3090   // First, split out any predication code. Ignore mnemonics we know aren't
3091   // predicated but do have a carry-set and so weren't caught above.
3092   if (Mnemonic != "adcs" && Mnemonic != "bics" && Mnemonic != "movs" &&
3093       Mnemonic != "muls" && Mnemonic != "smlals" && Mnemonic != "smulls" &&
3094       Mnemonic != "umlals" && Mnemonic != "umulls" && Mnemonic != "lsls" &&
3095       Mnemonic != "sbcs" && Mnemonic != "rscs") {
3096     unsigned CC = StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2))
3097       .Case("eq", ARMCC::EQ)
3098       .Case("ne", ARMCC::NE)
3099       .Case("hs", ARMCC::HS)
3100       .Case("cs", ARMCC::HS)
3101       .Case("lo", ARMCC::LO)
3102       .Case("cc", ARMCC::LO)
3103       .Case("mi", ARMCC::MI)
3104       .Case("pl", ARMCC::PL)
3105       .Case("vs", ARMCC::VS)
3106       .Case("vc", ARMCC::VC)
3107       .Case("hi", ARMCC::HI)
3108       .Case("ls", ARMCC::LS)
3109       .Case("ge", ARMCC::GE)
3110       .Case("lt", ARMCC::LT)
3111       .Case("gt", ARMCC::GT)
3112       .Case("le", ARMCC::LE)
3113       .Case("al", ARMCC::AL)
3114       .Default(~0U);
3115     if (CC != ~0U) {
3116       Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 2);
3117       PredicationCode = CC;
3118     }
3119   }
3120
3121   // Next, determine if we have a carry setting bit. We explicitly ignore all
3122   // the instructions we know end in 's'.
3123   if (Mnemonic.endswith("s") &&
3124       !(Mnemonic == "cps" || Mnemonic == "mls" ||
3125         Mnemonic == "mrs" || Mnemonic == "smmls" || Mnemonic == "vabs" ||
3126         Mnemonic == "vcls" || Mnemonic == "vmls" || Mnemonic == "vmrs" ||
3127         Mnemonic == "vnmls" || Mnemonic == "vqabs" || Mnemonic == "vrecps" ||
3128         Mnemonic == "vrsqrts" || Mnemonic == "srs" ||
3129         (Mnemonic == "movs" && isThumb()))) {
3130     Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 1);
3131     CarrySetting = true;
3132   }
3133
3134   // The "cps" instruction can have a interrupt mode operand which is glued into
3135   // the mnemonic. Check if this is the case, split it and parse the imod op
3136   if (Mnemonic.startswith("cps")) {
3137     // Split out any imod code.
3138     unsigned IMod =
3139       StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2, 2))
3140       .Case("ie", ARM_PROC::IE)
3141       .Case("id", ARM_PROC::ID)
3142       .Default(~0U);
3143     if (IMod != ~0U) {
3144       Mnemonic = Mnemonic.slice(0, Mnemonic.size()-2);
3145       ProcessorIMod = IMod;
3146     }
3147   }
3148
3149   // The "it" instruction has the condition mask on the end of the mnemonic.
3150   if (Mnemonic.startswith("it")) {
3151     ITMask = Mnemonic.slice(2, Mnemonic.size());
3152     Mnemonic = Mnemonic.slice(0, 2);
3153   }
3154
3155   return Mnemonic;
3156 }
3157
3158 /// \brief Given a canonical mnemonic, determine if the instruction ever allows
3159 /// inclusion of carry set or predication code operands.
3160 //
3161 // FIXME: It would be nice to autogen this.
3162 void ARMAsmParser::
3163 getMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet,
3164                       bool &CanAcceptPredicationCode) {
3165   if (Mnemonic == "and" || Mnemonic == "lsl" || Mnemonic == "lsr" ||
3166       Mnemonic == "rrx" || Mnemonic == "ror" || Mnemonic == "sub" ||
3167       Mnemonic == "smull" || Mnemonic == "add" || Mnemonic == "adc" ||
3168       Mnemonic == "mul" || Mnemonic == "bic" || Mnemonic == "asr" ||
3169       Mnemonic == "umlal" || Mnemonic == "orr" || Mnemonic == "mvn" ||
3170       Mnemonic == "rsb" || Mnemonic == "rsc" || Mnemonic == "orn" ||
3171       Mnemonic == "sbc" || Mnemonic == "mla" || Mnemonic == "umull" ||
3172       Mnemonic == "eor" || Mnemonic == "smlal" || Mnemonic == "neg" ||
3173       (Mnemonic == "mov" && !isThumb())) {
3174     CanAcceptCarrySet = true;
3175   } else {
3176     CanAcceptCarrySet = false;
3177   }
3178
3179   if (Mnemonic == "cbnz" || Mnemonic == "setend" || Mnemonic == "dmb" ||
3180       Mnemonic == "cps" || Mnemonic == "mcr2" || Mnemonic == "it" ||
3181       Mnemonic == "mcrr2" || Mnemonic == "cbz" || Mnemonic == "cdp2" ||
3182       Mnemonic == "trap" || Mnemonic == "mrc2" || Mnemonic == "mrrc2" ||
3183       Mnemonic == "dsb" || Mnemonic == "isb" || Mnemonic == "setend" ||
3184       (Mnemonic == "clrex" && !isThumb()) ||
3185       (Mnemonic == "nop" && isThumbOne()) ||
3186       ((Mnemonic == "pld" || Mnemonic == "pli" || Mnemonic == "pldw") &&
3187        !isThumb()) ||
3188       ((Mnemonic.startswith("rfe") || Mnemonic.startswith("srs")) &&
3189        !isThumb()) ||
3190       Mnemonic.startswith("cps") || (Mnemonic == "movs" && isThumb())) {
3191     CanAcceptPredicationCode = false;
3192   } else {
3193     CanAcceptPredicationCode = true;
3194   }
3195
3196   if (isThumb())
3197     if (Mnemonic == "bkpt" || Mnemonic == "mcr" || Mnemonic == "mcrr" ||
3198         Mnemonic == "mrc" || Mnemonic == "mrrc" || Mnemonic == "cdp")
3199       CanAcceptPredicationCode = false;
3200 }
3201
3202 bool ARMAsmParser::shouldOmitCCOutOperand(StringRef Mnemonic,
3203                                SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3204   // FIXME: This is all horribly hacky. We really need a better way to deal
3205   // with optional operands like this in the matcher table.
3206
3207   // The 'mov' mnemonic is special. One variant has a cc_out operand, while
3208   // another does not. Specifically, the MOVW instruction does not. So we
3209   // special case it here and remove the defaulted (non-setting) cc_out
3210   // operand if that's the instruction we're trying to match.
3211   //
3212   // We do this as post-processing of the explicit operands rather than just
3213   // conditionally adding the cc_out in the first place because we need
3214   // to check the type of the parsed immediate operand.
3215   if (Mnemonic == "mov" && Operands.size() > 4 &&
3216       !static_cast<ARMOperand*>(Operands[4])->isARMSOImm() &&
3217       static_cast<ARMOperand*>(Operands[4])->isImm0_65535Expr() &&
3218       static_cast<ARMOperand*>(Operands[1])->getReg() == 0)
3219     return true;
3220
3221   // Register-register 'add' for thumb does not have a cc_out operand
3222   // when there are only two register operands.
3223   if (isThumb() && Mnemonic == "add" && Operands.size() == 5 &&
3224       static_cast<ARMOperand*>(Operands[3])->isReg() &&
3225       static_cast<ARMOperand*>(Operands[4])->isReg() &&
3226       static_cast<ARMOperand*>(Operands[1])->getReg() == 0)
3227     return true;
3228   // Register-register 'add' for thumb does not have a cc_out operand
3229   // when it's an ADD Rdm, SP, {Rdm|#imm0_255} instruction. We do
3230   // have to check the immediate range here since Thumb2 has a variant
3231   // that can handle a different range and has a cc_out operand.
3232   if (isThumb() && Mnemonic == "add" && Operands.size() == 6 &&
3233       static_cast<ARMOperand*>(Operands[3])->isReg() &&
3234       static_cast<ARMOperand*>(Operands[4])->isReg() &&
3235       static_cast<ARMOperand*>(Operands[4])->getReg() == ARM::SP &&
3236       static_cast<ARMOperand*>(Operands[1])->getReg() == 0 &&
3237       (static_cast<ARMOperand*>(Operands[5])->isReg() ||
3238        static_cast<ARMOperand*>(Operands[5])->isImm0_1020s4()))
3239     return true;
3240   // For Thumb2, add immediate does not have a cc_out operand for the
3241   // imm0_4096 variant. That's the least-preferred variant when
3242   // selecting via the generic "add" mnemonic, so to know that we
3243   // should remove the cc_out operand, we have to explicitly check that
3244   // it's not one of the other variants. Ugh.
3245   if (isThumbTwo() && Mnemonic == "add" && Operands.size() == 6 &&
3246       static_cast<ARMOperand*>(Operands[3])->isReg() &&
3247       static_cast<ARMOperand*>(Operands[4])->isReg() &&
3248       static_cast<ARMOperand*>(Operands[5])->isImm()) {
3249     // Nest conditions rather than one big 'if' statement for readability.
3250     //
3251     // If either register is a high reg, it's either one of the SP
3252     // variants (handled above) or a 32-bit encoding, so we just
3253     // check against T3.
3254     if ((!isARMLowRegister(static_cast<ARMOperand*>(Operands[3])->getReg()) ||
3255          !isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg())) &&
3256         static_cast<ARMOperand*>(Operands[5])->isT2SOImm())
3257       return false;
3258     // If both registers are low, we're in an IT block, and the immediate is
3259     // in range, we should use encoding T1 instead, which has a cc_out.
3260     if (inITBlock() &&
3261         isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg()) &&
3262         isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg()) &&
3263         static_cast<ARMOperand*>(Operands[5])->isImm0_7())
3264       return false;
3265
3266     // Otherwise, we use encoding T4, which does not have a cc_out
3267     // operand.
3268     return true;
3269   }
3270
3271
3272   // Register-register 'add/sub' for thumb does not have a cc_out operand
3273   // when it's an ADD/SUB SP, #imm. Be lenient on count since there's also
3274   // the "add/sub SP, SP, #imm" version. If the follow-up operands aren't
3275   // right, this will result in better diagnostics (which operand is off)
3276   // anyway.
3277   if (isThumb() && (Mnemonic == "add" || Mnemonic == "sub") &&
3278       (Operands.size() == 5 || Operands.size() == 6) &&
3279       static_cast<ARMOperand*>(Operands[3])->isReg() &&
3280       static_cast<ARMOperand*>(Operands[3])->getReg() == ARM::SP &&
3281       static_cast<ARMOperand*>(Operands[1])->getReg() == 0)
3282     return true;
3283
3284   return false;
3285 }
3286
3287 /// Parse an arm instruction mnemonic followed by its operands.
3288 bool ARMAsmParser::ParseInstruction(StringRef Name, SMLoc NameLoc,
3289                                SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3290   // Create the leading tokens for the mnemonic, split by '.' characters.
3291   size_t Start = 0, Next = Name.find('.');
3292   StringRef Mnemonic = Name.slice(Start, Next);
3293
3294   // Split out the predication code and carry setting flag from the mnemonic.
3295   unsigned PredicationCode;
3296   unsigned ProcessorIMod;
3297   bool CarrySetting;
3298   StringRef ITMask;
3299   Mnemonic = splitMnemonic(Mnemonic, PredicationCode, CarrySetting,
3300                            ProcessorIMod, ITMask);
3301
3302   // In Thumb1, only the branch (B) instruction can be predicated.
3303   if (isThumbOne() && PredicationCode != ARMCC::AL && Mnemonic != "b") {
3304     Parser.EatToEndOfStatement();
3305     return Error(NameLoc, "conditional execution not supported in Thumb1");
3306   }
3307
3308   Operands.push_back(ARMOperand::CreateToken(Mnemonic, NameLoc));
3309
3310   // Handle the IT instruction ITMask. Convert it to a bitmask. This
3311   // is the mask as it will be for the IT encoding if the conditional
3312   // encoding has a '1' as it's bit0 (i.e. 't' ==> '1'). In the case
3313   // where the conditional bit0 is zero, the instruction post-processing
3314   // will adjust the mask accordingly.
3315   if (Mnemonic == "it") {
3316     SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + 2);
3317     if (ITMask.size() > 3) {
3318       Parser.EatToEndOfStatement();
3319       return Error(Loc, "too many conditions on IT instruction");
3320     }
3321     unsigned Mask = 8;
3322     for (unsigned i = ITMask.size(); i != 0; --i) {
3323       char pos = ITMask[i - 1];
3324       if (pos != 't' && pos != 'e') {
3325         Parser.EatToEndOfStatement();
3326         return Error(Loc, "illegal IT block condition mask '" + ITMask + "'");
3327       }
3328       Mask >>= 1;
3329       if (ITMask[i - 1] == 't')
3330         Mask |= 8;
3331     }
3332     Operands.push_back(ARMOperand::CreateITMask(Mask, Loc));
3333   }
3334
3335   // FIXME: This is all a pretty gross hack. We should automatically handle
3336   // optional operands like this via tblgen.
3337
3338   // Next, add the CCOut and ConditionCode operands, if needed.
3339   //
3340   // For mnemonics which can ever incorporate a carry setting bit or predication
3341   // code, our matching model involves us always generating CCOut and
3342   // ConditionCode operands to match the mnemonic "as written" and then we let
3343   // the matcher deal with finding the right instruction or generating an
3344   // appropriate error.
3345   bool CanAcceptCarrySet, CanAcceptPredicationCode;
3346   getMnemonicAcceptInfo(Mnemonic, CanAcceptCarrySet, CanAcceptPredicationCode);
3347
3348   // If we had a carry-set on an instruction that can't do that, issue an
3349   // error.
3350   if (!CanAcceptCarrySet && CarrySetting) {
3351     Parser.EatToEndOfStatement();
3352     return Error(NameLoc, "instruction '" + Mnemonic +
3353                  "' can not set flags, but 's' suffix specified");
3354   }
3355   // If we had a predication code on an instruction that can't do that, issue an
3356   // error.
3357   if (!CanAcceptPredicationCode && PredicationCode != ARMCC::AL) {
3358     Parser.EatToEndOfStatement();
3359     return Error(NameLoc, "instruction '" + Mnemonic +
3360                  "' is not predicable, but condition code specified");
3361   }
3362
3363   // Add the carry setting operand, if necessary.
3364   if (CanAcceptCarrySet) {
3365     SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size());
3366     Operands.push_back(ARMOperand::CreateCCOut(CarrySetting ? ARM::CPSR : 0,
3367                                                Loc));
3368   }
3369
3370   // Add the predication code operand, if necessary.
3371   if (CanAcceptPredicationCode) {
3372     SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size() +
3373                                       CarrySetting);
3374     Operands.push_back(ARMOperand::CreateCondCode(
3375                          ARMCC::CondCodes(PredicationCode), Loc));
3376   }
3377
3378   // Add the processor imod operand, if necessary.
3379   if (ProcessorIMod) {
3380     Operands.push_back(ARMOperand::CreateImm(
3381           MCConstantExpr::Create(ProcessorIMod, getContext()),
3382                                  NameLoc, NameLoc));
3383   }
3384
3385   // Add the remaining tokens in the mnemonic.
3386   while (Next != StringRef::npos) {
3387     Start = Next;
3388     Next = Name.find('.', Start + 1);
3389     StringRef ExtraToken = Name.slice(Start, Next);
3390
3391     // For now, we're only parsing Thumb1 (for the most part), so
3392     // just ignore ".n" qualifiers. We'll use them to restrict
3393     // matching when we do Thumb2.
3394     if (ExtraToken != ".n") {
3395       SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Start);
3396       Operands.push_back(ARMOperand::CreateToken(ExtraToken, Loc));
3397     }
3398   }
3399
3400   // Read the remaining operands.
3401   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3402     // Read the first operand.
3403     if (parseOperand(Operands, Mnemonic)) {
3404       Parser.EatToEndOfStatement();
3405       return true;
3406     }
3407
3408     while (getLexer().is(AsmToken::Comma)) {
3409       Parser.Lex();  // Eat the comma.
3410
3411       // Parse and remember the operand.
3412       if (parseOperand(Operands, Mnemonic)) {
3413         Parser.EatToEndOfStatement();
3414         return true;
3415       }
3416     }
3417   }
3418
3419   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3420     Parser.EatToEndOfStatement();
3421     return TokError("unexpected token in argument list");
3422   }
3423
3424   Parser.Lex(); // Consume the EndOfStatement
3425
3426   // Some instructions, mostly Thumb, have forms for the same mnemonic that
3427   // do and don't have a cc_out optional-def operand. With some spot-checks
3428   // of the operand list, we can figure out which variant we're trying to
3429   // parse and adjust accordingly before actually matching. We shouldn't ever
3430   // try to remove a cc_out operand that was explicitly set on the the
3431   // mnemonic, of course (CarrySetting == true). Reason number #317 the
3432   // table driven matcher doesn't fit well with the ARM instruction set.
3433   if (!CarrySetting && shouldOmitCCOutOperand(Mnemonic, Operands)) {
3434     ARMOperand *Op = static_cast<ARMOperand*>(Operands[1]);
3435     Operands.erase(Operands.begin() + 1);
3436     delete Op;
3437   }
3438
3439   // ARM mode 'blx' need special handling, as the register operand version
3440   // is predicable, but the label operand version is not. So, we can't rely
3441   // on the Mnemonic based checking to correctly figure out when to put
3442   // a CondCode operand in the list. If we're trying to match the label
3443   // version, remove the CondCode operand here.
3444   if (!isThumb() && Mnemonic == "blx" && Operands.size() == 3 &&
3445       static_cast<ARMOperand*>(Operands[2])->isImm()) {
3446     ARMOperand *Op = static_cast<ARMOperand*>(Operands[1]);
3447     Operands.erase(Operands.begin() + 1);
3448     delete Op;
3449   }
3450
3451   // The vector-compare-to-zero instructions have a literal token "#0" at
3452   // the end that comes to here as an immediate operand. Convert it to a
3453   // token to play nicely with the matcher.
3454   if ((Mnemonic == "vceq" || Mnemonic == "vcge" || Mnemonic == "vcgt" ||
3455       Mnemonic == "vcle" || Mnemonic == "vclt") && Operands.size() == 6 &&
3456       static_cast<ARMOperand*>(Operands[5])->isImm()) {
3457     ARMOperand *Op = static_cast<ARMOperand*>(Operands[5]);
3458     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Op->getImm());
3459     if (CE && CE->getValue() == 0) {
3460       Operands.erase(Operands.begin() + 5);
3461       Operands.push_back(ARMOperand::CreateToken("#0", Op->getStartLoc()));
3462       delete Op;
3463     }
3464   }
3465   // Similarly, the Thumb1 "RSB" instruction has a literal "#0" on the
3466   // end. Convert it to a token here.
3467   if (Mnemonic == "rsb" && isThumb() && Operands.size() == 6 &&
3468       static_cast<ARMOperand*>(Operands[5])->isImm()) {
3469     ARMOperand *Op = static_cast<ARMOperand*>(Operands[5]);
3470     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Op->getImm());
3471     if (CE && CE->getValue() == 0) {
3472       Operands.erase(Operands.begin() + 5);
3473       Operands.push_back(ARMOperand::CreateToken("#0", Op->getStartLoc()));
3474       delete Op;
3475     }
3476   }
3477
3478   return false;
3479 }
3480
3481 // Validate context-sensitive operand constraints.
3482
3483 // return 'true' if register list contains non-low GPR registers,
3484 // 'false' otherwise. If Reg is in the register list or is HiReg, set
3485 // 'containsReg' to true.
3486 static bool checkLowRegisterList(MCInst Inst, unsigned OpNo, unsigned Reg,
3487                                  unsigned HiReg, bool &containsReg) {
3488   containsReg = false;
3489   for (unsigned i = OpNo; i < Inst.getNumOperands(); ++i) {
3490     unsigned OpReg = Inst.getOperand(i).getReg();
3491     if (OpReg == Reg)
3492       containsReg = true;
3493     // Anything other than a low register isn't legal here.
3494     if (!isARMLowRegister(OpReg) && (!HiReg || OpReg != HiReg))
3495       return true;
3496   }
3497   return false;
3498 }
3499
3500 // Check if the specified regisgter is in the register list of the inst,
3501 // starting at the indicated operand number.
3502 static bool listContainsReg(MCInst &Inst, unsigned OpNo, unsigned Reg) {
3503   for (unsigned i = OpNo; i < Inst.getNumOperands(); ++i) {
3504     unsigned OpReg = Inst.getOperand(i).getReg();
3505     if (OpReg == Reg)
3506       return true;
3507   }
3508   return false;
3509 }
3510
3511 // FIXME: We would really prefer to have MCInstrInfo (the wrapper around
3512 // the ARMInsts array) instead. Getting that here requires awkward
3513 // API changes, though. Better way?
3514 namespace llvm {
3515 extern MCInstrDesc ARMInsts[];
3516 }
3517 static MCInstrDesc &getInstDesc(unsigned Opcode) {
3518   return ARMInsts[Opcode];
3519 }
3520
3521 // FIXME: We would really like to be able to tablegen'erate this.
3522 bool ARMAsmParser::
3523 validateInstruction(MCInst &Inst,
3524                     const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3525   MCInstrDesc &MCID = getInstDesc(Inst.getOpcode());
3526   SMLoc Loc = Operands[0]->getStartLoc();
3527   // Check the IT block state first.
3528   if (inITBlock()) {
3529     unsigned bit = 1;
3530     if (ITState.FirstCond)
3531       ITState.FirstCond = false;
3532     else
3533       bit = (ITState.Mask >> (5 - ITState.CurPosition)) & 1;
3534     // The instruction must be predicable.
3535     if (!MCID.isPredicable())
3536       return Error(Loc, "instructions in IT block must be predicable");
3537     unsigned Cond = Inst.getOperand(MCID.findFirstPredOperandIdx()).getImm();
3538     unsigned ITCond = bit ? ITState.Cond :
3539       ARMCC::getOppositeCondition(ITState.Cond);
3540     if (Cond != ITCond) {
3541       // Find the condition code Operand to get its SMLoc information.
3542       SMLoc CondLoc;
3543       for (unsigned i = 1; i < Operands.size(); ++i)
3544         if (static_cast<ARMOperand*>(Operands[i])->isCondCode())
3545           CondLoc = Operands[i]->getStartLoc();
3546       return Error(CondLoc, "incorrect condition in IT block; got '" +
3547                    StringRef(ARMCondCodeToString(ARMCC::CondCodes(Cond))) +
3548                    "', but expected '" +
3549                    ARMCondCodeToString(ARMCC::CondCodes(ITCond)) + "'");
3550     }
3551   // Check for non-'al' condition codes outside of the IT block.
3552   } else if (isThumbTwo() && MCID.isPredicable() &&
3553              Inst.getOperand(MCID.findFirstPredOperandIdx()).getImm() !=
3554              ARMCC::AL && Inst.getOpcode() != ARM::tBcc &&
3555              Inst.getOpcode() != ARM::t2Bcc)
3556     return Error(Loc, "predicated instructions must be in IT block");
3557
3558   switch (Inst.getOpcode()) {
3559   case ARM::LDRD:
3560   case ARM::LDRD_PRE:
3561   case ARM::LDRD_POST:
3562   case ARM::LDREXD: {
3563     // Rt2 must be Rt + 1.
3564     unsigned Rt = getARMRegisterNumbering(Inst.getOperand(0).getReg());
3565     unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(1).getReg());
3566     if (Rt2 != Rt + 1)
3567       return Error(Operands[3]->getStartLoc(),
3568                    "destination operands must be sequential");
3569     return false;
3570   }
3571   case ARM::STRD: {
3572     // Rt2 must be Rt + 1.
3573     unsigned Rt = getARMRegisterNumbering(Inst.getOperand(0).getReg());
3574     unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(1).getReg());
3575     if (Rt2 != Rt + 1)
3576       return Error(Operands[3]->getStartLoc(),
3577                    "source operands must be sequential");
3578     return false;
3579   }
3580   case ARM::STRD_PRE:
3581   case ARM::STRD_POST:
3582   case ARM::STREXD: {
3583     // Rt2 must be Rt + 1.
3584     unsigned Rt = getARMRegisterNumbering(Inst.getOperand(1).getReg());
3585     unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(2).getReg());
3586     if (Rt2 != Rt + 1)
3587       return Error(Operands[3]->getStartLoc(),
3588                    "source operands must be sequential");
3589     return false;
3590   }
3591   case ARM::SBFX:
3592   case ARM::UBFX: {
3593     // width must be in range [1, 32-lsb]
3594     unsigned lsb = Inst.getOperand(2).getImm();
3595     unsigned widthm1 = Inst.getOperand(3).getImm();
3596     if (widthm1 >= 32 - lsb)
3597       return Error(Operands[5]->getStartLoc(),
3598                    "bitfield width must be in range [1,32-lsb]");
3599     return false;
3600   }
3601   case ARM::tLDMIA: {
3602     // If we're parsing Thumb2, the .w variant is available and handles
3603     // most cases that are normally illegal for a Thumb1 LDM
3604     // instruction. We'll make the transformation in processInstruction()
3605     // if necessary.
3606     //
3607     // Thumb LDM instructions are writeback iff the base register is not
3608     // in the register list.
3609     unsigned Rn = Inst.getOperand(0).getReg();
3610     bool hasWritebackToken =
3611       (static_cast<ARMOperand*>(Operands[3])->isToken() &&
3612        static_cast<ARMOperand*>(Operands[3])->getToken() == "!");
3613     bool listContainsBase;
3614     if (checkLowRegisterList(Inst, 3, Rn, 0, listContainsBase) && !isThumbTwo())
3615       return Error(Operands[3 + hasWritebackToken]->getStartLoc(),
3616                    "registers must be in range r0-r7");
3617     // If we should have writeback, then there should be a '!' token.
3618     if (!listContainsBase && !hasWritebackToken && !isThumbTwo())
3619       return Error(Operands[2]->getStartLoc(),
3620                    "writeback operator '!' expected");
3621     // If we should not have writeback, there must not be a '!'. This is
3622     // true even for the 32-bit wide encodings.
3623     if (listContainsBase && hasWritebackToken)
3624       return Error(Operands[3]->getStartLoc(),
3625                    "writeback operator '!' not allowed when base register "
3626                    "in register list");
3627
3628     break;
3629   }
3630   case ARM::t2LDMIA_UPD: {
3631     if (listContainsReg(Inst, 3, Inst.getOperand(0).getReg()))
3632       return Error(Operands[4]->getStartLoc(),
3633                    "writeback operator '!' not allowed when base register "
3634                    "in register list");
3635     break;
3636   }
3637   case ARM::tPOP: {
3638     bool listContainsBase;
3639     if (checkLowRegisterList(Inst, 3, 0, ARM::PC, listContainsBase))
3640       return Error(Operands[2]->getStartLoc(),
3641                    "registers must be in range r0-r7 or pc");
3642     break;
3643   }
3644   case ARM::tPUSH: {
3645     bool listContainsBase;
3646     if (checkLowRegisterList(Inst, 3, 0, ARM::LR, listContainsBase))
3647       return Error(Operands[2]->getStartLoc(),
3648                    "registers must be in range r0-r7 or lr");
3649     break;
3650   }
3651   case ARM::tSTMIA_UPD: {
3652     bool listContainsBase;
3653     if (checkLowRegisterList(Inst, 4, 0, 0, listContainsBase))
3654       return Error(Operands[4]->getStartLoc(),
3655                    "registers must be in range r0-r7");
3656     break;
3657   }
3658   }
3659
3660   return false;
3661 }
3662
3663 void ARMAsmParser::
3664 processInstruction(MCInst &Inst,
3665                    const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3666   switch (Inst.getOpcode()) {
3667   case ARM::LDMIA_UPD:
3668     // If this is a load of a single register via a 'pop', then we should use
3669     // a post-indexed LDR instruction instead, per the ARM ARM.
3670     if (static_cast<ARMOperand*>(Operands[0])->getToken() == "pop" &&
3671         Inst.getNumOperands() == 5) {
3672       MCInst TmpInst;
3673       TmpInst.setOpcode(ARM::LDR_POST_IMM);
3674       TmpInst.addOperand(Inst.getOperand(4)); // Rt
3675       TmpInst.addOperand(Inst.getOperand(0)); // Rn_wb
3676       TmpInst.addOperand(Inst.getOperand(1)); // Rn
3677       TmpInst.addOperand(MCOperand::CreateReg(0));  // am2offset
3678       TmpInst.addOperand(MCOperand::CreateImm(4));
3679       TmpInst.addOperand(Inst.getOperand(2)); // CondCode
3680       TmpInst.addOperand(Inst.getOperand(3));
3681       Inst = TmpInst;
3682     }
3683     break;
3684   case ARM::STMDB_UPD:
3685     // If this is a store of a single register via a 'push', then we should use
3686     // a pre-indexed STR instruction instead, per the ARM ARM.
3687     if (static_cast<ARMOperand*>(Operands[0])->getToken() == "push" &&
3688         Inst.getNumOperands() == 5) {
3689       MCInst TmpInst;
3690       TmpInst.setOpcode(ARM::STR_PRE_IMM);
3691       TmpInst.addOperand(Inst.getOperand(0)); // Rn_wb
3692       TmpInst.addOperand(Inst.getOperand(4)); // Rt
3693       TmpInst.addOperand(Inst.getOperand(1)); // addrmode_imm12
3694       TmpInst.addOperand(MCOperand::CreateImm(-4));
3695       TmpInst.addOperand(Inst.getOperand(2)); // CondCode
3696       TmpInst.addOperand(Inst.getOperand(3));
3697       Inst = TmpInst;
3698     }
3699     break;
3700   case ARM::tADDi8:
3701     // If the immediate is in the range 0-7, we want tADDi3 iff Rd was
3702     // explicitly specified. From the ARM ARM: "Encoding T1 is preferred
3703     // to encoding T2 if <Rd> is specified and encoding T2 is preferred
3704     // to encoding T1 if <Rd> is omitted."
3705     if (Inst.getOperand(3).getImm() < 8 && Operands.size() == 6)
3706       Inst.setOpcode(ARM::tADDi3);
3707     break;
3708   case ARM::t2Bcc:
3709     // If the conditional is AL or we're in an IT block, we really want t2B.
3710     if (Inst.getOperand(1).getImm() == ARMCC::AL || inITBlock())
3711       Inst.setOpcode(ARM::t2B);
3712     break;
3713   case ARM::tBcc:
3714     // If the conditional is AL, we really want tB.
3715     if (Inst.getOperand(1).getImm() == ARMCC::AL)
3716       Inst.setOpcode(ARM::tB);
3717     break;
3718   case ARM::tLDMIA: {
3719     // If the register list contains any high registers, or if the writeback
3720     // doesn't match what tLDMIA can do, we need to use the 32-bit encoding
3721     // instead if we're in Thumb2. Otherwise, this should have generated
3722     // an error in validateInstruction().
3723     unsigned Rn = Inst.getOperand(0).getReg();
3724     bool hasWritebackToken =
3725       (static_cast<ARMOperand*>(Operands[3])->isToken() &&
3726        static_cast<ARMOperand*>(Operands[3])->getToken() == "!");
3727     bool listContainsBase;
3728     if (checkLowRegisterList(Inst, 3, Rn, 0, listContainsBase) ||
3729         (!listContainsBase && !hasWritebackToken) ||
3730         (listContainsBase && hasWritebackToken)) {
3731       // 16-bit encoding isn't sufficient. Switch to the 32-bit version.
3732       assert (isThumbTwo());
3733       Inst.setOpcode(hasWritebackToken ? ARM::t2LDMIA_UPD : ARM::t2LDMIA);
3734       // If we're switching to the updating version, we need to insert
3735       // the writeback tied operand.
3736       if (hasWritebackToken)
3737         Inst.insert(Inst.begin(),
3738                     MCOperand::CreateReg(Inst.getOperand(0).getReg()));
3739     }
3740     break;
3741   }
3742   case ARM::t2IT: {
3743     // The mask bits for all but the first condition are represented as
3744     // the low bit of the condition code value implies 't'. We currently
3745     // always have 1 implies 't', so XOR toggle the bits if the low bit
3746     // of the condition code is zero. The encoding also expects the low
3747     // bit of the condition to be encoded as bit 4 of the mask operand,
3748     // so mask that in if needed
3749     MCOperand &MO = Inst.getOperand(1);
3750     unsigned Mask = MO.getImm();
3751     unsigned OrigMask = Mask;
3752     unsigned TZ = CountTrailingZeros_32(Mask);
3753     if ((Inst.getOperand(0).getImm() & 1) == 0) {
3754       assert(Mask && TZ <= 3 && "illegal IT mask value!");
3755       for (unsigned i = 3; i != TZ; --i)
3756         Mask ^= 1 << i;
3757     } else
3758       Mask |= 0x10;
3759     MO.setImm(Mask);
3760
3761     // Set up the IT block state according to the IT instruction we just
3762     // matched.
3763     assert(!inITBlock() && "nested IT blocks?!");
3764     ITState.Cond = ARMCC::CondCodes(Inst.getOperand(0).getImm());
3765     ITState.Mask = OrigMask; // Use the original mask, not the updated one.
3766     ITState.CurPosition = 0;
3767     ITState.FirstCond = true;
3768     break;
3769   }
3770   }
3771 }
3772
3773 unsigned ARMAsmParser::checkTargetMatchPredicate(MCInst &Inst) {
3774   // 16-bit thumb arithmetic instructions either require or preclude the 'S'
3775   // suffix depending on whether they're in an IT block or not.
3776   unsigned Opc = Inst.getOpcode();
3777   MCInstrDesc &MCID = getInstDesc(Opc);
3778   if (MCID.TSFlags & ARMII::ThumbArithFlagSetting) {
3779     assert(MCID.hasOptionalDef() &&
3780            "optionally flag setting instruction missing optional def operand");
3781     assert(MCID.NumOperands == Inst.getNumOperands() &&
3782            "operand count mismatch!");
3783     // Find the optional-def operand (cc_out).
3784     unsigned OpNo;
3785     for (OpNo = 0;
3786          !MCID.OpInfo[OpNo].isOptionalDef() && OpNo < MCID.NumOperands;
3787          ++OpNo)
3788       ;
3789     // If we're parsing Thumb1, reject it completely.
3790     if (isThumbOne() && Inst.getOperand(OpNo).getReg() != ARM::CPSR)
3791       return Match_MnemonicFail;
3792     // If we're parsing Thumb2, which form is legal depends on whether we're
3793     // in an IT block.
3794     if (isThumbTwo() && Inst.getOperand(OpNo).getReg() != ARM::CPSR &&
3795         !inITBlock())
3796       return Match_RequiresITBlock;
3797     if (isThumbTwo() && Inst.getOperand(OpNo).getReg() == ARM::CPSR &&
3798         inITBlock())
3799       return Match_RequiresNotITBlock;
3800   }
3801   // Some high-register supporting Thumb1 encodings only allow both registers
3802   // to be from r0-r7 when in Thumb2.
3803   else if (Opc == ARM::tADDhirr && isThumbOne() &&
3804            isARMLowRegister(Inst.getOperand(1).getReg()) &&
3805            isARMLowRegister(Inst.getOperand(2).getReg()))
3806     return Match_RequiresThumb2;
3807   // Others only require ARMv6 or later.
3808   else if (Opc == ARM::tMOVr && isThumbOne() && !hasV6Ops() &&
3809            isARMLowRegister(Inst.getOperand(0).getReg()) &&
3810            isARMLowRegister(Inst.getOperand(1).getReg()))
3811     return Match_RequiresV6;
3812   return Match_Success;
3813 }
3814
3815 bool ARMAsmParser::
3816 MatchAndEmitInstruction(SMLoc IDLoc,
3817                         SmallVectorImpl<MCParsedAsmOperand*> &Operands,
3818                         MCStreamer &Out) {
3819   MCInst Inst;
3820   unsigned ErrorInfo;
3821   unsigned MatchResult;
3822   MatchResult = MatchInstructionImpl(Operands, Inst, ErrorInfo);
3823   switch (MatchResult) {
3824   default: break;
3825   case Match_Success:
3826     // Context sensitive operand constraints aren't handled by the matcher,
3827     // so check them here.
3828     if (validateInstruction(Inst, Operands)) {
3829       // Still progress the IT block, otherwise one wrong condition causes
3830       // nasty cascading errors.
3831       forwardITPosition();
3832       return true;
3833     }
3834
3835     // Some instructions need post-processing to, for example, tweak which
3836     // encoding is selected.
3837     processInstruction(Inst, Operands);
3838
3839     // Only move forward at the very end so that everything in validate
3840     // and process gets a consistent answer about whether we're in an IT
3841     // block.
3842     forwardITPosition();
3843
3844     Out.EmitInstruction(Inst);
3845     return false;
3846   case Match_MissingFeature:
3847     Error(IDLoc, "instruction requires a CPU feature not currently enabled");
3848     return true;
3849   case Match_InvalidOperand: {
3850     SMLoc ErrorLoc = IDLoc;
3851     if (ErrorInfo != ~0U) {
3852       if (ErrorInfo >= Operands.size())
3853         return Error(IDLoc, "too few operands for instruction");
3854
3855       ErrorLoc = ((ARMOperand*)Operands[ErrorInfo])->getStartLoc();
3856       if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc;
3857     }
3858
3859     return Error(ErrorLoc, "invalid operand for instruction");
3860   }
3861   case Match_MnemonicFail:
3862     return Error(IDLoc, "invalid instruction");
3863   case Match_ConversionFail:
3864     // The converter function will have already emited a diagnostic.
3865     return true;
3866   case Match_RequiresNotITBlock:
3867     return Error(IDLoc, "flag setting instruction only valid outside IT block");
3868   case Match_RequiresITBlock:
3869     return Error(IDLoc, "instruction only valid inside IT block");
3870   case Match_RequiresV6:
3871     return Error(IDLoc, "instruction variant requires ARMv6 or later");
3872   case Match_RequiresThumb2:
3873     return Error(IDLoc, "instruction variant requires Thumb2");
3874   }
3875
3876   llvm_unreachable("Implement any new match types added!");
3877   return true;
3878 }
3879
3880 /// parseDirective parses the arm specific directives
3881 bool ARMAsmParser::ParseDirective(AsmToken DirectiveID) {
3882   StringRef IDVal = DirectiveID.getIdentifier();
3883   if (IDVal == ".word")
3884     return parseDirectiveWord(4, DirectiveID.getLoc());
3885   else if (IDVal == ".thumb")
3886     return parseDirectiveThumb(DirectiveID.getLoc());
3887   else if (IDVal == ".thumb_func")
3888     return parseDirectiveThumbFunc(DirectiveID.getLoc());
3889   else if (IDVal == ".code")
3890     return parseDirectiveCode(DirectiveID.getLoc());
3891   else if (IDVal == ".syntax")
3892     return parseDirectiveSyntax(DirectiveID.getLoc());
3893   return true;
3894 }
3895
3896 /// parseDirectiveWord
3897 ///  ::= .word [ expression (, expression)* ]
3898 bool ARMAsmParser::parseDirectiveWord(unsigned Size, SMLoc L) {
3899   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3900     for (;;) {
3901       const MCExpr *Value;
3902       if (getParser().ParseExpression(Value))
3903         return true;
3904
3905       getParser().getStreamer().EmitValue(Value, Size, 0/*addrspace*/);
3906
3907       if (getLexer().is(AsmToken::EndOfStatement))
3908         break;
3909
3910       // FIXME: Improve diagnostic.
3911       if (getLexer().isNot(AsmToken::Comma))
3912         return Error(L, "unexpected token in directive");
3913       Parser.Lex();
3914     }
3915   }
3916
3917   Parser.Lex();
3918   return false;
3919 }
3920
3921 /// parseDirectiveThumb
3922 ///  ::= .thumb
3923 bool ARMAsmParser::parseDirectiveThumb(SMLoc L) {
3924   if (getLexer().isNot(AsmToken::EndOfStatement))
3925     return Error(L, "unexpected token in directive");
3926   Parser.Lex();
3927
3928   // TODO: set thumb mode
3929   // TODO: tell the MC streamer the mode
3930   // getParser().getStreamer().Emit???();
3931   return false;
3932 }
3933
3934 /// parseDirectiveThumbFunc
3935 ///  ::= .thumbfunc symbol_name
3936 bool ARMAsmParser::parseDirectiveThumbFunc(SMLoc L) {
3937   const MCAsmInfo &MAI = getParser().getStreamer().getContext().getAsmInfo();
3938   bool isMachO = MAI.hasSubsectionsViaSymbols();
3939   StringRef Name;
3940
3941   // Darwin asm has function name after .thumb_func direction
3942   // ELF doesn't
3943   if (isMachO) {
3944     const AsmToken &Tok = Parser.getTok();
3945     if (Tok.isNot(AsmToken::Identifier) && Tok.isNot(AsmToken::String))
3946       return Error(L, "unexpected token in .thumb_func directive");
3947     Name = Tok.getString();
3948     Parser.Lex(); // Consume the identifier token.
3949   }
3950
3951   if (getLexer().isNot(AsmToken::EndOfStatement))
3952     return Error(L, "unexpected token in directive");
3953   Parser.Lex();
3954
3955   // FIXME: assuming function name will be the line following .thumb_func
3956   if (!isMachO) {
3957     Name = Parser.getTok().getString();
3958   }
3959
3960   // Mark symbol as a thumb symbol.
3961   MCSymbol *Func = getParser().getContext().GetOrCreateSymbol(Name);
3962   getParser().getStreamer().EmitThumbFunc(Func);
3963   return false;
3964 }
3965
3966 /// parseDirectiveSyntax
3967 ///  ::= .syntax unified | divided
3968 bool ARMAsmParser::parseDirectiveSyntax(SMLoc L) {
3969   const AsmToken &Tok = Parser.getTok();
3970   if (Tok.isNot(AsmToken::Identifier))
3971     return Error(L, "unexpected token in .syntax directive");
3972   StringRef Mode = Tok.getString();
3973   if (Mode == "unified" || Mode == "UNIFIED")
3974     Parser.Lex();
3975   else if (Mode == "divided" || Mode == "DIVIDED")
3976     return Error(L, "'.syntax divided' arm asssembly not supported");
3977   else
3978     return Error(L, "unrecognized syntax mode in .syntax directive");
3979
3980   if (getLexer().isNot(AsmToken::EndOfStatement))
3981     return Error(Parser.getTok().getLoc(), "unexpected token in directive");
3982   Parser.Lex();
3983
3984   // TODO tell the MC streamer the mode
3985   // getParser().getStreamer().Emit???();
3986   return false;
3987 }
3988
3989 /// parseDirectiveCode
3990 ///  ::= .code 16 | 32
3991 bool ARMAsmParser::parseDirectiveCode(SMLoc L) {
3992   const AsmToken &Tok = Parser.getTok();
3993   if (Tok.isNot(AsmToken::Integer))
3994     return Error(L, "unexpected token in .code directive");
3995   int64_t Val = Parser.getTok().getIntVal();
3996   if (Val == 16)
3997     Parser.Lex();
3998   else if (Val == 32)
3999     Parser.Lex();
4000   else
4001     return Error(L, "invalid operand to .code directive");
4002
4003   if (getLexer().isNot(AsmToken::EndOfStatement))
4004     return Error(Parser.getTok().getLoc(), "unexpected token in directive");
4005   Parser.Lex();
4006
4007   if (Val == 16) {
4008     if (!isThumb())
4009       SwitchMode();
4010     getParser().getStreamer().EmitAssemblerFlag(MCAF_Code16);
4011   } else {
4012     if (isThumb())
4013       SwitchMode();
4014     getParser().getStreamer().EmitAssemblerFlag(MCAF_Code32);
4015   }
4016
4017   return false;
4018 }
4019
4020 extern "C" void LLVMInitializeARMAsmLexer();
4021
4022 /// Force static initialization.
4023 extern "C" void LLVMInitializeARMAsmParser() {
4024   RegisterMCAsmParser<ARMAsmParser> X(TheARMTarget);
4025   RegisterMCAsmParser<ARMAsmParser> Y(TheThumbTarget);
4026   LLVMInitializeARMAsmLexer();
4027 }
4028
4029 #define GET_REGISTER_MATCHER
4030 #define GET_MATCHER_IMPLEMENTATION
4031 #include "ARMGenAsmMatcher.inc"