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