85 if (&Subtarget == &NewSubtarget)
88 Names2InstrOpCodes.clear();
90 Names2RegMasks.clear();
91 Names2SubRegIndices.clear();
92 Names2TargetIndices.clear();
93 Names2DirectTargetFlags.clear();
94 Names2BitmaskTargetFlags.clear();
95 Names2MMOTargetFlags.clear();
97 initNames2RegClasses();
101void PerTargetMIParsingState::initNames2Regs() {
102 if (!Names2Regs.empty())
106 Names2Regs.insert(std::make_pair(
"noreg", 0));
108 assert(
TRI &&
"Expected target register info");
110 for (
unsigned I = 0, E =
TRI->getNumRegs();
I < E; ++
I) {
115 assert(WasInserted &&
"Expected registers to be unique case-insensitively");
122 auto RegInfo = Names2Regs.find(
RegName);
123 if (RegInfo == Names2Regs.end())
125 Reg = RegInfo->getValue();
131 const auto *
TRI = Subtarget.getRegisterInfo();
132 std::optional<uint8_t> FV =
TRI->getVRegFlagValue(FlagName);
139void PerTargetMIParsingState::initNames2InstrOpCodes() {
140 if (!Names2InstrOpCodes.
empty())
143 assert(
TII &&
"Expected target instruction info");
144 for (
unsigned I = 0, E =
TII->getNumOpcodes();
I < E; ++
I)
150 initNames2InstrOpCodes();
151 auto InstrInfo = Names2InstrOpCodes.find(InstrName);
152 if (InstrInfo == Names2InstrOpCodes.end())
154 OpCode = InstrInfo->getValue();
158void PerTargetMIParsingState::initNames2RegMasks() {
159 if (!Names2RegMasks.
empty())
162 assert(
TRI &&
"Expected target register info");
166 for (
size_t I = 0, E = RegMasks.
size();
I < E; ++
I)
172 initNames2RegMasks();
173 auto RegMaskInfo = Names2RegMasks.find(Identifier);
174 if (RegMaskInfo == Names2RegMasks.end())
176 return RegMaskInfo->getValue();
179void PerTargetMIParsingState::initNames2SubRegIndices() {
180 if (!Names2SubRegIndices.
empty())
183 for (
unsigned I = 1, E =
TRI->getNumSubRegIndices();
I < E; ++
I)
184 Names2SubRegIndices.
insert(
185 std::make_pair(
TRI->getSubRegIndexName(
I),
I));
189 initNames2SubRegIndices();
190 auto SubRegInfo = Names2SubRegIndices.find(Name);
191 if (SubRegInfo == Names2SubRegIndices.end())
193 return SubRegInfo->getValue();
196void PerTargetMIParsingState::initNames2TargetIndices() {
197 if (!Names2TargetIndices.
empty())
200 assert(
TII &&
"Expected target instruction info");
201 auto Indices =
TII->getSerializableTargetIndices();
202 for (
const auto &
I : Indices)
207 initNames2TargetIndices();
208 auto IndexInfo = Names2TargetIndices.find(Name);
209 if (IndexInfo == Names2TargetIndices.end())
211 Index = IndexInfo->second;
215void PerTargetMIParsingState::initNames2DirectTargetFlags() {
216 if (!Names2DirectTargetFlags.
empty())
220 assert(
TII &&
"Expected target instruction info");
221 auto Flags =
TII->getSerializableDirectMachineOperandTargetFlags();
222 for (
const auto &
I : Flags)
223 Names2DirectTargetFlags.
insert(
229 initNames2DirectTargetFlags();
230 auto FlagInfo = Names2DirectTargetFlags.find(Name);
231 if (FlagInfo == Names2DirectTargetFlags.end())
233 Flag = FlagInfo->second;
237void PerTargetMIParsingState::initNames2BitmaskTargetFlags() {
238 if (!Names2BitmaskTargetFlags.
empty())
242 assert(
TII &&
"Expected target instruction info");
243 auto Flags =
TII->getSerializableBitmaskMachineOperandTargetFlags();
244 for (
const auto &
I : Flags)
245 Names2BitmaskTargetFlags.
insert(
251 initNames2BitmaskTargetFlags();
252 auto FlagInfo = Names2BitmaskTargetFlags.find(Name);
253 if (FlagInfo == Names2BitmaskTargetFlags.end())
255 Flag = FlagInfo->second;
259void PerTargetMIParsingState::initNames2MMOTargetFlags() {
260 if (!Names2MMOTargetFlags.
empty())
264 assert(
TII &&
"Expected target instruction info");
265 auto Flags =
TII->getSerializableMachineMemOperandTargetFlags();
266 for (
const auto &
I : Flags)
272 initNames2MMOTargetFlags();
273 auto FlagInfo = Names2MMOTargetFlags.find(Name);
274 if (FlagInfo == Names2MMOTargetFlags.end())
276 Flag = FlagInfo->second;
280void PerTargetMIParsingState::initNames2RegClasses() {
281 if (!Names2RegClasses.
empty())
285 for (
unsigned I = 0, E =
TRI->getNumRegClasses();
I < E; ++
I) {
286 const auto *RC =
TRI->getRegClass(
I);
292void PerTargetMIParsingState::initNames2RegBanks() {
293 if (!Names2RegBanks.empty())
296 const RegisterBankInfo *RBI = Subtarget.getRegBankInfo();
304 Names2RegBanks.insert(
305 std::make_pair(StringRef(RegBank.getName()).lower(), &RegBank));
311 auto RegClassInfo = Names2RegClasses.find(Name);
312 if (RegClassInfo == Names2RegClasses.end())
314 return RegClassInfo->getValue();
318 auto RegBankInfo = Names2RegBanks.find(Name);
319 if (RegBankInfo == Names2RegBanks.end())
321 return RegBankInfo->getValue();
334 Info->
VReg =
MRI.createIncompleteVirtualRegister();
335 I.first->second = Info;
337 return *
I.first->second;
346 Info->
VReg =
MF.getRegInfo().createIncompleteVirtualRegister(
RegName);
347 I.first->second = Info;
349 return *
I.first->second;
357 Slots2Values.
insert(std::make_pair(
unsigned(Slot),
V));
365 for (
const auto &Arg :
F.args())
367 for (
const auto &BB :
F) {
369 for (
const auto &
I : BB)
384struct ParsedMachineOperand {
388 std::optional<unsigned> TiedDefIdx;
392 std::optional<unsigned> &TiedDefIdx)
393 : Operand(Operand), Begin(Begin),
End(
End), TiedDefIdx(TiedDefIdx) {
396 "Only used register operands can be tied");
403 StringRef
Source, CurrentSource;
405 PerFunctionMIParsingState &PFS;
407 DenseMap<unsigned, const BasicBlock *> Slots2BasicBlocks;
410 MIParser(PerFunctionMIParsingState &PFS, SMDiagnostic &
Error,
415 void lex(
unsigned SkipChar = 0);
428 parseBasicBlockDefinitions(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
429 bool parseBasicBlocks();
431 bool parseStandaloneMBB(MachineBasicBlock *&
MBB);
433 bool parseStandaloneVirtualRegister(VRegInfo *&Info);
435 bool parseStandaloneStackObject(
int &FI);
436 bool parseStandaloneMDNode(MDNode *&Node);
439 parseBasicBlockDefinition(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
440 bool parseBasicBlock(MachineBasicBlock &
MBB,
441 MachineBasicBlock *&AddFalthroughFrom);
442 bool parseBasicBlockLiveins(MachineBasicBlock &
MBB);
443 bool parseBasicBlockSuccessors(MachineBasicBlock &
MBB);
446 bool parseVirtualRegister(VRegInfo *&Info);
447 bool parseNamedVirtualRegister(VRegInfo *&Info);
448 bool parseRegister(
Register &
Reg, VRegInfo *&VRegInfo);
449 bool parseRegisterFlag(
RegState &Flags);
450 bool parseRegisterClassOrBank(VRegInfo &RegInfo);
451 bool parseSubRegisterIndex(
unsigned &SubReg);
452 bool parseRegisterTiedDefIndex(
unsigned &TiedDefIdx);
453 bool parseRegisterOperand(MachineOperand &Dest,
454 std::optional<unsigned> &TiedDefIdx,
456 bool parseImmediateOperand(MachineOperand &Dest);
457 bool parseInlineAsmOperandCount(InlineAsm::Flag &
F);
458 bool parseSymbolicInlineAsmOperand(
unsigned OpIdx, MachineOperand &Dest);
463 bool parseTypedImmediateOperand(MachineOperand &Dest);
464 bool parseFPImmediateOperand(MachineOperand &Dest);
466 bool parseMBBOperand(MachineOperand &Dest);
467 bool parseStackFrameIndex(
int &FI);
468 bool parseStackObjectOperand(MachineOperand &Dest);
469 bool parseFixedStackFrameIndex(
int &FI);
470 bool parseFixedStackObjectOperand(MachineOperand &Dest);
472 bool parseGlobalAddressOperand(MachineOperand &Dest);
473 bool parseConstantPoolIndexOperand(MachineOperand &Dest);
474 bool parseSubRegisterIndexOperand(MachineOperand &Dest);
475 bool parseJumpTableIndexOperand(MachineOperand &Dest);
476 bool parseExternalSymbolOperand(MachineOperand &Dest);
477 bool parseMCSymbolOperand(MachineOperand &Dest);
479 bool parseDIExpression(MDNode *&Expr);
480 bool parseDILocation(MDNode *&Expr);
481 bool parseMetadataOperand(MachineOperand &Dest);
482 bool parseCFIOffset(int64_t &
Offset);
483 bool parseCFIUnsigned(
unsigned &
Value);
484 bool parseCFIRegister(
unsigned &
Reg);
486 bool parseCFIEscapeValues(std::string&
Values);
487 bool parseCFIOperand(MachineOperand &Dest);
488 bool parseIRBlock(BasicBlock *&BB,
const Function &
F);
489 bool parseBlockAddressOperand(MachineOperand &Dest);
490 bool parseIntrinsicOperand(MachineOperand &Dest);
491 bool parsePredicateOperand(MachineOperand &Dest);
492 bool parseShuffleMaskOperand(MachineOperand &Dest);
493 bool parseTargetIndexOperand(MachineOperand &Dest);
494 bool parseDbgInstrRefOperand(MachineOperand &Dest);
495 bool parseCustomRegisterMaskOperand(MachineOperand &Dest);
496 bool parseLaneMaskOperand(MachineOperand &Dest);
497 bool parseLiveoutRegisterMaskOperand(MachineOperand &Dest);
498 bool parseMachineOperand(
const unsigned OpCode,
const unsigned OpIdx,
499 MachineOperand &Dest,
500 std::optional<unsigned> &TiedDefIdx);
501 bool parseMachineOperandAndTargetFlags(
const unsigned OpCode,
502 const unsigned OpIdx,
503 MachineOperand &Dest,
504 std::optional<unsigned> &TiedDefIdx);
505 bool parseOffset(int64_t &
Offset);
506 bool parseIRBlockAddressTaken(BasicBlock *&BB);
508 bool parseAddrspace(
unsigned &Addrspace);
509 bool parseSectionID(std::optional<MBBSectionID> &SID);
510 bool parseBBID(std::optional<UniqueBBID> &BBID);
511 bool parseCallFrameSize(
unsigned &CallFrameSize);
512 bool parseMaxBytesForAlignment(
unsigned &MaxBytesForAlignment);
514 bool parseOperandsOffset(MachineOperand &
Op);
517 bool parseMemoryPseudoSourceValue(
const PseudoSourceValue *&PSV);
518 bool parseMachinePointerInfo(MachinePointerInfo &Dest);
521 bool parseMachineMemoryOperand(MachineMemOperand *&Dest);
522 bool parsePreOrPostInstrSymbol(MCSymbol *&Symbol);
523 bool parseHeapAllocMarker(MDNode *&Node);
524 bool parsePCSections(MDNode *&Node);
525 bool parseMMRA(MDNode *&Node);
527 bool parseTargetImmMnemonic(
const unsigned OpCode,
const unsigned OpIdx,
528 MachineOperand &Dest,
const MIRFormatter &MF);
555 bool parseInstruction(
unsigned &OpCode,
unsigned &Flags);
557 bool assignRegisterTies(MachineInstr &
MI,
561 const MCInstrDesc &MCID);
567 MCSymbol *getOrCreateMCSymbol(StringRef Name);
571 bool parseStringConstant(std::string &Result);
581void MIParser::lex(
unsigned SkipChar) {
583 CurrentSource.substr(SkipChar), Token,
587bool MIParser::error(
const Twine &
Msg) {
return error(Token.location(),
Msg); }
622 return "<unknown token>";
627 if (Token.isNot(TokenKind))
634 if (Token.isNot(TokenKind))
641bool MIParser::parseSectionID(std::optional<MBBSectionID> &SID) {
647 return error(
"Unknown Section ID");
650 const StringRef &S = Token.stringValue();
651 if (S ==
"Exception")
653 else if (S ==
"Cold")
656 return error(
"Unknown Section ID");
663bool MIParser::parseBBID(std::optional<UniqueBBID> &BBID) {
665 return error(
"expected 'bb_id'");
668 unsigned CloneID = 0;
671 auto Parts = S.
split(
'.');
672 if (Parts.first.getAsInteger(10, BaseID) ||
673 Parts.second.getAsInteger(10, CloneID))
674 return error(
"Unknown BB ID");
678 return error(
"Unknown BB ID");
683 return error(
"Unknown Clone ID");
687 return error(
"Unknown Clone ID");
691 BBID = {BaseID, CloneID};
696bool MIParser::parseCallFrameSize(
unsigned &CallFrameSize) {
701 return error(
"Unknown call frame size");
702 CallFrameSize =
Value;
709bool MIParser::parseMaxBytesForAlignment(
unsigned &MaxBytesForAlignment) {
713 return error(
"expected an integer literal after 'max-bytes-for-alignment'");
717 MaxBytesForAlignment =
Value;
724 std::optional<UniqueBBID> BBID;
733bool MIParser::parseBasicBlockDefinition(
739 auto Loc = Token.location();
740 auto Name = Token.stringValue();
742 bool MachineBlockAddressTaken =
false;
743 bool LabelMustBeEmitted =
false;
745 bool IsLandingPad =
false;
746 bool IsInlineAsmBrIndirectTarget =
false;
747 bool IsEHFuncletEntry =
false;
748 bool IsEHScopeEntry =
false;
749 bool IsCleanupFuncletEntry =
false;
750 bool IsEHContTarget =
false;
751 std::optional<MBBSectionID> SectionID;
753 unsigned MaxBytesForAlignment = 0;
754 std::optional<UniqueBBID> BBID;
755 unsigned CallFrameSize = 0;
760 switch (Token.kind()) {
762 MachineBlockAddressTaken =
true;
766 LabelMustBeEmitted =
true;
770 if (parseIRBlockAddressTaken(AddressTakenIRBlock))
778 IsInlineAsmBrIndirectTarget =
true;
782 IsEHFuncletEntry =
true;
786 IsEHScopeEntry =
true;
790 IsCleanupFuncletEntry =
true;
794 IsEHContTarget =
true;
802 if (parseMaxBytesForAlignment(MaxBytesForAlignment))
808 if (parseIRBlock(BB, MF.getFunction()))
813 if (parseSectionID(SectionID))
821 if (parseCallFrameSize(CallFrameSize))
836 MF.getFunction().getValueSymbolTable()->lookup(Name));
839 "' is not defined in the function '" +
842 auto *
MBB = MF.CreateMachineBasicBlock(BB, BBID);
844 bool WasInserted = MBBSlots.
insert(std::make_pair(ID,
MBB)).second;
846 return error(
Loc,
Twine(
"redefinition of machine basic block with id #") +
850 else if (MaxBytesForAlignment)
851 return error(
Loc,
"'max-bytes-for-alignment' requires 'align'");
853 if (MachineBlockAddressTaken)
855 if (LabelMustBeEmitted)
857 if (AddressTakenIRBlock)
873bool MIParser::parseBasicBlockDefinitions(
879 if (Token.isErrorOrEOF())
880 return Token.isError();
882 return error(
"expected a basic block definition before instructions");
883 unsigned BraceDepth = 0;
885 if (parseBasicBlockDefinition(MBBSlots))
887 bool IsAfterNewline =
false;
891 Token.isErrorOrEOF())
894 return error(
"basic block definition should be located at the start of "
897 IsAfterNewline =
true;
900 IsAfterNewline =
false;
905 return error(
"extraneous closing brace ('}')");
911 if (!Token.isError() && BraceDepth)
912 return error(
"expected '}'");
913 }
while (!Token.isErrorOrEOF());
914 return Token.isError();
922 if (Token.isNewlineOrEOF())
926 return error(
"expected a named register");
928 if (parseNamedRegister(
Reg))
936 return error(
"expected a lane mask");
938 "Use correct get-function for lane mask");
941 return error(
"invalid lane mask value");
955 if (Token.isNewlineOrEOF())
959 return error(
"expected a machine basic block reference");
968 return error(
"expected an integer literal after '('");
1002 bool ExplicitSuccessors =
false;
1005 if (parseBasicBlockSuccessors(
MBB))
1007 ExplicitSuccessors =
true;
1009 if (parseBasicBlockLiveins(
MBB))
1016 if (!Token.isNewlineOrEOF())
1017 return error(
"expected line break at the end of a list");
1022 bool IsInBundle =
false;
1046 return error(
"nested instruction bundles are not allowed");
1055 assert(Token.isNewlineOrEOF() &&
"MI is not fully parsed");
1060 if (!ExplicitSuccessors) {
1067 if (IsFallthrough) {
1068 AddFalthroughFrom = &
MBB;
1077bool MIParser::parseBasicBlocks() {
1082 if (Token.isErrorOrEOF())
1083 return Token.isError();
1092 if (AddFalthroughFrom) {
1096 AddFalthroughFrom =
nullptr;
1098 if (parseBasicBlock(*
MBB, AddFalthroughFrom))
1111 while (Token.isRegister() || Token.isRegisterFlag()) {
1112 auto Loc = Token.location();
1113 std::optional<unsigned> TiedDefIdx;
1114 if (parseRegisterOperand(MO, TiedDefIdx,
true))
1117 ParsedMachineOperand(MO,
Loc, Token.location(), TiedDefIdx));
1126 if (Token.isError() || parseInstruction(OpCode, Flags))
1139 auto Loc = Token.location();
1140 std::optional<unsigned> TiedDefIdx;
1141 if (parseMachineOperandAndTargetFlags(OpCode,
Operands.size(), MO, TiedDefIdx))
1144 ParsedMachineOperand(MO,
Loc, Token.location(), TiedDefIdx));
1149 return error(
"expected ',' before the next machine operand");
1153 MCSymbol *PreInstrSymbol =
nullptr;
1155 if (parsePreOrPostInstrSymbol(PreInstrSymbol))
1157 MCSymbol *PostInstrSymbol =
nullptr;
1159 if (parsePreOrPostInstrSymbol(PostInstrSymbol))
1161 MDNode *HeapAllocMarker =
nullptr;
1163 if (parseHeapAllocMarker(HeapAllocMarker))
1165 MDNode *PCSections =
nullptr;
1167 if (parsePCSections(PCSections))
1172 unsigned CFIType = 0;
1176 return error(
"expected an integer literal after 'cfi-type'");
1194 unsigned InstrNum = 0;
1198 return error(
"expected an integer literal after 'debug-instr-number'");
1215 if (parseDILocation(Node))
1218 return error(
"expected a metadata node after 'debug-location'");
1222 return error(
"referenced metadata is not a DILocation");
1229 while (!Token.isNewlineOrEOF()) {
1231 if (parseMachineMemoryOperand(
MemOp))
1234 if (Token.isNewlineOrEOF())
1239 return error(
"expected ',' before the next machine memory operand");
1244 const auto &
MCID = MF.getSubtarget().getInstrInfo()->get(OpCode);
1245 if (!
MCID.isVariadic()) {
1251 MI = MF.CreateMachineInstr(
MCID, DebugLocation,
true);
1252 MI->setFlags(Flags);
1256 for (
const auto &Operand :
Operands)
1257 MI->addOperand(MF, Operand.Operand);
1262 MI->setPreInstrSymbol(MF, PreInstrSymbol);
1263 if (PostInstrSymbol)
1264 MI->setPostInstrSymbol(MF, PostInstrSymbol);
1265 if (HeapAllocMarker)
1266 MI->setHeapAllocMarker(MF, HeapAllocMarker);
1268 MI->setPCSections(MF, PCSections);
1270 MI->setMMRAMetadata(MF, MMRA);
1272 MI->setCFIType(MF, CFIType);
1274 MI->setDeactivationSymbol(MF, DS);
1275 if (!MemOperands.
empty())
1276 MI->setMemRefs(MF, MemOperands);
1278 MI->setDebugInstrNum(InstrNum);
1285 return error(
"expected a machine basic block reference");
1291 "expected end of string after the machine basic block reference");
1295bool MIParser::parseStandaloneNamedRegister(
Register &
Reg) {
1298 return error(
"expected a named register");
1299 if (parseNamedRegister(
Reg))
1303 return error(
"expected end of string after the register reference");
1307bool MIParser::parseStandaloneVirtualRegister(
VRegInfo *&Info) {
1310 return error(
"expected a virtual register");
1311 if (parseVirtualRegister(Info))
1315 return error(
"expected end of string after the register reference");
1319bool MIParser::parseStandaloneRegister(
Register &
Reg) {
1323 return error(
"expected either a named or virtual register");
1326 if (parseRegister(
Reg, Info))
1331 return error(
"expected end of string after the register reference");
1335bool MIParser::parseStandaloneStackObject(
int &FI) {
1338 return error(
"expected a stack object");
1339 if (parseStackFrameIndex(FI))
1342 return error(
"expected end of string after the stack object reference");
1346bool MIParser::parseStandaloneMDNode(
MDNode *&Node) {
1352 if (parseDIExpression(Node))
1355 if (parseDILocation(Node))
1358 return error(
"expected a metadata node");
1361 return error(
"expected end of string after the metadata node");
1367 return MO.
isDef() ?
"implicit-def" :
"implicit";
1372 assert(
Reg.isPhysical() &&
"expected phys reg");
1400 const auto *
TRI = MF.getSubtarget().getRegisterInfo();
1401 assert(
TRI &&
"Expected target register info");
1402 for (
const auto &
I : ImplicitOperands) {
1406 Twine(
"missing implicit register operand '") +
1413bool MIParser::parseInstruction(
unsigned &OpCode,
unsigned &Flags) {
1488 return error(
"expected a machine instruction");
1489 StringRef InstrName = Token.stringValue();
1490 if (PFS.Target.parseInstrName(InstrName, OpCode))
1491 return error(
Twine(
"unknown machine instruction name '") + InstrName +
"'");
1499 if (PFS.Target.getRegisterByName(Name,
Reg))
1500 return error(
Twine(
"unknown register name '") + Name +
"'");
1504bool MIParser::parseNamedVirtualRegister(
VRegInfo *&Info) {
1509 Info = &PFS.getVRegInfoNamed(Name);
1513bool MIParser::parseVirtualRegister(
VRegInfo *&Info) {
1515 return parseNamedVirtualRegister(Info);
1520 Info = &PFS.getVRegInfo(ID);
1525 switch (Token.kind()) {
1530 return parseNamedRegister(
Reg);
1533 if (parseVirtualRegister(Info))
1543bool MIParser::parseRegisterClassOrBank(
VRegInfo &RegInfo) {
1545 return error(
"expected '_', register class, or register bank name");
1554 switch (RegInfo.
Kind) {
1560 return error(
Loc,
Twine(
"conflicting register classes, previously: ") +
1569 return error(
Loc,
"register class specification on generic register");
1577 RegBank = PFS.Target.getRegBank(Name);
1579 return error(
Loc,
"expected '_', register class, or register bank name");
1584 switch (RegInfo.
Kind) {
1590 return error(
Loc,
"conflicting generic register banks");
1596 return error(
Loc,
"register bank specification on normal register");
1601bool MIParser::parseRegisterFlag(
RegState &Flags) {
1603 switch (Token.kind()) {
1637 if (OldFlags == Flags)
1640 return error(
"duplicate '" + Token.stringValue() +
"' register flag");
1645bool MIParser::parseSubRegisterIndex(
unsigned &SubReg) {
1649 return error(
"expected a subregister index after '.'");
1650 auto Name = Token.stringValue();
1651 SubReg = PFS.Target.getSubRegIndex(Name);
1653 return error(
Twine(
"use of unknown subregister index '") + Name +
"'");
1658bool MIParser::parseRegisterTiedDefIndex(
unsigned &TiedDefIdx) {
1662 return error(
"expected an integer literal after 'tied-def'");
1677 unsigned DefIdx = *
Operands[
I].TiedDefIdx;
1680 Twine(
"use of invalid tied-def operand index '" +
1681 Twine(DefIdx) +
"'; instruction has only ") +
1683 const auto &DefOperand =
Operands[DefIdx].Operand;
1684 if (!DefOperand.isReg() || !DefOperand.isDef())
1687 Twine(
"use of invalid tied-def operand index '") +
1688 Twine(DefIdx) +
"'; the operand #" +
Twine(DefIdx) +
1689 " isn't a defined register");
1691 for (
const auto &TiedPair : TiedRegisterPairs) {
1692 if (TiedPair.first == DefIdx)
1694 Twine(
"the tied-def operand #") +
Twine(DefIdx) +
1695 " is already tied with another register operand");
1697 TiedRegisterPairs.push_back(std::make_pair(DefIdx,
I));
1701 for (
const auto &TiedPair : TiedRegisterPairs)
1702 MI.tieOperands(TiedPair.first, TiedPair.second);
1707 std::optional<unsigned> &TiedDefIdx,
1710 while (Token.isRegisterFlag()) {
1711 if (parseRegisterFlag(Flags))
1716 if (!Token.isRegister())
1717 return error(
"expected a register after register flags");
1720 if (parseRegister(
Reg, RegInfo))
1723 unsigned SubReg = 0;
1725 if (parseSubRegisterIndex(SubReg))
1728 return error(
"subregister index expects a virtual register");
1732 return error(
"register class specification expects a virtual register");
1734 if (parseRegisterClassOrBank(*RegInfo))
1743 return error(
"tied-def not supported for defs");
1745 if (parseRegisterTiedDefIndex(Idx))
1750 return error(
"unexpected type on physical register");
1754 if (parseLowLevelType(Token.location(), Ty))
1756 :
error(
"expected tied-def or low-level type after '('");
1763 return error(
"inconsistent type for generic virtual register");
1773 return error(
"generic virtual registers must have a type");
1778 return error(
"cannot have a killed def operand");
1781 return error(
"cannot have a dead use operand");
1798 const APSInt &
Int = Token.integerValue();
1799 if (
auto SImm =
Int.trySExtValue();
Int.isSigned() && SImm.has_value())
1801 else if (
auto UImm =
Int.tryZExtValue(); !
Int.isSigned() && UImm.has_value())
1804 return error(
"integer literal is too large to be an immediate operand");
1817 return error(
"expected ':' after 'ops'");
1821 return error(
"expected an operand count after 'ops:'");
1828 return error(
"invalid inline asm operand count");
1830 F.setNumOperandRegisters(
NumOps);
1835bool MIParser::parseSymbolicInlineAsmOperand(
unsigned OpIdx,
1839 "expected symbolic inline asm operand");
1843 unsigned ExtraInfo = 0;
1848 StringRef FlagName = Token.stringValue();
1856 .
Case(
"attdialect", 0)
1860 return error(
"unknown inline asm extra info flag '" + FlagName +
"'");
1872 StringRef KindStr = Token.stringValue();
1883 if (K == InvalidKind)
1884 return error(
"unknown inline asm operand kind '" + KindStr +
"'");
1895 return error(
"expected ':' after 'tiedto'");
1898 return error(
"expected '$N' operand number after 'tiedto:'");
1900 if (Token.stringValue().getAsInteger(10, OperandNo))
1901 return error(
"invalid operand number in tiedto constraint");
1904 F.setMatchingOp(OperandNo);
1905 if (parseInlineAsmOperandCount(
F))
1918 "expected register class or memory constraint name after ':'");
1920 StringRef ConstraintStr = Token.stringValue();
1921 if (
F.isMemKind()) {
1955 return error(
"unknown memory constraint '" + ConstraintStr +
"'");
1956 F.setMemConstraint(
CC);
1957 }
else if (
F.isRegDefKind() ||
F.isRegUseKind() ||
1958 F.isRegDefEarlyClobberKind()) {
1960 PFS.Target.getRegClass(ConstraintStr.
lower());
1962 return error(
"unknown register class '" + ConstraintStr +
"'");
1963 F.setRegClass(RC->
getID());
1973 if (!
F.isRegDefKind() && !
F.isRegUseKind() && !
F.isRegDefEarlyClobberKind())
1974 return error(
"only a register operand can be 'foldable'");
1976 F.setRegMayBeFolded(
true);
1980 if (parseInlineAsmOperandCount(
F))
1987bool MIParser::parseTargetImmMnemonic(
const unsigned OpCode,
1988 const unsigned OpIdx,
1992 auto Loc = Token.location();
1998 Len += Token.range().size();
2007 Src =
StringRef(
Loc, Len + Token.stringValue().size());
2012 ->
bool { return error(Loc, Msg); }))
2024 auto Source = StringValue.
str();
2029 return ErrCB(
Loc + Err.getColumnNo(), Err.getMessage());
2035 return ::parseIRConstant(
2036 Loc, StringValue, PFS,
C,
2056 return NumElts != 0 && (HasVScale || NumElts != 1) &&
isUInt<16>(NumElts);
2070 "expected integers after 's'/'i'/'f'/'bf'/'p' type identifier");
2073 bool Scalar = Token.range().starts_with(
"s");
2074 if (Scalar || Token.range().starts_with(
"i")) {
2083 return error(
"invalid size for scalar type");
2090 if (Token.range().starts_with(
"p")) {
2094 return error(
"invalid address space number");
2101 if (Token.range().starts_with(
"f") || Token.range().starts_with(
"bf")) {
2104 return error(
"invalid size for scalar type");
2106 if (Token.range().starts_with(
"bf") && ScalarSize != 16)
2107 return error(
"invalid size for bfloat");
2110 :
LLT::floatIEEE(ScalarSize);
2117 return error(
Loc,
"expected tN, pA, <M x tN>, <M x pA>, <vscale x M x tN>, "
2118 "or <vscale x M x pA> for GlobalISel type, "
2119 "where t = {'s', 'i', 'f', 'bf'}");
2128 "expected <vscale x M x tN>, where t = {'s', 'i', 'f', 'bf', 'p'}");
2132 auto GetError = [
this, &HasVScale,
Loc]() {
2134 return error(
Loc,
"expected <vscale x M x tN> for vector type, where t = "
2135 "{'s', 'i', 'f', 'bf', 'p'}");
2136 return error(
Loc,
"expected <M x tN> for vector type, where t = {'s', 'i', "
2142 uint64_t NumElements = Token.integerValue().getZExtValue();
2144 return error(
"invalid number of vector elements");
2152 StringRef VectorTyDigits = Token.range();
2161 "expected integers after 's'/'i'/'f'/'bf'/'p' type identifier");
2163 Scalar = Token.range().starts_with(
"s");
2164 if (Scalar || Token.range().starts_with(
"i")) {
2167 return error(
"invalid size for scalar element in vector");
2169 }
else if (Token.range().starts_with(
"p")) {
2173 return error(
"invalid address space number");
2176 }
else if (Token.range().starts_with(
"f")) {
2179 return error(
"invalid size for float element in vector");
2181 }
else if (Token.range().starts_with(
"bf")) {
2184 return error(
"invalid size for bfloat element in vector");
2206 return error(
"a typed immediate operand should start with one of 'i', "
2207 "'s', 'f', 'bf', or 'p'");
2210 "expected integers after 'i'/'s'/'f'/'bf'/'p' type identifier");
2212 auto Loc = Token.location();
2216 !(Token.range() ==
"true" || Token.range() ==
"false"))
2217 return error(
"expected an integer literal");
2227 auto Loc = Token.location();
2231 return error(
"expected a floating point literal");
2242 assert(S[0] ==
'0' && tolower(S[1]) ==
'x');
2244 if (!isxdigit(S[2]))
2251 unsigned NumBits = (
A == 0) ? 32 :
A.getActiveBits();
2262 return ErrCB(Token.
location(),
"expected unsigned integer");
2265 return ErrCB(Token.
location(),
"expected 32-bit integer (too large)");
2273 if (
A.getBitWidth() > 32)
2274 return ErrCB(Token.
location(),
"expected 32-bit integer (too large)");
2275 Result =
A.getZExtValue();
2281bool MIParser::getUnsigned(
unsigned &Result) {
2282 return ::getUnsigned(
2294 auto MBBInfo = PFS.MBBSlots.find(
Number);
2295 if (MBBInfo == PFS.MBBSlots.end())
2296 return error(
Twine(
"use of undefined machine basic block #") +
2298 MBB = MBBInfo->second;
2301 if (!Token.stringValue().empty() && Token.stringValue() !=
MBB->
getName())
2303 " isn't '" + Token.stringValue() +
"'");
2316bool MIParser::parseStackFrameIndex(
int &FI) {
2321 auto ObjectInfo = PFS.StackObjectSlots.find(ID);
2322 if (ObjectInfo == PFS.StackObjectSlots.end())
2323 return error(
Twine(
"use of undefined stack object '%stack.") +
Twine(ID) +
2326 if (
const auto *Alloca =
2327 MF.getFrameInfo().getObjectAllocation(ObjectInfo->second))
2328 Name = Alloca->getName();
2329 if (!Token.stringValue().empty() && Token.stringValue() != Name)
2330 return error(
Twine(
"the name of the stack object '%stack.") +
Twine(ID) +
2331 "' isn't '" + Token.stringValue() +
"'");
2333 FI = ObjectInfo->second;
2339 if (parseStackFrameIndex(FI))
2345bool MIParser::parseFixedStackFrameIndex(
int &FI) {
2350 auto ObjectInfo = PFS.FixedStackObjectSlots.find(ID);
2351 if (ObjectInfo == PFS.FixedStackObjectSlots.end())
2352 return error(
Twine(
"use of undefined fixed stack object '%fixed-stack.") +
2355 FI = ObjectInfo->second;
2359bool MIParser::parseFixedStackObjectOperand(
MachineOperand &Dest) {
2361 if (parseFixedStackFrameIndex(FI))
2370 switch (Token.
kind()) {
2375 return ErrCB(Token.
location(),
Twine(
"use of undefined global value '") +
2376 Token.
range() +
"'");
2385 return ErrCB(Token.
location(),
Twine(
"use of undefined global value '@") +
2386 Twine(GVIdx) +
"'");
2395bool MIParser::parseGlobalValue(
GlobalValue *&GV) {
2396 return ::parseGlobalValue(
2409 if (parseOperandsOffset(Dest))
2414bool MIParser::parseConstantPoolIndexOperand(
MachineOperand &Dest) {
2421 return error(
"use of undefined constant '%const." +
Twine(ID) +
"'");
2424 if (parseOperandsOffset(Dest))
2434 auto JumpTableEntryInfo = PFS.JumpTableSlots.find(ID);
2435 if (JumpTableEntryInfo == PFS.JumpTableSlots.end())
2436 return error(
"use of undefined jump table '%jump-table." +
Twine(ID) +
"'");
2444 const char *
Symbol = MF.createExternalSymbolName(Token.stringValue());
2447 if (parseOperandsOffset(Dest))
2457 if (parseOperandsOffset(Dest))
2462bool MIParser::parseSubRegisterIndexOperand(
MachineOperand &Dest) {
2465 unsigned SubRegIndex = PFS.Target.getSubRegIndex(Token.stringValue());
2466 if (SubRegIndex == 0)
2467 return error(
Twine(
"unknown subregister index '") + Name +
"'");
2473bool MIParser::parseMDNode(
MDNode *&Node) {
2476 auto Loc = Token.location();
2479 return error(
"expected metadata id after '!'");
2483 auto NodeInfo = PFS.IRSlots.MetadataNodes.find(ID);
2484 if (NodeInfo == PFS.IRSlots.MetadataNodes.end()) {
2485 NodeInfo = PFS.MachineMetadataNodes.find(ID);
2486 if (NodeInfo == PFS.MachineMetadataNodes.end())
2487 return error(
Loc,
"use of undefined metadata '!" +
Twine(ID) +
"'");
2490 Node = NodeInfo->second.get();
2494bool MIParser::parseDIExpression(
MDNode *&Expr) {
2497 CurrentSource,
Read,
Error, *PFS.MF.getFunction().getParent(),
2499 CurrentSource = CurrentSource.substr(
Read);
2506bool MIParser::parseDILocation(
MDNode *&
Loc) {
2510 bool HaveLine =
false;
2512 unsigned Column = 0;
2514 MDNode *InlinedAt =
nullptr;
2515 bool ImplicitCode =
false;
2518 MDNode *IRLayers =
nullptr;
2526 if (Token.stringValue() ==
"line") {
2531 Token.integerValue().isSigned())
2532 return error(
"expected unsigned integer");
2533 Line = Token.integerValue().getZExtValue();
2538 if (Token.stringValue() ==
"column") {
2543 Token.integerValue().isSigned())
2544 return error(
"expected unsigned integer");
2545 Column = Token.integerValue().getZExtValue();
2549 if (Token.stringValue() ==
"scope") {
2554 return error(
"expected metadata node");
2556 return error(
"expected DIScope node");
2559 if (Token.stringValue() ==
"inlinedAt") {
2567 if (parseDILocation(InlinedAt))
2570 return error(
"expected metadata node");
2573 return error(
"expected DILocation node");
2576 if (Token.stringValue() ==
"isImplicitCode") {
2581 return error(
"expected true/false");
2585 if (Token.stringValue() ==
"true")
2586 ImplicitCode =
true;
2587 else if (Token.stringValue() ==
"false")
2588 ImplicitCode =
false;
2590 return error(
"expected true/false");
2594 if (Token.stringValue() ==
"atomGroup") {
2599 Token.integerValue().isSigned())
2600 return error(
"expected unsigned integer");
2601 AtomGroup = Token.integerValue().getZExtValue();
2605 if (Token.stringValue() ==
"atomRank") {
2610 Token.integerValue().isSigned())
2611 return error(
"expected unsigned integer");
2612 AtomRank = Token.integerValue().getZExtValue();
2616 if (Token.stringValue() ==
"irlayers") {
2621 return error(
"expected metadata node");
2623 return error(
"expected DILayerLocList node");
2627 return error(
Twine(
"invalid DILocation argument '") +
2628 Token.stringValue() +
"'");
2636 return error(
"DILocation requires line number");
2638 return error(
"DILocation requires a scope");
2641 InlinedAt, ImplicitCode, AtomGroup, AtomRank, IRLayers);
2651 if (parseDIExpression(Node))
2658bool MIParser::parseCFIOffset(int64_t &
Offset) {
2660 return error(
"expected a cfi offset");
2661 if (!Token.integerValue().isRepresentableByInt64())
2662 return error(
"expected a 64 bit integer (the cfi offset is too large)");
2663 Offset = Token.integerValue().getExtValue();
2668bool MIParser::parseCFIUnsigned(
unsigned &
Value) {
2675bool MIParser::parseCFIRegister(
unsigned &
Reg) {
2677 return error(
"expected a cfi register");
2679 if (parseNamedRegister(LLVMReg))
2681 const auto *
TRI = MF.getSubtarget().getRegisterInfo();
2682 assert(
TRI &&
"Expected target register info");
2683 int DwarfReg =
TRI->getDwarfRegNum(LLVMReg,
true);
2685 return error(
"invalid DWARF register");
2686 Reg = (unsigned)DwarfReg;
2691bool MIParser::parseCFIAddressSpace(
unsigned &
AddressSpace) {
2693 return error(
"expected a cfi address space literal");
2697bool MIParser::parseCFIEscapeValues(std::string &
Values) {
2700 return error(
"expected a hexadecimal literal");
2704 if (
Value > UINT8_MAX)
2705 return error(
"expected a 8-bit integer (too large)");
2713 auto Kind = Token.kind();
2721 if (parseCFIRegister(
Reg))
2736 CFIIndex = MF.addFrameInst(
2740 if (parseCFIRegister(
Reg))
2746 if (parseCFIOffset(
Offset))
2752 if (parseCFIOffset(
Offset))
2754 CFIIndex = MF.addFrameInst(
2776 if (parseCFIRegister(
Reg))
2784 if (parseCFIRegister(
Reg))
2791 parseCFIRegister(Reg2))
2814 PACSym = getOrCreateMCSymbol(Token.stringValue());
2816 CFIIndex = MF.addFrameInst(
2820 if (parseCFIOffset(
Offset))
2822 CFIIndex = MF.addFrameInst(
2825 return error(
"expected '<mcsymbol ...>' or integer offset for "
2826 "cfi_set_ra_state");
2831 unsigned Reg, R1,
R2;
2832 unsigned R1Size, R2Size;
2837 parseCFIUnsigned(R2Size))
2841 nullptr,
Reg, R1, R1Size,
R2, R2Size));
2845 std::vector<MCCFIInstruction::VectorRegisterWithLane> VectorRegisters;
2850 unsigned Lane,
Size;
2853 parseCFIUnsigned(
Size))
2855 VectorRegisters.push_back({VR, Lane,
Size});
2859 nullptr,
Reg, std::move(VectorRegisters)));
2863 unsigned Reg, MaskReg;
2864 unsigned RegSize, MaskRegSize;
2870 parseCFIUnsigned(MaskRegSize) || expectAndConsume(
MIToken::comma) ||
2879 unsigned Reg, SpillReg, MaskReg;
2880 unsigned SpillRegLaneSize, MaskRegSize;
2883 parseCFIRegister(SpillReg) || expectAndConsume(
MIToken::comma) ||
2884 parseCFIUnsigned(SpillRegLaneSize) ||
2886 expectAndConsume(
MIToken::comma) || parseCFIUnsigned(MaskRegSize))
2890 nullptr,
Reg, SpillReg, SpillRegLaneSize, MaskReg, MaskRegSize));
2895 if (parseCFIEscapeValues(
Values))
2909 switch (Token.kind()) {
2912 F.getValueSymbolTable()->lookup(Token.stringValue()));
2914 return error(
Twine(
"use of undefined IR block '") + Token.range() +
"'");
2918 unsigned SlotNumber = 0;
2921 BB =
const_cast<BasicBlock *
>(getIRBlock(SlotNumber,
F));
2923 return error(
Twine(
"use of undefined IR block '%ir-block.") +
2924 Twine(SlotNumber) +
"'");
2940 return error(
"expected a global value");
2946 return error(
"expected an IR function reference");
2952 return error(
"expected an IR block reference");
2953 if (parseIRBlock(BB, *
F))
2959 if (parseOperandsOffset(Dest))
2968 return error(
"expected syntax intrinsic(@llvm.whatever)");
2971 return error(
"expected syntax intrinsic(@llvm.whatever)");
2973 std::string
Name = std::string(Token.stringValue());
2977 return error(
"expected ')' to terminate intrinsic name");
2982 return error(
"unknown intrinsic name");
2994 return error(
"expected syntax intpred(whatever) or floatpred(whatever");
2997 return error(
"whatever");
3020 return error(
"invalid floating-point predicate");
3035 return error(
"invalid integer predicate");
3041 return error(
"predicate should be terminated by ')'.");
3051 return error(
"expected syntax shufflemask(<integer or undef>, ...)");
3058 const APSInt &
Int = Token.integerValue();
3061 return error(
"expected integer constant");
3068 return error(
"shufflemask should be terminated by ')'.");
3070 if (ShufMask.
size() < 2)
3071 return error(
"shufflemask should have > 1 element");
3083 return error(
"expected syntax dbg-instr-ref(<unsigned>, <unsigned>)");
3086 return error(
"expected unsigned integer for instruction index");
3087 uint64_t InstrIdx = Token.integerValue().getZExtValue();
3088 assert(InstrIdx <= std::numeric_limits<unsigned>::max() &&
3089 "Instruction reference's instruction index is too large");
3093 return error(
"expected syntax dbg-instr-ref(<unsigned>, <unsigned>)");
3096 return error(
"expected unsigned integer for operand index");
3097 uint64_t OpIdx = Token.integerValue().getZExtValue();
3098 assert(OpIdx <= std::numeric_limits<unsigned>::max() &&
3099 "Instruction reference's operand index is too large");
3103 return error(
"expected syntax dbg-instr-ref(<unsigned>, <unsigned>)");
3115 return error(
"expected the name of the target index");
3117 if (PFS.Target.getTargetIndex(Token.stringValue(), Index))
3118 return error(
"use of undefined target index '" + Token.stringValue() +
"'");
3123 if (parseOperandsOffset(Dest))
3128bool MIParser::parseCustomRegisterMaskOperand(
MachineOperand &Dest) {
3129 assert(Token.stringValue() ==
"CustomRegMask" &&
"Expected a custom RegMask");
3134 uint32_t *
Mask = MF.allocateRegMask();
3138 return error(
"expected a named register");
3140 if (parseNamedRegister(
Reg))
3164 return error(
"expected a valid lane mask value");
3166 "Use correct get-function for lane mask.");
3180bool MIParser::parseLiveoutRegisterMaskOperand(
MachineOperand &Dest) {
3182 uint32_t *
Mask = MF.allocateRegMask();
3188 return error(
"expected a named register");
3190 if (parseNamedRegister(
Reg))
3205bool MIParser::parseMachineOperand(
const unsigned OpCode,
const unsigned OpIdx,
3207 std::optional<unsigned> &TiedDefIdx) {
3208 switch (Token.kind()) {
3223 return parseRegisterOperand(Dest, TiedDefIdx);
3227 return parseImmediateOperand(Dest);
3235 return parseFPImmediateOperand(Dest);
3237 return parseMBBOperand(Dest);
3239 return parseStackObjectOperand(Dest);
3241 return parseFixedStackObjectOperand(Dest);
3244 return parseGlobalAddressOperand(Dest);
3246 return parseConstantPoolIndexOperand(Dest);
3248 return parseJumpTableIndexOperand(Dest);
3250 return parseExternalSymbolOperand(Dest);
3252 return parseMCSymbolOperand(Dest);
3254 return parseSubRegisterIndexOperand(Dest);
3257 return parseMetadataOperand(Dest);
3280 return parseCFIOperand(Dest);
3282 return parseBlockAddressOperand(Dest);
3284 return parseIntrinsicOperand(Dest);
3286 return parseTargetIndexOperand(Dest);
3288 return parseLaneMaskOperand(Dest);
3290 return parseLiveoutRegisterMaskOperand(Dest);
3293 return parsePredicateOperand(Dest);
3295 return parseShuffleMaskOperand(Dest);
3297 return parseDbgInstrRefOperand(Dest);
3301 bool IsInlineAsm =
OpCode == TargetOpcode::INLINEASM ||
3302 OpCode == TargetOpcode::INLINEASM_BR;
3304 return parseSymbolicInlineAsmOperand(OpIdx, Dest);
3307 if (
const auto *RegMask = PFS.Target.getRegMask(Id)) {
3311 }
else if (Id ==
"CustomRegMask") {
3312 return parseCustomRegisterMaskOperand(Dest);
3314 return parseTypedImmediateOperand(Dest);
3318 const auto *
TII = MF.getSubtarget().getInstrInfo();
3319 if (
const auto *Formatter =
TII->getMIRFormatter()) {
3320 return parseTargetImmMnemonic(OpCode, OpIdx, Dest, *Formatter);
3326 return error(
"expected a machine operand");
3331bool MIParser::parseMachineOperandAndTargetFlags(
3332 const unsigned OpCode,
const unsigned OpIdx,
MachineOperand &Dest,
3333 std::optional<unsigned> &TiedDefIdx) {
3335 bool HasTargetFlags =
false;
3337 HasTargetFlags =
true;
3342 return error(
"expected the name of the target flag");
3343 if (PFS.Target.getDirectTargetFlag(Token.stringValue(), TF)) {
3344 if (PFS.Target.getBitmaskTargetFlag(Token.stringValue(), TF))
3345 return error(
"use of undefined target flag '" + Token.stringValue() +
3352 return error(
"expected the name of the target flag");
3353 unsigned BitFlag = 0;
3354 if (PFS.Target.getBitmaskTargetFlag(Token.stringValue(), BitFlag))
3355 return error(
"use of undefined target flag '" + Token.stringValue() +
3364 auto Loc = Token.location();
3365 if (parseMachineOperand(OpCode, OpIdx, Dest, TiedDefIdx))
3367 if (!HasTargetFlags)
3370 return error(
Loc,
"register operands can't have target flags");
3375bool MIParser::parseOffset(int64_t &
Offset) {
3382 return error(
"expected an integer literal after '" +
Sign +
"'");
3383 if (Token.integerValue().getSignificantBits() > 64)
3384 return error(
"expected 64-bit integer (too large)");
3385 Offset = Token.integerValue().getExtValue();
3392bool MIParser::parseIRBlockAddressTaken(
BasicBlock *&BB) {
3396 return error(
"expected basic block after 'ir_block_address_taken'");
3398 if (parseIRBlock(BB, MF.getFunction()))
3405bool MIParser::parseAlignment(
uint64_t &Alignment) {
3409 return error(
"expected an integer literal after 'align'");
3410 if (getUint64(Alignment))
3415 return error(
"expected a power-of-2 literal after 'align'");
3420bool MIParser::parseAddrspace(
unsigned &Addrspace) {
3424 return error(
"expected an integer literal after 'addrspace'");
3441 switch (Token.
kind()) {
3447 unsigned SlotNumber = 0;
3475 return ErrCB(Token.
location(),
Twine(
"use of undefined IR value '") + Token.
range() +
"'");
3479bool MIParser::parseIRValue(
const Value *&
V) {
3480 return ::parseIRValue(
3486bool MIParser::getUint64(
uint64_t &Result) {
3487 if (Token.hasIntegerValue()) {
3488 if (Token.integerValue().getActiveBits() > 64)
3489 return error(
"expected 64-bit integer (too large)");
3490 Result = Token.integerValue().getZExtValue();
3497 if (
A.getBitWidth() > 64)
3498 return error(
"expected 64-bit integer (too large)");
3505bool MIParser::getHexUint(
APInt &Result) {
3506 return ::getHexUint(Token, Result);
3510 const auto OldFlags =
Flags;
3511 switch (Token.kind()) {
3526 if (PFS.Target.getMMOTargetFlag(Token.stringValue(), TF))
3527 return error(
"use of undefined target MMO flag '" + Token.stringValue() +
3535 if (OldFlags == Flags)
3538 return error(
"duplicate '" + Token.stringValue() +
"' memory operand flag");
3544 switch (Token.kind()) {
3546 PSV = MF.getPSVManager().getStack();
3549 PSV = MF.getPSVManager().getGOT();
3552 PSV = MF.getPSVManager().getJumpTable();
3555 PSV = MF.getPSVManager().getConstantPool();
3559 if (parseFixedStackFrameIndex(FI))
3561 PSV = MF.getPSVManager().getFixedStack(FI);
3567 if (parseStackFrameIndex(FI))
3569 PSV = MF.getPSVManager().getFixedStack(FI);
3575 switch (Token.kind()) {
3581 PSV = MF.getPSVManager().getGlobalValueCallEntry(GV);
3585 PSV = MF.getPSVManager().getExternalSymbolCallEntry(
3586 MF.createExternalSymbolName(Token.stringValue()));
3590 "expected a global value or an external symbol after 'call-entry'");
3595 const auto *
TII = MF.getSubtarget().getInstrInfo();
3596 if (
const auto *Formatter =
TII->getMIRFormatter()) {
3597 if (Formatter->parseCustomPseudoSourceValue(
3598 Token.stringValue(), MF, PFS, PSV,
3600 return error(Loc, Msg);
3604 return error(
"unable to parse target custom pseudo source value");
3621 if (parseMemoryPseudoSourceValue(PSV))
3634 return error(
"expected an IR value reference");
3635 const Value *
V =
nullptr;
3638 if (
V && !
V->getType()->isPointerTy())
3639 return error(
"expected a pointer IR value");
3654 return error(
"expected '(' in syncscope");
3657 if (parseStringConstant(SSN))
3660 SSID =
Context.getOrInsertSyncScopeID(SSN);
3662 return error(
"expected ')' in syncscope");
3668bool MIParser::parseOptionalAtomicOrdering(
AtomicOrdering &Order) {
3687 return error(
"expected an atomic scope, ordering or a size specification");
3694 while (Token.isMemoryOperandFlag()) {
3695 if (parseMemoryOperandFlag(Flags))
3699 (Token.stringValue() !=
"load" && Token.stringValue() !=
"store"))
3700 return error(
"expected 'load' or 'store' memory operation");
3701 if (Token.stringValue() ==
"load")
3715 if (parseOptionalScope(MF.getFunction().getContext(), SSID))
3720 if (parseOptionalAtomicOrdering(Order))
3723 if (parseOptionalAtomicOrdering(FailureOrder))
3729 return error(
"expected memory LLT, the size integer literal or 'unknown-size' after "
3730 "memory operation");
3735 if (getUint64(
Size))
3746 if (parseLowLevelType(Token.location(), MemoryType))
3759 if (Token.stringValue() != Word)
3760 return error(
Twine(
"expected '") + Word +
"'");
3763 if (parseMachinePointerInfo(Ptr))
3772 MDNode *MemCacheHint =
nullptr;
3774 switch (Token.kind()) {
3780 if (Ptr.
Offset & (Alignment - 1)) {
3785 return error(
"specified alignment is more aligned than offset");
3831 return error(
"expected 'align' or '!tbaa' or '!alias.scope' or "
3832 "'!noalias' or '!range' or '!mem.cache_hint' or "
3833 "'!noalias.addrspace'");
3838 Dest = MF.getMachineMemOperand(Ptr, Flags, MemoryType,
Align(BaseAlignment),
3840 Order, FailureOrder);
3844bool MIParser::parsePreOrPostInstrSymbol(
MCSymbol *&Symbol) {
3847 "Invalid token for a pre- post-instruction symbol!");
3850 return error(
"expected a symbol after 'pre-instr-symbol'");
3851 Symbol = getOrCreateMCSymbol(Token.stringValue());
3857 return error(
"expected ',' before the next machine operand");
3862bool MIParser::parseHeapAllocMarker(
MDNode *&Node) {
3864 "Invalid token for a heap alloc marker!");
3869 return error(
"expected a MDNode after 'heap-alloc-marker'");
3874 return error(
"expected ',' before the next machine operand");
3879bool MIParser::parsePCSections(
MDNode *&Node) {
3881 "Invalid token for a PC sections!");
3886 return error(
"expected a MDNode after 'pcsections'");
3891 return error(
"expected ',' before the next machine operand");
3896bool MIParser::parseMMRA(
MDNode *&Node) {
3905 return error(
"expected ',' before the next machine operand");
3915 for (
const auto &BB :
F) {
3921 Slots2BasicBlocks.
insert(std::make_pair(
unsigned(Slot), &BB));
3928 return Slots2BasicBlocks.
lookup(Slot);
3931const BasicBlock *MIParser::getIRBlock(
unsigned Slot) {
3932 if (Slots2BasicBlocks.empty())
3938 if (&
F == &MF.getFunction())
3939 return getIRBlock(Slot);
3951 return MF.getContext().getOrCreateSymbol(Name);
3954bool MIParser::parseStringConstant(std::string &Result) {
3956 return error(
"expected string constant");
3957 Result = std::string(Token.stringValue());
3965 return MIParser(PFS,
Error, Src).parseBasicBlockDefinitions(PFS.
MBBSlots);
3970 return MIParser(PFS,
Error, Src).parseBasicBlocks();
3976 return MIParser(PFS,
Error, Src).parseStandaloneMBB(
MBB);
3982 return MIParser(PFS,
Error, Src).parseStandaloneRegister(Reg);
3988 return MIParser(PFS,
Error, Src).parseStandaloneNamedRegister(Reg);
3994 return MIParser(PFS,
Error, Src).parseStandaloneVirtualRegister(Info);
3999 return MIParser(PFS,
Error, Src).parseStandaloneStackObject(FI);
4005 return MIParser(PFS,
Error, Src).parsePrefetchTarget(
Target);
4009 return MIParser(PFS,
Error, Src).parseStandaloneMDNode(
Node);
4021 return ::parseIRValue(Token, PFS, V, ErrorCallback);
const AArch64Subtarget & Subtarget
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file defines the StringMap class.
This file implements a class to represent arbitrary precision integral constant values and operations...
This file implements the APSInt class, which is a simple class that represents an arbitrary sized int...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Atomic ordering constants.
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static Error parseAlignment(StringRef Str, Align &Alignment, StringRef Name, bool AllowZero=false)
Attempts to parse an alignment component of a specification.
This file defines the DenseMap class.
const HexagonInstrInfo * TII
Module.h This file contains the declarations for the Module class.
const size_t AbstractManglingParser< Derived, Alloc >::NumOps
A common definition of LaneBitmask for use in TableGen and CodeGen.
static llvm::Error parse(GsymDataExtractor &Data, uint64_t BaseAddr, LineEntryCallback const &Callback)
Implement a low-level type suitable for MachineInstr level instruction selection.
static const char * printImplicitRegisterFlag(const MachineOperand &MO)
static bool verifyVectorElementCount(uint64_t NumElts, bool HasVScale)
static const BasicBlock * getIRBlockFromSlot(unsigned Slot, const DenseMap< unsigned, const BasicBlock * > &Slots2BasicBlocks)
static std::string getRegisterName(const TargetRegisterInfo *TRI, Register Reg)
static bool parseIRConstant(StringRef::iterator Loc, StringRef StringValue, PerFunctionMIParsingState &PFS, const Constant *&C, ErrorCallbackType ErrCB)
static void initSlots2Values(const Function &F, DenseMap< unsigned, const Value * > &Slots2Values)
Creates the mapping from slot numbers to function's unnamed IR values.
static bool parseIRValue(const MIToken &Token, PerFunctionMIParsingState &PFS, const Value *&V, ErrorCallbackType ErrCB)
static bool verifyScalarSize(uint64_t Size)
static bool getUnsigned(const MIToken &Token, unsigned &Result, ErrorCallbackType ErrCB)
static bool getHexUint(const MIToken &Token, APInt &Result)
static void mapValueToSlot(const Value *V, ModuleSlotTracker &MST, DenseMap< unsigned, const Value * > &Slots2Values)
static void initSlots2BasicBlocks(const Function &F, DenseMap< unsigned, const BasicBlock * > &Slots2BasicBlocks)
function_ref< bool(StringRef::iterator Loc, const Twine &)> ErrorCallbackType
static bool isImplicitOperandIn(const MachineOperand &ImplicitOperand, ArrayRef< ParsedMachineOperand > Operands)
Return true if the parsed machine operands contain a given machine operand.
static bool parseGlobalValue(const MIToken &Token, PerFunctionMIParsingState &PFS, GlobalValue *&GV, ErrorCallbackType ErrCB)
static bool verifyAddrSpace(uint64_t AddrSpace)
Register const TargetRegisterInfo * TRI
Promote Memory to Register
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
MachineRegisterInfo & MRI
This file defines the SmallVector class.
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
Class for arbitrary precision integers.
uint64_t getZExtValue() const
Get zero extended value.
uint64_t getLimitedValue(uint64_t Limit=UINT64_MAX) const
If this value is smaller than the specified limit, return it, otherwise return the limit value.
An arbitrary precision integer that knows its signedness.
bool isNegative() const
Determine sign of this APSInt.
Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
Get the array size.
LLVM Basic Block Representation.
static LLVM_ABI BlockAddress * get(Function *F, BasicBlock *BB)
Return a BlockAddress for the specified function and basic block.
static constexpr BranchProbability getRaw(uint32_t N)
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
@ FCMP_OEQ
0 0 0 1 True if ordered and equal
@ FCMP_TRUE
1 1 1 1 Always true (always folded)
@ ICMP_SLT
signed less than
@ ICMP_SLE
signed less or equal
@ FCMP_OLT
0 1 0 0 True if ordered and less than
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
@ ICMP_UGE
unsigned greater or equal
@ ICMP_UGT
unsigned greater than
@ ICMP_SGT
signed greater than
@ FCMP_ULT
1 1 0 0 True if unordered or less than
@ FCMP_ONE
0 1 1 0 True if ordered and operands are unequal
@ FCMP_UEQ
1 0 0 1 True if unordered or equal
@ ICMP_ULT
unsigned less than
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
@ FCMP_ORD
0 1 1 1 True if ordered (no nans)
@ ICMP_SGE
signed greater or equal
@ FCMP_UNE
1 1 1 0 True if unordered or not equal
@ ICMP_ULE
unsigned less or equal
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
@ FCMP_FALSE
0 0 0 0 Always false (always folded)
@ FCMP_UNO
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
static bool isFPPredicate(Predicate P)
static bool isIntPredicate(Predicate P)
This is an important base class in LLVM.
A parsed version of the target data layout string in and methods for querying it.
ValueT lookup(const_arg_type_t< KeyT > Val) const
Return the entry for the specified key, or a default constructed value if no such entry exists.
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
static constexpr ElementCount get(ScalarTy MinVal, bool Scalable)
Lightweight error class with error context and mandatory checking.
ValueSymbolTable * getValueSymbolTable()
getSymbolTable() - Return the symbol table if any, otherwise nullptr.
Module * getParent()
Get the module that this global value is contained inside of...
static constexpr unsigned getMaxNumOperandRegisters()
The largest number of operands that a flag can describe.
static constexpr LLT vector(ElementCount EC, unsigned ScalarSizeInBits)
Get a low-level vector of some number of elements and element width.
static constexpr LLT scalar(unsigned SizeInBits)
Get a low-level scalar or aggregate "bag of bits".
constexpr bool isValid() const
static constexpr LLT pointer(unsigned AddressSpace, unsigned SizeInBits)
Get a low-level pointer in the given address space.
static constexpr LLT token()
Get a low-level token; just a scalar with zero bits (or no size).
static constexpr LLT bfloat16()
static LLT floatIEEE(unsigned SizeInBits)
This is an important class for using LLVM in a threaded context.
static MCCFIInstruction createDefCfaRegister(MCSymbol *L, unsigned Register, SMLoc Loc={})
.cfi_def_cfa_register modifies a rule for computing CFA.
static MCCFIInstruction createLLVMVectorOffset(MCSymbol *L, unsigned Register, unsigned RegisterSizeInBits, unsigned MaskRegister, unsigned MaskRegisterSizeInBits, int64_t Offset, SMLoc Loc={})
.cfi_llvm_vector_offset Previous value of Register is saved at Offset from CFA.
static MCCFIInstruction createUndefined(MCSymbol *L, unsigned Register, SMLoc Loc={})
.cfi_undefined From now on the previous value of Register can't be restored anymore.
static MCCFIInstruction createLLVMVectorRegisters(MCSymbol *L, unsigned Register, ArrayRef< VectorRegisterWithLane > VectorRegisters, SMLoc Loc={})
.cfi_llvm_vector_registers Previous value of Register is saved in lanes of vector registers.
static MCCFIInstruction createRestore(MCSymbol *L, unsigned Register, SMLoc Loc={})
.cfi_restore says that the rule for Register is now the same as it was at the beginning of the functi...
static MCCFIInstruction createSetRAState(MCSymbol *L, unsigned State, MCSymbol *PACSym=nullptr, SMLoc Loc={})
.cfi_set_ra_state AArch64 set RA sign state,
static MCCFIInstruction createLLVMDefAspaceCfa(MCSymbol *L, unsigned Register, int64_t Offset, unsigned AddressSpace, SMLoc Loc)
.cfi_llvm_def_aspace_cfa defines the rule for computing the CFA to be the result of evaluating the DW...
static MCCFIInstruction createLLVMVectorRegisterMask(MCSymbol *L, unsigned Register, unsigned SpillRegister, unsigned SpillRegisterLaneSizeInBits, unsigned MaskRegister, unsigned MaskRegisterSizeInBits, SMLoc Loc={})
.cfi_llvm_vector_register_mask Previous value of Register is saved in SpillRegister,...
static MCCFIInstruction createRegister(MCSymbol *L, unsigned Register1, unsigned Register2, SMLoc Loc={})
.cfi_register Previous value of Register1 is saved in register Register2.
static MCCFIInstruction cfiDefCfa(MCSymbol *L, unsigned Register, int64_t Offset, SMLoc Loc={})
.cfi_def_cfa defines a rule for computing CFA as: take address from Register and add Offset to it.
static MCCFIInstruction createOffset(MCSymbol *L, unsigned Register, int64_t Offset, SMLoc Loc={})
.cfi_offset Previous value of Register is saved at offset Offset from CFA.
static MCCFIInstruction createNegateRAStateWithPC(MCSymbol *L, SMLoc Loc={})
.cfi_negate_ra_state_with_pc AArch64 negate RA state with PC.
static MCCFIInstruction createNegateRAState(MCSymbol *L, SMLoc Loc={})
.cfi_negate_ra_state AArch64 negate RA state.
static MCCFIInstruction createRememberState(MCSymbol *L, SMLoc Loc={})
.cfi_remember_state Save all current rules for all registers.
static MCCFIInstruction createLLVMRegisterPair(MCSymbol *L, unsigned Register, unsigned R1, unsigned R1SizeInBits, unsigned R2, unsigned R2SizeInBits, SMLoc Loc={})
.cfi_llvm_register_pair Previous value of Register is saved in R1:R2.
static MCCFIInstruction cfiDefCfaOffset(MCSymbol *L, int64_t Offset, SMLoc Loc={})
.cfi_def_cfa_offset modifies a rule for computing CFA.
static MCCFIInstruction createEscape(MCSymbol *L, StringRef Vals, SMLoc Loc={}, StringRef Comment="")
.cfi_escape Allows the user to add arbitrary bytes to the unwind info.
static MCCFIInstruction createWindowSave(MCSymbol *L, SMLoc Loc={})
.cfi_window_save SPARC register window is saved.
static MCCFIInstruction createAdjustCfaOffset(MCSymbol *L, int64_t Adjustment, SMLoc Loc={})
.cfi_adjust_cfa_offset Same as .cfi_def_cfa_offset, but Offset is a relative value that is added/subt...
static MCCFIInstruction createRestoreState(MCSymbol *L, SMLoc Loc={})
.cfi_restore_state Restore the previously saved state.
static MCCFIInstruction createSameValue(MCSymbol *L, unsigned Register, SMLoc Loc={})
.cfi_same_value Current value of Register is the same as in the previous frame.
static MCCFIInstruction createRelOffset(MCSymbol *L, unsigned Register, int64_t Offset, SMLoc Loc={})
.cfi_rel_offset Previous value of Register is saved at offset Offset from the current CFA register.
Describe properties that are true of each instruction in the target description file.
unsigned getID() const
getID() - Return the register class ID number.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
void normalizeSuccProbs()
Normalize probabilities of all successors so that the sum of them becomes one.
void setAddressTakenIRBlock(BasicBlock *BB)
Set this block to reflect that it corresponds to an IR-level basic block with a BlockAddress.
void setIsCleanupFuncletEntry(bool V=true)
Indicates if this is the entry block of a cleanup funclet.
void setLabelMustBeEmitted()
Set this block to reflect that, regardless how we flow to it, we need its label be emitted.
LLVM_ABI instr_iterator insert(instr_iterator I, MachineInstr *M)
Insert MI into the instruction list before I, possibly inside a bundle.
void setCallFrameSize(unsigned N)
Set the call frame size on entry to this basic block.
void setMaxBytesForAlignment(unsigned MaxBytes)
Set the maximum amount of padding allowed for aligning the basic block.
void setAlignment(Align A)
Set alignment of the basic block.
LLVM_ABI void addSuccessor(MachineBasicBlock *Succ, BranchProbability Prob=BranchProbability::getUnknown())
Add Succ as a successor of this MachineBasicBlock.
void setSectionID(MBBSectionID V)
Sets the section ID for this basic block.
void setIsInlineAsmBrIndirectTarget(bool V=true)
Indicates if this is the indirect dest of an INLINEASM_BR.
void addLiveIn(MCRegister PhysReg, LaneBitmask LaneMask=LaneBitmask::getAll())
Adds the specified register as a live in.
void setIsEHContTarget(bool V=true)
Indicates if this is a target of Windows EH Continuation Guard.
void setIsEHFuncletEntry(bool V=true)
Indicates if this is the entry block of an EH funclet.
LLVM_ABI bool isSuccessor(const MachineBasicBlock *MBB) const
Return true if the specified MBB is a successor of this block.
LLVM_ABI StringRef getName() const
Return the name of the corresponding LLVM basic block, or an empty string.
void setIsEHScopeEntry(bool V=true)
Indicates if this is the entry block of an EH scope, i.e., the block that that used to have a catchpa...
void setMachineBlockAddressTaken()
Set this block to indicate that its address is used as something other than the target of a terminato...
void setIsEHPad(bool V=true)
Indicates the block is a landing pad.
Function & getFunction()
Return the LLVM function that this machine code represents.
Representation of each machine instruction.
void setFlag(MIFlag Flag)
Set a MI flag.
A description of a memory reference used in the backend.
Flags
Flags values. These may be or'd together.
@ MOVolatile
The memory access is volatile.
@ MODereferenceable
The memory access is dereferenceable (i.e., doesn't trap).
@ MOLoad
The memory access reads data.
@ MONonTemporal
The memory access is non-temporal.
@ MOInvariant
The memory access always returns the same value (or traps).
@ MOStore
The memory access writes data.
MachineOperand class - Representation of each machine instruction operand.
static MachineOperand CreateMCSymbol(MCSymbol *Sym, unsigned TargetFlags=0)
static MachineOperand CreateES(const char *SymName, unsigned TargetFlags=0)
static MachineOperand CreateFPImm(const ConstantFP *CFP)
static MachineOperand CreateCFIIndex(unsigned CFIIndex)
static MachineOperand CreateRegMask(const uint32_t *Mask)
CreateRegMask - Creates a register mask operand referencing Mask.
bool isReg() const
isReg - Tests if this is a MO_Register operand.
static MachineOperand CreateCImm(const ConstantInt *CI)
static MachineOperand CreateMetadata(const MDNode *Meta)
static MachineOperand CreatePredicate(unsigned Pred)
static MachineOperand CreateImm(int64_t Val)
static MachineOperand CreateShuffleMask(ArrayRef< int > Mask)
static MachineOperand CreateJTI(unsigned Idx, unsigned TargetFlags=0)
static MachineOperand CreateDbgInstrRef(unsigned InstrIdx, unsigned OpIdx)
static MachineOperand CreateRegLiveOut(const uint32_t *Mask)
static MachineOperand CreateGA(const GlobalValue *GV, int64_t Offset, unsigned TargetFlags=0)
static MachineOperand CreateBA(const BlockAddress *BA, int64_t Offset, unsigned TargetFlags=0)
void setTargetFlags(unsigned F)
static MachineOperand CreateLaneMask(LaneBitmask LaneMask)
LLVM_ABI bool isIdenticalTo(const MachineOperand &Other) const
Returns true if this operand is identical to the specified operand except for liveness related flags ...
static MachineOperand CreateCPI(unsigned Idx, int Offset, unsigned TargetFlags=0)
static MachineOperand CreateReg(Register Reg, bool isDef, bool isImp=false, bool isKill=false, bool isDead=false, bool isUndef=false, bool isEarlyClobber=false, unsigned SubReg=0, bool isDebug=false, bool isInternalRead=false, bool isRenamable=false)
static MachineOperand CreateTargetIndex(unsigned Idx, int64_t Offset, unsigned TargetFlags=0)
static MachineOperand CreateMBB(MachineBasicBlock *MBB, unsigned TargetFlags=0)
static MachineOperand CreateIntrinsicID(Intrinsic::ID ID)
static MachineOperand CreateFI(int Idx)
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
void setRegClassOrRegBank(Register Reg, const RegClassOrRegBank &RCOrRB)
LLT getType(Register Reg) const
Get the low-level type of Reg or LLT{} if Reg is not a generic (target independent) virtual register.
LLVM_ABI void setType(Register VReg, LLT Ty)
Set the low-level type of VReg to Ty.
void noteNewVirtualRegister(Register Reg)
This interface provides simple read-only access to a block of memory, and provides simple methods for...
virtual StringRef getBufferIdentifier() const
Return an identifier for this buffer, typically the filename it was read from.
const char * getBufferEnd() const
const char * getBufferStart() const
Manage lifetime of a slot tracker for printing IR.
int getLocalSlot(const Value *V)
Return the slot number of the specified local value.
void incorporateFunction(const Function &F)
Incorporate the given function.
A Module instance is used to store all the information related to an LLVM module.
Special value supplied for machine level alias analysis.
const RegisterBank & getRegBank(unsigned ID)
Get the register bank identified by ID.
unsigned getNumRegBanks() const
Get the total number of register banks.
This class implements the register bank concept.
Wrapper class representing virtual and physical registers.
constexpr bool isVirtual() const
Return true if the specified register number is in the virtual register namespace.
constexpr unsigned id() const
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
Represents a location in source code.
static SMLoc getFromPointer(const char *Ptr)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling.
unsigned getMainFileID() const
const MemoryBuffer * getMemoryBuffer(unsigned i) const
LLVM_ABI SMDiagnostic GetMessage(SMLoc Loc, DiagKind Kind, const Twine &Msg, ArrayRef< SMRange > Ranges={}, ArrayRef< SMFixIt > FixIts={}) const
Return an SMDiagnostic at the specified location with the specified string.
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Represent a constant reference to a string, i.e.
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
std::string str() const
Get the contents as an std::string.
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
constexpr bool empty() const
Check if the string is empty.
LLVM_ABI std::string lower() const
bool consume_front(char Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
A switch()-like statement whose cases are string literals.
StringSwitch & Case(StringLiteral S, T Value)
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
TargetSubtargetInfo - Generic base class for all target subtargets.
Target - Wrapper for Target specific information.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Value * lookup(StringRef Name) const
This method finds the value with the given Name in the the symbol table.
LLVM Value Representation.
An efficient, type-erasing, non-owning reference to a callable.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
@ BasicBlock
Various leaf nodes.
LLVM_ABI ID lookupIntrinsicID(StringRef Name)
This does the actual lookup of an intrinsic ID which matches the given function name.
Flag
These should be considered private to the implementation of the MCInstrDesc class.
@ System
Synchronized with respect to all concurrently executing threads.
support::ulittle32_t Word
Scope
Defines the scope in which this symbol should be visible: Default – Visible in the public interface o...
NodeAddr< NodeBase * > Node
This is an optimization pass for GlobalISel generic memory operations.
LLVM_ABI bool parseStackObjectReference(PerFunctionMIParsingState &PFS, int &FI, StringRef Src, SMDiagnostic &Error)
LLVM_ABI bool parseMDNode(PerFunctionMIParsingState &PFS, MDNode *&Node, StringRef Src, SMDiagnostic &Error)
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
RelativeUniformCounterPtr Values
RegState
Flags to represent properties of register accesses.
@ Implicit
Not emitted register (e.g. carry, or temporary result).
@ Kill
The last use of a register.
@ InternalRead
Register reads a value that is defined inside the same instruction or bundle.
@ Undef
Value of the register doesn't matter.
@ EarlyClobber
Register definition happens before uses.
@ Define
Register definition.
@ Renamable
Register that may be renamed.
@ Debug
Register 'use' is for debugging purpose.
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
StringRef lexMIToken(StringRef Source, MIToken &Token, function_ref< void(StringRef::iterator, const Twine &)> ErrorCallback)
Consume a single machine instruction token in the given source and return the remaining source string...
constexpr bool isPowerOf2_64(uint64_t Value)
Return true if the argument is a power of two > 0 (64 bit edition.)
LLVM_ABI bool parseMachineBasicBlockDefinitions(PerFunctionMIParsingState &PFS, StringRef Src, SMDiagnostic &Error)
Parse the machine basic block definitions, and skip the machine instructions.
LLVM_ABI bool parsePrefetchTarget(PerFunctionMIParsingState &PFS, CallsiteID &Target, StringRef Src, SMDiagnostic &Error)
LLVM_ABI void guessSuccessors(const MachineBasicBlock &MBB, SmallVectorImpl< MachineBasicBlock * > &Result, bool &IsFallthrough)
Determine a possible list of successors of a basic block based on the basic block machine operand bei...
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Value
LLVM_ABI bool parseMBBReference(PerFunctionMIParsingState &PFS, MachineBasicBlock *&MBB, StringRef Src, SMDiagnostic &Error)
uint64_t PowerOf2Ceil(uint64_t A)
Returns the power of two which is greater than or equal to the given value.
auto dyn_cast_or_null(const Y &Val)
LLVM_ABI DIExpression * parseDIExpressionBodyAtBeginning(StringRef Asm, unsigned &Read, SMDiagnostic &Err, const Module &M, const SlotMapping *Slots)
constexpr RegState getDefRegState(bool B)
constexpr bool isUInt(uint64_t x)
Checks if an unsigned integer fits into the given bit width.
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
constexpr bool hasRegState(RegState Value, RegState Test)
AtomicOrdering
Atomic ordering for LLVM's memory model.
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
DWARFExpression::Operation Op
ArrayRef(const T &OneElt) -> ArrayRef< T >
std::string toString(const APInt &I, unsigned Radix, bool Signed, bool formatAsCLiteral=false, bool UpperCase=true, bool InsertSeparators=false)
LLVM_ABI bool parseMachineInstructions(PerFunctionMIParsingState &PFS, StringRef Src, SMDiagnostic &Error)
Parse the machine instructions.
LLVM_ABI bool parseRegisterReference(PerFunctionMIParsingState &PFS, Register &Reg, StringRef Src, SMDiagnostic &Error)
LLVM_ABI Constant * parseConstantValue(StringRef Asm, SMDiagnostic &Err, const Module &M, const SlotMapping *Slots=nullptr)
Parse a type and a constant value in the given string.
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
LLVM_ABI bool parseVirtualRegisterReference(PerFunctionMIParsingState &PFS, VRegInfo *&Info, StringRef Src, SMDiagnostic &Error)
@ End
Run the machine verifier once, at the end of the pipeline.
LLVM_ABI bool parseNamedRegisterReference(PerFunctionMIParsingState &PFS, Register &Reg, StringRef Src, SMDiagnostic &Error)
MCRegisterClass TargetRegisterClass
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
MDNode * NoAliasAddrSpace
The tag specifying the noalias address spaces.
MDNode * Scope
The tag for alias scope specification (used with noalias).
MDNode * TBAA
The tag for type-based alias analysis.
MDNode * NoAlias
The tag specifying the noalias scope.
This struct is a compact representation of a valid (non-zero power of two) alignment.
static constexpr LaneBitmask getAll()
LLVM_ABI static const MBBSectionID ExceptionSectionID
LLVM_ABI static const MBBSectionID ColdSectionID
A token produced by the machine instruction lexer.
bool hasIntegerValue() const
bool is(TokenKind K) const
StringRef stringValue() const
Return the token's string value.
@ kw_cfi_aarch64_negate_ra_sign_state
@ kw_cfi_llvm_def_aspace_cfa
@ kw_cleanup_funclet_entry
@ kw_cfi_llvm_register_pair
@ kw_cfi_llvm_vector_offset
@ kw_inlineasm_br_indirect_target
@ kw_cfi_llvm_vector_registers
@ kw_label_must_be_emitted
@ kw_cfi_llvm_vector_register_mask
@ kw_cfi_aarch64_negate_ra_sign_state_with_pc
@ kw_cfi_def_cfa_register
@ kw_cfi_adjust_cfa_offset
@ kw_max_bytes_for_alignment
@ kw_machine_block_address_taken
@ kw_ir_block_address_taken
StringRef::iterator location() const
const APSInt & integerValue() const
This class contains a discriminated union of information about pointers in memory operands,...
int64_t Offset
Offset - This is an offset from the base Value*.
LLVM_ABI VRegInfo & getVRegInfo(Register Num)
const SlotMapping & IRSlots
LLVM_ABI const Value * getIRValue(unsigned Slot)
DenseMap< unsigned, MachineBasicBlock * > MBBSlots
StringMap< VRegInfo * > VRegInfosNamed
DenseMap< unsigned, const Value * > Slots2Values
Maps from slot numbers to function's unnamed values.
LLVM_ABI PerFunctionMIParsingState(MachineFunction &MF, SourceMgr &SM, const SlotMapping &IRSlots, PerTargetMIParsingState &Target)
PerTargetMIParsingState & Target
DenseMap< Register, VRegInfo * > VRegInfos
LLVM_ABI VRegInfo & getVRegInfoNamed(StringRef RegName)
BumpPtrAllocator Allocator
LLVM_ABI bool getVRegFlagValue(StringRef FlagName, uint8_t &FlagValue) const
LLVM_ABI bool getDirectTargetFlag(StringRef Name, unsigned &Flag)
Try to convert a name of a direct target flag to the corresponding target flag.
LLVM_ABI const RegisterBank * getRegBank(StringRef Name)
Check if the given identifier is a name of a register bank.
LLVM_ABI bool parseInstrName(StringRef InstrName, unsigned &OpCode)
Try to convert an instruction name to an opcode.
LLVM_ABI unsigned getSubRegIndex(StringRef Name)
Check if the given identifier is a name of a subregister index.
LLVM_ABI bool getTargetIndex(StringRef Name, int &Index)
Try to convert a name of target index to the corresponding target index.
LLVM_ABI void setTarget(const TargetSubtargetInfo &NewSubtarget)
LLVM_ABI bool getRegisterByName(StringRef RegName, Register &Reg)
Try to convert a register name to a register number.
LLVM_ABI bool getMMOTargetFlag(StringRef Name, MachineMemOperand::Flags &Flag)
Try to convert a name of a MachineMemOperand target flag to the corresponding target flag.
LLVM_ABI bool getBitmaskTargetFlag(StringRef Name, unsigned &Flag)
Try to convert a name of a bitmask target flag to the corresponding target flag.
LLVM_ABI const TargetRegisterClass * getRegClass(StringRef Name)
Check if the given identifier is a name of a register class.
LLVM_ABI const uint32_t * getRegMask(StringRef Identifier)
Check if the given identifier is a name of a register mask.
This struct contains the mappings from the slot numbers to unnamed metadata nodes,...
NumberedValues< GlobalValue * > GlobalValues
const RegisterBank * RegBank
union llvm::VRegInfo::@127225073067155374133234315364317264041071000132 D
const TargetRegisterClass * RC
enum llvm::VRegInfo::@374354327266250320012227113300214031244227062232 Kind
bool Explicit
VReg was explicitly specified in the .mir file.