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