lib/Target/ARM/AsmParser/ARMAsmParser.cpp

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