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

Generated by: LCOV version 1.13