[RISCV] Add --print-supported-extensions support

[4vtomat]

Summary

This revision supports --print-supported-extensions,
it prints out all of the extensions and corresponding version supported.

[craig.topper]

clang/lib/Driver/Driver.cpp

107

Can we declare this in RISCVISAInfo.h and include that here?

llvm/lib/Support/RISCVISAInfo.cpp

200

This function is not in the llvm namespace or a namespace nested under it.

[craig.topper]

llvm/lib/Support/RISCVISAInfo.cpp

210

Question for the community. Should we maintain SupportedExtensions in the order we want printed instead of sorting?

[kito-cheng]

clang/lib/Driver/Driver.cpp

4305–4309

Plz did the similar action like what OPT_print_supported_cpus did instead of just exti 0

And check the triple to make sure only invoke that for riscv

llvm/lib/Support/RISCVISAInfo.cpp

209

I would prefer that print by canonical order *IF* we want to print in some order.

And then you can just use RISCVISAInfo::OrderedExtensionMap here.

[asb]

llvm/lib/Support/RISCVISAInfo.cpp

210

+1 on Kito's suggestion to print by the canonical order.

[4vtomat]

Resolved Craig and Kito's comments.

[craig.topper]

llvm/lib/Support/RISCVISAInfo.cpp

201

