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/MCRegisterInfo.h"
  22 #include "llvm/MC/MCSubtargetInfo.h"
  23 #include "llvm/MC/MCTargetAsmParser.h"
  24 #include "llvm/Target/TargetRegistry.h"
  25 #include "llvm/Support/SourceMgr.h"
  26 #include "llvm/Support/raw_ostream.h"
  27 #include "llvm/ADT/OwningPtr.h"
  28 #include "llvm/ADT/STLExtras.h"
  29 #include "llvm/ADT/SmallVector.h"
  30 #include "llvm/ADT/StringExtras.h"
  31 #include "llvm/ADT/StringSwitch.h"
  32 #include "llvm/ADT/Twine.h"
  33
  34 using namespace llvm;
  35
  36 namespace {
  37
  38 class ARMOperand;
  39
  40 class ARMAsmParser : public MCTargetAsmParser {
  41   MCSubtargetInfo &STI;
  42   MCAsmParser &Parser;
  43
  44   MCAsmParser &getParser() const { return Parser; }
  45   MCAsmLexer &getLexer() const { return Parser.getLexer(); }
  46
  47   void Warning(SMLoc L, const Twine &Msg) { Parser.Warning(L, Msg); }
  48   bool Error(SMLoc L, const Twine &Msg) { return Parser.Error(L, Msg); }
  49
  50   int tryParseRegister();
  51   bool tryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &);
  52   int tryParseShiftRegister(SmallVectorImpl<MCParsedAsmOperand*> &);
  53   bool parseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &);
  54   bool parseMemory(SmallVectorImpl<MCParsedAsmOperand*> &);
  55   bool parseOperand(SmallVectorImpl<MCParsedAsmOperand*> &, StringRef Mnemonic);
  56   bool parsePrefix(ARMMCExpr::VariantKind &RefKind);
  57   const MCExpr *applyPrefixToExpr(const MCExpr *E,
  58                                   MCSymbolRefExpr::VariantKind Variant);
  59
  60
  61   bool parseMemRegOffsetShift(ARM_AM::ShiftOpc &ShiftType,
  62                               unsigned &ShiftAmount);
  63   bool parseDirectiveWord(unsigned Size, SMLoc L);
  64   bool parseDirectiveThumb(SMLoc L);
  65   bool parseDirectiveThumbFunc(SMLoc L);
  66   bool parseDirectiveCode(SMLoc L);
  67   bool parseDirectiveSyntax(SMLoc L);
  68
  69   StringRef splitMnemonic(StringRef Mnemonic, unsigned &PredicationCode,
  70                           bool &CarrySetting, unsigned &ProcessorIMod);
  71   void getMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet,
  72                              bool &CanAcceptPredicationCode);
  73
  74   bool isThumb() const {
  75     // FIXME: Can tablegen auto-generate this?
  76     return (STI.getFeatureBits() & ARM::ModeThumb) != 0;
  77   }
  78   bool isThumbOne() const {
  79     return isThumb() && (STI.getFeatureBits() & ARM::FeatureThumb2) == 0;
  80   }
  81   void SwitchMode() {
  82     unsigned FB = ComputeAvailableFeatures(STI.ToggleFeature(ARM::ModeThumb));
  83     setAvailableFeatures(FB);
  84   }
  85
  86   /// @name Auto-generated Match Functions
  87   /// {
  88
  89 #define GET_ASSEMBLER_HEADER
  90 #include "ARMGenAsmMatcher.inc"
  91
  92   /// }
  93
  94   OperandMatchResultTy parseCoprocNumOperand(
  95     SmallVectorImpl<MCParsedAsmOperand*>&);
  96   OperandMatchResultTy parseCoprocRegOperand(
  97     SmallVectorImpl<MCParsedAsmOperand*>&);
  98   OperandMatchResultTy parseMemBarrierOptOperand(
  99     SmallVectorImpl<MCParsedAsmOperand*>&);
 100   OperandMatchResultTy parseProcIFlagsOperand(
 101     SmallVectorImpl<MCParsedAsmOperand*>&);
 102   OperandMatchResultTy parseMSRMaskOperand(
 103     SmallVectorImpl<MCParsedAsmOperand*>&);
 104   OperandMatchResultTy parsePKHImm(SmallVectorImpl<MCParsedAsmOperand*> &O,
 105                                    StringRef Op, int Low, int High);
 106   OperandMatchResultTy parsePKHLSLImm(SmallVectorImpl<MCParsedAsmOperand*> &O) {
 107     return parsePKHImm(O, "lsl", 0, 31);
 108   }
 109   OperandMatchResultTy parsePKHASRImm(SmallVectorImpl<MCParsedAsmOperand*> &O) {
 110     return parsePKHImm(O, "asr", 1, 32);
 111   }
 112   OperandMatchResultTy parseSetEndImm(SmallVectorImpl<MCParsedAsmOperand*>&);
 113   OperandMatchResultTy parseShifterImm(SmallVectorImpl<MCParsedAsmOperand*>&);
 114   OperandMatchResultTy parseRotImm(SmallVectorImpl<MCParsedAsmOperand*>&);
 115   OperandMatchResultTy parseBitfield(SmallVectorImpl<MCParsedAsmOperand*>&);
 116   OperandMatchResultTy parsePostIdxReg(SmallVectorImpl<MCParsedAsmOperand*>&);
 117   OperandMatchResultTy parseAM3Offset(SmallVectorImpl<MCParsedAsmOperand*>&);
 118
 119   // Asm Match Converter Methods
 120   bool cvtLdWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
 121                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 122   bool cvtStWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
 123                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 124   bool cvtStWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
 125                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 126   bool cvtLdExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
 127                              const SmallVectorImpl<MCParsedAsmOperand*> &);
 128   bool cvtLdExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
 129                              const SmallVectorImpl<MCParsedAsmOperand*> &);
 130   bool cvtStExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
 131                              const SmallVectorImpl<MCParsedAsmOperand*> &);
 132   bool cvtStExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
 133                              const SmallVectorImpl<MCParsedAsmOperand*> &);
 134   bool cvtLdrdPre(MCInst &Inst, unsigned Opcode,
 135                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 136   bool cvtStrdPre(MCInst &Inst, unsigned Opcode,
 137                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 138   bool cvtLdWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
 139                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 140
 141   bool validateInstruction(MCInst &Inst,
 142                            const SmallVectorImpl<MCParsedAsmOperand*> &Ops);
 143   void processInstruction(MCInst &Inst,
 144                           const SmallVectorImpl<MCParsedAsmOperand*> &Ops);
 145
 146 public:
 147   ARMAsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser)
 148     : MCTargetAsmParser(), STI(_STI), Parser(_Parser) {
 149     MCAsmParserExtension::Initialize(_Parser);
 150
 151     // Initialize the set of available features.
 152     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
 153   }
 154
 155   // Implementation of the MCTargetAsmParser interface:
 156   bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc);
 157   bool ParseInstruction(StringRef Name, SMLoc NameLoc,
 158                         SmallVectorImpl<MCParsedAsmOperand*> &Operands);
 159   bool ParseDirective(AsmToken DirectiveID);
 160
 161   bool MatchAndEmitInstruction(SMLoc IDLoc,
 162                                SmallVectorImpl<MCParsedAsmOperand*> &Operands,
 163                                MCStreamer &Out);
 164 };
 165 } // end anonymous namespace
 166
 167 namespace {
 168
 169 /// ARMOperand - Instances of this class represent a parsed ARM machine
 170 /// instruction.
 171 class ARMOperand : public MCParsedAsmOperand {
 172   enum KindTy {
 173     CondCode,
 174     CCOut,
 175     CoprocNum,
 176     CoprocReg,
 177     Immediate,
 178     MemBarrierOpt,
 179     Memory,
 180     PostIndexRegister,
 181     MSRMask,
 182     ProcIFlags,
 183     Register,
 184     RegisterList,
 185     DPRRegisterList,
 186     SPRRegisterList,
 187     ShiftedRegister,
 188     ShiftedImmediate,
 189     ShifterImmediate,
 190     RotateImmediate,
 191     BitfieldDescriptor,
 192     Token
 193   } Kind;
 194
 195   SMLoc StartLoc, EndLoc;
 196   SmallVector<unsigned, 8> Registers;
 197
 198   union {
 199     struct {
 200       ARMCC::CondCodes Val;
 201     } CC;
 202
 203     struct {
 204       ARM_MB::MemBOpt Val;
 205     } MBOpt;
 206
 207     struct {
 208       unsigned Val;
 209     } Cop;
 210
 211     struct {
 212       ARM_PROC::IFlags Val;
 213     } IFlags;
 214
 215     struct {
 216       unsigned Val;
 217     } MMask;
 218
 219     struct {
 220       const char *Data;
 221       unsigned Length;
 222     } Tok;
 223
 224     struct {
 225       unsigned RegNum;
 226     } Reg;
 227
 228     struct {
 229       const MCExpr *Val;
 230     } Imm;
 231
 232     /// Combined record for all forms of ARM address expressions.
 233     struct {
 234       unsigned BaseRegNum;
 235       // Offset is in OffsetReg or OffsetImm. If both are zero, no offset
 236       // was specified.
 237       const MCConstantExpr *OffsetImm;  // Offset immediate value
 238       unsigned OffsetRegNum;    // Offset register num, when OffsetImm == NULL
 239       ARM_AM::ShiftOpc ShiftType; // Shift type for OffsetReg
 240       unsigned ShiftImm;      // shift for OffsetReg.
 241       unsigned isNegative : 1;  // Negated OffsetReg? (~'U' bit)
 242     } Mem;
 243
 244     struct {
 245       unsigned RegNum;
 246       bool isAdd;
 247       ARM_AM::ShiftOpc ShiftTy;
 248       unsigned ShiftImm;
 249     } PostIdxReg;
 250
 251     struct {
 252       bool isASR;
 253       unsigned Imm;
 254     } ShifterImm;
 255     struct {
 256       ARM_AM::ShiftOpc ShiftTy;
 257       unsigned SrcReg;
 258       unsigned ShiftReg;
 259       unsigned ShiftImm;
 260     } RegShiftedReg;
 261     struct {
 262       ARM_AM::ShiftOpc ShiftTy;
 263       unsigned SrcReg;
 264       unsigned ShiftImm;
 265     } RegShiftedImm;
 266     struct {
 267       unsigned Imm;
 268     } RotImm;
 269     struct {
 270       unsigned LSB;
 271       unsigned Width;
 272     } Bitfield;
 273   };
 274
 275   ARMOperand(KindTy K) : MCParsedAsmOperand(), Kind(K) {}
 276 public:
 277   ARMOperand(const ARMOperand &o) : MCParsedAsmOperand() {
 278     Kind = o.Kind;
 279     StartLoc = o.StartLoc;
 280     EndLoc = o.EndLoc;
 281     switch (Kind) {
 282     case CondCode:
 283       CC = o.CC;
 284       break;
 285     case Token:
 286       Tok = o.Tok;
 287       break;
 288     case CCOut:
 289     case Register:
 290       Reg = o.Reg;
 291       break;
 292     case RegisterList:
 293     case DPRRegisterList:
 294     case SPRRegisterList:
 295       Registers = o.Registers;
 296       break;
 297     case CoprocNum:
 298     case CoprocReg:
 299       Cop = o.Cop;
 300       break;
 301     case Immediate:
 302       Imm = o.Imm;
 303       break;
 304     case MemBarrierOpt:
 305       MBOpt = o.MBOpt;
 306       break;
 307     case Memory:
 308       Mem = o.Mem;
 309       break;
 310     case PostIndexRegister:
 311       PostIdxReg = o.PostIdxReg;
 312       break;
 313     case MSRMask:
 314       MMask = o.MMask;
 315       break;
 316     case ProcIFlags:
 317       IFlags = o.IFlags;
 318       break;
 319     case ShifterImmediate:
 320       ShifterImm = o.ShifterImm;
 321       break;
 322     case ShiftedRegister:
 323       RegShiftedReg = o.RegShiftedReg;
 324       break;
 325     case ShiftedImmediate:
 326       RegShiftedImm = o.RegShiftedImm;
 327       break;
 328     case RotateImmediate:
 329       RotImm = o.RotImm;
 330       break;
 331     case BitfieldDescriptor:
 332       Bitfield = o.Bitfield;
 333       break;
 334     }
 335   }
 336
 337   /// getStartLoc - Get the location of the first token of this operand.
 338   SMLoc getStartLoc() const { return StartLoc; }
 339   /// getEndLoc - Get the location of the last token of this operand.
 340   SMLoc getEndLoc() const { return EndLoc; }
 341
 342   ARMCC::CondCodes getCondCode() const {
 343     assert(Kind == CondCode && "Invalid access!");
 344     return CC.Val;
 345   }
 346
 347   unsigned getCoproc() const {
 348     assert((Kind == CoprocNum || Kind == CoprocReg) && "Invalid access!");
 349     return Cop.Val;
 350   }
 351
 352   StringRef getToken() const {
 353     assert(Kind == Token && "Invalid access!");
 354     return StringRef(Tok.Data, Tok.Length);
 355   }
 356
 357   unsigned getReg() const {
 358     assert((Kind == Register || Kind == CCOut) && "Invalid access!");
 359     return Reg.RegNum;
 360   }
 361
 362   const SmallVectorImpl<unsigned> &getRegList() const {
 363     assert((Kind == RegisterList || Kind == DPRRegisterList ||
 364             Kind == SPRRegisterList) && "Invalid access!");
 365     return Registers;
 366   }
 367
 368   const MCExpr *getImm() const {
 369     assert(Kind == Immediate && "Invalid access!");
 370     return Imm.Val;
 371   }
 372
 373   ARM_MB::MemBOpt getMemBarrierOpt() const {
 374     assert(Kind == MemBarrierOpt && "Invalid access!");
 375     return MBOpt.Val;
 376   }
 377
 378   ARM_PROC::IFlags getProcIFlags() const {
 379     assert(Kind == ProcIFlags && "Invalid access!");
 380     return IFlags.Val;
 381   }
 382
 383   unsigned getMSRMask() const {
 384     assert(Kind == MSRMask && "Invalid access!");
 385     return MMask.Val;
 386   }
 387
 388   bool isCoprocNum() const { return Kind == CoprocNum; }
 389   bool isCoprocReg() const { return Kind == CoprocReg; }
 390   bool isCondCode() const { return Kind == CondCode; }
 391   bool isCCOut() const { return Kind == CCOut; }
 392   bool isImm() const { return Kind == Immediate; }
 393   bool isImm0_255() const {
 394     if (Kind != Immediate)
 395       return false;
 396     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 397     if (!CE) return false;
 398     int64_t Value = CE->getValue();
 399     return Value >= 0 && Value < 256;
 400   }
 401   bool isImm0_7() const {
 402     if (Kind != Immediate)
 403       return false;
 404     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 405     if (!CE) return false;
 406     int64_t Value = CE->getValue();
 407     return Value >= 0 && Value < 8;
 408   }
 409   bool isImm0_15() const {
 410     if (Kind != Immediate)
 411       return false;
 412     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 413     if (!CE) return false;
 414     int64_t Value = CE->getValue();
 415     return Value >= 0 && Value < 16;
 416   }
 417   bool isImm0_31() const {
 418     if (Kind != Immediate)
 419       return false;
 420     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 421     if (!CE) return false;
 422     int64_t Value = CE->getValue();
 423     return Value >= 0 && Value < 32;
 424   }
 425   bool isImm1_16() const {
 426     if (Kind != Immediate)
 427       return false;
 428     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 429     if (!CE) return false;
 430     int64_t Value = CE->getValue();
 431     return Value > 0 && Value < 17;
 432   }
 433   bool isImm1_32() const {
 434     if (Kind != Immediate)
 435       return false;
 436     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 437     if (!CE) return false;
 438     int64_t Value = CE->getValue();
 439     return Value > 0 && Value < 33;
 440   }
 441   bool isImm0_65535() const {
 442     if (Kind != Immediate)
 443       return false;
 444     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 445     if (!CE) return false;
 446     int64_t Value = CE->getValue();
 447     return Value >= 0 && Value < 65536;
 448   }
 449   bool isImm0_65535Expr() const {
 450     if (Kind != Immediate)
 451       return false;
 452     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 453     // If it's not a constant expression, it'll generate a fixup and be
 454     // handled later.
 455     if (!CE) return true;
 456     int64_t Value = CE->getValue();
 457     return Value >= 0 && Value < 65536;
 458   }
 459   bool isImm24bit() const {
 460     if (Kind != Immediate)
 461       return false;
 462     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 463     if (!CE) return false;
 464     int64_t Value = CE->getValue();
 465     return Value >= 0 && Value <= 0xffffff;
 466   }
 467   bool isPKHLSLImm() const {
 468     if (Kind != Immediate)
 469       return false;
 470     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 471     if (!CE) return false;
 472     int64_t Value = CE->getValue();
 473     return Value >= 0 && Value < 32;
 474   }
 475   bool isPKHASRImm() const {
 476     if (Kind != Immediate)
 477       return false;
 478     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 479     if (!CE) return false;
 480     int64_t Value = CE->getValue();
 481     return Value > 0 && Value <= 32;
 482   }
 483   bool isARMSOImm() const {
 484     if (Kind != Immediate)
 485       return false;
 486     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 487     if (!CE) return false;
 488     int64_t Value = CE->getValue();
 489     return ARM_AM::getSOImmVal(Value) != -1;
 490   }
 491   bool isT2SOImm() const {
 492     if (Kind != Immediate)
 493       return false;
 494     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 495     if (!CE) return false;
 496     int64_t Value = CE->getValue();
 497     return ARM_AM::getT2SOImmVal(Value) != -1;
 498   }
 499   bool isSetEndImm() const {
 500     if (Kind != Immediate)
 501       return false;
 502     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 503     if (!CE) return false;
 504     int64_t Value = CE->getValue();
 505     return Value == 1 || Value == 0;
 506   }
 507   bool isReg() const { return Kind == Register; }
 508   bool isRegList() const { return Kind == RegisterList; }
 509   bool isDPRRegList() const { return Kind == DPRRegisterList; }
 510   bool isSPRRegList() const { return Kind == SPRRegisterList; }
 511   bool isToken() const { return Kind == Token; }
 512   bool isMemBarrierOpt() const { return Kind == MemBarrierOpt; }
 513   bool isMemory() const { return Kind == Memory; }
 514   bool isShifterImm() const { return Kind == ShifterImmediate; }
 515   bool isRegShiftedReg() const { return Kind == ShiftedRegister; }
 516   bool isRegShiftedImm() const { return Kind == ShiftedImmediate; }
 517   bool isRotImm() const { return Kind == RotateImmediate; }
 518   bool isBitfield() const { return Kind == BitfieldDescriptor; }
 519   bool isPostIdxRegShifted() const { return Kind == PostIndexRegister; }
 520   bool isPostIdxReg() const {
 521     return Kind == PostIndexRegister && PostIdxReg.ShiftTy == ARM_AM::no_shift;
 522   }
 523   bool isMemNoOffset() const {
 524     if (Kind != Memory)
 525       return false;
 526     // No offset of any kind.
 527     return Mem.OffsetRegNum == 0 && Mem.OffsetImm == 0;
 528   }
 529   bool isAddrMode2() const {
 530     if (Kind != Memory)
 531       return false;
 532     // Check for register offset.
 533     if (Mem.OffsetRegNum) return true;
 534     // Immediate offset in range [-4095, 4095].
 535     if (!Mem.OffsetImm) return true;
 536     int64_t Val = Mem.OffsetImm->getValue();
 537     return Val > -4096 && Val < 4096;
 538   }
 539   bool isAM2OffsetImm() const {
 540     if (Kind != Immediate)
 541       return false;
 542     // Immediate offset in range [-4095, 4095].
 543     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 544     if (!CE) return false;
 545     int64_t Val = CE->getValue();
 546     return Val > -4096 && Val < 4096;
 547   }
 548   bool isAddrMode3() const {
 549     if (Kind != Memory)
 550       return false;
 551     // No shifts are legal for AM3.
 552     if (Mem.ShiftType != ARM_AM::no_shift) return false;
 553     // Check for register offset.
 554     if (Mem.OffsetRegNum) return true;
 555     // Immediate offset in range [-255, 255].
 556     if (!Mem.OffsetImm) return true;
 557     int64_t Val = Mem.OffsetImm->getValue();
 558     return Val > -256 && Val < 256;
 559   }
 560   bool isAM3Offset() const {
 561     if (Kind != Immediate && Kind != PostIndexRegister)
 562       return false;
 563     if (Kind == PostIndexRegister)
 564       return PostIdxReg.ShiftTy == ARM_AM::no_shift;
 565     // Immediate offset in range [-255, 255].
 566     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 567     if (!CE) return false;
 568     int64_t Val = CE->getValue();
 569     // Special case, #-0 is INT32_MIN.
 570     return (Val > -256 && Val < 256) || Val == INT32_MIN;
 571   }
 572   bool isAddrMode5() const {
 573     if (Kind != Memory)
 574       return false;
 575     // Check for register offset.
 576     if (Mem.OffsetRegNum) return false;
 577     // Immediate offset in range [-1020, 1020] and a multiple of 4.
 578     if (!Mem.OffsetImm) return true;
 579     int64_t Val = Mem.OffsetImm->getValue();
 580     return Val >= -1020 && Val <= 1020 && ((Val & 3) == 0);
 581   }
 582   bool isMemRegOffset() const {
 583     if (Kind != Memory || !Mem.OffsetRegNum)
 584       return false;
 585     return true;
 586   }
 587   bool isMemThumbRR() const {
 588     // Thumb reg+reg addressing is simple. Just two registers, a base and
 589     // an offset. No shifts, negations or any other complicating factors.
 590     if (Kind != Memory || !Mem.OffsetRegNum || Mem.isNegative ||
 591         Mem.ShiftType != ARM_AM::no_shift)
 592       return false;
 593     return true;
 594   }
 595   bool isMemImm8Offset() const {
 596     if (Kind != Memory || Mem.OffsetRegNum != 0)
 597       return false;
 598     // Immediate offset in range [-255, 255].
 599     if (!Mem.OffsetImm) return true;
 600     int64_t Val = Mem.OffsetImm->getValue();
 601     return Val > -256 && Val < 256;
 602   }
 603   bool isMemImm12Offset() const {
 604     // If we have an immediate that's not a constant, treat it as a label
 605     // reference needing a fixup. If it is a constant, it's something else
 606     // and we reject it.
 607     if (Kind == Immediate && !isa<MCConstantExpr>(getImm()))
 608       return true;
 609
 610     if (Kind != Memory || Mem.OffsetRegNum != 0)
 611       return false;
 612     // Immediate offset in range [-4095, 4095].
 613     if (!Mem.OffsetImm) return true;
 614     int64_t Val = Mem.OffsetImm->getValue();
 615     return Val > -4096 && Val < 4096;
 616   }
 617   bool isPostIdxImm8() const {
 618     if (Kind != Immediate)
 619       return false;
 620     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 621     if (!CE) return false;
 622     int64_t Val = CE->getValue();
 623     return Val > -256 && Val < 256;
 624   }
 625
 626   bool isMSRMask() const { return Kind == MSRMask; }
 627   bool isProcIFlags() const { return Kind == ProcIFlags; }
 628
 629   void addExpr(MCInst &Inst, const MCExpr *Expr) const {
 630     // Add as immediates when possible.  Null MCExpr = 0.
 631     if (Expr == 0)
 632       Inst.addOperand(MCOperand::CreateImm(0));
 633     else if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr))
 634       Inst.addOperand(MCOperand::CreateImm(CE->getValue()));
 635     else
 636       Inst.addOperand(MCOperand::CreateExpr(Expr));
 637   }
 638
 639   void addCondCodeOperands(MCInst &Inst, unsigned N) const {
 640     assert(N == 2 && "Invalid number of operands!");
 641     Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode())));
 642     unsigned RegNum = getCondCode() == ARMCC::AL ? 0: ARM::CPSR;
 643     Inst.addOperand(MCOperand::CreateReg(RegNum));
 644   }
 645
 646   void addCoprocNumOperands(MCInst &Inst, unsigned N) const {
 647     assert(N == 1 && "Invalid number of operands!");
 648     Inst.addOperand(MCOperand::CreateImm(getCoproc()));
 649   }
 650
 651   void addCoprocRegOperands(MCInst &Inst, unsigned N) const {
 652     assert(N == 1 && "Invalid number of operands!");
 653     Inst.addOperand(MCOperand::CreateImm(getCoproc()));
 654   }
 655
 656   void addCCOutOperands(MCInst &Inst, unsigned N) const {
 657     assert(N == 1 && "Invalid number of operands!");
 658     Inst.addOperand(MCOperand::CreateReg(getReg()));
 659   }
 660
 661   void addRegOperands(MCInst &Inst, unsigned N) const {
 662     assert(N == 1 && "Invalid number of operands!");
 663     Inst.addOperand(MCOperand::CreateReg(getReg()));
 664   }
 665
 666   void addRegShiftedRegOperands(MCInst &Inst, unsigned N) const {
 667     assert(N == 3 && "Invalid number of operands!");
 668     assert(isRegShiftedReg() && "addRegShiftedRegOperands() on non RegShiftedReg!");
 669     Inst.addOperand(MCOperand::CreateReg(RegShiftedReg.SrcReg));
 670     Inst.addOperand(MCOperand::CreateReg(RegShiftedReg.ShiftReg));
 671     Inst.addOperand(MCOperand::CreateImm(
 672       ARM_AM::getSORegOpc(RegShiftedReg.ShiftTy, RegShiftedReg.ShiftImm)));
 673   }
 674
 675   void addRegShiftedImmOperands(MCInst &Inst, unsigned N) const {
 676     assert(N == 2 && "Invalid number of operands!");
 677     assert(isRegShiftedImm() && "addRegShiftedImmOperands() on non RegShiftedImm!");
 678     Inst.addOperand(MCOperand::CreateReg(RegShiftedImm.SrcReg));
 679     Inst.addOperand(MCOperand::CreateImm(
 680       ARM_AM::getSORegOpc(RegShiftedImm.ShiftTy, RegShiftedImm.ShiftImm)));
 681   }
 682
 683
 684   void addShifterImmOperands(MCInst &Inst, unsigned N) const {
 685     assert(N == 1 && "Invalid number of operands!");
 686     Inst.addOperand(MCOperand::CreateImm((ShifterImm.isASR << 5) |
 687                                          ShifterImm.Imm));
 688   }
 689
 690   void addRegListOperands(MCInst &Inst, unsigned N) const {
 691     assert(N == 1 && "Invalid number of operands!");
 692     const SmallVectorImpl<unsigned> &RegList = getRegList();
 693     for (SmallVectorImpl<unsigned>::const_iterator
 694            I = RegList.begin(), E = RegList.end(); I != E; ++I)
 695       Inst.addOperand(MCOperand::CreateReg(*I));
 696   }
 697
 698   void addDPRRegListOperands(MCInst &Inst, unsigned N) const {
 699     addRegListOperands(Inst, N);
 700   }
 701
 702   void addSPRRegListOperands(MCInst &Inst, unsigned N) const {
 703     addRegListOperands(Inst, N);
 704   }
 705
 706   void addRotImmOperands(MCInst &Inst, unsigned N) const {
 707     assert(N == 1 && "Invalid number of operands!");
 708     // Encoded as val>>3. The printer handles display as 8, 16, 24.
 709     Inst.addOperand(MCOperand::CreateImm(RotImm.Imm >> 3));
 710   }
 711
 712   void addBitfieldOperands(MCInst &Inst, unsigned N) const {
 713     assert(N == 1 && "Invalid number of operands!");
 714     // Munge the lsb/width into a bitfield mask.
 715     unsigned lsb = Bitfield.LSB;
 716     unsigned width = Bitfield.Width;
 717     // Make a 32-bit mask w/ the referenced bits clear and all other bits set.
 718     uint32_t Mask = ~(((uint32_t)0xffffffff >> lsb) << (32 - width) >>
 719                       (32 - (lsb + width)));
 720     Inst.addOperand(MCOperand::CreateImm(Mask));
 721   }
 722
 723   void addImmOperands(MCInst &Inst, unsigned N) const {
 724     assert(N == 1 && "Invalid number of operands!");
 725     addExpr(Inst, getImm());
 726   }
 727
 728   void addImm0_255Operands(MCInst &Inst, unsigned N) const {
 729     assert(N == 1 && "Invalid number of operands!");
 730     addExpr(Inst, getImm());
 731   }
 732
 733   void addImm0_7Operands(MCInst &Inst, unsigned N) const {
 734     assert(N == 1 && "Invalid number of operands!");
 735     addExpr(Inst, getImm());
 736   }
 737
 738   void addImm0_15Operands(MCInst &Inst, unsigned N) const {
 739     assert(N == 1 && "Invalid number of operands!");
 740     addExpr(Inst, getImm());
 741   }
 742
 743   void addImm0_31Operands(MCInst &Inst, unsigned N) const {
 744     assert(N == 1 && "Invalid number of operands!");
 745     addExpr(Inst, getImm());
 746   }
 747
 748   void addImm1_16Operands(MCInst &Inst, unsigned N) const {
 749     assert(N == 1 && "Invalid number of operands!");
 750     // The constant encodes as the immediate-1, and we store in the instruction
 751     // the bits as encoded, so subtract off one here.
 752     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 753     Inst.addOperand(MCOperand::CreateImm(CE->getValue() - 1));
 754   }
 755
 756   void addImm1_32Operands(MCInst &Inst, unsigned N) const {
 757     assert(N == 1 && "Invalid number of operands!");
 758     // The constant encodes as the immediate-1, and we store in the instruction
 759     // the bits as encoded, so subtract off one here.
 760     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 761     Inst.addOperand(MCOperand::CreateImm(CE->getValue() - 1));
 762   }
 763
 764   void addImm0_65535Operands(MCInst &Inst, unsigned N) const {
 765     assert(N == 1 && "Invalid number of operands!");
 766     addExpr(Inst, getImm());
 767   }
 768
 769   void addImm0_65535ExprOperands(MCInst &Inst, unsigned N) const {
 770     assert(N == 1 && "Invalid number of operands!");
 771     addExpr(Inst, getImm());
 772   }
 773
 774   void addImm24bitOperands(MCInst &Inst, unsigned N) const {
 775     assert(N == 1 && "Invalid number of operands!");
 776     addExpr(Inst, getImm());
 777   }
 778
 779   void addPKHLSLImmOperands(MCInst &Inst, unsigned N) const {
 780     assert(N == 1 && "Invalid number of operands!");
 781     addExpr(Inst, getImm());
 782   }
 783
 784   void addPKHASRImmOperands(MCInst &Inst, unsigned N) const {
 785     assert(N == 1 && "Invalid number of operands!");
 786     // An ASR value of 32 encodes as 0, so that's how we want to add it to
 787     // the instruction as well.
 788     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 789     int Val = CE->getValue();
 790     Inst.addOperand(MCOperand::CreateImm(Val == 32 ? 0 : Val));
 791   }
 792
 793   void addARMSOImmOperands(MCInst &Inst, unsigned N) const {
 794     assert(N == 1 && "Invalid number of operands!");
 795     addExpr(Inst, getImm());
 796   }
 797
 798   void addT2SOImmOperands(MCInst &Inst, unsigned N) const {
 799     assert(N == 1 && "Invalid number of operands!");
 800     addExpr(Inst, getImm());
 801   }
 802
 803   void addSetEndImmOperands(MCInst &Inst, unsigned N) const {
 804     assert(N == 1 && "Invalid number of operands!");
 805     addExpr(Inst, getImm());
 806   }
 807
 808   void addMemBarrierOptOperands(MCInst &Inst, unsigned N) const {
 809     assert(N == 1 && "Invalid number of operands!");
 810     Inst.addOperand(MCOperand::CreateImm(unsigned(getMemBarrierOpt())));
 811   }
 812
 813   void addMemNoOffsetOperands(MCInst &Inst, unsigned N) const {
 814     assert(N == 1 && "Invalid number of operands!");
 815     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
 816   }
 817
 818   void addAddrMode2Operands(MCInst &Inst, unsigned N) const {
 819     assert(N == 3 && "Invalid number of operands!");
 820     int32_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() : 0;
 821     if (!Mem.OffsetRegNum) {
 822       ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
 823       // Special case for #-0
 824       if (Val == INT32_MIN) Val = 0;
 825       if (Val < 0) Val = -Val;
 826       Val = ARM_AM::getAM2Opc(AddSub, Val, ARM_AM::no_shift);
 827     } else {
 828       // For register offset, we encode the shift type and negation flag
 829       // here.
 830       Val = ARM_AM::getAM2Opc(Mem.isNegative ? ARM_AM::sub : ARM_AM::add,
 831                               0, Mem.ShiftType);
 832     }
 833     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
 834     Inst.addOperand(MCOperand::CreateReg(Mem.OffsetRegNum));
 835     Inst.addOperand(MCOperand::CreateImm(Val));
 836   }
 837
 838   void addAM2OffsetImmOperands(MCInst &Inst, unsigned N) const {
 839     assert(N == 2 && "Invalid number of operands!");
 840     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 841     assert(CE && "non-constant AM2OffsetImm operand!");
 842     int32_t Val = CE->getValue();
 843     ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
 844     // Special case for #-0
 845     if (Val == INT32_MIN) Val = 0;
 846     if (Val < 0) Val = -Val;
 847     Val = ARM_AM::getAM2Opc(AddSub, Val, ARM_AM::no_shift);
 848     Inst.addOperand(MCOperand::CreateReg(0));
 849     Inst.addOperand(MCOperand::CreateImm(Val));
 850   }
 851
 852   void addAddrMode3Operands(MCInst &Inst, unsigned N) const {
 853     assert(N == 3 && "Invalid number of operands!");
 854     int32_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() : 0;
 855     if (!Mem.OffsetRegNum) {
 856       ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
 857       // Special case for #-0
 858       if (Val == INT32_MIN) Val = 0;
 859       if (Val < 0) Val = -Val;
 860       Val = ARM_AM::getAM3Opc(AddSub, Val);
 861     } else {
 862       // For register offset, we encode the shift type and negation flag
 863       // here.
 864       Val = ARM_AM::getAM3Opc(Mem.isNegative ? ARM_AM::sub : ARM_AM::add, 0);
 865     }
 866     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
 867     Inst.addOperand(MCOperand::CreateReg(Mem.OffsetRegNum));
 868     Inst.addOperand(MCOperand::CreateImm(Val));
 869   }
 870
 871   void addAM3OffsetOperands(MCInst &Inst, unsigned N) const {
 872     assert(N == 2 && "Invalid number of operands!");
 873     if (Kind == PostIndexRegister) {
 874       int32_t Val =
 875         ARM_AM::getAM3Opc(PostIdxReg.isAdd ? ARM_AM::add : ARM_AM::sub, 0);
 876       Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum));
 877       Inst.addOperand(MCOperand::CreateImm(Val));
 878       return;
 879     }
 880
 881     // Constant offset.
 882     const MCConstantExpr *CE = static_cast<const MCConstantExpr*>(getImm());
 883     int32_t Val = CE->getValue();
 884     ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
 885     // Special case for #-0
 886     if (Val == INT32_MIN) Val = 0;
 887     if (Val < 0) Val = -Val;
 888     Val = ARM_AM::getAM3Opc(AddSub, Val);
 889     Inst.addOperand(MCOperand::CreateReg(0));
 890     Inst.addOperand(MCOperand::CreateImm(Val));
 891   }
 892
 893   void addAddrMode5Operands(MCInst &Inst, unsigned N) const {
 894     assert(N == 2 && "Invalid number of operands!");
 895     // The lower two bits are always zero and as such are not encoded.
 896     int32_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() / 4 : 0;
 897     ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
 898     // Special case for #-0
 899     if (Val == INT32_MIN) Val = 0;
 900     if (Val < 0) Val = -Val;
 901     Val = ARM_AM::getAM5Opc(AddSub, Val);
 902     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
 903     Inst.addOperand(MCOperand::CreateImm(Val));
 904   }
 905
 906   void addMemImm8OffsetOperands(MCInst &Inst, unsigned N) const {
 907     assert(N == 2 && "Invalid number of operands!");
 908     int64_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() : 0;
 909     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
 910     Inst.addOperand(MCOperand::CreateImm(Val));
 911   }
 912
 913   void addMemImm12OffsetOperands(MCInst &Inst, unsigned N) const {
 914     assert(N == 2 && "Invalid number of operands!");
 915     // If this is an immediate, it's a label reference.
 916     if (Kind == Immediate) {
 917       addExpr(Inst, getImm());
 918       Inst.addOperand(MCOperand::CreateImm(0));
 919       return;
 920     }
 921
 922     // Otherwise, it's a normal memory reg+offset.
 923     int64_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() : 0;
 924     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
 925     Inst.addOperand(MCOperand::CreateImm(Val));
 926   }
 927
 928   void addMemRegOffsetOperands(MCInst &Inst, unsigned N) const {
 929     assert(N == 3 && "Invalid number of operands!");
 930     unsigned Val = ARM_AM::getAM2Opc(Mem.isNegative ? ARM_AM::sub : ARM_AM::add,
 931                                      Mem.ShiftImm, Mem.ShiftType);
 932     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
 933     Inst.addOperand(MCOperand::CreateReg(Mem.OffsetRegNum));
 934     Inst.addOperand(MCOperand::CreateImm(Val));
 935   }
 936
 937   void addMemThumbRROperands(MCInst &Inst, unsigned N) const {
 938     assert(N == 2 && "Invalid number of operands!");
 939     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
 940     Inst.addOperand(MCOperand::CreateReg(Mem.OffsetRegNum));
 941   }
 942
 943   void addPostIdxImm8Operands(MCInst &Inst, unsigned N) const {
 944     assert(N == 1 && "Invalid number of operands!");
 945     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 946     assert(CE && "non-constant post-idx-imm8 operand!");
 947     int Imm = CE->getValue();
 948     bool isAdd = Imm >= 0;
 949     Imm = (Imm < 0 ? -Imm : Imm) | (int)isAdd << 8;
 950     Inst.addOperand(MCOperand::CreateImm(Imm));
 951   }
 952
 953   void addPostIdxRegOperands(MCInst &Inst, unsigned N) const {
 954     assert(N == 2 && "Invalid number of operands!");
 955     Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum));
 956     Inst.addOperand(MCOperand::CreateImm(PostIdxReg.isAdd));
 957   }
 958
 959   void addPostIdxRegShiftedOperands(MCInst &Inst, unsigned N) const {
 960     assert(N == 2 && "Invalid number of operands!");
 961     Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum));
 962     // The sign, shift type, and shift amount are encoded in a single operand
 963     // using the AM2 encoding helpers.
 964     ARM_AM::AddrOpc opc = PostIdxReg.isAdd ? ARM_AM::add : ARM_AM::sub;
 965     unsigned Imm = ARM_AM::getAM2Opc(opc, PostIdxReg.ShiftImm,
 966                                      PostIdxReg.ShiftTy);
 967     Inst.addOperand(MCOperand::CreateImm(Imm));
 968   }
 969
 970   void addMSRMaskOperands(MCInst &Inst, unsigned N) const {
 971     assert(N == 1 && "Invalid number of operands!");
 972     Inst.addOperand(MCOperand::CreateImm(unsigned(getMSRMask())));
 973   }
 974
 975   void addProcIFlagsOperands(MCInst &Inst, unsigned N) const {
 976     assert(N == 1 && "Invalid number of operands!");
 977     Inst.addOperand(MCOperand::CreateImm(unsigned(getProcIFlags())));
 978   }
 979
 980   virtual void print(raw_ostream &OS) const;
 981
 982   static ARMOperand *CreateCondCode(ARMCC::CondCodes CC, SMLoc S) {
 983     ARMOperand *Op = new ARMOperand(CondCode);
 984     Op->CC.Val = CC;
 985     Op->StartLoc = S;
 986     Op->EndLoc = S;
 987     return Op;
 988   }
 989
 990   static ARMOperand *CreateCoprocNum(unsigned CopVal, SMLoc S) {
 991     ARMOperand *Op = new ARMOperand(CoprocNum);
 992     Op->Cop.Val = CopVal;
 993     Op->StartLoc = S;
 994     Op->EndLoc = S;
 995     return Op;
 996   }
 997
 998   static ARMOperand *CreateCoprocReg(unsigned CopVal, SMLoc S) {
 999     ARMOperand *Op = new ARMOperand(CoprocReg);
1000     Op->Cop.Val = CopVal;
1001     Op->StartLoc = S;
1002     Op->EndLoc = S;
1003     return Op;
1004   }
1005
1006   static ARMOperand *CreateCCOut(unsigned RegNum, SMLoc S) {
1007     ARMOperand *Op = new ARMOperand(CCOut);
1008     Op->Reg.RegNum = RegNum;
1009     Op->StartLoc = S;
1010     Op->EndLoc = S;
1011     return Op;
1012   }
1013
1014   static ARMOperand *CreateToken(StringRef Str, SMLoc S) {
1015     ARMOperand *Op = new ARMOperand(Token);
1016     Op->Tok.Data = Str.data();
1017     Op->Tok.Length = Str.size();
1018     Op->StartLoc = S;
1019     Op->EndLoc = S;
1020     return Op;
1021   }
1022
1023   static ARMOperand *CreateReg(unsigned RegNum, SMLoc S, SMLoc E) {
1024     ARMOperand *Op = new ARMOperand(Register);
1025     Op->Reg.RegNum = RegNum;
1026     Op->StartLoc = S;
1027     Op->EndLoc = E;
1028     return Op;
1029   }
1030
1031   static ARMOperand *CreateShiftedRegister(ARM_AM::ShiftOpc ShTy,
1032                                            unsigned SrcReg,
1033                                            unsigned ShiftReg,
1034                                            unsigned ShiftImm,
1035                                            SMLoc S, SMLoc E) {
1036     ARMOperand *Op = new ARMOperand(ShiftedRegister);
1037     Op->RegShiftedReg.ShiftTy = ShTy;
1038     Op->RegShiftedReg.SrcReg = SrcReg;
1039     Op->RegShiftedReg.ShiftReg = ShiftReg;
1040     Op->RegShiftedReg.ShiftImm = ShiftImm;
1041     Op->StartLoc = S;
1042     Op->EndLoc = E;
1043     return Op;
1044   }
1045
1046   static ARMOperand *CreateShiftedImmediate(ARM_AM::ShiftOpc ShTy,
1047                                             unsigned SrcReg,
1048                                             unsigned ShiftImm,
1049                                             SMLoc S, SMLoc E) {
1050     ARMOperand *Op = new ARMOperand(ShiftedImmediate);
1051     Op->RegShiftedImm.ShiftTy = ShTy;
1052     Op->RegShiftedImm.SrcReg = SrcReg;
1053     Op->RegShiftedImm.ShiftImm = ShiftImm;
1054     Op->StartLoc = S;
1055     Op->EndLoc = E;
1056     return Op;
1057   }
1058
1059   static ARMOperand *CreateShifterImm(bool isASR, unsigned Imm,
1060                                    SMLoc S, SMLoc E) {
1061     ARMOperand *Op = new ARMOperand(ShifterImmediate);
1062     Op->ShifterImm.isASR = isASR;
1063     Op->ShifterImm.Imm = Imm;
1064     Op->StartLoc = S;
1065     Op->EndLoc = E;
1066     return Op;
1067   }
1068
1069   static ARMOperand *CreateRotImm(unsigned Imm, SMLoc S, SMLoc E) {
1070     ARMOperand *Op = new ARMOperand(RotateImmediate);
1071     Op->RotImm.Imm = Imm;
1072     Op->StartLoc = S;
1073     Op->EndLoc = E;
1074     return Op;
1075   }
1076
1077   static ARMOperand *CreateBitfield(unsigned LSB, unsigned Width,
1078                                     SMLoc S, SMLoc E) {
1079     ARMOperand *Op = new ARMOperand(BitfieldDescriptor);
1080     Op->Bitfield.LSB = LSB;
1081     Op->Bitfield.Width = Width;
1082     Op->StartLoc = S;
1083     Op->EndLoc = E;
1084     return Op;
1085   }
1086
1087   static ARMOperand *
1088   CreateRegList(const SmallVectorImpl<std::pair<unsigned, SMLoc> > &Regs,
1089                 SMLoc StartLoc, SMLoc EndLoc) {
1090     KindTy Kind = RegisterList;
1091
1092     if (llvm::ARMMCRegisterClasses[ARM::DPRRegClassID].
1093         contains(Regs.front().first))
1094       Kind = DPRRegisterList;
1095     else if (llvm::ARMMCRegisterClasses[ARM::SPRRegClassID].
1096              contains(Regs.front().first))
1097       Kind = SPRRegisterList;
1098
1099     ARMOperand *Op = new ARMOperand(Kind);
1100     for (SmallVectorImpl<std::pair<unsigned, SMLoc> >::const_iterator
1101            I = Regs.begin(), E = Regs.end(); I != E; ++I)
1102       Op->Registers.push_back(I->first);
1103     array_pod_sort(Op->Registers.begin(), Op->Registers.end());
1104     Op->StartLoc = StartLoc;
1105     Op->EndLoc = EndLoc;
1106     return Op;
1107   }
1108
1109   static ARMOperand *CreateImm(const MCExpr *Val, SMLoc S, SMLoc E) {
1110     ARMOperand *Op = new ARMOperand(Immediate);
1111     Op->Imm.Val = Val;
1112     Op->StartLoc = S;
1113     Op->EndLoc = E;
1114     return Op;
1115   }
1116
1117   static ARMOperand *CreateMem(unsigned BaseRegNum,
1118                                const MCConstantExpr *OffsetImm,
1119                                unsigned OffsetRegNum,
1120                                ARM_AM::ShiftOpc ShiftType,
1121                                unsigned ShiftImm,
1122                                bool isNegative,
1123                                SMLoc S, SMLoc E) {
1124     ARMOperand *Op = new ARMOperand(Memory);
1125     Op->Mem.BaseRegNum = BaseRegNum;
1126     Op->Mem.OffsetImm = OffsetImm;
1127     Op->Mem.OffsetRegNum = OffsetRegNum;
1128     Op->Mem.ShiftType = ShiftType;
1129     Op->Mem.ShiftImm = ShiftImm;
1130     Op->Mem.isNegative = isNegative;
1131     Op->StartLoc = S;
1132     Op->EndLoc = E;
1133     return Op;
1134   }
1135
1136   static ARMOperand *CreatePostIdxReg(unsigned RegNum, bool isAdd,
1137                                       ARM_AM::ShiftOpc ShiftTy,
1138                                       unsigned ShiftImm,
1139                                       SMLoc S, SMLoc E) {
1140     ARMOperand *Op = new ARMOperand(PostIndexRegister);
1141     Op->PostIdxReg.RegNum = RegNum;
1142     Op->PostIdxReg.isAdd = isAdd;
1143     Op->PostIdxReg.ShiftTy = ShiftTy;
1144     Op->PostIdxReg.ShiftImm = ShiftImm;
1145     Op->StartLoc = S;
1146     Op->EndLoc = E;
1147     return Op;
1148   }
1149
1150   static ARMOperand *CreateMemBarrierOpt(ARM_MB::MemBOpt Opt, SMLoc S) {
1151     ARMOperand *Op = new ARMOperand(MemBarrierOpt);
1152     Op->MBOpt.Val = Opt;
1153     Op->StartLoc = S;
1154     Op->EndLoc = S;
1155     return Op;
1156   }
1157
1158   static ARMOperand *CreateProcIFlags(ARM_PROC::IFlags IFlags, SMLoc S) {
1159     ARMOperand *Op = new ARMOperand(ProcIFlags);
1160     Op->IFlags.Val = IFlags;
1161     Op->StartLoc = S;
1162     Op->EndLoc = S;
1163     return Op;
1164   }
1165
1166   static ARMOperand *CreateMSRMask(unsigned MMask, SMLoc S) {
1167     ARMOperand *Op = new ARMOperand(MSRMask);
1168     Op->MMask.Val = MMask;
1169     Op->StartLoc = S;
1170     Op->EndLoc = S;
1171     return Op;
1172   }
1173 };
1174
1175 } // end anonymous namespace.
1176
1177 void ARMOperand::print(raw_ostream &OS) const {
1178   switch (Kind) {
1179   case CondCode:
1180     OS << "<ARMCC::" << ARMCondCodeToString(getCondCode()) << ">";
1181     break;
1182   case CCOut:
1183     OS << "<ccout " << getReg() << ">";
1184     break;
1185   case CoprocNum:
1186     OS << "<coprocessor number: " << getCoproc() << ">";
1187     break;
1188   case CoprocReg:
1189     OS << "<coprocessor register: " << getCoproc() << ">";
1190     break;
1191   case MSRMask:
1192     OS << "<mask: " << getMSRMask() << ">";
1193     break;
1194   case Immediate:
1195     getImm()->print(OS);
1196     break;
1197   case MemBarrierOpt:
1198     OS << "<ARM_MB::" << MemBOptToString(getMemBarrierOpt()) << ">";
1199     break;
1200   case Memory:
1201     OS << "<memory "
1202        << " base:" << Mem.BaseRegNum;
1203     OS << ">";
1204     break;
1205   case PostIndexRegister:
1206     OS << "post-idx register " << (PostIdxReg.isAdd ? "" : "-")
1207        << PostIdxReg.RegNum;
1208     if (PostIdxReg.ShiftTy != ARM_AM::no_shift)
1209       OS << ARM_AM::getShiftOpcStr(PostIdxReg.ShiftTy) << " "
1210          << PostIdxReg.ShiftImm;
1211     OS << ">";
1212     break;
1213   case ProcIFlags: {
1214     OS << "<ARM_PROC::";
1215     unsigned IFlags = getProcIFlags();
1216     for (int i=2; i >= 0; --i)
1217       if (IFlags & (1 << i))
1218         OS << ARM_PROC::IFlagsToString(1 << i);
1219     OS << ">";
1220     break;
1221   }
1222   case Register:
1223     OS << "<register " << getReg() << ">";
1224     break;
1225   case ShifterImmediate:
1226     OS << "<shift " << (ShifterImm.isASR ? "asr" : "lsl")
1227        << " #" << ShifterImm.Imm << ">";
1228     break;
1229   case ShiftedRegister:
1230     OS << "<so_reg_reg "
1231        << RegShiftedReg.SrcReg
1232        << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(RegShiftedReg.ShiftImm))
1233        << ", " << RegShiftedReg.ShiftReg << ", "
1234        << ARM_AM::getSORegOffset(RegShiftedReg.ShiftImm)
1235        << ">";
1236     break;
1237   case ShiftedImmediate:
1238     OS << "<so_reg_imm "
1239        << RegShiftedImm.SrcReg
1240        << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(RegShiftedImm.ShiftImm))
1241        << ", " << ARM_AM::getSORegOffset(RegShiftedImm.ShiftImm)
1242        << ">";
1243     break;
1244   case RotateImmediate:
1245     OS << "<ror " << " #" << (RotImm.Imm * 8) << ">";
1246     break;
1247   case BitfieldDescriptor:
1248     OS << "<bitfield " << "lsb: " << Bitfield.LSB
1249        << ", width: " << Bitfield.Width << ">";
1250     break;
1251   case RegisterList:
1252   case DPRRegisterList:
1253   case SPRRegisterList: {
1254     OS << "<register_list ";
1255
1256     const SmallVectorImpl<unsigned> &RegList = getRegList();
1257     for (SmallVectorImpl<unsigned>::const_iterator
1258            I = RegList.begin(), E = RegList.end(); I != E; ) {
1259       OS << *I;
1260       if (++I < E) OS << ", ";
1261     }
1262
1263     OS << ">";
1264     break;
1265   }
1266   case Token:
1267     OS << "'" << getToken() << "'";
1268     break;
1269   }
1270 }
1271
1272 /// @name Auto-generated Match Functions
1273 /// {
1274
1275 static unsigned MatchRegisterName(StringRef Name);
1276
1277 /// }
1278
1279 bool ARMAsmParser::ParseRegister(unsigned &RegNo,
1280                                  SMLoc &StartLoc, SMLoc &EndLoc) {
1281   RegNo = tryParseRegister();
1282
1283   return (RegNo == (unsigned)-1);
1284 }
1285
1286 /// Try to parse a register name.  The token must be an Identifier when called,
1287 /// and if it is a register name the token is eaten and the register number is
1288 /// returned.  Otherwise return -1.
1289 ///
1290 int ARMAsmParser::tryParseRegister() {
1291   const AsmToken &Tok = Parser.getTok();
1292   if (Tok.isNot(AsmToken::Identifier)) return -1;
1293
1294   // FIXME: Validate register for the current architecture; we have to do
1295   // validation later, so maybe there is no need for this here.
1296   std::string upperCase = Tok.getString().str();
1297   std::string lowerCase = LowercaseString(upperCase);
1298   unsigned RegNum = MatchRegisterName(lowerCase);
1299   if (!RegNum) {
1300     RegNum = StringSwitch<unsigned>(lowerCase)
1301       .Case("r13", ARM::SP)
1302       .Case("r14", ARM::LR)
1303       .Case("r15", ARM::PC)
1304       .Case("ip", ARM::R12)
1305       .Default(0);
1306   }
1307   if (!RegNum) return -1;
1308
1309   Parser.Lex(); // Eat identifier token.
1310   return RegNum;
1311 }
1312
1313 // Try to parse a shifter  (e.g., "lsl <amt>"). On success, return 0.
1314 // If a recoverable error occurs, return 1. If an irrecoverable error
1315 // occurs, return -1. An irrecoverable error is one where tokens have been
1316 // consumed in the process of trying to parse the shifter (i.e., when it is
1317 // indeed a shifter operand, but malformed).
1318 int ARMAsmParser::tryParseShiftRegister(
1319                                SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1320   SMLoc S = Parser.getTok().getLoc();
1321   const AsmToken &Tok = Parser.getTok();
1322   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1323
1324   std::string upperCase = Tok.getString().str();
1325   std::string lowerCase = LowercaseString(upperCase);
1326   ARM_AM::ShiftOpc ShiftTy = StringSwitch<ARM_AM::ShiftOpc>(lowerCase)
1327       .Case("lsl", ARM_AM::lsl)
1328       .Case("lsr", ARM_AM::lsr)
1329       .Case("asr", ARM_AM::asr)
1330       .Case("ror", ARM_AM::ror)
1331       .Case("rrx", ARM_AM::rrx)
1332       .Default(ARM_AM::no_shift);
1333
1334   if (ShiftTy == ARM_AM::no_shift)
1335     return 1;
1336
1337   Parser.Lex(); // Eat the operator.
1338
1339   // The source register for the shift has already been added to the
1340   // operand list, so we need to pop it off and combine it into the shifted
1341   // register operand instead.
1342   OwningPtr<ARMOperand> PrevOp((ARMOperand*)Operands.pop_back_val());
1343   if (!PrevOp->isReg())
1344     return Error(PrevOp->getStartLoc(), "shift must be of a register");
1345   int SrcReg = PrevOp->getReg();
1346   int64_t Imm = 0;
1347   int ShiftReg = 0;
1348   if (ShiftTy == ARM_AM::rrx) {
1349     // RRX Doesn't have an explicit shift amount. The encoder expects
1350     // the shift register to be the same as the source register. Seems odd,
1351     // but OK.
1352     ShiftReg = SrcReg;
1353   } else {
1354     // Figure out if this is shifted by a constant or a register (for non-RRX).
1355     if (Parser.getTok().is(AsmToken::Hash)) {
1356       Parser.Lex(); // Eat hash.
1357       SMLoc ImmLoc = Parser.getTok().getLoc();
1358       const MCExpr *ShiftExpr = 0;
1359       if (getParser().ParseExpression(ShiftExpr)) {
1360         Error(ImmLoc, "invalid immediate shift value");
1361         return -1;
1362       }
1363       // The expression must be evaluatable as an immediate.
1364       const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftExpr);
1365       if (!CE) {
1366         Error(ImmLoc, "invalid immediate shift value");
1367         return -1;
1368       }
1369       // Range check the immediate.
1370       // lsl, ror: 0 <= imm <= 31
1371       // lsr, asr: 0 <= imm <= 32
1372       Imm = CE->getValue();
1373       if (Imm < 0 ||
1374           ((ShiftTy == ARM_AM::lsl || ShiftTy == ARM_AM::ror) && Imm > 31) ||
1375           ((ShiftTy == ARM_AM::lsr || ShiftTy == ARM_AM::asr) && Imm > 32)) {
1376         Error(ImmLoc, "immediate shift value out of range");
1377         return -1;
1378       }
1379     } else if (Parser.getTok().is(AsmToken::Identifier)) {
1380       ShiftReg = tryParseRegister();
1381       SMLoc L = Parser.getTok().getLoc();
1382       if (ShiftReg == -1) {
1383         Error (L, "expected immediate or register in shift operand");
1384         return -1;
1385       }
1386     } else {
1387       Error (Parser.getTok().getLoc(),
1388                     "expected immediate or register in shift operand");
1389       return -1;
1390     }
1391   }
1392
1393   if (ShiftReg && ShiftTy != ARM_AM::rrx)
1394     Operands.push_back(ARMOperand::CreateShiftedRegister(ShiftTy, SrcReg,
1395                                                          ShiftReg, Imm,
1396                                                S, Parser.getTok().getLoc()));
1397   else
1398     Operands.push_back(ARMOperand::CreateShiftedImmediate(ShiftTy, SrcReg, Imm,
1399                                                S, Parser.getTok().getLoc()));
1400
1401   return 0;
1402 }
1403
1404
1405 /// Try to parse a register name.  The token must be an Identifier when called.
1406 /// If it's a register, an AsmOperand is created. Another AsmOperand is created
1407 /// if there is a "writeback". 'true' if it's not a register.
1408 ///
1409 /// TODO this is likely to change to allow different register types and or to
1410 /// parse for a specific register type.
1411 bool ARMAsmParser::
1412 tryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1413   SMLoc S = Parser.getTok().getLoc();
1414   int RegNo = tryParseRegister();
1415   if (RegNo == -1)
1416     return true;
1417
1418   Operands.push_back(ARMOperand::CreateReg(RegNo, S, Parser.getTok().getLoc()));
1419
1420   const AsmToken &ExclaimTok = Parser.getTok();
1421   if (ExclaimTok.is(AsmToken::Exclaim)) {
1422     Operands.push_back(ARMOperand::CreateToken(ExclaimTok.getString(),
1423                                                ExclaimTok.getLoc()));
1424     Parser.Lex(); // Eat exclaim token
1425   }
1426
1427   return false;
1428 }
1429
1430 /// MatchCoprocessorOperandName - Try to parse an coprocessor related
1431 /// instruction with a symbolic operand name. Example: "p1", "p7", "c3",
1432 /// "c5", ...
1433 static int MatchCoprocessorOperandName(StringRef Name, char CoprocOp) {
1434   // Use the same layout as the tablegen'erated register name matcher. Ugly,
1435   // but efficient.
1436   switch (Name.size()) {
1437   default: break;
1438   case 2:
1439     if (Name[0] != CoprocOp)
1440       return -1;
1441     switch (Name[1]) {
1442     default:  return -1;
1443     case '0': return 0;
1444     case '1': return 1;
1445     case '2': return 2;
1446     case '3': return 3;
1447     case '4': return 4;
1448     case '5': return 5;
1449     case '6': return 6;
1450     case '7': return 7;
1451     case '8': return 8;
1452     case '9': return 9;
1453     }
1454     break;
1455   case 3:
1456     if (Name[0] != CoprocOp || Name[1] != '1')
1457       return -1;
1458     switch (Name[2]) {
1459     default:  return -1;
1460     case '0': return 10;
1461     case '1': return 11;
1462     case '2': return 12;
1463     case '3': return 13;
1464     case '4': return 14;
1465     case '5': return 15;
1466     }
1467     break;
1468   }
1469
1470   return -1;
1471 }
1472
1473 /// parseCoprocNumOperand - Try to parse an coprocessor number operand. The
1474 /// token must be an Identifier when called, and if it is a coprocessor
1475 /// number, the token is eaten and the operand is added to the operand list.
1476 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1477 parseCoprocNumOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1478   SMLoc S = Parser.getTok().getLoc();
1479   const AsmToken &Tok = Parser.getTok();
1480   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1481
1482   int Num = MatchCoprocessorOperandName(Tok.getString(), 'p');
1483   if (Num == -1)
1484     return MatchOperand_NoMatch;
1485
1486   Parser.Lex(); // Eat identifier token.
1487   Operands.push_back(ARMOperand::CreateCoprocNum(Num, S));
1488   return MatchOperand_Success;
1489 }
1490
1491 /// parseCoprocRegOperand - Try to parse an coprocessor register operand. The
1492 /// token must be an Identifier when called, and if it is a coprocessor
1493 /// number, the token is eaten and the operand is added to the operand list.
1494 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1495 parseCoprocRegOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1496   SMLoc S = Parser.getTok().getLoc();
1497   const AsmToken &Tok = Parser.getTok();
1498   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1499
1500   int Reg = MatchCoprocessorOperandName(Tok.getString(), 'c');
1501   if (Reg == -1)
1502     return MatchOperand_NoMatch;
1503
1504   Parser.Lex(); // Eat identifier token.
1505   Operands.push_back(ARMOperand::CreateCoprocReg(Reg, S));
1506   return MatchOperand_Success;
1507 }
1508
1509 /// Parse a register list, return it if successful else return null.  The first
1510 /// token must be a '{' when called.
1511 bool ARMAsmParser::
1512 parseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1513   assert(Parser.getTok().is(AsmToken::LCurly) &&
1514          "Token is not a Left Curly Brace");
1515   SMLoc S = Parser.getTok().getLoc();
1516
1517   // Read the rest of the registers in the list.
1518   unsigned PrevRegNum = 0;
1519   SmallVector<std::pair<unsigned, SMLoc>, 32> Registers;
1520
1521   do {
1522     bool IsRange = Parser.getTok().is(AsmToken::Minus);
1523     Parser.Lex(); // Eat non-identifier token.
1524
1525     const AsmToken &RegTok = Parser.getTok();
1526     SMLoc RegLoc = RegTok.getLoc();
1527     if (RegTok.isNot(AsmToken::Identifier)) {
1528       Error(RegLoc, "register expected");
1529       return true;
1530     }
1531
1532     int RegNum = tryParseRegister();
1533     if (RegNum == -1) {
1534       Error(RegLoc, "register expected");
1535       return true;
1536     }
1537
1538     if (IsRange) {
1539       int Reg = PrevRegNum;
1540       do {
1541         ++Reg;
1542         Registers.push_back(std::make_pair(Reg, RegLoc));
1543       } while (Reg != RegNum);
1544     } else {
1545       Registers.push_back(std::make_pair(RegNum, RegLoc));
1546     }
1547
1548     PrevRegNum = RegNum;
1549   } while (Parser.getTok().is(AsmToken::Comma) ||
1550            Parser.getTok().is(AsmToken::Minus));
1551
1552   // Process the right curly brace of the list.
1553   const AsmToken &RCurlyTok = Parser.getTok();
1554   if (RCurlyTok.isNot(AsmToken::RCurly)) {
1555     Error(RCurlyTok.getLoc(), "'}' expected");
1556     return true;
1557   }
1558
1559   SMLoc E = RCurlyTok.getLoc();
1560   Parser.Lex(); // Eat right curly brace token.
1561
1562   // Verify the register list.
1563   SmallVectorImpl<std::pair<unsigned, SMLoc> >::const_iterator
1564     RI = Registers.begin(), RE = Registers.end();
1565
1566   unsigned HighRegNum = getARMRegisterNumbering(RI->first);
1567   bool EmittedWarning = false;
1568
1569   DenseMap<unsigned, bool> RegMap;
1570   RegMap[HighRegNum] = true;
1571
1572   for (++RI; RI != RE; ++RI) {
1573     const std::pair<unsigned, SMLoc> &RegInfo = *RI;
1574     unsigned Reg = getARMRegisterNumbering(RegInfo.first);
1575
1576     if (RegMap[Reg]) {
1577       Error(RegInfo.second, "register duplicated in register list");
1578       return true;
1579     }
1580
1581     if (!EmittedWarning && Reg < HighRegNum)
1582       Warning(RegInfo.second,
1583               "register not in ascending order in register list");
1584
1585     RegMap[Reg] = true;
1586     HighRegNum = std::max(Reg, HighRegNum);
1587   }
1588
1589   Operands.push_back(ARMOperand::CreateRegList(Registers, S, E));
1590   return false;
1591 }
1592
1593 /// parseMemBarrierOptOperand - Try to parse DSB/DMB data barrier options.
1594 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1595 parseMemBarrierOptOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1596   SMLoc S = Parser.getTok().getLoc();
1597   const AsmToken &Tok = Parser.getTok();
1598   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1599   StringRef OptStr = Tok.getString();
1600
1601   unsigned Opt = StringSwitch<unsigned>(OptStr.slice(0, OptStr.size()))
1602     .Case("sy",    ARM_MB::SY)
1603     .Case("st",    ARM_MB::ST)
1604     .Case("sh",    ARM_MB::ISH)
1605     .Case("ish",   ARM_MB::ISH)
1606     .Case("shst",  ARM_MB::ISHST)
1607     .Case("ishst", ARM_MB::ISHST)
1608     .Case("nsh",   ARM_MB::NSH)
1609     .Case("un",    ARM_MB::NSH)
1610     .Case("nshst", ARM_MB::NSHST)
1611     .Case("unst",  ARM_MB::NSHST)
1612     .Case("osh",   ARM_MB::OSH)
1613     .Case("oshst", ARM_MB::OSHST)
1614     .Default(~0U);
1615
1616   if (Opt == ~0U)
1617     return MatchOperand_NoMatch;
1618
1619   Parser.Lex(); // Eat identifier token.
1620   Operands.push_back(ARMOperand::CreateMemBarrierOpt((ARM_MB::MemBOpt)Opt, S));
1621   return MatchOperand_Success;
1622 }
1623
1624 /// parseProcIFlagsOperand - Try to parse iflags from CPS instruction.
1625 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1626 parseProcIFlagsOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1627   SMLoc S = Parser.getTok().getLoc();
1628   const AsmToken &Tok = Parser.getTok();
1629   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1630   StringRef IFlagsStr = Tok.getString();
1631
1632   unsigned IFlags = 0;
1633   for (int i = 0, e = IFlagsStr.size(); i != e; ++i) {
1634     unsigned Flag = StringSwitch<unsigned>(IFlagsStr.substr(i, 1))
1635     .Case("a", ARM_PROC::A)
1636     .Case("i", ARM_PROC::I)
1637     .Case("f", ARM_PROC::F)
1638     .Default(~0U);
1639
1640     // If some specific iflag is already set, it means that some letter is
1641     // present more than once, this is not acceptable.
1642     if (Flag == ~0U || (IFlags & Flag))
1643       return MatchOperand_NoMatch;
1644
1645     IFlags |= Flag;
1646   }
1647
1648   Parser.Lex(); // Eat identifier token.
1649   Operands.push_back(ARMOperand::CreateProcIFlags((ARM_PROC::IFlags)IFlags, S));
1650   return MatchOperand_Success;
1651 }
1652
1653 /// parseMSRMaskOperand - Try to parse mask flags from MSR instruction.
1654 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1655 parseMSRMaskOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1656   SMLoc S = Parser.getTok().getLoc();
1657   const AsmToken &Tok = Parser.getTok();
1658   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1659   StringRef Mask = Tok.getString();
1660
1661   // Split spec_reg from flag, example: CPSR_sxf => "CPSR" and "sxf"
1662   size_t Start = 0, Next = Mask.find('_');
1663   StringRef Flags = "";
1664   std::string SpecReg = LowercaseString(Mask.slice(Start, Next));
1665   if (Next != StringRef::npos)
1666     Flags = Mask.slice(Next+1, Mask.size());
1667
1668   // FlagsVal contains the complete mask:
1669   // 3-0: Mask
1670   // 4: Special Reg (cpsr, apsr => 0; spsr => 1)
1671   unsigned FlagsVal = 0;
1672
1673   if (SpecReg == "apsr") {
1674     FlagsVal = StringSwitch<unsigned>(Flags)
1675     .Case("nzcvq",  0x8) // same as CPSR_f
1676     .Case("g",      0x4) // same as CPSR_s
1677     .Case("nzcvqg", 0xc) // same as CPSR_fs
1678     .Default(~0U);
1679
1680     if (FlagsVal == ~0U) {
1681       if (!Flags.empty())
1682         return MatchOperand_NoMatch;
1683       else
1684         FlagsVal = 0; // No flag
1685     }
1686   } else if (SpecReg == "cpsr" || SpecReg == "spsr") {
1687     if (Flags == "all") // cpsr_all is an alias for cpsr_fc
1688       Flags = "fc";
1689     for (int i = 0, e = Flags.size(); i != e; ++i) {
1690       unsigned Flag = StringSwitch<unsigned>(Flags.substr(i, 1))
1691       .Case("c", 1)
1692       .Case("x", 2)
1693       .Case("s", 4)
1694       .Case("f", 8)
1695       .Default(~0U);
1696
1697       // If some specific flag is already set, it means that some letter is
1698       // present more than once, this is not acceptable.
1699       if (FlagsVal == ~0U || (FlagsVal & Flag))
1700         return MatchOperand_NoMatch;
1701       FlagsVal |= Flag;
1702     }
1703   } else // No match for special register.
1704     return MatchOperand_NoMatch;
1705
1706   // Special register without flags are equivalent to "fc" flags.
1707   if (!FlagsVal)
1708     FlagsVal = 0x9;
1709
1710   // Bit 4: Special Reg (cpsr, apsr => 0; spsr => 1)
1711   if (SpecReg == "spsr")
1712     FlagsVal |= 16;
1713
1714   Parser.Lex(); // Eat identifier token.
1715   Operands.push_back(ARMOperand::CreateMSRMask(FlagsVal, S));
1716   return MatchOperand_Success;
1717 }
1718
1719 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1720 parsePKHImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands, StringRef Op,
1721             int Low, int High) {
1722   const AsmToken &Tok = Parser.getTok();
1723   if (Tok.isNot(AsmToken::Identifier)) {
1724     Error(Parser.getTok().getLoc(), Op + " operand expected.");
1725     return MatchOperand_ParseFail;
1726   }
1727   StringRef ShiftName = Tok.getString();
1728   std::string LowerOp = LowercaseString(Op);
1729   std::string UpperOp = UppercaseString(Op);
1730   if (ShiftName != LowerOp && ShiftName != UpperOp) {
1731     Error(Parser.getTok().getLoc(), Op + " operand expected.");
1732     return MatchOperand_ParseFail;
1733   }
1734   Parser.Lex(); // Eat shift type token.
1735
1736   // There must be a '#' and a shift amount.
1737   if (Parser.getTok().isNot(AsmToken::Hash)) {
1738     Error(Parser.getTok().getLoc(), "'#' expected");
1739     return MatchOperand_ParseFail;
1740   }
1741   Parser.Lex(); // Eat hash token.
1742
1743   const MCExpr *ShiftAmount;
1744   SMLoc Loc = Parser.getTok().getLoc();
1745   if (getParser().ParseExpression(ShiftAmount)) {
1746     Error(Loc, "illegal expression");
1747     return MatchOperand_ParseFail;
1748   }
1749   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount);
1750   if (!CE) {
1751     Error(Loc, "constant expression expected");
1752     return MatchOperand_ParseFail;
1753   }
1754   int Val = CE->getValue();
1755   if (Val < Low || Val > High) {
1756     Error(Loc, "immediate value out of range");
1757     return MatchOperand_ParseFail;
1758   }
1759
1760   Operands.push_back(ARMOperand::CreateImm(CE, Loc, Parser.getTok().getLoc()));
1761
1762   return MatchOperand_Success;
1763 }
1764
1765 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1766 parseSetEndImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1767   const AsmToken &Tok = Parser.getTok();
1768   SMLoc S = Tok.getLoc();
1769   if (Tok.isNot(AsmToken::Identifier)) {
1770     Error(Tok.getLoc(), "'be' or 'le' operand expected");
1771     return MatchOperand_ParseFail;
1772   }
1773   int Val = StringSwitch<int>(Tok.getString())
1774     .Case("be", 1)
1775     .Case("le", 0)
1776     .Default(-1);
1777   Parser.Lex(); // Eat the token.
1778
1779   if (Val == -1) {
1780     Error(Tok.getLoc(), "'be' or 'le' operand expected");
1781     return MatchOperand_ParseFail;
1782   }
1783   Operands.push_back(ARMOperand::CreateImm(MCConstantExpr::Create(Val,
1784                                                                   getContext()),
1785                                            S, Parser.getTok().getLoc()));
1786   return MatchOperand_Success;
1787 }
1788
1789 /// parseShifterImm - Parse the shifter immediate operand for SSAT/USAT
1790 /// instructions. Legal values are:
1791 ///     lsl #n  'n' in [0,31]
1792 ///     asr #n  'n' in [1,32]
1793 ///             n == 32 encoded as n == 0.
1794 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1795 parseShifterImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1796   const AsmToken &Tok = Parser.getTok();
1797   SMLoc S = Tok.getLoc();
1798   if (Tok.isNot(AsmToken::Identifier)) {
1799     Error(S, "shift operator 'asr' or 'lsl' expected");
1800     return MatchOperand_ParseFail;
1801   }
1802   StringRef ShiftName = Tok.getString();
1803   bool isASR;
1804   if (ShiftName == "lsl" || ShiftName == "LSL")
1805     isASR = false;
1806   else if (ShiftName == "asr" || ShiftName == "ASR")
1807     isASR = true;
1808   else {
1809     Error(S, "shift operator 'asr' or 'lsl' expected");
1810     return MatchOperand_ParseFail;
1811   }
1812   Parser.Lex(); // Eat the operator.
1813
1814   // A '#' and a shift amount.
1815   if (Parser.getTok().isNot(AsmToken::Hash)) {
1816     Error(Parser.getTok().getLoc(), "'#' expected");
1817     return MatchOperand_ParseFail;
1818   }
1819   Parser.Lex(); // Eat hash token.
1820
1821   const MCExpr *ShiftAmount;
1822   SMLoc E = Parser.getTok().getLoc();
1823   if (getParser().ParseExpression(ShiftAmount)) {
1824     Error(E, "malformed shift expression");
1825     return MatchOperand_ParseFail;
1826   }
1827   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount);
1828   if (!CE) {
1829     Error(E, "shift amount must be an immediate");
1830     return MatchOperand_ParseFail;
1831   }
1832
1833   int64_t Val = CE->getValue();
1834   if (isASR) {
1835     // Shift amount must be in [1,32]
1836     if (Val < 1 || Val > 32) {
1837       Error(E, "'asr' shift amount must be in range [1,32]");
1838       return MatchOperand_ParseFail;
1839     }
1840     // asr #32 encoded as asr #0.
1841     if (Val == 32) Val = 0;
1842   } else {
1843     // Shift amount must be in [1,32]
1844     if (Val < 0 || Val > 31) {
1845       Error(E, "'lsr' shift amount must be in range [0,31]");
1846       return MatchOperand_ParseFail;
1847     }
1848   }
1849
1850   E = Parser.getTok().getLoc();
1851   Operands.push_back(ARMOperand::CreateShifterImm(isASR, Val, S, E));
1852
1853   return MatchOperand_Success;
1854 }
1855
1856 /// parseRotImm - Parse the shifter immediate operand for SXTB/UXTB family
1857 /// of instructions. Legal values are:
1858 ///     ror #n  'n' in {0, 8, 16, 24}
1859 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1860 parseRotImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1861   const AsmToken &Tok = Parser.getTok();
1862   SMLoc S = Tok.getLoc();
1863   if (Tok.isNot(AsmToken::Identifier)) {
1864     Error(S, "rotate operator 'ror' expected");
1865     return MatchOperand_ParseFail;
1866   }
1867   StringRef ShiftName = Tok.getString();
1868   if (ShiftName != "ror" && ShiftName != "ROR") {
1869     Error(S, "rotate operator 'ror' expected");
1870     return MatchOperand_ParseFail;
1871   }
1872   Parser.Lex(); // Eat the operator.
1873
1874   // A '#' and a rotate amount.
1875   if (Parser.getTok().isNot(AsmToken::Hash)) {
1876     Error(Parser.getTok().getLoc(), "'#' expected");
1877     return MatchOperand_ParseFail;
1878   }
1879   Parser.Lex(); // Eat hash token.
1880
1881   const MCExpr *ShiftAmount;
1882   SMLoc E = Parser.getTok().getLoc();
1883   if (getParser().ParseExpression(ShiftAmount)) {
1884     Error(E, "malformed rotate expression");
1885     return MatchOperand_ParseFail;
1886   }
1887   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount);
1888   if (!CE) {
1889     Error(E, "rotate amount must be an immediate");
1890     return MatchOperand_ParseFail;
1891   }
1892
1893   int64_t Val = CE->getValue();
1894   // Shift amount must be in {0, 8, 16, 24} (0 is undocumented extension)
1895   // normally, zero is represented in asm by omitting the rotate operand
1896   // entirely.
1897   if (Val != 8 && Val != 16 && Val != 24 && Val != 0) {
1898     Error(E, "'ror' rotate amount must be 8, 16, or 24");
1899     return MatchOperand_ParseFail;
1900   }
1901
1902   E = Parser.getTok().getLoc();
1903   Operands.push_back(ARMOperand::CreateRotImm(Val, S, E));
1904
1905   return MatchOperand_Success;
1906 }
1907
1908 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1909 parseBitfield(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1910   SMLoc S = Parser.getTok().getLoc();
1911   // The bitfield descriptor is really two operands, the LSB and the width.
1912   if (Parser.getTok().isNot(AsmToken::Hash)) {
1913     Error(Parser.getTok().getLoc(), "'#' expected");
1914     return MatchOperand_ParseFail;
1915   }
1916   Parser.Lex(); // Eat hash token.
1917
1918   const MCExpr *LSBExpr;
1919   SMLoc E = Parser.getTok().getLoc();
1920   if (getParser().ParseExpression(LSBExpr)) {
1921     Error(E, "malformed immediate expression");
1922     return MatchOperand_ParseFail;
1923   }
1924   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(LSBExpr);
1925   if (!CE) {
1926     Error(E, "'lsb' operand must be an immediate");
1927     return MatchOperand_ParseFail;
1928   }
1929
1930   int64_t LSB = CE->getValue();
1931   // The LSB must be in the range [0,31]
1932   if (LSB < 0 || LSB > 31) {
1933     Error(E, "'lsb' operand must be in the range [0,31]");
1934     return MatchOperand_ParseFail;
1935   }
1936   E = Parser.getTok().getLoc();
1937
1938   // Expect another immediate operand.
1939   if (Parser.getTok().isNot(AsmToken::Comma)) {
1940     Error(Parser.getTok().getLoc(), "too few operands");
1941     return MatchOperand_ParseFail;
1942   }
1943   Parser.Lex(); // Eat hash token.
1944   if (Parser.getTok().isNot(AsmToken::Hash)) {
1945     Error(Parser.getTok().getLoc(), "'#' expected");
1946     return MatchOperand_ParseFail;
1947   }
1948   Parser.Lex(); // Eat hash token.
1949
1950   const MCExpr *WidthExpr;
1951   if (getParser().ParseExpression(WidthExpr)) {
1952     Error(E, "malformed immediate expression");
1953     return MatchOperand_ParseFail;
1954   }
1955   CE = dyn_cast<MCConstantExpr>(WidthExpr);
1956   if (!CE) {
1957     Error(E, "'width' operand must be an immediate");
1958     return MatchOperand_ParseFail;
1959   }
1960
1961   int64_t Width = CE->getValue();
1962   // The LSB must be in the range [1,32-lsb]
1963   if (Width < 1 || Width > 32 - LSB) {
1964     Error(E, "'width' operand must be in the range [1,32-lsb]");
1965     return MatchOperand_ParseFail;
1966   }
1967   E = Parser.getTok().getLoc();
1968
1969   Operands.push_back(ARMOperand::CreateBitfield(LSB, Width, S, E));
1970
1971   return MatchOperand_Success;
1972 }
1973
1974 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1975 parsePostIdxReg(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1976   // Check for a post-index addressing register operand. Specifically:
1977   // postidx_reg := '+' register {, shift}
1978   //              | '-' register {, shift}
1979   //              | register {, shift}
1980
1981   // This method must return MatchOperand_NoMatch without consuming any tokens
1982   // in the case where there is no match, as other alternatives take other
1983   // parse methods.
1984   AsmToken Tok = Parser.getTok();
1985   SMLoc S = Tok.getLoc();
1986   bool haveEaten = false;
1987   bool isAdd = true;
1988   int Reg = -1;
1989   if (Tok.is(AsmToken::Plus)) {
1990     Parser.Lex(); // Eat the '+' token.
1991     haveEaten = true;
1992   } else if (Tok.is(AsmToken::Minus)) {
1993     Parser.Lex(); // Eat the '-' token.
1994     isAdd = false;
1995     haveEaten = true;
1996   }
1997   if (Parser.getTok().is(AsmToken::Identifier))
1998     Reg = tryParseRegister();
1999   if (Reg == -1) {
2000     if (!haveEaten)
2001       return MatchOperand_NoMatch;
2002     Error(Parser.getTok().getLoc(), "register expected");
2003     return MatchOperand_ParseFail;
2004   }
2005   SMLoc E = Parser.getTok().getLoc();
2006
2007   ARM_AM::ShiftOpc ShiftTy = ARM_AM::no_shift;
2008   unsigned ShiftImm = 0;
2009   if (Parser.getTok().is(AsmToken::Comma)) {
2010     Parser.Lex(); // Eat the ','.
2011     if (parseMemRegOffsetShift(ShiftTy, ShiftImm))
2012       return MatchOperand_ParseFail;
2013   }
2014
2015   Operands.push_back(ARMOperand::CreatePostIdxReg(Reg, isAdd, ShiftTy,
2016                                                   ShiftImm, S, E));
2017
2018   return MatchOperand_Success;
2019 }
2020
2021 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2022 parseAM3Offset(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2023   // Check for a post-index addressing register operand. Specifically:
2024   // am3offset := '+' register
2025   //              | '-' register
2026   //              | register
2027   //              | # imm
2028   //              | # + imm
2029   //              | # - imm
2030
2031   // This method must return MatchOperand_NoMatch without consuming any tokens
2032   // in the case where there is no match, as other alternatives take other
2033   // parse methods.
2034   AsmToken Tok = Parser.getTok();
2035   SMLoc S = Tok.getLoc();
2036
2037   // Do immediates first, as we always parse those if we have a '#'.
2038   if (Parser.getTok().is(AsmToken::Hash)) {
2039     Parser.Lex(); // Eat the '#'.
2040     // Explicitly look for a '-', as we need to encode negative zero
2041     // differently.
2042     bool isNegative = Parser.getTok().is(AsmToken::Minus);
2043     const MCExpr *Offset;
2044     if (getParser().ParseExpression(Offset))
2045       return MatchOperand_ParseFail;
2046     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Offset);
2047     if (!CE) {
2048       Error(S, "constant expression expected");
2049       return MatchOperand_ParseFail;
2050     }
2051     SMLoc E = Tok.getLoc();
2052     // Negative zero is encoded as the flag value INT32_MIN.
2053     int32_t Val = CE->getValue();
2054     if (isNegative && Val == 0)
2055       Val = INT32_MIN;
2056
2057     Operands.push_back(
2058       ARMOperand::CreateImm(MCConstantExpr::Create(Val, getContext()), S, E));
2059
2060     return MatchOperand_Success;
2061   }
2062
2063
2064   bool haveEaten = false;
2065   bool isAdd = true;
2066   int Reg = -1;
2067   if (Tok.is(AsmToken::Plus)) {
2068     Parser.Lex(); // Eat the '+' token.
2069     haveEaten = true;
2070   } else if (Tok.is(AsmToken::Minus)) {
2071     Parser.Lex(); // Eat the '-' token.
2072     isAdd = false;
2073     haveEaten = true;
2074   }
2075   if (Parser.getTok().is(AsmToken::Identifier))
2076     Reg = tryParseRegister();
2077   if (Reg == -1) {
2078     if (!haveEaten)
2079       return MatchOperand_NoMatch;
2080     Error(Parser.getTok().getLoc(), "register expected");
2081     return MatchOperand_ParseFail;
2082   }
2083   SMLoc E = Parser.getTok().getLoc();
2084
2085   Operands.push_back(ARMOperand::CreatePostIdxReg(Reg, isAdd, ARM_AM::no_shift,
2086                                                   0, S, E));
2087
2088   return MatchOperand_Success;
2089 }
2090
2091 /// cvtLdWriteBackRegAddrMode2 - Convert parsed operands to MCInst.
2092 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2093 /// when they refer multiple MIOperands inside a single one.
2094 bool ARMAsmParser::
2095 cvtLdWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
2096                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2097   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2098
2099   // Create a writeback register dummy placeholder.
2100   Inst.addOperand(MCOperand::CreateImm(0));
2101
2102   ((ARMOperand*)Operands[3])->addAddrMode2Operands(Inst, 3);
2103   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2104   return true;
2105 }
2106
2107 /// cvtStWriteBackRegAddrModeImm12 - Convert parsed operands to MCInst.
2108 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2109 /// when they refer multiple MIOperands inside a single one.
2110 bool ARMAsmParser::
2111 cvtStWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
2112                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2113   // Create a writeback register dummy placeholder.
2114   Inst.addOperand(MCOperand::CreateImm(0));
2115   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2116   ((ARMOperand*)Operands[3])->addMemImm12OffsetOperands(Inst, 2);
2117   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2118   return true;
2119 }
2120
2121 /// cvtStWriteBackRegAddrMode2 - Convert parsed operands to MCInst.
2122 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2123 /// when they refer multiple MIOperands inside a single one.
2124 bool ARMAsmParser::
2125 cvtStWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
2126                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2127   // Create a writeback register dummy placeholder.
2128   Inst.addOperand(MCOperand::CreateImm(0));
2129   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2130   ((ARMOperand*)Operands[3])->addAddrMode2Operands(Inst, 3);
2131   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2132   return true;
2133 }
2134
2135 /// cvtLdExtTWriteBackImm - Convert parsed operands to MCInst.
2136 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2137 /// when they refer multiple MIOperands inside a single one.
2138 bool ARMAsmParser::
2139 cvtLdExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
2140                       const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2141   // Rt
2142   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2143   // Create a writeback register dummy placeholder.
2144   Inst.addOperand(MCOperand::CreateImm(0));
2145   // addr
2146   ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
2147   // offset
2148   ((ARMOperand*)Operands[4])->addPostIdxImm8Operands(Inst, 1);
2149   // pred
2150   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2151   return true;
2152 }
2153
2154 /// cvtLdExtTWriteBackReg - Convert parsed operands to MCInst.
2155 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2156 /// when they refer multiple MIOperands inside a single one.
2157 bool ARMAsmParser::
2158 cvtLdExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
2159                       const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2160   // Rt
2161   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2162   // Create a writeback register dummy placeholder.
2163   Inst.addOperand(MCOperand::CreateImm(0));
2164   // addr
2165   ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
2166   // offset
2167   ((ARMOperand*)Operands[4])->addPostIdxRegOperands(Inst, 2);
2168   // pred
2169   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2170   return true;
2171 }
2172
2173 /// cvtStExtTWriteBackImm - Convert parsed operands to MCInst.
2174 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2175 /// when they refer multiple MIOperands inside a single one.
2176 bool ARMAsmParser::
2177 cvtStExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
2178                       const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2179   // Create a writeback register dummy placeholder.
2180   Inst.addOperand(MCOperand::CreateImm(0));
2181   // Rt
2182   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2183   // addr
2184   ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
2185   // offset
2186   ((ARMOperand*)Operands[4])->addPostIdxImm8Operands(Inst, 1);
2187   // pred
2188   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2189   return true;
2190 }
2191
2192 /// cvtStExtTWriteBackReg - Convert parsed operands to MCInst.
2193 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2194 /// when they refer multiple MIOperands inside a single one.
2195 bool ARMAsmParser::
2196 cvtStExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
2197                       const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2198   // Create a writeback register dummy placeholder.
2199   Inst.addOperand(MCOperand::CreateImm(0));
2200   // Rt
2201   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2202   // addr
2203   ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
2204   // offset
2205   ((ARMOperand*)Operands[4])->addPostIdxRegOperands(Inst, 2);
2206   // pred
2207   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2208   return true;
2209 }
2210
2211 /// cvtLdrdPre - Convert parsed operands to MCInst.
2212 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2213 /// when they refer multiple MIOperands inside a single one.
2214 bool ARMAsmParser::
2215 cvtLdrdPre(MCInst &Inst, unsigned Opcode,
2216            const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2217   // Rt, Rt2
2218   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2219   ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
2220   // Create a writeback register dummy placeholder.
2221   Inst.addOperand(MCOperand::CreateImm(0));
2222   // addr
2223   ((ARMOperand*)Operands[4])->addAddrMode3Operands(Inst, 3);
2224   // pred
2225   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2226   return true;
2227 }
2228
2229 /// cvtStrdPre - Convert parsed operands to MCInst.
2230 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2231 /// when they refer multiple MIOperands inside a single one.
2232 bool ARMAsmParser::
2233 cvtStrdPre(MCInst &Inst, unsigned Opcode,
2234            const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2235   // Create a writeback register dummy placeholder.
2236   Inst.addOperand(MCOperand::CreateImm(0));
2237   // Rt, Rt2
2238   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2239   ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
2240   // addr
2241   ((ARMOperand*)Operands[4])->addAddrMode3Operands(Inst, 3);
2242   // pred
2243   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2244   return true;
2245 }
2246
2247 /// cvtLdWriteBackRegAddrMode3 - Convert parsed operands to MCInst.
2248 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2249 /// when they refer multiple MIOperands inside a single one.
2250 bool ARMAsmParser::
2251 cvtLdWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
2252                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2253   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2254   // Create a writeback register dummy placeholder.
2255   Inst.addOperand(MCOperand::CreateImm(0));
2256   ((ARMOperand*)Operands[3])->addAddrMode3Operands(Inst, 3);
2257   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2258   return true;
2259 }
2260
2261
2262 /// Parse an ARM memory expression, return false if successful else return true
2263 /// or an error.  The first token must be a '[' when called.
2264 bool ARMAsmParser::
2265 parseMemory(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2266   SMLoc S, E;
2267   assert(Parser.getTok().is(AsmToken::LBrac) &&
2268          "Token is not a Left Bracket");
2269   S = Parser.getTok().getLoc();
2270   Parser.Lex(); // Eat left bracket token.
2271
2272   const AsmToken &BaseRegTok = Parser.getTok();
2273   int BaseRegNum = tryParseRegister();
2274   if (BaseRegNum == -1)
2275     return Error(BaseRegTok.getLoc(), "register expected");
2276
2277   // The next token must either be a comma or a closing bracket.
2278   const AsmToken &Tok = Parser.getTok();
2279   if (!Tok.is(AsmToken::Comma) && !Tok.is(AsmToken::RBrac))
2280     return Error(Tok.getLoc(), "malformed memory operand");
2281
2282   if (Tok.is(AsmToken::RBrac)) {
2283     E = Tok.getLoc();
2284     Parser.Lex(); // Eat right bracket token.
2285
2286     Operands.push_back(ARMOperand::CreateMem(BaseRegNum, 0, 0, ARM_AM::no_shift,
2287                                              0, false, S, E));
2288
2289     return false;
2290   }
2291
2292   assert(Tok.is(AsmToken::Comma) && "Lost comma in memory operand?!");
2293   Parser.Lex(); // Eat the comma.
2294
2295   // If we have a '#' it's an immediate offset, else assume it's a register
2296   // offset.
2297   if (Parser.getTok().is(AsmToken::Hash)) {
2298     Parser.Lex(); // Eat the '#'.
2299     E = Parser.getTok().getLoc();
2300
2301     // FIXME: Special case #-0 so we can correctly set the U bit.
2302
2303     const MCExpr *Offset;
2304     if (getParser().ParseExpression(Offset))
2305      return true;
2306
2307     // The expression has to be a constant. Memory references with relocations
2308     // don't come through here, as they use the <label> forms of the relevant
2309     // instructions.
2310     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Offset);
2311     if (!CE)
2312       return Error (E, "constant expression expected");
2313
2314     // Now we should have the closing ']'
2315     E = Parser.getTok().getLoc();
2316     if (Parser.getTok().isNot(AsmToken::RBrac))
2317       return Error(E, "']' expected");
2318     Parser.Lex(); // Eat right bracket token.
2319
2320     // Don't worry about range checking the value here. That's handled by
2321     // the is*() predicates.
2322     Operands.push_back(ARMOperand::CreateMem(BaseRegNum, CE, 0,
2323                                              ARM_AM::no_shift, 0, false, S,E));
2324
2325     // If there's a pre-indexing writeback marker, '!', just add it as a token
2326     // operand.
2327     if (Parser.getTok().is(AsmToken::Exclaim)) {
2328       Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc()));
2329       Parser.Lex(); // Eat the '!'.
2330     }
2331
2332     return false;
2333   }
2334
2335   // The register offset is optionally preceded by a '+' or '-'
2336   bool isNegative = false;
2337   if (Parser.getTok().is(AsmToken::Minus)) {
2338     isNegative = true;
2339     Parser.Lex(); // Eat the '-'.
2340   } else if (Parser.getTok().is(AsmToken::Plus)) {
2341     // Nothing to do.
2342     Parser.Lex(); // Eat the '+'.
2343   }
2344
2345   E = Parser.getTok().getLoc();
2346   int OffsetRegNum = tryParseRegister();
2347   if (OffsetRegNum == -1)
2348     return Error(E, "register expected");
2349
2350   // If there's a shift operator, handle it.
2351   ARM_AM::ShiftOpc ShiftType = ARM_AM::no_shift;
2352   unsigned ShiftImm = 0;
2353   if (Parser.getTok().is(AsmToken::Comma)) {
2354     Parser.Lex(); // Eat the ','.
2355     if (parseMemRegOffsetShift(ShiftType, ShiftImm))
2356       return true;
2357   }
2358
2359   // Now we should have the closing ']'
2360   E = Parser.getTok().getLoc();
2361   if (Parser.getTok().isNot(AsmToken::RBrac))
2362     return Error(E, "']' expected");
2363   Parser.Lex(); // Eat right bracket token.
2364
2365   Operands.push_back(ARMOperand::CreateMem(BaseRegNum, 0, OffsetRegNum,
2366                                            ShiftType, ShiftImm, isNegative,
2367                                            S, E));
2368
2369   // If there's a pre-indexing writeback marker, '!', just add it as a token
2370   // operand.
2371   if (Parser.getTok().is(AsmToken::Exclaim)) {
2372     Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc()));
2373     Parser.Lex(); // Eat the '!'.
2374   }
2375
2376   return false;
2377 }
2378
2379 /// parseMemRegOffsetShift - one of these two:
2380 ///   ( lsl | lsr | asr | ror ) , # shift_amount
2381 ///   rrx
2382 /// return true if it parses a shift otherwise it returns false.
2383 bool ARMAsmParser::parseMemRegOffsetShift(ARM_AM::ShiftOpc &St,
2384                                           unsigned &Amount) {
2385   SMLoc Loc = Parser.getTok().getLoc();
2386   const AsmToken &Tok = Parser.getTok();
2387   if (Tok.isNot(AsmToken::Identifier))
2388     return true;
2389   StringRef ShiftName = Tok.getString();
2390   if (ShiftName == "lsl" || ShiftName == "LSL")
2391     St = ARM_AM::lsl;
2392   else if (ShiftName == "lsr" || ShiftName == "LSR")
2393     St = ARM_AM::lsr;
2394   else if (ShiftName == "asr" || ShiftName == "ASR")
2395     St = ARM_AM::asr;
2396   else if (ShiftName == "ror" || ShiftName == "ROR")
2397     St = ARM_AM::ror;
2398   else if (ShiftName == "rrx" || ShiftName == "RRX")
2399     St = ARM_AM::rrx;
2400   else
2401     return Error(Loc, "illegal shift operator");
2402   Parser.Lex(); // Eat shift type token.
2403
2404   // rrx stands alone.
2405   Amount = 0;
2406   if (St != ARM_AM::rrx) {
2407     Loc = Parser.getTok().getLoc();
2408     // A '#' and a shift amount.
2409     const AsmToken &HashTok = Parser.getTok();
2410     if (HashTok.isNot(AsmToken::Hash))
2411       return Error(HashTok.getLoc(), "'#' expected");
2412     Parser.Lex(); // Eat hash token.
2413
2414     const MCExpr *Expr;
2415     if (getParser().ParseExpression(Expr))
2416       return true;
2417     // Range check the immediate.
2418     // lsl, ror: 0 <= imm <= 31
2419     // lsr, asr: 0 <= imm <= 32
2420     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr);
2421     if (!CE)
2422       return Error(Loc, "shift amount must be an immediate");
2423     int64_t Imm = CE->getValue();
2424     if (Imm < 0 ||
2425         ((St == ARM_AM::lsl || St == ARM_AM::ror) && Imm > 31) ||
2426         ((St == ARM_AM::lsr || St == ARM_AM::asr) && Imm > 32))
2427       return Error(Loc, "immediate shift value out of range");
2428     Amount = Imm;
2429   }
2430
2431   return false;
2432 }
2433
2434 /// Parse a arm instruction operand.  For now this parses the operand regardless
2435 /// of the mnemonic.
2436 bool ARMAsmParser::parseOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands,
2437                                 StringRef Mnemonic) {
2438   SMLoc S, E;
2439
2440   // Check if the current operand has a custom associated parser, if so, try to
2441   // custom parse the operand, or fallback to the general approach.
2442   OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic);
2443   if (ResTy == MatchOperand_Success)
2444     return false;
2445   // If there wasn't a custom match, try the generic matcher below. Otherwise,
2446   // there was a match, but an error occurred, in which case, just return that
2447   // the operand parsing failed.
2448   if (ResTy == MatchOperand_ParseFail)
2449     return true;
2450
2451   switch (getLexer().getKind()) {
2452   default:
2453     Error(Parser.getTok().getLoc(), "unexpected token in operand");
2454     return true;
2455   case AsmToken::Identifier: {
2456     if (!tryParseRegisterWithWriteBack(Operands))
2457       return false;
2458     int Res = tryParseShiftRegister(Operands);
2459     if (Res == 0) // success
2460       return false;
2461     else if (Res == -1) // irrecoverable error
2462       return true;
2463
2464     // Fall though for the Identifier case that is not a register or a
2465     // special name.
2466   }
2467   case AsmToken::Integer: // things like 1f and 2b as a branch targets
2468   case AsmToken::Dot: {   // . as a branch target
2469     // This was not a register so parse other operands that start with an
2470     // identifier (like labels) as expressions and create them as immediates.
2471     const MCExpr *IdVal;
2472     S = Parser.getTok().getLoc();
2473     if (getParser().ParseExpression(IdVal))
2474       return true;
2475     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2476     Operands.push_back(ARMOperand::CreateImm(IdVal, S, E));
2477     return false;
2478   }
2479   case AsmToken::LBrac:
2480     return parseMemory(Operands);
2481   case AsmToken::LCurly:
2482     return parseRegisterList(Operands);
2483   case AsmToken::Hash:
2484     // #42 -> immediate.
2485     // TODO: ":lower16:" and ":upper16:" modifiers after # before immediate
2486     S = Parser.getTok().getLoc();
2487     Parser.Lex();
2488     const MCExpr *ImmVal;
2489     if (getParser().ParseExpression(ImmVal))
2490       return true;
2491     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2492     Operands.push_back(ARMOperand::CreateImm(ImmVal, S, E));
2493     return false;
2494   case AsmToken::Colon: {
2495     // ":lower16:" and ":upper16:" expression prefixes
2496     // FIXME: Check it's an expression prefix,
2497     // e.g. (FOO - :lower16:BAR) isn't legal.
2498     ARMMCExpr::VariantKind RefKind;
2499     if (parsePrefix(RefKind))
2500       return true;
2501
2502     const MCExpr *SubExprVal;
2503     if (getParser().ParseExpression(SubExprVal))
2504       return true;
2505
2506     const MCExpr *ExprVal = ARMMCExpr::Create(RefKind, SubExprVal,
2507                                                    getContext());
2508     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2509     Operands.push_back(ARMOperand::CreateImm(ExprVal, S, E));
2510     return false;
2511   }
2512   }
2513 }
2514
2515 // parsePrefix - Parse ARM 16-bit relocations expression prefix, i.e.
2516 //  :lower16: and :upper16:.
2517 bool ARMAsmParser::parsePrefix(ARMMCExpr::VariantKind &RefKind) {
2518   RefKind = ARMMCExpr::VK_ARM_None;
2519
2520   // :lower16: and :upper16: modifiers
2521   assert(getLexer().is(AsmToken::Colon) && "expected a :");
2522   Parser.Lex(); // Eat ':'
2523
2524   if (getLexer().isNot(AsmToken::Identifier)) {
2525     Error(Parser.getTok().getLoc(), "expected prefix identifier in operand");
2526     return true;
2527   }
2528
2529   StringRef IDVal = Parser.getTok().getIdentifier();
2530   if (IDVal == "lower16") {
2531     RefKind = ARMMCExpr::VK_ARM_LO16;
2532   } else if (IDVal == "upper16") {
2533     RefKind = ARMMCExpr::VK_ARM_HI16;
2534   } else {
2535     Error(Parser.getTok().getLoc(), "unexpected prefix in operand");
2536     return true;
2537   }
2538   Parser.Lex();
2539
2540   if (getLexer().isNot(AsmToken::Colon)) {
2541     Error(Parser.getTok().getLoc(), "unexpected token after prefix");
2542     return true;
2543   }
2544   Parser.Lex(); // Eat the last ':'
2545   return false;
2546 }
2547
2548 const MCExpr *
2549 ARMAsmParser::applyPrefixToExpr(const MCExpr *E,
2550                                 MCSymbolRefExpr::VariantKind Variant) {
2551   // Recurse over the given expression, rebuilding it to apply the given variant
2552   // to the leftmost symbol.
2553   if (Variant == MCSymbolRefExpr::VK_None)
2554     return E;
2555
2556   switch (E->getKind()) {
2557   case MCExpr::Target:
2558     llvm_unreachable("Can't handle target expr yet");
2559   case MCExpr::Constant:
2560     llvm_unreachable("Can't handle lower16/upper16 of constant yet");
2561
2562   case MCExpr::SymbolRef: {
2563     const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(E);
2564
2565     if (SRE->getKind() != MCSymbolRefExpr::VK_None)
2566       return 0;
2567
2568     return MCSymbolRefExpr::Create(&SRE->getSymbol(), Variant, getContext());
2569   }
2570
2571   case MCExpr::Unary:
2572     llvm_unreachable("Can't handle unary expressions yet");
2573
2574   case MCExpr::Binary: {
2575     const MCBinaryExpr *BE = cast<MCBinaryExpr>(E);
2576     const MCExpr *LHS = applyPrefixToExpr(BE->getLHS(), Variant);
2577     const MCExpr *RHS = BE->getRHS();
2578     if (!LHS)
2579       return 0;
2580
2581     return MCBinaryExpr::Create(BE->getOpcode(), LHS, RHS, getContext());
2582   }
2583   }
2584
2585   assert(0 && "Invalid expression kind!");
2586   return 0;
2587 }
2588
2589 /// \brief Given a mnemonic, split out possible predication code and carry
2590 /// setting letters to form a canonical mnemonic and flags.
2591 //
2592 // FIXME: Would be nice to autogen this.
2593 StringRef ARMAsmParser::splitMnemonic(StringRef Mnemonic,
2594                                       unsigned &PredicationCode,
2595                                       bool &CarrySetting,
2596                                       unsigned &ProcessorIMod) {
2597   PredicationCode = ARMCC::AL;
2598   CarrySetting = false;
2599   ProcessorIMod = 0;
2600
2601   // Ignore some mnemonics we know aren't predicated forms.
2602   //
2603   // FIXME: Would be nice to autogen this.
2604   if ((Mnemonic == "movs" && isThumb()) ||
2605       Mnemonic == "teq"   || Mnemonic == "vceq"   || Mnemonic == "svc"   ||
2606       Mnemonic == "mls"   || Mnemonic == "smmls"  || Mnemonic == "vcls"  ||
2607       Mnemonic == "vmls"  || Mnemonic == "vnmls"  || Mnemonic == "vacge" ||
2608       Mnemonic == "vcge"  || Mnemonic == "vclt"   || Mnemonic == "vacgt" ||
2609       Mnemonic == "vcgt"  || Mnemonic == "vcle"   || Mnemonic == "smlal" ||
2610       Mnemonic == "umaal" || Mnemonic == "umlal"  || Mnemonic == "vabal" ||
2611       Mnemonic == "vmlal" || Mnemonic == "vpadal" || Mnemonic == "vqdmlal")
2612     return Mnemonic;
2613
2614   // First, split out any predication code. Ignore mnemonics we know aren't
2615   // predicated but do have a carry-set and so weren't caught above.
2616   if (Mnemonic != "adcs" && Mnemonic != "bics" && Mnemonic != "movs" &&
2617       Mnemonic != "muls" && Mnemonic != "smlals" && Mnemonic != "smulls" &&
2618       Mnemonic != "umlals" && Mnemonic != "umulls") {
2619     unsigned CC = StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2))
2620       .Case("eq", ARMCC::EQ)
2621       .Case("ne", ARMCC::NE)
2622       .Case("hs", ARMCC::HS)
2623       .Case("cs", ARMCC::HS)
2624       .Case("lo", ARMCC::LO)
2625       .Case("cc", ARMCC::LO)
2626       .Case("mi", ARMCC::MI)
2627       .Case("pl", ARMCC::PL)
2628       .Case("vs", ARMCC::VS)
2629       .Case("vc", ARMCC::VC)
2630       .Case("hi", ARMCC::HI)
2631       .Case("ls", ARMCC::LS)
2632       .Case("ge", ARMCC::GE)
2633       .Case("lt", ARMCC::LT)
2634       .Case("gt", ARMCC::GT)
2635       .Case("le", ARMCC::LE)
2636       .Case("al", ARMCC::AL)
2637       .Default(~0U);
2638     if (CC != ~0U) {
2639       Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 2);
2640       PredicationCode = CC;
2641     }
2642   }
2643
2644   // Next, determine if we have a carry setting bit. We explicitly ignore all
2645   // the instructions we know end in 's'.
2646   if (Mnemonic.endswith("s") &&
2647       !(Mnemonic == "asrs" || Mnemonic == "cps" || Mnemonic == "mls" ||
2648         Mnemonic == "mrs" || Mnemonic == "smmls" || Mnemonic == "vabs" ||
2649         Mnemonic == "vcls" || Mnemonic == "vmls" || Mnemonic == "vmrs" ||
2650         Mnemonic == "vnmls" || Mnemonic == "vqabs" || Mnemonic == "vrecps" ||
2651         Mnemonic == "vrsqrts" || Mnemonic == "srs" ||
2652         (Mnemonic == "movs" && isThumb()))) {
2653     Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 1);
2654     CarrySetting = true;
2655   }
2656
2657   // The "cps" instruction can have a interrupt mode operand which is glued into
2658   // the mnemonic. Check if this is the case, split it and parse the imod op
2659   if (Mnemonic.startswith("cps")) {
2660     // Split out any imod code.
2661     unsigned IMod =
2662       StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2, 2))
2663       .Case("ie", ARM_PROC::IE)
2664       .Case("id", ARM_PROC::ID)
2665       .Default(~0U);
2666     if (IMod != ~0U) {
2667       Mnemonic = Mnemonic.slice(0, Mnemonic.size()-2);
2668       ProcessorIMod = IMod;
2669     }
2670   }
2671
2672   return Mnemonic;
2673 }
2674
2675 /// \brief Given a canonical mnemonic, determine if the instruction ever allows
2676 /// inclusion of carry set or predication code operands.
2677 //
2678 // FIXME: It would be nice to autogen this.
2679 void ARMAsmParser::
2680 getMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet,
2681                       bool &CanAcceptPredicationCode) {
2682   if (Mnemonic == "and" || Mnemonic == "lsl" || Mnemonic == "lsr" ||
2683       Mnemonic == "rrx" || Mnemonic == "ror" || Mnemonic == "sub" ||
2684       Mnemonic == "smull" || Mnemonic == "add" || Mnemonic == "adc" ||
2685       Mnemonic == "mul" || Mnemonic == "bic" || Mnemonic == "asr" ||
2686       Mnemonic == "umlal" || Mnemonic == "orr" || Mnemonic == "mvn" ||
2687       Mnemonic == "rsb" || Mnemonic == "rsc" || Mnemonic == "orn" ||
2688       Mnemonic == "sbc" || Mnemonic == "mla" || Mnemonic == "umull" ||
2689       Mnemonic == "eor" || Mnemonic == "smlal" ||
2690       (Mnemonic == "mov" && !isThumbOne())) {
2691     CanAcceptCarrySet = true;
2692   } else {
2693     CanAcceptCarrySet = false;
2694   }
2695
2696   if (Mnemonic == "cbnz" || Mnemonic == "setend" || Mnemonic == "dmb" ||
2697       Mnemonic == "cps" || Mnemonic == "mcr2" || Mnemonic == "it" ||
2698       Mnemonic == "mcrr2" || Mnemonic == "cbz" || Mnemonic == "cdp2" ||
2699       Mnemonic == "trap" || Mnemonic == "mrc2" || Mnemonic == "mrrc2" ||
2700       Mnemonic == "dsb" || Mnemonic == "isb" || Mnemonic == "clrex" ||
2701       Mnemonic == "setend" ||
2702       ((Mnemonic == "pld" || Mnemonic == "pli") && !isThumb()) ||
2703       ((Mnemonic.startswith("rfe") || Mnemonic.startswith("srs"))
2704         && !isThumb()) ||
2705       Mnemonic.startswith("cps") || (Mnemonic == "movs" && isThumb())) {
2706     CanAcceptPredicationCode = false;
2707   } else {
2708     CanAcceptPredicationCode = true;
2709   }
2710
2711   if (isThumb())
2712     if (Mnemonic == "bkpt" || Mnemonic == "mcr" || Mnemonic == "mcrr" ||
2713         Mnemonic == "mrc" || Mnemonic == "mrrc" || Mnemonic == "cdp")
2714       CanAcceptPredicationCode = false;
2715 }
2716
2717 /// Parse an arm instruction mnemonic followed by its operands.
2718 bool ARMAsmParser::ParseInstruction(StringRef Name, SMLoc NameLoc,
2719                                SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2720   // Create the leading tokens for the mnemonic, split by '.' characters.
2721   size_t Start = 0, Next = Name.find('.');
2722   StringRef Mnemonic = Name.slice(Start, Next);
2723
2724   // Split out the predication code and carry setting flag from the mnemonic.
2725   unsigned PredicationCode;
2726   unsigned ProcessorIMod;
2727   bool CarrySetting;
2728   Mnemonic = splitMnemonic(Mnemonic, PredicationCode, CarrySetting,
2729                            ProcessorIMod);
2730
2731   Operands.push_back(ARMOperand::CreateToken(Mnemonic, NameLoc));
2732
2733   // FIXME: This is all a pretty gross hack. We should automatically handle
2734   // optional operands like this via tblgen.
2735
2736   // Next, add the CCOut and ConditionCode operands, if needed.
2737   //
2738   // For mnemonics which can ever incorporate a carry setting bit or predication
2739   // code, our matching model involves us always generating CCOut and
2740   // ConditionCode operands to match the mnemonic "as written" and then we let
2741   // the matcher deal with finding the right instruction or generating an
2742   // appropriate error.
2743   bool CanAcceptCarrySet, CanAcceptPredicationCode;
2744   getMnemonicAcceptInfo(Mnemonic, CanAcceptCarrySet, CanAcceptPredicationCode);
2745
2746   // If we had a carry-set on an instruction that can't do that, issue an
2747   // error.
2748   if (!CanAcceptCarrySet && CarrySetting) {
2749     Parser.EatToEndOfStatement();
2750     return Error(NameLoc, "instruction '" + Mnemonic +
2751                  "' can not set flags, but 's' suffix specified");
2752   }
2753   // If we had a predication code on an instruction that can't do that, issue an
2754   // error.
2755   if (!CanAcceptPredicationCode && PredicationCode != ARMCC::AL) {
2756     Parser.EatToEndOfStatement();
2757     return Error(NameLoc, "instruction '" + Mnemonic +
2758                  "' is not predicable, but condition code specified");
2759   }
2760
2761   // Add the carry setting operand, if necessary.
2762   //
2763   // FIXME: It would be awesome if we could somehow invent a location such that
2764   // match errors on this operand would print a nice diagnostic about how the
2765   // 's' character in the mnemonic resulted in a CCOut operand.
2766   if (CanAcceptCarrySet)
2767     Operands.push_back(ARMOperand::CreateCCOut(CarrySetting ? ARM::CPSR : 0,
2768                                                NameLoc));
2769
2770   // Add the predication code operand, if necessary.
2771   if (CanAcceptPredicationCode) {
2772     Operands.push_back(ARMOperand::CreateCondCode(
2773                          ARMCC::CondCodes(PredicationCode), NameLoc));
2774   }
2775
2776   // Add the processor imod operand, if necessary.
2777   if (ProcessorIMod) {
2778     Operands.push_back(ARMOperand::CreateImm(
2779           MCConstantExpr::Create(ProcessorIMod, getContext()),
2780                                  NameLoc, NameLoc));
2781   } else {
2782     // This mnemonic can't ever accept a imod, but the user wrote
2783     // one (or misspelled another mnemonic).
2784
2785     // FIXME: Issue a nice error.
2786   }
2787
2788   // Add the remaining tokens in the mnemonic.
2789   while (Next != StringRef::npos) {
2790     Start = Next;
2791     Next = Name.find('.', Start + 1);
2792     StringRef ExtraToken = Name.slice(Start, Next);
2793
2794     Operands.push_back(ARMOperand::CreateToken(ExtraToken, NameLoc));
2795   }
2796
2797   // Read the remaining operands.
2798   if (getLexer().isNot(AsmToken::EndOfStatement)) {
2799     // Read the first operand.
2800     if (parseOperand(Operands, Mnemonic)) {
2801       Parser.EatToEndOfStatement();
2802       return true;
2803     }
2804
2805     while (getLexer().is(AsmToken::Comma)) {
2806       Parser.Lex();  // Eat the comma.
2807
2808       // Parse and remember the operand.
2809       if (parseOperand(Operands, Mnemonic)) {
2810         Parser.EatToEndOfStatement();
2811         return true;
2812       }
2813     }
2814   }
2815
2816   if (getLexer().isNot(AsmToken::EndOfStatement)) {
2817     Parser.EatToEndOfStatement();
2818     return TokError("unexpected token in argument list");
2819   }
2820
2821   Parser.Lex(); // Consume the EndOfStatement
2822
2823
2824   // The 'mov' mnemonic is special. One variant has a cc_out operand, while
2825   // another does not. Specifically, the MOVW instruction does not. So we
2826   // special case it here and remove the defaulted (non-setting) cc_out
2827   // operand if that's the instruction we're trying to match.
2828   //
2829   // We do this post-processing of the explicit operands rather than just
2830   // conditionally adding the cc_out in the first place because we need
2831   // to check the type of the parsed immediate operand.
2832   if (Mnemonic == "mov" && Operands.size() > 4 &&
2833       !static_cast<ARMOperand*>(Operands[4])->isARMSOImm() &&
2834       static_cast<ARMOperand*>(Operands[4])->isImm0_65535Expr() &&
2835       static_cast<ARMOperand*>(Operands[1])->getReg() == 0) {
2836     ARMOperand *Op = static_cast<ARMOperand*>(Operands[1]);
2837     Operands.erase(Operands.begin() + 1);
2838     delete Op;
2839   }
2840
2841   // ARM mode 'blx' need special handling, as the register operand version
2842   // is predicable, but the label operand version is not. So, we can't rely
2843   // on the Mnemonic based checking to correctly figure out when to put
2844   // a CondCode operand in the list. If we're trying to match the label
2845   // version, remove the CondCode operand here.
2846   if (!isThumb() && Mnemonic == "blx" && Operands.size() == 3 &&
2847       static_cast<ARMOperand*>(Operands[2])->isImm()) {
2848     ARMOperand *Op = static_cast<ARMOperand*>(Operands[1]);
2849     Operands.erase(Operands.begin() + 1);
2850     delete Op;
2851   }
2852   return false;
2853 }
2854
2855 // Validate context-sensitive operand constraints.
2856 // FIXME: We would really like to be able to tablegen'erate this.
2857 bool ARMAsmParser::
2858 validateInstruction(MCInst &Inst,
2859                     const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2860   switch (Inst.getOpcode()) {
2861   case ARM::LDRD:
2862   case ARM::LDRD_PRE:
2863   case ARM::LDRD_POST:
2864   case ARM::LDREXD: {
2865     // Rt2 must be Rt + 1.
2866     unsigned Rt = getARMRegisterNumbering(Inst.getOperand(0).getReg());
2867     unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(1).getReg());
2868     if (Rt2 != Rt + 1)
2869       return Error(Operands[3]->getStartLoc(),
2870                    "destination operands must be sequential");
2871     return false;
2872   }
2873   case ARM::STRD: {
2874     // Rt2 must be Rt + 1.
2875     unsigned Rt = getARMRegisterNumbering(Inst.getOperand(0).getReg());
2876     unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(1).getReg());
2877     if (Rt2 != Rt + 1)
2878       return Error(Operands[3]->getStartLoc(),
2879                    "source operands must be sequential");
2880     return false;
2881   }
2882   case ARM::STRD_PRE:
2883   case ARM::STRD_POST:
2884   case ARM::STREXD: {
2885     // Rt2 must be Rt + 1.
2886     unsigned Rt = getARMRegisterNumbering(Inst.getOperand(1).getReg());
2887     unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(2).getReg());
2888     if (Rt2 != Rt + 1)
2889       return Error(Operands[3]->getStartLoc(),
2890                    "source operands must be sequential");
2891     return false;
2892   }
2893   case ARM::SBFX:
2894   case ARM::UBFX: {
2895     // width must be in range [1, 32-lsb]
2896     unsigned lsb = Inst.getOperand(2).getImm();
2897     unsigned widthm1 = Inst.getOperand(3).getImm();
2898     if (widthm1 >= 32 - lsb)
2899       return Error(Operands[5]->getStartLoc(),
2900                    "bitfield width must be in range [1,32-lsb]");
2901   }
2902   }
2903
2904   return false;
2905 }
2906
2907 void ARMAsmParser::
2908 processInstruction(MCInst &Inst,
2909                    const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2910   switch (Inst.getOpcode()) {
2911   case ARM::LDMIA_UPD:
2912     // If this is a load of a single register via a 'pop', then we should use
2913     // a post-indexed LDR instruction instead, per the ARM ARM.
2914     if (static_cast<ARMOperand*>(Operands[0])->getToken() == "pop" &&
2915         Inst.getNumOperands() == 5) {
2916       MCInst TmpInst;
2917       TmpInst.setOpcode(ARM::LDR_POST_IMM);
2918       TmpInst.addOperand(Inst.getOperand(4)); // Rt
2919       TmpInst.addOperand(Inst.getOperand(0)); // Rn_wb
2920       TmpInst.addOperand(Inst.getOperand(1)); // Rn
2921       TmpInst.addOperand(MCOperand::CreateReg(0));  // am2offset
2922       TmpInst.addOperand(MCOperand::CreateImm(4));
2923       TmpInst.addOperand(Inst.getOperand(2)); // CondCode
2924       TmpInst.addOperand(Inst.getOperand(3));
2925       Inst = TmpInst;
2926     }
2927     break;
2928   case ARM::STMDB_UPD:
2929     // If this is a store of a single register via a 'push', then we should use
2930     // a pre-indexed STR instruction instead, per the ARM ARM.
2931     if (static_cast<ARMOperand*>(Operands[0])->getToken() == "push" &&
2932         Inst.getNumOperands() == 5) {
2933       MCInst TmpInst;
2934       TmpInst.setOpcode(ARM::STR_PRE_IMM);
2935       TmpInst.addOperand(Inst.getOperand(0)); // Rn_wb
2936       TmpInst.addOperand(Inst.getOperand(4)); // Rt
2937       TmpInst.addOperand(Inst.getOperand(1)); // addrmode_imm12
2938       TmpInst.addOperand(MCOperand::CreateImm(-4));
2939       TmpInst.addOperand(Inst.getOperand(2)); // CondCode
2940       TmpInst.addOperand(Inst.getOperand(3));
2941       Inst = TmpInst;
2942     }
2943     break;
2944   }
2945 }
2946
2947 bool ARMAsmParser::
2948 MatchAndEmitInstruction(SMLoc IDLoc,
2949                         SmallVectorImpl<MCParsedAsmOperand*> &Operands,
2950                         MCStreamer &Out) {
2951   MCInst Inst;
2952   unsigned ErrorInfo;
2953   MatchResultTy MatchResult;
2954   MatchResult = MatchInstructionImpl(Operands, Inst, ErrorInfo);
2955   switch (MatchResult) {
2956   case Match_Success:
2957     // Context sensitive operand constraints aren't handled by the matcher,
2958     // so check them here.
2959     if (validateInstruction(Inst, Operands))
2960       return true;
2961
2962     // Some instructions need post-processing to, for example, tweak which
2963     // encoding is selected.
2964     processInstruction(Inst, Operands);
2965
2966     Out.EmitInstruction(Inst);
2967     return false;
2968   case Match_MissingFeature:
2969     Error(IDLoc, "instruction requires a CPU feature not currently enabled");
2970     return true;
2971   case Match_InvalidOperand: {
2972     SMLoc ErrorLoc = IDLoc;
2973     if (ErrorInfo != ~0U) {
2974       if (ErrorInfo >= Operands.size())
2975         return Error(IDLoc, "too few operands for instruction");
2976
2977       ErrorLoc = ((ARMOperand*)Operands[ErrorInfo])->getStartLoc();
2978       if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc;
2979     }
2980
2981     return Error(ErrorLoc, "invalid operand for instruction");
2982   }
2983   case Match_MnemonicFail:
2984     return Error(IDLoc, "unrecognized instruction mnemonic");
2985   case Match_ConversionFail:
2986     return Error(IDLoc, "unable to convert operands to instruction");
2987   }
2988
2989   llvm_unreachable("Implement any new match types added!");
2990   return true;
2991 }
2992
2993 /// parseDirective parses the arm specific directives
2994 bool ARMAsmParser::ParseDirective(AsmToken DirectiveID) {
2995   StringRef IDVal = DirectiveID.getIdentifier();
2996   if (IDVal == ".word")
2997     return parseDirectiveWord(4, DirectiveID.getLoc());
2998   else if (IDVal == ".thumb")
2999     return parseDirectiveThumb(DirectiveID.getLoc());
3000   else if (IDVal == ".thumb_func")
3001     return parseDirectiveThumbFunc(DirectiveID.getLoc());
3002   else if (IDVal == ".code")
3003     return parseDirectiveCode(DirectiveID.getLoc());
3004   else if (IDVal == ".syntax")
3005     return parseDirectiveSyntax(DirectiveID.getLoc());
3006   return true;
3007 }
3008
3009 /// parseDirectiveWord
3010 ///  ::= .word [ expression (, expression)* ]
3011 bool ARMAsmParser::parseDirectiveWord(unsigned Size, SMLoc L) {
3012   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3013     for (;;) {
3014       const MCExpr *Value;
3015       if (getParser().ParseExpression(Value))
3016         return true;
3017
3018       getParser().getStreamer().EmitValue(Value, Size, 0/*addrspace*/);
3019
3020       if (getLexer().is(AsmToken::EndOfStatement))
3021         break;
3022
3023       // FIXME: Improve diagnostic.
3024       if (getLexer().isNot(AsmToken::Comma))
3025         return Error(L, "unexpected token in directive");
3026       Parser.Lex();
3027     }
3028   }
3029
3030   Parser.Lex();
3031   return false;
3032 }
3033
3034 /// parseDirectiveThumb
3035 ///  ::= .thumb
3036 bool ARMAsmParser::parseDirectiveThumb(SMLoc L) {
3037   if (getLexer().isNot(AsmToken::EndOfStatement))
3038     return Error(L, "unexpected token in directive");
3039   Parser.Lex();
3040
3041   // TODO: set thumb mode
3042   // TODO: tell the MC streamer the mode
3043   // getParser().getStreamer().Emit???();
3044   return false;
3045 }
3046
3047 /// parseDirectiveThumbFunc
3048 ///  ::= .thumbfunc symbol_name
3049 bool ARMAsmParser::parseDirectiveThumbFunc(SMLoc L) {
3050   const MCAsmInfo &MAI = getParser().getStreamer().getContext().getAsmInfo();
3051   bool isMachO = MAI.hasSubsectionsViaSymbols();
3052   StringRef Name;
3053
3054   // Darwin asm has function name after .thumb_func direction
3055   // ELF doesn't
3056   if (isMachO) {
3057     const AsmToken &Tok = Parser.getTok();
3058     if (Tok.isNot(AsmToken::Identifier) && Tok.isNot(AsmToken::String))
3059       return Error(L, "unexpected token in .thumb_func directive");
3060     Name = Tok.getString();
3061     Parser.Lex(); // Consume the identifier token.
3062   }
3063
3064   if (getLexer().isNot(AsmToken::EndOfStatement))
3065     return Error(L, "unexpected token in directive");
3066   Parser.Lex();
3067
3068   // FIXME: assuming function name will be the line following .thumb_func
3069   if (!isMachO) {
3070     Name = Parser.getTok().getString();
3071   }
3072
3073   // Mark symbol as a thumb symbol.
3074   MCSymbol *Func = getParser().getContext().GetOrCreateSymbol(Name);
3075   getParser().getStreamer().EmitThumbFunc(Func);
3076   return false;
3077 }
3078
3079 /// parseDirectiveSyntax
3080 ///  ::= .syntax unified | divided
3081 bool ARMAsmParser::parseDirectiveSyntax(SMLoc L) {
3082   const AsmToken &Tok = Parser.getTok();
3083   if (Tok.isNot(AsmToken::Identifier))
3084     return Error(L, "unexpected token in .syntax directive");
3085   StringRef Mode = Tok.getString();
3086   if (Mode == "unified" || Mode == "UNIFIED")
3087     Parser.Lex();
3088   else if (Mode == "divided" || Mode == "DIVIDED")
3089     return Error(L, "'.syntax divided' arm asssembly not supported");
3090   else
3091     return Error(L, "unrecognized syntax mode in .syntax directive");
3092
3093   if (getLexer().isNot(AsmToken::EndOfStatement))
3094     return Error(Parser.getTok().getLoc(), "unexpected token in directive");
3095   Parser.Lex();
3096
3097   // TODO tell the MC streamer the mode
3098   // getParser().getStreamer().Emit???();
3099   return false;
3100 }
3101
3102 /// parseDirectiveCode
3103 ///  ::= .code 16 | 32
3104 bool ARMAsmParser::parseDirectiveCode(SMLoc L) {
3105   const AsmToken &Tok = Parser.getTok();
3106   if (Tok.isNot(AsmToken::Integer))
3107     return Error(L, "unexpected token in .code directive");
3108   int64_t Val = Parser.getTok().getIntVal();
3109   if (Val == 16)
3110     Parser.Lex();
3111   else if (Val == 32)
3112     Parser.Lex();
3113   else
3114     return Error(L, "invalid operand to .code directive");
3115
3116   if (getLexer().isNot(AsmToken::EndOfStatement))
3117     return Error(Parser.getTok().getLoc(), "unexpected token in directive");
3118   Parser.Lex();
3119
3120   if (Val == 16) {
3121     if (!isThumb()) {
3122       SwitchMode();
3123       getParser().getStreamer().EmitAssemblerFlag(MCAF_Code16);
3124     }
3125   } else {
3126     if (isThumb()) {
3127       SwitchMode();
3128       getParser().getStreamer().EmitAssemblerFlag(MCAF_Code32);
3129     }
3130   }
3131
3132   return false;
3133 }
3134
3135 extern "C" void LLVMInitializeARMAsmLexer();
3136
3137 /// Force static initialization.
3138 extern "C" void LLVMInitializeARMAsmParser() {
3139   RegisterMCAsmParser<ARMAsmParser> X(TheARMTarget);
3140   RegisterMCAsmParser<ARMAsmParser> Y(TheThumbTarget);
3141   LLVMInitializeARMAsmLexer();
3142 }
3143
3144 #define GET_REGISTER_MATCHER
3145 #define GET_MATCHER_IMPLEMENTATION
3146 #include "ARMGenAsmMatcher.inc"