[AArch64] Suggest b.nfrst if the user tries b.nfirst.

[paulwalker-arm]

llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

3092

To be consistent with other clang/llvm diagnostic can this be "did you mean 'Suggestion'"?

[peterwaller-arm]

LGTM with one more consistency tweak.

llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

3092

Thanks for the patch. Sorry, I think another pass is needed here for consistency, the messages look like so (no quotes, single sentence):

https://github.com/llvm/llvm-project/blob/779bbbf27fe631154bdfaac7a443f198d4654688/llvm/utils/TableGen/AsmMatcherEmitter.cpp#L3091

test/MC/AArch64/invalid-instructions-spellcheck.s
28:// CHECK:      error: unrecognized instruction mnemonic, did you mean: add, addp, adds, addv, fadd, madd?
35:// CHECK-NO-NEON:      error: unrecognized instruction mnemonic, did you mean: add, adds, fadd, madd?

llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

AArch64TargetStreamer &getTargetStreamer() {
     MCTargetStreamer &TS = *getParser().getStreamer().getTargetStreamer();
     return static_cast<AArch64TargetStreamer &>(TS);
   }
 
   SMLoc getLoc() const { return getParser().getTok().getLoc(); }
 
   bool parseSysAlias(StringRef Name, SMLoc NameLoc, OperandVector &Operands);
   void createSysAlias(uint16_t Encoding, OperandVector &Operands, SMLoc S);
-  AArch64CC::CondCode parseCondCodeString(StringRef Cond);
+  AArch64CC::CondCode parseCondCodeString(StringRef Cond,
+                                          std::string &Suggestion);
   bool parseCondCode(OperandVector &Operands, bool invertCondCode);
   unsigned matchRegisterNameAlias(StringRef Name, RegKind Kind);
   bool parseRegister(OperandVector &Operands);
   bool parseSymbolicImmVal(const MCExpr *&ImmVal);
   bool parseNeonVectorList(OperandVector &Operands);
   bool parseOptionalMulOperand(OperandVector &Operands);
   bool parseKeywordOperand(OperandVector &Operands);
   bool parseOperand(OperandVector &Operands, bool isCondCode,
if (ShiftAmount == 0 && Imm != nullptr) {
     return MatchOperand_Success;
   }
 
   Operands.push_back(AArch64Operand::CreateShiftedImm(Imm, ShiftAmount, S,
                                                       getLoc(), getContext()));
   return MatchOperand_Success;
 }
 
