Enable multilib.yaml in the BareMetal ToolChain

[michaelplatings]

Summary

The default location for multilib.yaml is lib/clang-runtimes, without
any target-specific suffix. This will allow multilibs for different
architectures to share a common include directory.

To avoid breaking the arm-execute-only.c CHECK-NO-EXECUTE-ONLY-ASM
test, add a GetExecuteOnly argument to getARMTargetFeatures.

Since the presence of multilib.yaml can change the exact location of a
library, relax the baremetal.cpp test.

[michaelplatings]

Rebase

[michaelplatings]

Rebase

[michaelplatings]

Rebase

[peter.smith]

Looks good to me. Some small suggestions around execute-only as I expect this to be a useful multilib variant.

clang/lib/Driver/ToolChain.cpp

196–197

Now that there are two boolean parameters, could you put a prefix comment to show which one is which for example:
/* ForAs */ false, /* GenExecuteOnly */

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

778–780

I can see execute-only being used in a multilib configuration as it can impact code-generation significantly yet is a requirement for a system aiming to have all code execute-only.

Rather than a specific GenExecuteOnly flag, would it be better for something like ForMultilib like ForAS and then we could move it to not give the error message when doing ForMultilib the name would also generalise to other parts.

[michaelplatings]

Add clangMinimumVersion

[MaskRay]

clang/lib/Driver/ToolChains/BareMetal.cpp

167

delete blank line

169

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

193

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

clang/test/Driver/baremetal-multilib.cpp

1 ↗

