[Driver] Add verbatim dry run option

[smeenai]

Summary

When writing driver tests, it's useful to have a way to output arguments
verbatim (i.e. without any quoting and escaping). For example, on
Windows today, the installation directory is output without backslashes
being escaped, but any -internal-isystem arguments passed by the driver
to the frontend will have backslashes escaped in the -### output, making
it impossible to write a FileCheck match against the installation
directory. Add a new argument to avoid any quoting and escaping to ease
driver testing. Make this argument output to stdout instead of stderr to
avoid needing 2>&1 in all the driver tests.

[smeenai]

I'm not tied to the name -###-verbatim and am open to suggestions if anyone can think of something better.

My troll suggestion was -####, but @compnerd didn't like that for some reason...

[smeenai]

Output to stdout

[compnerd]

clang/include/clang/Driver/Options.td

333

What about -print-raw-commands?

[phosek]

I'm fine with -###-verbatim.

[MaskRay]

One thing I (a zsh user) feel inconvenient about -### is that.......

% echo -###
zsh: bad pattern: -###
% echo '-###'
-###

clang/include/clang/Driver/Job.h

class Command {
   /// will escape the regular backslashes (used in Windows paths) and quotes.
   /// The results are the contents of a response file, written into a raw_ostream.
   void writeResponseFile(raw_ostream &OS) const;
 
 public:
   enum class PrintingMode {
     AlwaysQuote,
     QuoteIfNeeded,
+    Verbatim,
   };
 
   Command(const Action &Source, const Tool &Creator, const char *Executable,
           const llvm::opt::ArgStringList &Arguments,
           ArrayRef<InputInfo> Inputs);
   // FIXME: This really shouldn't be copyable, but is currently copied in some
   // error handling in Driver::generateCompilationDiagnostics.
   Command(const Command &) = default;

clang/include/clang/Driver/Options.td

 
 // Make sure all other -ccc- options are rejected.
 def ccc_ : Joined<["-"], "ccc-">, Group<internal_Group>, Flags<[Unsupported]>;
 
 // Standard Options
 
 def _HASH_HASH_HASH : Flag<["-"], "###">, Flags<[DriverOption, CoreOption]>,
     HelpText<"Print (but do not run) the commands to run for this compilation">;
+def _HASH_HASH_HASH_VERBATIM : Flag<["-"], "###-verbatim">,
+    Flags<[DriverOption, CoreOption]>,
+    HelpText<"Print (but do not run) the commands to run for this compilation, "
+             "unquoted and unescaped">;
 def _DASH_DASH : Option<["--"], "", KIND_REMAINING_ARGS>,
     Flags<[DriverOption, CoreOption]>;
 def A : JoinedOrSeparate<["-"], "A">, Flags<[RenderJoined]>, Group<gfortran_Group>;
 def B : JoinedOrSeparate<["-"], "B">, MetaVarName<"<dir>">,
     HelpText<"Add <dir> to search path for binaries and object files used implicitly">;
 def CC : Flag<["-"], "CC">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
     HelpText<"Include comments from within macros in preprocessed output">;
 def C : Flag<["-"], "C">, Flags<[CC1Option]>, Group<Preprocessor_Group>,

clang/lib/Driver/Driver.cpp

int Driver::ExecuteCompilation(
     Compilation &C,
     SmallVectorImpl<std::pair<int, const Command *>> &FailingCommands) {
   // Just print if -### was present.
   if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
     C.getJobs().Print(llvm::errs(), "\n", Command::PrintingMode::AlwaysQuote);
     return 0;
   }
 
+  // Just print verbatim if -###-verbatim was present.
+  if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH_VERBATIM)) {
+    C.getJobs().Print(llvm::outs(), "\n", Command::PrintingMode::Verbatim);
+    return 0;
+  }
+
   // If there were errors building the compilation, quit now.
   if (Diags.hasErrorOccurred())
     return 1;
 
   // Set up response file names for each command, if necessary
   for (auto &Job : C.getJobs())
     setUpResponseFiles(C, Job);
 
