[Driver] Allow search of included response files as configuration files

[sepavloff]

Summary

If a configuration file contains directive @fname, the file 'fname'
in it is normally searched for relative to the including configuration
file. In some cases it is not convenient. Configuration parameters may
be logically partitioned into caterories (like 'platform variant' and
'processor variant') and it may be convenient to have different
configuration files for these categories maintained separately. Similar
motivation was described in
https://discourse.llvm.org/t/rfc-adding-a-default-file-location-to-config-file-support/63606.
Simple file inclusion by @file does not help, because in this case the
path to file is specified relative to the directory of the used
configuration file, but it actually is not dependent on the latter. Using
absolute paths is not convenient and it still do not allow user to
easily override the settings.

This change implements option --search-config-dirs, which modifies the
search algorithm, - files included by @file are searched for as
configuration files, in the same directories, and can be overridden by a
user. With this facility a configuration file can include other files
like in:

@platform.cfg
@processor.cfg
...other options...

The effect is as if two configuration files are loaded, both are
searched for in well-known places and can be overridden if user
provides a file with the same name in user configuration directory.

[MaskRay]

Normally a file included into configuration file by directive @file is
searched for relative the including configuration file. In some cases it
is not convenient.

relative => relative to.

(A configuration file may specify (value of an option) --option=file and (a "child" config file) @cfg. I assume this means @cfg.)

Configuration parameters may be logically partitioned
into caterories (like 'platform variant' and 'processor variant') and it
is convenient to have different configuration files for these
categories maintained separately. Similar motivation was described in
https://discourse.llvm.org/t/rfc-adding-a-default-file-location-to-config-file-support/63606.
Simple file inclusion by @file does not help, because in this case the
path to file is specified relative to the directory of the used
configuration file, but it actually is not dependent on the latter. Using
absolute paths is not convenient and it still do not allow user to
easily override the settings.

There are traditional response files and --config files. I was initially confused.
The patch does not change response files.

For a config file, --search-config-dirs is introduced to change how @cfg is resolved
(relative to --config-system-dir or --config-user-dir=).
I think mentioning the option names in the summary and having an elaborated example in clang/docs/UsersManual.rst will help.

This change implements option --search-config-dirs, which modifies the search algorithm, - files included by @file are searched for as configuration files, in the same directories, and can be overridden by a user.

Is the previous search algorithm sensible? If we think not, we can change the default, and introduce a driver or CC1 option to stay the old behavior.
My reasoning is that I cannot imagine many cases which can be broken by changing the search algorithm.

I think I'm still confused why we need a new option for changing the search algorithm.

Say, we have --config-system-dir=system --config-user-dir=user and three files system/a.cfg, system/b.cfg, user/b.cfg.
system/a.cfg contains @b.
The old algorithm resolves to system/b.cfg (relative to the dir of system/a.cfg: system/) while the new algorithm resolves to user/b.cfg?

clang/include/clang/Driver/Options.td

909

I am confused by the help text.

[MaskRay]

llvm/include/llvm/Support/CommandLine.h

2129

Unused

[sepavloff]

Change help message

[MaskRay]

As mentioned, if the new search algorithm makes sense, perhaps use the new algorithm by default and provide a temporary driver option for keeping the old behavior?

[aaron.ballman]

clang/docs/UsersManual.rst

953–955

llvm/lib/Support/CommandLine.cpp

1188–1194

1382–1385

[sepavloff]

Rebased, addressed reviewers' notes.

[sepavloff]

In D133325#3771275, @MaskRay wrote:

For a config file, --search-config-dirs is introduced to change how @cfg is resolved
(relative to --config-system-dir or --config-user-dir=).
I think mentioning the option names in the summary and having an elaborated example in clang/docs/UsersManual.rst will help.

Added simple example in clang/docs/UsersManual.rst.

This change implements option --search-config-dirs, which modifies the search algorithm, - files included by @file are searched for as configuration files, in the same directories, and can be overridden by a user.

Is the previous search algorithm sensible? If we think not, we can change the default, and introduce a driver or CC1 option to stay the old behavior.
My reasoning is that I cannot imagine many cases which can be broken by changing the search algorithm.

There is nothing wrong with the previous algorithm, it is just for a different use case. For example, some users prepare set of config files, which contain set of options for various tasks, and put them to directories, which are easy to access (like ~/p1/dbg.cfg). There files may share bulky information like include paths by using @file directives. Another directory may contain set of configuration files, say, for different platform. Enforcing the new algorithm would break existing work environments and require additional efforts to restore functionality.

One of the use case for the new algorithm is described in the patch description. As the option --search-config-dirs may be specified inside config file, from user perspective nothing changes, they just specify config file with the option --config, as previously. Compatibility is not broken.

