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