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

Generated by: LCOV version 1.13