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

Generated by: LCOV version 1.13