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/APInt.h"
17 #include "llvm/ADT/APSInt.h"
18 #include "llvm/ADT/ArrayRef.h"
19 #include "llvm/ADT/DenseMap.h"
20 #include "llvm/ADT/None.h"
21 #include "llvm/ADT/Optional.h"
22 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/ADT/StringMap.h"
24 #include "llvm/ADT/StringRef.h"
25 #include "llvm/ADT/StringSwitch.h"
26 #include "llvm/ADT/Twine.h"
27 #include "llvm/AsmParser/Parser.h"
28 #include "llvm/AsmParser/SlotMapping.h"
29 #include "llvm/CodeGen/MIRPrinter.h"
30 #include "llvm/CodeGen/MachineBasicBlock.h"
31 #include "llvm/CodeGen/MachineFrameInfo.h"
32 #include "llvm/CodeGen/MachineFunction.h"
33 #include "llvm/CodeGen/MachineInstr.h"
34 #include "llvm/CodeGen/MachineInstrBuilder.h"
35 #include "llvm/CodeGen/MachineMemOperand.h"
36 #include "llvm/CodeGen/MachineOperand.h"
37 #include "llvm/CodeGen/MachineRegisterInfo.h"
38 #include "llvm/CodeGen/TargetInstrInfo.h"
39 #include "llvm/CodeGen/TargetRegisterInfo.h"
40 #include "llvm/CodeGen/TargetSubtargetInfo.h"
41 #include "llvm/IR/BasicBlock.h"
42 #include "llvm/IR/Constants.h"
43 #include "llvm/IR/DataLayout.h"
44 #include "llvm/IR/DebugInfoMetadata.h"
45 #include "llvm/IR/DebugLoc.h"
46 #include "llvm/IR/Function.h"
47 #include "llvm/IR/InstrTypes.h"
48 #include "llvm/IR/Instructions.h"
49 #include "llvm/IR/Intrinsics.h"
50 #include "llvm/IR/Metadata.h"
51 #include "llvm/IR/Module.h"
52 #include "llvm/IR/ModuleSlotTracker.h"
53 #include "llvm/IR/Type.h"
54 #include "llvm/IR/Value.h"
55 #include "llvm/IR/ValueSymbolTable.h"
56 #include "llvm/MC/LaneBitmask.h"
57 #include "llvm/MC/MCDwarf.h"
58 #include "llvm/MC/MCInstrDesc.h"
59 #include "llvm/MC/MCRegisterInfo.h"
60 #include "llvm/Support/AtomicOrdering.h"
61 #include "llvm/Support/BranchProbability.h"
62 #include "llvm/Support/Casting.h"
63 #include "llvm/Support/ErrorHandling.h"
64 #include "llvm/Support/LowLevelTypeImpl.h"
65 #include "llvm/Support/MemoryBuffer.h"
66 #include "llvm/Support/SMLoc.h"
67 #include "llvm/Support/SourceMgr.h"
68 #include "llvm/Support/raw_ostream.h"
69 #include "llvm/Target/TargetIntrinsicInfo.h"
70 #include "llvm/Target/TargetMachine.h"
82 PerFunctionMIParsingState::PerFunctionMIParsingState(MachineFunction &MF,
83 SourceMgr &SM, const SlotMapping &IRSlots,
84 const Name2RegClassMap &Names2RegClasses,
85 const Name2RegBankMap &Names2RegBanks)
86 : MF(MF), SM(&SM), IRSlots(IRSlots), Names2RegClasses(Names2RegClasses),
87 Names2RegBanks(Names2RegBanks) {
90 VRegInfo &PerFunctionMIParsingState::getVRegInfo(unsigned Num) {
91 auto I = VRegInfos.insert(std::make_pair(Num, nullptr));
93 MachineRegisterInfo &MRI = MF.getRegInfo();
94 VRegInfo *Info = new (Allocator) VRegInfo;
95 Info->VReg = MRI.createIncompleteVirtualRegister();
96 I.first->second = Info;
98 return *I.first->second;
103 /// A wrapper struct around the 'MachineOperand' struct that includes a source
104 /// range and other attributes.
105 struct ParsedMachineOperand {
106 MachineOperand Operand;
107 StringRef::iterator Begin;
108 StringRef::iterator End;
109 Optional<unsigned> TiedDefIdx;
111 ParsedMachineOperand(const MachineOperand &Operand, StringRef::iterator Begin,
112 StringRef::iterator End, Optional<unsigned> &TiedDefIdx)
113 : Operand(Operand), Begin(Begin), End(End), TiedDefIdx(TiedDefIdx) {
115 assert(Operand.isReg() && Operand.isUse() &&
116 "Only used register operands can be tied");
123 StringRef Source, CurrentSource;
125 PerFunctionMIParsingState &PFS;
126 /// Maps from instruction names to op codes.
127 StringMap<unsigned> Names2InstrOpCodes;
128 /// Maps from register names to registers.
129 StringMap<unsigned> Names2Regs;
130 /// Maps from register mask names to register masks.
131 StringMap<const uint32_t *> Names2RegMasks;
132 /// Maps from subregister names to subregister indices.
133 StringMap<unsigned> Names2SubRegIndices;
134 /// Maps from slot numbers to function's unnamed basic blocks.
135 DenseMap<unsigned, const BasicBlock *> Slots2BasicBlocks;
136 /// Maps from slot numbers to function's unnamed values.
137 DenseMap<unsigned, const Value *> Slots2Values;
138 /// Maps from target index names to target indices.
139 StringMap<int> Names2TargetIndices;
140 /// Maps from direct target flag names to the direct target flag values.
141 StringMap<unsigned> Names2DirectTargetFlags;
142 /// Maps from direct target flag names to the bitmask target flag values.
143 StringMap<unsigned> Names2BitmaskTargetFlags;
144 /// Maps from MMO target flag names to MMO target flag values.
145 StringMap<MachineMemOperand::Flags> Names2MMOTargetFlags;
148 MIParser(PerFunctionMIParsingState &PFS, SMDiagnostic &Error,
151 /// \p SkipChar gives the number of characters to skip before looking
152 /// for the next token.
153 void lex(unsigned SkipChar = 0);
155 /// Report an error at the current location with the given message.
157 /// This function always return true.
158 bool error(const Twine &Msg);
160 /// Report an error at the given location with the given message.
162 /// This function always return true.
163 bool error(StringRef::iterator Loc, const Twine &Msg);
166 parseBasicBlockDefinitions(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
167 bool parseBasicBlocks();
168 bool parse(MachineInstr *&MI);
169 bool parseStandaloneMBB(MachineBasicBlock *&MBB);
170 bool parseStandaloneNamedRegister(unsigned &Reg);
171 bool parseStandaloneVirtualRegister(VRegInfo *&Info);
172 bool parseStandaloneRegister(unsigned &Reg);
173 bool parseStandaloneStackObject(int &FI);
174 bool parseStandaloneMDNode(MDNode *&Node);
177 parseBasicBlockDefinition(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
178 bool parseBasicBlock(MachineBasicBlock &MBB,
179 MachineBasicBlock *&AddFalthroughFrom);
180 bool parseBasicBlockLiveins(MachineBasicBlock &MBB);
181 bool parseBasicBlockSuccessors(MachineBasicBlock &MBB);
183 bool parseNamedRegister(unsigned &Reg);
184 bool parseVirtualRegister(VRegInfo *&Info);
185 bool parseRegister(unsigned &Reg, VRegInfo *&VRegInfo);
186 bool parseRegisterFlag(unsigned &Flags);
187 bool parseRegisterClassOrBank(VRegInfo &RegInfo);
188 bool parseSubRegisterIndex(unsigned &SubReg);
189 bool parseRegisterTiedDefIndex(unsigned &TiedDefIdx);
190 bool parseRegisterOperand(MachineOperand &Dest,
191 Optional<unsigned> &TiedDefIdx, bool IsDef = false);
192 bool parseImmediateOperand(MachineOperand &Dest);
193 bool parseIRConstant(StringRef::iterator Loc, StringRef Source,
195 bool parseIRConstant(StringRef::iterator Loc, const Constant *&C);
196 bool parseLowLevelType(StringRef::iterator Loc, LLT &Ty);
197 bool parseTypedImmediateOperand(MachineOperand &Dest);
198 bool parseFPImmediateOperand(MachineOperand &Dest);
199 bool parseMBBReference(MachineBasicBlock *&MBB);
200 bool parseMBBOperand(MachineOperand &Dest);
201 bool parseStackFrameIndex(int &FI);
202 bool parseStackObjectOperand(MachineOperand &Dest);
203 bool parseFixedStackFrameIndex(int &FI);
204 bool parseFixedStackObjectOperand(MachineOperand &Dest);
205 bool parseGlobalValue(GlobalValue *&GV);
206 bool parseGlobalAddressOperand(MachineOperand &Dest);
207 bool parseConstantPoolIndexOperand(MachineOperand &Dest);
208 bool parseSubRegisterIndexOperand(MachineOperand &Dest);
209 bool parseJumpTableIndexOperand(MachineOperand &Dest);
210 bool parseExternalSymbolOperand(MachineOperand &Dest);
211 bool parseMDNode(MDNode *&Node);
212 bool parseDIExpression(MDNode *&Node);
213 bool parseMetadataOperand(MachineOperand &Dest);
214 bool parseCFIOffset(int &Offset);
215 bool parseCFIRegister(unsigned &Reg);
216 bool parseCFIEscapeValues(std::string& Values);
217 bool parseCFIOperand(MachineOperand &Dest);
218 bool parseIRBlock(BasicBlock *&BB, const Function &F);
219 bool parseBlockAddressOperand(MachineOperand &Dest);
220 bool parseIntrinsicOperand(MachineOperand &Dest);
221 bool parsePredicateOperand(MachineOperand &Dest);
222 bool parseTargetIndexOperand(MachineOperand &Dest);
223 bool parseCustomRegisterMaskOperand(MachineOperand &Dest);
224 bool parseLiveoutRegisterMaskOperand(MachineOperand &Dest);
225 bool parseMachineOperand(MachineOperand &Dest,
226 Optional<unsigned> &TiedDefIdx);
227 bool parseMachineOperandAndTargetFlags(MachineOperand &Dest,
228 Optional<unsigned> &TiedDefIdx);
229 bool parseOffset(int64_t &Offset);
230 bool parseAlignment(unsigned &Alignment);
231 bool parseOperandsOffset(MachineOperand &Op);
232 bool parseIRValue(const Value *&V);
233 bool parseMemoryOperandFlag(MachineMemOperand::Flags &Flags);
234 bool parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV);
235 bool parseMachinePointerInfo(MachinePointerInfo &Dest);
236 bool parseOptionalScope(LLVMContext &Context, SyncScope::ID &SSID);
237 bool parseOptionalAtomicOrdering(AtomicOrdering &Order);
238 bool parseMachineMemoryOperand(MachineMemOperand *&Dest);
241 /// Convert the integer literal in the current token into an unsigned integer.
243 /// Return true if an error occurred.
244 bool getUnsigned(unsigned &Result);
246 /// Convert the integer literal in the current token into an uint64.
248 /// Return true if an error occurred.
249 bool getUint64(uint64_t &Result);
251 /// Convert the hexadecimal literal in the current token into an unsigned
252 /// APInt with a minimum bitwidth required to represent the value.
254 /// Return true if the literal does not represent an integer value.
255 bool getHexUint(APInt &Result);
257 /// If the current token is of the given kind, consume it and return false.
258 /// Otherwise report an error and return true.
259 bool expectAndConsume(MIToken::TokenKind TokenKind);
261 /// If the current token is of the given kind, consume it and return true.
262 /// Otherwise return false.
263 bool consumeIfPresent(MIToken::TokenKind TokenKind);
265 void initNames2InstrOpCodes();
267 /// Try to convert an instruction name to an opcode. Return true if the
268 /// instruction name is invalid.
269 bool parseInstrName(StringRef InstrName, unsigned &OpCode);
271 bool parseInstruction(unsigned &OpCode, unsigned &Flags);
273 bool assignRegisterTies(MachineInstr &MI,
274 ArrayRef<ParsedMachineOperand> Operands);
276 bool verifyImplicitOperands(ArrayRef<ParsedMachineOperand> Operands,
277 const MCInstrDesc &MCID);
279 void initNames2Regs();
281 /// Try to convert a register name to a register number. Return true if the
282 /// register name is invalid.
283 bool getRegisterByName(StringRef RegName, unsigned &Reg);
285 void initNames2RegMasks();
287 /// Check if the given identifier is a name of a register mask.
289 /// Return null if the identifier isn't a register mask.
290 const uint32_t *getRegMask(StringRef Identifier);
292 void initNames2SubRegIndices();
294 /// Check if the given identifier is a name of a subregister index.
296 /// Return 0 if the name isn't a subregister index class.
297 unsigned getSubRegIndex(StringRef Name);
299 const BasicBlock *getIRBlock(unsigned Slot);
300 const BasicBlock *getIRBlock(unsigned Slot, const Function &F);
302 const Value *getIRValue(unsigned Slot);
304 void initNames2TargetIndices();
306 /// Try to convert a name of target index to the corresponding target index.
308 /// Return true if the name isn't a name of a target index.
309 bool getTargetIndex(StringRef Name, int &Index);
311 void initNames2DirectTargetFlags();
313 /// Try to convert a name of a direct target flag to the corresponding
316 /// Return true if the name isn't a name of a direct flag.
317 bool getDirectTargetFlag(StringRef Name, unsigned &Flag);
319 void initNames2BitmaskTargetFlags();
321 /// Try to convert a name of a bitmask target flag to the corresponding
324 /// Return true if the name isn't a name of a bitmask target flag.
325 bool getBitmaskTargetFlag(StringRef Name, unsigned &Flag);
327 void initNames2MMOTargetFlags();
329 /// Try to convert a name of a MachineMemOperand target flag to the
330 /// corresponding target flag.
332 /// Return true if the name isn't a name of a target MMO flag.
333 bool getMMOTargetFlag(StringRef Name, MachineMemOperand::Flags &Flag);
335 /// parseStringConstant
336 /// ::= StringConstant
337 bool parseStringConstant(std::string &Result);
340 } // end anonymous namespace
342 MIParser::MIParser(PerFunctionMIParsingState &PFS, SMDiagnostic &Error,
344 : MF(PFS.MF), Error(Error), Source(Source), CurrentSource(Source), PFS(PFS)
347 void MIParser::lex(unsigned SkipChar) {
348 CurrentSource = lexMIToken(
349 CurrentSource.data() + SkipChar, Token,
350 [this](StringRef::iterator Loc, const Twine &Msg) { error(Loc, Msg); });
353 bool MIParser::error(const Twine &Msg) { return error(Token.location(), Msg); }
355 bool MIParser::error(StringRef::iterator Loc, const Twine &Msg) {
356 const SourceMgr &SM = *PFS.SM;
357 assert(Loc >= Source.data() && Loc <= (Source.data() + Source.size()));
358 const MemoryBuffer &Buffer = *SM.getMemoryBuffer(SM.getMainFileID());
359 if (Loc >= Buffer.getBufferStart() && Loc <= Buffer.getBufferEnd()) {
360 // Create an ordinary diagnostic when the source manager's buffer is the
362 Error = SM.GetMessage(SMLoc::getFromPointer(Loc), SourceMgr::DK_Error, Msg);
365 // Create a diagnostic for a YAML string literal.
366 Error = SMDiagnostic(SM, SMLoc(), Buffer.getBufferIdentifier(), 1,
367 Loc - Source.data(), SourceMgr::DK_Error, Msg.str(),
372 static const char *toString(MIToken::TokenKind TokenKind) {
380 case MIToken::lparen:
382 case MIToken::rparen:
385 return "<unknown token>";
389 bool MIParser::expectAndConsume(MIToken::TokenKind TokenKind) {
390 if (Token.isNot(TokenKind))
391 return error(Twine("expected ") + toString(TokenKind));
396 bool MIParser::consumeIfPresent(MIToken::TokenKind TokenKind) {
397 if (Token.isNot(TokenKind))
403 bool MIParser::parseBasicBlockDefinition(
404 DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
405 assert(Token.is(MIToken::MachineBasicBlockLabel));
409 auto Loc = Token.location();
410 auto Name = Token.stringValue();
412 bool HasAddressTaken = false;
413 bool IsLandingPad = false;
414 unsigned Alignment = 0;
415 BasicBlock *BB = nullptr;
416 if (consumeIfPresent(MIToken::lparen)) {
418 // TODO: Report an error when multiple same attributes are specified.
419 switch (Token.kind()) {
420 case MIToken::kw_address_taken:
421 HasAddressTaken = true;
424 case MIToken::kw_landing_pad:
428 case MIToken::kw_align:
429 if (parseAlignment(Alignment))
432 case MIToken::IRBlock:
433 // TODO: Report an error when both name and ir block are specified.
434 if (parseIRBlock(BB, MF.getFunction()))
441 } while (consumeIfPresent(MIToken::comma));
442 if (expectAndConsume(MIToken::rparen))
445 if (expectAndConsume(MIToken::colon))
449 BB = dyn_cast_or_null<BasicBlock>(
450 MF.getFunction().getValueSymbolTable()->lookup(Name));
452 return error(Loc, Twine("basic block '") + Name +
453 "' is not defined in the function '" +
456 auto *MBB = MF.CreateMachineBasicBlock(BB);
457 MF.insert(MF.end(), MBB);
458 bool WasInserted = MBBSlots.insert(std::make_pair(ID, MBB)).second;
460 return error(Loc, Twine("redefinition of machine basic block with id #") +
463 MBB->setAlignment(Alignment);
465 MBB->setHasAddressTaken();
466 MBB->setIsEHPad(IsLandingPad);
470 bool MIParser::parseBasicBlockDefinitions(
471 DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
473 // Skip until the first machine basic block.
474 while (Token.is(MIToken::Newline))
476 if (Token.isErrorOrEOF())
477 return Token.isError();
478 if (Token.isNot(MIToken::MachineBasicBlockLabel))
479 return error("expected a basic block definition before instructions");
480 unsigned BraceDepth = 0;
482 if (parseBasicBlockDefinition(MBBSlots))
484 bool IsAfterNewline = false;
485 // Skip until the next machine basic block.
487 if ((Token.is(MIToken::MachineBasicBlockLabel) && IsAfterNewline) ||
488 Token.isErrorOrEOF())
490 else if (Token.is(MIToken::MachineBasicBlockLabel))
491 return error("basic block definition should be located at the start of "
493 else if (consumeIfPresent(MIToken::Newline)) {
494 IsAfterNewline = true;
497 IsAfterNewline = false;
498 if (Token.is(MIToken::lbrace))
500 if (Token.is(MIToken::rbrace)) {
502 return error("extraneous closing brace ('}')");
507 // Verify that we closed all of the '{' at the end of a file or a block.
508 if (!Token.isError() && BraceDepth)
509 return error("expected '}'"); // FIXME: Report a note that shows '{'.
510 } while (!Token.isErrorOrEOF());
511 return Token.isError();
514 bool MIParser::parseBasicBlockLiveins(MachineBasicBlock &MBB) {
515 assert(Token.is(MIToken::kw_liveins));
517 if (expectAndConsume(MIToken::colon))
519 if (Token.isNewlineOrEOF()) // Allow an empty list of liveins.
522 if (Token.isNot(MIToken::NamedRegister))
523 return error("expected a named register");
525 if (parseNamedRegister(Reg))
528 LaneBitmask Mask = LaneBitmask::getAll();
529 if (consumeIfPresent(MIToken::colon)) {
531 if (Token.isNot(MIToken::IntegerLiteral) &&
532 Token.isNot(MIToken::HexLiteral))
533 return error("expected a lane mask");
534 static_assert(sizeof(LaneBitmask::Type) == sizeof(unsigned),
535 "Use correct get-function for lane mask");
538 return error("invalid lane mask value");
539 Mask = LaneBitmask(V);
542 MBB.addLiveIn(Reg, Mask);
543 } while (consumeIfPresent(MIToken::comma));
547 bool MIParser::parseBasicBlockSuccessors(MachineBasicBlock &MBB) {
548 assert(Token.is(MIToken::kw_successors));
550 if (expectAndConsume(MIToken::colon))
552 if (Token.isNewlineOrEOF()) // Allow an empty list of successors.
555 if (Token.isNot(MIToken::MachineBasicBlock))
556 return error("expected a machine basic block reference");
557 MachineBasicBlock *SuccMBB = nullptr;
558 if (parseMBBReference(SuccMBB))
562 if (consumeIfPresent(MIToken::lparen)) {
563 if (Token.isNot(MIToken::IntegerLiteral) &&
564 Token.isNot(MIToken::HexLiteral))
565 return error("expected an integer literal after '('");
566 if (getUnsigned(Weight))
569 if (expectAndConsume(MIToken::rparen))
572 MBB.addSuccessor(SuccMBB, BranchProbability::getRaw(Weight));
573 } while (consumeIfPresent(MIToken::comma));
574 MBB.normalizeSuccProbs();
578 bool MIParser::parseBasicBlock(MachineBasicBlock &MBB,
579 MachineBasicBlock *&AddFalthroughFrom) {
580 // Skip the definition.
581 assert(Token.is(MIToken::MachineBasicBlockLabel));
583 if (consumeIfPresent(MIToken::lparen)) {
584 while (Token.isNot(MIToken::rparen) && !Token.isErrorOrEOF())
586 consumeIfPresent(MIToken::rparen);
588 consumeIfPresent(MIToken::colon);
590 // Parse the liveins and successors.
591 // N.B: Multiple lists of successors and liveins are allowed and they're
598 // liveins: %edi, %esi
599 bool ExplicitSuccessors = false;
601 if (Token.is(MIToken::kw_successors)) {
602 if (parseBasicBlockSuccessors(MBB))
604 ExplicitSuccessors = true;
605 } else if (Token.is(MIToken::kw_liveins)) {
606 if (parseBasicBlockLiveins(MBB))
608 } else if (consumeIfPresent(MIToken::Newline)) {
612 if (!Token.isNewlineOrEOF())
613 return error("expected line break at the end of a list");
617 // Parse the instructions.
618 bool IsInBundle = false;
619 MachineInstr *PrevMI = nullptr;
620 while (!Token.is(MIToken::MachineBasicBlockLabel) &&
621 !Token.is(MIToken::Eof)) {
622 if (consumeIfPresent(MIToken::Newline))
624 if (consumeIfPresent(MIToken::rbrace)) {
625 // The first parsing pass should verify that all closing '}' have an
631 MachineInstr *MI = nullptr;
634 MBB.insert(MBB.end(), MI);
636 PrevMI->setFlag(MachineInstr::BundledSucc);
637 MI->setFlag(MachineInstr::BundledPred);
640 if (Token.is(MIToken::lbrace)) {
642 return error("nested instruction bundles are not allowed");
644 // This instruction is the start of the bundle.
645 MI->setFlag(MachineInstr::BundledSucc);
647 if (!Token.is(MIToken::Newline))
648 // The next instruction can be on the same line.
651 assert(Token.isNewlineOrEOF() && "MI is not fully parsed");
655 // Construct successor list by searching for basic block machine operands.
656 if (!ExplicitSuccessors) {
657 SmallVector<MachineBasicBlock*,4> Successors;
659 guessSuccessors(MBB, Successors, IsFallthrough);
660 for (MachineBasicBlock *Succ : Successors)
661 MBB.addSuccessor(Succ);
664 AddFalthroughFrom = &MBB;
666 MBB.normalizeSuccProbs();
673 bool MIParser::parseBasicBlocks() {
675 // Skip until the first machine basic block.
676 while (Token.is(MIToken::Newline))
678 if (Token.isErrorOrEOF())
679 return Token.isError();
680 // The first parsing pass should have verified that this token is a MBB label
681 // in the 'parseBasicBlockDefinitions' method.
682 assert(Token.is(MIToken::MachineBasicBlockLabel));
683 MachineBasicBlock *AddFalthroughFrom = nullptr;
685 MachineBasicBlock *MBB = nullptr;
686 if (parseMBBReference(MBB))
688 if (AddFalthroughFrom) {
689 if (!AddFalthroughFrom->isSuccessor(MBB))
690 AddFalthroughFrom->addSuccessor(MBB);
691 AddFalthroughFrom->normalizeSuccProbs();
692 AddFalthroughFrom = nullptr;
694 if (parseBasicBlock(*MBB, AddFalthroughFrom))
696 // The method 'parseBasicBlock' should parse the whole block until the next
697 // block or the end of file.
698 assert(Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof));
699 } while (Token.isNot(MIToken::Eof));
703 bool MIParser::parse(MachineInstr *&MI) {
704 // Parse any register operands before '='
705 MachineOperand MO = MachineOperand::CreateImm(0);
706 SmallVector<ParsedMachineOperand, 8> Operands;
707 while (Token.isRegister() || Token.isRegisterFlag()) {
708 auto Loc = Token.location();
709 Optional<unsigned> TiedDefIdx;
710 if (parseRegisterOperand(MO, TiedDefIdx, /*IsDef=*/true))
713 ParsedMachineOperand(MO, Loc, Token.location(), TiedDefIdx));
714 if (Token.isNot(MIToken::comma))
718 if (!Operands.empty() && expectAndConsume(MIToken::equal))
721 unsigned OpCode, Flags = 0;
722 if (Token.isError() || parseInstruction(OpCode, Flags))
725 // Parse the remaining machine operands.
726 while (!Token.isNewlineOrEOF() && Token.isNot(MIToken::kw_debug_location) &&
727 Token.isNot(MIToken::coloncolon) && Token.isNot(MIToken::lbrace)) {
728 auto Loc = Token.location();
729 Optional<unsigned> TiedDefIdx;
730 if (parseMachineOperandAndTargetFlags(MO, TiedDefIdx))
733 ParsedMachineOperand(MO, Loc, Token.location(), TiedDefIdx));
734 if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
735 Token.is(MIToken::lbrace))
737 if (Token.isNot(MIToken::comma))
738 return error("expected ',' before the next machine operand");
742 DebugLoc DebugLocation;
743 if (Token.is(MIToken::kw_debug_location)) {
745 if (Token.isNot(MIToken::exclaim))
746 return error("expected a metadata node after 'debug-location'");
747 MDNode *Node = nullptr;
748 if (parseMDNode(Node))
750 DebugLocation = DebugLoc(Node);
753 // Parse the machine memory operands.
754 SmallVector<MachineMemOperand *, 2> MemOperands;
755 if (Token.is(MIToken::coloncolon)) {
757 while (!Token.isNewlineOrEOF()) {
758 MachineMemOperand *MemOp = nullptr;
759 if (parseMachineMemoryOperand(MemOp))
761 MemOperands.push_back(MemOp);
762 if (Token.isNewlineOrEOF())
764 if (Token.isNot(MIToken::comma))
765 return error("expected ',' before the next machine memory operand");
770 const auto &MCID = MF.getSubtarget().getInstrInfo()->get(OpCode);
771 if (!MCID.isVariadic()) {
772 // FIXME: Move the implicit operand verification to the machine verifier.
773 if (verifyImplicitOperands(Operands, MCID))
777 // TODO: Check for extraneous machine operands.
778 MI = MF.CreateMachineInstr(MCID, DebugLocation, /*NoImplicit=*/true);
780 for (const auto &Operand : Operands)
781 MI->addOperand(MF, Operand.Operand);
782 if (assignRegisterTies(*MI, Operands))
784 if (MemOperands.empty())
786 MachineInstr::mmo_iterator MemRefs =
787 MF.allocateMemRefsArray(MemOperands.size());
788 std::copy(MemOperands.begin(), MemOperands.end(), MemRefs);
789 MI->setMemRefs(MemRefs, MemRefs + MemOperands.size());
793 bool MIParser::parseStandaloneMBB(MachineBasicBlock *&MBB) {
795 if (Token.isNot(MIToken::MachineBasicBlock))
796 return error("expected a machine basic block reference");
797 if (parseMBBReference(MBB))
800 if (Token.isNot(MIToken::Eof))
802 "expected end of string after the machine basic block reference");
806 bool MIParser::parseStandaloneNamedRegister(unsigned &Reg) {
808 if (Token.isNot(MIToken::NamedRegister))
809 return error("expected a named register");
810 if (parseNamedRegister(Reg))
813 if (Token.isNot(MIToken::Eof))
814 return error("expected end of string after the register reference");
818 bool MIParser::parseStandaloneVirtualRegister(VRegInfo *&Info) {
820 if (Token.isNot(MIToken::VirtualRegister))
821 return error("expected a virtual register");
822 if (parseVirtualRegister(Info))
825 if (Token.isNot(MIToken::Eof))
826 return error("expected end of string after the register reference");
830 bool MIParser::parseStandaloneRegister(unsigned &Reg) {
832 if (Token.isNot(MIToken::NamedRegister) &&
833 Token.isNot(MIToken::VirtualRegister))
834 return error("expected either a named or virtual register");
837 if (parseRegister(Reg, Info))
841 if (Token.isNot(MIToken::Eof))
842 return error("expected end of string after the register reference");
846 bool MIParser::parseStandaloneStackObject(int &FI) {
848 if (Token.isNot(MIToken::StackObject))
849 return error("expected a stack object");
850 if (parseStackFrameIndex(FI))
852 if (Token.isNot(MIToken::Eof))
853 return error("expected end of string after the stack object reference");
857 bool MIParser::parseStandaloneMDNode(MDNode *&Node) {
859 if (Token.is(MIToken::exclaim)) {
860 if (parseMDNode(Node))
862 } else if (Token.is(MIToken::md_diexpr)) {
863 if (parseDIExpression(Node))
866 return error("expected a metadata node");
867 if (Token.isNot(MIToken::Eof))
868 return error("expected end of string after the metadata node");
872 static const char *printImplicitRegisterFlag(const MachineOperand &MO) {
873 assert(MO.isImplicit());
874 return MO.isDef() ? "implicit-def" : "implicit";
877 static std::string getRegisterName(const TargetRegisterInfo *TRI,
879 assert(TargetRegisterInfo::isPhysicalRegister(Reg) && "expected phys reg");
880 return StringRef(TRI->getName(Reg)).lower();
883 /// Return true if the parsed machine operands contain a given machine operand.
884 static bool isImplicitOperandIn(const MachineOperand &ImplicitOperand,
885 ArrayRef<ParsedMachineOperand> Operands) {
886 for (const auto &I : Operands) {
887 if (ImplicitOperand.isIdenticalTo(I.Operand))
893 bool MIParser::verifyImplicitOperands(ArrayRef<ParsedMachineOperand> Operands,
894 const MCInstrDesc &MCID) {
896 // We can't verify call instructions as they can contain arbitrary implicit
897 // register and register mask operands.
900 // Gather all the expected implicit operands.
901 SmallVector<MachineOperand, 4> ImplicitOperands;
902 if (MCID.ImplicitDefs)
903 for (const MCPhysReg *ImpDefs = MCID.getImplicitDefs(); *ImpDefs; ++ImpDefs)
904 ImplicitOperands.push_back(
905 MachineOperand::CreateReg(*ImpDefs, true, true));
906 if (MCID.ImplicitUses)
907 for (const MCPhysReg *ImpUses = MCID.getImplicitUses(); *ImpUses; ++ImpUses)
908 ImplicitOperands.push_back(
909 MachineOperand::CreateReg(*ImpUses, false, true));
911 const auto *TRI = MF.getSubtarget().getRegisterInfo();
912 assert(TRI && "Expected target register info");
913 for (const auto &I : ImplicitOperands) {
914 if (isImplicitOperandIn(I, Operands))
916 return error(Operands.empty() ? Token.location() : Operands.back().End,
917 Twine("missing implicit register operand '") +
918 printImplicitRegisterFlag(I) + " %" +
919 getRegisterName(TRI, I.getReg()) + "'");
924 bool MIParser::parseInstruction(unsigned &OpCode, unsigned &Flags) {
925 if (Token.is(MIToken::kw_frame_setup)) {
926 Flags |= MachineInstr::FrameSetup;
929 if (Token.isNot(MIToken::Identifier))
930 return error("expected a machine instruction");
931 StringRef InstrName = Token.stringValue();
932 if (parseInstrName(InstrName, OpCode))
933 return error(Twine("unknown machine instruction name '") + InstrName + "'");
938 bool MIParser::parseNamedRegister(unsigned &Reg) {
939 assert(Token.is(MIToken::NamedRegister) && "Needs NamedRegister token");
940 StringRef Name = Token.stringValue();
941 if (getRegisterByName(Name, Reg))
942 return error(Twine("unknown register name '") + Name + "'");
946 bool MIParser::parseVirtualRegister(VRegInfo *&Info) {
947 assert(Token.is(MIToken::VirtualRegister) && "Needs VirtualRegister token");
951 Info = &PFS.getVRegInfo(ID);
955 bool MIParser::parseRegister(unsigned &Reg, VRegInfo *&Info) {
956 switch (Token.kind()) {
957 case MIToken::underscore:
960 case MIToken::NamedRegister:
961 return parseNamedRegister(Reg);
962 case MIToken::VirtualRegister:
963 if (parseVirtualRegister(Info))
967 // TODO: Parse other register kinds.
969 llvm_unreachable("The current token should be a register");
973 bool MIParser::parseRegisterClassOrBank(VRegInfo &RegInfo) {
974 if (Token.isNot(MIToken::Identifier) && Token.isNot(MIToken::underscore))
975 return error("expected '_', register class, or register bank name");
976 StringRef::iterator Loc = Token.location();
977 StringRef Name = Token.stringValue();
979 // Was it a register class?
980 auto RCNameI = PFS.Names2RegClasses.find(Name);
981 if (RCNameI != PFS.Names2RegClasses.end()) {
983 const TargetRegisterClass &RC = *RCNameI->getValue();
985 switch (RegInfo.Kind) {
986 case VRegInfo::UNKNOWN:
987 case VRegInfo::NORMAL:
988 RegInfo.Kind = VRegInfo::NORMAL;
989 if (RegInfo.Explicit && RegInfo.D.RC != &RC) {
990 const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo();
991 return error(Loc, Twine("conflicting register classes, previously: ") +
992 Twine(TRI.getRegClassName(RegInfo.D.RC)));
995 RegInfo.Explicit = true;
998 case VRegInfo::GENERIC:
999 case VRegInfo::REGBANK:
1000 return error(Loc, "register class specification on generic register");
1002 llvm_unreachable("Unexpected register kind");
1005 // Should be a register bank or a generic register.
1006 const RegisterBank *RegBank = nullptr;
1008 auto RBNameI = PFS.Names2RegBanks.find(Name);
1009 if (RBNameI == PFS.Names2RegBanks.end())
1010 return error(Loc, "expected '_', register class, or register bank name");
1011 RegBank = RBNameI->getValue();
1016 switch (RegInfo.Kind) {
1017 case VRegInfo::UNKNOWN:
1018 case VRegInfo::GENERIC:
1019 case VRegInfo::REGBANK:
1020 RegInfo.Kind = RegBank ? VRegInfo::REGBANK : VRegInfo::GENERIC;
1021 if (RegInfo.Explicit && RegInfo.D.RegBank != RegBank)
1022 return error(Loc, "conflicting generic register banks");
1023 RegInfo.D.RegBank = RegBank;
1024 RegInfo.Explicit = true;
1027 case VRegInfo::NORMAL:
1028 return error(Loc, "register bank specification on normal register");
1030 llvm_unreachable("Unexpected register kind");
1033 bool MIParser::parseRegisterFlag(unsigned &Flags) {
1034 const unsigned OldFlags = Flags;
1035 switch (Token.kind()) {
1036 case MIToken::kw_implicit:
1037 Flags |= RegState::Implicit;
1039 case MIToken::kw_implicit_define:
1040 Flags |= RegState::ImplicitDefine;
1042 case MIToken::kw_def:
1043 Flags |= RegState::Define;
1045 case MIToken::kw_dead:
1046 Flags |= RegState::Dead;
1048 case MIToken::kw_killed:
1049 Flags |= RegState::Kill;
1051 case MIToken::kw_undef:
1052 Flags |= RegState::Undef;
1054 case MIToken::kw_internal:
1055 Flags |= RegState::InternalRead;
1057 case MIToken::kw_early_clobber:
1058 Flags |= RegState::EarlyClobber;
1060 case MIToken::kw_debug_use:
1061 Flags |= RegState::Debug;
1063 case MIToken::kw_renamable:
1064 Flags |= RegState::Renamable;
1067 llvm_unreachable("The current token should be a register flag");
1069 if (OldFlags == Flags)
1070 // We know that the same flag is specified more than once when the flags
1071 // weren't modified.
1072 return error("duplicate '" + Token.stringValue() + "' register flag");
1077 bool MIParser::parseSubRegisterIndex(unsigned &SubReg) {
1078 assert(Token.is(MIToken::dot));
1080 if (Token.isNot(MIToken::Identifier))
1081 return error("expected a subregister index after '.'");
1082 auto Name = Token.stringValue();
1083 SubReg = getSubRegIndex(Name);
1085 return error(Twine("use of unknown subregister index '") + Name + "'");
1090 bool MIParser::parseRegisterTiedDefIndex(unsigned &TiedDefIdx) {
1091 if (!consumeIfPresent(MIToken::kw_tied_def))
1093 if (Token.isNot(MIToken::IntegerLiteral))
1094 return error("expected an integer literal after 'tied-def'");
1095 if (getUnsigned(TiedDefIdx))
1098 if (expectAndConsume(MIToken::rparen))
1103 bool MIParser::assignRegisterTies(MachineInstr &MI,
1104 ArrayRef<ParsedMachineOperand> Operands) {
1105 SmallVector<std::pair<unsigned, unsigned>, 4> TiedRegisterPairs;
1106 for (unsigned I = 0, E = Operands.size(); I != E; ++I) {
1107 if (!Operands[I].TiedDefIdx)
1109 // The parser ensures that this operand is a register use, so we just have
1110 // to check the tied-def operand.
1111 unsigned DefIdx = Operands[I].TiedDefIdx.getValue();
1113 return error(Operands[I].Begin,
1114 Twine("use of invalid tied-def operand index '" +
1115 Twine(DefIdx) + "'; instruction has only ") +
1116 Twine(E) + " operands");
1117 const auto &DefOperand = Operands[DefIdx].Operand;
1118 if (!DefOperand.isReg() || !DefOperand.isDef())
1119 // FIXME: add note with the def operand.
1120 return error(Operands[I].Begin,
1121 Twine("use of invalid tied-def operand index '") +
1122 Twine(DefIdx) + "'; the operand #" + Twine(DefIdx) +
1123 " isn't a defined register");
1124 // Check that the tied-def operand wasn't tied elsewhere.
1125 for (const auto &TiedPair : TiedRegisterPairs) {
1126 if (TiedPair.first == DefIdx)
1127 return error(Operands[I].Begin,
1128 Twine("the tied-def operand #") + Twine(DefIdx) +
1129 " is already tied with another register operand");
1131 TiedRegisterPairs.push_back(std::make_pair(DefIdx, I));
1133 // FIXME: Verify that for non INLINEASM instructions, the def and use tied
1134 // indices must be less than tied max.
1135 for (const auto &TiedPair : TiedRegisterPairs)
1136 MI.tieOperands(TiedPair.first, TiedPair.second);
1140 bool MIParser::parseRegisterOperand(MachineOperand &Dest,
1141 Optional<unsigned> &TiedDefIdx,
1143 unsigned Flags = IsDef ? RegState::Define : 0;
1144 while (Token.isRegisterFlag()) {
1145 if (parseRegisterFlag(Flags))
1148 if (!Token.isRegister())
1149 return error("expected a register after register flags");
1152 if (parseRegister(Reg, RegInfo))
1155 unsigned SubReg = 0;
1156 if (Token.is(MIToken::dot)) {
1157 if (parseSubRegisterIndex(SubReg))
1159 if (!TargetRegisterInfo::isVirtualRegister(Reg))
1160 return error("subregister index expects a virtual register");
1162 if (Token.is(MIToken::colon)) {
1163 if (!TargetRegisterInfo::isVirtualRegister(Reg))
1164 return error("register class specification expects a virtual register");
1166 if (parseRegisterClassOrBank(*RegInfo))
1169 MachineRegisterInfo &MRI = MF.getRegInfo();
1170 if ((Flags & RegState::Define) == 0) {
1171 if (consumeIfPresent(MIToken::lparen)) {
1173 if (!parseRegisterTiedDefIndex(Idx))
1176 // Try a redundant low-level type.
1178 if (parseLowLevelType(Token.location(), Ty))
1179 return error("expected tied-def or low-level type after '('");
1181 if (expectAndConsume(MIToken::rparen))
1184 if (MRI.getType(Reg).isValid() && MRI.getType(Reg) != Ty)
1185 return error("inconsistent type for generic virtual register");
1187 MRI.setType(Reg, Ty);
1190 } else if (consumeIfPresent(MIToken::lparen)) {
1191 // Virtual registers may have a tpe with GlobalISel.
1192 if (!TargetRegisterInfo::isVirtualRegister(Reg))
1193 return error("unexpected type on physical register");
1196 if (parseLowLevelType(Token.location(), Ty))
1199 if (expectAndConsume(MIToken::rparen))
1202 if (MRI.getType(Reg).isValid() && MRI.getType(Reg) != Ty)
1203 return error("inconsistent type for generic virtual register");
1205 MRI.setType(Reg, Ty);
1206 } else if (TargetRegisterInfo::isVirtualRegister(Reg)) {
1207 // Generic virtual registers must have a type.
1208 // If we end up here this means the type hasn't been specified and
1210 if (RegInfo->Kind == VRegInfo::GENERIC ||
1211 RegInfo->Kind == VRegInfo::REGBANK)
1212 return error("generic virtual registers must have a type");
1214 Dest = MachineOperand::CreateReg(
1215 Reg, Flags & RegState::Define, Flags & RegState::Implicit,
1216 Flags & RegState::Kill, Flags & RegState::Dead, Flags & RegState::Undef,
1217 Flags & RegState::EarlyClobber, SubReg, Flags & RegState::Debug,
1218 Flags & RegState::InternalRead, Flags & RegState::Renamable);
1223 bool MIParser::parseImmediateOperand(MachineOperand &Dest) {
1224 assert(Token.is(MIToken::IntegerLiteral));
1225 const APSInt &Int = Token.integerValue();
1226 if (Int.getMinSignedBits() > 64)
1227 return error("integer literal is too large to be an immediate operand");
1228 Dest = MachineOperand::CreateImm(Int.getExtValue());
1233 bool MIParser::parseIRConstant(StringRef::iterator Loc, StringRef StringValue,
1234 const Constant *&C) {
1235 auto Source = StringValue.str(); // The source has to be null terminated.
1237 C = parseConstantValue(Source, Err, *MF.getFunction().getParent(),
1240 return error(Loc + Err.getColumnNo(), Err.getMessage());
1244 bool MIParser::parseIRConstant(StringRef::iterator Loc, const Constant *&C) {
1245 if (parseIRConstant(Loc, StringRef(Loc, Token.range().end() - Loc), C))
1251 bool MIParser::parseLowLevelType(StringRef::iterator Loc, LLT &Ty) {
1252 if (Token.is(MIToken::ScalarType)) {
1253 Ty = LLT::scalar(APSInt(Token.range().drop_front()).getZExtValue());
1256 } else if (Token.is(MIToken::PointerType)) {
1257 const DataLayout &DL = MF.getDataLayout();
1258 unsigned AS = APSInt(Token.range().drop_front()).getZExtValue();
1259 Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
1264 // Now we're looking for a vector.
1265 if (Token.isNot(MIToken::less))
1267 "expected unsized, pN, sN or <N x sM> for GlobalISel type");
1271 if (Token.isNot(MIToken::IntegerLiteral))
1272 return error(Loc, "expected <N x sM> for vctor type");
1273 uint64_t NumElements = Token.integerValue().getZExtValue();
1276 if (Token.isNot(MIToken::Identifier) || Token.stringValue() != "x")
1277 return error(Loc, "expected '<N x sM>' for vector type");
1280 if (Token.isNot(MIToken::ScalarType))
1281 return error(Loc, "expected '<N x sM>' for vector type");
1282 uint64_t ScalarSize = APSInt(Token.range().drop_front()).getZExtValue();
1285 if (Token.isNot(MIToken::greater))
1286 return error(Loc, "expected '<N x sM>' for vector type");
1289 Ty = LLT::vector(NumElements, ScalarSize);
1293 bool MIParser::parseTypedImmediateOperand(MachineOperand &Dest) {
1294 assert(Token.is(MIToken::IntegerType));
1295 auto Loc = Token.location();
1297 if (Token.isNot(MIToken::IntegerLiteral))
1298 return error("expected an integer literal");
1299 const Constant *C = nullptr;
1300 if (parseIRConstant(Loc, C))
1302 Dest = MachineOperand::CreateCImm(cast<ConstantInt>(C));
1306 bool MIParser::parseFPImmediateOperand(MachineOperand &Dest) {
1307 auto Loc = Token.location();
1309 if (Token.isNot(MIToken::FloatingPointLiteral) &&
1310 Token.isNot(MIToken::HexLiteral))
1311 return error("expected a floating point literal");
1312 const Constant *C = nullptr;
1313 if (parseIRConstant(Loc, C))
1315 Dest = MachineOperand::CreateFPImm(cast<ConstantFP>(C));
1319 bool MIParser::getUnsigned(unsigned &Result) {
1320 if (Token.hasIntegerValue()) {
1321 const uint64_t Limit = uint64_t(std::numeric_limits<unsigned>::max()) + 1;
1322 uint64_t Val64 = Token.integerValue().getLimitedValue(Limit);
1324 return error("expected 32-bit integer (too large)");
1328 if (Token.is(MIToken::HexLiteral)) {
1332 if (A.getBitWidth() > 32)
1333 return error("expected 32-bit integer (too large)");
1334 Result = A.getZExtValue();
1340 bool MIParser::parseMBBReference(MachineBasicBlock *&MBB) {
1341 assert(Token.is(MIToken::MachineBasicBlock) ||
1342 Token.is(MIToken::MachineBasicBlockLabel));
1344 if (getUnsigned(Number))
1346 auto MBBInfo = PFS.MBBSlots.find(Number);
1347 if (MBBInfo == PFS.MBBSlots.end())
1348 return error(Twine("use of undefined machine basic block #") +
1350 MBB = MBBInfo->second;
1351 // TODO: Only parse the name if it's a MachineBasicBlockLabel. Deprecate once
1352 // we drop the <irname> from the bb.<id>.<irname> format.
1353 if (!Token.stringValue().empty() && Token.stringValue() != MBB->getName())
1354 return error(Twine("the name of machine basic block #") + Twine(Number) +
1355 " isn't '" + Token.stringValue() + "'");
1359 bool MIParser::parseMBBOperand(MachineOperand &Dest) {
1360 MachineBasicBlock *MBB;
1361 if (parseMBBReference(MBB))
1363 Dest = MachineOperand::CreateMBB(MBB);
1368 bool MIParser::parseStackFrameIndex(int &FI) {
1369 assert(Token.is(MIToken::StackObject));
1371 if (getUnsigned(ID))
1373 auto ObjectInfo = PFS.StackObjectSlots.find(ID);
1374 if (ObjectInfo == PFS.StackObjectSlots.end())
1375 return error(Twine("use of undefined stack object '%stack.") + Twine(ID) +
1378 if (const auto *Alloca =
1379 MF.getFrameInfo().getObjectAllocation(ObjectInfo->second))
1380 Name = Alloca->getName();
1381 if (!Token.stringValue().empty() && Token.stringValue() != Name)
1382 return error(Twine("the name of the stack object '%stack.") + Twine(ID) +
1383 "' isn't '" + Token.stringValue() + "'");
1385 FI = ObjectInfo->second;
1389 bool MIParser::parseStackObjectOperand(MachineOperand &Dest) {
1391 if (parseStackFrameIndex(FI))
1393 Dest = MachineOperand::CreateFI(FI);
1397 bool MIParser::parseFixedStackFrameIndex(int &FI) {
1398 assert(Token.is(MIToken::FixedStackObject));
1400 if (getUnsigned(ID))
1402 auto ObjectInfo = PFS.FixedStackObjectSlots.find(ID);
1403 if (ObjectInfo == PFS.FixedStackObjectSlots.end())
1404 return error(Twine("use of undefined fixed stack object '%fixed-stack.") +
1407 FI = ObjectInfo->second;
1411 bool MIParser::parseFixedStackObjectOperand(MachineOperand &Dest) {
1413 if (parseFixedStackFrameIndex(FI))
1415 Dest = MachineOperand::CreateFI(FI);
1419 bool MIParser::parseGlobalValue(GlobalValue *&GV) {
1420 switch (Token.kind()) {
1421 case MIToken::NamedGlobalValue: {
1422 const Module *M = MF.getFunction().getParent();
1423 GV = M->getNamedValue(Token.stringValue());
1425 return error(Twine("use of undefined global value '") + Token.range() +
1429 case MIToken::GlobalValue: {
1431 if (getUnsigned(GVIdx))
1433 if (GVIdx >= PFS.IRSlots.GlobalValues.size())
1434 return error(Twine("use of undefined global value '@") + Twine(GVIdx) +
1436 GV = PFS.IRSlots.GlobalValues[GVIdx];
1440 llvm_unreachable("The current token should be a global value");
1445 bool MIParser::parseGlobalAddressOperand(MachineOperand &Dest) {
1446 GlobalValue *GV = nullptr;
1447 if (parseGlobalValue(GV))
1450 Dest = MachineOperand::CreateGA(GV, /*Offset=*/0);
1451 if (parseOperandsOffset(Dest))
1456 bool MIParser::parseConstantPoolIndexOperand(MachineOperand &Dest) {
1457 assert(Token.is(MIToken::ConstantPoolItem));
1459 if (getUnsigned(ID))
1461 auto ConstantInfo = PFS.ConstantPoolSlots.find(ID);
1462 if (ConstantInfo == PFS.ConstantPoolSlots.end())
1463 return error("use of undefined constant '%const." + Twine(ID) + "'");
1465 Dest = MachineOperand::CreateCPI(ID, /*Offset=*/0);
1466 if (parseOperandsOffset(Dest))
1471 bool MIParser::parseJumpTableIndexOperand(MachineOperand &Dest) {
1472 assert(Token.is(MIToken::JumpTableIndex));
1474 if (getUnsigned(ID))
1476 auto JumpTableEntryInfo = PFS.JumpTableSlots.find(ID);
1477 if (JumpTableEntryInfo == PFS.JumpTableSlots.end())
1478 return error("use of undefined jump table '%jump-table." + Twine(ID) + "'");
1480 Dest = MachineOperand::CreateJTI(JumpTableEntryInfo->second);
1484 bool MIParser::parseExternalSymbolOperand(MachineOperand &Dest) {
1485 assert(Token.is(MIToken::ExternalSymbol));
1486 const char *Symbol = MF.createExternalSymbolName(Token.stringValue());
1488 Dest = MachineOperand::CreateES(Symbol);
1489 if (parseOperandsOffset(Dest))
1494 bool MIParser::parseSubRegisterIndexOperand(MachineOperand &Dest) {
1495 assert(Token.is(MIToken::SubRegisterIndex));
1496 StringRef Name = Token.stringValue();
1497 unsigned SubRegIndex = getSubRegIndex(Token.stringValue());
1498 if (SubRegIndex == 0)
1499 return error(Twine("unknown subregister index '") + Name + "'");
1501 Dest = MachineOperand::CreateImm(SubRegIndex);
1505 bool MIParser::parseMDNode(MDNode *&Node) {
1506 assert(Token.is(MIToken::exclaim));
1508 auto Loc = Token.location();
1510 if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
1511 return error("expected metadata id after '!'");
1513 if (getUnsigned(ID))
1515 auto NodeInfo = PFS.IRSlots.MetadataNodes.find(ID);
1516 if (NodeInfo == PFS.IRSlots.MetadataNodes.end())
1517 return error(Loc, "use of undefined metadata '!" + Twine(ID) + "'");
1519 Node = NodeInfo->second.get();
1523 bool MIParser::parseDIExpression(MDNode *&Expr) {
1524 assert(Token.is(MIToken::md_diexpr));
1527 // FIXME: Share this parsing with the IL parser.
1528 SmallVector<uint64_t, 8> Elements;
1530 if (expectAndConsume(MIToken::lparen))
1533 if (Token.isNot(MIToken::rparen)) {
1535 if (Token.is(MIToken::Identifier)) {
1536 if (unsigned Op = dwarf::getOperationEncoding(Token.stringValue())) {
1538 Elements.push_back(Op);
1541 return error(Twine("invalid DWARF op '") + Token.stringValue() + "'");
1544 if (Token.isNot(MIToken::IntegerLiteral) ||
1545 Token.integerValue().isSigned())
1546 return error("expected unsigned integer");
1548 auto &U = Token.integerValue();
1549 if (U.ugt(UINT64_MAX))
1550 return error("element too large, limit is " + Twine(UINT64_MAX));
1551 Elements.push_back(U.getZExtValue());
1554 } while (consumeIfPresent(MIToken::comma));
1557 if (expectAndConsume(MIToken::rparen))
1560 Expr = DIExpression::get(MF.getFunction().getContext(), Elements);
1564 bool MIParser::parseMetadataOperand(MachineOperand &Dest) {
1565 MDNode *Node = nullptr;
1566 if (Token.is(MIToken::exclaim)) {
1567 if (parseMDNode(Node))
1569 } else if (Token.is(MIToken::md_diexpr)) {
1570 if (parseDIExpression(Node))
1573 Dest = MachineOperand::CreateMetadata(Node);
1577 bool MIParser::parseCFIOffset(int &Offset) {
1578 if (Token.isNot(MIToken::IntegerLiteral))
1579 return error("expected a cfi offset");
1580 if (Token.integerValue().getMinSignedBits() > 32)
1581 return error("expected a 32 bit integer (the cfi offset is too large)");
1582 Offset = (int)Token.integerValue().getExtValue();
1587 bool MIParser::parseCFIRegister(unsigned &Reg) {
1588 if (Token.isNot(MIToken::NamedRegister))
1589 return error("expected a cfi register");
1591 if (parseNamedRegister(LLVMReg))
1593 const auto *TRI = MF.getSubtarget().getRegisterInfo();
1594 assert(TRI && "Expected target register info");
1595 int DwarfReg = TRI->getDwarfRegNum(LLVMReg, true);
1597 return error("invalid DWARF register");
1598 Reg = (unsigned)DwarfReg;
1603 bool MIParser::parseCFIEscapeValues(std::string &Values) {
1605 if (Token.isNot(MIToken::HexLiteral))
1606 return error("expected a hexadecimal literal");
1608 if (getUnsigned(Value))
1610 if (Value > UINT8_MAX)
1611 return error("expected a 8-bit integer (too large)");
1612 Values.push_back(static_cast<uint8_t>(Value));
1614 } while (consumeIfPresent(MIToken::comma));
1618 bool MIParser::parseCFIOperand(MachineOperand &Dest) {
1619 auto Kind = Token.kind();
1625 case MIToken::kw_cfi_same_value:
1626 if (parseCFIRegister(Reg))
1628 CFIIndex = MF.addFrameInst(MCCFIInstruction::createSameValue(nullptr, Reg));
1630 case MIToken::kw_cfi_offset:
1631 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1632 parseCFIOffset(Offset))
1635 MF.addFrameInst(MCCFIInstruction::createOffset(nullptr, Reg, Offset));
1637 case MIToken::kw_cfi_rel_offset:
1638 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1639 parseCFIOffset(Offset))
1641 CFIIndex = MF.addFrameInst(
1642 MCCFIInstruction::createRelOffset(nullptr, Reg, Offset));
1644 case MIToken::kw_cfi_def_cfa_register:
1645 if (parseCFIRegister(Reg))
1648 MF.addFrameInst(MCCFIInstruction::createDefCfaRegister(nullptr, Reg));
1650 case MIToken::kw_cfi_def_cfa_offset:
1651 if (parseCFIOffset(Offset))
1653 // NB: MCCFIInstruction::createDefCfaOffset negates the offset.
1654 CFIIndex = MF.addFrameInst(
1655 MCCFIInstruction::createDefCfaOffset(nullptr, -Offset));
1657 case MIToken::kw_cfi_adjust_cfa_offset:
1658 if (parseCFIOffset(Offset))
1660 CFIIndex = MF.addFrameInst(
1661 MCCFIInstruction::createAdjustCfaOffset(nullptr, Offset));
1663 case MIToken::kw_cfi_def_cfa:
1664 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1665 parseCFIOffset(Offset))
1667 // NB: MCCFIInstruction::createDefCfa negates the offset.
1669 MF.addFrameInst(MCCFIInstruction::createDefCfa(nullptr, Reg, -Offset));
1671 case MIToken::kw_cfi_remember_state:
1672 CFIIndex = MF.addFrameInst(MCCFIInstruction::createRememberState(nullptr));
1674 case MIToken::kw_cfi_restore:
1675 if (parseCFIRegister(Reg))
1677 CFIIndex = MF.addFrameInst(MCCFIInstruction::createRestore(nullptr, Reg));
1679 case MIToken::kw_cfi_restore_state:
1680 CFIIndex = MF.addFrameInst(MCCFIInstruction::createRestoreState(nullptr));
1682 case MIToken::kw_cfi_undefined:
1683 if (parseCFIRegister(Reg))
1685 CFIIndex = MF.addFrameInst(MCCFIInstruction::createUndefined(nullptr, Reg));
1687 case MIToken::kw_cfi_register: {
1689 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1690 parseCFIRegister(Reg2))
1694 MF.addFrameInst(MCCFIInstruction::createRegister(nullptr, Reg, Reg2));
1697 case MIToken::kw_cfi_window_save:
1698 CFIIndex = MF.addFrameInst(MCCFIInstruction::createWindowSave(nullptr));
1700 case MIToken::kw_cfi_escape: {
1702 if (parseCFIEscapeValues(Values))
1704 CFIIndex = MF.addFrameInst(MCCFIInstruction::createEscape(nullptr, Values));
1708 // TODO: Parse the other CFI operands.
1709 llvm_unreachable("The current token should be a cfi operand");
1711 Dest = MachineOperand::CreateCFIIndex(CFIIndex);
1715 bool MIParser::parseIRBlock(BasicBlock *&BB, const Function &F) {
1716 switch (Token.kind()) {
1717 case MIToken::NamedIRBlock: {
1718 BB = dyn_cast_or_null<BasicBlock>(
1719 F.getValueSymbolTable()->lookup(Token.stringValue()));
1721 return error(Twine("use of undefined IR block '") + Token.range() + "'");
1724 case MIToken::IRBlock: {
1725 unsigned SlotNumber = 0;
1726 if (getUnsigned(SlotNumber))
1728 BB = const_cast<BasicBlock *>(getIRBlock(SlotNumber, F));
1730 return error(Twine("use of undefined IR block '%ir-block.") +
1731 Twine(SlotNumber) + "'");
1735 llvm_unreachable("The current token should be an IR block reference");
1740 bool MIParser::parseBlockAddressOperand(MachineOperand &Dest) {
1741 assert(Token.is(MIToken::kw_blockaddress));
1743 if (expectAndConsume(MIToken::lparen))
1745 if (Token.isNot(MIToken::GlobalValue) &&
1746 Token.isNot(MIToken::NamedGlobalValue))
1747 return error("expected a global value");
1748 GlobalValue *GV = nullptr;
1749 if (parseGlobalValue(GV))
1751 auto *F = dyn_cast<Function>(GV);
1753 return error("expected an IR function reference");
1755 if (expectAndConsume(MIToken::comma))
1757 BasicBlock *BB = nullptr;
1758 if (Token.isNot(MIToken::IRBlock) && Token.isNot(MIToken::NamedIRBlock))
1759 return error("expected an IR block reference");
1760 if (parseIRBlock(BB, *F))
1763 if (expectAndConsume(MIToken::rparen))
1765 Dest = MachineOperand::CreateBA(BlockAddress::get(F, BB), /*Offset=*/0);
1766 if (parseOperandsOffset(Dest))
1771 bool MIParser::parseIntrinsicOperand(MachineOperand &Dest) {
1772 assert(Token.is(MIToken::kw_intrinsic));
1774 if (expectAndConsume(MIToken::lparen))
1775 return error("expected syntax intrinsic(@llvm.whatever)");
1777 if (Token.isNot(MIToken::NamedGlobalValue))
1778 return error("expected syntax intrinsic(@llvm.whatever)");
1780 std::string Name = Token.stringValue();
1783 if (expectAndConsume(MIToken::rparen))
1784 return error("expected ')' to terminate intrinsic name");
1786 // Find out what intrinsic we're dealing with, first try the global namespace
1787 // and then the target's private intrinsics if that fails.
1788 const TargetIntrinsicInfo *TII = MF.getTarget().getIntrinsicInfo();
1789 Intrinsic::ID ID = Function::lookupIntrinsicID(Name);
1790 if (ID == Intrinsic::not_intrinsic && TII)
1791 ID = static_cast<Intrinsic::ID>(TII->lookupName(Name));
1793 if (ID == Intrinsic::not_intrinsic)
1794 return error("unknown intrinsic name");
1795 Dest = MachineOperand::CreateIntrinsicID(ID);
1800 bool MIParser::parsePredicateOperand(MachineOperand &Dest) {
1801 assert(Token.is(MIToken::kw_intpred) || Token.is(MIToken::kw_floatpred));
1802 bool IsFloat = Token.is(MIToken::kw_floatpred);
1805 if (expectAndConsume(MIToken::lparen))
1806 return error("expected syntax intpred(whatever) or floatpred(whatever");
1808 if (Token.isNot(MIToken::Identifier))
1809 return error("whatever");
1811 CmpInst::Predicate Pred;
1813 Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
1814 .Case("false", CmpInst::FCMP_FALSE)
1815 .Case("oeq", CmpInst::FCMP_OEQ)
1816 .Case("ogt", CmpInst::FCMP_OGT)
1817 .Case("oge", CmpInst::FCMP_OGE)
1818 .Case("olt", CmpInst::FCMP_OLT)
1819 .Case("ole", CmpInst::FCMP_OLE)
1820 .Case("one", CmpInst::FCMP_ONE)
1821 .Case("ord", CmpInst::FCMP_ORD)
1822 .Case("uno", CmpInst::FCMP_UNO)
1823 .Case("ueq", CmpInst::FCMP_UEQ)
1824 .Case("ugt", CmpInst::FCMP_UGT)
1825 .Case("uge", CmpInst::FCMP_UGE)
1826 .Case("ult", CmpInst::FCMP_ULT)
1827 .Case("ule", CmpInst::FCMP_ULE)
1828 .Case("une", CmpInst::FCMP_UNE)
1829 .Case("true", CmpInst::FCMP_TRUE)
1830 .Default(CmpInst::BAD_FCMP_PREDICATE);
1831 if (!CmpInst::isFPPredicate(Pred))
1832 return error("invalid floating-point predicate");
1834 Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
1835 .Case("eq", CmpInst::ICMP_EQ)
1836 .Case("ne", CmpInst::ICMP_NE)
1837 .Case("sgt", CmpInst::ICMP_SGT)
1838 .Case("sge", CmpInst::ICMP_SGE)
1839 .Case("slt", CmpInst::ICMP_SLT)
1840 .Case("sle", CmpInst::ICMP_SLE)
1841 .Case("ugt", CmpInst::ICMP_UGT)
1842 .Case("uge", CmpInst::ICMP_UGE)
1843 .Case("ult", CmpInst::ICMP_ULT)
1844 .Case("ule", CmpInst::ICMP_ULE)
1845 .Default(CmpInst::BAD_ICMP_PREDICATE);
1846 if (!CmpInst::isIntPredicate(Pred))
1847 return error("invalid integer predicate");
1851 Dest = MachineOperand::CreatePredicate(Pred);
1852 if (expectAndConsume(MIToken::rparen))
1853 return error("predicate should be terminated by ')'.");
1858 bool MIParser::parseTargetIndexOperand(MachineOperand &Dest) {
1859 assert(Token.is(MIToken::kw_target_index));
1861 if (expectAndConsume(MIToken::lparen))
1863 if (Token.isNot(MIToken::Identifier))
1864 return error("expected the name of the target index");
1866 if (getTargetIndex(Token.stringValue(), Index))
1867 return error("use of undefined target index '" + Token.stringValue() + "'");
1869 if (expectAndConsume(MIToken::rparen))
1871 Dest = MachineOperand::CreateTargetIndex(unsigned(Index), /*Offset=*/0);
1872 if (parseOperandsOffset(Dest))
1877 bool MIParser::parseCustomRegisterMaskOperand(MachineOperand &Dest) {
1878 assert(Token.stringValue() == "CustomRegMask" && "Expected a custom RegMask");
1879 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
1880 assert(TRI && "Expected target register info");
1882 if (expectAndConsume(MIToken::lparen))
1885 uint32_t *Mask = MF.allocateRegisterMask(TRI->getNumRegs());
1887 if (Token.isNot(MIToken::NamedRegister))
1888 return error("expected a named register");
1890 if (parseNamedRegister(Reg))
1893 Mask[Reg / 32] |= 1U << (Reg % 32);
1894 // TODO: Report an error if the same register is used more than once.
1895 if (Token.isNot(MIToken::comma))
1900 if (expectAndConsume(MIToken::rparen))
1902 Dest = MachineOperand::CreateRegMask(Mask);
1906 bool MIParser::parseLiveoutRegisterMaskOperand(MachineOperand &Dest) {
1907 assert(Token.is(MIToken::kw_liveout));
1908 const auto *TRI = MF.getSubtarget().getRegisterInfo();
1909 assert(TRI && "Expected target register info");
1910 uint32_t *Mask = MF.allocateRegisterMask(TRI->getNumRegs());
1912 if (expectAndConsume(MIToken::lparen))
1915 if (Token.isNot(MIToken::NamedRegister))
1916 return error("expected a named register");
1918 if (parseNamedRegister(Reg))
1921 Mask[Reg / 32] |= 1U << (Reg % 32);
1922 // TODO: Report an error if the same register is used more than once.
1923 if (Token.isNot(MIToken::comma))
1927 if (expectAndConsume(MIToken::rparen))
1929 Dest = MachineOperand::CreateRegLiveOut(Mask);
1933 bool MIParser::parseMachineOperand(MachineOperand &Dest,
1934 Optional<unsigned> &TiedDefIdx) {
1935 switch (Token.kind()) {
1936 case MIToken::kw_implicit:
1937 case MIToken::kw_implicit_define:
1938 case MIToken::kw_def:
1939 case MIToken::kw_dead:
1940 case MIToken::kw_killed:
1941 case MIToken::kw_undef:
1942 case MIToken::kw_internal:
1943 case MIToken::kw_early_clobber:
1944 case MIToken::kw_debug_use:
1945 case MIToken::kw_renamable:
1946 case MIToken::underscore:
1947 case MIToken::NamedRegister:
1948 case MIToken::VirtualRegister:
1949 return parseRegisterOperand(Dest, TiedDefIdx);
1950 case MIToken::IntegerLiteral:
1951 return parseImmediateOperand(Dest);
1952 case MIToken::IntegerType:
1953 return parseTypedImmediateOperand(Dest);
1954 case MIToken::kw_half:
1955 case MIToken::kw_float:
1956 case MIToken::kw_double:
1957 case MIToken::kw_x86_fp80:
1958 case MIToken::kw_fp128:
1959 case MIToken::kw_ppc_fp128:
1960 return parseFPImmediateOperand(Dest);
1961 case MIToken::MachineBasicBlock:
1962 return parseMBBOperand(Dest);
1963 case MIToken::StackObject:
1964 return parseStackObjectOperand(Dest);
1965 case MIToken::FixedStackObject:
1966 return parseFixedStackObjectOperand(Dest);
1967 case MIToken::GlobalValue:
1968 case MIToken::NamedGlobalValue:
1969 return parseGlobalAddressOperand(Dest);
1970 case MIToken::ConstantPoolItem:
1971 return parseConstantPoolIndexOperand(Dest);
1972 case MIToken::JumpTableIndex:
1973 return parseJumpTableIndexOperand(Dest);
1974 case MIToken::ExternalSymbol:
1975 return parseExternalSymbolOperand(Dest);
1976 case MIToken::SubRegisterIndex:
1977 return parseSubRegisterIndexOperand(Dest);
1978 case MIToken::md_diexpr:
1979 case MIToken::exclaim:
1980 return parseMetadataOperand(Dest);
1981 case MIToken::kw_cfi_same_value:
1982 case MIToken::kw_cfi_offset:
1983 case MIToken::kw_cfi_rel_offset:
1984 case MIToken::kw_cfi_def_cfa_register:
1985 case MIToken::kw_cfi_def_cfa_offset:
1986 case MIToken::kw_cfi_adjust_cfa_offset:
1987 case MIToken::kw_cfi_escape:
1988 case MIToken::kw_cfi_def_cfa:
1989 case MIToken::kw_cfi_register:
1990 case MIToken::kw_cfi_remember_state:
1991 case MIToken::kw_cfi_restore:
1992 case MIToken::kw_cfi_restore_state:
1993 case MIToken::kw_cfi_undefined:
1994 case MIToken::kw_cfi_window_save:
1995 return parseCFIOperand(Dest);
1996 case MIToken::kw_blockaddress:
1997 return parseBlockAddressOperand(Dest);
1998 case MIToken::kw_intrinsic:
1999 return parseIntrinsicOperand(Dest);
2000 case MIToken::kw_target_index:
2001 return parseTargetIndexOperand(Dest);
2002 case MIToken::kw_liveout:
2003 return parseLiveoutRegisterMaskOperand(Dest);
2004 case MIToken::kw_floatpred:
2005 case MIToken::kw_intpred:
2006 return parsePredicateOperand(Dest);
2007 case MIToken::Error:
2009 case MIToken::Identifier:
2010 if (const auto *RegMask = getRegMask(Token.stringValue())) {
2011 Dest = MachineOperand::CreateRegMask(RegMask);
2015 return parseCustomRegisterMaskOperand(Dest);
2017 // FIXME: Parse the MCSymbol machine operand.
2018 return error("expected a machine operand");
2023 bool MIParser::parseMachineOperandAndTargetFlags(
2024 MachineOperand &Dest, Optional<unsigned> &TiedDefIdx) {
2026 bool HasTargetFlags = false;
2027 if (Token.is(MIToken::kw_target_flags)) {
2028 HasTargetFlags = true;
2030 if (expectAndConsume(MIToken::lparen))
2032 if (Token.isNot(MIToken::Identifier))
2033 return error("expected the name of the target flag");
2034 if (getDirectTargetFlag(Token.stringValue(), TF)) {
2035 if (getBitmaskTargetFlag(Token.stringValue(), TF))
2036 return error("use of undefined target flag '" + Token.stringValue() +
2040 while (Token.is(MIToken::comma)) {
2042 if (Token.isNot(MIToken::Identifier))
2043 return error("expected the name of the target flag");
2044 unsigned BitFlag = 0;
2045 if (getBitmaskTargetFlag(Token.stringValue(), BitFlag))
2046 return error("use of undefined target flag '" + Token.stringValue() +
2048 // TODO: Report an error when using a duplicate bit target flag.
2052 if (expectAndConsume(MIToken::rparen))
2055 auto Loc = Token.location();
2056 if (parseMachineOperand(Dest, TiedDefIdx))
2058 if (!HasTargetFlags)
2061 return error(Loc, "register operands can't have target flags");
2062 Dest.setTargetFlags(TF);
2066 bool MIParser::parseOffset(int64_t &Offset) {
2067 if (Token.isNot(MIToken::plus) && Token.isNot(MIToken::minus))
2069 StringRef Sign = Token.range();
2070 bool IsNegative = Token.is(MIToken::minus);
2072 if (Token.isNot(MIToken::IntegerLiteral))
2073 return error("expected an integer literal after '" + Sign + "'");
2074 if (Token.integerValue().getMinSignedBits() > 64)
2075 return error("expected 64-bit integer (too large)");
2076 Offset = Token.integerValue().getExtValue();
2083 bool MIParser::parseAlignment(unsigned &Alignment) {
2084 assert(Token.is(MIToken::kw_align));
2086 if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
2087 return error("expected an integer literal after 'align'");
2088 if (getUnsigned(Alignment))
2094 bool MIParser::parseOperandsOffset(MachineOperand &Op) {
2096 if (parseOffset(Offset))
2098 Op.setOffset(Offset);
2102 bool MIParser::parseIRValue(const Value *&V) {
2103 switch (Token.kind()) {
2104 case MIToken::NamedIRValue: {
2105 V = MF.getFunction().getValueSymbolTable()->lookup(Token.stringValue());
2108 case MIToken::IRValue: {
2109 unsigned SlotNumber = 0;
2110 if (getUnsigned(SlotNumber))
2112 V = getIRValue(SlotNumber);
2115 case MIToken::NamedGlobalValue:
2116 case MIToken::GlobalValue: {
2117 GlobalValue *GV = nullptr;
2118 if (parseGlobalValue(GV))
2123 case MIToken::QuotedIRValue: {
2124 const Constant *C = nullptr;
2125 if (parseIRConstant(Token.location(), Token.stringValue(), C))
2131 llvm_unreachable("The current token should be an IR block reference");
2134 return error(Twine("use of undefined IR value '") + Token.range() + "'");
2138 bool MIParser::getUint64(uint64_t &Result) {
2139 if (Token.hasIntegerValue()) {
2140 if (Token.integerValue().getActiveBits() > 64)
2141 return error("expected 64-bit integer (too large)");
2142 Result = Token.integerValue().getZExtValue();
2145 if (Token.is(MIToken::HexLiteral)) {
2149 if (A.getBitWidth() > 64)
2150 return error("expected 64-bit integer (too large)");
2151 Result = A.getZExtValue();
2157 bool MIParser::getHexUint(APInt &Result) {
2158 assert(Token.is(MIToken::HexLiteral));
2159 StringRef S = Token.range();
2160 assert(S[0] == '0' && tolower(S[1]) == 'x');
2161 // This could be a floating point literal with a special prefix.
2162 if (!isxdigit(S[2]))
2164 StringRef V = S.substr(2);
2165 APInt A(V.size()*4, V, 16);
2167 // If A is 0, then A.getActiveBits() is 0. This isn't a valid bitwidth. Make
2168 // sure it isn't the case before constructing result.
2169 unsigned NumBits = (A == 0) ? 32 : A.getActiveBits();
2170 Result = APInt(NumBits, ArrayRef<uint64_t>(A.getRawData(), A.getNumWords()));
2174 bool MIParser::parseMemoryOperandFlag(MachineMemOperand::Flags &Flags) {
2175 const auto OldFlags = Flags;
2176 switch (Token.kind()) {
2177 case MIToken::kw_volatile:
2178 Flags |= MachineMemOperand::MOVolatile;
2180 case MIToken::kw_non_temporal:
2181 Flags |= MachineMemOperand::MONonTemporal;
2183 case MIToken::kw_dereferenceable:
2184 Flags |= MachineMemOperand::MODereferenceable;
2186 case MIToken::kw_invariant:
2187 Flags |= MachineMemOperand::MOInvariant;
2189 case MIToken::StringConstant: {
2190 MachineMemOperand::Flags TF;
2191 if (getMMOTargetFlag(Token.stringValue(), TF))
2192 return error("use of undefined target MMO flag '" + Token.stringValue() +
2198 llvm_unreachable("The current token should be a memory operand flag");
2200 if (OldFlags == Flags)
2201 // We know that the same flag is specified more than once when the flags
2202 // weren't modified.
2203 return error("duplicate '" + Token.stringValue() + "' memory operand flag");
2208 bool MIParser::parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV) {
2209 switch (Token.kind()) {
2210 case MIToken::kw_stack:
2211 PSV = MF.getPSVManager().getStack();
2213 case MIToken::kw_got:
2214 PSV = MF.getPSVManager().getGOT();
2216 case MIToken::kw_jump_table:
2217 PSV = MF.getPSVManager().getJumpTable();
2219 case MIToken::kw_constant_pool:
2220 PSV = MF.getPSVManager().getConstantPool();
2222 case MIToken::FixedStackObject: {
2224 if (parseFixedStackFrameIndex(FI))
2226 PSV = MF.getPSVManager().getFixedStack(FI);
2227 // The token was already consumed, so use return here instead of break.
2230 case MIToken::StackObject: {
2232 if (parseStackFrameIndex(FI))
2234 PSV = MF.getPSVManager().getFixedStack(FI);
2235 // The token was already consumed, so use return here instead of break.
2238 case MIToken::kw_call_entry:
2240 switch (Token.kind()) {
2241 case MIToken::GlobalValue:
2242 case MIToken::NamedGlobalValue: {
2243 GlobalValue *GV = nullptr;
2244 if (parseGlobalValue(GV))
2246 PSV = MF.getPSVManager().getGlobalValueCallEntry(GV);
2249 case MIToken::ExternalSymbol:
2250 PSV = MF.getPSVManager().getExternalSymbolCallEntry(
2251 MF.createExternalSymbolName(Token.stringValue()));
2255 "expected a global value or an external symbol after 'call-entry'");
2259 llvm_unreachable("The current token should be pseudo source value");
2265 bool MIParser::parseMachinePointerInfo(MachinePointerInfo &Dest) {
2266 if (Token.is(MIToken::kw_constant_pool) || Token.is(MIToken::kw_stack) ||
2267 Token.is(MIToken::kw_got) || Token.is(MIToken::kw_jump_table) ||
2268 Token.is(MIToken::FixedStackObject) || Token.is(MIToken::StackObject) ||
2269 Token.is(MIToken::kw_call_entry)) {
2270 const PseudoSourceValue *PSV = nullptr;
2271 if (parseMemoryPseudoSourceValue(PSV))
2274 if (parseOffset(Offset))
2276 Dest = MachinePointerInfo(PSV, Offset);
2279 if (Token.isNot(MIToken::NamedIRValue) && Token.isNot(MIToken::IRValue) &&
2280 Token.isNot(MIToken::GlobalValue) &&
2281 Token.isNot(MIToken::NamedGlobalValue) &&
2282 Token.isNot(MIToken::QuotedIRValue))
2283 return error("expected an IR value reference");
2284 const Value *V = nullptr;
2285 if (parseIRValue(V))
2287 if (!V->getType()->isPointerTy())
2288 return error("expected a pointer IR value");
2291 if (parseOffset(Offset))
2293 Dest = MachinePointerInfo(V, Offset);
2297 bool MIParser::parseOptionalScope(LLVMContext &Context,
2298 SyncScope::ID &SSID) {
2299 SSID = SyncScope::System;
2300 if (Token.is(MIToken::Identifier) && Token.stringValue() == "syncscope") {
2302 if (expectAndConsume(MIToken::lparen))
2303 return error("expected '(' in syncscope");
2306 if (parseStringConstant(SSN))
2309 SSID = Context.getOrInsertSyncScopeID(SSN);
2310 if (expectAndConsume(MIToken::rparen))
2311 return error("expected ')' in syncscope");
2317 bool MIParser::parseOptionalAtomicOrdering(AtomicOrdering &Order) {
2318 Order = AtomicOrdering::NotAtomic;
2319 if (Token.isNot(MIToken::Identifier))
2322 Order = StringSwitch<AtomicOrdering>(Token.stringValue())
2323 .Case("unordered", AtomicOrdering::Unordered)
2324 .Case("monotonic", AtomicOrdering::Monotonic)
2325 .Case("acquire", AtomicOrdering::Acquire)
2326 .Case("release", AtomicOrdering::Release)
2327 .Case("acq_rel", AtomicOrdering::AcquireRelease)
2328 .Case("seq_cst", AtomicOrdering::SequentiallyConsistent)
2329 .Default(AtomicOrdering::NotAtomic);
2331 if (Order != AtomicOrdering::NotAtomic) {
2336 return error("expected an atomic scope, ordering or a size integer literal");
2339 bool MIParser::parseMachineMemoryOperand(MachineMemOperand *&Dest) {
2340 if (expectAndConsume(MIToken::lparen))
2342 MachineMemOperand::Flags Flags = MachineMemOperand::MONone;
2343 while (Token.isMemoryOperandFlag()) {
2344 if (parseMemoryOperandFlag(Flags))
2347 if (Token.isNot(MIToken::Identifier) ||
2348 (Token.stringValue() != "load" && Token.stringValue() != "store"))
2349 return error("expected 'load' or 'store' memory operation");
2350 if (Token.stringValue() == "load")
2351 Flags |= MachineMemOperand::MOLoad;
2353 Flags |= MachineMemOperand::MOStore;
2356 // Optional 'store' for operands that both load and store.
2357 if (Token.is(MIToken::Identifier) && Token.stringValue() == "store") {
2358 Flags |= MachineMemOperand::MOStore;
2362 // Optional synchronization scope.
2364 if (parseOptionalScope(MF.getFunction().getContext(), SSID))
2367 // Up to two atomic orderings (cmpxchg provides guarantees on failure).
2368 AtomicOrdering Order, FailureOrder;
2369 if (parseOptionalAtomicOrdering(Order))
2372 if (parseOptionalAtomicOrdering(FailureOrder))
2375 if (Token.isNot(MIToken::IntegerLiteral))
2376 return error("expected the size integer literal after memory operation");
2378 if (getUint64(Size))
2382 MachinePointerInfo Ptr = MachinePointerInfo();
2383 if (Token.is(MIToken::Identifier)) {
2385 ((Flags & MachineMemOperand::MOLoad) &&
2386 (Flags & MachineMemOperand::MOStore))
2388 : Flags & MachineMemOperand::MOLoad ? "from" : "into";
2389 if (Token.stringValue() != Word)
2390 return error(Twine("expected '") + Word + "'");
2393 if (parseMachinePointerInfo(Ptr))
2396 unsigned BaseAlignment = Size;
2398 MDNode *Range = nullptr;
2399 while (consumeIfPresent(MIToken::comma)) {
2400 switch (Token.kind()) {
2401 case MIToken::kw_align:
2402 if (parseAlignment(BaseAlignment))
2405 case MIToken::md_tbaa:
2407 if (parseMDNode(AAInfo.TBAA))
2410 case MIToken::md_alias_scope:
2412 if (parseMDNode(AAInfo.Scope))
2415 case MIToken::md_noalias:
2417 if (parseMDNode(AAInfo.NoAlias))
2420 case MIToken::md_range:
2422 if (parseMDNode(Range))
2425 // TODO: Report an error on duplicate metadata nodes.
2427 return error("expected 'align' or '!tbaa' or '!alias.scope' or "
2428 "'!noalias' or '!range'");
2431 if (expectAndConsume(MIToken::rparen))
2433 Dest = MF.getMachineMemOperand(Ptr, Flags, Size, BaseAlignment, AAInfo, Range,
2434 SSID, Order, FailureOrder);
2438 void MIParser::initNames2InstrOpCodes() {
2439 if (!Names2InstrOpCodes.empty())
2441 const auto *TII = MF.getSubtarget().getInstrInfo();
2442 assert(TII && "Expected target instruction info");
2443 for (unsigned I = 0, E = TII->getNumOpcodes(); I < E; ++I)
2444 Names2InstrOpCodes.insert(std::make_pair(StringRef(TII->getName(I)), I));
2447 bool MIParser::parseInstrName(StringRef InstrName, unsigned &OpCode) {
2448 initNames2InstrOpCodes();
2449 auto InstrInfo = Names2InstrOpCodes.find(InstrName);
2450 if (InstrInfo == Names2InstrOpCodes.end())
2452 OpCode = InstrInfo->getValue();
2456 void MIParser::initNames2Regs() {
2457 if (!Names2Regs.empty())
2459 // The '%noreg' register is the register 0.
2460 Names2Regs.insert(std::make_pair("noreg", 0));
2461 const auto *TRI = MF.getSubtarget().getRegisterInfo();
2462 assert(TRI && "Expected target register info");
2463 for (unsigned I = 0, E = TRI->getNumRegs(); I < E; ++I) {
2465 Names2Regs.insert(std::make_pair(StringRef(TRI->getName(I)).lower(), I))
2468 assert(WasInserted && "Expected registers to be unique case-insensitively");
2472 bool MIParser::getRegisterByName(StringRef RegName, unsigned &Reg) {
2474 auto RegInfo = Names2Regs.find(RegName);
2475 if (RegInfo == Names2Regs.end())
2477 Reg = RegInfo->getValue();
2481 void MIParser::initNames2RegMasks() {
2482 if (!Names2RegMasks.empty())
2484 const auto *TRI = MF.getSubtarget().getRegisterInfo();
2485 assert(TRI && "Expected target register info");
2486 ArrayRef<const uint32_t *> RegMasks = TRI->getRegMasks();
2487 ArrayRef<const char *> RegMaskNames = TRI->getRegMaskNames();
2488 assert(RegMasks.size() == RegMaskNames.size());
2489 for (size_t I = 0, E = RegMasks.size(); I < E; ++I)
2490 Names2RegMasks.insert(
2491 std::make_pair(StringRef(RegMaskNames[I]).lower(), RegMasks[I]));
2494 const uint32_t *MIParser::getRegMask(StringRef Identifier) {
2495 initNames2RegMasks();
2496 auto RegMaskInfo = Names2RegMasks.find(Identifier);
2497 if (RegMaskInfo == Names2RegMasks.end())
2499 return RegMaskInfo->getValue();
2502 void MIParser::initNames2SubRegIndices() {
2503 if (!Names2SubRegIndices.empty())
2505 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
2506 for (unsigned I = 1, E = TRI->getNumSubRegIndices(); I < E; ++I)
2507 Names2SubRegIndices.insert(
2508 std::make_pair(StringRef(TRI->getSubRegIndexName(I)).lower(), I));
2511 unsigned MIParser::getSubRegIndex(StringRef Name) {
2512 initNames2SubRegIndices();
2513 auto SubRegInfo = Names2SubRegIndices.find(Name);
2514 if (SubRegInfo == Names2SubRegIndices.end())
2516 return SubRegInfo->getValue();
2519 static void initSlots2BasicBlocks(
2521 DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
2522 ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
2523 MST.incorporateFunction(F);
2524 for (auto &BB : F) {
2527 int Slot = MST.getLocalSlot(&BB);
2530 Slots2BasicBlocks.insert(std::make_pair(unsigned(Slot), &BB));
2534 static const BasicBlock *getIRBlockFromSlot(
2536 const DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
2537 auto BlockInfo = Slots2BasicBlocks.find(Slot);
2538 if (BlockInfo == Slots2BasicBlocks.end())
2540 return BlockInfo->second;
2543 const BasicBlock *MIParser::getIRBlock(unsigned Slot) {
2544 if (Slots2BasicBlocks.empty())
2545 initSlots2BasicBlocks(MF.getFunction(), Slots2BasicBlocks);
2546 return getIRBlockFromSlot(Slot, Slots2BasicBlocks);
2549 const BasicBlock *MIParser::getIRBlock(unsigned Slot, const Function &F) {
2550 if (&F == &MF.getFunction())
2551 return getIRBlock(Slot);
2552 DenseMap<unsigned, const BasicBlock *> CustomSlots2BasicBlocks;
2553 initSlots2BasicBlocks(F, CustomSlots2BasicBlocks);
2554 return getIRBlockFromSlot(Slot, CustomSlots2BasicBlocks);
2557 static void mapValueToSlot(const Value *V, ModuleSlotTracker &MST,
2558 DenseMap<unsigned, const Value *> &Slots2Values) {
2559 int Slot = MST.getLocalSlot(V);
2562 Slots2Values.insert(std::make_pair(unsigned(Slot), V));
2565 /// Creates the mapping from slot numbers to function's unnamed IR values.
2566 static void initSlots2Values(const Function &F,
2567 DenseMap<unsigned, const Value *> &Slots2Values) {
2568 ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
2569 MST.incorporateFunction(F);
2570 for (const auto &Arg : F.args())
2571 mapValueToSlot(&Arg, MST, Slots2Values);
2572 for (const auto &BB : F) {
2573 mapValueToSlot(&BB, MST, Slots2Values);
2574 for (const auto &I : BB)
2575 mapValueToSlot(&I, MST, Slots2Values);
2579 const Value *MIParser::getIRValue(unsigned Slot) {
2580 if (Slots2Values.empty())
2581 initSlots2Values(MF.getFunction(), Slots2Values);
2582 auto ValueInfo = Slots2Values.find(Slot);
2583 if (ValueInfo == Slots2Values.end())
2585 return ValueInfo->second;
2588 void MIParser::initNames2TargetIndices() {
2589 if (!Names2TargetIndices.empty())
2591 const auto *TII = MF.getSubtarget().getInstrInfo();
2592 assert(TII && "Expected target instruction info");
2593 auto Indices = TII->getSerializableTargetIndices();
2594 for (const auto &I : Indices)
2595 Names2TargetIndices.insert(std::make_pair(StringRef(I.second), I.first));
2598 bool MIParser::getTargetIndex(StringRef Name, int &Index) {
2599 initNames2TargetIndices();
2600 auto IndexInfo = Names2TargetIndices.find(Name);
2601 if (IndexInfo == Names2TargetIndices.end())
2603 Index = IndexInfo->second;
2607 void MIParser::initNames2DirectTargetFlags() {
2608 if (!Names2DirectTargetFlags.empty())
2610 const auto *TII = MF.getSubtarget().getInstrInfo();
2611 assert(TII && "Expected target instruction info");
2612 auto Flags = TII->getSerializableDirectMachineOperandTargetFlags();
2613 for (const auto &I : Flags)
2614 Names2DirectTargetFlags.insert(
2615 std::make_pair(StringRef(I.second), I.first));
2618 bool MIParser::getDirectTargetFlag(StringRef Name, unsigned &Flag) {
2619 initNames2DirectTargetFlags();
2620 auto FlagInfo = Names2DirectTargetFlags.find(Name);
2621 if (FlagInfo == Names2DirectTargetFlags.end())
2623 Flag = FlagInfo->second;
2627 void MIParser::initNames2BitmaskTargetFlags() {
2628 if (!Names2BitmaskTargetFlags.empty())
2630 const auto *TII = MF.getSubtarget().getInstrInfo();
2631 assert(TII && "Expected target instruction info");
2632 auto Flags = TII->getSerializableBitmaskMachineOperandTargetFlags();
2633 for (const auto &I : Flags)
2634 Names2BitmaskTargetFlags.insert(
2635 std::make_pair(StringRef(I.second), I.first));
2638 bool MIParser::getBitmaskTargetFlag(StringRef Name, unsigned &Flag) {
2639 initNames2BitmaskTargetFlags();
2640 auto FlagInfo = Names2BitmaskTargetFlags.find(Name);
2641 if (FlagInfo == Names2BitmaskTargetFlags.end())
2643 Flag = FlagInfo->second;
2647 void MIParser::initNames2MMOTargetFlags() {
2648 if (!Names2MMOTargetFlags.empty())
2650 const auto *TII = MF.getSubtarget().getInstrInfo();
2651 assert(TII && "Expected target instruction info");
2652 auto Flags = TII->getSerializableMachineMemOperandTargetFlags();
2653 for (const auto &I : Flags)
2654 Names2MMOTargetFlags.insert(
2655 std::make_pair(StringRef(I.second), I.first));
2658 bool MIParser::getMMOTargetFlag(StringRef Name,
2659 MachineMemOperand::Flags &Flag) {
2660 initNames2MMOTargetFlags();
2661 auto FlagInfo = Names2MMOTargetFlags.find(Name);
2662 if (FlagInfo == Names2MMOTargetFlags.end())
2664 Flag = FlagInfo->second;
2668 bool MIParser::parseStringConstant(std::string &Result) {
2669 if (Token.isNot(MIToken::StringConstant))
2670 return error("expected string constant");
2671 Result = Token.stringValue();
2676 bool llvm::parseMachineBasicBlockDefinitions(PerFunctionMIParsingState &PFS,
2678 SMDiagnostic &Error) {
2679 return MIParser(PFS, Error, Src).parseBasicBlockDefinitions(PFS.MBBSlots);
2682 bool llvm::parseMachineInstructions(PerFunctionMIParsingState &PFS,
2683 StringRef Src, SMDiagnostic &Error) {
2684 return MIParser(PFS, Error, Src).parseBasicBlocks();
2687 bool llvm::parseMBBReference(PerFunctionMIParsingState &PFS,
2688 MachineBasicBlock *&MBB, StringRef Src,
2689 SMDiagnostic &Error) {
2690 return MIParser(PFS, Error, Src).parseStandaloneMBB(MBB);
2693 bool llvm::parseRegisterReference(PerFunctionMIParsingState &PFS,
2694 unsigned &Reg, StringRef Src,
2695 SMDiagnostic &Error) {
2696 return MIParser(PFS, Error, Src).parseStandaloneRegister(Reg);
2699 bool llvm::parseNamedRegisterReference(PerFunctionMIParsingState &PFS,
2700 unsigned &Reg, StringRef Src,
2701 SMDiagnostic &Error) {
2702 return MIParser(PFS, Error, Src).parseStandaloneNamedRegister(Reg);
2705 bool llvm::parseVirtualRegisterReference(PerFunctionMIParsingState &PFS,
2706 VRegInfo *&Info, StringRef Src,
2707 SMDiagnostic &Error) {
2708 return MIParser(PFS, Error, Src).parseStandaloneVirtualRegister(Info);
2711 bool llvm::parseStackObjectReference(PerFunctionMIParsingState &PFS,
2712 int &FI, StringRef Src,
2713 SMDiagnostic &Error) {
2714 return MIParser(PFS, Error, Src).parseStandaloneStackObject(FI);
2717 bool llvm::parseMDNode(PerFunctionMIParsingState &PFS,
2718 MDNode *&Node, StringRef Src, SMDiagnostic &Error) {
2719 return MIParser(PFS, Error, Src).parseStandaloneMDNode(Node);