lib/Target/X86/AsmParser/X86AsmParser.cpp

   1 //===-- X86AsmParser.cpp - Parse X86 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 "llvm/Target/TargetAsmParser.h"
  11 #include "X86.h"
  12 #include "X86Subtarget.h"
  13 #include "llvm/Target/TargetRegistry.h"
  14 #include "llvm/Target/TargetAsmParser.h"
  15 #include "llvm/MC/MCStreamer.h"
  16 #include "llvm/MC/MCExpr.h"
  17 #include "llvm/MC/MCInst.h"
  18 #include "llvm/MC/MCParser/MCAsmLexer.h"
  19 #include "llvm/MC/MCParser/MCAsmParser.h"
  20 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  21 #include "llvm/ADT/SmallString.h"
  22 #include "llvm/ADT/SmallVector.h"
  23 #include "llvm/ADT/StringExtras.h"
  24 #include "llvm/ADT/StringSwitch.h"
  25 #include "llvm/ADT/Twine.h"
  26 #include "llvm/Support/SourceMgr.h"
  27 #include "llvm/Support/raw_ostream.h"
  28 using namespace llvm;
  29
  30 namespace {
  31 struct X86Operand;
  32
  33 class X86ATTAsmParser : public TargetAsmParser {
  34   MCAsmParser &Parser;
  35   TargetMachine &TM;
  36
  37 protected:
  38   unsigned Is64Bit : 1;
  39
  40 private:
  41   MCAsmParser &getParser() const { return Parser; }
  42
  43   MCAsmLexer &getLexer() const { return Parser.getLexer(); }
  44
  45   bool Error(SMLoc L, const Twine &Msg) { return Parser.Error(L, Msg); }
  46
  47   bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc);
  48
  49   X86Operand *ParseOperand();
  50   X86Operand *ParseMemOperand(unsigned SegReg, SMLoc StartLoc);
  51
  52   bool ParseDirectiveWord(unsigned Size, SMLoc L);
  53
  54   bool MatchAndEmitInstruction(SMLoc IDLoc,
  55                                SmallVectorImpl<MCParsedAsmOperand*> &Operands,
  56                                MCStreamer &Out);
  57
  58   /// @name Auto-generated Matcher Functions
  59   /// {
  60
  61 #define GET_ASSEMBLER_HEADER
  62 #include "X86GenAsmMatcher.inc"
  63
  64   /// }
  65
  66 public:
  67   X86ATTAsmParser(const Target &T, MCAsmParser &_Parser, TargetMachine &TM)
  68     : TargetAsmParser(T), Parser(_Parser), TM(TM) {
  69
  70     // Initialize the set of available features.
  71     setAvailableFeatures(ComputeAvailableFeatures(
  72                            &TM.getSubtarget<X86Subtarget>()));
  73   }
  74
  75   virtual bool ParseInstruction(StringRef Name, SMLoc NameLoc,
  76                                 SmallVectorImpl<MCParsedAsmOperand*> &Operands);
  77
  78   virtual bool ParseDirective(AsmToken DirectiveID);
  79 };
  80
  81 class X86_32ATTAsmParser : public X86ATTAsmParser {
  82 public:
  83   X86_32ATTAsmParser(const Target &T, MCAsmParser &_Parser, TargetMachine &TM)
  84     : X86ATTAsmParser(T, _Parser, TM) {
  85     Is64Bit = false;
  86   }
  87 };
  88
  89 class X86_64ATTAsmParser : public X86ATTAsmParser {
  90 public:
  91   X86_64ATTAsmParser(const Target &T, MCAsmParser &_Parser, TargetMachine &TM)
  92     : X86ATTAsmParser(T, _Parser, TM) {
  93     Is64Bit = true;
  94   }
  95 };
  96
  97 } // end anonymous namespace
  98
  99 /// @name Auto-generated Match Functions
 100 /// {
 101
 102 static unsigned MatchRegisterName(StringRef Name);
 103
 104 /// }
 105
 106 namespace {
 107
 108 /// X86Operand - Instances of this class represent a parsed X86 machine
 109 /// instruction.
 110 struct X86Operand : public MCParsedAsmOperand {
 111   enum KindTy {
 112     Token,
 113     Register,
 114     Immediate,
 115     Memory
 116   } Kind;
 117
 118   SMLoc StartLoc, EndLoc;
 119
 120   union {
 121     struct {
 122       const char *Data;
 123       unsigned Length;
 124     } Tok;
 125
 126     struct {
 127       unsigned RegNo;
 128     } Reg;
 129
 130     struct {
 131       const MCExpr *Val;
 132     } Imm;
 133
 134     struct {
 135       unsigned SegReg;
 136       const MCExpr *Disp;
 137       unsigned BaseReg;
 138       unsigned IndexReg;
 139       unsigned Scale;
 140     } Mem;
 141   };
 142
 143   X86Operand(KindTy K, SMLoc Start, SMLoc End)
 144     : Kind(K), StartLoc(Start), EndLoc(End) {}
 145
 146   /// getStartLoc - Get the location of the first token of this operand.
 147   SMLoc getStartLoc() const { return StartLoc; }
 148   /// getEndLoc - Get the location of the last token of this operand.
 149   SMLoc getEndLoc() const { return EndLoc; }
 150
 151   virtual void dump(raw_ostream &OS) const {}
 152
 153   StringRef getToken() const {
 154     assert(Kind == Token && "Invalid access!");
 155     return StringRef(Tok.Data, Tok.Length);
 156   }
 157   void setTokenValue(StringRef Value) {
 158     assert(Kind == Token && "Invalid access!");
 159     Tok.Data = Value.data();
 160     Tok.Length = Value.size();
 161   }
 162
 163   unsigned getReg() const {
 164     assert(Kind == Register && "Invalid access!");
 165     return Reg.RegNo;
 166   }
 167
 168   const MCExpr *getImm() const {
 169     assert(Kind == Immediate && "Invalid access!");
 170     return Imm.Val;
 171   }
 172
 173   const MCExpr *getMemDisp() const {
 174     assert(Kind == Memory && "Invalid access!");
 175     return Mem.Disp;
 176   }
 177   unsigned getMemSegReg() const {
 178     assert(Kind == Memory && "Invalid access!");
 179     return Mem.SegReg;
 180   }
 181   unsigned getMemBaseReg() const {
 182     assert(Kind == Memory && "Invalid access!");
 183     return Mem.BaseReg;
 184   }
 185   unsigned getMemIndexReg() const {
 186     assert(Kind == Memory && "Invalid access!");
 187     return Mem.IndexReg;
 188   }
 189   unsigned getMemScale() const {
 190     assert(Kind == Memory && "Invalid access!");
 191     return Mem.Scale;
 192   }
 193
 194   bool isToken() const {return Kind == Token; }
 195
 196   bool isImm() const { return Kind == Immediate; }
 197
 198   bool isImmSExti16i8() const {
 199     if (!isImm())
 200       return false;
 201
 202     // If this isn't a constant expr, just assume it fits and let relaxation
 203     // handle it.
 204     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 205     if (!CE)
 206       return true;
 207
 208     // Otherwise, check the value is in a range that makes sense for this
 209     // extension.
 210     uint64_t Value = CE->getValue();
 211     return ((                                  Value <= 0x000000000000007FULL)||
 212             (0x000000000000FF80ULL <= Value && Value <= 0x000000000000FFFFULL)||
 213             (0xFFFFFFFFFFFFFF80ULL <= Value && Value <= 0xFFFFFFFFFFFFFFFFULL));
 214   }
 215   bool isImmSExti32i8() const {
 216     if (!isImm())
 217       return false;
 218
 219     // If this isn't a constant expr, just assume it fits and let relaxation
 220     // handle it.
 221     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 222     if (!CE)
 223       return true;
 224
 225     // Otherwise, check the value is in a range that makes sense for this
 226     // extension.
 227     uint64_t Value = CE->getValue();
 228     return ((                                  Value <= 0x000000000000007FULL)||
 229             (0x00000000FFFFFF80ULL <= Value && Value <= 0x00000000FFFFFFFFULL)||
 230             (0xFFFFFFFFFFFFFF80ULL <= Value && Value <= 0xFFFFFFFFFFFFFFFFULL));
 231   }
 232   bool isImmSExti64i8() const {
 233     if (!isImm())
 234       return false;
 235
 236     // If this isn't a constant expr, just assume it fits and let relaxation
 237     // handle it.
 238     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 239     if (!CE)
 240       return true;
 241
 242     // Otherwise, check the value is in a range that makes sense for this
 243     // extension.
 244     uint64_t Value = CE->getValue();
 245     return ((                                  Value <= 0x000000000000007FULL)||
 246             (0xFFFFFFFFFFFFFF80ULL <= Value && Value <= 0xFFFFFFFFFFFFFFFFULL));
 247   }
 248   bool isImmSExti64i32() const {
 249     if (!isImm())
 250       return false;
 251
 252     // If this isn't a constant expr, just assume it fits and let relaxation
 253     // handle it.
 254     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 255     if (!CE)
 256       return true;
 257
 258     // Otherwise, check the value is in a range that makes sense for this
 259     // extension.
 260     uint64_t Value = CE->getValue();
 261     return ((                                  Value <= 0x000000007FFFFFFFULL)||
 262             (0xFFFFFFFF80000000ULL <= Value && Value <= 0xFFFFFFFFFFFFFFFFULL));
 263   }
 264
 265   bool isMem() const { return Kind == Memory; }
 266
 267   bool isAbsMem() const {
 268     return Kind == Memory && !getMemSegReg() && !getMemBaseReg() &&
 269       !getMemIndexReg() && getMemScale() == 1;
 270   }
 271
 272   bool isReg() const { return Kind == Register; }
 273
 274   void addExpr(MCInst &Inst, const MCExpr *Expr) const {
 275     // Add as immediates when possible.
 276     if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr))
 277       Inst.addOperand(MCOperand::CreateImm(CE->getValue()));
 278     else
 279       Inst.addOperand(MCOperand::CreateExpr(Expr));
 280   }
 281
 282   void addRegOperands(MCInst &Inst, unsigned N) const {
 283     assert(N == 1 && "Invalid number of operands!");
 284     Inst.addOperand(MCOperand::CreateReg(getReg()));
 285   }
 286
 287   void addImmOperands(MCInst &Inst, unsigned N) const {
 288     assert(N == 1 && "Invalid number of operands!");
 289     addExpr(Inst, getImm());
 290   }
 291
 292   void addMemOperands(MCInst &Inst, unsigned N) const {
 293     assert((N == 5) && "Invalid number of operands!");
 294     Inst.addOperand(MCOperand::CreateReg(getMemBaseReg()));
 295     Inst.addOperand(MCOperand::CreateImm(getMemScale()));
 296     Inst.addOperand(MCOperand::CreateReg(getMemIndexReg()));
 297     addExpr(Inst, getMemDisp());
 298     Inst.addOperand(MCOperand::CreateReg(getMemSegReg()));
 299   }
 300
 301   void addAbsMemOperands(MCInst &Inst, unsigned N) const {
 302     assert((N == 1) && "Invalid number of operands!");
 303     Inst.addOperand(MCOperand::CreateExpr(getMemDisp()));
 304   }
 305
 306   static X86Operand *CreateToken(StringRef Str, SMLoc Loc) {
 307     X86Operand *Res = new X86Operand(Token, Loc, Loc);
 308     Res->Tok.Data = Str.data();
 309     Res->Tok.Length = Str.size();
 310     return Res;
 311   }
 312
 313   static X86Operand *CreateReg(unsigned RegNo, SMLoc StartLoc, SMLoc EndLoc) {
 314     X86Operand *Res = new X86Operand(Register, StartLoc, EndLoc);
 315     Res->Reg.RegNo = RegNo;
 316     return Res;
 317   }
 318
 319   static X86Operand *CreateImm(const MCExpr *Val, SMLoc StartLoc, SMLoc EndLoc){
 320     X86Operand *Res = new X86Operand(Immediate, StartLoc, EndLoc);
 321     Res->Imm.Val = Val;
 322     return Res;
 323   }
 324
 325   /// Create an absolute memory operand.
 326   static X86Operand *CreateMem(const MCExpr *Disp, SMLoc StartLoc,
 327                                SMLoc EndLoc) {
 328     X86Operand *Res = new X86Operand(Memory, StartLoc, EndLoc);
 329     Res->Mem.SegReg   = 0;
 330     Res->Mem.Disp     = Disp;
 331     Res->Mem.BaseReg  = 0;
 332     Res->Mem.IndexReg = 0;
 333     Res->Mem.Scale    = 1;
 334     return Res;
 335   }
 336
 337   /// Create a generalized memory operand.
 338   static X86Operand *CreateMem(unsigned SegReg, const MCExpr *Disp,
 339                                unsigned BaseReg, unsigned IndexReg,
 340                                unsigned Scale, SMLoc StartLoc, SMLoc EndLoc) {
 341     // We should never just have a displacement, that should be parsed as an
 342     // absolute memory operand.
 343     assert((SegReg || BaseReg || IndexReg) && "Invalid memory operand!");
 344
 345     // The scale should always be one of {1,2,4,8}.
 346     assert(((Scale == 1 || Scale == 2 || Scale == 4 || Scale == 8)) &&
 347            "Invalid scale!");
 348     X86Operand *Res = new X86Operand(Memory, StartLoc, EndLoc);
 349     Res->Mem.SegReg   = SegReg;
 350     Res->Mem.Disp     = Disp;
 351     Res->Mem.BaseReg  = BaseReg;
 352     Res->Mem.IndexReg = IndexReg;
 353     Res->Mem.Scale    = Scale;
 354     return Res;
 355   }
 356 };
 357
 358 } // end anonymous namespace.
 359
 360
 361 bool X86ATTAsmParser::ParseRegister(unsigned &RegNo,
 362                                     SMLoc &StartLoc, SMLoc &EndLoc) {
 363   RegNo = 0;
 364   const AsmToken &TokPercent = Parser.getTok();
 365   assert(TokPercent.is(AsmToken::Percent) && "Invalid token kind!");
 366   StartLoc = TokPercent.getLoc();
 367   Parser.Lex(); // Eat percent token.
 368
 369   const AsmToken &Tok = Parser.getTok();
 370   if (Tok.isNot(AsmToken::Identifier))
 371     return Error(Tok.getLoc(), "invalid register name");
 372
 373   // FIXME: Validate register for the current architecture; we have to do
 374   // validation later, so maybe there is no need for this here.
 375   RegNo = MatchRegisterName(Tok.getString());
 376
 377   // If the match failed, try the register name as lowercase.
 378   if (RegNo == 0)
 379     RegNo = MatchRegisterName(LowercaseString(Tok.getString()));
 380
 381   // FIXME: This should be done using Requires<In32BitMode> and
 382   // Requires<In64BitMode> so "eiz" usage in 64-bit instructions
 383   // can be also checked.
 384   if (RegNo == X86::RIZ && !Is64Bit)
 385     return Error(Tok.getLoc(), "riz register in 64-bit mode only");
 386
 387   // Parse "%st" as "%st(0)" and "%st(1)", which is multiple tokens.
 388   if (RegNo == 0 && (Tok.getString() == "st" || Tok.getString() == "ST")) {
 389     RegNo = X86::ST0;
 390     EndLoc = Tok.getLoc();
 391     Parser.Lex(); // Eat 'st'
 392
 393     // Check to see if we have '(4)' after %st.
 394     if (getLexer().isNot(AsmToken::LParen))
 395       return false;
 396     // Lex the paren.
 397     getParser().Lex();
 398
 399     const AsmToken &IntTok = Parser.getTok();
 400     if (IntTok.isNot(AsmToken::Integer))
 401       return Error(IntTok.getLoc(), "expected stack index");
 402     switch (IntTok.getIntVal()) {
 403     case 0: RegNo = X86::ST0; break;
 404     case 1: RegNo = X86::ST1; break;
 405     case 2: RegNo = X86::ST2; break;
 406     case 3: RegNo = X86::ST3; break;
 407     case 4: RegNo = X86::ST4; break;
 408     case 5: RegNo = X86::ST5; break;
 409     case 6: RegNo = X86::ST6; break;
 410     case 7: RegNo = X86::ST7; break;
 411     default: return Error(IntTok.getLoc(), "invalid stack index");
 412     }
 413
 414     if (getParser().Lex().isNot(AsmToken::RParen))
 415       return Error(Parser.getTok().getLoc(), "expected ')'");
 416
 417     EndLoc = Tok.getLoc();
 418     Parser.Lex(); // Eat ')'
 419     return false;
 420   }
 421
 422   // If this is "db[0-7]", match it as an alias
 423   // for dr[0-7].
 424   if (RegNo == 0 && Tok.getString().size() == 3 &&
 425       Tok.getString().startswith("db")) {
 426     switch (Tok.getString()[2]) {
 427     case '0': RegNo = X86::DR0; break;
 428     case '1': RegNo = X86::DR1; break;
 429     case '2': RegNo = X86::DR2; break;
 430     case '3': RegNo = X86::DR3; break;
 431     case '4': RegNo = X86::DR4; break;
 432     case '5': RegNo = X86::DR5; break;
 433     case '6': RegNo = X86::DR6; break;
 434     case '7': RegNo = X86::DR7; break;
 435     }
 436
 437     if (RegNo != 0) {
 438       EndLoc = Tok.getLoc();
 439       Parser.Lex(); // Eat it.
 440       return false;
 441     }
 442   }
 443
 444   if (RegNo == 0)
 445     return Error(Tok.getLoc(), "invalid register name");
 446
 447   EndLoc = Tok.getLoc();
 448   Parser.Lex(); // Eat identifier token.
 449   return false;
 450 }
 451
 452 X86Operand *X86ATTAsmParser::ParseOperand() {
 453   switch (getLexer().getKind()) {
 454   default:
 455     // Parse a memory operand with no segment register.
 456     return ParseMemOperand(0, Parser.getTok().getLoc());
 457   case AsmToken::Percent: {
 458     // Read the register.
 459     unsigned RegNo;
 460     SMLoc Start, End;
 461     if (ParseRegister(RegNo, Start, End)) return 0;
 462     if (RegNo == X86::EIZ || RegNo == X86::RIZ) {
 463       Error(Start, "eiz and riz can only be used as index registers");
 464       return 0;
 465     }
 466
 467     // If this is a segment register followed by a ':', then this is the start
 468     // of a memory reference, otherwise this is a normal register reference.
 469     if (getLexer().isNot(AsmToken::Colon))
 470       return X86Operand::CreateReg(RegNo, Start, End);
 471
 472
 473     getParser().Lex(); // Eat the colon.
 474     return ParseMemOperand(RegNo, Start);
 475   }
 476   case AsmToken::Dollar: {
 477     // $42 -> immediate.
 478     SMLoc Start = Parser.getTok().getLoc(), End;
 479     Parser.Lex();
 480     const MCExpr *Val;
 481     if (getParser().ParseExpression(Val, End))
 482       return 0;
 483     return X86Operand::CreateImm(Val, Start, End);
 484   }
 485   }
 486 }
 487
 488 /// ParseMemOperand: segment: disp(basereg, indexreg, scale).  The '%ds:' prefix
 489 /// has already been parsed if present.
 490 X86Operand *X86ATTAsmParser::ParseMemOperand(unsigned SegReg, SMLoc MemStart) {
 491
 492   // We have to disambiguate a parenthesized expression "(4+5)" from the start
 493   // of a memory operand with a missing displacement "(%ebx)" or "(,%eax)".  The
 494   // only way to do this without lookahead is to eat the '(' and see what is
 495   // after it.
 496   const MCExpr *Disp = MCConstantExpr::Create(0, getParser().getContext());
 497   if (getLexer().isNot(AsmToken::LParen)) {
 498     SMLoc ExprEnd;
 499     if (getParser().ParseExpression(Disp, ExprEnd)) return 0;
 500
 501     // After parsing the base expression we could either have a parenthesized
 502     // memory address or not.  If not, return now.  If so, eat the (.
 503     if (getLexer().isNot(AsmToken::LParen)) {
 504       // Unless we have a segment register, treat this as an immediate.
 505       if (SegReg == 0)
 506         return X86Operand::CreateMem(Disp, MemStart, ExprEnd);
 507       return X86Operand::CreateMem(SegReg, Disp, 0, 0, 1, MemStart, ExprEnd);
 508     }
 509
 510     // Eat the '('.
 511     Parser.Lex();
 512   } else {
 513     // Okay, we have a '('.  We don't know if this is an expression or not, but
 514     // so we have to eat the ( to see beyond it.
 515     SMLoc LParenLoc = Parser.getTok().getLoc();
 516     Parser.Lex(); // Eat the '('.
 517
 518     if (getLexer().is(AsmToken::Percent) || getLexer().is(AsmToken::Comma)) {
 519       // Nothing to do here, fall into the code below with the '(' part of the
 520       // memory operand consumed.
 521     } else {
 522       SMLoc ExprEnd;
 523
 524       // It must be an parenthesized expression, parse it now.
 525       if (getParser().ParseParenExpression(Disp, ExprEnd))
 526         return 0;
 527
 528       // After parsing the base expression we could either have a parenthesized
 529       // memory address or not.  If not, return now.  If so, eat the (.
 530       if (getLexer().isNot(AsmToken::LParen)) {
 531         // Unless we have a segment register, treat this as an immediate.
 532         if (SegReg == 0)
 533           return X86Operand::CreateMem(Disp, LParenLoc, ExprEnd);
 534         return X86Operand::CreateMem(SegReg, Disp, 0, 0, 1, MemStart, ExprEnd);
 535       }
 536
 537       // Eat the '('.
 538       Parser.Lex();
 539     }
 540   }
 541
 542   // If we reached here, then we just ate the ( of the memory operand.  Process
 543   // the rest of the memory operand.
 544   unsigned BaseReg = 0, IndexReg = 0, Scale = 1;
 545
 546   if (getLexer().is(AsmToken::Percent)) {
 547     SMLoc L;
 548     if (ParseRegister(BaseReg, L, L)) return 0;
 549     if (BaseReg == X86::EIZ || BaseReg == X86::RIZ) {
 550       Error(L, "eiz and riz can only be used as index registers");
 551       return 0;
 552     }
 553   }
 554
 555   if (getLexer().is(AsmToken::Comma)) {
 556     Parser.Lex(); // Eat the comma.
 557
 558     // Following the comma we should have either an index register, or a scale
 559     // value. We don't support the later form, but we want to parse it
 560     // correctly.
 561     //
 562     // Not that even though it would be completely consistent to support syntax
 563     // like "1(%eax,,1)", the assembler doesn't. Use "eiz" or "riz" for this.
 564     if (getLexer().is(AsmToken::Percent)) {
 565       SMLoc L;
 566       if (ParseRegister(IndexReg, L, L)) return 0;
 567
 568       if (getLexer().isNot(AsmToken::RParen)) {
 569         // Parse the scale amount:
 570         //  ::= ',' [scale-expression]
 571         if (getLexer().isNot(AsmToken::Comma)) {
 572           Error(Parser.getTok().getLoc(),
 573                 "expected comma in scale expression");
 574           return 0;
 575         }
 576         Parser.Lex(); // Eat the comma.
 577
 578         if (getLexer().isNot(AsmToken::RParen)) {
 579           SMLoc Loc = Parser.getTok().getLoc();
 580
 581           int64_t ScaleVal;
 582           if (getParser().ParseAbsoluteExpression(ScaleVal))
 583             return 0;
 584
 585           // Validate the scale amount.
 586           if (ScaleVal != 1 && ScaleVal != 2 && ScaleVal != 4 && ScaleVal != 8){
 587             Error(Loc, "scale factor in address must be 1, 2, 4 or 8");
 588             return 0;
 589           }
 590           Scale = (unsigned)ScaleVal;
 591         }
 592       }
 593     } else if (getLexer().isNot(AsmToken::RParen)) {
 594       // A scale amount without an index is ignored.
 595       // index.
 596       SMLoc Loc = Parser.getTok().getLoc();
 597
 598       int64_t Value;
 599       if (getParser().ParseAbsoluteExpression(Value))
 600         return 0;
 601
 602       if (Value != 1)
 603         Warning(Loc, "scale factor without index register is ignored");
 604       Scale = 1;
 605     }
 606   }
 607
 608   // Ok, we've eaten the memory operand, verify we have a ')' and eat it too.
 609   if (getLexer().isNot(AsmToken::RParen)) {
 610     Error(Parser.getTok().getLoc(), "unexpected token in memory operand");
 611     return 0;
 612   }
 613   SMLoc MemEnd = Parser.getTok().getLoc();
 614   Parser.Lex(); // Eat the ')'.
 615
 616   return X86Operand::CreateMem(SegReg, Disp, BaseReg, IndexReg, Scale,
 617                                MemStart, MemEnd);
 618 }
 619
 620 bool X86ATTAsmParser::
 621 ParseInstruction(StringRef Name, SMLoc NameLoc,
 622                  SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
 623   // FIXME: Hack to recognize "sal..." and "rep..." for now. We need a way to
 624   // represent alternative syntaxes in the .td file, without requiring
 625   // instruction duplication.
 626   StringRef PatchedName = StringSwitch<StringRef>(Name)
 627     .Case("sal", "shl")
 628     .Case("salb", "shlb")
 629     .Case("sall", "shll")
 630     .Case("salq", "shlq")
 631     .Case("salw", "shlw")
 632     .Case("repe", "rep")
 633     .Case("repz", "rep")
 634     .Case("repnz", "repne")
 635     .Case("iret", "iretl")
 636     .Case("sysret", "sysretl")
 637     .Case("cbw",  "cbtw")
 638     .Case("cwd",  "cwtd")
 639     .Case("cdq", "cltd")
 640     .Case("cwde", "cwtl")
 641     .Case("cdqe", "cltq")
 642     .Case("smovb", "movsb")
 643     .Case("smovw", "movsw")
 644     .Case("smovl", "movsl")
 645     .Case("smovq", "movsq")
 646     .Case("push", Is64Bit ? "pushq" : "pushl")
 647     .Case("pop", Is64Bit ? "popq" : "popl")
 648     .Case("pushf", Is64Bit ? "pushfq" : "pushfl")
 649     .Case("popf",  Is64Bit ? "popfq"  : "popfl")
 650     .Case("pushfd", "pushfl")
 651     .Case("popfd",  "popfl")
 652     .Case("retl", Is64Bit ? "retl" : "ret")
 653     .Case("retq", Is64Bit ? "ret" : "retq")
 654     .Case("setz", "sete")  .Case("setnz", "setne")
 655     .Case("setc", "setb")  .Case("setna", "setbe")
 656     .Case("setnae", "setb").Case("setnb", "setae")
 657     .Case("setnbe", "seta").Case("setnc", "setae")
 658     .Case("setng", "setle").Case("setnge", "setl")
 659     .Case("setnl", "setge").Case("setnle", "setg")
 660     .Case("setpe", "setp") .Case("setpo", "setnp")
 661     .Case("jz", "je")  .Case("jnz", "jne")
 662     .Case("jc", "jb")  .Case("jna", "jbe")
 663     .Case("jnae", "jb").Case("jnb", "jae")
 664     .Case("jnbe", "ja").Case("jnc", "jae")
 665     .Case("jng", "jle").Case("jnge", "jl")
 666     .Case("jnl", "jge").Case("jnle", "jg")
 667     .Case("jpe", "jp") .Case("jpo", "jnp")
 668     // Condition code aliases for 16-bit, 32-bit, 64-bit and unspec operands.
 669     .Case("cmovcw",  "cmovbw") .Case("cmovcl",  "cmovbl")
 670     .Case("cmovcq",  "cmovbq") .Case("cmovc",   "cmovb")
 671     .Case("cmovnaew","cmovbw") .Case("cmovnael","cmovbl")
 672     .Case("cmovnaeq","cmovbq") .Case("cmovnae", "cmovb")
 673     .Case("cmovnaw", "cmovbew").Case("cmovnal", "cmovbel")
 674     .Case("cmovnaq", "cmovbeq").Case("cmovna",  "cmovbe")
 675     .Case("cmovnbw", "cmovaew").Case("cmovnbl", "cmovael")
 676     .Case("cmovnbq", "cmovaeq").Case("cmovnb",  "cmovae")
 677     .Case("cmovnbew","cmovaw") .Case("cmovnbel","cmoval")
 678     .Case("cmovnbeq","cmovaq") .Case("cmovnbe", "cmova")
 679     .Case("cmovncw", "cmovaew").Case("cmovncl", "cmovael")
 680     .Case("cmovncq", "cmovaeq").Case("cmovnc",  "cmovae")
 681     .Case("cmovngw", "cmovlew").Case("cmovngl", "cmovlel")
 682     .Case("cmovngq", "cmovleq").Case("cmovng",  "cmovle")
 683     .Case("cmovnw",  "cmovgew").Case("cmovnl",  "cmovgel")
 684     .Case("cmovnq",  "cmovgeq").Case("cmovn",   "cmovge")
 685     .Case("cmovngw", "cmovlew").Case("cmovngl", "cmovlel")
 686     .Case("cmovngq", "cmovleq").Case("cmovng",  "cmovle")
 687     .Case("cmovngew","cmovlw") .Case("cmovngel","cmovll")
 688     .Case("cmovngeq","cmovlq") .Case("cmovnge", "cmovl")
 689     .Case("cmovnlw", "cmovgew").Case("cmovnll", "cmovgel")
 690     .Case("cmovnlq", "cmovgeq").Case("cmovnl",  "cmovge")
 691     .Case("cmovnlew","cmovgw") .Case("cmovnlel","cmovgl")
 692     .Case("cmovnleq","cmovgq") .Case("cmovnle", "cmovg")
 693     .Case("cmovnzw", "cmovnew").Case("cmovnzl", "cmovnel")
 694     .Case("cmovnzq", "cmovneq").Case("cmovnz",  "cmovne")
 695     .Case("cmovzw",  "cmovew") .Case("cmovzl",  "cmovel")
 696     .Case("cmovzq",  "cmoveq") .Case("cmovz",   "cmove")
 697     // Floating point stack cmov aliases.
 698     .Case("fcmovz", "fcmove")
 699     .Case("fcmova", "fcmovnbe")
 700     .Case("fcmovnae", "fcmovb")
 701     .Case("fcmovna", "fcmovbe")
 702     .Case("fcmovae", "fcmovnb")
 703     .Case("fwait", "wait")
 704     .Case("movzx", "movzb")  // FIXME: Not correct.
 705     .Case("fildq", "fildll")
 706     .Case("fcompi", "fcomip")
 707     .Case("fucompi", "fucomip")
 708     .Case("fldcww", "fldcw")
 709     .Case("fnstcww", "fnstcw")
 710     .Case("fstcww", "fstcw")
 711     .Case("fnstsww", "fnstsw")
 712     .Case("fstsww", "fstsw")
 713     .Case("verrw", "verr")
 714     .Case("ud2a", "ud2")
 715     .Default(Name);
 716
 717   // FIXME: Hack to recognize cmp<comparison code>{ss,sd,ps,pd}.
 718   const MCExpr *ExtraImmOp = 0;
 719   if ((PatchedName.startswith("cmp") || PatchedName.startswith("vcmp")) &&
 720       (PatchedName.endswith("ss") || PatchedName.endswith("sd") ||
 721        PatchedName.endswith("ps") || PatchedName.endswith("pd"))) {
 722     bool IsVCMP = PatchedName.startswith("vcmp");
 723     unsigned SSECCIdx = IsVCMP ? 4 : 3;
 724     unsigned SSEComparisonCode = StringSwitch<unsigned>(
 725       PatchedName.slice(SSECCIdx, PatchedName.size() - 2))
 726       .Case("eq",          0)
 727       .Case("lt",          1)
 728       .Case("le",          2)
 729       .Case("unord",       3)
 730       .Case("neq",         4)
 731       .Case("nlt",         5)
 732       .Case("nle",         6)
 733       .Case("ord",         7)
 734       .Case("eq_uq",       8)
 735       .Case("nge",         9)
 736       .Case("ngt",      0x0A)
 737       .Case("false",    0x0B)
 738       .Case("neq_oq",   0x0C)
 739       .Case("ge",       0x0D)
 740       .Case("gt",       0x0E)
 741       .Case("true",     0x0F)
 742       .Case("eq_os",    0x10)
 743       .Case("lt_oq",    0x11)
 744       .Case("le_oq",    0x12)
 745       .Case("unord_s",  0x13)
 746       .Case("neq_us",   0x14)
 747       .Case("nlt_uq",   0x15)
 748       .Case("nle_uq",   0x16)
 749       .Case("ord_s",    0x17)
 750       .Case("eq_us",    0x18)
 751       .Case("nge_uq",   0x19)
 752       .Case("ngt_uq",   0x1A)
 753       .Case("false_os", 0x1B)
 754       .Case("neq_os",   0x1C)
 755       .Case("ge_oq",    0x1D)
 756       .Case("gt_oq",    0x1E)
 757       .Case("true_us",  0x1F)
 758       .Default(~0U);
 759     if (SSEComparisonCode != ~0U) {
 760       ExtraImmOp = MCConstantExpr::Create(SSEComparisonCode,
 761                                           getParser().getContext());
 762       if (PatchedName.endswith("ss")) {
 763         PatchedName = IsVCMP ? "vcmpss" : "cmpss";
 764       } else if (PatchedName.endswith("sd")) {
 765         PatchedName = IsVCMP ? "vcmpsd" : "cmpsd";
 766       } else if (PatchedName.endswith("ps")) {
 767         PatchedName = IsVCMP ? "vcmpps" : "cmpps";
 768       } else {
 769         assert(PatchedName.endswith("pd") && "Unexpected mnemonic!");
 770         PatchedName = IsVCMP ? "vcmppd" : "cmppd";
 771       }
 772     }
 773   }
 774
 775   // FIXME: Hack to recognize vpclmul<src1_quadword, src2_quadword>dq
 776   if (PatchedName.startswith("vpclmul")) {
 777     unsigned CLMULQuadWordSelect = StringSwitch<unsigned>(
 778       PatchedName.slice(7, PatchedName.size() - 2))
 779       .Case("lqlq", 0x00) // src1[63:0],   src2[63:0]
 780       .Case("hqlq", 0x01) // src1[127:64], src2[63:0]
 781       .Case("lqhq", 0x10) // src1[63:0],   src2[127:64]
 782       .Case("hqhq", 0x11) // src1[127:64], src2[127:64]
 783       .Default(~0U);
 784     if (CLMULQuadWordSelect != ~0U) {
 785       ExtraImmOp = MCConstantExpr::Create(CLMULQuadWordSelect,
 786                                           getParser().getContext());
 787       assert(PatchedName.endswith("dq") && "Unexpected mnemonic!");
 788       PatchedName = "vpclmulqdq";
 789     }
 790   }
 791
 792   Operands.push_back(X86Operand::CreateToken(PatchedName, NameLoc));
 793
 794   if (ExtraImmOp)
 795     Operands.push_back(X86Operand::CreateImm(ExtraImmOp, NameLoc, NameLoc));
 796
 797
 798   // Determine whether this is an instruction prefix.
 799   bool isPrefix =
 800     PatchedName == "lock" || PatchedName == "rep" ||
 801     PatchedName == "repne";
 802
 803
 804   // This does the actual operand parsing.  Don't parse any more if we have a
 805   // prefix juxtaposed with an operation like "lock incl 4(%rax)", because we
 806   // just want to parse the "lock" as the first instruction and the "incl" as
 807   // the next one.
 808   if (getLexer().isNot(AsmToken::EndOfStatement) && !isPrefix) {
 809
 810     // Parse '*' modifier.
 811     if (getLexer().is(AsmToken::Star)) {
 812       SMLoc Loc = Parser.getTok().getLoc();
 813       Operands.push_back(X86Operand::CreateToken("*", Loc));
 814       Parser.Lex(); // Eat the star.
 815     }
 816
 817     // Read the first operand.
 818     if (X86Operand *Op = ParseOperand())
 819       Operands.push_back(Op);
 820     else {
 821       Parser.EatToEndOfStatement();
 822       return true;
 823     }
 824
 825     while (getLexer().is(AsmToken::Comma)) {
 826       Parser.Lex();  // Eat the comma.
 827
 828       // Parse and remember the operand.
 829       if (X86Operand *Op = ParseOperand())
 830         Operands.push_back(Op);
 831       else {
 832         Parser.EatToEndOfStatement();
 833         return true;
 834       }
 835     }
 836
 837     if (getLexer().isNot(AsmToken::EndOfStatement)) {
 838       Parser.EatToEndOfStatement();
 839       return TokError("unexpected token in argument list");
 840     }
 841   }
 842
 843   if (getLexer().is(AsmToken::EndOfStatement))
 844     Parser.Lex(); // Consume the EndOfStatement
 845
 846   // Hack to allow 'movq <largeimm>, <reg>' as an alias for movabsq.
 847   if ((Name == "movq" || Name == "mov") && Operands.size() == 3 &&
 848       static_cast<X86Operand*>(Operands[2])->isReg() &&
 849       static_cast<X86Operand*>(Operands[1])->isImm() &&
 850       !static_cast<X86Operand*>(Operands[1])->isImmSExti64i32()) {
 851     delete Operands[0];
 852     Operands[0] = X86Operand::CreateToken("movabsq", NameLoc);
 853   }
 854
 855   // FIXME: Hack to handle recognize s{hr,ar,hl} $1, <op>.  Canonicalize to
 856   // "shift <op>".
 857   if ((Name.startswith("shr") || Name.startswith("sar") ||
 858        Name.startswith("shl")) &&
 859       Operands.size() == 3) {
 860     X86Operand *Op1 = static_cast<X86Operand*>(Operands[1]);
 861     if (Op1->isImm() && isa<MCConstantExpr>(Op1->getImm()) &&
 862         cast<MCConstantExpr>(Op1->getImm())->getValue() == 1) {
 863       delete Operands[1];
 864       Operands.erase(Operands.begin() + 1);
 865     }
 866   }
 867
 868   // FIXME: Hack to handle recognize "rc[lr] <op>" -> "rcl $1, <op>".
 869   if ((Name.startswith("rcl") || Name.startswith("rcr")) &&
 870       Operands.size() == 2) {
 871     const MCExpr *One = MCConstantExpr::Create(1, getParser().getContext());
 872     Operands.push_back(X86Operand::CreateImm(One, NameLoc, NameLoc));
 873     std::swap(Operands[1], Operands[2]);
 874   }
 875
 876   // FIXME: Hack to handle recognize "sh[lr]d op,op" -> "shld $1, op,op".
 877   if ((Name.startswith("shld") || Name.startswith("shrd")) &&
 878       Operands.size() == 3) {
 879     const MCExpr *One = MCConstantExpr::Create(1, getParser().getContext());
 880     Operands.insert(Operands.begin()+1,
 881                     X86Operand::CreateImm(One, NameLoc, NameLoc));
 882   }
 883
 884
 885   // FIXME: Hack to handle recognize "in[bwl] <op>".  Canonicalize it to
 886   // "inb <op>, %al".
 887   if ((Name == "inb" || Name == "inw" || Name == "inl") &&
 888       Operands.size() == 2) {
 889     unsigned Reg;
 890     if (Name[2] == 'b')
 891       Reg = MatchRegisterName("al");
 892     else if (Name[2] == 'w')
 893       Reg = MatchRegisterName("ax");
 894     else
 895       Reg = MatchRegisterName("eax");
 896     SMLoc Loc = Operands.back()->getEndLoc();
 897     Operands.push_back(X86Operand::CreateReg(Reg, Loc, Loc));
 898   }
 899
 900   // FIXME: Hack to handle recognize "out[bwl] <op>".  Canonicalize it to
 901   // "outb %al, <op>".
 902   if ((Name == "outb" || Name == "outw" || Name == "outl") &&
 903       Operands.size() == 2) {
 904     unsigned Reg;
 905     if (Name[3] == 'b')
 906       Reg = MatchRegisterName("al");
 907     else if (Name[3] == 'w')
 908       Reg = MatchRegisterName("ax");
 909     else
 910       Reg = MatchRegisterName("eax");
 911     SMLoc Loc = Operands.back()->getEndLoc();
 912     Operands.push_back(X86Operand::CreateReg(Reg, Loc, Loc));
 913     std::swap(Operands[1], Operands[2]);
 914   }
 915
 916   // FIXME: Hack to handle "out[bwl]? %al, (%dx)" -> "outb %al, %dx".
 917   if ((Name == "outb" || Name == "outw" || Name == "outl" || Name == "out") &&
 918       Operands.size() == 3) {
 919     X86Operand &Op = *(X86Operand*)Operands.back();
 920     if (Op.isMem() && Op.Mem.SegReg == 0 &&
 921         isa<MCConstantExpr>(Op.Mem.Disp) &&
 922         cast<MCConstantExpr>(Op.Mem.Disp)->getValue() == 0 &&
 923         Op.Mem.BaseReg == MatchRegisterName("dx") && Op.Mem.IndexReg == 0) {
 924       SMLoc Loc = Op.getEndLoc();
 925       Operands.back() = X86Operand::CreateReg(Op.Mem.BaseReg, Loc, Loc);
 926       delete &Op;
 927     }
 928   }
 929
 930   // FIXME: Hack to handle "f{mul*,add*,sub*,div*} $op, st(0)" the same as
 931   // "f{mul*,add*,sub*,div*} $op"
 932   if ((Name.startswith("fmul") || Name.startswith("fadd") ||
 933        Name.startswith("fsub") || Name.startswith("fdiv")) &&
 934       Operands.size() == 3 &&
 935       static_cast<X86Operand*>(Operands[2])->isReg() &&
 936       static_cast<X86Operand*>(Operands[2])->getReg() == X86::ST0) {
 937     delete Operands[2];
 938     Operands.erase(Operands.begin() + 2);
 939   }
 940
 941   // FIXME: Hack to handle "f{mulp,addp} st(0), $op" the same as
 942   // "f{mulp,addp} $op", since they commute.  We also allow fdivrp/fsubrp even
 943   // though they don't commute, solely because gas does support this.
 944   if ((Name=="fmulp" || Name=="faddp" || Name=="fsubrp" || Name=="fdivrp") &&
 945       Operands.size() == 3 &&
 946       static_cast<X86Operand*>(Operands[1])->isReg() &&
 947       static_cast<X86Operand*>(Operands[1])->getReg() == X86::ST0) {
 948     delete Operands[1];
 949     Operands.erase(Operands.begin() + 1);
 950   }
 951
 952   // FIXME: Hack to handle "imul <imm>, B" which is an alias for "imul <imm>, B,
 953   // B".
 954   if (Name.startswith("imul") && Operands.size() == 3 &&
 955       static_cast<X86Operand*>(Operands[1])->isImm() &&
 956       static_cast<X86Operand*>(Operands.back())->isReg()) {
 957     X86Operand *Op = static_cast<X86Operand*>(Operands.back());
 958     Operands.push_back(X86Operand::CreateReg(Op->getReg(), Op->getStartLoc(),
 959                                              Op->getEndLoc()));
 960   }
 961
 962   // 'sldt <mem>' can be encoded with either sldtw or sldtq with the same
 963   // effect (both store to a 16-bit mem).  Force to sldtw to avoid ambiguity
 964   // errors, since its encoding is the most compact.
 965   if (Name == "sldt" && Operands.size() == 2 &&
 966       static_cast<X86Operand*>(Operands[1])->isMem()) {
 967     delete Operands[0];
 968     Operands[0] = X86Operand::CreateToken("sldtw", NameLoc);
 969   }
 970
 971   // The assembler accepts "xchgX <reg>, <mem>" and "xchgX <mem>, <reg>" as
 972   // synonyms.  Our tables only have the "<reg>, <mem>" form, so if we see the
 973   // other operand order, swap them.
 974   if (Name == "xchgb" || Name == "xchgw" || Name == "xchgl" || Name == "xchgq"||
 975       Name == "xchg")
 976     if (Operands.size() == 3 &&
 977         static_cast<X86Operand*>(Operands[1])->isMem() &&
 978         static_cast<X86Operand*>(Operands[2])->isReg()) {
 979       std::swap(Operands[1], Operands[2]);
 980     }
 981
 982   // The assembler accepts "testX <reg>, <mem>" and "testX <mem>, <reg>" as
 983   // synonyms.  Our tables only have the "<mem>, <reg>" form, so if we see the
 984   // other operand order, swap them.
 985   if (Name == "testb" || Name == "testw" || Name == "testl" || Name == "testq"||
 986       Name == "test")
 987     if (Operands.size() == 3 &&
 988         static_cast<X86Operand*>(Operands[1])->isReg() &&
 989         static_cast<X86Operand*>(Operands[2])->isMem()) {
 990       std::swap(Operands[1], Operands[2]);
 991     }
 992
 993   // The assembler accepts these instructions with no operand as a synonym for
 994   // an instruction acting on st(1).  e.g. "fxch" -> "fxch %st(1)".
 995   if ((Name == "fxch" || Name == "fucom" || Name == "fucomp" ||
 996        Name == "faddp" || Name == "fsubp" || Name == "fsubrp" ||
 997        Name == "fmulp" || Name == "fdivp" || Name == "fdivrp") &&
 998       Operands.size() == 1) {
 999     Operands.push_back(X86Operand::CreateReg(MatchRegisterName("st(1)"),
1000                                              NameLoc, NameLoc));
1001   }
1002
1003   // The assembler accepts this instruction with no operand as a synonym for an
1004   // instruction taking %st(1),%st(0). e.g. "fcompi" -> "fcompi %st(1),st(0)".
1005   if (Name == "fcompi" && Operands.size() == 1) {
1006     Operands.push_back(X86Operand::CreateReg(MatchRegisterName("st(1)"),
1007                                              NameLoc, NameLoc));
1008     Operands.push_back(X86Operand::CreateReg(MatchRegisterName("st(0)"),
1009                                              NameLoc, NameLoc));
1010   }
1011
1012   // The assembler accepts these instructions with two few operands as a synonym
1013   // for taking %st(1),%st(0) or X, %st(0).
1014   if ((Name == "fcomi" || Name == "fucomi" || Name == "fucompi" ||
1015        Name == "fcompi" ) &&
1016       Operands.size() < 3) {
1017     if (Operands.size() == 1)
1018       Operands.push_back(X86Operand::CreateReg(MatchRegisterName("st(1)"),
1019                                                NameLoc, NameLoc));
1020     Operands.push_back(X86Operand::CreateReg(MatchRegisterName("st(0)"),
1021                                              NameLoc, NameLoc));
1022   }
1023
1024   // The assembler accepts various amounts of brokenness for fnstsw.
1025   if (Name == "fnstsw") {
1026     if (Operands.size() == 2 &&
1027         static_cast<X86Operand*>(Operands[1])->isReg()) {
1028       // "fnstsw al" and "fnstsw eax" -> "fnstw"
1029       unsigned Reg = static_cast<X86Operand*>(Operands[1])->Reg.RegNo;
1030       if (Reg == MatchRegisterName("eax") ||
1031           Reg == MatchRegisterName("al")) {
1032         delete Operands[1];
1033         Operands.pop_back();
1034       }
1035     }
1036
1037     // "fnstw" -> "fnstw %ax"
1038     if (Operands.size() == 1)
1039       Operands.push_back(X86Operand::CreateReg(MatchRegisterName("ax"),
1040                                                NameLoc, NameLoc));
1041   }
1042
1043   // jmp $42,$5 -> ljmp, similarly for call.
1044   if ((Name.startswith("call") || Name.startswith("jmp")) &&
1045       Operands.size() == 3 &&
1046       static_cast<X86Operand*>(Operands[1])->isImm() &&
1047       static_cast<X86Operand*>(Operands[2])->isImm()) {
1048     const char *NewOpName = StringSwitch<const char *>(Name)
1049       .Case("jmp", "ljmp")
1050       .Case("jmpw", "ljmpw")
1051       .Case("jmpl", "ljmpl")
1052       .Case("jmpq", "ljmpq")
1053       .Case("call", "lcall")
1054       .Case("callw", "lcallw")
1055       .Case("calll", "lcalll")
1056       .Case("callq", "lcallq")
1057     .Default(0);
1058     if (NewOpName) {
1059       delete Operands[0];
1060       Operands[0] = X86Operand::CreateToken(NewOpName, NameLoc);
1061       Name = NewOpName;
1062     }
1063   }
1064
1065   // lcall  and ljmp  -> lcalll and ljmpl
1066   if ((Name == "lcall" || Name == "ljmp") && Operands.size() == 3) {
1067     delete Operands[0];
1068     Operands[0] = X86Operand::CreateToken(Name == "lcall" ? "lcalll" : "ljmpl",
1069                                           NameLoc);
1070   }
1071
1072   // call foo is not ambiguous with callw.
1073   if (Name == "call" && Operands.size() == 2) {
1074     const char *NewName = Is64Bit ? "callq" : "calll";
1075     delete Operands[0];
1076     Operands[0] = X86Operand::CreateToken(NewName, NameLoc);
1077     Name = NewName;
1078   }
1079
1080   // movsd -> movsl (when no operands are specified).
1081   if (Name == "movsd" && Operands.size() == 1) {
1082     delete Operands[0];
1083     Operands[0] = X86Operand::CreateToken("movsl", NameLoc);
1084   }
1085
1086   // fstp <mem> -> fstps <mem>.  Without this, we'll default to fstpl due to
1087   // suffix searching.
1088   if (Name == "fstp" && Operands.size() == 2 &&
1089       static_cast<X86Operand*>(Operands[1])->isMem()) {
1090     delete Operands[0];
1091     Operands[0] = X86Operand::CreateToken("fstps", NameLoc);
1092   }
1093
1094
1095   // "clr <reg>" -> "xor <reg>, <reg>".
1096   if ((Name == "clrb" || Name == "clrw" || Name == "clrl" || Name == "clrq" ||
1097        Name == "clr") && Operands.size() == 2 &&
1098       static_cast<X86Operand*>(Operands[1])->isReg()) {
1099     unsigned RegNo = static_cast<X86Operand*>(Operands[1])->getReg();
1100     Operands.push_back(X86Operand::CreateReg(RegNo, NameLoc, NameLoc));
1101     delete Operands[0];
1102     Operands[0] = X86Operand::CreateToken("xor", NameLoc);
1103   }
1104
1105   // FIXME: Hack to handle recognize "aa[dm]" -> "aa[dm] $0xA".
1106   if ((Name.startswith("aad") || Name.startswith("aam")) &&
1107       Operands.size() == 1) {
1108     const MCExpr *A = MCConstantExpr::Create(0xA, getParser().getContext());
1109     Operands.push_back(X86Operand::CreateImm(A, NameLoc, NameLoc));
1110   }
1111
1112   // "lgdtl" is not ambiguous 32-bit mode and is the same as "lgdt".
1113   // "lgdtq" is not ambiguous 64-bit mode and is the same as "lgdt".
1114   if ((Name == "lgdtl" && Is64Bit == false) ||
1115       (Name == "lgdtq" && Is64Bit == true)) {
1116     const char *NewName = "lgdt";
1117     delete Operands[0];
1118     Operands[0] = X86Operand::CreateToken(NewName, NameLoc);
1119     Name = NewName;
1120   }
1121
1122   // "lidtl" is not ambiguous 32-bit mode and is the same as "lidt".
1123   // "lidtq" is not ambiguous 64-bit mode and is the same as "lidt".
1124   if ((Name == "lidtl" && Is64Bit == false) ||
1125       (Name == "lidtq" && Is64Bit == true)) {
1126     const char *NewName = "lidt";
1127     delete Operands[0];
1128     Operands[0] = X86Operand::CreateToken(NewName, NameLoc);
1129     Name = NewName;
1130   }
1131
1132   // "sgdtl" is not ambiguous 32-bit mode and is the same as "sgdt".
1133   // "sgdtq" is not ambiguous 64-bit mode and is the same as "sgdt".
1134   if ((Name == "sgdtl" && Is64Bit == false) ||
1135       (Name == "sgdtq" && Is64Bit == true)) {
1136     const char *NewName = "sgdt";
1137     delete Operands[0];
1138     Operands[0] = X86Operand::CreateToken(NewName, NameLoc);
1139     Name = NewName;
1140   }
1141
1142   // "sidtl" is not ambiguous 32-bit mode and is the same as "sidt".
1143   // "sidtq" is not ambiguous 64-bit mode and is the same as "sidt".
1144   if ((Name == "sidtl" && Is64Bit == false) ||
1145       (Name == "sidtq" && Is64Bit == true)) {
1146     const char *NewName = "sidt";
1147     delete Operands[0];
1148     Operands[0] = X86Operand::CreateToken(NewName, NameLoc);
1149     Name = NewName;
1150   }
1151
1152   return false;
1153 }
1154
1155 bool X86ATTAsmParser::ParseDirective(AsmToken DirectiveID) {
1156   StringRef IDVal = DirectiveID.getIdentifier();
1157   if (IDVal == ".word")
1158     return ParseDirectiveWord(2, DirectiveID.getLoc());
1159   return true;
1160 }
1161
1162 /// ParseDirectiveWord
1163 ///  ::= .word [ expression (, expression)* ]
1164 bool X86ATTAsmParser::ParseDirectiveWord(unsigned Size, SMLoc L) {
1165   if (getLexer().isNot(AsmToken::EndOfStatement)) {
1166     for (;;) {
1167       const MCExpr *Value;
1168       if (getParser().ParseExpression(Value))
1169         return true;
1170
1171       getParser().getStreamer().EmitValue(Value, Size, 0 /*addrspace*/);
1172
1173       if (getLexer().is(AsmToken::EndOfStatement))
1174         break;
1175
1176       // FIXME: Improve diagnostic.
1177       if (getLexer().isNot(AsmToken::Comma))
1178         return Error(L, "unexpected token in directive");
1179       Parser.Lex();
1180     }
1181   }
1182
1183   Parser.Lex();
1184   return false;
1185 }
1186
1187
1188 bool X86ATTAsmParser::
1189 MatchAndEmitInstruction(SMLoc IDLoc,
1190                         SmallVectorImpl<MCParsedAsmOperand*> &Operands,
1191                         MCStreamer &Out) {
1192   assert(!Operands.empty() && "Unexpect empty operand list!");
1193   X86Operand *Op = static_cast<X86Operand*>(Operands[0]);
1194   assert(Op->isToken() && "Leading operand should always be a mnemonic!");
1195
1196   // First, handle aliases that expand to multiple instructions.
1197   // FIXME: This should be replaced with a real .td file alias mechanism.
1198   if (Op->getToken() == "fstsw" || Op->getToken() == "fstcw" ||
1199       Op->getToken() == "finit" || Op->getToken() == "fsave" ||
1200       Op->getToken() == "fstenv" || Op->getToken() == "fclex") {
1201     MCInst Inst;
1202     Inst.setOpcode(X86::WAIT);
1203     Out.EmitInstruction(Inst);
1204
1205     const char *Repl =
1206       StringSwitch<const char*>(Op->getToken())
1207         .Case("finit", "fninit")
1208         .Case("fsave", "fnsave")
1209         .Case("fstcw", "fnstcw")
1210         .Case("fstenv", "fnstenv")
1211         .Case("fstsw", "fnstsw")
1212         .Case("fclex", "fnclex")
1213         .Default(0);
1214     assert(Repl && "Unknown wait-prefixed instruction");
1215     delete Operands[0];
1216     Operands[0] = X86Operand::CreateToken(Repl, IDLoc);
1217   }
1218
1219   bool WasOriginallyInvalidOperand = false;
1220   unsigned OrigErrorInfo;
1221   MCInst Inst;
1222
1223   // First, try a direct match.
1224   switch (MatchInstructionImpl(Operands, Inst, OrigErrorInfo)) {
1225   case Match_Success:
1226     Out.EmitInstruction(Inst);
1227     return false;
1228   case Match_MissingFeature:
1229     Error(IDLoc, "instruction requires a CPU feature not currently enabled");
1230     return true;
1231   case Match_InvalidOperand:
1232     WasOriginallyInvalidOperand = true;
1233     break;
1234   case Match_MnemonicFail:
1235     break;
1236   }
1237
1238   // FIXME: Ideally, we would only attempt suffix matches for things which are
1239   // valid prefixes, and we could just infer the right unambiguous
1240   // type. However, that requires substantially more matcher support than the
1241   // following hack.
1242
1243   // Change the operand to point to a temporary token.
1244   StringRef Base = Op->getToken();
1245   SmallString<16> Tmp;
1246   Tmp += Base;
1247   Tmp += ' ';
1248   Op->setTokenValue(Tmp.str());
1249
1250   // Check for the various suffix matches.
1251   Tmp[Base.size()] = 'b';
1252   unsigned BErrorInfo, WErrorInfo, LErrorInfo, QErrorInfo;
1253   MatchResultTy MatchB = MatchInstructionImpl(Operands, Inst, BErrorInfo);
1254   Tmp[Base.size()] = 'w';
1255   MatchResultTy MatchW = MatchInstructionImpl(Operands, Inst, WErrorInfo);
1256   Tmp[Base.size()] = 'l';
1257   MatchResultTy MatchL = MatchInstructionImpl(Operands, Inst, LErrorInfo);
1258   Tmp[Base.size()] = 'q';
1259   MatchResultTy MatchQ = MatchInstructionImpl(Operands, Inst, QErrorInfo);
1260
1261   // Restore the old token.
1262   Op->setTokenValue(Base);
1263
1264   // If exactly one matched, then we treat that as a successful match (and the
1265   // instruction will already have been filled in correctly, since the failing
1266   // matches won't have modified it).
1267   unsigned NumSuccessfulMatches =
1268     (MatchB == Match_Success) + (MatchW == Match_Success) +
1269     (MatchL == Match_Success) + (MatchQ == Match_Success);
1270   if (NumSuccessfulMatches == 1) {
1271     Out.EmitInstruction(Inst);
1272     return false;
1273   }
1274
1275   // Otherwise, the match failed, try to produce a decent error message.
1276
1277   // If we had multiple suffix matches, then identify this as an ambiguous
1278   // match.
1279   if (NumSuccessfulMatches > 1) {
1280     char MatchChars[4];
1281     unsigned NumMatches = 0;
1282     if (MatchB == Match_Success)
1283       MatchChars[NumMatches++] = 'b';
1284     if (MatchW == Match_Success)
1285       MatchChars[NumMatches++] = 'w';
1286     if (MatchL == Match_Success)
1287       MatchChars[NumMatches++] = 'l';
1288     if (MatchQ == Match_Success)
1289       MatchChars[NumMatches++] = 'q';
1290
1291     SmallString<126> Msg;
1292     raw_svector_ostream OS(Msg);
1293     OS << "ambiguous instructions require an explicit suffix (could be ";
1294     for (unsigned i = 0; i != NumMatches; ++i) {
1295       if (i != 0)
1296         OS << ", ";
1297       if (i + 1 == NumMatches)
1298         OS << "or ";
1299       OS << "'" << Base << MatchChars[i] << "'";
1300     }
1301     OS << ")";
1302     Error(IDLoc, OS.str());
1303     return true;
1304   }
1305
1306   // Okay, we know that none of the variants matched successfully.
1307
1308   // If all of the instructions reported an invalid mnemonic, then the original
1309   // mnemonic was invalid.
1310   if ((MatchB == Match_MnemonicFail) && (MatchW == Match_MnemonicFail) &&
1311       (MatchL == Match_MnemonicFail) && (MatchQ == Match_MnemonicFail)) {
1312     if (!WasOriginallyInvalidOperand) {
1313       Error(IDLoc, "invalid instruction mnemonic '" + Base + "'");
1314       return true;
1315     }
1316
1317     // Recover location info for the operand if we know which was the problem.
1318     SMLoc ErrorLoc = IDLoc;
1319     if (OrigErrorInfo != ~0U) {
1320       if (OrigErrorInfo >= Operands.size())
1321         return Error(IDLoc, "too few operands for instruction");
1322
1323       ErrorLoc = ((X86Operand*)Operands[OrigErrorInfo])->getStartLoc();
1324       if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc;
1325     }
1326
1327     return Error(ErrorLoc, "invalid operand for instruction");
1328   }
1329
1330   // If one instruction matched with a missing feature, report this as a
1331   // missing feature.
1332   if ((MatchB == Match_MissingFeature) + (MatchW == Match_MissingFeature) +
1333       (MatchL == Match_MissingFeature) + (MatchQ == Match_MissingFeature) == 1){
1334     Error(IDLoc, "instruction requires a CPU feature not currently enabled");
1335     return true;
1336   }
1337
1338   // If one instruction matched with an invalid operand, report this as an
1339   // operand failure.
1340   if ((MatchB == Match_InvalidOperand) + (MatchW == Match_InvalidOperand) +
1341       (MatchL == Match_InvalidOperand) + (MatchQ == Match_InvalidOperand) == 1){
1342     Error(IDLoc, "invalid operand for instruction");
1343     return true;
1344   }
1345
1346   // If all of these were an outright failure, report it in a useless way.
1347   // FIXME: We should give nicer diagnostics about the exact failure.
1348   Error(IDLoc, "unknown use of instruction mnemonic without a size suffix");
1349   return true;
1350 }
1351
1352
1353 extern "C" void LLVMInitializeX86AsmLexer();
1354
1355 // Force static initialization.
1356 extern "C" void LLVMInitializeX86AsmParser() {
1357   RegisterAsmParser<X86_32ATTAsmParser> X(TheX86_32Target);
1358   RegisterAsmParser<X86_64ATTAsmParser> Y(TheX86_64Target);
1359   LLVMInitializeX86AsmLexer();
1360 }
1361
1362 #define GET_REGISTER_MATCHER
1363 #define GET_MATCHER_IMPLEMENTATION
1364 #include "X86GenAsmMatcher.inc"