ninja windows: support precompiled headers

pylib/gyp/msvs_emulation.py

 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """
 This module helps emulate Visual Studio 2008 behavior on top of other
 build systems, primarily ninja.
 """
 
 import os
@@ skipping 125 matching lines @@
 
     # Try to find an installation location for the Windows DDK by checking
     # the WDK_DIR environment variable, may be None.
     self.wdk_dir = os.environ.get('WDK_DIR')
 
     supported_fields = [
         ('msvs_configuration_attributes', dict),
         ('msvs_settings', dict),
         ('msvs_system_include_dirs', list),
         ('msvs_disabled_warnings', list),
+        ('msvs_precompiled_header', str),
+        ('msvs_precompiled_source', str),
         ]
     configs = spec['configurations']
     for field, default in supported_fields:
       setattr(self, field, {})
       for configname, config in configs.iteritems():
         getattr(self, field)[configname] = config.get(field, default())
 
     self.msvs_cygwin_dirs = spec.get('msvs_cygwin_dirs', ['.'])
 
   def GetVSMacroEnv(self, base_to_build=None):
@@ skipping 110 matching lines @@
     cl('BufferSecurityCheck', map={'true': '/GS', 'false': '/GS-'})
     cl('BasicRuntimeChecks', map={'1': 's', '2': 'u', '3': '1'}, prefix='/RTC')
     cl('RuntimeLibrary',
         map={'0': 'T', '1': 'Td', '2': 'D', '3': 'Dd'}, prefix='/M')
     cl('ExceptionHandling', map={'1': 'sc','2': 'a'}, prefix='/EH')
     cl('AdditionalOptions', prefix='')
     # ninja handles parallelism by itself, don't have the compiler do it too.
     cflags = filter(lambda x: not x.startswith('/MP'), cflags)
     return cflags
 
+  def GetPrecompiledHeader(self, config, gyp_to_build_path):
+    """Returns an object that handles the generation of precompiled header
+    build steps."""
+    return _PchHelper(self, config, gyp_to_build_path)
+
+  def _GetPchFlags(self, config, extension):
+    """Get the flags to be added to the cflags for precompiled header support.
+    """
+    # The PCH is only built once by a particular source file. Usage of PCH must
+    # only be for the same language (i.e. C vs. C++), so only include the pch
+    # flags when the language matches.
+    if self.msvs_precompiled_header[config]:
+      source_ext = os.path.splitext(self.msvs_precompiled_source[config])[1][1:]
+      if _LanguageMatchesForPch(source_ext, extension):
+        pch = os.path.split(self.msvs_precompiled_header[config])[1]
+        return ['/Yu' + pch, '/FI' + pch, '/Fp${pchprefix}.' + pch + '.pch']

[Nico, 2012/05/23 20:53:29]

http://msdn.microsoft.com/en-us/library/z0atkd6c(v=vs.71) sounds like /Yu
implies /FI, are you sure you need them both?

[scottmg, 2012/05/24 20:34:39]

I don't think it implies that. Normally projects have the literal text '#include
"precompile.h"' in all .cc files. Because that's not practical for us, we use
/FI to effectively inject it at the top of all .cc files that use pch.

(Also, the msvs generator uses ForceInclude so it's probably best to do the same
in both places so that builds work/break in the same way.)

+    return  []
+
   def GetCflagsC(self, config):
     """Returns the flags that need to be added to .c compilations."""
-    return []
+    return self._GetPchFlags(config, 'c')
 
   def GetCflagsCC(self, config):
     """Returns the flags that need to be added to .cc compilations."""
-    return ['/TP']
+    return ['/TP'] + self._GetPchFlags(config, 'cc')
 
   def _GetAdditionalLibraryDirectories(self, root, config, gyp_to_build_path):
     """Get and normalize the list of paths in AdditionalLibraryDirectories
     setting."""
     libpaths = self._Setting((root, 'AdditionalLibraryDirectories'),
                              config, default=[])
     libpaths = [os.path.normpath(gyp_to_build_path(self.ConvertVSMacros(p)))
                 for p in libpaths]
     return ['/LIBPATH:"' + p + '"' for p in libpaths]
 