I think I'm still confused why we need a new option for changing the search algorithm.

Say, we have --config-system-dir=system --config-user-dir=user and three files system/a.cfg, system/b.cfg, user/b.cfg.
system/a.cfg contains @b.
The old algorithm resolves to system/b.cfg (relative to the dir of system/a.cfg: system/) while the new algorithm resolves to user/b.cfg?

You are right. It simplify preparing working environment by combining its parts (include paths, libraries, preprocessor definitions etc) taken from well-knows place, still allowing a user to modify it without need to copy all environment into a new directory and then changing it.

[sepavloff]

An alternative implementation is in D136354. Instead of using new command-line option, it uses --config to include file, which is searched for as a configuration file.

[sepavloff]

The alternative solution in D136354 was implemented.

clang/docs/UsersManual.rst

 treated as a file name and is searched for sequentially in the directories:
 
     - user directory,
     - system directory,
     - the directory where Clang executable resides.
 
 Both user and system directories for configuration files are specified during
 clang build using CMake parameters, CLANG_CONFIG_FILE_USER_DIR and
-CLANG_CONFIG_FILE_SYSTEM_DIR respectively. The first file found is used. It is
-an error if the required file cannot be found.
+CLANG_CONFIG_FILE_SYSTEM_DIR respectively. They may be overridden using command
+line options `--config-user-dir='` and `--config-system-dir=`. The first file
+found is used. It is an error if the required file cannot be found.
 
 Another way to specify a configuration file is to encode it in executable name.
 For example, if the Clang executable is named `armv7l-clang` (it may be a
 symbolic link to `clang`), then Clang will search for file `armv7l.cfg` in the
 directory where Clang resides.
 
 If a driver mode is specified in invocation, Clang tries to find a file specific
 for the specified mode. For example, if the executable file is named
::
     # Long option split between lines
     -I/usr/lib/gcc/x86_64-linux-gnu/5.4.0/../../../../\
     include/c++/5.4.0
 
     # other config files may be included
     @linux.options
 
 Files included by `@file` directives in configuration files are resolved
-relative to the including file. For example, if a configuration file
+relative to the including file by default. For example, if a configuration file
 `~/.llvm/target.cfg` contains the directive `@os/linux.opts`, the file
 `linux.opts` is searched for in the directory `~/.llvm/os`.
 
+Option `--search-config-dirs` changes the search algorithm if the included
+file is specified without a directory separator. In this case the file is looked
+for in the same directories as configuration files. For example, if user and
+system configuration directories are `/user` and '/system`, both contain file
+`platform.cfg`, configuration file is in `/system` and it contains directive
+`@platform.cfg`, then the content of `/system/platform.cfg` is loaded by
+default, but with the option `--search-config-dirs` the content of
+`/user/platform.cfg` is used.
+
 To generate paths relative to the configuration file, the `<CFGDIR>` token may
 be used. This will expand to the absolute path of the directory containing the
 configuration file.
 
 In cases where a configuration file is deployed alongside SDK contents, the
 SDK directory can remain fully portable by using `<CFGDIR>` prefixed paths.
 In this way, the user may only need to specify a root configuration file with
 `--config` to establish every aspect of the SDK with the compiler:

