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