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