clang/include/clang/Driver/Driver.h

 #include <map>
 #include <string>
 
 namespace llvm {
 class Triple;
 namespace vfs {
 class FileSystem;
 }
+namespace cl {
+class ExpansionContext;
+}
 } // namespace llvm
 
 namespace clang {
 
 namespace driver {
 
 typedef SmallVector<InputInfo, 4> InputInfoList;
 
private:
   ///
   /// \returns true if error occurred.
   bool loadConfigFile();
 
   /// Read options from the specified file.
   ///
   /// \param [in] FileName File to read.
   /// \returns true, if error occurred while reading.
-  bool readConfigFile(StringRef FileName);
+  bool readConfigFile(StringRef FileName, llvm::cl::ExpansionContext &ECtx);
 
   /// Set the driver mode (cl, gcc, etc) from the value of the `--driver-mode`
   /// option.
   void setDriverMode(StringRef DriverModeValue);
 
   /// Parse the \p Args list for LTO options and record the type of LTO
   /// compilation based on which -f(no-)?lto(=.*)? option occurs last.
   void setLTOMode(const llvm::opt::ArgList &Args);

clang/include/clang/Driver/Options.td

HelpText<"OpenCL only. Enable or disable OpenCL extensions/optional features. The argument is a comma-separated "
            "sequence of one or more extension names, each prefixed by '+' or '-'.">,
   MarshallingInfoStringVector<TargetOpts<"OpenCLExtensionsAsWritten">>;
 
 def client__name : JoinedOrSeparate<["-"], "client_name">;
 def combine : Flag<["-", "--"], "combine">, Flags<[NoXarchOption, Unsupported]>;
 def compatibility__version : JoinedOrSeparate<["-"], "compatibility_version">;
 def config : Separate<["--"], "config">, Flags<[NoXarchOption]>,
   HelpText<"Specifies configuration file">;
-def config_system_dir_EQ : Joined<["--"], "config-system-dir=">, Flags<[NoXarchOption, HelpHidden]>,
+def config_system_dir_EQ : Joined<["--"], "config-system-dir=">, Flags<[NoXarchOption]>,
   HelpText<"System directory for configuration files">;
-def config_user_dir_EQ : Joined<["--"], "config-user-dir=">, Flags<[NoXarchOption, HelpHidden]>,
+def config_user_dir_EQ : Joined<["--"], "config-user-dir=">, Flags<[NoXarchOption]>,
   HelpText<"User directory for configuration files">;
+def search_config_dirs : Flag<["--"], "search-config-dirs">, Flags<[NoXarchOption]>,
+  HelpText<"Search for files included by configuration file is search directories">;
 def coverage : Flag<["-", "--"], "coverage">, Group<Link_Group>, Flags<[CoreOption]>;
 def cpp_precomp : Flag<["-"], "cpp-precomp">, Group<clang_ignored_f_Group>;
 def current__version : JoinedOrSeparate<["-"], "current_version">;
 def cxx_isystem : JoinedOrSeparate<["-"], "cxx-isystem">, Group<clang_i_Group>,
   HelpText<"Add directory to the C++ SYSTEM include search path">, Flags<[CC1Option]>,
   MetaVarName<"<directory>">;
 def c : Flag<["-"], "c">, Flags<[NoXarchOption, FlangOption]>, Group<Action_Group>,
   HelpText<"Only run preprocess, compile, and assemble steps">;

clang/lib/Driver/Driver.cpp

if (IsOpenMPOffloading) {
     return;
   }
 
   //
   // TODO: Add support for other offloading programming models here.
   //
 }
 
-/// Looks the given directories for the specified file.
-///
-/// \param[out] FilePath File path, if the file was found.
-/// \param[in]  Dirs Directories used for the search.
-/// \param[in]  FileName Name of the file to search for.
-/// \return True if file was found.
-///
-/// Looks for file specified by FileName sequentially in directories specified
-/// by Dirs.
-///
-static bool searchForFile(SmallVectorImpl<char> &FilePath,
-                          ArrayRef<StringRef> Dirs, StringRef FileName,
-                          llvm::vfs::FileSystem &FS) {
-  SmallString<128> WPath;
-  for (const StringRef &Dir : Dirs) {
-    if (Dir.empty())
-      continue;
-    WPath.clear();
-    llvm::sys::path::append(WPath, Dir, FileName);
-    llvm::sys::path::native(WPath);
-    auto Status = FS.status(WPath);
-    if (Status && Status->getType() == llvm::sys::fs::file_type::regular_file) {
-      FilePath = std::move(WPath);
-      return true;
-    }
-  }
-  return false;
-}
-
-bool Driver::readConfigFile(StringRef FileName) {
+bool Driver::readConfigFile(StringRef FileName,
+                            llvm::cl::ExpansionContext &ECtx) {
   // Try reading the given file.
   SmallVector<const char *, 32> NewCfgArgs;
-  llvm::cl::ExpansionContext ExpCtx(Saver, llvm::cl::tokenizeConfigFile, &getVFS());
-  if (!ExpCtx.readConfigFile(FileName, NewCfgArgs)) {
+  if (!ECtx.readConfigFile(FileName, NewCfgArgs)) {
     Diag(diag::err_drv_cannot_read_config_file) << FileName;
     return true;
   }
 
   // Read options from config file.
   llvm::SmallString<128> CfgFileName(FileName);
   llvm::sys::path::native(CfgFileName);
   ConfigFile = std::string(CfgFileName);
bool Driver::readConfigFile(StringRef FileName,
   for (Arg *A : *CfgOptions)
     A->claim();
   return false;
 }
 
 bool Driver::loadConfigFile() {
   std::string CfgFileName;
   bool FileSpecifiedExplicitly = false;
+  llvm::cl::ExpansionContext ExpCtx(Saver, llvm::cl::tokenizeConfigFile,
+                                    &getVFS());
 
   // Process options that change search path for config files.
   if (CLOptions) {
     if (CLOptions->hasArg(options::OPT_config_system_dir_EQ)) {
       SmallString<128> CfgDir;
       CfgDir.append(
           CLOptions->getLastArgValue(options::OPT_config_system_dir_EQ));
       if (CfgDir.empty() || getVFS().makeAbsolute(CfgDir))
         SystemConfigDir.clear();
       else
         SystemConfigDir = static_cast<std::string>(CfgDir);
     }
     if (CLOptions->hasArg(options::OPT_config_user_dir_EQ)) {
       SmallString<128> CfgDir;
       CfgDir.append(
           CLOptions->getLastArgValue(options::OPT_config_user_dir_EQ));
       if (CfgDir.empty() || getVFS().makeAbsolute(CfgDir))
         UserConfigDir.clear();
       else
         UserConfigDir = static_cast<std::string>(CfgDir);
     }
+    if (CLOptions->hasArg(options::OPT_search_config_dirs))
+      ExpCtx.setSearchAsConfig(true);
   }
 
   // First try to find config file specified in command line.
   if (CLOptions) {
     std::vector<std::string> ConfigFiles =
         CLOptions->getAllArgValues(options::OPT_config);
     if (ConfigFiles.size() > 1) {
       if (!llvm::all_equal(ConfigFiles)) {
if (!ConfigFiles.empty()) {
             return true;
           auto Status = getVFS().status(CfgFilePath);
           if (!Status ||
               Status->getType() != llvm::sys::fs::file_type::regular_file) {
             Diag(diag::err_drv_config_file_not_exist) << CfgFilePath;
             return true;
           }
         }
-        return readConfigFile(CfgFilePath);
+        return readConfigFile(CfgFilePath, ExpCtx);
       }
 
       FileSpecifiedExplicitly = true;
     }
   }
 
   // If config file is not specified explicitly, try to deduce configuration
   // from executable name. For instance, an executable 'armv7l-clang' will
if (CfgTriple.getArch() != EffectiveTriple.getArch()) {
       // like: i386-clang.cfg -> x86_64-clang.cfg.
       if (ArchPrefixLen < CfgFileName.size())
         FixedConfigFile += CfgFileName.substr(ArchPrefixLen);
     }
   }
 
   // Prepare list of directories where config file is searched for.
   StringRef CfgFileSearchDirs[] = {UserConfigDir, SystemConfigDir, Dir};
+  ExpCtx.setSearchDirs(CfgFileSearchDirs);
 
   // Try to find config file. First try file with corrected architecture.
-  llvm::SmallString<128> CfgFilePath;
+  std::string CfgFilePath;
   if (!FixedConfigFile.empty()) {
-    if (searchForFile(CfgFilePath, CfgFileSearchDirs, FixedConfigFile,
-                      getVFS()))
-      return readConfigFile(CfgFilePath);
+    if (ExpCtx.findConfigFile(FixedConfigFile, CfgFilePath))
+      return readConfigFile(CfgFilePath, ExpCtx);
     // If 'x86_64-clang.cfg' was not found, try 'x86_64.cfg'.
     FixedConfigFile.resize(FixedArchPrefixLen);
     FixedConfigFile.append(".cfg");
-    if (searchForFile(CfgFilePath, CfgFileSearchDirs, FixedConfigFile,
-                      getVFS()))
-      return readConfigFile(CfgFilePath);
+    if (ExpCtx.findConfigFile(FixedConfigFile, CfgFilePath))
+      return readConfigFile(CfgFilePath, ExpCtx);
   }
 
   // Then try original file name.
-  if (searchForFile(CfgFilePath, CfgFileSearchDirs, CfgFileName, getVFS()))
-    return readConfigFile(CfgFilePath);
+  if (ExpCtx.findConfigFile(CfgFileName, CfgFilePath))
+    return readConfigFile(CfgFilePath, ExpCtx);
 
   // Finally try removing driver mode part: 'x86_64-clang.cfg' -> 'x86_64.cfg'.
   if (!ClangNameParts.ModeSuffix.empty() &&
       !ClangNameParts.TargetPrefix.empty()) {
     CfgFileName.assign(ClangNameParts.TargetPrefix);
     CfgFileName.append(".cfg");
-    if (searchForFile(CfgFilePath, CfgFileSearchDirs, CfgFileName, getVFS()))
-      return readConfigFile(CfgFilePath);
+    if (ExpCtx.findConfigFile(CfgFileName, CfgFilePath))
+      return readConfigFile(CfgFilePath, ExpCtx);
   }
 
   // Report error but only if config file was specified explicitly, by option
   // --config. If it was deduced from executable name, it is not an error.
   if (FileSpecifiedExplicitly) {
     Diag(diag::err_drv_config_file_not_found) << CfgFileName;
     for (const StringRef &SearchDir : CfgFileSearchDirs)
       if (!SearchDir.empty())
if (Opt->isClaimed())
       Copy->claim();
     Copy->setOwnsValues(Opt->getOwnsValues());
     Opt->setOwnsValues(false);
     Args.append(Copy);
   };
 
   if (HasConfigFile)
     for (auto *Opt : *CLOptions) {
-      if (Opt->getOption().matches(options::OPT_config))
+      if (Opt->getOption().matches(options::OPT_config) ||
+          Opt->getOption().matches(options::OPT_search_config_dirs))
         continue;
       const Arg *BaseArg = &Opt->getBaseArg();
       if (BaseArg == Opt)
         BaseArg = nullptr;
       appendOneArg(Opt, BaseArg);
     }
 
   // In CL mode, look for any pass-through arguments

clang/test/Driver/Inputs/config/config-3.cfg

+-isysroot /opt/sdk/user

clang/test/Driver/config-file.c

 // RUN: %clang --config-system-dir=%S/Inputs --config-user-dir= --config config-1.cfg -S %s -o /dev/null -v 2>&1 | FileCheck %s -check-prefix CHECK-V2
 // CHECK-V2: Configuration file: {{.*}}Inputs{{.}}config-1.cfg
 // CHECK-V2: -Werror
 // CHECK-V2: -std=c99
 
 
 //--- Nested config files
 //
-// RUN: %clang --config-system-dir=%S/Inputs --config-user-dir= --config config-2.cfg -S %s -### 2>&1 | FileCheck %s -check-prefix CHECK-NESTED
+// RUN: %clang --config-system-dir=%S/Inputs --config-user-dir=%S/Inputs/config --config config-2.cfg -S %s -### 2>&1 | FileCheck %s -check-prefix CHECK-NESTED
 // CHECK-NESTED: Configuration file: {{.*}}Inputs{{.}}config-2.cfg
 // CHECK-NESTED: -Wundefined-func-template
 
-// RUN: %clang --config-system-dir=%S/Inputs --config-user-dir= --config config-2.cfg -S %s -### 2>&1 | FileCheck %s -check-prefix CHECK-NESTED2
+// RUN: %clang --config-system-dir=%S/Inputs --config-user-dir=%S/Inputs/config --config config-2.cfg -S --search-config-dirs %s -### 2>&1 | FileCheck %s -check-prefix CHECK-NESTED2
 // CHECK-NESTED2: Configuration file: {{.*}}Inputs{{.}}config-2.cfg
-// CHECK-NESTED2: -Wundefined-func-template
-
+// CHECK-NESTED2: -isysroot
+// CHECK-NESTED2-SAME: /opt/sdk/user
 
 // RUN: %clang --config %S/Inputs/config-2a.cfg -S %s -### 2>&1 | FileCheck %s -check-prefix CHECK-NESTEDa
 // CHECK-NESTEDa: Configuration file: {{.*}}Inputs{{.}}config-2a.cfg
 // CHECK-NESTEDa: -isysroot
 // CHECK-NESTEDa-SAME: /opt/data
 
 // RUN: %clang --config-system-dir=%S/Inputs --config-user-dir= --config config-2a.cfg -S %s -### 2>&1 | FileCheck %s -check-prefix CHECK-NESTED2a
 // CHECK-NESTED2a: Configuration file: {{.*}}Inputs{{.}}config-2a.cfg

clang/unittests/Driver/ToolChainTest.cpp

FS->addFile(
       llvm::MemoryBuffer::getMemBuffer("--sysroot=/opt/sdk/platform0\n"));
   FS->addFile(
       "/home/test/sdk/root.cfg", 0,
       llvm::MemoryBuffer::getMemBuffer("--sysroot=/opt/sdk/platform1\n"));
   FS->addFile(
       "/home/test/bin/root.cfg", 0,
       llvm::MemoryBuffer::getMemBuffer("--sysroot=/opt/sdk/platform2\n"));
 
+  SmallString<128> ClangExecutable("/home/test/bin/clang");
+  FS->makeAbsolute(ClangExecutable);
+
   {
-    Driver TheDriver("/home/test/bin/clang", "arm-linux-gnueabi", Diags,
+    Driver TheDriver(ClangExecutable, "arm-linux-gnueabi", Diags,
                      "clang LLVM compiler", FS);
     std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
         {"/home/test/bin/clang", "--config", "root.cfg",
          "--config-system-dir=/opt/sdk", "--config-user-dir=/home/test/sdk"}));
     ASSERT_TRUE(C);
     ASSERT_FALSE(C->containsError());
     EXPECT_EQ("/opt/sdk/platform1", TheDriver.SysRoot);
   }
   {
-    Driver TheDriver("/home/test/bin/clang", "arm-linux-gnueabi", Diags,
+    Driver TheDriver(ClangExecutable, "arm-linux-gnueabi", Diags,
                      "clang LLVM compiler", FS);
     std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
         {"/home/test/bin/clang", "--config", "root.cfg",
          "--config-system-dir=/opt/sdk", "--config-user-dir="}));
     ASSERT_TRUE(C);
     ASSERT_FALSE(C->containsError());
     EXPECT_EQ("/opt/sdk/platform0", TheDriver.SysRoot);
   }
   {
-    Driver TheDriver("/home/test/bin/clang", "arm-linux-gnueabi", Diags,
+    Driver TheDriver(ClangExecutable, "arm-linux-gnueabi", Diags,
                      "clang LLVM compiler", FS);
     std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
         {"/home/test/bin/clang", "--config", "root.cfg",
          "--config-system-dir=", "--config-user-dir="}));
     ASSERT_TRUE(C);
     ASSERT_FALSE(C->containsError());
     EXPECT_EQ("/opt/sdk/platform2", TheDriver.SysRoot);
   }
 }
 
