[Driver][RISCV] Support parsing multi-lib config from GCC.

[kito-cheng]

Summary

RISC-V is highly configurable architecture, so it's hard to list all
possible multi-lib here, in order to deal with that issue , GCC has support
a flexible way to configure the multi-lib[1] for bare-matel toolchain.

So I think it would be great to just leverage that from GCC, the
simplest way is asking the multi-lib configuration from GCC.

[1] https://gcc.gnu.org/git/?p=gcc.git;a=commit;h=c1e6691245ca2f1f329549f323f67afe32bcb97a

[kito-cheng]

Minor clean up

[MaskRay]

clang/lib/Driver/ToolChains/Arch/RISCV.cpp

741

//

clang/lib/Driver/ToolChains/Gnu.cpp

1597

https://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return

1627

camelCase. Just ignore older functions which use CamelCase.

clang/test/Driver/riscv64-toolchain.c

158 ↗

(On Diff #328040)

Hmm. I happened to have posted https://lists.llvm.org/pipermail/cfe-dev/2021-March/067820.html about how folks use --gcc-toolchain.

Is this an useful option on non-riscv host?

[kito-cheng]

clang/test/Driver/riscv64-toolchain.c

158 ↗

(On Diff #328040)

--gcc-toolchain should be useful for non-pure LLVM toolchain especially for bare-metal cross toolchain, IIRC GCC_INSTALL_PREFIX is not support relative path well like DEFAULT_SYSROOT[1], so I think this option is necessary even we have GCC_INSTALL_PREFIX cmake option.

[1] https://reviews.llvm.org/D76653

[kito-cheng]

Address MaskRay's comment and apply clang-format.

[kito-cheng]

clang/lib/Driver/ToolChains/Arch/RISCV.cpp

741

Thanks, I guess some time my brain still in GCC development mode :P

[Jim]

clang/lib/Driver/ToolChains/Gnu.cpp

1705

Do you have plan to support other kind of options to build multilib?

[Jim]

clang/lib/Driver/ToolChains/Gnu.cpp

1746

scanGCCMultilibConfig ?

[khchen]

I didn't check why I got error in
Failed Tests (1):

Clang :: Driver/riscv64-toolchain.c

Could you please double check it?
Thanks!

clang/lib/Driver/ToolChains/Gnu.cpp

1601

move into else

1606

if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain))

1627

bool -> static bool?
const std::string &MultilibOutput -> StringRef ?

The function name seem like it's not a target-specific function, but it's only support RISC-V now. Maybe we could rename it or make an assertion in function to check the target should be RISC-V?

1644

Could they be declared as StringRef and use llvm::StringSwitch<StringRef>?

1652

if (!File)
  return;

1738

rc->RC

1746

ScanGCCMultilibConfig->scanGCCMultilibConfig

[kito-cheng]

Here is another solution for flexible multi-lib configuration I consider before:

• Add an option called -fmultilib-config=
• Using same or similar syntax with GCC's --with-multilib-generator

But the problem is it's really toooooo long for describe a multi-lib config.

e.g: current default bare-metal multi-lib configuration:
--with-multilib-generator="rv32i-ilp32--c;rv32im-ilp32--c;rv32iac-ilp32--;rv32imac-ilp32--;rv32imafc-ilp32f-rv32imafdc-;rv64imc-lp64--;rv64imfc-lp64f--;rv64imac-lp64--;rv64imafdc-lp64d--"

clang/lib/Driver/ToolChains/Gnu.cpp

1627

Maybe we could rename it or make an assertion in function to check the target should be RISC-V?

Good point, renamed.

1644

I would prefer keep const char * to prevent create a temporal object for StringRef here.

And I also found another place are used same way:

