lib/CodeGen/MIRParser/MIParser.cpp

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