[RISCV] More validations on the input value of -march=

[apazos]

Summary

[RISCV] More validations on the input value of -march=

• RISC-V ISA strings must be lowercase.

E.g.: rv32IMC is not supported, rv32imc is correct.

• Multi-letter extensions are to be separated by a single underscore '_'.

The extension prefix counts as a letter.
This means extensions that start with S, X and SX are all multi-letter.
E.g.:
xasb is a single non-standard extension named 'xasb'
xa_sb are two extensions, the non-standard user level extension 'xa',
and the supervisor level extension 'sb'.

• Extensions might have a version number.

Underscores may be used to separate ISA subset components to improve
readability and to provide disambiguation.
E.g.: rv32i2_m3_a1_f2_d2

• Additional checks for dependent extensions and invalid extensions combinations. E.g.: 'e' requires rv32 'e' can't be combined with 'f' nor 'd' 'q' requires rv64

[apazos]

updated test case

[apazos]

test fix

[apazos]

fixed test merged line

[asb]

test/Driver/riscv-arch.c

151

But rv32e is a valid arch name.

161

Both GCC and the current clang ISA string logic expect lowercase letters. However, the spec does state that the string should be treated as case insensitive. We're probably best following GCC, though perhaps we should discuss this with them

[kito-cheng]

Long time ago, GCC also accept upper case too, but I have no idea why Andrew change that? I guess one possible reason is because multi-lib?

[1] https://github.com/riscv/riscv-gcc/commit/6531a11f03ec3a95cd8b9033daeab0ebf23b5472

[asb]

Based on Andrew's response (thanks Kito for sending the query) it looks like GCC accepting lowercase only is intentional, and we should follow that. In which case, it might be an improvement to reject uppercase letters in the ISA string with a message saying that only lowercase letters are accepted.

[apazos]

Updated code according to the ISA string rules that have been clarified.

[asb]

I've added a few comments on tweaking the error messages based on your tests.

test/Driver/riscv-arch.c

157

But the given string does begin with rv32. 'string must begin with rv32{i,e,g} or rv64{i,g}'?

167

I don't think this message is clear, specifically 'unsupported canonical order...'. How about 'error: standard extension not given in canonical order'

203

I think this would be clearer if you said "name missing after 'sx'"

208

Ditto.

213

Ditto.

[apazos]

Updated error messages and fixed getExtensionVersion

[apazos]

• Simplified hasOtherExtensions() now that we clarified non-standard extensions are separated by '_'. We just need to find the first occurrence of the prefixes.
• updated error message, removed "unsupported" from some messages.

[apazos]

Fixed failure in release mode

[asb]

lib/Driver/ToolChains/Arch/RISCV.cpp

50

You should probably document the limitation that this doesn't currently parse minor versions e.g. i2p0.

157–159

This could be tightened up by also rejected rv64e as invalid.

197–198

I'd suggest either just using StringRef::contains and getting rid of hasExtension, or adding a doc comment to hasExtension to explain its semantics.