$ grep "StringSwitch<const" * -R
clang/lib/Basic/SourceManager.cpp:      llvm::StringSwitch<const char *>(BufStr)
clang/lib/Driver/ToolChains/Gnu.cpp:  std::string CurrentMCmodelOpt = llvm::StringSwitch<const char *>(CodeModel)
clang/lib/Driver/ToolChains/Clang.cpp:        MipsTargetFeature = llvm::StringSwitch<const char *>(Value)
clang/lib/Driver/ToolChains/Cuda.cpp:      OOpt = llvm::StringSwitch<const char *>(A->getValue())
clang/lib/Driver/ToolChains/AMDGPUOpenMP.cpp:      OOpt = llvm::StringSwitch<const char *>(A->getValue())
clang/lib/Driver/ToolChains/Arch/Mips.cpp:    ABIName = llvm::StringSwitch<const char *>(CPUName)
clang/lib/Driver/ToolChains/Arch/Mips.cpp:    CPUName = llvm::StringSwitch<const char *>(ABIName)
clang/lib/Driver/ToolChains/Arch/PPC.cpp:    return llvm::StringSwitch<const char *>(CPUName)
clang/lib/Driver/ToolChains/Arch/PPC.cpp:  return llvm::StringSwitch<const char *>(Name)
clang/lib/Driver/ToolChains/Arch/Sparc.cpp:    return llvm::StringSwitch<const char *>(Name)
clang/lib/Driver/ToolChains/Arch/Sparc.cpp:    return llvm::StringSwitch<const char *>(Name)
clang/lib/Driver/ToolChains/Darwin.cpp:  return llvm::StringSwitch<const char *>(Arch)
clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp:        StringSwitch<const char *>(T.first->getValueAsString("AccessQualifier"))
clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp:      OS << StringSwitch<const char *>(
llvm/include/llvm/Support/FormatProviders.h:    Stream << StringSwitch<const char *>(Style)
llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp:          StringSwitch<const char *>(BroadcastString)
llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp:    const char *Repl = StringSwitch<const char *>(Name)
llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp:  const char *Repl = StringSwitch<const char *>(Op.getToken())
llvm/lib/Support/Host.cpp:  return StringSwitch<const char *>(StringRef(CPUStart, CPULen))
llvm/lib/Support/Host.cpp:    return StringSwitch<const char *>(Part)
llvm/lib/Support/Host.cpp:    return StringSwitch<const char *>(Part)
llvm/lib/Support/Host.cpp:    return StringSwitch<const char *>(Part)
llvm/lib/Support/Host.cpp:    return StringSwitch<const char *>(Part)
llvm/lib/Support/Host.cpp:    return StringSwitch<const char *>(Part)
llvm/lib/Support/Host.cpp:    return StringSwitch<const char *>(Part)
llvm/unittests/Support/Host.cpp:  StringRef MCPU = StringSwitch<const char *>(CPU)

1652

Good suggestion, thanks!

1705

Currently, no, but I think could be consider in future.

[kito-cheng]

• Fix build issue.
• Address Jim Lin's and Zakk's comment

[kito-cheng]

Reupload

[khchen]

Overall LGTM.

clang/lib/Driver/ToolChains/Gnu.cpp

1606

Sorry, I forget this rule: https://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return

1652

https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

[jrtc27]

clang/test/Driver/Inputs/multilib_riscv32_elf_sdk/bin/riscv32-unknown-elf-gcc

2

Python 3

4–6

[luismarques]

This patch seems to be in pretty good shape now.

One thing that might be useful (important?) to add is additional diagnostics when run in verbose mode. Currently clang -v will indicate that it found the GCC installation and will list the multilibs but there will be no indication that the multilib list came from GCC. Also, if things like the ExecuteAndWait (in getRISCVMultilibFromGCC) fail shouldn't we print some kind of diagnostic, at least in verbose mode? Otherwise when problems occur it might be tricky to figure out what's going on.

clang/lib/Driver/ToolChains/Arch/RISCV.cpp

740

Nitpicking suggestion: \\ Default code model is 'small' (what GCC calls 'medlow').

clang/lib/Driver/ToolChains/Gnu.cpp

1659

Maybe trim whitespace before checking for empty lines, for extra robustness?

[kito-cheng]

Address jrtc27's and luismarques comment

ChangeLogs

• Move all new test to clang/test/Driver/riscv-toolchain-gcc-multilib.c
  • I don't found good way to test that on windows, since ExecuteAndWait only allow to execute .exe file on windows , upload a prebuilt *.exe file and execute that sounds like not reasonable.
• Add error message output when execute GCC with non-zero return code, it come with a new test.

[luismarques]

This still doesn't report that the multilib configuration came from GCC when it succeeds, does it? I suppose that's not a deal-breaker, but it would be nice to have. Would it be difficult to implement?

Regarding the Windows test issue, aren't there other test cases in similar situations that managed to sort that out?

clang/lib/Driver/ToolChains/Gnu.cpp

1659

I was actually thinking something along the lines of Line = Line.trim();, so that the rest of the parsing code would also benefit from having any extraneous whitespace removed and thus be more robust. Or does this mutate the argument?

1742

configureation -> configuration. Also, the user won't know what the "non-zero return code" refers to. How about something like "Failed to execute <path> in an attempt to obtain the multilib configuration from GCC"?

[kito-cheng]

This still doesn't report that the multilib configuration came from GCC when it succeeds, does it? I suppose that's not a deal-breaker, but it would be nice to have. Would it be difficult to implement?

There is some order issue is those function are executed before printing clang version info like clang version 13.0.0 ([e-mail]:llvm/llvm-project.git 95cd87efe65d5c485670dd1281bf44dd0bff753d)..., some script might parse that, so I don't like to disrupt that, but I guess I could try to append verbose messages into MultilibErrorMessages and rename that to MultilibVerboseMessages.

[kito-cheng]

ChangeLog:

• Add more verbose message during reading GCC multilib configuration.
• Add test case to verify verbose messages.

[MaskRay]

In D97916#2625170, @luismarques wrote:

This patch seems to be in pretty good shape now.

One thing that might be useful (important?) to add is additional diagnostics when run in verbose mode. Currently clang -v will indicate that it found the GCC installation and will list the multilibs but there will be no indication that the multilib list came from GCC. Also, if things like the ExecuteAndWait (in getRISCVMultilibFromGCC) fail shouldn't we print some kind of diagnostic, at least in verbose mode? Otherwise when problems occur it might be tricky to figure out what's going on.

Running an external program ($triple-gcc) to get library/include paths? This is a very unusual behavior to me and can have security issues (previously -### does not run programs). I'd suggest you raise a topic on cfe-dev getting consensus before this can be committed.

In the test, clang will invoke python3 Inputs/multilib_riscv64_elf_sdk/bin/riscv64-unknown-elf-gcc --print-multi-lib and parse its output - this is unusual, too. I am concerned whether we can do this.

So I think it would be great to just leverage that from GCC, the simplest way is asking the multi-lib configuration from GCC.

The description should include an overview about what the patch does, not simply deferring to another place about what it will do. By following the link - the description does not clearly state what the particular GCC commit does as well.

Only by following the logic under a debugger it becomes clear to me that the patch adds code to spawn an external process of gcc, parse its output, and uses that as include/library/march/etc.

As an alternative, have you considered https://clang.llvm.org/docs/UsersManual.html#configuration-files

About testing, multilib_riscv64_elf_sdk_bad{,2,3} suggest that lit tests are probably inadequate. You may need unit tests, see unittests/Driver/MultilibTest.cpp.

clang/include/clang/Basic/DiagnosticDriverKinds.td

395

Delete trailing period.

clang/lib/Driver/ToolChains/Arch/RISCV.cpp

742

getLastArgValue

clang/lib/Driver/ToolChains/Gnu.cpp

1602

--gcc-toolchain if specified

-gcc-toolchain is not a valid option.

1608

This should reuse the Generic_GCC::GCCInstallationDetector::init logic.

1661

This means an inlin element number of 128. This is excessive - consumes lots of stack space. The value should typically be <= 4.

clang/test/Driver/riscv-toolchain-gcc-multilib.c

7

This can pack more options on one line.

Having more lines makes the file longer and actually harms readability.

[MaskRay]

clang/lib/Driver/ToolChains/Gnu.cpp

1754

Even if ExecuteAndWait is accepted, you may consider a pipe. The current implementation leaves temporary files under /tmp.

clang/include/clang/Basic/DiagnosticDriverKinds.td

 def err_drv_modules_validate_once_requires_timestamp : Error<
   "option '-fmodules-validate-once-per-build-session' requires "
   "'-fbuild-session-timestamp=<seconds since Epoch>' or '-fbuild-session-file=<file>'">;
 
 def err_test_module_file_extension_format : Error<
   "-ftest-module-file-extension argument '%0' is not of the required form "
   "'blockname:major:minor:hashed:user info'">;
 
+def warn_drv_multilib_fallback : Warning<
+  "%0 option unrecognized in multi-lib configuration when parsing config "
+  "from GCC, falling back to built-in multi-lib configuration.">,
+  InGroup<MultilibFallback>;
+
 def warn_slash_u_filename : Warning<"'/U%0' treated as the '/U' option">,
   InGroup<DiagGroup<"slash-u-filename">>;
 def note_use_dashdash : Note<"Use '--' to treat subsequent arguments as filenames">;
 
 def err_drv_ropi_rwpi_incompatible_with_pic : Error<
   "embedded and GOT-based position independence are incompatible">;
 def err_drv_ropi_incompatible_with_cxx : Error<
   "ROPI is not compatible with c++">;

clang/include/clang/Basic/DiagnosticGroups.td

 def VLAExtension : DiagGroup<"vla-extension">;
 def VLA : DiagGroup<"vla", [VLAExtension]>;
 def VolatileRegisterVar : DiagGroup<"volatile-register-var">;
 def Visibility : DiagGroup<"visibility">;
 def ZeroLengthArray : DiagGroup<"zero-length-array">;
 def GNUZeroLineDirective : DiagGroup<"gnu-zero-line-directive">;
 def GNUZeroVariadicMacroArguments : DiagGroup<"gnu-zero-variadic-macro-arguments">;
 def MisleadingIndentation : DiagGroup<"misleading-indentation">;
+def MultilibFallback : DiagGroup<"multilib-fallback">;
 
 // This covers both the deprecated case (in C++98)
 // and the extension case (in C++11 onwards).
 def WritableStrings : DiagGroup<"writable-strings", [DeprecatedWritableStr]>;
 
 // GCC calls -Wdeprecated-writable-strings -Wwrite-strings.
 //
 // Bizarrely, this warning flag enables -fconst-strings in C. This is

clang/lib/Driver/ToolChains/Arch/RISCV.h

 namespace riscv {
 void getRISCVTargetFeatures(const Driver &D, const llvm::Triple &Triple,
                             const llvm::opt::ArgList &Args,
                             std::vector<llvm::StringRef> &Features);
 StringRef getRISCVABI(const llvm::opt::ArgList &Args,
                       const llvm::Triple &Triple);
 StringRef getRISCVArch(const llvm::opt::ArgList &Args,
                        const llvm::Triple &Triple);
+StringRef getRISCVCodeModel(const llvm::opt::ArgList &Args);
 } // end namespace riscv
 } // namespace tools
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ARCH_RISCV_H

clang/lib/Driver/ToolChains/Arch/RISCV.cpp

else
       return "rv32imafdc";
   } else {
     if (Triple.getOS() == llvm::Triple::UnknownOS)
       return "rv64imac";
     else
       return "rv64imafdc";
   }
 }