(On Diff #496537)

This C++ source file is empty excluding comments. Just name it baremetal-multilib.yaml.

Note: if you need extra files, check out split-file

14 ↗

(On Diff #496537)

With -cc1 CHECK lines, remove clang{{.*}} before -cc1, then remove -no-canonical-prefixes. See my prior commits in this area.

[MaskRay]

clang/test/Driver/baremetal-multilib.cpp

19 ↗

(On Diff #496537)

Use a style similar to linux-cross.cpp.

Test a few variants (https://github.com/MaskRay/Config/wiki/LLVM#clanglibdriver)

[michaelplatings]

Apply changes requested by @peter.smith and @MaskRay

clang/test/Driver/baremetal-multilib.cpp

14 ↗

(On Diff #496537)

I found your commit 980679981fbc311bc07f8cd23e3739fd56c22d2a which removes many uses of -no-canonical-prefixes. However in this case the test relies on -no-canonical-prefixes to ensure that clang finds the correct lib/clang-runtimes directory so it's necessary to keep it.

I have removed clang{{.*}} which was a copy-paste from baremetal-sysroot.cpp and applied similar tweaks like your tidy-up to ld.

19 ↗

(On Diff #496537)

Use a style similar to linux-cross.cpp.

I think you're referring to the use of -L[[SYSROOT]] instead of -L{{.*}} and I've made that change.

Test a few variants (https://github.com/MaskRay/Config/wiki/LLVM#clanglibdriver)

The test follows the same pattern as baremetal-sysroot.cpp so in theory if that works on all the variants then so should this.

[michaelplatings]

PrintArgs -> PrintOptions

[michaelplatings]

flags -> tags

[peter.smith]

I've set approved from the Arm side. Please leave some time for people in the US time zone to leave any final comments or ask for extensions.

[michaelplatings]

Rebase

[abidh]

The BareMetal.cpp part looks ok to me.

[phosek]

clang/lib/Driver/ToolChains/BareMetal.cpp

184

Rather than hardcoding the filename and the location, which is inflexible, could we instead provide a command line option to specify the file to use?

[michaelplatings]

tags->flags

[michaelplatings]

Rebase

clang/lib/Driver/ToolChains/BareMetal.cpp

184

I'm not opposed to that in principle but I'd rather leave that as an option for a future change. At this point, for LLVM Embedded Toolchain for Arm our intent is that users will specify --sysroot if they want to use a separate set of multilibs.

[michaelplatings]

Rebase on D146141

[michaelplatings]

Rebase

[michaelplatings]

Rebase

[phosek]

clang/lib/Driver/ToolChains/BareMetal.cpp

180

Defer to llvm::sys::path::append for joining the path components to ensure that the right separator is used.

183

I see that this is a pre-existing behavior, but I find it a unfortunate that the BareMetal driver is using its own convention. I'd prefer using ../sys-root which the existing convention used by GCC. I'm wondering if this is something we can change as part of the transition to the new multilib implementation?

184

Relying on --sysroot is fine if you're assembling the sysroot yourself and control the content, but when dealing with an existing sysroot it may not be possible to add additional files in which case having the ability to specify the .yaml file may be essential. Having an option also gives more flexibility, for example I could imagine having more than one .yaml file for the same sysroot with different subsets of multilibs.

[michaelplatings]

Rebase

clang/lib/Driver/ToolChains/BareMetal.cpp

183

If I remember correctly @abidh did it this way specifically to avoid conflicting with the contents of GCC's sys-root directory.

184

Sounds good, let's do it in a later patch.

[phosek]

clang/lib/Driver/ToolChains/BareMetal.cpp

174

This is not idiomatic, I couldn't find any instance of #define for string literals anywhere in LLVM. I believe the idiomatic LLVM alternative is:

static constexpr llvm::StringLiteral MultilibFilename = "multilib.yaml";

[michaelplatings]

Change string literal as suggested by @phosek

[phosek]

LGTM

[michaelplatings]

Rebase

clang/lib/Driver/ToolChain.cpp

 }
 
 static void getARMMultiSelectionTags(const Driver &D,
                                      const llvm::Triple &Triple,
                                      const llvm::opt::ArgList &Args,
                                      std::vector<std::string> &Result) {
   std::vector<StringRef> Features;
   unsigned FPUKind = llvm::ARM::FK_INVALID;
-  tools::arm::getARMTargetFeatures(D, Triple, Args, Features, false, &FPUKind);
+  tools::arm::getARMTargetFeatures(D, Triple, Args, Features, false /*ForAs*/,
+                                   true /*ForMultilib*/, &FPUKind);
   const auto UnifiedFeatures = tools::unifyTargetFeatures(Features);
   llvm::DenseSet<StringRef> FeatureSet(UnifiedFeatures.begin(),
                                        UnifiedFeatures.end());
   for (const auto &Ext : ARM::ARCHExtNames)
     if (FeatureSet.find(Ext.Feature) != FeatureSet.end())
       Result.push_back(("march=+" + Ext.Name).str());
 
   switch (FPUKind) {

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

 bool useAAPCSForMachO(const llvm::Triple &T);
 void getARMArchCPUFromArgs(const llvm::opt::ArgList &Args,
                            llvm::StringRef &Arch, llvm::StringRef &CPU,
                            bool FromAs = false);
 // Optionally returns the FPUKind
 void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
                           const llvm::opt::ArgList &Args,
                           std::vector<llvm::StringRef> &Features, bool ForAS,
+                          bool ForMultilib = false,
                           unsigned *OutFPUKind = nullptr);
 int getARMSubArchVersionNumber(const llvm::Triple &Triple);
 bool isARMMProfile(const llvm::Triple &Triple);
 bool isARMAProfile(const llvm::Triple &Triple);
 
 } // end namespace arm
 } // end namespace tools
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ARCH_ARM_H

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

static bool hasIntegerMVE(const std::vector<StringRef> &F) {
   auto NoMVE = llvm::find(llvm::reverse(F), "-mve");
   return MVE != F.rend() &&
          (NoMVE == F.rend() || std::distance(MVE, NoMVE) > 0);
 }
 
 void arm::getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
                                const ArgList &Args,
                                std::vector<StringRef> &Features, bool ForAS,
-                               unsigned *OutFPUKind) {
+                               bool ForMultilib, unsigned *OutFPUKind) {
   bool KernelOrKext =
       Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
   arm::FloatABI ABI = arm::getARMFloatABI(D, Triple, Args);
   std::optional<std::pair<const Arg *, StringRef>> WaCPU, WaFPU, WaHDiv, WaArch;
 
   // This vector will accumulate features from the architecture
   // extension suffixes on -mcpu and -march (e.g. the 'bar' in
   // -mcpu=foo+bar). We want to apply those after the features derived
if (A->getOption().matches(options::OPT_mlong_calls))
       Features.push_back("+long-calls");
   } else if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)) &&
              !Triple.isWatchOS()) {
       Features.push_back("+long-calls");
   }
 
   // Generate execute-only output (no data access to code sections).
   // This only makes sense for the compiler, not for the assembler.
-  if (!ForAS) {
+  // It's not needed for multilib selection and may hide an unused
+  // argument diagnostic if the code is always run.
+  if (!ForAS && !ForMultilib) {
     // Supported only on ARMv6T2 and ARMv7 and above.
     // Cannot be combined with -mno-movt.
     if (Arg *A = Args.getLastArg(options::OPT_mexecute_only, options::OPT_mno_execute_only)) {
       if (A->getOption().matches(options::OPT_mexecute_only)) {
         if (getARMSubArchVersionNumber(Triple) < 7 &&
             llvm::ARM::parseArch(Triple.getArchName()) != llvm::ARM::ArchKind::ARMV6T2)
               D.Diag(diag::err_target_unsupported_execute_only) << Triple.getArchName();
         else if (Arg *B = Args.getLastArg(options::OPT_mno_movt))

clang/lib/Driver/ToolChains/BareMetal.cpp

if (Triple.getVendor() != llvm::Triple::UnknownVendor)
     return false;
 
   if (Triple.getOS() != llvm::Triple::UnknownOS)
     return false;
 
   return Triple.getEnvironmentName() == "elf";
 }
 
+static bool findMultilibsFromYAML(const ToolChain &TC, const Driver &D,
+                                  StringRef MultilibPath, const ArgList &Args,
+                                  DetectedMultilibs &Result) {
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MB =
+      D.getVFS().getBufferForFile(MultilibPath);
+  if (!MB)
+    return false;
+  std::vector<std::string> ArgsTags = TC.getMultiSelectionTags(Args);
+  if (!Result.Multilibs.parse(*MB.get()))
+    return false;
+  Multilib::tag_set Tags(ArgsTags.begin(), ArgsTags.end());
+  return Result.Multilibs.select(Tags, Result.SelectedMultilib);
+}
+
+#define MULTILIB_YAML_FILENAME "multilib.yaml"
+
+// Get the sysroot, before multilib takes effect.
+static std::string computeBaseSysRoot(const Driver &D,
+                                      const llvm::Triple &Triple) {
+  if (!D.SysRoot.empty())
+    return D.SysRoot;
+
+  SmallString<128> SysRootDir(D.Dir);
+  llvm::sys::path::append(SysRootDir, "../lib/clang-runtimes");
+
+  SmallString<128> MultilibPath(SysRootDir);
+  llvm::sys::path::append(MultilibPath, MULTILIB_YAML_FILENAME);
+
+  // New behaviour: if multilib.yaml is found then use clang-runtimes as the
+  // sysroot.
+  if (D.getVFS().exists(MultilibPath))
+    return std::string(SysRootDir);
+
+  // Otherwise fall back to the old behaviour of appending the target triple.
+  llvm::sys::path::append(SysRootDir, D.getTargetTriple());
+  return std::string(SysRootDir);
+}
+
 void BareMetal::findMultilibs(const Driver &D, const llvm::Triple &Triple,
                               const ArgList &Args) {
   DetectedMultilibs Result;
   if (isRISCVBareMetal(Triple)) {
     if (findRISCVMultilibs(D, Triple, Args, Result)) {
       SelectedMultilib = Result.SelectedMultilib;
       Multilibs = Result.Multilibs;
     }
+  } else {
+    llvm::SmallString<128> MultilibPath(computeBaseSysRoot(D, Triple));
+    llvm::sys::path::append(MultilibPath, MULTILIB_YAML_FILENAME);
+    findMultilibsFromYAML(*this, D, MultilibPath, Args, Result);
+    SelectedMultilib = Result.SelectedMultilib;
+    Multilibs = Result.Multilibs;
   }
 }
 
 bool BareMetal::handlesTarget(const llvm::Triple &Triple) {
   return isARMBareMetal(Triple) || isAArch64BareMetal(Triple) ||
          isRISCVBareMetal(Triple);
 }
 
 Tool *BareMetal::buildLinker() const {
   return new tools::baremetal::Linker(*this);
 }
 
 std::string BareMetal::computeSysRoot() const {
-  if (!getDriver().SysRoot.empty())
-    return getDriver().SysRoot + SelectedMultilib.osSuffix();
-
-  SmallString<128> SysRootDir;
-  llvm::sys::path::append(SysRootDir, getDriver().Dir, "../lib/clang-runtimes",
-                          getDriver().getTargetTriple());
-
-  SysRootDir += SelectedMultilib.osSuffix();
-  return std::string(SysRootDir);
+  return computeBaseSysRoot(getDriver(), getTriple()) +
+         SelectedMultilib.osSuffix();
 }
 
 void BareMetal::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
                                           ArgStringList &CC1Args) const {
   if (DriverArgs.hasArg(options::OPT_nostdinc))
     return;
 
   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {

clang/test/Driver/baremetal-multilib.yaml

+# REQUIRES: shell
+# UNSUPPORTED: system-windows
+
+# RUN: rm -rf %T/baremetal_multilib
+# RUN: mkdir -p %T/baremetal_multilib/bin
+# RUN: mkdir -p %T/baremetal_multilib/lib/clang-runtimes/arm-none-eabi/thumb/v8-m.main/fp/lib
+# RUN: touch %T/baremetal_multilib/lib/clang-runtimes/arm-none-eabi/thumb/v8-m.main/fp/lib/libclang_rt.builtins.a
+# RUN: ln -s %clang %T/baremetal_multilib/bin/clang
+# RUN: ln -s %s %T/baremetal_multilib/lib/clang-runtimes/multilib.yaml
+
+# RUN: %T/baremetal_multilib/bin/clang -no-canonical-prefixes -x c++ %s -### -o %t.out 2>&1 \
+# RUN:     --target=thumbv8m.main-none-eabihf --sysroot= \
+# RUN:   | FileCheck -DSYSROOT=%T/baremetal_multilib %s
+# CHECK:      "-cc1" "-triple" "thumbv8m.main-none-unknown-eabihf"
+# CHECK-SAME: "-internal-isystem" "[[SYSROOT]]/bin/../lib/clang-runtimes/arm-none-eabi/thumb/v8-m.main/fp/include/c++/v1"
+# CHECK-SAME: "-internal-isystem" "[[SYSROOT]]/bin/../lib/clang-runtimes/arm-none-eabi/thumb/v8-m.main/fp/include"
+# CHECK-SAME: "-x" "c++" "{{.*}}baremetal-multilib.yaml"
+# CHECK-NEXT: ld{{(.exe)?}}" "{{.*}}.o" "-Bstatic"
+# CHECK-SAME: "-L[[SYSROOT]]/bin/../lib/clang-runtimes/arm-none-eabi/thumb/v8-m.main/fp/lib"
+# CHECK-SAME: "-lc" "-lm" "-lclang_rt.builtins"
+# CHECK-SAME: "-o" "{{.*}}.tmp.out"
+
+# RUN: %T/baremetal_multilib/bin/clang -no-canonical-prefixes -print-multi-directory 2>&1 \
+# RUN:     --target=thumbv8m.main-none-eabihf --sysroot= \
+# RUN:   | FileCheck --check-prefix=CHECK-PRINT-MULTI-DIRECTORY %s
+# CHECK-PRINT-MULTI-DIRECTORY: arm-none-eabi/thumb/v8-m.main/fp
+
+# RUN: %T/baremetal_multilib/bin/clang -no-canonical-prefixes -print-multi-lib 2>&1 \
+# RUN:     --target=arm-none-eabi --sysroot= \
+# RUN:   | FileCheck --check-prefix=CHECK-PRINT-MULTI-LIB %s
+# CHECK-PRINT-MULTI-LIB: arm-none-eabi/thumb/v6-m/nofp;@-target=thumbv6m-none-eabi@mfloat-abi=soft
+# CHECK-PRINT-MULTI-LIB: arm-none-eabi/thumb/v7-m/nofp;@-target=thumbv7m-none-eabi@mfloat-abi=soft
+# CHECK-PRINT-MULTI-LIB: arm-none-eabi/thumb/v7e-m/nofp;@-target=thumbv7em-none-eabi@mfloat-abi=soft@mfpu=none
+# CHECK-PRINT-MULTI-LIB: arm-none-eabi/thumb/v8-m.main/nofp;@-target=arm-none-eabi@mfloat-abi=soft@march=armv8m.main+nofp
+# CHECK-PRINT-MULTI-LIB: arm-none-eabi/thumb/v8.1-m.main/nofp/nomve;@-target=arm-none-eabi@mfloat-abi=soft@march=armv8.1m.main+nofp+nomve
+# CHECK-PRINT-MULTI-LIB: arm-none-eabi/thumb/v7e-m/fpv4_sp_d16;@-target=thumbv7em-none-eabihf@mfpu=fpv4-sp-d16
+# CHECK-PRINT-MULTI-LIB: arm-none-eabi/thumb/v7e-m/fpv5_d16;@-target=thumbv7em-none-eabihf@mfpu=fpv5-d16
+# CHECK-PRINT-MULTI-LIB: arm-none-eabi/thumb/v8-m.main/fp;@-target=thumbv8m.main-none-eabihf
+# CHECK-PRINT-MULTI-LIB: arm-none-eabi/thumb/v8.1-m.main/fp;@-target=thumbv8.1m.main-none-eabihf
+# CHECK-PRINT-MULTI-LIB: arm-none-eabi/thumb/v8.1-m.main/nofp/mve;@-target=arm-none-eabihf@march=armv8.1m.main+nofp+mve
+
+# RUN: %T/baremetal_multilib/bin/clang -no-canonical-prefixes -x assembler -mexecute-only \
+# RUN:     --target=arm-none-eabi --sysroot= %s -c -### 2>&1 \
+# RUN:    | FileCheck %s --check-prefix=CHECK-NO-EXECUTE-ONLY-ASM
+# CHECK-NO-EXECUTE-ONLY-ASM: warning: argument unused during compilation: '-mexecute-only'
+
+---
+# This file is in two parts:
+# 1. A list of library variants.
+# 2. A mapping from tags generated from command line arguments to further
+#    tags.
+
+# How does clang use this file?
+# 1. If the ToolChain class for the architecture supports this form of
+#    multilib it then it loads the file if present in sysroot.
+# 2. Generate tags from the user provided arguments.
+#    (Use `clang -print-multi-selection-tags` to see which tags are
+#    generated).
+# 3. Compare the arguments against each regular expression and store
+#    associated tags if there's a match.
+# 4. Find the last library variant whose tags are a subset of the
+#    tags derived from the user provided arguments.
+# 5. Use the directory for the library variant as the sysroot.
+
+# This defines the minimum version of Clang required to use this file.
+# It is required to be present.
+# Clang will emit an error if this number is greater than its version, but
+# will accept lesser versions.
+ClangMinimumVersion: 17.0.0
+
+# The first section of the file is the list of library variants.
+# A library is considered compatible if the are a subset of the tags derived
+# from the arguments provided by the user.
+# If multiple libraries are deemed compatible then the one that appears
+# last in the list wins. A ToolChain may instead opt to use more than one
+# multilib, layered on top of each other.
+# Each library variant must have a "PrintOptions" attribute. This is solely to
+# support `clang -print-multi-lib`.
+
+Variants:
+- Dir: arm-none-eabi/thumb/v6-m/nofp
+  Tags: [target=thumbv6m-none-unknown-eabi]
+  PrintOptions: [--target=thumbv6m-none-eabi, -mfloat-abi=soft]
+
+- Dir: arm-none-eabi/thumb/v7-m/nofp
+  Tags: [target=thumbv7m-none-unknown-eabi]
+  PrintOptions: [--target=thumbv7m-none-eabi, -mfloat-abi=soft]
+
+- Dir: arm-none-eabi/thumb/v7e-m/nofp
+  Tags: [target=thumbv7em-none-unknown-eabi]
+  PrintOptions: [--target=thumbv7em-none-eabi, -mfloat-abi=soft, -mfpu=none]
+
+- Dir: arm-none-eabi/thumb/v8-m.main/nofp
+  Tags: [target=thumbv8m.main-none-unknown-eabi]
+  PrintOptions: [--target=arm-none-eabi, -mfloat-abi=soft, -march=armv8m.main+nofp]
+
+- Dir: arm-none-eabi/thumb/v8.1-m.main/nofp/nomve
+  Tags: [target=thumbv8.1m.main-none-unknown-eabi]
+  PrintOptions: [--target=arm-none-eabi, -mfloat-abi=soft, -march=armv8.1m.main+nofp+nomve]
+
+- Dir: arm-none-eabi/thumb/v7e-m/fpv4_sp_d16
+  Tags: [target=thumbv7em-none-unknown-eabihf, mfpu=fpv4-sp-d16]
+  PrintOptions: [--target=thumbv7em-none-eabihf, -mfpu=fpv4-sp-d16]
+
+- Dir: arm-none-eabi/thumb/v7e-m/fpv5_d16
+  Tags: [target=thumbv7em-none-unknown-eabihf, mfpu=fpv5-d16]
+  PrintOptions: [--target=thumbv7em-none-eabihf, -mfpu=fpv5-d16]
+
+- Dir: arm-none-eabi/thumb/v8-m.main/fp
+  Tags: [target=thumbv8m.main-none-unknown-eabihf, hasfpu]
+  PrintOptions: [--target=thumbv8m.main-none-eabihf]
+
+- Dir: arm-none-eabi/thumb/v8.1-m.main/fp
+  Tags: [target=thumbv8.1m.main-none-unknown-eabihf, hasfpu]
+  PrintOptions: [--target=thumbv8.1m.main-none-eabihf]
+
+- Dir: arm-none-eabi/thumb/v8.1-m.main/nofp/mve
+  Tags: [target=thumbv8.1m.main-none-unknown-eabihf, march=+mve]
+  PrintOptions: [--target=arm-none-eabihf, -march=armv8.1m.main+nofp+mve]
+
+
+# The second section of the file is a map from auto-detected tags
+# to custom tags. The auto-detected tags can be printed out
+# by running clang with `-print-multi-selection-tags`.
+# The regex must match a whole tag string.
+# "MatchTags" tags will be added if an argument matches, while
+# "NoMatchTags" tags will be added otherwise.
+TagMap:
+- Regex: mfpu=none
+  NoMatchTags: [hasfpu]
+# For v8m.base (and potential later v8m baseline versions) use v6m
+- Regex: target=thumbv8(\.[0-9]+)?m\.base-none-unknown-eabi
+  MatchTags: [target=thumbv6m-none-unknown-eabi]
+# Match versions after v8.1m.main. We assume that v8.2m (if/when it exists) will
+# be backwards compatible with v8.1m.
+# The alternative is to not recognise later versions, and require that
+# this multilib spec is updated before it can be used with newer
+# architecture versions.
+- Regex: thumbv8\.[1-9]m\.main-none-unknown-eabi
+  MatchTags: [target=thumbv8.1m.main-none-unknown-eabi]
+- Regex: thumbv8\.[1-9]m\.main-none-unknown-eabihf
+  MatchTags: [target=thumbv8.1m.main-none-unknown-eabihf]
+...

clang/test/Driver/baremetal.cpp

 // RUN:   | FileCheck %s --check-prefix=CHECK-SYSROOT-INC
 // CHECK-SYSROOT-INC-NOT: "-internal-isystem" "include"
 
 // RUN: %clang -no-canonical-prefixes %s -### --target=aarch64-none-elf 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-AARCH64-NO-HOST-INC %s
 // Verify that the bare metal driver does not include any host system paths:
 // CHECK-AARCH64-NO-HOST-INC: InstalledDir: [[INSTALLEDDIR:.+]]
 // CHECK-AARCH64-NO-HOST-INC: "-resource-dir" "[[RESOURCE:[^"]+]]"
-// CHECK-AARCH64-NO-HOST-INC-SAME: "-internal-isystem" "[[INSTALLEDDIR]]{{[/\\]+}}..{{[/\\]+}}lib{{[/\\]+}}clang-runtimes{{[/\\]+}}aarch64-none-elf{{[/\\]+}}include{{[/\\]+}}c++{{[/\\]+}}v1"
+// CHECK-AARCH64-NO-HOST-INC-SAME: "-internal-isystem" "[[INSTALLEDDIR]]{{[/\\]+}}..{{[/\\]+}}lib{{[/\\]+}}clang-runtimes{{[/\\]+[^"]*}}include{{[/\\]+}}c++{{[/\\]+}}v1"
 // CHECK-AARCH64-NO-HOST-INC-SAME: "-internal-isystem" "[[RESOURCE]]{{[/\\]+}}include"
-// CHECK-AARCH64-NO-HOST-INC-SAME: "-internal-isystem" "[[INSTALLEDDIR]]{{[/\\]+}}..{{[/\\]+}}lib{{[/\\]+}}clang-runtimes{{[/\\]+}}aarch64-none-elf{{[/\\]+}}include"
+// CHECK-AARCH64-NO-HOST-INC-SAME: "-internal-isystem" "[[INSTALLEDDIR]]{{[/\\]+}}..{{[/\\]+}}lib{{[/\\]+}}clang-runtimes{{[/\\]+[^"]*}}include"
 
 // RUN: %clang %s -### --target=riscv64-unknown-elf -o %t.out -L some/directory/user/asked/for \
 // RUN:     --sysroot=%S/Inputs/basic_riscv64_tree/riscv64-unknown-elf 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-RV64 %s
 // CHECK-RV64:      "-cc1" "-triple" "riscv64-unknown-unknown-elf"
 // CHECK-RV64-SAME: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
 // CHECK-RV64-SAME: "-isysroot" "[[SYSROOT:[^"]*]]"
 // CHECK-RV64-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}include{{[/\\]+}}c++{{[/\\]+}}v1"

clang/test/Driver/lit.local.cfg

 from lit.llvm import llvm_config
 
 config.suffixes = ['.c', '.cpp', '.cppm', '.h', '.m', '.mm', '.S', '.s', '.f90', '.F90', '.f95',
-                   '.cu', '.rs', '.cl', '.clcpp', '.hip', '.hipi', '.hlsl']
+                   '.cu', '.rs', '.cl', '.clcpp', '.hip', '.hipi', '.hlsl', '.yaml']
 config.substitutions = list(config.substitutions)
 config.substitutions.insert(0,
     ('%clang_cc1',
      """*** Do not use 'clang -cc1' in Driver tests. ***""") )
 
 # Remove harmful environmental variables for clang Driver tests.
 # Some might be useful for other tests so they are only removed here.
 driver_overwrite_env_vars = ['MACOSX_DEPLOYMENT_TARGET',