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