+
+StringRef riscv::getRISCVCodeModel(const llvm::opt::ArgList &Args) {
+  // Default code model is 'small' (what GCC calls 'medlow').
+  StringRef CodeModel;
+  if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
+    CodeModel = A->getValue();
+  else
+    CodeModel = "small";
+
+  return CodeModel;
+}

clang/lib/Driver/ToolChains/Gnu.h

class GCCInstallationDetector {
     std::set<std::string> CandidateGCCInstallPaths;
 
     /// The set of multilibs that the detected installation supports.
     MultilibSet Multilibs;
 
     // Gentoo-specific toolchain configurations are stored here.
     const std::string GentooConfigDir = "/etc/env.d/gcc";
 
+    /// Error message during detect multilib
+    std::string MultilibErrorMessages;
+
   public:
     explicit GCCInstallationDetector(const Driver &D) : IsValid(false), D(D) {}
     void init(const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args,
               ArrayRef<std::string> ExtraTripleAliases = None);
 
     /// Check whether we detected a valid GCC install.
     bool isValid() const { return IsValid; }
 

clang/lib/Driver/ToolChains/Gnu.cpp

 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/Tool.h"
 #include "clang/Driver/ToolChain.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/Program.h"
 #include "llvm/Support/TargetParser.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include <system_error>
 
