ninja: make cross-compilation use $CC/$CXX for the target compiler

pylib/gyp/generator/ninja.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.
 
 import copy
 import gyp
 import gyp.common
 import gyp.msvs_emulation
 import gyp.MSVSVersion
 import gyp.system_test
@@ skipping 37 matching lines @@
 }
 
 # Placates pylint.
 generator_additional_non_configuration_keys = []
 generator_additional_path_sections = []
 generator_extra_sources_for_rules = []
 
 # TODO: figure out how to not build extra host objects in the non-cross-compile
 # case when this is enabled, and enable unconditionally.
 generator_supports_multiple_toolsets = (
-  os.environ.get('AR_target') or os.environ.get('CC_target') or
+  os.environ.get('GYP_CROSSCOMPILE') or
+  os.environ.get('AR_host') or
+  os.environ.get('CC_host') or
+  os.environ.get('CXX_host') or
+  os.environ.get('AR_target') or
+  os.environ.get('CC_target') or
   os.environ.get('CXX_target'))
 
 
 def StripPrefix(arg, prefix):
   if arg.startswith(prefix):
     return arg[len(prefix):]
   return arg
 
 
 def QuoteShellArgument(arg, flavor):
@@ skipping 625 matching lines @@
     env = self.ComputeExportEnvString(env)
 
     self.ninja.build(out, 'mac_tool', info_plist,
                      variables=[('mactool_cmd', 'copy-info-plist'),
                                 ('env', env)])
     bundle_depends.append(out)
 
   def WriteSources(self, config_name, config, sources, predepends,
                    precompiled_header):
     """Write build rules to compile all of |sources|."""
-    if self.toolset == 'target':
-      self.ninja.variable('ar', '$ar_target')
-      self.ninja.variable('cc', '$cc_target')
-      self.ninja.variable('cxx', '$cxx_target')
-      self.ninja.variable('ld', '$ld_target')
+    if self.toolset == 'host':
+      self.ninja.variable('ar', '$ar_host')
+      self.ninja.variable('cc', '$cc_host')
+      self.ninja.variable('cxx', '$cxx_host')
+      self.ninja.variable('ld', '$ld_host')
 
     extra_defines = []
     if self.flavor == 'mac':
       cflags = self.xcode_settings.GetCflags(config_name)
       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)
@@ skipping 537 matching lines @@
 
 def OpenOutput(path, mode='w'):
   """Open |path| for writing, creating directories if necessary."""
   try:
     os.makedirs(os.path.dirname(path))
   except OSError:
     pass
   return open(path, mode)
 
 
+def GetEnvironFallback(var_list, default):
+  for var in var_list:
+    if var in os.environ:
+      return os.environ[var]
+  return default
+
+
 def GenerateOutputForConfig(target_list, target_dicts, data, params,
                             config_name):
   options = params['options']
   flavor = gyp.common.GetFlavor(params)
   generator_flags = params.get('generator_flags', {})
 
   # build_dir: relative path from source root to our output files.
   # e.g. "out/Debug"
   build_dir = os.path.join(generator_flags.get('output_dir', 'out'),
                            config_name)
 
   toplevel_build = os.path.join(options.toplevel_dir, build_dir)
 
   master_ninja = ninja_syntax.Writer(
       OpenOutput(os.path.join(toplevel_build, 'build.ninja')),
       width=120)
 
   # Put build-time support tools in out/{config_name}.
   gyp.common.CopyTool(flavor, toplevel_build)
 
   # Grab make settings for CC/CXX.
   if flavor == 'win':
     cc = cxx = 'cl.exe'
     gyp.msvs_emulation.GenerateEnvironmentFiles(
         toplevel_build, generator_flags, OpenOutput)
   else:
     cc, cxx = 'gcc', 'g++'
+  cc_host, cxx_host = cc, cxx
   build_file, _, _ = gyp.common.ParseQualifiedTarget(target_list[0])
   make_global_settings = data[build_file].get('make_global_settings', [])
   build_to_root = InvertRelativePath(build_dir)
   for key, value in make_global_settings:
     if key == 'CC': cc = os.path.join(build_to_root, value)
     if key == 'CXX': cxx = os.path.join(build_to_root, value)
+    if key == 'CC.host': cc_host = os.path.join(build_to_root, value)
+    if key == 'CXX.host': cxx_host = os.path.join(build_to_root, value)
 
   flock = 'flock'
   if flavor == 'mac':
     flock = './gyp-mac-tool flock'
-  master_ninja.variable('cc', os.environ.get('CC', cc))
-  master_ninja.variable('cxx', os.environ.get('CXX', cxx))
+  master_ninja.variable('cc', GetEnvironFallback(['CC_target', 'CC'], cc))
+  master_ninja.variable('cxx', GetEnvironFallback(['CXX_target', 'CXX'], cxx))
   if flavor == 'win':
     master_ninja.variable('ld', 'link.exe')
     master_ninja.variable('idl', 'midl.exe')
     master_ninja.variable('ar', 'lib.exe')
     master_ninja.variable('rc', 'rc.exe')
     master_ninja.variable('asm', 'ml.exe')
     master_ninja.variable('mt', 'mt.exe')
   else:
     master_ninja.variable('ld', flock + ' linker.lock $cxx')
-    master_ninja.variable('ar', os.environ.get('AR', 'ar'))
+    master_ninja.variable('ar', GetEnvironFallback(['AR_target', 'AR'], 'ar'))
 
-  master_ninja.variable('ar_target', os.environ.get('AR_target', '$ar'))
-  master_ninja.variable('cc_target', os.environ.get('CC_target', '$cc'))
-  master_ninja.variable('cxx_target', os.environ.get('CXX_target', '$cxx'))
+  master_ninja.variable('ar_host', GetEnvironFallback(['AR_host'], 'ar'))
+  master_ninja.variable('cc_host', GetEnvironFallback(['CC_host'], cc_host))
+  master_ninja.variable('cxx_host', GetEnvironFallback(['CXX_host'], cxx_host))
   if flavor == 'win':
-    master_ninja.variable('ld_target', os.environ.get('LD_target', '$ld'))
+    master_ninja.variable('ld_host', os.environ.get('LD_target', '$ld'))

[piman, 2012/08/02 18:55:31]

LD_host instead of LD_target

[michaelbai, 2012/08/02 21:33:48]

Done.

   else:
-    master_ninja.variable('ld_target', flock + ' linker.lock $cxx_target')
+    master_ninja.variable('ld_host', flock + ' linker.lock $cxx_host')
 
   if flavor == 'mac':
     master_ninja.variable('mac_tool', os.path.join('.', 'gyp-mac-tool'))
   master_ninja.newline()
 
   if flavor != 'win':
     master_ninja.rule(
       'cc',
       description='CC $out',
       command=('$cc -MMD -MF $out.d $defines $includes $cflags $cflags_c '
@@ skipping 311 matching lines @@
 
   user_config = params.get('generator_flags', {}).get('config', None)
   if user_config:
     GenerateOutputForConfig(target_list, target_dicts, data, params,
                             user_config)
   else:
     config_names = target_dicts[target_list[0]]['configurations'].keys()
     for config_name in config_names:
       GenerateOutputForConfig(target_list, target_dicts, data, params,
                               config_name)