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