 using namespace clang::driver;
 using namespace clang::driver::toolchains;
 using namespace clang;
 using namespace llvm::opt;
addMultilibFlag(Args.hasFlag(options::OPT_fexceptions,
                                options::OPT_fno_exceptions, false),
                   "exceptions", Flags);
   if (Result.Multilibs.select(Flags, Result.SelectedMultilib))
     return true;
 
   return false;
 }
 
-static void findRISCVBareMetalMultilibs(const Driver &D,
-                                        const llvm::Triple &TargetTriple,
-                                        StringRef Path, const ArgList &Args,
-                                        DetectedMultilibs &Result) {
+static std::string findGCCPath(const Driver &D, llvm::StringRef BasePath) {
+  SmallString<128> GCCPath;
+  llvm::sys::path::append(GCCPath, BasePath, "bin",
+                          D.getTargetTriple() + "-gcc");
+
+  if (llvm::sys::fs::exists(GCCPath))
+    return GCCPath.str().str();
+
+  return "";
+}
+
+static std::string getGCCPath(const Driver &D, const ArgList &Args) {
+
+  // Find GCC from -gcc-toolchain if given.
+  if (const Arg *A =
+          Args.getLastArg(clang::driver::options::OPT_gcc_toolchain)) {
+    return findGCCPath(D, A->getValue());
+  } else {
+    // Try to find GCC from GCC_INSTALL_PREFIX if define.
+    llvm::StringRef GCCInstallPrefix = GCC_INSTALL_PREFIX;
+    std::string GCCPath;
+    if (!GCCInstallPrefix.empty())
+      GCCPath = findGCCPath(D, GCCInstallPrefix);
+    else {
+      // Try to find GCC from the same folder as driver.
+      SmallString<128> GCCBasePath;
+      llvm::sys::path::append(GCCBasePath, D.Dir, "..");
+      GCCPath = findGCCPath(D, GCCBasePath);
+    }
+    return GCCPath;
+  }
+}
+
+static bool scanRISCVGCCMultilibConfig(const Driver &D,
+                                       StringRef MultilibOutput,
+  llvm::StringSet<> AllABI;
+  llvm::StringSet<> AllArch;
+  llvm::StringSet<> AllMCmodel;
+  Multilib::flags_list Flags;
+
+  FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
+
+  // Get current ABI, Arch, and code model.
+  StringRef ABIName = tools::riscv::getRISCVABI(Args, TargetTriple);
+  StringRef MArch = tools::riscv::getRISCVArch(Args, TargetTriple);
+  StringRef CodeModel = tools::riscv::getRISCVCodeModel(Args);
+
+  // Turns it into option style, to make it able to compare
+  // to multi-lib option list.
+  std::string CurrentABIOpt = Twine("mabi=", ABIName).str();
+  std::string CurrentArchOpt = Twine("march=", MArch).str();
+  std::string CurrentMCmodelOpt = llvm::StringSwitch<const char *>(CodeModel)
+                                      .Case("medium", "mcmodel=medany")
+                                      .Default("mcmodel=medlow");
+
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
+      D.getVFS().getBufferForFile(MultilibOutput);
+  std::vector<Multilib> Ms;
+
+  if (!File) {
+    // Ooops, some thing wrong during open file, let's fallback.
+    return false;
+  }
+
+  SmallVector<StringRef, 128> Lines;
+  File.get()->getBuffer().split(Lines, "\n");
+  for (StringRef Line : Lines) {
+    if (Line.trim().empty())
+      continue;
+    // Format for multi-lib:
+    // <path>;@opt1@opt2
+    // For example:
+    // rv32ec/ilp32e;@march=rv32ec@mabi=ilp32e
+    // -march=rv32ec and -mabi=ilp32e using rv32ec/ilp32e.
+    auto MultilibInfo = Line.split(';');
+    StringRef Path = MultilibInfo.first;
+
+    // Skip default multi-lib path.
+    // Clang has implied a default multi-lib rule there,
+    // so we don't need to add it manually.
+    if (Path == ".")
+      continue;
+
+    StringRef Options = MultilibInfo.second.substr(1);
+    SmallVector<StringRef, 2> OptionList;
+    Options.split(OptionList, '@');
+    // multilib path rule is ${march}/${mabi}
+    auto Multilib = makeMultilib(Path);
+    for (StringRef Option : OptionList) {
+      Multilib.flag(Twine("+", Option).str());
+
+      // Gather all used option from multi-lib config.
+      if (Option.startswith("march=")) {
+        if (!AllArch.contains(Option)) {
+          // Make sure every option we only process once
+          AllArch.insert(Option);
+          addMultilibFlag(CurrentArchOpt == Option, Option.str().c_str(),
+                          Flags);
+        }
+      } else if (Option.startswith("mabi=")) {
+        if (!AllABI.contains(Option)) {
+          AllABI.insert(Option);
+          addMultilibFlag(CurrentABIOpt == Option, Option.str().c_str(), Flags);
+        }
+      } else if (Option.startswith("mcmodel=")) {
+        if (!AllMCmodel.contains(Option)) {
+          AllMCmodel.insert(Option);
+          addMultilibFlag(CurrentMCmodelOpt == Option, Option.str().c_str(),
+                          Flags);
+        }
+      } else {
+        // Got unrecognized option in multi-lib config, fallback.
+        D.Diag(diag::warn_drv_multilib_fallback) << Option;
+        return false;
+      }
+    }
+    Ms.emplace_back(Multilib);
+  }
+
+  MultilibSet RISCVMultilibs =
+      MultilibSet().FilterOut(NonExistent).Either(ArrayRef<Multilib>(Ms));
+
+  RISCVMultilibs.select(Flags, Result.SelectedMultilib);
+
+  Result.Multilibs = RISCVMultilibs;
+
+  return true;
+}
+
+static bool getRISCVMultilibFromGCC(const Driver &D,
+                                    const llvm::Triple &TargetTriple,
+                                    StringRef Path, const ArgList &Args,
+                                    DetectedMultilibs &Result,
+                                    std::string &MultilibErrorMessages) {
+  // Try to find where is GCC.
+  std::string GCCPath = getGCCPath(D, Args);
+
+  // Not found? fallback to built-in multi-lib.
+  if (GCCPath.empty())
+    return false;
+
+  // Ask GCC's multi-lib config via --print-multi-lib.
+  StringRef GCCArgs[] = {{GCCPath}, {"--print-multi-lib"}};
+  std::string MultilibOutput = D.GetTemporaryPath("gcc-output-", "");
+  Optional<StringRef> Redirects[] = {None, {MultilibOutput}, {""}};
+
+  int RC = llvm::sys::ExecuteAndWait(GCCPath, GCCArgs, None, Redirects);
+
+  // Any failed happen? let fallback to built-in multi-lib.
+  if (RC != 0) {
+    MultilibErrorMessages = "Read GCC multilib configureation failed due to "
+                            "non-zero return code";
+    return false;
+  }
+
+  // Parsing output of --print-multi-lib, and use that info to determine
+  // which multi-lib should be used.
+  return scanRISCVGCCMultilibConfig(D, TargetTriple, Path, Args, MultilibOutput,
+                                    Result);
+}
+
+static void findRISCVBareMetalMultilibs(const Driver &D,
+                                        const llvm::Triple &TargetTriple,
+                                        StringRef Path, const ArgList &Args,
+                                        DetectedMultilibs &Result,
+                                        std::string &MultilibErrorMessages) {
+  // Try to get multilib from GCC first.
+  if (getRISCVMultilibFromGCC(D, TargetTriple, Path, Args, Result,
+                              MultilibErrorMessages))
+    return;
+
   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
   struct RiscvMultilib {
     StringRef march;
     StringRef mabi;
   };
   // currently only support the set of multilibs like riscv-gnu-toolchain does.
   // TODO: support MULTILIB_REUSE
   constexpr RiscvMultilib RISCVMultilibSet[] = {
static void findRISCVBareMetalMultilibs(const Driver &D,
   }
 
   if (RISCVMultilibs.select(Flags, Result.SelectedMultilib))
     Result.Multilibs = RISCVMultilibs;
 }
 
 static void findRISCVMultilibs(const Driver &D,
                                const llvm::Triple &TargetTriple, StringRef Path,
-                               const ArgList &Args, DetectedMultilibs &Result) {
+                               const ArgList &Args, DetectedMultilibs &Result,
+                               std::string &MultilibErrorMessages) {
   if (TargetTriple.getOS() == llvm::Triple::UnknownOS)
-    return findRISCVBareMetalMultilibs(D, TargetTriple, Path, Args, Result);
+    return findRISCVBareMetalMultilibs(D, TargetTriple, Path, Args, Result,
+                                       MultilibErrorMessages);
 
   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
   Multilib Ilp32 = makeMultilib("lib32/ilp32").flag("+m32").flag("+mabi=ilp32");
   Multilib Ilp32f =
       makeMultilib("lib32/ilp32f").flag("+m32").flag("+mabi=ilp32f");
   Multilib Ilp32d =
       makeMultilib("lib32/ilp32d").flag("+m32").flag("+mabi=ilp32d");
   Multilib Lp64 = makeMultilib("lib64/lp64").flag("+m64").flag("+mabi=lp64");

 
 void Generic_GCC::GCCInstallationDetector::print(raw_ostream &OS) const {
   for (const auto &InstallPath : CandidateGCCInstallPaths)
     OS << "Found candidate GCC installation: " << InstallPath << "\n";
 
   if (!GCCInstallPath.empty())
     OS << "Selected GCC installation: " << GCCInstallPath << "\n";
 
+  if (!MultilibErrorMessages.empty())
+    OS << MultilibErrorMessages << "\n";
+
   for (const auto &Multilib : Multilibs)
     OS << "Candidate multilib: " << Multilib << "\n";
 
   if (Multilibs.size() != 0 || !SelectedMultilib.isDefault())
     OS << "Selected multilib: " << SelectedMultilib << "\n";
 }
 
 bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const {
bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(
   // so handle them there
   if (isArmOrThumbArch(TargetArch) && TargetTriple.isAndroid()) {
     // It should also work without multilibs in a simplified toolchain.
     findAndroidArmMultilibs(D, TargetTriple, Path, Args, Detected);
   } else if (TargetTriple.isMIPS()) {
     if (!findMIPSMultilibs(D, TargetTriple, Path, Args, Detected))
       return false;
   } else if (TargetTriple.isRISCV()) {
-    findRISCVMultilibs(D, TargetTriple, Path, Args, Detected);
+    findRISCVMultilibs(D, TargetTriple, Path, Args, Detected,
+                       MultilibErrorMessages);
   } else if (isMSP430(TargetArch)) {
     findMSP430Multilibs(D, TargetTriple, Path, Args, Detected);
   } else if (TargetArch == llvm::Triple::avr) {
     // AVR has no multilibs.
   } else if (!findBiarchMultilibs(D, TargetTriple, Path, Args,
                                   NeedsBiarchSuffix, Detected)) {
     return false;
   }

clang/test/Driver/Inputs/multilib_riscv32_elf_sdk/bin/riscv32-unknown-elf-gcc

+#!/usr/bin/env python3
+
+print("rv32iac/ilp32;@march=rv32iac@mabi=ilp32")
+print("rv32imafc/ilp32f;@march=rv32iac@mabi=ilp32f")
+print("rv64imafdc/lp64d;@march=rv64imafdc@mabi=lp64d")

clang/test/Driver/Inputs/multilib_riscv64_elf_sdk/bin/riscv64-unknown-elf-gcc

+#!/usr/bin/env python3
+
+print("rv32iac/ilp32;@march=rv32iac@mabi=ilp32")
+print("rv32imafc/ilp32f;@march=rv32iac@mabi=ilp32f")
+print("rv64imafdc/lp64d;@march=rv64imafdc@mabi=lp64d")

clang/test/Driver/Inputs/multilib_riscv64_elf_sdk_bad/bin/riscv64-unknown-elf-gcc

+#!/usr/bin/env python3
+
+print("rv32iac/ilp32;@march=rv32iac@mabi=ilp32")
+print("rv32imafc/ilp32f;@march=rv32iac@mabi=ilp32f")
+print("rv64imafdc/lp64d;@march=rv64imafdc@mabi=lp64d@xxx")

clang/test/Driver/Inputs/multilib_riscv64_elf_sdk_bad2/bin/riscv64-unknown-elf-gcc

+#!/usr/bin/env python3
+import sys
+
+sys.exit(1)

clang/test/Driver/riscv-toolchain-gcc-multilib.c

+// Test case for scanning input of GCC output as multilib config
+// Skip this test on Windows, we can't create a dummy GCC to output
+// multilib config, ExecuteAndWait only execute *.exe file.
+// UNSUPPORTED: system-windows
+
+// RUN: %clang %s \
+// RUN:   -target riscv32-unknown-elf \
+// RUN:   --gcc-toolchain=%S/Inputs/multilib_riscv32_elf_sdk \
+// RUN:   --print-multi-lib \
+// RUN:   | FileCheck -check-prefix=C-RV32-GCC-MULTI-LIB %s
+// C-RV32-GCC-MULTI-LIB: rv32iac/ilp32;@march=rv32iac@mabi=ilp32
+// C-RV32-GCC-MULTI-LIB-NEXT: rv32imafc/ilp32f;@march=rv32iac@mabi=ilp32f
+// C-RV32-GCC-MULTI-LIB-NEXT: rv64imafdc/lp64d;@march=rv64imafdc@mabi=lp64d
+// C-RV32-GCC-MULTI-LIB-NOT:  {{^.+$}}
+
+// RUN: %clang %s \
+// RUN:   -### -v \
+// RUN:   -target riscv32-unknown-elf \
+// RUN:   --gcc-toolchain=%S/Inputs/multilib_riscv32_elf_sdk 2>&1 \
+// RUN:   | FileCheck -check-prefix=C-RV32-GCC-MULTI-LIB-V %s
+// C-RV32-GCC-MULTI-LIB-V: Candidate multilib: rv32iac/ilp32;@march=rv32iac@mabi=ilp32
+// C-RV32-GCC-MULTI-LIB-V-NEXT: Candidate multilib: rv32imafc/ilp32f;@march=rv32iac@mabi=ilp32f
+// C-RV32-GCC-MULTI-LIB-V-NEXT: Candidate multilib: rv64imafdc/lp64d;@march=rv64imafdc@mabi=lp64d
+
+// RUN: %clang %s \
+// RUN:   -target riscv64-unknown-elf \
+// RUN:   --gcc-toolchain=%S/Inputs/multilib_riscv64_elf_sdk \
+// RUN:   --print-multi-lib \
+// RUN:   | FileCheck -check-prefix=C-RV64-GCC-MULTI-LIB %s
+// C-RV64-GCC-MULTI-LIB: rv32iac/ilp32;@march=rv32iac@mabi=ilp32
+// C-RV64-GCC-MULTI-LIB-NEXT: rv32imafc/ilp32f;@march=rv32iac@mabi=ilp32f
+// C-RV64-GCC-MULTI-LIB-NEXT: rv64imafdc/lp64d;@march=rv64imafdc@mabi=lp64d
+// C-RV64-GCC-MULTI-LIB-NOT:  {{^.+$}}
+
+// RUN: %clang %s \
+// RUN:   -### -v \
+// RUN:   -target riscv64-unknown-elf \
+// RUN:   --gcc-toolchain=%S/Inputs/multilib_riscv64_elf_sdk 2>&1 \
+// RUN:   | FileCheck -check-prefix=C-RV64-GCC-MULTI-LIB-V %s
+// C-RV64-GCC-MULTI-LIB-V: Candidate multilib: rv32iac/ilp32;@march=rv32iac@mabi=ilp32
+// C-RV64-GCC-MULTI-LIB-V-NEXT: Candidate multilib: rv32imafc/ilp32f;@march=rv32iac@mabi=ilp32f
+// C-RV64-GCC-MULTI-LIB-V-NEXT: Candidate multilib: rv64imafdc/lp64d;@march=rv64imafdc@mabi=lp64d
+
+// RUN: %clang %s \
+// RUN:   -target riscv64-unknown-elf \
+// RUN:   --gcc-toolchain=%S/Inputs/multilib_riscv64_elf_sdk_bad \
+// RUN:   --print-multi-lib 2>&1 \
+// RUN:   | FileCheck -check-prefix=C-RV64-GCC-MULTI-LIB-BAD %s
+// C-RV64-GCC-MULTI-LIB-BAD: warning: xxx option unrecognized in multi-lib configuration when parsing config from GCC, falling back to built-in multi-lib configuration. [-Wmultilib-fallback]
+
+// RUN: %clang %s \
+// RUN:   -### -v \
+// RUN:   -target riscv64-unknown-elf \
+// RUN:   --gcc-toolchain=%S/Inputs/multilib_riscv64_elf_sdk_bad2 2>&1 \
+// RUN:   | FileCheck -check-prefix=C-RV64-GCC-MULTI-LIB-BAD-V %s
+// C-RV64-GCC-MULTI-LIB-BAD-V: Read GCC multilib configureation failed due to non-zero return code