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