contrib/llvm/lib/CodeGen/MIRParser/MIParser.cpp

   1 //===- MIParser.cpp - Machine instructions parser implementation ----------===//
   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 // This file implements the parsing of machine instructions.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "MIParser.h"
  15 #include "MILexer.h"
  16 #include "llvm/ADT/APInt.h"
  17 #include "llvm/ADT/APSInt.h"
  18 #include "llvm/ADT/ArrayRef.h"
  19 #include "llvm/ADT/DenseMap.h"
  20 #include "llvm/ADT/None.h"
  21 #include "llvm/ADT/Optional.h"
  22 #include "llvm/ADT/SmallVector.h"
  23 #include "llvm/ADT/StringMap.h"
  24 #include "llvm/ADT/StringRef.h"
  25 #include "llvm/ADT/StringSwitch.h"
  26 #include "llvm/ADT/Twine.h"
  27 #include "llvm/AsmParser/Parser.h"
  28 #include "llvm/AsmParser/SlotMapping.h"
  29 #include "llvm/CodeGen/MIRPrinter.h"
  30 #include "llvm/CodeGen/MachineBasicBlock.h"
  31 #include "llvm/CodeGen/MachineFrameInfo.h"
  32 #include "llvm/CodeGen/MachineFunction.h"
  33 #include "llvm/CodeGen/MachineInstr.h"
  34 #include "llvm/CodeGen/MachineInstrBuilder.h"
  35 #include "llvm/CodeGen/MachineMemOperand.h"
  36 #include "llvm/CodeGen/MachineOperand.h"
  37 #include "llvm/CodeGen/MachineRegisterInfo.h"
  38 #include "llvm/CodeGen/TargetInstrInfo.h"
  39 #include "llvm/CodeGen/TargetRegisterInfo.h"
  40 #include "llvm/CodeGen/TargetSubtargetInfo.h"
  41 #include "llvm/IR/BasicBlock.h"
  42 #include "llvm/IR/Constants.h"
  43 #include "llvm/IR/DataLayout.h"
  44 #include "llvm/IR/DebugInfoMetadata.h"
  45 #include "llvm/IR/DebugLoc.h"
  46 #include "llvm/IR/Function.h"
  47 #include "llvm/IR/InstrTypes.h"
  48 #include "llvm/IR/Instructions.h"
  49 #include "llvm/IR/Intrinsics.h"
  50 #include "llvm/IR/Metadata.h"
  51 #include "llvm/IR/Module.h"
  52 #include "llvm/IR/ModuleSlotTracker.h"
  53 #include "llvm/IR/Type.h"
  54 #include "llvm/IR/Value.h"
  55 #include "llvm/IR/ValueSymbolTable.h"
  56 #include "llvm/MC/LaneBitmask.h"
  57 #include "llvm/MC/MCDwarf.h"
  58 #include "llvm/MC/MCInstrDesc.h"
  59 #include "llvm/MC/MCRegisterInfo.h"
  60 #include "llvm/Support/AtomicOrdering.h"
  61 #include "llvm/Support/BranchProbability.h"
  62 #include "llvm/Support/Casting.h"
  63 #include "llvm/Support/ErrorHandling.h"
  64 #include "llvm/Support/LowLevelTypeImpl.h"
  65 #include "llvm/Support/MemoryBuffer.h"
  66 #include "llvm/Support/SMLoc.h"
  67 #include "llvm/Support/SourceMgr.h"
  68 #include "llvm/Support/raw_ostream.h"
  69 #include "llvm/Target/TargetIntrinsicInfo.h"
  70 #include "llvm/Target/TargetMachine.h"
  71 #include <algorithm>
  72 #include <cassert>
  73 #include <cctype>
  74 #include <cstddef>
  75 #include <cstdint>
  76 #include <limits>
  77 #include <string>
  78 #include <utility>
  79
  80 using namespace llvm;
  81
  82 PerFunctionMIParsingState::PerFunctionMIParsingState(MachineFunction &MF,
  83     SourceMgr &SM, const SlotMapping &IRSlots,
  84     const Name2RegClassMap &Names2RegClasses,
  85     const Name2RegBankMap &Names2RegBanks)
  86   : MF(MF), SM(&SM), IRSlots(IRSlots), Names2RegClasses(Names2RegClasses),
  87     Names2RegBanks(Names2RegBanks) {
  88 }
  89
  90 VRegInfo &PerFunctionMIParsingState::getVRegInfo(unsigned Num) {
  91   auto I = VRegInfos.insert(std::make_pair(Num, nullptr));
  92   if (I.second) {
  93     MachineRegisterInfo &MRI = MF.getRegInfo();
  94     VRegInfo *Info = new (Allocator) VRegInfo;
  95     Info->VReg = MRI.createIncompleteVirtualRegister();
  96     I.first->second = Info;
  97   }
  98   return *I.first->second;
  99 }
 100
 101 namespace {
 102
 103 /// A wrapper struct around the 'MachineOperand' struct that includes a source
 104 /// range and other attributes.
 105 struct ParsedMachineOperand {
 106   MachineOperand Operand;
 107   StringRef::iterator Begin;
 108   StringRef::iterator End;
 109   Optional<unsigned> TiedDefIdx;
 110
 111   ParsedMachineOperand(const MachineOperand &Operand, StringRef::iterator Begin,
 112                        StringRef::iterator End, Optional<unsigned> &TiedDefIdx)
 113       : Operand(Operand), Begin(Begin), End(End), TiedDefIdx(TiedDefIdx) {
 114     if (TiedDefIdx)
 115       assert(Operand.isReg() && Operand.isUse() &&
 116              "Only used register operands can be tied");
 117   }
 118 };
 119
 120 class MIParser {
 121   MachineFunction &MF;
 122   SMDiagnostic &Error;
 123   StringRef Source, CurrentSource;
 124   MIToken Token;
 125   PerFunctionMIParsingState &PFS;
 126   /// Maps from instruction names to op codes.
 127   StringMap<unsigned> Names2InstrOpCodes;
 128   /// Maps from register names to registers.
 129   StringMap<unsigned> Names2Regs;
 130   /// Maps from register mask names to register masks.
 131   StringMap<const uint32_t *> Names2RegMasks;
 132   /// Maps from subregister names to subregister indices.
 133   StringMap<unsigned> Names2SubRegIndices;
 134   /// Maps from slot numbers to function's unnamed basic blocks.
 135   DenseMap<unsigned, const BasicBlock *> Slots2BasicBlocks;
 136   /// Maps from slot numbers to function's unnamed values.
 137   DenseMap<unsigned, const Value *> Slots2Values;
 138   /// Maps from target index names to target indices.
 139   StringMap<int> Names2TargetIndices;
 140   /// Maps from direct target flag names to the direct target flag values.
 141   StringMap<unsigned> Names2DirectTargetFlags;
 142   /// Maps from direct target flag names to the bitmask target flag values.
 143   StringMap<unsigned> Names2BitmaskTargetFlags;
 144   /// Maps from MMO target flag names to MMO target flag values.
 145   StringMap<MachineMemOperand::Flags> Names2MMOTargetFlags;
 146
 147 public:
 148   MIParser(PerFunctionMIParsingState &PFS, SMDiagnostic &Error,
 149            StringRef Source);
 150
 151   /// \p SkipChar gives the number of characters to skip before looking
 152   /// for the next token.
 153   void lex(unsigned SkipChar = 0);
 154
 155   /// Report an error at the current location with the given message.
 156   ///
 157   /// This function always return true.
 158   bool error(const Twine &Msg);
 159
 160   /// Report an error at the given location with the given message.
 161   ///
 162   /// This function always return true.
 163   bool error(StringRef::iterator Loc, const Twine &Msg);
 164
 165   bool
 166   parseBasicBlockDefinitions(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
 167   bool parseBasicBlocks();
 168   bool parse(MachineInstr *&MI);
 169   bool parseStandaloneMBB(MachineBasicBlock *&MBB);
 170   bool parseStandaloneNamedRegister(unsigned &Reg);
 171   bool parseStandaloneVirtualRegister(VRegInfo *&Info);
 172   bool parseStandaloneRegister(unsigned &Reg);
 173   bool parseStandaloneStackObject(int &FI);
 174   bool parseStandaloneMDNode(MDNode *&Node);
 175
 176   bool
 177   parseBasicBlockDefinition(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
 178   bool parseBasicBlock(MachineBasicBlock &MBB,
 179                        MachineBasicBlock *&AddFalthroughFrom);
 180   bool parseBasicBlockLiveins(MachineBasicBlock &MBB);
 181   bool parseBasicBlockSuccessors(MachineBasicBlock &MBB);
 182
 183   bool parseNamedRegister(unsigned &Reg);
 184   bool parseVirtualRegister(VRegInfo *&Info);
 185   bool parseRegister(unsigned &Reg, VRegInfo *&VRegInfo);
 186   bool parseRegisterFlag(unsigned &Flags);
 187   bool parseRegisterClassOrBank(VRegInfo &RegInfo);
 188   bool parseSubRegisterIndex(unsigned &SubReg);
 189   bool parseRegisterTiedDefIndex(unsigned &TiedDefIdx);
 190   bool parseRegisterOperand(MachineOperand &Dest,
 191                             Optional<unsigned> &TiedDefIdx, bool IsDef = false);
 192   bool parseImmediateOperand(MachineOperand &Dest);
 193   bool parseIRConstant(StringRef::iterator Loc, StringRef Source,
 194                        const Constant *&C);
 195   bool parseIRConstant(StringRef::iterator Loc, const Constant *&C);
 196   bool parseLowLevelType(StringRef::iterator Loc, LLT &Ty);
 197   bool parseTypedImmediateOperand(MachineOperand &Dest);
 198   bool parseFPImmediateOperand(MachineOperand &Dest);
 199   bool parseMBBReference(MachineBasicBlock *&MBB);
 200   bool parseMBBOperand(MachineOperand &Dest);
 201   bool parseStackFrameIndex(int &FI);
 202   bool parseStackObjectOperand(MachineOperand &Dest);
 203   bool parseFixedStackFrameIndex(int &FI);
 204   bool parseFixedStackObjectOperand(MachineOperand &Dest);
 205   bool parseGlobalValue(GlobalValue *&GV);
 206   bool parseGlobalAddressOperand(MachineOperand &Dest);
 207   bool parseConstantPoolIndexOperand(MachineOperand &Dest);
 208   bool parseSubRegisterIndexOperand(MachineOperand &Dest);
 209   bool parseJumpTableIndexOperand(MachineOperand &Dest);
 210   bool parseExternalSymbolOperand(MachineOperand &Dest);
 211   bool parseMDNode(MDNode *&Node);
 212   bool parseDIExpression(MDNode *&Node);
 213   bool parseMetadataOperand(MachineOperand &Dest);
 214   bool parseCFIOffset(int &Offset);
 215   bool parseCFIRegister(unsigned &Reg);
 216   bool parseCFIEscapeValues(std::string& Values);
 217   bool parseCFIOperand(MachineOperand &Dest);
 218   bool parseIRBlock(BasicBlock *&BB, const Function &F);
 219   bool parseBlockAddressOperand(MachineOperand &Dest);
 220   bool parseIntrinsicOperand(MachineOperand &Dest);
 221   bool parsePredicateOperand(MachineOperand &Dest);
 222   bool parseTargetIndexOperand(MachineOperand &Dest);
 223   bool parseCustomRegisterMaskOperand(MachineOperand &Dest);
 224   bool parseLiveoutRegisterMaskOperand(MachineOperand &Dest);
 225   bool parseMachineOperand(MachineOperand &Dest,
 226                            Optional<unsigned> &TiedDefIdx);
 227   bool parseMachineOperandAndTargetFlags(MachineOperand &Dest,
 228                                          Optional<unsigned> &TiedDefIdx);
 229   bool parseOffset(int64_t &Offset);
 230   bool parseAlignment(unsigned &Alignment);
 231   bool parseOperandsOffset(MachineOperand &Op);
 232   bool parseIRValue(const Value *&V);
 233   bool parseMemoryOperandFlag(MachineMemOperand::Flags &Flags);
 234   bool parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV);
 235   bool parseMachinePointerInfo(MachinePointerInfo &Dest);
 236   bool parseOptionalScope(LLVMContext &Context, SyncScope::ID &SSID);
 237   bool parseOptionalAtomicOrdering(AtomicOrdering &Order);
 238   bool parseMachineMemoryOperand(MachineMemOperand *&Dest);
 239
 240 private:
 241   /// Convert the integer literal in the current token into an unsigned integer.
 242   ///
 243   /// Return true if an error occurred.
 244   bool getUnsigned(unsigned &Result);
 245
 246   /// Convert the integer literal in the current token into an uint64.
 247   ///
 248   /// Return true if an error occurred.
 249   bool getUint64(uint64_t &Result);
 250
 251   /// Convert the hexadecimal literal in the current token into an unsigned
 252   ///  APInt with a minimum bitwidth required to represent the value.
 253   ///
 254   /// Return true if the literal does not represent an integer value.
 255   bool getHexUint(APInt &Result);
 256
 257   /// If the current token is of the given kind, consume it and return false.
 258   /// Otherwise report an error and return true.
 259   bool expectAndConsume(MIToken::TokenKind TokenKind);
 260
 261   /// If the current token is of the given kind, consume it and return true.
 262   /// Otherwise return false.
 263   bool consumeIfPresent(MIToken::TokenKind TokenKind);
 264
 265   void initNames2InstrOpCodes();
 266
 267   /// Try to convert an instruction name to an opcode. Return true if the
 268   /// instruction name is invalid.
 269   bool parseInstrName(StringRef InstrName, unsigned &OpCode);
 270
 271   bool parseInstruction(unsigned &OpCode, unsigned &Flags);
 272
 273   bool assignRegisterTies(MachineInstr &MI,
 274                           ArrayRef<ParsedMachineOperand> Operands);
 275
 276   bool verifyImplicitOperands(ArrayRef<ParsedMachineOperand> Operands,
 277                               const MCInstrDesc &MCID);
 278
 279   void initNames2Regs();
 280
 281   /// Try to convert a register name to a register number. Return true if the
 282   /// register name is invalid.
 283   bool getRegisterByName(StringRef RegName, unsigned &Reg);
 284
 285   void initNames2RegMasks();
 286
 287   /// Check if the given identifier is a name of a register mask.
 288   ///
 289   /// Return null if the identifier isn't a register mask.
 290   const uint32_t *getRegMask(StringRef Identifier);
 291
 292   void initNames2SubRegIndices();
 293
 294   /// Check if the given identifier is a name of a subregister index.
 295   ///
 296   /// Return 0 if the name isn't a subregister index class.
 297   unsigned getSubRegIndex(StringRef Name);
 298
 299   const BasicBlock *getIRBlock(unsigned Slot);
 300   const BasicBlock *getIRBlock(unsigned Slot, const Function &F);
 301
 302   const Value *getIRValue(unsigned Slot);
 303
 304   void initNames2TargetIndices();
 305
 306   /// Try to convert a name of target index to the corresponding target index.
 307   ///
 308   /// Return true if the name isn't a name of a target index.
 309   bool getTargetIndex(StringRef Name, int &Index);
 310
 311   void initNames2DirectTargetFlags();
 312
 313   /// Try to convert a name of a direct target flag to the corresponding
 314   /// target flag.
 315   ///
 316   /// Return true if the name isn't a name of a direct flag.
 317   bool getDirectTargetFlag(StringRef Name, unsigned &Flag);
 318
 319   void initNames2BitmaskTargetFlags();
 320
 321   /// Try to convert a name of a bitmask target flag to the corresponding
 322   /// target flag.
 323   ///
 324   /// Return true if the name isn't a name of a bitmask target flag.
 325   bool getBitmaskTargetFlag(StringRef Name, unsigned &Flag);
 326
 327   void initNames2MMOTargetFlags();
 328
 329   /// Try to convert a name of a MachineMemOperand target flag to the
 330   /// corresponding target flag.
 331   ///
 332   /// Return true if the name isn't a name of a target MMO flag.
 333   bool getMMOTargetFlag(StringRef Name, MachineMemOperand::Flags &Flag);
 334
 335   /// parseStringConstant
 336   ///   ::= StringConstant
 337   bool parseStringConstant(std::string &Result);
 338 };
 339
 340 } // end anonymous namespace
 341
 342 MIParser::MIParser(PerFunctionMIParsingState &PFS, SMDiagnostic &Error,
 343                    StringRef Source)
 344     : MF(PFS.MF), Error(Error), Source(Source), CurrentSource(Source), PFS(PFS)
 345 {}
 346
 347 void MIParser::lex(unsigned SkipChar) {
 348   CurrentSource = lexMIToken(
 349       CurrentSource.data() + SkipChar, Token,
 350       [this](StringRef::iterator Loc, const Twine &Msg) { error(Loc, Msg); });
 351 }
 352
 353 bool MIParser::error(const Twine &Msg) { return error(Token.location(), Msg); }
 354
 355 bool MIParser::error(StringRef::iterator Loc, const Twine &Msg) {
 356   const SourceMgr &SM = *PFS.SM;
 357   assert(Loc >= Source.data() && Loc <= (Source.data() + Source.size()));
 358   const MemoryBuffer &Buffer = *SM.getMemoryBuffer(SM.getMainFileID());
 359   if (Loc >= Buffer.getBufferStart() && Loc <= Buffer.getBufferEnd()) {
 360     // Create an ordinary diagnostic when the source manager's buffer is the
 361     // source string.
 362     Error = SM.GetMessage(SMLoc::getFromPointer(Loc), SourceMgr::DK_Error, Msg);
 363     return true;
 364   }
 365   // Create a diagnostic for a YAML string literal.
 366   Error = SMDiagnostic(SM, SMLoc(), Buffer.getBufferIdentifier(), 1,
 367                        Loc - Source.data(), SourceMgr::DK_Error, Msg.str(),
 368                        Source, None, None);
 369   return true;
 370 }
 371
 372 static const char *toString(MIToken::TokenKind TokenKind) {
 373   switch (TokenKind) {
 374   case MIToken::comma:
 375     return "','";
 376   case MIToken::equal:
 377     return "'='";
 378   case MIToken::colon:
 379     return "':'";
 380   case MIToken::lparen:
 381     return "'('";
 382   case MIToken::rparen:
 383     return "')'";
 384   default:
 385     return "<unknown token>";
 386   }
 387 }
 388
 389 bool MIParser::expectAndConsume(MIToken::TokenKind TokenKind) {
 390   if (Token.isNot(TokenKind))
 391     return error(Twine("expected ") + toString(TokenKind));
 392   lex();
 393   return false;
 394 }
 395
 396 bool MIParser::consumeIfPresent(MIToken::TokenKind TokenKind) {
 397   if (Token.isNot(TokenKind))
 398     return false;
 399   lex();
 400   return true;
 401 }
 402
 403 bool MIParser::parseBasicBlockDefinition(
 404     DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
 405   assert(Token.is(MIToken::MachineBasicBlockLabel));
 406   unsigned ID = 0;
 407   if (getUnsigned(ID))
 408     return true;
 409   auto Loc = Token.location();
 410   auto Name = Token.stringValue();
 411   lex();
 412   bool HasAddressTaken = false;
 413   bool IsLandingPad = false;
 414   unsigned Alignment = 0;
 415   BasicBlock *BB = nullptr;
 416   if (consumeIfPresent(MIToken::lparen)) {
 417     do {
 418       // TODO: Report an error when multiple same attributes are specified.
 419       switch (Token.kind()) {
 420       case MIToken::kw_address_taken:
 421         HasAddressTaken = true;
 422         lex();
 423         break;
 424       case MIToken::kw_landing_pad:
 425         IsLandingPad = true;
 426         lex();
 427         break;
 428       case MIToken::kw_align:
 429         if (parseAlignment(Alignment))
 430           return true;
 431         break;
 432       case MIToken::IRBlock:
 433         // TODO: Report an error when both name and ir block are specified.
 434         if (parseIRBlock(BB, MF.getFunction()))
 435           return true;
 436         lex();
 437         break;
 438       default:
 439         break;
 440       }
 441     } while (consumeIfPresent(MIToken::comma));
 442     if (expectAndConsume(MIToken::rparen))
 443       return true;
 444   }
 445   if (expectAndConsume(MIToken::colon))
 446     return true;
 447
 448   if (!Name.empty()) {
 449     BB = dyn_cast_or_null<BasicBlock>(
 450         MF.getFunction().getValueSymbolTable()->lookup(Name));
 451     if (!BB)
 452       return error(Loc, Twine("basic block '") + Name +
 453                             "' is not defined in the function '" +
 454                             MF.getName() + "'");
 455   }
 456   auto *MBB = MF.CreateMachineBasicBlock(BB);
 457   MF.insert(MF.end(), MBB);
 458   bool WasInserted = MBBSlots.insert(std::make_pair(ID, MBB)).second;
 459   if (!WasInserted)
 460     return error(Loc, Twine("redefinition of machine basic block with id #") +
 461                           Twine(ID));
 462   if (Alignment)
 463     MBB->setAlignment(Alignment);
 464   if (HasAddressTaken)
 465     MBB->setHasAddressTaken();
 466   MBB->setIsEHPad(IsLandingPad);
 467   return false;
 468 }
 469
 470 bool MIParser::parseBasicBlockDefinitions(
 471     DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
 472   lex();
 473   // Skip until the first machine basic block.
 474   while (Token.is(MIToken::Newline))
 475     lex();
 476   if (Token.isErrorOrEOF())
 477     return Token.isError();
 478   if (Token.isNot(MIToken::MachineBasicBlockLabel))
 479     return error("expected a basic block definition before instructions");
 480   unsigned BraceDepth = 0;
 481   do {
 482     if (parseBasicBlockDefinition(MBBSlots))
 483       return true;
 484     bool IsAfterNewline = false;
 485     // Skip until the next machine basic block.
 486     while (true) {
 487       if ((Token.is(MIToken::MachineBasicBlockLabel) && IsAfterNewline) ||
 488           Token.isErrorOrEOF())
 489         break;
 490       else if (Token.is(MIToken::MachineBasicBlockLabel))
 491         return error("basic block definition should be located at the start of "
 492                      "the line");
 493       else if (consumeIfPresent(MIToken::Newline)) {
 494         IsAfterNewline = true;
 495         continue;
 496       }
 497       IsAfterNewline = false;
 498       if (Token.is(MIToken::lbrace))
 499         ++BraceDepth;
 500       if (Token.is(MIToken::rbrace)) {
 501         if (!BraceDepth)
 502           return error("extraneous closing brace ('}')");
 503         --BraceDepth;
 504       }
 505       lex();
 506     }
 507     // Verify that we closed all of the '{' at the end of a file or a block.
 508     if (!Token.isError() && BraceDepth)
 509       return error("expected '}'"); // FIXME: Report a note that shows '{'.
 510   } while (!Token.isErrorOrEOF());
 511   return Token.isError();
 512 }
 513
 514 bool MIParser::parseBasicBlockLiveins(MachineBasicBlock &MBB) {
 515   assert(Token.is(MIToken::kw_liveins));
 516   lex();
 517   if (expectAndConsume(MIToken::colon))
 518     return true;
 519   if (Token.isNewlineOrEOF()) // Allow an empty list of liveins.
 520     return false;
 521   do {
 522     if (Token.isNot(MIToken::NamedRegister))
 523       return error("expected a named register");
 524     unsigned Reg = 0;
 525     if (parseNamedRegister(Reg))
 526       return true;
 527     lex();
 528     LaneBitmask Mask = LaneBitmask::getAll();
 529     if (consumeIfPresent(MIToken::colon)) {
 530       // Parse lane mask.
 531       if (Token.isNot(MIToken::IntegerLiteral) &&
 532           Token.isNot(MIToken::HexLiteral))
 533         return error("expected a lane mask");
 534       static_assert(sizeof(LaneBitmask::Type) == sizeof(unsigned),
 535                     "Use correct get-function for lane mask");
 536       LaneBitmask::Type V;
 537       if (getUnsigned(V))
 538         return error("invalid lane mask value");
 539       Mask = LaneBitmask(V);
 540       lex();
 541     }
 542     MBB.addLiveIn(Reg, Mask);
 543   } while (consumeIfPresent(MIToken::comma));
 544   return false;
 545 }
 546
 547 bool MIParser::parseBasicBlockSuccessors(MachineBasicBlock &MBB) {
 548   assert(Token.is(MIToken::kw_successors));
 549   lex();
 550   if (expectAndConsume(MIToken::colon))
 551     return true;
 552   if (Token.isNewlineOrEOF()) // Allow an empty list of successors.
 553     return false;
 554   do {
 555     if (Token.isNot(MIToken::MachineBasicBlock))
 556       return error("expected a machine basic block reference");
 557     MachineBasicBlock *SuccMBB = nullptr;
 558     if (parseMBBReference(SuccMBB))
 559       return true;
 560     lex();
 561     unsigned Weight = 0;
 562     if (consumeIfPresent(MIToken::lparen)) {
 563       if (Token.isNot(MIToken::IntegerLiteral) &&
 564           Token.isNot(MIToken::HexLiteral))
 565         return error("expected an integer literal after '('");
 566       if (getUnsigned(Weight))
 567         return true;
 568       lex();
 569       if (expectAndConsume(MIToken::rparen))
 570         return true;
 571     }
 572     MBB.addSuccessor(SuccMBB, BranchProbability::getRaw(Weight));
 573   } while (consumeIfPresent(MIToken::comma));
 574   MBB.normalizeSuccProbs();
 575   return false;
 576 }
 577
 578 bool MIParser::parseBasicBlock(MachineBasicBlock &MBB,
 579                                MachineBasicBlock *&AddFalthroughFrom) {
 580   // Skip the definition.
 581   assert(Token.is(MIToken::MachineBasicBlockLabel));
 582   lex();
 583   if (consumeIfPresent(MIToken::lparen)) {
 584     while (Token.isNot(MIToken::rparen) && !Token.isErrorOrEOF())
 585       lex();
 586     consumeIfPresent(MIToken::rparen);
 587   }
 588   consumeIfPresent(MIToken::colon);
 589
 590   // Parse the liveins and successors.
 591   // N.B: Multiple lists of successors and liveins are allowed and they're
 592   // merged into one.
 593   // Example:
 594   //   liveins: %edi
 595   //   liveins: %esi
 596   //
 597   // is equivalent to
 598   //   liveins: %edi, %esi
 599   bool ExplicitSuccessors = false;
 600   while (true) {
 601     if (Token.is(MIToken::kw_successors)) {
 602       if (parseBasicBlockSuccessors(MBB))
 603         return true;
 604       ExplicitSuccessors = true;
 605     } else if (Token.is(MIToken::kw_liveins)) {
 606       if (parseBasicBlockLiveins(MBB))
 607         return true;
 608     } else if (consumeIfPresent(MIToken::Newline)) {
 609       continue;
 610     } else
 611       break;
 612     if (!Token.isNewlineOrEOF())
 613       return error("expected line break at the end of a list");
 614     lex();
 615   }
 616
 617   // Parse the instructions.
 618   bool IsInBundle = false;
 619   MachineInstr *PrevMI = nullptr;
 620   while (!Token.is(MIToken::MachineBasicBlockLabel) &&
 621          !Token.is(MIToken::Eof)) {
 622     if (consumeIfPresent(MIToken::Newline))
 623       continue;
 624     if (consumeIfPresent(MIToken::rbrace)) {
 625       // The first parsing pass should verify that all closing '}' have an
 626       // opening '{'.
 627       assert(IsInBundle);
 628       IsInBundle = false;
 629       continue;
 630     }
 631     MachineInstr *MI = nullptr;
 632     if (parse(MI))
 633       return true;
 634     MBB.insert(MBB.end(), MI);
 635     if (IsInBundle) {
 636       PrevMI->setFlag(MachineInstr::BundledSucc);
 637       MI->setFlag(MachineInstr::BundledPred);
 638     }
 639     PrevMI = MI;
 640     if (Token.is(MIToken::lbrace)) {
 641       if (IsInBundle)
 642         return error("nested instruction bundles are not allowed");
 643       lex();
 644       // This instruction is the start of the bundle.
 645       MI->setFlag(MachineInstr::BundledSucc);
 646       IsInBundle = true;
 647       if (!Token.is(MIToken::Newline))
 648         // The next instruction can be on the same line.
 649         continue;
 650     }
 651     assert(Token.isNewlineOrEOF() && "MI is not fully parsed");
 652     lex();
 653   }
 654
 655   // Construct successor list by searching for basic block machine operands.
 656   if (!ExplicitSuccessors) {
 657     SmallVector<MachineBasicBlock*,4> Successors;
 658     bool IsFallthrough;
 659     guessSuccessors(MBB, Successors, IsFallthrough);
 660     for (MachineBasicBlock *Succ : Successors)
 661       MBB.addSuccessor(Succ);
 662
 663     if (IsFallthrough) {
 664       AddFalthroughFrom = &MBB;
 665     } else {
 666       MBB.normalizeSuccProbs();
 667     }
 668   }
 669
 670   return false;
 671 }
 672
 673 bool MIParser::parseBasicBlocks() {
 674   lex();
 675   // Skip until the first machine basic block.
 676   while (Token.is(MIToken::Newline))
 677     lex();
 678   if (Token.isErrorOrEOF())
 679     return Token.isError();
 680   // The first parsing pass should have verified that this token is a MBB label
 681   // in the 'parseBasicBlockDefinitions' method.
 682   assert(Token.is(MIToken::MachineBasicBlockLabel));
 683   MachineBasicBlock *AddFalthroughFrom = nullptr;
 684   do {
 685     MachineBasicBlock *MBB = nullptr;
 686     if (parseMBBReference(MBB))
 687       return true;
 688     if (AddFalthroughFrom) {
 689       if (!AddFalthroughFrom->isSuccessor(MBB))
 690         AddFalthroughFrom->addSuccessor(MBB);
 691       AddFalthroughFrom->normalizeSuccProbs();
 692       AddFalthroughFrom = nullptr;
 693     }
 694     if (parseBasicBlock(*MBB, AddFalthroughFrom))
 695       return true;
 696     // The method 'parseBasicBlock' should parse the whole block until the next
 697     // block or the end of file.
 698     assert(Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof));
 699   } while (Token.isNot(MIToken::Eof));
 700   return false;
 701 }
 702
 703 bool MIParser::parse(MachineInstr *&MI) {
 704   // Parse any register operands before '='
 705   MachineOperand MO = MachineOperand::CreateImm(0);
 706   SmallVector<ParsedMachineOperand, 8> Operands;
 707   while (Token.isRegister() || Token.isRegisterFlag()) {
 708     auto Loc = Token.location();
 709     Optional<unsigned> TiedDefIdx;
 710     if (parseRegisterOperand(MO, TiedDefIdx, /*IsDef=*/true))
 711       return true;
 712     Operands.push_back(
 713         ParsedMachineOperand(MO, Loc, Token.location(), TiedDefIdx));
 714     if (Token.isNot(MIToken::comma))
 715       break;
 716     lex();
 717   }
 718   if (!Operands.empty() && expectAndConsume(MIToken::equal))
 719     return true;
 720
 721   unsigned OpCode, Flags = 0;
 722   if (Token.isError() || parseInstruction(OpCode, Flags))
 723     return true;
 724
 725   // Parse the remaining machine operands.
 726   while (!Token.isNewlineOrEOF() && Token.isNot(MIToken::kw_debug_location) &&
 727          Token.isNot(MIToken::coloncolon) && Token.isNot(MIToken::lbrace)) {
 728     auto Loc = Token.location();
 729     Optional<unsigned> TiedDefIdx;
 730     if (parseMachineOperandAndTargetFlags(MO, TiedDefIdx))
 731       return true;
 732     Operands.push_back(
 733         ParsedMachineOperand(MO, Loc, Token.location(), TiedDefIdx));
 734     if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
 735         Token.is(MIToken::lbrace))
 736       break;
 737     if (Token.isNot(MIToken::comma))
 738       return error("expected ',' before the next machine operand");
 739     lex();
 740   }
 741
 742   DebugLoc DebugLocation;
 743   if (Token.is(MIToken::kw_debug_location)) {
 744     lex();
 745     if (Token.isNot(MIToken::exclaim))
 746       return error("expected a metadata node after 'debug-location'");
 747     MDNode *Node = nullptr;
 748     if (parseMDNode(Node))
 749       return true;
 750     DebugLocation = DebugLoc(Node);
 751   }
 752
 753   // Parse the machine memory operands.
 754   SmallVector<MachineMemOperand *, 2> MemOperands;
 755   if (Token.is(MIToken::coloncolon)) {
 756     lex();
 757     while (!Token.isNewlineOrEOF()) {
 758       MachineMemOperand *MemOp = nullptr;
 759       if (parseMachineMemoryOperand(MemOp))
 760         return true;
 761       MemOperands.push_back(MemOp);
 762       if (Token.isNewlineOrEOF())
 763         break;
 764       if (Token.isNot(MIToken::comma))
 765         return error("expected ',' before the next machine memory operand");
 766       lex();
 767     }
 768   }
 769
 770   const auto &MCID = MF.getSubtarget().getInstrInfo()->get(OpCode);
 771   if (!MCID.isVariadic()) {
 772     // FIXME: Move the implicit operand verification to the machine verifier.
 773     if (verifyImplicitOperands(Operands, MCID))
 774       return true;
 775   }
 776
 777   // TODO: Check for extraneous machine operands.
 778   MI = MF.CreateMachineInstr(MCID, DebugLocation, /*NoImplicit=*/true);
 779   MI->setFlags(Flags);
 780   for (const auto &Operand : Operands)
 781     MI->addOperand(MF, Operand.Operand);
 782   if (assignRegisterTies(*MI, Operands))
 783     return true;
 784   if (MemOperands.empty())
 785     return false;
 786   MachineInstr::mmo_iterator MemRefs =
 787       MF.allocateMemRefsArray(MemOperands.size());
 788   std::copy(MemOperands.begin(), MemOperands.end(), MemRefs);
 789   MI->setMemRefs(MemRefs, MemRefs + MemOperands.size());
 790   return false;
 791 }
 792
 793 bool MIParser::parseStandaloneMBB(MachineBasicBlock *&MBB) {
 794   lex();
 795   if (Token.isNot(MIToken::MachineBasicBlock))
 796     return error("expected a machine basic block reference");
 797   if (parseMBBReference(MBB))
 798     return true;
 799   lex();
 800   if (Token.isNot(MIToken::Eof))
 801     return error(
 802         "expected end of string after the machine basic block reference");
 803   return false;
 804 }
 805
 806 bool MIParser::parseStandaloneNamedRegister(unsigned &Reg) {
 807   lex();
 808   if (Token.isNot(MIToken::NamedRegister))
 809     return error("expected a named register");
 810   if (parseNamedRegister(Reg))
 811     return true;
 812   lex();
 813   if (Token.isNot(MIToken::Eof))
 814     return error("expected end of string after the register reference");
 815   return false;
 816 }
 817
 818 bool MIParser::parseStandaloneVirtualRegister(VRegInfo *&Info) {
 819   lex();
 820   if (Token.isNot(MIToken::VirtualRegister))
 821     return error("expected a virtual register");
 822   if (parseVirtualRegister(Info))
 823     return true;
 824   lex();
 825   if (Token.isNot(MIToken::Eof))
 826     return error("expected end of string after the register reference");
 827   return false;
 828 }
 829
 830 bool MIParser::parseStandaloneRegister(unsigned &Reg) {
 831   lex();
 832   if (Token.isNot(MIToken::NamedRegister) &&
 833       Token.isNot(MIToken::VirtualRegister))
 834     return error("expected either a named or virtual register");
 835
 836   VRegInfo *Info;
 837   if (parseRegister(Reg, Info))
 838     return true;
 839
 840   lex();
 841   if (Token.isNot(MIToken::Eof))
 842     return error("expected end of string after the register reference");
 843   return false;
 844 }
 845
 846 bool MIParser::parseStandaloneStackObject(int &FI) {
 847   lex();
 848   if (Token.isNot(MIToken::StackObject))
 849     return error("expected a stack object");
 850   if (parseStackFrameIndex(FI))
 851     return true;
 852   if (Token.isNot(MIToken::Eof))
 853     return error("expected end of string after the stack object reference");
 854   return false;
 855 }
 856
 857 bool MIParser::parseStandaloneMDNode(MDNode *&Node) {
 858   lex();
 859   if (Token.is(MIToken::exclaim)) {
 860     if (parseMDNode(Node))
 861       return true;
 862   } else if (Token.is(MIToken::md_diexpr)) {
 863     if (parseDIExpression(Node))
 864       return true;
 865   } else
 866     return error("expected a metadata node");
 867   if (Token.isNot(MIToken::Eof))
 868     return error("expected end of string after the metadata node");
 869   return false;
 870 }
 871
 872 static const char *printImplicitRegisterFlag(const MachineOperand &MO) {
 873   assert(MO.isImplicit());
 874   return MO.isDef() ? "implicit-def" : "implicit";
 875 }
 876
 877 static std::string getRegisterName(const TargetRegisterInfo *TRI,
 878                                    unsigned Reg) {
 879   assert(TargetRegisterInfo::isPhysicalRegister(Reg) && "expected phys reg");
 880   return StringRef(TRI->getName(Reg)).lower();
 881 }
 882
 883 /// Return true if the parsed machine operands contain a given machine operand.
 884 static bool isImplicitOperandIn(const MachineOperand &ImplicitOperand,
 885                                 ArrayRef<ParsedMachineOperand> Operands) {
 886   for (const auto &I : Operands) {
 887     if (ImplicitOperand.isIdenticalTo(I.Operand))
 888       return true;
 889   }
 890   return false;
 891 }
 892
 893 bool MIParser::verifyImplicitOperands(ArrayRef<ParsedMachineOperand> Operands,
 894                                       const MCInstrDesc &MCID) {
 895   if (MCID.isCall())
 896     // We can't verify call instructions as they can contain arbitrary implicit
 897     // register and register mask operands.
 898     return false;
 899
 900   // Gather all the expected implicit operands.
 901   SmallVector<MachineOperand, 4> ImplicitOperands;
 902   if (MCID.ImplicitDefs)
 903     for (const MCPhysReg *ImpDefs = MCID.getImplicitDefs(); *ImpDefs; ++ImpDefs)
 904       ImplicitOperands.push_back(
 905           MachineOperand::CreateReg(*ImpDefs, true, true));
 906   if (MCID.ImplicitUses)
 907     for (const MCPhysReg *ImpUses = MCID.getImplicitUses(); *ImpUses; ++ImpUses)
 908       ImplicitOperands.push_back(
 909           MachineOperand::CreateReg(*ImpUses, false, true));
 910
 911   const auto *TRI = MF.getSubtarget().getRegisterInfo();
 912   assert(TRI && "Expected target register info");
 913   for (const auto &I : ImplicitOperands) {
 914     if (isImplicitOperandIn(I, Operands))
 915       continue;
 916     return error(Operands.empty() ? Token.location() : Operands.back().End,
 917                  Twine("missing implicit register operand '") +
 918                      printImplicitRegisterFlag(I) + " %" +
 919                      getRegisterName(TRI, I.getReg()) + "'");
 920   }
 921   return false;
 922 }
 923
 924 bool MIParser::parseInstruction(unsigned &OpCode, unsigned &Flags) {
 925   if (Token.is(MIToken::kw_frame_setup)) {
 926     Flags |= MachineInstr::FrameSetup;
 927     lex();
 928   }
 929   if (Token.isNot(MIToken::Identifier))
 930     return error("expected a machine instruction");
 931   StringRef InstrName = Token.stringValue();
 932   if (parseInstrName(InstrName, OpCode))
 933     return error(Twine("unknown machine instruction name '") + InstrName + "'");
 934   lex();
 935   return false;
 936 }
 937
 938 bool MIParser::parseNamedRegister(unsigned &Reg) {
 939   assert(Token.is(MIToken::NamedRegister) && "Needs NamedRegister token");
 940   StringRef Name = Token.stringValue();
 941   if (getRegisterByName(Name, Reg))
 942     return error(Twine("unknown register name '") + Name + "'");
 943   return false;
 944 }
 945
 946 bool MIParser::parseVirtualRegister(VRegInfo *&Info) {
 947   assert(Token.is(MIToken::VirtualRegister) && "Needs VirtualRegister token");
 948   unsigned ID;
 949   if (getUnsigned(ID))
 950     return true;
 951   Info = &PFS.getVRegInfo(ID);
 952   return false;
 953 }
 954
 955 bool MIParser::parseRegister(unsigned &Reg, VRegInfo *&Info) {
 956   switch (Token.kind()) {
 957   case MIToken::underscore:
 958     Reg = 0;
 959     return false;
 960   case MIToken::NamedRegister:
 961     return parseNamedRegister(Reg);
 962   case MIToken::VirtualRegister:
 963     if (parseVirtualRegister(Info))
 964       return true;
 965     Reg = Info->VReg;
 966     return false;
 967   // TODO: Parse other register kinds.
 968   default:
 969     llvm_unreachable("The current token should be a register");
 970   }
 971 }
 972
 973 bool MIParser::parseRegisterClassOrBank(VRegInfo &RegInfo) {
 974   if (Token.isNot(MIToken::Identifier) && Token.isNot(MIToken::underscore))
 975     return error("expected '_', register class, or register bank name");
 976   StringRef::iterator Loc = Token.location();
 977   StringRef Name = Token.stringValue();
 978
 979   // Was it a register class?
 980   auto RCNameI = PFS.Names2RegClasses.find(Name);
 981   if (RCNameI != PFS.Names2RegClasses.end()) {
 982     lex();
 983     const TargetRegisterClass &RC = *RCNameI->getValue();
 984
 985     switch (RegInfo.Kind) {
 986     case VRegInfo::UNKNOWN:
 987     case VRegInfo::NORMAL:
 988       RegInfo.Kind = VRegInfo::NORMAL;
 989       if (RegInfo.Explicit && RegInfo.D.RC != &RC) {
 990         const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo();
 991         return error(Loc, Twine("conflicting register classes, previously: ") +
 992                      Twine(TRI.getRegClassName(RegInfo.D.RC)));
 993       }
 994       RegInfo.D.RC = &RC;
 995       RegInfo.Explicit = true;
 996       return false;
 997
 998     case VRegInfo::GENERIC:
 999     case VRegInfo::REGBANK:
1000       return error(Loc, "register class specification on generic register");
1001     }
1002     llvm_unreachable("Unexpected register kind");
1003   }
1004
1005   // Should be a register bank or a generic register.
1006   const RegisterBank *RegBank = nullptr;
1007   if (Name != "_") {
1008     auto RBNameI = PFS.Names2RegBanks.find(Name);
1009     if (RBNameI == PFS.Names2RegBanks.end())
1010       return error(Loc, "expected '_', register class, or register bank name");
1011     RegBank = RBNameI->getValue();
1012   }
1013
1014   lex();
1015
1016   switch (RegInfo.Kind) {
1017   case VRegInfo::UNKNOWN:
1018   case VRegInfo::GENERIC:
1019   case VRegInfo::REGBANK:
1020     RegInfo.Kind = RegBank ? VRegInfo::REGBANK : VRegInfo::GENERIC;
1021     if (RegInfo.Explicit && RegInfo.D.RegBank != RegBank)
1022       return error(Loc, "conflicting generic register banks");
1023     RegInfo.D.RegBank = RegBank;
1024     RegInfo.Explicit = true;
1025     return false;
1026
1027   case VRegInfo::NORMAL:
1028     return error(Loc, "register bank specification on normal register");
1029   }
1030   llvm_unreachable("Unexpected register kind");
1031 }
1032
1033 bool MIParser::parseRegisterFlag(unsigned &Flags) {
1034   const unsigned OldFlags = Flags;
1035   switch (Token.kind()) {
1036   case MIToken::kw_implicit:
1037     Flags |= RegState::Implicit;
1038     break;
1039   case MIToken::kw_implicit_define:
1040     Flags |= RegState::ImplicitDefine;
1041     break;
1042   case MIToken::kw_def:
1043     Flags |= RegState::Define;
1044     break;
1045   case MIToken::kw_dead:
1046     Flags |= RegState::Dead;
1047     break;
1048   case MIToken::kw_killed:
1049     Flags |= RegState::Kill;
1050     break;
1051   case MIToken::kw_undef:
1052     Flags |= RegState::Undef;
1053     break;
1054   case MIToken::kw_internal:
1055     Flags |= RegState::InternalRead;
1056     break;
1057   case MIToken::kw_early_clobber:
1058     Flags |= RegState::EarlyClobber;
1059     break;
1060   case MIToken::kw_debug_use:
1061     Flags |= RegState::Debug;
1062     break;
1063   case MIToken::kw_renamable:
1064     Flags |= RegState::Renamable;
1065     break;
1066   default:
1067     llvm_unreachable("The current token should be a register flag");
1068   }
1069   if (OldFlags == Flags)
1070     // We know that the same flag is specified more than once when the flags
1071     // weren't modified.
1072     return error("duplicate '" + Token.stringValue() + "' register flag");
1073   lex();
1074   return false;
1075 }
1076
1077 bool MIParser::parseSubRegisterIndex(unsigned &SubReg) {
1078   assert(Token.is(MIToken::dot));
1079   lex();
1080   if (Token.isNot(MIToken::Identifier))
1081     return error("expected a subregister index after '.'");
1082   auto Name = Token.stringValue();
1083   SubReg = getSubRegIndex(Name);
1084   if (!SubReg)
1085     return error(Twine("use of unknown subregister index '") + Name + "'");
1086   lex();
1087   return false;
1088 }
1089
1090 bool MIParser::parseRegisterTiedDefIndex(unsigned &TiedDefIdx) {
1091   if (!consumeIfPresent(MIToken::kw_tied_def))
1092     return true;
1093   if (Token.isNot(MIToken::IntegerLiteral))
1094     return error("expected an integer literal after 'tied-def'");
1095   if (getUnsigned(TiedDefIdx))
1096     return true;
1097   lex();
1098   if (expectAndConsume(MIToken::rparen))
1099     return true;
1100   return false;
1101 }
1102
1103 bool MIParser::assignRegisterTies(MachineInstr &MI,
1104                                   ArrayRef<ParsedMachineOperand> Operands) {
1105   SmallVector<std::pair<unsigned, unsigned>, 4> TiedRegisterPairs;
1106   for (unsigned I = 0, E = Operands.size(); I != E; ++I) {
1107     if (!Operands[I].TiedDefIdx)
1108       continue;
1109     // The parser ensures that this operand is a register use, so we just have
1110     // to check the tied-def operand.
1111     unsigned DefIdx = Operands[I].TiedDefIdx.getValue();
1112     if (DefIdx >= E)
1113       return error(Operands[I].Begin,
1114                    Twine("use of invalid tied-def operand index '" +
1115                          Twine(DefIdx) + "'; instruction has only ") +
1116                        Twine(E) + " operands");
1117     const auto &DefOperand = Operands[DefIdx].Operand;
1118     if (!DefOperand.isReg() || !DefOperand.isDef())
1119       // FIXME: add note with the def operand.
1120       return error(Operands[I].Begin,
1121                    Twine("use of invalid tied-def operand index '") +
1122                        Twine(DefIdx) + "'; the operand #" + Twine(DefIdx) +
1123                        " isn't a defined register");
1124     // Check that the tied-def operand wasn't tied elsewhere.
1125     for (const auto &TiedPair : TiedRegisterPairs) {
1126       if (TiedPair.first == DefIdx)
1127         return error(Operands[I].Begin,
1128                      Twine("the tied-def operand #") + Twine(DefIdx) +
1129                          " is already tied with another register operand");
1130     }
1131     TiedRegisterPairs.push_back(std::make_pair(DefIdx, I));
1132   }
1133   // FIXME: Verify that for non INLINEASM instructions, the def and use tied
1134   // indices must be less than tied max.
1135   for (const auto &TiedPair : TiedRegisterPairs)
1136     MI.tieOperands(TiedPair.first, TiedPair.second);
1137   return false;
1138 }
1139
1140 bool MIParser::parseRegisterOperand(MachineOperand &Dest,
1141                                     Optional<unsigned> &TiedDefIdx,
1142                                     bool IsDef) {
1143   unsigned Flags = IsDef ? RegState::Define : 0;
1144   while (Token.isRegisterFlag()) {
1145     if (parseRegisterFlag(Flags))
1146       return true;
1147   }
1148   if (!Token.isRegister())
1149     return error("expected a register after register flags");
1150   unsigned Reg;
1151   VRegInfo *RegInfo;
1152   if (parseRegister(Reg, RegInfo))
1153     return true;
1154   lex();
1155   unsigned SubReg = 0;
1156   if (Token.is(MIToken::dot)) {
1157     if (parseSubRegisterIndex(SubReg))
1158       return true;
1159     if (!TargetRegisterInfo::isVirtualRegister(Reg))
1160       return error("subregister index expects a virtual register");
1161   }
1162   if (Token.is(MIToken::colon)) {
1163     if (!TargetRegisterInfo::isVirtualRegister(Reg))
1164       return error("register class specification expects a virtual register");
1165     lex();
1166     if (parseRegisterClassOrBank(*RegInfo))
1167         return true;
1168   }
1169   MachineRegisterInfo &MRI = MF.getRegInfo();
1170   if ((Flags & RegState::Define) == 0) {
1171     if (consumeIfPresent(MIToken::lparen)) {
1172       unsigned Idx;
1173       if (!parseRegisterTiedDefIndex(Idx))
1174         TiedDefIdx = Idx;
1175       else {
1176         // Try a redundant low-level type.
1177         LLT Ty;
1178         if (parseLowLevelType(Token.location(), Ty))
1179           return error("expected tied-def or low-level type after '('");
1180
1181         if (expectAndConsume(MIToken::rparen))
1182           return true;
1183
1184         if (MRI.getType(Reg).isValid() && MRI.getType(Reg) != Ty)
1185           return error("inconsistent type for generic virtual register");
1186
1187         MRI.setType(Reg, Ty);
1188       }
1189     }
1190   } else if (consumeIfPresent(MIToken::lparen)) {
1191     // Virtual registers may have a tpe with GlobalISel.
1192     if (!TargetRegisterInfo::isVirtualRegister(Reg))
1193       return error("unexpected type on physical register");
1194
1195     LLT Ty;
1196     if (parseLowLevelType(Token.location(), Ty))
1197       return true;
1198
1199     if (expectAndConsume(MIToken::rparen))
1200       return true;
1201
1202     if (MRI.getType(Reg).isValid() && MRI.getType(Reg) != Ty)
1203       return error("inconsistent type for generic virtual register");
1204
1205     MRI.setType(Reg, Ty);
1206   } else if (TargetRegisterInfo::isVirtualRegister(Reg)) {
1207     // Generic virtual registers must have a type.
1208     // If we end up here this means the type hasn't been specified and
1209     // this is bad!
1210     if (RegInfo->Kind == VRegInfo::GENERIC ||
1211         RegInfo->Kind == VRegInfo::REGBANK)
1212       return error("generic virtual registers must have a type");
1213   }
1214   Dest = MachineOperand::CreateReg(
1215       Reg, Flags & RegState::Define, Flags & RegState::Implicit,
1216       Flags & RegState::Kill, Flags & RegState::Dead, Flags & RegState::Undef,
1217       Flags & RegState::EarlyClobber, SubReg, Flags & RegState::Debug,
1218       Flags & RegState::InternalRead, Flags & RegState::Renamable);
1219
1220   return false;
1221 }
1222
1223 bool MIParser::parseImmediateOperand(MachineOperand &Dest) {
1224   assert(Token.is(MIToken::IntegerLiteral));
1225   const APSInt &Int = Token.integerValue();
1226   if (Int.getMinSignedBits() > 64)
1227     return error("integer literal is too large to be an immediate operand");
1228   Dest = MachineOperand::CreateImm(Int.getExtValue());
1229   lex();
1230   return false;
1231 }
1232
1233 bool MIParser::parseIRConstant(StringRef::iterator Loc, StringRef StringValue,
1234                                const Constant *&C) {
1235   auto Source = StringValue.str(); // The source has to be null terminated.
1236   SMDiagnostic Err;
1237   C = parseConstantValue(Source, Err, *MF.getFunction().getParent(),
1238                          &PFS.IRSlots);
1239   if (!C)
1240     return error(Loc + Err.getColumnNo(), Err.getMessage());
1241   return false;
1242 }
1243
1244 bool MIParser::parseIRConstant(StringRef::iterator Loc, const Constant *&C) {
1245   if (parseIRConstant(Loc, StringRef(Loc, Token.range().end() - Loc), C))
1246     return true;
1247   lex();
1248   return false;
1249 }
1250
1251 bool MIParser::parseLowLevelType(StringRef::iterator Loc, LLT &Ty) {
1252   if (Token.is(MIToken::ScalarType)) {
1253     Ty = LLT::scalar(APSInt(Token.range().drop_front()).getZExtValue());
1254     lex();
1255     return false;
1256   } else if (Token.is(MIToken::PointerType)) {
1257     const DataLayout &DL = MF.getDataLayout();
1258     unsigned AS = APSInt(Token.range().drop_front()).getZExtValue();
1259     Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
1260     lex();
1261     return false;
1262   }
1263
1264   // Now we're looking for a vector.
1265   if (Token.isNot(MIToken::less))
1266     return error(Loc,
1267                  "expected unsized, pN, sN or <N x sM> for GlobalISel type");
1268
1269   lex();
1270
1271   if (Token.isNot(MIToken::IntegerLiteral))
1272     return error(Loc, "expected <N x sM> for vctor type");
1273   uint64_t NumElements = Token.integerValue().getZExtValue();
1274   lex();
1275
1276   if (Token.isNot(MIToken::Identifier) || Token.stringValue() != "x")
1277     return error(Loc, "expected '<N x sM>' for vector type");
1278   lex();
1279
1280   if (Token.isNot(MIToken::ScalarType))
1281     return error(Loc, "expected '<N x sM>' for vector type");
1282   uint64_t ScalarSize = APSInt(Token.range().drop_front()).getZExtValue();
1283   lex();
1284
1285   if (Token.isNot(MIToken::greater))
1286     return error(Loc, "expected '<N x sM>' for vector type");
1287   lex();
1288
1289   Ty = LLT::vector(NumElements, ScalarSize);
1290   return false;
1291 }
1292
1293 bool MIParser::parseTypedImmediateOperand(MachineOperand &Dest) {
1294   assert(Token.is(MIToken::IntegerType));
1295   auto Loc = Token.location();
1296   lex();
1297   if (Token.isNot(MIToken::IntegerLiteral))
1298     return error("expected an integer literal");
1299   const Constant *C = nullptr;
1300   if (parseIRConstant(Loc, C))
1301     return true;
1302   Dest = MachineOperand::CreateCImm(cast<ConstantInt>(C));
1303   return false;
1304 }
1305
1306 bool MIParser::parseFPImmediateOperand(MachineOperand &Dest) {
1307   auto Loc = Token.location();
1308   lex();
1309   if (Token.isNot(MIToken::FloatingPointLiteral) &&
1310       Token.isNot(MIToken::HexLiteral))
1311     return error("expected a floating point literal");
1312   const Constant *C = nullptr;
1313   if (parseIRConstant(Loc, C))
1314     return true;
1315   Dest = MachineOperand::CreateFPImm(cast<ConstantFP>(C));
1316   return false;
1317 }
1318
1319 bool MIParser::getUnsigned(unsigned &Result) {
1320   if (Token.hasIntegerValue()) {
1321     const uint64_t Limit = uint64_t(std::numeric_limits<unsigned>::max()) + 1;
1322     uint64_t Val64 = Token.integerValue().getLimitedValue(Limit);
1323     if (Val64 == Limit)
1324       return error("expected 32-bit integer (too large)");
1325     Result = Val64;
1326     return false;
1327   }
1328   if (Token.is(MIToken::HexLiteral)) {
1329     APInt A;
1330     if (getHexUint(A))
1331       return true;
1332     if (A.getBitWidth() > 32)
1333       return error("expected 32-bit integer (too large)");
1334     Result = A.getZExtValue();
1335     return false;
1336   }
1337   return true;
1338 }
1339
1340 bool MIParser::parseMBBReference(MachineBasicBlock *&MBB) {
1341   assert(Token.is(MIToken::MachineBasicBlock) ||
1342          Token.is(MIToken::MachineBasicBlockLabel));
1343   unsigned Number;
1344   if (getUnsigned(Number))
1345     return true;
1346   auto MBBInfo = PFS.MBBSlots.find(Number);
1347   if (MBBInfo == PFS.MBBSlots.end())
1348     return error(Twine("use of undefined machine basic block #") +
1349                  Twine(Number));
1350   MBB = MBBInfo->second;
1351   // TODO: Only parse the name if it's a MachineBasicBlockLabel. Deprecate once
1352   // we drop the <irname> from the bb.<id>.<irname> format.
1353   if (!Token.stringValue().empty() && Token.stringValue() != MBB->getName())
1354     return error(Twine("the name of machine basic block #") + Twine(Number) +
1355                  " isn't '" + Token.stringValue() + "'");
1356   return false;
1357 }
1358
1359 bool MIParser::parseMBBOperand(MachineOperand &Dest) {
1360   MachineBasicBlock *MBB;
1361   if (parseMBBReference(MBB))
1362     return true;
1363   Dest = MachineOperand::CreateMBB(MBB);
1364   lex();
1365   return false;
1366 }
1367
1368 bool MIParser::parseStackFrameIndex(int &FI) {
1369   assert(Token.is(MIToken::StackObject));
1370   unsigned ID;
1371   if (getUnsigned(ID))
1372     return true;
1373   auto ObjectInfo = PFS.StackObjectSlots.find(ID);
1374   if (ObjectInfo == PFS.StackObjectSlots.end())
1375     return error(Twine("use of undefined stack object '%stack.") + Twine(ID) +
1376                  "'");
1377   StringRef Name;
1378   if (const auto *Alloca =
1379           MF.getFrameInfo().getObjectAllocation(ObjectInfo->second))
1380     Name = Alloca->getName();
1381   if (!Token.stringValue().empty() && Token.stringValue() != Name)
1382     return error(Twine("the name of the stack object '%stack.") + Twine(ID) +
1383                  "' isn't '" + Token.stringValue() + "'");
1384   lex();
1385   FI = ObjectInfo->second;
1386   return false;
1387 }
1388
1389 bool MIParser::parseStackObjectOperand(MachineOperand &Dest) {
1390   int FI;
1391   if (parseStackFrameIndex(FI))
1392     return true;
1393   Dest = MachineOperand::CreateFI(FI);
1394   return false;
1395 }
1396
1397 bool MIParser::parseFixedStackFrameIndex(int &FI) {
1398   assert(Token.is(MIToken::FixedStackObject));
1399   unsigned ID;
1400   if (getUnsigned(ID))
1401     return true;
1402   auto ObjectInfo = PFS.FixedStackObjectSlots.find(ID);
1403   if (ObjectInfo == PFS.FixedStackObjectSlots.end())
1404     return error(Twine("use of undefined fixed stack object '%fixed-stack.") +
1405                  Twine(ID) + "'");
1406   lex();
1407   FI = ObjectInfo->second;
1408   return false;
1409 }
1410
1411 bool MIParser::parseFixedStackObjectOperand(MachineOperand &Dest) {
1412   int FI;
1413   if (parseFixedStackFrameIndex(FI))
1414     return true;
1415   Dest = MachineOperand::CreateFI(FI);
1416   return false;
1417 }
1418
1419 bool MIParser::parseGlobalValue(GlobalValue *&GV) {
1420   switch (Token.kind()) {
1421   case MIToken::NamedGlobalValue: {
1422     const Module *M = MF.getFunction().getParent();
1423     GV = M->getNamedValue(Token.stringValue());
1424     if (!GV)
1425       return error(Twine("use of undefined global value '") + Token.range() +
1426                    "'");
1427     break;
1428   }
1429   case MIToken::GlobalValue: {
1430     unsigned GVIdx;
1431     if (getUnsigned(GVIdx))
1432       return true;
1433     if (GVIdx >= PFS.IRSlots.GlobalValues.size())
1434       return error(Twine("use of undefined global value '@") + Twine(GVIdx) +
1435                    "'");
1436     GV = PFS.IRSlots.GlobalValues[GVIdx];
1437     break;
1438   }
1439   default:
1440     llvm_unreachable("The current token should be a global value");
1441   }
1442   return false;
1443 }
1444
1445 bool MIParser::parseGlobalAddressOperand(MachineOperand &Dest) {
1446   GlobalValue *GV = nullptr;
1447   if (parseGlobalValue(GV))
1448     return true;
1449   lex();
1450   Dest = MachineOperand::CreateGA(GV, /*Offset=*/0);
1451   if (parseOperandsOffset(Dest))
1452     return true;
1453   return false;
1454 }
1455
1456 bool MIParser::parseConstantPoolIndexOperand(MachineOperand &Dest) {
1457   assert(Token.is(MIToken::ConstantPoolItem));
1458   unsigned ID;
1459   if (getUnsigned(ID))
1460     return true;
1461   auto ConstantInfo = PFS.ConstantPoolSlots.find(ID);
1462   if (ConstantInfo == PFS.ConstantPoolSlots.end())
1463     return error("use of undefined constant '%const." + Twine(ID) + "'");
1464   lex();
1465   Dest = MachineOperand::CreateCPI(ID, /*Offset=*/0);
1466   if (parseOperandsOffset(Dest))
1467     return true;
1468   return false;
1469 }
1470
1471 bool MIParser::parseJumpTableIndexOperand(MachineOperand &Dest) {
1472   assert(Token.is(MIToken::JumpTableIndex));
1473   unsigned ID;
1474   if (getUnsigned(ID))
1475     return true;
1476   auto JumpTableEntryInfo = PFS.JumpTableSlots.find(ID);
1477   if (JumpTableEntryInfo == PFS.JumpTableSlots.end())
1478     return error("use of undefined jump table '%jump-table." + Twine(ID) + "'");
1479   lex();
1480   Dest = MachineOperand::CreateJTI(JumpTableEntryInfo->second);
1481   return false;
1482 }
1483
1484 bool MIParser::parseExternalSymbolOperand(MachineOperand &Dest) {
1485   assert(Token.is(MIToken::ExternalSymbol));
1486   const char *Symbol = MF.createExternalSymbolName(Token.stringValue());
1487   lex();
1488   Dest = MachineOperand::CreateES(Symbol);
1489   if (parseOperandsOffset(Dest))
1490     return true;
1491   return false;
1492 }
1493
1494 bool MIParser::parseSubRegisterIndexOperand(MachineOperand &Dest) {
1495   assert(Token.is(MIToken::SubRegisterIndex));
1496   StringRef Name = Token.stringValue();
1497   unsigned SubRegIndex = getSubRegIndex(Token.stringValue());
1498   if (SubRegIndex == 0)
1499     return error(Twine("unknown subregister index '") + Name + "'");
1500   lex();
1501   Dest = MachineOperand::CreateImm(SubRegIndex);
1502   return false;
1503 }
1504
1505 bool MIParser::parseMDNode(MDNode *&Node) {
1506   assert(Token.is(MIToken::exclaim));
1507
1508   auto Loc = Token.location();
1509   lex();
1510   if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
1511     return error("expected metadata id after '!'");
1512   unsigned ID;
1513   if (getUnsigned(ID))
1514     return true;
1515   auto NodeInfo = PFS.IRSlots.MetadataNodes.find(ID);
1516   if (NodeInfo == PFS.IRSlots.MetadataNodes.end())
1517     return error(Loc, "use of undefined metadata '!" + Twine(ID) + "'");
1518   lex();
1519   Node = NodeInfo->second.get();
1520   return false;
1521 }
1522
1523 bool MIParser::parseDIExpression(MDNode *&Expr) {
1524   assert(Token.is(MIToken::md_diexpr));
1525   lex();
1526
1527   // FIXME: Share this parsing with the IL parser.
1528   SmallVector<uint64_t, 8> Elements;
1529
1530   if (expectAndConsume(MIToken::lparen))
1531     return true;
1532
1533   if (Token.isNot(MIToken::rparen)) {
1534     do {
1535       if (Token.is(MIToken::Identifier)) {
1536         if (unsigned Op = dwarf::getOperationEncoding(Token.stringValue())) {
1537           lex();
1538           Elements.push_back(Op);
1539           continue;
1540         }
1541         return error(Twine("invalid DWARF op '") + Token.stringValue() + "'");
1542       }
1543
1544       if (Token.isNot(MIToken::IntegerLiteral) ||
1545           Token.integerValue().isSigned())
1546         return error("expected unsigned integer");
1547
1548       auto &U = Token.integerValue();
1549       if (U.ugt(UINT64_MAX))
1550         return error("element too large, limit is " + Twine(UINT64_MAX));
1551       Elements.push_back(U.getZExtValue());
1552       lex();
1553
1554     } while (consumeIfPresent(MIToken::comma));
1555   }
1556
1557   if (expectAndConsume(MIToken::rparen))
1558     return true;
1559
1560   Expr = DIExpression::get(MF.getFunction().getContext(), Elements);
1561   return false;
1562 }
1563
1564 bool MIParser::parseMetadataOperand(MachineOperand &Dest) {
1565   MDNode *Node = nullptr;
1566   if (Token.is(MIToken::exclaim)) {
1567     if (parseMDNode(Node))
1568       return true;
1569   } else if (Token.is(MIToken::md_diexpr)) {
1570     if (parseDIExpression(Node))
1571       return true;
1572   }
1573   Dest = MachineOperand::CreateMetadata(Node);
1574   return false;
1575 }
1576
1577 bool MIParser::parseCFIOffset(int &Offset) {
1578   if (Token.isNot(MIToken::IntegerLiteral))
1579     return error("expected a cfi offset");
1580   if (Token.integerValue().getMinSignedBits() > 32)
1581     return error("expected a 32 bit integer (the cfi offset is too large)");
1582   Offset = (int)Token.integerValue().getExtValue();
1583   lex();
1584   return false;
1585 }
1586
1587 bool MIParser::parseCFIRegister(unsigned &Reg) {
1588   if (Token.isNot(MIToken::NamedRegister))
1589     return error("expected a cfi register");
1590   unsigned LLVMReg;
1591   if (parseNamedRegister(LLVMReg))
1592     return true;
1593   const auto *TRI = MF.getSubtarget().getRegisterInfo();
1594   assert(TRI && "Expected target register info");
1595   int DwarfReg = TRI->getDwarfRegNum(LLVMReg, true);
1596   if (DwarfReg < 0)
1597     return error("invalid DWARF register");
1598   Reg = (unsigned)DwarfReg;
1599   lex();
1600   return false;
1601 }
1602
1603 bool MIParser::parseCFIEscapeValues(std::string &Values) {
1604   do {
1605     if (Token.isNot(MIToken::HexLiteral))
1606       return error("expected a hexadecimal literal");
1607     unsigned Value;
1608     if (getUnsigned(Value))
1609       return true;
1610     if (Value > UINT8_MAX)
1611       return error("expected a 8-bit integer (too large)");
1612     Values.push_back(static_cast<uint8_t>(Value));
1613     lex();
1614   } while (consumeIfPresent(MIToken::comma));
1615   return false;
1616 }
1617
1618 bool MIParser::parseCFIOperand(MachineOperand &Dest) {
1619   auto Kind = Token.kind();
1620   lex();
1621   int Offset;
1622   unsigned Reg;
1623   unsigned CFIIndex;
1624   switch (Kind) {
1625   case MIToken::kw_cfi_same_value:
1626     if (parseCFIRegister(Reg))
1627       return true;
1628     CFIIndex = MF.addFrameInst(MCCFIInstruction::createSameValue(nullptr, Reg));
1629     break;
1630   case MIToken::kw_cfi_offset:
1631     if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1632         parseCFIOffset(Offset))
1633       return true;
1634     CFIIndex =
1635         MF.addFrameInst(MCCFIInstruction::createOffset(nullptr, Reg, Offset));
1636     break;
1637   case MIToken::kw_cfi_rel_offset:
1638     if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1639         parseCFIOffset(Offset))
1640       return true;
1641     CFIIndex = MF.addFrameInst(
1642         MCCFIInstruction::createRelOffset(nullptr, Reg, Offset));
1643     break;
1644   case MIToken::kw_cfi_def_cfa_register:
1645     if (parseCFIRegister(Reg))
1646       return true;
1647     CFIIndex =
1648         MF.addFrameInst(MCCFIInstruction::createDefCfaRegister(nullptr, Reg));
1649     break;
1650   case MIToken::kw_cfi_def_cfa_offset:
1651     if (parseCFIOffset(Offset))
1652       return true;
1653     // NB: MCCFIInstruction::createDefCfaOffset negates the offset.
1654     CFIIndex = MF.addFrameInst(
1655         MCCFIInstruction::createDefCfaOffset(nullptr, -Offset));
1656     break;
1657   case MIToken::kw_cfi_adjust_cfa_offset:
1658     if (parseCFIOffset(Offset))
1659       return true;
1660     CFIIndex = MF.addFrameInst(
1661         MCCFIInstruction::createAdjustCfaOffset(nullptr, Offset));
1662     break;
1663   case MIToken::kw_cfi_def_cfa:
1664     if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1665         parseCFIOffset(Offset))
1666       return true;
1667     // NB: MCCFIInstruction::createDefCfa negates the offset.
1668     CFIIndex =
1669         MF.addFrameInst(MCCFIInstruction::createDefCfa(nullptr, Reg, -Offset));
1670     break;
1671   case MIToken::kw_cfi_remember_state:
1672     CFIIndex = MF.addFrameInst(MCCFIInstruction::createRememberState(nullptr));
1673     break;
1674   case MIToken::kw_cfi_restore:
1675     if (parseCFIRegister(Reg))
1676       return true;
1677     CFIIndex = MF.addFrameInst(MCCFIInstruction::createRestore(nullptr, Reg));
1678     break;
1679   case MIToken::kw_cfi_restore_state:
1680     CFIIndex = MF.addFrameInst(MCCFIInstruction::createRestoreState(nullptr));
1681     break;
1682   case MIToken::kw_cfi_undefined:
1683     if (parseCFIRegister(Reg))
1684       return true;
1685     CFIIndex = MF.addFrameInst(MCCFIInstruction::createUndefined(nullptr, Reg));
1686     break;
1687   case MIToken::kw_cfi_register: {
1688     unsigned Reg2;
1689     if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1690         parseCFIRegister(Reg2))
1691       return true;
1692
1693     CFIIndex =
1694         MF.addFrameInst(MCCFIInstruction::createRegister(nullptr, Reg, Reg2));
1695     break;
1696   }
1697   case MIToken::kw_cfi_window_save:
1698     CFIIndex = MF.addFrameInst(MCCFIInstruction::createWindowSave(nullptr));
1699     break;
1700   case MIToken::kw_cfi_escape: {
1701     std::string Values;
1702     if (parseCFIEscapeValues(Values))
1703       return true;
1704     CFIIndex = MF.addFrameInst(MCCFIInstruction::createEscape(nullptr, Values));
1705     break;
1706   }
1707   default:
1708     // TODO: Parse the other CFI operands.
1709     llvm_unreachable("The current token should be a cfi operand");
1710   }
1711   Dest = MachineOperand::CreateCFIIndex(CFIIndex);
1712   return false;
1713 }
1714
1715 bool MIParser::parseIRBlock(BasicBlock *&BB, const Function &F) {
1716   switch (Token.kind()) {
1717   case MIToken::NamedIRBlock: {
1718     BB = dyn_cast_or_null<BasicBlock>(
1719         F.getValueSymbolTable()->lookup(Token.stringValue()));
1720     if (!BB)
1721       return error(Twine("use of undefined IR block '") + Token.range() + "'");
1722     break;
1723   }
1724   case MIToken::IRBlock: {
1725     unsigned SlotNumber = 0;
1726     if (getUnsigned(SlotNumber))
1727       return true;
1728     BB = const_cast<BasicBlock *>(getIRBlock(SlotNumber, F));
1729     if (!BB)
1730       return error(Twine("use of undefined IR block '%ir-block.") +
1731                    Twine(SlotNumber) + "'");
1732     break;
1733   }
1734   default:
1735     llvm_unreachable("The current token should be an IR block reference");
1736   }
1737   return false;
1738 }
1739
1740 bool MIParser::parseBlockAddressOperand(MachineOperand &Dest) {
1741   assert(Token.is(MIToken::kw_blockaddress));
1742   lex();
1743   if (expectAndConsume(MIToken::lparen))
1744     return true;
1745   if (Token.isNot(MIToken::GlobalValue) &&
1746       Token.isNot(MIToken::NamedGlobalValue))
1747     return error("expected a global value");
1748   GlobalValue *GV = nullptr;
1749   if (parseGlobalValue(GV))
1750     return true;
1751   auto *F = dyn_cast<Function>(GV);
1752   if (!F)
1753     return error("expected an IR function reference");
1754   lex();
1755   if (expectAndConsume(MIToken::comma))
1756     return true;
1757   BasicBlock *BB = nullptr;
1758   if (Token.isNot(MIToken::IRBlock) && Token.isNot(MIToken::NamedIRBlock))
1759     return error("expected an IR block reference");
1760   if (parseIRBlock(BB, *F))
1761     return true;
1762   lex();
1763   if (expectAndConsume(MIToken::rparen))
1764     return true;
1765   Dest = MachineOperand::CreateBA(BlockAddress::get(F, BB), /*Offset=*/0);
1766   if (parseOperandsOffset(Dest))
1767     return true;
1768   return false;
1769 }
1770
1771 bool MIParser::parseIntrinsicOperand(MachineOperand &Dest) {
1772   assert(Token.is(MIToken::kw_intrinsic));
1773   lex();
1774   if (expectAndConsume(MIToken::lparen))
1775     return error("expected syntax intrinsic(@llvm.whatever)");
1776
1777   if (Token.isNot(MIToken::NamedGlobalValue))
1778     return error("expected syntax intrinsic(@llvm.whatever)");
1779
1780   std::string Name = Token.stringValue();
1781   lex();
1782
1783   if (expectAndConsume(MIToken::rparen))
1784     return error("expected ')' to terminate intrinsic name");
1785
1786   // Find out what intrinsic we're dealing with, first try the global namespace
1787   // and then the target's private intrinsics if that fails.
1788   const TargetIntrinsicInfo *TII = MF.getTarget().getIntrinsicInfo();
1789   Intrinsic::ID ID = Function::lookupIntrinsicID(Name);
1790   if (ID == Intrinsic::not_intrinsic && TII)
1791     ID = static_cast<Intrinsic::ID>(TII->lookupName(Name));
1792
1793   if (ID == Intrinsic::not_intrinsic)
1794     return error("unknown intrinsic name");
1795   Dest = MachineOperand::CreateIntrinsicID(ID);
1796
1797   return false;
1798 }
1799
1800 bool MIParser::parsePredicateOperand(MachineOperand &Dest) {
1801   assert(Token.is(MIToken::kw_intpred) || Token.is(MIToken::kw_floatpred));
1802   bool IsFloat = Token.is(MIToken::kw_floatpred);
1803   lex();
1804
1805   if (expectAndConsume(MIToken::lparen))
1806     return error("expected syntax intpred(whatever) or floatpred(whatever");
1807
1808   if (Token.isNot(MIToken::Identifier))
1809     return error("whatever");
1810
1811   CmpInst::Predicate Pred;
1812   if (IsFloat) {
1813     Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
1814                .Case("false", CmpInst::FCMP_FALSE)
1815                .Case("oeq", CmpInst::FCMP_OEQ)
1816                .Case("ogt", CmpInst::FCMP_OGT)
1817                .Case("oge", CmpInst::FCMP_OGE)
1818                .Case("olt", CmpInst::FCMP_OLT)
1819                .Case("ole", CmpInst::FCMP_OLE)
1820                .Case("one", CmpInst::FCMP_ONE)
1821                .Case("ord", CmpInst::FCMP_ORD)
1822                .Case("uno", CmpInst::FCMP_UNO)
1823                .Case("ueq", CmpInst::FCMP_UEQ)
1824                .Case("ugt", CmpInst::FCMP_UGT)
1825                .Case("uge", CmpInst::FCMP_UGE)
1826                .Case("ult", CmpInst::FCMP_ULT)
1827                .Case("ule", CmpInst::FCMP_ULE)
1828                .Case("une", CmpInst::FCMP_UNE)
1829                .Case("true", CmpInst::FCMP_TRUE)
1830                .Default(CmpInst::BAD_FCMP_PREDICATE);
1831     if (!CmpInst::isFPPredicate(Pred))
1832       return error("invalid floating-point predicate");
1833   } else {
1834     Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
1835                .Case("eq", CmpInst::ICMP_EQ)
1836                .Case("ne", CmpInst::ICMP_NE)
1837                .Case("sgt", CmpInst::ICMP_SGT)
1838                .Case("sge", CmpInst::ICMP_SGE)
1839                .Case("slt", CmpInst::ICMP_SLT)
1840                .Case("sle", CmpInst::ICMP_SLE)
1841                .Case("ugt", CmpInst::ICMP_UGT)
1842                .Case("uge", CmpInst::ICMP_UGE)
1843                .Case("ult", CmpInst::ICMP_ULT)
1844                .Case("ule", CmpInst::ICMP_ULE)
1845                .Default(CmpInst::BAD_ICMP_PREDICATE);
1846     if (!CmpInst::isIntPredicate(Pred))
1847       return error("invalid integer predicate");
1848   }
1849
1850   lex();
1851   Dest = MachineOperand::CreatePredicate(Pred);
1852   if (expectAndConsume(MIToken::rparen))
1853     return error("predicate should be terminated by ')'.");
1854
1855   return false;
1856 }
1857
1858 bool MIParser::parseTargetIndexOperand(MachineOperand &Dest) {
1859   assert(Token.is(MIToken::kw_target_index));
1860   lex();
1861   if (expectAndConsume(MIToken::lparen))
1862     return true;
1863   if (Token.isNot(MIToken::Identifier))
1864     return error("expected the name of the target index");
1865   int Index = 0;
1866   if (getTargetIndex(Token.stringValue(), Index))
1867     return error("use of undefined target index '" + Token.stringValue() + "'");
1868   lex();
1869   if (expectAndConsume(MIToken::rparen))
1870     return true;
1871   Dest = MachineOperand::CreateTargetIndex(unsigned(Index), /*Offset=*/0);
1872   if (parseOperandsOffset(Dest))
1873     return true;
1874   return false;
1875 }
1876
1877 bool MIParser::parseCustomRegisterMaskOperand(MachineOperand &Dest) {
1878   assert(Token.stringValue() == "CustomRegMask" && "Expected a custom RegMask");
1879   const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
1880   assert(TRI && "Expected target register info");
1881   lex();
1882   if (expectAndConsume(MIToken::lparen))
1883     return true;
1884
1885   uint32_t *Mask = MF.allocateRegisterMask(TRI->getNumRegs());
1886   while (true) {
1887     if (Token.isNot(MIToken::NamedRegister))
1888       return error("expected a named register");
1889     unsigned Reg;
1890     if (parseNamedRegister(Reg))
1891       return true;
1892     lex();
1893     Mask[Reg / 32] |= 1U << (Reg % 32);
1894     // TODO: Report an error if the same register is used more than once.
1895     if (Token.isNot(MIToken::comma))
1896       break;
1897     lex();
1898   }
1899
1900   if (expectAndConsume(MIToken::rparen))
1901     return true;
1902   Dest = MachineOperand::CreateRegMask(Mask);
1903   return false;
1904 }
1905
1906 bool MIParser::parseLiveoutRegisterMaskOperand(MachineOperand &Dest) {
1907   assert(Token.is(MIToken::kw_liveout));
1908   const auto *TRI = MF.getSubtarget().getRegisterInfo();
1909   assert(TRI && "Expected target register info");
1910   uint32_t *Mask = MF.allocateRegisterMask(TRI->getNumRegs());
1911   lex();
1912   if (expectAndConsume(MIToken::lparen))
1913     return true;
1914   while (true) {
1915     if (Token.isNot(MIToken::NamedRegister))
1916       return error("expected a named register");
1917     unsigned Reg;
1918     if (parseNamedRegister(Reg))
1919       return true;
1920     lex();
1921     Mask[Reg / 32] |= 1U << (Reg % 32);
1922     // TODO: Report an error if the same register is used more than once.
1923     if (Token.isNot(MIToken::comma))
1924       break;
1925     lex();
1926   }
1927   if (expectAndConsume(MIToken::rparen))
1928     return true;
1929   Dest = MachineOperand::CreateRegLiveOut(Mask);
1930   return false;
1931 }
1932
1933 bool MIParser::parseMachineOperand(MachineOperand &Dest,
1934                                    Optional<unsigned> &TiedDefIdx) {
1935   switch (Token.kind()) {
1936   case MIToken::kw_implicit:
1937   case MIToken::kw_implicit_define:
1938   case MIToken::kw_def:
1939   case MIToken::kw_dead:
1940   case MIToken::kw_killed:
1941   case MIToken::kw_undef:
1942   case MIToken::kw_internal:
1943   case MIToken::kw_early_clobber:
1944   case MIToken::kw_debug_use:
1945   case MIToken::kw_renamable:
1946   case MIToken::underscore:
1947   case MIToken::NamedRegister:
1948   case MIToken::VirtualRegister:
1949     return parseRegisterOperand(Dest, TiedDefIdx);
1950   case MIToken::IntegerLiteral:
1951     return parseImmediateOperand(Dest);
1952   case MIToken::IntegerType:
1953     return parseTypedImmediateOperand(Dest);
1954   case MIToken::kw_half:
1955   case MIToken::kw_float:
1956   case MIToken::kw_double:
1957   case MIToken::kw_x86_fp80:
1958   case MIToken::kw_fp128:
1959   case MIToken::kw_ppc_fp128:
1960     return parseFPImmediateOperand(Dest);
1961   case MIToken::MachineBasicBlock:
1962     return parseMBBOperand(Dest);
1963   case MIToken::StackObject:
1964     return parseStackObjectOperand(Dest);
1965   case MIToken::FixedStackObject:
1966     return parseFixedStackObjectOperand(Dest);
1967   case MIToken::GlobalValue:
1968   case MIToken::NamedGlobalValue:
1969     return parseGlobalAddressOperand(Dest);
1970   case MIToken::ConstantPoolItem:
1971     return parseConstantPoolIndexOperand(Dest);
1972   case MIToken::JumpTableIndex:
1973     return parseJumpTableIndexOperand(Dest);
1974   case MIToken::ExternalSymbol:
1975     return parseExternalSymbolOperand(Dest);
1976   case MIToken::SubRegisterIndex:
1977     return parseSubRegisterIndexOperand(Dest);
1978   case MIToken::md_diexpr:
1979   case MIToken::exclaim:
1980     return parseMetadataOperand(Dest);
1981   case MIToken::kw_cfi_same_value:
1982   case MIToken::kw_cfi_offset:
1983   case MIToken::kw_cfi_rel_offset:
1984   case MIToken::kw_cfi_def_cfa_register:
1985   case MIToken::kw_cfi_def_cfa_offset:
1986   case MIToken::kw_cfi_adjust_cfa_offset:
1987   case MIToken::kw_cfi_escape:
1988   case MIToken::kw_cfi_def_cfa:
1989   case MIToken::kw_cfi_register:
1990   case MIToken::kw_cfi_remember_state:
1991   case MIToken::kw_cfi_restore:
1992   case MIToken::kw_cfi_restore_state:
1993   case MIToken::kw_cfi_undefined:
1994   case MIToken::kw_cfi_window_save:
1995     return parseCFIOperand(Dest);
1996   case MIToken::kw_blockaddress:
1997     return parseBlockAddressOperand(Dest);
1998   case MIToken::kw_intrinsic:
1999     return parseIntrinsicOperand(Dest);
2000   case MIToken::kw_target_index:
2001     return parseTargetIndexOperand(Dest);
2002   case MIToken::kw_liveout:
2003     return parseLiveoutRegisterMaskOperand(Dest);
2004   case MIToken::kw_floatpred:
2005   case MIToken::kw_intpred:
2006     return parsePredicateOperand(Dest);
2007   case MIToken::Error:
2008     return true;
2009   case MIToken::Identifier:
2010     if (const auto *RegMask = getRegMask(Token.stringValue())) {
2011       Dest = MachineOperand::CreateRegMask(RegMask);
2012       lex();
2013       break;
2014     } else
2015       return parseCustomRegisterMaskOperand(Dest);
2016   default:
2017     // FIXME: Parse the MCSymbol machine operand.
2018     return error("expected a machine operand");
2019   }
2020   return false;
2021 }
2022
2023 bool MIParser::parseMachineOperandAndTargetFlags(
2024     MachineOperand &Dest, Optional<unsigned> &TiedDefIdx) {
2025   unsigned TF = 0;
2026   bool HasTargetFlags = false;
2027   if (Token.is(MIToken::kw_target_flags)) {
2028     HasTargetFlags = true;
2029     lex();
2030     if (expectAndConsume(MIToken::lparen))
2031       return true;
2032     if (Token.isNot(MIToken::Identifier))
2033       return error("expected the name of the target flag");
2034     if (getDirectTargetFlag(Token.stringValue(), TF)) {
2035       if (getBitmaskTargetFlag(Token.stringValue(), TF))
2036         return error("use of undefined target flag '" + Token.stringValue() +
2037                      "'");
2038     }
2039     lex();
2040     while (Token.is(MIToken::comma)) {
2041       lex();
2042       if (Token.isNot(MIToken::Identifier))
2043         return error("expected the name of the target flag");
2044       unsigned BitFlag = 0;
2045       if (getBitmaskTargetFlag(Token.stringValue(), BitFlag))
2046         return error("use of undefined target flag '" + Token.stringValue() +
2047                      "'");
2048       // TODO: Report an error when using a duplicate bit target flag.
2049       TF |= BitFlag;
2050       lex();
2051     }
2052     if (expectAndConsume(MIToken::rparen))
2053       return true;
2054   }
2055   auto Loc = Token.location();
2056   if (parseMachineOperand(Dest, TiedDefIdx))
2057     return true;
2058   if (!HasTargetFlags)
2059     return false;
2060   if (Dest.isReg())
2061     return error(Loc, "register operands can't have target flags");
2062   Dest.setTargetFlags(TF);
2063   return false;
2064 }
2065
2066 bool MIParser::parseOffset(int64_t &Offset) {
2067   if (Token.isNot(MIToken::plus) && Token.isNot(MIToken::minus))
2068     return false;
2069   StringRef Sign = Token.range();
2070   bool IsNegative = Token.is(MIToken::minus);
2071   lex();
2072   if (Token.isNot(MIToken::IntegerLiteral))
2073     return error("expected an integer literal after '" + Sign + "'");
2074   if (Token.integerValue().getMinSignedBits() > 64)
2075     return error("expected 64-bit integer (too large)");
2076   Offset = Token.integerValue().getExtValue();
2077   if (IsNegative)
2078     Offset = -Offset;
2079   lex();
2080   return false;
2081 }
2082
2083 bool MIParser::parseAlignment(unsigned &Alignment) {
2084   assert(Token.is(MIToken::kw_align));
2085   lex();
2086   if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
2087     return error("expected an integer literal after 'align'");
2088   if (getUnsigned(Alignment))
2089     return true;
2090   lex();
2091   return false;
2092 }
2093
2094 bool MIParser::parseOperandsOffset(MachineOperand &Op) {
2095   int64_t Offset = 0;
2096   if (parseOffset(Offset))
2097     return true;
2098   Op.setOffset(Offset);
2099   return false;
2100 }
2101
2102 bool MIParser::parseIRValue(const Value *&V) {
2103   switch (Token.kind()) {
2104   case MIToken::NamedIRValue: {
2105     V = MF.getFunction().getValueSymbolTable()->lookup(Token.stringValue());
2106     break;
2107   }
2108   case MIToken::IRValue: {
2109     unsigned SlotNumber = 0;
2110     if (getUnsigned(SlotNumber))
2111       return true;
2112     V = getIRValue(SlotNumber);
2113     break;
2114   }
2115   case MIToken::NamedGlobalValue:
2116   case MIToken::GlobalValue: {
2117     GlobalValue *GV = nullptr;
2118     if (parseGlobalValue(GV))
2119       return true;
2120     V = GV;
2121     break;
2122   }
2123   case MIToken::QuotedIRValue: {
2124     const Constant *C = nullptr;
2125     if (parseIRConstant(Token.location(), Token.stringValue(), C))
2126       return true;
2127     V = C;
2128     break;
2129   }
2130   default:
2131     llvm_unreachable("The current token should be an IR block reference");
2132   }
2133   if (!V)
2134     return error(Twine("use of undefined IR value '") + Token.range() + "'");
2135   return false;
2136 }
2137
2138 bool MIParser::getUint64(uint64_t &Result) {
2139   if (Token.hasIntegerValue()) {
2140     if (Token.integerValue().getActiveBits() > 64)
2141       return error("expected 64-bit integer (too large)");
2142     Result = Token.integerValue().getZExtValue();
2143     return false;
2144   }
2145   if (Token.is(MIToken::HexLiteral)) {
2146     APInt A;
2147     if (getHexUint(A))
2148       return true;
2149     if (A.getBitWidth() > 64)
2150       return error("expected 64-bit integer (too large)");
2151     Result = A.getZExtValue();
2152     return false;
2153   }
2154   return true;
2155 }
2156
2157 bool MIParser::getHexUint(APInt &Result) {
2158   assert(Token.is(MIToken::HexLiteral));
2159   StringRef S = Token.range();
2160   assert(S[0] == '0' && tolower(S[1]) == 'x');
2161   // This could be a floating point literal with a special prefix.
2162   if (!isxdigit(S[2]))
2163     return true;
2164   StringRef V = S.substr(2);
2165   APInt A(V.size()*4, V, 16);
2166
2167   // If A is 0, then A.getActiveBits() is 0. This isn't a valid bitwidth. Make
2168   // sure it isn't the case before constructing result.
2169   unsigned NumBits = (A == 0) ? 32 : A.getActiveBits();
2170   Result = APInt(NumBits, ArrayRef<uint64_t>(A.getRawData(), A.getNumWords()));
2171   return false;
2172 }
2173
2174 bool MIParser::parseMemoryOperandFlag(MachineMemOperand::Flags &Flags) {
2175   const auto OldFlags = Flags;
2176   switch (Token.kind()) {
2177   case MIToken::kw_volatile:
2178     Flags |= MachineMemOperand::MOVolatile;
2179     break;
2180   case MIToken::kw_non_temporal:
2181     Flags |= MachineMemOperand::MONonTemporal;
2182     break;
2183   case MIToken::kw_dereferenceable:
2184     Flags |= MachineMemOperand::MODereferenceable;
2185     break;
2186   case MIToken::kw_invariant:
2187     Flags |= MachineMemOperand::MOInvariant;
2188     break;
2189   case MIToken::StringConstant: {
2190     MachineMemOperand::Flags TF;
2191     if (getMMOTargetFlag(Token.stringValue(), TF))
2192       return error("use of undefined target MMO flag '" + Token.stringValue() +
2193                    "'");
2194     Flags |= TF;
2195     break;
2196   }
2197   default:
2198     llvm_unreachable("The current token should be a memory operand flag");
2199   }
2200   if (OldFlags == Flags)
2201     // We know that the same flag is specified more than once when the flags
2202     // weren't modified.
2203     return error("duplicate '" + Token.stringValue() + "' memory operand flag");
2204   lex();
2205   return false;
2206 }
2207
2208 bool MIParser::parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV) {
2209   switch (Token.kind()) {
2210   case MIToken::kw_stack:
2211     PSV = MF.getPSVManager().getStack();
2212     break;
2213   case MIToken::kw_got:
2214     PSV = MF.getPSVManager().getGOT();
2215     break;
2216   case MIToken::kw_jump_table:
2217     PSV = MF.getPSVManager().getJumpTable();
2218     break;
2219   case MIToken::kw_constant_pool:
2220     PSV = MF.getPSVManager().getConstantPool();
2221     break;
2222   case MIToken::FixedStackObject: {
2223     int FI;
2224     if (parseFixedStackFrameIndex(FI))
2225       return true;
2226     PSV = MF.getPSVManager().getFixedStack(FI);
2227     // The token was already consumed, so use return here instead of break.
2228     return false;
2229   }
2230   case MIToken::StackObject: {
2231     int FI;
2232     if (parseStackFrameIndex(FI))
2233       return true;
2234     PSV = MF.getPSVManager().getFixedStack(FI);
2235     // The token was already consumed, so use return here instead of break.
2236     return false;
2237   }
2238   case MIToken::kw_call_entry:
2239     lex();
2240     switch (Token.kind()) {
2241     case MIToken::GlobalValue:
2242     case MIToken::NamedGlobalValue: {
2243       GlobalValue *GV = nullptr;
2244       if (parseGlobalValue(GV))
2245         return true;
2246       PSV = MF.getPSVManager().getGlobalValueCallEntry(GV);
2247       break;
2248     }
2249     case MIToken::ExternalSymbol:
2250       PSV = MF.getPSVManager().getExternalSymbolCallEntry(
2251           MF.createExternalSymbolName(Token.stringValue()));
2252       break;
2253     default:
2254       return error(
2255           "expected a global value or an external symbol after 'call-entry'");
2256     }
2257     break;
2258   default:
2259     llvm_unreachable("The current token should be pseudo source value");
2260   }
2261   lex();
2262   return false;
2263 }
2264
2265 bool MIParser::parseMachinePointerInfo(MachinePointerInfo &Dest) {
2266   if (Token.is(MIToken::kw_constant_pool) || Token.is(MIToken::kw_stack) ||
2267       Token.is(MIToken::kw_got) || Token.is(MIToken::kw_jump_table) ||
2268       Token.is(MIToken::FixedStackObject) || Token.is(MIToken::StackObject) ||
2269       Token.is(MIToken::kw_call_entry)) {
2270     const PseudoSourceValue *PSV = nullptr;
2271     if (parseMemoryPseudoSourceValue(PSV))
2272       return true;
2273     int64_t Offset = 0;
2274     if (parseOffset(Offset))
2275       return true;
2276     Dest = MachinePointerInfo(PSV, Offset);
2277     return false;
2278   }
2279   if (Token.isNot(MIToken::NamedIRValue) && Token.isNot(MIToken::IRValue) &&
2280       Token.isNot(MIToken::GlobalValue) &&
2281       Token.isNot(MIToken::NamedGlobalValue) &&
2282       Token.isNot(MIToken::QuotedIRValue))
2283     return error("expected an IR value reference");
2284   const Value *V = nullptr;
2285   if (parseIRValue(V))
2286     return true;
2287   if (!V->getType()->isPointerTy())
2288     return error("expected a pointer IR value");
2289   lex();
2290   int64_t Offset = 0;
2291   if (parseOffset(Offset))
2292     return true;
2293   Dest = MachinePointerInfo(V, Offset);
2294   return false;
2295 }
2296
2297 bool MIParser::parseOptionalScope(LLVMContext &Context,
2298                                   SyncScope::ID &SSID) {
2299   SSID = SyncScope::System;
2300   if (Token.is(MIToken::Identifier) && Token.stringValue() == "syncscope") {
2301     lex();
2302     if (expectAndConsume(MIToken::lparen))
2303       return error("expected '(' in syncscope");
2304
2305     std::string SSN;
2306     if (parseStringConstant(SSN))
2307       return true;
2308
2309     SSID = Context.getOrInsertSyncScopeID(SSN);
2310     if (expectAndConsume(MIToken::rparen))
2311       return error("expected ')' in syncscope");
2312   }
2313
2314   return false;
2315 }
2316
2317 bool MIParser::parseOptionalAtomicOrdering(AtomicOrdering &Order) {
2318   Order = AtomicOrdering::NotAtomic;
2319   if (Token.isNot(MIToken::Identifier))
2320     return false;
2321
2322   Order = StringSwitch<AtomicOrdering>(Token.stringValue())
2323               .Case("unordered", AtomicOrdering::Unordered)
2324               .Case("monotonic", AtomicOrdering::Monotonic)
2325               .Case("acquire", AtomicOrdering::Acquire)
2326               .Case("release", AtomicOrdering::Release)
2327               .Case("acq_rel", AtomicOrdering::AcquireRelease)
2328               .Case("seq_cst", AtomicOrdering::SequentiallyConsistent)
2329               .Default(AtomicOrdering::NotAtomic);
2330
2331   if (Order != AtomicOrdering::NotAtomic) {
2332     lex();
2333     return false;
2334   }
2335
2336   return error("expected an atomic scope, ordering or a size integer literal");
2337 }
2338
2339 bool MIParser::parseMachineMemoryOperand(MachineMemOperand *&Dest) {
2340   if (expectAndConsume(MIToken::lparen))
2341     return true;
2342   MachineMemOperand::Flags Flags = MachineMemOperand::MONone;
2343   while (Token.isMemoryOperandFlag()) {
2344     if (parseMemoryOperandFlag(Flags))
2345       return true;
2346   }
2347   if (Token.isNot(MIToken::Identifier) ||
2348       (Token.stringValue() != "load" && Token.stringValue() != "store"))
2349     return error("expected 'load' or 'store' memory operation");
2350   if (Token.stringValue() == "load")
2351     Flags |= MachineMemOperand::MOLoad;
2352   else
2353     Flags |= MachineMemOperand::MOStore;
2354   lex();
2355
2356   // Optional 'store' for operands that both load and store.
2357   if (Token.is(MIToken::Identifier) && Token.stringValue() == "store") {
2358     Flags |= MachineMemOperand::MOStore;
2359     lex();
2360   }
2361
2362   // Optional synchronization scope.
2363   SyncScope::ID SSID;
2364   if (parseOptionalScope(MF.getFunction().getContext(), SSID))
2365     return true;
2366
2367   // Up to two atomic orderings (cmpxchg provides guarantees on failure).
2368   AtomicOrdering Order, FailureOrder;
2369   if (parseOptionalAtomicOrdering(Order))
2370     return true;
2371
2372   if (parseOptionalAtomicOrdering(FailureOrder))
2373     return true;
2374
2375   if (Token.isNot(MIToken::IntegerLiteral))
2376     return error("expected the size integer literal after memory operation");
2377   uint64_t Size;
2378   if (getUint64(Size))
2379     return true;
2380   lex();
2381
2382   MachinePointerInfo Ptr = MachinePointerInfo();
2383   if (Token.is(MIToken::Identifier)) {
2384     const char *Word =
2385         ((Flags & MachineMemOperand::MOLoad) &&
2386          (Flags & MachineMemOperand::MOStore))
2387             ? "on"
2388             : Flags & MachineMemOperand::MOLoad ? "from" : "into";
2389     if (Token.stringValue() != Word)
2390       return error(Twine("expected '") + Word + "'");
2391     lex();
2392
2393     if (parseMachinePointerInfo(Ptr))
2394       return true;
2395   }
2396   unsigned BaseAlignment = Size;
2397   AAMDNodes AAInfo;
2398   MDNode *Range = nullptr;
2399   while (consumeIfPresent(MIToken::comma)) {
2400     switch (Token.kind()) {
2401     case MIToken::kw_align:
2402       if (parseAlignment(BaseAlignment))
2403         return true;
2404       break;
2405     case MIToken::md_tbaa:
2406       lex();
2407       if (parseMDNode(AAInfo.TBAA))
2408         return true;
2409       break;
2410     case MIToken::md_alias_scope:
2411       lex();
2412       if (parseMDNode(AAInfo.Scope))
2413         return true;
2414       break;
2415     case MIToken::md_noalias:
2416       lex();
2417       if (parseMDNode(AAInfo.NoAlias))
2418         return true;
2419       break;
2420     case MIToken::md_range:
2421       lex();
2422       if (parseMDNode(Range))
2423         return true;
2424       break;
2425     // TODO: Report an error on duplicate metadata nodes.
2426     default:
2427       return error("expected 'align' or '!tbaa' or '!alias.scope' or "
2428                    "'!noalias' or '!range'");
2429     }
2430   }
2431   if (expectAndConsume(MIToken::rparen))
2432     return true;
2433   Dest = MF.getMachineMemOperand(Ptr, Flags, Size, BaseAlignment, AAInfo, Range,
2434                                  SSID, Order, FailureOrder);
2435   return false;
2436 }
2437
2438 void MIParser::initNames2InstrOpCodes() {
2439   if (!Names2InstrOpCodes.empty())
2440     return;
2441   const auto *TII = MF.getSubtarget().getInstrInfo();
2442   assert(TII && "Expected target instruction info");
2443   for (unsigned I = 0, E = TII->getNumOpcodes(); I < E; ++I)
2444     Names2InstrOpCodes.insert(std::make_pair(StringRef(TII->getName(I)), I));
2445 }
2446
2447 bool MIParser::parseInstrName(StringRef InstrName, unsigned &OpCode) {
2448   initNames2InstrOpCodes();
2449   auto InstrInfo = Names2InstrOpCodes.find(InstrName);
2450   if (InstrInfo == Names2InstrOpCodes.end())
2451     return true;
2452   OpCode = InstrInfo->getValue();
2453   return false;
2454 }
2455
2456 void MIParser::initNames2Regs() {
2457   if (!Names2Regs.empty())
2458     return;
2459   // The '%noreg' register is the register 0.
2460   Names2Regs.insert(std::make_pair("noreg", 0));
2461   const auto *TRI = MF.getSubtarget().getRegisterInfo();
2462   assert(TRI && "Expected target register info");
2463   for (unsigned I = 0, E = TRI->getNumRegs(); I < E; ++I) {
2464     bool WasInserted =
2465         Names2Regs.insert(std::make_pair(StringRef(TRI->getName(I)).lower(), I))
2466             .second;
2467     (void)WasInserted;
2468     assert(WasInserted && "Expected registers to be unique case-insensitively");
2469   }
2470 }
2471
2472 bool MIParser::getRegisterByName(StringRef RegName, unsigned &Reg) {
2473   initNames2Regs();
2474   auto RegInfo = Names2Regs.find(RegName);
2475   if (RegInfo == Names2Regs.end())
2476     return true;
2477   Reg = RegInfo->getValue();
2478   return false;
2479 }
2480
2481 void MIParser::initNames2RegMasks() {
2482   if (!Names2RegMasks.empty())
2483     return;
2484   const auto *TRI = MF.getSubtarget().getRegisterInfo();
2485   assert(TRI && "Expected target register info");
2486   ArrayRef<const uint32_t *> RegMasks = TRI->getRegMasks();
2487   ArrayRef<const char *> RegMaskNames = TRI->getRegMaskNames();
2488   assert(RegMasks.size() == RegMaskNames.size());
2489   for (size_t I = 0, E = RegMasks.size(); I < E; ++I)
2490     Names2RegMasks.insert(
2491         std::make_pair(StringRef(RegMaskNames[I]).lower(), RegMasks[I]));
2492 }
2493
2494 const uint32_t *MIParser::getRegMask(StringRef Identifier) {
2495   initNames2RegMasks();
2496   auto RegMaskInfo = Names2RegMasks.find(Identifier);
2497   if (RegMaskInfo == Names2RegMasks.end())
2498     return nullptr;
2499   return RegMaskInfo->getValue();
2500 }
2501
2502 void MIParser::initNames2SubRegIndices() {
2503   if (!Names2SubRegIndices.empty())
2504     return;
2505   const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
2506   for (unsigned I = 1, E = TRI->getNumSubRegIndices(); I < E; ++I)
2507     Names2SubRegIndices.insert(
2508         std::make_pair(StringRef(TRI->getSubRegIndexName(I)).lower(), I));
2509 }
2510
2511 unsigned MIParser::getSubRegIndex(StringRef Name) {
2512   initNames2SubRegIndices();
2513   auto SubRegInfo = Names2SubRegIndices.find(Name);
2514   if (SubRegInfo == Names2SubRegIndices.end())
2515     return 0;
2516   return SubRegInfo->getValue();
2517 }
2518
2519 static void initSlots2BasicBlocks(
2520     const Function &F,
2521     DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
2522   ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
2523   MST.incorporateFunction(F);
2524   for (auto &BB : F) {
2525     if (BB.hasName())
2526       continue;
2527     int Slot = MST.getLocalSlot(&BB);
2528     if (Slot == -1)
2529       continue;
2530     Slots2BasicBlocks.insert(std::make_pair(unsigned(Slot), &BB));
2531   }
2532 }
2533
2534 static const BasicBlock *getIRBlockFromSlot(
2535     unsigned Slot,
2536     const DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
2537   auto BlockInfo = Slots2BasicBlocks.find(Slot);
2538   if (BlockInfo == Slots2BasicBlocks.end())
2539     return nullptr;
2540   return BlockInfo->second;
2541 }
2542
2543 const BasicBlock *MIParser::getIRBlock(unsigned Slot) {
2544   if (Slots2BasicBlocks.empty())
2545     initSlots2BasicBlocks(MF.getFunction(), Slots2BasicBlocks);
2546   return getIRBlockFromSlot(Slot, Slots2BasicBlocks);
2547 }
2548
2549 const BasicBlock *MIParser::getIRBlock(unsigned Slot, const Function &F) {
2550   if (&F == &MF.getFunction())
2551     return getIRBlock(Slot);
2552   DenseMap<unsigned, const BasicBlock *> CustomSlots2BasicBlocks;
2553   initSlots2BasicBlocks(F, CustomSlots2BasicBlocks);
2554   return getIRBlockFromSlot(Slot, CustomSlots2BasicBlocks);
2555 }
2556
2557 static void mapValueToSlot(const Value *V, ModuleSlotTracker &MST,
2558                            DenseMap<unsigned, const Value *> &Slots2Values) {
2559   int Slot = MST.getLocalSlot(V);
2560   if (Slot == -1)
2561     return;
2562   Slots2Values.insert(std::make_pair(unsigned(Slot), V));
2563 }
2564
2565 /// Creates the mapping from slot numbers to function's unnamed IR values.
2566 static void initSlots2Values(const Function &F,
2567                              DenseMap<unsigned, const Value *> &Slots2Values) {
2568   ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
2569   MST.incorporateFunction(F);
2570   for (const auto &Arg : F.args())
2571     mapValueToSlot(&Arg, MST, Slots2Values);
2572   for (const auto &BB : F) {
2573     mapValueToSlot(&BB, MST, Slots2Values);
2574     for (const auto &I : BB)
2575       mapValueToSlot(&I, MST, Slots2Values);
2576   }
2577 }
2578
2579 const Value *MIParser::getIRValue(unsigned Slot) {
2580   if (Slots2Values.empty())
2581     initSlots2Values(MF.getFunction(), Slots2Values);
2582   auto ValueInfo = Slots2Values.find(Slot);
2583   if (ValueInfo == Slots2Values.end())
2584     return nullptr;
2585   return ValueInfo->second;
2586 }
2587
2588 void MIParser::initNames2TargetIndices() {
2589   if (!Names2TargetIndices.empty())
2590     return;
2591   const auto *TII = MF.getSubtarget().getInstrInfo();
2592   assert(TII && "Expected target instruction info");
2593   auto Indices = TII->getSerializableTargetIndices();
2594   for (const auto &I : Indices)
2595     Names2TargetIndices.insert(std::make_pair(StringRef(I.second), I.first));
2596 }
2597
2598 bool MIParser::getTargetIndex(StringRef Name, int &Index) {
2599   initNames2TargetIndices();
2600   auto IndexInfo = Names2TargetIndices.find(Name);
2601   if (IndexInfo == Names2TargetIndices.end())
2602     return true;
2603   Index = IndexInfo->second;
2604   return false;
2605 }
2606
2607 void MIParser::initNames2DirectTargetFlags() {
2608   if (!Names2DirectTargetFlags.empty())
2609     return;
2610   const auto *TII = MF.getSubtarget().getInstrInfo();
2611   assert(TII && "Expected target instruction info");
2612   auto Flags = TII->getSerializableDirectMachineOperandTargetFlags();
2613   for (const auto &I : Flags)
2614     Names2DirectTargetFlags.insert(
2615         std::make_pair(StringRef(I.second), I.first));
2616 }
2617
2618 bool MIParser::getDirectTargetFlag(StringRef Name, unsigned &Flag) {
2619   initNames2DirectTargetFlags();
2620   auto FlagInfo = Names2DirectTargetFlags.find(Name);
2621   if (FlagInfo == Names2DirectTargetFlags.end())
2622     return true;
2623   Flag = FlagInfo->second;
2624   return false;
2625 }
2626
2627 void MIParser::initNames2BitmaskTargetFlags() {
2628   if (!Names2BitmaskTargetFlags.empty())
2629     return;
2630   const auto *TII = MF.getSubtarget().getInstrInfo();
2631   assert(TII && "Expected target instruction info");
2632   auto Flags = TII->getSerializableBitmaskMachineOperandTargetFlags();
2633   for (const auto &I : Flags)
2634     Names2BitmaskTargetFlags.insert(
2635         std::make_pair(StringRef(I.second), I.first));
2636 }
2637
2638 bool MIParser::getBitmaskTargetFlag(StringRef Name, unsigned &Flag) {
2639   initNames2BitmaskTargetFlags();
2640   auto FlagInfo = Names2BitmaskTargetFlags.find(Name);
2641   if (FlagInfo == Names2BitmaskTargetFlags.end())
2642     return true;
2643   Flag = FlagInfo->second;
2644   return false;
2645 }
2646
2647 void MIParser::initNames2MMOTargetFlags() {
2648   if (!Names2MMOTargetFlags.empty())
2649     return;
2650   const auto *TII = MF.getSubtarget().getInstrInfo();
2651   assert(TII && "Expected target instruction info");
2652   auto Flags = TII->getSerializableMachineMemOperandTargetFlags();
2653   for (const auto &I : Flags)
2654     Names2MMOTargetFlags.insert(
2655         std::make_pair(StringRef(I.second), I.first));
2656 }
2657
2658 bool MIParser::getMMOTargetFlag(StringRef Name,
2659                                 MachineMemOperand::Flags &Flag) {
2660   initNames2MMOTargetFlags();
2661   auto FlagInfo = Names2MMOTargetFlags.find(Name);
2662   if (FlagInfo == Names2MMOTargetFlags.end())
2663     return true;
2664   Flag = FlagInfo->second;
2665   return false;
2666 }
2667
2668 bool MIParser::parseStringConstant(std::string &Result) {
2669   if (Token.isNot(MIToken::StringConstant))
2670     return error("expected string constant");
2671   Result = Token.stringValue();
2672   lex();
2673   return false;
2674 }
2675
2676 bool llvm::parseMachineBasicBlockDefinitions(PerFunctionMIParsingState &PFS,
2677                                              StringRef Src,
2678                                              SMDiagnostic &Error) {
2679   return MIParser(PFS, Error, Src).parseBasicBlockDefinitions(PFS.MBBSlots);
2680 }
2681
2682 bool llvm::parseMachineInstructions(PerFunctionMIParsingState &PFS,
2683                                     StringRef Src, SMDiagnostic &Error) {
2684   return MIParser(PFS, Error, Src).parseBasicBlocks();
2685 }
2686
2687 bool llvm::parseMBBReference(PerFunctionMIParsingState &PFS,
2688                              MachineBasicBlock *&MBB, StringRef Src,
2689                              SMDiagnostic &Error) {
2690   return MIParser(PFS, Error, Src).parseStandaloneMBB(MBB);
2691 }
2692
2693 bool llvm::parseRegisterReference(PerFunctionMIParsingState &PFS,
2694                                   unsigned &Reg, StringRef Src,
2695                                   SMDiagnostic &Error) {
2696   return MIParser(PFS, Error, Src).parseStandaloneRegister(Reg);
2697 }
2698
2699 bool llvm::parseNamedRegisterReference(PerFunctionMIParsingState &PFS,
2700                                        unsigned &Reg, StringRef Src,
2701                                        SMDiagnostic &Error) {
2702   return MIParser(PFS, Error, Src).parseStandaloneNamedRegister(Reg);
2703 }
2704
2705 bool llvm::parseVirtualRegisterReference(PerFunctionMIParsingState &PFS,
2706                                          VRegInfo *&Info, StringRef Src,
2707                                          SMDiagnostic &Error) {
2708   return MIParser(PFS, Error, Src).parseStandaloneVirtualRegister(Info);
2709 }
2710
2711 bool llvm::parseStackObjectReference(PerFunctionMIParsingState &PFS,
2712                                      int &FI, StringRef Src,
2713                                      SMDiagnostic &Error) {
2714   return MIParser(PFS, Error, Src).parseStandaloneStackObject(FI);
2715 }
2716
2717 bool llvm::parseMDNode(PerFunctionMIParsingState &PFS,
2718                        MDNode *&Node, StringRef Src, SMDiagnostic &Error) {
2719   return MIParser(PFS, Error, Src).parseStandaloneMDNode(Node);
2720 }