+TEST(ToolChainTest, ConfigFileSearch2) {
+  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  struct TestDiagnosticConsumer : public DiagnosticConsumer {};
+  DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
+  IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> FS(
+      new llvm::vfs::InMemoryFileSystem);
+
+#ifdef _WIN32
+  const char *TestRoot = "C:\\";
+#else
+  const char *TestRoot = "/";
+#endif
+  FS->setCurrentWorkingDirectory(TestRoot);
+
+  FS->addFile("/opt/sdk/root.cfg", 0,
+              llvm::MemoryBuffer::getMemBuffer("@platform.cfg\n"));
+  FS->addFile("/opt/sdk/root2.cfg", 0,
+              llvm::MemoryBuffer::getMemBuffer("@platform.cfg\n"
+                                               "--search-config-dirs\n"));
+  FS->addFile("/opt/sdk/platform.cfg", 0,
+              llvm::MemoryBuffer::getMemBuffer("--sysroot=/platform-sys\n"));
+  FS->addFile("/home/test/sdk/platform.cfg", 0,
+              llvm::MemoryBuffer::getMemBuffer("--sysroot=/platform-user\n"));
+  FS->addFile("/home/test/bin/platform.cfg", 0,
+              llvm::MemoryBuffer::getMemBuffer("--sysroot=/platform-bin\n"));
+
+  SmallString<128> ClangExecutable("/home/test/bin/clang");
+  FS->makeAbsolute(ClangExecutable);
+
+  {
+    // Without '--search-config-dirs' included file is searched for in the same
+    // directory where including file is resided.
+    Driver TheDriver(ClangExecutable, "arm-linux-gnueabi", Diags,
+                     "clang LLVM compiler", FS);
+    std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
+        {"/home/test/bin/clang", "--config", "root.cfg",
+         "--config-system-dir=/opt/sdk", "--config-user-dir=/home/test/sdk"}));
+    ASSERT_TRUE(C);
+    ASSERT_FALSE(C->containsError());
+    EXPECT_EQ("/platform-sys", TheDriver.SysRoot);
+  }
+
+  {
+    // With '--search-config-dirs' included file is searched for in the same
+    // directories as config files, so the file in user directory is found.
+    Driver TheDriver(ClangExecutable, "arm-linux-gnueabi", Diags,
+                     "clang LLVM compiler", FS);
+    std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
+        {"/home/test/bin/clang", "--config", "root.cfg",
+         "--config-system-dir=/opt/sdk", "--config-user-dir=/home/test/sdk",
+         "--search-config-dirs"}));
+    ASSERT_TRUE(C);
+    ASSERT_FALSE(C->containsError());
+    EXPECT_EQ("/platform-user", TheDriver.SysRoot);
+  }
+
+  {
+    // The option '--search-config-dirs' can be specified inside configuration
+    // file.
+    Driver TheDriver(ClangExecutable, "arm-linux-gnueabi", Diags,
+                     "clang LLVM compiler", FS);
+    std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
+        {"/home/test/bin/clang", "--config", "root2.cfg",
+         "--config-system-dir=/opt/sdk", "--config-user-dir=/home/test/sdk"}));
+    ASSERT_TRUE(C);
+    ASSERT_FALSE(C->containsError());
+    EXPECT_EQ("/platform-user", TheDriver.SysRoot);
+  }
+}
+
+TEST(ToolChainTest, ConfigFileSearch3) {
+  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  struct TestDiagnosticConsumer : public DiagnosticConsumer {};
+  DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
+  IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> FS(
+      new llvm::vfs::InMemoryFileSystem);
+
+#ifdef _WIN32
+  const char *TestRoot = "C:\\";
+#else
+  const char *TestRoot = "/";
+#endif
+  FS->setCurrentWorkingDirectory(TestRoot);
+
+  SmallString<128> ClangExecutable("/opt/sdk/bin/clang");
+  FS->makeAbsolute(ClangExecutable);
+
+  // Configuration file is loaded from system directory, it includes file
+  // from binary one.
+  FS->addFile("/opt/sdk/root.cfg", 0,
+              llvm::MemoryBuffer::getMemBuffer("--search-config-dirs\n"
+                                               "@workspace.cfg\n"));
+  FS->addFile("/opt/sdk/bin/workspace.cfg", 0,
+              llvm::MemoryBuffer::getMemBuffer("--sysroot=/settings-bin\n"));
+
+  {
+    Driver TheDriver(ClangExecutable, "arm-linux-gnueabi", Diags,
+                     "clang LLVM compiler", FS);
+    std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
+        {ClangExecutable.c_str(), "--config", "root.cfg",
+         "--config-system-dir=/opt/sdk", "--config-user-dir=/home/test/sdk"}));
+    ASSERT_TRUE(C);
+    ASSERT_FALSE(C->containsError());
+    EXPECT_EQ("/settings-bin", TheDriver.SysRoot);
+  }
+
+  // User can override included file by providing file with the same name in
+  // the user directory.
+  FS->addFile("/home/test/sdk/workspace.cfg", 0,
+              llvm::MemoryBuffer::getMemBuffer("--sysroot=/settings-user\n"));
+
+  {
+    Driver TheDriver(ClangExecutable, "arm-linux-gnueabi", Diags,
+                     "clang LLVM compiler", FS);
+    std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
+        {ClangExecutable.c_str(), "--config", "root.cfg",
+         "--config-system-dir=/opt/sdk", "--config-user-dir=/home/test/sdk"}));
+    ASSERT_TRUE(C);
+    ASSERT_FALSE(C->containsError());
+    EXPECT_EQ("/settings-user", TheDriver.SysRoot);
+  }
+}
+
 } // end anonymous namespace.

