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 "MCTargetDesc/X86BaseInfo.h"
  11 #include "X86AsmParserCommon.h"
  12 #include "X86Operand.h"
  13 #include "llvm/ADT/APFloat.h"
  14 #include "llvm/ADT/STLExtras.h"
  15 #include "llvm/ADT/SmallString.h"
  16 #include "llvm/ADT/SmallVector.h"
  17 #include "llvm/ADT/StringSwitch.h"
  18 #include "llvm/ADT/Twine.h"
  19 #include "llvm/MC/MCContext.h"
  20 #include "llvm/MC/MCExpr.h"
  21 #include "llvm/MC/MCInst.h"
  22 #include "llvm/MC/MCParser/MCAsmLexer.h"
  23 #include "llvm/MC/MCParser/MCAsmParser.h"
  24 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  25 #include "llvm/MC/MCRegisterInfo.h"
  26 #include "llvm/MC/MCStreamer.h"
  27 #include "llvm/MC/MCSubtargetInfo.h"
  28 #include "llvm/MC/MCSymbol.h"
  29 #include "llvm/MC/MCTargetAsmParser.h"
  30 #include "llvm/Support/SourceMgr.h"
  31 #include "llvm/Support/TargetRegistry.h"
  32 #include "llvm/Support/raw_ostream.h"
  33
  34 using namespace llvm;
  35
  36 namespace {
  37
  38 static const char OpPrecedence[] = {
  39   0, // IC_OR
  40   1, // IC_AND
  41   2, // IC_LSHIFT
  42   2, // IC_RSHIFT
  43   3, // IC_PLUS
  44   3, // IC_MINUS
  45   4, // IC_MULTIPLY
  46   4, // IC_DIVIDE
  47   5, // IC_RPAREN
  48   6, // IC_LPAREN
  49   0, // IC_IMM
  50   0  // IC_REGISTER
  51 };
  52
  53 class X86AsmParser : public MCTargetAsmParser {
  54   MCSubtargetInfo &STI;
  55   MCAsmParser &Parser;
  56   ParseInstructionInfo *InstInfo;
  57 private:
  58   SMLoc consumeToken() {
  59     SMLoc Result = Parser.getTok().getLoc();
  60     Parser.Lex();
  61     return Result;
  62   }
  63
  64   enum InfixCalculatorTok {
  65     IC_OR = 0,
  66     IC_AND,
  67     IC_LSHIFT,
  68     IC_RSHIFT,
  69     IC_PLUS,
  70     IC_MINUS,
  71     IC_MULTIPLY,
  72     IC_DIVIDE,
  73     IC_RPAREN,
  74     IC_LPAREN,
  75     IC_IMM,
  76     IC_REGISTER
  77   };
  78
  79   class InfixCalculator {
  80     typedef std::pair< InfixCalculatorTok, int64_t > ICToken;
  81     SmallVector<InfixCalculatorTok, 4> InfixOperatorStack;
  82     SmallVector<ICToken, 4> PostfixStack;
  83
  84   public:
  85     int64_t popOperand() {
  86       assert (!PostfixStack.empty() && "Poped an empty stack!");
  87       ICToken Op = PostfixStack.pop_back_val();
  88       assert ((Op.first == IC_IMM || Op.first == IC_REGISTER)
  89               && "Expected and immediate or register!");
  90       return Op.second;
  91     }
  92     void pushOperand(InfixCalculatorTok Op, int64_t Val = 0) {
  93       assert ((Op == IC_IMM || Op == IC_REGISTER) &&
  94               "Unexpected operand!");
  95       PostfixStack.push_back(std::make_pair(Op, Val));
  96     }
  97
  98     void popOperator() { InfixOperatorStack.pop_back(); }
  99     void pushOperator(InfixCalculatorTok Op) {
 100       // Push the new operator if the stack is empty.
 101       if (InfixOperatorStack.empty()) {
 102         InfixOperatorStack.push_back(Op);
 103         return;
 104       }
 105
 106       // Push the new operator if it has a higher precedence than the operator
 107       // on the top of the stack or the operator on the top of the stack is a
 108       // left parentheses.
 109       unsigned Idx = InfixOperatorStack.size() - 1;
 110       InfixCalculatorTok StackOp = InfixOperatorStack[Idx];
 111       if (OpPrecedence[Op] > OpPrecedence[StackOp] || StackOp == IC_LPAREN) {
 112         InfixOperatorStack.push_back(Op);
 113         return;
 114       }
 115
 116       // The operator on the top of the stack has higher precedence than the
 117       // new operator.
 118       unsigned ParenCount = 0;
 119       while (1) {
 120         // Nothing to process.
 121         if (InfixOperatorStack.empty())
 122           break;
 123
 124         Idx = InfixOperatorStack.size() - 1;
 125         StackOp = InfixOperatorStack[Idx];
 126         if (!(OpPrecedence[StackOp] >= OpPrecedence[Op] || ParenCount))
 127           break;
 128
 129         // If we have an even parentheses count and we see a left parentheses,
 130         // then stop processing.
 131         if (!ParenCount && StackOp == IC_LPAREN)
 132           break;
 133
 134         if (StackOp == IC_RPAREN) {
 135           ++ParenCount;
 136           InfixOperatorStack.pop_back();
 137         } else if (StackOp == IC_LPAREN) {
 138           --ParenCount;
 139           InfixOperatorStack.pop_back();
 140         } else {
 141           InfixOperatorStack.pop_back();
 142           PostfixStack.push_back(std::make_pair(StackOp, 0));
 143         }
 144       }
 145       // Push the new operator.
 146       InfixOperatorStack.push_back(Op);
 147     }
 148     int64_t execute() {
 149       // Push any remaining operators onto the postfix stack.
 150       while (!InfixOperatorStack.empty()) {
 151         InfixCalculatorTok StackOp = InfixOperatorStack.pop_back_val();
 152         if (StackOp != IC_LPAREN && StackOp != IC_RPAREN)
 153           PostfixStack.push_back(std::make_pair(StackOp, 0));
 154       }
 155
 156       if (PostfixStack.empty())
 157         return 0;
 158
 159       SmallVector<ICToken, 16> OperandStack;
 160       for (unsigned i = 0, e = PostfixStack.size(); i != e; ++i) {
 161         ICToken Op = PostfixStack[i];
 162         if (Op.first == IC_IMM || Op.first == IC_REGISTER) {
 163           OperandStack.push_back(Op);
 164         } else {
 165           assert (OperandStack.size() > 1 && "Too few operands.");
 166           int64_t Val;
 167           ICToken Op2 = OperandStack.pop_back_val();
 168           ICToken Op1 = OperandStack.pop_back_val();
 169           switch (Op.first) {
 170           default:
 171             report_fatal_error("Unexpected operator!");
 172             break;
 173           case IC_PLUS:
 174             Val = Op1.second + Op2.second;
 175             OperandStack.push_back(std::make_pair(IC_IMM, Val));
 176             break;
 177           case IC_MINUS:
 178             Val = Op1.second - Op2.second;
 179             OperandStack.push_back(std::make_pair(IC_IMM, Val));
 180             break;
 181           case IC_MULTIPLY:
 182             assert (Op1.first == IC_IMM && Op2.first == IC_IMM &&
 183                     "Multiply operation with an immediate and a register!");
 184             Val = Op1.second * Op2.second;
 185             OperandStack.push_back(std::make_pair(IC_IMM, Val));
 186             break;
 187           case IC_DIVIDE:
 188             assert (Op1.first == IC_IMM && Op2.first == IC_IMM &&
 189                     "Divide operation with an immediate and a register!");
 190             assert (Op2.second != 0 && "Division by zero!");
 191             Val = Op1.second / Op2.second;
 192             OperandStack.push_back(std::make_pair(IC_IMM, Val));
 193             break;
 194           case IC_OR:
 195             assert (Op1.first == IC_IMM && Op2.first == IC_IMM &&
 196                     "Or operation with an immediate and a register!");
 197             Val = Op1.second | Op2.second;
 198             OperandStack.push_back(std::make_pair(IC_IMM, Val));
 199             break;
 200           case IC_AND:
 201             assert (Op1.first == IC_IMM && Op2.first == IC_IMM &&
 202                     "And operation with an immediate and a register!");
 203             Val = Op1.second & Op2.second;
 204             OperandStack.push_back(std::make_pair(IC_IMM, Val));
 205             break;
 206           case IC_LSHIFT:
 207             assert (Op1.first == IC_IMM && Op2.first == IC_IMM &&
 208                     "Left shift operation with an immediate and a register!");
 209             Val = Op1.second << Op2.second;
 210             OperandStack.push_back(std::make_pair(IC_IMM, Val));
 211             break;
 212           case IC_RSHIFT:
 213             assert (Op1.first == IC_IMM && Op2.first == IC_IMM &&
 214                     "Right shift operation with an immediate and a register!");
 215             Val = Op1.second >> Op2.second;
 216             OperandStack.push_back(std::make_pair(IC_IMM, Val));
 217             break;
 218           }
 219         }
 220       }
 221       assert (OperandStack.size() == 1 && "Expected a single result.");
 222       return OperandStack.pop_back_val().second;
 223     }
 224   };
 225
 226   enum IntelExprState {
 227     IES_OR,
 228     IES_AND,
 229     IES_LSHIFT,
 230     IES_RSHIFT,
 231     IES_PLUS,
 232     IES_MINUS,
 233     IES_MULTIPLY,
 234     IES_DIVIDE,
 235     IES_LBRAC,
 236     IES_RBRAC,
 237     IES_LPAREN,
 238     IES_RPAREN,
 239     IES_REGISTER,
 240     IES_INTEGER,
 241     IES_IDENTIFIER,
 242     IES_ERROR
 243   };
 244
 245   class IntelExprStateMachine {
 246     IntelExprState State, PrevState;
 247     unsigned BaseReg, IndexReg, TmpReg, Scale;
 248     int64_t Imm;
 249     const MCExpr *Sym;
 250     StringRef SymName;
 251     bool StopOnLBrac, AddImmPrefix;
 252     InfixCalculator IC;
 253     InlineAsmIdentifierInfo Info;
 254   public:
 255     IntelExprStateMachine(int64_t imm, bool stoponlbrac, bool addimmprefix) :
 256       State(IES_PLUS), PrevState(IES_ERROR), BaseReg(0), IndexReg(0), TmpReg(0),
 257       Scale(1), Imm(imm), Sym(0), StopOnLBrac(stoponlbrac),
 258       AddImmPrefix(addimmprefix) { Info.clear(); }
 259
 260     unsigned getBaseReg() { return BaseReg; }
 261     unsigned getIndexReg() { return IndexReg; }
 262     unsigned getScale() { return Scale; }
 263     const MCExpr *getSym() { return Sym; }
 264     StringRef getSymName() { return SymName; }
 265     int64_t getImm() { return Imm + IC.execute(); }
 266     bool isValidEndState() {
 267       return State == IES_RBRAC || State == IES_INTEGER;
 268     }
 269     bool getStopOnLBrac() { return StopOnLBrac; }
 270     bool getAddImmPrefix() { return AddImmPrefix; }
 271     bool hadError() { return State == IES_ERROR; }
 272
 273     InlineAsmIdentifierInfo &getIdentifierInfo() {
 274       return Info;
 275     }
 276
 277     void onOr() {
 278       IntelExprState CurrState = State;
 279       switch (State) {
 280       default:
 281         State = IES_ERROR;
 282         break;
 283       case IES_INTEGER:
 284       case IES_RPAREN:
 285       case IES_REGISTER:
 286         State = IES_OR;
 287         IC.pushOperator(IC_OR);
 288         break;
 289       }
 290       PrevState = CurrState;
 291     }
 292     void onAnd() {
 293       IntelExprState CurrState = State;
 294       switch (State) {
 295       default:
 296         State = IES_ERROR;
 297         break;
 298       case IES_INTEGER:
 299       case IES_RPAREN:
 300       case IES_REGISTER:
 301         State = IES_AND;
 302         IC.pushOperator(IC_AND);
 303         break;
 304       }
 305       PrevState = CurrState;
 306     }
 307     void onLShift() {
 308       IntelExprState CurrState = State;
 309       switch (State) {
 310       default:
 311         State = IES_ERROR;
 312         break;
 313       case IES_INTEGER:
 314       case IES_RPAREN:
 315       case IES_REGISTER:
 316         State = IES_LSHIFT;
 317         IC.pushOperator(IC_LSHIFT);
 318         break;
 319       }
 320       PrevState = CurrState;
 321     }
 322     void onRShift() {
 323       IntelExprState CurrState = State;
 324       switch (State) {
 325       default:
 326         State = IES_ERROR;
 327         break;
 328       case IES_INTEGER:
 329       case IES_RPAREN:
 330       case IES_REGISTER:
 331         State = IES_RSHIFT;
 332         IC.pushOperator(IC_RSHIFT);
 333         break;
 334       }
 335       PrevState = CurrState;
 336     }
 337     void onPlus() {
 338       IntelExprState CurrState = State;
 339       switch (State) {
 340       default:
 341         State = IES_ERROR;
 342         break;
 343       case IES_INTEGER:
 344       case IES_RPAREN:
 345       case IES_REGISTER:
 346         State = IES_PLUS;
 347         IC.pushOperator(IC_PLUS);
 348         if (CurrState == IES_REGISTER && PrevState != IES_MULTIPLY) {
 349           // If we already have a BaseReg, then assume this is the IndexReg with
 350           // a scale of 1.
 351           if (!BaseReg) {
 352             BaseReg = TmpReg;
 353           } else {
 354             assert (!IndexReg && "BaseReg/IndexReg already set!");
 355             IndexReg = TmpReg;
 356             Scale = 1;
 357           }
 358         }
 359         break;
 360       }
 361       PrevState = CurrState;
 362     }
 363     void onMinus() {
 364       IntelExprState CurrState = State;
 365       switch (State) {
 366       default:
 367         State = IES_ERROR;
 368         break;
 369       case IES_PLUS:
 370       case IES_MULTIPLY:
 371       case IES_DIVIDE:
 372       case IES_LPAREN:
 373       case IES_RPAREN:
 374       case IES_LBRAC:
 375       case IES_RBRAC:
 376       case IES_INTEGER:
 377       case IES_REGISTER:
 378         State = IES_MINUS;
 379         // Only push the minus operator if it is not a unary operator.
 380         if (!(CurrState == IES_PLUS || CurrState == IES_MINUS ||
 381               CurrState == IES_MULTIPLY || CurrState == IES_DIVIDE ||
 382               CurrState == IES_LPAREN || CurrState == IES_LBRAC))
 383           IC.pushOperator(IC_MINUS);
 384         if (CurrState == IES_REGISTER && PrevState != IES_MULTIPLY) {
 385           // If we already have a BaseReg, then assume this is the IndexReg with
 386           // a scale of 1.
 387           if (!BaseReg) {
 388             BaseReg = TmpReg;
 389           } else {
 390             assert (!IndexReg && "BaseReg/IndexReg already set!");
 391             IndexReg = TmpReg;
 392             Scale = 1;
 393           }
 394         }
 395         break;
 396       }
 397       PrevState = CurrState;
 398     }
 399     void onRegister(unsigned Reg) {
 400       IntelExprState CurrState = State;
 401       switch (State) {
 402       default:
 403         State = IES_ERROR;
 404         break;
 405       case IES_PLUS:
 406       case IES_LPAREN:
 407         State = IES_REGISTER;
 408         TmpReg = Reg;
 409         IC.pushOperand(IC_REGISTER);
 410         break;
 411       case IES_MULTIPLY:
 412         // Index Register - Scale * Register
 413         if (PrevState == IES_INTEGER) {
 414           assert (!IndexReg && "IndexReg already set!");
 415           State = IES_REGISTER;
 416           IndexReg = Reg;
 417           // Get the scale and replace the 'Scale * Register' with '0'.
 418           Scale = IC.popOperand();
 419           IC.pushOperand(IC_IMM);
 420           IC.popOperator();
 421         } else {
 422           State = IES_ERROR;
 423         }
 424         break;
 425       }
 426       PrevState = CurrState;
 427     }
 428     void onIdentifierExpr(const MCExpr *SymRef, StringRef SymRefName) {
 429       PrevState = State;
 430       switch (State) {
 431       default:
 432         State = IES_ERROR;
 433         break;
 434       case IES_PLUS:
 435       case IES_MINUS:
 436         State = IES_INTEGER;
 437         Sym = SymRef;
 438         SymName = SymRefName;
 439         IC.pushOperand(IC_IMM);
 440         break;
 441       }
 442     }
 443     bool onInteger(int64_t TmpInt, StringRef &ErrMsg) {
 444       IntelExprState CurrState = State;
 445       switch (State) {
 446       default:
 447         State = IES_ERROR;
 448         break;
 449       case IES_PLUS:
 450       case IES_MINUS:
 451       case IES_OR:
 452       case IES_AND:
 453       case IES_LSHIFT:
 454       case IES_RSHIFT:
 455       case IES_DIVIDE:
 456       case IES_MULTIPLY:
 457       case IES_LPAREN:
 458         State = IES_INTEGER;
 459         if (PrevState == IES_REGISTER && CurrState == IES_MULTIPLY) {
 460           // Index Register - Register * Scale
 461           assert (!IndexReg && "IndexReg already set!");
 462           IndexReg = TmpReg;
 463           Scale = TmpInt;
 464           if(Scale != 1 && Scale != 2 && Scale != 4 && Scale != 8) {
 465             ErrMsg = "scale factor in address must be 1, 2, 4 or 8";
 466             return true;
 467           }
 468           // Get the scale and replace the 'Register * Scale' with '0'.
 469           IC.popOperator();
 470         } else if ((PrevState == IES_PLUS || PrevState == IES_MINUS ||
 471                     PrevState == IES_OR || PrevState == IES_AND ||
 472                     PrevState == IES_LSHIFT || PrevState == IES_RSHIFT ||
 473                     PrevState == IES_MULTIPLY || PrevState == IES_DIVIDE ||
 474                     PrevState == IES_LPAREN || PrevState == IES_LBRAC) &&
 475                    CurrState == IES_MINUS) {
 476           // Unary minus.  No need to pop the minus operand because it was never
 477           // pushed.
 478           IC.pushOperand(IC_IMM, -TmpInt); // Push -Imm.
 479         } else {
 480           IC.pushOperand(IC_IMM, TmpInt);
 481         }
 482         break;
 483       }
 484       PrevState = CurrState;
 485       return false;
 486     }
 487     void onStar() {
 488       PrevState = State;
 489       switch (State) {
 490       default:
 491         State = IES_ERROR;
 492         break;
 493       case IES_INTEGER:
 494       case IES_REGISTER:
 495       case IES_RPAREN:
 496         State = IES_MULTIPLY;
 497         IC.pushOperator(IC_MULTIPLY);
 498         break;
 499       }
 500     }
 501     void onDivide() {
 502       PrevState = State;
 503       switch (State) {
 504       default:
 505         State = IES_ERROR;
 506         break;
 507       case IES_INTEGER:
 508       case IES_RPAREN:
 509         State = IES_DIVIDE;
 510         IC.pushOperator(IC_DIVIDE);
 511         break;
 512       }
 513     }
 514     void onLBrac() {
 515       PrevState = State;
 516       switch (State) {
 517       default:
 518         State = IES_ERROR;
 519         break;
 520       case IES_RBRAC:
 521         State = IES_PLUS;
 522         IC.pushOperator(IC_PLUS);
 523         break;
 524       }
 525     }
 526     void onRBrac() {
 527       IntelExprState CurrState = State;
 528       switch (State) {
 529       default:
 530         State = IES_ERROR;
 531         break;
 532       case IES_INTEGER:
 533       case IES_REGISTER:
 534       case IES_RPAREN:
 535         State = IES_RBRAC;
 536         if (CurrState == IES_REGISTER && PrevState != IES_MULTIPLY) {
 537           // If we already have a BaseReg, then assume this is the IndexReg with
 538           // a scale of 1.
 539           if (!BaseReg) {
 540             BaseReg = TmpReg;
 541           } else {
 542             assert (!IndexReg && "BaseReg/IndexReg already set!");
 543             IndexReg = TmpReg;
 544             Scale = 1;
 545           }
 546         }
 547         break;
 548       }
 549       PrevState = CurrState;
 550     }
 551     void onLParen() {
 552       IntelExprState CurrState = State;
 553       switch (State) {
 554       default:
 555         State = IES_ERROR;
 556         break;
 557       case IES_PLUS:
 558       case IES_MINUS:
 559       case IES_OR:
 560       case IES_AND:
 561       case IES_LSHIFT:
 562       case IES_RSHIFT:
 563       case IES_MULTIPLY:
 564       case IES_DIVIDE:
 565       case IES_LPAREN:
 566         // FIXME: We don't handle this type of unary minus, yet.
 567         if ((PrevState == IES_PLUS || PrevState == IES_MINUS ||
 568             PrevState == IES_OR || PrevState == IES_AND ||
 569             PrevState == IES_LSHIFT || PrevState == IES_RSHIFT ||
 570             PrevState == IES_MULTIPLY || PrevState == IES_DIVIDE ||
 571             PrevState == IES_LPAREN || PrevState == IES_LBRAC) &&
 572             CurrState == IES_MINUS) {
 573           State = IES_ERROR;
 574           break;
 575         }
 576         State = IES_LPAREN;
 577         IC.pushOperator(IC_LPAREN);
 578         break;
 579       }
 580       PrevState = CurrState;
 581     }
 582     void onRParen() {
 583       PrevState = State;
 584       switch (State) {
 585       default:
 586         State = IES_ERROR;
 587         break;
 588       case IES_INTEGER:
 589       case IES_REGISTER:
 590       case IES_RPAREN:
 591         State = IES_RPAREN;
 592         IC.pushOperator(IC_RPAREN);
 593         break;
 594       }
 595     }
 596   };
 597
 598   MCAsmParser &getParser() const { return Parser; }
 599
 600   MCAsmLexer &getLexer() const { return Parser.getLexer(); }
 601
 602   bool Error(SMLoc L, const Twine &Msg,
 603              ArrayRef<SMRange> Ranges = None,
 604              bool MatchingInlineAsm = false) {
 605     if (MatchingInlineAsm) return true;
 606     return Parser.Error(L, Msg, Ranges);
 607   }
 608
 609   bool ErrorAndEatStatement(SMLoc L, const Twine &Msg,
 610           ArrayRef<SMRange> Ranges = None,
 611           bool MatchingInlineAsm = false) {
 612       Parser.eatToEndOfStatement();
 613       return Error(L, Msg, Ranges, MatchingInlineAsm);
 614   }
 615
 616   X86Operand *ErrorOperand(SMLoc Loc, StringRef Msg) {
 617     Error(Loc, Msg);
 618     return 0;
 619   }
 620
 621   X86Operand *DefaultMemSIOperand(SMLoc Loc);
 622   X86Operand *DefaultMemDIOperand(SMLoc Loc);
 623   X86Operand *ParseOperand();
 624   X86Operand *ParseATTOperand();
 625   X86Operand *ParseIntelOperand();
 626   X86Operand *ParseIntelOffsetOfOperator();
 627   bool ParseIntelDotOperator(const MCExpr *Disp, const MCExpr *&NewDisp);
 628   X86Operand *ParseIntelOperator(unsigned OpKind);
 629   X86Operand *ParseIntelSegmentOverride(unsigned SegReg, SMLoc Start, unsigned Size);
 630   X86Operand *ParseIntelMemOperand(int64_t ImmDisp, SMLoc StartLoc,
 631                                    unsigned Size);
 632   bool ParseIntelExpression(IntelExprStateMachine &SM, SMLoc &End);
 633   X86Operand *ParseIntelBracExpression(unsigned SegReg, SMLoc Start,
 634                                        int64_t ImmDisp, unsigned Size);
 635   bool ParseIntelIdentifier(const MCExpr *&Val, StringRef &Identifier,
 636                             InlineAsmIdentifierInfo &Info,
 637                             bool IsUnevaluatedOperand, SMLoc &End);
 638
 639   X86Operand *ParseMemOperand(unsigned SegReg, SMLoc StartLoc);
 640
 641   X86Operand *CreateMemForInlineAsm(unsigned SegReg, const MCExpr *Disp,
 642                                     unsigned BaseReg, unsigned IndexReg,
 643                                     unsigned Scale, SMLoc Start, SMLoc End,
 644                                     unsigned Size, StringRef Identifier,
 645                                     InlineAsmIdentifierInfo &Info);
 646
 647   bool ParseDirectiveWord(unsigned Size, SMLoc L);
 648   bool ParseDirectiveCode(StringRef IDVal, SMLoc L);
 649
 650   bool processInstruction(MCInst &Inst,
 651                           const SmallVectorImpl<MCParsedAsmOperand*> &Ops);
 652
 653   bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
 654                                SmallVectorImpl<MCParsedAsmOperand*> &Operands,
 655                                MCStreamer &Out, unsigned &ErrorInfo,
 656                                bool MatchingInlineAsm);
 657
 658   /// doSrcDstMatch - Returns true if operands are matching in their
 659   /// word size (%si and %di, %esi and %edi, etc.). Order depends on
 660   /// the parsing mode (Intel vs. AT&T).
 661   bool doSrcDstMatch(X86Operand &Op1, X86Operand &Op2);
 662
 663   /// Parses AVX512 specific operand primitives: masked registers ({%k<NUM>}, {z})
 664   /// and memory broadcasting ({1to<NUM>}) primitives, updating Operands vector if required.
 665   /// \return \c true if no parsing errors occurred, \c false otherwise.
 666   bool HandleAVX512Operand(SmallVectorImpl<MCParsedAsmOperand*> &Operands,
 667                             const MCParsedAsmOperand &Op);
 668
 669   bool is64BitMode() const {
 670     // FIXME: Can tablegen auto-generate this?
 671     return (STI.getFeatureBits() & X86::Mode64Bit) != 0;
 672   }
 673   bool is32BitMode() const {
 674     // FIXME: Can tablegen auto-generate this?
 675     return (STI.getFeatureBits() & X86::Mode32Bit) != 0;
 676   }
 677   bool is16BitMode() const {
 678     // FIXME: Can tablegen auto-generate this?
 679     return (STI.getFeatureBits() & X86::Mode16Bit) != 0;
 680   }
 681   void SwitchMode(uint64_t mode) {
 682     uint64_t oldMode = STI.getFeatureBits() &
 683         (X86::Mode64Bit | X86::Mode32Bit | X86::Mode16Bit);
 684     unsigned FB = ComputeAvailableFeatures(STI.ToggleFeature(oldMode | mode));
 685     setAvailableFeatures(FB);
 686     assert(mode == (STI.getFeatureBits() &
 687                     (X86::Mode64Bit | X86::Mode32Bit | X86::Mode16Bit)));
 688   }
 689
 690   bool isParsingIntelSyntax() {
 691     return getParser().getAssemblerDialect();
 692   }
 693
 694   /// @name Auto-generated Matcher Functions
 695   /// {
 696
 697 #define GET_ASSEMBLER_HEADER
 698 #include "X86GenAsmMatcher.inc"
 699
 700   /// }
 701
 702 public:
 703   X86AsmParser(MCSubtargetInfo &sti, MCAsmParser &parser,
 704                const MCInstrInfo &MII)
 705       : MCTargetAsmParser(), STI(sti), Parser(parser), InstInfo(0) {
 706
 707     // Initialize the set of available features.
 708     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
 709   }
 710   virtual bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc);
 711
 712   virtual bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
 713                                 SMLoc NameLoc,
 714                                 SmallVectorImpl<MCParsedAsmOperand*> &Operands);
 715
 716   virtual bool ParseDirective(AsmToken DirectiveID);
 717 };
 718 } // end anonymous namespace
 719
 720 /// @name Auto-generated Match Functions
 721 /// {
 722
 723 static unsigned MatchRegisterName(StringRef Name);
 724
 725 /// }
 726
 727 static bool CheckBaseRegAndIndexReg(unsigned BaseReg, unsigned IndexReg,
 728                                     StringRef &ErrMsg) {
 729   // If we have both a base register and an index register make sure they are
 730   // both 64-bit or 32-bit registers.
 731   // To support VSIB, IndexReg can be 128-bit or 256-bit registers.
 732   if (BaseReg != 0 && IndexReg != 0) {
 733     if (X86MCRegisterClasses[X86::GR64RegClassID].contains(BaseReg) &&
 734         (X86MCRegisterClasses[X86::GR16RegClassID].contains(IndexReg) ||
 735          X86MCRegisterClasses[X86::GR32RegClassID].contains(IndexReg)) &&
 736         IndexReg != X86::RIZ) {
 737       ErrMsg = "base register is 64-bit, but index register is not";
 738       return true;
 739     }
 740     if (X86MCRegisterClasses[X86::GR32RegClassID].contains(BaseReg) &&
 741         (X86MCRegisterClasses[X86::GR16RegClassID].contains(IndexReg) ||
 742          X86MCRegisterClasses[X86::GR64RegClassID].contains(IndexReg)) &&
 743         IndexReg != X86::EIZ){
 744       ErrMsg = "base register is 32-bit, but index register is not";
 745       return true;
 746     }
 747     if (X86MCRegisterClasses[X86::GR16RegClassID].contains(BaseReg)) {
 748       if (X86MCRegisterClasses[X86::GR32RegClassID].contains(IndexReg) ||
 749           X86MCRegisterClasses[X86::GR64RegClassID].contains(IndexReg)) {
 750         ErrMsg = "base register is 16-bit, but index register is not";
 751         return true;
 752       }
 753       if (((BaseReg == X86::BX || BaseReg == X86::BP) &&
 754            IndexReg != X86::SI && IndexReg != X86::DI) ||
 755           ((BaseReg == X86::SI || BaseReg == X86::DI) &&
 756            IndexReg != X86::BX && IndexReg != X86::BP)) {
 757         ErrMsg = "invalid 16-bit base/index register combination";
 758         return true;
 759       }
 760     }
 761   }
 762   return false;
 763 }
 764
 765 bool X86AsmParser::doSrcDstMatch(X86Operand &Op1, X86Operand &Op2)
 766 {
 767   // Return true and let a normal complaint about bogus operands happen.
 768   if (!Op1.isMem() || !Op2.isMem())
 769     return true;
 770
 771   // Actually these might be the other way round if Intel syntax is
 772   // being used. It doesn't matter.
 773   unsigned diReg = Op1.Mem.BaseReg;
 774   unsigned siReg = Op2.Mem.BaseReg;
 775
 776   if (X86MCRegisterClasses[X86::GR16RegClassID].contains(siReg))
 777     return X86MCRegisterClasses[X86::GR16RegClassID].contains(diReg);
 778   if (X86MCRegisterClasses[X86::GR32RegClassID].contains(siReg))
 779     return X86MCRegisterClasses[X86::GR32RegClassID].contains(diReg);
 780   if (X86MCRegisterClasses[X86::GR64RegClassID].contains(siReg))
 781     return X86MCRegisterClasses[X86::GR64RegClassID].contains(diReg);
 782   // Again, return true and let another error happen.
 783   return true;
 784 }
 785
 786 bool X86AsmParser::ParseRegister(unsigned &RegNo,
 787                                  SMLoc &StartLoc, SMLoc &EndLoc) {
 788   RegNo = 0;
 789   const AsmToken &PercentTok = Parser.getTok();
 790   StartLoc = PercentTok.getLoc();
 791
 792   // If we encounter a %, ignore it. This code handles registers with and
 793   // without the prefix, unprefixed registers can occur in cfi directives.
 794   if (!isParsingIntelSyntax() && PercentTok.is(AsmToken::Percent))
 795     Parser.Lex(); // Eat percent token.
 796
 797   const AsmToken &Tok = Parser.getTok();
 798   EndLoc = Tok.getEndLoc();
 799
 800   if (Tok.isNot(AsmToken::Identifier)) {
 801     if (isParsingIntelSyntax()) return true;
 802     return Error(StartLoc, "invalid register name",
 803                  SMRange(StartLoc, EndLoc));
 804   }
 805
 806   RegNo = MatchRegisterName(Tok.getString());
 807
 808   // If the match failed, try the register name as lowercase.
 809   if (RegNo == 0)
 810     RegNo = MatchRegisterName(Tok.getString().lower());
 811
 812   if (!is64BitMode()) {
 813     // FIXME: This should be done using Requires<Not64BitMode> and
 814     // Requires<In64BitMode> so "eiz" usage in 64-bit instructions can be also
 815     // checked.
 816     // FIXME: Check AH, CH, DH, BH cannot be used in an instruction requiring a
 817     // REX prefix.
 818     if (RegNo == X86::RIZ ||
 819         X86MCRegisterClasses[X86::GR64RegClassID].contains(RegNo) ||
 820         X86II::isX86_64NonExtLowByteReg(RegNo) ||
 821         X86II::isX86_64ExtendedReg(RegNo))
 822       return Error(StartLoc, "register %"
 823                    + Tok.getString() + " is only available in 64-bit mode",
 824                    SMRange(StartLoc, EndLoc));
 825   }
 826
 827   // Parse "%st" as "%st(0)" and "%st(1)", which is multiple tokens.
 828   if (RegNo == 0 && (Tok.getString() == "st" || Tok.getString() == "ST")) {
 829     RegNo = X86::ST0;
 830     Parser.Lex(); // Eat 'st'
 831
 832     // Check to see if we have '(4)' after %st.
 833     if (getLexer().isNot(AsmToken::LParen))
 834       return false;
 835     // Lex the paren.
 836     getParser().Lex();
 837
 838     const AsmToken &IntTok = Parser.getTok();
 839     if (IntTok.isNot(AsmToken::Integer))
 840       return Error(IntTok.getLoc(), "expected stack index");
 841     switch (IntTok.getIntVal()) {
 842     case 0: RegNo = X86::ST0; break;
 843     case 1: RegNo = X86::ST1; break;
 844     case 2: RegNo = X86::ST2; break;
 845     case 3: RegNo = X86::ST3; break;
 846     case 4: RegNo = X86::ST4; break;
 847     case 5: RegNo = X86::ST5; break;
 848     case 6: RegNo = X86::ST6; break;
 849     case 7: RegNo = X86::ST7; break;
 850     default: return Error(IntTok.getLoc(), "invalid stack index");
 851     }
 852
 853     if (getParser().Lex().isNot(AsmToken::RParen))
 854       return Error(Parser.getTok().getLoc(), "expected ')'");
 855
 856     EndLoc = Parser.getTok().getEndLoc();
 857     Parser.Lex(); // Eat ')'
 858     return false;
 859   }
 860
 861   EndLoc = Parser.getTok().getEndLoc();
 862
 863   // If this is "db[0-7]", match it as an alias
 864   // for dr[0-7].
 865   if (RegNo == 0 && Tok.getString().size() == 3 &&
 866       Tok.getString().startswith("db")) {
 867     switch (Tok.getString()[2]) {
 868     case '0': RegNo = X86::DR0; break;
 869     case '1': RegNo = X86::DR1; break;
 870     case '2': RegNo = X86::DR2; break;
 871     case '3': RegNo = X86::DR3; break;
 872     case '4': RegNo = X86::DR4; break;
 873     case '5': RegNo = X86::DR5; break;
 874     case '6': RegNo = X86::DR6; break;
 875     case '7': RegNo = X86::DR7; break;
 876     }
 877
 878     if (RegNo != 0) {
 879       EndLoc = Parser.getTok().getEndLoc();
 880       Parser.Lex(); // Eat it.
 881       return false;
 882     }
 883   }
 884
 885   if (RegNo == 0) {
 886     if (isParsingIntelSyntax()) return true;
 887     return Error(StartLoc, "invalid register name",
 888                  SMRange(StartLoc, EndLoc));
 889   }
 890
 891   Parser.Lex(); // Eat identifier token.
 892   return false;
 893 }
 894
 895 X86Operand *X86AsmParser::DefaultMemSIOperand(SMLoc Loc) {
 896   unsigned basereg =
 897     is64BitMode() ? X86::RSI : (is32BitMode() ? X86::ESI : X86::SI);
 898   const MCExpr *Disp = MCConstantExpr::Create(0, getContext());
 899   return X86Operand::CreateMem(/*SegReg=*/0, Disp, /*BaseReg=*/basereg,
 900                                /*IndexReg=*/0, /*Scale=*/1, Loc, Loc, 0);
 901 }
 902
 903 X86Operand *X86AsmParser::DefaultMemDIOperand(SMLoc Loc) {
 904   unsigned basereg =
 905     is64BitMode() ? X86::RDI : (is32BitMode() ? X86::EDI : X86::DI);
 906   const MCExpr *Disp = MCConstantExpr::Create(0, getContext());
 907   return X86Operand::CreateMem(/*SegReg=*/0, Disp, /*BaseReg=*/basereg,
 908                                /*IndexReg=*/0, /*Scale=*/1, Loc, Loc, 0);
 909 }
 910
 911 X86Operand *X86AsmParser::ParseOperand() {
 912   if (isParsingIntelSyntax())
 913     return ParseIntelOperand();
 914   return ParseATTOperand();
 915 }
 916
 917 /// getIntelMemOperandSize - Return intel memory operand size.
 918 static unsigned getIntelMemOperandSize(StringRef OpStr) {
 919   unsigned Size = StringSwitch<unsigned>(OpStr)
 920     .Cases("BYTE", "byte", 8)
 921     .Cases("WORD", "word", 16)
 922     .Cases("DWORD", "dword", 32)
 923     .Cases("QWORD", "qword", 64)
 924     .Cases("XWORD", "xword", 80)
 925     .Cases("XMMWORD", "xmmword", 128)
 926     .Cases("YMMWORD", "ymmword", 256)
 927     .Cases("ZMMWORD", "zmmword", 512)
 928     .Cases("OPAQUE", "opaque", -1U) // needs to be non-zero, but doesn't matter
 929     .Default(0);
 930   return Size;
 931 }
 932
 933 X86Operand *
 934 X86AsmParser::CreateMemForInlineAsm(unsigned SegReg, const MCExpr *Disp,
 935                                     unsigned BaseReg, unsigned IndexReg,
 936                                     unsigned Scale, SMLoc Start, SMLoc End,
 937                                     unsigned Size, StringRef Identifier,
 938                                     InlineAsmIdentifierInfo &Info){
 939   // If this is not a VarDecl then assume it is a FuncDecl or some other label
 940   // reference.  We need an 'r' constraint here, so we need to create register
 941   // operand to ensure proper matching.  Just pick a GPR based on the size of
 942   // a pointer.
 943   if (isa<MCSymbolRefExpr>(Disp) && !Info.IsVarDecl) {
 944     unsigned RegNo =
 945         is64BitMode() ? X86::RBX : (is32BitMode() ? X86::EBX : X86::BX);
 946     return X86Operand::CreateReg(RegNo, Start, End, /*AddressOf=*/true,
 947                                  SMLoc(), Identifier, Info.OpDecl);
 948   }
 949
 950   // We either have a direct symbol reference, or an offset from a symbol.  The
 951   // parser always puts the symbol on the LHS, so look there for size
 952   // calculation purposes.
 953   const MCBinaryExpr *BinOp = dyn_cast<MCBinaryExpr>(Disp);
 954   bool IsSymRef =
 955       isa<MCSymbolRefExpr>(BinOp ? BinOp->getLHS() : Disp);
 956   if (IsSymRef) {
 957     if (!Size) {
 958       Size = Info.Type * 8; // Size is in terms of bits in this context.
 959       if (Size)
 960         InstInfo->AsmRewrites->push_back(AsmRewrite(AOK_SizeDirective, Start,
 961                                                     /*Len=*/0, Size));
 962     }
 963   }
 964
 965   // When parsing inline assembly we set the base register to a non-zero value
 966   // if we don't know the actual value at this time.  This is necessary to
 967   // get the matching correct in some cases.
 968   BaseReg = BaseReg ? BaseReg : 1;
 969   return X86Operand::CreateMem(SegReg, Disp, BaseReg, IndexReg, Scale, Start,
 970                                End, Size, Identifier, Info.OpDecl);
 971 }
 972
 973 static void
 974 RewriteIntelBracExpression(SmallVectorImpl<AsmRewrite> *AsmRewrites,
 975                            StringRef SymName, int64_t ImmDisp,
 976                            int64_t FinalImmDisp, SMLoc &BracLoc,
 977                            SMLoc &StartInBrac, SMLoc &End) {
 978   // Remove the '[' and ']' from the IR string.
 979   AsmRewrites->push_back(AsmRewrite(AOK_Skip, BracLoc, 1));
 980   AsmRewrites->push_back(AsmRewrite(AOK_Skip, End, 1));
 981
 982   // If ImmDisp is non-zero, then we parsed a displacement before the
 983   // bracketed expression (i.e., ImmDisp [ BaseReg + Scale*IndexReg + Disp])
 984   // If ImmDisp doesn't match the displacement computed by the state machine
 985   // then we have an additional displacement in the bracketed expression.
 986   if (ImmDisp != FinalImmDisp) {
 987     if (ImmDisp) {
 988       // We have an immediate displacement before the bracketed expression.
 989       // Adjust this to match the final immediate displacement.
 990       bool Found = false;
 991       for (SmallVectorImpl<AsmRewrite>::iterator I = AsmRewrites->begin(),
 992              E = AsmRewrites->end(); I != E; ++I) {
 993         if ((*I).Loc.getPointer() > BracLoc.getPointer())
 994           continue;
 995         if ((*I).Kind == AOK_ImmPrefix || (*I).Kind == AOK_Imm) {
 996           assert (!Found && "ImmDisp already rewritten.");
 997           (*I).Kind = AOK_Imm;
 998           (*I).Len = BracLoc.getPointer() - (*I).Loc.getPointer();
 999           (*I).Val = FinalImmDisp;
1000           Found = true;
1001           break;
1002         }
1003       }
1004       assert (Found && "Unable to rewrite ImmDisp.");
1005       (void)Found;
1006     } else {
1007       // We have a symbolic and an immediate displacement, but no displacement
1008       // before the bracketed expression.  Put the immediate displacement
1009       // before the bracketed expression.
1010       AsmRewrites->push_back(AsmRewrite(AOK_Imm, BracLoc, 0, FinalImmDisp));
1011     }
1012   }
1013   // Remove all the ImmPrefix rewrites within the brackets.
1014   for (SmallVectorImpl<AsmRewrite>::iterator I = AsmRewrites->begin(),
1015          E = AsmRewrites->end(); I != E; ++I) {
1016     if ((*I).Loc.getPointer() < StartInBrac.getPointer())
1017       continue;
1018     if ((*I).Kind == AOK_ImmPrefix)
1019       (*I).Kind = AOK_Delete;
1020   }
1021   const char *SymLocPtr = SymName.data();
1022   // Skip everything before the symbol.
1023   if (unsigned Len = SymLocPtr - StartInBrac.getPointer()) {
1024     assert(Len > 0 && "Expected a non-negative length.");
1025     AsmRewrites->push_back(AsmRewrite(AOK_Skip, StartInBrac, Len));
1026   }
1027   // Skip everything after the symbol.
1028   if (unsigned Len = End.getPointer() - (SymLocPtr + SymName.size())) {
1029     SMLoc Loc = SMLoc::getFromPointer(SymLocPtr + SymName.size());
1030     assert(Len > 0 && "Expected a non-negative length.");
1031     AsmRewrites->push_back(AsmRewrite(AOK_Skip, Loc, Len));
1032   }
1033 }
1034
1035 bool X86AsmParser::ParseIntelExpression(IntelExprStateMachine &SM, SMLoc &End) {
1036   const AsmToken &Tok = Parser.getTok();
1037
1038   bool Done = false;
1039   while (!Done) {
1040     bool UpdateLocLex = true;
1041
1042     // The period in the dot operator (e.g., [ebx].foo.bar) is parsed as an
1043     // identifier.  Don't try an parse it as a register.
1044     if (Tok.getString().startswith("."))
1045       break;
1046
1047     // If we're parsing an immediate expression, we don't expect a '['.
1048     if (SM.getStopOnLBrac() && getLexer().getKind() == AsmToken::LBrac)
1049       break;
1050
1051     switch (getLexer().getKind()) {
1052     default: {
1053       if (SM.isValidEndState()) {
1054         Done = true;
1055         break;
1056       }
1057       return Error(Tok.getLoc(), "unknown token in expression");
1058     }
1059     case AsmToken::EndOfStatement: {
1060       Done = true;
1061       break;
1062     }
1063     case AsmToken::Identifier: {
1064       // This could be a register or a symbolic displacement.
1065       unsigned TmpReg;
1066       const MCExpr *Val;
1067       SMLoc IdentLoc = Tok.getLoc();
1068       StringRef Identifier = Tok.getString();
1069       if(!ParseRegister(TmpReg, IdentLoc, End)) {
1070         SM.onRegister(TmpReg);
1071         UpdateLocLex = false;
1072         break;
1073       } else {
1074         if (!isParsingInlineAsm()) {
1075           if (getParser().parsePrimaryExpr(Val, End))
1076             return Error(Tok.getLoc(), "Unexpected identifier!");
1077         } else {
1078           InlineAsmIdentifierInfo &Info = SM.getIdentifierInfo();
1079           if (ParseIntelIdentifier(Val, Identifier, Info,
1080                                    /*Unevaluated=*/false, End))
1081             return true;
1082         }
1083         SM.onIdentifierExpr(Val, Identifier);
1084         UpdateLocLex = false;
1085         break;
1086       }
1087       return Error(Tok.getLoc(), "Unexpected identifier!");
1088     }
1089     case AsmToken::Integer: {
1090       StringRef ErrMsg;
1091       if (isParsingInlineAsm() && SM.getAddImmPrefix())
1092         InstInfo->AsmRewrites->push_back(AsmRewrite(AOK_ImmPrefix,
1093                                                     Tok.getLoc()));
1094       // Look for 'b' or 'f' following an Integer as a directional label
1095       SMLoc Loc = getTok().getLoc();
1096       int64_t IntVal = getTok().getIntVal();
1097       End = consumeToken();
1098       UpdateLocLex = false;
1099       if (getLexer().getKind() == AsmToken::Identifier) {
1100         StringRef IDVal = getTok().getString();
1101         if (IDVal == "f" || IDVal == "b") {
1102           MCSymbol *Sym =
1103             getContext().GetDirectionalLocalSymbol(IntVal,
1104                                                    IDVal == "f" ? 1 : 0);
1105           MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
1106           const MCExpr *Val =
1107             MCSymbolRefExpr::Create(Sym, Variant, getContext());
1108           if (IDVal == "b" && Sym->isUndefined())
1109             return Error(Loc, "invalid reference to undefined symbol");
1110           StringRef Identifier = Sym->getName();
1111           SM.onIdentifierExpr(Val, Identifier);
1112           End = consumeToken();
1113         } else {
1114           if (SM.onInteger(IntVal, ErrMsg))
1115             return Error(Loc, ErrMsg);
1116         }
1117       } else {
1118         if (SM.onInteger(IntVal, ErrMsg))
1119           return Error(Loc, ErrMsg);
1120       }
1121       break;
1122     }
1123     case AsmToken::Plus:    SM.onPlus(); break;
1124     case AsmToken::Minus:   SM.onMinus(); break;
1125     case AsmToken::Star:    SM.onStar(); break;
1126     case AsmToken::Slash:   SM.onDivide(); break;
1127     case AsmToken::Pipe:    SM.onOr(); break;
1128     case AsmToken::Amp:     SM.onAnd(); break;
1129     case AsmToken::LessLess:
1130                             SM.onLShift(); break;
1131     case AsmToken::GreaterGreater:
1132                             SM.onRShift(); break;
1133     case AsmToken::LBrac:   SM.onLBrac(); break;
1134     case AsmToken::RBrac:   SM.onRBrac(); break;
1135     case AsmToken::LParen:  SM.onLParen(); break;
1136     case AsmToken::RParen:  SM.onRParen(); break;
1137     }
1138     if (SM.hadError())
1139       return Error(Tok.getLoc(), "unknown token in expression");
1140
1141     if (!Done && UpdateLocLex)
1142       End = consumeToken();
1143   }
1144   return false;
1145 }
1146
1147 X86Operand *X86AsmParser::ParseIntelBracExpression(unsigned SegReg, SMLoc Start,
1148                                                    int64_t ImmDisp,
1149                                                    unsigned Size) {
1150   const AsmToken &Tok = Parser.getTok();
1151   SMLoc BracLoc = Tok.getLoc(), End = Tok.getEndLoc();
1152   if (getLexer().isNot(AsmToken::LBrac))
1153     return ErrorOperand(BracLoc, "Expected '[' token!");
1154   Parser.Lex(); // Eat '['
1155
1156   SMLoc StartInBrac = Tok.getLoc();
1157   // Parse [ Symbol + ImmDisp ] and [ BaseReg + Scale*IndexReg + ImmDisp ].  We
1158   // may have already parsed an immediate displacement before the bracketed
1159   // expression.
1160   IntelExprStateMachine SM(ImmDisp, /*StopOnLBrac=*/false, /*AddImmPrefix=*/true);
1161   if (ParseIntelExpression(SM, End))
1162     return 0;
1163
1164   const MCExpr *Disp = 0;
1165   if (const MCExpr *Sym = SM.getSym()) {
1166     // A symbolic displacement.
1167     Disp = Sym;
1168     if (isParsingInlineAsm())
1169       RewriteIntelBracExpression(InstInfo->AsmRewrites, SM.getSymName(),
1170                                  ImmDisp, SM.getImm(), BracLoc, StartInBrac,
1171                                  End);
1172   }
1173
1174   if (SM.getImm() || !Disp) {
1175     const MCExpr *Imm = MCConstantExpr::Create(SM.getImm(), getContext());
1176     if (Disp)
1177       Disp = MCBinaryExpr::CreateAdd(Disp, Imm, getContext());
1178     else
1179       Disp = Imm;  // An immediate displacement only.
1180   }
1181
1182   // Parse the dot operator (e.g., [ebx].foo.bar).
1183   if (Tok.getString().startswith(".")) {
1184     const MCExpr *NewDisp;
1185     if (ParseIntelDotOperator(Disp, NewDisp))
1186       return 0;
1187
1188     End = Tok.getEndLoc();
1189     Parser.Lex();  // Eat the field.
1190     Disp = NewDisp;
1191   }
1192
1193   int BaseReg = SM.getBaseReg();
1194   int IndexReg = SM.getIndexReg();
1195   int Scale = SM.getScale();
1196   if (!isParsingInlineAsm()) {
1197     // handle [-42]
1198     if (!BaseReg && !IndexReg) {
1199       if (!SegReg)
1200         return X86Operand::CreateMem(Disp, Start, End, Size);
1201       else
1202         return X86Operand::CreateMem(SegReg, Disp, 0, 0, 1, Start, End, Size);
1203     }
1204     StringRef ErrMsg;
1205     if (CheckBaseRegAndIndexReg(BaseReg, IndexReg, ErrMsg)) {
1206       Error(StartInBrac, ErrMsg);
1207       return 0;
1208     }
1209     return X86Operand::CreateMem(SegReg, Disp, BaseReg, IndexReg, Scale, Start,
1210                                  End, Size);
1211   }
1212
1213   InlineAsmIdentifierInfo &Info = SM.getIdentifierInfo();
1214   return CreateMemForInlineAsm(SegReg, Disp, BaseReg, IndexReg, Scale, Start,
1215                                End, Size, SM.getSymName(), Info);
1216 }
1217
1218 // Inline assembly may use variable names with namespace alias qualifiers.
1219 bool X86AsmParser::ParseIntelIdentifier(const MCExpr *&Val,
1220                                         StringRef &Identifier,
1221                                         InlineAsmIdentifierInfo &Info,
1222                                         bool IsUnevaluatedOperand, SMLoc &End) {
1223   assert (isParsingInlineAsm() && "Expected to be parsing inline assembly.");
1224   Val = 0;
1225
1226   StringRef LineBuf(Identifier.data());
1227   SemaCallback->LookupInlineAsmIdentifier(LineBuf, Info, IsUnevaluatedOperand);
1228
1229   const AsmToken &Tok = Parser.getTok();
1230
1231   // Advance the token stream until the end of the current token is
1232   // after the end of what the frontend claimed.
1233   const char *EndPtr = Tok.getLoc().getPointer() + LineBuf.size();
1234   while (true) {
1235     End = Tok.getEndLoc();
1236     getLexer().Lex();
1237
1238     assert(End.getPointer() <= EndPtr && "frontend claimed part of a token?");
1239     if (End.getPointer() == EndPtr) break;
1240   }
1241
1242   // Create the symbol reference.
1243   Identifier = LineBuf;
1244   MCSymbol *Sym = getContext().GetOrCreateSymbol(Identifier);
1245   MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
1246   Val = MCSymbolRefExpr::Create(Sym, Variant, getParser().getContext());
1247   return false;
1248 }
1249
1250 /// \brief Parse intel style segment override.
1251 X86Operand *X86AsmParser::ParseIntelSegmentOverride(unsigned SegReg,
1252                                                     SMLoc Start,
1253                                                     unsigned Size) {
1254   assert(SegReg != 0 && "Tried to parse a segment override without a segment!");
1255   const AsmToken &Tok = Parser.getTok(); // Eat colon.
1256   if (Tok.isNot(AsmToken::Colon))
1257     return ErrorOperand(Tok.getLoc(), "Expected ':' token!");
1258   Parser.Lex(); // Eat ':'
1259
1260   int64_t ImmDisp = 0;
1261   if (getLexer().is(AsmToken::Integer)) {
1262     ImmDisp = Tok.getIntVal();
1263     AsmToken ImmDispToken = Parser.Lex(); // Eat the integer.
1264
1265     if (isParsingInlineAsm())
1266       InstInfo->AsmRewrites->push_back(
1267           AsmRewrite(AOK_ImmPrefix, ImmDispToken.getLoc()));
1268
1269     if (getLexer().isNot(AsmToken::LBrac)) {
1270       // An immediate following a 'segment register', 'colon' token sequence can
1271       // be followed by a bracketed expression.  If it isn't we know we have our
1272       // final segment override.
1273       const MCExpr *Disp = MCConstantExpr::Create(ImmDisp, getContext());
1274       return X86Operand::CreateMem(SegReg, Disp, /*BaseReg=*/0, /*IndexReg=*/0,
1275                                    /*Scale=*/1, Start, ImmDispToken.getEndLoc(),
1276                                    Size);
1277     }
1278   }
1279
1280   if (getLexer().is(AsmToken::LBrac))
1281     return ParseIntelBracExpression(SegReg, Start, ImmDisp, Size);
1282
1283   const MCExpr *Val;
1284   SMLoc End;
1285   if (!isParsingInlineAsm()) {
1286     if (getParser().parsePrimaryExpr(Val, End))
1287       return ErrorOperand(Tok.getLoc(), "unknown token in expression");
1288
1289     return X86Operand::CreateMem(Val, Start, End, Size);
1290   }
1291
1292   InlineAsmIdentifierInfo Info;
1293   StringRef Identifier = Tok.getString();
1294   if (ParseIntelIdentifier(Val, Identifier, Info,
1295                            /*Unevaluated=*/false, End))
1296     return 0;
1297   return CreateMemForInlineAsm(/*SegReg=*/0, Val, /*BaseReg=*/0,/*IndexReg=*/0,
1298                                /*Scale=*/1, Start, End, Size, Identifier, Info);
1299 }
1300
1301 /// ParseIntelMemOperand - Parse intel style memory operand.
1302 X86Operand *X86AsmParser::ParseIntelMemOperand(int64_t ImmDisp, SMLoc Start,
1303                                                unsigned Size) {
1304   const AsmToken &Tok = Parser.getTok();
1305   SMLoc End;
1306
1307   // Parse ImmDisp [ BaseReg + Scale*IndexReg + Disp ].
1308   if (getLexer().is(AsmToken::LBrac))
1309     return ParseIntelBracExpression(/*SegReg=*/0, Start, ImmDisp, Size);
1310
1311   const MCExpr *Val;
1312   if (!isParsingInlineAsm()) {
1313     if (getParser().parsePrimaryExpr(Val, End))
1314       return ErrorOperand(Tok.getLoc(), "unknown token in expression");
1315
1316     return X86Operand::CreateMem(Val, Start, End, Size);
1317   }
1318
1319   InlineAsmIdentifierInfo Info;
1320   StringRef Identifier = Tok.getString();
1321   if (ParseIntelIdentifier(Val, Identifier, Info,
1322                            /*Unevaluated=*/false, End))
1323     return 0;
1324   return CreateMemForInlineAsm(/*SegReg=*/0, Val, /*BaseReg=*/0, /*IndexReg=*/0,
1325                                /*Scale=*/1, Start, End, Size, Identifier, Info);
1326 }
1327
1328 /// Parse the '.' operator.
1329 bool X86AsmParser::ParseIntelDotOperator(const MCExpr *Disp,
1330                                                 const MCExpr *&NewDisp) {
1331   const AsmToken &Tok = Parser.getTok();
1332   int64_t OrigDispVal, DotDispVal;
1333
1334   // FIXME: Handle non-constant expressions.
1335   if (const MCConstantExpr *OrigDisp = dyn_cast<MCConstantExpr>(Disp))
1336     OrigDispVal = OrigDisp->getValue();
1337   else
1338     return Error(Tok.getLoc(), "Non-constant offsets are not supported!");
1339
1340   // Drop the '.'.
1341   StringRef DotDispStr = Tok.getString().drop_front(1);
1342
1343   // .Imm gets lexed as a real.
1344   if (Tok.is(AsmToken::Real)) {
1345     APInt DotDisp;
1346     DotDispStr.getAsInteger(10, DotDisp);
1347     DotDispVal = DotDisp.getZExtValue();
1348   } else if (isParsingInlineAsm() && Tok.is(AsmToken::Identifier)) {
1349     unsigned DotDisp;
1350     std::pair<StringRef, StringRef> BaseMember = DotDispStr.split('.');
1351     if (SemaCallback->LookupInlineAsmField(BaseMember.first, BaseMember.second,
1352                                            DotDisp))
1353       return Error(Tok.getLoc(), "Unable to lookup field reference!");
1354     DotDispVal = DotDisp;
1355   } else
1356     return Error(Tok.getLoc(), "Unexpected token type!");
1357
1358   if (isParsingInlineAsm() && Tok.is(AsmToken::Identifier)) {
1359     SMLoc Loc = SMLoc::getFromPointer(DotDispStr.data());
1360     unsigned Len = DotDispStr.size();
1361     unsigned Val = OrigDispVal + DotDispVal;
1362     InstInfo->AsmRewrites->push_back(AsmRewrite(AOK_DotOperator, Loc, Len,
1363                                                 Val));
1364   }
1365
1366   NewDisp = MCConstantExpr::Create(OrigDispVal + DotDispVal, getContext());
1367   return false;
1368 }
1369
1370 /// Parse the 'offset' operator.  This operator is used to specify the
1371 /// location rather then the content of a variable.
1372 X86Operand *X86AsmParser::ParseIntelOffsetOfOperator() {
1373   const AsmToken &Tok = Parser.getTok();
1374   SMLoc OffsetOfLoc = Tok.getLoc();
1375   Parser.Lex(); // Eat offset.
1376
1377   const MCExpr *Val;
1378   InlineAsmIdentifierInfo Info;
1379   SMLoc Start = Tok.getLoc(), End;
1380   StringRef Identifier = Tok.getString();
1381   if (ParseIntelIdentifier(Val, Identifier, Info,
1382                            /*Unevaluated=*/false, End))
1383     return 0;
1384
1385   // Don't emit the offset operator.
1386   InstInfo->AsmRewrites->push_back(AsmRewrite(AOK_Skip, OffsetOfLoc, 7));
1387
1388   // The offset operator will have an 'r' constraint, thus we need to create
1389   // register operand to ensure proper matching.  Just pick a GPR based on
1390   // the size of a pointer.
1391   unsigned RegNo =
1392       is64BitMode() ? X86::RBX : (is32BitMode() ? X86::EBX : X86::BX);
1393   return X86Operand::CreateReg(RegNo, Start, End, /*GetAddress=*/true,
1394                                OffsetOfLoc, Identifier, Info.OpDecl);
1395 }
1396
1397 enum IntelOperatorKind {
1398   IOK_LENGTH,
1399   IOK_SIZE,
1400   IOK_TYPE
1401 };
1402
1403 /// Parse the 'LENGTH', 'TYPE' and 'SIZE' operators.  The LENGTH operator
1404 /// returns the number of elements in an array.  It returns the value 1 for
1405 /// non-array variables.  The SIZE operator returns the size of a C or C++
1406 /// variable.  A variable's size is the product of its LENGTH and TYPE.  The
1407 /// TYPE operator returns the size of a C or C++ type or variable. If the
1408 /// variable is an array, TYPE returns the size of a single element.
1409 X86Operand *X86AsmParser::ParseIntelOperator(unsigned OpKind) {
1410   const AsmToken &Tok = Parser.getTok();
1411   SMLoc TypeLoc = Tok.getLoc();
1412   Parser.Lex(); // Eat operator.
1413
1414   const MCExpr *Val = 0;
1415   InlineAsmIdentifierInfo Info;
1416   SMLoc Start = Tok.getLoc(), End;
1417   StringRef Identifier = Tok.getString();
1418   if (ParseIntelIdentifier(Val, Identifier, Info,
1419                            /*Unevaluated=*/true, End))
1420     return 0;
1421
1422   if (!Info.OpDecl)
1423     return ErrorOperand(Start, "unable to lookup expression");
1424
1425   unsigned CVal = 0;
1426   switch(OpKind) {
1427   default: llvm_unreachable("Unexpected operand kind!");
1428   case IOK_LENGTH: CVal = Info.Length; break;
1429   case IOK_SIZE: CVal = Info.Size; break;
1430   case IOK_TYPE: CVal = Info.Type; break;
1431   }
1432
1433   // Rewrite the type operator and the C or C++ type or variable in terms of an
1434   // immediate.  E.g. TYPE foo -> $$4
1435   unsigned Len = End.getPointer() - TypeLoc.getPointer();
1436   InstInfo->AsmRewrites->push_back(AsmRewrite(AOK_Imm, TypeLoc, Len, CVal));
1437
1438   const MCExpr *Imm = MCConstantExpr::Create(CVal, getContext());
1439   return X86Operand::CreateImm(Imm, Start, End);
1440 }
1441
1442 X86Operand *X86AsmParser::ParseIntelOperand() {
1443   const AsmToken &Tok = Parser.getTok();
1444   SMLoc Start, End;
1445
1446   // Offset, length, type and size operators.
1447   if (isParsingInlineAsm()) {
1448     StringRef AsmTokStr = Tok.getString();
1449     if (AsmTokStr == "offset" || AsmTokStr == "OFFSET")
1450       return ParseIntelOffsetOfOperator();
1451     if (AsmTokStr == "length" || AsmTokStr == "LENGTH")
1452       return ParseIntelOperator(IOK_LENGTH);
1453     if (AsmTokStr == "size" || AsmTokStr == "SIZE")
1454       return ParseIntelOperator(IOK_SIZE);
1455     if (AsmTokStr == "type" || AsmTokStr == "TYPE")
1456       return ParseIntelOperator(IOK_TYPE);
1457   }
1458
1459   unsigned Size = getIntelMemOperandSize(Tok.getString());
1460   if (Size) {
1461     Parser.Lex(); // Eat operand size (e.g., byte, word).
1462     if (Tok.getString() != "PTR" && Tok.getString() != "ptr")
1463       return ErrorOperand(Start, "Expected 'PTR' or 'ptr' token!");
1464     Parser.Lex(); // Eat ptr.
1465   }
1466   Start = Tok.getLoc();
1467
1468   // Immediate.
1469   if (getLexer().is(AsmToken::Integer) || getLexer().is(AsmToken::Minus) ||
1470       getLexer().is(AsmToken::LParen)) {
1471     AsmToken StartTok = Tok;
1472     IntelExprStateMachine SM(/*Imm=*/0, /*StopOnLBrac=*/true,
1473                              /*AddImmPrefix=*/false);
1474     if (ParseIntelExpression(SM, End))
1475       return 0;
1476
1477     int64_t Imm = SM.getImm();
1478     if (isParsingInlineAsm()) {
1479       unsigned Len = Tok.getLoc().getPointer() - Start.getPointer();
1480       if (StartTok.getString().size() == Len)
1481         // Just add a prefix if this wasn't a complex immediate expression.
1482         InstInfo->AsmRewrites->push_back(AsmRewrite(AOK_ImmPrefix, Start));
1483       else
1484         // Otherwise, rewrite the complex expression as a single immediate.
1485         InstInfo->AsmRewrites->push_back(AsmRewrite(AOK_Imm, Start, Len, Imm));
1486     }
1487
1488     if (getLexer().isNot(AsmToken::LBrac)) {
1489       // If a directional label (ie. 1f or 2b) was parsed above from
1490       // ParseIntelExpression() then SM.getSym() was set to a pointer to
1491       // to the MCExpr with the directional local symbol and this is a
1492       // memory operand not an immediate operand.
1493       if (SM.getSym())
1494         return X86Operand::CreateMem(SM.getSym(), Start, End, Size);
1495
1496       const MCExpr *ImmExpr = MCConstantExpr::Create(Imm, getContext());
1497       return X86Operand::CreateImm(ImmExpr, Start, End);
1498     }
1499
1500     // Only positive immediates are valid.
1501     if (Imm < 0)
1502       return ErrorOperand(Start, "expected a positive immediate displacement "
1503                           "before bracketed expr.");
1504
1505     // Parse ImmDisp [ BaseReg + Scale*IndexReg + Disp ].
1506     return ParseIntelMemOperand(Imm, Start, Size);
1507   }
1508
1509   // Register.
1510   unsigned RegNo = 0;
1511   if (!ParseRegister(RegNo, Start, End)) {
1512     // If this is a segment register followed by a ':', then this is the start
1513     // of a segment override, otherwise this is a normal register reference.
1514     if (getLexer().isNot(AsmToken::Colon))
1515       return X86Operand::CreateReg(RegNo, Start, End);
1516
1517     return ParseIntelSegmentOverride(/*SegReg=*/RegNo, Start, Size);
1518   }
1519
1520   // Memory operand.
1521   return ParseIntelMemOperand(/*Disp=*/0, Start, Size);
1522 }
1523
1524 X86Operand *X86AsmParser::ParseATTOperand() {
1525   switch (getLexer().getKind()) {
1526   default:
1527     // Parse a memory operand with no segment register.
1528     return ParseMemOperand(0, Parser.getTok().getLoc());
1529   case AsmToken::Percent: {
1530     // Read the register.
1531     unsigned RegNo;
1532     SMLoc Start, End;
1533     if (ParseRegister(RegNo, Start, End)) return 0;
1534     if (RegNo == X86::EIZ || RegNo == X86::RIZ) {
1535       Error(Start, "%eiz and %riz can only be used as index registers",
1536             SMRange(Start, End));
1537       return 0;
1538     }
1539
1540     // If this is a segment register followed by a ':', then this is the start
1541     // of a memory reference, otherwise this is a normal register reference.
1542     if (getLexer().isNot(AsmToken::Colon))
1543       return X86Operand::CreateReg(RegNo, Start, End);
1544
1545     getParser().Lex(); // Eat the colon.
1546     return ParseMemOperand(RegNo, Start);
1547   }
1548   case AsmToken::Dollar: {
1549     // $42 -> immediate.
1550     SMLoc Start = Parser.getTok().getLoc(), End;
1551     Parser.Lex();
1552     const MCExpr *Val;
1553     if (getParser().parseExpression(Val, End))
1554       return 0;
1555     return X86Operand::CreateImm(Val, Start, End);
1556   }
1557   }
1558 }
1559
1560 bool
1561 X86AsmParser::HandleAVX512Operand(SmallVectorImpl<MCParsedAsmOperand*> &Operands,
1562                                   const MCParsedAsmOperand &Op) {
1563   if(STI.getFeatureBits() & X86::FeatureAVX512) {
1564     if (getLexer().is(AsmToken::LCurly)) {
1565       // Eat "{" and mark the current place.
1566       const SMLoc consumedToken = consumeToken();
1567       // Distinguish {1to<NUM>} from {%k<NUM>}.
1568       if(getLexer().is(AsmToken::Integer)) {
1569         // Parse memory broadcasting ({1to<NUM>}).
1570         if (getLexer().getTok().getIntVal() != 1)
1571           return !ErrorAndEatStatement(getLexer().getLoc(),
1572                                        "Expected 1to<NUM> at this point");
1573         Parser.Lex();  // Eat "1" of 1to8
1574         if (!getLexer().is(AsmToken::Identifier) ||
1575             !getLexer().getTok().getIdentifier().startswith("to"))
1576           return !ErrorAndEatStatement(getLexer().getLoc(),
1577                                        "Expected 1to<NUM> at this point");
1578         // Recognize only reasonable suffixes.
1579         const char *BroadcastPrimitive =
1580           StringSwitch<const char*>(getLexer().getTok().getIdentifier())
1581             .Case("to8",  "{1to8}")
1582             .Case("to16", "{1to16}")
1583             .Default(0);
1584         if (!BroadcastPrimitive)
1585           return !ErrorAndEatStatement(getLexer().getLoc(),
1586                                        "Invalid memory broadcast primitive.");
1587         Parser.Lex();  // Eat "toN" of 1toN
1588         if (!getLexer().is(AsmToken::RCurly))
1589           return !ErrorAndEatStatement(getLexer().getLoc(),
1590                                        "Expected } at this point");
1591         Parser.Lex();  // Eat "}"
1592         Operands.push_back(X86Operand::CreateToken(BroadcastPrimitive,
1593                                                    consumedToken));
1594         // No AVX512 specific primitives can pass
1595         // after memory broadcasting, so return.
1596         return true;
1597       } else {
1598         // Parse mask register {%k1}
1599         Operands.push_back(X86Operand::CreateToken("{", consumedToken));
1600         if (X86Operand *Op = ParseOperand()) {
1601           Operands.push_back(Op);
1602           if (!getLexer().is(AsmToken::RCurly))
1603             return !ErrorAndEatStatement(getLexer().getLoc(),
1604                                          "Expected } at this point");
1605           Operands.push_back(X86Operand::CreateToken("}", consumeToken()));
1606
1607           // Parse "zeroing non-masked" semantic {z}
1608           if (getLexer().is(AsmToken::LCurly)) {
1609             Operands.push_back(X86Operand::CreateToken("{z}", consumeToken()));
1610             if (!getLexer().is(AsmToken::Identifier) ||
1611                 getLexer().getTok().getIdentifier() != "z")
1612               return !ErrorAndEatStatement(getLexer().getLoc(),
1613                                            "Expected z at this point");
1614             Parser.Lex();  // Eat the z
1615             if (!getLexer().is(AsmToken::RCurly))
1616               return !ErrorAndEatStatement(getLexer().getLoc(),
1617                                            "Expected } at this point");
1618             Parser.Lex();  // Eat the }
1619           }
1620         }
1621       }
1622     }
1623   }
1624   return true;
1625 }
1626
1627 /// ParseMemOperand: segment: disp(basereg, indexreg, scale).  The '%ds:' prefix
1628 /// has already been parsed if present.
1629 X86Operand *X86AsmParser::ParseMemOperand(unsigned SegReg, SMLoc MemStart) {
1630
1631   // We have to disambiguate a parenthesized expression "(4+5)" from the start
1632   // of a memory operand with a missing displacement "(%ebx)" or "(,%eax)".  The
1633   // only way to do this without lookahead is to eat the '(' and see what is
1634   // after it.
1635   const MCExpr *Disp = MCConstantExpr::Create(0, getParser().getContext());
1636   if (getLexer().isNot(AsmToken::LParen)) {
1637     SMLoc ExprEnd;
1638     if (getParser().parseExpression(Disp, ExprEnd)) return 0;
1639
1640     // After parsing the base expression we could either have a parenthesized
1641     // memory address or not.  If not, return now.  If so, eat the (.
1642     if (getLexer().isNot(AsmToken::LParen)) {
1643       // Unless we have a segment register, treat this as an immediate.
1644       if (SegReg == 0)
1645         return X86Operand::CreateMem(Disp, MemStart, ExprEnd);
1646       return X86Operand::CreateMem(SegReg, Disp, 0, 0, 1, MemStart, ExprEnd);
1647     }
1648
1649     // Eat the '('.
1650     Parser.Lex();
1651   } else {
1652     // Okay, we have a '('.  We don't know if this is an expression or not, but
1653     // so we have to eat the ( to see beyond it.
1654     SMLoc LParenLoc = Parser.getTok().getLoc();
1655     Parser.Lex(); // Eat the '('.
1656
1657     if (getLexer().is(AsmToken::Percent) || getLexer().is(AsmToken::Comma)) {
1658       // Nothing to do here, fall into the code below with the '(' part of the
1659       // memory operand consumed.
1660     } else {
1661       SMLoc ExprEnd;
1662
1663       // It must be an parenthesized expression, parse it now.
1664       if (getParser().parseParenExpression(Disp, ExprEnd))
1665         return 0;
1666
1667       // After parsing the base expression we could either have a parenthesized
1668       // memory address or not.  If not, return now.  If so, eat the (.
1669       if (getLexer().isNot(AsmToken::LParen)) {
1670         // Unless we have a segment register, treat this as an immediate.
1671         if (SegReg == 0)
1672           return X86Operand::CreateMem(Disp, LParenLoc, ExprEnd);
1673         return X86Operand::CreateMem(SegReg, Disp, 0, 0, 1, MemStart, ExprEnd);
1674       }
1675
1676       // Eat the '('.
1677       Parser.Lex();
1678     }
1679   }
1680
1681   // If we reached here, then we just ate the ( of the memory operand.  Process
1682   // the rest of the memory operand.
1683   unsigned BaseReg = 0, IndexReg = 0, Scale = 1;
1684   SMLoc IndexLoc, BaseLoc;
1685
1686   if (getLexer().is(AsmToken::Percent)) {
1687     SMLoc StartLoc, EndLoc;
1688     BaseLoc = Parser.getTok().getLoc();
1689     if (ParseRegister(BaseReg, StartLoc, EndLoc)) return 0;
1690     if (BaseReg == X86::EIZ || BaseReg == X86::RIZ) {
1691       Error(StartLoc, "eiz and riz can only be used as index registers",
1692             SMRange(StartLoc, EndLoc));
1693       return 0;
1694     }
1695   }
1696
1697   if (getLexer().is(AsmToken::Comma)) {
1698     Parser.Lex(); // Eat the comma.
1699     IndexLoc = Parser.getTok().getLoc();
1700
1701     // Following the comma we should have either an index register, or a scale
1702     // value. We don't support the later form, but we want to parse it
1703     // correctly.
1704     //
1705     // Not that even though it would be completely consistent to support syntax
1706     // like "1(%eax,,1)", the assembler doesn't. Use "eiz" or "riz" for this.
1707     if (getLexer().is(AsmToken::Percent)) {
1708       SMLoc L;
1709       if (ParseRegister(IndexReg, L, L)) return 0;
1710
1711       if (getLexer().isNot(AsmToken::RParen)) {
1712         // Parse the scale amount:
1713         //  ::= ',' [scale-expression]
1714         if (getLexer().isNot(AsmToken::Comma)) {
1715           Error(Parser.getTok().getLoc(),
1716                 "expected comma in scale expression");
1717           return 0;
1718         }
1719         Parser.Lex(); // Eat the comma.
1720
1721         if (getLexer().isNot(AsmToken::RParen)) {
1722           SMLoc Loc = Parser.getTok().getLoc();
1723
1724           int64_t ScaleVal;
1725           if (getParser().parseAbsoluteExpression(ScaleVal)){
1726             Error(Loc, "expected scale expression");
1727             return 0;
1728           }
1729
1730           // Validate the scale amount.
1731           if (X86MCRegisterClasses[X86::GR16RegClassID].contains(BaseReg) &&
1732               ScaleVal != 1) {
1733             Error(Loc, "scale factor in 16-bit address must be 1");
1734             return 0;
1735           }
1736           if (ScaleVal != 1 && ScaleVal != 2 && ScaleVal != 4 && ScaleVal != 8){
1737             Error(Loc, "scale factor in address must be 1, 2, 4 or 8");
1738             return 0;
1739           }
1740           Scale = (unsigned)ScaleVal;
1741         }
1742       }
1743     } else if (getLexer().isNot(AsmToken::RParen)) {
1744       // A scale amount without an index is ignored.
1745       // index.
1746       SMLoc Loc = Parser.getTok().getLoc();
1747
1748       int64_t Value;
1749       if (getParser().parseAbsoluteExpression(Value))
1750         return 0;
1751
1752       if (Value != 1)
1753         Warning(Loc, "scale factor without index register is ignored");
1754       Scale = 1;
1755     }
1756   }
1757
1758   // Ok, we've eaten the memory operand, verify we have a ')' and eat it too.
1759   if (getLexer().isNot(AsmToken::RParen)) {
1760     Error(Parser.getTok().getLoc(), "unexpected token in memory operand");
1761     return 0;
1762   }
1763   SMLoc MemEnd = Parser.getTok().getEndLoc();
1764   Parser.Lex(); // Eat the ')'.
1765
1766   // Check for use of invalid 16-bit registers. Only BX/BP/SI/DI are allowed,
1767   // and then only in non-64-bit modes. Except for DX, which is a special case
1768   // because an unofficial form of in/out instructions uses it.
1769   if (X86MCRegisterClasses[X86::GR16RegClassID].contains(BaseReg) &&
1770       (is64BitMode() || (BaseReg != X86::BX && BaseReg != X86::BP &&
1771                          BaseReg != X86::SI && BaseReg != X86::DI)) &&
1772       BaseReg != X86::DX) {
1773     Error(BaseLoc, "invalid 16-bit base register");
1774     return 0;
1775   }
1776   if (BaseReg == 0 &&
1777       X86MCRegisterClasses[X86::GR16RegClassID].contains(IndexReg)) {
1778     Error(IndexLoc, "16-bit memory operand may not include only index register");
1779     return 0;
1780   }
1781
1782   StringRef ErrMsg;
1783   if (CheckBaseRegAndIndexReg(BaseReg, IndexReg, ErrMsg)) {
1784     Error(BaseLoc, ErrMsg);
1785     return 0;
1786   }
1787
1788   return X86Operand::CreateMem(SegReg, Disp, BaseReg, IndexReg, Scale,
1789                                MemStart, MemEnd);
1790 }
1791
1792 bool X86AsmParser::
1793 ParseInstruction(ParseInstructionInfo &Info, StringRef Name, SMLoc NameLoc,
1794                  SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1795   InstInfo = &Info;
1796   StringRef PatchedName = Name;
1797
1798   // FIXME: Hack to recognize setneb as setne.
1799   if (PatchedName.startswith("set") && PatchedName.endswith("b") &&
1800       PatchedName != "setb" && PatchedName != "setnb")
1801     PatchedName = PatchedName.substr(0, Name.size()-1);
1802
1803   // FIXME: Hack to recognize cmp<comparison code>{ss,sd,ps,pd}.
1804   const MCExpr *ExtraImmOp = 0;
1805   if ((PatchedName.startswith("cmp") || PatchedName.startswith("vcmp")) &&
1806       (PatchedName.endswith("ss") || PatchedName.endswith("sd") ||
1807        PatchedName.endswith("ps") || PatchedName.endswith("pd"))) {
1808     bool IsVCMP = PatchedName[0] == 'v';
1809     unsigned SSECCIdx = IsVCMP ? 4 : 3;
1810     unsigned SSEComparisonCode = StringSwitch<unsigned>(
1811       PatchedName.slice(SSECCIdx, PatchedName.size() - 2))
1812       .Case("eq",       0x00)
1813       .Case("lt",       0x01)
1814       .Case("le",       0x02)
1815       .Case("unord",    0x03)
1816       .Case("neq",      0x04)
1817       .Case("nlt",      0x05)
1818       .Case("nle",      0x06)
1819       .Case("ord",      0x07)
1820       /* AVX only from here */
1821       .Case("eq_uq",    0x08)
1822       .Case("nge",      0x09)
1823       .Case("ngt",      0x0A)
1824       .Case("false",    0x0B)
1825       .Case("neq_oq",   0x0C)
1826       .Case("ge",       0x0D)
1827       .Case("gt",       0x0E)
1828       .Case("true",     0x0F)
1829       .Case("eq_os",    0x10)
1830       .Case("lt_oq",    0x11)
1831       .Case("le_oq",    0x12)
1832       .Case("unord_s",  0x13)
1833       .Case("neq_us",   0x14)
1834       .Case("nlt_uq",   0x15)
1835       .Case("nle_uq",   0x16)
1836       .Case("ord_s",    0x17)
1837       .Case("eq_us",    0x18)
1838       .Case("nge_uq",   0x19)
1839       .Case("ngt_uq",   0x1A)
1840       .Case("false_os", 0x1B)
1841       .Case("neq_os",   0x1C)
1842       .Case("ge_oq",    0x1D)
1843       .Case("gt_oq",    0x1E)
1844       .Case("true_us",  0x1F)
1845       .Default(~0U);
1846     if (SSEComparisonCode != ~0U && (IsVCMP || SSEComparisonCode < 8)) {
1847       ExtraImmOp = MCConstantExpr::Create(SSEComparisonCode,
1848                                           getParser().getContext());
1849       if (PatchedName.endswith("ss")) {
1850         PatchedName = IsVCMP ? "vcmpss" : "cmpss";
1851       } else if (PatchedName.endswith("sd")) {
1852         PatchedName = IsVCMP ? "vcmpsd" : "cmpsd";
1853       } else if (PatchedName.endswith("ps")) {
1854         PatchedName = IsVCMP ? "vcmpps" : "cmpps";
1855       } else {
1856         assert(PatchedName.endswith("pd") && "Unexpected mnemonic!");
1857         PatchedName = IsVCMP ? "vcmppd" : "cmppd";
1858       }
1859     }
1860   }
1861
1862   Operands.push_back(X86Operand::CreateToken(PatchedName, NameLoc));
1863
1864   if (ExtraImmOp && !isParsingIntelSyntax())
1865     Operands.push_back(X86Operand::CreateImm(ExtraImmOp, NameLoc, NameLoc));
1866
1867   // Determine whether this is an instruction prefix.
1868   bool isPrefix =
1869     Name == "lock" || Name == "rep" ||
1870     Name == "repe" || Name == "repz" ||
1871     Name == "repne" || Name == "repnz" ||
1872     Name == "rex64" || Name == "data16";
1873
1874
1875   // This does the actual operand parsing.  Don't parse any more if we have a
1876   // prefix juxtaposed with an operation like "lock incl 4(%rax)", because we
1877   // just want to parse the "lock" as the first instruction and the "incl" as
1878   // the next one.
1879   if (getLexer().isNot(AsmToken::EndOfStatement) && !isPrefix) {
1880
1881     // Parse '*' modifier.
1882     if (getLexer().is(AsmToken::Star))
1883       Operands.push_back(X86Operand::CreateToken("*", consumeToken()));
1884
1885     // Read the operands.
1886     while(1) {
1887       if (X86Operand *Op = ParseOperand()) {
1888          Operands.push_back(Op);
1889         if (!HandleAVX512Operand(Operands, *Op))
1890           return true;
1891       } else {
1892          Parser.eatToEndOfStatement();
1893          return true;
1894       }
1895       // check for comma and eat it
1896       if (getLexer().is(AsmToken::Comma))
1897         Parser.Lex();
1898       else
1899         break;
1900      }
1901
1902     if (getLexer().isNot(AsmToken::EndOfStatement))
1903       return ErrorAndEatStatement(getLexer().getLoc(),
1904                                   "unexpected token in argument list");
1905    }
1906
1907   // Consume the EndOfStatement or the prefix separator Slash
1908   if (getLexer().is(AsmToken::EndOfStatement) ||
1909       (isPrefix && getLexer().is(AsmToken::Slash)))
1910     Parser.Lex();
1911
1912   if (ExtraImmOp && isParsingIntelSyntax())
1913     Operands.push_back(X86Operand::CreateImm(ExtraImmOp, NameLoc, NameLoc));
1914
1915   // This is a terrible hack to handle "out[bwl]? %al, (%dx)" ->
1916   // "outb %al, %dx".  Out doesn't take a memory form, but this is a widely
1917   // documented form in various unofficial manuals, so a lot of code uses it.
1918   if ((Name == "outb" || Name == "outw" || Name == "outl" || Name == "out") &&
1919       Operands.size() == 3) {
1920     X86Operand &Op = *(X86Operand*)Operands.back();
1921     if (Op.isMem() && Op.Mem.SegReg == 0 &&
1922         isa<MCConstantExpr>(Op.Mem.Disp) &&
1923         cast<MCConstantExpr>(Op.Mem.Disp)->getValue() == 0 &&
1924         Op.Mem.BaseReg == MatchRegisterName("dx") && Op.Mem.IndexReg == 0) {
1925       SMLoc Loc = Op.getEndLoc();
1926       Operands.back() = X86Operand::CreateReg(Op.Mem.BaseReg, Loc, Loc);
1927       delete &Op;
1928     }
1929   }
1930   // Same hack for "in[bwl]? (%dx), %al" -> "inb %dx, %al".
1931   if ((Name == "inb" || Name == "inw" || Name == "inl" || Name == "in") &&
1932       Operands.size() == 3) {
1933     X86Operand &Op = *(X86Operand*)Operands.begin()[1];
1934     if (Op.isMem() && Op.Mem.SegReg == 0 &&
1935         isa<MCConstantExpr>(Op.Mem.Disp) &&
1936         cast<MCConstantExpr>(Op.Mem.Disp)->getValue() == 0 &&
1937         Op.Mem.BaseReg == MatchRegisterName("dx") && Op.Mem.IndexReg == 0) {
1938       SMLoc Loc = Op.getEndLoc();
1939       Operands.begin()[1] = X86Operand::CreateReg(Op.Mem.BaseReg, Loc, Loc);
1940       delete &Op;
1941     }
1942   }
1943
1944   // Append default arguments to "ins[bwld]"
1945   if (Name.startswith("ins") && Operands.size() == 1 &&
1946       (Name == "insb" || Name == "insw" || Name == "insl" ||
1947        Name == "insd" )) {
1948     if (isParsingIntelSyntax()) {
1949       Operands.push_back(X86Operand::CreateReg(X86::DX, NameLoc, NameLoc));
1950       Operands.push_back(DefaultMemDIOperand(NameLoc));
1951     } else {
1952       Operands.push_back(X86Operand::CreateReg(X86::DX, NameLoc, NameLoc));
1953       Operands.push_back(DefaultMemDIOperand(NameLoc));
1954     }
1955   }
1956
1957   // Append default arguments to "outs[bwld]"
1958   if (Name.startswith("outs") && Operands.size() == 1 &&
1959       (Name == "outsb" || Name == "outsw" || Name == "outsl" ||
1960        Name == "outsd" )) {
1961     if (isParsingIntelSyntax()) {
1962       Operands.push_back(DefaultMemSIOperand(NameLoc));
1963       Operands.push_back(X86Operand::CreateReg(X86::DX, NameLoc, NameLoc));
1964     } else {
1965       Operands.push_back(DefaultMemSIOperand(NameLoc));
1966       Operands.push_back(X86Operand::CreateReg(X86::DX, NameLoc, NameLoc));
1967     }
1968   }
1969
1970   // Transform "lods[bwlq]" into "lods[bwlq] ($SIREG)" for appropriate
1971   // values of $SIREG according to the mode. It would be nice if this
1972   // could be achieved with InstAlias in the tables.
1973   if (Name.startswith("lods") && Operands.size() == 1 &&
1974       (Name == "lods" || Name == "lodsb" || Name == "lodsw" ||
1975        Name == "lodsl" || Name == "lodsd" || Name == "lodsq"))
1976     Operands.push_back(DefaultMemSIOperand(NameLoc));
1977
1978   // Transform "stos[bwlq]" into "stos[bwlq] ($DIREG)" for appropriate
1979   // values of $DIREG according to the mode. It would be nice if this
1980   // could be achieved with InstAlias in the tables.
1981   if (Name.startswith("stos") && Operands.size() == 1 &&
1982       (Name == "stos" || Name == "stosb" || Name == "stosw" ||
1983        Name == "stosl" || Name == "stosd" || Name == "stosq"))
1984     Operands.push_back(DefaultMemDIOperand(NameLoc));
1985
1986   // Transform "scas[bwlq]" into "scas[bwlq] ($DIREG)" for appropriate
1987   // values of $DIREG according to the mode. It would be nice if this
1988   // could be achieved with InstAlias in the tables.
1989   if (Name.startswith("scas") && Operands.size() == 1 &&
1990       (Name == "scas" || Name == "scasb" || Name == "scasw" ||
1991        Name == "scasl" || Name == "scasd" || Name == "scasq"))
1992     Operands.push_back(DefaultMemDIOperand(NameLoc));
1993
1994   // Add default SI and DI operands to "cmps[bwlq]".
1995   if (Name.startswith("cmps") &&
1996       (Name == "cmps" || Name == "cmpsb" || Name == "cmpsw" ||
1997        Name == "cmpsl" || Name == "cmpsd" || Name == "cmpsq")) {
1998     if (Operands.size() == 1) {
1999       if (isParsingIntelSyntax()) {
2000         Operands.push_back(DefaultMemSIOperand(NameLoc));
2001         Operands.push_back(DefaultMemDIOperand(NameLoc));
2002       } else {
2003         Operands.push_back(DefaultMemDIOperand(NameLoc));
2004         Operands.push_back(DefaultMemSIOperand(NameLoc));
2005       }
2006     } else if (Operands.size() == 3) {
2007       X86Operand &Op = *(X86Operand*)Operands.begin()[1];
2008       X86Operand &Op2 = *(X86Operand*)Operands.begin()[2];
2009       if (!doSrcDstMatch(Op, Op2))
2010         return Error(Op.getStartLoc(),
2011                      "mismatching source and destination index registers");
2012     }
2013   }
2014
2015   // Add default SI and DI operands to "movs[bwlq]".
2016   if ((Name.startswith("movs") &&
2017       (Name == "movs" || Name == "movsb" || Name == "movsw" ||
2018        Name == "movsl" || Name == "movsd" || Name == "movsq")) ||
2019       (Name.startswith("smov") &&
2020       (Name == "smov" || Name == "smovb" || Name == "smovw" ||
2021        Name == "smovl" || Name == "smovd" || Name == "smovq"))) {
2022     if (Operands.size() == 1) {
2023       if (Name == "movsd")
2024         Operands.back() = X86Operand::CreateToken("movsl", NameLoc);
2025       if (isParsingIntelSyntax()) {
2026         Operands.push_back(DefaultMemDIOperand(NameLoc));
2027         Operands.push_back(DefaultMemSIOperand(NameLoc));
2028       } else {
2029         Operands.push_back(DefaultMemSIOperand(NameLoc));
2030         Operands.push_back(DefaultMemDIOperand(NameLoc));
2031       }
2032     } else if (Operands.size() == 3) {
2033       X86Operand &Op = *(X86Operand*)Operands.begin()[1];
2034       X86Operand &Op2 = *(X86Operand*)Operands.begin()[2];
2035       if (!doSrcDstMatch(Op, Op2))
2036         return Error(Op.getStartLoc(),
2037                      "mismatching source and destination index registers");
2038     }
2039   }
2040
2041   // FIXME: Hack to handle recognize s{hr,ar,hl} $1, <op>.  Canonicalize to
2042   // "shift <op>".
2043   if ((Name.startswith("shr") || Name.startswith("sar") ||
2044        Name.startswith("shl") || Name.startswith("sal") ||
2045        Name.startswith("rcl") || Name.startswith("rcr") ||
2046        Name.startswith("rol") || Name.startswith("ror")) &&
2047       Operands.size() == 3) {
2048     if (isParsingIntelSyntax()) {
2049       // Intel syntax
2050       X86Operand *Op1 = static_cast<X86Operand*>(Operands[2]);
2051       if (Op1->isImm() && isa<MCConstantExpr>(Op1->getImm()) &&
2052           cast<MCConstantExpr>(Op1->getImm())->getValue() == 1) {
2053         delete Operands[2];
2054         Operands.pop_back();
2055       }
2056     } else {
2057       X86Operand *Op1 = static_cast<X86Operand*>(Operands[1]);
2058       if (Op1->isImm() && isa<MCConstantExpr>(Op1->getImm()) &&
2059           cast<MCConstantExpr>(Op1->getImm())->getValue() == 1) {
2060         delete Operands[1];
2061         Operands.erase(Operands.begin() + 1);
2062       }
2063     }
2064   }
2065
2066   // Transforms "int $3" into "int3" as a size optimization.  We can't write an
2067   // instalias with an immediate operand yet.
2068   if (Name == "int" && Operands.size() == 2) {
2069     X86Operand *Op1 = static_cast<X86Operand*>(Operands[1]);
2070     if (Op1->isImm() && isa<MCConstantExpr>(Op1->getImm()) &&
2071         cast<MCConstantExpr>(Op1->getImm())->getValue() == 3) {
2072       delete Operands[1];
2073       Operands.erase(Operands.begin() + 1);
2074       static_cast<X86Operand*>(Operands[0])->setTokenValue("int3");
2075     }
2076   }
2077
2078   return false;
2079 }
2080
2081 static bool convertToSExti8(MCInst &Inst, unsigned Opcode, unsigned Reg,
2082                             bool isCmp) {
2083   MCInst TmpInst;
2084   TmpInst.setOpcode(Opcode);
2085   if (!isCmp)
2086     TmpInst.addOperand(MCOperand::CreateReg(Reg));
2087   TmpInst.addOperand(MCOperand::CreateReg(Reg));
2088   TmpInst.addOperand(Inst.getOperand(0));
2089   Inst = TmpInst;
2090   return true;
2091 }
2092
2093 static bool convert16i16to16ri8(MCInst &Inst, unsigned Opcode,
2094                                 bool isCmp = false) {
2095   if (!Inst.getOperand(0).isImm() ||
2096       !isImmSExti16i8Value(Inst.getOperand(0).getImm()))
2097     return false;
2098
2099   return convertToSExti8(Inst, Opcode, X86::AX, isCmp);
2100 }
2101
2102 static bool convert32i32to32ri8(MCInst &Inst, unsigned Opcode,
2103                                 bool isCmp = false) {
2104   if (!Inst.getOperand(0).isImm() ||
2105       !isImmSExti32i8Value(Inst.getOperand(0).getImm()))
2106     return false;
2107
2108   return convertToSExti8(Inst, Opcode, X86::EAX, isCmp);
2109 }
2110
2111 static bool convert64i32to64ri8(MCInst &Inst, unsigned Opcode,
2112                                 bool isCmp = false) {
2113   if (!Inst.getOperand(0).isImm() ||
2114       !isImmSExti64i8Value(Inst.getOperand(0).getImm()))
2115     return false;
2116
2117   return convertToSExti8(Inst, Opcode, X86::RAX, isCmp);
2118 }
2119
2120 bool X86AsmParser::
2121 processInstruction(MCInst &Inst,
2122                    const SmallVectorImpl<MCParsedAsmOperand*> &Ops) {
2123   switch (Inst.getOpcode()) {
2124   default: return false;
2125   case X86::AND16i16: return convert16i16to16ri8(Inst, X86::AND16ri8);
2126   case X86::AND32i32: return convert32i32to32ri8(Inst, X86::AND32ri8);
2127   case X86::AND64i32: return convert64i32to64ri8(Inst, X86::AND64ri8);
2128   case X86::XOR16i16: return convert16i16to16ri8(Inst, X86::XOR16ri8);
2129   case X86::XOR32i32: return convert32i32to32ri8(Inst, X86::XOR32ri8);
2130   case X86::XOR64i32: return convert64i32to64ri8(Inst, X86::XOR64ri8);
2131   case X86::OR16i16:  return convert16i16to16ri8(Inst, X86::OR16ri8);
2132   case X86::OR32i32:  return convert32i32to32ri8(Inst, X86::OR32ri8);
2133   case X86::OR64i32:  return convert64i32to64ri8(Inst, X86::OR64ri8);
2134   case X86::CMP16i16: return convert16i16to16ri8(Inst, X86::CMP16ri8, true);
2135   case X86::CMP32i32: return convert32i32to32ri8(Inst, X86::CMP32ri8, true);
2136   case X86::CMP64i32: return convert64i32to64ri8(Inst, X86::CMP64ri8, true);
2137   case X86::ADD16i16: return convert16i16to16ri8(Inst, X86::ADD16ri8);
2138   case X86::ADD32i32: return convert32i32to32ri8(Inst, X86::ADD32ri8);
2139   case X86::ADD64i32: return convert64i32to64ri8(Inst, X86::ADD64ri8);
2140   case X86::SUB16i16: return convert16i16to16ri8(Inst, X86::SUB16ri8);
2141   case X86::SUB32i32: return convert32i32to32ri8(Inst, X86::SUB32ri8);
2142   case X86::SUB64i32: return convert64i32to64ri8(Inst, X86::SUB64ri8);
2143   case X86::ADC16i16: return convert16i16to16ri8(Inst, X86::ADC16ri8);
2144   case X86::ADC32i32: return convert32i32to32ri8(Inst, X86::ADC32ri8);
2145   case X86::ADC64i32: return convert64i32to64ri8(Inst, X86::ADC64ri8);
2146   case X86::SBB16i16: return convert16i16to16ri8(Inst, X86::SBB16ri8);
2147   case X86::SBB32i32: return convert32i32to32ri8(Inst, X86::SBB32ri8);
2148   case X86::SBB64i32: return convert64i32to64ri8(Inst, X86::SBB64ri8);
2149   case X86::VMOVAPDrr:
2150   case X86::VMOVAPDYrr:
2151   case X86::VMOVAPSrr:
2152   case X86::VMOVAPSYrr:
2153   case X86::VMOVDQArr:
2154   case X86::VMOVDQAYrr:
2155   case X86::VMOVDQUrr:
2156   case X86::VMOVDQUYrr:
2157   case X86::VMOVUPDrr:
2158   case X86::VMOVUPDYrr:
2159   case X86::VMOVUPSrr:
2160   case X86::VMOVUPSYrr: {
2161     if (X86II::isX86_64ExtendedReg(Inst.getOperand(0).getReg()) ||
2162         !X86II::isX86_64ExtendedReg(Inst.getOperand(1).getReg()))
2163       return false;
2164
2165     unsigned NewOpc;
2166     switch (Inst.getOpcode()) {
2167     default: llvm_unreachable("Invalid opcode");
2168     case X86::VMOVAPDrr:  NewOpc = X86::VMOVAPDrr_REV;  break;
2169     case X86::VMOVAPDYrr: NewOpc = X86::VMOVAPDYrr_REV; break;
2170     case X86::VMOVAPSrr:  NewOpc = X86::VMOVAPSrr_REV;  break;
2171     case X86::VMOVAPSYrr: NewOpc = X86::VMOVAPSYrr_REV; break;
2172     case X86::VMOVDQArr:  NewOpc = X86::VMOVDQArr_REV;  break;
2173     case X86::VMOVDQAYrr: NewOpc = X86::VMOVDQAYrr_REV; break;
2174     case X86::VMOVDQUrr:  NewOpc = X86::VMOVDQUrr_REV;  break;
2175     case X86::VMOVDQUYrr: NewOpc = X86::VMOVDQUYrr_REV; break;
2176     case X86::VMOVUPDrr:  NewOpc = X86::VMOVUPDrr_REV;  break;
2177     case X86::VMOVUPDYrr: NewOpc = X86::VMOVUPDYrr_REV; break;
2178     case X86::VMOVUPSrr:  NewOpc = X86::VMOVUPSrr_REV;  break;
2179     case X86::VMOVUPSYrr: NewOpc = X86::VMOVUPSYrr_REV; break;
2180     }
2181     Inst.setOpcode(NewOpc);
2182     return true;
2183   }
2184   case X86::VMOVSDrr:
2185   case X86::VMOVSSrr: {
2186     if (X86II::isX86_64ExtendedReg(Inst.getOperand(0).getReg()) ||
2187         !X86II::isX86_64ExtendedReg(Inst.getOperand(2).getReg()))
2188       return false;
2189     unsigned NewOpc;
2190     switch (Inst.getOpcode()) {
2191     default: llvm_unreachable("Invalid opcode");
2192     case X86::VMOVSDrr: NewOpc = X86::VMOVSDrr_REV;   break;
2193     case X86::VMOVSSrr: NewOpc = X86::VMOVSSrr_REV;   break;
2194     }
2195     Inst.setOpcode(NewOpc);
2196     return true;
2197   }
2198   }
2199 }
2200
2201 static const char *getSubtargetFeatureName(unsigned Val);
2202 bool X86AsmParser::
2203 MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
2204                         SmallVectorImpl<MCParsedAsmOperand*> &Operands,
2205                         MCStreamer &Out, unsigned &ErrorInfo,
2206                         bool MatchingInlineAsm) {
2207   assert(!Operands.empty() && "Unexpect empty operand list!");
2208   X86Operand *Op = static_cast<X86Operand*>(Operands[0]);
2209   assert(Op->isToken() && "Leading operand should always be a mnemonic!");
2210   ArrayRef<SMRange> EmptyRanges = None;
2211
2212   // First, handle aliases that expand to multiple instructions.
2213   // FIXME: This should be replaced with a real .td file alias mechanism.
2214   // Also, MatchInstructionImpl should actually *do* the EmitInstruction
2215   // call.
2216   if (Op->getToken() == "fstsw" || Op->getToken() == "fstcw" ||
2217       Op->getToken() == "fstsww" || Op->getToken() == "fstcww" ||
2218       Op->getToken() == "finit" || Op->getToken() == "fsave" ||
2219       Op->getToken() == "fstenv" || Op->getToken() == "fclex") {
2220     MCInst Inst;
2221     Inst.setOpcode(X86::WAIT);
2222     Inst.setLoc(IDLoc);
2223     if (!MatchingInlineAsm)
2224       Out.EmitInstruction(Inst, STI);
2225
2226     const char *Repl =
2227       StringSwitch<const char*>(Op->getToken())
2228         .Case("finit",  "fninit")
2229         .Case("fsave",  "fnsave")
2230         .Case("fstcw",  "fnstcw")
2231         .Case("fstcww",  "fnstcw")
2232         .Case("fstenv", "fnstenv")
2233         .Case("fstsw",  "fnstsw")
2234         .Case("fstsww", "fnstsw")
2235         .Case("fclex",  "fnclex")
2236         .Default(0);
2237     assert(Repl && "Unknown wait-prefixed instruction");
2238     delete Operands[0];
2239     Operands[0] = X86Operand::CreateToken(Repl, IDLoc);
2240   }
2241
2242   bool WasOriginallyInvalidOperand = false;
2243   MCInst Inst;
2244
2245   // First, try a direct match.
2246   switch (MatchInstructionImpl(Operands, Inst,
2247                                ErrorInfo, MatchingInlineAsm,
2248                                isParsingIntelSyntax())) {
2249   default: break;
2250   case Match_Success:
2251     // Some instructions need post-processing to, for example, tweak which
2252     // encoding is selected. Loop on it while changes happen so the
2253     // individual transformations can chain off each other.
2254     if (!MatchingInlineAsm)
2255       while (processInstruction(Inst, Operands))
2256         ;
2257
2258     Inst.setLoc(IDLoc);
2259     if (!MatchingInlineAsm)
2260       Out.EmitInstruction(Inst, STI);
2261     Opcode = Inst.getOpcode();
2262     return false;
2263   case Match_MissingFeature: {
2264     assert(ErrorInfo && "Unknown missing feature!");
2265     // Special case the error message for the very common case where only
2266     // a single subtarget feature is missing.
2267     std::string Msg = "instruction requires:";
2268     unsigned Mask = 1;
2269     for (unsigned i = 0; i < (sizeof(ErrorInfo)*8-1); ++i) {
2270       if (ErrorInfo & Mask) {
2271         Msg += " ";
2272         Msg += getSubtargetFeatureName(ErrorInfo & Mask);
2273       }
2274       Mask <<= 1;
2275     }
2276     return Error(IDLoc, Msg, EmptyRanges, MatchingInlineAsm);
2277   }
2278   case Match_InvalidOperand:
2279     WasOriginallyInvalidOperand = true;
2280     break;
2281   case Match_MnemonicFail:
2282     break;
2283   }
2284
2285   // FIXME: Ideally, we would only attempt suffix matches for things which are
2286   // valid prefixes, and we could just infer the right unambiguous
2287   // type. However, that requires substantially more matcher support than the
2288   // following hack.
2289
2290   // Change the operand to point to a temporary token.
2291   StringRef Base = Op->getToken();
2292   SmallString<16> Tmp;
2293   Tmp += Base;
2294   Tmp += ' ';
2295   Op->setTokenValue(Tmp.str());
2296
2297   // If this instruction starts with an 'f', then it is a floating point stack
2298   // instruction.  These come in up to three forms for 32-bit, 64-bit, and
2299   // 80-bit floating point, which use the suffixes s,l,t respectively.
2300   //
2301   // Otherwise, we assume that this may be an integer instruction, which comes
2302   // in 8/16/32/64-bit forms using the b,w,l,q suffixes respectively.
2303   const char *Suffixes = Base[0] != 'f' ? "bwlq" : "slt\0";
2304
2305   // Check for the various suffix matches.
2306   Tmp[Base.size()] = Suffixes[0];
2307   unsigned ErrorInfoIgnore;
2308   unsigned ErrorInfoMissingFeature = 0; // Init suppresses compiler warnings.
2309   unsigned Match1, Match2, Match3, Match4;
2310
2311   Match1 = MatchInstructionImpl(Operands, Inst, ErrorInfoIgnore,
2312                                 MatchingInlineAsm, isParsingIntelSyntax());
2313   // If this returned as a missing feature failure, remember that.
2314   if (Match1 == Match_MissingFeature)
2315     ErrorInfoMissingFeature = ErrorInfoIgnore;
2316   Tmp[Base.size()] = Suffixes[1];
2317   Match2 = MatchInstructionImpl(Operands, Inst, ErrorInfoIgnore,
2318                                 MatchingInlineAsm, isParsingIntelSyntax());
2319   // If this returned as a missing feature failure, remember that.
2320   if (Match2 == Match_MissingFeature)
2321     ErrorInfoMissingFeature = ErrorInfoIgnore;
2322   Tmp[Base.size()] = Suffixes[2];
2323   Match3 = MatchInstructionImpl(Operands, Inst, ErrorInfoIgnore,
2324                                 MatchingInlineAsm, isParsingIntelSyntax());
2325   // If this returned as a missing feature failure, remember that.
2326   if (Match3 == Match_MissingFeature)
2327     ErrorInfoMissingFeature = ErrorInfoIgnore;
2328   Tmp[Base.size()] = Suffixes[3];
2329   Match4 = MatchInstructionImpl(Operands, Inst, ErrorInfoIgnore,
2330                                 MatchingInlineAsm, isParsingIntelSyntax());
2331   // If this returned as a missing feature failure, remember that.
2332   if (Match4 == Match_MissingFeature)
2333     ErrorInfoMissingFeature = ErrorInfoIgnore;
2334
2335   // Restore the old token.
2336   Op->setTokenValue(Base);
2337
2338   // If exactly one matched, then we treat that as a successful match (and the
2339   // instruction will already have been filled in correctly, since the failing
2340   // matches won't have modified it).
2341   unsigned NumSuccessfulMatches =
2342     (Match1 == Match_Success) + (Match2 == Match_Success) +
2343     (Match3 == Match_Success) + (Match4 == Match_Success);
2344   if (NumSuccessfulMatches == 1) {
2345     Inst.setLoc(IDLoc);
2346     if (!MatchingInlineAsm)
2347       Out.EmitInstruction(Inst, STI);
2348     Opcode = Inst.getOpcode();
2349     return false;
2350   }
2351
2352   // Otherwise, the match failed, try to produce a decent error message.
2353
2354   // If we had multiple suffix matches, then identify this as an ambiguous
2355   // match.
2356   if (NumSuccessfulMatches > 1) {
2357     char MatchChars[4];
2358     unsigned NumMatches = 0;
2359     if (Match1 == Match_Success) MatchChars[NumMatches++] = Suffixes[0];
2360     if (Match2 == Match_Success) MatchChars[NumMatches++] = Suffixes[1];
2361     if (Match3 == Match_Success) MatchChars[NumMatches++] = Suffixes[2];
2362     if (Match4 == Match_Success) MatchChars[NumMatches++] = Suffixes[3];
2363
2364     SmallString<126> Msg;
2365     raw_svector_ostream OS(Msg);
2366     OS << "ambiguous instructions require an explicit suffix (could be ";
2367     for (unsigned i = 0; i != NumMatches; ++i) {
2368       if (i != 0)
2369         OS << ", ";
2370       if (i + 1 == NumMatches)
2371         OS << "or ";
2372       OS << "'" << Base << MatchChars[i] << "'";
2373     }
2374     OS << ")";
2375     Error(IDLoc, OS.str(), EmptyRanges, MatchingInlineAsm);
2376     return true;
2377   }
2378
2379   // Okay, we know that none of the variants matched successfully.
2380
2381   // If all of the instructions reported an invalid mnemonic, then the original
2382   // mnemonic was invalid.
2383   if ((Match1 == Match_MnemonicFail) && (Match2 == Match_MnemonicFail) &&
2384       (Match3 == Match_MnemonicFail) && (Match4 == Match_MnemonicFail)) {
2385     if (!WasOriginallyInvalidOperand) {
2386       ArrayRef<SMRange> Ranges = MatchingInlineAsm ? EmptyRanges :
2387         Op->getLocRange();
2388       return Error(IDLoc, "invalid instruction mnemonic '" + Base + "'",
2389                    Ranges, MatchingInlineAsm);
2390     }
2391
2392     // Recover location info for the operand if we know which was the problem.
2393     if (ErrorInfo != ~0U) {
2394       if (ErrorInfo >= Operands.size())
2395         return Error(IDLoc, "too few operands for instruction",
2396                      EmptyRanges, MatchingInlineAsm);
2397
2398       X86Operand *Operand = (X86Operand*)Operands[ErrorInfo];
2399       if (Operand->getStartLoc().isValid()) {
2400         SMRange OperandRange = Operand->getLocRange();
2401         return Error(Operand->getStartLoc(), "invalid operand for instruction",
2402                      OperandRange, MatchingInlineAsm);
2403       }
2404     }
2405
2406     return Error(IDLoc, "invalid operand for instruction", EmptyRanges,
2407                  MatchingInlineAsm);
2408   }
2409
2410   // If one instruction matched with a missing feature, report this as a
2411   // missing feature.
2412   if ((Match1 == Match_MissingFeature) + (Match2 == Match_MissingFeature) +
2413       (Match3 == Match_MissingFeature) + (Match4 == Match_MissingFeature) == 1){
2414     std::string Msg = "instruction requires:";
2415     unsigned Mask = 1;
2416     for (unsigned i = 0; i < (sizeof(ErrorInfoMissingFeature)*8-1); ++i) {
2417       if (ErrorInfoMissingFeature & Mask) {
2418         Msg += " ";
2419         Msg += getSubtargetFeatureName(ErrorInfoMissingFeature & Mask);
2420       }
2421       Mask <<= 1;
2422     }
2423     return Error(IDLoc, Msg, EmptyRanges, MatchingInlineAsm);
2424   }
2425
2426   // If one instruction matched with an invalid operand, report this as an
2427   // operand failure.
2428   if ((Match1 == Match_InvalidOperand) + (Match2 == Match_InvalidOperand) +
2429       (Match3 == Match_InvalidOperand) + (Match4 == Match_InvalidOperand) == 1){
2430     Error(IDLoc, "invalid operand for instruction", EmptyRanges,
2431           MatchingInlineAsm);
2432     return true;
2433   }
2434
2435   // If all of these were an outright failure, report it in a useless way.
2436   Error(IDLoc, "unknown use of instruction mnemonic without a size suffix",
2437         EmptyRanges, MatchingInlineAsm);
2438   return true;
2439 }
2440
2441
2442 bool X86AsmParser::ParseDirective(AsmToken DirectiveID) {
2443   StringRef IDVal = DirectiveID.getIdentifier();
2444   if (IDVal == ".word")
2445     return ParseDirectiveWord(2, DirectiveID.getLoc());
2446   else if (IDVal.startswith(".code"))
2447     return ParseDirectiveCode(IDVal, DirectiveID.getLoc());
2448   else if (IDVal.startswith(".att_syntax")) {
2449     getParser().setAssemblerDialect(0);
2450     return false;
2451   } else if (IDVal.startswith(".intel_syntax")) {
2452     getParser().setAssemblerDialect(1);
2453     if (getLexer().isNot(AsmToken::EndOfStatement)) {
2454       // FIXME: Handle noprefix
2455       if (Parser.getTok().getString() == "noprefix")
2456         Parser.Lex();
2457     }
2458     return false;
2459   }
2460   return true;
2461 }
2462
2463 /// ParseDirectiveWord
2464 ///  ::= .word [ expression (, expression)* ]
2465 bool X86AsmParser::ParseDirectiveWord(unsigned Size, SMLoc L) {
2466   if (getLexer().isNot(AsmToken::EndOfStatement)) {
2467     for (;;) {
2468       const MCExpr *Value;
2469       if (getParser().parseExpression(Value))
2470         return false;
2471
2472       getParser().getStreamer().EmitValue(Value, Size);
2473
2474       if (getLexer().is(AsmToken::EndOfStatement))
2475         break;
2476
2477       // FIXME: Improve diagnostic.
2478       if (getLexer().isNot(AsmToken::Comma)) {
2479         Error(L, "unexpected token in directive");
2480         return false;
2481       }
2482       Parser.Lex();
2483     }
2484   }
2485
2486   Parser.Lex();
2487   return false;
2488 }
2489
2490 /// ParseDirectiveCode
2491 ///  ::= .code16 | .code32 | .code64
2492 bool X86AsmParser::ParseDirectiveCode(StringRef IDVal, SMLoc L) {
2493   if (IDVal == ".code16") {
2494     Parser.Lex();
2495     if (!is16BitMode()) {
2496       SwitchMode(X86::Mode16Bit);
2497       getParser().getStreamer().EmitAssemblerFlag(MCAF_Code16);
2498     }
2499   } else if (IDVal == ".code32") {
2500     Parser.Lex();
2501     if (!is32BitMode()) {
2502       SwitchMode(X86::Mode32Bit);
2503       getParser().getStreamer().EmitAssemblerFlag(MCAF_Code32);
2504     }
2505   } else if (IDVal == ".code64") {
2506     Parser.Lex();
2507     if (!is64BitMode()) {
2508       SwitchMode(X86::Mode64Bit);
2509       getParser().getStreamer().EmitAssemblerFlag(MCAF_Code64);
2510     }
2511   } else {
2512     Error(L, "unknown directive " + IDVal);
2513     return false;
2514   }
2515
2516   return false;
2517 }
2518
2519 // Force static initialization.
2520 extern "C" void LLVMInitializeX86AsmParser() {
2521   RegisterMCAsmParser<X86AsmParser> X(TheX86_32Target);
2522   RegisterMCAsmParser<X86AsmParser> Y(TheX86_64Target);
2523 }
2524
2525 #define GET_REGISTER_MATCHER
2526 #define GET_MATCHER_IMPLEMENTATION
2527 #define GET_SUBTARGET_FEATURE_NAME
2528 #include "X86GenAsmMatcher.inc"