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