LCOV - code coverage report
Current view: top level - lib/CodeGen/MIRParser - MIParser.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 1374 1466 93.7 %
Date: 2018-10-20 13:21:21 Functions: 110 111 99.1 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13