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