lib/Target/ARM/AsmParser/ARMAsmParser.cpp

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