Response files for GCC maybe stands in the way of our rpath wrapper script functioning

[Micket]

GCC and such supports response files, which looks like this

gcc @foo.rsp

where foo.rsp is just a textfile with many many flags

-o foo -lfoo -blablabla -asdf -sdfg -dfgh

Ninja was going this for me automatically i think when i was building QEMU (which have such long link lines it requires the use of a file, ~45k characters long).

It think this breaks linking for us with the rpath_wrappers, but I'm not 100% sure how it works out, other than that QEMU didn't end up using RPATH when linking, instead it used RUNPATH (which is kind of better?) by itself, so it still is OK.

[Thyre]

Those files are also referenced as @file by GCC, and are understood by basically any compiler. We ran into this with our Score-P instrumentation wrapper as well, but haven't developed a solution for this yet.

Here is a bit more documentation though:

From the GCC documentation:

@file
      Read command-line options from file.  The options read are inserted
      in place of the original @file option.  If file does not exist, or
      cannot be read, then the option will be treated literally, and not
      removed.

      Options in file are separated by whitespace.  A whitespace
      character may be included in an option by surrounding the entire
      option in either single or double quotes.  Any character (including
      a backslash) may be included by prefixing the character to be
      included with a backslash.  The file may itself contain additional
      @file options; any such options will be processed recursively.

I saw this with Hypre as well, where three files were used by CMake during the linking process:

• includes_CUDA.rsp
• objects1.rsp
• linkLibs.rsp

CUDA supports this as well, with nvcc using --options-file [file]: https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html#options-file-file-optf

---

One important thing to keep in mind is that these files cannot be nested indefinitely, but the maximum depth is implementation defined. This may cause a bit of headache.