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