bool Driver::HandleImmediateArgs(const Compilation &C) {
 
   if (C.getArgs().hasArg(options::OPT_v) ||
       C.getArgs().hasArg(options::OPT__HASH_HASH_HASH) ||
       C.getArgs().hasArg(options::OPT_print_supported_cpus)) {
     PrintVersion(C, llvm::errs());
     SuppressMissingInputWarning = true;
   }
 
+  if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH_VERBATIM)) {
+    PrintVersion(C, llvm::outs());
+    SuppressMissingInputWarning = true;
+  }
+
   if (C.getArgs().hasArg(options::OPT_v)) {
     if (!SystemConfigDir.empty())
       llvm::errs() << "System configuration file directory: "
                    << SystemConfigDir << "\n";
     if (!UserConfigDir.empty())
       llvm::errs() << "User configuration file directory: "
                    << UserConfigDir << "\n";
   }
void Driver::BuildJobs(Compilation &C) const {
   }
 
   // If the user passed -Qunused-arguments or there were errors, don't warn
   // about any unused arguments.
   if (Diags.hasErrorOccurred() ||
       C.getArgs().hasArg(options::OPT_Qunused_arguments))
     return;
 
-  // Claim -### here.
+  // Claim -### and -###-verbatim here.
   (void)C.getArgs().hasArg(options::OPT__HASH_HASH_HASH);
