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/StringMap.h"
  17 #include "llvm/AsmParser/Parser.h"
  18 #include "llvm/AsmParser/SlotMapping.h"
  19 #include "llvm/CodeGen/MachineBasicBlock.h"
  20 #include "llvm/CodeGen/MachineFunction.h"
  21 #include "llvm/CodeGen/MachineFrameInfo.h"
  22 #include "llvm/CodeGen/MachineInstr.h"
  23 #include "llvm/CodeGen/MachineInstrBuilder.h"
  24 #include "llvm/CodeGen/MachineMemOperand.h"
  25 #include "llvm/CodeGen/MachineModuleInfo.h"
  26 #include "llvm/IR/Instructions.h"
  27 #include "llvm/IR/Constants.h"
  28 #include "llvm/IR/Module.h"
  29 #include "llvm/IR/ModuleSlotTracker.h"
  30 #include "llvm/IR/ValueSymbolTable.h"
  31 #include "llvm/Support/raw_ostream.h"
  32 #include "llvm/Support/SourceMgr.h"
  33 #include "llvm/Target/TargetSubtargetInfo.h"
  34 #include "llvm/Target/TargetInstrInfo.h"
  35
  36 using namespace llvm;
  37
  38 namespace {
  39
  40 /// A wrapper struct around the 'MachineOperand' struct that includes a source
  41 /// range.
  42 struct MachineOperandWithLocation {
  43   MachineOperand Operand;
  44   StringRef::iterator Begin;
  45   StringRef::iterator End;
  46
  47   MachineOperandWithLocation(const MachineOperand &Operand,
  48                              StringRef::iterator Begin, StringRef::iterator End)
  49       : Operand(Operand), Begin(Begin), End(End) {}
  50 };
  51
  52 class MIParser {
  53   SourceMgr &SM;
  54   MachineFunction &MF;
  55   SMDiagnostic &Error;
  56   StringRef Source, CurrentSource;
  57   MIToken Token;
  58   const PerFunctionMIParsingState &PFS;
  59   /// Maps from indices to unnamed global values and metadata nodes.
  60   const SlotMapping &IRSlots;
  61   /// Maps from instruction names to op codes.
  62   StringMap<unsigned> Names2InstrOpCodes;
  63   /// Maps from register names to registers.
  64   StringMap<unsigned> Names2Regs;
  65   /// Maps from register mask names to register masks.
  66   StringMap<const uint32_t *> Names2RegMasks;
  67   /// Maps from subregister names to subregister indices.
  68   StringMap<unsigned> Names2SubRegIndices;
  69   /// Maps from slot numbers to function's unnamed basic blocks.
  70   DenseMap<unsigned, const BasicBlock *> Slots2BasicBlocks;
  71   /// Maps from target index names to target indices.
  72   StringMap<int> Names2TargetIndices;
  73   /// Maps from direct target flag names to the direct target flag values.
  74   StringMap<unsigned> Names2DirectTargetFlags;
  75
  76 public:
  77   MIParser(SourceMgr &SM, MachineFunction &MF, SMDiagnostic &Error,
  78            StringRef Source, const PerFunctionMIParsingState &PFS,
  79            const SlotMapping &IRSlots);
  80
  81   void lex();
  82
  83   /// Report an error at the current location with the given message.
  84   ///
  85   /// This function always return true.
  86   bool error(const Twine &Msg);
  87
  88   /// Report an error at the given location with the given message.
  89   ///
  90   /// This function always return true.
  91   bool error(StringRef::iterator Loc, const Twine &Msg);
  92
  93   bool
  94   parseBasicBlockDefinitions(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
  95   bool parseBasicBlocks();
  96   bool parse(MachineInstr *&MI);
  97   bool parseStandaloneMBB(MachineBasicBlock *&MBB);
  98   bool parseStandaloneNamedRegister(unsigned &Reg);
  99   bool parseStandaloneVirtualRegister(unsigned &Reg);
 100
 101   bool
 102   parseBasicBlockDefinition(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
 103   bool parseBasicBlock(MachineBasicBlock &MBB);
 104   bool parseBasicBlockLiveins(MachineBasicBlock &MBB);
 105   bool parseBasicBlockSuccessors(MachineBasicBlock &MBB);
 106
 107   bool parseRegister(unsigned &Reg);
 108   bool parseRegisterFlag(unsigned &Flags);
 109   bool parseSubRegisterIndex(unsigned &SubReg);
 110   bool parseRegisterOperand(MachineOperand &Dest, bool IsDef = false);
 111   bool parseImmediateOperand(MachineOperand &Dest);
 112   bool parseIRConstant(StringRef::iterator Loc, const Constant *&C);
 113   bool parseTypedImmediateOperand(MachineOperand &Dest);
 114   bool parseFPImmediateOperand(MachineOperand &Dest);
 115   bool parseMBBReference(MachineBasicBlock *&MBB);
 116   bool parseMBBOperand(MachineOperand &Dest);
 117   bool parseStackFrameIndex(int &FI);
 118   bool parseStackObjectOperand(MachineOperand &Dest);
 119   bool parseFixedStackFrameIndex(int &FI);
 120   bool parseFixedStackObjectOperand(MachineOperand &Dest);
 121   bool parseGlobalValue(GlobalValue *&GV);
 122   bool parseGlobalAddressOperand(MachineOperand &Dest);
 123   bool parseConstantPoolIndexOperand(MachineOperand &Dest);
 124   bool parseJumpTableIndexOperand(MachineOperand &Dest);
 125   bool parseExternalSymbolOperand(MachineOperand &Dest);
 126   bool parseMDNode(MDNode *&Node);
 127   bool parseMetadataOperand(MachineOperand &Dest);
 128   bool parseCFIOffset(int &Offset);
 129   bool parseCFIRegister(unsigned &Reg);
 130   bool parseCFIOperand(MachineOperand &Dest);
 131   bool parseIRBlock(BasicBlock *&BB, const Function &F);
 132   bool parseBlockAddressOperand(MachineOperand &Dest);
 133   bool parseTargetIndexOperand(MachineOperand &Dest);
 134   bool parseLiveoutRegisterMaskOperand(MachineOperand &Dest);
 135   bool parseMachineOperand(MachineOperand &Dest);
 136   bool parseMachineOperandAndTargetFlags(MachineOperand &Dest);
 137   bool parseOffset(int64_t &Offset);
 138   bool parseAlignment(unsigned &Alignment);
 139   bool parseOperandsOffset(MachineOperand &Op);
 140   bool parseIRValue(Value *&V);
 141   bool parseMemoryOperandFlag(unsigned &Flags);
 142   bool parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV);
 143   bool parseMachinePointerInfo(MachinePointerInfo &Dest);
 144   bool parseMachineMemoryOperand(MachineMemOperand *&Dest);
 145
 146 private:
 147   /// Convert the integer literal in the current token into an unsigned integer.
 148   ///
 149   /// Return true if an error occurred.
 150   bool getUnsigned(unsigned &Result);
 151
 152   /// Convert the integer literal in the current token into an uint64.
 153   ///
 154   /// Return true if an error occurred.
 155   bool getUint64(uint64_t &Result);
 156
 157   /// If the current token is of the given kind, consume it and return false.
 158   /// Otherwise report an error and return true.
 159   bool expectAndConsume(MIToken::TokenKind TokenKind);
 160
 161   /// If the current token is of the given kind, consume it and return true.
 162   /// Otherwise return false.
 163   bool consumeIfPresent(MIToken::TokenKind TokenKind);
 164
 165   void initNames2InstrOpCodes();
 166
 167   /// Try to convert an instruction name to an opcode. Return true if the
 168   /// instruction name is invalid.
 169   bool parseInstrName(StringRef InstrName, unsigned &OpCode);
 170
 171   bool parseInstruction(unsigned &OpCode, unsigned &Flags);
 172
 173   bool verifyImplicitOperands(ArrayRef<MachineOperandWithLocation> Operands,
 174                               const MCInstrDesc &MCID);
 175
 176   void initNames2Regs();
 177
 178   /// Try to convert a register name to a register number. Return true if the
 179   /// register name is invalid.
 180   bool getRegisterByName(StringRef RegName, unsigned &Reg);
 181
 182   void initNames2RegMasks();
 183
 184   /// Check if the given identifier is a name of a register mask.
 185   ///
 186   /// Return null if the identifier isn't a register mask.
 187   const uint32_t *getRegMask(StringRef Identifier);
 188
 189   void initNames2SubRegIndices();
 190
 191   /// Check if the given identifier is a name of a subregister index.
 192   ///
 193   /// Return 0 if the name isn't a subregister index class.
 194   unsigned getSubRegIndex(StringRef Name);
 195
 196   const BasicBlock *getIRBlock(unsigned Slot);
 197   const BasicBlock *getIRBlock(unsigned Slot, const Function &F);
 198
 199   void initNames2TargetIndices();
 200
 201   /// Try to convert a name of target index to the corresponding target index.
 202   ///
 203   /// Return true if the name isn't a name of a target index.
 204   bool getTargetIndex(StringRef Name, int &Index);
 205
 206   void initNames2DirectTargetFlags();
 207
 208   /// Try to convert a name of a direct target flag to the corresponding
 209   /// target flag.
 210   ///
 211   /// Return true if the name isn't a name of a direct flag.
 212   bool getDirectTargetFlag(StringRef Name, unsigned &Flag);
 213 };
 214
 215 } // end anonymous namespace
 216
 217 MIParser::MIParser(SourceMgr &SM, MachineFunction &MF, SMDiagnostic &Error,
 218                    StringRef Source, const PerFunctionMIParsingState &PFS,
 219                    const SlotMapping &IRSlots)
 220     : SM(SM), MF(MF), Error(Error), Source(Source), CurrentSource(Source),
 221       PFS(PFS), IRSlots(IRSlots) {}
 222
 223 void MIParser::lex() {
 224   CurrentSource = lexMIToken(
 225       CurrentSource, Token,
 226       [this](StringRef::iterator Loc, const Twine &Msg) { error(Loc, Msg); });
 227 }
 228
 229 bool MIParser::error(const Twine &Msg) { return error(Token.location(), Msg); }
 230
 231 bool MIParser::error(StringRef::iterator Loc, const Twine &Msg) {
 232   assert(Loc >= Source.data() && Loc <= (Source.data() + Source.size()));
 233   const MemoryBuffer &Buffer = *SM.getMemoryBuffer(SM.getMainFileID());
 234   if (Loc >= Buffer.getBufferStart() && Loc <= Buffer.getBufferEnd()) {
 235     // Create an ordinary diagnostic when the source manager's buffer is the
 236     // source string.
 237     Error = SM.GetMessage(SMLoc::getFromPointer(Loc), SourceMgr::DK_Error, Msg);
 238     return true;
 239   }
 240   // Create a diagnostic for a YAML string literal.
 241   Error = SMDiagnostic(SM, SMLoc(), Buffer.getBufferIdentifier(), 1,
 242                        Loc - Source.data(), SourceMgr::DK_Error, Msg.str(),
 243                        Source, None, None);
 244   return true;
 245 }
 246
 247 static const char *toString(MIToken::TokenKind TokenKind) {
 248   switch (TokenKind) {
 249   case MIToken::comma:
 250     return "','";
 251   case MIToken::equal:
 252     return "'='";
 253   case MIToken::colon:
 254     return "':'";
 255   case MIToken::lparen:
 256     return "'('";
 257   case MIToken::rparen:
 258     return "')'";
 259   default:
 260     return "<unknown token>";
 261   }
 262 }
 263
 264 bool MIParser::expectAndConsume(MIToken::TokenKind TokenKind) {
 265   if (Token.isNot(TokenKind))
 266     return error(Twine("expected ") + toString(TokenKind));
 267   lex();
 268   return false;
 269 }
 270
 271 bool MIParser::consumeIfPresent(MIToken::TokenKind TokenKind) {
 272   if (Token.isNot(TokenKind))
 273     return false;
 274   lex();
 275   return true;
 276 }
 277
 278 bool MIParser::parseBasicBlockDefinition(
 279     DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
 280   assert(Token.is(MIToken::MachineBasicBlockLabel));
 281   unsigned ID = 0;
 282   if (getUnsigned(ID))
 283     return true;
 284   auto Loc = Token.location();
 285   auto Name = Token.stringValue();
 286   lex();
 287   bool HasAddressTaken = false;
 288   bool IsLandingPad = false;
 289   unsigned Alignment = 0;
 290   BasicBlock *BB = nullptr;
 291   if (consumeIfPresent(MIToken::lparen)) {
 292     do {
 293       // TODO: Report an error when multiple same attributes are specified.
 294       switch (Token.kind()) {
 295       case MIToken::kw_address_taken:
 296         HasAddressTaken = true;
 297         lex();
 298         break;
 299       case MIToken::kw_landing_pad:
 300         IsLandingPad = true;
 301         lex();
 302         break;
 303       case MIToken::kw_align:
 304         if (parseAlignment(Alignment))
 305           return true;
 306         break;
 307       case MIToken::IRBlock:
 308         // TODO: Report an error when both name and ir block are specified.
 309         if (parseIRBlock(BB, *MF.getFunction()))
 310           return true;
 311         lex();
 312         break;
 313       default:
 314         break;
 315       }
 316     } while (consumeIfPresent(MIToken::comma));
 317     if (expectAndConsume(MIToken::rparen))
 318       return true;
 319   }
 320   if (expectAndConsume(MIToken::colon))
 321     return true;
 322
 323   if (!Name.empty()) {
 324     BB = dyn_cast_or_null<BasicBlock>(
 325         MF.getFunction()->getValueSymbolTable().lookup(Name));
 326     if (!BB)
 327       return error(Loc, Twine("basic block '") + Name +
 328                             "' is not defined in the function '" +
 329                             MF.getName() + "'");
 330   }
 331   auto *MBB = MF.CreateMachineBasicBlock(BB);
 332   MF.insert(MF.end(), MBB);
 333   bool WasInserted = MBBSlots.insert(std::make_pair(ID, MBB)).second;
 334   if (!WasInserted)
 335     return error(Loc, Twine("redefinition of machine basic block with id #") +
 336                           Twine(ID));
 337   if (Alignment)
 338     MBB->setAlignment(Alignment);
 339   if (HasAddressTaken)
 340     MBB->setHasAddressTaken();
 341   MBB->setIsLandingPad(IsLandingPad);
 342   return false;
 343 }
 344
 345 bool MIParser::parseBasicBlockDefinitions(
 346     DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
 347   lex();
 348   // Skip until the first machine basic block.
 349   while (Token.is(MIToken::Newline))
 350     lex();
 351   if (Token.isErrorOrEOF())
 352     return Token.isError();
 353   if (Token.isNot(MIToken::MachineBasicBlockLabel))
 354     return error("expected a basic block definition before instructions");
 355   unsigned BraceDepth = 0;
 356   do {
 357     if (parseBasicBlockDefinition(MBBSlots))
 358       return true;
 359     bool IsAfterNewline = false;
 360     // Skip until the next machine basic block.
 361     while (true) {
 362       if ((Token.is(MIToken::MachineBasicBlockLabel) && IsAfterNewline) ||
 363           Token.isErrorOrEOF())
 364         break;
 365       else if (Token.is(MIToken::MachineBasicBlockLabel))
 366         return error("basic block definition should be located at the start of "
 367                      "the line");
 368       else if (consumeIfPresent(MIToken::Newline)) {
 369         IsAfterNewline = true;
 370         continue;
 371       }
 372       IsAfterNewline = false;
 373       if (Token.is(MIToken::lbrace))
 374         ++BraceDepth;
 375       if (Token.is(MIToken::rbrace)) {
 376         if (!BraceDepth)
 377           return error("extraneous closing brace ('}')");
 378         --BraceDepth;
 379       }
 380       lex();
 381     }
 382     // Verify that we closed all of the '{' at the end of a file or a block.
 383     if (!Token.isError() && BraceDepth)
 384       return error("expected '}'"); // FIXME: Report a note that shows '{'.
 385   } while (!Token.isErrorOrEOF());
 386   return Token.isError();
 387 }
 388
 389 bool MIParser::parseBasicBlockLiveins(MachineBasicBlock &MBB) {
 390   assert(Token.is(MIToken::kw_liveins));
 391   lex();
 392   if (expectAndConsume(MIToken::colon))
 393     return true;
 394   if (Token.isNewlineOrEOF()) // Allow an empty list of liveins.
 395     return false;
 396   do {
 397     if (Token.isNot(MIToken::NamedRegister))
 398       return error("expected a named register");
 399     unsigned Reg = 0;
 400     if (parseRegister(Reg))
 401       return true;
 402     MBB.addLiveIn(Reg);
 403     lex();
 404   } while (consumeIfPresent(MIToken::comma));
 405   return false;
 406 }
 407
 408 bool MIParser::parseBasicBlockSuccessors(MachineBasicBlock &MBB) {
 409   assert(Token.is(MIToken::kw_successors));
 410   lex();
 411   if (expectAndConsume(MIToken::colon))
 412     return true;
 413   if (Token.isNewlineOrEOF()) // Allow an empty list of successors.
 414     return false;
 415   do {
 416     if (Token.isNot(MIToken::MachineBasicBlock))
 417       return error("expected a machine basic block reference");
 418     MachineBasicBlock *SuccMBB = nullptr;
 419     if (parseMBBReference(SuccMBB))
 420       return true;
 421     lex();
 422     unsigned Weight = 0;
 423     if (consumeIfPresent(MIToken::lparen)) {
 424       if (Token.isNot(MIToken::IntegerLiteral))
 425         return error("expected an integer literal after '('");
 426       if (getUnsigned(Weight))
 427         return true;
 428       lex();
 429       if (expectAndConsume(MIToken::rparen))
 430         return true;
 431     }
 432     MBB.addSuccessor(SuccMBB, Weight);
 433   } while (consumeIfPresent(MIToken::comma));
 434   return false;
 435 }
 436
 437 bool MIParser::parseBasicBlock(MachineBasicBlock &MBB) {
 438   // Skip the definition.
 439   assert(Token.is(MIToken::MachineBasicBlockLabel));
 440   lex();
 441   if (consumeIfPresent(MIToken::lparen)) {
 442     while (Token.isNot(MIToken::rparen) && !Token.isErrorOrEOF())
 443       lex();
 444     consumeIfPresent(MIToken::rparen);
 445   }
 446   consumeIfPresent(MIToken::colon);
 447
 448   // Parse the liveins and successors.
 449   // N.B: Multiple lists of successors and liveins are allowed and they're
 450   // merged into one.
 451   // Example:
 452   //   liveins: %edi
 453   //   liveins: %esi
 454   //
 455   // is equivalent to
 456   //   liveins: %edi, %esi
 457   while (true) {
 458     if (Token.is(MIToken::kw_successors)) {
 459       if (parseBasicBlockSuccessors(MBB))
 460         return true;
 461     } else if (Token.is(MIToken::kw_liveins)) {
 462       if (parseBasicBlockLiveins(MBB))
 463         return true;
 464     } else if (consumeIfPresent(MIToken::Newline)) {
 465       continue;
 466     } else
 467       break;
 468     if (!Token.isNewlineOrEOF())
 469       return error("expected line break at the end of a list");
 470     lex();
 471   }
 472
 473   // Parse the instructions.
 474   bool IsInBundle = false;
 475   MachineInstr *PrevMI = nullptr;
 476   while (true) {
 477     if (Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof))
 478       return false;
 479     else if (consumeIfPresent(MIToken::Newline))
 480       continue;
 481     if (consumeIfPresent(MIToken::rbrace)) {
 482       // The first parsing pass should verify that all closing '}' have an
 483       // opening '{'.
 484       assert(IsInBundle);
 485       IsInBundle = false;
 486       continue;
 487     }
 488     MachineInstr *MI = nullptr;
 489     if (parse(MI))
 490       return true;
 491     MBB.insert(MBB.end(), MI);
 492     if (IsInBundle) {
 493       PrevMI->setFlag(MachineInstr::BundledSucc);
 494       MI->setFlag(MachineInstr::BundledPred);
 495     }
 496     PrevMI = MI;
 497     if (Token.is(MIToken::lbrace)) {
 498       if (IsInBundle)
 499         return error("nested instruction bundles are not allowed");
 500       lex();
 501       // This instruction is the start of the bundle.
 502       MI->setFlag(MachineInstr::BundledSucc);
 503       IsInBundle = true;
 504       if (!Token.is(MIToken::Newline))
 505         // The next instruction can be on the same line.
 506         continue;
 507     }
 508     assert(Token.isNewlineOrEOF() && "MI is not fully parsed");
 509     lex();
 510   }
 511   return false;
 512 }
 513
 514 bool MIParser::parseBasicBlocks() {
 515   lex();
 516   // Skip until the first machine basic block.
 517   while (Token.is(MIToken::Newline))
 518     lex();
 519   if (Token.isErrorOrEOF())
 520     return Token.isError();
 521   // The first parsing pass should have verified that this token is a MBB label
 522   // in the 'parseBasicBlockDefinitions' method.
 523   assert(Token.is(MIToken::MachineBasicBlockLabel));
 524   do {
 525     MachineBasicBlock *MBB = nullptr;
 526     if (parseMBBReference(MBB))
 527       return true;
 528     if (parseBasicBlock(*MBB))
 529       return true;
 530     // The method 'parseBasicBlock' should parse the whole block until the next
 531     // block or the end of file.
 532     assert(Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof));
 533   } while (Token.isNot(MIToken::Eof));
 534   return false;
 535 }
 536
 537 bool MIParser::parse(MachineInstr *&MI) {
 538   // Parse any register operands before '='
 539   MachineOperand MO = MachineOperand::CreateImm(0);
 540   SmallVector<MachineOperandWithLocation, 8> Operands;
 541   while (Token.isRegister() || Token.isRegisterFlag()) {
 542     auto Loc = Token.location();
 543     if (parseRegisterOperand(MO, /*IsDef=*/true))
 544       return true;
 545     Operands.push_back(MachineOperandWithLocation(MO, Loc, Token.location()));
 546     if (Token.isNot(MIToken::comma))
 547       break;
 548     lex();
 549   }
 550   if (!Operands.empty() && expectAndConsume(MIToken::equal))
 551     return true;
 552
 553   unsigned OpCode, Flags = 0;
 554   if (Token.isError() || parseInstruction(OpCode, Flags))
 555     return true;
 556
 557   // Parse the remaining machine operands.
 558   while (!Token.isNewlineOrEOF() && Token.isNot(MIToken::kw_debug_location) &&
 559          Token.isNot(MIToken::coloncolon) && Token.isNot(MIToken::lbrace)) {
 560     auto Loc = Token.location();
 561     if (parseMachineOperandAndTargetFlags(MO))
 562       return true;
 563     Operands.push_back(MachineOperandWithLocation(MO, Loc, Token.location()));
 564     if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
 565         Token.is(MIToken::lbrace))
 566       break;
 567     if (Token.isNot(MIToken::comma))
 568       return error("expected ',' before the next machine operand");
 569     lex();
 570   }
 571
 572   DebugLoc DebugLocation;
 573   if (Token.is(MIToken::kw_debug_location)) {
 574     lex();
 575     if (Token.isNot(MIToken::exclaim))
 576       return error("expected a metadata node after 'debug-location'");
 577     MDNode *Node = nullptr;
 578     if (parseMDNode(Node))
 579       return true;
 580     DebugLocation = DebugLoc(Node);
 581   }
 582
 583   // Parse the machine memory operands.
 584   SmallVector<MachineMemOperand *, 2> MemOperands;
 585   if (Token.is(MIToken::coloncolon)) {
 586     lex();
 587     while (!Token.isNewlineOrEOF()) {
 588       MachineMemOperand *MemOp = nullptr;
 589       if (parseMachineMemoryOperand(MemOp))
 590         return true;
 591       MemOperands.push_back(MemOp);
 592       if (Token.isNewlineOrEOF())
 593         break;
 594       if (Token.isNot(MIToken::comma))
 595         return error("expected ',' before the next machine memory operand");
 596       lex();
 597     }
 598   }
 599
 600   const auto &MCID = MF.getSubtarget().getInstrInfo()->get(OpCode);
 601   if (!MCID.isVariadic()) {
 602     // FIXME: Move the implicit operand verification to the machine verifier.
 603     if (verifyImplicitOperands(Operands, MCID))
 604       return true;
 605   }
 606
 607   // TODO: Check for extraneous machine operands.
 608   MI = MF.CreateMachineInstr(MCID, DebugLocation, /*NoImplicit=*/true);
 609   MI->setFlags(Flags);
 610   for (const auto &Operand : Operands)
 611     MI->addOperand(MF, Operand.Operand);
 612   if (MemOperands.empty())
 613     return false;
 614   MachineInstr::mmo_iterator MemRefs =
 615       MF.allocateMemRefsArray(MemOperands.size());
 616   std::copy(MemOperands.begin(), MemOperands.end(), MemRefs);
 617   MI->setMemRefs(MemRefs, MemRefs + MemOperands.size());
 618   return false;
 619 }
 620
 621 bool MIParser::parseStandaloneMBB(MachineBasicBlock *&MBB) {
 622   lex();
 623   if (Token.isNot(MIToken::MachineBasicBlock))
 624     return error("expected a machine basic block reference");
 625   if (parseMBBReference(MBB))
 626     return true;
 627   lex();
 628   if (Token.isNot(MIToken::Eof))
 629     return error(
 630         "expected end of string after the machine basic block reference");
 631   return false;
 632 }
 633
 634 bool MIParser::parseStandaloneNamedRegister(unsigned &Reg) {
 635   lex();
 636   if (Token.isNot(MIToken::NamedRegister))
 637     return error("expected a named register");
 638   if (parseRegister(Reg))
 639     return 0;
 640   lex();
 641   if (Token.isNot(MIToken::Eof))
 642     return error("expected end of string after the register reference");
 643   return false;
 644 }
 645
 646 bool MIParser::parseStandaloneVirtualRegister(unsigned &Reg) {
 647   lex();
 648   if (Token.isNot(MIToken::VirtualRegister))
 649     return error("expected a virtual register");
 650   if (parseRegister(Reg))
 651     return 0;
 652   lex();
 653   if (Token.isNot(MIToken::Eof))
 654     return error("expected end of string after the register reference");
 655   return false;
 656 }
 657
 658 static const char *printImplicitRegisterFlag(const MachineOperand &MO) {
 659   assert(MO.isImplicit());
 660   return MO.isDef() ? "implicit-def" : "implicit";
 661 }
 662
 663 static std::string getRegisterName(const TargetRegisterInfo *TRI,
 664                                    unsigned Reg) {
 665   assert(TargetRegisterInfo::isPhysicalRegister(Reg) && "expected phys reg");
 666   return StringRef(TRI->getName(Reg)).lower();
 667 }
 668
 669 bool MIParser::verifyImplicitOperands(
 670     ArrayRef<MachineOperandWithLocation> Operands, const MCInstrDesc &MCID) {
 671   if (MCID.isCall())
 672     // We can't verify call instructions as they can contain arbitrary implicit
 673     // register and register mask operands.
 674     return false;
 675
 676   // Gather all the expected implicit operands.
 677   SmallVector<MachineOperand, 4> ImplicitOperands;
 678   if (MCID.ImplicitDefs)
 679     for (const uint16_t *ImpDefs = MCID.getImplicitDefs(); *ImpDefs; ++ImpDefs)
 680       ImplicitOperands.push_back(
 681           MachineOperand::CreateReg(*ImpDefs, true, true));
 682   if (MCID.ImplicitUses)
 683     for (const uint16_t *ImpUses = MCID.getImplicitUses(); *ImpUses; ++ImpUses)
 684       ImplicitOperands.push_back(
 685           MachineOperand::CreateReg(*ImpUses, false, true));
 686
 687   const auto *TRI = MF.getSubtarget().getRegisterInfo();
 688   assert(TRI && "Expected target register info");
 689   size_t I = ImplicitOperands.size(), J = Operands.size();
 690   while (I) {
 691     --I;
 692     if (J) {
 693       --J;
 694       const auto &ImplicitOperand = ImplicitOperands[I];
 695       const auto &Operand = Operands[J].Operand;
 696       if (ImplicitOperand.isIdenticalTo(Operand))
 697         continue;
 698       if (Operand.isReg() && Operand.isImplicit()) {
 699         // Check if this implicit register is a subregister of an explicit
 700         // register operand.
 701         bool IsImplicitSubRegister = false;
 702         for (size_t K = 0, E = Operands.size(); K < E; ++K) {
 703           const auto &Op = Operands[K].Operand;
 704           if (Op.isReg() && !Op.isImplicit() &&
 705               TRI->isSubRegister(Op.getReg(), Operand.getReg())) {
 706             IsImplicitSubRegister = true;
 707             break;
 708           }
 709         }
 710         if (IsImplicitSubRegister)
 711           continue;
 712         return error(Operands[J].Begin,
 713                      Twine("expected an implicit register operand '") +
 714                          printImplicitRegisterFlag(ImplicitOperand) + " %" +
 715                          getRegisterName(TRI, ImplicitOperand.getReg()) + "'");
 716       }
 717     }
 718     // TODO: Fix source location when Operands[J].end is right before '=', i.e:
 719     // insead of reporting an error at this location:
 720     //            %eax = MOV32r0
 721     //                 ^
 722     // report the error at the following location:
 723     //            %eax = MOV32r0
 724     //                          ^
 725     return error(J < Operands.size() ? Operands[J].End : Token.location(),
 726                  Twine("missing implicit register operand '") +
 727                      printImplicitRegisterFlag(ImplicitOperands[I]) + " %" +
 728                      getRegisterName(TRI, ImplicitOperands[I].getReg()) + "'");
 729   }
 730   return false;
 731 }
 732
 733 bool MIParser::parseInstruction(unsigned &OpCode, unsigned &Flags) {
 734   if (Token.is(MIToken::kw_frame_setup)) {
 735     Flags |= MachineInstr::FrameSetup;
 736     lex();
 737   }
 738   if (Token.isNot(MIToken::Identifier))
 739     return error("expected a machine instruction");
 740   StringRef InstrName = Token.stringValue();
 741   if (parseInstrName(InstrName, OpCode))
 742     return error(Twine("unknown machine instruction name '") + InstrName + "'");
 743   lex();
 744   return false;
 745 }
 746
 747 bool MIParser::parseRegister(unsigned &Reg) {
 748   switch (Token.kind()) {
 749   case MIToken::underscore:
 750     Reg = 0;
 751     break;
 752   case MIToken::NamedRegister: {
 753     StringRef Name = Token.stringValue();
 754     if (getRegisterByName(Name, Reg))
 755       return error(Twine("unknown register name '") + Name + "'");
 756     break;
 757   }
 758   case MIToken::VirtualRegister: {
 759     unsigned ID;
 760     if (getUnsigned(ID))
 761       return true;
 762     const auto RegInfo = PFS.VirtualRegisterSlots.find(ID);
 763     if (RegInfo == PFS.VirtualRegisterSlots.end())
 764       return error(Twine("use of undefined virtual register '%") + Twine(ID) +
 765                    "'");
 766     Reg = RegInfo->second;
 767     break;
 768   }
 769   // TODO: Parse other register kinds.
 770   default:
 771     llvm_unreachable("The current token should be a register");
 772   }
 773   return false;
 774 }
 775
 776 bool MIParser::parseRegisterFlag(unsigned &Flags) {
 777   const unsigned OldFlags = Flags;
 778   switch (Token.kind()) {
 779   case MIToken::kw_implicit:
 780     Flags |= RegState::Implicit;
 781     break;
 782   case MIToken::kw_implicit_define:
 783     Flags |= RegState::ImplicitDefine;
 784     break;
 785   case MIToken::kw_dead:
 786     Flags |= RegState::Dead;
 787     break;
 788   case MIToken::kw_killed:
 789     Flags |= RegState::Kill;
 790     break;
 791   case MIToken::kw_undef:
 792     Flags |= RegState::Undef;
 793     break;
 794   case MIToken::kw_internal:
 795     Flags |= RegState::InternalRead;
 796     break;
 797   case MIToken::kw_early_clobber:
 798     Flags |= RegState::EarlyClobber;
 799     break;
 800   case MIToken::kw_debug_use:
 801     Flags |= RegState::Debug;
 802     break;
 803   default:
 804     llvm_unreachable("The current token should be a register flag");
 805   }
 806   if (OldFlags == Flags)
 807     // We know that the same flag is specified more than once when the flags
 808     // weren't modified.
 809     return error("duplicate '" + Token.stringValue() + "' register flag");
 810   lex();
 811   return false;
 812 }
 813
 814 bool MIParser::parseSubRegisterIndex(unsigned &SubReg) {
 815   assert(Token.is(MIToken::colon));
 816   lex();
 817   if (Token.isNot(MIToken::Identifier))
 818     return error("expected a subregister index after ':'");
 819   auto Name = Token.stringValue();
 820   SubReg = getSubRegIndex(Name);
 821   if (!SubReg)
 822     return error(Twine("use of unknown subregister index '") + Name + "'");
 823   lex();
 824   return false;
 825 }
 826
 827 bool MIParser::parseRegisterOperand(MachineOperand &Dest, bool IsDef) {
 828   unsigned Reg;
 829   unsigned Flags = IsDef ? RegState::Define : 0;
 830   while (Token.isRegisterFlag()) {
 831     if (parseRegisterFlag(Flags))
 832       return true;
 833   }
 834   if (!Token.isRegister())
 835     return error("expected a register after register flags");
 836   if (parseRegister(Reg))
 837     return true;
 838   lex();
 839   unsigned SubReg = 0;
 840   if (Token.is(MIToken::colon)) {
 841     if (parseSubRegisterIndex(SubReg))
 842       return true;
 843   }
 844   Dest = MachineOperand::CreateReg(
 845       Reg, Flags & RegState::Define, Flags & RegState::Implicit,
 846       Flags & RegState::Kill, Flags & RegState::Dead, Flags & RegState::Undef,
 847       Flags & RegState::EarlyClobber, SubReg, Flags & RegState::Debug,
 848       Flags & RegState::InternalRead);
 849   return false;
 850 }
 851
 852 bool MIParser::parseImmediateOperand(MachineOperand &Dest) {
 853   assert(Token.is(MIToken::IntegerLiteral));
 854   const APSInt &Int = Token.integerValue();
 855   if (Int.getMinSignedBits() > 64)
 856     return error("integer literal is too large to be an immediate operand");
 857   Dest = MachineOperand::CreateImm(Int.getExtValue());
 858   lex();
 859   return false;
 860 }
 861
 862 bool MIParser::parseIRConstant(StringRef::iterator Loc, const Constant *&C) {
 863   auto Source = StringRef(Loc, Token.range().end() - Loc).str();
 864   lex();
 865   SMDiagnostic Err;
 866   C = parseConstantValue(Source.c_str(), Err, *MF.getFunction()->getParent());
 867   if (!C)
 868     return error(Loc + Err.getColumnNo(), Err.getMessage());
 869   return false;
 870 }
 871
 872 bool MIParser::parseTypedImmediateOperand(MachineOperand &Dest) {
 873   assert(Token.is(MIToken::IntegerType));
 874   auto Loc = Token.location();
 875   lex();
 876   if (Token.isNot(MIToken::IntegerLiteral))
 877     return error("expected an integer literal");
 878   const Constant *C = nullptr;
 879   if (parseIRConstant(Loc, C))
 880     return true;
 881   Dest = MachineOperand::CreateCImm(cast<ConstantInt>(C));
 882   return false;
 883 }
 884
 885 bool MIParser::parseFPImmediateOperand(MachineOperand &Dest) {
 886   auto Loc = Token.location();
 887   lex();
 888   if (Token.isNot(MIToken::FloatingPointLiteral))
 889     return error("expected a floating point literal");
 890   const Constant *C = nullptr;
 891   if (parseIRConstant(Loc, C))
 892     return true;
 893   Dest = MachineOperand::CreateFPImm(cast<ConstantFP>(C));
 894   return false;
 895 }
 896
 897 bool MIParser::getUnsigned(unsigned &Result) {
 898   assert(Token.hasIntegerValue() && "Expected a token with an integer value");
 899   const uint64_t Limit = uint64_t(std::numeric_limits<unsigned>::max()) + 1;
 900   uint64_t Val64 = Token.integerValue().getLimitedValue(Limit);
 901   if (Val64 == Limit)
 902     return error("expected 32-bit integer (too large)");
 903   Result = Val64;
 904   return false;
 905 }
 906
 907 bool MIParser::parseMBBReference(MachineBasicBlock *&MBB) {
 908   assert(Token.is(MIToken::MachineBasicBlock) ||
 909          Token.is(MIToken::MachineBasicBlockLabel));
 910   unsigned Number;
 911   if (getUnsigned(Number))
 912     return true;
 913   auto MBBInfo = PFS.MBBSlots.find(Number);
 914   if (MBBInfo == PFS.MBBSlots.end())
 915     return error(Twine("use of undefined machine basic block #") +
 916                  Twine(Number));
 917   MBB = MBBInfo->second;
 918   if (!Token.stringValue().empty() && Token.stringValue() != MBB->getName())
 919     return error(Twine("the name of machine basic block #") + Twine(Number) +
 920                  " isn't '" + Token.stringValue() + "'");
 921   return false;
 922 }
 923
 924 bool MIParser::parseMBBOperand(MachineOperand &Dest) {
 925   MachineBasicBlock *MBB;
 926   if (parseMBBReference(MBB))
 927     return true;
 928   Dest = MachineOperand::CreateMBB(MBB);
 929   lex();
 930   return false;
 931 }
 932
 933 bool MIParser::parseStackFrameIndex(int &FI) {
 934   assert(Token.is(MIToken::StackObject));
 935   unsigned ID;
 936   if (getUnsigned(ID))
 937     return true;
 938   auto ObjectInfo = PFS.StackObjectSlots.find(ID);
 939   if (ObjectInfo == PFS.StackObjectSlots.end())
 940     return error(Twine("use of undefined stack object '%stack.") + Twine(ID) +
 941                  "'");
 942   StringRef Name;
 943   if (const auto *Alloca =
 944           MF.getFrameInfo()->getObjectAllocation(ObjectInfo->second))
 945     Name = Alloca->getName();
 946   if (!Token.stringValue().empty() && Token.stringValue() != Name)
 947     return error(Twine("the name of the stack object '%stack.") + Twine(ID) +
 948                  "' isn't '" + Token.stringValue() + "'");
 949   lex();
 950   FI = ObjectInfo->second;
 951   return false;
 952 }
 953
 954 bool MIParser::parseStackObjectOperand(MachineOperand &Dest) {
 955   int FI;
 956   if (parseStackFrameIndex(FI))
 957     return true;
 958   Dest = MachineOperand::CreateFI(FI);
 959   return false;
 960 }
 961
 962 bool MIParser::parseFixedStackFrameIndex(int &FI) {
 963   assert(Token.is(MIToken::FixedStackObject));
 964   unsigned ID;
 965   if (getUnsigned(ID))
 966     return true;
 967   auto ObjectInfo = PFS.FixedStackObjectSlots.find(ID);
 968   if (ObjectInfo == PFS.FixedStackObjectSlots.end())
 969     return error(Twine("use of undefined fixed stack object '%fixed-stack.") +
 970                  Twine(ID) + "'");
 971   lex();
 972   FI = ObjectInfo->second;
 973   return false;
 974 }
 975
 976 bool MIParser::parseFixedStackObjectOperand(MachineOperand &Dest) {
 977   int FI;
 978   if (parseFixedStackFrameIndex(FI))
 979     return true;
 980   Dest = MachineOperand::CreateFI(FI);
 981   return false;
 982 }
 983
 984 bool MIParser::parseGlobalValue(GlobalValue *&GV) {
 985   switch (Token.kind()) {
 986   case MIToken::NamedGlobalValue: {
 987     const Module *M = MF.getFunction()->getParent();
 988     GV = M->getNamedValue(Token.stringValue());
 989     if (!GV)
 990       return error(Twine("use of undefined global value '") + Token.range() +
 991                    "'");
 992     break;
 993   }
 994   case MIToken::GlobalValue: {
 995     unsigned GVIdx;
 996     if (getUnsigned(GVIdx))
 997       return true;
 998     if (GVIdx >= IRSlots.GlobalValues.size())
 999       return error(Twine("use of undefined global value '@") + Twine(GVIdx) +
1000                    "'");
1001     GV = IRSlots.GlobalValues[GVIdx];
1002     break;
1003   }
1004   default:
1005     llvm_unreachable("The current token should be a global value");
1006   }
1007   return false;
1008 }
1009
1010 bool MIParser::parseGlobalAddressOperand(MachineOperand &Dest) {
1011   GlobalValue *GV = nullptr;
1012   if (parseGlobalValue(GV))
1013     return true;
1014   lex();
1015   Dest = MachineOperand::CreateGA(GV, /*Offset=*/0);
1016   if (parseOperandsOffset(Dest))
1017     return true;
1018   return false;
1019 }
1020
1021 bool MIParser::parseConstantPoolIndexOperand(MachineOperand &Dest) {
1022   assert(Token.is(MIToken::ConstantPoolItem));
1023   unsigned ID;
1024   if (getUnsigned(ID))
1025     return true;
1026   auto ConstantInfo = PFS.ConstantPoolSlots.find(ID);
1027   if (ConstantInfo == PFS.ConstantPoolSlots.end())
1028     return error("use of undefined constant '%const." + Twine(ID) + "'");
1029   lex();
1030   Dest = MachineOperand::CreateCPI(ID, /*Offset=*/0);
1031   if (parseOperandsOffset(Dest))
1032     return true;
1033   return false;
1034 }
1035
1036 bool MIParser::parseJumpTableIndexOperand(MachineOperand &Dest) {
1037   assert(Token.is(MIToken::JumpTableIndex));
1038   unsigned ID;
1039   if (getUnsigned(ID))
1040     return true;
1041   auto JumpTableEntryInfo = PFS.JumpTableSlots.find(ID);
1042   if (JumpTableEntryInfo == PFS.JumpTableSlots.end())
1043     return error("use of undefined jump table '%jump-table." + Twine(ID) + "'");
1044   lex();
1045   Dest = MachineOperand::CreateJTI(JumpTableEntryInfo->second);
1046   return false;
1047 }
1048
1049 bool MIParser::parseExternalSymbolOperand(MachineOperand &Dest) {
1050   assert(Token.is(MIToken::ExternalSymbol));
1051   const char *Symbol = MF.createExternalSymbolName(Token.stringValue());
1052   lex();
1053   Dest = MachineOperand::CreateES(Symbol);
1054   if (parseOperandsOffset(Dest))
1055     return true;
1056   return false;
1057 }
1058
1059 bool MIParser::parseMDNode(MDNode *&Node) {
1060   assert(Token.is(MIToken::exclaim));
1061   auto Loc = Token.location();
1062   lex();
1063   if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
1064     return error("expected metadata id after '!'");
1065   unsigned ID;
1066   if (getUnsigned(ID))
1067     return true;
1068   auto NodeInfo = IRSlots.MetadataNodes.find(ID);
1069   if (NodeInfo == IRSlots.MetadataNodes.end())
1070     return error(Loc, "use of undefined metadata '!" + Twine(ID) + "'");
1071   lex();
1072   Node = NodeInfo->second.get();
1073   return false;
1074 }
1075
1076 bool MIParser::parseMetadataOperand(MachineOperand &Dest) {
1077   MDNode *Node = nullptr;
1078   if (parseMDNode(Node))
1079     return true;
1080   Dest = MachineOperand::CreateMetadata(Node);
1081   return false;
1082 }
1083
1084 bool MIParser::parseCFIOffset(int &Offset) {
1085   if (Token.isNot(MIToken::IntegerLiteral))
1086     return error("expected a cfi offset");
1087   if (Token.integerValue().getMinSignedBits() > 32)
1088     return error("expected a 32 bit integer (the cfi offset is too large)");
1089   Offset = (int)Token.integerValue().getExtValue();
1090   lex();
1091   return false;
1092 }
1093
1094 bool MIParser::parseCFIRegister(unsigned &Reg) {
1095   if (Token.isNot(MIToken::NamedRegister))
1096     return error("expected a cfi register");
1097   unsigned LLVMReg;
1098   if (parseRegister(LLVMReg))
1099     return true;
1100   const auto *TRI = MF.getSubtarget().getRegisterInfo();
1101   assert(TRI && "Expected target register info");
1102   int DwarfReg = TRI->getDwarfRegNum(LLVMReg, true);
1103   if (DwarfReg < 0)
1104     return error("invalid DWARF register");
1105   Reg = (unsigned)DwarfReg;
1106   lex();
1107   return false;
1108 }
1109
1110 bool MIParser::parseCFIOperand(MachineOperand &Dest) {
1111   auto Kind = Token.kind();
1112   lex();
1113   auto &MMI = MF.getMMI();
1114   int Offset;
1115   unsigned Reg;
1116   unsigned CFIIndex;
1117   switch (Kind) {
1118   case MIToken::kw_cfi_same_value:
1119     if (parseCFIRegister(Reg))
1120       return true;
1121     CFIIndex =
1122         MMI.addFrameInst(MCCFIInstruction::createSameValue(nullptr, Reg));
1123     break;
1124   case MIToken::kw_cfi_offset:
1125     if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1126         parseCFIOffset(Offset))
1127       return true;
1128     CFIIndex =
1129         MMI.addFrameInst(MCCFIInstruction::createOffset(nullptr, Reg, Offset));
1130     break;
1131   case MIToken::kw_cfi_def_cfa_register:
1132     if (parseCFIRegister(Reg))
1133       return true;
1134     CFIIndex =
1135         MMI.addFrameInst(MCCFIInstruction::createDefCfaRegister(nullptr, Reg));
1136     break;
1137   case MIToken::kw_cfi_def_cfa_offset:
1138     if (parseCFIOffset(Offset))
1139       return true;
1140     // NB: MCCFIInstruction::createDefCfaOffset negates the offset.
1141     CFIIndex = MMI.addFrameInst(
1142         MCCFIInstruction::createDefCfaOffset(nullptr, -Offset));
1143     break;
1144   case MIToken::kw_cfi_def_cfa:
1145     if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1146         parseCFIOffset(Offset))
1147       return true;
1148     // NB: MCCFIInstruction::createDefCfa negates the offset.
1149     CFIIndex =
1150         MMI.addFrameInst(MCCFIInstruction::createDefCfa(nullptr, Reg, -Offset));
1151     break;
1152   default:
1153     // TODO: Parse the other CFI operands.
1154     llvm_unreachable("The current token should be a cfi operand");
1155   }
1156   Dest = MachineOperand::CreateCFIIndex(CFIIndex);
1157   return false;
1158 }
1159
1160 bool MIParser::parseIRBlock(BasicBlock *&BB, const Function &F) {
1161   switch (Token.kind()) {
1162   case MIToken::NamedIRBlock: {
1163     BB = dyn_cast_or_null<BasicBlock>(
1164         F.getValueSymbolTable().lookup(Token.stringValue()));
1165     if (!BB)
1166       return error(Twine("use of undefined IR block '") + Token.range() + "'");
1167     break;
1168   }
1169   case MIToken::IRBlock: {
1170     unsigned SlotNumber = 0;
1171     if (getUnsigned(SlotNumber))
1172       return true;
1173     BB = const_cast<BasicBlock *>(getIRBlock(SlotNumber, F));
1174     if (!BB)
1175       return error(Twine("use of undefined IR block '%ir-block.") +
1176                    Twine(SlotNumber) + "'");
1177     break;
1178   }
1179   default:
1180     llvm_unreachable("The current token should be an IR block reference");
1181   }
1182   return false;
1183 }
1184
1185 bool MIParser::parseBlockAddressOperand(MachineOperand &Dest) {
1186   assert(Token.is(MIToken::kw_blockaddress));
1187   lex();
1188   if (expectAndConsume(MIToken::lparen))
1189     return true;
1190   if (Token.isNot(MIToken::GlobalValue) &&
1191       Token.isNot(MIToken::NamedGlobalValue))
1192     return error("expected a global value");
1193   GlobalValue *GV = nullptr;
1194   if (parseGlobalValue(GV))
1195     return true;
1196   auto *F = dyn_cast<Function>(GV);
1197   if (!F)
1198     return error("expected an IR function reference");
1199   lex();
1200   if (expectAndConsume(MIToken::comma))
1201     return true;
1202   BasicBlock *BB = nullptr;
1203   if (Token.isNot(MIToken::IRBlock) && Token.isNot(MIToken::NamedIRBlock))
1204     return error("expected an IR block reference");
1205   if (parseIRBlock(BB, *F))
1206     return true;
1207   lex();
1208   if (expectAndConsume(MIToken::rparen))
1209     return true;
1210   Dest = MachineOperand::CreateBA(BlockAddress::get(F, BB), /*Offset=*/0);
1211   if (parseOperandsOffset(Dest))
1212     return true;
1213   return false;
1214 }
1215
1216 bool MIParser::parseTargetIndexOperand(MachineOperand &Dest) {
1217   assert(Token.is(MIToken::kw_target_index));
1218   lex();
1219   if (expectAndConsume(MIToken::lparen))
1220     return true;
1221   if (Token.isNot(MIToken::Identifier))
1222     return error("expected the name of the target index");
1223   int Index = 0;
1224   if (getTargetIndex(Token.stringValue(), Index))
1225     return error("use of undefined target index '" + Token.stringValue() + "'");
1226   lex();
1227   if (expectAndConsume(MIToken::rparen))
1228     return true;
1229   Dest = MachineOperand::CreateTargetIndex(unsigned(Index), /*Offset=*/0);
1230   if (parseOperandsOffset(Dest))
1231     return true;
1232   return false;
1233 }
1234
1235 bool MIParser::parseLiveoutRegisterMaskOperand(MachineOperand &Dest) {
1236   assert(Token.is(MIToken::kw_liveout));
1237   const auto *TRI = MF.getSubtarget().getRegisterInfo();
1238   assert(TRI && "Expected target register info");
1239   uint32_t *Mask = MF.allocateRegisterMask(TRI->getNumRegs());
1240   lex();
1241   if (expectAndConsume(MIToken::lparen))
1242     return true;
1243   while (true) {
1244     if (Token.isNot(MIToken::NamedRegister))
1245       return error("expected a named register");
1246     unsigned Reg = 0;
1247     if (parseRegister(Reg))
1248       return true;
1249     lex();
1250     Mask[Reg / 32] |= 1U << (Reg % 32);
1251     // TODO: Report an error if the same register is used more than once.
1252     if (Token.isNot(MIToken::comma))
1253       break;
1254     lex();
1255   }
1256   if (expectAndConsume(MIToken::rparen))
1257     return true;
1258   Dest = MachineOperand::CreateRegLiveOut(Mask);
1259   return false;
1260 }
1261
1262 bool MIParser::parseMachineOperand(MachineOperand &Dest) {
1263   switch (Token.kind()) {
1264   case MIToken::kw_implicit:
1265   case MIToken::kw_implicit_define:
1266   case MIToken::kw_dead:
1267   case MIToken::kw_killed:
1268   case MIToken::kw_undef:
1269   case MIToken::kw_internal:
1270   case MIToken::kw_early_clobber:
1271   case MIToken::kw_debug_use:
1272   case MIToken::underscore:
1273   case MIToken::NamedRegister:
1274   case MIToken::VirtualRegister:
1275     return parseRegisterOperand(Dest);
1276   case MIToken::IntegerLiteral:
1277     return parseImmediateOperand(Dest);
1278   case MIToken::IntegerType:
1279     return parseTypedImmediateOperand(Dest);
1280   case MIToken::kw_half:
1281   case MIToken::kw_float:
1282   case MIToken::kw_double:
1283   case MIToken::kw_x86_fp80:
1284   case MIToken::kw_fp128:
1285   case MIToken::kw_ppc_fp128:
1286     return parseFPImmediateOperand(Dest);
1287   case MIToken::MachineBasicBlock:
1288     return parseMBBOperand(Dest);
1289   case MIToken::StackObject:
1290     return parseStackObjectOperand(Dest);
1291   case MIToken::FixedStackObject:
1292     return parseFixedStackObjectOperand(Dest);
1293   case MIToken::GlobalValue:
1294   case MIToken::NamedGlobalValue:
1295     return parseGlobalAddressOperand(Dest);
1296   case MIToken::ConstantPoolItem:
1297     return parseConstantPoolIndexOperand(Dest);
1298   case MIToken::JumpTableIndex:
1299     return parseJumpTableIndexOperand(Dest);
1300   case MIToken::ExternalSymbol:
1301     return parseExternalSymbolOperand(Dest);
1302   case MIToken::exclaim:
1303     return parseMetadataOperand(Dest);
1304   case MIToken::kw_cfi_same_value:
1305   case MIToken::kw_cfi_offset:
1306   case MIToken::kw_cfi_def_cfa_register:
1307   case MIToken::kw_cfi_def_cfa_offset:
1308   case MIToken::kw_cfi_def_cfa:
1309     return parseCFIOperand(Dest);
1310   case MIToken::kw_blockaddress:
1311     return parseBlockAddressOperand(Dest);
1312   case MIToken::kw_target_index:
1313     return parseTargetIndexOperand(Dest);
1314   case MIToken::kw_liveout:
1315     return parseLiveoutRegisterMaskOperand(Dest);
1316   case MIToken::Error:
1317     return true;
1318   case MIToken::Identifier:
1319     if (const auto *RegMask = getRegMask(Token.stringValue())) {
1320       Dest = MachineOperand::CreateRegMask(RegMask);
1321       lex();
1322       break;
1323     }
1324   // fallthrough
1325   default:
1326     // TODO: parse the other machine operands.
1327     return error("expected a machine operand");
1328   }
1329   return false;
1330 }
1331
1332 bool MIParser::parseMachineOperandAndTargetFlags(MachineOperand &Dest) {
1333   unsigned TF = 0;
1334   bool HasTargetFlags = false;
1335   if (Token.is(MIToken::kw_target_flags)) {
1336     HasTargetFlags = true;
1337     lex();
1338     if (expectAndConsume(MIToken::lparen))
1339       return true;
1340     if (Token.isNot(MIToken::Identifier))
1341       return error("expected the name of the target flag");
1342     if (getDirectTargetFlag(Token.stringValue(), TF))
1343       return error("use of undefined target flag '" + Token.stringValue() +
1344                    "'");
1345     lex();
1346     // TODO: Parse target's bit target flags.
1347     if (expectAndConsume(MIToken::rparen))
1348       return true;
1349   }
1350   auto Loc = Token.location();
1351   if (parseMachineOperand(Dest))
1352     return true;
1353   if (!HasTargetFlags)
1354     return false;
1355   if (Dest.isReg())
1356     return error(Loc, "register operands can't have target flags");
1357   Dest.setTargetFlags(TF);
1358   return false;
1359 }
1360
1361 bool MIParser::parseOffset(int64_t &Offset) {
1362   if (Token.isNot(MIToken::plus) && Token.isNot(MIToken::minus))
1363     return false;
1364   StringRef Sign = Token.range();
1365   bool IsNegative = Token.is(MIToken::minus);
1366   lex();
1367   if (Token.isNot(MIToken::IntegerLiteral))
1368     return error("expected an integer literal after '" + Sign + "'");
1369   if (Token.integerValue().getMinSignedBits() > 64)
1370     return error("expected 64-bit integer (too large)");
1371   Offset = Token.integerValue().getExtValue();
1372   if (IsNegative)
1373     Offset = -Offset;
1374   lex();
1375   return false;
1376 }
1377
1378 bool MIParser::parseAlignment(unsigned &Alignment) {
1379   assert(Token.is(MIToken::kw_align));
1380   lex();
1381   if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
1382     return error("expected an integer literal after 'align'");
1383   if (getUnsigned(Alignment))
1384     return true;
1385   lex();
1386   return false;
1387 }
1388
1389 bool MIParser::parseOperandsOffset(MachineOperand &Op) {
1390   int64_t Offset = 0;
1391   if (parseOffset(Offset))
1392     return true;
1393   Op.setOffset(Offset);
1394   return false;
1395 }
1396
1397 bool MIParser::parseIRValue(Value *&V) {
1398   switch (Token.kind()) {
1399   case MIToken::NamedIRValue: {
1400     V = MF.getFunction()->getValueSymbolTable().lookup(Token.stringValue());
1401     if (!V)
1402       V = MF.getFunction()->getParent()->getValueSymbolTable().lookup(
1403           Token.stringValue());
1404     if (!V)
1405       return error(Twine("use of undefined IR value '") + Token.range() + "'");
1406     break;
1407   }
1408   // TODO: Parse unnamed IR value references.
1409   default:
1410     llvm_unreachable("The current token should be an IR block reference");
1411   }
1412   return false;
1413 }
1414
1415 bool MIParser::getUint64(uint64_t &Result) {
1416   assert(Token.hasIntegerValue());
1417   if (Token.integerValue().getActiveBits() > 64)
1418     return error("expected 64-bit integer (too large)");
1419   Result = Token.integerValue().getZExtValue();
1420   return false;
1421 }
1422
1423 bool MIParser::parseMemoryOperandFlag(unsigned &Flags) {
1424   const unsigned OldFlags = Flags;
1425   switch (Token.kind()) {
1426   case MIToken::kw_volatile:
1427     Flags |= MachineMemOperand::MOVolatile;
1428     break;
1429   case MIToken::kw_non_temporal:
1430     Flags |= MachineMemOperand::MONonTemporal;
1431     break;
1432   case MIToken::kw_invariant:
1433     Flags |= MachineMemOperand::MOInvariant;
1434     break;
1435   // TODO: parse the target specific memory operand flags.
1436   default:
1437     llvm_unreachable("The current token should be a memory operand flag");
1438   }
1439   if (OldFlags == Flags)
1440     // We know that the same flag is specified more than once when the flags
1441     // weren't modified.
1442     return error("duplicate '" + Token.stringValue() + "' memory operand flag");
1443   lex();
1444   return false;
1445 }
1446
1447 bool MIParser::parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV) {
1448   switch (Token.kind()) {
1449   case MIToken::kw_stack:
1450     PSV = MF.getPSVManager().getStack();
1451     break;
1452   case MIToken::kw_got:
1453     PSV = MF.getPSVManager().getGOT();
1454     break;
1455   case MIToken::kw_jump_table:
1456     PSV = MF.getPSVManager().getJumpTable();
1457     break;
1458   case MIToken::kw_constant_pool:
1459     PSV = MF.getPSVManager().getConstantPool();
1460     break;
1461   case MIToken::FixedStackObject: {
1462     int FI;
1463     if (parseFixedStackFrameIndex(FI))
1464       return true;
1465     PSV = MF.getPSVManager().getFixedStack(FI);
1466     // The token was already consumed, so use return here instead of break.
1467     return false;
1468   }
1469   case MIToken::GlobalValue:
1470   case MIToken::NamedGlobalValue: {
1471     GlobalValue *GV = nullptr;
1472     if (parseGlobalValue(GV))
1473       return true;
1474     PSV = MF.getPSVManager().getGlobalValueCallEntry(GV);
1475     break;
1476   }
1477   case MIToken::ExternalSymbol:
1478     PSV = MF.getPSVManager().getExternalSymbolCallEntry(
1479         MF.createExternalSymbolName(Token.stringValue()));
1480     break;
1481   default:
1482     llvm_unreachable("The current token should be pseudo source value");
1483   }
1484   lex();
1485   return false;
1486 }
1487
1488 bool MIParser::parseMachinePointerInfo(MachinePointerInfo &Dest) {
1489   if (Token.is(MIToken::kw_constant_pool) || Token.is(MIToken::kw_stack) ||
1490       Token.is(MIToken::kw_got) || Token.is(MIToken::kw_jump_table) ||
1491       Token.is(MIToken::FixedStackObject) || Token.is(MIToken::GlobalValue) ||
1492       Token.is(MIToken::NamedGlobalValue) ||
1493       Token.is(MIToken::ExternalSymbol)) {
1494     const PseudoSourceValue *PSV = nullptr;
1495     if (parseMemoryPseudoSourceValue(PSV))
1496       return true;
1497     int64_t Offset = 0;
1498     if (parseOffset(Offset))
1499       return true;
1500     Dest = MachinePointerInfo(PSV, Offset);
1501     return false;
1502   }
1503   if (Token.isNot(MIToken::NamedIRValue))
1504     return error("expected an IR value reference");
1505   Value *V = nullptr;
1506   if (parseIRValue(V))
1507     return true;
1508   if (!V->getType()->isPointerTy())
1509     return error("expected a pointer IR value");
1510   lex();
1511   int64_t Offset = 0;
1512   if (parseOffset(Offset))
1513     return true;
1514   Dest = MachinePointerInfo(V, Offset);
1515   return false;
1516 }
1517
1518 bool MIParser::parseMachineMemoryOperand(MachineMemOperand *&Dest) {
1519   if (expectAndConsume(MIToken::lparen))
1520     return true;
1521   unsigned Flags = 0;
1522   while (Token.isMemoryOperandFlag()) {
1523     if (parseMemoryOperandFlag(Flags))
1524       return true;
1525   }
1526   if (Token.isNot(MIToken::Identifier) ||
1527       (Token.stringValue() != "load" && Token.stringValue() != "store"))
1528     return error("expected 'load' or 'store' memory operation");
1529   if (Token.stringValue() == "load")
1530     Flags |= MachineMemOperand::MOLoad;
1531   else
1532     Flags |= MachineMemOperand::MOStore;
1533   lex();
1534
1535   if (Token.isNot(MIToken::IntegerLiteral))
1536     return error("expected the size integer literal after memory operation");
1537   uint64_t Size;
1538   if (getUint64(Size))
1539     return true;
1540   lex();
1541
1542   const char *Word = Flags & MachineMemOperand::MOLoad ? "from" : "into";
1543   if (Token.isNot(MIToken::Identifier) || Token.stringValue() != Word)
1544     return error(Twine("expected '") + Word + "'");
1545   lex();
1546
1547   MachinePointerInfo Ptr = MachinePointerInfo();
1548   if (parseMachinePointerInfo(Ptr))
1549     return true;
1550   unsigned BaseAlignment = Size;
1551   AAMDNodes AAInfo;
1552   MDNode *Range = nullptr;
1553   while (consumeIfPresent(MIToken::comma)) {
1554     switch (Token.kind()) {
1555     case MIToken::kw_align:
1556       if (parseAlignment(BaseAlignment))
1557         return true;
1558       break;
1559     case MIToken::md_tbaa:
1560       lex();
1561       if (parseMDNode(AAInfo.TBAA))
1562         return true;
1563       break;
1564     case MIToken::md_alias_scope:
1565       lex();
1566       if (parseMDNode(AAInfo.Scope))
1567         return true;
1568       break;
1569     case MIToken::md_noalias:
1570       lex();
1571       if (parseMDNode(AAInfo.NoAlias))
1572         return true;
1573       break;
1574     case MIToken::md_range:
1575       lex();
1576       if (parseMDNode(Range))
1577         return true;
1578       break;
1579     // TODO: Report an error on duplicate metadata nodes.
1580     default:
1581       return error("expected 'align' or '!tbaa' or '!alias.scope' or "
1582                    "'!noalias' or '!range'");
1583     }
1584   }
1585   if (expectAndConsume(MIToken::rparen))
1586     return true;
1587   Dest =
1588       MF.getMachineMemOperand(Ptr, Flags, Size, BaseAlignment, AAInfo, Range);
1589   return false;
1590 }
1591
1592 void MIParser::initNames2InstrOpCodes() {
1593   if (!Names2InstrOpCodes.empty())
1594     return;
1595   const auto *TII = MF.getSubtarget().getInstrInfo();
1596   assert(TII && "Expected target instruction info");
1597   for (unsigned I = 0, E = TII->getNumOpcodes(); I < E; ++I)
1598     Names2InstrOpCodes.insert(std::make_pair(StringRef(TII->getName(I)), I));
1599 }
1600
1601 bool MIParser::parseInstrName(StringRef InstrName, unsigned &OpCode) {
1602   initNames2InstrOpCodes();
1603   auto InstrInfo = Names2InstrOpCodes.find(InstrName);
1604   if (InstrInfo == Names2InstrOpCodes.end())
1605     return true;
1606   OpCode = InstrInfo->getValue();
1607   return false;
1608 }
1609
1610 void MIParser::initNames2Regs() {
1611   if (!Names2Regs.empty())
1612     return;
1613   // The '%noreg' register is the register 0.
1614   Names2Regs.insert(std::make_pair("noreg", 0));
1615   const auto *TRI = MF.getSubtarget().getRegisterInfo();
1616   assert(TRI && "Expected target register info");
1617   for (unsigned I = 0, E = TRI->getNumRegs(); I < E; ++I) {
1618     bool WasInserted =
1619         Names2Regs.insert(std::make_pair(StringRef(TRI->getName(I)).lower(), I))
1620             .second;
1621     (void)WasInserted;
1622     assert(WasInserted && "Expected registers to be unique case-insensitively");
1623   }
1624 }
1625
1626 bool MIParser::getRegisterByName(StringRef RegName, unsigned &Reg) {
1627   initNames2Regs();
1628   auto RegInfo = Names2Regs.find(RegName);
1629   if (RegInfo == Names2Regs.end())
1630     return true;
1631   Reg = RegInfo->getValue();
1632   return false;
1633 }
1634
1635 void MIParser::initNames2RegMasks() {
1636   if (!Names2RegMasks.empty())
1637     return;
1638   const auto *TRI = MF.getSubtarget().getRegisterInfo();
1639   assert(TRI && "Expected target register info");
1640   ArrayRef<const uint32_t *> RegMasks = TRI->getRegMasks();
1641   ArrayRef<const char *> RegMaskNames = TRI->getRegMaskNames();
1642   assert(RegMasks.size() == RegMaskNames.size());
1643   for (size_t I = 0, E = RegMasks.size(); I < E; ++I)
1644     Names2RegMasks.insert(
1645         std::make_pair(StringRef(RegMaskNames[I]).lower(), RegMasks[I]));
1646 }
1647
1648 const uint32_t *MIParser::getRegMask(StringRef Identifier) {
1649   initNames2RegMasks();
1650   auto RegMaskInfo = Names2RegMasks.find(Identifier);
1651   if (RegMaskInfo == Names2RegMasks.end())
1652     return nullptr;
1653   return RegMaskInfo->getValue();
1654 }
1655
1656 void MIParser::initNames2SubRegIndices() {
1657   if (!Names2SubRegIndices.empty())
1658     return;
1659   const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
1660   for (unsigned I = 1, E = TRI->getNumSubRegIndices(); I < E; ++I)
1661     Names2SubRegIndices.insert(
1662         std::make_pair(StringRef(TRI->getSubRegIndexName(I)).lower(), I));
1663 }
1664
1665 unsigned MIParser::getSubRegIndex(StringRef Name) {
1666   initNames2SubRegIndices();
1667   auto SubRegInfo = Names2SubRegIndices.find(Name);
1668   if (SubRegInfo == Names2SubRegIndices.end())
1669     return 0;
1670   return SubRegInfo->getValue();
1671 }
1672
1673 static void initSlots2BasicBlocks(
1674     const Function &F,
1675     DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
1676   ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
1677   MST.incorporateFunction(F);
1678   for (auto &BB : F) {
1679     if (BB.hasName())
1680       continue;
1681     int Slot = MST.getLocalSlot(&BB);
1682     if (Slot == -1)
1683       continue;
1684     Slots2BasicBlocks.insert(std::make_pair(unsigned(Slot), &BB));
1685   }
1686 }
1687
1688 static const BasicBlock *getIRBlockFromSlot(
1689     unsigned Slot,
1690     const DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
1691   auto BlockInfo = Slots2BasicBlocks.find(Slot);
1692   if (BlockInfo == Slots2BasicBlocks.end())
1693     return nullptr;
1694   return BlockInfo->second;
1695 }
1696
1697 const BasicBlock *MIParser::getIRBlock(unsigned Slot) {
1698   if (Slots2BasicBlocks.empty())
1699     initSlots2BasicBlocks(*MF.getFunction(), Slots2BasicBlocks);
1700   return getIRBlockFromSlot(Slot, Slots2BasicBlocks);
1701 }
1702
1703 const BasicBlock *MIParser::getIRBlock(unsigned Slot, const Function &F) {
1704   if (&F == MF.getFunction())
1705     return getIRBlock(Slot);
1706   DenseMap<unsigned, const BasicBlock *> CustomSlots2BasicBlocks;
1707   initSlots2BasicBlocks(F, CustomSlots2BasicBlocks);
1708   return getIRBlockFromSlot(Slot, CustomSlots2BasicBlocks);
1709 }
1710
1711 void MIParser::initNames2TargetIndices() {
1712   if (!Names2TargetIndices.empty())
1713     return;
1714   const auto *TII = MF.getSubtarget().getInstrInfo();
1715   assert(TII && "Expected target instruction info");
1716   auto Indices = TII->getSerializableTargetIndices();
1717   for (const auto &I : Indices)
1718     Names2TargetIndices.insert(std::make_pair(StringRef(I.second), I.first));
1719 }
1720
1721 bool MIParser::getTargetIndex(StringRef Name, int &Index) {
1722   initNames2TargetIndices();
1723   auto IndexInfo = Names2TargetIndices.find(Name);
1724   if (IndexInfo == Names2TargetIndices.end())
1725     return true;
1726   Index = IndexInfo->second;
1727   return false;
1728 }
1729
1730 void MIParser::initNames2DirectTargetFlags() {
1731   if (!Names2DirectTargetFlags.empty())
1732     return;
1733   const auto *TII = MF.getSubtarget().getInstrInfo();
1734   assert(TII && "Expected target instruction info");
1735   auto Flags = TII->getSerializableDirectMachineOperandTargetFlags();
1736   for (const auto &I : Flags)
1737     Names2DirectTargetFlags.insert(
1738         std::make_pair(StringRef(I.second), I.first));
1739 }
1740
1741 bool MIParser::getDirectTargetFlag(StringRef Name, unsigned &Flag) {
1742   initNames2DirectTargetFlags();
1743   auto FlagInfo = Names2DirectTargetFlags.find(Name);
1744   if (FlagInfo == Names2DirectTargetFlags.end())
1745     return true;
1746   Flag = FlagInfo->second;
1747   return false;
1748 }
1749
1750 bool llvm::parseMachineBasicBlockDefinitions(MachineFunction &MF, StringRef Src,
1751                                              PerFunctionMIParsingState &PFS,
1752                                              const SlotMapping &IRSlots,
1753                                              SMDiagnostic &Error) {
1754   SourceMgr SM;
1755   SM.AddNewSourceBuffer(
1756       MemoryBuffer::getMemBuffer(Src, "", /*RequiresNullTerminator=*/false),
1757       SMLoc());
1758   return MIParser(SM, MF, Error, Src, PFS, IRSlots)
1759       .parseBasicBlockDefinitions(PFS.MBBSlots);
1760 }
1761
1762 bool llvm::parseMachineInstructions(MachineFunction &MF, StringRef Src,
1763                                     const PerFunctionMIParsingState &PFS,
1764                                     const SlotMapping &IRSlots,
1765                                     SMDiagnostic &Error) {
1766   SourceMgr SM;
1767   SM.AddNewSourceBuffer(
1768       MemoryBuffer::getMemBuffer(Src, "", /*RequiresNullTerminator=*/false),
1769       SMLoc());
1770   return MIParser(SM, MF, Error, Src, PFS, IRSlots).parseBasicBlocks();
1771 }
1772
1773 bool llvm::parseMBBReference(MachineBasicBlock *&MBB, SourceMgr &SM,
1774                              MachineFunction &MF, StringRef Src,
1775                              const PerFunctionMIParsingState &PFS,
1776                              const SlotMapping &IRSlots, SMDiagnostic &Error) {
1777   return MIParser(SM, MF, Error, Src, PFS, IRSlots).parseStandaloneMBB(MBB);
1778 }
1779
1780 bool llvm::parseNamedRegisterReference(unsigned &Reg, SourceMgr &SM,
1781                                        MachineFunction &MF, StringRef Src,
1782                                        const PerFunctionMIParsingState &PFS,
1783                                        const SlotMapping &IRSlots,
1784                                        SMDiagnostic &Error) {
1785   return MIParser(SM, MF, Error, Src, PFS, IRSlots)
1786       .parseStandaloneNamedRegister(Reg);
1787 }
1788
1789 bool llvm::parseVirtualRegisterReference(unsigned &Reg, SourceMgr &SM,
1790                                          MachineFunction &MF, StringRef Src,
1791                                          const PerFunctionMIParsingState &PFS,
1792                                          const SlotMapping &IRSlots,
1793                                          SMDiagnostic &Error) {
1794   return MIParser(SM, MF, Error, Src, PFS, IRSlots)
1795       .parseStandaloneVirtualRegister(Reg);
1796 }