void llvm::RISCVMarchHelp and remove the namespace llvm {

[MaskRay]

clang/test/Driver/print-supported-marchs.c

17 ↗

(On Diff #506062)

Use -NEXT: whenever applicable so that new extensions can be caught by the test.

clang/tools/driver/cc1_main.cpp

197

The check should be added to lib/Driver

201

riscvMarchHelp

Use camelCase for new function names.

llvm/lib/Support/RISCVISAInfo.cpp

220

Move '\n' into the "Use -march to specify the target's extension.\n..." string.

[craig.topper]

clang/tools/driver/cc1_main.cpp

197

RISCV -> RISC-V in user facing messages.

[4vtomat]

Resolved MaskRay and Craig's comments.

[craig.topper]

clang/tools/driver/cc1_main.cpp

189

Why do we need to lookup the TargetRegistry?

[craig.topper]

clang/include/clang/Driver/Options.td

5254

Maybe this should be -print-supported-extensions to match RISC-V terminology?

5257

There's no default target behavior. It's always RISC-V.

clang/lib/Driver/Driver.cpp

4308

"-march=help is only supported for RISC-V"

[4vtomat]

Resolved Craig's comments.

[craig.topper]

LGTM

[MaskRay]

Aliasing -march=help to --print-supported-extensions looks weird. I think this patch should remove -march=help.

clang/test/Driver/print-supported-marchs.c

1 ↗

(On Diff #508475)

The filename should be fixed.

[MaskRay]

Created a GCC feature request: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109349

The subject and summary should be fixed and -march=help references should be removed.

clang/lib/Driver/Driver.cpp

4308

The convention is to use Diag(...).

4312

Why is the code needed? Can --print-supported-extensions reuse the approach of OPT_print_supported_cpus?

[kito-cheng]

I would support have -march=help, but I know it's really not make scene to alias -march=help to --print-supported-extensions for other targets, what about redirect that in Driver.cpp for RISC-V only?

[craig.topper]

clang/lib/Driver/Driver.cpp

4312

@MaskRay are you just asking to use the same block of code for both cases?

[MaskRay]

clang/lib/Driver/Driver.cpp

4312

Yes, this should reuse some code with the OPT_print_supported_cpus handler.

[4vtomat]

Resolved MaskRay's comments.
Should we use @kito-cheng's approach to deal with -march=help? what do you think, @MaskRay ?

[MaskRay]

I hope that we add just one option, instead of aliases. Aliases are usually added for compatibility when something is deprecated or changed, not for new options.

My "Request Changes" status still holds. The patch hasn't fixed something obvious: the description mentions print-supported-marchs (well, it should really name the exact name, --print-supported-marchs, don't omit dashes) while the implementation uses ...extensions.

[4vtomat]

Rename clang/test/Driver/print-supported-marchs.c to clang/test/Driver/print-supported-extensions.c

[kito-cheng]

clang/tools/driver/cc1_main.cpp

187–188

Plz make sure only RISC-V print that, x86 or other target print RISC-V's ext is really weird.

[4vtomat]

clang/lib/Driver/Driver.cpp

107

Yes, we can.

clang/tools/driver/cc1_main.cpp

187–188

The check is in clang/lib/Driver/Driver.cpp:4225~

189

I forgot to remove lol~

[kito-cheng]

LGTM, consider about the GNU compatibility, I would that has -march=help form for that.

[craig.topper]

In D146054#4314766, @kito-cheng wrote:

LGTM, consider about the GNU compatibility, I would that has -march=help form for that.

Are you saying gcc supports march=help? Is that recent?

[MaskRay]

-march= -mcpu= -mtune= are from GCC and they traditionally have many opinions on the features.
If GCC is going to have -march=help, I think adding -march=help to Clang to match is fine.
But I'd really like to avoid aliases for non-compatibility reasons. They just cause confusion and make users undecided about which one is canonical.

[4vtomat]

Remove -march=help alias.

[kito-cheng]

GCC ins't implement yet, but planed, so add it later I think?

@4vtomat already drop -march=help, @MaskRay did you mind take a look again?

[MaskRay]

In D146054#4337866, @kito-cheng wrote:

GCC ins't implement yet, but planed, so add it later I think?

@4vtomat already drop -march=help, @MaskRay did you mind take a look again?

Done. But this update still doesn't look quite polished. If -march=help is dropped, at the very least the subject needs to updated.

clang/tools/driver/cc1_main.cpp

187

Use camelCase for new function names. StringRef TargetStr?

llvm/include/llvm/Support/RISCVISAInfo.h

25

This naming does not match the --print-supported-extensions option name.

llvm/lib/Support/RISCVISAInfo.cpp

201

For most --print-* options, the output goes to stdout instead of stderr.

[4vtomat]

Resolved MaskRay's comments.

[MaskRay]

Please also mark resolved comments as done, otherwise reviewers can presume that some comments are unresolved and don't necessarily give another round of reviews.

clang/test/Driver/print-supported-extensions.c

6 ↗

(On Diff #522411)

Use --implicit-check-not=warning: instead of // CHECK-NOT: warning: argument unused during compilation.

We additionally check that there is no warning and the warning doesn't come after the output from --print-supported-extensions.

6 ↗

(On Diff #522411)

For a file with just one prefix, conventionally we just use the default CHECK and omit --check-prefix.

Have you ever checked that the test detects issues? CHECK below are ignored with --check-prefix=CHECK-RISCV.

[MaskRay]

clang/test/Driver/print-supported-extensions.c

1 ↗

(On Diff #522411)

Some newer tests use /// to distinguish non-CHECK-non-RUN comments from others. This helps automation tools to catch wrong prefixes (e.g. with a typo) in comments and helps auto-generating checks in the future while retaining manual comments.

3 ↗

(On Diff #522411)

If you remove all and RISCV from LLVM_TARGETS_TO_BUILD, you can test whether this feature works without lib/Target/RISCV support. I suspect it works, so you may need another build for verification.

10 ↗

(On Diff #522411)

The formatting matters here. To test formatting see --strict-whitespace --match-full-lines (example: See llvm/test/tools/llvm-readobj/ELF/gnu-sections.txt): https://llvm.org/docs/CommandGuide/FileCheck.html

[4vtomat]

Sorry for late update.
Resolved MaskRay's comments, thanks for detailed review!

[4vtomat]

clang/test/Driver/print-supported-extensions.c

6 ↗

(On Diff #522411)

Oh, I missed it, CHECK-NEXT are all ignored...
thanks!!

[4vtomat]

clang/test/Driver/print-supported-extensions.c

3 ↗

(On Diff #522411)

No it cause an error if I use the command with the target without riscv such as:

bin/clang --target=aarch64 --print-supported-extensions
or
bin/clang --target=x86 --print-supported-extensions

[4vtomat]

Hi @MaskRay if you are available, please help me to check the revision, thanks!!

[MaskRay]

Sorry for the delay.

clang/include/clang/Frontend/FrontendOptions.h

286

290

stray change?

clang/test/Driver/print-supported-extensions.c

6 ↗

(On Diff #536947)

10 ↗

(On Diff #536947)

For --strict-whitespace --match-full-lines testing, we usually right align CHECK and CHECK-NEXT.

clang/tools/driver/cc1_main.cpp

187

printSupportedExtensions. Why does this function return a dummy return value?

You can do return printSupportedExtensions(), 0 below to save some lines.

llvm/lib/Support/RISCVISAInfo.cpp

214

I think outs() is more conventional. Most gcc --print-* options go to stdout. clang --print-supported-cpus deviates and we should not copy its issue.

[4vtomat]

Resolved MaskRay's comments, thanks for reviewing!!

[4vtomat]

Rebase

[MaskRay]

clang/lib/Driver/Driver.cpp

4301

no blank line here

clang/test/Driver/print-supported-extensions.c

93 ↗

(On Diff #545412)

//CHECK-EMPTY:

120 ↗

(On Diff #545412)

//CHECK-EMPTY:

clang/tools/driver/cc1_main.cpp

187

The call site should just call riscvExtensionsHelp so that this internal linkage function can be avoided.

190

one blank line

190

one blank line

llvm/lib/Support/RISCVISAInfo.cpp

219

clang-format will remove the space after {

[4vtomat]

Resolved MaskRay's comments.

clang/include/clang/Frontend/FrontendOptions.h

290

Oh, maybe it was added accidentally during rebase lol~

clang/test/Driver/print-supported-extensions.c

10 ↗

(On Diff #536947)

Oh, I got it, thanks!

clang/tools/driver/cc1_main.cpp

187

This is a good idea, return in its caller is much clear for it's intension!

187

Yeah, good idea!

llvm/lib/Support/RISCVISAInfo.cpp

214

Sure, I agree to keep it conventional, since I was following --print-supported-cpus so I made it this way, thank you for pointing out this!

[4vtomat]

Updated test case.

[4vtomat]

Ping

[MaskRay]

I think the best place to test RISCVISAInfo.cpp is llvm/unittests/Support/RISCVISAInfoTest.cpp.

clang/test/Driver/print-supported-extensions.c can test just a few lines (there will be some overlap with the testing in llvm/unittests/Support/RISCVISAInfoTest.cpp), so that changes to RISC-V extensions will generally not require updates to clang/test/Driver/print-supported-extensions.c

clang/test/Driver/print-supported-extensions.c

6 ↗

(On Diff #545500)

Now that D156363 is stable, we can replace FileCheck --implicit-check-not=warning: with %clang -Werror.

llvm/lib/Support/RISCVISAInfo.cpp

219

Not done.

[4vtomat]

In D146054#4586067, @MaskRay wrote:

I think the best place to test RISCVISAInfo.cpp is llvm/unittests/Support/RISCVISAInfoTest.cpp.

clang/test/Driver/print-supported-extensions.c can test just a few lines (there will be some overlap with the testing in llvm/unittests/Support/RISCVISAInfoTest.cpp), so that changes to RISC-V extensions will generally not require updates to clang/test/Driver/print-supported-extensions.c

The goal of this patch is to list the supported extensions and their versions by providing an option, so I guess clang/test/Driver/print-supported-extensions.c aims differently with llvm/unittests/Support/RISCVISAInfoTest.cpp which is testing the functionalities in RISCVISAInfoTest.cpp.
clang/test/Driver/print-supported-extensions.c only tracks the extensions added and the their version changes and riscvExtensionsHelp in llvm/lib/Support/RISCVISAInfo.cpp doesn't have any input or output as well as any side effect, it only reads SupportedExtensions and SupportedExperimentalExtensions and dump the information.
So I think clang/test/Driver/print-supported-extensions.c is enough for this patch?

[4vtomat]

1. Apply clang-format for this patch
2. Replace FileCheck --implicit-check-not=warning: with %clang -Werror

[MaskRay]

In D146054#4587210, @4vtomat wrote:

In D146054#4586067, @MaskRay wrote:

I think the best place to test RISCVISAInfo.cpp is llvm/unittests/Support/RISCVISAInfoTest.cpp.

clang/test/Driver/print-supported-extensions.c can test just a few lines (there will be some overlap with the testing in llvm/unittests/Support/RISCVISAInfoTest.cpp), so that changes to RISC-V extensions will generally not require updates to clang/test/Driver/print-supported-extensions.c

The goal of this patch is to list the supported extensions and their versions by providing an option, so I guess clang/test/Driver/print-supported-extensions.c aims differently with llvm/unittests/Support/RISCVISAInfoTest.cpp which is testing the functionalities in RISCVISAInfoTest.cpp.
clang/test/Driver/print-supported-extensions.c only tracks the extensions added and the their version changes and riscvExtensionsHelp in llvm/lib/Support/RISCVISAInfo.cpp doesn't have any input or output as well as any side effect, it only reads SupportedExtensions and SupportedExperimentalExtensions and dump the information.
So I think clang/test/Driver/print-supported-extensions.c is enough for this patch?

My comment is about: the test is placed at the wrong layer. See https://maskray.me/blog/2021-08-08-toolchain-testing#the-test-checks-at-the-wrong-layer

I don't want that RISC-V development in LLVM causes repeated changes to clang/test/Driver.

[4vtomat]

In D146054#4596571, @MaskRay wrote:

In D146054#4587210, @4vtomat wrote:

In D146054#4586067, @MaskRay wrote:

I think the best place to test RISCVISAInfo.cpp is llvm/unittests/Support/RISCVISAInfoTest.cpp.

clang/test/Driver/print-supported-extensions.c can test just a few lines (there will be some overlap with the testing in llvm/unittests/Support/RISCVISAInfoTest.cpp), so that changes to RISC-V extensions will generally not require updates to clang/test/Driver/print-supported-extensions.c

The goal of this patch is to list the supported extensions and their versions by providing an option, so I guess clang/test/Driver/print-supported-extensions.c aims differently with llvm/unittests/Support/RISCVISAInfoTest.cpp which is testing the functionalities in RISCVISAInfoTest.cpp.
clang/test/Driver/print-supported-extensions.c only tracks the extensions added and the their version changes and riscvExtensionsHelp in llvm/lib/Support/RISCVISAInfo.cpp doesn't have any input or output as well as any side effect, it only reads SupportedExtensions and SupportedExperimentalExtensions and dump the information.
So I think clang/test/Driver/print-supported-extensions.c is enough for this patch?

My comment is about: the test is placed at the wrong layer. See https://maskray.me/blog/2021-08-08-toolchain-testing#the-test-checks-at-the-wrong-layer

I don't want that RISC-V development in LLVM causes repeated changes to clang/test/Driver.

Got it, thanks!

[4vtomat]

Resolved MaskRay's comments.

[MaskRay]

clang/include/clang/Driver/Options.td

5255

CC1Option/CoreOption has been removed. Please rebase. Visibility<[ClangOption, CC1Option, CLOption]>,

Remove Group<CompileOnly_Group>. We don't need a workaround to claim the option in the case of clang -xxx a.o

clang/include/clang/Driver/Options.td

def darwin_target_variant : Separate<["-"], "darwin-target-variant">,
   Flags<[NoXarchOption]>, Visibility<[ClangOption, CLOption]>,
   HelpText<"Generate code for an additional runtime variant of the deployment target">;
 def print_supported_cpus : Flag<["-", "--"], "print-supported-cpus">,
   Group<CompileOnly_Group>,
   Visibility<[ClangOption, CC1Option, CLOption]>,
   HelpText<"Print supported cpu models for the given target (if target is not specified,"
            " it will print the supported cpus for the default target)">,
   MarshallingInfoFlag<FrontendOpts<"PrintSupportedCPUs">>;
+def print_supported_extensions : Flag<["-", "--"], "print-supported-extensions">,
+  Visibility<[ClangOption, CC1Option, CLOption]>,
+  HelpText<"Print supported extensions for RISC-V">,
+  MarshallingInfoFlag<FrontendOpts<"PrintSupportedExtensions">>;
 def : Flag<["-"], "mcpu=help">, Alias<print_supported_cpus>;
 def : Flag<["-"], "mtune=help">, Alias<print_supported_cpus>;
 def time : Flag<["-"], "time">,
   HelpText<"Time individual commands">;
 def traditional_cpp : Flag<["-", "--"], "traditional-cpp">,
   Visibility<[ClangOption, CC1Option]>,
   HelpText<"Enable some traditional CPP emulation">,
   MarshallingInfoFlag<LangOpts<"TraditionalCPP">>;

clang/include/clang/Frontend/FrontendOptions.h

public:
   /// Show frontend performance metrics and statistics.
   unsigned ShowStats : 1;
 
   unsigned AppendStats : 1;
 
   /// print the supported cpus for the current target
   unsigned PrintSupportedCPUs : 1;
 
+  /// Print the supported extensions for the current target.
+  unsigned PrintSupportedExtensions : 1;
+
   /// Show the -version text.
   unsigned ShowVersion : 1;
 
   /// Apply fixes even if there are unfixable errors.
   unsigned FixWhatYouCan : 1;
 
   /// Apply fixes only for warnings.
   unsigned FixOnlyWarnings : 1;
 
   /// Apply fixes and recompile.

clang/lib/Driver/Driver.cpp

 #if LLVM_ON_UNIX
 #include <unistd.h> // getpid
 #endif
 
 using namespace clang::driver;
 using namespace clang;
 using namespace llvm::opt;
 
 static std::optional<llvm::Triple> getOffloadTargetTriple(const Driver &D,
                                                           const ArgList &Args) {
   auto OffloadTargets = Args.getAllArgValues(options::OPT_offload_EQ);
   // Offload compilation flow does not support multiple targets for now. We
   // need the HIPActionBuilder (and possibly the CudaActionBuilder{,Base}too)
   // to support multiple tool chains first.
   switch (OffloadTargets.size()) {
   default:
     D.Diag(diag::err_drv_only_one_offload_target_supported);
bool Driver::HandleImmediateArgs(const Compilation &C) {
   if (C.getArgs().hasArg(options::OPT__version)) {
     // Follow gcc behavior and use stdout for --version and stderr for -v.
     PrintVersion(C, llvm::outs());
     return false;
   }
 
   if (C.getArgs().hasArg(options::OPT_v) ||
       C.getArgs().hasArg(options::OPT__HASH_HASH_HASH) ||
-      C.getArgs().hasArg(options::OPT_print_supported_cpus)) {
+      C.getArgs().hasArg(options::OPT_print_supported_cpus) ||
+      C.getArgs().hasArg(options::OPT_print_supported_extensions)) {
     PrintVersion(C, llvm::errs());
     SuppressMissingInputWarning = true;
   }
 
   if (C.getArgs().hasArg(options::OPT_v)) {
     if (!SystemConfigDir.empty())
       llvm::errs() << "System configuration file directory: "
                    << SystemConfigDir << "\n";
if (Args.hasArg(options::OPT_emit_interface_stubs)) {
     }
 
     // Add an interface stubs merge action if necessary.
     if (!MergerInputs.empty())
       Actions.push_back(
           C.MakeAction<IfsMergeJobAction>(MergerInputs, types::TY_Image));
   }
 
-  // If --print-supported-cpus, -mcpu=? or -mtune=? is specified, build a custom
-  // Compile phase that prints out supported cpu models and quits.
-  if (Arg *A = Args.getLastArg(options::OPT_print_supported_cpus)) {
+  for (auto Opt : {options::OPT_print_supported_cpus,
+                   options::OPT_print_supported_extensions}) {
+    // If --print-supported-cpus, -mcpu=? or -mtune=? is specified, build a
+    // custom Compile phase that prints out supported cpu models and quits.
+    //
+    // If --print-supported-extensions is specified, call the helper function
+    // RISCVMarchHelp in RISCVISAInfo.cpp that prints out supported extensions
+    // and quits.
+    if (Arg *A = Args.getLastArg(Opt)) {
+      if (Opt == options::OPT_print_supported_extensions &&
+          !C.getDefaultToolChain().getTriple().isRISCV()) {
+        C.getDriver().Diag(diag::err_opt_not_valid_on_target)
+            << "--print-supported-extensions";
+        return;
+      }
+
       // Use the -mcpu=? flag as the dummy input to cc1.
       Actions.clear();
       Action *InputAc = C.MakeAction<InputAction>(*A, types::TY_C);
       Actions.push_back(
           C.MakeAction<PrecompileJobAction>(InputAc, types::TY_Nothing));
       for (auto &I : Inputs)
         I.second->claim();
     }
+  }
 
   // Call validator for dxil when -Vd not in Args.
   if (C.getDefaultToolChain().getTriple().isDXIL()) {
     // Only add action when needValidation.
     const auto &TC =
         static_cast<const toolchains::HLSLToolChain &>(C.getDefaultToolChain());
     if (TC.requiresValidation(Args)) {
       Action *LastAction = Actions.back();
       Actions.push_back(C.MakeAction<BinaryAnalyzeJobAction>(
           LastAction, types::TY_DX_CONTAINER));
     }
   }
 
   // Claim ignored clang-cl options.
   Args.ClaimAllArgs(options::OPT_cl_ignored_Group);
 }
 
 /// Returns the canonical name for the offloading architecture when using a HIP
 /// or CUDA architecture.

clang/tools/driver/cc1_main.cpp

 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/BuryPointer.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
+#include "llvm/Support/RISCVISAInfo.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include <cstdio>
 
static int PrintSupportedCPUs(std::string TargetStr) {
   llvm::TargetOptions Options;
   std::unique_ptr<llvm::TargetMachine> TheTargetMachine(
       TheTarget->createTargetMachine(TargetStr, "", "+cpuhelp", Options,
                                      std::nullopt));
   return 0;
 }
 
 int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
   ensureSufficientStack();
 
   std::unique_ptr<CompilerInstance> Clang(new CompilerInstance());
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
 
   // Register the support for object-file-wrapped Clang modules.
   auto PCHOps = Clang->getPCHContainerOperations();
   PCHOps->registerWriter(std::make_unique<ObjectFilePCHContainerWriter>());
   PCHOps->registerReader(std::make_unique<ObjectFilePCHContainerReader>());
 
   // Initialize targets first, so that --version shows registered targets.
   llvm::InitializeAllTargets();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmPrinters();
   llvm::InitializeAllAsmParsers();
 
   // Buffer diagnostics from argument parsing so that we can output them using a
   // well formed diagnostic object.
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer;
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer);
 
   // Setup round-trip remarks for the DiagnosticsEngine used in CreateFromArgs.
   if (find(Argv, StringRef("-Rround-trip-cc1-args")) != Argv.end())
     Diags.setSeverity(diag::remark_cc1_round_trip_generated,
                       diag::Severity::Remark, {});
 
   bool Success = CompilerInvocation::CreateFromArgs(Clang->getInvocation(),
                                                     Argv, Diags, Argv0);
 
   if (!Clang->getFrontendOpts().TimeTracePath.empty()) {
     llvm::timeTraceProfilerInitialize(
         Clang->getFrontendOpts().TimeTraceGranularity, Argv0);
   }
   // --print-supported-cpus takes priority over the actual compilation.
   if (Clang->getFrontendOpts().PrintSupportedCPUs)
     return PrintSupportedCPUs(Clang->getTargetOpts().Triple);
 
+  // --print-supported-extensions takes priority over the actual compilation.
+  if (Clang->getFrontendOpts().PrintSupportedExtensions)
+    return llvm::riscvExtensionsHelp(), 0;
+
   // Infer the builtin include path if unspecified.
   if (Clang->getHeaderSearchOpts().UseBuiltinIncludes &&
       Clang->getHeaderSearchOpts().ResourceDir.empty())
     Clang->getHeaderSearchOpts().ResourceDir =
       CompilerInvocation::GetResourcesPath(Argv0, MainAddr);
 
   // Create the actual diagnostics engine.
   Clang->createDiagnostics();

llvm/include/llvm/Support/RISCVISAInfo.h

 #include <vector>
 
 namespace llvm {
 struct RISCVExtensionInfo {
   unsigned MajorVersion;
   unsigned MinorVersion;
 };
 
+void riscvExtensionsHelp();
+
 class RISCVISAInfo {
 public:
   RISCVISAInfo(const RISCVISAInfo &) = delete;
   RISCVISAInfo &operator=(const RISCVISAInfo &) = delete;
 
   static bool compareExtension(const std::string &LHS, const std::string &RHS);
 
   /// Helper class for OrderedExtensionMap.

llvm/lib/Support/RISCVISAInfo.cpp

static const RISCVSupportedExtension SupportedExperimentalExtensions[] = {
     {"zvks", RISCVExtensionVersion{1, 0}},
     {"zvksc", RISCVExtensionVersion{1, 0}},
     {"zvksed", RISCVExtensionVersion{1, 0}},
     {"zvksg", RISCVExtensionVersion{1, 0}},
     {"zvksh", RISCVExtensionVersion{1, 0}},
     {"zvkt", RISCVExtensionVersion{1, 0}},
 };
 
 static void verifyTables() {
 #ifndef NDEBUG
   static std::atomic<bool> TableChecked(false);
   if (!TableChecked.load(std::memory_order_relaxed)) {
     assert(llvm::is_sorted(SupportedExtensions) &&
            "Extensions are not sorted by name");
     assert(llvm::is_sorted(SupportedExperimentalExtensions) &&
            "Experimental extensions are not sorted by name");
     TableChecked.store(true, std::memory_order_relaxed);
   }
 #endif
 }
 
+void llvm::riscvExtensionsHelp() {
+  outs() << "All available -march extensions for RISC-V\n\n";
+  outs() << '\t' << left_justify("Name", 20) << "Version\n";
+
+  RISCVISAInfo::OrderedExtensionMap ExtMap;
+  for (const auto &E : SupportedExtensions)
+    ExtMap[E.Name] = {E.Version.Major, E.Version.Minor};
+  for (const auto &E : ExtMap)
+    outs() << format("\t%-20s%d.%d\n", E.first.c_str(), E.second.MajorVersion,
+                     E.second.MinorVersion);
+
+  outs() << "\nExperimental extensions\n";
+  ExtMap.clear();
+  for (const auto &E : SupportedExperimentalExtensions)
+    ExtMap[E.Name] = {E.Version.Major, E.Version.Minor};
+  for (const auto &E : ExtMap)
+    outs() << format("\t%-20s%d.%d\n", E.first.c_str(), E.second.MajorVersion,
+                     E.second.MinorVersion);
+
+  outs() << "\nUse -march to specify the target's extension.\n"
+            "For example, clang -march=rv32i_v1p0\n";
+}
+
 static bool stripExperimentalPrefix(StringRef &Ext) {
   return Ext.consume_front("experimental-");
 }
 
 // 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.

llvm/unittests/Support/RISCVISAInfoTest.cpp

TEST(getTargetFeatureForExtension, RetrieveTargetFeatureFromOneExt) {
   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"), "");
 }
+
+TEST(RiscvExtensionsHelp, CheckExtensions) {
+  std::string ExpectedOutput =
+R"(All available -march extensions for RISC-V
+
+  Name                Version
+  i                   2.1
+  e                   2.0
+  m                   2.0
+  a                   2.1
+  f                   2.2
+  d                   2.2
+  c                   2.0
+  v                   1.0
+  h                   1.0
+  zicbom              1.0
+  zicbop              1.0
+  zicboz              1.0
+  zicntr              1.0
+  zicsr               2.0
+  zifencei            2.0
+  zihintntl           1.0
+  zihintpause         2.0
+  zihpm               1.0
+  zmmul               1.0
+  zawrs               1.0
+  zfh                 1.0
+  zfhmin              1.0
+  zfinx               1.0
+  zdinx               1.0
+  zca                 1.0
+  zcb                 1.0
+  zcd                 1.0
+  zce                 1.0
+  zcf                 1.0
+  zcmp                1.0
+  zcmt                1.0
+  zba                 1.0
+  zbb                 1.0
+  zbc                 1.0
+  zbkb                1.0
+  zbkc                1.0
+  zbkx                1.0
+  zbs                 1.0
+  zk                  1.0
+  zkn                 1.0
+  zknd                1.0
+  zkne                1.0
+  zknh                1.0
+  zkr                 1.0
+  zks                 1.0
+  zksed               1.0
+  zksh                1.0
+  zkt                 1.0
+  zve32f              1.0
+  zve32x              1.0
+  zve64d              1.0
+  zve64f              1.0
+  zve64x              1.0
+  zvfh                1.0
+  zvfhmin             1.0
+  zvl1024b            1.0
+  zvl128b             1.0
+  zvl16384b           1.0
+  zvl2048b            1.0
+  zvl256b             1.0
+  zvl32768b           1.0
+  zvl32b              1.0
+  zvl4096b            1.0
+  zvl512b             1.0
+  zvl64b              1.0
+  zvl65536b           1.0
+  zvl8192b            1.0
+  zhinx               1.0
+  zhinxmin            1.0
+  svinval             1.0
+  svnapot             1.0
+  svpbmt              1.0
+  xcvalu              1.0
+  xcvbi               1.0
+  xcvbitmanip         1.0
+  xcvmac              1.0
+  xcvsimd             1.0
+  xsfcie              1.0
+  xsfvcp              1.0
+  xtheadba            1.0
+  xtheadbb            1.0
+  xtheadbs            1.0
+  xtheadcmo           1.0
+  xtheadcondmov       1.0
+  xtheadfmemidx       1.0
+  xtheadmac           1.0
+  xtheadmemidx        1.0
+  xtheadmempair       1.0
+  xtheadsync          1.0
+  xtheadvdot          1.0
+  xventanacondops     1.0
+
+Experimental extensions
+  zicfilp             0.2
+  zicond              1.0
+  zacas               1.0
+  zfa                 0.2
+  zfbfmin             0.8
+  ztso                0.1
+  zvbb                1.0
+  zvbc                1.0
+  zvfbfmin            0.8
+  zvfbfwma            0.8
+  zvkb                1.0
+  zvkg                1.0
+  zvkn                1.0
+  zvknc               1.0
+  zvkned              1.0
+  zvkng               1.0
+  zvknha              1.0
+  zvknhb              1.0
+  zvks                1.0
+  zvksc               1.0
+  zvksed              1.0
+  zvksg               1.0
+  zvksh               1.0
+  zvkt                1.0
+  smaia               1.0
+  ssaia               1.0
+
+Use -march to specify the target's extension.
+For example, clang -march=rv32i_v1p0)";
+
+  outs().flush();
+  testing::internal::CaptureStdout();
+
+  llvm::riscvExtensionsHelp();
+  outs().flush();
+
+  std::string CapturedOutput = testing::internal::GetCapturedStdout();
+  EXPECT_TRUE([](std::string &Captured, std::string &Expected) {
+                return Captured.find(Expected) != std::string::npos;
+              }(CapturedOutput, ExpectedOutput));
+}