Support generating Jom-style depfiles.

[probinson]

Summary

Jom (https://wiki.qt.io/Jom) is an NMake-compatible build tool on
Windows. Dependency files for Jom need to use double-quotes to wrap
filespecs containing special characters, instead of the backslash
escapes that GNU Make wants.

Adds the -MV option, which specifies to use double-quotes as needed
instead of backslash escapes when writing the dependency file.

[probinson]

The most obvious choice for the option would have been -MQ (Q for Quote) but that's already taken.
I picked -MV because we have a proprietary compiler that uses that option for the same purpose, but that's not a hard requirement and I'm open to suggestions.

[silvas]

Mimicking the existing precedent from another compiler for the option name makes sense (actually wasn't this at least in one of SCE's GCC derivatives?, so the sources ought to be out there in open source somewhere...). The other alternative I can think of is -Msyntax={make,nmake}, but I'm fine with -MV.

Also, since this feature is not in GCC, it requires documentation in docs/UsersManual.rst

lib/Frontend/DependencyFile.cpp

153 ↗

(On Diff #24398)

Maybe a comment explaining why you would want double quotes? Alternatively, maybe instead of "bool" it could be enum DepfileSyntax { Make, NMake } or something like that.

298 ↗

(On Diff #24398)

Is there a "spec" you can link to explaining the syntax? IIRC the microsoft docs for nmake have something explaining the quoting scheme.

300 ↗

(On Diff #24398)

I guess #include <foo"bar.h> is "don't do that"? I'm fine with that; I think the standard actually gives us a lot of freedom in what we can accept here; as long as we don't break use cases we care about it's all "implementation defined". We currently accept this though with no warning. If NMake doesn't have a way to quote this then maybe we should consider a "unadvisable include name" warning.

[probinson]

Re. origin of the -MV option, you are correct, it was a PS3 GCC option; the proprietary compiler always emitted NMake-style, it didn't have that option. My bad.

Re. UserManual.rst, it was not immediately obvious where to put this, so I invented a new section. Let me know if you have a better idea.

lib/Frontend/DependencyFile.cpp

153 ↗

(On Diff #24398)

Okay, an enum would be more self-documenting, and it's true there is more to it than just double-quotes.

298 ↗

(On Diff #24398)

There is online NMake documentation, but nothing explicitly saying when you do or don't need quotes. I can cite the base NMake URL.

300 ↗

(On Diff #24398)

Double-quote is not a legal filespec character in Windows, so compilation would fail regardless.

That said, the purpose of quoting is to avoid the builder misinterpreting the string, and the set of characters that could cause trouble for NMake is more than what seems to be trouble for Make. I should add curly braces and caret to this list, might as well add bang too, as they are all meaningful to NMake outside of recipes.

[probinson]

Revised per Sean's comments.

[rnk]

Sounds good, lgtm.

[probinson]

r235903, thanks!

cfe/trunk/docs/UsersManual.rst

 
 2. Some source locations are not displayed correctly. The front end has
    a more detailed source location tracking than the locations included
    in the debug info (e.g., the front end can locate code inside macro
    expansions). However, the locations used by :option:`-Rpass` are
    translated from debug annotations. That translation can be lossy,
    which results in some remarks having no location information.
 
+Other Options
+-------------
+Clang options that that don't fit neatly into other categories.
+
+.. option:: -MV
+
+  When emitting a dependency file, use formatting conventions appropriate
+  for NMake or Jom. Ignored unless another option causes Clang to emit a
+  dependency file.
+
+When Clang emits a dependency file (e.g., you supplied the -M option)
+most filenames can be written to the file without any special formatting.
+Different Make tools will treat different sets of characters as "special"
+and use different conventions for telling the Make tool that the character
+is actually part of the filename. Normally Clang uses backslash to "escape"
+a special character, which is the convention used by GNU Make. The -MV
+option tells Clang to put double-quotes around the entire filename, which
+is the convention used by NMake and Jom.
+
 
 Language and Target-Independent Features
 ========================================
 
 Controlling Errors and Warnings
 -------------------------------
 
 Clang provides a number of ways to control which code constructs cause

cfe/trunk/include/clang/Driver/Options.td

 def MG : Flag<["-"], "MG">, Group<M_Group>, Flags<[CC1Option]>,
     HelpText<"Add missing headers to depfile">;
 def MP : Flag<["-"], "MP">, Group<M_Group>, Flags<[CC1Option]>,
     HelpText<"Create phony target for each dependency (other than main file)">;
 def MQ : JoinedOrSeparate<["-"], "MQ">, Group<M_Group>, Flags<[CC1Option]>,
     HelpText<"Specify name of main file output to quote in depfile">;
 def MT : JoinedOrSeparate<["-"], "MT">, Group<M_Group>, Flags<[CC1Option]>,
     HelpText<"Specify name of main file output in depfile">;
+def MV : Flag<["-"], "MV">, Group<M_Group>, Flags<[CC1Option]>,
+    HelpText<"Use NMake/Jom format for the depfile">;
 def Mach : Flag<["-"], "Mach">;
 def O0 : Flag<["-"], "O0">, Group<O_Group>, Flags<[CC1Option]>;
 def O4 : Flag<["-"], "O4">, Group<O_Group>, Flags<[CC1Option]>;
 def ObjCXX : Flag<["-"], "ObjC++">, Flags<[DriverOption]>,
   HelpText<"Treat source input files as Objective-C++ inputs">;
 def ObjC : Flag<["-"], "ObjC">, Flags<[DriverOption]>,
   HelpText<"Treat source input files as Objective-C inputs">;
 def O : Joined<["-"], "O">, Group<O_Group>, Flags<[CC1Option]>;

cfe/trunk/include/clang/Frontend/DependencyOutputOptions.h

 #ifndef LLVM_CLANG_FRONTEND_DEPENDENCYOUTPUTOPTIONS_H
 #define LLVM_CLANG_FRONTEND_DEPENDENCYOUTPUTOPTIONS_H
 
 #include <string>
 #include <vector>
 
 namespace clang {
 
+/// DependencyOutputFormat - Format for the compiler dependency file.
+enum class DependencyOutputFormat { Make, NMake };
+
 /// DependencyOutputOptions - Options for controlling the compiler dependency
 /// file generation.
 class DependencyOutputOptions {
 public:
   unsigned IncludeSystemHeaders : 1; ///< Include system header dependencies.
   unsigned ShowHeaderIncludes : 1;   ///< Show header inclusions (-H).
   unsigned UsePhonyTargets : 1;      ///< Include phony targets for each
                                      /// dependency, which can avoid some 'make'
                                      /// problems.
   unsigned AddMissingHeaderDeps : 1; ///< Add missing headers to dependency list
   unsigned PrintShowIncludes : 1; ///< Print cl.exe style /showIncludes info.
   unsigned IncludeModuleFiles : 1; ///< Include module file dependencies.
-  
+  /// The format for the dependency file.
+  DependencyOutputFormat OutputFormat;
+
   /// The file to write dependency output to.
   std::string OutputFile;
 
   /// The file to write header include output to. This is orthogonal to
   /// ShowHeaderIncludes (-H) and will include headers mentioned in the
   /// predefines buffer. If the output file is "-", output will be sent to
   /// stderr.
   std::string HeaderIncludeOutputFile;

 public:
   DependencyOutputOptions() {
     IncludeSystemHeaders = 0;
     ShowHeaderIncludes = 0;
     UsePhonyTargets = 0;
     AddMissingHeaderDeps = 0;
     PrintShowIncludes = 0;
     IncludeModuleFiles = 0;
+    OutputFormat = DependencyOutputFormat::Make;
   }
 };
 
 }  // end namespace clang
 
 #endif

cfe/trunk/lib/Driver/Tools.cpp

void Clang::AddPreprocessingOptions(Compilation &C,
   if (Args.hasArg(options::OPT_MG)) {
     if (!A || A->getOption().matches(options::OPT_MD) ||
               A->getOption().matches(options::OPT_MMD))
       D.Diag(diag::err_drv_mg_requires_m_or_mm);
     CmdArgs.push_back("-MG");
   }
 
   Args.AddLastArg(CmdArgs, options::OPT_MP);
+  Args.AddLastArg(CmdArgs, options::OPT_MV);
 
   // Convert all -MQ <target> args to -MT <quoted target>
   for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
                                              options::OPT_MQ),
          ie = Args.filtered_end(); it != ie; ++it) {
     const Arg *A = *it;
     A->claim();
 

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
   Opts.UsePhonyTargets = Args.hasArg(OPT_MP);
   Opts.ShowHeaderIncludes = Args.hasArg(OPT_H);
   Opts.HeaderIncludeOutputFile = Args.getLastArgValue(OPT_header_include_file);
   Opts.AddMissingHeaderDeps = Args.hasArg(OPT_MG);
   Opts.PrintShowIncludes = Args.hasArg(OPT_show_includes);
   Opts.DOTOutputFile = Args.getLastArgValue(OPT_dependency_dot);
   Opts.ModuleDependencyOutputDir =
       Args.getLastArgValue(OPT_module_dependency_dir);
+  if (Args.hasArg(OPT_MV))
+    Opts.OutputFormat = DependencyOutputFormat::NMake;
 }
 
 bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
                                 DiagnosticsEngine *Diags) {
   using namespace options;
   bool Success = true;
 
   Opts.DiagnosticLogFile = Args.getLastArgValue(OPT_diagnostic_log_file);

cfe/trunk/lib/Frontend/DependencyFile.cpp

class DFGImpl : public PPCallbacks {
   const Preprocessor *PP;
   std::string OutputFile;
   std::vector<std::string> Targets;
   bool IncludeSystemHeaders;
   bool PhonyTarget;
   bool AddMissingHeaderDeps;
   bool SeenMissingHeader;
   bool IncludeModuleFiles;
+  DependencyOutputFormat OutputFormat;
+
 private:
   bool FileMatchesDepCriteria(const char *Filename,
                               SrcMgr::CharacteristicKind FileType);
   void OutputDependencyFile();
 
 public:
   DFGImpl(const Preprocessor *_PP, const DependencyOutputOptions &Opts)
     : PP(_PP), OutputFile(Opts.OutputFile), Targets(Opts.Targets),
       IncludeSystemHeaders(Opts.IncludeSystemHeaders),
       PhonyTarget(Opts.UsePhonyTargets),
       AddMissingHeaderDeps(Opts.AddMissingHeaderDeps),
       SeenMissingHeader(false),
-      IncludeModuleFiles(Opts.IncludeModuleFiles) {}
+      IncludeModuleFiles(Opts.IncludeModuleFiles),
+      OutputFormat(Opts.OutputFormat) {}
 
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override;
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
                           CharSourceRange FilenameRange, const FileEntry *File,
                           StringRef SearchPath, StringRef RelativePath,

 }
 
 void DFGImpl::AddFilename(StringRef Filename) {
   if (FilesSet.insert(Filename).second)
     Files.push_back(Filename);
 }
 
 /// PrintFilename - GCC escapes spaces, # and $, but apparently not ' or " or
-/// other scary characters.
-static void PrintFilename(raw_ostream &OS, StringRef Filename) {
+/// other scary characters. NMake/Jom has a different set of scary characters,
+/// but wraps filespecs in double-quotes to avoid misinterpreting them;
+/// https://msdn.microsoft.com/en-us/library/dd9y37ha.aspx for NMake info,
+/// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx
+/// for Windows file-naming info.
+static void PrintFilename(raw_ostream &OS, StringRef Filename,
+                          DependencyOutputFormat OutputFormat) {
+  if (OutputFormat == DependencyOutputFormat::NMake) {
+    // Add quotes if needed. These are the characters listed as "special" to
+    // NMake, that are legal in a Windows filespec, and that could cause
+    // misinterpretation of the dependency string.
+    if (Filename.find_first_of(" #${}^!") != StringRef::npos)
+      OS << '\"' << Filename << '\"';
+    else
+      OS << Filename;
+    return;
+  }
   for (unsigned i = 0, e = Filename.size(); i != e; ++i) {
     if (Filename[i] == ' ' || Filename[i] == '#')
       OS << '\\';
     else if (Filename[i] == '$') // $ is escaped by $$.
       OS << '$';
     OS << Filename[i];
   }
 }
for (std::vector<std::string>::iterator I = Files.begin(),
     // sure to leave space for a trailing " \" in case we need to
     // break the line on the next iteration.
     unsigned N = I->length();
     if (Columns + (N + 1) + 2 > MaxColumns) {
       OS << " \\\n ";
       Columns = 2;
     }
     OS << ' ';
-    PrintFilename(OS, *I);
+    PrintFilename(OS, *I, OutputFormat);
     Columns += N + 1;
   }
   OS << '\n';
 
   // Create phony targets if requested.
   if (PhonyTarget && !Files.empty()) {
     // Skip the first entry, this is always the input file itself.
     for (std::vector<std::string>::iterator I = Files.begin() + 1,
            E = Files.end(); I != E; ++I) {
       OS << '\n';
-      PrintFilename(OS, *I);
+      PrintFilename(OS, *I, OutputFormat);
       OS << ":\n";
     }
   }
 }
 
 bool DFGASTReaderListener::visitInputFile(llvm::StringRef Filename,
                                           bool IsSystem, bool IsOverridden) {
   assert(!IsSystem || needsSystemInputFileVisitation());

cfe/trunk/test/Frontend/dependency-gen-escaping.c

 // PR15642
 // RUN: rm -rf %t.dir
 // RUN: mkdir -p %t.dir
 // RUN: echo > '%t.dir/    .h'
 // RUN: echo > '%t.dir/$$.h'
 // RUN: echo > '%t.dir/##.h'
+// RUN: echo > '%t.dir/normal.h'
 // RUN: cd %t.dir
 // RUN: %clang -MD -MF - %s -fsyntax-only -I. | FileCheck -strict-whitespace %s
+// RUN: %clang -MD -MF - -MV %s -fsyntax-only -I. | FileCheck -strict-whitespace %s --check-prefix=QUOTE
 
 // CHECK: \ \ \ \ .h
 // CHECK: $$$$.h
 // CHECK: \#\#.h
+// QUOTE: "    .h"
+// QUOTE: "$$.h"
+// QUOTE: "##.h"
+// QUOTE-NOT: "
+// QUOTE: normal.h
+// QUOTE-NOT: "
 
 #include "    .h"
 #include "$$.h"
 #include "##.h"
+#include "normal.h"