-/// parseCondCodeString - Parse a Condition Code string.
-AArch64CC::CondCode AArch64AsmParser::parseCondCodeString(StringRef Cond) {
+/// parseCondCodeString - Parse a Condition Code string, optionally returning a
+/// suggestion to help common typos.
+AArch64CC::CondCode
+AArch64AsmParser::parseCondCodeString(StringRef Cond, std::string &Suggestion) {
   AArch64CC::CondCode CC = StringSwitch<AArch64CC::CondCode>(Cond.lower())
                     .Case("eq", AArch64CC::EQ)
                     .Case("ne", AArch64CC::NE)
                     .Case("cs", AArch64CC::HS)
                     .Case("hs", AArch64CC::HS)
                     .Case("cc", AArch64CC::LO)
                     .Case("lo", AArch64CC::LO)
                     .Case("mi", AArch64CC::MI)
                     .Case("pl", AArch64CC::PL)
                     .Case("vs", AArch64CC::VS)
                     .Case("vc", AArch64CC::VC)
                     .Case("hi", AArch64CC::HI)
                     .Case("ls", AArch64CC::LS)
                     .Case("ge", AArch64CC::GE)
                     .Case("lt", AArch64CC::LT)
                     .Case("gt", AArch64CC::GT)
                     .Case("le", AArch64CC::LE)
                     .Case("al", AArch64CC::AL)
                     .Case("nv", AArch64CC::NV)
                     .Default(AArch64CC::Invalid);
 
   if (CC == AArch64CC::Invalid &&
-      getSTI().getFeatureBits()[AArch64::FeatureSVE])
+      getSTI().getFeatureBits()[AArch64::FeatureSVE]) {
     CC = StringSwitch<AArch64CC::CondCode>(Cond.lower())
                     .Case("none",  AArch64CC::EQ)
                     .Case("any",   AArch64CC::NE)
                     .Case("nlast", AArch64CC::HS)
                     .Case("last",  AArch64CC::LO)
                     .Case("first", AArch64CC::MI)
                     .Case("nfrst", AArch64CC::PL)
                     .Case("pmore", AArch64CC::HI)
                     .Case("plast", AArch64CC::LS)
                     .Case("tcont", AArch64CC::GE)
                     .Case("tstop", AArch64CC::LT)
                     .Default(AArch64CC::Invalid);
 
+    if (CC == AArch64CC::Invalid && Cond.lower() == "nfirst")
+      Suggestion = "nfrst";
+  }
   return CC;
 }
 
 /// parseCondCode - Parse a Condition Code operand.
 bool AArch64AsmParser::parseCondCode(OperandVector &Operands,
                                      bool invertCondCode) {
   SMLoc S = getLoc();
   const AsmToken &Tok = getTok();
   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
 
   StringRef Cond = Tok.getString();
-  AArch64CC::CondCode CC = parseCondCodeString(Cond);
-  if (CC == AArch64CC::Invalid)
-    return TokError("invalid condition code");
+  std::string Suggestion;
+  AArch64CC::CondCode CC = parseCondCodeString(Cond, Suggestion);
+  if (CC == AArch64CC::Invalid) {
+    std::string Msg = "invalid condition code";
+    if (!Suggestion.empty())
+      Msg += ", you probably meant " + Suggestion;
+    return TokError(Msg);
+  }
   Lex(); // Eat identifier token.
 
   if (invertCondCode) {
     if (CC == AArch64CC::AL || CC == AArch64CC::NV)
       return TokError("condition codes AL and NV are invalid for this instruction");
     CC = AArch64CC::getInvertedCondCode(AArch64CC::CondCode(CC));
   }
 
bool AArch64AsmParser::ParseInstruction(ParseInstructionInfo &Info,
   // Handle condition codes for a branch mnemonic
   if ((Head == "b" || Head == "bc") && Next != StringRef::npos) {
     Start = Next;
     Next = Name.find('.', Start + 1);
     Head = Name.slice(Start + 1, Next);
 
     SMLoc SuffixLoc = SMLoc::getFromPointer(NameLoc.getPointer() +
                                             (Head.data() - Name.data()));
-    AArch64CC::CondCode CC = parseCondCodeString(Head);
-    if (CC == AArch64CC::Invalid)
-      return Error(SuffixLoc, "invalid condition code");
+    std::string Suggestion;
+    AArch64CC::CondCode CC = parseCondCodeString(Head, Suggestion);
+    if (CC == AArch64CC::Invalid) {
+      std::string Msg = "invalid condition code";
+      if (!Suggestion.empty())
+        Msg += ", you probably meant " + Suggestion;
+      return Error(SuffixLoc, Msg);
+    }
     Operands.push_back(AArch64Operand::CreateToken(".", SuffixLoc, getContext(),
                                                    /*IsSuffix=*/true));
     Operands.push_back(
         AArch64Operand::CreateCondCode(CC, NameLoc, NameLoc, getContext()));
   }
 
   // Add the remaining tokens in the mnemonic.
   while (Next != StringRef::npos) {

llvm/test/MC/AArch64/SVE/condtion-code-diagnostics.s

+// RUN: not llvm-mc -triple aarch64 -show-encoding -mattr=+sve < %s 2>&1 | FileCheck %s
+
+//------------------------------------------------------------------------------
+// Condition code diagnostics for SVE
+//------------------------------------------------------------------------------
+
+        b.nfirst lbl
+// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid condition code, you probably meant nfrst
+// CHECK-NEXT:  b.nfirst lbl