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