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