1296 lines · cpp
1//===-- unittests/RISCVISAInfoTest.cpp ------------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#include "llvm/TargetParser/RISCVISAInfo.h"10#include "llvm/ADT/StringMap.h"11#include "llvm/Testing/Support/Error.h"12#include "gtest/gtest.h"13 14using ::testing::ElementsAre;15 16using namespace llvm;17 18bool operator==(const RISCVISAUtils::ExtensionVersion &A,19 const RISCVISAUtils::ExtensionVersion &B) {20 return A.Major == B.Major && A.Minor == B.Minor;21}22 23TEST(ParseNormalizedArchString, RejectsInvalidChars) {24 for (StringRef Input : {"RV32", "rV64", "rv32i2P0", "rv64i2p0_A2p0",25 "rv32e2.0", "rva20u64+zbc"}) {26 EXPECT_EQ(27 toString(RISCVISAInfo::parseNormalizedArchString(Input).takeError()),28 "string may only contain [a-z0-9_]");29 }30}31 32TEST(ParseNormalizedArchString, RejectsInvalidBaseISA) {33 for (StringRef Input : {"rv32", "rv64", "rv32j", "rv65i"}) {34 EXPECT_EQ(35 toString(RISCVISAInfo::parseNormalizedArchString(Input).takeError()),36 "arch string must begin with valid base ISA");37 }38}39 40TEST(ParseNormalizedArchString, RejectsMalformedInputs) {41 for (StringRef Input : {"rv64e2p", "rv32i", "rv64ip1"}) {42 EXPECT_EQ(43 toString(RISCVISAInfo::parseNormalizedArchString(Input).takeError()),44 "extension lacks version in expected format");45 }46 47 for (StringRef Input : {"rv64i2p0_", "rv32i2p0__a2p0"}) {48 EXPECT_EQ(49 toString(RISCVISAInfo::parseNormalizedArchString(Input).takeError()),50 "extension name missing after separator '_'");51 }52}53 54TEST(ParseNormalizedArchString, RejectsOnlyVersion) {55 for (StringRef Input : {"rv64i2p0_1p0", "rv32i2p0_1p0"}) {56 EXPECT_EQ(57 toString(RISCVISAInfo::parseNormalizedArchString(Input).takeError()),58 "missing extension name");59 }60}61 62TEST(ParseNormalizedArchString, RejectsBadZ) {63 for (StringRef Input : {"rv64i2p0_z1p0", "rv32i2p0_z2a1p0"}) {64 EXPECT_EQ(65 toString(RISCVISAInfo::parseNormalizedArchString(Input).takeError()),66 "'z' must be followed by a letter");67 }68}69 70TEST(ParseNormalizedArchString, RejectsBadS) {71 for (StringRef Input : {"rv64i2p0_s1p0", "rv32i2p0_s2a1p0"}) {72 EXPECT_EQ(73 toString(RISCVISAInfo::parseNormalizedArchString(Input).takeError()),74 "'s' must be followed by a letter");75 }76}77 78TEST(ParseNormalizedArchString, RejectsBadX) {79 for (StringRef Input : {"rv64i2p0_x1p0", "rv32i2p0_x2a1p0"}) {80 EXPECT_EQ(81 toString(RISCVISAInfo::parseNormalizedArchString(Input).takeError()),82 "'x' must be followed by a letter");83 }84}85 86TEST(ParseNormalizedArchString, DuplicateExtension) {87 for (StringRef Input : {"rv64i2p0_a2p0_a1p0"}) {88 EXPECT_EQ(89 toString(RISCVISAInfo::parseNormalizedArchString(Input).takeError()),90 "duplicate extension 'a'");91 }92}93 94TEST(ParseNormalizedArchString, AcceptsValidBaseISAsAndSetsXLen) {95 auto MaybeRV32I = RISCVISAInfo::parseNormalizedArchString("rv32i2p0");96 ASSERT_THAT_EXPECTED(MaybeRV32I, Succeeded());97 RISCVISAInfo &InfoRV32I = **MaybeRV32I;98 EXPECT_EQ(InfoRV32I.getExtensions().size(), 1UL);99 EXPECT_TRUE(InfoRV32I.getExtensions().at("i") ==100 (RISCVISAUtils::ExtensionVersion{2, 0}));101 EXPECT_EQ(InfoRV32I.getXLen(), 32U);102 103 auto MaybeRV32E = RISCVISAInfo::parseNormalizedArchString("rv32e2p0");104 ASSERT_THAT_EXPECTED(MaybeRV32E, Succeeded());105 RISCVISAInfo &InfoRV32E = **MaybeRV32E;106 EXPECT_EQ(InfoRV32E.getExtensions().size(), 1UL);107 EXPECT_TRUE(InfoRV32E.getExtensions().at("e") ==108 (RISCVISAUtils::ExtensionVersion{2, 0}));109 EXPECT_EQ(InfoRV32E.getXLen(), 32U);110 111 auto MaybeRV64I = RISCVISAInfo::parseNormalizedArchString("rv64i2p0");112 ASSERT_THAT_EXPECTED(MaybeRV64I, Succeeded());113 RISCVISAInfo &InfoRV64I = **MaybeRV64I;114 EXPECT_EQ(InfoRV64I.getExtensions().size(), 1UL);115 EXPECT_TRUE(InfoRV64I.getExtensions().at("i") ==116 (RISCVISAUtils::ExtensionVersion{2, 0}));117 EXPECT_EQ(InfoRV64I.getXLen(), 64U);118 119 auto MaybeRV64E = RISCVISAInfo::parseNormalizedArchString("rv64e2p0");120 ASSERT_THAT_EXPECTED(MaybeRV64E, Succeeded());121 RISCVISAInfo &InfoRV64E = **MaybeRV64E;122 EXPECT_EQ(InfoRV64E.getExtensions().size(), 1UL);123 EXPECT_TRUE(InfoRV64E.getExtensions().at("e") ==124 (RISCVISAUtils::ExtensionVersion{2, 0}));125 EXPECT_EQ(InfoRV64E.getXLen(), 64U);126}127 128TEST(ParseNormalizedArchString, AcceptsArbitraryExtensionsAndVersions) {129 auto MaybeISAInfo = RISCVISAInfo::parseNormalizedArchString(130 "rv64i5p1_m3p2_zmadeup11p12_sfoo2p0_xbar3p0");131 ASSERT_THAT_EXPECTED(MaybeISAInfo, Succeeded());132 RISCVISAInfo &Info = **MaybeISAInfo;133 EXPECT_EQ(Info.getExtensions().size(), 5UL);134 EXPECT_TRUE(Info.getExtensions().at("i") ==135 (RISCVISAUtils::ExtensionVersion{5, 1}));136 EXPECT_TRUE(Info.getExtensions().at("m") ==137 (RISCVISAUtils::ExtensionVersion{3, 2}));138 EXPECT_TRUE(Info.getExtensions().at("zmadeup") ==139 (RISCVISAUtils::ExtensionVersion{11, 12}));140 EXPECT_TRUE(Info.getExtensions().at("sfoo") ==141 (RISCVISAUtils::ExtensionVersion{2, 0}));142 EXPECT_TRUE(Info.getExtensions().at("xbar") ==143 (RISCVISAUtils::ExtensionVersion{3, 0}));144}145 146TEST(ParseNormalizedArchString, UpdatesFLenMinVLenMaxELen) {147 auto MaybeISAInfo = RISCVISAInfo::parseNormalizedArchString(148 "rv64i2p0_d2p0_zvl64b1p0_zve64d1p0");149 ASSERT_THAT_EXPECTED(MaybeISAInfo, Succeeded());150 RISCVISAInfo &Info = **MaybeISAInfo;151 EXPECT_EQ(Info.getXLen(), 64U);152 EXPECT_EQ(Info.getFLen(), 64U);153 EXPECT_EQ(Info.getMinVLen(), 64U);154 EXPECT_EQ(Info.getMaxELen(), 64U);155 EXPECT_EQ(Info.getMaxELenFp(), 64U);156}157 158TEST(ParseNormalizedArchString, AcceptsUnknownMultiletter) {159 auto MaybeISAInfo = RISCVISAInfo::parseNormalizedArchString(160 "rv64i2p0_f2p0_d2p0_zicsr2p0_ykk1p0");161 ASSERT_THAT_EXPECTED(MaybeISAInfo, Succeeded());162 RISCVISAInfo &Info = **MaybeISAInfo;163 EXPECT_EQ(Info.toString(), "rv64i2p0_f2p0_d2p0_zicsr2p0_ykk1p0");164}165 166TEST(ParseArchString, RejectsInvalidChars) {167 for (StringRef Input : {"RV32", "rV64", "rv32i2P0", "rv64i2p0_A2p0"}) {168 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),169 "string may only contain [a-z0-9_]");170 }171}172 173TEST(ParseArchString, RejectsInvalidBaseISA) {174 for (StringRef Input : {"rv32", "rv64", "rv65i"}) {175 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),176 "string must begin with rv32{i,e,g}, rv64{i,e,g}, or a supported "177 "profile name");178 }179 180 for (StringRef Input : {"rv32j", "rv32_i"}) {181 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),182 "first letter after 'rv32' should be 'e', 'i' or 'g'");183 }184 185 EXPECT_EQ(toString(RISCVISAInfo::parseArchString("rv64k", true).takeError()),186 "first letter after 'rv64' should be 'e', 'i' or 'g'");187}188 189TEST(ParseArchString, RejectsUnsupportedBaseISA) {190 for (StringRef Input : {"rv128i", "rv128g"}) {191 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),192 "string must begin with rv32{i,e,g}, rv64{i,e,g}, or a supported "193 "profile name");194 }195}196 197TEST(ParseArchString, AcceptsSupportedBaseISAsAndSetsXLenAndFLen) {198 auto MaybeRV32I = RISCVISAInfo::parseArchString("rv32i", true);199 ASSERT_THAT_EXPECTED(MaybeRV32I, Succeeded());200 RISCVISAInfo &InfoRV32I = **MaybeRV32I;201 const auto &ExtsRV32I = InfoRV32I.getExtensions();202 EXPECT_EQ(ExtsRV32I.size(), 1UL);203 EXPECT_TRUE(ExtsRV32I.at("i") == (RISCVISAUtils::ExtensionVersion{2, 1}));204 EXPECT_EQ(InfoRV32I.getXLen(), 32U);205 EXPECT_EQ(InfoRV32I.getFLen(), 0U);206 EXPECT_EQ(InfoRV32I.getMinVLen(), 0U);207 EXPECT_EQ(InfoRV32I.getMaxELen(), 0U);208 EXPECT_EQ(InfoRV32I.getMaxELenFp(), 0U);209 210 auto MaybeRV32E = RISCVISAInfo::parseArchString("rv32e", true);211 ASSERT_THAT_EXPECTED(MaybeRV32E, Succeeded());212 RISCVISAInfo &InfoRV32E = **MaybeRV32E;213 const auto &ExtsRV32E = InfoRV32E.getExtensions();214 EXPECT_EQ(ExtsRV32E.size(), 1UL);215 EXPECT_TRUE(ExtsRV32E.at("e") == (RISCVISAUtils::ExtensionVersion{2, 0}));216 EXPECT_EQ(InfoRV32E.getXLen(), 32U);217 EXPECT_EQ(InfoRV32E.getFLen(), 0U);218 EXPECT_EQ(InfoRV32E.getMinVLen(), 0U);219 EXPECT_EQ(InfoRV32E.getMaxELen(), 0U);220 EXPECT_EQ(InfoRV32E.getMaxELenFp(), 0U);221 222 auto MaybeRV32G = RISCVISAInfo::parseArchString("rv32g", true);223 ASSERT_THAT_EXPECTED(MaybeRV32G, Succeeded());224 RISCVISAInfo &InfoRV32G = **MaybeRV32G;225 const auto &ExtsRV32G = InfoRV32G.getExtensions();226 EXPECT_EQ(ExtsRV32G.size(), 10UL);227 EXPECT_TRUE(ExtsRV32G.at("i") == (RISCVISAUtils::ExtensionVersion{2, 1}));228 EXPECT_TRUE(ExtsRV32G.at("m") == (RISCVISAUtils::ExtensionVersion{2, 0}));229 EXPECT_TRUE(ExtsRV32G.at("a") == (RISCVISAUtils::ExtensionVersion{2, 1}));230 EXPECT_TRUE(ExtsRV32G.at("f") == (RISCVISAUtils::ExtensionVersion{2, 2}));231 EXPECT_TRUE(ExtsRV32G.at("d") == (RISCVISAUtils::ExtensionVersion{2, 2}));232 EXPECT_TRUE(ExtsRV32G.at("zicsr") == (RISCVISAUtils::ExtensionVersion{2, 0}));233 EXPECT_TRUE(ExtsRV32G.at("zifencei") ==234 (RISCVISAUtils::ExtensionVersion{2, 0}));235 EXPECT_TRUE(ExtsRV32G.at("zmmul") == (RISCVISAUtils::ExtensionVersion{1, 0}));236 EXPECT_TRUE(ExtsRV32G.at("zaamo") == (RISCVISAUtils::ExtensionVersion{1, 0}));237 EXPECT_TRUE(ExtsRV32G.at("zalrsc") ==238 (RISCVISAUtils::ExtensionVersion{1, 0}));239 EXPECT_EQ(InfoRV32G.getXLen(), 32U);240 EXPECT_EQ(InfoRV32G.getFLen(), 64U);241 EXPECT_EQ(InfoRV32G.getMinVLen(), 0U);242 EXPECT_EQ(InfoRV32G.getMaxELen(), 0U);243 EXPECT_EQ(InfoRV32G.getMaxELenFp(), 0U);244 245 auto MaybeRV64I = RISCVISAInfo::parseArchString("rv64i", true);246 ASSERT_THAT_EXPECTED(MaybeRV64I, Succeeded());247 RISCVISAInfo &InfoRV64I = **MaybeRV64I;248 const auto &ExtsRV64I = InfoRV64I.getExtensions();249 EXPECT_EQ(ExtsRV64I.size(), 1UL);250 EXPECT_TRUE(ExtsRV64I.at("i") == (RISCVISAUtils::ExtensionVersion{2, 1}));251 EXPECT_EQ(InfoRV64I.getXLen(), 64U);252 EXPECT_EQ(InfoRV64I.getFLen(), 0U);253 EXPECT_EQ(InfoRV64I.getMinVLen(), 0U);254 EXPECT_EQ(InfoRV64I.getMaxELen(), 0U);255 EXPECT_EQ(InfoRV64I.getMaxELenFp(), 0U);256 257 auto MaybeRV64E = RISCVISAInfo::parseArchString("rv64e", true);258 ASSERT_THAT_EXPECTED(MaybeRV64E, Succeeded());259 RISCVISAInfo &InfoRV64E = **MaybeRV64E;260 const auto &ExtsRV64E = InfoRV64E.getExtensions();261 EXPECT_EQ(ExtsRV64E.size(), 1UL);262 EXPECT_TRUE(ExtsRV64E.at("e") == (RISCVISAUtils::ExtensionVersion{2, 0}));263 EXPECT_EQ(InfoRV64E.getXLen(), 64U);264 EXPECT_EQ(InfoRV64E.getFLen(), 0U);265 EXPECT_EQ(InfoRV64E.getMinVLen(), 0U);266 EXPECT_EQ(InfoRV64E.getMaxELen(), 0U);267 EXPECT_EQ(InfoRV64E.getMaxELenFp(), 0U);268 269 auto MaybeRV64G = RISCVISAInfo::parseArchString("rv64g", true);270 ASSERT_THAT_EXPECTED(MaybeRV64G, Succeeded());271 RISCVISAInfo &InfoRV64G = **MaybeRV64G;272 const auto &ExtsRV64G = InfoRV64G.getExtensions();273 EXPECT_EQ(ExtsRV64G.size(), 10UL);274 EXPECT_TRUE(ExtsRV64G.at("i") == (RISCVISAUtils::ExtensionVersion{2, 1}));275 EXPECT_TRUE(ExtsRV64G.at("m") == (RISCVISAUtils::ExtensionVersion{2, 0}));276 EXPECT_TRUE(ExtsRV64G.at("a") == (RISCVISAUtils::ExtensionVersion{2, 1}));277 EXPECT_TRUE(ExtsRV64G.at("f") == (RISCVISAUtils::ExtensionVersion{2, 2}));278 EXPECT_TRUE(ExtsRV64G.at("d") == (RISCVISAUtils::ExtensionVersion{2, 2}));279 EXPECT_TRUE(ExtsRV64G.at("zicsr") == (RISCVISAUtils::ExtensionVersion{2, 0}));280 EXPECT_TRUE(ExtsRV64G.at("zifencei") ==281 (RISCVISAUtils::ExtensionVersion{2, 0}));282 EXPECT_TRUE(ExtsRV64G.at("zmmul") == (RISCVISAUtils::ExtensionVersion{1, 0}));283 EXPECT_TRUE(ExtsRV64G.at("zaamo") == (RISCVISAUtils::ExtensionVersion{1, 0}));284 EXPECT_TRUE(ExtsRV64G.at("zalrsc") ==285 (RISCVISAUtils::ExtensionVersion{1, 0}));286 EXPECT_EQ(InfoRV64G.getXLen(), 64U);287 EXPECT_EQ(InfoRV64G.getFLen(), 64U);288 EXPECT_EQ(InfoRV64G.getMinVLen(), 0U);289 EXPECT_EQ(InfoRV64G.getMaxELen(), 0U);290 EXPECT_EQ(InfoRV64G.getMaxELenFp(), 0U);291 292 auto MaybeRV64GCV = RISCVISAInfo::parseArchString("rv64gcv", true);293 ASSERT_THAT_EXPECTED(MaybeRV64GCV, Succeeded());294 RISCVISAInfo &InfoRV64GCV = **MaybeRV64GCV;295 const auto &ExtsRV64GCV = InfoRV64GCV.getExtensions();296 EXPECT_EQ(ExtsRV64GCV.size(), 22UL);297 EXPECT_TRUE(ExtsRV64GCV.at("i") == (RISCVISAUtils::ExtensionVersion{2, 1}));298 EXPECT_TRUE(ExtsRV64GCV.at("m") == (RISCVISAUtils::ExtensionVersion{2, 0}));299 EXPECT_TRUE(ExtsRV64GCV.at("a") == (RISCVISAUtils::ExtensionVersion{2, 1}));300 EXPECT_TRUE(ExtsRV64GCV.at("f") == (RISCVISAUtils::ExtensionVersion{2, 2}));301 EXPECT_TRUE(ExtsRV64GCV.at("d") == (RISCVISAUtils::ExtensionVersion{2, 2}));302 EXPECT_TRUE(ExtsRV64GCV.at("c") == (RISCVISAUtils::ExtensionVersion{2, 0}));303 EXPECT_TRUE(ExtsRV64GCV.at("zicsr") == (RISCVISAUtils::ExtensionVersion{2, 0}));304 EXPECT_TRUE(ExtsRV64GCV.at("zifencei") ==305 (RISCVISAUtils::ExtensionVersion{2, 0}));306 EXPECT_TRUE(ExtsRV64GCV.at("zmmul") == (RISCVISAUtils::ExtensionVersion{1, 0}));307 EXPECT_TRUE(ExtsRV64GCV.at("zaamo") == (RISCVISAUtils::ExtensionVersion{1, 0}));308 EXPECT_TRUE(ExtsRV64GCV.at("zalrsc") ==309 (RISCVISAUtils::ExtensionVersion{1, 0}));310 EXPECT_TRUE(ExtsRV64GCV.at("zca") == (RISCVISAUtils::ExtensionVersion{1, 0}));311 EXPECT_TRUE(ExtsRV64GCV.at("zcd") == (RISCVISAUtils::ExtensionVersion{1, 0}));312 EXPECT_TRUE(ExtsRV64GCV.at("v") == (RISCVISAUtils::ExtensionVersion{1, 0}));313 EXPECT_TRUE(ExtsRV64GCV.at("zve32x") == (RISCVISAUtils::ExtensionVersion{1, 0}));314 EXPECT_TRUE(ExtsRV64GCV.at("zve32f") == (RISCVISAUtils::ExtensionVersion{1, 0}));315 EXPECT_TRUE(ExtsRV64GCV.at("zve64x") == (RISCVISAUtils::ExtensionVersion{1, 0}));316 EXPECT_TRUE(ExtsRV64GCV.at("zve64f") == (RISCVISAUtils::ExtensionVersion{1, 0}));317 EXPECT_TRUE(ExtsRV64GCV.at("zve64d") == (RISCVISAUtils::ExtensionVersion{1, 0}));318 EXPECT_TRUE(ExtsRV64GCV.at("zvl32b") == (RISCVISAUtils::ExtensionVersion{1, 0}));319 EXPECT_TRUE(ExtsRV64GCV.at("zvl64b") == (RISCVISAUtils::ExtensionVersion{1, 0}));320 EXPECT_TRUE(ExtsRV64GCV.at("zvl128b") == (RISCVISAUtils::ExtensionVersion{1, 0}));321 EXPECT_EQ(InfoRV64GCV.getXLen(), 64U);322 EXPECT_EQ(InfoRV64GCV.getFLen(), 64U);323 EXPECT_EQ(InfoRV64GCV.getMinVLen(), 128U);324 EXPECT_EQ(InfoRV64GCV.getMaxELen(), 64U);325 EXPECT_EQ(InfoRV64GCV.getMaxELenFp(), 64U);326}327 328TEST(ParseArchString, RejectsUnrecognizedExtensionNamesByDefault) {329 EXPECT_EQ(330 toString(331 RISCVISAInfo::parseArchString("rv32i_zmadeup", true).takeError()),332 "unsupported standard user-level extension 'zmadeup'");333 EXPECT_EQ(334 toString(335 RISCVISAInfo::parseArchString("rv64g_smadeup", true).takeError()),336 "unsupported standard supervisor-level extension 'smadeup'");337 EXPECT_EQ(338 toString(339 RISCVISAInfo::parseArchString("rv64g_xmadeup", true).takeError()),340 "unsupported non-standard user-level extension 'xmadeup'");341 EXPECT_EQ(342 toString(343 RISCVISAInfo::parseArchString("rv32i_zmadeup1p0", true).takeError()),344 "unsupported standard user-level extension 'zmadeup'");345 EXPECT_EQ(346 toString(347 RISCVISAInfo::parseArchString("rv64g_smadeup1p0", true).takeError()),348 "unsupported standard supervisor-level extension 'smadeup'");349 EXPECT_EQ(350 toString(351 RISCVISAInfo::parseArchString("rv64g_xmadeup1p0", true).takeError()),352 "unsupported non-standard user-level extension 'xmadeup'");353}354 355TEST(ParseArchString, AcceptsVersionInLongOrShortForm) {356 for (StringRef Input : {"rv64i2p1"}) {357 auto MaybeISAInfo = RISCVISAInfo::parseArchString(Input, true);358 ASSERT_THAT_EXPECTED(MaybeISAInfo, Succeeded());359 const auto &Exts = (*MaybeISAInfo)->getExtensions();360 EXPECT_TRUE(Exts.at("i") == (RISCVISAUtils::ExtensionVersion{2, 1}));361 }362 for (StringRef Input : {"rv32i_zfinx1", "rv32i_zfinx1p0"}) {363 auto MaybeISAInfo = RISCVISAInfo::parseArchString(Input, true);364 ASSERT_THAT_EXPECTED(MaybeISAInfo, Succeeded());365 const auto &Exts = (*MaybeISAInfo)->getExtensions();366 EXPECT_TRUE(Exts.at("zfinx") == (RISCVISAUtils::ExtensionVersion{1, 0}));367 }368}369 370TEST(ParseArchString, RejectsUnrecognizedExtensionVersionsByDefault) {371 EXPECT_EQ(372 toString(RISCVISAInfo::parseArchString("rv64i2p", true).takeError()),373 "minor version number missing after 'p' for extension 'i'");374 EXPECT_EQ(375 toString(RISCVISAInfo::parseArchString("rv64i1p0", true).takeError()),376 "unsupported version number 1.0 for extension 'i'");377 EXPECT_EQ(378 toString(RISCVISAInfo::parseArchString("rv64i9p9", true).takeError()),379 "unsupported version number 9.9 for extension 'i'");380 EXPECT_EQ(381 toString(RISCVISAInfo::parseArchString("rv32im0p1", true).takeError()),382 "unsupported version number 0.1 for extension 'm'");383 EXPECT_EQ(toString(RISCVISAInfo::parseArchString("rv32izifencei10p10", true)384 .takeError()),385 "unsupported version number 10.10 for extension 'zifencei'");386}387 388TEST(ParseArchString, AcceptsUnderscoreSplittingExtensions) {389 for (StringRef Input : {"rv32imafdczifencei", "rv32i_m_a_f_d_c_zifencei"}) {390 auto MaybeISAInfo = RISCVISAInfo::parseArchString(Input, true);391 ASSERT_THAT_EXPECTED(MaybeISAInfo, Succeeded());392 const auto &Exts = (*MaybeISAInfo)->getExtensions();393 EXPECT_EQ(Exts.size(), 14UL);394 EXPECT_EQ(Exts.count("i"), 1U);395 EXPECT_EQ(Exts.count("m"), 1U);396 EXPECT_EQ(Exts.count("a"), 1U);397 EXPECT_EQ(Exts.count("f"), 1U);398 EXPECT_EQ(Exts.count("d"), 1U);399 EXPECT_EQ(Exts.count("c"), 1U);400 EXPECT_EQ(Exts.count("zicsr"), 1U);401 EXPECT_EQ(Exts.count("zifencei"), 1U);402 EXPECT_EQ(Exts.count("zmmul"), 1U);403 EXPECT_EQ(Exts.count("zaamo"), 1U);404 EXPECT_EQ(Exts.count("zalrsc"), 1U);405 EXPECT_EQ(Exts.count("zca"), 1U);406 EXPECT_EQ(Exts.count("zcf"), 1U);407 EXPECT_EQ(Exts.count("zcd"), 1U);408 }409}410 411TEST(ParseArchString, AcceptsRelaxSingleLetterExtensions) {412 for (StringRef Input :413 {"rv32imfad", "rv32im_fa_d", "rv32im2p0fad", "rv32i2p1m2p0fad"}) {414 auto MaybeISAInfo = RISCVISAInfo::parseArchString(Input, true);415 ASSERT_THAT_EXPECTED(MaybeISAInfo, Succeeded());416 const auto &Exts = (*MaybeISAInfo)->getExtensions();417 EXPECT_EQ(Exts.size(), 9UL);418 EXPECT_EQ(Exts.count("i"), 1U);419 EXPECT_EQ(Exts.count("m"), 1U);420 EXPECT_EQ(Exts.count("f"), 1U);421 EXPECT_EQ(Exts.count("a"), 1U);422 EXPECT_EQ(Exts.count("d"), 1U);423 EXPECT_EQ(Exts.count("zicsr"), 1U);424 EXPECT_EQ(Exts.count("zmmul"), 1U);425 EXPECT_EQ(Exts.count("zaamo"), 1U);426 EXPECT_EQ(Exts.count("zalrsc"), 1U);427 }428}429 430TEST(ParseArchString, AcceptsRelaxMixedLetterExtensions) {431 for (StringRef Input :432 {"rv32i_zihintntl_m_a_f_d_svinval", "rv32izihintntl_mafdsvinval",433 "rv32i_zihintntl_mafd_svinval"}) {434 auto MaybeISAInfo = RISCVISAInfo::parseArchString(Input, true);435 ASSERT_THAT_EXPECTED(MaybeISAInfo, Succeeded());436 const auto &Exts = (*MaybeISAInfo)->getExtensions();437 EXPECT_EQ(Exts.size(), 11UL);438 EXPECT_EQ(Exts.count("i"), 1U);439 EXPECT_EQ(Exts.count("m"), 1U);440 EXPECT_EQ(Exts.count("a"), 1U);441 EXPECT_EQ(Exts.count("f"), 1U);442 EXPECT_EQ(Exts.count("d"), 1U);443 EXPECT_EQ(Exts.count("zihintntl"), 1U);444 EXPECT_EQ(Exts.count("svinval"), 1U);445 EXPECT_EQ(Exts.count("zicsr"), 1U);446 EXPECT_EQ(Exts.count("zmmul"), 1U);447 EXPECT_EQ(Exts.count("zaamo"), 1U);448 EXPECT_EQ(Exts.count("zalrsc"), 1U);449 }450}451 452TEST(ParseArchString, AcceptsAmbiguousFromRelaxExtensions) {453 for (StringRef Input : {"rv32i_zba_m", "rv32izba_m", "rv32izba1p0_m2p0"}) {454 auto MaybeISAInfo = RISCVISAInfo::parseArchString(Input, true);455 ASSERT_THAT_EXPECTED(MaybeISAInfo, Succeeded());456 const auto &Exts = (*MaybeISAInfo)->getExtensions();457 EXPECT_EQ(Exts.size(), 4UL);458 EXPECT_EQ(Exts.count("i"), 1U);459 EXPECT_EQ(Exts.count("zba"), 1U);460 EXPECT_EQ(Exts.count("m"), 1U);461 EXPECT_EQ(Exts.count("zmmul"), 1U);462 }463 for (StringRef Input :464 {"rv32ia_zba_m", "rv32iazba_m", "rv32ia2p1zba1p0_m2p0"}) {465 auto MaybeISAInfo = RISCVISAInfo::parseArchString(Input, true);466 ASSERT_THAT_EXPECTED(MaybeISAInfo, Succeeded());467 const auto &Exts = (*MaybeISAInfo)->getExtensions();468 EXPECT_EQ(Exts.size(), 7UL);469 EXPECT_EQ(Exts.count("i"), 1U);470 EXPECT_EQ(Exts.count("zba"), 1U);471 EXPECT_EQ(Exts.count("m"), 1U);472 EXPECT_EQ(Exts.count("a"), 1U);473 EXPECT_EQ(Exts.count("zmmul"), 1U);474 EXPECT_EQ(Exts.count("zaamo"), 1U);475 EXPECT_EQ(Exts.count("zalrsc"), 1U);476 }477}478 479TEST(ParseArchString, RejectsRelaxExtensionsNotStartWithEorIorG) {480 EXPECT_EQ(481 toString(RISCVISAInfo::parseArchString("rv32zba_im", true).takeError()),482 "first letter after 'rv32' should be 'e', 'i' or 'g'");483}484 485TEST(ParseArchString,486 RejectsMultiLetterExtensionFollowBySingleLetterExtensions) {487 for (StringRef Input : {"rv32izbam", "rv32i_zbam"})488 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),489 "unsupported standard user-level extension 'zbam'");490 EXPECT_EQ(491 toString(RISCVISAInfo::parseArchString("rv32izbai_m", true).takeError()),492 "unsupported standard user-level extension 'zbai'");493 EXPECT_EQ(494 toString(RISCVISAInfo::parseArchString("rv32izbaim", true).takeError()),495 "unsupported standard user-level extension 'zbaim'");496 EXPECT_EQ(497 toString(498 RISCVISAInfo::parseArchString("rv32i_zba1p0m", true).takeError()),499 "unsupported standard user-level extension 'zba1p0m'");500}501 502TEST(ParseArchString, RejectsDoubleOrTrailingUnderscore) {503 EXPECT_EQ(504 toString(RISCVISAInfo::parseArchString("rv64i__m", true).takeError()),505 "extension name missing after separator '_'");506 507 for (StringRef Input :508 {"rv32ezicsr__zifencei", "rv32i_", "rv32izicsr_", "rv64im_"}) {509 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),510 "extension name missing after separator '_'");511 }512}513 514TEST(ParseArchString, RejectsDuplicateExtensionNames) {515 // Zicsr/Zifencei are allowed to duplicate with "g".516 ASSERT_THAT_EXPECTED(RISCVISAInfo::parseArchString("rv64g_zicsr", true),517 Succeeded());518 ASSERT_THAT_EXPECTED(RISCVISAInfo::parseArchString("rv64g_zifencei", true),519 Succeeded());520 ASSERT_THAT_EXPECTED(521 RISCVISAInfo::parseArchString("rv64g_zicsr_zifencei", true), Succeeded());522 523 EXPECT_EQ(toString(RISCVISAInfo::parseArchString("rv64ii", true).takeError()),524 "invalid standard user-level extension 'i'");525 EXPECT_EQ(toString(RISCVISAInfo::parseArchString("rv32ee", true).takeError()),526 "invalid standard user-level extension 'e'");527 EXPECT_EQ(528 toString(RISCVISAInfo::parseArchString("rv64imm", true).takeError()),529 "duplicated standard user-level extension 'm'");530 EXPECT_EQ(531 toString(532 RISCVISAInfo::parseArchString("rv32i_zicsr_zicsr", true).takeError()),533 "duplicated standard user-level extension 'zicsr'");534}535 536TEST(ParseArchString,537 RejectsExperimentalExtensionsIfNotEnableExperimentalExtension) {538 EXPECT_EQ(539 toString(RISCVISAInfo::parseArchString("rv64izalasr", false).takeError()),540 "requires '-menable-experimental-extensions' for experimental extension "541 "'zalasr'");542}543 544TEST(ParseArchString,545 AcceptsExperimentalExtensionsIfEnableExperimentalExtension) {546 // Note: If zalasr becomes none-experimental, this test will need547 // updating (and unfortunately, it will still pass). The failure of548 // RejectsExperimentalExtensionsIfNotEnableExperimentalExtension will549 // hopefully serve as a reminder to update.550 auto MaybeISAInfo = RISCVISAInfo::parseArchString("rv64izalasr", true, false);551 ASSERT_THAT_EXPECTED(MaybeISAInfo, Succeeded());552 const auto &Exts = (*MaybeISAInfo)->getExtensions();553 EXPECT_EQ(Exts.size(), 2UL);554 EXPECT_EQ(Exts.count("zalasr"), 1U);555 auto MaybeISAInfo2 = RISCVISAInfo::parseArchString("rv64izalasr0p9", true);556 ASSERT_THAT_EXPECTED(MaybeISAInfo2, Succeeded());557 const auto &Exts2 = (*MaybeISAInfo2)->getExtensions();558 EXPECT_EQ(Exts2.size(), 2UL);559 EXPECT_EQ(Exts2.count("zalasr"), 1U);560}561 562TEST(ParseArchString,563 RequiresExplicitVersionNumberForExperimentalExtensionByDefault) {564 EXPECT_EQ(565 toString(RISCVISAInfo::parseArchString("rv64izalasr", true).takeError()),566 "experimental extension requires explicit version number `zalasr`");567}568 569TEST(ParseArchString,570 AcceptsUnrecognizedVersionIfNotExperimentalExtensionVersionCheck) {571 auto MaybeISAInfo =572 RISCVISAInfo::parseArchString("rv64izalasr9p9", true, false);573 ASSERT_THAT_EXPECTED(MaybeISAInfo, Succeeded());574 const auto &Exts = (*MaybeISAInfo)->getExtensions();575 EXPECT_EQ(Exts.size(), 2UL);576 EXPECT_TRUE(Exts.at("zalasr") == (RISCVISAUtils::ExtensionVersion{9, 9}));577}578 579TEST(ParseArchString, RejectsUnrecognizedVersionForExperimentalExtension) {580 EXPECT_EQ(581 toString(582 RISCVISAInfo::parseArchString("rv64izalasr9p9", true).takeError()),583 "unsupported version number 9.9 for experimental extension 'zalasr' "584 "(this compiler supports 0.9)");585}586 587TEST(ParseArchString, RejectsExtensionVersionForG) {588 for (StringRef Input : {"rv32g1c", "rv64g2p0"}) {589 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),590 "version not supported for 'g'");591 }592}593 594TEST(ParseArchString, AddsImpliedExtensions) {595 // Does not attempt to exhaustively test all implications.596 auto MaybeRV64ID = RISCVISAInfo::parseArchString("rv64id", true);597 ASSERT_THAT_EXPECTED(MaybeRV64ID, Succeeded());598 const auto &ExtsRV64ID = (*MaybeRV64ID)->getExtensions();599 EXPECT_EQ(ExtsRV64ID.size(), 4UL);600 EXPECT_EQ(ExtsRV64ID.count("i"), 1U);601 EXPECT_EQ(ExtsRV64ID.count("f"), 1U);602 EXPECT_EQ(ExtsRV64ID.count("d"), 1U);603 EXPECT_EQ(ExtsRV64ID.count("zicsr"), 1U);604 605 auto MaybeRV32IZKN = RISCVISAInfo::parseArchString("rv64izkn", true);606 ASSERT_THAT_EXPECTED(MaybeRV32IZKN, Succeeded());607 const auto &ExtsRV32IZKN = (*MaybeRV32IZKN)->getExtensions();608 EXPECT_EQ(ExtsRV32IZKN.size(), 8UL);609 EXPECT_EQ(ExtsRV32IZKN.count("i"), 1U);610 EXPECT_EQ(ExtsRV32IZKN.count("zbkb"), 1U);611 EXPECT_EQ(ExtsRV32IZKN.count("zbkc"), 1U);612 EXPECT_EQ(ExtsRV32IZKN.count("zbkx"), 1U);613 EXPECT_EQ(ExtsRV32IZKN.count("zkne"), 1U);614 EXPECT_EQ(ExtsRV32IZKN.count("zknd"), 1U);615 EXPECT_EQ(ExtsRV32IZKN.count("zknh"), 1U);616 EXPECT_EQ(ExtsRV32IZKN.count("zkn"), 1U);617}618 619TEST(ParseArchString, RejectsConflictingExtensions) {620 for (StringRef Input : {"rv32ifzfinx", "rv64gzdinx"}) {621 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),622 "'f' and 'zfinx' extensions are incompatible");623 }624 625 for (StringRef Input : {"rv32idc_zcmp1p0", "rv64idc_zcmp1p0"}) {626 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),627 "'zcmp' extension is incompatible with 'c' extension when 'd' "628 "extension is enabled");629 }630 631 for (StringRef Input : {"rv32id_zcd1p0_zcmp1p0", "rv64id_zcd1p0_zcmp1p0"}) {632 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),633 "'zcmp' extension is incompatible with 'zcd' extension when 'd' "634 "extension is enabled");635 }636 637 for (StringRef Input : {"rv32idc_zcmt1p0", "rv64idc_zcmt1p0"}) {638 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),639 "'zcmt' extension is incompatible with 'c' extension when 'd' "640 "extension is enabled");641 }642 643 for (StringRef Input : {"rv32id_zcd1p0_zcmt1p0", "rv64id_zcd1p0_zcmt1p0"}) {644 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),645 "'zcmt' extension is incompatible with 'zcd' extension when 'd' "646 "extension is enabled");647 }648 649 for (StringRef Input : {"rv64if_zcf"}) {650 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),651 "'zcf' is only supported for 'rv32'");652 }653 654 for (StringRef Input : {"rv64i_xwchc"}) {655 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),656 "'xwchc' is only supported for 'rv32'");657 }658 659 for (StringRef Input : {"rv32id_xwchc"}) {660 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),661 "'d' and 'xwchc' extensions are incompatible");662 }663 664 for (StringRef Input : {"rv32i_zcb_xwchc"}) {665 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),666 "'xwchc' and 'zcb' extensions are incompatible");667 }668 669 for (StringRef Input : {"rv64i_zilsd"}) {670 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),671 "'zilsd' is only supported for 'rv32'");672 }673 674 for (StringRef Input : {"rv64i_zclsd"}) {675 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),676 "'zclsd' is only supported for 'rv32'");677 }678 679 for (StringRef Input : {"rv32i_zcf_zclsd"}) {680 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),681 "'zclsd' and 'zcf' extensions are incompatible");682 }683 684 for (StringRef Input :685 {"rv64i_xqcia0p7", "rv64i_xqciac0p3", "rv64i_xqcibi0p2",686 "rv64i_xqcibm0p8", "rv64i_xqcicli0p3", "rv64i_xqcicm0p2",687 "rv64i_xqcics0p2", "rv64i_xqcicsr0p4", "rv64i_xqciint0p10",688 "rv64i_xqciio0p1", "rv64i_xqcilb0p2", "rv64i_xqcili0p2",689 "rv64i_xqcilia0p2", "rv64i_xqcilo0p3", "rv64i_xqcilsm0p6",690 "rv64i_xqcisim0p2", "rv64i_xqcisls0p2", "rv64i_xqcisync0p3"}) {691 EXPECT_THAT(692 toString(RISCVISAInfo::parseArchString(Input, true).takeError()),693 ::testing::EndsWith(" is only supported for 'rv32'"));694 }695 696 for (StringRef Input :697 {"rv32idc_xqciac0p3", "rv32i_zcd_xqciac0p3", "rv32idc_xqcicm0p2",698 "rv32i_zcd_xqcicm0p2", "rv32idc_xqccmp0p3", "rv32i_zcd_xqccmp0p3"}) {699 EXPECT_THAT(700 toString(RISCVISAInfo::parseArchString(Input, true).takeError()),701 ::testing::EndsWith("extension when 'd' extension is enabled"));702 }703 704 for (StringRef Input : {"rv32i_zcmp_xqccmp0p3", "rv64i_zcmp_xqccmp0p3"}) {705 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),706 "'zcmp' and 'xqccmp' extensions are incompatible");707 }708}709 710TEST(ParseArchString, MissingDepency) {711 for (StringRef Input : {"rv32i_zvl32b", "rv64i_zvl128b"}) {712 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),713 "'zvl*b' requires 'v' or 'zve*' extension to also be specified");714 }715 716 // These all have an implication relationship, thus should pass717 for (StringRef Input : {718 "rv32i_zvbb",719 "rv32i_zvbc32e0p7",720 "rv32i_zvbc",721 "rv32i_zvkb",722 "rv32i_zvkg",723 "rv32i_zvkgs0p7",724 "rv32i_zvkned",725 "rv32i_zvknha",726 "rv32i_zvksed",727 "rv32i_zvksh",728 "rv32i_zvknhb",729 }) {730 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),731 "");732 }733 734 EXPECT_EQ(toString(RISCVISAInfo::parseArchString("rv64i_xsfvfbfexp16e", true)735 .takeError()),736 "'xsfvfbfexp16e' requires 'zvfbfmin' or 'zvfbfa' extension to also "737 "be specified");738}739 740TEST(ParseArchString, RejectsUnrecognizedProfileNames) {741 for (StringRef Input : {"rvi23u99", "rvz23u64", "rva99u32"}) {742 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),743 "string must begin with rv32{i,e,g}, rv64{i,e,g}, or a supported "744 "profile name");745 }746}747 748TEST(ParseArchString, RejectsProfilesWithUnseparatedExtraExtensions) {749 for (StringRef Input : {"rvi20u32m", "rvi20u64c"}) {750 EXPECT_EQ(toString(RISCVISAInfo::parseArchString(Input, true).takeError()),751 "additional extensions must be after separator '_'");752 }753}754 755TEST(ParseArchString, AcceptsBareProfileNames) {756 auto MaybeRVA20U64 = RISCVISAInfo::parseArchString("rva20u64", true);757 ASSERT_THAT_EXPECTED(MaybeRVA20U64, Succeeded());758 const auto &Exts = (*MaybeRVA20U64)->getExtensions();759 EXPECT_EQ(Exts.size(), 18UL);760 EXPECT_EQ(Exts.count("i"), 1U);761 EXPECT_EQ(Exts.count("m"), 1U);762 EXPECT_EQ(Exts.count("f"), 1U);763 EXPECT_EQ(Exts.count("a"), 1U);764 EXPECT_EQ(Exts.count("d"), 1U);765 EXPECT_EQ(Exts.count("c"), 1U);766 EXPECT_EQ(Exts.count("za128rs"), 1U);767 EXPECT_EQ(Exts.count("zicntr"), 1U);768 EXPECT_EQ(Exts.count("ziccif"), 1U);769 EXPECT_EQ(Exts.count("zicsr"), 1U);770 EXPECT_EQ(Exts.count("ziccrse"), 1U);771 EXPECT_EQ(Exts.count("ziccamoa"), 1U);772 EXPECT_EQ(Exts.count("zicclsm"), 1U);773 EXPECT_EQ(Exts.count("zmmul"), 1U);774 EXPECT_EQ(Exts.count("zaamo"), 1U);775 EXPECT_EQ(Exts.count("zalrsc"), 1U);776 EXPECT_EQ(Exts.count("zca"), 1U);777 EXPECT_EQ(Exts.count("zcd"), 1U);778 779 auto MaybeRVA23U64 = RISCVISAInfo::parseArchString("rva23u64", true);780 ASSERT_THAT_EXPECTED(MaybeRVA23U64, Succeeded());781 EXPECT_GT((*MaybeRVA23U64)->getExtensions().size(), 13UL);782}783 784TEST(ParseArchSTring, AcceptsProfileNamesWithSeparatedAdditionalExtensions) {785 auto MaybeRVI20U64 = RISCVISAInfo::parseArchString("rvi20u64_m_zba", true);786 ASSERT_THAT_EXPECTED(MaybeRVI20U64, Succeeded());787 const auto &Exts = (*MaybeRVI20U64)->getExtensions();788 EXPECT_EQ(Exts.size(), 4UL);789 EXPECT_EQ(Exts.count("i"), 1U);790 EXPECT_EQ(Exts.count("m"), 1U);791 EXPECT_EQ(Exts.count("zba"), 1U);792 EXPECT_EQ(Exts.count("zmmul"), 1U);793}794 795TEST(ParseArchString,796 RejectsProfilesWithAdditionalExtensionsGivenAlreadyInProfile) {797 // This test was added to document the current behaviour. Discussion isn't798 // believed to have taken place about if this is desirable or not.799 EXPECT_EQ(800 toString(801 RISCVISAInfo::parseArchString("rva20u64_zicntr", true).takeError()),802 "duplicated standard user-level extension 'zicntr'");803}804 805TEST(ParseArchString,806 RejectsExperimentalProfilesIfEnableExperimentalExtensionsNotSet) {807 EXPECT_EQ(808 toString(RISCVISAInfo::parseArchString("rvm23u32", false).takeError()),809 "requires '-menable-experimental-extensions' for profile 'rvm23u32'");810}811 812TEST(ToFeatures, IIsDroppedAndExperimentalExtensionsArePrefixed) {813 auto MaybeISAInfo1 =814 RISCVISAInfo::parseArchString("rv64im_zalasr", true, false);815 ASSERT_THAT_EXPECTED(MaybeISAInfo1, Succeeded());816 EXPECT_THAT((*MaybeISAInfo1)->toFeatures(),817 ElementsAre("+i", "+m", "+zmmul", "+experimental-zalasr"));818 819 auto MaybeISAInfo2 = RISCVISAInfo::parseArchString(820 "rv32e_zalasr_xventanacondops", true, false);821 ASSERT_THAT_EXPECTED(MaybeISAInfo2, Succeeded());822 EXPECT_THAT((*MaybeISAInfo2)->toFeatures(),823 ElementsAre("+e", "+experimental-zalasr", "+xventanacondops"));824}825 826TEST(ToFeatures, UnsupportedExtensionsAreDropped) {827 auto MaybeISAInfo =828 RISCVISAInfo::parseNormalizedArchString("rv64i2p0_m2p0_xmadeup1p0");829 ASSERT_THAT_EXPECTED(MaybeISAInfo, Succeeded());830 EXPECT_THAT((*MaybeISAInfo)->toFeatures(), ElementsAre("+i", "+m"));831}832 833TEST(ToFeatures, UnsupportedExtensionsAreKeptIfIgnoreUnknownIsFalse) {834 auto MaybeISAInfo =835 RISCVISAInfo::parseNormalizedArchString("rv64i2p0_m2p0_xmadeup1p0");836 ASSERT_THAT_EXPECTED(MaybeISAInfo, Succeeded());837 EXPECT_THAT((*MaybeISAInfo)->toFeatures(false, false),838 ElementsAre("+i", "+m", "+xmadeup"));839}840 841TEST(ToFeatures, AddAllExtensionsAddsNegativeExtensions) {842 auto MaybeISAInfo = RISCVISAInfo::parseNormalizedArchString("rv64i2p0_m2p0");843 ASSERT_THAT_EXPECTED(MaybeISAInfo, Succeeded());844 845 auto Features = (*MaybeISAInfo)->toFeatures(true);846 EXPECT_GT(Features.size(), 2UL);847 EXPECT_EQ(Features[0], "+i");848 EXPECT_EQ(Features[1], "+m");849 // Every feature after should be a negative feature850 for (auto &NegativeExt : llvm::drop_begin(Features, 2))851 EXPECT_TRUE(NegativeExt.substr(0, 1) == "-");852}853 854TEST(OrderedExtensionMap, ExtensionsAreCorrectlyOrdered) {855 RISCVISAUtils::OrderedExtensionMap Exts;856 for (auto ExtName : {"y", "l", "m", "c", "i", "xfoo", "xbar", "sfoo", "sbar",857 "zmfoo", "zzfoo", "zfinx", "zicsr"})858 Exts[ExtName] = {1, 0};859 860 std::vector<std::string> ExtNames;861 for (const auto &Ext : Exts)862 ExtNames.push_back(Ext.first);863 864 // FIXME: 'l' and 'y' should be ordered after 'i', 'm', 'c'.865 EXPECT_THAT(ExtNames,866 ElementsAre("i", "m", "l", "c", "y", "zicsr", "zmfoo", "zfinx",867 "zzfoo", "sbar", "sfoo", "xbar", "xfoo"));868}869 870TEST(ParseArchString, ZceImplication) {871 auto MaybeRV32IZce = RISCVISAInfo::parseArchString("rv32izce", true);872 ASSERT_THAT_EXPECTED(MaybeRV32IZce, Succeeded());873 const auto &ExtsRV32IZce = (*MaybeRV32IZce)->getExtensions();874 EXPECT_EQ(ExtsRV32IZce.size(), 7UL);875 EXPECT_EQ(ExtsRV32IZce.count("i"), 1U);876 EXPECT_EQ(ExtsRV32IZce.count("zicsr"), 1U);877 EXPECT_EQ(ExtsRV32IZce.count("zca"), 1U);878 EXPECT_EQ(ExtsRV32IZce.count("zcb"), 1U);879 EXPECT_EQ(ExtsRV32IZce.count("zce"), 1U);880 EXPECT_EQ(ExtsRV32IZce.count("zcmp"), 1U);881 EXPECT_EQ(ExtsRV32IZce.count("zcmt"), 1U);882 883 auto MaybeRV32IFZce = RISCVISAInfo::parseArchString("rv32ifzce", true);884 ASSERT_THAT_EXPECTED(MaybeRV32IFZce, Succeeded());885 const auto &ExtsRV32IFZce = (*MaybeRV32IFZce)->getExtensions();886 EXPECT_EQ(ExtsRV32IFZce.size(), 9UL);887 EXPECT_EQ(ExtsRV32IFZce.count("i"), 1U);888 EXPECT_EQ(ExtsRV32IFZce.count("zicsr"), 1U);889 EXPECT_EQ(ExtsRV32IFZce.count("f"), 1U);890 EXPECT_EQ(ExtsRV32IFZce.count("zca"), 1U);891 EXPECT_EQ(ExtsRV32IFZce.count("zcb"), 1U);892 EXPECT_EQ(ExtsRV32IFZce.count("zce"), 1U);893 EXPECT_EQ(ExtsRV32IFZce.count("zcf"), 1U);894 EXPECT_EQ(ExtsRV32IFZce.count("zcmp"), 1U);895 EXPECT_EQ(ExtsRV32IFZce.count("zcmt"), 1U);896 897 auto MaybeRV32IDZce = RISCVISAInfo::parseArchString("rv32idzce", true);898 ASSERT_THAT_EXPECTED(MaybeRV32IDZce, Succeeded());899 const auto &ExtsRV32IDZce = (*MaybeRV32IDZce)->getExtensions();900 EXPECT_EQ(ExtsRV32IDZce.size(), 10UL);901 EXPECT_EQ(ExtsRV32IDZce.count("i"), 1U);902 EXPECT_EQ(ExtsRV32IDZce.count("zicsr"), 1U);903 EXPECT_EQ(ExtsRV32IDZce.count("f"), 1U);904 EXPECT_EQ(ExtsRV32IDZce.count("d"), 1U);905 EXPECT_EQ(ExtsRV32IDZce.count("zca"), 1U);906 EXPECT_EQ(ExtsRV32IDZce.count("zcb"), 1U);907 EXPECT_EQ(ExtsRV32IDZce.count("zce"), 1U);908 EXPECT_EQ(ExtsRV32IDZce.count("zcf"), 1U);909 EXPECT_EQ(ExtsRV32IDZce.count("zcmp"), 1U);910 EXPECT_EQ(ExtsRV32IDZce.count("zcmt"), 1U);911 912 auto MaybeRV64IZce = RISCVISAInfo::parseArchString("rv64izce", true);913 ASSERT_THAT_EXPECTED(MaybeRV64IZce, Succeeded());914 const auto &ExtsRV64IZce = (*MaybeRV64IZce)->getExtensions();915 EXPECT_EQ(ExtsRV64IZce.size(), 7UL);916 EXPECT_EQ(ExtsRV64IZce.count("i"), 1U);917 EXPECT_EQ(ExtsRV64IZce.count("zicsr"), 1U);918 EXPECT_EQ(ExtsRV64IZce.count("zca"), 1U);919 EXPECT_EQ(ExtsRV64IZce.count("zcb"), 1U);920 EXPECT_EQ(ExtsRV64IZce.count("zce"), 1U);921 EXPECT_EQ(ExtsRV64IZce.count("zcmp"), 1U);922 EXPECT_EQ(ExtsRV64IZce.count("zcmt"), 1U);923 924 auto MaybeRV64IFZce = RISCVISAInfo::parseArchString("rv64ifzce", true);925 ASSERT_THAT_EXPECTED(MaybeRV64IFZce, Succeeded());926 const auto &ExtsRV64IFZce = (*MaybeRV64IFZce)->getExtensions();927 EXPECT_EQ(ExtsRV64IFZce.size(), 8UL);928 EXPECT_EQ(ExtsRV64IFZce.count("i"), 1U);929 EXPECT_EQ(ExtsRV64IFZce.count("zicsr"), 1U);930 EXPECT_EQ(ExtsRV64IFZce.count("f"), 1U);931 EXPECT_EQ(ExtsRV64IFZce.count("zca"), 1U);932 EXPECT_EQ(ExtsRV64IFZce.count("zcb"), 1U);933 EXPECT_EQ(ExtsRV64IFZce.count("zce"), 1U);934 EXPECT_EQ(ExtsRV64IFZce.count("zcmp"), 1U);935 EXPECT_EQ(ExtsRV64IFZce.count("zcmt"), 1U);936 937 EXPECT_EQ(ExtsRV64IFZce.count("zca"), 1U);938 EXPECT_EQ(ExtsRV64IFZce.count("zcb"), 1U);939 EXPECT_EQ(ExtsRV64IFZce.count("zce"), 1U);940 EXPECT_EQ(ExtsRV64IFZce.count("zcmp"), 1U);941 EXPECT_EQ(ExtsRV64IFZce.count("zcmt"), 1U);942 943 auto MaybeRV64IDZce = RISCVISAInfo::parseArchString("rv64idzce", true);944 ASSERT_THAT_EXPECTED(MaybeRV64IDZce, Succeeded());945 const auto &ExtsRV64IDZce = (*MaybeRV64IDZce)->getExtensions();946 EXPECT_EQ(ExtsRV64IDZce.size(), 9UL);947 EXPECT_EQ(ExtsRV64IDZce.count("i"), 1U);948 EXPECT_EQ(ExtsRV64IDZce.count("zicsr"), 1U);949 EXPECT_EQ(ExtsRV64IDZce.count("f"), 1U);950 EXPECT_EQ(ExtsRV64IDZce.count("d"), 1U);951 EXPECT_EQ(ExtsRV64IDZce.count("zca"), 1U);952 EXPECT_EQ(ExtsRV64IDZce.count("zcb"), 1U);953 EXPECT_EQ(ExtsRV64IDZce.count("zce"), 1U);954 EXPECT_EQ(ExtsRV64IDZce.count("zcmp"), 1U);955 EXPECT_EQ(ExtsRV64IDZce.count("zcmt"), 1U);956}957 958TEST(isSupportedExtensionWithVersion, AcceptsSingleExtensionWithVersion) {959 EXPECT_TRUE(RISCVISAInfo::isSupportedExtensionWithVersion("zbb1p0"));960 EXPECT_FALSE(RISCVISAInfo::isSupportedExtensionWithVersion("zbb"));961 EXPECT_FALSE(RISCVISAInfo::isSupportedExtensionWithVersion("zfoo1p0"));962 EXPECT_FALSE(RISCVISAInfo::isSupportedExtensionWithVersion("zfoo"));963 EXPECT_FALSE(RISCVISAInfo::isSupportedExtensionWithVersion(""));964 EXPECT_FALSE(RISCVISAInfo::isSupportedExtensionWithVersion("c2p0zbb1p0"));965}966 967TEST(getTargetFeatureForExtension, RetrieveTargetFeatureFromOneExt) {968 EXPECT_EQ(RISCVISAInfo::getTargetFeatureForExtension("zbb"), "zbb");969 EXPECT_EQ(RISCVISAInfo::getTargetFeatureForExtension("ztso1p0"), "ztso");970 EXPECT_EQ(RISCVISAInfo::getTargetFeatureForExtension("ztso"), "ztso");971 EXPECT_EQ(RISCVISAInfo::getTargetFeatureForExtension("zihintntl1234p4321"),972 "");973 EXPECT_EQ(RISCVISAInfo::getTargetFeatureForExtension("zfoo"), "");974 EXPECT_EQ(RISCVISAInfo::getTargetFeatureForExtension(""), "");975 EXPECT_EQ(RISCVISAInfo::getTargetFeatureForExtension("zbbzihintntl"), "");976}977 978TEST(RiscvExtensionsHelp, CheckExtensions) {979 // clang-format off980 std::string ExpectedOutput =981R"(All available -march extensions for RISC-V982 983 Name Version Description984 i 2.1 This is a long dummy description985 e 2.0986 m 2.0987 a 2.1988 f 2.2989 d 2.2990 q 2.2991 c 2.0992 b 1.0993 v 1.0994 h 1.0995 zic64b 1.0996 zicbom 1.0997 zicbop 1.0998 zicboz 1.0999 ziccamoa 1.01000 ziccamoc 1.01001 ziccif 1.01002 zicclsm 1.01003 ziccrse 1.01004 zicntr 2.01005 zicond 1.01006 zicsr 2.01007 zifencei 2.01008 zihintntl 1.01009 zihintpause 2.01010 zihpm 2.01011 zilsd 1.01012 zimop 1.01013 zmmul 1.01014 za128rs 1.01015 za64rs 1.01016 zaamo 1.01017 zabha 1.01018 zacas 1.01019 zalrsc 1.01020 zama16b 1.01021 zawrs 1.01022 zfa 1.01023 zfbfmin 1.01024 zfh 1.01025 zfhmin 1.01026 zfinx 1.01027 zdinx 1.01028 zca 1.01029 zcb 1.01030 zcd 1.01031 zce 1.01032 zcf 1.01033 zclsd 1.01034 zcmop 1.01035 zcmp 1.01036 zcmt 1.01037 zba 1.01038 zbb 1.01039 zbc 1.01040 zbkb 1.01041 zbkc 1.01042 zbkx 1.01043 zbs 1.01044 zk 1.01045 zkn 1.01046 zknd 1.01047 zkne 1.01048 zknh 1.01049 zkr 1.01050 zks 1.01051 zksed 1.01052 zksh 1.01053 zkt 1.01054 ztso 1.01055 zvbb 1.01056 zvbc 1.01057 zve32f 1.01058 zve32x 1.01059 zve64d 1.01060 zve64f 1.01061 zve64x 1.01062 zvfbfmin 1.01063 zvfbfwma 1.01064 zvfh 1.01065 zvfhmin 1.01066 zvkb 1.01067 zvkg 1.01068 zvkn 1.01069 zvknc 1.01070 zvkned 1.01071 zvkng 1.01072 zvknha 1.01073 zvknhb 1.01074 zvks 1.01075 zvksc 1.01076 zvksed 1.01077 zvksg 1.01078 zvksh 1.01079 zvkt 1.01080 zvl1024b 1.01081 zvl128b 1.01082 zvl16384b 1.01083 zvl2048b 1.01084 zvl256b 1.01085 zvl32768b 1.01086 zvl32b 1.01087 zvl4096b 1.01088 zvl512b 1.01089 zvl64b 1.01090 zvl65536b 1.01091 zvl8192b 1.01092 zhinx 1.01093 zhinxmin 1.01094 sdext 1.01095 sdtrig 1.01096 sha 1.01097 shcounterenw 1.01098 shgatpa 1.01099 shlcofideleg 1.01100 shtvala 1.01101 shvsatpa 1.01102 shvstvala 1.01103 shvstvecd 1.01104 smaia 1.01105 smcdeleg 1.01106 smcntrpmf 1.01107 smcsrind 1.01108 smctr 1.01109 smdbltrp 1.01110 smepmp 1.01111 smmpm 1.01112 smnpm 1.01113 smrnmi 1.01114 smstateen 1.01115 ssaia 1.01116 ssccfg 1.01117 ssccptr 1.01118 sscofpmf 1.01119 sscounterenw 1.01120 sscsrind 1.01121 ssctr 1.01122 ssdbltrp 1.01123 ssnpm 1.01124 sspm 1.01125 ssqosid 1.01126 ssstateen 1.01127 ssstrict 1.01128 sstc 1.01129 sstvala 1.01130 sstvecd 1.01131 ssu64xl 1.01132 supm 1.01133 svade 1.01134 svadu 1.01135 svbare 1.01136 svinval 1.01137 svnapot 1.01138 svpbmt 1.01139 svvptc 1.01140 xandesbfhcvt 5.01141 xandesperf 5.01142 xandesvbfhcvt 5.01143 xandesvdot 5.01144 xandesvpackfph 5.01145 xandesvsinth 5.01146 xandesvsintload 5.01147 xcvalu 1.01148 xcvbi 1.01149 xcvbitmanip 1.01150 xcvelw 1.01151 xcvmac 1.01152 xcvmem 1.01153 xcvsimd 1.01154 xmipscbop 1.01155 xmipscmov 1.01156 xmipsexectl 1.01157 xmipslsp 1.01158 xsfcease 1.01159 xsfmm128t 0.61160 xsfmm16t 0.61161 xsfmm32a16f 0.61162 xsfmm32a32f 0.61163 xsfmm32a8f 0.61164 xsfmm32a8i 0.61165 xsfmm32t 0.61166 xsfmm64a64f 0.61167 xsfmm64t 0.61168 xsfmmbase 0.61169 xsfvcp 1.01170 xsfvfbfexp16e 0.51171 xsfvfexp16e 0.51172 xsfvfexp32e 0.51173 xsfvfexpa 0.21174 xsfvfexpa64e 0.21175 xsfvfnrclipxfqf 1.01176 xsfvfwmaccqqq 1.01177 xsfvqmaccdod 1.01178 xsfvqmaccqoq 1.01179 xsifivecdiscarddlone 1.01180 xsifivecflushdlone 1.01181 xsmtvdot 1.01182 xtheadba 1.01183 xtheadbb 1.01184 xtheadbs 1.01185 xtheadcmo 1.01186 xtheadcondmov 1.01187 xtheadfmemidx 1.01188 xtheadmac 1.01189 xtheadmemidx 1.01190 xtheadmempair 1.01191 xtheadsync 1.01192 xtheadvdot 1.01193 xventanacondops 1.01194 xwchc 2.21195 1196Experimental extensions1197 p 0.151198 zibi 0.11199 zicfilp 1.0 This is a long dummy description1200 zicfiss 1.01201 zalasr 0.91202 zvbc32e 0.71203 zvfbfa 0.11204 zvfofp8min 0.21205 zvkgs 0.71206 zvqdotq 0.01207 smpmpmt 0.61208 svukte 0.31209 xqccmp 0.31210 xqcia 0.71211 xqciac 0.31212 xqcibi 0.21213 xqcibm 0.81214 xqcicli 0.31215 xqcicm 0.21216 xqcics 0.21217 xqcicsr 0.41218 xqciint 0.101219 xqciio 0.11220 xqcilb 0.21221 xqcili 0.21222 xqcilia 0.21223 xqcilo 0.31224 xqcilsm 0.61225 xqcisim 0.21226 xqcisls 0.21227 xqcisync 0.31228 xrivosvisni 0.11229 xrivosvizip 0.11230 xsfmclic 0.11231 xsfsclic 0.11232 1233Supported Profiles1234 rva20s641235 rva20u641236 rva22s641237 rva22u641238 rva23s641239 rva23u641240 rvb23s641241 rvb23u641242 rvi20u321243 rvi20u641244 1245Experimental Profiles1246 rvm23u321247 1248Use -march to specify the target's extension.1249For example, clang -march=rv32i_v1p0)";1250 // clang-format on1251 1252 StringMap<StringRef> DummyMap;1253 DummyMap["i"] = "This is a long dummy description";1254 DummyMap["experimental-zicfilp"] = "This is a long dummy description";1255 1256 outs().flush();1257 testing::internal::CaptureStdout();1258 RISCVISAInfo::printSupportedExtensions(DummyMap);1259 outs().flush();1260 1261 std::string CapturedOutput = testing::internal::GetCapturedStdout();1262 EXPECT_TRUE([](std::string &Captured, std::string &Expected) {1263 return Captured.find(Expected) != std::string::npos;1264 }(CapturedOutput, ExpectedOutput));1265}1266 1267TEST(TargetParserTest, RISCVPrintEnabledExtensions) {1268 // clang-format off1269 std::string ExpectedOutput =1270R"(Extensions enabled for the given RISC-V target1271 1272 Name Version Description1273 i 2.1 'I' (Base Integer Instruction Set)1274 1275Experimental extensions1276 zicfilp 1.0 'Zicfilp' (Landing pad)1277 1278ISA String: rv64i2p1_zicfilp1p0_zicsr2p01279)";1280 // clang-format on1281 1282 StringMap<StringRef> DescMap;1283 DescMap["i"] = "'I' (Base Integer Instruction Set)";1284 DescMap["experimental-zicfilp"] = "'Zicfilp' (Landing pad)";1285 std::set<StringRef> EnabledExtensions = {"i", "experimental-zicfilp"};1286 1287 outs().flush();1288 testing::internal::CaptureStdout();1289 RISCVISAInfo::printEnabledExtensions(/*IsRV64=*/true, EnabledExtensions,1290 DescMap);1291 outs().flush();1292 std::string CapturedOutput = testing::internal::GetCapturedStdout();1293 1294 EXPECT_EQ(CapturedOutput, ExpectedOutput);1295}1296