| #!/usr/bin/env python |
| |
| # Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| # This script is wrapper for Chromium that adds some support for how GYP |
| # is invoked by Chromium beyond what can be done in the gclient hooks. |
| |
| import glob |
| import gyp_helper |
| import os |
| import pipes |
| import shlex |
| import shutil |
| import subprocess |
| import string |
| import sys |
| |
| script_dir = os.path.dirname(os.path.realpath(__file__)) |
| chrome_src = os.path.abspath(os.path.join(script_dir, os.pardir)) |
| |
| sys.path.insert(0, os.path.join(chrome_src, 'tools', 'gyp', 'pylib')) |
| import gyp |
| |
| # Assume this file is in a one-level-deep subdirectory of the source root. |
| SRC_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) |
| |
| # Add paths so that pymod_do_main(...) can import files. |
| sys.path.insert(1, os.path.join(chrome_src, 'tools')) |
| sys.path.insert(1, os.path.join(chrome_src, 'tools', 'generate_shim_headers')) |
| sys.path.insert(1, os.path.join(chrome_src, 'tools', 'grit')) |
| sys.path.insert(1, os.path.join(chrome_src, 'chrome', 'tools', 'build')) |
| sys.path.insert(1, os.path.join(chrome_src, 'native_client', 'build')) |
| sys.path.insert(1, os.path.join(chrome_src, 'native_client_sdk', 'src', |
| 'build_tools')) |
| sys.path.insert(1, os.path.join(chrome_src, 'remoting', 'tools', 'build')) |
| sys.path.insert(1, os.path.join(chrome_src, 'third_party', 'liblouis')) |
| sys.path.insert(1, os.path.join(chrome_src, 'third_party', 'WebKit', |
| 'Source', 'build', 'scripts')) |
| |
| import find_depot_tools |
| |
| # On Windows, Psyco shortens warm runs of build/gyp_chromium by about |
| # 20 seconds on a z600 machine with 12 GB of RAM, from 90 down to 70 |
| # seconds. Conversely, memory usage of build/gyp_chromium with Psyco |
| # maxes out at about 158 MB vs. 132 MB without it. |
| # |
| # Psyco uses native libraries, so we need to load a different |
| # installation depending on which OS we are running under. It has not |
| # been tested whether using Psyco on our Mac and Linux builds is worth |
| # it (the GYP running time is a lot shorter, so the JIT startup cost |
| # may not be worth it). |
| if sys.platform == 'win32': |
| try: |
| sys.path.insert(0, os.path.join(chrome_src, 'third_party', 'psyco_win32')) |
| import psyco |
| except: |
| psyco = None |
| else: |
| psyco = None |
| |
| |
| def GetSupplementalFiles(): |
| """Returns a list of the supplemental files that are included in all GYP |
| sources.""" |
| return glob.glob(os.path.join(chrome_src, '*', 'supplement.gypi')) |
| |
| |
| def FormatKeyForGN(key): |
| """Returns the given GYP key reformatted for GN. |
| |
| GYP dictionary keys can be almost anything, but in GN they are identifiers |
| and must follow the same rules. This reformats such keys to be valid GN |
| identifiers.""" |
| return ''.join([c if c in string.ascii_letters else '_' for c in key]) |
| |
| |
| def EscapeStringForGN(s): |
| """Converts a string to a GN string literal.""" |
| for old, new in [('\\', '\\\\'), ('$', '\\$'), ('"', '\\"')]: |
| s = s.replace(old, new) |
| return '"' + s + '"' |
| |
| |
| def ProcessGypDefinesItems(items): |
| """Converts a list of strings to a list of key-value pairs.""" |
| result = [] |
| for item in items: |
| tokens = item.split('=', 1) |
| # Some GYP variables have hyphens, which we don't support. |
| key = FormatKeyForGN(tokens[0]) |
| if len(tokens) == 2: |
| result += [(key, tokens[1])] |
| else: |
| # No value supplied, treat it as a boolean and set it. Note that we |
| # use the string '1' here so we have a consistent definition whether |
| # you do 'foo=1' or 'foo'. |
| result += [(key, '1')] |
| return result |
| |
| def GetGypVarsForGN(supplemental_files): |
| """Returns a dictionary of all GYP vars that we will be passing to GN.""" |
| |
| # GYP defines from the supplemental.gypi files. |
| supp_items = [] |
| for supplement in supplemental_files: |
| with open(supplement, 'r') as f: |
| try: |
| file_data = eval(f.read(), {'__builtins__': None}, None) |
| except SyntaxError, e: |
| e.filename = os.path.abspath(supplement) |
| raise |
| variables = file_data.get('variables', []) |
| for v in variables: |
| supp_items += [(FormatKeyForGN(v), str(variables[v]))] |
| |
| # GYP defines from the environment. |
| env_items = ProcessGypDefinesItems( |
| shlex.split(os.environ.get('GYP_DEFINES', ''))) |
| |
| # GYP defines from the command line. We can't use optparse since we want |
| # to ignore all arguments other than "-D". |
| cmdline_input_items = [] |
| for i in range(len(sys.argv))[1:]: |
| if sys.argv[i].startswith('-D'): |
| if sys.argv[i] == '-D' and i + 1 < len(sys.argv): |
| cmdline_input_items += [sys.argv[i + 1]] |
| elif len(sys.argv[i]) > 2: |
| cmdline_input_items += [sys.argv[i][2:]] |
| cmdline_items = ProcessGypDefinesItems(cmdline_input_items) |
| |
| return dict(supp_items + env_items + cmdline_items) |
| |
| def GetOutputDirectory(): |
| """Returns the output directory that GYP will use.""" |
| # GYP generator flags from the command line. We can't use optparse since we |
| # want to ignore all arguments other than "-G". |
| needle = '-Goutput_dir=' |
| cmdline_input_items = [] |
| for item in sys.argv[1:]: |
| if item.startswith(needle): |
| return item[len(needle):] |
| |
| env_items = shlex.split(os.environ.get('GYP_GENERATOR_FLAGS', '')) |
| needle = 'output_dir=' |
| for item in env_items: |
| if item.startswith(needle): |
| return item[len(needle):] |
| |
| return "out" |
| |
| def GetArgsStringForGN(supplemental_files): |
| """Returns the args to pass to GN. |
| Based on a subset of the GYP variables that have been rewritten a bit.""" |
| |
| # Find the .gyp directory in the user's home directory. |
| home_dot_gyp = os.environ.get('GYP_CONFIG_DIR', None) |
| if home_dot_gyp: |
| home_dot_gyp = os.path.expanduser(home_dot_gyp) |
| if not home_dot_gyp: |
| home_vars = ['HOME'] |
| if sys.platform in ('cygwin', 'win32'): |
| home_vars.append('USERPROFILE') |
| for home_var in home_vars: |
| home = os.getenv(home_var) |
| if home != None: |
| home_dot_gyp = os.path.join(home, '.gyp') |
| if not os.path.exists(home_dot_gyp): |
| home_dot_gyp = None |
| else: |
| break |
| |
| if home_dot_gyp: |
| include_gypi = os.path.join(home_dot_gyp, "include.gypi") |
| if os.path.exists(include_gypi): |
| supplemental_files += [include_gypi] |
| |
| vars_dict = GetGypVarsForGN(supplemental_files) |
| gn_args = '' |
| |
| # Note: These are the additional flags passed to various builds by builders |
| # on the main waterfall. We'll probably need to add these at some point: |
| # mac_strip_release=1 http://crbug.com/330301 |
| # linux_dump_symbols=0 http://crbug.com/330300 |
| # host_os=linux Probably can skip, GN knows the host OS. |
| # order_text_section=<path> http://crbug.com/330299 |
| # chromium_win_pch=0 http://crbug.com/297678 |
| # chromium_ios_signing=0 http://crbug.com/330302 |
| # linux_use_tcmalloc=0 http://crbug.com/330303 |
| # release_extra_flags=... http://crbug.com/330305 |
| |
| # These tuples of (key, value, gn_arg_string) use the gn_arg_string for |
| # gn when the key is set to the given value in the GYP arguments. |
| remap_cases = [ |
| ('android_webview_build', '1', 'is_android_webview_build=true'), |
| ('branding', 'Chrome', 'is_chrome_branded=true'), |
| ('build_for_tool', 'drmemory', 'disable_iterator_debugging=true'), |
| ('build_for_tool', 'tsan', 'disable_iterator_debugging=true'), |
| ('buildtype', 'Official', 'is_official_build=true'), |
| ('component', 'shared_library', 'is_component_build=true'), |
| ('clang', '1', 'is_clang=true'), |
| ('clang_use_chrome_plugins', '0', 'clang_use_chrome_plugins=false'), |
| ('disable_glibcxx_debug', '1', 'disable_iterator_debugging=true'), |
| ('target_arch', 'ia32', 'cpu_arch="x86"'), |
| ('target_arch', 'x64', 'cpu_arch="x64" force_win64=true'), |
| ('target_arch', 'arm', 'cpu_arch="arm"'), |
| ('target_arch', 'mipsel', 'cpu_arch="mipsel"'), |
| ('fastbuild', '0', 'symbol_level=2'), |
| ('fastbuild', '1', 'symbol_level=1'), |
| ('fastbuild', '2', 'symbol_level=0'), |
| ('OS', 'ios', 'os="ios"'), |
| ('OS', 'android', 'os="android"'), |
| ('chromeos', '1', 'os="chromeos"'), |
| ('use_aura', '1', 'use_aura=true'), |
| ('use_goma', '1', 'use_goma=true'), |
| ('asan', '1', 'is_asan=true'), |
| ('lsan', '1', 'is_lsan=true'), |
| ('msan', '1', 'is_msan=true'), |
| ('tsan', '1', 'is_tsan=true'), |
| ] |
| for i in remap_cases: |
| if i[0] in vars_dict and vars_dict[i[0]] == i[1]: |
| gn_args += ' ' + i[2] |
| |
| # These string arguments get passed directly as GN strings. |
| for v in ['android_src', 'arm_float_abi', 'ios_deployment_target', |
| 'ios_sdk_path', 'windows_sdk_path']: |
| if v in vars_dict: |
| gn_args += ' ' + v + '=' + EscapeStringForGN(vars_dict[v]) |
| |
| # gomadir is renamed goma_dir in the GN build. |
| if 'gomadir' in vars_dict: |
| gn_args += ' goma_dir=%s' % EscapeStringForGN(vars_dict['gomadir']) |
| |
| # Set the "use_ios_simulator" flag if the ios_sdk_path is set. |
| if 'ios_sdk_path' in vars_dict: |
| if os.path.basename(vars_dict['ios_sdk_path']).lower().startswith( |
| 'iphonesimulator'): |
| gn_args += ' use_ios_simulator=true' |
| else: |
| gn_args += ' use_ios_simulator=false' |
| |
| # These arguments get passed directly as integers (avoiding the quoting and |
| # escaping of the string ones above). |
| for v in ['arm_version']: |
| if v in vars_dict: |
| gn_args += ' %s=%s' % (v, vars_dict[v]) |
| |
| # Some other flags come from GYP environment variables. |
| gyp_msvs_version = os.environ.get('GYP_MSVS_VERSION', '') |
| if gyp_msvs_version: |
| gn_args += ' visual_studio_version=' + EscapeStringForGN(gyp_msvs_version) |
| gyp_msvs_override_path = os.environ.get('GYP_MSVS_OVERRIDE_PATH', '') |
| if gyp_msvs_override_path: |
| gn_args += ' visual_studio_path=' + \ |
| EscapeStringForGN(gyp_msvs_override_path) |
| |
| # Set the GYP flag so BUILD files know they're being invoked in GYP mode. |
| gn_args += ' is_gyp=true' |
| |
| gyp_outdir = GetOutputDirectory() |
| gn_args += ' gyp_output_dir=\"%s\"' % gyp_outdir |
| |
| return gn_args.strip() |
| |
| |
| def additional_include_files(supplemental_files, args=[]): |
| """ |
| Returns a list of additional (.gypi) files to include, without duplicating |
| ones that are already specified on the command line. The list of supplemental |
| include files is passed in as an argument. |
| """ |
| # Determine the include files specified on the command line. |
| # This doesn't cover all the different option formats you can use, |
| # but it's mainly intended to avoid duplicating flags on the automatic |
| # makefile regeneration which only uses this format. |
| specified_includes = set() |
| for arg in args: |
| if arg.startswith('-I') and len(arg) > 2: |
| specified_includes.add(os.path.realpath(arg[2:])) |
| |
| result = [] |
| def AddInclude(path): |
| if os.path.realpath(path) not in specified_includes: |
| result.append(path) |
| |
| # Always include common.gypi. |
| AddInclude(os.path.join(script_dir, 'common.gypi')) |
| |
| # Optionally add supplemental .gypi files if present. |
| for supplement in supplemental_files: |
| AddInclude(supplement) |
| |
| return result |
| |
| |
| def RunGN(supplemental_includes): |
| """Runs GN, returning True if it succeeded, printing an error and returning |
| false if not.""" |
| |
| # The binaries in platform-specific subdirectories in src/tools/gn/bin. |
| gnpath = SRC_DIR + '/tools/gn/bin/' |
| if sys.platform in ('cygwin', 'win32'): |
| gnpath += 'win/gn.exe' |
| elif sys.platform.startswith('linux'): |
| # On Linux we have 32-bit and 64-bit versions. |
| if subprocess.check_output(["getconf", "LONG_BIT"]).find("64") >= 0: |
| gnpath += 'linux/gn' |
| else: |
| gnpath += 'linux/gn32' |
| elif sys.platform == 'darwin': |
| gnpath += 'mac/gn' |
| else: |
| print 'Unknown platform for GN: ', sys.platform |
| return False |
| |
| print 'Generating gyp files from GN...' |
| |
| # Need to pass both the source root (the bots don't run this command from |
| # within the source tree) as well as set the is_gyp value so the BUILD files |
| # to know they're being run under GYP. |
| args = [gnpath, 'gyp', '-q', |
| '--root=' + chrome_src, |
| '--args=' + GetArgsStringForGN(supplemental_includes), |
| '--output=//' + GetOutputDirectory() + '/gn_build/'] |
| return subprocess.call(args) == 0 |
| |
| |
| def CopyVsRuntimeDlls(output_dir, runtime_dirs): |
| """Copies the VS runtime DLLs from the given |runtime_dirs| to the output |
| directory so that even if not system-installed, built binaries are likely to |
| be able to run. |
| |
| This needs to be run after gyp has been run so that the expected target |
| output directories are already created. |
| """ |
| assert sys.platform.startswith(('win32', 'cygwin')) |
| |
| def copy_runtime(target_dir, source_dir, dll_pattern): |
| """Copy both the msvcr and msvcp runtime DLLs, only if the target doesn't |
| exist, but the target directory does exist.""" |
| for which in ('p', 'r'): |
| dll = dll_pattern % which |
| target = os.path.join(target_dir, dll) |
| source = os.path.join(source_dir, dll) |
| # If gyp generated to that output dir, and the runtime isn't already |
| # there, then copy it over. |
| if os.path.isdir(target_dir) and not os.path.isfile(target): |
| shutil.copyfile(source, target) |
| |
| x86, x64 = runtime_dirs |
| out_debug = os.path.join(output_dir, 'Debug') |
| out_release = os.path.join(output_dir, 'Release') |
| out_debug_x64 = os.path.join(output_dir, 'Debug_x64') |
| out_release_x64 = os.path.join(output_dir, 'Release_x64') |
| copy_runtime(out_debug, x86, 'msvc%s120d.dll') |
| copy_runtime(out_release, x86, 'msvc%s120.dll') |
| copy_runtime(out_debug_x64, x64, 'msvc%s120d.dll') |
| copy_runtime(out_release_x64, x64, 'msvc%s120.dll') |
| |
| |
| if __name__ == '__main__': |
| args = sys.argv[1:] |
| |
| if int(os.environ.get('GYP_CHROMIUM_NO_ACTION', 0)): |
| print 'Skipping gyp_chromium due to GYP_CHROMIUM_NO_ACTION env var.' |
| sys.exit(0) |
| |
| # Use the Psyco JIT if available. |
| if psyco: |
| psyco.profile() |
| print "Enabled Psyco JIT." |
| |
| # Fall back on hermetic python if we happen to get run under cygwin. |
| # TODO(bradnelson): take this out once this issue is fixed: |
| # http://code.google.com/p/gyp/issues/detail?id=177 |
| if sys.platform == 'cygwin': |
| depot_tools_path = find_depot_tools.add_depot_tools_to_path() |
| python_dir = sorted(glob.glob(os.path.join(depot_tools_path, |
| 'python2*_bin')))[-1] |
| env = os.environ.copy() |
| env['PATH'] = python_dir + os.pathsep + env.get('PATH', '') |
| p = subprocess.Popen( |
| [os.path.join(python_dir, 'python.exe')] + sys.argv, |
| env=env, shell=False) |
| p.communicate() |
| sys.exit(p.returncode) |
| |
| gyp_helper.apply_chromium_gyp_env() |
| |
| # This could give false positives since it doesn't actually do real option |
| # parsing. Oh well. |
| gyp_file_specified = False |
| for arg in args: |
| if arg.endswith('.gyp'): |
| gyp_file_specified = True |
| break |
| |
| # If we didn't get a file, check an env var, and then fall back to |
| # assuming 'all.gyp' from the same directory as the script. |
| if not gyp_file_specified: |
| gyp_file = os.environ.get('CHROMIUM_GYP_FILE') |
| if gyp_file: |
| # Note that CHROMIUM_GYP_FILE values can't have backslashes as |
| # path separators even on Windows due to the use of shlex.split(). |
| args.extend(shlex.split(gyp_file)) |
| else: |
| args.append(os.path.join(script_dir, 'all.gyp')) |
| |
| # There shouldn't be a circular dependency relationship between .gyp files, |
| # but in Chromium's .gyp files, on non-Mac platforms, circular relationships |
| # currently exist. The check for circular dependencies is currently |
| # bypassed on other platforms, but is left enabled on the Mac, where a |
| # violation of the rule causes Xcode to misbehave badly. |
| # TODO(mark): Find and kill remaining circular dependencies, and remove this |
| # option. http://crbug.com/35878. |
| # TODO(tc): Fix circular dependencies in ChromiumOS then add linux2 to the |
| # list. |
| if sys.platform not in ('darwin',): |
| args.append('--no-circular-check') |
| |
| # Default to ninja on linux and windows, but only if no generator has |
| # explicitly been set. |
| # Also default to ninja on mac, but only when not building chrome/ios. |
| # . -f / --format has precedence over the env var, no need to check for it |
| # . set the env var only if it hasn't been set yet |
| # . chromium.gyp_env has been applied to os.environ at this point already |
| if sys.platform.startswith('linux') and not os.environ.get('GYP_GENERATORS'): |
| os.environ['GYP_GENERATORS'] = 'ninja' |
| if sys.platform.startswith('win') and not os.environ.get('GYP_GENERATORS'): |
| os.environ['GYP_GENERATORS'] = 'ninja' |
| elif sys.platform == 'darwin' and not os.environ.get('GYP_GENERATORS') and \ |
| not 'OS=ios' in os.environ.get('GYP_DEFINES', []): |
| os.environ['GYP_GENERATORS'] = 'ninja' |
| |
| # If using ninja on windows, and the automatic toolchain has been installed |
| # by depot_tools, then use it. |
| vs2013_runtime_dll_dirs = None |
| if (sys.platform in ('win32', 'cygwin') and |
| os.environ.get('GYP_GENERATORS') == 'ninja'): |
| depot_tools_path = find_depot_tools.add_depot_tools_to_path() |
| toolchain = os.path.normpath(os.path.join( |
| depot_tools_path, 'win_toolchain', 'vs2013_files')) |
| version_file = os.path.join(toolchain, '.version') |
| if os.path.isdir(toolchain) and os.path.isfile(version_file): |
| os.environ['GYP_MSVS_OVERRIDE_PATH'] = toolchain |
| with open(version_file, 'r') as f: |
| version_is_pro = f.read().strip() == 'pro' |
| vs2013_runtime_dll_dirs = (os.path.join(toolchain, 'sys32'), |
| os.path.join(toolchain, 'sys64')) |
| os.environ['GYP_MSVS_VERSION'] = '2013' if version_is_pro else '2013e' |
| # We need to make sure windows_sdk_path is set to the automated |
| # toolchain values in GYP_DEFINES, but don't want to override any other |
| # values there. |
| gyp_defines_dict = gyp.NameValueListToDict(gyp.ShlexEnv('GYP_DEFINES')) |
| win8sdk = os.path.join(toolchain, 'win8sdk') |
| wdk = os.path.join(toolchain, 'wdk') |
| gyp_defines_dict['windows_sdk_path'] = win8sdk |
| os.environ['WINDOWSSDKDIR'] = win8sdk |
| os.environ['WDK_DIR'] = wdk |
| os.environ['GYP_DEFINES'] = ' '.join('%s=%s' % (k, pipes.quote(str(v))) |
| for k, v in gyp_defines_dict.iteritems()) |
| # Include the VS runtime in the PATH in case it's not machine-installed. |
| runtime_path = ';'.join(os.path.normpath(os.path.join(toolchain, s)) |
| for s in ('sys64', 'sys32')) |
| os.environ['PATH'] = runtime_path + ';' + os.environ['PATH'] |
| print('Using automatic toolchain in %s (%s edition).' % ( |
| toolchain, 'Pro' if version_is_pro else 'Express')) |
| |
| # If CHROMIUM_GYP_SYNTAX_CHECK is set to 1, it will invoke gyp with --check |
| # to enfore syntax checking. |
| syntax_check = os.environ.get('CHROMIUM_GYP_SYNTAX_CHECK') |
| if syntax_check and int(syntax_check): |
| args.append('--check') |
| |
| supplemental_includes = GetSupplementalFiles() |
| if not RunGN(supplemental_includes): |
| sys.exit(1) |
| args.extend( |
| ['-I' + i for i in additional_include_files(supplemental_includes, args)]) |
| |
| args.extend(['-D', 'gyp_output_dir=' + GetOutputDirectory()]) |
| |
| print 'Updating projects from gyp files...' |
| sys.stdout.flush() |
| |
| # Off we go... |
| gyp_rc = gyp.main(args) |
| |
| # Check for landmines (reasons to clobber the build). This must be run here, |
| # rather than a separate runhooks step so that any environment modifications |
| # from above are picked up. |
| print 'Running build/landmines.py...' |
| subprocess.check_call( |
| [sys.executable, os.path.join(script_dir, 'landmines.py')]) |
| |
| if vs2013_runtime_dll_dirs: |
| CopyVsRuntimeDlls(GetOutputDirectory(), vs2013_runtime_dll_dirs) |
| |
| sys.exit(gyp_rc) |