build/gyp_chromium

   1 #!/usr/bin/env python
   2
   3 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   4 # Use of this source code is governed by a BSD-style license that can be
   5 # found in the LICENSE file.
   6
   7 # This script is wrapper for Chromium that adds some support for how GYP
   8 # is invoked by Chromium beyond what can be done in the gclient hooks.
   9
  10 import argparse
  11 import glob
  12 import gyp_environment
  13 import os
  14 import re
  15 import shlex
  16 import subprocess
  17 import string
  18 import sys
  19 import vs_toolchain
  20
  21 script_dir = os.path.dirname(os.path.realpath(__file__))
  22 chrome_src = os.path.abspath(os.path.join(script_dir, os.pardir))
  23
  24 sys.path.insert(0, os.path.join(chrome_src, 'tools', 'gyp', 'pylib'))
  25 import gyp
  26
  27 # Assume this file is in a one-level-deep subdirectory of the source root.
  28 SRC_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
  29
  30 # Add paths so that pymod_do_main(...) can import files.
  31 sys.path.insert(1, os.path.join(chrome_src, 'android_webview', 'tools'))
  32 sys.path.insert(1, os.path.join(chrome_src, 'build', 'android', 'gyp'))
  33 sys.path.insert(1, os.path.join(chrome_src, 'chrome', 'tools', 'build'))
  34 sys.path.insert(1, os.path.join(chrome_src, 'chromecast', 'tools', 'build'))
  35 sys.path.insert(1, os.path.join(chrome_src, 'ios', 'chrome', 'tools', 'build'))
  36 sys.path.insert(1, os.path.join(chrome_src, 'native_client', 'build'))
  37 sys.path.insert(1, os.path.join(chrome_src, 'native_client_sdk', 'src',
  38     'build_tools'))
  39 sys.path.insert(1, os.path.join(chrome_src, 'remoting', 'tools', 'build'))
  40 sys.path.insert(1, os.path.join(chrome_src, 'third_party', 'liblouis'))
  41 sys.path.insert(1, os.path.join(chrome_src, 'third_party', 'WebKit',
  42     'Source', 'build', 'scripts'))
  43 sys.path.insert(1, os.path.join(chrome_src, 'tools'))
  44 sys.path.insert(1, os.path.join(chrome_src, 'tools', 'generate_shim_headers'))
  45 sys.path.insert(1, os.path.join(chrome_src, 'tools', 'grit'))
  46
  47 # On Windows, Psyco shortens warm runs of build/gyp_chromium by about
  48 # 20 seconds on a z600 machine with 12 GB of RAM, from 90 down to 70
  49 # seconds.  Conversely, memory usage of build/gyp_chromium with Psyco
  50 # maxes out at about 158 MB vs. 132 MB without it.
  51 #
  52 # Psyco uses native libraries, so we need to load a different
  53 # installation depending on which OS we are running under. It has not
  54 # been tested whether using Psyco on our Mac and Linux builds is worth
  55 # it (the GYP running time is a lot shorter, so the JIT startup cost
  56 # may not be worth it).
  57 if sys.platform == 'win32':
  58   try:
  59     sys.path.insert(0, os.path.join(chrome_src, 'third_party', 'psyco_win32'))
  60     import psyco
  61   except:
  62     psyco = None
  63 else:
  64   psyco = None
  65
  66
  67 def GetSupplementalFiles():
  68   """Returns a list of the supplemental files that are included in all GYP
  69   sources."""
  70   return glob.glob(os.path.join(chrome_src, '*', 'supplement.gypi'))
  71
  72
  73 def ProcessGypDefinesItems(items):
  74   """Converts a list of strings to a list of key-value pairs."""
  75   result = []
  76   for item in items:
  77     tokens = item.split('=', 1)
  78     # Some GYP variables have hyphens, which we don't support.
  79     if len(tokens) == 2:
  80       result += [(tokens[0], tokens[1])]
  81     else:
  82       # No value supplied, treat it as a boolean and set it. Note that we
  83       # use the string '1' here so we have a consistent definition whether
  84       # you do 'foo=1' or 'foo'.
  85       result += [(tokens[0], '1')]
  86   return result
  87
  88
  89 def GetGypVars(supplemental_files):
  90   """Returns a dictionary of all GYP vars."""
  91   # Find the .gyp directory in the user's home directory.
  92   home_dot_gyp = os.environ.get('GYP_CONFIG_DIR', None)
  93   if home_dot_gyp:
  94     home_dot_gyp = os.path.expanduser(home_dot_gyp)
  95   if not home_dot_gyp:
  96     home_vars = ['HOME']
  97     if sys.platform in ('cygwin', 'win32'):
  98       home_vars.append('USERPROFILE')
  99     for home_var in home_vars:
 100       home = os.getenv(home_var)
 101       if home != None:
 102         home_dot_gyp = os.path.join(home, '.gyp')
 103         if not os.path.exists(home_dot_gyp):
 104           home_dot_gyp = None
 105         else:
 106           break
 107
 108   if home_dot_gyp:
 109     include_gypi = os.path.join(home_dot_gyp, "include.gypi")
 110     if os.path.exists(include_gypi):
 111       supplemental_files += [include_gypi]
 112
 113   # GYP defines from the supplemental.gypi files.
 114   supp_items = []
 115   for supplement in supplemental_files:
 116     with open(supplement, 'r') as f:
 117       try:
 118         file_data = eval(f.read(), {'__builtins__': None}, None)
 119       except SyntaxError, e:
 120         e.filename = os.path.abspath(supplement)
 121         raise
 122       variables = file_data.get('variables', [])
 123       for v in variables:
 124         supp_items += [(v, str(variables[v]))]
 125
 126   # GYP defines from the environment.
 127   env_items = ProcessGypDefinesItems(
 128       shlex.split(os.environ.get('GYP_DEFINES', '')))
 129
 130   # GYP defines from the command line.
 131   parser = argparse.ArgumentParser()
 132   parser.add_argument('-D', dest='defines', action='append', default=[])
 133   cmdline_input_items = parser.parse_known_args()[0].defines
 134   cmdline_items = ProcessGypDefinesItems(cmdline_input_items)
 135
 136   vars_dict = dict(supp_items + env_items + cmdline_items)
 137   return vars_dict
 138
 139
 140 def GetOutputDirectory():
 141   """Returns the output directory that GYP will use."""
 142
 143   # Handle command line generator flags.
 144   parser = argparse.ArgumentParser()
 145   parser.add_argument('-G', dest='genflags', default=[], action='append')
 146   genflags = parser.parse_known_args()[0].genflags
 147
 148   # Handle generator flags from the environment.
 149   genflags += shlex.split(os.environ.get('GYP_GENERATOR_FLAGS', ''))
 150
 151   needle = 'output_dir='
 152   for item in genflags:
 153     if item.startswith(needle):
 154       return item[len(needle):]
 155
 156   return 'out'
 157
 158
 159 def additional_include_files(supplemental_files, args=[]):
 160   """
 161   Returns a list of additional (.gypi) files to include, without duplicating
 162   ones that are already specified on the command line. The list of supplemental
 163   include files is passed in as an argument.
 164   """
 165   # Determine the include files specified on the command line.
 166   # This doesn't cover all the different option formats you can use,
 167   # but it's mainly intended to avoid duplicating flags on the automatic
 168   # makefile regeneration which only uses this format.
 169   specified_includes = set()
 170   for arg in args:
 171     if arg.startswith('-I') and len(arg) > 2:
 172       specified_includes.add(os.path.realpath(arg[2:]))
 173
 174   result = []
 175   def AddInclude(path):
 176     if os.path.realpath(path) not in specified_includes:
 177       result.append(path)
 178
 179   if os.environ.get('GYP_INCLUDE_FIRST') != None:
 180     AddInclude(os.path.join(chrome_src, os.environ.get('GYP_INCLUDE_FIRST')))
 181
 182   # Always include common.gypi.
 183   AddInclude(os.path.join(script_dir, 'common.gypi'))
 184
 185   # Optionally add supplemental .gypi files if present.
 186   for supplement in supplemental_files:
 187     AddInclude(supplement)
 188
 189   if os.environ.get('GYP_INCLUDE_LAST') != None:
 190     AddInclude(os.path.join(chrome_src, os.environ.get('GYP_INCLUDE_LAST')))
 191
 192   return result
 193
 194
 195 if __name__ == '__main__':
 196   # Disabling garbage collection saves about 1 second out of 16 on a Linux
 197   # z620 workstation. Since this is a short-lived process it's not a problem to
 198   # leak a few cyclyc references in order to spare the CPU cycles for
 199   # scanning the heap.
 200   import gc
 201   gc.disable()
 202
 203   args = sys.argv[1:]
 204
 205   use_analyzer = len(args) and args[0] == '--analyzer'
 206   if use_analyzer:
 207     args.pop(0)
 208     os.environ['GYP_GENERATORS'] = 'analyzer'
 209     args.append('-Gconfig_path=' + args.pop(0))
 210     args.append('-Ganalyzer_output_path=' + args.pop(0))
 211
 212   if int(os.environ.get('GYP_CHROMIUM_NO_ACTION', 0)):
 213     print 'Skipping gyp_chromium due to GYP_CHROMIUM_NO_ACTION env var.'
 214     sys.exit(0)
 215
 216   # Use the Psyco JIT if available.
 217   if psyco:
 218     psyco.profile()
 219     print "Enabled Psyco JIT."
 220
 221   # Fall back on hermetic python if we happen to get run under cygwin.
 222   # TODO(bradnelson): take this out once this issue is fixed:
 223   #    http://code.google.com/p/gyp/issues/detail?id=177
 224   if sys.platform == 'cygwin':
 225     import find_depot_tools
 226     depot_tools_path = find_depot_tools.add_depot_tools_to_path()
 227     python_dir = sorted(glob.glob(os.path.join(depot_tools_path,
 228                                                'python2*_bin')))[-1]
 229     env = os.environ.copy()
 230     env['PATH'] = python_dir + os.pathsep + env.get('PATH', '')
 231     cmd = [os.path.join(python_dir, 'python.exe')] + sys.argv
 232     sys.exit(subprocess.call(cmd, env=env))
 233
 234   # This could give false positives since it doesn't actually do real option
 235   # parsing.  Oh well.
 236   gyp_file_specified = any(arg.endswith('.gyp') for arg in args)
 237
 238   gyp_environment.SetEnvironment()
 239
 240   # If we didn't get a file, check an env var, and then fall back to
 241   # assuming 'all.gyp' from the same directory as the script.
 242   if not gyp_file_specified:
 243     gyp_file = os.environ.get('CHROMIUM_GYP_FILE')
 244     if gyp_file:
 245       # Note that CHROMIUM_GYP_FILE values can't have backslashes as
 246       # path separators even on Windows due to the use of shlex.split().
 247       args.extend(shlex.split(gyp_file))
 248     else:
 249       args.append(os.path.join(script_dir, 'all.gyp'))
 250
 251   supplemental_includes = GetSupplementalFiles()
 252   gyp_vars_dict = GetGypVars(supplemental_includes)
 253   # There shouldn't be a circular dependency relationship between .gyp files,
 254   # but in Chromium's .gyp files, on non-Mac platforms, circular relationships
 255   # currently exist.  The check for circular dependencies is currently
 256   # bypassed on other platforms, but is left enabled on iOS, where a violation
 257   # of the rule causes Xcode to misbehave badly.
 258   # TODO(mark): Find and kill remaining circular dependencies, and remove this
 259   # option.  http://crbug.com/35878.
 260   # TODO(tc): Fix circular dependencies in ChromiumOS then add linux2 to the
 261   # list.
 262   if gyp_vars_dict.get('OS') != 'ios':
 263     args.append('--no-circular-check')
 264
 265   # libtool on Mac warns about duplicate basenames in static libraries, so
 266   # they're disallowed in general by gyp. We are lax on this point, so disable
 267   # this check other than on Mac. GN does not use static libraries as heavily,
 268   # so over time this restriction will mostly go away anyway, even on Mac.
 269   # https://code.google.com/p/gyp/issues/detail?id=384
 270   if sys.platform != 'darwin':
 271     args.append('--no-duplicate-basename-check')
 272
 273   # We explicitly don't support the make gyp generator (crbug.com/348686). Be
 274   # nice and fail here, rather than choking in gyp.
 275   if re.search(r'(^|,|\s)make($|,|\s)', os.environ.get('GYP_GENERATORS', '')):
 276     print 'Error: make gyp generator not supported (check GYP_GENERATORS).'
 277     sys.exit(1)
 278
 279   # We explicitly don't support the native msvs gyp generator. Be nice and
 280   # fail here, rather than generating broken projects.
 281   if re.search(r'(^|,|\s)msvs($|,|\s)', os.environ.get('GYP_GENERATORS', '')):
 282     print 'Error: msvs gyp generator not supported (check GYP_GENERATORS).'
 283     print 'Did you mean to use the `msvs-ninja` generator?'
 284     sys.exit(1)
 285
 286   # If CHROMIUM_GYP_SYNTAX_CHECK is set to 1, it will invoke gyp with --check
 287   # to enfore syntax checking.
 288   syntax_check = os.environ.get('CHROMIUM_GYP_SYNTAX_CHECK')
 289   if syntax_check and int(syntax_check):
 290     args.append('--check')
 291
 292   # TODO(dmikurube): Remove these checks and messages after a while.
 293   if ('linux_use_tcmalloc' in gyp_vars_dict or
 294       'android_use_tcmalloc' in gyp_vars_dict):
 295     print '*****************************************************************'
 296     print '"linux_use_tcmalloc" and "android_use_tcmalloc" are deprecated!'
 297     print '-----------------------------------------------------------------'
 298     print 'You specify "linux_use_tcmalloc" or "android_use_tcmalloc" in'
 299     print 'your GYP_DEFINES. Please switch them into "use_allocator" now.'
 300     print 'See http://crbug.com/345554 for the details.'
 301     print '*****************************************************************'
 302
 303   # Automatically turn on crosscompile support for platforms that need it.
 304   # (The Chrome OS build sets CC_host / CC_target which implicitly enables
 305   # this mode.)
 306   if all(('ninja' in os.environ.get('GYP_GENERATORS', ''),
 307           gyp_vars_dict.get('OS') in ['android', 'ios'],
 308           'GYP_CROSSCOMPILE' not in os.environ)):
 309     os.environ['GYP_CROSSCOMPILE'] = '1'
 310   if gyp_vars_dict.get('OS') == 'android':
 311     args.append('--check')
 312
 313   args.extend(
 314       ['-I' + i for i in additional_include_files(supplemental_includes, args)])
 315
 316   args.extend(['-D', 'gyp_output_dir=' + GetOutputDirectory()])
 317
 318   if not use_analyzer:
 319     print 'Updating projects from gyp files...'
 320     sys.stdout.flush()
 321
 322   # Off we go...
 323   gyp_rc = gyp.main(args)
 324
 325   if not use_analyzer:
 326     vs2013_runtime_dll_dirs = vs_toolchain.SetEnvironmentAndGetRuntimeDllDirs()
 327     if vs2013_runtime_dll_dirs:
 328       x64_runtime, x86_runtime = vs2013_runtime_dll_dirs
 329       vs_toolchain.CopyVsRuntimeDlls(
 330         os.path.join(chrome_src, GetOutputDirectory()),
 331         (x86_runtime, x64_runtime))
 332
 333   sys.exit(gyp_rc)