lib/Target/ARM/AsmParser/ARMAsmParser.cpp

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