llvm/include/llvm/Support/CommandLine.h

class ExpansionContext {
 
   /// File system used for all file access when running the expansion.
   llvm::vfs::FileSystem *FS;
 
   /// Path used to resolve relative rsp files. If empty, the file system
   /// current directory is used instead.
   StringRef CurrentDir;
 
+  /// Directories used for search of config files.
+  ArrayRef<StringRef> SearchDirs;
+
   /// True if names of nested response files must be resolved relative to
   /// including file.
   bool RelativeNames = false;
 
   /// If true, mark end of lines and the end of the response file with nullptrs
   /// in the Argv vector.
   bool MarkEOLs = false;
 
   /// If true, body of config file is expanded.
   bool InConfigFile = false;
 
+  /// If true, the file included by '@file' is searched for as a config file, in
+  /// the config search directories.
+  bool SearchAsConfig = false;
+
   llvm::Error expandResponseFile(StringRef FName,
                                  SmallVectorImpl<const char *> &NewArgv);
 
 public:
   ExpansionContext(StringSaver &S, TokenizerCallback T,
                    llvm::vfs::FileSystem *FS = nullptr);
 
   ExpansionContext &setMarkEOLs(bool X) {
     MarkEOLs = X;
     return *this;
   }
 
   ExpansionContext &setRelativeNames(bool X) {
     RelativeNames = X;
     return *this;
   }
 
