Pass the /safeseh option to ml.exe.

pylib/gyp/generator/ninja.py

 # Copyright (c) 2013 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.
 
 import collections
 import copy
 import hashlib
 import json
 import multiprocessing
 import os.path
@@ skipping 807 matching lines @@
     extra_defines = []
     if self.flavor == 'mac':
       cflags = self.xcode_settings.GetCflags(config_name, arch=arch)
       cflags_c = self.xcode_settings.GetCflagsC(config_name)
       cflags_cc = self.xcode_settings.GetCflagsCC(config_name)
       cflags_objc = ['$cflags_c'] + \
                     self.xcode_settings.GetCflagsObjC(config_name)
       cflags_objcc = ['$cflags_cc'] + \
                      self.xcode_settings.GetCflagsObjCC(config_name)
     elif self.flavor == 'win':
+      asmflags = self.msvs_settings.GetAsmflags(config_name)
       cflags = self.msvs_settings.GetCflags(config_name)
       cflags_c = self.msvs_settings.GetCflagsC(config_name)
       cflags_cc = self.msvs_settings.GetCflagsCC(config_name)
       extra_defines = self.msvs_settings.GetComputedDefines(config_name)
       # See comment at cc_command for why there's two .pdb files.
       pdbpath_c = pdbpath_cc = self.msvs_settings.GetCompilerPdbName(
           config_name, self.ExpandSpecial)
       if not pdbpath_c:
         obj = 'obj'
         if self.toolset != 'target':
@@ skipping 14 matching lines @@
     if self.toolset == 'target':
       cflags_c = (os.environ.get('CPPFLAGS', '').split() +
                   os.environ.get('CFLAGS', '').split() + cflags_c)
       cflags_cc = (os.environ.get('CPPFLAGS', '').split() +
                    os.environ.get('CXXFLAGS', '').split() + cflags_cc)
 
     defines = config.get('defines', []) + extra_defines
     self.WriteVariableList(ninja_file, 'defines',
                            [Define(d, self.flavor) for d in defines])
     if self.flavor == 'win':
+      self.WriteVariableList(ninja_file, 'asmflags',
+                             map(self.ExpandSpecial, asmflags))
       self.WriteVariableList(ninja_file, 'rcflags',
           [QuoteShellArgument(self.ExpandSpecial(f), self.flavor)
            for f in self.msvs_settings.GetRcflags(config_name,
                                                   self.GypPathToNinja)])
 
     include_dirs = config.get('include_dirs', [])
 
     env = self.GetToolchainEnv()
     if self.flavor == 'win':
       include_dirs = self.msvs_settings.AdjustIncludeDirs(include_dirs,
@@ skipping 988 matching lines @@
                    '@$out.rsp /c $in /Fo$out /Fd$pdbname_cc ')
     master_ninja.rule(
       'cc',
       description='CC $out',
       command=cc_command,
       rspfile='$out.rsp',
       rspfile_content='$defines $includes $cflags $cflags_c',
       deps=deps)
     master_ninja.rule(
       'cxx',
       description='CXX $out',

[wtc, 2014/04/11 03:13:19]

Scott: when compiling a C++ file, Ninja displays the output filename, but when
assembling an assembly code file, Ninja displays the input filename. See line
1893. I was confused by this.

Why the difference?

[scottmg, 2014/04/11 03:31:43]

No reason, probably because Evan/Nico wrote the CC rules for Linux/Mac that
Windows was copied from, and I wrote those Windows-specific rules for IDL/RC. I
guess the input seemed more useful than the output at the time. It's just a
message for the user, so it could be "ASM $in -> $out" or whatever.

       command=cxx_command,
       rspfile='$out.rsp',
       rspfile_content='$defines $includes $cflags $cflags_cc',
       deps=deps)
     master_ninja.rule(
       'idl',
       description='IDL $in',
       command=('%s gyp-win-tool midl-wrapper $arch $outdir '
                '$tlb $h $dlldata $iid $proxy $in '
                '$idlflags' % sys.executable))
     master_ninja.rule(
       'rc',
       description='RC $in',
       # Note: $in must be last otherwise rc.exe complains.
       command=('%s gyp-win-tool rc-wrapper '
                '$arch $rc $defines $resource_includes $rcflags /fo$out $in' %
                sys.executable))
     master_ninja.rule(
       'asm',
       description='ASM $in',
       command=('%s gyp-win-tool asm-wrapper '
-               '$arch $asm $defines $includes /c /Fo $out $in' %
+               '$arch $asm $defines $includes $asmflags /c /Fo $out $in' %
                sys.executable))
 
   if flavor != 'mac' and flavor != 'win':
     master_ninja.rule(
       'alink',
       description='AR $out',
       command='rm -f $out && $ar rcs $out $in')
     master_ninja.rule(
       'alink_thin',
       description='AR $out',
@@ skipping 300 matching lines @@
           arglists.append(
               (target_list, target_dicts, data, params, config_name))
         pool.map(CallGenerateOutputForConfig, arglists)
       except KeyboardInterrupt, e:
         pool.terminate()
         raise e
     else:
       for config_name in config_names:
         GenerateOutputForConfig(target_list, target_dicts, data, params,
                                 config_name)