ARMAsmParser.cpp revision d475f8612b1c7959dbf50242c8fa9d4aea1ee1a9 
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/MCInstrDesc.h"
22#include "llvm/MC/MCRegisterInfo.h"
23#include "llvm/MC/MCSubtargetInfo.h"
24#include "llvm/MC/MCTargetAsmParser.h"
25#include "llvm/Support/MathExtras.h"
26#include "llvm/Support/SourceMgr.h"
27#include "llvm/Support/TargetRegistry.h"
28#include "llvm/Support/raw_ostream.h"
29#include "llvm/ADT/BitVector.h"
30#include "llvm/ADT/OwningPtr.h"
31#include "llvm/ADT/STLExtras.h"
32#include "llvm/ADT/SmallVector.h"
33#include "llvm/ADT/StringSwitch.h"
34#include "llvm/ADT/Twine.h"
35
36using namespace llvm;
37
38namespace {
39
40class ARMOperand;
41
42class ARMAsmParser : public MCTargetAsmParser {
43  MCSubtargetInfo &STI;
44  MCAsmParser &Parser;
45
46  struct {
47    ARMCC::CondCodes Cond;    // Condition for IT block.
48    unsigned Mask:4;          // Condition mask for instructions.
49                              // Starting at first 1 (from lsb).
50                              //   '1'  condition as indicated in IT.
51                              //   '0'  inverse of condition (else).
52                              // Count of instructions in IT block is
53                              // 4 - trailingzeroes(mask)
54
55    bool FirstCond;           // Explicit flag for when we're parsing the
56                              // First instruction in the IT block. It's
57                              // implied in the mask, so needs special
58                              // handling.
59
60    unsigned CurPosition;     // Current position in parsing of IT
61                              // block. In range [0,3]. Initialized
62                              // according to count of instructions in block.
63                              // ~0U if no active IT block.
64  } ITState;
65  bool inITBlock() { return ITState.CurPosition != ~0U;}
66  void forwardITPosition() {
67    if (!inITBlock()) return;
68    // Move to the next instruction in the IT block, if there is one. If not,
69    // mark the block as done.
70    unsigned TZ = CountTrailingZeros_32(ITState.Mask);
71    if (++ITState.CurPosition == 5 - TZ)
72      ITState.CurPosition = ~0U; // Done with the IT block after this.
73  }
74
75
76  MCAsmParser &getParser() const { return Parser; }
77  MCAsmLexer &getLexer() const { return Parser.getLexer(); }
78
79  void Warning(SMLoc L, const Twine &Msg) { Parser.Warning(L, Msg); }
80  bool Error(SMLoc L, const Twine &Msg) { return Parser.Error(L, Msg); }
81
82  int tryParseRegister();
83  bool tryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &);
84  int tryParseShiftRegister(SmallVectorImpl<MCParsedAsmOperand*> &);
85  bool parseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &);
86  bool parseMemory(SmallVectorImpl<MCParsedAsmOperand*> &);
87  bool parseOperand(SmallVectorImpl<MCParsedAsmOperand*> &, StringRef Mnemonic);
88  bool parsePrefix(ARMMCExpr::VariantKind &RefKind);
89  bool parseMemRegOffsetShift(ARM_AM::ShiftOpc &ShiftType,
90                              unsigned &ShiftAmount);
91  bool parseDirectiveWord(unsigned Size, SMLoc L);
92  bool parseDirectiveThumb(SMLoc L);
93  bool parseDirectiveThumbFunc(SMLoc L);
94  bool parseDirectiveCode(SMLoc L);
95  bool parseDirectiveSyntax(SMLoc L);
96
97  StringRef splitMnemonic(StringRef Mnemonic, unsigned &PredicationCode,
98                          bool &CarrySetting, unsigned &ProcessorIMod,
99                          StringRef &ITMask);
100  void getMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet,
101                             bool &CanAcceptPredicationCode);
102
103  bool isThumb() const {
104    // FIXME: Can tablegen auto-generate this?
105    return (STI.getFeatureBits() & ARM::ModeThumb) != 0;
106  }
107  bool isThumbOne() const {
108    return isThumb() && (STI.getFeatureBits() & ARM::FeatureThumb2) == 0;
109  }
110  bool isThumbTwo() const {
111    return isThumb() && (STI.getFeatureBits() & ARM::FeatureThumb2);
112  }
113  bool hasV6Ops() const {
114    return STI.getFeatureBits() & ARM::HasV6Ops;
115  }
116  bool hasV7Ops() const {
117    return STI.getFeatureBits() & ARM::HasV7Ops;
118  }
119  void SwitchMode() {
120    unsigned FB = ComputeAvailableFeatures(STI.ToggleFeature(ARM::ModeThumb));
121    setAvailableFeatures(FB);
122  }
123  bool isMClass() const {
124    return STI.getFeatureBits() & ARM::FeatureMClass;
125  }
126
127  /// @name Auto-generated Match Functions
128  /// {
129
130#define GET_ASSEMBLER_HEADER
131#include "ARMGenAsmMatcher.inc"
132
133  /// }
134
135  OperandMatchResultTy parseITCondCode(SmallVectorImpl<MCParsedAsmOperand*>&);
136  OperandMatchResultTy parseCoprocNumOperand(
137    SmallVectorImpl<MCParsedAsmOperand*>&);
138  OperandMatchResultTy parseCoprocRegOperand(
139    SmallVectorImpl<MCParsedAsmOperand*>&);
140  OperandMatchResultTy parseCoprocOptionOperand(
141    SmallVectorImpl<MCParsedAsmOperand*>&);
142  OperandMatchResultTy parseMemBarrierOptOperand(
143    SmallVectorImpl<MCParsedAsmOperand*>&);
144  OperandMatchResultTy parseProcIFlagsOperand(
145    SmallVectorImpl<MCParsedAsmOperand*>&);
146  OperandMatchResultTy parseMSRMaskOperand(
147    SmallVectorImpl<MCParsedAsmOperand*>&);
148  OperandMatchResultTy parsePKHImm(SmallVectorImpl<MCParsedAsmOperand*> &O,
149                                   StringRef Op, int Low, int High);
150  OperandMatchResultTy parsePKHLSLImm(SmallVectorImpl<MCParsedAsmOperand*> &O) {
151    return parsePKHImm(O, "lsl", 0, 31);
152  }
153  OperandMatchResultTy parsePKHASRImm(SmallVectorImpl<MCParsedAsmOperand*> &O) {
154    return parsePKHImm(O, "asr", 1, 32);
155  }
156  OperandMatchResultTy parseSetEndImm(SmallVectorImpl<MCParsedAsmOperand*>&);
157  OperandMatchResultTy parseShifterImm(SmallVectorImpl<MCParsedAsmOperand*>&);
158  OperandMatchResultTy parseRotImm(SmallVectorImpl<MCParsedAsmOperand*>&);
159  OperandMatchResultTy parseBitfield(SmallVectorImpl<MCParsedAsmOperand*>&);
160  OperandMatchResultTy parsePostIdxReg(SmallVectorImpl<MCParsedAsmOperand*>&);
161  OperandMatchResultTy parseAM3Offset(SmallVectorImpl<MCParsedAsmOperand*>&);
162  OperandMatchResultTy parseFPImm(SmallVectorImpl<MCParsedAsmOperand*>&);
163  OperandMatchResultTy parseVectorList(SmallVectorImpl<MCParsedAsmOperand*>&);
164
165  // Asm Match Converter Methods
166  bool cvtT2LdrdPre(MCInst &Inst, unsigned Opcode,
167                    const SmallVectorImpl<MCParsedAsmOperand*> &);
168  bool cvtT2StrdPre(MCInst &Inst, unsigned Opcode,
169                    const SmallVectorImpl<MCParsedAsmOperand*> &);
170  bool cvtLdWriteBackRegT2AddrModeImm8(MCInst &Inst, unsigned Opcode,
171                                  const SmallVectorImpl<MCParsedAsmOperand*> &);
172  bool cvtStWriteBackRegT2AddrModeImm8(MCInst &Inst, unsigned Opcode,
173                                  const SmallVectorImpl<MCParsedAsmOperand*> &);
174  bool cvtLdWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
175                                  const SmallVectorImpl<MCParsedAsmOperand*> &);
176  bool cvtLdWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
177                                  const SmallVectorImpl<MCParsedAsmOperand*> &);
178  bool cvtStWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
179                                  const SmallVectorImpl<MCParsedAsmOperand*> &);
180  bool cvtStWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
181                                  const SmallVectorImpl<MCParsedAsmOperand*> &);
182  bool cvtStWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
183                                  const SmallVectorImpl<MCParsedAsmOperand*> &);
184  bool cvtLdExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
185                             const SmallVectorImpl<MCParsedAsmOperand*> &);
186  bool cvtLdExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
187                             const SmallVectorImpl<MCParsedAsmOperand*> &);
188  bool cvtStExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
189                             const SmallVectorImpl<MCParsedAsmOperand*> &);
190  bool cvtStExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
191                             const SmallVectorImpl<MCParsedAsmOperand*> &);
192  bool cvtLdrdPre(MCInst &Inst, unsigned Opcode,
193                  const SmallVectorImpl<MCParsedAsmOperand*> &);
194  bool cvtStrdPre(MCInst &Inst, unsigned Opcode,
195                  const SmallVectorImpl<MCParsedAsmOperand*> &);
196  bool cvtLdWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
197                                  const SmallVectorImpl<MCParsedAsmOperand*> &);
198  bool cvtThumbMultiply(MCInst &Inst, unsigned Opcode,
199                        const SmallVectorImpl<MCParsedAsmOperand*> &);
200  bool cvtVLDwbFixed(MCInst &Inst, unsigned Opcode,
201                     const SmallVectorImpl<MCParsedAsmOperand*> &);
202  bool cvtVLDwbRegister(MCInst &Inst, unsigned Opcode,
203                        const SmallVectorImpl<MCParsedAsmOperand*> &);
204  bool cvtVSTwbFixed(MCInst &Inst, unsigned Opcode,
205                     const SmallVectorImpl<MCParsedAsmOperand*> &);
206  bool cvtVSTwbRegister(MCInst &Inst, unsigned Opcode,
207                        const SmallVectorImpl<MCParsedAsmOperand*> &);
208
209  bool validateInstruction(MCInst &Inst,
210                           const SmallVectorImpl<MCParsedAsmOperand*> &Ops);
211  void processInstruction(MCInst &Inst,
212                          const SmallVectorImpl<MCParsedAsmOperand*> &Ops);
213  bool shouldOmitCCOutOperand(StringRef Mnemonic,
214                              SmallVectorImpl<MCParsedAsmOperand*> &Operands);
215
216public:
217  enum ARMMatchResultTy {
218    Match_RequiresITBlock = FIRST_TARGET_MATCH_RESULT_TY,
219    Match_RequiresNotITBlock,
220    Match_RequiresV6,
221    Match_RequiresThumb2
222  };
223
224  ARMAsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser)
225    : MCTargetAsmParser(), STI(_STI), Parser(_Parser) {
226    MCAsmParserExtension::Initialize(_Parser);
227
228    // Initialize the set of available features.
229    setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
230
231    // Not in an ITBlock to start with.
232    ITState.CurPosition = ~0U;
233  }
234
235  // Implementation of the MCTargetAsmParser interface:
236  bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc);
237  bool ParseInstruction(StringRef Name, SMLoc NameLoc,
238                        SmallVectorImpl<MCParsedAsmOperand*> &Operands);
239  bool ParseDirective(AsmToken DirectiveID);
240
241  unsigned checkTargetMatchPredicate(MCInst &Inst);
242
243  bool MatchAndEmitInstruction(SMLoc IDLoc,
244                               SmallVectorImpl<MCParsedAsmOperand*> &Operands,
245                               MCStreamer &Out);
246};
247} // end anonymous namespace
248
249namespace {
250
251/// ARMOperand - Instances of this class represent a parsed ARM machine
252/// instruction.
253class ARMOperand : public MCParsedAsmOperand {
254  enum KindTy {
255    k_CondCode,
256    k_CCOut,
257    k_ITCondMask,
258    k_CoprocNum,
259    k_CoprocReg,
260    k_CoprocOption,
261    k_Immediate,
262    k_FPImmediate,
263    k_MemBarrierOpt,
264    k_Memory,
265    k_PostIndexRegister,
266    k_MSRMask,
267    k_ProcIFlags,
268    k_VectorIndex,
269    k_Register,
270    k_RegisterList,
271    k_DPRRegisterList,
272    k_SPRRegisterList,
273    k_VectorList,
274    k_ShiftedRegister,
275    k_ShiftedImmediate,
276    k_ShifterImmediate,
277    k_RotateImmediate,
278    k_BitfieldDescriptor,
279    k_Token
280  } Kind;
281
282  SMLoc StartLoc, EndLoc;
283  SmallVector<unsigned, 8> Registers;
284
285  union {
286    struct {
287      ARMCC::CondCodes Val;
288    } CC;
289
290    struct {
291      unsigned Val;
292    } Cop;
293
294    struct {
295      unsigned Val;
296    } CoprocOption;
297
298    struct {
299      unsigned Mask:4;
300    } ITMask;
301
302    struct {
303      ARM_MB::MemBOpt Val;
304    } MBOpt;
305
306    struct {
307      ARM_PROC::IFlags Val;
308    } IFlags;
309
310    struct {
311      unsigned Val;
312    } MMask;
313
314    struct {
315      const char *Data;
316      unsigned Length;
317    } Tok;
318
319    struct {
320      unsigned RegNum;
321    } Reg;
322
323    // A vector register list is a sequential list of 1 to 4 registers.
324    struct {
325      unsigned RegNum;
326      unsigned Count;
327    } VectorList;
328
329    struct {
330      unsigned Val;
331    } VectorIndex;
332
333    struct {
334      const MCExpr *Val;
335    } Imm;
336
337    struct {
338      unsigned Val;       // encoded 8-bit representation
339    } FPImm;
340
341    /// Combined record for all forms of ARM address expressions.
342    struct {
343      unsigned BaseRegNum;
344      // Offset is in OffsetReg or OffsetImm. If both are zero, no offset
345      // was specified.
346      const MCConstantExpr *OffsetImm;  // Offset immediate value
347      unsigned OffsetRegNum;    // Offset register num, when OffsetImm == NULL
348      ARM_AM::ShiftOpc ShiftType; // Shift type for OffsetReg
349      unsigned ShiftImm;        // shift for OffsetReg.
350      unsigned Alignment;       // 0 = no alignment specified
351                                // n = alignment in bytes (8, 16, or 32)
352      unsigned isNegative : 1;  // Negated OffsetReg? (~'U' bit)
353    } Memory;
354
355    struct {
356      unsigned RegNum;
357      bool isAdd;
358      ARM_AM::ShiftOpc ShiftTy;
359      unsigned ShiftImm;
360    } PostIdxReg;
361
362    struct {
363      bool isASR;
364      unsigned Imm;
365    } ShifterImm;
366    struct {
367      ARM_AM::ShiftOpc ShiftTy;
368      unsigned SrcReg;
369      unsigned ShiftReg;
370      unsigned ShiftImm;
371    } RegShiftedReg;
372    struct {
373      ARM_AM::ShiftOpc ShiftTy;
374      unsigned SrcReg;
375      unsigned ShiftImm;
376    } RegShiftedImm;
377    struct {
378      unsigned Imm;
379    } RotImm;
380    struct {
381      unsigned LSB;
382      unsigned Width;
383    } Bitfield;
384  };
385
386  ARMOperand(KindTy K) : MCParsedAsmOperand(), Kind(K) {}
387public:
388  ARMOperand(const ARMOperand &o) : MCParsedAsmOperand() {
389    Kind = o.Kind;
390    StartLoc = o.StartLoc;
391    EndLoc = o.EndLoc;
392    switch (Kind) {
393    case k_CondCode:
394      CC = o.CC;
395      break;
396    case k_ITCondMask:
397      ITMask = o.ITMask;
398      break;
399    case k_Token:
400      Tok = o.Tok;
401      break;
402    case k_CCOut:
403    case k_Register:
404      Reg = o.Reg;
405      break;
406    case k_RegisterList:
407    case k_DPRRegisterList:
408    case k_SPRRegisterList:
409      Registers = o.Registers;
410      break;
411    case k_VectorList:
412      VectorList = o.VectorList;
413      break;
414    case k_CoprocNum:
415    case k_CoprocReg:
416      Cop = o.Cop;
417      break;
418    case k_CoprocOption:
419      CoprocOption = o.CoprocOption;
420      break;
421    case k_Immediate:
422      Imm = o.Imm;
423      break;
424    case k_FPImmediate:
425      FPImm = o.FPImm;
426      break;
427    case k_MemBarrierOpt:
428      MBOpt = o.MBOpt;
429      break;
430    case k_Memory:
431      Memory = o.Memory;
432      break;
433    case k_PostIndexRegister:
434      PostIdxReg = o.PostIdxReg;
435      break;
436    case k_MSRMask:
437      MMask = o.MMask;
438      break;
439    case k_ProcIFlags:
440      IFlags = o.IFlags;
441      break;
442    case k_ShifterImmediate:
443      ShifterImm = o.ShifterImm;
444      break;
445    case k_ShiftedRegister:
446      RegShiftedReg = o.RegShiftedReg;
447      break;
448    case k_ShiftedImmediate:
449      RegShiftedImm = o.RegShiftedImm;
450      break;
451    case k_RotateImmediate:
452      RotImm = o.RotImm;
453      break;
454    case k_BitfieldDescriptor:
455      Bitfield = o.Bitfield;
456      break;
457    case k_VectorIndex:
458      VectorIndex = o.VectorIndex;
459      break;
460    }
461  }
462
463  /// getStartLoc - Get the location of the first token of this operand.
464  SMLoc getStartLoc() const { return StartLoc; }
465  /// getEndLoc - Get the location of the last token of this operand.
466  SMLoc getEndLoc() const { return EndLoc; }
467
468  ARMCC::CondCodes getCondCode() const {
469    assert(Kind == k_CondCode && "Invalid access!");
470    return CC.Val;
471  }
472
473  unsigned getCoproc() const {
474    assert((Kind == k_CoprocNum || Kind == k_CoprocReg) && "Invalid access!");
475    return Cop.Val;
476  }
477
478  StringRef getToken() const {
479    assert(Kind == k_Token && "Invalid access!");
480    return StringRef(Tok.Data, Tok.Length);
481  }
482
483  unsigned getReg() const {
484    assert((Kind == k_Register || Kind == k_CCOut) && "Invalid access!");
485    return Reg.RegNum;
486  }
487
488  const SmallVectorImpl<unsigned> &getRegList() const {
489    assert((Kind == k_RegisterList || Kind == k_DPRRegisterList ||
490            Kind == k_SPRRegisterList) && "Invalid access!");
491    return Registers;
492  }
493
494  const MCExpr *getImm() const {
495    assert(Kind == k_Immediate && "Invalid access!");
496    return Imm.Val;
497  }
498
499  unsigned getFPImm() const {
500    assert(Kind == k_FPImmediate && "Invalid access!");
501    return FPImm.Val;
502  }
503
504  unsigned getVectorIndex() const {
505    assert(Kind == k_VectorIndex && "Invalid access!");
506    return VectorIndex.Val;
507  }
508
509  ARM_MB::MemBOpt getMemBarrierOpt() const {
510    assert(Kind == k_MemBarrierOpt && "Invalid access!");
511    return MBOpt.Val;
512  }
513
514  ARM_PROC::IFlags getProcIFlags() const {
515    assert(Kind == k_ProcIFlags && "Invalid access!");
516    return IFlags.Val;
517  }
518
519  unsigned getMSRMask() const {
520    assert(Kind == k_MSRMask && "Invalid access!");
521    return MMask.Val;
522  }
523
524  bool isCoprocNum() const { return Kind == k_CoprocNum; }
525  bool isCoprocReg() const { return Kind == k_CoprocReg; }
526  bool isCoprocOption() const { return Kind == k_CoprocOption; }
527  bool isCondCode() const { return Kind == k_CondCode; }
528  bool isCCOut() const { return Kind == k_CCOut; }
529  bool isITMask() const { return Kind == k_ITCondMask; }
530  bool isITCondCode() const { return Kind == k_CondCode; }
531  bool isImm() const { return Kind == k_Immediate; }
532  bool isFPImm() const { return Kind == k_FPImmediate; }
533  bool isImm8s4() const {
534    if (Kind != k_Immediate)
535      return false;
536    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
537    if (!CE) return false;
538    int64_t Value = CE->getValue();
539    return ((Value & 3) == 0) && Value >= -1020 && Value <= 1020;
540  }
541  bool isImm0_1020s4() const {
542    if (Kind != k_Immediate)
543      return false;
544    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
545    if (!CE) return false;
546    int64_t Value = CE->getValue();
547    return ((Value & 3) == 0) && Value >= 0 && Value <= 1020;
548  }
549  bool isImm0_508s4() const {
550    if (Kind != k_Immediate)
551      return false;
552    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
553    if (!CE) return false;
554    int64_t Value = CE->getValue();
555    return ((Value & 3) == 0) && Value >= 0 && Value <= 508;
556  }
557  bool isImm0_255() const {
558    if (Kind != k_Immediate)
559      return false;
560    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
561    if (!CE) return false;
562    int64_t Value = CE->getValue();
563    return Value >= 0 && Value < 256;
564  }
565  bool isImm0_7() const {
566    if (Kind != k_Immediate)
567      return false;
568    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
569    if (!CE) return false;
570    int64_t Value = CE->getValue();
571    return Value >= 0 && Value < 8;
572  }
573  bool isImm0_15() const {
574    if (Kind != k_Immediate)
575      return false;
576    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
577    if (!CE) return false;
578    int64_t Value = CE->getValue();
579    return Value >= 0 && Value < 16;
580  }
581  bool isImm0_31() const {
582    if (Kind != k_Immediate)
583      return false;
584    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
585    if (!CE) return false;
586    int64_t Value = CE->getValue();
587    return Value >= 0 && Value < 32;
588  }
589  bool isImm1_16() const {
590    if (Kind != k_Immediate)
591      return false;
592    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
593    if (!CE) return false;
594    int64_t Value = CE->getValue();
595    return Value > 0 && Value < 17;
596  }
597  bool isImm1_32() const {
598    if (Kind != k_Immediate)
599      return false;
600    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
601    if (!CE) return false;
602    int64_t Value = CE->getValue();
603    return Value > 0 && Value < 33;
604  }
605  bool isImm0_32() const {
606    if (Kind != k_Immediate)
607      return false;
608    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
609    if (!CE) return false;
610    int64_t Value = CE->getValue();
611    return Value >= 0 && Value < 33;
612  }
613  bool isImm0_65535() const {
614    if (Kind != k_Immediate)
615      return false;
616    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
617    if (!CE) return false;
618    int64_t Value = CE->getValue();
619    return Value >= 0 && Value < 65536;
620  }
621  bool isImm0_65535Expr() const {
622    if (Kind != k_Immediate)
623      return false;
624    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
625    // If it's not a constant expression, it'll generate a fixup and be
626    // handled later.
627    if (!CE) return true;
628    int64_t Value = CE->getValue();
629    return Value >= 0 && Value < 65536;
630  }
631  bool isImm24bit() const {
632    if (Kind != k_Immediate)
633      return false;
634    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
635    if (!CE) return false;
636    int64_t Value = CE->getValue();
637    return Value >= 0 && Value <= 0xffffff;
638  }
639  bool isImmThumbSR() const {
640    if (Kind != k_Immediate)
641      return false;
642    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
643    if (!CE) return false;
644    int64_t Value = CE->getValue();
645    return Value > 0 && Value < 33;
646  }
647  bool isPKHLSLImm() const {
648    if (Kind != k_Immediate)
649      return false;
650    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
651    if (!CE) return false;
652    int64_t Value = CE->getValue();
653    return Value >= 0 && Value < 32;
654  }
655  bool isPKHASRImm() const {
656    if (Kind != k_Immediate)
657      return false;
658    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
659    if (!CE) return false;
660    int64_t Value = CE->getValue();
661    return Value > 0 && Value <= 32;
662  }
663  bool isARMSOImm() const {
664    if (Kind != k_Immediate)
665      return false;
666    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
667    if (!CE) return false;
668    int64_t Value = CE->getValue();
669    return ARM_AM::getSOImmVal(Value) != -1;
670  }
671  bool isARMSOImmNot() const {
672    if (Kind != k_Immediate)
673      return false;
674    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
675    if (!CE) return false;
676    int64_t Value = CE->getValue();
677    return ARM_AM::getSOImmVal(~Value) != -1;
678  }
679  bool isT2SOImm() const {
680    if (Kind != k_Immediate)
681      return false;
682    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
683    if (!CE) return false;
684    int64_t Value = CE->getValue();
685    return ARM_AM::getT2SOImmVal(Value) != -1;
686  }
687  bool isT2SOImmNot() const {
688    if (Kind != k_Immediate)
689      return false;
690    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
691    if (!CE) return false;
692    int64_t Value = CE->getValue();
693    return ARM_AM::getT2SOImmVal(~Value) != -1;
694  }
695  bool isSetEndImm() const {
696    if (Kind != k_Immediate)
697      return false;
698    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
699    if (!CE) return false;
700    int64_t Value = CE->getValue();
701    return Value == 1 || Value == 0;
702  }
703  bool isReg() const { return Kind == k_Register; }
704  bool isRegList() const { return Kind == k_RegisterList; }
705  bool isDPRRegList() const { return Kind == k_DPRRegisterList; }
706  bool isSPRRegList() const { return Kind == k_SPRRegisterList; }
707  bool isToken() const { return Kind == k_Token; }
708  bool isMemBarrierOpt() const { return Kind == k_MemBarrierOpt; }
709  bool isMemory() const { return Kind == k_Memory; }
710  bool isShifterImm() const { return Kind == k_ShifterImmediate; }
711  bool isRegShiftedReg() const { return Kind == k_ShiftedRegister; }
712  bool isRegShiftedImm() const { return Kind == k_ShiftedImmediate; }
713  bool isRotImm() const { return Kind == k_RotateImmediate; }
714  bool isBitfield() const { return Kind == k_BitfieldDescriptor; }
715  bool isPostIdxRegShifted() const { return Kind == k_PostIndexRegister; }
716  bool isPostIdxReg() const {
717    return Kind == k_PostIndexRegister && PostIdxReg.ShiftTy == ARM_AM::no_shift;
718  }
719  bool isMemNoOffset(bool alignOK = false) const {
720    if (!isMemory())
721      return false;
722    // No offset of any kind.
723    return Memory.OffsetRegNum == 0 && Memory.OffsetImm == 0 &&
724     (alignOK || Memory.Alignment == 0);
725  }
726  bool isAlignedMemory() const {
727    return isMemNoOffset(true);
728  }
729  bool isAddrMode2() const {
730    if (!isMemory() || Memory.Alignment != 0) return false;
731    // Check for register offset.
732    if (Memory.OffsetRegNum) return true;
733    // Immediate offset in range [-4095, 4095].
734    if (!Memory.OffsetImm) return true;
735    int64_t Val = Memory.OffsetImm->getValue();
736    return Val > -4096 && Val < 4096;
737  }
738  bool isAM2OffsetImm() const {
739    if (Kind != k_Immediate)
740      return false;
741    // Immediate offset in range [-4095, 4095].
742    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
743    if (!CE) return false;
744    int64_t Val = CE->getValue();
745    return Val > -4096 && Val < 4096;
746  }
747  bool isAddrMode3() const {
748    if (!isMemory() || Memory.Alignment != 0) return false;
749    // No shifts are legal for AM3.
750    if (Memory.ShiftType != ARM_AM::no_shift) return false;
751    // Check for register offset.
752    if (Memory.OffsetRegNum) return true;
753    // Immediate offset in range [-255, 255].
754    if (!Memory.OffsetImm) return true;
755    int64_t Val = Memory.OffsetImm->getValue();
756    return Val > -256 && Val < 256;
757  }
758  bool isAM3Offset() const {
759    if (Kind != k_Immediate && Kind != k_PostIndexRegister)
760      return false;
761    if (Kind == k_PostIndexRegister)
762      return PostIdxReg.ShiftTy == ARM_AM::no_shift;
763    // Immediate offset in range [-255, 255].
764    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
765    if (!CE) return false;
766    int64_t Val = CE->getValue();
767    // Special case, #-0 is INT32_MIN.
768    return (Val > -256 && Val < 256) || Val == INT32_MIN;
769  }
770  bool isAddrMode5() const {
771    // If we have an immediate that's not a constant, treat it as a label
772    // reference needing a fixup. If it is a constant, it's something else
773    // and we reject it.
774    if (Kind == k_Immediate && !isa<MCConstantExpr>(getImm()))
775      return true;
776    if (!isMemory() || Memory.Alignment != 0) return false;
777    // Check for register offset.
778    if (Memory.OffsetRegNum) return false;
779    // Immediate offset in range [-1020, 1020] and a multiple of 4.
780    if (!Memory.OffsetImm) return true;
781    int64_t Val = Memory.OffsetImm->getValue();
782    return (Val >= -1020 && Val <= 1020 && ((Val & 3) == 0)) ||
783      Val == INT32_MIN;
784  }
785  bool isMemTBB() const {
786    if (!isMemory() || !Memory.OffsetRegNum || Memory.isNegative ||
787        Memory.ShiftType != ARM_AM::no_shift || Memory.Alignment != 0)
788      return false;
789    return true;
790  }
791  bool isMemTBH() const {
792    if (!isMemory() || !Memory.OffsetRegNum || Memory.isNegative ||
793        Memory.ShiftType != ARM_AM::lsl || Memory.ShiftImm != 1 ||
794        Memory.Alignment != 0 )
795      return false;
796    return true;
797  }
798  bool isMemRegOffset() const {
799    if (!isMemory() || !Memory.OffsetRegNum || Memory.Alignment != 0)
800      return false;
801    return true;
802  }
803  bool isT2MemRegOffset() const {
804    if (!isMemory() || !Memory.OffsetRegNum || Memory.isNegative ||
805        Memory.Alignment != 0)
806      return false;
807    // Only lsl #{0, 1, 2, 3} allowed.
808    if (Memory.ShiftType == ARM_AM::no_shift)
809      return true;
810    if (Memory.ShiftType != ARM_AM::lsl || Memory.ShiftImm > 3)
811      return false;
812    return true;
813  }
814  bool isMemThumbRR() const {
815    // Thumb reg+reg addressing is simple. Just two registers, a base and
816    // an offset. No shifts, negations or any other complicating factors.
817    if (!isMemory() || !Memory.OffsetRegNum || Memory.isNegative ||
818        Memory.ShiftType != ARM_AM::no_shift || Memory.Alignment != 0)
819      return false;
820    return isARMLowRegister(Memory.BaseRegNum) &&
821      (!Memory.OffsetRegNum || isARMLowRegister(Memory.OffsetRegNum));
822  }
823  bool isMemThumbRIs4() const {
824    if (!isMemory() || Memory.OffsetRegNum != 0 ||
825        !isARMLowRegister(Memory.BaseRegNum) || Memory.Alignment != 0)
826      return false;
827    // Immediate offset, multiple of 4 in range [0, 124].
828    if (!Memory.OffsetImm) return true;
829    int64_t Val = Memory.OffsetImm->getValue();
830    return Val >= 0 && Val <= 124 && (Val % 4) == 0;
831  }
832  bool isMemThumbRIs2() const {
833    if (!isMemory() || Memory.OffsetRegNum != 0 ||
834        !isARMLowRegister(Memory.BaseRegNum) || Memory.Alignment != 0)
835      return false;
836    // Immediate offset, multiple of 4 in range [0, 62].
837    if (!Memory.OffsetImm) return true;
838    int64_t Val = Memory.OffsetImm->getValue();
839    return Val >= 0 && Val <= 62 && (Val % 2) == 0;
840  }
841  bool isMemThumbRIs1() const {
842    if (!isMemory() || Memory.OffsetRegNum != 0 ||
843        !isARMLowRegister(Memory.BaseRegNum) || Memory.Alignment != 0)
844      return false;
845    // Immediate offset in range [0, 31].
846    if (!Memory.OffsetImm) return true;
847    int64_t Val = Memory.OffsetImm->getValue();
848    return Val >= 0 && Val <= 31;
849  }
850  bool isMemThumbSPI() const {
851    if (!isMemory() || Memory.OffsetRegNum != 0 ||
852        Memory.BaseRegNum != ARM::SP || Memory.Alignment != 0)
853      return false;
854    // Immediate offset, multiple of 4 in range [0, 1020].
855    if (!Memory.OffsetImm) return true;
856    int64_t Val = Memory.OffsetImm->getValue();
857    return Val >= 0 && Val <= 1020 && (Val % 4) == 0;
858  }
859  bool isMemImm8s4Offset() const {
860    if (!isMemory() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0)
861      return false;
862    // Immediate offset a multiple of 4 in range [-1020, 1020].
863    if (!Memory.OffsetImm) return true;
864    int64_t Val = Memory.OffsetImm->getValue();
865    return Val >= -1020 && Val <= 1020 && (Val & 3) == 0;
866  }
867  bool isMemImm0_1020s4Offset() const {
868    if (!isMemory() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0)
869      return false;
870    // Immediate offset a multiple of 4 in range [0, 1020].
871    if (!Memory.OffsetImm) return true;
872    int64_t Val = Memory.OffsetImm->getValue();
873    return Val >= 0 && Val <= 1020 && (Val & 3) == 0;
874  }
875  bool isMemImm8Offset() const {
876    if (!isMemory() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0)
877      return false;
878    // Immediate offset in range [-255, 255].
879    if (!Memory.OffsetImm) return true;
880    int64_t Val = Memory.OffsetImm->getValue();
881    return (Val == INT32_MIN) || (Val > -256 && Val < 256);
882  }
883  bool isMemPosImm8Offset() const {
884    if (!isMemory() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0)
885      return false;
886    // Immediate offset in range [0, 255].
887    if (!Memory.OffsetImm) return true;
888    int64_t Val = Memory.OffsetImm->getValue();
889    return Val >= 0 && Val < 256;
890  }
891  bool isMemNegImm8Offset() const {
892    if (!isMemory() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0)
893      return false;
894    // Immediate offset in range [-255, -1].
895    if (!Memory.OffsetImm) return true;
896    int64_t Val = Memory.OffsetImm->getValue();
897    return Val > -256 && Val < 0;
898  }
899  bool isMemUImm12Offset() const {
900    if (!isMemory() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0)
901      return false;
902    // Immediate offset in range [0, 4095].
903    if (!Memory.OffsetImm) return true;
904    int64_t Val = Memory.OffsetImm->getValue();
905    return (Val >= 0 && Val < 4096);
906  }
907  bool isMemImm12Offset() const {
908    // If we have an immediate that's not a constant, treat it as a label
909    // reference needing a fixup. If it is a constant, it's something else
910    // and we reject it.
911    if (Kind == k_Immediate && !isa<MCConstantExpr>(getImm()))
912      return true;
913
914    if (!isMemory() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0)
915      return false;
916    // Immediate offset in range [-4095, 4095].
917    if (!Memory.OffsetImm) return true;
918    int64_t Val = Memory.OffsetImm->getValue();
919    return (Val > -4096 && Val < 4096) || (Val == INT32_MIN);
920  }
921  bool isPostIdxImm8() const {
922    if (Kind != k_Immediate)
923      return false;
924    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
925    if (!CE) return false;
926    int64_t Val = CE->getValue();
927    return (Val > -256 && Val < 256) || (Val == INT32_MIN);
928  }
929  bool isPostIdxImm8s4() const {
930    if (Kind != k_Immediate)
931      return false;
932    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
933    if (!CE) return false;
934    int64_t Val = CE->getValue();
935    return ((Val & 3) == 0 && Val >= -1020 && Val <= 1020) ||
936      (Val == INT32_MIN);
937  }
938
939  bool isMSRMask() const { return Kind == k_MSRMask; }
940  bool isProcIFlags() const { return Kind == k_ProcIFlags; }
941
942  // NEON operands.
943  bool isVecListOneD() const {
944    if (Kind != k_VectorList) return false;
945    return VectorList.Count == 1;
946  }
947
948  bool isVecListTwoD() const {
949    if (Kind != k_VectorList) return false;
950    return VectorList.Count == 2;
951  }
952
953  bool isVecListThreeD() const {
954    if (Kind != k_VectorList) return false;
955    return VectorList.Count == 3;
956  }
957
958  bool isVecListFourD() const {
959    if (Kind != k_VectorList) return false;
960    return VectorList.Count == 4;
961  }
962
963  bool isVecListTwoQ() const {
964    if (Kind != k_VectorList) return false;
965    //FIXME: We haven't taught the parser to handle by-two register lists
966    // yet, so don't pretend to know one.
967    return VectorList.Count == 2 && false;
968  }
969
970  bool isVectorIndex8() const {
971    if (Kind != k_VectorIndex) return false;
972    return VectorIndex.Val < 8;
973  }
974  bool isVectorIndex16() const {
975    if (Kind != k_VectorIndex) return false;
976    return VectorIndex.Val < 4;
977  }
978  bool isVectorIndex32() const {
979    if (Kind != k_VectorIndex) return false;
980    return VectorIndex.Val < 2;
981  }
982
983  bool isNEONi8splat() const {
984    if (Kind != k_Immediate)
985      return false;
986    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
987    // Must be a constant.
988    if (!CE) return false;
989    int64_t Value = CE->getValue();
990    // i8 value splatted across 8 bytes. The immediate is just the 8 byte
991    // value.
992    return Value >= 0 && Value < 256;
993  }
994
995  bool isNEONi16splat() const {
996    if (Kind != k_Immediate)
997      return false;
998    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
999    // Must be a constant.
1000    if (!CE) return false;
1001    int64_t Value = CE->getValue();
1002    // i16 value in the range [0,255] or [0x0100, 0xff00]
1003    return (Value >= 0 && Value < 256) || (Value >= 0x0100 && Value <= 0xff00);
1004  }
1005
1006  bool isNEONi32splat() const {
1007    if (Kind != k_Immediate)
1008      return false;
1009    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1010    // Must be a constant.
1011    if (!CE) return false;
1012    int64_t Value = CE->getValue();
1013    // i32 value with set bits only in one byte X000, 0X00, 00X0, or 000X.
1014    return (Value >= 0 && Value < 256) ||
1015      (Value >= 0x0100 && Value <= 0xff00) ||
1016      (Value >= 0x010000 && Value <= 0xff0000) ||
1017      (Value >= 0x01000000 && Value <= 0xff000000);
1018  }
1019
1020  bool isNEONi32vmov() const {
1021    if (Kind != k_Immediate)
1022      return false;
1023    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1024    // Must be a constant.
1025    if (!CE) return false;
1026    int64_t Value = CE->getValue();
1027    // i32 value with set bits only in one byte X000, 0X00, 00X0, or 000X,
1028    // for VMOV/VMVN only, 00Xf or 0Xff are also accepted.
1029    return (Value >= 0 && Value < 256) ||
1030      (Value >= 0x0100 && Value <= 0xff00) ||
1031      (Value >= 0x010000 && Value <= 0xff0000) ||
1032      (Value >= 0x01000000 && Value <= 0xff000000) ||
1033      (Value >= 0x01ff && Value <= 0xffff && (Value & 0xff) == 0xff) ||
1034      (Value >= 0x01ffff && Value <= 0xffffff && (Value & 0xffff) == 0xffff);
1035  }
1036
1037  bool isNEONi64splat() const {
1038    if (Kind != k_Immediate)
1039      return false;
1040    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1041    // Must be a constant.
1042    if (!CE) return false;
1043    uint64_t Value = CE->getValue();
1044    // i64 value with each byte being either 0 or 0xff.
1045    for (unsigned i = 0; i < 8; ++i)
1046      if ((Value & 0xff) != 0 && (Value & 0xff) != 0xff) return false;
1047    return true;
1048  }
1049
1050  void addExpr(MCInst &Inst, const MCExpr *Expr) const {
1051    // Add as immediates when possible.  Null MCExpr = 0.
1052    if (Expr == 0)
1053      Inst.addOperand(MCOperand::CreateImm(0));
1054    else if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr))
1055      Inst.addOperand(MCOperand::CreateImm(CE->getValue()));
1056    else
1057      Inst.addOperand(MCOperand::CreateExpr(Expr));
1058  }
1059
1060  void addCondCodeOperands(MCInst &Inst, unsigned N) const {
1061    assert(N == 2 && "Invalid number of operands!");
1062    Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode())));
1063    unsigned RegNum = getCondCode() == ARMCC::AL ? 0: ARM::CPSR;
1064    Inst.addOperand(MCOperand::CreateReg(RegNum));
1065  }
1066
1067  void addCoprocNumOperands(MCInst &Inst, unsigned N) const {
1068    assert(N == 1 && "Invalid number of operands!");
1069    Inst.addOperand(MCOperand::CreateImm(getCoproc()));
1070  }
1071
1072  void addCoprocRegOperands(MCInst &Inst, unsigned N) const {
1073    assert(N == 1 && "Invalid number of operands!");
1074    Inst.addOperand(MCOperand::CreateImm(getCoproc()));
1075  }
1076
1077  void addCoprocOptionOperands(MCInst &Inst, unsigned N) const {
1078    assert(N == 1 && "Invalid number of operands!");
1079    Inst.addOperand(MCOperand::CreateImm(CoprocOption.Val));
1080  }
1081
1082  void addITMaskOperands(MCInst &Inst, unsigned N) const {
1083    assert(N == 1 && "Invalid number of operands!");
1084    Inst.addOperand(MCOperand::CreateImm(ITMask.Mask));
1085  }
1086
1087  void addITCondCodeOperands(MCInst &Inst, unsigned N) const {
1088    assert(N == 1 && "Invalid number of operands!");
1089    Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode())));
1090  }
1091
1092  void addCCOutOperands(MCInst &Inst, unsigned N) const {
1093    assert(N == 1 && "Invalid number of operands!");
1094    Inst.addOperand(MCOperand::CreateReg(getReg()));
1095  }
1096
1097  void addRegOperands(MCInst &Inst, unsigned N) const {
1098    assert(N == 1 && "Invalid number of operands!");
1099    Inst.addOperand(MCOperand::CreateReg(getReg()));
1100  }
1101
1102  void addRegShiftedRegOperands(MCInst &Inst, unsigned N) const {
1103    assert(N == 3 && "Invalid number of operands!");
1104    assert(isRegShiftedReg() && "addRegShiftedRegOperands() on non RegShiftedReg!");
1105    Inst.addOperand(MCOperand::CreateReg(RegShiftedReg.SrcReg));
1106    Inst.addOperand(MCOperand::CreateReg(RegShiftedReg.ShiftReg));
1107    Inst.addOperand(MCOperand::CreateImm(
1108      ARM_AM::getSORegOpc(RegShiftedReg.ShiftTy, RegShiftedReg.ShiftImm)));
1109  }
1110
1111  void addRegShiftedImmOperands(MCInst &Inst, unsigned N) const {
1112    assert(N == 2 && "Invalid number of operands!");
1113    assert(isRegShiftedImm() && "addRegShiftedImmOperands() on non RegShiftedImm!");
1114    Inst.addOperand(MCOperand::CreateReg(RegShiftedImm.SrcReg));
1115    Inst.addOperand(MCOperand::CreateImm(
1116      ARM_AM::getSORegOpc(RegShiftedImm.ShiftTy, RegShiftedImm.ShiftImm)));
1117  }
1118
1119  void addShifterImmOperands(MCInst &Inst, unsigned N) const {
1120    assert(N == 1 && "Invalid number of operands!");
1121    Inst.addOperand(MCOperand::CreateImm((ShifterImm.isASR << 5) |
1122                                         ShifterImm.Imm));
1123  }
1124
1125  void addRegListOperands(MCInst &Inst, unsigned N) const {
1126    assert(N == 1 && "Invalid number of operands!");
1127    const SmallVectorImpl<unsigned> &RegList = getRegList();
1128    for (SmallVectorImpl<unsigned>::const_iterator
1129           I = RegList.begin(), E = RegList.end(); I != E; ++I)
1130      Inst.addOperand(MCOperand::CreateReg(*I));
1131  }
1132
1133  void addDPRRegListOperands(MCInst &Inst, unsigned N) const {
1134    addRegListOperands(Inst, N);
1135  }
1136
1137  void addSPRRegListOperands(MCInst &Inst, unsigned N) const {
1138    addRegListOperands(Inst, N);
1139  }
1140
1141  void addRotImmOperands(MCInst &Inst, unsigned N) const {
1142    assert(N == 1 && "Invalid number of operands!");
1143    // Encoded as val>>3. The printer handles display as 8, 16, 24.
1144    Inst.addOperand(MCOperand::CreateImm(RotImm.Imm >> 3));
1145  }
1146
1147  void addBitfieldOperands(MCInst &Inst, unsigned N) const {
1148    assert(N == 1 && "Invalid number of operands!");
1149    // Munge the lsb/width into a bitfield mask.
1150    unsigned lsb = Bitfield.LSB;
1151    unsigned width = Bitfield.Width;
1152    // Make a 32-bit mask w/ the referenced bits clear and all other bits set.
1153    uint32_t Mask = ~(((uint32_t)0xffffffff >> lsb) << (32 - width) >>
1154                      (32 - (lsb + width)));
1155    Inst.addOperand(MCOperand::CreateImm(Mask));
1156  }
1157
1158  void addImmOperands(MCInst &Inst, unsigned N) const {
1159    assert(N == 1 && "Invalid number of operands!");
1160    addExpr(Inst, getImm());
1161  }
1162
1163  void addFPImmOperands(MCInst &Inst, unsigned N) const {
1164    assert(N == 1 && "Invalid number of operands!");
1165    Inst.addOperand(MCOperand::CreateImm(getFPImm()));
1166  }
1167
1168  void addImm8s4Operands(MCInst &Inst, unsigned N) const {
1169    assert(N == 1 && "Invalid number of operands!");
1170    // FIXME: We really want to scale the value here, but the LDRD/STRD
1171    // instruction don't encode operands that way yet.
1172    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1173    Inst.addOperand(MCOperand::CreateImm(CE->getValue()));
1174  }
1175
1176  void addImm0_1020s4Operands(MCInst &Inst, unsigned N) const {
1177    assert(N == 1 && "Invalid number of operands!");
1178    // The immediate is scaled by four in the encoding and is stored
1179    // in the MCInst as such. Lop off the low two bits here.
1180    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1181    Inst.addOperand(MCOperand::CreateImm(CE->getValue() / 4));
1182  }
1183
1184  void addImm0_508s4Operands(MCInst &Inst, unsigned N) const {
1185    assert(N == 1 && "Invalid number of operands!");
1186    // The immediate is scaled by four in the encoding and is stored
1187    // in the MCInst as such. Lop off the low two bits here.
1188    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1189    Inst.addOperand(MCOperand::CreateImm(CE->getValue() / 4));
1190  }
1191
1192  void addImm0_255Operands(MCInst &Inst, unsigned N) const {
1193    assert(N == 1 && "Invalid number of operands!");
1194    addExpr(Inst, getImm());
1195  }
1196
1197  void addImm0_7Operands(MCInst &Inst, unsigned N) const {
1198    assert(N == 1 && "Invalid number of operands!");
1199    addExpr(Inst, getImm());
1200  }
1201
1202  void addImm0_15Operands(MCInst &Inst, unsigned N) const {
1203    assert(N == 1 && "Invalid number of operands!");
1204    addExpr(Inst, getImm());
1205  }
1206
1207  void addImm0_31Operands(MCInst &Inst, unsigned N) const {
1208    assert(N == 1 && "Invalid number of operands!");
1209    addExpr(Inst, getImm());
1210  }
1211
1212  void addImm1_16Operands(MCInst &Inst, unsigned N) const {
1213    assert(N == 1 && "Invalid number of operands!");
1214    // The constant encodes as the immediate-1, and we store in the instruction
1215    // the bits as encoded, so subtract off one here.
1216    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1217    Inst.addOperand(MCOperand::CreateImm(CE->getValue() - 1));
1218  }
1219
1220  void addImm1_32Operands(MCInst &Inst, unsigned N) const {
1221    assert(N == 1 && "Invalid number of operands!");
1222    // The constant encodes as the immediate-1, and we store in the instruction
1223    // the bits as encoded, so subtract off one here.
1224    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1225    Inst.addOperand(MCOperand::CreateImm(CE->getValue() - 1));
1226  }
1227
1228  void addImm0_32Operands(MCInst &Inst, unsigned N) const {
1229    assert(N == 1 && "Invalid number of operands!");
1230    addExpr(Inst, getImm());
1231  }
1232
1233  void addImm0_65535Operands(MCInst &Inst, unsigned N) const {
1234    assert(N == 1 && "Invalid number of operands!");
1235    addExpr(Inst, getImm());
1236  }
1237
1238  void addImm0_65535ExprOperands(MCInst &Inst, unsigned N) const {
1239    assert(N == 1 && "Invalid number of operands!");
1240    addExpr(Inst, getImm());
1241  }
1242
1243  void addImm24bitOperands(MCInst &Inst, unsigned N) const {
1244    assert(N == 1 && "Invalid number of operands!");
1245    addExpr(Inst, getImm());
1246  }
1247
1248  void addImmThumbSROperands(MCInst &Inst, unsigned N) const {
1249    assert(N == 1 && "Invalid number of operands!");
1250    // The constant encodes as the immediate, except for 32, which encodes as
1251    // zero.
1252    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1253    unsigned Imm = CE->getValue();
1254    Inst.addOperand(MCOperand::CreateImm((Imm == 32 ? 0 : Imm)));
1255  }
1256
1257  void addPKHLSLImmOperands(MCInst &Inst, unsigned N) const {
1258    assert(N == 1 && "Invalid number of operands!");
1259    addExpr(Inst, getImm());
1260  }
1261
1262  void addPKHASRImmOperands(MCInst &Inst, unsigned N) const {
1263    assert(N == 1 && "Invalid number of operands!");
1264    // An ASR value of 32 encodes as 0, so that's how we want to add it to
1265    // the instruction as well.
1266    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1267    int Val = CE->getValue();
1268    Inst.addOperand(MCOperand::CreateImm(Val == 32 ? 0 : Val));
1269  }
1270
1271  void addARMSOImmOperands(MCInst &Inst, unsigned N) const {
1272    assert(N == 1 && "Invalid number of operands!");
1273    addExpr(Inst, getImm());
1274  }
1275
1276  void addT2SOImmOperands(MCInst &Inst, unsigned N) const {
1277    assert(N == 1 && "Invalid number of operands!");
1278    addExpr(Inst, getImm());
1279  }
1280
1281  void addT2SOImmNotOperands(MCInst &Inst, unsigned N) const {
1282    assert(N == 1 && "Invalid number of operands!");
1283    // The operand is actually a t2_so_imm, but we have its bitwise
1284    // negation in the assembly source, so twiddle it here.
1285    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1286    Inst.addOperand(MCOperand::CreateImm(~CE->getValue()));
1287  }
1288
1289  void addARMSOImmNotOperands(MCInst &Inst, unsigned N) const {
1290    assert(N == 1 && "Invalid number of operands!");
1291    // The operand is actually a so_imm, but we have its bitwise
1292    // negation in the assembly source, so twiddle it here.
1293    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1294    Inst.addOperand(MCOperand::CreateImm(~CE->getValue()));
1295  }
1296
1297  void addSetEndImmOperands(MCInst &Inst, unsigned N) const {
1298    assert(N == 1 && "Invalid number of operands!");
1299    addExpr(Inst, getImm());
1300  }
1301
1302  void addMemBarrierOptOperands(MCInst &Inst, unsigned N) const {
1303    assert(N == 1 && "Invalid number of operands!");
1304    Inst.addOperand(MCOperand::CreateImm(unsigned(getMemBarrierOpt())));
1305  }
1306
1307  void addMemNoOffsetOperands(MCInst &Inst, unsigned N) const {
1308    assert(N == 1 && "Invalid number of operands!");
1309    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1310  }
1311
1312  void addAlignedMemoryOperands(MCInst &Inst, unsigned N) const {
1313    assert(N == 2 && "Invalid number of operands!");
1314    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1315    Inst.addOperand(MCOperand::CreateImm(Memory.Alignment));
1316  }
1317
1318  void addAddrMode2Operands(MCInst &Inst, unsigned N) const {
1319    assert(N == 3 && "Invalid number of operands!");
1320    int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0;
1321    if (!Memory.OffsetRegNum) {
1322      ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1323      // Special case for #-0
1324      if (Val == INT32_MIN) Val = 0;
1325      if (Val < 0) Val = -Val;
1326      Val = ARM_AM::getAM2Opc(AddSub, Val, ARM_AM::no_shift);
1327    } else {
1328      // For register offset, we encode the shift type and negation flag
1329      // here.
1330      Val = ARM_AM::getAM2Opc(Memory.isNegative ? ARM_AM::sub : ARM_AM::add,
1331                              Memory.ShiftImm, Memory.ShiftType);
1332    }
1333    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1334    Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum));
1335    Inst.addOperand(MCOperand::CreateImm(Val));
1336  }
1337
1338  void addAM2OffsetImmOperands(MCInst &Inst, unsigned N) const {
1339    assert(N == 2 && "Invalid number of operands!");
1340    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1341    assert(CE && "non-constant AM2OffsetImm operand!");
1342    int32_t Val = CE->getValue();
1343    ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1344    // Special case for #-0
1345    if (Val == INT32_MIN) Val = 0;
1346    if (Val < 0) Val = -Val;
1347    Val = ARM_AM::getAM2Opc(AddSub, Val, ARM_AM::no_shift);
1348    Inst.addOperand(MCOperand::CreateReg(0));
1349    Inst.addOperand(MCOperand::CreateImm(Val));
1350  }
1351
1352  void addAddrMode3Operands(MCInst &Inst, unsigned N) const {
1353    assert(N == 3 && "Invalid number of operands!");
1354    int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0;
1355    if (!Memory.OffsetRegNum) {
1356      ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1357      // Special case for #-0
1358      if (Val == INT32_MIN) Val = 0;
1359      if (Val < 0) Val = -Val;
1360      Val = ARM_AM::getAM3Opc(AddSub, Val);
1361    } else {
1362      // For register offset, we encode the shift type and negation flag
1363      // here.
1364      Val = ARM_AM::getAM3Opc(Memory.isNegative ? ARM_AM::sub : ARM_AM::add, 0);
1365    }
1366    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1367    Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum));
1368    Inst.addOperand(MCOperand::CreateImm(Val));
1369  }
1370
1371  void addAM3OffsetOperands(MCInst &Inst, unsigned N) const {
1372    assert(N == 2 && "Invalid number of operands!");
1373    if (Kind == k_PostIndexRegister) {
1374      int32_t Val =
1375        ARM_AM::getAM3Opc(PostIdxReg.isAdd ? ARM_AM::add : ARM_AM::sub, 0);
1376      Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum));
1377      Inst.addOperand(MCOperand::CreateImm(Val));
1378      return;
1379    }
1380
1381    // Constant offset.
1382    const MCConstantExpr *CE = static_cast<const MCConstantExpr*>(getImm());
1383    int32_t Val = CE->getValue();
1384    ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1385    // Special case for #-0
1386    if (Val == INT32_MIN) Val = 0;
1387    if (Val < 0) Val = -Val;
1388    Val = ARM_AM::getAM3Opc(AddSub, Val);
1389    Inst.addOperand(MCOperand::CreateReg(0));
1390    Inst.addOperand(MCOperand::CreateImm(Val));
1391  }
1392
1393  void addAddrMode5Operands(MCInst &Inst, unsigned N) const {
1394    assert(N == 2 && "Invalid number of operands!");
1395    // If we have an immediate that's not a constant, treat it as a label
1396    // reference needing a fixup. If it is a constant, it's something else
1397    // and we reject it.
1398    if (isImm()) {
1399      Inst.addOperand(MCOperand::CreateExpr(getImm()));
1400      Inst.addOperand(MCOperand::CreateImm(0));
1401      return;
1402    }
1403
1404    // The lower two bits are always zero and as such are not encoded.
1405    int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() / 4 : 0;
1406    ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1407    // Special case for #-0
1408    if (Val == INT32_MIN) Val = 0;
1409    if (Val < 0) Val = -Val;
1410    Val = ARM_AM::getAM5Opc(AddSub, Val);
1411    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1412    Inst.addOperand(MCOperand::CreateImm(Val));
1413  }
1414
1415  void addMemImm8s4OffsetOperands(MCInst &Inst, unsigned N) const {
1416    assert(N == 2 && "Invalid number of operands!");
1417    int64_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0;
1418    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1419    Inst.addOperand(MCOperand::CreateImm(Val));
1420  }
1421
1422  void addMemImm0_1020s4OffsetOperands(MCInst &Inst, unsigned N) const {
1423    assert(N == 2 && "Invalid number of operands!");
1424    // The lower two bits are always zero and as such are not encoded.
1425    int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() / 4 : 0;
1426    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1427    Inst.addOperand(MCOperand::CreateImm(Val));
1428  }
1429
1430  void addMemImm8OffsetOperands(MCInst &Inst, unsigned N) const {
1431    assert(N == 2 && "Invalid number of operands!");
1432    int64_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0;
1433    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1434    Inst.addOperand(MCOperand::CreateImm(Val));
1435  }
1436
1437  void addMemPosImm8OffsetOperands(MCInst &Inst, unsigned N) const {
1438    addMemImm8OffsetOperands(Inst, N);
1439  }
1440
1441  void addMemNegImm8OffsetOperands(MCInst &Inst, unsigned N) const {
1442    addMemImm8OffsetOperands(Inst, N);
1443  }
1444
1445  void addMemUImm12OffsetOperands(MCInst &Inst, unsigned N) const {
1446    assert(N == 2 && "Invalid number of operands!");
1447    // If this is an immediate, it's a label reference.
1448    if (Kind == k_Immediate) {
1449      addExpr(Inst, getImm());
1450      Inst.addOperand(MCOperand::CreateImm(0));
1451      return;
1452    }
1453
1454    // Otherwise, it's a normal memory reg+offset.
1455    int64_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0;
1456    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1457    Inst.addOperand(MCOperand::CreateImm(Val));
1458  }
1459
1460  void addMemImm12OffsetOperands(MCInst &Inst, unsigned N) const {
1461    assert(N == 2 && "Invalid number of operands!");
1462    // If this is an immediate, it's a label reference.
1463    if (Kind == k_Immediate) {
1464      addExpr(Inst, getImm());
1465      Inst.addOperand(MCOperand::CreateImm(0));
1466      return;
1467    }
1468
1469    // Otherwise, it's a normal memory reg+offset.
1470    int64_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0;
1471    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1472    Inst.addOperand(MCOperand::CreateImm(Val));
1473  }
1474
1475  void addMemTBBOperands(MCInst &Inst, unsigned N) const {
1476    assert(N == 2 && "Invalid number of operands!");
1477    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1478    Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum));
1479  }
1480
1481  void addMemTBHOperands(MCInst &Inst, unsigned N) const {
1482    assert(N == 2 && "Invalid number of operands!");
1483    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1484    Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum));
1485  }
1486
1487  void addMemRegOffsetOperands(MCInst &Inst, unsigned N) const {
1488    assert(N == 3 && "Invalid number of operands!");
1489    unsigned Val = ARM_AM::getAM2Opc(Memory.isNegative ? ARM_AM::sub : ARM_AM::add,
1490                                     Memory.ShiftImm, Memory.ShiftType);
1491    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1492    Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum));
1493    Inst.addOperand(MCOperand::CreateImm(Val));
1494  }
1495
1496  void addT2MemRegOffsetOperands(MCInst &Inst, unsigned N) const {
1497    assert(N == 3 && "Invalid number of operands!");
1498    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1499    Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum));
1500    Inst.addOperand(MCOperand::CreateImm(Memory.ShiftImm));
1501  }
1502
1503  void addMemThumbRROperands(MCInst &Inst, unsigned N) const {
1504    assert(N == 2 && "Invalid number of operands!");
1505    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1506    Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum));
1507  }
1508
1509  void addMemThumbRIs4Operands(MCInst &Inst, unsigned N) const {
1510    assert(N == 2 && "Invalid number of operands!");
1511    int64_t Val = Memory.OffsetImm ? (Memory.OffsetImm->getValue() / 4) : 0;
1512    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1513    Inst.addOperand(MCOperand::CreateImm(Val));
1514  }
1515
1516  void addMemThumbRIs2Operands(MCInst &Inst, unsigned N) const {
1517    assert(N == 2 && "Invalid number of operands!");
1518    int64_t Val = Memory.OffsetImm ? (Memory.OffsetImm->getValue() / 2) : 0;
1519    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1520    Inst.addOperand(MCOperand::CreateImm(Val));
1521  }
1522
1523  void addMemThumbRIs1Operands(MCInst &Inst, unsigned N) const {
1524    assert(N == 2 && "Invalid number of operands!");
1525    int64_t Val = Memory.OffsetImm ? (Memory.OffsetImm->getValue()) : 0;
1526    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1527    Inst.addOperand(MCOperand::CreateImm(Val));
1528  }
1529
1530  void addMemThumbSPIOperands(MCInst &Inst, unsigned N) const {
1531    assert(N == 2 && "Invalid number of operands!");
1532    int64_t Val = Memory.OffsetImm ? (Memory.OffsetImm->getValue() / 4) : 0;
1533    Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1534    Inst.addOperand(MCOperand::CreateImm(Val));
1535  }
1536
1537  void addPostIdxImm8Operands(MCInst &Inst, unsigned N) const {
1538    assert(N == 1 && "Invalid number of operands!");
1539    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1540    assert(CE && "non-constant post-idx-imm8 operand!");
1541    int Imm = CE->getValue();
1542    bool isAdd = Imm >= 0;
1543    if (Imm == INT32_MIN) Imm = 0;
1544    Imm = (Imm < 0 ? -Imm : Imm) | (int)isAdd << 8;
1545    Inst.addOperand(MCOperand::CreateImm(Imm));
1546  }
1547
1548  void addPostIdxImm8s4Operands(MCInst &Inst, unsigned N) const {
1549    assert(N == 1 && "Invalid number of operands!");
1550    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1551    assert(CE && "non-constant post-idx-imm8s4 operand!");
1552    int Imm = CE->getValue();
1553    bool isAdd = Imm >= 0;
1554    if (Imm == INT32_MIN) Imm = 0;
1555    // Immediate is scaled by 4.
1556    Imm = ((Imm < 0 ? -Imm : Imm) / 4) | (int)isAdd << 8;
1557    Inst.addOperand(MCOperand::CreateImm(Imm));
1558  }
1559
1560  void addPostIdxRegOperands(MCInst &Inst, unsigned N) const {
1561    assert(N == 2 && "Invalid number of operands!");
1562    Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum));
1563    Inst.addOperand(MCOperand::CreateImm(PostIdxReg.isAdd));
1564  }
1565
1566  void addPostIdxRegShiftedOperands(MCInst &Inst, unsigned N) const {
1567    assert(N == 2 && "Invalid number of operands!");
1568    Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum));
1569    // The sign, shift type, and shift amount are encoded in a single operand
1570    // using the AM2 encoding helpers.
1571    ARM_AM::AddrOpc opc = PostIdxReg.isAdd ? ARM_AM::add : ARM_AM::sub;
1572    unsigned Imm = ARM_AM::getAM2Opc(opc, PostIdxReg.ShiftImm,
1573                                     PostIdxReg.ShiftTy);
1574    Inst.addOperand(MCOperand::CreateImm(Imm));
1575  }
1576
1577  void addMSRMaskOperands(MCInst &Inst, unsigned N) const {
1578    assert(N == 1 && "Invalid number of operands!");
1579    Inst.addOperand(MCOperand::CreateImm(unsigned(getMSRMask())));
1580  }
1581
1582  void addProcIFlagsOperands(MCInst &Inst, unsigned N) const {
1583    assert(N == 1 && "Invalid number of operands!");
1584    Inst.addOperand(MCOperand::CreateImm(unsigned(getProcIFlags())));
1585  }
1586
1587  void addVecListOneDOperands(MCInst &Inst, unsigned N) const {
1588    assert(N == 1 && "Invalid number of operands!");
1589    Inst.addOperand(MCOperand::CreateReg(VectorList.RegNum));
1590  }
1591
1592  void addVecListTwoDOperands(MCInst &Inst, unsigned N) const {
1593    assert(N == 1 && "Invalid number of operands!");
1594    // Only the first register actually goes on the instruction. The rest
1595    // are implied by the opcode.
1596    Inst.addOperand(MCOperand::CreateReg(VectorList.RegNum));
1597  }
1598
1599  void addVecListThreeDOperands(MCInst &Inst, unsigned N) const {
1600    assert(N == 1 && "Invalid number of operands!");
1601    // Only the first register actually goes on the instruction. The rest
1602    // are implied by the opcode.
1603    Inst.addOperand(MCOperand::CreateReg(VectorList.RegNum));
1604  }
1605
1606  void addVecListFourDOperands(MCInst &Inst, unsigned N) const {
1607    assert(N == 1 && "Invalid number of operands!");
1608    // Only the first register actually goes on the instruction. The rest
1609    // are implied by the opcode.
1610    Inst.addOperand(MCOperand::CreateReg(VectorList.RegNum));
1611  }
1612
1613  void addVecListTwoQOperands(MCInst &Inst, unsigned N) const {
1614    assert(N == 1 && "Invalid number of operands!");
1615    // Only the first register actually goes on the instruction. The rest
1616    // are implied by the opcode.
1617    Inst.addOperand(MCOperand::CreateReg(VectorList.RegNum));
1618  }
1619
1620  void addVectorIndex8Operands(MCInst &Inst, unsigned N) const {
1621    assert(N == 1 && "Invalid number of operands!");
1622    Inst.addOperand(MCOperand::CreateImm(getVectorIndex()));
1623  }
1624
1625  void addVectorIndex16Operands(MCInst &Inst, unsigned N) const {
1626    assert(N == 1 && "Invalid number of operands!");
1627    Inst.addOperand(MCOperand::CreateImm(getVectorIndex()));
1628  }
1629
1630  void addVectorIndex32Operands(MCInst &Inst, unsigned N) const {
1631    assert(N == 1 && "Invalid number of operands!");
1632    Inst.addOperand(MCOperand::CreateImm(getVectorIndex()));
1633  }
1634
1635  void addNEONi8splatOperands(MCInst &Inst, unsigned N) const {
1636    assert(N == 1 && "Invalid number of operands!");
1637    // The immediate encodes the type of constant as well as the value.
1638    // Mask in that this is an i8 splat.
1639    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1640    Inst.addOperand(MCOperand::CreateImm(CE->getValue() | 0xe00));
1641  }
1642
1643  void addNEONi16splatOperands(MCInst &Inst, unsigned N) const {
1644    assert(N == 1 && "Invalid number of operands!");
1645    // The immediate encodes the type of constant as well as the value.
1646    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1647    unsigned Value = CE->getValue();
1648    if (Value >= 256)
1649      Value = (Value >> 8) | 0xa00;
1650    else
1651      Value |= 0x800;
1652    Inst.addOperand(MCOperand::CreateImm(Value));
1653  }
1654
1655  void addNEONi32splatOperands(MCInst &Inst, unsigned N) const {
1656    assert(N == 1 && "Invalid number of operands!");
1657    // The immediate encodes the type of constant as well as the value.
1658    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1659    unsigned Value = CE->getValue();
1660    if (Value >= 256 && Value <= 0xff00)
1661      Value = (Value >> 8) | 0x200;
1662    else if (Value > 0xffff && Value <= 0xff0000)
1663      Value = (Value >> 16) | 0x400;
1664    else if (Value > 0xffffff)
1665      Value = (Value >> 24) | 0x600;
1666    Inst.addOperand(MCOperand::CreateImm(Value));
1667  }
1668
1669  void addNEONi32vmovOperands(MCInst &Inst, unsigned N) const {
1670    assert(N == 1 && "Invalid number of operands!");
1671    // The immediate encodes the type of constant as well as the value.
1672    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1673    unsigned Value = CE->getValue();
1674    if (Value >= 256 && Value <= 0xffff)
1675      Value = (Value >> 8) | ((Value & 0xff) ? 0xc00 : 0x200);
1676    else if (Value > 0xffff && Value <= 0xffffff)
1677      Value = (Value >> 16) | ((Value & 0xff) ? 0xd00 : 0x400);
1678    else if (Value > 0xffffff)
1679      Value = (Value >> 24) | 0x600;
1680    Inst.addOperand(MCOperand::CreateImm(Value));
1681  }
1682
1683  void addNEONi64splatOperands(MCInst &Inst, unsigned N) const {
1684    assert(N == 1 && "Invalid number of operands!");
1685    // The immediate encodes the type of constant as well as the value.
1686    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1687    uint64_t Value = CE->getValue();
1688    unsigned Imm = 0;
1689    for (unsigned i = 0; i < 8; ++i, Value >>= 8) {
1690      Imm |= (Value & 1) << i;
1691    }
1692    Inst.addOperand(MCOperand::CreateImm(Imm | 0x1e00));
1693  }
1694
1695  virtual void print(raw_ostream &OS) const;
1696
1697  static ARMOperand *CreateITMask(unsigned Mask, SMLoc S) {
1698    ARMOperand *Op = new ARMOperand(k_ITCondMask);
1699    Op->ITMask.Mask = Mask;
1700    Op->StartLoc = S;
1701    Op->EndLoc = S;
1702    return Op;
1703  }
1704
1705  static ARMOperand *CreateCondCode(ARMCC::CondCodes CC, SMLoc S) {
1706    ARMOperand *Op = new ARMOperand(k_CondCode);
1707    Op->CC.Val = CC;
1708    Op->StartLoc = S;
1709    Op->EndLoc = S;
1710    return Op;
1711  }
1712
1713  static ARMOperand *CreateCoprocNum(unsigned CopVal, SMLoc S) {
1714    ARMOperand *Op = new ARMOperand(k_CoprocNum);
1715    Op->Cop.Val = CopVal;
1716    Op->StartLoc = S;
1717    Op->EndLoc = S;
1718    return Op;
1719  }
1720
1721  static ARMOperand *CreateCoprocReg(unsigned CopVal, SMLoc S) {
1722    ARMOperand *Op = new ARMOperand(k_CoprocReg);
1723    Op->Cop.Val = CopVal;
1724    Op->StartLoc = S;
1725    Op->EndLoc = S;
1726    return Op;
1727  }
1728
1729  static ARMOperand *CreateCoprocOption(unsigned Val, SMLoc S, SMLoc E) {
1730    ARMOperand *Op = new ARMOperand(k_CoprocOption);
1731    Op->Cop.Val = Val;
1732    Op->StartLoc = S;
1733    Op->EndLoc = E;
1734    return Op;
1735  }
1736
1737  static ARMOperand *CreateCCOut(unsigned RegNum, SMLoc S) {
1738    ARMOperand *Op = new ARMOperand(k_CCOut);
1739    Op->Reg.RegNum = RegNum;
1740    Op->StartLoc = S;
1741    Op->EndLoc = S;
1742    return Op;
1743  }
1744
1745  static ARMOperand *CreateToken(StringRef Str, SMLoc S) {
1746    ARMOperand *Op = new ARMOperand(k_Token);
1747    Op->Tok.Data = Str.data();
1748    Op->Tok.Length = Str.size();
1749    Op->StartLoc = S;
1750    Op->EndLoc = S;
1751    return Op;
1752  }
1753
1754  static ARMOperand *CreateReg(unsigned RegNum, SMLoc S, SMLoc E) {
1755    ARMOperand *Op = new ARMOperand(k_Register);
1756    Op->Reg.RegNum = RegNum;
1757    Op->StartLoc = S;
1758    Op->EndLoc = E;
1759    return Op;
1760  }
1761
1762  static ARMOperand *CreateShiftedRegister(ARM_AM::ShiftOpc ShTy,
1763                                           unsigned SrcReg,
1764                                           unsigned ShiftReg,
1765                                           unsigned ShiftImm,
1766                                           SMLoc S, SMLoc E) {
1767    ARMOperand *Op = new ARMOperand(k_ShiftedRegister);
1768    Op->RegShiftedReg.ShiftTy = ShTy;
1769    Op->RegShiftedReg.SrcReg = SrcReg;
1770    Op->RegShiftedReg.ShiftReg = ShiftReg;
1771    Op->RegShiftedReg.ShiftImm = ShiftImm;
1772    Op->StartLoc = S;
1773    Op->EndLoc = E;
1774    return Op;
1775  }
1776
1777  static ARMOperand *CreateShiftedImmediate(ARM_AM::ShiftOpc ShTy,
1778                                            unsigned SrcReg,
1779                                            unsigned ShiftImm,
1780                                            SMLoc S, SMLoc E) {
1781    ARMOperand *Op = new ARMOperand(k_ShiftedImmediate);
1782    Op->RegShiftedImm.ShiftTy = ShTy;
1783    Op->RegShiftedImm.SrcReg = SrcReg;
1784    Op->RegShiftedImm.ShiftImm = ShiftImm;
1785    Op->StartLoc = S;
1786    Op->EndLoc = E;
1787    return Op;
1788  }
1789
1790  static ARMOperand *CreateShifterImm(bool isASR, unsigned Imm,
1791                                   SMLoc S, SMLoc E) {
1792    ARMOperand *Op = new ARMOperand(k_ShifterImmediate);
1793    Op->ShifterImm.isASR = isASR;
1794    Op->ShifterImm.Imm = Imm;
1795    Op->StartLoc = S;
1796    Op->EndLoc = E;
1797    return Op;
1798  }
1799
1800  static ARMOperand *CreateRotImm(unsigned Imm, SMLoc S, SMLoc E) {
1801    ARMOperand *Op = new ARMOperand(k_RotateImmediate);
1802    Op->RotImm.Imm = Imm;
1803    Op->StartLoc = S;
1804    Op->EndLoc = E;
1805    return Op;
1806  }
1807
1808  static ARMOperand *CreateBitfield(unsigned LSB, unsigned Width,
1809                                    SMLoc S, SMLoc E) {
1810    ARMOperand *Op = new ARMOperand(k_BitfieldDescriptor);
1811    Op->Bitfield.LSB = LSB;
1812    Op->Bitfield.Width = Width;
1813    Op->StartLoc = S;
1814    Op->EndLoc = E;
1815    return Op;
1816  }
1817
1818  static ARMOperand *
1819  CreateRegList(const SmallVectorImpl<std::pair<unsigned, SMLoc> > &Regs,
1820                SMLoc StartLoc, SMLoc EndLoc) {
1821    KindTy Kind = k_RegisterList;
1822
1823    if (ARMMCRegisterClasses[ARM::DPRRegClassID].contains(Regs.front().first))
1824      Kind = k_DPRRegisterList;
1825    else if (ARMMCRegisterClasses[ARM::SPRRegClassID].
1826             contains(Regs.front().first))
1827      Kind = k_SPRRegisterList;
1828
1829    ARMOperand *Op = new ARMOperand(Kind);
1830    for (SmallVectorImpl<std::pair<unsigned, SMLoc> >::const_iterator
1831           I = Regs.begin(), E = Regs.end(); I != E; ++I)
1832      Op->Registers.push_back(I->first);
1833    array_pod_sort(Op->Registers.begin(), Op->Registers.end());
1834    Op->StartLoc = StartLoc;
1835    Op->EndLoc = EndLoc;
1836    return Op;
1837  }
1838
1839  static ARMOperand *CreateVectorList(unsigned RegNum, unsigned Count,
1840                                      SMLoc S, SMLoc E) {
1841    ARMOperand *Op = new ARMOperand(k_VectorList);
1842    Op->VectorList.RegNum = RegNum;
1843    Op->VectorList.Count = Count;
1844    Op->StartLoc = S;
1845    Op->EndLoc = E;
1846    return Op;
1847  }
1848
1849  static ARMOperand *CreateVectorIndex(unsigned Idx, SMLoc S, SMLoc E,
1850                                       MCContext &Ctx) {
1851    ARMOperand *Op = new ARMOperand(k_VectorIndex);
1852    Op->VectorIndex.Val = Idx;
1853    Op->StartLoc = S;
1854    Op->EndLoc = E;
1855    return Op;
1856  }
1857
1858  static ARMOperand *CreateImm(const MCExpr *Val, SMLoc S, SMLoc E) {
1859    ARMOperand *Op = new ARMOperand(k_Immediate);
1860    Op->Imm.Val = Val;
1861    Op->StartLoc = S;
1862    Op->EndLoc = E;
1863    return Op;
1864  }
1865
1866  static ARMOperand *CreateFPImm(unsigned Val, SMLoc S, MCContext &Ctx) {
1867    ARMOperand *Op = new ARMOperand(k_FPImmediate);
1868    Op->FPImm.Val = Val;
1869    Op->StartLoc = S;
1870    Op->EndLoc = S;
1871    return Op;
1872  }
1873
1874  static ARMOperand *CreateMem(unsigned BaseRegNum,
1875                               const MCConstantExpr *OffsetImm,
1876                               unsigned OffsetRegNum,
1877                               ARM_AM::ShiftOpc ShiftType,
1878                               unsigned ShiftImm,
1879                               unsigned Alignment,
1880                               bool isNegative,
1881                               SMLoc S, SMLoc E) {
1882    ARMOperand *Op = new ARMOperand(k_Memory);
1883    Op->Memory.BaseRegNum = BaseRegNum;
1884    Op->Memory.OffsetImm = OffsetImm;
1885    Op->Memory.OffsetRegNum = OffsetRegNum;
1886    Op->Memory.ShiftType = ShiftType;
1887    Op->Memory.ShiftImm = ShiftImm;
1888    Op->Memory.Alignment = Alignment;
1889    Op->Memory.isNegative = isNegative;
1890    Op->StartLoc = S;
1891    Op->EndLoc = E;
1892    return Op;
1893  }
1894
1895  static ARMOperand *CreatePostIdxReg(unsigned RegNum, bool isAdd,
1896                                      ARM_AM::ShiftOpc ShiftTy,
1897                                      unsigned ShiftImm,
1898                                      SMLoc S, SMLoc E) {
1899    ARMOperand *Op = new ARMOperand(k_PostIndexRegister);
1900    Op->PostIdxReg.RegNum = RegNum;
1901    Op->PostIdxReg.isAdd = isAdd;
1902    Op->PostIdxReg.ShiftTy = ShiftTy;
1903    Op->PostIdxReg.ShiftImm = ShiftImm;
1904    Op->StartLoc = S;
1905    Op->EndLoc = E;
1906    return Op;
1907  }
1908
1909  static ARMOperand *CreateMemBarrierOpt(ARM_MB::MemBOpt Opt, SMLoc S) {
1910    ARMOperand *Op = new ARMOperand(k_MemBarrierOpt);
1911    Op->MBOpt.Val = Opt;
1912    Op->StartLoc = S;
1913    Op->EndLoc = S;
1914    return Op;
1915  }
1916
1917  static ARMOperand *CreateProcIFlags(ARM_PROC::IFlags IFlags, SMLoc S) {
1918    ARMOperand *Op = new ARMOperand(k_ProcIFlags);
1919    Op->IFlags.Val = IFlags;
1920    Op->StartLoc = S;
1921    Op->EndLoc = S;
1922    return Op;
1923  }
1924
1925  static ARMOperand *CreateMSRMask(unsigned MMask, SMLoc S) {
1926    ARMOperand *Op = new ARMOperand(k_MSRMask);
1927    Op->MMask.Val = MMask;
1928    Op->StartLoc = S;
1929    Op->EndLoc = S;
1930    return Op;
1931  }
1932};
1933
1934} // end anonymous namespace.
1935
1936void ARMOperand::print(raw_ostream &OS) const {
1937  switch (Kind) {
1938  case k_FPImmediate:
1939    OS << "<fpimm " << getFPImm() << "(" << ARM_AM::getFPImmFloat(getFPImm())
1940       << ") >";
1941    break;
1942  case k_CondCode:
1943    OS << "<ARMCC::" << ARMCondCodeToString(getCondCode()) << ">";
1944    break;
1945  case k_CCOut:
1946    OS << "<ccout " << getReg() << ">";
1947    break;
1948  case k_ITCondMask: {
1949    static const char *MaskStr[] = {
1950      "()", "(t)", "(e)", "(tt)", "(et)", "(te)", "(ee)", "(ttt)", "(ett)",
1951      "(tet)", "(eet)", "(tte)", "(ete)", "(tee)", "(eee)"
1952    };
1953    assert((ITMask.Mask & 0xf) == ITMask.Mask);
1954    OS << "<it-mask " << MaskStr[ITMask.Mask] << ">";
1955    break;
1956  }
1957  case k_CoprocNum:
1958    OS << "<coprocessor number: " << getCoproc() << ">";
1959    break;
1960  case k_CoprocReg:
1961    OS << "<coprocessor register: " << getCoproc() << ">";
1962    break;
1963  case k_CoprocOption:
1964    OS << "<coprocessor option: " << CoprocOption.Val << ">";
1965    break;
1966  case k_MSRMask:
1967    OS << "<mask: " << getMSRMask() << ">";
1968    break;
1969  case k_Immediate:
1970    getImm()->print(OS);
1971    break;
1972  case k_MemBarrierOpt:
1973    OS << "<ARM_MB::" << MemBOptToString(getMemBarrierOpt()) << ">";
1974    break;
1975  case k_Memory:
1976    OS << "<memory "
1977       << " base:" << Memory.BaseRegNum;
1978    OS << ">";
1979    break;
1980  case k_PostIndexRegister:
1981    OS << "post-idx register " << (PostIdxReg.isAdd ? "" : "-")
1982       << PostIdxReg.RegNum;
1983    if (PostIdxReg.ShiftTy != ARM_AM::no_shift)
1984      OS << ARM_AM::getShiftOpcStr(PostIdxReg.ShiftTy) << " "
1985         << PostIdxReg.ShiftImm;
1986    OS << ">";
1987    break;
1988  case k_ProcIFlags: {
1989    OS << "<ARM_PROC::";
1990    unsigned IFlags = getProcIFlags();
1991    for (int i=2; i >= 0; --i)
1992      if (IFlags & (1 << i))
1993        OS << ARM_PROC::IFlagsToString(1 << i);
1994    OS << ">";
1995    break;
1996  }
1997  case k_Register:
1998    OS << "<register " << getReg() << ">";
1999    break;
2000  case k_ShifterImmediate:
2001    OS << "<shift " << (ShifterImm.isASR ? "asr" : "lsl")
2002       << " #" << ShifterImm.Imm << ">";
2003    break;
2004  case k_ShiftedRegister:
2005    OS << "<so_reg_reg "
2006       << RegShiftedReg.SrcReg
2007       << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(RegShiftedReg.ShiftImm))
2008       << ", " << RegShiftedReg.ShiftReg << ", "
2009       << ARM_AM::getSORegOffset(RegShiftedReg.ShiftImm)
2010       << ">";
2011    break;
2012  case k_ShiftedImmediate:
2013    OS << "<so_reg_imm "
2014       << RegShiftedImm.SrcReg
2015       << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(RegShiftedImm.ShiftImm))
2016       << ", " << ARM_AM::getSORegOffset(RegShiftedImm.ShiftImm)
2017       << ">";
2018    break;
2019  case k_RotateImmediate:
2020    OS << "<ror " << " #" << (RotImm.Imm * 8) << ">";
2021    break;
2022  case k_BitfieldDescriptor:
2023    OS << "<bitfield " << "lsb: " << Bitfield.LSB
2024       << ", width: " << Bitfield.Width << ">";
2025    break;
2026  case k_RegisterList:
2027  case k_DPRRegisterList:
2028  case k_SPRRegisterList: {
2029    OS << "<register_list ";
2030
2031    const SmallVectorImpl<unsigned> &RegList = getRegList();
2032    for (SmallVectorImpl<unsigned>::const_iterator
2033           I = RegList.begin(), E = RegList.end(); I != E; ) {
2034      OS << *I;
2035      if (++I < E) OS << ", ";
2036    }
2037
2038    OS << ">";
2039    break;
2040  }
2041  case k_VectorList:
2042    OS << "<vector_list " << VectorList.Count << " * "
2043       << VectorList.RegNum << ">";
2044    break;
2045  case k_Token:
2046    OS << "'" << getToken() << "'";
2047    break;
2048  case k_VectorIndex:
2049    OS << "<vectorindex " << getVectorIndex() << ">";
2050    break;
2051  }
2052}
2053
2054/// @name Auto-generated Match Functions
2055/// {
2056
2057static unsigned MatchRegisterName(StringRef Name);
2058
2059/// }
2060
2061bool ARMAsmParser::ParseRegister(unsigned &RegNo,
2062                                 SMLoc &StartLoc, SMLoc &EndLoc) {
2063  RegNo = tryParseRegister();
2064
2065  return (RegNo == (unsigned)-1);
2066}
2067
2068/// Try to parse a register name.  The token must be an Identifier when called,
2069/// and if it is a register name the token is eaten and the register number is
2070/// returned.  Otherwise return -1.
2071///
2072int ARMAsmParser::tryParseRegister() {
2073  const AsmToken &Tok = Parser.getTok();
2074  if (Tok.isNot(AsmToken::Identifier)) return -1;
2075
2076  // FIXME: Validate register for the current architecture; we have to do
2077  // validation later, so maybe there is no need for this here.
2078  std::string lowerCase = Tok.getString().lower();
2079  unsigned RegNum = MatchRegisterName(lowerCase);
2080  if (!RegNum) {
2081    RegNum = StringSwitch<unsigned>(lowerCase)
2082      .Case("r13", ARM::SP)
2083      .Case("r14", ARM::LR)
2084      .Case("r15", ARM::PC)
2085      .Case("ip", ARM::R12)
2086      .Default(0);
2087  }
2088  if (!RegNum) return -1;
2089
2090  Parser.Lex(); // Eat identifier token.
2091
2092  return RegNum;
2093}
2094
2095// Try to parse a shifter  (e.g., "lsl <amt>"). On success, return 0.
2096// If a recoverable error occurs, return 1. If an irrecoverable error
2097// occurs, return -1. An irrecoverable error is one where tokens have been
2098// consumed in the process of trying to parse the shifter (i.e., when it is
2099// indeed a shifter operand, but malformed).
2100int ARMAsmParser::tryParseShiftRegister(
2101                               SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2102  SMLoc S = Parser.getTok().getLoc();
2103  const AsmToken &Tok = Parser.getTok();
2104  assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
2105
2106  std::string lowerCase = Tok.getString().lower();
2107  ARM_AM::ShiftOpc ShiftTy = StringSwitch<ARM_AM::ShiftOpc>(lowerCase)
2108      .Case("lsl", ARM_AM::lsl)
2109      .Case("lsr", ARM_AM::lsr)
2110      .Case("asr", ARM_AM::asr)
2111      .Case("ror", ARM_AM::ror)
2112      .Case("rrx", ARM_AM::rrx)
2113      .Default(ARM_AM::no_shift);
2114
2115  if (ShiftTy == ARM_AM::no_shift)
2116    return 1;
2117
2118  Parser.Lex(); // Eat the operator.
2119
2120  // The source register for the shift has already been added to the
2121  // operand list, so we need to pop it off and combine it into the shifted
2122  // register operand instead.
2123  OwningPtr<ARMOperand> PrevOp((ARMOperand*)Operands.pop_back_val());
2124  if (!PrevOp->isReg())
2125    return Error(PrevOp->getStartLoc(), "shift must be of a register");
2126  int SrcReg = PrevOp->getReg();
2127  int64_t Imm = 0;
2128  int ShiftReg = 0;
2129  if (ShiftTy == ARM_AM::rrx) {
2130    // RRX Doesn't have an explicit shift amount. The encoder expects
2131    // the shift register to be the same as the source register. Seems odd,
2132    // but OK.
2133    ShiftReg = SrcReg;
2134  } else {
2135    // Figure out if this is shifted by a constant or a register (for non-RRX).
2136    if (Parser.getTok().is(AsmToken::Hash)) {
2137      Parser.Lex(); // Eat hash.
2138      SMLoc ImmLoc = Parser.getTok().getLoc();
2139      const MCExpr *ShiftExpr = 0;
2140      if (getParser().ParseExpression(ShiftExpr)) {
2141        Error(ImmLoc, "invalid immediate shift value");
2142        return -1;
2143      }
2144      // The expression must be evaluatable as an immediate.
2145      const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftExpr);
2146      if (!CE) {
2147        Error(ImmLoc, "invalid immediate shift value");
2148        return -1;
2149      }
2150      // Range check the immediate.
2151      // lsl, ror: 0 <= imm <= 31
2152      // lsr, asr: 0 <= imm <= 32
2153      Imm = CE->getValue();
2154      if (Imm < 0 ||
2155          ((ShiftTy == ARM_AM::lsl || ShiftTy == ARM_AM::ror) && Imm > 31) ||
2156          ((ShiftTy == ARM_AM::lsr || ShiftTy == ARM_AM::asr) && Imm > 32)) {
2157        Error(ImmLoc, "immediate shift value out of range");
2158        return -1;
2159      }
2160    } else if (Parser.getTok().is(AsmToken::Identifier)) {
2161      ShiftReg = tryParseRegister();
2162      SMLoc L = Parser.getTok().getLoc();
2163      if (ShiftReg == -1) {
2164        Error (L, "expected immediate or register in shift operand");
2165        return -1;
2166      }
2167    } else {
2168      Error (Parser.getTok().getLoc(),
2169                    "expected immediate or register in shift operand");
2170      return -1;
2171    }
2172  }
2173
2174  if (ShiftReg && ShiftTy != ARM_AM::rrx)
2175    Operands.push_back(ARMOperand::CreateShiftedRegister(ShiftTy, SrcReg,
2176                                                         ShiftReg, Imm,
2177                                               S, Parser.getTok().getLoc()));
2178  else
2179    Operands.push_back(ARMOperand::CreateShiftedImmediate(ShiftTy, SrcReg, Imm,
2180                                               S, Parser.getTok().getLoc()));
2181
2182  return 0;
2183}
2184
2185
2186/// Try to parse a register name.  The token must be an Identifier when called.
2187/// If it's a register, an AsmOperand is created. Another AsmOperand is created
2188/// if there is a "writeback". 'true' if it's not a register.
2189///
2190/// TODO this is likely to change to allow different register types and or to
2191/// parse for a specific register type.
2192bool ARMAsmParser::
2193tryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2194  SMLoc S = Parser.getTok().getLoc();
2195  int RegNo = tryParseRegister();
2196  if (RegNo == -1)
2197    return true;
2198
2199  Operands.push_back(ARMOperand::CreateReg(RegNo, S, Parser.getTok().getLoc()));
2200
2201  const AsmToken &ExclaimTok = Parser.getTok();
2202  if (ExclaimTok.is(AsmToken::Exclaim)) {
2203    Operands.push_back(ARMOperand::CreateToken(ExclaimTok.getString(),
2204                                               ExclaimTok.getLoc()));
2205    Parser.Lex(); // Eat exclaim token
2206    return false;
2207  }
2208
2209  // Also check for an index operand. This is only legal for vector registers,
2210  // but that'll get caught OK in operand matching, so we don't need to
2211  // explicitly filter everything else out here.
2212  if (Parser.getTok().is(AsmToken::LBrac)) {
2213    SMLoc SIdx = Parser.getTok().getLoc();
2214    Parser.Lex(); // Eat left bracket token.
2215
2216    const MCExpr *ImmVal;
2217    if (getParser().ParseExpression(ImmVal))
2218      return MatchOperand_ParseFail;
2219    const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(ImmVal);
2220    if (!MCE) {
2221      TokError("immediate value expected for vector index");
2222      return MatchOperand_ParseFail;
2223    }
2224
2225    SMLoc E = Parser.getTok().getLoc();
2226    if (Parser.getTok().isNot(AsmToken::RBrac)) {
2227      Error(E, "']' expected");
2228      return MatchOperand_ParseFail;
2229    }
2230
2231    Parser.Lex(); // Eat right bracket token.
2232
2233    Operands.push_back(ARMOperand::CreateVectorIndex(MCE->getValue(),
2234                                                     SIdx, E,
2235                                                     getContext()));
2236  }
2237
2238  return false;
2239}
2240
2241/// MatchCoprocessorOperandName - Try to parse an coprocessor related
2242/// instruction with a symbolic operand name. Example: "p1", "p7", "c3",
2243/// "c5", ...
2244static int MatchCoprocessorOperandName(StringRef Name, char CoprocOp) {
2245  // Use the same layout as the tablegen'erated register name matcher. Ugly,
2246  // but efficient.
2247  switch (Name.size()) {
2248  default: break;
2249  case 2:
2250    if (Name[0] != CoprocOp)
2251      return -1;
2252    switch (Name[1]) {
2253    default:  return -1;
2254    case '0': return 0;
2255    case '1': return 1;
2256    case '2': return 2;
2257    case '3': return 3;
2258    case '4': return 4;
2259    case '5': return 5;
2260    case '6': return 6;
2261    case '7': return 7;
2262    case '8': return 8;
2263    case '9': return 9;
2264    }
2265    break;
2266  case 3:
2267    if (Name[0] != CoprocOp || Name[1] != '1')
2268      return -1;
2269    switch (Name[2]) {
2270    default:  return -1;
2271    case '0': return 10;
2272    case '1': return 11;
2273    case '2': return 12;
2274    case '3': return 13;
2275    case '4': return 14;
2276    case '5': return 15;
2277    }
2278    break;
2279  }
2280
2281  return -1;
2282}
2283
2284/// parseITCondCode - Try to parse a condition code for an IT instruction.
2285ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2286parseITCondCode(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2287  SMLoc S = Parser.getTok().getLoc();
2288  const AsmToken &Tok = Parser.getTok();
2289  if (!Tok.is(AsmToken::Identifier))
2290    return MatchOperand_NoMatch;
2291  unsigned CC = StringSwitch<unsigned>(Tok.getString())
2292    .Case("eq", ARMCC::EQ)
2293    .Case("ne", ARMCC::NE)
2294    .Case("hs", ARMCC::HS)
2295    .Case("cs", ARMCC::HS)
2296    .Case("lo", ARMCC::LO)
2297    .Case("cc", ARMCC::LO)
2298    .Case("mi", ARMCC::MI)
2299    .Case("pl", ARMCC::PL)
2300    .Case("vs", ARMCC::VS)
2301    .Case("vc", ARMCC::VC)
2302    .Case("hi", ARMCC::HI)
2303    .Case("ls", ARMCC::LS)
2304    .Case("ge", ARMCC::GE)
2305    .Case("lt", ARMCC::LT)
2306    .Case("gt", ARMCC::GT)
2307    .Case("le", ARMCC::LE)
2308    .Case("al", ARMCC::AL)
2309    .Default(~0U);
2310  if (CC == ~0U)
2311    return MatchOperand_NoMatch;
2312  Parser.Lex(); // Eat the token.
2313
2314  Operands.push_back(ARMOperand::CreateCondCode(ARMCC::CondCodes(CC), S));
2315
2316  return MatchOperand_Success;
2317}
2318
2319/// parseCoprocNumOperand - Try to parse an coprocessor number operand. The
2320/// token must be an Identifier when called, and if it is a coprocessor
2321/// number, the token is eaten and the operand is added to the operand list.
2322ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2323parseCoprocNumOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2324  SMLoc S = Parser.getTok().getLoc();
2325  const AsmToken &Tok = Parser.getTok();
2326  if (Tok.isNot(AsmToken::Identifier))
2327    return MatchOperand_NoMatch;
2328
2329  int Num = MatchCoprocessorOperandName(Tok.getString(), 'p');
2330  if (Num == -1)
2331    return MatchOperand_NoMatch;
2332
2333  Parser.Lex(); // Eat identifier token.
2334  Operands.push_back(ARMOperand::CreateCoprocNum(Num, S));
2335  return MatchOperand_Success;
2336}
2337
2338/// parseCoprocRegOperand - Try to parse an coprocessor register operand. The
2339/// token must be an Identifier when called, and if it is a coprocessor
2340/// number, the token is eaten and the operand is added to the operand list.
2341ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2342parseCoprocRegOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2343  SMLoc S = Parser.getTok().getLoc();
2344  const AsmToken &Tok = Parser.getTok();
2345  if (Tok.isNot(AsmToken::Identifier))
2346    return MatchOperand_NoMatch;
2347
2348  int Reg = MatchCoprocessorOperandName(Tok.getString(), 'c');
2349  if (Reg == -1)
2350    return MatchOperand_NoMatch;
2351
2352  Parser.Lex(); // Eat identifier token.
2353  Operands.push_back(ARMOperand::CreateCoprocReg(Reg, S));
2354  return MatchOperand_Success;
2355}
2356
2357/// parseCoprocOptionOperand - Try to parse an coprocessor option operand.
2358/// coproc_option : '{' imm0_255 '}'
2359ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2360parseCoprocOptionOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2361  SMLoc S = Parser.getTok().getLoc();
2362
2363  // If this isn't a '{', this isn't a coprocessor immediate operand.
2364  if (Parser.getTok().isNot(AsmToken::LCurly))
2365    return MatchOperand_NoMatch;
2366  Parser.Lex(); // Eat the '{'
2367
2368  const MCExpr *Expr;
2369  SMLoc Loc = Parser.getTok().getLoc();
2370  if (getParser().ParseExpression(Expr)) {
2371    Error(Loc, "illegal expression");
2372    return MatchOperand_ParseFail;
2373  }
2374  const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr);
2375  if (!CE || CE->getValue() < 0 || CE->getValue() > 255) {
2376    Error(Loc, "coprocessor option must be an immediate in range [0, 255]");
2377    return MatchOperand_ParseFail;
2378  }
2379  int Val = CE->getValue();
2380
2381  // Check for and consume the closing '}'
2382  if (Parser.getTok().isNot(AsmToken::RCurly))
2383    return MatchOperand_ParseFail;
2384  SMLoc E = Parser.getTok().getLoc();
2385  Parser.Lex(); // Eat the '}'
2386
2387  Operands.push_back(ARMOperand::CreateCoprocOption(Val, S, E));
2388  return MatchOperand_Success;
2389}
2390
2391// For register list parsing, we need to map from raw GPR register numbering
2392// to the enumeration values. The enumeration values aren't sorted by
2393// register number due to our using "sp", "lr" and "pc" as canonical names.
2394static unsigned getNextRegister(unsigned Reg) {
2395  // If this is a GPR, we need to do it manually, otherwise we can rely
2396  // on the sort ordering of the enumeration since the other reg-classes
2397  // are sane.
2398  if (!ARMMCRegisterClasses[ARM::GPRRegClassID].contains(Reg))
2399    return Reg + 1;
2400  switch(Reg) {
2401  default: assert(0 && "Invalid GPR number!");
2402  case ARM::R0:  return ARM::R1;  case ARM::R1:  return ARM::R2;
2403  case ARM::R2:  return ARM::R3;  case ARM::R3:  return ARM::R4;
2404  case ARM::R4:  return ARM::R5;  case ARM::R5:  return ARM::R6;
2405  case ARM::R6:  return ARM::R7;  case ARM::R7:  return ARM::R8;
2406  case ARM::R8:  return ARM::R9;  case ARM::R9:  return ARM::R10;
2407  case ARM::R10: return ARM::R11; case ARM::R11: return ARM::R12;
2408  case ARM::R12: return ARM::SP;  case ARM::SP:  return ARM::LR;
2409  case ARM::LR:  return ARM::PC;  case ARM::PC:  return ARM::R0;
2410  }
2411}
2412
2413/// Parse a register list.
2414bool ARMAsmParser::
2415parseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2416  assert(Parser.getTok().is(AsmToken::LCurly) &&
2417         "Token is not a Left Curly Brace");
2418  SMLoc S = Parser.getTok().getLoc();
2419  Parser.Lex(); // Eat '{' token.
2420  SMLoc RegLoc = Parser.getTok().getLoc();
2421
2422  // Check the first register in the list to see what register class
2423  // this is a list of.
2424  int Reg = tryParseRegister();
2425  if (Reg == -1)
2426    return Error(RegLoc, "register expected");
2427
2428  const MCRegisterClass *RC;
2429  if (ARMMCRegisterClasses[ARM::GPRRegClassID].contains(Reg))
2430    RC = &ARMMCRegisterClasses[ARM::GPRRegClassID];
2431  else if (ARMMCRegisterClasses[ARM::DPRRegClassID].contains(Reg))
2432    RC = &ARMMCRegisterClasses[ARM::DPRRegClassID];
2433  else if (ARMMCRegisterClasses[ARM::SPRRegClassID].contains(Reg))
2434    RC = &ARMMCRegisterClasses[ARM::SPRRegClassID];
2435  else
2436    return Error(RegLoc, "invalid register in register list");
2437
2438  // The reglist instructions have at most 16 registers, so reserve
2439  // space for that many.
2440  SmallVector<std::pair<unsigned, SMLoc>, 16> Registers;
2441  // Store the first register.
2442  Registers.push_back(std::pair<unsigned, SMLoc>(Reg, RegLoc));
2443
2444  // This starts immediately after the first register token in the list,
2445  // so we can see either a comma or a minus (range separator) as a legal
2446  // next token.
2447  while (Parser.getTok().is(AsmToken::Comma) ||
2448         Parser.getTok().is(AsmToken::Minus)) {
2449    if (Parser.getTok().is(AsmToken::Minus)) {
2450      Parser.Lex(); // Eat the comma.
2451      SMLoc EndLoc = Parser.getTok().getLoc();
2452      int EndReg = tryParseRegister();
2453      if (EndReg == -1)
2454        return Error(EndLoc, "register expected");
2455      // If the register is the same as the start reg, there's nothing
2456      // more to do.
2457      if (Reg == EndReg)
2458        continue;
2459      // The register must be in the same register class as the first.
2460      if (!RC->contains(EndReg))
2461        return Error(EndLoc, "invalid register in register list");
2462      // Ranges must go from low to high.
2463      if (getARMRegisterNumbering(Reg) > getARMRegisterNumbering(EndReg))
2464        return Error(EndLoc, "bad range in register list");
2465
2466      // Add all the registers in the range to the register list.
2467      while (Reg != EndReg) {
2468        Reg = getNextRegister(Reg);
2469        Registers.push_back(std::pair<unsigned, SMLoc>(Reg, RegLoc));
2470      }
2471      continue;
2472    }
2473    Parser.Lex(); // Eat the comma.
2474    RegLoc = Parser.getTok().getLoc();
2475    int OldReg = Reg;
2476    Reg = tryParseRegister();
2477    if (Reg == -1)
2478      return Error(RegLoc, "register expected");
2479    // The register must be in the same register class as the first.
2480    if (!RC->contains(Reg))
2481      return Error(RegLoc, "invalid register in register list");
2482    // List must be monotonically increasing.
2483    if (getARMRegisterNumbering(Reg) <= getARMRegisterNumbering(OldReg))
2484      return Error(RegLoc, "register list not in ascending order");
2485    // VFP register lists must also be contiguous.
2486    // It's OK to use the enumeration values directly here rather, as the
2487    // VFP register classes have the enum sorted properly.
2488    if (RC != &ARMMCRegisterClasses[ARM::GPRRegClassID] &&
2489        Reg != OldReg + 1)
2490      return Error(RegLoc, "non-contiguous register range");
2491    Registers.push_back(std::pair<unsigned, SMLoc>(Reg, RegLoc));
2492  }
2493
2494  SMLoc E = Parser.getTok().getLoc();
2495  if (Parser.getTok().isNot(AsmToken::RCurly))
2496    return Error(E, "'}' expected");
2497  Parser.Lex(); // Eat '}' token.
2498
2499  Operands.push_back(ARMOperand::CreateRegList(Registers, S, E));
2500  return false;
2501}
2502
2503// Return the low-subreg of a given Q register.
2504static unsigned getDRegFromQReg(unsigned QReg) {
2505  switch (QReg) {
2506  default: llvm_unreachable("expected a Q register!");
2507  case ARM::Q0:  return ARM::D0;
2508  case ARM::Q1:  return ARM::D2;
2509  case ARM::Q2:  return ARM::D4;
2510  case ARM::Q3:  return ARM::D6;
2511  case ARM::Q4:  return ARM::D8;
2512  case ARM::Q5:  return ARM::D10;
2513  case ARM::Q6:  return ARM::D12;
2514  case ARM::Q7:  return ARM::D14;
2515  case ARM::Q8:  return ARM::D16;
2516  case ARM::Q9:  return ARM::D19;
2517  case ARM::Q10: return ARM::D20;
2518  case ARM::Q11: return ARM::D22;
2519  case ARM::Q12: return ARM::D24;
2520  case ARM::Q13: return ARM::D26;
2521  case ARM::Q14: return ARM::D28;
2522  case ARM::Q15: return ARM::D30;
2523  }
2524}
2525
2526// parse a vector register list
2527ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2528parseVectorList(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2529  if(Parser.getTok().isNot(AsmToken::LCurly))
2530    return MatchOperand_NoMatch;
2531
2532  SMLoc S = Parser.getTok().getLoc();
2533  Parser.Lex(); // Eat '{' token.
2534  SMLoc RegLoc = Parser.getTok().getLoc();
2535
2536  int Reg = tryParseRegister();
2537  if (Reg == -1) {
2538    Error(RegLoc, "register expected");
2539    return MatchOperand_ParseFail;
2540  }
2541  unsigned Count = 1;
2542  unsigned FirstReg = Reg;
2543  // The list is of D registers, but we also allow Q regs and just interpret
2544  // them as the two D sub-registers.
2545  if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(Reg)) {
2546    FirstReg = Reg = getDRegFromQReg(Reg);
2547    ++Reg;
2548    ++Count;
2549  }
2550
2551  while (Parser.getTok().is(AsmToken::Comma)) {
2552    Parser.Lex(); // Eat the comma.
2553    RegLoc = Parser.getTok().getLoc();
2554    int OldReg = Reg;
2555    Reg = tryParseRegister();
2556    if (Reg == -1) {
2557      Error(RegLoc, "register expected");
2558      return MatchOperand_ParseFail;
2559    }
2560    // vector register lists must be contiguous.
2561    // It's OK to use the enumeration values directly here rather, as the
2562    // VFP register classes have the enum sorted properly.
2563    //
2564    // The list is of D registers, but we also allow Q regs and just interpret
2565    // them as the two D sub-registers.
2566    if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(Reg)) {
2567      Reg = getDRegFromQReg(Reg);
2568      if (Reg != OldReg + 1) {
2569        Error(RegLoc, "non-contiguous register range");
2570        return MatchOperand_ParseFail;
2571      }
2572      ++Reg;
2573      Count += 2;
2574      continue;
2575    }
2576    // Normal D register. Just check that it's contiguous and keep going.
2577    if (Reg != OldReg + 1) {
2578      Error(RegLoc, "non-contiguous register range");
2579      return MatchOperand_ParseFail;
2580    }
2581    ++Count;
2582  }
2583
2584  SMLoc E = Parser.getTok().getLoc();
2585  if (Parser.getTok().isNot(AsmToken::RCurly)) {
2586    Error(E, "'}' expected");
2587    return MatchOperand_ParseFail;
2588  }
2589  Parser.Lex(); // Eat '}' token.
2590
2591  Operands.push_back(ARMOperand::CreateVectorList(FirstReg, Count, S, E));
2592  return MatchOperand_Success;
2593}
2594
2595/// parseMemBarrierOptOperand - Try to parse DSB/DMB data barrier options.
2596ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2597parseMemBarrierOptOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2598  SMLoc S = Parser.getTok().getLoc();
2599  const AsmToken &Tok = Parser.getTok();
2600  assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
2601  StringRef OptStr = Tok.getString();
2602
2603  unsigned Opt = StringSwitch<unsigned>(OptStr.slice(0, OptStr.size()))
2604    .Case("sy",    ARM_MB::SY)
2605    .Case("st",    ARM_MB::ST)
2606    .Case("sh",    ARM_MB::ISH)
2607    .Case("ish",   ARM_MB::ISH)
2608    .Case("shst",  ARM_MB::ISHST)
2609    .Case("ishst", ARM_MB::ISHST)
2610    .Case("nsh",   ARM_MB::NSH)
2611    .Case("un",    ARM_MB::NSH)
2612    .Case("nshst", ARM_MB::NSHST)
2613    .Case("unst",  ARM_MB::NSHST)
2614    .Case("osh",   ARM_MB::OSH)
2615    .Case("oshst", ARM_MB::OSHST)
2616    .Default(~0U);
2617
2618  if (Opt == ~0U)
2619    return MatchOperand_NoMatch;
2620
2621  Parser.Lex(); // Eat identifier token.
2622  Operands.push_back(ARMOperand::CreateMemBarrierOpt((ARM_MB::MemBOpt)Opt, S));
2623  return MatchOperand_Success;
2624}
2625
2626/// parseProcIFlagsOperand - Try to parse iflags from CPS instruction.
2627ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2628parseProcIFlagsOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2629  SMLoc S = Parser.getTok().getLoc();
2630  const AsmToken &Tok = Parser.getTok();
2631  assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
2632  StringRef IFlagsStr = Tok.getString();
2633
2634  // An iflags string of "none" is interpreted to mean that none of the AIF
2635  // bits are set.  Not a terribly useful instruction, but a valid encoding.
2636  unsigned IFlags = 0;
2637  if (IFlagsStr != "none") {
2638        for (int i = 0, e = IFlagsStr.size(); i != e; ++i) {
2639      unsigned Flag = StringSwitch<unsigned>(IFlagsStr.substr(i, 1))
2640        .Case("a", ARM_PROC::A)
2641        .Case("i", ARM_PROC::I)
2642        .Case("f", ARM_PROC::F)
2643        .Default(~0U);
2644
2645      // If some specific iflag is already set, it means that some letter is
2646      // present more than once, this is not acceptable.
2647      if (Flag == ~0U || (IFlags & Flag))
2648        return MatchOperand_NoMatch;
2649
2650      IFlags |= Flag;
2651    }
2652  }
2653
2654  Parser.Lex(); // Eat identifier token.
2655  Operands.push_back(ARMOperand::CreateProcIFlags((ARM_PROC::IFlags)IFlags, S));
2656  return MatchOperand_Success;
2657}
2658
2659/// parseMSRMaskOperand - Try to parse mask flags from MSR instruction.
2660ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2661parseMSRMaskOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2662  SMLoc S = Parser.getTok().getLoc();
2663  const AsmToken &Tok = Parser.getTok();
2664  assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
2665  StringRef Mask = Tok.getString();
2666
2667  if (isMClass()) {
2668    // See ARMv6-M 10.1.1
2669    unsigned FlagsVal = StringSwitch<unsigned>(Mask)
2670      .Case("apsr", 0)
2671      .Case("iapsr", 1)
2672      .Case("eapsr", 2)
2673      .Case("xpsr", 3)
2674      .Case("ipsr", 5)
2675      .Case("epsr", 6)
2676      .Case("iepsr", 7)
2677      .Case("msp", 8)
2678      .Case("psp", 9)
2679      .Case("primask", 16)
2680      .Case("basepri", 17)
2681      .Case("basepri_max", 18)
2682      .Case("faultmask", 19)
2683      .Case("control", 20)
2684      .Default(~0U);
2685
2686    if (FlagsVal == ~0U)
2687      return MatchOperand_NoMatch;
2688
2689    if (!hasV7Ops() && FlagsVal >= 17 && FlagsVal <= 19)
2690      // basepri, basepri_max and faultmask only valid for V7m.
2691      return MatchOperand_NoMatch;
2692
2693    Parser.Lex(); // Eat identifier token.
2694    Operands.push_back(ARMOperand::CreateMSRMask(FlagsVal, S));
2695    return MatchOperand_Success;
2696  }
2697
2698  // Split spec_reg from flag, example: CPSR_sxf => "CPSR" and "sxf"
2699  size_t Start = 0, Next = Mask.find('_');
2700  StringRef Flags = "";
2701  std::string SpecReg = Mask.slice(Start, Next).lower();
2702  if (Next != StringRef::npos)
2703    Flags = Mask.slice(Next+1, Mask.size());
2704
2705  // FlagsVal contains the complete mask:
2706  // 3-0: Mask
2707  // 4: Special Reg (cpsr, apsr => 0; spsr => 1)
2708  unsigned FlagsVal = 0;
2709
2710  if (SpecReg == "apsr") {
2711    FlagsVal = StringSwitch<unsigned>(Flags)
2712    .Case("nzcvq",  0x8) // same as CPSR_f
2713    .Case("g",      0x4) // same as CPSR_s
2714    .Case("nzcvqg", 0xc) // same as CPSR_fs
2715    .Default(~0U);
2716
2717    if (FlagsVal == ~0U) {
2718      if (!Flags.empty())
2719        return MatchOperand_NoMatch;
2720      else
2721        FlagsVal = 8; // No flag
2722    }
2723  } else if (SpecReg == "cpsr" || SpecReg == "spsr") {
2724    if (Flags == "all") // cpsr_all is an alias for cpsr_fc
2725      Flags = "fc";
2726    for (int i = 0, e = Flags.size(); i != e; ++i) {
2727      unsigned Flag = StringSwitch<unsigned>(Flags.substr(i, 1))
2728      .Case("c", 1)
2729      .Case("x", 2)
2730      .Case("s", 4)
2731      .Case("f", 8)
2732      .Default(~0U);
2733
2734      // If some specific flag is already set, it means that some letter is
2735      // present more than once, this is not acceptable.
2736      if (FlagsVal == ~0U || (FlagsVal & Flag))
2737        return MatchOperand_NoMatch;
2738      FlagsVal |= Flag;
2739    }
2740  } else // No match for special register.
2741    return MatchOperand_NoMatch;
2742
2743  // Special register without flags is NOT equivalent to "fc" flags.
2744  // NOTE: This is a divergence from gas' behavior.  Uncommenting the following
2745  // two lines would enable gas compatibility at the expense of breaking
2746  // round-tripping.
2747  //
2748  // if (!FlagsVal)
2749  //  FlagsVal = 0x9;
2750
2751  // Bit 4: Special Reg (cpsr, apsr => 0; spsr => 1)
2752  if (SpecReg == "spsr")
2753    FlagsVal |= 16;
2754
2755  Parser.Lex(); // Eat identifier token.
2756  Operands.push_back(ARMOperand::CreateMSRMask(FlagsVal, S));
2757  return MatchOperand_Success;
2758}
2759
2760ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2761parsePKHImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands, StringRef Op,
2762            int Low, int High) {
2763  const AsmToken &Tok = Parser.getTok();
2764  if (Tok.isNot(AsmToken::Identifier)) {
2765    Error(Parser.getTok().getLoc(), Op + " operand expected.");
2766    return MatchOperand_ParseFail;
2767  }
2768  StringRef ShiftName = Tok.getString();
2769  std::string LowerOp = Op.lower();
2770  std::string UpperOp = Op.upper();
2771  if (ShiftName != LowerOp && ShiftName != UpperOp) {
2772    Error(Parser.getTok().getLoc(), Op + " operand expected.");
2773    return MatchOperand_ParseFail;
2774  }
2775  Parser.Lex(); // Eat shift type token.
2776
2777  // There must be a '#' and a shift amount.
2778  if (Parser.getTok().isNot(AsmToken::Hash)) {
2779    Error(Parser.getTok().getLoc(), "'#' expected");
2780    return MatchOperand_ParseFail;
2781  }
2782  Parser.Lex(); // Eat hash token.
2783
2784  const MCExpr *ShiftAmount;
2785  SMLoc Loc = Parser.getTok().getLoc();
2786  if (getParser().ParseExpression(ShiftAmount)) {
2787    Error(Loc, "illegal expression");
2788    return MatchOperand_ParseFail;
2789  }
2790  const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount);
2791  if (!CE) {
2792    Error(Loc, "constant expression expected");
2793    return MatchOperand_ParseFail;
2794  }
2795  int Val = CE->getValue();
2796  if (Val < Low || Val > High) {
2797    Error(Loc, "immediate value out of range");
2798    return MatchOperand_ParseFail;
2799  }
2800
2801  Operands.push_back(ARMOperand::CreateImm(CE, Loc, Parser.getTok().getLoc()));
2802
2803  return MatchOperand_Success;
2804}
2805
2806ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2807parseSetEndImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2808  const AsmToken &Tok = Parser.getTok();
2809  SMLoc S = Tok.getLoc();
2810  if (Tok.isNot(AsmToken::Identifier)) {
2811    Error(Tok.getLoc(), "'be' or 'le' operand expected");
2812    return MatchOperand_ParseFail;
2813  }
2814  int Val = StringSwitch<int>(Tok.getString())
2815    .Case("be", 1)
2816    .Case("le", 0)
2817    .Default(-1);
2818  Parser.Lex(); // Eat the token.
2819
2820  if (Val == -1) {
2821    Error(Tok.getLoc(), "'be' or 'le' operand expected");
2822    return MatchOperand_ParseFail;
2823  }
2824  Operands.push_back(ARMOperand::CreateImm(MCConstantExpr::Create(Val,
2825                                                                  getContext()),
2826                                           S, Parser.getTok().getLoc()));
2827  return MatchOperand_Success;
2828}
2829
2830/// parseShifterImm - Parse the shifter immediate operand for SSAT/USAT
2831/// instructions. Legal values are:
2832///     lsl #n  'n' in [0,31]
2833///     asr #n  'n' in [1,32]
2834///             n == 32 encoded as n == 0.
2835ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2836parseShifterImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2837  const AsmToken &Tok = Parser.getTok();
2838  SMLoc S = Tok.getLoc();
2839  if (Tok.isNot(AsmToken::Identifier)) {
2840    Error(S, "shift operator 'asr' or 'lsl' expected");
2841    return MatchOperand_ParseFail;
2842  }
2843  StringRef ShiftName = Tok.getString();
2844  bool isASR;
2845  if (ShiftName == "lsl" || ShiftName == "LSL")
2846    isASR = false;
2847  else if (ShiftName == "asr" || ShiftName == "ASR")
2848    isASR = true;
2849  else {
2850    Error(S, "shift operator 'asr' or 'lsl' expected");
2851    return MatchOperand_ParseFail;
2852  }
2853  Parser.Lex(); // Eat the operator.
2854
2855  // A '#' and a shift amount.
2856  if (Parser.getTok().isNot(AsmToken::Hash)) {
2857    Error(Parser.getTok().getLoc(), "'#' expected");
2858    return MatchOperand_ParseFail;
2859  }
2860  Parser.Lex(); // Eat hash token.
2861
2862  const MCExpr *ShiftAmount;
2863  SMLoc E = Parser.getTok().getLoc();
2864  if (getParser().ParseExpression(ShiftAmount)) {
2865    Error(E, "malformed shift expression");
2866    return MatchOperand_ParseFail;
2867  }
2868  const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount);
2869  if (!CE) {
2870    Error(E, "shift amount must be an immediate");
2871    return MatchOperand_ParseFail;
2872  }
2873
2874  int64_t Val = CE->getValue();
2875  if (isASR) {
2876    // Shift amount must be in [1,32]
2877    if (Val < 1 || Val > 32) {
2878      Error(E, "'asr' shift amount must be in range [1,32]");
2879      return MatchOperand_ParseFail;
2880    }
2881    // asr #32 encoded as asr #0, but is not allowed in Thumb2 mode.
2882    if (isThumb() && Val == 32) {
2883      Error(E, "'asr #32' shift amount not allowed in Thumb mode");
2884      return MatchOperand_ParseFail;
2885    }
2886    if (Val == 32) Val = 0;
2887  } else {
2888    // Shift amount must be in [1,32]
2889    if (Val < 0 || Val > 31) {
2890      Error(E, "'lsr' shift amount must be in range [0,31]");
2891      return MatchOperand_ParseFail;
2892    }
2893  }
2894
2895  E = Parser.getTok().getLoc();
2896  Operands.push_back(ARMOperand::CreateShifterImm(isASR, Val, S, E));
2897
2898  return MatchOperand_Success;
2899}
2900
2901/// parseRotImm - Parse the shifter immediate operand for SXTB/UXTB family
2902/// of instructions. Legal values are:
2903///     ror #n  'n' in {0, 8, 16, 24}
2904ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2905parseRotImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2906  const AsmToken &Tok = Parser.getTok();
2907  SMLoc S = Tok.getLoc();
2908  if (Tok.isNot(AsmToken::Identifier))
2909    return MatchOperand_NoMatch;
2910  StringRef ShiftName = Tok.getString();
2911  if (ShiftName != "ror" && ShiftName != "ROR")
2912    return MatchOperand_NoMatch;
2913  Parser.Lex(); // Eat the operator.
2914
2915  // A '#' and a rotate amount.
2916  if (Parser.getTok().isNot(AsmToken::Hash)) {
2917    Error(Parser.getTok().getLoc(), "'#' expected");
2918    return MatchOperand_ParseFail;
2919  }
2920  Parser.Lex(); // Eat hash token.
2921
2922  const MCExpr *ShiftAmount;
2923  SMLoc E = Parser.getTok().getLoc();
2924  if (getParser().ParseExpression(ShiftAmount)) {
2925    Error(E, "malformed rotate expression");
2926    return MatchOperand_ParseFail;
2927  }
2928  const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount);
2929  if (!CE) {
2930    Error(E, "rotate amount must be an immediate");
2931    return MatchOperand_ParseFail;
2932  }
2933
2934  int64_t Val = CE->getValue();
2935  // Shift amount must be in {0, 8, 16, 24} (0 is undocumented extension)
2936  // normally, zero is represented in asm by omitting the rotate operand
2937  // entirely.
2938  if (Val != 8 && Val != 16 && Val != 24 && Val != 0) {
2939    Error(E, "'ror' rotate amount must be 8, 16, or 24");
2940    return MatchOperand_ParseFail;
2941  }
2942
2943  E = Parser.getTok().getLoc();
2944  Operands.push_back(ARMOperand::CreateRotImm(Val, S, E));
2945
2946  return MatchOperand_Success;
2947}
2948
2949ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2950parseBitfield(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2951  SMLoc S = Parser.getTok().getLoc();
2952  // The bitfield descriptor is really two operands, the LSB and the width.
2953  if (Parser.getTok().isNot(AsmToken::Hash)) {
2954    Error(Parser.getTok().getLoc(), "'#' expected");
2955    return MatchOperand_ParseFail;
2956  }
2957  Parser.Lex(); // Eat hash token.
2958
2959  const MCExpr *LSBExpr;
2960  SMLoc E = Parser.getTok().getLoc();
2961  if (getParser().ParseExpression(LSBExpr)) {
2962    Error(E, "malformed immediate expression");
2963    return MatchOperand_ParseFail;
2964  }
2965  const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(LSBExpr);
2966  if (!CE) {
2967    Error(E, "'lsb' operand must be an immediate");
2968    return MatchOperand_ParseFail;
2969  }
2970
2971  int64_t LSB = CE->getValue();
2972  // The LSB must be in the range [0,31]
2973  if (LSB < 0 || LSB > 31) {
2974    Error(E, "'lsb' operand must be in the range [0,31]");
2975    return MatchOperand_ParseFail;
2976  }
2977  E = Parser.getTok().getLoc();
2978
2979  // Expect another immediate operand.
2980  if (Parser.getTok().isNot(AsmToken::Comma)) {
2981    Error(Parser.getTok().getLoc(), "too few operands");
2982    return MatchOperand_ParseFail;
2983  }
2984  Parser.Lex(); // Eat hash token.
2985  if (Parser.getTok().isNot(AsmToken::Hash)) {
2986    Error(Parser.getTok().getLoc(), "'#' expected");
2987    return MatchOperand_ParseFail;
2988  }
2989  Parser.Lex(); // Eat hash token.
2990
2991  const MCExpr *WidthExpr;
2992  if (getParser().ParseExpression(WidthExpr)) {
2993    Error(E, "malformed immediate expression");
2994    return MatchOperand_ParseFail;
2995  }
2996  CE = dyn_cast<MCConstantExpr>(WidthExpr);
2997  if (!CE) {
2998    Error(E, "'width' operand must be an immediate");
2999    return MatchOperand_ParseFail;
3000  }
3001
3002  int64_t Width = CE->getValue();
3003  // The LSB must be in the range [1,32-lsb]
3004  if (Width < 1 || Width > 32 - LSB) {
3005    Error(E, "'width' operand must be in the range [1,32-lsb]");
3006    return MatchOperand_ParseFail;
3007  }
3008  E = Parser.getTok().getLoc();
3009
3010  Operands.push_back(ARMOperand::CreateBitfield(LSB, Width, S, E));
3011
3012  return MatchOperand_Success;
3013}
3014
3015ARMAsmParser::OperandMatchResultTy ARMAsmParser::
3016parsePostIdxReg(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3017  // Check for a post-index addressing register operand. Specifically:
3018  // postidx_reg := '+' register {, shift}
3019  //              | '-' register {, shift}
3020  //              | register {, shift}
3021
3022  // This method must return MatchOperand_NoMatch without consuming any tokens
3023  // in the case where there is no match, as other alternatives take other
3024  // parse methods.
3025  AsmToken Tok = Parser.getTok();
3026  SMLoc S = Tok.getLoc();
3027  bool haveEaten = false;
3028  bool isAdd = true;
3029  int Reg = -1;
3030  if (Tok.is(AsmToken::Plus)) {
3031    Parser.Lex(); // Eat the '+' token.
3032    haveEaten = true;
3033  } else if (Tok.is(AsmToken::Minus)) {
3034    Parser.Lex(); // Eat the '-' token.
3035    isAdd = false;
3036    haveEaten = true;
3037  }
3038  if (Parser.getTok().is(AsmToken::Identifier))
3039    Reg = tryParseRegister();
3040  if (Reg == -1) {
3041    if (!haveEaten)
3042      return MatchOperand_NoMatch;
3043    Error(Parser.getTok().getLoc(), "register expected");
3044    return MatchOperand_ParseFail;
3045  }
3046  SMLoc E = Parser.getTok().getLoc();
3047
3048  ARM_AM::ShiftOpc ShiftTy = ARM_AM::no_shift;
3049  unsigned ShiftImm = 0;
3050  if (Parser.getTok().is(AsmToken::Comma)) {
3051    Parser.Lex(); // Eat the ','.
3052    if (parseMemRegOffsetShift(ShiftTy, ShiftImm))
3053      return MatchOperand_ParseFail;
3054  }
3055
3056  Operands.push_back(ARMOperand::CreatePostIdxReg(Reg, isAdd, ShiftTy,
3057                                                  ShiftImm, S, E));
3058
3059  return MatchOperand_Success;
3060}
3061
3062ARMAsmParser::OperandMatchResultTy ARMAsmParser::
3063parseAM3Offset(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3064  // Check for a post-index addressing register operand. Specifically:
3065  // am3offset := '+' register
3066  //              | '-' register
3067  //              | register
3068  //              | # imm
3069  //              | # + imm
3070  //              | # - imm
3071
3072  // This method must return MatchOperand_NoMatch without consuming any tokens
3073  // in the case where there is no match, as other alternatives take other
3074  // parse methods.
3075  AsmToken Tok = Parser.getTok();
3076  SMLoc S = Tok.getLoc();
3077
3078  // Do immediates first, as we always parse those if we have a '#'.
3079  if (Parser.getTok().is(AsmToken::Hash)) {
3080    Parser.Lex(); // Eat the '#'.
3081    // Explicitly look for a '-', as we need to encode negative zero
3082    // differently.
3083    bool isNegative = Parser.getTok().is(AsmToken::Minus);
3084    const MCExpr *Offset;
3085    if (getParser().ParseExpression(Offset))
3086      return MatchOperand_ParseFail;
3087    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Offset);
3088    if (!CE) {
3089      Error(S, "constant expression expected");
3090      return MatchOperand_ParseFail;
3091    }
3092    SMLoc E = Tok.getLoc();
3093    // Negative zero is encoded as the flag value INT32_MIN.
3094    int32_t Val = CE->getValue();
3095    if (isNegative && Val == 0)
3096      Val = INT32_MIN;
3097
3098    Operands.push_back(
3099      ARMOperand::CreateImm(MCConstantExpr::Create(Val, getContext()), S, E));
3100
3101    return MatchOperand_Success;
3102  }
3103
3104
3105  bool haveEaten = false;
3106  bool isAdd = true;
3107  int Reg = -1;
3108  if (Tok.is(AsmToken::Plus)) {
3109    Parser.Lex(); // Eat the '+' token.
3110    haveEaten = true;
3111  } else if (Tok.is(AsmToken::Minus)) {
3112    Parser.Lex(); // Eat the '-' token.
3113    isAdd = false;
3114    haveEaten = true;
3115  }
3116  if (Parser.getTok().is(AsmToken::Identifier))
3117    Reg = tryParseRegister();
3118  if (Reg == -1) {
3119    if (!haveEaten)
3120      return MatchOperand_NoMatch;
3121    Error(Parser.getTok().getLoc(), "register expected");
3122    return MatchOperand_ParseFail;
3123  }
3124  SMLoc E = Parser.getTok().getLoc();
3125
3126  Operands.push_back(ARMOperand::CreatePostIdxReg(Reg, isAdd, ARM_AM::no_shift,
3127                                                  0, S, E));
3128
3129  return MatchOperand_Success;
3130}
3131
3132/// cvtT2LdrdPre - Convert parsed operands to MCInst.
3133/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3134/// when they refer multiple MIOperands inside a single one.
3135bool ARMAsmParser::
3136cvtT2LdrdPre(MCInst &Inst, unsigned Opcode,
3137             const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3138  // Rt, Rt2
3139  ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3140  ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
3141  // Create a writeback register dummy placeholder.
3142  Inst.addOperand(MCOperand::CreateReg(0));
3143  // addr
3144  ((ARMOperand*)Operands[4])->addMemImm8s4OffsetOperands(Inst, 2);
3145  // pred
3146  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3147  return true;
3148}
3149
3150/// cvtT2StrdPre - Convert parsed operands to MCInst.
3151/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3152/// when they refer multiple MIOperands inside a single one.
3153bool ARMAsmParser::
3154cvtT2StrdPre(MCInst &Inst, unsigned Opcode,
3155             const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3156  // Create a writeback register dummy placeholder.
3157  Inst.addOperand(MCOperand::CreateReg(0));
3158  // Rt, Rt2
3159  ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3160  ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
3161  // addr
3162  ((ARMOperand*)Operands[4])->addMemImm8s4OffsetOperands(Inst, 2);
3163  // pred
3164  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3165  return true;
3166}
3167
3168/// cvtLdWriteBackRegT2AddrModeImm8 - Convert parsed operands to MCInst.
3169/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3170/// when they refer multiple MIOperands inside a single one.
3171bool ARMAsmParser::
3172cvtLdWriteBackRegT2AddrModeImm8(MCInst &Inst, unsigned Opcode,
3173                         const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3174  ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3175
3176  // Create a writeback register dummy placeholder.
3177  Inst.addOperand(MCOperand::CreateImm(0));
3178
3179  ((ARMOperand*)Operands[3])->addMemImm8OffsetOperands(Inst, 2);
3180  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3181  return true;
3182}
3183
3184/// cvtStWriteBackRegT2AddrModeImm8 - Convert parsed operands to MCInst.
3185/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3186/// when they refer multiple MIOperands inside a single one.
3187bool ARMAsmParser::
3188cvtStWriteBackRegT2AddrModeImm8(MCInst &Inst, unsigned Opcode,
3189                         const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3190  // Create a writeback register dummy placeholder.
3191  Inst.addOperand(MCOperand::CreateImm(0));
3192  ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3193  ((ARMOperand*)Operands[3])->addMemImm8OffsetOperands(Inst, 2);
3194  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3195  return true;
3196}
3197
3198/// cvtLdWriteBackRegAddrMode2 - Convert parsed operands to MCInst.
3199/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3200/// when they refer multiple MIOperands inside a single one.
3201bool ARMAsmParser::
3202cvtLdWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
3203                         const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3204  ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3205
3206  // Create a writeback register dummy placeholder.
3207  Inst.addOperand(MCOperand::CreateImm(0));
3208
3209  ((ARMOperand*)Operands[3])->addAddrMode2Operands(Inst, 3);
3210  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3211  return true;
3212}
3213
3214/// cvtLdWriteBackRegAddrModeImm12 - Convert parsed operands to MCInst.
3215/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3216/// when they refer multiple MIOperands inside a single one.
3217bool ARMAsmParser::
3218cvtLdWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
3219                         const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3220  ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3221
3222  // Create a writeback register dummy placeholder.
3223  Inst.addOperand(MCOperand::CreateImm(0));
3224
3225  ((ARMOperand*)Operands[3])->addMemImm12OffsetOperands(Inst, 2);
3226  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3227  return true;
3228}
3229
3230
3231/// cvtStWriteBackRegAddrModeImm12 - Convert parsed operands to MCInst.
3232/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3233/// when they refer multiple MIOperands inside a single one.
3234bool ARMAsmParser::
3235cvtStWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
3236                         const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3237  // Create a writeback register dummy placeholder.
3238  Inst.addOperand(MCOperand::CreateImm(0));
3239  ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3240  ((ARMOperand*)Operands[3])->addMemImm12OffsetOperands(Inst, 2);
3241  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3242  return true;
3243}
3244
3245/// cvtStWriteBackRegAddrMode2 - Convert parsed operands to MCInst.
3246/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3247/// when they refer multiple MIOperands inside a single one.
3248bool ARMAsmParser::
3249cvtStWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
3250                         const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3251  // Create a writeback register dummy placeholder.
3252  Inst.addOperand(MCOperand::CreateImm(0));
3253  ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3254  ((ARMOperand*)Operands[3])->addAddrMode2Operands(Inst, 3);
3255  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3256  return true;
3257}
3258
3259/// cvtStWriteBackRegAddrMode3 - Convert parsed operands to MCInst.
3260/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3261/// when they refer multiple MIOperands inside a single one.
3262bool ARMAsmParser::
3263cvtStWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
3264                         const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3265  // Create a writeback register dummy placeholder.
3266  Inst.addOperand(MCOperand::CreateImm(0));
3267  ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3268  ((ARMOperand*)Operands[3])->addAddrMode3Operands(Inst, 3);
3269  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3270  return true;
3271}
3272
3273/// cvtLdExtTWriteBackImm - Convert parsed operands to MCInst.
3274/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3275/// when they refer multiple MIOperands inside a single one.
3276bool ARMAsmParser::
3277cvtLdExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
3278                      const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3279  // Rt
3280  ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3281  // Create a writeback register dummy placeholder.
3282  Inst.addOperand(MCOperand::CreateImm(0));
3283  // addr
3284  ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
3285  // offset
3286  ((ARMOperand*)Operands[4])->addPostIdxImm8Operands(Inst, 1);
3287  // pred
3288  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3289  return true;
3290}
3291
3292/// cvtLdExtTWriteBackReg - Convert parsed operands to MCInst.
3293/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3294/// when they refer multiple MIOperands inside a single one.
3295bool ARMAsmParser::
3296cvtLdExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
3297                      const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3298  // Rt
3299  ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3300  // Create a writeback register dummy placeholder.
3301  Inst.addOperand(MCOperand::CreateImm(0));
3302  // addr
3303  ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
3304  // offset
3305  ((ARMOperand*)Operands[4])->addPostIdxRegOperands(Inst, 2);
3306  // pred
3307  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3308  return true;
3309}
3310
3311/// cvtStExtTWriteBackImm - Convert parsed operands to MCInst.
3312/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3313/// when they refer multiple MIOperands inside a single one.
3314bool ARMAsmParser::
3315cvtStExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
3316                      const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3317  // Create a writeback register dummy placeholder.
3318  Inst.addOperand(MCOperand::CreateImm(0));
3319  // Rt
3320  ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3321  // addr
3322  ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
3323  // offset
3324  ((ARMOperand*)Operands[4])->addPostIdxImm8Operands(Inst, 1);
3325  // pred
3326  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3327  return true;
3328}
3329
3330/// cvtStExtTWriteBackReg - Convert parsed operands to MCInst.
3331/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3332/// when they refer multiple MIOperands inside a single one.
3333bool ARMAsmParser::
3334cvtStExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
3335                      const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3336  // Create a writeback register dummy placeholder.
3337  Inst.addOperand(MCOperand::CreateImm(0));
3338  // Rt
3339  ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3340  // addr
3341  ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
3342  // offset
3343  ((ARMOperand*)Operands[4])->addPostIdxRegOperands(Inst, 2);
3344  // pred
3345  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3346  return true;
3347}
3348
3349/// cvtLdrdPre - Convert parsed operands to MCInst.
3350/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3351/// when they refer multiple MIOperands inside a single one.
3352bool ARMAsmParser::
3353cvtLdrdPre(MCInst &Inst, unsigned Opcode,
3354           const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3355  // Rt, Rt2
3356  ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3357  ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
3358  // Create a writeback register dummy placeholder.
3359  Inst.addOperand(MCOperand::CreateImm(0));
3360  // addr
3361  ((ARMOperand*)Operands[4])->addAddrMode3Operands(Inst, 3);
3362  // pred
3363  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3364  return true;
3365}
3366
3367/// cvtStrdPre - Convert parsed operands to MCInst.
3368/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3369/// when they refer multiple MIOperands inside a single one.
3370bool ARMAsmParser::
3371cvtStrdPre(MCInst &Inst, unsigned Opcode,
3372           const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3373  // Create a writeback register dummy placeholder.
3374  Inst.addOperand(MCOperand::CreateImm(0));
3375  // Rt, Rt2
3376  ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3377  ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
3378  // addr
3379  ((ARMOperand*)Operands[4])->addAddrMode3Operands(Inst, 3);
3380  // pred
3381  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3382  return true;
3383}
3384
3385/// cvtLdWriteBackRegAddrMode3 - Convert parsed operands to MCInst.
3386/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3387/// when they refer multiple MIOperands inside a single one.
3388bool ARMAsmParser::
3389cvtLdWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
3390                         const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3391  ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3392  // Create a writeback register dummy placeholder.
3393  Inst.addOperand(MCOperand::CreateImm(0));
3394  ((ARMOperand*)Operands[3])->addAddrMode3Operands(Inst, 3);
3395  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3396  return true;
3397}
3398
3399/// cvtThumbMultiple- Convert parsed operands to MCInst.
3400/// Needed here because the Asm Gen Matcher can't handle properly tied operands
3401/// when they refer multiple MIOperands inside a single one.
3402bool ARMAsmParser::
3403cvtThumbMultiply(MCInst &Inst, unsigned Opcode,
3404           const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3405  // The second source operand must be the same register as the destination
3406  // operand.
3407  if (Operands.size() == 6 &&
3408      (((ARMOperand*)Operands[3])->getReg() !=
3409       ((ARMOperand*)Operands[5])->getReg()) &&
3410      (((ARMOperand*)Operands[3])->getReg() !=
3411       ((ARMOperand*)Operands[4])->getReg())) {
3412    Error(Operands[3]->getStartLoc(),
3413          "destination register must match source register");
3414    return false;
3415  }
3416  ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
3417  ((ARMOperand*)Operands[1])->addCCOutOperands(Inst, 1);
3418  ((ARMOperand*)Operands[4])->addRegOperands(Inst, 1);
3419  // If we have a three-operand form, use that, else the second source operand
3420  // is just the destination operand again.
3421  if (Operands.size() == 6)
3422    ((ARMOperand*)Operands[5])->addRegOperands(Inst, 1);
3423  else
3424    Inst.addOperand(Inst.getOperand(0));
3425  ((ARMOperand*)Operands[2])->addCondCodeOperands(Inst, 2);
3426
3427  return true;
3428}
3429
3430bool ARMAsmParser::
3431cvtVLDwbFixed(MCInst &Inst, unsigned Opcode,
3432              const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3433  // Vd
3434  ((ARMOperand*)Operands[3])->addVecListTwoDOperands(Inst, 1);
3435  // Create a writeback register dummy placeholder.
3436  Inst.addOperand(MCOperand::CreateImm(0));
3437  // Vn
3438  ((ARMOperand*)Operands[4])->addAlignedMemoryOperands(Inst, 2);
3439  // pred
3440  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3441  return true;
3442}
3443
3444bool ARMAsmParser::
3445cvtVLDwbRegister(MCInst &Inst, unsigned Opcode,
3446                 const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3447  // Vd
3448  ((ARMOperand*)Operands[3])->addVecListTwoDOperands(Inst, 1);
3449  // Create a writeback register dummy placeholder.
3450  Inst.addOperand(MCOperand::CreateImm(0));
3451  // Vn
3452  ((ARMOperand*)Operands[4])->addAlignedMemoryOperands(Inst, 2);
3453  // Vm
3454  ((ARMOperand*)Operands[5])->addRegOperands(Inst, 1);
3455  // pred
3456  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3457  return true;
3458}
3459
3460bool ARMAsmParser::
3461cvtVSTwbFixed(MCInst &Inst, unsigned Opcode,
3462              const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3463  // Create a writeback register dummy placeholder.
3464  Inst.addOperand(MCOperand::CreateImm(0));
3465  // Vn
3466  ((ARMOperand*)Operands[4])->addAlignedMemoryOperands(Inst, 2);
3467  // Vt
3468  ((ARMOperand*)Operands[3])->addVecListTwoDOperands(Inst, 1);
3469  // pred
3470  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3471  return true;
3472}
3473
3474bool ARMAsmParser::
3475cvtVSTwbRegister(MCInst &Inst, unsigned Opcode,
3476                 const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3477  // Create a writeback register dummy placeholder.
3478  Inst.addOperand(MCOperand::CreateImm(0));
3479  // Vn
3480  ((ARMOperand*)Operands[4])->addAlignedMemoryOperands(Inst, 2);
3481  // Vm
3482  ((ARMOperand*)Operands[5])->addRegOperands(Inst, 1);
3483  // Vt
3484  ((ARMOperand*)Operands[3])->addVecListTwoDOperands(Inst, 1);
3485  // pred
3486  ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3487  return true;
3488}
3489
3490/// Parse an ARM memory expression, return false if successful else return true
3491/// or an error.  The first token must be a '[' when called.
3492bool ARMAsmParser::
3493parseMemory(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3494  SMLoc S, E;
3495  assert(Parser.getTok().is(AsmToken::LBrac) &&
3496         "Token is not a Left Bracket");
3497  S = Parser.getTok().getLoc();
3498  Parser.Lex(); // Eat left bracket token.
3499
3500  const AsmToken &BaseRegTok = Parser.getTok();
3501  int BaseRegNum = tryParseRegister();
3502  if (BaseRegNum == -1)
3503    return Error(BaseRegTok.getLoc(), "register expected");
3504
3505  // The next token must either be a comma or a closing bracket.
3506  const AsmToken &Tok = Parser.getTok();
3507  if (!Tok.is(AsmToken::Comma) && !Tok.is(AsmToken::RBrac))
3508    return Error(Tok.getLoc(), "malformed memory operand");
3509
3510  if (Tok.is(AsmToken::RBrac)) {
3511    E = Tok.getLoc();
3512    Parser.Lex(); // Eat right bracket token.
3513
3514    Operands.push_back(ARMOperand::CreateMem(BaseRegNum, 0, 0, ARM_AM::no_shift,
3515                                             0, 0, false, S, E));
3516
3517    // If there's a pre-indexing writeback marker, '!', just add it as a token
3518    // operand. It's rather odd, but syntactically valid.
3519    if (Parser.getTok().is(AsmToken::Exclaim)) {
3520      Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc()));
3521      Parser.Lex(); // Eat the '!'.
3522    }
3523
3524    return false;
3525  }
3526
3527  assert(Tok.is(AsmToken::Comma) && "Lost comma in memory operand?!");
3528  Parser.Lex(); // Eat the comma.
3529
3530  // If we have a ':', it's an alignment specifier.
3531  if (Parser.getTok().is(AsmToken::Colon)) {
3532    Parser.Lex(); // Eat the ':'.
3533    E = Parser.getTok().getLoc();
3534
3535    const MCExpr *Expr;
3536    if (getParser().ParseExpression(Expr))
3537     return true;
3538
3539    // The expression has to be a constant. Memory references with relocations
3540    // don't come through here, as they use the <label> forms of the relevant
3541    // instructions.
3542    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr);
3543    if (!CE)
3544      return Error (E, "constant expression expected");
3545
3546    unsigned Align = 0;
3547    switch (CE->getValue()) {
3548    default:
3549      return Error(E, "alignment specifier must be 64, 128, or 256 bits");
3550    case 64:  Align = 8; break;
3551    case 128: Align = 16; break;
3552    case 256: Align = 32; break;
3553    }
3554
3555    // Now we should have the closing ']'
3556    E = Parser.getTok().getLoc();
3557    if (Parser.getTok().isNot(AsmToken::RBrac))
3558      return Error(E, "']' expected");
3559    Parser.Lex(); // Eat right bracket token.
3560
3561    // Don't worry about range checking the value here. That's handled by
3562    // the is*() predicates.
3563    Operands.push_back(ARMOperand::CreateMem(BaseRegNum, 0, 0,
3564                                             ARM_AM::no_shift, 0, Align,
3565                                             false, S, E));
3566
3567    // If there's a pre-indexing writeback marker, '!', just add it as a token
3568    // operand.
3569    if (Parser.getTok().is(AsmToken::Exclaim)) {
3570      Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc()));
3571      Parser.Lex(); // Eat the '!'.
3572    }
3573
3574    return false;
3575  }
3576
3577  // If we have a '#', it's an immediate offset, else assume it's a register
3578  // offset.
3579  if (Parser.getTok().is(AsmToken::Hash)) {
3580    Parser.Lex(); // Eat the '#'.
3581    E = Parser.getTok().getLoc();
3582
3583    bool isNegative = getParser().getTok().is(AsmToken::Minus);
3584    const MCExpr *Offset;
3585    if (getParser().ParseExpression(Offset))
3586     return true;
3587
3588    // The expression has to be a constant. Memory references with relocations
3589    // don't come through here, as they use the <label> forms of the relevant
3590    // instructions.
3591    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Offset);
3592    if (!CE)
3593      return Error (E, "constant expression expected");
3594
3595    // If the constant was #-0, represent it as INT32_MIN.
3596    int32_t Val = CE->getValue();
3597    if (isNegative && Val == 0)
3598      CE = MCConstantExpr::Create(INT32_MIN, getContext());
3599
3600    // Now we should have the closing ']'
3601    E = Parser.getTok().getLoc();
3602    if (Parser.getTok().isNot(AsmToken::RBrac))
3603      return Error(E, "']' expected");
3604    Parser.Lex(); // Eat right bracket token.
3605
3606    // Don't worry about range checking the value here. That's handled by
3607    // the is*() predicates.
3608    Operands.push_back(ARMOperand::CreateMem(BaseRegNum, CE, 0,
3609                                             ARM_AM::no_shift, 0, 0,
3610                                             false, S, E));
3611
3612    // If there's a pre-indexing writeback marker, '!', just add it as a token
3613    // operand.
3614    if (Parser.getTok().is(AsmToken::Exclaim)) {
3615      Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc()));
3616      Parser.Lex(); // Eat the '!'.
3617    }
3618
3619    return false;
3620  }
3621
3622  // The register offset is optionally preceded by a '+' or '-'
3623  bool isNegative = false;
3624  if (Parser.getTok().is(AsmToken::Minus)) {
3625    isNegative = true;
3626    Parser.Lex(); // Eat the '-'.
3627  } else if (Parser.getTok().is(AsmToken::Plus)) {
3628    // Nothing to do.
3629    Parser.Lex(); // Eat the '+'.
3630  }
3631
3632  E = Parser.getTok().getLoc();
3633  int OffsetRegNum = tryParseRegister();
3634  if (OffsetRegNum == -1)
3635    return Error(E, "register expected");
3636
3637  // If there's a shift operator, handle it.
3638  ARM_AM::ShiftOpc ShiftType = ARM_AM::no_shift;
3639  unsigned ShiftImm = 0;
3640  if (Parser.getTok().is(AsmToken::Comma)) {
3641    Parser.Lex(); // Eat the ','.
3642    if (parseMemRegOffsetShift(ShiftType, ShiftImm))
3643      return true;
3644  }
3645
3646  // Now we should have the closing ']'
3647  E = Parser.getTok().getLoc();
3648  if (Parser.getTok().isNot(AsmToken::RBrac))
3649    return Error(E, "']' expected");
3650  Parser.Lex(); // Eat right bracket token.
3651
3652  Operands.push_back(ARMOperand::CreateMem(BaseRegNum, 0, OffsetRegNum,
3653                                           ShiftType, ShiftImm, 0, isNegative,
3654                                           S, E));
3655
3656  // If there's a pre-indexing writeback marker, '!', just add it as a token
3657  // operand.
3658  if (Parser.getTok().is(AsmToken::Exclaim)) {
3659    Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc()));
3660    Parser.Lex(); // Eat the '!'.
3661  }
3662
3663  return false;
3664}
3665
3666/// parseMemRegOffsetShift - one of these two:
3667///   ( lsl | lsr | asr | ror ) , # shift_amount
3668///   rrx
3669/// return true if it parses a shift otherwise it returns false.
3670bool ARMAsmParser::parseMemRegOffsetShift(ARM_AM::ShiftOpc &St,
3671                                          unsigned &Amount) {
3672  SMLoc Loc = Parser.getTok().getLoc();
3673  const AsmToken &Tok = Parser.getTok();
3674  if (Tok.isNot(AsmToken::Identifier))
3675    return true;
3676  StringRef ShiftName = Tok.getString();
3677  if (ShiftName == "lsl" || ShiftName == "LSL")
3678    St = ARM_AM::lsl;
3679  else if (ShiftName == "lsr" || ShiftName == "LSR")
3680    St = ARM_AM::lsr;
3681  else if (ShiftName == "asr" || ShiftName == "ASR")
3682    St = ARM_AM::asr;
3683  else if (ShiftName == "ror" || ShiftName == "ROR")
3684    St = ARM_AM::ror;
3685  else if (ShiftName == "rrx" || ShiftName == "RRX")
3686    St = ARM_AM::rrx;
3687  else
3688    return Error(Loc, "illegal shift operator");
3689  Parser.Lex(); // Eat shift type token.
3690
3691  // rrx stands alone.
3692  Amount = 0;
3693  if (St != ARM_AM::rrx) {
3694    Loc = Parser.getTok().getLoc();
3695    // A '#' and a shift amount.
3696    const AsmToken &HashTok = Parser.getTok();
3697    if (HashTok.isNot(AsmToken::Hash))
3698      return Error(HashTok.getLoc(), "'#' expected");
3699    Parser.Lex(); // Eat hash token.
3700
3701    const MCExpr *Expr;
3702    if (getParser().ParseExpression(Expr))
3703      return true;
3704    // Range check the immediate.
3705    // lsl, ror: 0 <= imm <= 31
3706    // lsr, asr: 0 <= imm <= 32
3707    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr);
3708    if (!CE)
3709      return Error(Loc, "shift amount must be an immediate");
3710    int64_t Imm = CE->getValue();
3711    if (Imm < 0 ||
3712        ((St == ARM_AM::lsl || St == ARM_AM::ror) && Imm > 31) ||
3713        ((St == ARM_AM::lsr || St == ARM_AM::asr) && Imm > 32))
3714      return Error(Loc, "immediate shift value out of range");
3715    Amount = Imm;
3716  }
3717
3718  return false;
3719}
3720
3721/// parseFPImm - A floating point immediate expression operand.
3722ARMAsmParser::OperandMatchResultTy ARMAsmParser::
3723parseFPImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3724  SMLoc S = Parser.getTok().getLoc();
3725
3726  if (Parser.getTok().isNot(AsmToken::Hash))
3727    return MatchOperand_NoMatch;
3728
3729  // Disambiguate the VMOV forms that can accept an FP immediate.
3730  // vmov.f32 <sreg>, #imm
3731  // vmov.f64 <dreg>, #imm
3732  // vmov.f32 <dreg>, #imm  @ vector f32x2
3733  // vmov.f32 <qreg>, #imm  @ vector f32x4
3734  //
3735  // There are also the NEON VMOV instructions which expect an
3736  // integer constant. Make sure we don't try to parse an FPImm
3737  // for these:
3738  // vmov.i{8|16|32|64} <dreg|qreg>, #imm
3739  ARMOperand *TyOp = static_cast<ARMOperand*>(Operands[2]);
3740  if (!TyOp->isToken() || (TyOp->getToken() != ".f32" &&
3741                           TyOp->getToken() != ".f64"))
3742    return MatchOperand_NoMatch;
3743
3744  Parser.Lex(); // Eat the '#'.
3745
3746  // Handle negation, as that still comes through as a separate token.
3747  bool isNegative = false;
3748  if (Parser.getTok().is(AsmToken::Minus)) {
3749    isNegative = true;
3750    Parser.Lex();
3751  }
3752  const AsmToken &Tok = Parser.getTok();
3753  if (Tok.is(AsmToken::Real)) {
3754    APFloat RealVal(APFloat::IEEEdouble, Tok.getString());
3755    uint64_t IntVal = RealVal.bitcastToAPInt().getZExtValue();
3756    // If we had a '-' in front, toggle the sign bit.
3757    IntVal ^= (uint64_t)isNegative << 63;
3758    int Val = ARM_AM::getFP64Imm(APInt(64, IntVal));
3759    Parser.Lex(); // Eat the token.
3760    if (Val == -1) {
3761      TokError("floating point value out of range");
3762      return MatchOperand_ParseFail;
3763    }
3764    Operands.push_back(ARMOperand::CreateFPImm(Val, S, getContext()));
3765    return MatchOperand_Success;
3766  }
3767  if (Tok.is(AsmToken::Integer)) {
3768    int64_t Val = Tok.getIntVal();
3769    Parser.Lex(); // Eat the token.
3770    if (Val > 255 || Val < 0) {
3771      TokError("encoded floating point value out of range");
3772      return MatchOperand_ParseFail;
3773    }
3774    Operands.push_back(ARMOperand::CreateFPImm(Val, S, getContext()));
3775    return MatchOperand_Success;
3776  }
3777
3778  TokError("invalid floating point immediate");
3779  return MatchOperand_ParseFail;
3780}
3781/// Parse a arm instruction operand.  For now this parses the operand regardless
3782/// of the mnemonic.
3783bool ARMAsmParser::parseOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands,
3784                                StringRef Mnemonic) {
3785  SMLoc S, E;
3786
3787  // Check if the current operand has a custom associated parser, if so, try to
3788  // custom parse the operand, or fallback to the general approach.
3789  OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic);
3790  if (ResTy == MatchOperand_Success)
3791    return false;
3792  // If there wasn't a custom match, try the generic matcher below. Otherwise,
3793  // there was a match, but an error occurred, in which case, just return that
3794  // the operand parsing failed.
3795  if (ResTy == MatchOperand_ParseFail)
3796    return true;
3797
3798  switch (getLexer().getKind()) {
3799  default:
3800    Error(Parser.getTok().getLoc(), "unexpected token in operand");
3801    return true;
3802  case AsmToken::Identifier: {
3803    // If this is VMRS, check for the apsr_nzcv operand.
3804    if (!tryParseRegisterWithWriteBack(Operands))
3805      return false;
3806    int Res = tryParseShiftRegister(Operands);
3807    if (Res == 0) // success
3808      return false;
3809    else if (Res == -1) // irrecoverable error
3810      return true;
3811    if (Mnemonic == "vmrs" && Parser.getTok().getString() == "apsr_nzcv") {
3812      S = Parser.getTok().getLoc();
3813      Parser.Lex();
3814      Operands.push_back(ARMOperand::CreateToken("apsr_nzcv", S));
3815      return false;
3816    }
3817
3818    // Fall though for the Identifier case that is not a register or a
3819    // special name.
3820  }
3821  case AsmToken::LParen:  // parenthesized expressions like (_strcmp-4)
3822  case AsmToken::Integer: // things like 1f and 2b as a branch targets
3823  case AsmToken::String:  // quoted label names.
3824  case AsmToken::Dot: {   // . as a branch target
3825    // This was not a register so parse other operands that start with an
3826    // identifier (like labels) as expressions and create them as immediates.
3827    const MCExpr *IdVal;
3828    S = Parser.getTok().getLoc();
3829    if (getParser().ParseExpression(IdVal))
3830      return true;
3831    E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
3832    Operands.push_back(ARMOperand::CreateImm(IdVal, S, E));
3833    return false;
3834  }
3835  case AsmToken::LBrac:
3836    return parseMemory(Operands);
3837  case AsmToken::LCurly:
3838    return parseRegisterList(Operands);
3839  case AsmToken::Hash: {
3840    // #42 -> immediate.
3841    // TODO: ":lower16:" and ":upper16:" modifiers after # before immediate
3842    S = Parser.getTok().getLoc();
3843    Parser.Lex();
3844    bool isNegative = Parser.getTok().is(AsmToken::Minus);
3845    const MCExpr *ImmVal;
3846    if (getParser().ParseExpression(ImmVal))
3847      return true;
3848    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ImmVal);
3849    if (CE) {
3850      int32_t Val = CE->getValue();
3851      if (isNegative && Val == 0)
3852        ImmVal = MCConstantExpr::Create(INT32_MIN, getContext());
3853    }
3854    E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
3855    Operands.push_back(ARMOperand::CreateImm(ImmVal, S, E));
3856    return false;
3857  }
3858  case AsmToken::Colon: {
3859    // ":lower16:" and ":upper16:" expression prefixes
3860    // FIXME: Check it's an expression prefix,
3861    // e.g. (FOO - :lower16:BAR) isn't legal.
3862    ARMMCExpr::VariantKind RefKind;
3863    if (parsePrefix(RefKind))
3864      return true;
3865
3866    const MCExpr *SubExprVal;
3867    if (getParser().ParseExpression(SubExprVal))
3868      return true;
3869
3870    const MCExpr *ExprVal = ARMMCExpr::Create(RefKind, SubExprVal,
3871                                                   getContext());
3872    E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
3873    Operands.push_back(ARMOperand::CreateImm(ExprVal, S, E));
3874    return false;
3875  }
3876  }
3877}
3878
3879// parsePrefix - Parse ARM 16-bit relocations expression prefix, i.e.
3880//  :lower16: and :upper16:.
3881bool ARMAsmParser::parsePrefix(ARMMCExpr::VariantKind &RefKind) {
3882  RefKind = ARMMCExpr::VK_ARM_None;
3883
3884  // :lower16: and :upper16: modifiers
3885  assert(getLexer().is(AsmToken::Colon) && "expected a :");
3886  Parser.Lex(); // Eat ':'
3887
3888  if (getLexer().isNot(AsmToken::Identifier)) {
3889    Error(Parser.getTok().getLoc(), "expected prefix identifier in operand");
3890    return true;
3891  }
3892
3893  StringRef IDVal = Parser.getTok().getIdentifier();
3894  if (IDVal == "lower16") {
3895    RefKind = ARMMCExpr::VK_ARM_LO16;
3896  } else if (IDVal == "upper16") {
3897    RefKind = ARMMCExpr::VK_ARM_HI16;
3898  } else {
3899    Error(Parser.getTok().getLoc(), "unexpected prefix in operand");
3900    return true;
3901  }
3902  Parser.Lex();
3903
3904  if (getLexer().isNot(AsmToken::Colon)) {
3905    Error(Parser.getTok().getLoc(), "unexpected token after prefix");
3906    return true;
3907  }
3908  Parser.Lex(); // Eat the last ':'
3909  return false;
3910}
3911
3912/// \brief Given a mnemonic, split out possible predication code and carry
3913/// setting letters to form a canonical mnemonic and flags.
3914//
3915// FIXME: Would be nice to autogen this.
3916// FIXME: This is a bit of a maze of special cases.
3917StringRef ARMAsmParser::splitMnemonic(StringRef Mnemonic,
3918                                      unsigned &PredicationCode,
3919                                      bool &CarrySetting,
3920                                      unsigned &ProcessorIMod,
3921                                      StringRef &ITMask) {
3922  PredicationCode = ARMCC::AL;
3923  CarrySetting = false;
3924  ProcessorIMod = 0;
3925
3926  // Ignore some mnemonics we know aren't predicated forms.
3927  //
3928  // FIXME: Would be nice to autogen this.
3929  if ((Mnemonic == "movs" && isThumb()) ||
3930      Mnemonic == "teq"   || Mnemonic == "vceq"   || Mnemonic == "svc"   ||
3931      Mnemonic == "mls"   || Mnemonic == "smmls"  || Mnemonic == "vcls"  ||
3932      Mnemonic == "vmls"  || Mnemonic == "vnmls"  || Mnemonic == "vacge" ||
3933      Mnemonic == "vcge"  || Mnemonic == "vclt"   || Mnemonic == "vacgt" ||
3934      Mnemonic == "vcgt"  || Mnemonic == "vcle"   || Mnemonic == "smlal" ||
3935      Mnemonic == "umaal" || Mnemonic == "umlal"  || Mnemonic == "vabal" ||
3936      Mnemonic == "vmlal" || Mnemonic == "vpadal" || Mnemonic == "vqdmlal")
3937    return Mnemonic;
3938
3939  // First, split out any predication code. Ignore mnemonics we know aren't
3940  // predicated but do have a carry-set and so weren't caught above.
3941  if (Mnemonic != "adcs" && Mnemonic != "bics" && Mnemonic != "movs" &&
3942      Mnemonic != "muls" && Mnemonic != "smlals" && Mnemonic != "smulls" &&
3943      Mnemonic != "umlals" && Mnemonic != "umulls" && Mnemonic != "lsls" &&
3944      Mnemonic != "sbcs" && Mnemonic != "rscs") {
3945    unsigned CC = StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2))
3946      .Case("eq", ARMCC::EQ)
3947      .Case("ne", ARMCC::NE)
3948      .Case("hs", ARMCC::HS)
3949      .Case("cs", ARMCC::HS)
3950      .Case("lo", ARMCC::LO)
3951      .Case("cc", ARMCC::LO)
3952      .Case("mi", ARMCC::MI)
3953      .Case("pl", ARMCC::PL)
3954      .Case("vs", ARMCC::VS)
3955      .Case("vc", ARMCC::VC)
3956      .Case("hi", ARMCC::HI)
3957      .Case("ls", ARMCC::LS)
3958      .Case("ge", ARMCC::GE)
3959      .Case("lt", ARMCC::LT)
3960      .Case("gt", ARMCC::GT)
3961      .Case("le", ARMCC::LE)
3962      .Case("al", ARMCC::AL)
3963      .Default(~0U);
3964    if (CC != ~0U) {
3965      Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 2);
3966      PredicationCode = CC;
3967    }
3968  }
3969
3970  // Next, determine if we have a carry setting bit. We explicitly ignore all
3971  // the instructions we know end in 's'.
3972  if (Mnemonic.endswith("s") &&
3973      !(Mnemonic == "cps" || Mnemonic == "mls" ||
3974        Mnemonic == "mrs" || Mnemonic == "smmls" || Mnemonic == "vabs" ||
3975        Mnemonic == "vcls" || Mnemonic == "vmls" || Mnemonic == "vmrs" ||
3976        Mnemonic == "vnmls" || Mnemonic == "vqabs" || Mnemonic == "vrecps" ||
3977        Mnemonic == "vrsqrts" || Mnemonic == "srs" ||
3978        (Mnemonic == "movs" && isThumb()))) {
3979    Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 1);
3980    CarrySetting = true;
3981  }
3982
3983  // The "cps" instruction can have a interrupt mode operand which is glued into
3984  // the mnemonic. Check if this is the case, split it and parse the imod op
3985  if (Mnemonic.startswith("cps")) {
3986    // Split out any imod code.
3987    unsigned IMod =
3988      StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2, 2))
3989      .Case("ie", ARM_PROC::IE)
3990      .Case("id", ARM_PROC::ID)
3991      .Default(~0U);
3992    if (IMod != ~0U) {
3993      Mnemonic = Mnemonic.slice(0, Mnemonic.size()-2);
3994      ProcessorIMod = IMod;
3995    }
3996  }
3997
3998  // The "it" instruction has the condition mask on the end of the mnemonic.
3999  if (Mnemonic.startswith("it")) {
4000    ITMask = Mnemonic.slice(2, Mnemonic.size());
4001    Mnemonic = Mnemonic.slice(0, 2);
4002  }
4003
4004  return Mnemonic;
4005}
4006
4007/// \brief Given a canonical mnemonic, determine if the instruction ever allows
4008/// inclusion of carry set or predication code operands.
4009//
4010// FIXME: It would be nice to autogen this.
4011void ARMAsmParser::
4012getMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet,
4013                      bool &CanAcceptPredicationCode) {
4014  if (Mnemonic == "and" || Mnemonic == "lsl" || Mnemonic == "lsr" ||
4015      Mnemonic == "rrx" || Mnemonic == "ror" || Mnemonic == "sub" ||
4016      Mnemonic == "add" || Mnemonic == "adc" ||
4017      Mnemonic == "mul" || Mnemonic == "bic" || Mnemonic == "asr" ||
4018      Mnemonic == "orr" || Mnemonic == "mvn" ||
4019      Mnemonic == "rsb" || Mnemonic == "rsc" || Mnemonic == "orn" ||
4020      Mnemonic == "sbc" || Mnemonic == "eor" || Mnemonic == "neg" ||
4021      (!isThumb() && (Mnemonic == "smull" || Mnemonic == "mov" ||
4022                      Mnemonic == "mla" || Mnemonic == "smlal" ||
4023                      Mnemonic == "umlal" || Mnemonic == "umull"))) {
4024    CanAcceptCarrySet = true;
4025  } else
4026    CanAcceptCarrySet = false;
4027
4028  if (Mnemonic == "cbnz" || Mnemonic == "setend" || Mnemonic == "dmb" ||
4029      Mnemonic == "cps" || Mnemonic == "mcr2" || Mnemonic == "it" ||
4030      Mnemonic == "mcrr2" || Mnemonic == "cbz" || Mnemonic == "cdp2" ||
4031      Mnemonic == "trap" || Mnemonic == "mrc2" || Mnemonic == "mrrc2" ||
4032      Mnemonic == "dsb" || Mnemonic == "isb" || Mnemonic == "setend" ||
4033      (Mnemonic == "clrex" && !isThumb()) ||
4034      (Mnemonic == "nop" && isThumbOne()) ||
4035      ((Mnemonic == "pld" || Mnemonic == "pli" || Mnemonic == "pldw" ||
4036        Mnemonic == "ldc2" || Mnemonic == "ldc2l" ||
4037        Mnemonic == "stc2" || Mnemonic == "stc2l") && !isThumb()) ||
4038      ((Mnemonic.startswith("rfe") || Mnemonic.startswith("srs")) &&
4039       !isThumb()) ||
4040      Mnemonic.startswith("cps") || (Mnemonic == "movs" && isThumbOne())) {
4041    CanAcceptPredicationCode = false;
4042  } else
4043    CanAcceptPredicationCode = true;
4044
4045  if (isThumb()) {
4046    if (Mnemonic == "bkpt" || Mnemonic == "mcr" || Mnemonic == "mcrr" ||
4047        Mnemonic == "mrc" || Mnemonic == "mrrc" || Mnemonic == "cdp")
4048      CanAcceptPredicationCode = false;
4049  }
4050}
4051
4052bool ARMAsmParser::shouldOmitCCOutOperand(StringRef Mnemonic,
4053                               SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
4054  // FIXME: This is all horribly hacky. We really need a better way to deal
4055  // with optional operands like this in the matcher table.
4056
4057  // The 'mov' mnemonic is special. One variant has a cc_out operand, while
4058  // another does not. Specifically, the MOVW instruction does not. So we
4059  // special case it here and remove the defaulted (non-setting) cc_out
4060  // operand if that's the instruction we're trying to match.
4061  //
4062  // We do this as post-processing of the explicit operands rather than just
4063  // conditionally adding the cc_out in the first place because we need
4064  // to check the type of the parsed immediate operand.
4065  if (Mnemonic == "mov" && Operands.size() > 4 && !isThumb() &&
4066      !static_cast<ARMOperand*>(Operands[4])->isARMSOImm() &&
4067      static_cast<ARMOperand*>(Operands[4])->isImm0_65535Expr() &&
4068      static_cast<ARMOperand*>(Operands[1])->getReg() == 0)
4069    return true;
4070
4071  // Register-register 'add' for thumb does not have a cc_out operand
4072  // when there are only two register operands.
4073  if (isThumb() && Mnemonic == "add" && Operands.size() == 5 &&
4074      static_cast<ARMOperand*>(Operands[3])->isReg() &&
4075      static_cast<ARMOperand*>(Operands[4])->isReg() &&
4076      static_cast<ARMOperand*>(Operands[1])->getReg() == 0)
4077    return true;
4078  // Register-register 'add' for thumb does not have a cc_out operand
4079  // when it's an ADD Rdm, SP, {Rdm|#imm0_255} instruction. We do
4080  // have to check the immediate range here since Thumb2 has a variant
4081  // that can handle a different range and has a cc_out operand.
4082  if (((isThumb() && Mnemonic == "add") ||
4083       (isThumbTwo() && Mnemonic == "sub")) &&
4084      Operands.size() == 6 &&
4085      static_cast<ARMOperand*>(Operands[3])->isReg() &&
4086      static_cast<ARMOperand*>(Operands[4])->isReg() &&
4087      static_cast<ARMOperand*>(Operands[4])->getReg() == ARM::SP &&
4088      static_cast<ARMOperand*>(Operands[1])->getReg() == 0 &&
4089      (static_cast<ARMOperand*>(Operands[5])->isReg() ||
4090       static_cast<ARMOperand*>(Operands[5])->isImm0_1020s4()))
4091    return true;
4092  // For Thumb2, add/sub immediate does not have a cc_out operand for the
4093  // imm0_4095 variant. That's the least-preferred variant when
4094  // selecting via the generic "add" mnemonic, so to know that we
4095  // should remove the cc_out operand, we have to explicitly check that
4096  // it's not one of the other variants. Ugh.
4097  if (isThumbTwo() && (Mnemonic == "add" || Mnemonic == "sub") &&
4098      Operands.size() == 6 &&
4099      static_cast<ARMOperand*>(Operands[3])->isReg() &&
4100      static_cast<ARMOperand*>(Operands[4])->isReg() &&
4101      static_cast<ARMOperand*>(Operands[5])->isImm()) {
4102    // Nest conditions rather than one big 'if' statement for readability.
4103    //
4104    // If either register is a high reg, it's either one of the SP
4105    // variants (handled above) or a 32-bit encoding, so we just
4106    // check against T3.
4107    if ((!isARMLowRegister(static_cast<ARMOperand*>(Operands[3])->getReg()) ||
4108         !isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg())) &&
4109        static_cast<ARMOperand*>(Operands[5])->isT2SOImm())
4110      return false;
4111    // If both registers are low, we're in an IT block, and the immediate is
4112    // in range, we should use encoding T1 instead, which has a cc_out.
4113    if (inITBlock() &&
4114        isARMLowRegister(static_cast<ARMOperand*>(Operands[3])->getReg()) &&
4115        isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg()) &&
4116        static_cast<ARMOperand*>(Operands[5])->isImm0_7())
4117      return false;
4118
4119    // Otherwise, we use encoding T4, which does not have a cc_out
4120    // operand.
4121    return true;
4122  }
4123
4124  // The thumb2 multiply instruction doesn't have a CCOut register, so
4125  // if we have a "mul" mnemonic in Thumb mode, check if we'll be able to
4126  // use the 16-bit encoding or not.
4127  if (isThumbTwo() && Mnemonic == "mul" && Operands.size() == 6 &&
4128      static_cast<ARMOperand*>(Operands[1])->getReg() == 0 &&
4129      static_cast<ARMOperand*>(Operands[3])->isReg() &&
4130      static_cast<ARMOperand*>(Operands[4])->isReg() &&
4131      static_cast<ARMOperand*>(Operands[5])->isReg() &&
4132      // If the registers aren't low regs, the destination reg isn't the
4133      // same as one of the source regs, or the cc_out operand is zero
4134      // outside of an IT block, we have to use the 32-bit encoding, so
4135      // remove the cc_out operand.
4136      (!isARMLowRegister(static_cast<ARMOperand*>(Operands[3])->getReg()) ||
4137       !isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg()) ||
4138       !inITBlock() ||
4139       (static_cast<ARMOperand*>(Operands[3])->getReg() !=
4140        static_cast<ARMOperand*>(Operands[5])->getReg() &&
4141        static_cast<ARMOperand*>(Operands[3])->getReg() !=
4142        static_cast<ARMOperand*>(Operands[4])->getReg())))
4143    return true;
4144
4145
4146
4147  // Register-register 'add/sub' for thumb does not have a cc_out operand
4148  // when it's an ADD/SUB SP, #imm. Be lenient on count since there's also
4149  // the "add/sub SP, SP, #imm" version. If the follow-up operands aren't
4150  // right, this will result in better diagnostics (which operand is off)
4151  // anyway.
4152  if (isThumb() && (Mnemonic == "add" || Mnemonic == "sub") &&
4153      (Operands.size() == 5 || Operands.size() == 6) &&
4154      static_cast<ARMOperand*>(Operands[3])->isReg() &&
4155      static_cast<ARMOperand*>(Operands[3])->getReg() == ARM::SP &&
4156      static_cast<ARMOperand*>(Operands[1])->getReg() == 0)
4157    return true;
4158
4159  return false;
4160}
4161
4162/// Parse an arm instruction mnemonic followed by its operands.
4163bool ARMAsmParser::ParseInstruction(StringRef Name, SMLoc NameLoc,
4164                               SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
4165  // Create the leading tokens for the mnemonic, split by '.' characters.
4166  size_t Start = 0, Next = Name.find('.');
4167  StringRef Mnemonic = Name.slice(Start, Next);
4168
4169  // Split out the predication code and carry setting flag from the mnemonic.
4170  unsigned PredicationCode;
4171  unsigned ProcessorIMod;
4172  bool CarrySetting;
4173  StringRef ITMask;
4174  Mnemonic = splitMnemonic(Mnemonic, PredicationCode, CarrySetting,
4175                           ProcessorIMod, ITMask);
4176
4177  // In Thumb1, only the branch (B) instruction can be predicated.
4178  if (isThumbOne() && PredicationCode != ARMCC::AL && Mnemonic != "b") {
4179    Parser.EatToEndOfStatement();
4180    return Error(NameLoc, "conditional execution not supported in Thumb1");
4181  }
4182
4183  Operands.push_back(ARMOperand::CreateToken(Mnemonic, NameLoc));
4184
4185  // Handle the IT instruction ITMask. Convert it to a bitmask. This
4186  // is the mask as it will be for the IT encoding if the conditional
4187  // encoding has a '1' as it's bit0 (i.e. 't' ==> '1'). In the case
4188  // where the conditional bit0 is zero, the instruction post-processing
4189  // will adjust the mask accordingly.
4190  if (Mnemonic == "it") {
4191    SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + 2);
4192    if (ITMask.size() > 3) {
4193      Parser.EatToEndOfStatement();
4194      return Error(Loc, "too many conditions on IT instruction");
4195    }
4196    unsigned Mask = 8;
4197    for (unsigned i = ITMask.size(); i != 0; --i) {
4198      char pos = ITMask[i - 1];
4199      if (pos != 't' && pos != 'e') {
4200        Parser.EatToEndOfStatement();
4201        return Error(Loc, "illegal IT block condition mask '" + ITMask + "'");
4202      }
4203      Mask >>= 1;
4204      if (ITMask[i - 1] == 't')
4205        Mask |= 8;
4206    }
4207    Operands.push_back(ARMOperand::CreateITMask(Mask, Loc));
4208  }
4209
4210  // FIXME: This is all a pretty gross hack. We should automatically handle
4211  // optional operands like this via tblgen.
4212
4213  // Next, add the CCOut and ConditionCode operands, if needed.
4214  //
4215  // For mnemonics which can ever incorporate a carry setting bit or predication
4216  // code, our matching model involves us always generating CCOut and
4217  // ConditionCode operands to match the mnemonic "as written" and then we let
4218  // the matcher deal with finding the right instruction or generating an
4219  // appropriate error.
4220  bool CanAcceptCarrySet, CanAcceptPredicationCode;
4221  getMnemonicAcceptInfo(Mnemonic, CanAcceptCarrySet, CanAcceptPredicationCode);
4222
4223  // If we had a carry-set on an instruction that can't do that, issue an
4224  // error.
4225  if (!CanAcceptCarrySet && CarrySetting) {
4226    Parser.EatToEndOfStatement();
4227    return Error(NameLoc, "instruction '" + Mnemonic +
4228                 "' can not set flags, but 's' suffix specified");
4229  }
4230  // If we had a predication code on an instruction that can't do that, issue an
4231  // error.
4232  if (!CanAcceptPredicationCode && PredicationCode != ARMCC::AL) {
4233    Parser.EatToEndOfStatement();
4234    return Error(NameLoc, "instruction '" + Mnemonic +
4235                 "' is not predicable, but condition code specified");
4236  }
4237
4238  // Add the carry setting operand, if necessary.
4239  if (CanAcceptCarrySet) {
4240    SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size());
4241    Operands.push_back(ARMOperand::CreateCCOut(CarrySetting ? ARM::CPSR : 0,
4242                                               Loc));
4243  }
4244
4245  // Add the predication code operand, if necessary.
4246  if (CanAcceptPredicationCode) {
4247    SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size() +
4248                                      CarrySetting);
4249    Operands.push_back(ARMOperand::CreateCondCode(
4250                         ARMCC::CondCodes(PredicationCode), Loc));
4251  }
4252
4253  // Add the processor imod operand, if necessary.
4254  if (ProcessorIMod) {
4255    Operands.push_back(ARMOperand::CreateImm(
4256          MCConstantExpr::Create(ProcessorIMod, getContext()),
4257                                 NameLoc, NameLoc));
4258  }
4259
4260  // Add the remaining tokens in the mnemonic.
4261  while (Next != StringRef::npos) {
4262    Start = Next;
4263    Next = Name.find('.', Start + 1);
4264    StringRef ExtraToken = Name.slice(Start, Next);
4265
4266    // For now, we're only parsing Thumb1 (for the most part), so
4267    // just ignore ".n" qualifiers. We'll use them to restrict
4268    // matching when we do Thumb2.
4269    if (ExtraToken != ".n") {
4270      SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Start);
4271      Operands.push_back(ARMOperand::CreateToken(ExtraToken, Loc));
4272    }
4273  }
4274
4275  // Read the remaining operands.
4276  if (getLexer().isNot(AsmToken::EndOfStatement)) {
4277    // Read the first operand.
4278    if (parseOperand(Operands, Mnemonic)) {
4279      Parser.EatToEndOfStatement();
4280      return true;
4281    }
4282
4283    while (getLexer().is(AsmToken::Comma)) {
4284      Parser.Lex();  // Eat the comma.
4285
4286      // Parse and remember the operand.
4287      if (parseOperand(Operands, Mnemonic)) {
4288        Parser.EatToEndOfStatement();
4289        return true;
4290      }
4291    }
4292  }
4293
4294  if (getLexer().isNot(AsmToken::EndOfStatement)) {
4295    SMLoc Loc = getLexer().getLoc();
4296    Parser.EatToEndOfStatement();
4297    return Error(Loc, "unexpected token in argument list");
4298  }
4299
4300  Parser.Lex(); // Consume the EndOfStatement
4301
4302  // Some instructions, mostly Thumb, have forms for the same mnemonic that
4303  // do and don't have a cc_out optional-def operand. With some spot-checks
4304  // of the operand list, we can figure out which variant we're trying to
4305  // parse and adjust accordingly before actually matching. We shouldn't ever
4306  // try to remove a cc_out operand that was explicitly set on the the
4307  // mnemonic, of course (CarrySetting == true). Reason number #317 the
4308  // table driven matcher doesn't fit well with the ARM instruction set.
4309  if (!CarrySetting && shouldOmitCCOutOperand(Mnemonic, Operands)) {
4310    ARMOperand *Op = static_cast<ARMOperand*>(Operands[1]);
4311    Operands.erase(Operands.begin() + 1);
4312    delete Op;
4313  }
4314
4315  // ARM mode 'blx' need special handling, as the register operand version
4316  // is predicable, but the label operand version is not. So, we can't rely
4317  // on the Mnemonic based checking to correctly figure out when to put
4318  // a k_CondCode operand in the list. If we're trying to match the label
4319  // version, remove the k_CondCode operand here.
4320  if (!isThumb() && Mnemonic == "blx" && Operands.size() == 3 &&
4321      static_cast<ARMOperand*>(Operands[2])->isImm()) {
4322    ARMOperand *Op = static_cast<ARMOperand*>(Operands[1]);
4323    Operands.erase(Operands.begin() + 1);
4324    delete Op;
4325  }
4326
4327  // The vector-compare-to-zero instructions have a literal token "#0" at
4328  // the end that comes to here as an immediate operand. Convert it to a
4329  // token to play nicely with the matcher.
4330  if ((Mnemonic == "vceq" || Mnemonic == "vcge" || Mnemonic == "vcgt" ||
4331      Mnemonic == "vcle" || Mnemonic == "vclt") && Operands.size() == 6 &&
4332      static_cast<ARMOperand*>(Operands[5])->isImm()) {
4333    ARMOperand *Op = static_cast<ARMOperand*>(Operands[5]);
4334    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Op->getImm());
4335    if (CE && CE->getValue() == 0) {
4336      Operands.erase(Operands.begin() + 5);
4337      Operands.push_back(ARMOperand::CreateToken("#0", Op->getStartLoc()));
4338      delete Op;
4339    }
4340  }
4341  // VCMP{E} does the same thing, but with a different operand count.
4342  if ((Mnemonic == "vcmp" || Mnemonic == "vcmpe") && Operands.size() == 5 &&
4343      static_cast<ARMOperand*>(Operands[4])->isImm()) {
4344    ARMOperand *Op = static_cast<ARMOperand*>(Operands[4]);
4345    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Op->getImm());
4346    if (CE && CE->getValue() == 0) {
4347      Operands.erase(Operands.begin() + 4);
4348      Operands.push_back(ARMOperand::CreateToken("#0", Op->getStartLoc()));
4349      delete Op;
4350    }
4351  }
4352  // Similarly, the Thumb1 "RSB" instruction has a literal "#0" on the
4353  // end. Convert it to a token here.
4354  if (Mnemonic == "rsb" && isThumb() && Operands.size() == 6 &&
4355      static_cast<ARMOperand*>(Operands[5])->isImm()) {
4356    ARMOperand *Op = static_cast<ARMOperand*>(Operands[5]);
4357    const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Op->getImm());
4358    if (CE && CE->getValue() == 0) {
4359      Operands.erase(Operands.begin() + 5);
4360      Operands.push_back(ARMOperand::CreateToken("#0", Op->getStartLoc()));
4361      delete Op;
4362    }
4363  }
4364
4365  return false;
4366}
4367
4368// Validate context-sensitive operand constraints.
4369
4370// return 'true' if register list contains non-low GPR registers,
4371// 'false' otherwise. If Reg is in the register list or is HiReg, set
4372// 'containsReg' to true.
4373static bool checkLowRegisterList(MCInst Inst, unsigned OpNo, unsigned Reg,
4374                                 unsigned HiReg, bool &containsReg) {
4375  containsReg = false;
4376  for (unsigned i = OpNo; i < Inst.getNumOperands(); ++i) {
4377    unsigned OpReg = Inst.getOperand(i).getReg();
4378    if (OpReg == Reg)
4379      containsReg = true;
4380    // Anything other than a low register isn't legal here.
4381    if (!isARMLowRegister(OpReg) && (!HiReg || OpReg != HiReg))
4382      return true;
4383  }
4384  return false;
4385}
4386
4387// Check if the specified regisgter is in the register list of the inst,
4388// starting at the indicated operand number.
4389static bool listContainsReg(MCInst &Inst, unsigned OpNo, unsigned Reg) {
4390  for (unsigned i = OpNo; i < Inst.getNumOperands(); ++i) {
4391    unsigned OpReg = Inst.getOperand(i).getReg();
4392    if (OpReg == Reg)
4393      return true;
4394  }
4395  return false;
4396}
4397
4398// FIXME: We would really prefer to have MCInstrInfo (the wrapper around
4399// the ARMInsts array) instead. Getting that here requires awkward
4400// API changes, though. Better way?
4401namespace llvm {
4402extern const MCInstrDesc ARMInsts[];
4403}
4404static const MCInstrDesc &getInstDesc(unsigned Opcode) {
4405  return ARMInsts[Opcode];
4406}
4407
4408// FIXME: We would really like to be able to tablegen'erate this.
4409bool ARMAsmParser::
4410validateInstruction(MCInst &Inst,
4411                    const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
4412  const MCInstrDesc &MCID = getInstDesc(Inst.getOpcode());
4413  SMLoc Loc = Operands[0]->getStartLoc();
4414  // Check the IT block state first.
4415  // NOTE: In Thumb mode, the BKPT instruction has the interesting property of
4416  // being allowed in IT blocks, but not being predicable.  It just always
4417  // executes.
4418  if (inITBlock() && Inst.getOpcode() != ARM::tBKPT) {
4419    unsigned bit = 1;
4420    if (ITState.FirstCond)
4421      ITState.FirstCond = false;
4422    else
4423      bit = (ITState.Mask >> (5 - ITState.CurPosition)) & 1;
4424    // The instruction must be predicable.
4425    if (!MCID.isPredicable())
4426      return Error(Loc, "instructions in IT block must be predicable");
4427    unsigned Cond = Inst.getOperand(MCID.findFirstPredOperandIdx()).getImm();
4428    unsigned ITCond = bit ? ITState.Cond :
4429      ARMCC::getOppositeCondition(ITState.Cond);
4430    if (Cond != ITCond) {
4431      // Find the condition code Operand to get its SMLoc information.
4432      SMLoc CondLoc;
4433      for (unsigned i = 1; i < Operands.size(); ++i)
4434        if (static_cast<ARMOperand*>(Operands[i])->isCondCode())
4435          CondLoc = Operands[i]->getStartLoc();
4436      return Error(CondLoc, "incorrect condition in IT block; got '" +
4437                   StringRef(ARMCondCodeToString(ARMCC::CondCodes(Cond))) +
4438                   "', but expected '" +
4439                   ARMCondCodeToString(ARMCC::CondCodes(ITCond)) + "'");
4440    }
4441  // Check for non-'al' condition codes outside of the IT block.
4442  } else if (isThumbTwo() && MCID.isPredicable() &&
4443             Inst.getOperand(MCID.findFirstPredOperandIdx()).getImm() !=
4444             ARMCC::AL && Inst.getOpcode() != ARM::tB &&
4445             Inst.getOpcode() != ARM::t2B)
4446    return Error(Loc, "predicated instructions must be in IT block");
4447
4448  switch (Inst.getOpcode()) {
4449  case ARM::LDRD:
4450  case ARM::LDRD_PRE:
4451  case ARM::LDRD_POST:
4452  case ARM::LDREXD: {
4453    // Rt2 must be Rt + 1.
4454    unsigned Rt = getARMRegisterNumbering(Inst.getOperand(0).getReg());
4455    unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(1).getReg());
4456    if (Rt2 != Rt + 1)
4457      return Error(Operands[3]->getStartLoc(),
4458                   "destination operands must be sequential");
4459    return false;
4460  }
4461  case ARM::STRD: {
4462    // Rt2 must be Rt + 1.
4463    unsigned Rt = getARMRegisterNumbering(Inst.getOperand(0).getReg());
4464    unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(1).getReg());
4465    if (Rt2 != Rt + 1)
4466      return Error(Operands[3]->getStartLoc(),
4467                   "source operands must be sequential");
4468    return false;
4469  }
4470  case ARM::STRD_PRE:
4471  case ARM::STRD_POST:
4472  case ARM::STREXD: {
4473    // Rt2 must be Rt + 1.
4474    unsigned Rt = getARMRegisterNumbering(Inst.getOperand(1).getReg());
4475    unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(2).getReg());
4476    if (Rt2 != Rt + 1)
4477      return Error(Operands[3]->getStartLoc(),
4478                   "source operands must be sequential");
4479    return false;
4480  }
4481  case ARM::SBFX:
4482  case ARM::UBFX: {
4483    // width must be in range [1, 32-lsb]
4484    unsigned lsb = Inst.getOperand(2).getImm();
4485    unsigned widthm1 = Inst.getOperand(3).getImm();
4486    if (widthm1 >= 32 - lsb)
4487      return Error(Operands[5]->getStartLoc(),
4488                   "bitfield width must be in range [1,32-lsb]");
4489    return false;
4490  }
4491  case ARM::tLDMIA: {
4492    // If we're parsing Thumb2, the .w variant is available and handles
4493    // most cases that are normally illegal for a Thumb1 LDM
4494    // instruction. We'll make the transformation in processInstruction()
4495    // if necessary.
4496    //
4497    // Thumb LDM instructions are writeback iff the base register is not
4498    // in the register list.
4499    unsigned Rn = Inst.getOperand(0).getReg();
4500    bool hasWritebackToken =
4501      (static_cast<ARMOperand*>(Operands[3])->isToken() &&
4502       static_cast<ARMOperand*>(Operands[3])->getToken() == "!");
4503    bool listContainsBase;
4504    if (checkLowRegisterList(Inst, 3, Rn, 0, listContainsBase) && !isThumbTwo())
4505      return Error(Operands[3 + hasWritebackToken]->getStartLoc(),
4506                   "registers must be in range r0-r7");
4507    // If we should have writeback, then there should be a '!' token.
4508    if (!listContainsBase && !hasWritebackToken && !isThumbTwo())
4509      return Error(Operands[2]->getStartLoc(),
4510                   "writeback operator '!' expected");
4511    // If we should not have writeback, there must not be a '!'. This is
4512    // true even for the 32-bit wide encodings.
4513    if (listContainsBase && hasWritebackToken)
4514      return Error(Operands[3]->getStartLoc(),
4515                   "writeback operator '!' not allowed when base register "
4516                   "in register list");
4517
4518    break;
4519  }
4520  case ARM::t2LDMIA_UPD: {
4521    if (listContainsReg(Inst, 3, Inst.getOperand(0).getReg()))
4522      return Error(Operands[4]->getStartLoc(),
4523                   "writeback operator '!' not allowed when base register "
4524                   "in register list");
4525    break;
4526  }
4527  case ARM::tPOP: {
4528    bool listContainsBase;
4529    if (checkLowRegisterList(Inst, 3, 0, ARM::PC, listContainsBase))
4530      return Error(Operands[2]->getStartLoc(),
4531                   "registers must be in range r0-r7 or pc");
4532    break;
4533  }
4534  case ARM::tPUSH: {
4535    bool listContainsBase;
4536    if (checkLowRegisterList(Inst, 3, 0, ARM::LR, listContainsBase))
4537      return Error(Operands[2]->getStartLoc(),
4538                   "registers must be in range r0-r7 or lr");
4539    break;
4540  }
4541  case ARM::tSTMIA_UPD: {
4542    bool listContainsBase;
4543    if (checkLowRegisterList(Inst, 4, 0, 0, listContainsBase) && !isThumbTwo())
4544      return Error(Operands[4]->getStartLoc(),
4545                   "registers must be in range r0-r7");
4546    break;
4547  }
4548  }
4549
4550  return false;
4551}
4552
4553void ARMAsmParser::
4554processInstruction(MCInst &Inst,
4555                   const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
4556  switch (Inst.getOpcode()) {
4557  // Handle the MOV complex aliases.
4558  case ARM::ASRi:
4559  case ARM::LSRi:
4560  case ARM::LSLi:
4561  case ARM::RORi: {
4562    ARM_AM::ShiftOpc ShiftTy;
4563    unsigned Amt = Inst.getOperand(2).getImm();
4564    switch(Inst.getOpcode()) {
4565    default: llvm_unreachable("unexpected opcode!");
4566    case ARM::ASRi: ShiftTy = ARM_AM::asr; break;
4567    case ARM::LSRi: ShiftTy = ARM_AM::lsr; break;
4568    case ARM::LSLi: ShiftTy = ARM_AM::lsl; break;
4569    case ARM::RORi: ShiftTy = ARM_AM::ror; break;
4570    }
4571    // A shift by zero is a plain MOVr, not a MOVsi.
4572    unsigned Opc = Amt == 0 ? ARM::MOVr : ARM::MOVsi;
4573    unsigned Shifter = ARM_AM::getSORegOpc(ShiftTy, Amt);
4574    MCInst TmpInst;
4575    TmpInst.setOpcode(Opc);
4576    TmpInst.addOperand(Inst.getOperand(0)); // Rd
4577    TmpInst.addOperand(Inst.getOperand(1)); // Rn
4578    if (Opc == ARM::MOVsi)
4579      TmpInst.addOperand(MCOperand::CreateImm(Shifter)); // Shift value and ty
4580    TmpInst.addOperand(Inst.getOperand(3)); // CondCode
4581    TmpInst.addOperand(Inst.getOperand(4));
4582    TmpInst.addOperand(Inst.getOperand(5)); // cc_out
4583    Inst = TmpInst;
4584    break;
4585  }
4586  case ARM::LDMIA_UPD:
4587    // If this is a load of a single register via a 'pop', then we should use
4588    // a post-indexed LDR instruction instead, per the ARM ARM.
4589    if (static_cast<ARMOperand*>(Operands[0])->getToken() == "pop" &&
4590        Inst.getNumOperands() == 5) {
4591      MCInst TmpInst;
4592      TmpInst.setOpcode(ARM::LDR_POST_IMM);
4593      TmpInst.addOperand(Inst.getOperand(4)); // Rt
4594      TmpInst.addOperand(Inst.getOperand(0)); // Rn_wb
4595      TmpInst.addOperand(Inst.getOperand(1)); // Rn
4596      TmpInst.addOperand(MCOperand::CreateReg(0));  // am2offset
4597      TmpInst.addOperand(MCOperand::CreateImm(4));
4598      TmpInst.addOperand(Inst.getOperand(2)); // CondCode
4599      TmpInst.addOperand(Inst.getOperand(3));
4600      Inst = TmpInst;
4601    }
4602    break;
4603  case ARM::STMDB_UPD:
4604    // If this is a store of a single register via a 'push', then we should use
4605    // a pre-indexed STR instruction instead, per the ARM ARM.
4606    if (static_cast<ARMOperand*>(Operands[0])->getToken() == "push" &&
4607        Inst.getNumOperands() == 5) {
4608      MCInst TmpInst;
4609      TmpInst.setOpcode(ARM::STR_PRE_IMM);
4610      TmpInst.addOperand(Inst.getOperand(0)); // Rn_wb
4611      TmpInst.addOperand(Inst.getOperand(4)); // Rt
4612      TmpInst.addOperand(Inst.getOperand(1)); // addrmode_imm12
4613      TmpInst.addOperand(MCOperand::CreateImm(-4));
4614      TmpInst.addOperand(Inst.getOperand(2)); // CondCode
4615      TmpInst.addOperand(Inst.getOperand(3));
4616      Inst = TmpInst;
4617    }
4618    break;
4619  case ARM::tADDi8:
4620    // If the immediate is in the range 0-7, we want tADDi3 iff Rd was
4621    // explicitly specified. From the ARM ARM: "Encoding T1 is preferred
4622    // to encoding T2 if <Rd> is specified and encoding T2 is preferred
4623    // to encoding T1 if <Rd> is omitted."
4624    if (Inst.getOperand(3).getImm() < 8 && Operands.size() == 6)
4625      Inst.setOpcode(ARM::tADDi3);
4626    break;
4627  case ARM::tSUBi8:
4628    // If the immediate is in the range 0-7, we want tADDi3 iff Rd was
4629    // explicitly specified. From the ARM ARM: "Encoding T1 is preferred
4630    // to encoding T2 if <Rd> is specified and encoding T2 is preferred
4631    // to encoding T1 if <Rd> is omitted."
4632    if (Inst.getOperand(3).getImm() < 8 && Operands.size() == 6)
4633      Inst.setOpcode(ARM::tSUBi3);
4634    break;
4635  case ARM::tB:
4636    // A Thumb conditional branch outside of an IT block is a tBcc.
4637    if (Inst.getOperand(1).getImm() != ARMCC::AL && !inITBlock())
4638      Inst.setOpcode(ARM::tBcc);
4639    break;
4640  case ARM::t2B:
4641    // A Thumb2 conditional branch outside of an IT block is a t2Bcc.
4642    if (Inst.getOperand(1).getImm() != ARMCC::AL && !inITBlock())
4643      Inst.setOpcode(ARM::t2Bcc);
4644    break;
4645  case ARM::t2Bcc:
4646    // If the conditional is AL or we're in an IT block, we really want t2B.
4647    if (Inst.getOperand(1).getImm() == ARMCC::AL || inITBlock())
4648      Inst.setOpcode(ARM::t2B);
4649    break;
4650  case ARM::tBcc:
4651    // If the conditional is AL, we really want tB.
4652    if (Inst.getOperand(1).getImm() == ARMCC::AL)
4653      Inst.setOpcode(ARM::tB);
4654    break;
4655  case ARM::tLDMIA: {
4656    // If the register list contains any high registers, or if the writeback
4657    // doesn't match what tLDMIA can do, we need to use the 32-bit encoding
4658    // instead if we're in Thumb2. Otherwise, this should have generated
4659    // an error in validateInstruction().
4660    unsigned Rn = Inst.getOperand(0).getReg();
4661    bool hasWritebackToken =
4662      (static_cast<ARMOperand*>(Operands[3])->isToken() &&
4663       static_cast<ARMOperand*>(Operands[3])->getToken() == "!");
4664    bool listContainsBase;
4665    if (checkLowRegisterList(Inst, 3, Rn, 0, listContainsBase) ||
4666        (!listContainsBase && !hasWritebackToken) ||
4667        (listContainsBase && hasWritebackToken)) {
4668      // 16-bit encoding isn't sufficient. Switch to the 32-bit version.
4669      assert (isThumbTwo());
4670      Inst.setOpcode(hasWritebackToken ? ARM::t2LDMIA_UPD : ARM::t2LDMIA);
4671      // If we're switching to the updating version, we need to insert
4672      // the writeback tied operand.
4673      if (hasWritebackToken)
4674        Inst.insert(Inst.begin(),
4675                    MCOperand::CreateReg(Inst.getOperand(0).getReg()));
4676    }
4677    break;
4678  }
4679  case ARM::tSTMIA_UPD: {
4680    // If the register list contains any high registers, we need to use
4681    // the 32-bit encoding instead if we're in Thumb2. Otherwise, this
4682    // should have generated an error in validateInstruction().
4683    unsigned Rn = Inst.getOperand(0).getReg();
4684    bool listContainsBase;
4685    if (checkLowRegisterList(Inst, 4, Rn, 0, listContainsBase)) {
4686      // 16-bit encoding isn't sufficient. Switch to the 32-bit version.
4687      assert (isThumbTwo());
4688      Inst.setOpcode(ARM::t2STMIA_UPD);
4689    }
4690    break;
4691  }
4692  case ARM::t2MOVi: {
4693    // If we can use the 16-bit encoding and the user didn't explicitly
4694    // request the 32-bit variant, transform it here.
4695    if (isARMLowRegister(Inst.getOperand(0).getReg()) &&
4696        Inst.getOperand(1).getImm() <= 255 &&
4697        ((!inITBlock() && Inst.getOperand(2).getImm() == ARMCC::AL &&
4698         Inst.getOperand(4).getReg() == ARM::CPSR) ||
4699        (inITBlock() && Inst.getOperand(4).getReg() == 0)) &&
4700        (!static_cast<ARMOperand*>(Operands[2])->isToken() ||
4701         static_cast<ARMOperand*>(Operands[2])->getToken() != ".w")) {
4702      // The operands aren't in the same order for tMOVi8...
4703      MCInst TmpInst;
4704      TmpInst.setOpcode(ARM::tMOVi8);
4705      TmpInst.addOperand(Inst.getOperand(0));
4706      TmpInst.addOperand(Inst.getOperand(4));
4707      TmpInst.addOperand(Inst.getOperand(1));
4708      TmpInst.addOperand(Inst.getOperand(2));
4709      TmpInst.addOperand(Inst.getOperand(3));
4710      Inst = TmpInst;
4711    }
4712    break;
4713  }
4714  case ARM::t2MOVr: {
4715    // If we can use the 16-bit encoding and the user didn't explicitly
4716    // request the 32-bit variant, transform it here.
4717    if (isARMLowRegister(Inst.getOperand(0).getReg()) &&
4718        isARMLowRegister(Inst.getOperand(1).getReg()) &&
4719        Inst.getOperand(2).getImm() == ARMCC::AL &&
4720        Inst.getOperand(4).getReg() == ARM::CPSR &&
4721        (!static_cast<ARMOperand*>(Operands[2])->isToken() ||
4722         static_cast<ARMOperand*>(Operands[2])->getToken() != ".w")) {
4723      // The operands aren't the same for tMOV[S]r... (no cc_out)
4724      MCInst TmpInst;
4725      TmpInst.setOpcode(Inst.getOperand(4).getReg() ? ARM::tMOVSr : ARM::tMOVr);
4726      TmpInst.addOperand(Inst.getOperand(0));
4727      TmpInst.addOperand(Inst.getOperand(1));
4728      TmpInst.addOperand(Inst.getOperand(2));
4729      TmpInst.addOperand(Inst.getOperand(3));
4730      Inst = TmpInst;
4731    }
4732    break;
4733  }
4734  case ARM::t2SXTH:
4735  case ARM::t2SXTB:
4736  case ARM::t2UXTH:
4737  case ARM::t2UXTB: {
4738    // If we can use the 16-bit encoding and the user didn't explicitly
4739    // request the 32-bit variant, transform it here.
4740    if (isARMLowRegister(Inst.getOperand(0).getReg()) &&
4741        isARMLowRegister(Inst.getOperand(1).getReg()) &&
4742        Inst.getOperand(2).getImm() == 0 &&
4743        (!static_cast<ARMOperand*>(Operands[2])->isToken() ||
4744         static_cast<ARMOperand*>(Operands[2])->getToken() != ".w")) {
4745      unsigned NewOpc;
4746      switch (Inst.getOpcode()) {
4747      default: llvm_unreachable("Illegal opcode!");
4748      case ARM::t2SXTH: NewOpc = ARM::tSXTH; break;
4749      case ARM::t2SXTB: NewOpc = ARM::tSXTB; break;
4750      case ARM::t2UXTH: NewOpc = ARM::tUXTH; break;
4751      case ARM::t2UXTB: NewOpc = ARM::tUXTB; break;
4752      }
4753      // The operands aren't the same for thumb1 (no rotate operand).
4754      MCInst TmpInst;
4755      TmpInst.setOpcode(NewOpc);
4756      TmpInst.addOperand(Inst.getOperand(0));
4757      TmpInst.addOperand(Inst.getOperand(1));
4758      TmpInst.addOperand(Inst.getOperand(3));
4759      TmpInst.addOperand(Inst.getOperand(4));
4760      Inst = TmpInst;
4761    }
4762    break;
4763  }
4764  case ARM::t2IT: {
4765    // The mask bits for all but the first condition are represented as
4766    // the low bit of the condition code value implies 't'. We currently
4767    // always have 1 implies 't', so XOR toggle the bits if the low bit
4768    // of the condition code is zero. The encoding also expects the low
4769    // bit of the condition to be encoded as bit 4 of the mask operand,
4770    // so mask that in if needed
4771    MCOperand &MO = Inst.getOperand(1);
4772    unsigned Mask = MO.getImm();
4773    unsigned OrigMask = Mask;
4774    unsigned TZ = CountTrailingZeros_32(Mask);
4775    if ((Inst.getOperand(0).getImm() & 1) == 0) {
4776      assert(Mask && TZ <= 3 && "illegal IT mask value!");
4777      for (unsigned i = 3; i != TZ; --i)
4778        Mask ^= 1 << i;
4779    } else
4780      Mask |= 0x10;
4781    MO.setImm(Mask);
4782
4783    // Set up the IT block state according to the IT instruction we just
4784    // matched.
4785    assert(!inITBlock() && "nested IT blocks?!");
4786    ITState.Cond = ARMCC::CondCodes(Inst.getOperand(0).getImm());
4787    ITState.Mask = OrigMask; // Use the original mask, not the updated one.
4788    ITState.CurPosition = 0;
4789    ITState.FirstCond = true;
4790    break;
4791  }
4792  }
4793}
4794
4795unsigned ARMAsmParser::checkTargetMatchPredicate(MCInst &Inst) {
4796  // 16-bit thumb arithmetic instructions either require or preclude the 'S'
4797  // suffix depending on whether they're in an IT block or not.
4798  unsigned Opc = Inst.getOpcode();
4799  const MCInstrDesc &MCID = getInstDesc(Opc);
4800  if (MCID.TSFlags & ARMII::ThumbArithFlagSetting) {
4801    assert(MCID.hasOptionalDef() &&
4802           "optionally flag setting instruction missing optional def operand");
4803    assert(MCID.NumOperands == Inst.getNumOperands() &&
4804           "operand count mismatch!");
4805    // Find the optional-def operand (cc_out).
4806    unsigned OpNo;
4807    for (OpNo = 0;
4808         !MCID.OpInfo[OpNo].isOptionalDef() && OpNo < MCID.NumOperands;
4809         ++OpNo)
4810      ;
4811    // If we're parsing Thumb1, reject it completely.
4812    if (isThumbOne() && Inst.getOperand(OpNo).getReg() != ARM::CPSR)
4813      return Match_MnemonicFail;
4814    // If we're parsing Thumb2, which form is legal depends on whether we're
4815    // in an IT block.
4816    if (isThumbTwo() && Inst.getOperand(OpNo).getReg() != ARM::CPSR &&
4817        !inITBlock())
4818      return Match_RequiresITBlock;
4819    if (isThumbTwo() && Inst.getOperand(OpNo).getReg() == ARM::CPSR &&
4820        inITBlock())
4821      return Match_RequiresNotITBlock;
4822  }
4823  // Some high-register supporting Thumb1 encodings only allow both registers
4824  // to be from r0-r7 when in Thumb2.
4825  else if (Opc == ARM::tADDhirr && isThumbOne() &&
4826           isARMLowRegister(Inst.getOperand(1).getReg()) &&
4827           isARMLowRegister(Inst.getOperand(2).getReg()))
4828    return Match_RequiresThumb2;
4829  // Others only require ARMv6 or later.
4830  else if (Opc == ARM::tMOVr && isThumbOne() && !hasV6Ops() &&
4831           isARMLowRegister(Inst.getOperand(0).getReg()) &&
4832           isARMLowRegister(Inst.getOperand(1).getReg()))
4833    return Match_RequiresV6;
4834  return Match_Success;
4835}
4836
4837bool ARMAsmParser::
4838MatchAndEmitInstruction(SMLoc IDLoc,
4839                        SmallVectorImpl<MCParsedAsmOperand*> &Operands,
4840                        MCStreamer &Out) {
4841  MCInst Inst;
4842  unsigned ErrorInfo;
4843  unsigned MatchResult;
4844  MatchResult = MatchInstructionImpl(Operands, Inst, ErrorInfo);
4845  switch (MatchResult) {
4846  default: break;
4847  case Match_Success:
4848    // Context sensitive operand constraints aren't handled by the matcher,
4849    // so check them here.
4850    if (validateInstruction(Inst, Operands)) {
4851      // Still progress the IT block, otherwise one wrong condition causes
4852      // nasty cascading errors.
4853      forwardITPosition();
4854      return true;
4855    }
4856
4857    // Some instructions need post-processing to, for example, tweak which
4858    // encoding is selected.
4859    processInstruction(Inst, Operands);
4860
4861    // Only move forward at the very end so that everything in validate
4862    // and process gets a consistent answer about whether we're in an IT
4863    // block.
4864    forwardITPosition();
4865
4866    Out.EmitInstruction(Inst);
4867    return false;
4868  case Match_MissingFeature:
4869    Error(IDLoc, "instruction requires a CPU feature not currently enabled");
4870    return true;
4871  case Match_InvalidOperand: {
4872    SMLoc ErrorLoc = IDLoc;
4873    if (ErrorInfo != ~0U) {
4874      if (ErrorInfo >= Operands.size())
4875        return Error(IDLoc, "too few operands for instruction");
4876
4877      ErrorLoc = ((ARMOperand*)Operands[ErrorInfo])->getStartLoc();
4878      if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc;
4879    }
4880
4881    return Error(ErrorLoc, "invalid operand for instruction");
4882  }
4883  case Match_MnemonicFail:
4884    return Error(IDLoc, "invalid instruction");
4885  case Match_ConversionFail:
4886    // The converter function will have already emited a diagnostic.
4887    return true;
4888  case Match_RequiresNotITBlock:
4889    return Error(IDLoc, "flag setting instruction only valid outside IT block");
4890  case Match_RequiresITBlock:
4891    return Error(IDLoc, "instruction only valid inside IT block");
4892  case Match_RequiresV6:
4893    return Error(IDLoc, "instruction variant requires ARMv6 or later");
4894  case Match_RequiresThumb2:
4895    return Error(IDLoc, "instruction variant requires Thumb2");
4896  }
4897
4898  llvm_unreachable("Implement any new match types added!");
4899  return true;
4900}
4901
4902/// parseDirective parses the arm specific directives
4903bool ARMAsmParser::ParseDirective(AsmToken DirectiveID) {
4904  StringRef IDVal = DirectiveID.getIdentifier();
4905  if (IDVal == ".word")
4906    return parseDirectiveWord(4, DirectiveID.getLoc());
4907  else if (IDVal == ".thumb")
4908    return parseDirectiveThumb(DirectiveID.getLoc());
4909  else if (IDVal == ".thumb_func")
4910    return parseDirectiveThumbFunc(DirectiveID.getLoc());
4911  else if (IDVal == ".code")
4912    return parseDirectiveCode(DirectiveID.getLoc());
4913  else if (IDVal == ".syntax")
4914    return parseDirectiveSyntax(DirectiveID.getLoc());
4915  return true;
4916}
4917
4918/// parseDirectiveWord
4919///  ::= .word [ expression (, expression)* ]
4920bool ARMAsmParser::parseDirectiveWord(unsigned Size, SMLoc L) {
4921  if (getLexer().isNot(AsmToken::EndOfStatement)) {
4922    for (;;) {
4923      const MCExpr *Value;
4924      if (getParser().ParseExpression(Value))
4925        return true;
4926
4927      getParser().getStreamer().EmitValue(Value, Size, 0/*addrspace*/);
4928
4929      if (getLexer().is(AsmToken::EndOfStatement))
4930        break;
4931
4932      // FIXME: Improve diagnostic.
4933      if (getLexer().isNot(AsmToken::Comma))
4934        return Error(L, "unexpected token in directive");
4935      Parser.Lex();
4936    }
4937  }
4938
4939  Parser.Lex();
4940  return false;
4941}
4942
4943/// parseDirectiveThumb
4944///  ::= .thumb
4945bool ARMAsmParser::parseDirectiveThumb(SMLoc L) {
4946  if (getLexer().isNot(AsmToken::EndOfStatement))
4947    return Error(L, "unexpected token in directive");
4948  Parser.Lex();
4949
4950  // TODO: set thumb mode
4951  // TODO: tell the MC streamer the mode
4952  // getParser().getStreamer().Emit???();
4953  return false;
4954}
4955
4956/// parseDirectiveThumbFunc
4957///  ::= .thumbfunc symbol_name
4958bool ARMAsmParser::parseDirectiveThumbFunc(SMLoc L) {
4959  const MCAsmInfo &MAI = getParser().getStreamer().getContext().getAsmInfo();
4960  bool isMachO = MAI.hasSubsectionsViaSymbols();
4961  StringRef Name;
4962
4963  // Darwin asm has function name after .thumb_func direction
4964  // ELF doesn't
4965  if (isMachO) {
4966    const AsmToken &Tok = Parser.getTok();
4967    if (Tok.isNot(AsmToken::Identifier) && Tok.isNot(AsmToken::String))
4968      return Error(L, "unexpected token in .thumb_func directive");
4969    Name = Tok.getIdentifier();
4970    Parser.Lex(); // Consume the identifier token.
4971  }
4972
4973 if (getLexer().isNot(AsmToken::EndOfStatement))
4974    return Error(L, "unexpected token in directive");
4975  Parser.Lex();
4976
4977  // FIXME: assuming function name will be the line following .thumb_func
4978  if (!isMachO) {
4979    Name = Parser.getTok().getIdentifier();
4980  }
4981
4982  // Mark symbol as a thumb symbol.
4983  MCSymbol *Func = getParser().getContext().GetOrCreateSymbol(Name);
4984  getParser().getStreamer().EmitThumbFunc(Func);
4985  return false;
4986}
4987
4988/// parseDirectiveSyntax
4989///  ::= .syntax unified | divided
4990bool ARMAsmParser::parseDirectiveSyntax(SMLoc L) {
4991  const AsmToken &Tok = Parser.getTok();
4992  if (Tok.isNot(AsmToken::Identifier))
4993    return Error(L, "unexpected token in .syntax directive");
4994  StringRef Mode = Tok.getString();
4995  if (Mode == "unified" || Mode == "UNIFIED")
4996    Parser.Lex();
4997  else if (Mode == "divided" || Mode == "DIVIDED")
4998    return Error(L, "'.syntax divided' arm asssembly not supported");
4999  else
5000    return Error(L, "unrecognized syntax mode in .syntax directive");
5001
5002  if (getLexer().isNot(AsmToken::EndOfStatement))
5003    return Error(Parser.getTok().getLoc(), "unexpected token in directive");
5004  Parser.Lex();
5005
5006  // TODO tell the MC streamer the mode
5007  // getParser().getStreamer().Emit???();
5008  return false;
5009}
5010
5011/// parseDirectiveCode
5012///  ::= .code 16 | 32
5013bool ARMAsmParser::parseDirectiveCode(SMLoc L) {
5014  const AsmToken &Tok = Parser.getTok();
5015  if (Tok.isNot(AsmToken::Integer))
5016    return Error(L, "unexpected token in .code directive");
5017  int64_t Val = Parser.getTok().getIntVal();
5018  if (Val == 16)
5019    Parser.Lex();
5020  else if (Val == 32)
5021    Parser.Lex();
5022  else
5023    return Error(L, "invalid operand to .code directive");
5024
5025  if (getLexer().isNot(AsmToken::EndOfStatement))
5026    return Error(Parser.getTok().getLoc(), "unexpected token in directive");
5027  Parser.Lex();
5028
5029  if (Val == 16) {
5030    if (!isThumb())
5031      SwitchMode();
5032    getParser().getStreamer().EmitAssemblerFlag(MCAF_Code16);
5033  } else {
5034    if (isThumb())
5035      SwitchMode();
5036    getParser().getStreamer().EmitAssemblerFlag(MCAF_Code32);
5037  }
5038
5039  return false;
5040}
5041
5042extern "C" void LLVMInitializeARMAsmLexer();
5043
5044/// Force static initialization.
5045extern "C" void LLVMInitializeARMAsmParser() {
5046  RegisterMCAsmParser<ARMAsmParser> X(TheARMTarget);
5047  RegisterMCAsmParser<ARMAsmParser> Y(TheThumbTarget);
5048  LLVMInitializeARMAsmLexer();
5049}
5050
5051#define GET_REGISTER_MATCHER
5052#define GET_MATCHER_IMPLEMENTATION
5053#include "ARMGenAsmMatcher.inc"
5054