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