lib/Target/X86/AsmParser/X86AsmParser.cpp

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