[RISCV] Add function that check extension name with version

[BeMg]

Summary

Check whether a extension string with version is valid, and get the targetfeature from it.

New functions be used in RISCVISAInfo for https://reviews.llvm.org/D151730.

[BeMg]

update

[kito-cheng]

Could you add some testcase in llvm/unittests/Support/RISCVISAInfoTest.cpp?

[craig.topper]

llvm/lib/Support/RISCVISAInfo.cpp

1261

This function is poorly named. Shouldn't it be findLastNonVersionCharacter?

1262

I think writing as an assignment is more common

StringRef Name = Ext.substr(0, Pos);
StringRef Vers = Ext.substr(Pos);

[craig.topper]

llvm/lib/Support/RISCVISAInfo.cpp

1261

Or it should be findFirstVersionCharacter and take care of the +1

[BeMg]

1. update function body
2. Add unit test
3. findFirstNonVersionCharacter -> findLastNonVersionCharacter

[craig.topper]

llvm/lib/Support/RISCVISAInfo.cpp

223

Can you make a separate patch for renaming this?

[BeMg]

llvm/lib/Support/RISCVISAInfo.cpp

223

OK

[BeMg]

rename findLastNonVersionCharacter with https://reviews.llvm.org/D152506

[BeMg]

rebase

[craig.topper]

llvm/lib/Support/RISCVISAInfo.cpp

1283

I don't think Vers needs to exist. It's only used for !Vers.empty() which is equivalent to Pos != Ext.size()

llvm/unittests/Support/RISCVISAInfoTest.cpp

517

Use EXPECT_TRUE and EXPECT_FALSE

[BeMg]

1. Remove Vers and use Pos != Ext.size()
2. Update testcase by using EXPECT_TRUE|EXPECT_FALSE

[BeMg]

1. Let isSupportedExtension support extension name with version
2. Remove isSupportedExtensionWithVersion

[BeMg]

Revert previous update

[BeMg]

And rename getTargetFeatureFromOneExt into getTargetFeatureForExtension

[BeMg]

rebase

[BeMg]

rebase and update testcase

[BeMg]

rebase and update testcase

[BeMg]

revert last patch because it's wrong one

[craig.topper]

LGTM

llvm/include/llvm/Support/RISCVISAInfo.h

public:
 
   bool hasExtension(StringRef Ext) const;
   std::string toString() const;
   std::vector<std::string> toFeatureVector() const;
   StringRef computeDefaultABI() const;
 
   static bool isSupportedExtensionFeature(StringRef Ext);
   static bool isSupportedExtension(StringRef Ext);
+  static bool isSupportedExtensionWithVersion(StringRef Ext);
   static bool isSupportedExtension(StringRef Ext, unsigned MajorVersion,
                                    unsigned MinorVersion);
   static llvm::Expected<std::unique_ptr<RISCVISAInfo>>
   postProcessAndChecking(std::unique_ptr<RISCVISAInfo> &&ISAInfo);
+  static std::string getTargetFeatureForExtension(StringRef Ext);
 
 private:
   RISCVISAInfo(unsigned XLen)
       : XLen(XLen), FLen(0), MinVLen(0), MaxELen(0), MaxELenFp(0) {}
 
   unsigned XLen;
   unsigned FLen;
   unsigned MinVLen;