@@ skipping 136 matching lines @@
     output = [header, dlldata, iid, proxy]
     variables = [('tlb', tlb),
                  ('h', header),
                  ('dlldata', dlldata),
                  ('iid', iid),
                  ('proxy', proxy)]
     # TODO(scottmg): Are there configuration settings to set these flags?
     flags = ['/char', 'signed', '/env', 'win32', '/Oicf']
     return outdir, output, variables, flags
 
+
+def _LanguageMatchesForPch(source_ext, pch_source_ext):
+  c_exts = ('c',)
+  cc_exts = ('cc', 'cxx', 'cpp')
+  return ((source_ext in c_exts and pch_source_ext in c_exts) or
+          (source_ext in cc_exts and pch_source_ext in cc_exts))
+
+class PrecompiledHeader(object):
+  """Helper to generate dependencies and build rules to handle generation of
+  precompiled headers. Interface matches the GCH handler in xcode_emulation.py.
+  """
+  def __init__(self, settings, config, gyp_to_build_path):
+    self.settings = settings
+    self.config = config
+    self.gyp_to_build_path = gyp_to_build_path
+
+  def _PchHeader(self):
+    """Get the header that will appear in an #include line for all source
+    files."""
+    return os.path.split(self.settings.msvs_precompiled_header[self.config])[1]
+
+  def _PchSource(self):
+    """Get the source file that is built once to compile the pch data."""
+    return self.gyp_to_build_path(
+        self.settings.msvs_precompiled_source[self.config])
+
+  def _PchOutput(self):
+    """Get the name of the output of the compiled pch data."""
+    return '${pchprefix}.' + self._PchHeader() + '.pch'
+
+  def _PchObj(self):
+    """Get the name of the output of the compiled pch data."""
+    return '${pchprefix}.' + self._PchHeader() + '.obj'
+
+  def GetObjDependencies(self, sources, objs):
+    """Given a list of sources files and the corresponding object files,
+    returns a list of the pch files that should be depended upon."""
+    if not self._PchHeader():
+      return []
+    source = self._PchSource()
+    assert source
+    pch_ext = os.path.splitext(self._PchSource())[1][1:]

[Nico, 2012/05/23 20:53:29]

Dealing with extensions in python is so painful :-/ (not your fault, obviously)

[scottmg, 2012/05/24 20:34:39]

Yeah :/. I switched to literals '.x' to remove the [1:]s... a bit less ugly?

+    for source in sources:
+      if _LanguageMatchesForPch(os.path.splitext(source)[1][1:], pch_ext):
+        return [self._PchOutput()]
+    return []
+
+  def GetPchBuildCommands(self):
+    """Returns [(path_to_pch, language_flag, language, header, extra_vars)].
+    |path_to_gch| and |header| are relative to the build directory."""
+    header = self._PchHeader()
+    source = self._PchSource()
+    if not source or not header:
+      return []
+    ext = os.path.splitext(source)[1][1:]
+    lang = 'c' if ext == 'c' else 'cc'
+    extra_vars = [('outflag', '/Fp'),
+                  ('pchobj', '/Fo' + self._PchObj())]
+    return [(self._PchOutput(), '/Yc' + header, lang, source, extra_vars)]
+
+
 vs_version = None
 def GetVSVersion(generator_flags):
   global vs_version
   if not vs_version:
     vs_version = gyp.MSVSVersion.SelectVisualStudioVersion(
         generator_flags.get('msvs_version', 'auto'))
   return vs_version
 
 def _GetBinaryPath(generator_flags, tool):
   vs = GetVSVersion(generator_flags)
@@ skipping 19 matching lines @@
   return vs.SetupScript()
 
 def ExpandMacros(string, expansions):
   """Expand $(Variable) per expansions dict. See MsvsSettings.GetVSMacroEnv
   for the canonical way to retrieve a suitable dict."""
   if '$' in string:
     for old, new in expansions.iteritems():
       assert '$(' not in new, new
       string = string.replace(old, new)
   return string