reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

lib/CodeGen/MIRParser/MIParser.cpp
  530       CurrentSource.data() + SkipChar, Token,
  534 bool MIParser::error(const Twine &Msg) { return error(Token.location(), Msg); }
  571   if (Token.isNot(TokenKind))
  578   if (Token.isNot(TokenKind))
  586   assert(Token.is(MIToken::MachineBasicBlockLabel));
  590   auto Loc = Token.location();
  591   auto Name = Token.stringValue();
  600       switch (Token.kind()) {
  655   while (Token.is(MIToken::Newline))
  657   if (Token.isErrorOrEOF())
  658     return Token.isError();
  659   if (Token.isNot(MIToken::MachineBasicBlockLabel))
  668       if ((Token.is(MIToken::MachineBasicBlockLabel) && IsAfterNewline) ||
  669           Token.isErrorOrEOF())
  671       else if (Token.is(MIToken::MachineBasicBlockLabel))
  679       if (Token.is(MIToken::lbrace))
  681       if (Token.is(MIToken::rbrace)) {
  689     if (!Token.isError() && BraceDepth)
  691   } while (!Token.isErrorOrEOF());
  692   return Token.isError();
  696   assert(Token.is(MIToken::kw_liveins));
  700   if (Token.isNewlineOrEOF()) // Allow an empty list of liveins.
  703     if (Token.isNot(MIToken::NamedRegister))
  712       if (Token.isNot(MIToken::IntegerLiteral) &&
  713           Token.isNot(MIToken::HexLiteral))
  729   assert(Token.is(MIToken::kw_successors));
  733   if (Token.isNewlineOrEOF()) // Allow an empty list of successors.
  736     if (Token.isNot(MIToken::MachineBasicBlock))
  744       if (Token.isNot(MIToken::IntegerLiteral) &&
  745           Token.isNot(MIToken::HexLiteral))
  762   assert(Token.is(MIToken::MachineBasicBlockLabel));
  765     while (Token.isNot(MIToken::rparen) && !Token.isErrorOrEOF())
  765     while (Token.isNot(MIToken::rparen) && !Token.isErrorOrEOF())
  782     if (Token.is(MIToken::kw_successors)) {
  786     } else if (Token.is(MIToken::kw_liveins)) {
  793     if (!Token.isNewlineOrEOF())
  801   while (!Token.is(MIToken::MachineBasicBlockLabel) &&
  802          !Token.is(MIToken::Eof)) {
  821     if (Token.is(MIToken::lbrace)) {
  828       if (!Token.is(MIToken::Newline))
  832     assert(Token.isNewlineOrEOF() && "MI is not fully parsed");
  857   while (Token.is(MIToken::Newline))
  859   if (Token.isErrorOrEOF())
  860     return Token.isError();
  863   assert(Token.is(MIToken::MachineBasicBlockLabel));
  879     assert(Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof));
  879     assert(Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof));
  880   } while (Token.isNot(MIToken::Eof));
  888   while (Token.isRegister() || Token.isRegisterFlag()) {
  888   while (Token.isRegister() || Token.isRegisterFlag()) {
  889     auto Loc = Token.location();
  894         ParsedMachineOperand(MO, Loc, Token.location(), TiedDefIdx));
  895     if (Token.isNot(MIToken::comma))
  903   if (Token.isError() || parseInstruction(OpCode, Flags))
  907   while (!Token.isNewlineOrEOF() && Token.isNot(MIToken::kw_pre_instr_symbol) &&
  907   while (!Token.isNewlineOrEOF() && Token.isNot(MIToken::kw_pre_instr_symbol) &&
  908          Token.isNot(MIToken::kw_post_instr_symbol) &&
  909          Token.isNot(MIToken::kw_debug_location) &&
  910          Token.isNot(MIToken::coloncolon) && Token.isNot(MIToken::lbrace)) {
  910          Token.isNot(MIToken::coloncolon) && Token.isNot(MIToken::lbrace)) {
  911     auto Loc = Token.location();
  918         ParsedMachineOperand(MO, Loc, Token.location(), TiedDefIdx));
  919     if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
  919     if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
  920         Token.is(MIToken::lbrace))
  922     if (Token.isNot(MIToken::comma))
  928   if (Token.is(MIToken::kw_pre_instr_symbol))
  932   if (Token.is(MIToken::kw_post_instr_symbol))
  937   if (Token.is(MIToken::kw_debug_location)) {
  940     if (Token.is(MIToken::exclaim)) {
  943     } else if (Token.is(MIToken::md_dilocation)) {
  955   if (Token.is(MIToken::coloncolon)) {
  957     while (!Token.isNewlineOrEOF()) {
  962       if (Token.isNewlineOrEOF())
  964       if (Token.isNot(MIToken::comma))
  995   if (Token.isNot(MIToken::MachineBasicBlock))
 1000   if (Token.isNot(MIToken::Eof))
 1008   if (Token.isNot(MIToken::NamedRegister))
 1013   if (Token.isNot(MIToken::Eof))
 1020   if (Token.isNot(MIToken::VirtualRegister))
 1025   if (Token.isNot(MIToken::Eof))
 1032   if (Token.isNot(MIToken::NamedRegister) &&
 1033       Token.isNot(MIToken::VirtualRegister))
 1041   if (Token.isNot(MIToken::Eof))
 1048   if (Token.isNot(MIToken::StackObject))
 1052   if (Token.isNot(MIToken::Eof))
 1059   if (Token.is(MIToken::exclaim)) {
 1062   } else if (Token.is(MIToken::md_diexpr)) {
 1065   } else if (Token.is(MIToken::md_dilocation)) {
 1070   if (Token.isNot(MIToken::Eof))
 1119     return error(Operands.empty() ? Token.location() : Operands.back().End,
 1129   while (Token.is(MIToken::kw_frame_setup) ||
 1130          Token.is(MIToken::kw_frame_destroy) ||
 1131          Token.is(MIToken::kw_nnan) ||
 1132          Token.is(MIToken::kw_ninf) ||
 1133          Token.is(MIToken::kw_nsz) ||
 1134          Token.is(MIToken::kw_arcp) ||
 1135          Token.is(MIToken::kw_contract) ||
 1136          Token.is(MIToken::kw_afn) ||
 1137          Token.is(MIToken::kw_reassoc) ||
 1138          Token.is(MIToken::kw_nuw) ||
 1139          Token.is(MIToken::kw_nsw) ||
 1140          Token.is(MIToken::kw_exact) ||
 1141          Token.is(MIToken::kw_fpexcept)) {
 1143     if (Token.is(MIToken::kw_frame_setup))
 1145     if (Token.is(MIToken::kw_frame_destroy))
 1147     if (Token.is(MIToken::kw_nnan))
 1149     if (Token.is(MIToken::kw_ninf))
 1151     if (Token.is(MIToken::kw_nsz))
 1153     if (Token.is(MIToken::kw_arcp))
 1155     if (Token.is(MIToken::kw_contract))
 1157     if (Token.is(MIToken::kw_afn))
 1159     if (Token.is(MIToken::kw_reassoc))
 1161     if (Token.is(MIToken::kw_nuw))
 1163     if (Token.is(MIToken::kw_nsw))
 1165     if (Token.is(MIToken::kw_exact))
 1167     if (Token.is(MIToken::kw_fpexcept))
 1172   if (Token.isNot(MIToken::Identifier))
 1174   StringRef InstrName = Token.stringValue();
 1182   assert(Token.is(MIToken::NamedRegister) && "Needs NamedRegister token");
 1183   StringRef Name = Token.stringValue();
 1190   assert(Token.is(MIToken::NamedVirtualRegister) && "Expected NamedVReg token");
 1191   StringRef Name = Token.stringValue();
 1199   if (Token.is(MIToken::NamedVirtualRegister))
 1201   assert(Token.is(MIToken::VirtualRegister) && "Needs VirtualRegister token");
 1210   switch (Token.kind()) {
 1229   if (Token.isNot(MIToken::Identifier) && Token.isNot(MIToken::underscore))
 1229   if (Token.isNot(MIToken::Identifier) && Token.isNot(MIToken::underscore))
 1231   StringRef::iterator Loc = Token.location();
 1232   StringRef Name = Token.stringValue();
 1288   switch (Token.kind()) {
 1325     return error("duplicate '" + Token.stringValue() + "' register flag");
 1331   assert(Token.is(MIToken::dot));
 1333   if (Token.isNot(MIToken::Identifier))
 1335   auto Name = Token.stringValue();
 1346   if (Token.isNot(MIToken::IntegerLiteral))
 1397   while (Token.isRegisterFlag()) {
 1401   if (!Token.isRegister())
 1409   if (Token.is(MIToken::dot)) {
 1415   if (Token.is(MIToken::colon)) {
 1431         if (parseLowLevelType(Token.location(), Ty))
 1450     if (parseLowLevelType(Token.location(), Ty))
 1479   assert(Token.is(MIToken::IntegerLiteral));
 1480   const APSInt &Int = Token.integerValue();
 1500   if (parseIRConstant(Loc, StringRef(Loc, Token.range().end() - Loc), C))
 1520   if (Token.range().front() == 's' || Token.range().front() == 'p') {
 1520   if (Token.range().front() == 's' || Token.range().front() == 'p') {
 1521     StringRef SizeStr = Token.range().drop_front();
 1526   if (Token.range().front() == 's') {
 1527     auto ScalarSize = APSInt(Token.range().drop_front()).getZExtValue();
 1534   } else if (Token.range().front() == 'p') {
 1536     uint64_t AS = APSInt(Token.range().drop_front()).getZExtValue();
 1546   if (Token.isNot(MIToken::less))
 1551   if (Token.isNot(MIToken::IntegerLiteral))
 1553   uint64_t NumElements = Token.integerValue().getZExtValue();
 1559   if (Token.isNot(MIToken::Identifier) || Token.stringValue() != "x")
 1559   if (Token.isNot(MIToken::Identifier) || Token.stringValue() != "x")
 1563   if (Token.range().front() != 's' && Token.range().front() != 'p')
 1563   if (Token.range().front() != 's' && Token.range().front() != 'p')
 1565   StringRef SizeStr = Token.range().drop_front();
 1569   if (Token.range().front() == 's') {
 1570     auto ScalarSize = APSInt(Token.range().drop_front()).getZExtValue();
 1574   } else if (Token.range().front() == 'p') {
 1576     uint64_t AS = APSInt(Token.range().drop_front()).getZExtValue();
 1585   if (Token.isNot(MIToken::greater))
 1594   assert(Token.is(MIToken::Identifier));
 1595   StringRef TypeStr = Token.range();
 1600   StringRef SizeStr = Token.range().drop_front();
 1604   auto Loc = Token.location();
 1606   if (Token.isNot(MIToken::IntegerLiteral)) {
 1607     if (Token.isNot(MIToken::Identifier) ||
 1608         !(Token.range() == "true" || Token.range() == "false"))
 1608         !(Token.range() == "true" || Token.range() == "false"))
 1619   auto Loc = Token.location();
 1621   if (Token.isNot(MIToken::FloatingPointLiteral) &&
 1622       Token.isNot(MIToken::HexLiteral))
 1632   if (Token.hasIntegerValue()) {
 1634     uint64_t Val64 = Token.integerValue().getLimitedValue(Limit);
 1640   if (Token.is(MIToken::HexLiteral)) {
 1653   assert(Token.is(MIToken::MachineBasicBlock) ||
 1654          Token.is(MIToken::MachineBasicBlockLabel));
 1665   if (!Token.stringValue().empty() && Token.stringValue() != MBB->getName())
 1665   if (!Token.stringValue().empty() && Token.stringValue() != MBB->getName())
 1667                  " isn't '" + Token.stringValue() + "'");
 1681   assert(Token.is(MIToken::StackObject));
 1693   if (!Token.stringValue().empty() && Token.stringValue() != Name)
 1693   if (!Token.stringValue().empty() && Token.stringValue() != Name)
 1695                  "' isn't '" + Token.stringValue() + "'");
 1710   assert(Token.is(MIToken::FixedStackObject));
 1732   switch (Token.kind()) {
 1735     GV = M->getNamedValue(Token.stringValue());
 1737       return error(Twine("use of undefined global value '") + Token.range() +
 1769   assert(Token.is(MIToken::ConstantPoolItem));
 1784   assert(Token.is(MIToken::JumpTableIndex));
 1797   assert(Token.is(MIToken::ExternalSymbol));
 1798   const char *Symbol = MF.createExternalSymbolName(Token.stringValue());
 1807   assert(Token.is(MIToken::MCSymbol));
 1808   MCSymbol *Symbol = getOrCreateMCSymbol(Token.stringValue());
 1817   assert(Token.is(MIToken::SubRegisterIndex));
 1818   StringRef Name = Token.stringValue();
 1819   unsigned SubRegIndex = PFS.Target.getSubRegIndex(Token.stringValue());
 1828   assert(Token.is(MIToken::exclaim));
 1830   auto Loc = Token.location();
 1832   if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
 1832   if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
 1846   assert(Token.is(MIToken::md_diexpr));
 1855   if (Token.isNot(MIToken::rparen)) {
 1857       if (Token.is(MIToken::Identifier)) {
 1858         if (unsigned Op = dwarf::getOperationEncoding(Token.stringValue())) {
 1863         if (unsigned Enc = dwarf::getAttributeEncoding(Token.stringValue())) {
 1868         return error(Twine("invalid DWARF op '") + Token.stringValue() + "'");
 1871       if (Token.isNot(MIToken::IntegerLiteral) ||
 1872           Token.integerValue().isSigned())
 1875       auto &U = Token.integerValue();
 1892   assert(Token.is(MIToken::md_dilocation));
 1905   if (Token.isNot(MIToken::rparen)) {
 1907       if (Token.is(MIToken::Identifier)) {
 1908         if (Token.stringValue() == "line") {
 1912           if (Token.isNot(MIToken::IntegerLiteral) ||
 1913               Token.integerValue().isSigned())
 1915           Line = Token.integerValue().getZExtValue();
 1920         if (Token.stringValue() == "column") {
 1924           if (Token.isNot(MIToken::IntegerLiteral) ||
 1925               Token.integerValue().isSigned())
 1927           Column = Token.integerValue().getZExtValue();
 1931         if (Token.stringValue() == "scope") {
 1941         if (Token.stringValue() == "inlinedAt") {
 1945           if (Token.is(MIToken::exclaim)) {
 1948           } else if (Token.is(MIToken::md_dilocation)) {
 1957         if (Token.stringValue() == "isImplicitCode") {
 1961           if (!Token.is(MIToken::Identifier))
 1966           if (Token.stringValue() == "true")
 1968           else if (Token.stringValue() == "false")
 1977                    Token.stringValue() + "'");
 1996   if (Token.is(MIToken::exclaim)) {
 1999   } else if (Token.is(MIToken::md_diexpr)) {
 2008   if (Token.isNot(MIToken::IntegerLiteral))
 2010   if (Token.integerValue().getMinSignedBits() > 32)
 2012   Offset = (int)Token.integerValue().getExtValue();
 2018   if (Token.isNot(MIToken::NamedRegister))
 2035     if (Token.isNot(MIToken::HexLiteral))
 2049   auto Kind = Token.kind();
 2149   switch (Token.kind()) {
 2152         F.getValueSymbolTable()->lookup(Token.stringValue()));
 2154       return error(Twine("use of undefined IR block '") + Token.range() + "'");
 2174   assert(Token.is(MIToken::kw_blockaddress));
 2178   if (Token.isNot(MIToken::GlobalValue) &&
 2179       Token.isNot(MIToken::NamedGlobalValue))
 2191   if (Token.isNot(MIToken::IRBlock) && Token.isNot(MIToken::NamedIRBlock))
 2191   if (Token.isNot(MIToken::IRBlock) && Token.isNot(MIToken::NamedIRBlock))
 2205   assert(Token.is(MIToken::kw_intrinsic));
 2210   if (Token.isNot(MIToken::NamedGlobalValue))
 2213   std::string Name = Token.stringValue();
 2234   assert(Token.is(MIToken::kw_intpred) || Token.is(MIToken::kw_floatpred));
 2234   assert(Token.is(MIToken::kw_intpred) || Token.is(MIToken::kw_floatpred));
 2235   bool IsFloat = Token.is(MIToken::kw_floatpred);
 2241   if (Token.isNot(MIToken::Identifier))
 2246     Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
 2267     Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
 2292   assert(Token.is(MIToken::kw_shufflemask));
 2306     if (Token.is(MIToken::kw_undef)) {
 2309     } else if (Token.is(MIToken::IntegerLiteral)) {
 2311       const APSInt &Int = Token.integerValue();
 2335   assert(Token.is(MIToken::kw_target_index));
 2339   if (Token.isNot(MIToken::Identifier))
 2342   if (PFS.Target.getTargetIndex(Token.stringValue(), Index))
 2343     return error("use of undefined target index '" + Token.stringValue() + "'");
 2354   assert(Token.stringValue() == "CustomRegMask" && "Expected a custom RegMask");
 2361     if (Token.isNot(MIToken::NamedRegister))
 2369     if (Token.isNot(MIToken::comma))
 2381   assert(Token.is(MIToken::kw_liveout));
 2387     if (Token.isNot(MIToken::NamedRegister))
 2395     if (Token.isNot(MIToken::comma))
 2407   switch (Token.kind()) {
 2486     if (const auto *RegMask = PFS.Target.getRegMask(Token.stringValue())) {
 2490     } else if (Token.stringValue() == "CustomRegMask") {
 2505   if (Token.is(MIToken::kw_target_flags)) {
 2510     if (Token.isNot(MIToken::Identifier))
 2512     if (PFS.Target.getDirectTargetFlag(Token.stringValue(), TF)) {
 2513       if (PFS.Target.getBitmaskTargetFlag(Token.stringValue(), TF))
 2514         return error("use of undefined target flag '" + Token.stringValue() +
 2518     while (Token.is(MIToken::comma)) {
 2520       if (Token.isNot(MIToken::Identifier))
 2523       if (PFS.Target.getBitmaskTargetFlag(Token.stringValue(), BitFlag))
 2524         return error("use of undefined target flag '" + Token.stringValue() +
 2533   auto Loc = Token.location();
 2545   if (Token.isNot(MIToken::plus) && Token.isNot(MIToken::minus))
 2545   if (Token.isNot(MIToken::plus) && Token.isNot(MIToken::minus))
 2547   StringRef Sign = Token.range();
 2548   bool IsNegative = Token.is(MIToken::minus);
 2550   if (Token.isNot(MIToken::IntegerLiteral))
 2552   if (Token.integerValue().getMinSignedBits() > 64)
 2554   Offset = Token.integerValue().getExtValue();
 2562   assert(Token.is(MIToken::kw_align));
 2564   if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
 2564   if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
 2577   assert(Token.is(MIToken::kw_addrspace));
 2579   if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
 2579   if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
 2596   switch (Token.kind()) {
 2598     V = MF.getFunction().getValueSymbolTable()->lookup(Token.stringValue());
 2618     if (parseIRConstant(Token.location(), Token.stringValue(), C))
 2618     if (parseIRConstant(Token.location(), Token.stringValue(), C))
 2627     return error(Twine("use of undefined IR value '") + Token.range() + "'");
 2632   if (Token.hasIntegerValue()) {
 2633     if (Token.integerValue().getActiveBits() > 64)
 2635     Result = Token.integerValue().getZExtValue();
 2638   if (Token.is(MIToken::HexLiteral)) {
 2651   assert(Token.is(MIToken::HexLiteral));
 2652   StringRef S = Token.range();
 2669   switch (Token.kind()) {
 2684     if (PFS.Target.getMMOTargetFlag(Token.stringValue(), TF))
 2685       return error("use of undefined target MMO flag '" + Token.stringValue() +
 2696     return error("duplicate '" + Token.stringValue() + "' memory operand flag");
 2702   switch (Token.kind()) {
 2733     switch (Token.kind()) {
 2744           MF.createExternalSymbolName(Token.stringValue()));
 2759   if (Token.is(MIToken::kw_constant_pool) || Token.is(MIToken::kw_stack) ||
 2759   if (Token.is(MIToken::kw_constant_pool) || Token.is(MIToken::kw_stack) ||
 2760       Token.is(MIToken::kw_got) || Token.is(MIToken::kw_jump_table) ||
 2760       Token.is(MIToken::kw_got) || Token.is(MIToken::kw_jump_table) ||
 2761       Token.is(MIToken::FixedStackObject) || Token.is(MIToken::StackObject) ||
 2761       Token.is(MIToken::FixedStackObject) || Token.is(MIToken::StackObject) ||
 2762       Token.is(MIToken::kw_call_entry)) {
 2772   if (Token.isNot(MIToken::NamedIRValue) && Token.isNot(MIToken::IRValue) &&
 2772   if (Token.isNot(MIToken::NamedIRValue) && Token.isNot(MIToken::IRValue) &&
 2773       Token.isNot(MIToken::GlobalValue) &&
 2774       Token.isNot(MIToken::NamedGlobalValue) &&
 2775       Token.isNot(MIToken::QuotedIRValue))
 2793   if (Token.is(MIToken::Identifier) && Token.stringValue() == "syncscope") {
 2793   if (Token.is(MIToken::Identifier) && Token.stringValue() == "syncscope") {
 2812   if (Token.isNot(MIToken::Identifier))
 2815   Order = StringSwitch<AtomicOrdering>(Token.stringValue())
 2836   while (Token.isMemoryOperandFlag()) {
 2840   if (Token.isNot(MIToken::Identifier) ||
 2841       (Token.stringValue() != "load" && Token.stringValue() != "store"))
 2841       (Token.stringValue() != "load" && Token.stringValue() != "store"))
 2843   if (Token.stringValue() == "load")
 2850   if (Token.is(MIToken::Identifier) && Token.stringValue() == "store") {
 2850   if (Token.is(MIToken::Identifier) && Token.stringValue() == "store") {
 2868   if (Token.isNot(MIToken::IntegerLiteral) &&
 2869       Token.isNot(MIToken::kw_unknown_size))
 2873   if (Token.is(MIToken::IntegerLiteral)) {
 2876   } else if (Token.is(MIToken::kw_unknown_size)) {
 2882   if (Token.is(MIToken::Identifier)) {
 2888     if (Token.stringValue() != Word)
 2899     switch (Token.kind()) {
 2942   assert((Token.is(MIToken::kw_pre_instr_symbol) ||
 2943           Token.is(MIToken::kw_post_instr_symbol)) &&
 2946   if (Token.isNot(MIToken::MCSymbol))
 2948   Symbol = getOrCreateMCSymbol(Token.stringValue());
 2950   if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
 2950   if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
 2951       Token.is(MIToken::lbrace))
 2953   if (Token.isNot(MIToken::comma))
 3038   if (Token.isNot(MIToken::StringConstant))
 3040   Result = Token.stringValue();