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