It might also be worth adding a comment to explain why you want to check the extension is present in the StdExts string (e.g. We have reached the end of the StdExts string. Either the current extension was given outside of the canonical order (in which case issue an error), or else no canonical ordering is defined meaning no error should be generated'.

200

Won't this now iterate StdExtsItr past StdExtsEnd if StdExtsItr == StdExtsEnd but the hasExtension call is false?

234–239

Add a TODO about other dependencies perhaps? e.g. ef and efd are invalid, and q requires rv64.

[apazos]

lib/Driver/ToolChains/Arch/RISCV.cpp

50

Correct, it is parsing the major version for each standard extension. Will make note of how to parse minor version.

157–159

OK, will add an error message for the invalid combo 'rv64' and 'e', though e is not supported yet for rv32.

197–198

When we reach here, either c contains a valid extension but it was not given in
canonical order or it is an invalid extension. The code that follows was checking for the former, while the check for the latter happens in the switch default statement right below. But we can handle both here and print the appropriate messages, and leave the the check in switch statement just error out if LLVM does not support the extension. Yes, we can also get rid of hasExtension, it is not used any other place anymore.

200

At this point, if StdExtsItr is StdExtsEnd, the code will error out in the switch case default statement. It means you found an invalid extension. Otherwise it will return due to invalid canonical order check above.

I willl move both error conditions to the same place to make the logic clearer.

234–239

will make a note of the additional dependency checks.

[apazos]

Addressed the latest review comments.
Added TODOs for validations we cannot do now.

[asb]

This is looking great, the only remaining code comment I have is that getExtensionFeatures needs a comment describing it.

The remaining issue I have is more of a spec issue - do canonical ordering requirements apply to extension categories? e.g. is sfoo_xbar illegal because it should be ordered xbar_sfoo? From my reading of the note below table 22.1 in the spec I think it is illegal and ordering of non-standard user-level vs standard supervisor-level vs nons-standard supervisor-level should be checked. Do you agree with my interpretation?

[apazos]

Hi Alex, it seems the table expects these extensions in a canonical order too: all x extensions, followed by all s extensions, and then all sx extensions.

I can make the change, no problem. I have also coded other error situations described below.

But f I cannot push a test we can enable, because we error out when we find the first non-supported extension in the string with unsupported extension message, and stop parsing the string.

Any suggestion?

Examples:

clang -target riscv32-unknown-elf -march=rv32ixabc_ -###
extension name missing after separator '_'

clang -target riscv32-unknown-elf -march=rv32ixabc_a -###
invalid extension prefix 'a'

clang -target riscv32-unknown-elf -march=rv32isabc_xdef -###
non-standard user-level extension not given in canonical order 'xdef'

clang -target riscv32-unknown-elf -march=rv32isxabc_sdef -###
standard supervisor-level extension not given in canonical order 'sdef'

clang -target riscv32-unknown-elf -march=rv32ixabc_xabc -###
duplicated non-standard user-level extension 'xabc'

clang -target riscv32-unknown-elf -march=rv32ixabc_xdef -###
no parsing error, should be accepted if xabc and xdef are valid extensions

clang -target riscv32-unknown-elf -march=rv32ixabc_sdef_sxghi -###
no parsing error, should be accepted if xabc sdef sxghi are valid extensions

[asb]

In D45284#1074282, @apazos wrote:

Hi Alex, it seems the table expects these extensions in a canonical order too: all x extensions, followed by all s extensions, and then all sx extensions.

I can make the change, no problem. I have also coded other error situations described below.

But f I cannot push a test we can enable, because we error out when we find the first non-supported extension in the string with unsupported extension message, and stop parsing the string.

In the best case we would first parse the string and give errors based on the string being malformed before determining which extensions the compiler supports and complaining if the extension is not supported. This would probably move us towards a two-pass scheme where structs are are generated from the string, (parsing stage) which are then processed. e.g. { enum ExtType Type; StringRef name; int MajorVersion; int MinorVersion; }. The parser can issue errors encountered when extracting this struct (e.g. malformed version identifiers), including erroring if the ordering of the ExtType relative to the previous ExtType is unexpected. The next step is complaining about semantic issues (clashing extensions or extensions with missing dependencies) as well as extensions that aren't supported.

However I realise that might be a larger refactoring. This is already the most complete RISC-V ISA string parser in existence (as far as I know), which goes some way beyond our near-term requirements. I'd be happy to merge this current version and evolve it in-tree if you prefer, or of course I'll happily review further updates to this patch.

[apazos]

Hi Alex, the refactoring will be simple and can be done later when we need it, all the pieces are already parsed (type, name, major, minor) and are in strings, we will only need to convert to the preferred type (enum, int, etc).
I changed the code to not error out on unsupported extension, allowing all the non-standard extensions to be parsed and the format errors reported. Only when we try to set target features I then enforce unsupported extension.
This way I could push all my tests.

[asb]

Looks good to me - thanks!

include/clang/Basic/DiagnosticDriverKinds.td

def err_drv_unsupported_option_argument : Error<
   "unsupported argument '%1' to option '%0'">;
 def err_drv_unknown_stdin_type : Error<
   "-E or -x required when input is from standard input">;
 def err_drv_unknown_stdin_type_clang_cl : Error<
   "use /Tc or /Tp to set input type for standard input">;
 def err_drv_unknown_language : Error<"language not recognized: '%0'">;
 def err_drv_invalid_arch_name : Error<
   "invalid arch name '%0'">;
+def err_drv_invalid_riscv_arch_name : Error<
+  "invalid arch name '%0', %1">;
+def err_drv_unsupported_riscv_ext_arch_name : Error<
+  "invalid arch name '%0', unsupported %1 '%2'">;
 def err_drv_cuda_bad_gpu_arch : Error<"Unsupported CUDA gpu architecture: %0">;
 def err_drv_no_cuda_installation : Error<
   "cannot find CUDA installation.  Provide its path via --cuda-path, or pass "
   "-nocudainc to build without CUDA includes.">;
 def err_drv_no_cuda_libdevice : Error<
   "cannot find libdevice for %0. Provide path to different CUDA installation "
   "via --cuda-path, or pass -nocudalib to build without linking with libdevice.">;
 def err_drv_cuda_version_unsupported : Error<

lib/Driver/ToolChains/Arch/RISCV.cpp

 #include "llvm/Support/TargetParser.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
+static bool hasExtension(StringRef In, StringRef Ext, size_t &Pos) {
+  Pos = In.find(Ext);
+  return Pos != StringRef::npos;
+}
+
+static StringRef getExtensionPrefix(StringRef Ext) {
+  if (Ext.startswith("sx"))
+    return "sx";
+  if (Ext.startswith("s"))
+    return "s";
+  if (Ext.startswith("x"))
+    return "x";
+  return StringRef();
+}
+
+static bool hasOtherExtensions(StringRef In, size_t &Pos) {
+  size_t PosSX, PosS, PosX;
+  Pos = PosSX = PosS = PosX = StringRef::npos;
+
+  bool Found = hasExtension(In, "sx", PosSX);
+  Found |= hasExtension(In, "s", PosS);
+  Found |= hasExtension(In, "x", PosX);
+
+  if (!Found)
+    return false;
+
+  auto getMinPos = [](size_t &Pos, size_t &minPos) {
+    if (Pos == StringRef::npos)
+      return;
+    if (minPos == StringRef::npos) {
+      minPos = Pos;
+      return;
+    }
+    minPos = std::min(minPos, Pos);
+  };
+
+  getMinPos(PosSX, Pos);
+  getMinPos(PosS, Pos);
+  getMinPos(PosX, Pos);
+
+  assert(Pos != StringRef::npos && "Expected an unsupported extension!");
+
+  return true;
+}
+
+// TODO: Hardware features to be handled in Support/TargetParser.cpp.
+static bool isSupportedExtension(std::vector<StringRef> &Features,
+                                 StringRef Prefix, StringRef Name) {
+  return false;
+}
+
+static void getExtensionFeatures(const Driver &D,
+                                 std::vector<StringRef> &Features,
+                                 StringRef &MArch, StringRef &Exts) {
+  if (Exts.empty())
+    return;
+
+  // Multi-letter extensions are seperated by a single underscore
+  // as described in RISC-V User-Level ISA V2.2.
+  SmallVector<StringRef, 8> Split;
+  Exts.split(Split, StringRef("_"), -1, false);
+
+  for (StringRef Ext : Split) {
+    StringRef Prefix = getExtensionPrefix(Ext);
+    StringRef Name(Ext.substr(Prefix.size()));
+
+    StringRef Type;
+    if (Prefix == "sx")
+      Type = "non-standard supervisor-level extension";
+    else if (Prefix == "s")
+      Type = "standard supervisor-level extension";
+    else if (Prefix == "x")
+      Type = "non-standard user-level extension";
+    else {
+      Type = "invalid extension prefix";
+      D.Diag(diag::err_drv_unsupported_riscv_ext_arch_name)
+        << MArch << Type << Ext;
+      return;
+    }
+
+    size_t Pos;
+    if (hasOtherExtensions(Name, Pos)) {
+      std::string Error = "_";
+      Error += Name.substr(Pos);
+      D.Diag(diag::err_drv_unsupported_riscv_ext_arch_name)
+        << MArch
+        << "multi-letter extensions, separate by a single underscore"
+        << Error;
+      return;
+    }
+
+    if (Name.empty()) {
+      std::string Error = Type;
+      Error += " name missing";
+      D.Diag(diag::err_drv_unsupported_riscv_ext_arch_name)
+        << MArch << Error << Ext;
+      return;
+    }
+
+    if (!isSupportedExtension(Features, Prefix, Name)) {
+      D.Diag(diag::err_drv_unsupported_riscv_ext_arch_name)
+        << MArch << Type << Ext;
+      return;
+    }
+  }
+}
+
 void riscv::getRISCVTargetFeatures(const Driver &D, const ArgList &Args,
                                    std::vector<StringRef> &Features) {
   if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
     StringRef MArch = A->getValue();
     if (!(MArch.startswith("rv32") || MArch.startswith("rv64")) ||
         (MArch.size() < 5)) {
       // ISA string must begin with rv32 or rv64.
-      // TODO: Improve diagnostic message.
-      D.Diag(diag::err_drv_invalid_arch_name) << MArch;
+      D.Diag(diag::err_drv_invalid_riscv_arch_name) << MArch
+        << "string must begin with rv32 or rv64";
       return;
     }
 
     // The canonical order specified in ISA manual.
     // Ref: Table 22.1 in RISC-V User-Level ISA V2.2
-    StringRef StdExts = "mafdc";
+    StringRef StdExts = "mafdqlcbjtpvn";
 
     bool HasF = false, HasD = false;
     char Baseline = MArch[4];
 
     // TODO: Add 'e' once backend supported.
     switch (Baseline) {
     default:
       // First letter should be 'e', 'i' or 'g'.
-      // TODO: Improve diagnostic message.
-      D.Diag(diag::err_drv_invalid_arch_name) << MArch;
+      D.Diag(diag::err_drv_invalid_riscv_arch_name) << MArch
+        << "first letter should be 'e', 'i' or 'g'";
       return;
     case 'i':
       break;
     case 'g':
       // g = imafd
       StdExts = StdExts.drop_front(4);
       Features.push_back("+m");
       Features.push_back("+a");
       Features.push_back("+f");
       Features.push_back("+d");
       HasF = true;
       HasD = true;
       break;
     }
 
     auto StdExtsItr = StdExts.begin();
+
     // Skip rvxxx
     StringRef Exts = MArch.substr(5);
 
+    // Remove non-standard extensions (user-level and supervisor-level) and
+    // supervisor-level extensions to parse them at the end.
+    StringRef OtherExts;
+    size_t Pos;
+    if (hasOtherExtensions(Exts, Pos)) {
+      OtherExts = Exts.substr(Pos);
+      Exts = Exts.substr(0, Pos);
+    }
+
     for (char c : Exts) {
       // Check ISA extensions are specified in the canonical order.
       while (StdExtsItr != StdExts.end() && *StdExtsItr != c)
         ++StdExtsItr;
 
       if (StdExtsItr == StdExts.end()) {
-        // TODO: Improve diagnostic message.
-        D.Diag(diag::err_drv_invalid_arch_name) << MArch;
+        size_t Pos;
+        StringRef Error = "standard user-level extension";
+        if (hasExtension(StdExts, std::string(1, c), Pos))
+          Error = "canonical order of extension";
+        D.Diag(diag::err_drv_unsupported_riscv_ext_arch_name)
+          << MArch << Error << std::string(1, c);
         return;
       }
 
       // Move to next char to prevent repeated letter.
       ++StdExtsItr;
 
       // The order is OK, then push it into features.
       switch (c) {
       default:
-        // TODO: Improve diagnostic message.
-        D.Diag(diag::err_drv_invalid_arch_name) << MArch;
+        // Currently LLVM supports only "mafdc".
+        D.Diag(diag::err_drv_unsupported_riscv_ext_arch_name)
+          << MArch << "standard user-level extension"
+          << std::string(1, c);
         return;
       case 'm':
         Features.push_back("+m");
         break;
       case 'a':
         Features.push_back("+a");
         break;
       case 'f':
for (char c : Exts) {
         break;
       }
     }
 
     // Dependency check
     // It's illegal to specify the 'd' (double-precision floating point)
     // extension without also specifying the 'f' (single precision
     // floating-point) extension.
-    // TODO: Improve diagnostic message.
     if (HasD && !HasF)
-      D.Diag(diag::err_drv_invalid_arch_name) << MArch;
+      D.Diag(diag::err_drv_invalid_riscv_arch_name) << MArch
+        << "d requires f extension to also be specified";
+
+    getExtensionFeatures(D, Features, MArch, OtherExts);
   }
 }
 
 StringRef riscv::getRISCVABI(const ArgList &Args, const llvm::Triple &Triple) {
   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
     return A->getValue();
 
   return Triple.getArch() == llvm::Triple::riscv32 ? "ilp32" : "lp64";
 }

test/Driver/riscv-arch.c

-// RUN: %clang -target riscv32-unknown-elf -march=rv32i -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv32-unknown-elf -march=rv32im -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv32-unknown-elf -march=rv32ima -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv32-unknown-elf -march=rv32imaf -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv32-unknown-elf -march=rv32imafd -### %s -fsyntax-only 2>&1 | FileCheck %s
-
-// RUN: %clang -target riscv32-unknown-elf -march=rv32ic -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv32-unknown-elf -march=rv32imc -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv32-unknown-elf -march=rv32imac -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv32-unknown-elf -march=rv32imafc -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv32-unknown-elf -march=rv32imafdc -### %s -fsyntax-only 2>&1 | FileCheck %s
-
-// RUN: %clang -target riscv32-unknown-elf -march=rv32ia -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv32-unknown-elf -march=rv32iaf -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv32-unknown-elf -march=rv32iafd -### %s -fsyntax-only 2>&1 | FileCheck %s
-
-// RUN: %clang -target riscv32-unknown-elf -march=rv32iac -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv32-unknown-elf -march=rv32iafc -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv32-unknown-elf -march=rv32iafdc -### %s -fsyntax-only 2>&1 | FileCheck %s
-
-// RUN: %clang -target riscv32-unknown-elf -march=rv32g -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv32-unknown-elf -march=rv32gc -### %s -fsyntax-only 2>&1 | FileCheck %s
-
-// RUN: %clang -target riscv64-unknown-elf -march=rv64i -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv64-unknown-elf -march=rv64im -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv64-unknown-elf -march=rv64ima -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv64-unknown-elf -march=rv64imaf -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv64-unknown-elf -march=rv64imafd -### %s -fsyntax-only 2>&1 | FileCheck %s
-
-// RUN: %clang -target riscv64-unknown-elf -march=rv64ic -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv64-unknown-elf -march=rv64imc -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv64-unknown-elf -march=rv64imac -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv64-unknown-elf -march=rv64imafc -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv64-unknown-elf -march=rv64imafdc -### %s -fsyntax-only 2>&1 | FileCheck %s
-
-// RUN: %clang -target riscv64-unknown-elf -march=rv64ia -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv64-unknown-elf -march=rv64iaf -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv64-unknown-elf -march=rv64iafd -### %s -fsyntax-only 2>&1 | FileCheck %s
-
-// RUN: %clang -target riscv64-unknown-elf -march=rv64iac -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv64-unknown-elf -march=rv64iafc -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv64-unknown-elf -march=rv64iafdc -### %s -fsyntax-only 2>&1 | FileCheck %s
-
-// RUN: %clang -target riscv64-unknown-elf -march=rv64g -### %s -fsyntax-only 2>&1 | FileCheck %s
-// RUN: %clang -target riscv64-unknown-elf -march=rv64gc -### %s -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32i -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32im -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32ima -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32imaf -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32imafd -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32ic -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32imc -### %s \
+// RUN: -fsyntax-only RUN: 2>&1 | FileCheck %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32imac -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32imafc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32imafdc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32ia -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32iaf -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32iafd -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32iac -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32iafc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32iafdc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32g -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32gc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+
+// RUN: %clang -target riscv64-unknown-elf -march=rv64i -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64im -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64ima -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64imaf -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64imafd -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+
+// RUN: %clang -target riscv64-unknown-elf -march=rv64ic -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64imc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64imac -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64imafc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64imafdc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+
+// RUN: %clang -target riscv64-unknown-elf -march=rv64ia -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64iaf -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64iafd -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+
+// RUN: %clang -target riscv64-unknown-elf -march=rv64iac -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64iafc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64iafdc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+
+// RUN: %clang -target riscv64-unknown-elf -march=rv64g -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64gc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck %s
 
 // CHECK-NOT: error: invalid arch name '
 
-// RUN: %clang -target riscv32-unknown-elf -march=rv32 -### %s -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32 %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32 -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32 %s
 // RV32: error: invalid arch name 'rv32'
 
-// RUN: %clang -target riscv32-unknown-elf -march=rv32m -### %s -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32M %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32m -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32M %s
 // RV32M: error: invalid arch name 'rv32m'
 
-// RUN: %clang -target riscv32-unknown-elf -march=rv32id -### %s -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32ID %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32id -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32ID %s
 // RV32ID: error: invalid arch name 'rv32id'
 
-// RUN: %clang -target riscv32-unknown-elf -march=rv32l -### %s -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32L %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32l -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32L %s
 // RV32L: error: invalid arch name 'rv32l'
 
-// RUN: %clang -target riscv32-unknown-elf -march=rv32imadf -### %s -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32IMADF %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32imadf -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32IMADF %s
 // RV32IMADF: error: invalid arch name 'rv32imadf'
 
-// RUN: %clang -target riscv32-unknown-elf -march=rv32imm -### %s -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32IMM %s
+// RUN: %clang -target riscv32-unknown-elf -march=rv32imm -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32IMM %s
 // RV32IMM: error: invalid arch name 'rv32imm'
 
-// RUN: %clang -target riscv32-unknown-elf -march=RV32I -### %s -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32I-UPPER %s
+// RUN: %clang -target riscv32-unknown-elf -march=RV32I -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32I-UPPER %s
 // RV32I-UPPER: error: invalid arch name 'RV32I'
 
-// RUN: %clang -target riscv64-unknown-elf -march=rv64 -### %s -fsyntax-only 2>&1 | FileCheck -check-prefix=RV64 %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64 -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV64 %s
 // RV64: error: invalid arch name 'rv64'
 
-// RUN: %clang -target riscv64-unknown-elf -march=rv64m -### %s -fsyntax-only 2>&1 | FileCheck -check-prefix=RV64M %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64m -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV64M %s
 // RV64M: error: invalid arch name 'rv64m'
 
-// RUN: %clang -target riscv64-unknown-elf -march=rv64id -### %s -fsyntax-only 2>&1 | FileCheck -check-prefix=RV64ID %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64id -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV64ID %s
 // RV64ID: error: invalid arch name 'rv64id'
 
-// RUN: %clang -target riscv64-unknown-elf -march=rv64l -### %s -fsyntax-only 2>&1 | FileCheck -check-prefix=RV64L %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64l -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV64L %s
 // RV64L: error: invalid arch name 'rv64l'
 
-// RUN: %clang -target riscv64-unknown-elf -march=rv64imadf -### %s -fsyntax-only 2>&1 | FileCheck -check-prefix=RV64IMADF %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64imadf -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV64IMADF %s
 // RV64IMADF: error: invalid arch name 'rv64imadf'
 
-// RUN: %clang -target riscv64-unknown-elf -march=rv64imm -### %s -fsyntax-only 2>&1 | FileCheck -check-prefix=RV64IMM %s
+// RUN: %clang -target riscv64-unknown-elf -march=rv64imm -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV64IMM %s
 // RV64IMM: error: invalid arch name 'rv64imm'
 
-// RUN: %clang -target riscv64-unknown-elf -march=RV64I -### %s -fsyntax-only 2>&1 | FileCheck -check-prefix=RV64I-UPPER %s
+// RUN: %clang -target riscv64-unknown-elf -march=RV64I -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV64I-UPPER %s
 // RV64I-UPPER: error: invalid arch name 'RV64I'
+
+
+// Testing specific messages and unsupported extensions.
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32 -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32-STR %s
+// RV32-STR: error: invalid arch name 'rv32',
+// RV32-STR: string must begin with rv32 or rv64
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32e -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32-LETTER %s
+// RV32-LETTER: error: invalid arch name 'rv32e',
+// RV32-LETTER: first letter should be 'e', 'i' or 'g'
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32imcq -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32-ORDER %s
+// RV32-ORDER: error: invalid arch name 'rv32imcq',
+// RV32-ORDER: unsupported  canonical order of extension 'q'
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32imC -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32-STD-INVAL %s
+// RV32-STD-INVAL: error: invalid arch name 'rv32imC',
+// RV32-STD-INVAL: unsupported standard user-level extension 'C'
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32imqc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32-STD %s
+// RV32-STD: error: invalid arch name 'rv32imqc',
+// RV32-STD: unsupported standard user-level extension 'q'
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32xabc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32X %s
+// RV32X: error: invalid arch name 'rv32xabc',
+// RV32X: first letter should be 'e', 'i' or 'g'
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32sxabc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32SX %s
+// RV32SX: error: invalid arch name 'rv32sxabc',
+// RV32SX: first letter should be 'e', 'i' or 'g'
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32sabc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32S %s
+// RV32S: error: invalid arch name 'rv32sabc',
+// RV32S: first letter should be 'e', 'i' or 'g'
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32ix -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32X-NAME %s
+// RV32X-NAME: error: invalid arch name 'rv32ix', unsupported
+// RV32X-NAME: non-standard user-level extension name missing 'x'
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32isx -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32SX-NAME %s
+// RV32SX-NAME: error: invalid arch name 'rv32isx',
+// RV32SX-NAME: unsupported non-standard supervisor-level extension
+// RV32SX-NAME: name missing 'sx'
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32is -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32S-NAME %s
+// RV32S-NAME: error: invalid arch name 'rv32is',
+// RV32S-NAME:unsupported standard supervisor-level extension name missing 's'
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32ix_s_sx -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32ALL-NAME %s
+// RV32ALL-NAME: error: invalid arch name 'rv32ix_s_sx',
+// RV32ALL-NAME: unsupported non-standard user-level extension name missing 'x'
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32ixabc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32X-UNS %s
+// RV32X-UNS: error: invalid arch name 'rv32ixabc',
+// RV32X-UNS: unsupported non-standard user-level extension 'xabc'
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32isa -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32S-UNS %s
+// RV32S-UNS: error: invalid arch name 'rv32isa',
+// RV32S-UNS: unsupported standard supervisor-level extension 'sa'
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32isxabc -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32SX-UNS %s
+// RV32SX-UNS: error: invalid arch name 'rv32isxabc',
+// RV32SX-UNS: unsupported non-standard supervisor-level extension 'sxabc'
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32ixabc_sp_sxlw -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32ALL %s
+// RV32ALL: error: invalid arch name 'rv32ixabc_sp_sxlw',
+// RV32ALL: unsupported non-standard user-level extension 'xabc'
+
+// RUN: %clang -target riscv32-unknown-elf -march=rv32ixabcslw -### %s \
+// RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32ALL-SEP %s
+// RV32ALL-SEP: error: invalid arch name 'rv32ixabcslw',
+// RV32ALL-SEP: unsupported multi-letter extensions, separate by
+// RV32ALL-SEP: a single underscore '_slw'