   ExpansionContext &setCurrentDir(StringRef X) {
     CurrentDir = X;
     return *this;
   }
 
+  ArrayRef<StringRef> getSearchDirs() const { return SearchDirs; }
+  ExpansionContext &setSearchDirs(ArrayRef<StringRef> X) {
+    SearchDirs = X;
+    return *this;
+  }
+
+  bool getSearchAsConfig() const { return SearchAsConfig; }
+  ExpansionContext &setSearchAsConfig(bool X) {
+    SearchAsConfig = X;
+    return *this;
+  }
+
+  /// Looks for the specified configuration file.
+  ///
+  /// \param[in]  FileName Name of the file to search for.
+  /// \param[out] FilePath File absolute path, if it was found.
+  /// \return True if file was found.
+  ///
+  /// If the specified file name contains a directory separator, it is searched
+  /// for by its absolute path. Otherwise looks for file sequentially in
+  /// directories specified by SearchDirs field.
+  bool findConfigFile(StringRef FileName, std::string &FilePath);
+
   /// Reads command line options from the given configuration file.
   ///
   /// \param [in] CfgFile Path to configuration file.
   /// \param [out] Argv Array to which the read options are added.
   /// \return true if the file was successfully read.
   ///
   /// It reads content of the specified file, tokenizes it and expands "@file"
   /// commands resolving file names in them relative to the directory where

llvm/lib/Support/CommandLine.cpp

ExpansionContext::expandResponseFile(StringRef FName,
   else if (hasUTF8ByteOrderMark(BufRef))
     Str = StringRef(BufRef.data() + 3, BufRef.size() - 3);
 
   // Tokenize the contents into NewArgv.
   Tokenizer(Str, Saver, NewArgv, MarkEOLs);
 
   if (!RelativeNames)
     return Error::success();
+
+  if (InConfigFile &&
+      std::find_if(NewArgv.begin(), NewArgv.end(), [](const char *Arg) -> bool {
+        return StringRef("--search-config-dirs") == Arg;
+      }) != NewArgv.end())
+    setSearchAsConfig(true);
+
   llvm::StringRef BasePath = llvm::sys::path::parent_path(FName);
   // If names of nested response files should be resolved relative to including
   // file, replace the included response file names with their full paths
   // obtained by required resolution.
   for (auto &Arg : NewArgv) {
     if (!Arg)
       continue;
 
     // Substitute <CFGDIR> with the file's base path.
     if (InConfigFile)
       ExpandBasePaths(BasePath, Saver, Arg);
 
     // Skip non-rsp file arguments.
     if (Arg[0] != '@')
       continue;
 
     StringRef FileName(Arg + 1);
     // Skip if non-relative.
     if (!llvm::sys::path::is_relative(FileName))
       continue;
 
     SmallString<128> ResponseFile;
     ResponseFile.push_back('@');
+    if (SearchAsConfig) {
+      std::string FilePath;
+      if (!findConfigFile(FileName, FilePath))
+        return llvm::createStringError(
+            std::make_error_code(std::errc::no_such_file_or_directory),
+            "Could not find config file: " + FileName);
+      ResponseFile.append(FilePath);
+    } else {
       ResponseFile.append(BasePath);
       llvm::sys::path::append(ResponseFile, FileName);
+    }
     Arg = Saver.save(ResponseFile.str()).data();
   }
   return Error::success();
 }
 
