1 //===- MIParser.cpp - Machine instructions parser implementation ----------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the parsing of machine instructions.
12 //===----------------------------------------------------------------------===//
16 #include "llvm/ADT/StringMap.h"
17 #include "llvm/AsmParser/Parser.h"
18 #include "llvm/AsmParser/SlotMapping.h"
19 #include "llvm/CodeGen/MachineBasicBlock.h"
20 #include "llvm/CodeGen/MachineFunction.h"
21 #include "llvm/CodeGen/MachineFrameInfo.h"
22 #include "llvm/CodeGen/MachineInstr.h"
23 #include "llvm/CodeGen/MachineInstrBuilder.h"
24 #include "llvm/CodeGen/MachineMemOperand.h"
25 #include "llvm/CodeGen/MachineModuleInfo.h"
26 #include "llvm/IR/Instructions.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/Module.h"
29 #include "llvm/IR/ModuleSlotTracker.h"
30 #include "llvm/IR/ValueSymbolTable.h"
31 #include "llvm/Support/raw_ostream.h"
32 #include "llvm/Support/SourceMgr.h"
33 #include "llvm/Target/TargetSubtargetInfo.h"
34 #include "llvm/Target/TargetInstrInfo.h"
40 /// A wrapper struct around the 'MachineOperand' struct that includes a source
42 struct MachineOperandWithLocation {
43 MachineOperand Operand;
44 StringRef::iterator Begin;
45 StringRef::iterator End;
47 MachineOperandWithLocation(const MachineOperand &Operand,
48 StringRef::iterator Begin, StringRef::iterator End)
49 : Operand(Operand), Begin(Begin), End(End) {}
56 StringRef Source, CurrentSource;
58 const PerFunctionMIParsingState &PFS;
59 /// Maps from indices to unnamed global values and metadata nodes.
60 const SlotMapping &IRSlots;
61 /// Maps from instruction names to op codes.
62 StringMap<unsigned> Names2InstrOpCodes;
63 /// Maps from register names to registers.
64 StringMap<unsigned> Names2Regs;
65 /// Maps from register mask names to register masks.
66 StringMap<const uint32_t *> Names2RegMasks;
67 /// Maps from subregister names to subregister indices.
68 StringMap<unsigned> Names2SubRegIndices;
69 /// Maps from slot numbers to function's unnamed basic blocks.
70 DenseMap<unsigned, const BasicBlock *> Slots2BasicBlocks;
71 /// Maps from target index names to target indices.
72 StringMap<int> Names2TargetIndices;
73 /// Maps from direct target flag names to the direct target flag values.
74 StringMap<unsigned> Names2DirectTargetFlags;
77 MIParser(SourceMgr &SM, MachineFunction &MF, SMDiagnostic &Error,
78 StringRef Source, const PerFunctionMIParsingState &PFS,
79 const SlotMapping &IRSlots);
83 /// Report an error at the current location with the given message.
85 /// This function always return true.
86 bool error(const Twine &Msg);
88 /// Report an error at the given location with the given message.
90 /// This function always return true.
91 bool error(StringRef::iterator Loc, const Twine &Msg);
93 bool parse(MachineInstr *&MI);
94 bool parseStandaloneMBB(MachineBasicBlock *&MBB);
95 bool parseStandaloneNamedRegister(unsigned &Reg);
96 bool parseStandaloneVirtualRegister(unsigned &Reg);
97 bool parseStandaloneIRBlockReference(const BasicBlock *&BB);
99 bool parseRegister(unsigned &Reg);
100 bool parseRegisterFlag(unsigned &Flags);
101 bool parseSubRegisterIndex(unsigned &SubReg);
102 bool parseRegisterOperand(MachineOperand &Dest, bool IsDef = false);
103 bool parseImmediateOperand(MachineOperand &Dest);
104 bool parseIRConstant(StringRef::iterator Loc, const Constant *&C);
105 bool parseTypedImmediateOperand(MachineOperand &Dest);
106 bool parseFPImmediateOperand(MachineOperand &Dest);
107 bool parseMBBReference(MachineBasicBlock *&MBB);
108 bool parseMBBOperand(MachineOperand &Dest);
109 bool parseStackObjectOperand(MachineOperand &Dest);
110 bool parseFixedStackFrameIndex(int &FI);
111 bool parseFixedStackObjectOperand(MachineOperand &Dest);
112 bool parseGlobalValue(GlobalValue *&GV);
113 bool parseGlobalAddressOperand(MachineOperand &Dest);
114 bool parseConstantPoolIndexOperand(MachineOperand &Dest);
115 bool parseJumpTableIndexOperand(MachineOperand &Dest);
116 bool parseExternalSymbolOperand(MachineOperand &Dest);
117 bool parseMDNode(MDNode *&Node);
118 bool parseMetadataOperand(MachineOperand &Dest);
119 bool parseCFIOffset(int &Offset);
120 bool parseCFIRegister(unsigned &Reg);
121 bool parseCFIOperand(MachineOperand &Dest);
122 bool parseIRBlock(BasicBlock *&BB, const Function &F);
123 bool parseBlockAddressOperand(MachineOperand &Dest);
124 bool parseTargetIndexOperand(MachineOperand &Dest);
125 bool parseLiveoutRegisterMaskOperand(MachineOperand &Dest);
126 bool parseMachineOperand(MachineOperand &Dest);
127 bool parseMachineOperandAndTargetFlags(MachineOperand &Dest);
128 bool parseOffset(int64_t &Offset);
129 bool parseAlignment(unsigned &Alignment);
130 bool parseOperandsOffset(MachineOperand &Op);
131 bool parseIRValue(Value *&V);
132 bool parseMemoryOperandFlag(unsigned &Flags);
133 bool parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV);
134 bool parseMachinePointerInfo(MachinePointerInfo &Dest);
135 bool parseMachineMemoryOperand(MachineMemOperand *&Dest);
138 /// Convert the integer literal in the current token into an unsigned integer.
140 /// Return true if an error occurred.
141 bool getUnsigned(unsigned &Result);
143 /// Convert the integer literal in the current token into an uint64.
145 /// Return true if an error occurred.
146 bool getUint64(uint64_t &Result);
148 /// If the current token is of the given kind, consume it and return false.
149 /// Otherwise report an error and return true.
150 bool expectAndConsume(MIToken::TokenKind TokenKind);
152 void initNames2InstrOpCodes();
154 /// Try to convert an instruction name to an opcode. Return true if the
155 /// instruction name is invalid.
156 bool parseInstrName(StringRef InstrName, unsigned &OpCode);
158 bool parseInstruction(unsigned &OpCode, unsigned &Flags);
160 bool verifyImplicitOperands(ArrayRef<MachineOperandWithLocation> Operands,
161 const MCInstrDesc &MCID);
163 void initNames2Regs();
165 /// Try to convert a register name to a register number. Return true if the
166 /// register name is invalid.
167 bool getRegisterByName(StringRef RegName, unsigned &Reg);
169 void initNames2RegMasks();
171 /// Check if the given identifier is a name of a register mask.
173 /// Return null if the identifier isn't a register mask.
174 const uint32_t *getRegMask(StringRef Identifier);
176 void initNames2SubRegIndices();
178 /// Check if the given identifier is a name of a subregister index.
180 /// Return 0 if the name isn't a subregister index class.
181 unsigned getSubRegIndex(StringRef Name);
183 const BasicBlock *getIRBlock(unsigned Slot);
184 const BasicBlock *getIRBlock(unsigned Slot, const Function &F);
186 void initNames2TargetIndices();
188 /// Try to convert a name of target index to the corresponding target index.
190 /// Return true if the name isn't a name of a target index.
191 bool getTargetIndex(StringRef Name, int &Index);
193 void initNames2DirectTargetFlags();
195 /// Try to convert a name of a direct target flag to the corresponding
198 /// Return true if the name isn't a name of a direct flag.
199 bool getDirectTargetFlag(StringRef Name, unsigned &Flag);
202 } // end anonymous namespace
204 MIParser::MIParser(SourceMgr &SM, MachineFunction &MF, SMDiagnostic &Error,
205 StringRef Source, const PerFunctionMIParsingState &PFS,
206 const SlotMapping &IRSlots)
207 : SM(SM), MF(MF), Error(Error), Source(Source), CurrentSource(Source),
208 PFS(PFS), IRSlots(IRSlots) {}
210 void MIParser::lex() {
211 CurrentSource = lexMIToken(
212 CurrentSource, Token,
213 [this](StringRef::iterator Loc, const Twine &Msg) { error(Loc, Msg); });
216 bool MIParser::error(const Twine &Msg) { return error(Token.location(), Msg); }
218 bool MIParser::error(StringRef::iterator Loc, const Twine &Msg) {
219 assert(Loc >= Source.data() && Loc <= (Source.data() + Source.size()));
220 Error = SMDiagnostic(
222 SM.getMemoryBuffer(SM.getMainFileID())->getBufferIdentifier(), 1,
223 Loc - Source.data(), SourceMgr::DK_Error, Msg.str(), Source, None, None);
227 static const char *toString(MIToken::TokenKind TokenKind) {
233 case MIToken::lparen:
235 case MIToken::rparen:
238 return "<unknown token>";
242 bool MIParser::expectAndConsume(MIToken::TokenKind TokenKind) {
243 if (Token.isNot(TokenKind))
244 return error(Twine("expected ") + toString(TokenKind));
249 bool MIParser::parse(MachineInstr *&MI) {
252 // Parse any register operands before '='
253 MachineOperand MO = MachineOperand::CreateImm(0);
254 SmallVector<MachineOperandWithLocation, 8> Operands;
255 while (Token.isRegister() || Token.isRegisterFlag()) {
256 auto Loc = Token.location();
257 if (parseRegisterOperand(MO, /*IsDef=*/true))
259 Operands.push_back(MachineOperandWithLocation(MO, Loc, Token.location()));
260 if (Token.isNot(MIToken::comma))
264 if (!Operands.empty() && expectAndConsume(MIToken::equal))
267 unsigned OpCode, Flags = 0;
268 if (Token.isError() || parseInstruction(OpCode, Flags))
271 // TODO: Parse the bundle instruction flags.
273 // Parse the remaining machine operands.
274 while (Token.isNot(MIToken::Eof) && Token.isNot(MIToken::kw_debug_location) &&
275 Token.isNot(MIToken::coloncolon)) {
276 auto Loc = Token.location();
277 if (parseMachineOperandAndTargetFlags(MO))
279 Operands.push_back(MachineOperandWithLocation(MO, Loc, Token.location()));
280 if (Token.is(MIToken::Eof) || Token.is(MIToken::coloncolon))
282 if (Token.isNot(MIToken::comma))
283 return error("expected ',' before the next machine operand");
287 DebugLoc DebugLocation;
288 if (Token.is(MIToken::kw_debug_location)) {
290 if (Token.isNot(MIToken::exclaim))
291 return error("expected a metadata node after 'debug-location'");
292 MDNode *Node = nullptr;
293 if (parseMDNode(Node))
295 DebugLocation = DebugLoc(Node);
298 // Parse the machine memory operands.
299 SmallVector<MachineMemOperand *, 2> MemOperands;
300 if (Token.is(MIToken::coloncolon)) {
302 while (Token.isNot(MIToken::Eof)) {
303 MachineMemOperand *MemOp = nullptr;
304 if (parseMachineMemoryOperand(MemOp))
306 MemOperands.push_back(MemOp);
307 if (Token.is(MIToken::Eof))
309 if (Token.isNot(MIToken::comma))
310 return error("expected ',' before the next machine memory operand");
315 const auto &MCID = MF.getSubtarget().getInstrInfo()->get(OpCode);
316 if (!MCID.isVariadic()) {
317 // FIXME: Move the implicit operand verification to the machine verifier.
318 if (verifyImplicitOperands(Operands, MCID))
322 // TODO: Check for extraneous machine operands.
323 MI = MF.CreateMachineInstr(MCID, DebugLocation, /*NoImplicit=*/true);
325 for (const auto &Operand : Operands)
326 MI->addOperand(MF, Operand.Operand);
327 if (MemOperands.empty())
329 MachineInstr::mmo_iterator MemRefs =
330 MF.allocateMemRefsArray(MemOperands.size());
331 std::copy(MemOperands.begin(), MemOperands.end(), MemRefs);
332 MI->setMemRefs(MemRefs, MemRefs + MemOperands.size());
336 bool MIParser::parseStandaloneMBB(MachineBasicBlock *&MBB) {
338 if (Token.isNot(MIToken::MachineBasicBlock))
339 return error("expected a machine basic block reference");
340 if (parseMBBReference(MBB))
343 if (Token.isNot(MIToken::Eof))
345 "expected end of string after the machine basic block reference");
349 bool MIParser::parseStandaloneNamedRegister(unsigned &Reg) {
351 if (Token.isNot(MIToken::NamedRegister))
352 return error("expected a named register");
353 if (parseRegister(Reg))
356 if (Token.isNot(MIToken::Eof))
357 return error("expected end of string after the register reference");
361 bool MIParser::parseStandaloneVirtualRegister(unsigned &Reg) {
363 if (Token.isNot(MIToken::VirtualRegister))
364 return error("expected a virtual register");
365 if (parseRegister(Reg))
368 if (Token.isNot(MIToken::Eof))
369 return error("expected end of string after the register reference");
373 bool MIParser::parseStandaloneIRBlockReference(const BasicBlock *&BB) {
375 if (Token.isNot(MIToken::IRBlock))
376 return error("expected an IR block reference");
377 unsigned SlotNumber = 0;
378 if (getUnsigned(SlotNumber))
380 BB = getIRBlock(SlotNumber);
382 return error(Twine("use of undefined IR block '%ir-block.") +
383 Twine(SlotNumber) + "'");
385 if (Token.isNot(MIToken::Eof))
386 return error("expected end of string after the IR block reference");
390 static const char *printImplicitRegisterFlag(const MachineOperand &MO) {
391 assert(MO.isImplicit());
392 return MO.isDef() ? "implicit-def" : "implicit";
395 static std::string getRegisterName(const TargetRegisterInfo *TRI,
397 assert(TargetRegisterInfo::isPhysicalRegister(Reg) && "expected phys reg");
398 return StringRef(TRI->getName(Reg)).lower();
401 bool MIParser::verifyImplicitOperands(
402 ArrayRef<MachineOperandWithLocation> Operands, const MCInstrDesc &MCID) {
404 // We can't verify call instructions as they can contain arbitrary implicit
405 // register and register mask operands.
408 // Gather all the expected implicit operands.
409 SmallVector<MachineOperand, 4> ImplicitOperands;
410 if (MCID.ImplicitDefs)
411 for (const uint16_t *ImpDefs = MCID.getImplicitDefs(); *ImpDefs; ++ImpDefs)
412 ImplicitOperands.push_back(
413 MachineOperand::CreateReg(*ImpDefs, true, true));
414 if (MCID.ImplicitUses)
415 for (const uint16_t *ImpUses = MCID.getImplicitUses(); *ImpUses; ++ImpUses)
416 ImplicitOperands.push_back(
417 MachineOperand::CreateReg(*ImpUses, false, true));
419 const auto *TRI = MF.getSubtarget().getRegisterInfo();
420 assert(TRI && "Expected target register info");
421 size_t I = ImplicitOperands.size(), J = Operands.size();
426 const auto &ImplicitOperand = ImplicitOperands[I];
427 const auto &Operand = Operands[J].Operand;
428 if (ImplicitOperand.isIdenticalTo(Operand))
430 if (Operand.isReg() && Operand.isImplicit()) {
431 return error(Operands[J].Begin,
432 Twine("expected an implicit register operand '") +
433 printImplicitRegisterFlag(ImplicitOperand) + " %" +
434 getRegisterName(TRI, ImplicitOperand.getReg()) + "'");
437 // TODO: Fix source location when Operands[J].end is right before '=', i.e:
438 // insead of reporting an error at this location:
441 // report the error at the following location:
444 return error(J < Operands.size() ? Operands[J].End : Token.location(),
445 Twine("missing implicit register operand '") +
446 printImplicitRegisterFlag(ImplicitOperands[I]) + " %" +
447 getRegisterName(TRI, ImplicitOperands[I].getReg()) + "'");
452 bool MIParser::parseInstruction(unsigned &OpCode, unsigned &Flags) {
453 if (Token.is(MIToken::kw_frame_setup)) {
454 Flags |= MachineInstr::FrameSetup;
457 if (Token.isNot(MIToken::Identifier))
458 return error("expected a machine instruction");
459 StringRef InstrName = Token.stringValue();
460 if (parseInstrName(InstrName, OpCode))
461 return error(Twine("unknown machine instruction name '") + InstrName + "'");
466 bool MIParser::parseRegister(unsigned &Reg) {
467 switch (Token.kind()) {
468 case MIToken::underscore:
471 case MIToken::NamedRegister: {
472 StringRef Name = Token.stringValue();
473 if (getRegisterByName(Name, Reg))
474 return error(Twine("unknown register name '") + Name + "'");
477 case MIToken::VirtualRegister: {
481 const auto RegInfo = PFS.VirtualRegisterSlots.find(ID);
482 if (RegInfo == PFS.VirtualRegisterSlots.end())
483 return error(Twine("use of undefined virtual register '%") + Twine(ID) +
485 Reg = RegInfo->second;
488 // TODO: Parse other register kinds.
490 llvm_unreachable("The current token should be a register");
495 bool MIParser::parseRegisterFlag(unsigned &Flags) {
496 const unsigned OldFlags = Flags;
497 switch (Token.kind()) {
498 case MIToken::kw_implicit:
499 Flags |= RegState::Implicit;
501 case MIToken::kw_implicit_define:
502 Flags |= RegState::ImplicitDefine;
504 case MIToken::kw_dead:
505 Flags |= RegState::Dead;
507 case MIToken::kw_killed:
508 Flags |= RegState::Kill;
510 case MIToken::kw_undef:
511 Flags |= RegState::Undef;
513 case MIToken::kw_early_clobber:
514 Flags |= RegState::EarlyClobber;
516 case MIToken::kw_debug_use:
517 Flags |= RegState::Debug;
519 // TODO: parse the other register flags.
521 llvm_unreachable("The current token should be a register flag");
523 if (OldFlags == Flags)
524 // We know that the same flag is specified more than once when the flags
526 return error("duplicate '" + Token.stringValue() + "' register flag");
531 bool MIParser::parseSubRegisterIndex(unsigned &SubReg) {
532 assert(Token.is(MIToken::colon));
534 if (Token.isNot(MIToken::Identifier))
535 return error("expected a subregister index after ':'");
536 auto Name = Token.stringValue();
537 SubReg = getSubRegIndex(Name);
539 return error(Twine("use of unknown subregister index '") + Name + "'");
544 bool MIParser::parseRegisterOperand(MachineOperand &Dest, bool IsDef) {
546 unsigned Flags = IsDef ? RegState::Define : 0;
547 while (Token.isRegisterFlag()) {
548 if (parseRegisterFlag(Flags))
551 if (!Token.isRegister())
552 return error("expected a register after register flags");
553 if (parseRegister(Reg))
557 if (Token.is(MIToken::colon)) {
558 if (parseSubRegisterIndex(SubReg))
561 Dest = MachineOperand::CreateReg(
562 Reg, Flags & RegState::Define, Flags & RegState::Implicit,
563 Flags & RegState::Kill, Flags & RegState::Dead, Flags & RegState::Undef,
564 Flags & RegState::EarlyClobber, SubReg, Flags & RegState::Debug);
568 bool MIParser::parseImmediateOperand(MachineOperand &Dest) {
569 assert(Token.is(MIToken::IntegerLiteral));
570 const APSInt &Int = Token.integerValue();
571 if (Int.getMinSignedBits() > 64)
572 return error("integer literal is too large to be an immediate operand");
573 Dest = MachineOperand::CreateImm(Int.getExtValue());
578 bool MIParser::parseIRConstant(StringRef::iterator Loc, const Constant *&C) {
579 auto Source = StringRef(Loc, Token.range().end() - Loc).str();
582 C = parseConstantValue(Source.c_str(), Err, *MF.getFunction()->getParent());
584 return error(Loc + Err.getColumnNo(), Err.getMessage());
588 bool MIParser::parseTypedImmediateOperand(MachineOperand &Dest) {
589 assert(Token.is(MIToken::IntegerType));
590 auto Loc = Token.location();
592 if (Token.isNot(MIToken::IntegerLiteral))
593 return error("expected an integer literal");
594 const Constant *C = nullptr;
595 if (parseIRConstant(Loc, C))
597 Dest = MachineOperand::CreateCImm(cast<ConstantInt>(C));
601 bool MIParser::parseFPImmediateOperand(MachineOperand &Dest) {
602 auto Loc = Token.location();
604 if (Token.isNot(MIToken::FloatingPointLiteral))
605 return error("expected a floating point literal");
606 const Constant *C = nullptr;
607 if (parseIRConstant(Loc, C))
609 Dest = MachineOperand::CreateFPImm(cast<ConstantFP>(C));
613 bool MIParser::getUnsigned(unsigned &Result) {
614 assert(Token.hasIntegerValue() && "Expected a token with an integer value");
615 const uint64_t Limit = uint64_t(std::numeric_limits<unsigned>::max()) + 1;
616 uint64_t Val64 = Token.integerValue().getLimitedValue(Limit);
618 return error("expected 32-bit integer (too large)");
623 bool MIParser::parseMBBReference(MachineBasicBlock *&MBB) {
624 assert(Token.is(MIToken::MachineBasicBlock));
626 if (getUnsigned(Number))
628 auto MBBInfo = PFS.MBBSlots.find(Number);
629 if (MBBInfo == PFS.MBBSlots.end())
630 return error(Twine("use of undefined machine basic block #") +
632 MBB = MBBInfo->second;
633 if (!Token.stringValue().empty() && Token.stringValue() != MBB->getName())
634 return error(Twine("the name of machine basic block #") + Twine(Number) +
635 " isn't '" + Token.stringValue() + "'");
639 bool MIParser::parseMBBOperand(MachineOperand &Dest) {
640 MachineBasicBlock *MBB;
641 if (parseMBBReference(MBB))
643 Dest = MachineOperand::CreateMBB(MBB);
648 bool MIParser::parseStackObjectOperand(MachineOperand &Dest) {
649 assert(Token.is(MIToken::StackObject));
653 auto ObjectInfo = PFS.StackObjectSlots.find(ID);
654 if (ObjectInfo == PFS.StackObjectSlots.end())
655 return error(Twine("use of undefined stack object '%stack.") + Twine(ID) +
658 if (const auto *Alloca =
659 MF.getFrameInfo()->getObjectAllocation(ObjectInfo->second))
660 Name = Alloca->getName();
661 if (!Token.stringValue().empty() && Token.stringValue() != Name)
662 return error(Twine("the name of the stack object '%stack.") + Twine(ID) +
663 "' isn't '" + Token.stringValue() + "'");
665 Dest = MachineOperand::CreateFI(ObjectInfo->second);
669 bool MIParser::parseFixedStackFrameIndex(int &FI) {
670 assert(Token.is(MIToken::FixedStackObject));
674 auto ObjectInfo = PFS.FixedStackObjectSlots.find(ID);
675 if (ObjectInfo == PFS.FixedStackObjectSlots.end())
676 return error(Twine("use of undefined fixed stack object '%fixed-stack.") +
679 FI = ObjectInfo->second;
683 bool MIParser::parseFixedStackObjectOperand(MachineOperand &Dest) {
685 if (parseFixedStackFrameIndex(FI))
687 Dest = MachineOperand::CreateFI(FI);
691 bool MIParser::parseGlobalValue(GlobalValue *&GV) {
692 switch (Token.kind()) {
693 case MIToken::NamedGlobalValue: {
694 const Module *M = MF.getFunction()->getParent();
695 GV = M->getNamedValue(Token.stringValue());
697 return error(Twine("use of undefined global value '") + Token.range() +
701 case MIToken::GlobalValue: {
703 if (getUnsigned(GVIdx))
705 if (GVIdx >= IRSlots.GlobalValues.size())
706 return error(Twine("use of undefined global value '@") + Twine(GVIdx) +
708 GV = IRSlots.GlobalValues[GVIdx];
712 llvm_unreachable("The current token should be a global value");
717 bool MIParser::parseGlobalAddressOperand(MachineOperand &Dest) {
718 GlobalValue *GV = nullptr;
719 if (parseGlobalValue(GV))
722 Dest = MachineOperand::CreateGA(GV, /*Offset=*/0);
723 if (parseOperandsOffset(Dest))
728 bool MIParser::parseConstantPoolIndexOperand(MachineOperand &Dest) {
729 assert(Token.is(MIToken::ConstantPoolItem));
733 auto ConstantInfo = PFS.ConstantPoolSlots.find(ID);
734 if (ConstantInfo == PFS.ConstantPoolSlots.end())
735 return error("use of undefined constant '%const." + Twine(ID) + "'");
737 Dest = MachineOperand::CreateCPI(ID, /*Offset=*/0);
738 if (parseOperandsOffset(Dest))
743 bool MIParser::parseJumpTableIndexOperand(MachineOperand &Dest) {
744 assert(Token.is(MIToken::JumpTableIndex));
748 auto JumpTableEntryInfo = PFS.JumpTableSlots.find(ID);
749 if (JumpTableEntryInfo == PFS.JumpTableSlots.end())
750 return error("use of undefined jump table '%jump-table." + Twine(ID) + "'");
752 Dest = MachineOperand::CreateJTI(JumpTableEntryInfo->second);
756 bool MIParser::parseExternalSymbolOperand(MachineOperand &Dest) {
757 assert(Token.is(MIToken::ExternalSymbol));
758 const char *Symbol = MF.createExternalSymbolName(Token.stringValue());
760 Dest = MachineOperand::CreateES(Symbol);
761 if (parseOperandsOffset(Dest))
766 bool MIParser::parseMDNode(MDNode *&Node) {
767 assert(Token.is(MIToken::exclaim));
768 auto Loc = Token.location();
770 if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
771 return error("expected metadata id after '!'");
775 auto NodeInfo = IRSlots.MetadataNodes.find(ID);
776 if (NodeInfo == IRSlots.MetadataNodes.end())
777 return error(Loc, "use of undefined metadata '!" + Twine(ID) + "'");
779 Node = NodeInfo->second.get();
783 bool MIParser::parseMetadataOperand(MachineOperand &Dest) {
784 MDNode *Node = nullptr;
785 if (parseMDNode(Node))
787 Dest = MachineOperand::CreateMetadata(Node);
791 bool MIParser::parseCFIOffset(int &Offset) {
792 if (Token.isNot(MIToken::IntegerLiteral))
793 return error("expected a cfi offset");
794 if (Token.integerValue().getMinSignedBits() > 32)
795 return error("expected a 32 bit integer (the cfi offset is too large)");
796 Offset = (int)Token.integerValue().getExtValue();
801 bool MIParser::parseCFIRegister(unsigned &Reg) {
802 if (Token.isNot(MIToken::NamedRegister))
803 return error("expected a cfi register");
805 if (parseRegister(LLVMReg))
807 const auto *TRI = MF.getSubtarget().getRegisterInfo();
808 assert(TRI && "Expected target register info");
809 int DwarfReg = TRI->getDwarfRegNum(LLVMReg, true);
811 return error("invalid DWARF register");
812 Reg = (unsigned)DwarfReg;
817 bool MIParser::parseCFIOperand(MachineOperand &Dest) {
818 auto Kind = Token.kind();
820 auto &MMI = MF.getMMI();
825 case MIToken::kw_cfi_offset:
826 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
827 parseCFIOffset(Offset))
830 MMI.addFrameInst(MCCFIInstruction::createOffset(nullptr, Reg, Offset));
832 case MIToken::kw_cfi_def_cfa_register:
833 if (parseCFIRegister(Reg))
836 MMI.addFrameInst(MCCFIInstruction::createDefCfaRegister(nullptr, Reg));
838 case MIToken::kw_cfi_def_cfa_offset:
839 if (parseCFIOffset(Offset))
841 // NB: MCCFIInstruction::createDefCfaOffset negates the offset.
842 CFIIndex = MMI.addFrameInst(
843 MCCFIInstruction::createDefCfaOffset(nullptr, -Offset));
845 case MIToken::kw_cfi_def_cfa:
846 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
847 parseCFIOffset(Offset))
849 // NB: MCCFIInstruction::createDefCfa negates the offset.
851 MMI.addFrameInst(MCCFIInstruction::createDefCfa(nullptr, Reg, -Offset));
854 // TODO: Parse the other CFI operands.
855 llvm_unreachable("The current token should be a cfi operand");
857 Dest = MachineOperand::CreateCFIIndex(CFIIndex);
861 bool MIParser::parseIRBlock(BasicBlock *&BB, const Function &F) {
862 switch (Token.kind()) {
863 case MIToken::NamedIRBlock: {
864 BB = dyn_cast_or_null<BasicBlock>(
865 F.getValueSymbolTable().lookup(Token.stringValue()));
867 return error(Twine("use of undefined IR block '") + Token.range() + "'");
870 case MIToken::IRBlock: {
871 unsigned SlotNumber = 0;
872 if (getUnsigned(SlotNumber))
874 BB = const_cast<BasicBlock *>(getIRBlock(SlotNumber, F));
876 return error(Twine("use of undefined IR block '%ir-block.") +
877 Twine(SlotNumber) + "'");
881 llvm_unreachable("The current token should be an IR block reference");
886 bool MIParser::parseBlockAddressOperand(MachineOperand &Dest) {
887 assert(Token.is(MIToken::kw_blockaddress));
889 if (expectAndConsume(MIToken::lparen))
891 if (Token.isNot(MIToken::GlobalValue) &&
892 Token.isNot(MIToken::NamedGlobalValue))
893 return error("expected a global value");
894 GlobalValue *GV = nullptr;
895 if (parseGlobalValue(GV))
897 auto *F = dyn_cast<Function>(GV);
899 return error("expected an IR function reference");
901 if (expectAndConsume(MIToken::comma))
903 BasicBlock *BB = nullptr;
904 if (Token.isNot(MIToken::IRBlock) && Token.isNot(MIToken::NamedIRBlock))
905 return error("expected an IR block reference");
906 if (parseIRBlock(BB, *F))
909 if (expectAndConsume(MIToken::rparen))
911 Dest = MachineOperand::CreateBA(BlockAddress::get(F, BB), /*Offset=*/0);
912 if (parseOperandsOffset(Dest))
917 bool MIParser::parseTargetIndexOperand(MachineOperand &Dest) {
918 assert(Token.is(MIToken::kw_target_index));
920 if (expectAndConsume(MIToken::lparen))
922 if (Token.isNot(MIToken::Identifier))
923 return error("expected the name of the target index");
925 if (getTargetIndex(Token.stringValue(), Index))
926 return error("use of undefined target index '" + Token.stringValue() + "'");
928 if (expectAndConsume(MIToken::rparen))
930 Dest = MachineOperand::CreateTargetIndex(unsigned(Index), /*Offset=*/0);
931 if (parseOperandsOffset(Dest))
936 bool MIParser::parseLiveoutRegisterMaskOperand(MachineOperand &Dest) {
937 assert(Token.is(MIToken::kw_liveout));
938 const auto *TRI = MF.getSubtarget().getRegisterInfo();
939 assert(TRI && "Expected target register info");
940 uint32_t *Mask = MF.allocateRegisterMask(TRI->getNumRegs());
942 if (expectAndConsume(MIToken::lparen))
945 if (Token.isNot(MIToken::NamedRegister))
946 return error("expected a named register");
948 if (parseRegister(Reg))
951 Mask[Reg / 32] |= 1U << (Reg % 32);
952 // TODO: Report an error if the same register is used more than once.
953 if (Token.isNot(MIToken::comma))
957 if (expectAndConsume(MIToken::rparen))
959 Dest = MachineOperand::CreateRegLiveOut(Mask);
963 bool MIParser::parseMachineOperand(MachineOperand &Dest) {
964 switch (Token.kind()) {
965 case MIToken::kw_implicit:
966 case MIToken::kw_implicit_define:
967 case MIToken::kw_dead:
968 case MIToken::kw_killed:
969 case MIToken::kw_undef:
970 case MIToken::kw_early_clobber:
971 case MIToken::kw_debug_use:
972 case MIToken::underscore:
973 case MIToken::NamedRegister:
974 case MIToken::VirtualRegister:
975 return parseRegisterOperand(Dest);
976 case MIToken::IntegerLiteral:
977 return parseImmediateOperand(Dest);
978 case MIToken::IntegerType:
979 return parseTypedImmediateOperand(Dest);
980 case MIToken::kw_half:
981 case MIToken::kw_float:
982 case MIToken::kw_double:
983 case MIToken::kw_x86_fp80:
984 case MIToken::kw_fp128:
985 case MIToken::kw_ppc_fp128:
986 return parseFPImmediateOperand(Dest);
987 case MIToken::MachineBasicBlock:
988 return parseMBBOperand(Dest);
989 case MIToken::StackObject:
990 return parseStackObjectOperand(Dest);
991 case MIToken::FixedStackObject:
992 return parseFixedStackObjectOperand(Dest);
993 case MIToken::GlobalValue:
994 case MIToken::NamedGlobalValue:
995 return parseGlobalAddressOperand(Dest);
996 case MIToken::ConstantPoolItem:
997 return parseConstantPoolIndexOperand(Dest);
998 case MIToken::JumpTableIndex:
999 return parseJumpTableIndexOperand(Dest);
1000 case MIToken::ExternalSymbol:
1001 return parseExternalSymbolOperand(Dest);
1002 case MIToken::exclaim:
1003 return parseMetadataOperand(Dest);
1004 case MIToken::kw_cfi_offset:
1005 case MIToken::kw_cfi_def_cfa_register:
1006 case MIToken::kw_cfi_def_cfa_offset:
1007 case MIToken::kw_cfi_def_cfa:
1008 return parseCFIOperand(Dest);
1009 case MIToken::kw_blockaddress:
1010 return parseBlockAddressOperand(Dest);
1011 case MIToken::kw_target_index:
1012 return parseTargetIndexOperand(Dest);
1013 case MIToken::kw_liveout:
1014 return parseLiveoutRegisterMaskOperand(Dest);
1015 case MIToken::Error:
1017 case MIToken::Identifier:
1018 if (const auto *RegMask = getRegMask(Token.stringValue())) {
1019 Dest = MachineOperand::CreateRegMask(RegMask);
1025 // TODO: parse the other machine operands.
1026 return error("expected a machine operand");
1031 bool MIParser::parseMachineOperandAndTargetFlags(MachineOperand &Dest) {
1033 bool HasTargetFlags = false;
1034 if (Token.is(MIToken::kw_target_flags)) {
1035 HasTargetFlags = true;
1037 if (expectAndConsume(MIToken::lparen))
1039 if (Token.isNot(MIToken::Identifier))
1040 return error("expected the name of the target flag");
1041 if (getDirectTargetFlag(Token.stringValue(), TF))
1042 return error("use of undefined target flag '" + Token.stringValue() +
1045 // TODO: Parse target's bit target flags.
1046 if (expectAndConsume(MIToken::rparen))
1049 auto Loc = Token.location();
1050 if (parseMachineOperand(Dest))
1052 if (!HasTargetFlags)
1055 return error(Loc, "register operands can't have target flags");
1056 Dest.setTargetFlags(TF);
1060 bool MIParser::parseOffset(int64_t &Offset) {
1061 if (Token.isNot(MIToken::plus) && Token.isNot(MIToken::minus))
1063 StringRef Sign = Token.range();
1064 bool IsNegative = Token.is(MIToken::minus);
1066 if (Token.isNot(MIToken::IntegerLiteral))
1067 return error("expected an integer literal after '" + Sign + "'");
1068 if (Token.integerValue().getMinSignedBits() > 64)
1069 return error("expected 64-bit integer (too large)");
1070 Offset = Token.integerValue().getExtValue();
1077 bool MIParser::parseAlignment(unsigned &Alignment) {
1078 assert(Token.is(MIToken::kw_align));
1080 if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
1081 return error("expected an integer literal after 'align'");
1082 if (getUnsigned(Alignment))
1088 bool MIParser::parseOperandsOffset(MachineOperand &Op) {
1090 if (parseOffset(Offset))
1092 Op.setOffset(Offset);
1096 bool MIParser::parseIRValue(Value *&V) {
1097 switch (Token.kind()) {
1098 case MIToken::NamedIRValue: {
1099 V = MF.getFunction()->getValueSymbolTable().lookup(Token.stringValue());
1101 V = MF.getFunction()->getParent()->getValueSymbolTable().lookup(
1102 Token.stringValue());
1104 return error(Twine("use of undefined IR value '") + Token.range() + "'");
1107 // TODO: Parse unnamed IR value references.
1109 llvm_unreachable("The current token should be an IR block reference");
1114 bool MIParser::getUint64(uint64_t &Result) {
1115 assert(Token.hasIntegerValue());
1116 if (Token.integerValue().getActiveBits() > 64)
1117 return error("expected 64-bit integer (too large)");
1118 Result = Token.integerValue().getZExtValue();
1122 bool MIParser::parseMemoryOperandFlag(unsigned &Flags) {
1123 const unsigned OldFlags = Flags;
1124 switch (Token.kind()) {
1125 case MIToken::kw_volatile:
1126 Flags |= MachineMemOperand::MOVolatile;
1128 case MIToken::kw_non_temporal:
1129 Flags |= MachineMemOperand::MONonTemporal;
1131 case MIToken::kw_invariant:
1132 Flags |= MachineMemOperand::MOInvariant;
1134 // TODO: parse the target specific memory operand flags.
1136 llvm_unreachable("The current token should be a memory operand flag");
1138 if (OldFlags == Flags)
1139 // We know that the same flag is specified more than once when the flags
1140 // weren't modified.
1141 return error("duplicate '" + Token.stringValue() + "' memory operand flag");
1146 bool MIParser::parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV) {
1147 switch (Token.kind()) {
1148 case MIToken::kw_stack:
1149 PSV = MF.getPSVManager().getStack();
1151 case MIToken::kw_got:
1152 PSV = MF.getPSVManager().getGOT();
1154 case MIToken::kw_jump_table:
1155 PSV = MF.getPSVManager().getJumpTable();
1157 case MIToken::kw_constant_pool:
1158 PSV = MF.getPSVManager().getConstantPool();
1160 case MIToken::FixedStackObject: {
1162 if (parseFixedStackFrameIndex(FI))
1164 PSV = MF.getPSVManager().getFixedStack(FI);
1165 // The token was already consumed, so use return here instead of break.
1168 // TODO: Parse the other pseudo source values.
1170 llvm_unreachable("The current token should be pseudo source value");
1176 bool MIParser::parseMachinePointerInfo(MachinePointerInfo &Dest) {
1177 if (Token.is(MIToken::kw_constant_pool) || Token.is(MIToken::kw_stack) ||
1178 Token.is(MIToken::kw_got) || Token.is(MIToken::kw_jump_table) ||
1179 Token.is(MIToken::FixedStackObject)) {
1180 const PseudoSourceValue *PSV = nullptr;
1181 if (parseMemoryPseudoSourceValue(PSV))
1184 if (parseOffset(Offset))
1186 Dest = MachinePointerInfo(PSV, Offset);
1189 if (Token.isNot(MIToken::NamedIRValue))
1190 return error("expected an IR value reference");
1192 if (parseIRValue(V))
1194 if (!V->getType()->isPointerTy())
1195 return error("expected a pointer IR value");
1198 if (parseOffset(Offset))
1200 Dest = MachinePointerInfo(V, Offset);
1204 bool MIParser::parseMachineMemoryOperand(MachineMemOperand *&Dest) {
1205 if (expectAndConsume(MIToken::lparen))
1208 while (Token.isMemoryOperandFlag()) {
1209 if (parseMemoryOperandFlag(Flags))
1212 if (Token.isNot(MIToken::Identifier) ||
1213 (Token.stringValue() != "load" && Token.stringValue() != "store"))
1214 return error("expected 'load' or 'store' memory operation");
1215 if (Token.stringValue() == "load")
1216 Flags |= MachineMemOperand::MOLoad;
1218 Flags |= MachineMemOperand::MOStore;
1221 if (Token.isNot(MIToken::IntegerLiteral))
1222 return error("expected the size integer literal after memory operation");
1224 if (getUint64(Size))
1228 const char *Word = Flags & MachineMemOperand::MOLoad ? "from" : "into";
1229 if (Token.isNot(MIToken::Identifier) || Token.stringValue() != Word)
1230 return error(Twine("expected '") + Word + "'");
1233 MachinePointerInfo Ptr = MachinePointerInfo();
1234 if (parseMachinePointerInfo(Ptr))
1236 unsigned BaseAlignment = Size;
1237 if (Token.is(MIToken::comma)) {
1239 if (Token.isNot(MIToken::kw_align))
1240 return error("expected 'align'");
1241 if (parseAlignment(BaseAlignment))
1244 // TODO: Parse the attached metadata nodes.
1245 if (expectAndConsume(MIToken::rparen))
1247 Dest = MF.getMachineMemOperand(Ptr, Flags, Size, BaseAlignment);
1251 void MIParser::initNames2InstrOpCodes() {
1252 if (!Names2InstrOpCodes.empty())
1254 const auto *TII = MF.getSubtarget().getInstrInfo();
1255 assert(TII && "Expected target instruction info");
1256 for (unsigned I = 0, E = TII->getNumOpcodes(); I < E; ++I)
1257 Names2InstrOpCodes.insert(std::make_pair(StringRef(TII->getName(I)), I));
1260 bool MIParser::parseInstrName(StringRef InstrName, unsigned &OpCode) {
1261 initNames2InstrOpCodes();
1262 auto InstrInfo = Names2InstrOpCodes.find(InstrName);
1263 if (InstrInfo == Names2InstrOpCodes.end())
1265 OpCode = InstrInfo->getValue();
1269 void MIParser::initNames2Regs() {
1270 if (!Names2Regs.empty())
1272 // The '%noreg' register is the register 0.
1273 Names2Regs.insert(std::make_pair("noreg", 0));
1274 const auto *TRI = MF.getSubtarget().getRegisterInfo();
1275 assert(TRI && "Expected target register info");
1276 for (unsigned I = 0, E = TRI->getNumRegs(); I < E; ++I) {
1278 Names2Regs.insert(std::make_pair(StringRef(TRI->getName(I)).lower(), I))
1281 assert(WasInserted && "Expected registers to be unique case-insensitively");
1285 bool MIParser::getRegisterByName(StringRef RegName, unsigned &Reg) {
1287 auto RegInfo = Names2Regs.find(RegName);
1288 if (RegInfo == Names2Regs.end())
1290 Reg = RegInfo->getValue();
1294 void MIParser::initNames2RegMasks() {
1295 if (!Names2RegMasks.empty())
1297 const auto *TRI = MF.getSubtarget().getRegisterInfo();
1298 assert(TRI && "Expected target register info");
1299 ArrayRef<const uint32_t *> RegMasks = TRI->getRegMasks();
1300 ArrayRef<const char *> RegMaskNames = TRI->getRegMaskNames();
1301 assert(RegMasks.size() == RegMaskNames.size());
1302 for (size_t I = 0, E = RegMasks.size(); I < E; ++I)
1303 Names2RegMasks.insert(
1304 std::make_pair(StringRef(RegMaskNames[I]).lower(), RegMasks[I]));
1307 const uint32_t *MIParser::getRegMask(StringRef Identifier) {
1308 initNames2RegMasks();
1309 auto RegMaskInfo = Names2RegMasks.find(Identifier);
1310 if (RegMaskInfo == Names2RegMasks.end())
1312 return RegMaskInfo->getValue();
1315 void MIParser::initNames2SubRegIndices() {
1316 if (!Names2SubRegIndices.empty())
1318 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
1319 for (unsigned I = 1, E = TRI->getNumSubRegIndices(); I < E; ++I)
1320 Names2SubRegIndices.insert(
1321 std::make_pair(StringRef(TRI->getSubRegIndexName(I)).lower(), I));
1324 unsigned MIParser::getSubRegIndex(StringRef Name) {
1325 initNames2SubRegIndices();
1326 auto SubRegInfo = Names2SubRegIndices.find(Name);
1327 if (SubRegInfo == Names2SubRegIndices.end())
1329 return SubRegInfo->getValue();
1332 static void initSlots2BasicBlocks(
1334 DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
1335 ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
1336 MST.incorporateFunction(F);
1337 for (auto &BB : F) {
1340 int Slot = MST.getLocalSlot(&BB);
1343 Slots2BasicBlocks.insert(std::make_pair(unsigned(Slot), &BB));
1347 static const BasicBlock *getIRBlockFromSlot(
1349 const DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
1350 auto BlockInfo = Slots2BasicBlocks.find(Slot);
1351 if (BlockInfo == Slots2BasicBlocks.end())
1353 return BlockInfo->second;
1356 const BasicBlock *MIParser::getIRBlock(unsigned Slot) {
1357 if (Slots2BasicBlocks.empty())
1358 initSlots2BasicBlocks(*MF.getFunction(), Slots2BasicBlocks);
1359 return getIRBlockFromSlot(Slot, Slots2BasicBlocks);
1362 const BasicBlock *MIParser::getIRBlock(unsigned Slot, const Function &F) {
1363 if (&F == MF.getFunction())
1364 return getIRBlock(Slot);
1365 DenseMap<unsigned, const BasicBlock *> CustomSlots2BasicBlocks;
1366 initSlots2BasicBlocks(F, CustomSlots2BasicBlocks);
1367 return getIRBlockFromSlot(Slot, CustomSlots2BasicBlocks);
1370 void MIParser::initNames2TargetIndices() {
1371 if (!Names2TargetIndices.empty())
1373 const auto *TII = MF.getSubtarget().getInstrInfo();
1374 assert(TII && "Expected target instruction info");
1375 auto Indices = TII->getSerializableTargetIndices();
1376 for (const auto &I : Indices)
1377 Names2TargetIndices.insert(std::make_pair(StringRef(I.second), I.first));
1380 bool MIParser::getTargetIndex(StringRef Name, int &Index) {
1381 initNames2TargetIndices();
1382 auto IndexInfo = Names2TargetIndices.find(Name);
1383 if (IndexInfo == Names2TargetIndices.end())
1385 Index = IndexInfo->second;
1389 void MIParser::initNames2DirectTargetFlags() {
1390 if (!Names2DirectTargetFlags.empty())
1392 const auto *TII = MF.getSubtarget().getInstrInfo();
1393 assert(TII && "Expected target instruction info");
1394 auto Flags = TII->getSerializableDirectMachineOperandTargetFlags();
1395 for (const auto &I : Flags)
1396 Names2DirectTargetFlags.insert(
1397 std::make_pair(StringRef(I.second), I.first));
1400 bool MIParser::getDirectTargetFlag(StringRef Name, unsigned &Flag) {
1401 initNames2DirectTargetFlags();
1402 auto FlagInfo = Names2DirectTargetFlags.find(Name);
1403 if (FlagInfo == Names2DirectTargetFlags.end())
1405 Flag = FlagInfo->second;
1409 bool llvm::parseMachineInstr(MachineInstr *&MI, SourceMgr &SM,
1410 MachineFunction &MF, StringRef Src,
1411 const PerFunctionMIParsingState &PFS,
1412 const SlotMapping &IRSlots, SMDiagnostic &Error) {
1413 return MIParser(SM, MF, Error, Src, PFS, IRSlots).parse(MI);
1416 bool llvm::parseMBBReference(MachineBasicBlock *&MBB, SourceMgr &SM,
1417 MachineFunction &MF, StringRef Src,
1418 const PerFunctionMIParsingState &PFS,
1419 const SlotMapping &IRSlots, SMDiagnostic &Error) {
1420 return MIParser(SM, MF, Error, Src, PFS, IRSlots).parseStandaloneMBB(MBB);
1423 bool llvm::parseNamedRegisterReference(unsigned &Reg, SourceMgr &SM,
1424 MachineFunction &MF, StringRef Src,
1425 const PerFunctionMIParsingState &PFS,
1426 const SlotMapping &IRSlots,
1427 SMDiagnostic &Error) {
1428 return MIParser(SM, MF, Error, Src, PFS, IRSlots)
1429 .parseStandaloneNamedRegister(Reg);
1432 bool llvm::parseVirtualRegisterReference(unsigned &Reg, SourceMgr &SM,
1433 MachineFunction &MF, StringRef Src,
1434 const PerFunctionMIParsingState &PFS,
1435 const SlotMapping &IRSlots,
1436 SMDiagnostic &Error) {
1437 return MIParser(SM, MF, Error, Src, PFS, IRSlots)
1438 .parseStandaloneVirtualRegister(Reg);
1441 bool llvm::parseIRBlockReference(const BasicBlock *&BB, SourceMgr &SM,
1442 MachineFunction &MF, StringRef Src,
1443 const PerFunctionMIParsingState &PFS,
1444 const SlotMapping &IRSlots,
1445 SMDiagnostic &Error) {
1446 return MIParser(SM, MF, Error, Src, PFS, IRSlots)
1447 .parseStandaloneIRBlockReference(BB);