llvm/lib/Support/RISCVISAInfo.cpp

 
 // This function finds the last character that doesn't belong to a version
 // (e.g. zba1p0 is extension 'zba' of version '1p0'). So the function will
 // consume [0-9]*p[0-9]* starting from the backward. An extension name will not
 // end with a digit or the letter 'p', so this function will parse correctly.
 // NOTE: This function is NOT able to take empty strings or strings that only
 // have version numbers and no extension name. It assumes the extension name
 // will be at least more than one character.
 static size_t findLastNonVersionCharacter(StringRef Ext) {
   assert(!Ext.empty() &&
          "Already guarded by if-statement in ::parseArchString");
 
   int Pos = Ext.size() - 1;
   while (Pos > 0 && isDigit(Ext[Pos]))
     Pos--;
   if (Pos > 0 && Ext[Pos] == 'p' && isDigit(Ext[Pos - 1])) {
     Pos--;
if (XLen == 32) {
     if (hasExtension("d"))
       return "lp64d";
     if (hasExtension("e"))
       return "lp64e";
     return "lp64";
   }
   llvm_unreachable("Invalid XLEN");
 }
+
+bool RISCVISAInfo::isSupportedExtensionWithVersion(StringRef Ext) {
+  if (Ext.empty())
+    return false;
+
+  auto Pos = findLastNonVersionCharacter(Ext) + 1;
+  StringRef Name = Ext.substr(0, Pos);
+  StringRef Vers = Ext.substr(Pos);
+  if (Vers.empty())
+    return false;
+
+  unsigned Major, Minor, ConsumeLength;
+  if (auto E = getExtensionVersion(Name, Vers, Major, Minor, ConsumeLength,
+                                   true, true)) {
+    consumeError(std::move(E));
+    return false;
+  }
+
+  return true;
+}
+
+std::string RISCVISAInfo::getTargetFeatureForExtension(StringRef Ext) {
+  if (Ext.empty())
+    return std::string();
+
+  auto Pos = findLastNonVersionCharacter(Ext) + 1;
+  StringRef Name = Ext.substr(0, Pos);
+
+  if (Pos != Ext.size() && !isSupportedExtensionWithVersion(Ext))
+    return std::string();
+
+  if (!isSupportedExtension(Name))
+    return std::string();
+
+  return isExperimentalExtension(Name) ? "experimental-" + Name.str()
+                                       : Name.str();
+}

llvm/unittests/Support/RISCVISAInfoTest.cpp

TEST(OrderedExtensionMap, ExtensionsAreCorrectlyOrdered) {
 
   // FIXME: 'l' and 'y' should be ordered after 'i', 'm', 'c'.
   EXPECT_THAT(ExtNames,
               ElementsAre("i", "m", "l", "c", "y", "zicsr", "zmfoo", "zfinx",
                            "zzfoo", "sbar", "sfoo", "xbar", "xfoo"));
 }
 
 TEST(ParseArchString, ZceImplication) {
   auto MaybeRV32IZce = RISCVISAInfo::parseArchString("rv32izce", true);
   ASSERT_THAT_EXPECTED(MaybeRV32IZce, Succeeded());
   RISCVISAInfo::OrderedExtensionMap ExtsRV32IZce =
       (*MaybeRV32IZce)->getExtensions();
   EXPECT_EQ(ExtsRV32IZce.size(), 6UL);
   EXPECT_EQ(ExtsRV32IZce.count("i"), 1U);
   EXPECT_EQ(ExtsRV32IZce.count("zca"), 1U);
   EXPECT_EQ(ExtsRV32IZce.count("zcb"), 1U);
   EXPECT_EQ(ExtsRV32IZce.count("zce"), 1U);
TEST(ParseArchString, ZceImplication) {
   EXPECT_EQ(ExtsRV64IDZce.count("f"), 1U);
   EXPECT_EQ(ExtsRV64IDZce.count("d"), 1U);
   EXPECT_EQ(ExtsRV64IDZce.count("zca"), 1U);
   EXPECT_EQ(ExtsRV64IDZce.count("zcb"), 1U);
   EXPECT_EQ(ExtsRV64IDZce.count("zce"), 1U);
   EXPECT_EQ(ExtsRV64IDZce.count("zcmp"), 1U);
   EXPECT_EQ(ExtsRV64IDZce.count("zcmt"), 1U);
 }
+
+TEST(isSupportedExtensionWithVersion, AcceptsSingleExtensionWithVersion) {
+  EXPECT_TRUE(RISCVISAInfo::isSupportedExtensionWithVersion("zbb1p0"));
+  EXPECT_FALSE(RISCVISAInfo::isSupportedExtensionWithVersion("zbb"));
+  EXPECT_FALSE(RISCVISAInfo::isSupportedExtensionWithVersion("zfoo1p0"));
+  EXPECT_FALSE(RISCVISAInfo::isSupportedExtensionWithVersion("zfoo"));
+  EXPECT_FALSE(RISCVISAInfo::isSupportedExtensionWithVersion(""));
+  EXPECT_FALSE(RISCVISAInfo::isSupportedExtensionWithVersion("c2p0zbb1p0"));
+}
+
+TEST(getTargetFeatureForExtension, RetrieveTargetFeatureFromOneExt) {
+  EXPECT_EQ(RISCVISAInfo::getTargetFeatureForExtension("zbb"), "zbb");
+  EXPECT_EQ(RISCVISAInfo::getTargetFeatureForExtension("zicond1p0"),
+            "experimental-zicond");
+  EXPECT_EQ(RISCVISAInfo::getTargetFeatureForExtension("zicond"),
+            "experimental-zicond");
+  EXPECT_EQ(RISCVISAInfo::getTargetFeatureForExtension("zihintntl1234p4321"),
+            "");
+  EXPECT_EQ(RISCVISAInfo::getTargetFeatureForExtension("zfoo"), "");
+  EXPECT_EQ(RISCVISAInfo::getTargetFeatureForExtension(""), "");
+  EXPECT_EQ(RISCVISAInfo::getTargetFeatureForExtension("zbbzihintntl"), "");
+}