 /// Expand response files on a command line recursively using the given
 /// StringSaver and tokenization strategy.
 bool ExpansionContext::expandResponseFiles(SmallVectorImpl<const char *> &Argv) {
bool cl::expandResponseFiles(int Argc, const char *const *Argv,
   ExpansionContext ECtx(Saver, Tokenize);
   return ECtx.expandResponseFiles(NewArgv);
 }
 
 ExpansionContext::ExpansionContext(StringSaver &S, TokenizerCallback T,
                                    llvm::vfs::FileSystem *FS)
     : Saver(S), Tokenizer(T), FS(FS ? FS : vfs::getRealFileSystem().get()) {}
 
-bool ExpansionContext::readConfigFile(StringRef CfgFile,
-                                      SmallVectorImpl<const char *> &Argv) {
-  SmallString<128> AbsPath;
-  if (sys::path::is_relative(CfgFile)) {
-    AbsPath.assign(CfgFile);
-    if (std::error_code EC = FS->makeAbsolute(AbsPath))
-      return false;
-    CfgFile = AbsPath.str();
-  }
+bool ExpansionContext::findConfigFile(StringRef FileName,
+                                      std::string &FilePath) {
+  SmallString<128> CfgFilePath;
+  const auto FileExists = [this](SmallString<128> Path) -> bool {
+    auto Status = FS->status(Path);
+    return Status &&
+           Status->getType() == llvm::sys::fs::file_type::regular_file;
+  };
+
+  // If file name contains directory separator, treat it as a path to
+  // configuration file.
+  if (llvm::sys::path::has_parent_path(FileName)) {
+    CfgFilePath = FileName;
+    if (llvm::sys::path::is_relative(FileName) && FS->makeAbsolute(CfgFilePath))
+      return false;
+    if (!FileExists(CfgFilePath))
+      return false;
+    FilePath = CfgFilePath.str();
+    return true;
+  }
+
+  // Look for the file in search directories.
+  for (const StringRef &Dir : SearchDirs) {
+    if (Dir.empty())
+      continue;
+    CfgFilePath.assign(Dir);
+    llvm::sys::path::append(CfgFilePath, FileName);
+    llvm::sys::path::native(CfgFilePath);
+    if (FileExists(CfgFilePath)) {
+      FilePath = CfgFilePath.str();
+      return true;
+    }
+  }
+
+
+bool ExpansionContext::readConfigFile(StringRef CfgFile,
+                                      SmallVectorImpl<const char *> &Argv) {
+  assert(llvm::sys::path::is_absolute(CfgFile));
   InConfigFile = true;
   RelativeNames = true;
   if (llvm::Error Err = expandResponseFile(CfgFile, Argv)) {
     // TODO: The error should be propagated up the stack.
     llvm::consumeError(std::move(Err));
     return false;
   }
   return expandResponseFiles(Argv);