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;
75 /// Maps from direct target flag names to the bitmask target flag values.
76 StringMap<unsigned> Names2BitmaskTargetFlags;
79 MIParser(SourceMgr &SM, MachineFunction &MF, SMDiagnostic &Error,
80 StringRef Source, const PerFunctionMIParsingState &PFS,
81 const SlotMapping &IRSlots);
85 /// Report an error at the current location with the given message.
87 /// This function always return true.
88 bool error(const Twine &Msg);
90 /// Report an error at the given location with the given message.
92 /// This function always return true.
93 bool error(StringRef::iterator Loc, const Twine &Msg);
96 parseBasicBlockDefinitions(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
97 bool parseBasicBlocks();
98 bool parse(MachineInstr *&MI);
99 bool parseStandaloneMBB(MachineBasicBlock *&MBB);
100 bool parseStandaloneNamedRegister(unsigned &Reg);
101 bool parseStandaloneVirtualRegister(unsigned &Reg);
102 bool parseStandaloneStackObject(int &FI);
105 parseBasicBlockDefinition(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
106 bool parseBasicBlock(MachineBasicBlock &MBB);
107 bool parseBasicBlockLiveins(MachineBasicBlock &MBB);
108 bool parseBasicBlockSuccessors(MachineBasicBlock &MBB);
110 bool parseRegister(unsigned &Reg);
111 bool parseRegisterFlag(unsigned &Flags);
112 bool parseSubRegisterIndex(unsigned &SubReg);
113 bool parseRegisterOperand(MachineOperand &Dest, bool IsDef = false);
114 bool parseImmediateOperand(MachineOperand &Dest);
115 bool parseIRConstant(StringRef::iterator Loc, const Constant *&C);
116 bool parseTypedImmediateOperand(MachineOperand &Dest);
117 bool parseFPImmediateOperand(MachineOperand &Dest);
118 bool parseMBBReference(MachineBasicBlock *&MBB);
119 bool parseMBBOperand(MachineOperand &Dest);
120 bool parseStackFrameIndex(int &FI);
121 bool parseStackObjectOperand(MachineOperand &Dest);
122 bool parseFixedStackFrameIndex(int &FI);
123 bool parseFixedStackObjectOperand(MachineOperand &Dest);
124 bool parseGlobalValue(GlobalValue *&GV);
125 bool parseGlobalAddressOperand(MachineOperand &Dest);
126 bool parseConstantPoolIndexOperand(MachineOperand &Dest);
127 bool parseJumpTableIndexOperand(MachineOperand &Dest);
128 bool parseExternalSymbolOperand(MachineOperand &Dest);
129 bool parseMDNode(MDNode *&Node);
130 bool parseMetadataOperand(MachineOperand &Dest);
131 bool parseCFIOffset(int &Offset);
132 bool parseCFIRegister(unsigned &Reg);
133 bool parseCFIOperand(MachineOperand &Dest);
134 bool parseIRBlock(BasicBlock *&BB, const Function &F);
135 bool parseBlockAddressOperand(MachineOperand &Dest);
136 bool parseTargetIndexOperand(MachineOperand &Dest);
137 bool parseLiveoutRegisterMaskOperand(MachineOperand &Dest);
138 bool parseMachineOperand(MachineOperand &Dest);
139 bool parseMachineOperandAndTargetFlags(MachineOperand &Dest);
140 bool parseOffset(int64_t &Offset);
141 bool parseAlignment(unsigned &Alignment);
142 bool parseOperandsOffset(MachineOperand &Op);
143 bool parseIRValue(Value *&V);
144 bool parseMemoryOperandFlag(unsigned &Flags);
145 bool parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV);
146 bool parseMachinePointerInfo(MachinePointerInfo &Dest);
147 bool parseMachineMemoryOperand(MachineMemOperand *&Dest);
150 /// Convert the integer literal in the current token into an unsigned integer.
152 /// Return true if an error occurred.
153 bool getUnsigned(unsigned &Result);
155 /// Convert the integer literal in the current token into an uint64.
157 /// Return true if an error occurred.
158 bool getUint64(uint64_t &Result);
160 /// If the current token is of the given kind, consume it and return false.
161 /// Otherwise report an error and return true.
162 bool expectAndConsume(MIToken::TokenKind TokenKind);
164 /// If the current token is of the given kind, consume it and return true.
165 /// Otherwise return false.
166 bool consumeIfPresent(MIToken::TokenKind TokenKind);
168 void initNames2InstrOpCodes();
170 /// Try to convert an instruction name to an opcode. Return true if the
171 /// instruction name is invalid.
172 bool parseInstrName(StringRef InstrName, unsigned &OpCode);
174 bool parseInstruction(unsigned &OpCode, unsigned &Flags);
176 bool verifyImplicitOperands(ArrayRef<MachineOperandWithLocation> Operands,
177 const MCInstrDesc &MCID);
179 void initNames2Regs();
181 /// Try to convert a register name to a register number. Return true if the
182 /// register name is invalid.
183 bool getRegisterByName(StringRef RegName, unsigned &Reg);
185 void initNames2RegMasks();
187 /// Check if the given identifier is a name of a register mask.
189 /// Return null if the identifier isn't a register mask.
190 const uint32_t *getRegMask(StringRef Identifier);
192 void initNames2SubRegIndices();
194 /// Check if the given identifier is a name of a subregister index.
196 /// Return 0 if the name isn't a subregister index class.
197 unsigned getSubRegIndex(StringRef Name);
199 const BasicBlock *getIRBlock(unsigned Slot);
200 const BasicBlock *getIRBlock(unsigned Slot, const Function &F);
202 void initNames2TargetIndices();
204 /// Try to convert a name of target index to the corresponding target index.
206 /// Return true if the name isn't a name of a target index.
207 bool getTargetIndex(StringRef Name, int &Index);
209 void initNames2DirectTargetFlags();
211 /// Try to convert a name of a direct target flag to the corresponding
214 /// Return true if the name isn't a name of a direct flag.
215 bool getDirectTargetFlag(StringRef Name, unsigned &Flag);
217 void initNames2BitmaskTargetFlags();
219 /// Try to convert a name of a bitmask target flag to the corresponding
222 /// Return true if the name isn't a name of a bitmask target flag.
223 bool getBitmaskTargetFlag(StringRef Name, unsigned &Flag);
226 } // end anonymous namespace
228 MIParser::MIParser(SourceMgr &SM, MachineFunction &MF, SMDiagnostic &Error,
229 StringRef Source, const PerFunctionMIParsingState &PFS,
230 const SlotMapping &IRSlots)
231 : SM(SM), MF(MF), Error(Error), Source(Source), CurrentSource(Source),
232 PFS(PFS), IRSlots(IRSlots) {}
234 void MIParser::lex() {
235 CurrentSource = lexMIToken(
236 CurrentSource, Token,
237 [this](StringRef::iterator Loc, const Twine &Msg) { error(Loc, Msg); });
240 bool MIParser::error(const Twine &Msg) { return error(Token.location(), Msg); }
242 bool MIParser::error(StringRef::iterator Loc, const Twine &Msg) {
243 assert(Loc >= Source.data() && Loc <= (Source.data() + Source.size()));
244 const MemoryBuffer &Buffer = *SM.getMemoryBuffer(SM.getMainFileID());
245 if (Loc >= Buffer.getBufferStart() && Loc <= Buffer.getBufferEnd()) {
246 // Create an ordinary diagnostic when the source manager's buffer is the
248 Error = SM.GetMessage(SMLoc::getFromPointer(Loc), SourceMgr::DK_Error, Msg);
251 // Create a diagnostic for a YAML string literal.
252 Error = SMDiagnostic(SM, SMLoc(), Buffer.getBufferIdentifier(), 1,
253 Loc - Source.data(), SourceMgr::DK_Error, Msg.str(),
258 static const char *toString(MIToken::TokenKind TokenKind) {
266 case MIToken::lparen:
268 case MIToken::rparen:
271 return "<unknown token>";
275 bool MIParser::expectAndConsume(MIToken::TokenKind TokenKind) {
276 if (Token.isNot(TokenKind))
277 return error(Twine("expected ") + toString(TokenKind));
282 bool MIParser::consumeIfPresent(MIToken::TokenKind TokenKind) {
283 if (Token.isNot(TokenKind))
289 bool MIParser::parseBasicBlockDefinition(
290 DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
291 assert(Token.is(MIToken::MachineBasicBlockLabel));
295 auto Loc = Token.location();
296 auto Name = Token.stringValue();
298 bool HasAddressTaken = false;
299 bool IsLandingPad = false;
300 unsigned Alignment = 0;
301 BasicBlock *BB = nullptr;
302 if (consumeIfPresent(MIToken::lparen)) {
304 // TODO: Report an error when multiple same attributes are specified.
305 switch (Token.kind()) {
306 case MIToken::kw_address_taken:
307 HasAddressTaken = true;
310 case MIToken::kw_landing_pad:
314 case MIToken::kw_align:
315 if (parseAlignment(Alignment))
318 case MIToken::IRBlock:
319 // TODO: Report an error when both name and ir block are specified.
320 if (parseIRBlock(BB, *MF.getFunction()))
327 } while (consumeIfPresent(MIToken::comma));
328 if (expectAndConsume(MIToken::rparen))
331 if (expectAndConsume(MIToken::colon))
335 BB = dyn_cast_or_null<BasicBlock>(
336 MF.getFunction()->getValueSymbolTable().lookup(Name));
338 return error(Loc, Twine("basic block '") + Name +
339 "' is not defined in the function '" +
342 auto *MBB = MF.CreateMachineBasicBlock(BB);
343 MF.insert(MF.end(), MBB);
344 bool WasInserted = MBBSlots.insert(std::make_pair(ID, MBB)).second;
346 return error(Loc, Twine("redefinition of machine basic block with id #") +
349 MBB->setAlignment(Alignment);
351 MBB->setHasAddressTaken();
352 MBB->setIsLandingPad(IsLandingPad);
356 bool MIParser::parseBasicBlockDefinitions(
357 DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
359 // Skip until the first machine basic block.
360 while (Token.is(MIToken::Newline))
362 if (Token.isErrorOrEOF())
363 return Token.isError();
364 if (Token.isNot(MIToken::MachineBasicBlockLabel))
365 return error("expected a basic block definition before instructions");
366 unsigned BraceDepth = 0;
368 if (parseBasicBlockDefinition(MBBSlots))
370 bool IsAfterNewline = false;
371 // Skip until the next machine basic block.
373 if ((Token.is(MIToken::MachineBasicBlockLabel) && IsAfterNewline) ||
374 Token.isErrorOrEOF())
376 else if (Token.is(MIToken::MachineBasicBlockLabel))
377 return error("basic block definition should be located at the start of "
379 else if (consumeIfPresent(MIToken::Newline)) {
380 IsAfterNewline = true;
383 IsAfterNewline = false;
384 if (Token.is(MIToken::lbrace))
386 if (Token.is(MIToken::rbrace)) {
388 return error("extraneous closing brace ('}')");
393 // Verify that we closed all of the '{' at the end of a file or a block.
394 if (!Token.isError() && BraceDepth)
395 return error("expected '}'"); // FIXME: Report a note that shows '{'.
396 } while (!Token.isErrorOrEOF());
397 return Token.isError();
400 bool MIParser::parseBasicBlockLiveins(MachineBasicBlock &MBB) {
401 assert(Token.is(MIToken::kw_liveins));
403 if (expectAndConsume(MIToken::colon))
405 if (Token.isNewlineOrEOF()) // Allow an empty list of liveins.
408 if (Token.isNot(MIToken::NamedRegister))
409 return error("expected a named register");
411 if (parseRegister(Reg))
415 } while (consumeIfPresent(MIToken::comma));
419 bool MIParser::parseBasicBlockSuccessors(MachineBasicBlock &MBB) {
420 assert(Token.is(MIToken::kw_successors));
422 if (expectAndConsume(MIToken::colon))
424 if (Token.isNewlineOrEOF()) // Allow an empty list of successors.
427 if (Token.isNot(MIToken::MachineBasicBlock))
428 return error("expected a machine basic block reference");
429 MachineBasicBlock *SuccMBB = nullptr;
430 if (parseMBBReference(SuccMBB))
434 if (consumeIfPresent(MIToken::lparen)) {
435 if (Token.isNot(MIToken::IntegerLiteral))
436 return error("expected an integer literal after '('");
437 if (getUnsigned(Weight))
440 if (expectAndConsume(MIToken::rparen))
443 MBB.addSuccessor(SuccMBB, Weight);
444 } while (consumeIfPresent(MIToken::comma));
448 bool MIParser::parseBasicBlock(MachineBasicBlock &MBB) {
449 // Skip the definition.
450 assert(Token.is(MIToken::MachineBasicBlockLabel));
452 if (consumeIfPresent(MIToken::lparen)) {
453 while (Token.isNot(MIToken::rparen) && !Token.isErrorOrEOF())
455 consumeIfPresent(MIToken::rparen);
457 consumeIfPresent(MIToken::colon);
459 // Parse the liveins and successors.
460 // N.B: Multiple lists of successors and liveins are allowed and they're
467 // liveins: %edi, %esi
469 if (Token.is(MIToken::kw_successors)) {
470 if (parseBasicBlockSuccessors(MBB))
472 } else if (Token.is(MIToken::kw_liveins)) {
473 if (parseBasicBlockLiveins(MBB))
475 } else if (consumeIfPresent(MIToken::Newline)) {
479 if (!Token.isNewlineOrEOF())
480 return error("expected line break at the end of a list");
484 // Parse the instructions.
485 bool IsInBundle = false;
486 MachineInstr *PrevMI = nullptr;
488 if (Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof))
490 else if (consumeIfPresent(MIToken::Newline))
492 if (consumeIfPresent(MIToken::rbrace)) {
493 // The first parsing pass should verify that all closing '}' have an
499 MachineInstr *MI = nullptr;
502 MBB.insert(MBB.end(), MI);
504 PrevMI->setFlag(MachineInstr::BundledSucc);
505 MI->setFlag(MachineInstr::BundledPred);
508 if (Token.is(MIToken::lbrace)) {
510 return error("nested instruction bundles are not allowed");
512 // This instruction is the start of the bundle.
513 MI->setFlag(MachineInstr::BundledSucc);
515 if (!Token.is(MIToken::Newline))
516 // The next instruction can be on the same line.
519 assert(Token.isNewlineOrEOF() && "MI is not fully parsed");
525 bool MIParser::parseBasicBlocks() {
527 // Skip until the first machine basic block.
528 while (Token.is(MIToken::Newline))
530 if (Token.isErrorOrEOF())
531 return Token.isError();
532 // The first parsing pass should have verified that this token is a MBB label
533 // in the 'parseBasicBlockDefinitions' method.
534 assert(Token.is(MIToken::MachineBasicBlockLabel));
536 MachineBasicBlock *MBB = nullptr;
537 if (parseMBBReference(MBB))
539 if (parseBasicBlock(*MBB))
541 // The method 'parseBasicBlock' should parse the whole block until the next
542 // block or the end of file.
543 assert(Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof));
544 } while (Token.isNot(MIToken::Eof));
548 bool MIParser::parse(MachineInstr *&MI) {
549 // Parse any register operands before '='
550 MachineOperand MO = MachineOperand::CreateImm(0);
551 SmallVector<MachineOperandWithLocation, 8> Operands;
552 while (Token.isRegister() || Token.isRegisterFlag()) {
553 auto Loc = Token.location();
554 if (parseRegisterOperand(MO, /*IsDef=*/true))
556 Operands.push_back(MachineOperandWithLocation(MO, Loc, Token.location()));
557 if (Token.isNot(MIToken::comma))
561 if (!Operands.empty() && expectAndConsume(MIToken::equal))
564 unsigned OpCode, Flags = 0;
565 if (Token.isError() || parseInstruction(OpCode, Flags))
568 // Parse the remaining machine operands.
569 while (!Token.isNewlineOrEOF() && Token.isNot(MIToken::kw_debug_location) &&
570 Token.isNot(MIToken::coloncolon) && Token.isNot(MIToken::lbrace)) {
571 auto Loc = Token.location();
572 if (parseMachineOperandAndTargetFlags(MO))
574 Operands.push_back(MachineOperandWithLocation(MO, Loc, Token.location()));
575 if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
576 Token.is(MIToken::lbrace))
578 if (Token.isNot(MIToken::comma))
579 return error("expected ',' before the next machine operand");
583 DebugLoc DebugLocation;
584 if (Token.is(MIToken::kw_debug_location)) {
586 if (Token.isNot(MIToken::exclaim))
587 return error("expected a metadata node after 'debug-location'");
588 MDNode *Node = nullptr;
589 if (parseMDNode(Node))
591 DebugLocation = DebugLoc(Node);
594 // Parse the machine memory operands.
595 SmallVector<MachineMemOperand *, 2> MemOperands;
596 if (Token.is(MIToken::coloncolon)) {
598 while (!Token.isNewlineOrEOF()) {
599 MachineMemOperand *MemOp = nullptr;
600 if (parseMachineMemoryOperand(MemOp))
602 MemOperands.push_back(MemOp);
603 if (Token.isNewlineOrEOF())
605 if (Token.isNot(MIToken::comma))
606 return error("expected ',' before the next machine memory operand");
611 const auto &MCID = MF.getSubtarget().getInstrInfo()->get(OpCode);
612 if (!MCID.isVariadic()) {
613 // FIXME: Move the implicit operand verification to the machine verifier.
614 if (verifyImplicitOperands(Operands, MCID))
618 // TODO: Check for extraneous machine operands.
619 MI = MF.CreateMachineInstr(MCID, DebugLocation, /*NoImplicit=*/true);
621 for (const auto &Operand : Operands)
622 MI->addOperand(MF, Operand.Operand);
623 if (MemOperands.empty())
625 MachineInstr::mmo_iterator MemRefs =
626 MF.allocateMemRefsArray(MemOperands.size());
627 std::copy(MemOperands.begin(), MemOperands.end(), MemRefs);
628 MI->setMemRefs(MemRefs, MemRefs + MemOperands.size());
632 bool MIParser::parseStandaloneMBB(MachineBasicBlock *&MBB) {
634 if (Token.isNot(MIToken::MachineBasicBlock))
635 return error("expected a machine basic block reference");
636 if (parseMBBReference(MBB))
639 if (Token.isNot(MIToken::Eof))
641 "expected end of string after the machine basic block reference");
645 bool MIParser::parseStandaloneNamedRegister(unsigned &Reg) {
647 if (Token.isNot(MIToken::NamedRegister))
648 return error("expected a named register");
649 if (parseRegister(Reg))
652 if (Token.isNot(MIToken::Eof))
653 return error("expected end of string after the register reference");
657 bool MIParser::parseStandaloneVirtualRegister(unsigned &Reg) {
659 if (Token.isNot(MIToken::VirtualRegister))
660 return error("expected a virtual register");
661 if (parseRegister(Reg))
664 if (Token.isNot(MIToken::Eof))
665 return error("expected end of string after the register reference");
669 bool MIParser::parseStandaloneStackObject(int &FI) {
671 if (Token.isNot(MIToken::StackObject))
672 return error("expected a stack object");
673 if (parseStackFrameIndex(FI))
675 if (Token.isNot(MIToken::Eof))
676 return error("expected end of string after the stack object reference");
680 static const char *printImplicitRegisterFlag(const MachineOperand &MO) {
681 assert(MO.isImplicit());
682 return MO.isDef() ? "implicit-def" : "implicit";
685 static std::string getRegisterName(const TargetRegisterInfo *TRI,
687 assert(TargetRegisterInfo::isPhysicalRegister(Reg) && "expected phys reg");
688 return StringRef(TRI->getName(Reg)).lower();
691 bool MIParser::verifyImplicitOperands(
692 ArrayRef<MachineOperandWithLocation> Operands, const MCInstrDesc &MCID) {
694 // We can't verify call instructions as they can contain arbitrary implicit
695 // register and register mask operands.
698 // Gather all the expected implicit operands.
699 SmallVector<MachineOperand, 4> ImplicitOperands;
700 if (MCID.ImplicitDefs)
701 for (const uint16_t *ImpDefs = MCID.getImplicitDefs(); *ImpDefs; ++ImpDefs)
702 ImplicitOperands.push_back(
703 MachineOperand::CreateReg(*ImpDefs, true, true));
704 if (MCID.ImplicitUses)
705 for (const uint16_t *ImpUses = MCID.getImplicitUses(); *ImpUses; ++ImpUses)
706 ImplicitOperands.push_back(
707 MachineOperand::CreateReg(*ImpUses, false, true));
709 const auto *TRI = MF.getSubtarget().getRegisterInfo();
710 assert(TRI && "Expected target register info");
711 size_t I = ImplicitOperands.size(), J = Operands.size();
716 const auto &ImplicitOperand = ImplicitOperands[I];
717 const auto &Operand = Operands[J].Operand;
718 if (ImplicitOperand.isIdenticalTo(Operand))
720 if (Operand.isReg() && Operand.isImplicit()) {
721 // Check if this implicit register is a subregister of an explicit
723 bool IsImplicitSubRegister = false;
724 for (size_t K = 0, E = Operands.size(); K < E; ++K) {
725 const auto &Op = Operands[K].Operand;
726 if (Op.isReg() && !Op.isImplicit() &&
727 TRI->isSubRegister(Op.getReg(), Operand.getReg())) {
728 IsImplicitSubRegister = true;
732 if (IsImplicitSubRegister)
734 return error(Operands[J].Begin,
735 Twine("expected an implicit register operand '") +
736 printImplicitRegisterFlag(ImplicitOperand) + " %" +
737 getRegisterName(TRI, ImplicitOperand.getReg()) + "'");
740 // TODO: Fix source location when Operands[J].end is right before '=', i.e:
741 // insead of reporting an error at this location:
744 // report the error at the following location:
747 return error(J < Operands.size() ? Operands[J].End : Token.location(),
748 Twine("missing implicit register operand '") +
749 printImplicitRegisterFlag(ImplicitOperands[I]) + " %" +
750 getRegisterName(TRI, ImplicitOperands[I].getReg()) + "'");
755 bool MIParser::parseInstruction(unsigned &OpCode, unsigned &Flags) {
756 if (Token.is(MIToken::kw_frame_setup)) {
757 Flags |= MachineInstr::FrameSetup;
760 if (Token.isNot(MIToken::Identifier))
761 return error("expected a machine instruction");
762 StringRef InstrName = Token.stringValue();
763 if (parseInstrName(InstrName, OpCode))
764 return error(Twine("unknown machine instruction name '") + InstrName + "'");
769 bool MIParser::parseRegister(unsigned &Reg) {
770 switch (Token.kind()) {
771 case MIToken::underscore:
774 case MIToken::NamedRegister: {
775 StringRef Name = Token.stringValue();
776 if (getRegisterByName(Name, Reg))
777 return error(Twine("unknown register name '") + Name + "'");
780 case MIToken::VirtualRegister: {
784 const auto RegInfo = PFS.VirtualRegisterSlots.find(ID);
785 if (RegInfo == PFS.VirtualRegisterSlots.end())
786 return error(Twine("use of undefined virtual register '%") + Twine(ID) +
788 Reg = RegInfo->second;
791 // TODO: Parse other register kinds.
793 llvm_unreachable("The current token should be a register");
798 bool MIParser::parseRegisterFlag(unsigned &Flags) {
799 const unsigned OldFlags = Flags;
800 switch (Token.kind()) {
801 case MIToken::kw_implicit:
802 Flags |= RegState::Implicit;
804 case MIToken::kw_implicit_define:
805 Flags |= RegState::ImplicitDefine;
807 case MIToken::kw_dead:
808 Flags |= RegState::Dead;
810 case MIToken::kw_killed:
811 Flags |= RegState::Kill;
813 case MIToken::kw_undef:
814 Flags |= RegState::Undef;
816 case MIToken::kw_internal:
817 Flags |= RegState::InternalRead;
819 case MIToken::kw_early_clobber:
820 Flags |= RegState::EarlyClobber;
822 case MIToken::kw_debug_use:
823 Flags |= RegState::Debug;
826 llvm_unreachable("The current token should be a register flag");
828 if (OldFlags == Flags)
829 // We know that the same flag is specified more than once when the flags
831 return error("duplicate '" + Token.stringValue() + "' register flag");
836 bool MIParser::parseSubRegisterIndex(unsigned &SubReg) {
837 assert(Token.is(MIToken::colon));
839 if (Token.isNot(MIToken::Identifier))
840 return error("expected a subregister index after ':'");
841 auto Name = Token.stringValue();
842 SubReg = getSubRegIndex(Name);
844 return error(Twine("use of unknown subregister index '") + Name + "'");
849 bool MIParser::parseRegisterOperand(MachineOperand &Dest, bool IsDef) {
851 unsigned Flags = IsDef ? RegState::Define : 0;
852 while (Token.isRegisterFlag()) {
853 if (parseRegisterFlag(Flags))
856 if (!Token.isRegister())
857 return error("expected a register after register flags");
858 if (parseRegister(Reg))
862 if (Token.is(MIToken::colon)) {
863 if (parseSubRegisterIndex(SubReg))
866 Dest = MachineOperand::CreateReg(
867 Reg, Flags & RegState::Define, Flags & RegState::Implicit,
868 Flags & RegState::Kill, Flags & RegState::Dead, Flags & RegState::Undef,
869 Flags & RegState::EarlyClobber, SubReg, Flags & RegState::Debug,
870 Flags & RegState::InternalRead);
874 bool MIParser::parseImmediateOperand(MachineOperand &Dest) {
875 assert(Token.is(MIToken::IntegerLiteral));
876 const APSInt &Int = Token.integerValue();
877 if (Int.getMinSignedBits() > 64)
878 return error("integer literal is too large to be an immediate operand");
879 Dest = MachineOperand::CreateImm(Int.getExtValue());
884 bool MIParser::parseIRConstant(StringRef::iterator Loc, const Constant *&C) {
885 auto Source = StringRef(Loc, Token.range().end() - Loc).str();
888 C = parseConstantValue(Source.c_str(), Err, *MF.getFunction()->getParent());
890 return error(Loc + Err.getColumnNo(), Err.getMessage());
894 bool MIParser::parseTypedImmediateOperand(MachineOperand &Dest) {
895 assert(Token.is(MIToken::IntegerType));
896 auto Loc = Token.location();
898 if (Token.isNot(MIToken::IntegerLiteral))
899 return error("expected an integer literal");
900 const Constant *C = nullptr;
901 if (parseIRConstant(Loc, C))
903 Dest = MachineOperand::CreateCImm(cast<ConstantInt>(C));
907 bool MIParser::parseFPImmediateOperand(MachineOperand &Dest) {
908 auto Loc = Token.location();
910 if (Token.isNot(MIToken::FloatingPointLiteral))
911 return error("expected a floating point literal");
912 const Constant *C = nullptr;
913 if (parseIRConstant(Loc, C))
915 Dest = MachineOperand::CreateFPImm(cast<ConstantFP>(C));
919 bool MIParser::getUnsigned(unsigned &Result) {
920 assert(Token.hasIntegerValue() && "Expected a token with an integer value");
921 const uint64_t Limit = uint64_t(std::numeric_limits<unsigned>::max()) + 1;
922 uint64_t Val64 = Token.integerValue().getLimitedValue(Limit);
924 return error("expected 32-bit integer (too large)");
929 bool MIParser::parseMBBReference(MachineBasicBlock *&MBB) {
930 assert(Token.is(MIToken::MachineBasicBlock) ||
931 Token.is(MIToken::MachineBasicBlockLabel));
933 if (getUnsigned(Number))
935 auto MBBInfo = PFS.MBBSlots.find(Number);
936 if (MBBInfo == PFS.MBBSlots.end())
937 return error(Twine("use of undefined machine basic block #") +
939 MBB = MBBInfo->second;
940 if (!Token.stringValue().empty() && Token.stringValue() != MBB->getName())
941 return error(Twine("the name of machine basic block #") + Twine(Number) +
942 " isn't '" + Token.stringValue() + "'");
946 bool MIParser::parseMBBOperand(MachineOperand &Dest) {
947 MachineBasicBlock *MBB;
948 if (parseMBBReference(MBB))
950 Dest = MachineOperand::CreateMBB(MBB);
955 bool MIParser::parseStackFrameIndex(int &FI) {
956 assert(Token.is(MIToken::StackObject));
960 auto ObjectInfo = PFS.StackObjectSlots.find(ID);
961 if (ObjectInfo == PFS.StackObjectSlots.end())
962 return error(Twine("use of undefined stack object '%stack.") + Twine(ID) +
965 if (const auto *Alloca =
966 MF.getFrameInfo()->getObjectAllocation(ObjectInfo->second))
967 Name = Alloca->getName();
968 if (!Token.stringValue().empty() && Token.stringValue() != Name)
969 return error(Twine("the name of the stack object '%stack.") + Twine(ID) +
970 "' isn't '" + Token.stringValue() + "'");
972 FI = ObjectInfo->second;
976 bool MIParser::parseStackObjectOperand(MachineOperand &Dest) {
978 if (parseStackFrameIndex(FI))
980 Dest = MachineOperand::CreateFI(FI);
984 bool MIParser::parseFixedStackFrameIndex(int &FI) {
985 assert(Token.is(MIToken::FixedStackObject));
989 auto ObjectInfo = PFS.FixedStackObjectSlots.find(ID);
990 if (ObjectInfo == PFS.FixedStackObjectSlots.end())
991 return error(Twine("use of undefined fixed stack object '%fixed-stack.") +
994 FI = ObjectInfo->second;
998 bool MIParser::parseFixedStackObjectOperand(MachineOperand &Dest) {
1000 if (parseFixedStackFrameIndex(FI))
1002 Dest = MachineOperand::CreateFI(FI);
1006 bool MIParser::parseGlobalValue(GlobalValue *&GV) {
1007 switch (Token.kind()) {
1008 case MIToken::NamedGlobalValue: {
1009 const Module *M = MF.getFunction()->getParent();
1010 GV = M->getNamedValue(Token.stringValue());
1012 return error(Twine("use of undefined global value '") + Token.range() +
1016 case MIToken::GlobalValue: {
1018 if (getUnsigned(GVIdx))
1020 if (GVIdx >= IRSlots.GlobalValues.size())
1021 return error(Twine("use of undefined global value '@") + Twine(GVIdx) +
1023 GV = IRSlots.GlobalValues[GVIdx];
1027 llvm_unreachable("The current token should be a global value");
1032 bool MIParser::parseGlobalAddressOperand(MachineOperand &Dest) {
1033 GlobalValue *GV = nullptr;
1034 if (parseGlobalValue(GV))
1037 Dest = MachineOperand::CreateGA(GV, /*Offset=*/0);
1038 if (parseOperandsOffset(Dest))
1043 bool MIParser::parseConstantPoolIndexOperand(MachineOperand &Dest) {
1044 assert(Token.is(MIToken::ConstantPoolItem));
1046 if (getUnsigned(ID))
1048 auto ConstantInfo = PFS.ConstantPoolSlots.find(ID);
1049 if (ConstantInfo == PFS.ConstantPoolSlots.end())
1050 return error("use of undefined constant '%const." + Twine(ID) + "'");
1052 Dest = MachineOperand::CreateCPI(ID, /*Offset=*/0);
1053 if (parseOperandsOffset(Dest))
1058 bool MIParser::parseJumpTableIndexOperand(MachineOperand &Dest) {
1059 assert(Token.is(MIToken::JumpTableIndex));
1061 if (getUnsigned(ID))
1063 auto JumpTableEntryInfo = PFS.JumpTableSlots.find(ID);
1064 if (JumpTableEntryInfo == PFS.JumpTableSlots.end())
1065 return error("use of undefined jump table '%jump-table." + Twine(ID) + "'");
1067 Dest = MachineOperand::CreateJTI(JumpTableEntryInfo->second);
1071 bool MIParser::parseExternalSymbolOperand(MachineOperand &Dest) {
1072 assert(Token.is(MIToken::ExternalSymbol));
1073 const char *Symbol = MF.createExternalSymbolName(Token.stringValue());
1075 Dest = MachineOperand::CreateES(Symbol);
1076 if (parseOperandsOffset(Dest))
1081 bool MIParser::parseMDNode(MDNode *&Node) {
1082 assert(Token.is(MIToken::exclaim));
1083 auto Loc = Token.location();
1085 if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
1086 return error("expected metadata id after '!'");
1088 if (getUnsigned(ID))
1090 auto NodeInfo = IRSlots.MetadataNodes.find(ID);
1091 if (NodeInfo == IRSlots.MetadataNodes.end())
1092 return error(Loc, "use of undefined metadata '!" + Twine(ID) + "'");
1094 Node = NodeInfo->second.get();
1098 bool MIParser::parseMetadataOperand(MachineOperand &Dest) {
1099 MDNode *Node = nullptr;
1100 if (parseMDNode(Node))
1102 Dest = MachineOperand::CreateMetadata(Node);
1106 bool MIParser::parseCFIOffset(int &Offset) {
1107 if (Token.isNot(MIToken::IntegerLiteral))
1108 return error("expected a cfi offset");
1109 if (Token.integerValue().getMinSignedBits() > 32)
1110 return error("expected a 32 bit integer (the cfi offset is too large)");
1111 Offset = (int)Token.integerValue().getExtValue();
1116 bool MIParser::parseCFIRegister(unsigned &Reg) {
1117 if (Token.isNot(MIToken::NamedRegister))
1118 return error("expected a cfi register");
1120 if (parseRegister(LLVMReg))
1122 const auto *TRI = MF.getSubtarget().getRegisterInfo();
1123 assert(TRI && "Expected target register info");
1124 int DwarfReg = TRI->getDwarfRegNum(LLVMReg, true);
1126 return error("invalid DWARF register");
1127 Reg = (unsigned)DwarfReg;
1132 bool MIParser::parseCFIOperand(MachineOperand &Dest) {
1133 auto Kind = Token.kind();
1135 auto &MMI = MF.getMMI();
1140 case MIToken::kw_cfi_same_value:
1141 if (parseCFIRegister(Reg))
1144 MMI.addFrameInst(MCCFIInstruction::createSameValue(nullptr, Reg));
1146 case MIToken::kw_cfi_offset:
1147 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1148 parseCFIOffset(Offset))
1151 MMI.addFrameInst(MCCFIInstruction::createOffset(nullptr, Reg, Offset));
1153 case MIToken::kw_cfi_def_cfa_register:
1154 if (parseCFIRegister(Reg))
1157 MMI.addFrameInst(MCCFIInstruction::createDefCfaRegister(nullptr, Reg));
1159 case MIToken::kw_cfi_def_cfa_offset:
1160 if (parseCFIOffset(Offset))
1162 // NB: MCCFIInstruction::createDefCfaOffset negates the offset.
1163 CFIIndex = MMI.addFrameInst(
1164 MCCFIInstruction::createDefCfaOffset(nullptr, -Offset));
1166 case MIToken::kw_cfi_def_cfa:
1167 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1168 parseCFIOffset(Offset))
1170 // NB: MCCFIInstruction::createDefCfa negates the offset.
1172 MMI.addFrameInst(MCCFIInstruction::createDefCfa(nullptr, Reg, -Offset));
1175 // TODO: Parse the other CFI operands.
1176 llvm_unreachable("The current token should be a cfi operand");
1178 Dest = MachineOperand::CreateCFIIndex(CFIIndex);
1182 bool MIParser::parseIRBlock(BasicBlock *&BB, const Function &F) {
1183 switch (Token.kind()) {
1184 case MIToken::NamedIRBlock: {
1185 BB = dyn_cast_or_null<BasicBlock>(
1186 F.getValueSymbolTable().lookup(Token.stringValue()));
1188 return error(Twine("use of undefined IR block '") + Token.range() + "'");
1191 case MIToken::IRBlock: {
1192 unsigned SlotNumber = 0;
1193 if (getUnsigned(SlotNumber))
1195 BB = const_cast<BasicBlock *>(getIRBlock(SlotNumber, F));
1197 return error(Twine("use of undefined IR block '%ir-block.") +
1198 Twine(SlotNumber) + "'");
1202 llvm_unreachable("The current token should be an IR block reference");
1207 bool MIParser::parseBlockAddressOperand(MachineOperand &Dest) {
1208 assert(Token.is(MIToken::kw_blockaddress));
1210 if (expectAndConsume(MIToken::lparen))
1212 if (Token.isNot(MIToken::GlobalValue) &&
1213 Token.isNot(MIToken::NamedGlobalValue))
1214 return error("expected a global value");
1215 GlobalValue *GV = nullptr;
1216 if (parseGlobalValue(GV))
1218 auto *F = dyn_cast<Function>(GV);
1220 return error("expected an IR function reference");
1222 if (expectAndConsume(MIToken::comma))
1224 BasicBlock *BB = nullptr;
1225 if (Token.isNot(MIToken::IRBlock) && Token.isNot(MIToken::NamedIRBlock))
1226 return error("expected an IR block reference");
1227 if (parseIRBlock(BB, *F))
1230 if (expectAndConsume(MIToken::rparen))
1232 Dest = MachineOperand::CreateBA(BlockAddress::get(F, BB), /*Offset=*/0);
1233 if (parseOperandsOffset(Dest))
1238 bool MIParser::parseTargetIndexOperand(MachineOperand &Dest) {
1239 assert(Token.is(MIToken::kw_target_index));
1241 if (expectAndConsume(MIToken::lparen))
1243 if (Token.isNot(MIToken::Identifier))
1244 return error("expected the name of the target index");
1246 if (getTargetIndex(Token.stringValue(), Index))
1247 return error("use of undefined target index '" + Token.stringValue() + "'");
1249 if (expectAndConsume(MIToken::rparen))
1251 Dest = MachineOperand::CreateTargetIndex(unsigned(Index), /*Offset=*/0);
1252 if (parseOperandsOffset(Dest))
1257 bool MIParser::parseLiveoutRegisterMaskOperand(MachineOperand &Dest) {
1258 assert(Token.is(MIToken::kw_liveout));
1259 const auto *TRI = MF.getSubtarget().getRegisterInfo();
1260 assert(TRI && "Expected target register info");
1261 uint32_t *Mask = MF.allocateRegisterMask(TRI->getNumRegs());
1263 if (expectAndConsume(MIToken::lparen))
1266 if (Token.isNot(MIToken::NamedRegister))
1267 return error("expected a named register");
1269 if (parseRegister(Reg))
1272 Mask[Reg / 32] |= 1U << (Reg % 32);
1273 // TODO: Report an error if the same register is used more than once.
1274 if (Token.isNot(MIToken::comma))
1278 if (expectAndConsume(MIToken::rparen))
1280 Dest = MachineOperand::CreateRegLiveOut(Mask);
1284 bool MIParser::parseMachineOperand(MachineOperand &Dest) {
1285 switch (Token.kind()) {
1286 case MIToken::kw_implicit:
1287 case MIToken::kw_implicit_define:
1288 case MIToken::kw_dead:
1289 case MIToken::kw_killed:
1290 case MIToken::kw_undef:
1291 case MIToken::kw_internal:
1292 case MIToken::kw_early_clobber:
1293 case MIToken::kw_debug_use:
1294 case MIToken::underscore:
1295 case MIToken::NamedRegister:
1296 case MIToken::VirtualRegister:
1297 return parseRegisterOperand(Dest);
1298 case MIToken::IntegerLiteral:
1299 return parseImmediateOperand(Dest);
1300 case MIToken::IntegerType:
1301 return parseTypedImmediateOperand(Dest);
1302 case MIToken::kw_half:
1303 case MIToken::kw_float:
1304 case MIToken::kw_double:
1305 case MIToken::kw_x86_fp80:
1306 case MIToken::kw_fp128:
1307 case MIToken::kw_ppc_fp128:
1308 return parseFPImmediateOperand(Dest);
1309 case MIToken::MachineBasicBlock:
1310 return parseMBBOperand(Dest);
1311 case MIToken::StackObject:
1312 return parseStackObjectOperand(Dest);
1313 case MIToken::FixedStackObject:
1314 return parseFixedStackObjectOperand(Dest);
1315 case MIToken::GlobalValue:
1316 case MIToken::NamedGlobalValue:
1317 return parseGlobalAddressOperand(Dest);
1318 case MIToken::ConstantPoolItem:
1319 return parseConstantPoolIndexOperand(Dest);
1320 case MIToken::JumpTableIndex:
1321 return parseJumpTableIndexOperand(Dest);
1322 case MIToken::ExternalSymbol:
1323 return parseExternalSymbolOperand(Dest);
1324 case MIToken::exclaim:
1325 return parseMetadataOperand(Dest);
1326 case MIToken::kw_cfi_same_value:
1327 case MIToken::kw_cfi_offset:
1328 case MIToken::kw_cfi_def_cfa_register:
1329 case MIToken::kw_cfi_def_cfa_offset:
1330 case MIToken::kw_cfi_def_cfa:
1331 return parseCFIOperand(Dest);
1332 case MIToken::kw_blockaddress:
1333 return parseBlockAddressOperand(Dest);
1334 case MIToken::kw_target_index:
1335 return parseTargetIndexOperand(Dest);
1336 case MIToken::kw_liveout:
1337 return parseLiveoutRegisterMaskOperand(Dest);
1338 case MIToken::Error:
1340 case MIToken::Identifier:
1341 if (const auto *RegMask = getRegMask(Token.stringValue())) {
1342 Dest = MachineOperand::CreateRegMask(RegMask);
1348 // TODO: parse the other machine operands.
1349 return error("expected a machine operand");
1354 bool MIParser::parseMachineOperandAndTargetFlags(MachineOperand &Dest) {
1356 bool HasTargetFlags = false;
1357 if (Token.is(MIToken::kw_target_flags)) {
1358 HasTargetFlags = true;
1360 if (expectAndConsume(MIToken::lparen))
1362 if (Token.isNot(MIToken::Identifier))
1363 return error("expected the name of the target flag");
1364 if (getDirectTargetFlag(Token.stringValue(), TF)) {
1365 if (getBitmaskTargetFlag(Token.stringValue(), TF))
1366 return error("use of undefined target flag '" + Token.stringValue() +
1370 while (Token.is(MIToken::comma)) {
1372 if (Token.isNot(MIToken::Identifier))
1373 return error("expected the name of the target flag");
1374 unsigned BitFlag = 0;
1375 if (getBitmaskTargetFlag(Token.stringValue(), BitFlag))
1376 return error("use of undefined target flag '" + Token.stringValue() +
1378 // TODO: Report an error when using a duplicate bit target flag.
1382 if (expectAndConsume(MIToken::rparen))
1385 auto Loc = Token.location();
1386 if (parseMachineOperand(Dest))
1388 if (!HasTargetFlags)
1391 return error(Loc, "register operands can't have target flags");
1392 Dest.setTargetFlags(TF);
1396 bool MIParser::parseOffset(int64_t &Offset) {
1397 if (Token.isNot(MIToken::plus) && Token.isNot(MIToken::minus))
1399 StringRef Sign = Token.range();
1400 bool IsNegative = Token.is(MIToken::minus);
1402 if (Token.isNot(MIToken::IntegerLiteral))
1403 return error("expected an integer literal after '" + Sign + "'");
1404 if (Token.integerValue().getMinSignedBits() > 64)
1405 return error("expected 64-bit integer (too large)");
1406 Offset = Token.integerValue().getExtValue();
1413 bool MIParser::parseAlignment(unsigned &Alignment) {
1414 assert(Token.is(MIToken::kw_align));
1416 if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
1417 return error("expected an integer literal after 'align'");
1418 if (getUnsigned(Alignment))
1424 bool MIParser::parseOperandsOffset(MachineOperand &Op) {
1426 if (parseOffset(Offset))
1428 Op.setOffset(Offset);
1432 bool MIParser::parseIRValue(Value *&V) {
1433 switch (Token.kind()) {
1434 case MIToken::NamedIRValue: {
1435 V = MF.getFunction()->getValueSymbolTable().lookup(Token.stringValue());
1437 V = MF.getFunction()->getParent()->getValueSymbolTable().lookup(
1438 Token.stringValue());
1440 return error(Twine("use of undefined IR value '") + Token.range() + "'");
1443 // TODO: Parse unnamed IR value references.
1445 llvm_unreachable("The current token should be an IR block reference");
1450 bool MIParser::getUint64(uint64_t &Result) {
1451 assert(Token.hasIntegerValue());
1452 if (Token.integerValue().getActiveBits() > 64)
1453 return error("expected 64-bit integer (too large)");
1454 Result = Token.integerValue().getZExtValue();
1458 bool MIParser::parseMemoryOperandFlag(unsigned &Flags) {
1459 const unsigned OldFlags = Flags;
1460 switch (Token.kind()) {
1461 case MIToken::kw_volatile:
1462 Flags |= MachineMemOperand::MOVolatile;
1464 case MIToken::kw_non_temporal:
1465 Flags |= MachineMemOperand::MONonTemporal;
1467 case MIToken::kw_invariant:
1468 Flags |= MachineMemOperand::MOInvariant;
1470 // TODO: parse the target specific memory operand flags.
1472 llvm_unreachable("The current token should be a memory operand flag");
1474 if (OldFlags == Flags)
1475 // We know that the same flag is specified more than once when the flags
1476 // weren't modified.
1477 return error("duplicate '" + Token.stringValue() + "' memory operand flag");
1482 bool MIParser::parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV) {
1483 switch (Token.kind()) {
1484 case MIToken::kw_stack:
1485 PSV = MF.getPSVManager().getStack();
1487 case MIToken::kw_got:
1488 PSV = MF.getPSVManager().getGOT();
1490 case MIToken::kw_jump_table:
1491 PSV = MF.getPSVManager().getJumpTable();
1493 case MIToken::kw_constant_pool:
1494 PSV = MF.getPSVManager().getConstantPool();
1496 case MIToken::FixedStackObject: {
1498 if (parseFixedStackFrameIndex(FI))
1500 PSV = MF.getPSVManager().getFixedStack(FI);
1501 // The token was already consumed, so use return here instead of break.
1504 case MIToken::GlobalValue:
1505 case MIToken::NamedGlobalValue: {
1506 GlobalValue *GV = nullptr;
1507 if (parseGlobalValue(GV))
1509 PSV = MF.getPSVManager().getGlobalValueCallEntry(GV);
1512 case MIToken::ExternalSymbol:
1513 PSV = MF.getPSVManager().getExternalSymbolCallEntry(
1514 MF.createExternalSymbolName(Token.stringValue()));
1517 llvm_unreachable("The current token should be pseudo source value");
1523 bool MIParser::parseMachinePointerInfo(MachinePointerInfo &Dest) {
1524 if (Token.is(MIToken::kw_constant_pool) || Token.is(MIToken::kw_stack) ||
1525 Token.is(MIToken::kw_got) || Token.is(MIToken::kw_jump_table) ||
1526 Token.is(MIToken::FixedStackObject) || Token.is(MIToken::GlobalValue) ||
1527 Token.is(MIToken::NamedGlobalValue) ||
1528 Token.is(MIToken::ExternalSymbol)) {
1529 const PseudoSourceValue *PSV = nullptr;
1530 if (parseMemoryPseudoSourceValue(PSV))
1533 if (parseOffset(Offset))
1535 Dest = MachinePointerInfo(PSV, Offset);
1538 if (Token.isNot(MIToken::NamedIRValue))
1539 return error("expected an IR value reference");
1541 if (parseIRValue(V))
1543 if (!V->getType()->isPointerTy())
1544 return error("expected a pointer IR value");
1547 if (parseOffset(Offset))
1549 Dest = MachinePointerInfo(V, Offset);
1553 bool MIParser::parseMachineMemoryOperand(MachineMemOperand *&Dest) {
1554 if (expectAndConsume(MIToken::lparen))
1557 while (Token.isMemoryOperandFlag()) {
1558 if (parseMemoryOperandFlag(Flags))
1561 if (Token.isNot(MIToken::Identifier) ||
1562 (Token.stringValue() != "load" && Token.stringValue() != "store"))
1563 return error("expected 'load' or 'store' memory operation");
1564 if (Token.stringValue() == "load")
1565 Flags |= MachineMemOperand::MOLoad;
1567 Flags |= MachineMemOperand::MOStore;
1570 if (Token.isNot(MIToken::IntegerLiteral))
1571 return error("expected the size integer literal after memory operation");
1573 if (getUint64(Size))
1577 const char *Word = Flags & MachineMemOperand::MOLoad ? "from" : "into";
1578 if (Token.isNot(MIToken::Identifier) || Token.stringValue() != Word)
1579 return error(Twine("expected '") + Word + "'");
1582 MachinePointerInfo Ptr = MachinePointerInfo();
1583 if (parseMachinePointerInfo(Ptr))
1585 unsigned BaseAlignment = Size;
1587 MDNode *Range = nullptr;
1588 while (consumeIfPresent(MIToken::comma)) {
1589 switch (Token.kind()) {
1590 case MIToken::kw_align:
1591 if (parseAlignment(BaseAlignment))
1594 case MIToken::md_tbaa:
1596 if (parseMDNode(AAInfo.TBAA))
1599 case MIToken::md_alias_scope:
1601 if (parseMDNode(AAInfo.Scope))
1604 case MIToken::md_noalias:
1606 if (parseMDNode(AAInfo.NoAlias))
1609 case MIToken::md_range:
1611 if (parseMDNode(Range))
1614 // TODO: Report an error on duplicate metadata nodes.
1616 return error("expected 'align' or '!tbaa' or '!alias.scope' or "
1617 "'!noalias' or '!range'");
1620 if (expectAndConsume(MIToken::rparen))
1623 MF.getMachineMemOperand(Ptr, Flags, Size, BaseAlignment, AAInfo, Range);
1627 void MIParser::initNames2InstrOpCodes() {
1628 if (!Names2InstrOpCodes.empty())
1630 const auto *TII = MF.getSubtarget().getInstrInfo();
1631 assert(TII && "Expected target instruction info");
1632 for (unsigned I = 0, E = TII->getNumOpcodes(); I < E; ++I)
1633 Names2InstrOpCodes.insert(std::make_pair(StringRef(TII->getName(I)), I));
1636 bool MIParser::parseInstrName(StringRef InstrName, unsigned &OpCode) {
1637 initNames2InstrOpCodes();
1638 auto InstrInfo = Names2InstrOpCodes.find(InstrName);
1639 if (InstrInfo == Names2InstrOpCodes.end())
1641 OpCode = InstrInfo->getValue();
1645 void MIParser::initNames2Regs() {
1646 if (!Names2Regs.empty())
1648 // The '%noreg' register is the register 0.
1649 Names2Regs.insert(std::make_pair("noreg", 0));
1650 const auto *TRI = MF.getSubtarget().getRegisterInfo();
1651 assert(TRI && "Expected target register info");
1652 for (unsigned I = 0, E = TRI->getNumRegs(); I < E; ++I) {
1654 Names2Regs.insert(std::make_pair(StringRef(TRI->getName(I)).lower(), I))
1657 assert(WasInserted && "Expected registers to be unique case-insensitively");
1661 bool MIParser::getRegisterByName(StringRef RegName, unsigned &Reg) {
1663 auto RegInfo = Names2Regs.find(RegName);
1664 if (RegInfo == Names2Regs.end())
1666 Reg = RegInfo->getValue();
1670 void MIParser::initNames2RegMasks() {
1671 if (!Names2RegMasks.empty())
1673 const auto *TRI = MF.getSubtarget().getRegisterInfo();
1674 assert(TRI && "Expected target register info");
1675 ArrayRef<const uint32_t *> RegMasks = TRI->getRegMasks();
1676 ArrayRef<const char *> RegMaskNames = TRI->getRegMaskNames();
1677 assert(RegMasks.size() == RegMaskNames.size());
1678 for (size_t I = 0, E = RegMasks.size(); I < E; ++I)
1679 Names2RegMasks.insert(
1680 std::make_pair(StringRef(RegMaskNames[I]).lower(), RegMasks[I]));
1683 const uint32_t *MIParser::getRegMask(StringRef Identifier) {
1684 initNames2RegMasks();
1685 auto RegMaskInfo = Names2RegMasks.find(Identifier);
1686 if (RegMaskInfo == Names2RegMasks.end())
1688 return RegMaskInfo->getValue();
1691 void MIParser::initNames2SubRegIndices() {
1692 if (!Names2SubRegIndices.empty())
1694 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
1695 for (unsigned I = 1, E = TRI->getNumSubRegIndices(); I < E; ++I)
1696 Names2SubRegIndices.insert(
1697 std::make_pair(StringRef(TRI->getSubRegIndexName(I)).lower(), I));
1700 unsigned MIParser::getSubRegIndex(StringRef Name) {
1701 initNames2SubRegIndices();
1702 auto SubRegInfo = Names2SubRegIndices.find(Name);
1703 if (SubRegInfo == Names2SubRegIndices.end())
1705 return SubRegInfo->getValue();
1708 static void initSlots2BasicBlocks(
1710 DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
1711 ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
1712 MST.incorporateFunction(F);
1713 for (auto &BB : F) {
1716 int Slot = MST.getLocalSlot(&BB);
1719 Slots2BasicBlocks.insert(std::make_pair(unsigned(Slot), &BB));
1723 static const BasicBlock *getIRBlockFromSlot(
1725 const DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
1726 auto BlockInfo = Slots2BasicBlocks.find(Slot);
1727 if (BlockInfo == Slots2BasicBlocks.end())
1729 return BlockInfo->second;
1732 const BasicBlock *MIParser::getIRBlock(unsigned Slot) {
1733 if (Slots2BasicBlocks.empty())
1734 initSlots2BasicBlocks(*MF.getFunction(), Slots2BasicBlocks);
1735 return getIRBlockFromSlot(Slot, Slots2BasicBlocks);
1738 const BasicBlock *MIParser::getIRBlock(unsigned Slot, const Function &F) {
1739 if (&F == MF.getFunction())
1740 return getIRBlock(Slot);
1741 DenseMap<unsigned, const BasicBlock *> CustomSlots2BasicBlocks;
1742 initSlots2BasicBlocks(F, CustomSlots2BasicBlocks);
1743 return getIRBlockFromSlot(Slot, CustomSlots2BasicBlocks);
1746 void MIParser::initNames2TargetIndices() {
1747 if (!Names2TargetIndices.empty())
1749 const auto *TII = MF.getSubtarget().getInstrInfo();
1750 assert(TII && "Expected target instruction info");
1751 auto Indices = TII->getSerializableTargetIndices();
1752 for (const auto &I : Indices)
1753 Names2TargetIndices.insert(std::make_pair(StringRef(I.second), I.first));
1756 bool MIParser::getTargetIndex(StringRef Name, int &Index) {
1757 initNames2TargetIndices();
1758 auto IndexInfo = Names2TargetIndices.find(Name);
1759 if (IndexInfo == Names2TargetIndices.end())
1761 Index = IndexInfo->second;
1765 void MIParser::initNames2DirectTargetFlags() {
1766 if (!Names2DirectTargetFlags.empty())
1768 const auto *TII = MF.getSubtarget().getInstrInfo();
1769 assert(TII && "Expected target instruction info");
1770 auto Flags = TII->getSerializableDirectMachineOperandTargetFlags();
1771 for (const auto &I : Flags)
1772 Names2DirectTargetFlags.insert(
1773 std::make_pair(StringRef(I.second), I.first));
1776 bool MIParser::getDirectTargetFlag(StringRef Name, unsigned &Flag) {
1777 initNames2DirectTargetFlags();
1778 auto FlagInfo = Names2DirectTargetFlags.find(Name);
1779 if (FlagInfo == Names2DirectTargetFlags.end())
1781 Flag = FlagInfo->second;
1785 void MIParser::initNames2BitmaskTargetFlags() {
1786 if (!Names2BitmaskTargetFlags.empty())
1788 const auto *TII = MF.getSubtarget().getInstrInfo();
1789 assert(TII && "Expected target instruction info");
1790 auto Flags = TII->getSerializableBitmaskMachineOperandTargetFlags();
1791 for (const auto &I : Flags)
1792 Names2BitmaskTargetFlags.insert(
1793 std::make_pair(StringRef(I.second), I.first));
1796 bool MIParser::getBitmaskTargetFlag(StringRef Name, unsigned &Flag) {
1797 initNames2BitmaskTargetFlags();
1798 auto FlagInfo = Names2BitmaskTargetFlags.find(Name);
1799 if (FlagInfo == Names2BitmaskTargetFlags.end())
1801 Flag = FlagInfo->second;
1805 bool llvm::parseMachineBasicBlockDefinitions(MachineFunction &MF, StringRef Src,
1806 PerFunctionMIParsingState &PFS,
1807 const SlotMapping &IRSlots,
1808 SMDiagnostic &Error) {
1810 SM.AddNewSourceBuffer(
1811 MemoryBuffer::getMemBuffer(Src, "", /*RequiresNullTerminator=*/false),
1813 return MIParser(SM, MF, Error, Src, PFS, IRSlots)
1814 .parseBasicBlockDefinitions(PFS.MBBSlots);
1817 bool llvm::parseMachineInstructions(MachineFunction &MF, StringRef Src,
1818 const PerFunctionMIParsingState &PFS,
1819 const SlotMapping &IRSlots,
1820 SMDiagnostic &Error) {
1822 SM.AddNewSourceBuffer(
1823 MemoryBuffer::getMemBuffer(Src, "", /*RequiresNullTerminator=*/false),
1825 return MIParser(SM, MF, Error, Src, PFS, IRSlots).parseBasicBlocks();
1828 bool llvm::parseMBBReference(MachineBasicBlock *&MBB, SourceMgr &SM,
1829 MachineFunction &MF, StringRef Src,
1830 const PerFunctionMIParsingState &PFS,
1831 const SlotMapping &IRSlots, SMDiagnostic &Error) {
1832 return MIParser(SM, MF, Error, Src, PFS, IRSlots).parseStandaloneMBB(MBB);
1835 bool llvm::parseNamedRegisterReference(unsigned &Reg, SourceMgr &SM,
1836 MachineFunction &MF, StringRef Src,
1837 const PerFunctionMIParsingState &PFS,
1838 const SlotMapping &IRSlots,
1839 SMDiagnostic &Error) {
1840 return MIParser(SM, MF, Error, Src, PFS, IRSlots)
1841 .parseStandaloneNamedRegister(Reg);
1844 bool llvm::parseVirtualRegisterReference(unsigned &Reg, SourceMgr &SM,
1845 MachineFunction &MF, StringRef Src,
1846 const PerFunctionMIParsingState &PFS,
1847 const SlotMapping &IRSlots,
1848 SMDiagnostic &Error) {
1849 return MIParser(SM, MF, Error, Src, PFS, IRSlots)
1850 .parseStandaloneVirtualRegister(Reg);
1853 bool llvm::parseStackObjectReference(int &FI, SourceMgr &SM,
1854 MachineFunction &MF, StringRef Src,
1855 const PerFunctionMIParsingState &PFS,
1856 const SlotMapping &IRSlots,
1857 SMDiagnostic &Error) {
1858 return MIParser(SM, MF, Error, Src, PFS, IRSlots)
1859 .parseStandaloneStackObject(FI);