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