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