+  (void)C.getArgs().hasArg(options::OPT__HASH_HASH_HASH_VERBATIM);
 
   // Claim --driver-mode, --rsp-quoting, it was handled earlier.
   (void)C.getArgs().hasArg(options::OPT_driver_mode);
   (void)C.getArgs().hasArg(options::OPT_rsp_quoting);
 
   for (Arg *A : C.getArgs()) {
     // FIXME: It would be nice to be able to send the argument to the
     // DiagnosticsEngine, so that extra values, position, and so on could be

clang/lib/Driver/Job.cpp

static bool skipArgs(const char *Flag, bool HaveCrashVFS, int &SkipNum,
 
   SkipNum = 0;
   return false;
 }
 
 void Command::printArg(raw_ostream &OS, StringRef Arg, PrintingMode Mode) {
   const bool Escape = Arg.find_first_of(" \"\\$") != StringRef::npos;
 
-  if (Mode == PrintingMode::QuoteIfNeeded && !Escape) {
+  if (Mode == PrintingMode::Verbatim ||
+      (Mode == PrintingMode::QuoteIfNeeded && !Escape)) {
     OS << Arg;
     return;
   }
 
   // Quote and escape. This isn't really complete, but good enough.
   OS << '"';
   for (const auto c : Arg) {
     if (c == '"' || c == '\\' || c == '$')
rewriteIncludes(const llvm::ArrayRef<const char *> &Args, size_t Idx,
   if (!getAbsPath(Inc, NewInc))
     return;
   IncFlags.push_back(SmallString<128>(Args[Idx]));
   IncFlags.push_back(std::move(NewInc));
 }
 
 void Command::Print(raw_ostream &OS, const char *Terminator, PrintingMode Mode,
                     CrashReportInfo *CrashInfo) const {
-  // Always quote the exe.
+  // Always quote the exe unless printing verbatim.
   OS << ' ';
-  printArg(OS, Executable, PrintingMode::AlwaysQuote);
+  printArg(OS, Executable,
+           Mode == PrintingMode::Verbatim ? PrintingMode::Verbatim
+                                          : PrintingMode::AlwaysQuote);
 
   ArrayRef<const char *> Args = Arguments;
   SmallVector<const char *, 128> ArgsRespFile;
   if (ResponseFile != nullptr) {
     buildArgvForResponseFile(ArgsRespFile);
     Args = ArrayRef<const char *>(ArgsRespFile).slice(1); // no executable name
   }
 

clang/lib/Driver/ToolChains/Clang.cpp

if (!Args.hasArg(options::OPT_fvisibility_EQ,
     CmdArgs.push_back("hidden");
   }
 }
 
 void Clang::DumpCompilationDatabase(Compilation &C, StringRef Filename,
                                     StringRef Target, const InputInfo &Output,
                                     const InputInfo &Input, const ArgList &Args) const {
   // If this is a dry run, do not create the compilation database file.
-  if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
+  if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH) ||
+      C.getArgs().hasArg(options::OPT__HASH_HASH_HASH_VERBATIM))
     return;
 
   using llvm::yaml::escape;
   const Driver &D = getToolChain().getDriver();
 
   if (!CompilationDatabase) {
     std::error_code EC;
     auto File = llvm::make_unique<llvm::raw_fd_ostream>(Filename, EC,

clang/lib/Driver/ToolChains/CommonArgs.cpp

void tools::AddOpenMPLinkerScript(const ToolChain &TC, Compilation &C,
   LksStream.flush();
 
   // Dump the contents of the linker script if the user requested that. We
   // support this option to enable testing of behavior with -###.
   if (C.getArgs().hasArg(options::OPT_fopenmp_dump_offload_linker_script))
     llvm::errs() << LksBuffer;
 
   // If this is a dry run, do not create the linker script file.
-  if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
+  if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH) ||
+      C.getArgs().hasArg(options::OPT__HASH_HASH_HASH_VERBATIM))
     return;
 
   // Open script file and write the contents.
   std::error_code EC;
   llvm::raw_fd_ostream Lksf(LKS, EC, llvm::sys::fs::OF_None);
 
   if (EC) {
     C.getDriver().Diag(clang::diag::err_unable_to_make_temp) << EC.message();
void tools::AddHIPLinkerScript(const ToolChain &TC, Compilation &C,
   LksStream.flush();
 
   // Dump the contents of the linker script if the user requested that. We
   // support this option to enable testing of behavior with -###.
   if (C.getArgs().hasArg(options::OPT_fhip_dump_offload_linker_script))
     llvm::errs() << LksBuffer;
 
   // If this is a dry run, do not create the linker script file.
-  if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
+  if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH) ||
+      C.getArgs().hasArg(options::OPT__HASH_HASH_HASH_VERBATIM))
     return;
 
   // Open script file and write the contents.
   std::error_code EC;
   llvm::raw_fd_ostream Lksf(LKS, EC, llvm::sys::fs::OF_None);
 
   if (EC) {
     C.getDriver().Diag(clang::diag::err_unable_to_make_temp) << EC.message();

clang/lib/Frontend/CreateInvocationFromCommandLine.cpp

std::unique_ptr<CompilerInvocation> clang::createInvocationFromCommandLine(
 
   // Just print the cc1 options if -### was present.
   if (C->getArgs().hasArg(driver::options::OPT__HASH_HASH_HASH)) {
     C->getJobs().Print(llvm::errs(), "\n",
                        driver::Command::PrintingMode::AlwaysQuote);
     return nullptr;
   }
 
+  // Just print the cc1 options verbatim if -###-verbatim was present.
+  if (C->getArgs().hasArg(driver::options::OPT__HASH_HASH_HASH_VERBATIM)) {
+    C->getJobs().Print(llvm::errs(), "\n",
+                       driver::Command::PrintingMode::Verbatim);
+    return nullptr;
+  }
+
   // We expect to get back exactly one command job, if we didn't something
   // failed. Offload compilation is an exception as it creates multiple jobs. If
   // that's the case, we proceed with the first job. If caller needs a
   // particular job, it should be controlled via options (e.g.
   // --cuda-{host|device}-only for CUDA) passed to the driver.
   const driver::JobList &Jobs = C->getJobs();
   bool OffloadCompilation = false;
   if (Jobs.size() > 1) {