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