diff --git a/DEPS b/DEPS index 86df372747..1a07954419 100644 --- a/DEPS +++ b/DEPS @@ -6,7 +6,7 @@ vars = { 'extra_gyp_flag': '-Dextra_gyp_flag=0', 'chromium_git': 'https://chromium.googlesource.com', - 'chromium_revision': 'f86fb54ec35e00f6b5b744ddd35dc19049caae7c', + 'chromium_revision': 'dd442d48128ff3043c105d83b922806e4c4f9080', } # NOTE: Use http rather than https; the latter can cause problems for users diff --git a/webrtc/build/chromium_common.gypi b/webrtc/build/chromium_common.gypi new file mode 100644 index 0000000000..c8e613497f --- /dev/null +++ b/webrtc/build/chromium_common.gypi @@ -0,0 +1,5973 @@ +# Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. +# +# Use of this source code is governed by a BSD-style license +# that can be found in the LICENSE file in the root of the source +# tree. An additional intellectual property rights grant can be found +# in the file PATENTS. All contributing project authors may +# be found in the AUTHORS file in the root of the source tree. + +# This ia copy of Chromium's common.gypi before it was deleted. +# TODO(kjellander): Clean this up as soon we've stopped using GYP entirely. +{ + # Variables expected to be overriden on the GYP command line (-D) or by + # ~/.gyp/include.gypi. + 'variables': { + # Putting a variables dict inside another variables dict looks kind of + # weird. This is done so that 'host_arch', 'chromeos', etc are defined as + # variables within the outer variables dict here. This is necessary + # to get these variables defined for the conditions within this variables + # dict that operate on these variables. + 'variables': { + 'variables': { + 'variables': { + 'variables': { + # Whether we're building a ChromeOS build. + 'chromeos%': 0, + # Whether we're building the cast (chromecast) shell + 'chromecast%': 0, + # Whether or not we are using the Aura windowing framework. + 'use_aura%': 0, + # Whether or not we are building the Ash shell. + 'use_ash%': 0, + # Whether or not we are using CRAS, the ChromeOS Audio Server. + 'use_cras%': 0, + # Use a raw surface abstraction. + 'use_ozone%': 0, + # Configure the build for small devices. See crbug.com/318413 + 'embedded%': 0, + 'conditions': [ + # Compute the architecture that we're building on. + ['OS=="win" or OS=="ios"', { + 'host_arch%': 'ia32', + }, { + 'host_arch%': '= 4.8 or clang. + # http://gcc.gnu.org/wiki/DebugFission + ['OS=="linux" and target_arch=="x64"', { + 'linux_use_debug_fission%': 1, + }, { + 'linux_use_debug_fission%': 0, + }], + ['OS=="android" or OS=="ios"', { + 'enable_captive_portal_detection%': 0, + }, { + 'enable_captive_portal_detection%': 1, + }], + # Enable Skia UI text drawing incrementally on different platforms. + # http://crbug.com/105550 + # + # On Aura, this allows per-tile painting to be used in the browser + # compositor. + ['OS!="android" and OS!="ios"', { + 'use_canvas_skia%': 1, + }], + ['chromeos==1', { + 'enable_basic_printing%': 1, + 'enable_print_preview%': 1, + }], + # Whether tests targets should be run, archived or just have the + # dependencies verified. All the tests targets have the '_run' suffix, + # e.g. base_unittests_run runs the target base_unittests. The test + # target always calls tools/swarming_client/isolate.py. See the script's + # --help for more information. Meant to be overriden with GYP_DEFINES. + # TODO(maruel): Remove the conditions as more configurations are + # supported. + ['OS!="ios" and OS!="android" and chromeos==0 and OS!="openbsd" and OS!="freebsd"', { + 'test_isolation_mode%': 'check', + }, { + 'test_isolation_mode%': 'noop', + }], + # Whether Android build uses OpenMAX DL FFT. + ['OS=="android" and ((target_arch=="arm" and arm_version >= 7) or target_arch=="ia32" or target_arch=="x64" or target_arch=="arm64" or target_arch=="mipsel")', { + # Currently only supported on Android ARMv7+, ARM64, ia32, x64 and mipsel. + # When enabled, this will also enable WebAudio support on + # Android for these architectures. Default is enabled. Whether + # WebAudio is actually available depends on runtime settings + # and flags. + 'use_openmax_dl_fft%': 1, + }, { + 'use_openmax_dl_fft%': 0, + }], + ['OS=="win" or OS=="linux" or OS=="openbsd" or OS=="freebsd"', { + 'enable_mdns%' : 1, + }], + # Disable various features by default on embedded. + ['embedded==1', { + 'remoting%': 0, + 'enable_basic_printing%': 0, + 'enable_print_preview%': 0, + }], + ['sysroot!=""', { + 'pkg-config': '<(chroot_cmd) <(DEPTH)/build/linux/pkg-config-wrapper "<(sysroot)" "<(target_arch)" "<(system_libdir)"', + }, { + 'pkg-config': 'pkg-config' + }], + # Enable WebVR support by default on Android + # Still requires command line flag to access API + ['OS=="android"', { + 'enable_webvr%': 1, + }, { + 'enable_webvr%': 0, + }], + ['order_profiling==0', { + # Set to 1 to enable fast builds. Set to 2 for even faster builds + # (it disables debug info for fastest compilation - only for use + # on compile-only bots). + 'fastbuild%': 0, + }, { + # With instrumentation enabled, debug info puts libchrome.so over 4gb, + # which causes the linker to produce an invalid ELF. + # http://crbug.com/574476 + 'fastbuild%': 2, + }], + ], + # Kasko reporting is disabled by default, but may get enabled below. + 'kasko%': 0, + # Setting this to '0' will cause V8's startup snapshot to be + # embedded in the binary instead of being a external files. + 'v8_use_external_startup_data%': 1, + # Set this to 1 to enable use of concatenated impulse responses + # for the HRTF panner in WebAudio. + 'use_concatenated_impulse_responses': 1, + # You can set the variable 'use_official_google_api_keys' to 1 + # to use the Google-internal file containing official API keys + # for Google Chrome even in a developer build. Setting this + # variable explicitly to 1 will cause your build to fail if the + # internal file is missing. + # + # The variable is documented here, but not handled in this file; + # see //google_apis/determine_use_official_keys.gypi for the + # implementation. + # + # Set the variable to 0 to not use the internal file, even when + # it exists in your checkout. + # + # Leave it unset in your include.gypi to have the variable + # implicitly set to 1 if you have + # src/google_apis/internal/google_chrome_api_keys.h in your + # checkout, and implicitly set to 0 if not. + # + # Note that official builds always behave as if the variable + # was explicitly set to 1, i.e. they always use official keys, + # and will fail to build if the internal file is missing. + # + # NOTE: You MUST NOT explicitly set the variable to 2 in your + # include.gypi or by other means. Due to subtleties of GYP, this + # is not the same as leaving the variable unset, even though its + # default value in + # //google_apis/determine_use_official_keys.gypi is 2. + # Set these to bake the specified API keys and OAuth client + # IDs/secrets into your build. + # + # If you create a build without values baked in, you can instead + # set environment variables to provide the keys at runtime (see + # src/google_apis/google_api_keys.h for details). Features that + # require server-side APIs may fail to work if no keys are + # provided. + # + # Note that if you are building an official build or if + # use_official_google_api_keys has been set to 1 (explicitly or + # implicitly), these values will be ignored and the official + # keys will be used instead. + 'google_api_key%': '', + 'google_default_client_id%': '', + 'google_default_client_secret%': '', + # Native Client is enabled by default. + 'disable_nacl%': '0', + # Native Client toolchains, enabled by default. + 'disable_pnacl%': 0, + 'disable_newlib%': 0, + # Sets the default version name and code for Android app, by default we + # do a developer build. + 'android_app_version_name%': 'Developer Build', + 'android_app_version_code%': 1, + # Use the internal version of the framework to build Android WebView. + 'use_webview_internal_framework%': 0, + }, + # Copy conditionally-set variables out one scope. + 'branding%': '<(branding)', + 'branding_path_component%': '<(branding_path_component)', + 'buildtype%': '<(buildtype)', + 'target_arch%': '<(target_arch)', + 'target_subarch%': '<(target_subarch)', + 'mips_arch_variant%': '<(mips_arch_variant)', + 'mips_dsp_rev%': '<(mips_dsp_rev)', + 'mips_msa%': '<(mips_msa)', + 'host_arch%': '<(host_arch)', + 'toolkit_views%': '<(toolkit_views)', + 'ui_compositor_image_transport%': '<(ui_compositor_image_transport)', + 'use_aura%': '<(use_aura)', + 'use_ash%': '<(use_ash)', + 'use_cras%': '<(use_cras)', + 'use_libpci%': '<(use_libpci)', + 'use_openssl_certs%': '<(use_openssl_certs)', + 'use_external_popup_menu%': '<(use_external_popup_menu)', + 'use_nss_certs%': '<(use_nss_certs)', + 'use_udev%': '<(use_udev)', + 'os_bsd%': '<(os_bsd)', + 'os_posix%': '<(os_posix)', + 'use_dbus%': '<(use_dbus)', + 'use_glib%': '<(use_glib)', + 'use_pango%': '<(use_pango)', + 'use_cairo%': '<(use_cairo)', + 'use_ozone%': '<(use_ozone)', + 'use_ozone_evdev%': '<(use_ozone_evdev)', + 'use_xkbcommon%': '<(use_xkbcommon)', + 'use_gtk3%': '<(use_gtk3)', + 'use_clipboard_aurax11%': '<(use_clipboard_aurax11)', + 'desktop_linux%': '<(desktop_linux)', + 'use_x11%': '<(use_x11)', + 'use_gnome_keyring%': '<(use_gnome_keyring)', + 'linux_fpic%': '<(linux_fpic)', + 'chromeos%': '<(chromeos)', + 'chromecast%': '<(chromecast)', + 'is_cast_desktop_build%': '<(is_cast_desktop_build)', + 'enable_viewport%': '<(enable_viewport)', + 'enable_hidpi%': '<(enable_hidpi)', + 'enable_wayland_server%': '<(enable_wayland_server)', + 'enable_wifi_display%': '<(enable_wifi_display)', + 'image_loader_extension%': '<(image_loader_extension)', + 'fastbuild%': '<(fastbuild)', + 'win_z7%': '<(win_z7)', + 'dcheck_always_on%': '<(dcheck_always_on)', + 'tracing_like_official_build%': '<(tracing_like_official_build)', + 'fieldtrial_testing_like_official_build%': '<(fieldtrial_testing_like_official_build)', + 'arm_version%': '<(arm_version)', + 'arm_neon%': '<(arm_neon)', + 'arm_neon_optional%': '<(arm_neon_optional)', + 'sysroot%': '<(sysroot)', + 'use_sysroot%': '<(use_sysroot)', + 'pkg-config%': '<(pkg-config)', + 'chroot_cmd%': '<(chroot_cmd)', + 'system_libdir%': '<(system_libdir)', + 'component%': '<(component)', + 'win_analyze%': '<(win_analyze)', + 'win_fastlink%': '<(win_fastlink)', + 'chrome_pgo_phase%': '<(chrome_pgo_phase)', + 'full_wpo_on_official%': '<(full_wpo_on_official)', + 'enable_resource_whitelist_generation%': '<(enable_resource_whitelist_generation)', + 'use_titlecase_in_grd%': '<(use_titlecase_in_grd)', + 'remoting%': '<(remoting)', + 'enable_one_click_signin%': '<(enable_one_click_signin)', + 'enable_media_router%': '<(enable_media_router)', + 'enable_webrtc%': '<(enable_webrtc)', + 'chromium_win_pch%': '<(chromium_win_pch)', + 'configuration_policy': '<(configuration_policy)', + 'safe_browsing%': '<(safe_browsing)', + 'enable_web_speech%': '<(enable_web_speech)', + 'enable_hotwording%': '<(enable_hotwording)', + 'notifications%': '<(notifications)', + 'clang_use_chrome_plugins%': '<(clang_use_chrome_plugins)', + 'mac_want_real_dsym%': '<(mac_want_real_dsym)', + 'asan%': '<(asan)', + 'asan_blacklist%': '<(asan_blacklist)', + 'sanitizer_coverage%': '<(sanitizer_coverage)', + 'asan_field_padding%': '<(asan_field_padding)', + 'use_sanitizer_options%': '<(use_sanitizer_options)', + 'syzyasan%': '<(syzyasan)', + 'kasko%': '<(kasko)', + 'syzygy_optimize%': '<(syzygy_optimize)', + 'lsan%': '<(lsan)', + 'msan%': '<(msan)', + 'msan_blacklist%': '<(msan_blacklist)', + 'msan_track_origins%': '<(msan_track_origins)', + 'tsan%': '<(tsan)', + 'tsan_blacklist%': '<(tsan_blacklist)', + 'ubsan%': '<(ubsan)', + 'ubsan_blacklist%': '<(ubsan_blacklist)', + 'ubsan_security%': '<(ubsan_security)', + 'ubsan_security_blacklist%': '<(ubsan_security_blacklist)', + 'ubsan_vptr%': '<(ubsan_vptr)', + 'ubsan_vptr_blacklist%': '<(ubsan_vptr_blacklist)', + 'use_instrumented_libraries%': '<(use_instrumented_libraries)', + 'use_prebuilt_instrumented_libraries%': '<(use_prebuilt_instrumented_libraries)', + 'use_custom_libcxx%': '<(use_custom_libcxx)', + 'order_profiling%': '<(order_profiling)', + 'order_text_section%': '<(order_text_section)', + 'enable_extensions%': '<(enable_extensions)', + 'enable_pdf%': '<(enable_pdf)', + 'pdf_enable_v8%': '<(pdf_enable_v8)', + 'pdf_enable_xfa%': '<(pdf_enable_xfa)', + 'enable_plugin_installation%': '<(enable_plugin_installation)', + 'enable_plugins%': '<(enable_plugins)', + 'enable_session_service%': '<(enable_session_service)', + 'enable_themes%': '<(enable_themes)', + 'linux_use_bundled_gold%': '<(linux_use_bundled_gold)', + 'linux_use_bundled_binutils%': '<(linux_use_bundled_binutils)', + 'linux_use_gold_flags%': '<(linux_use_gold_flags)', + 'linux_use_debug_fission%': '<(linux_use_debug_fission)', + 'use_canvas_skia%': '<(use_canvas_skia)', + 'test_isolation_mode%': '<(test_isolation_mode)', + 'enable_basic_printing%': '<(enable_basic_printing)', + 'enable_print_preview%': '<(enable_print_preview)', + 'enable_spellcheck%': '<(enable_spellcheck)', + 'use_browser_spellchecker%': '<(use_browser_spellchecker)', + 'use_minikin_hyphenation%': '<(use_minikin_hyphenation)', + 'cld2_table_size%': '<(cld2_table_size)', + 'enable_captive_portal_detection%': '<(enable_captive_portal_detection)', + 'disable_file_support%': '<(disable_file_support)', + 'disable_ftp_support%': '<(disable_ftp_support)', + 'use_platform_icu_alternatives%': '<(use_platform_icu_alternatives)', + 'disable_brotli_filter%': '<(disable_brotli_filter)', + 'enable_task_manager%': '<(enable_task_manager)', + 'wix_path%': '<(wix_path)', + 'use_libjpeg_turbo%': '<(use_libjpeg_turbo)', + 'use_system_libjpeg%': '<(use_system_libjpeg)', + 'android_channel%': '<(android_channel)', + 'icu_use_data_file_flag%': '<(icu_use_data_file_flag)', + 'gyp_managed_install%': 0, + 'create_standalone_apk%': 1, + 'enable_app_list%': '<(enable_app_list)', + 'use_default_render_theme%': '<(use_default_render_theme)', + 'google_api_key%': '<(google_api_key)', + 'google_default_client_id%': '<(google_default_client_id)', + 'google_default_client_secret%': '<(google_default_client_secret)', + 'enable_supervised_users%': '<(enable_supervised_users)', + 'enable_mdns%' : '<(enable_mdns)', + 'enable_service_discovery%' : '<(enable_service_discovery)', + 'enable_hangout_services_extension%' : '<(enable_hangout_services_extension)', + 'proprietary_codecs%': '<(proprietary_codecs)', + 'use_goma%': '<(use_goma)', + 'gomadir%': '<(gomadir)', + 'use_lto%': '<(use_lto)', + 'use_lto_o2%': '<(use_lto_o2)', + 'gold_icf_level%': '<(gold_icf_level)', + 'v8_use_external_startup_data%': '<(v8_use_external_startup_data)', + 'cfi_vptr%': '<(cfi_vptr)', + 'cfi_cast%': '<(cfi_cast)', + 'cfi_diag%': '<(cfi_diag)', + 'cfi_blacklist%': '<(cfi_blacklist)', + 'mac_views_browser%': '<(mac_views_browser)', + 'android_app_version_name%': '<(android_app_version_name)', + 'android_app_version_code%': '<(android_app_version_code)', + 'use_webview_internal_framework%': '<(use_webview_internal_framework)', + 'enable_webvr%': '<(enable_webvr)', + # Turns on compiler optimizations in V8 in Debug build. + 'v8_optimized_debug%': 1, + # Use system protobuf instead of bundled one. + 'use_system_protobuf%': 0, + # Use system yasm instead of bundled one. + 'use_system_yasm%': 0, + # Use system ICU instead of bundled one. + 'use_system_icu%' : 0, + # Default to enabled PIE; this is important for ASLR but we may need to be + # able to turn it off for various reasons. + 'linux_disable_pie%': 0, + # The release channel that this build targets. This is used to restrict + # channel-specific build options, like which installer packages to create. + # The default is 'all', which does no channel-specific filtering. + 'channel%': 'all', + # Override chromium_mac_pch and set it to 0 to suppress the use of + # precompiled headers on the Mac. Prefix header injection may still be + # used, but prefix headers will not be precompiled. This is useful when + # using distcc to distribute a build to compile slaves that don't + # share the same compiler executable as the system driving the compilation, + # because precompiled headers rely on pointers into a specific compiler + # executable's image. Setting this to 0 is needed to use an experimental + # Linux-Mac cross compiler distcc farm. + 'chromium_mac_pch%': 1, + # The default value for mac_strip in target_defaults. This cannot be + # set there, per the comment about variable% in a target_defaults. + 'mac_strip_release%': 0, + # Set to 1 to enable java code coverage. Instruments classes during build + # to produce .ec files during runtime. + 'emma_coverage%': 0, + # EMMA filter string consisting of a list of inclusion/exclusion patterns + # separated with whitespace and/or comma. Only has effect if + # 'emma_coverage=1'. + 'emma_filter%': '', + # Set to 1 to enable running Android lint on java/class files. + 'android_lint%': 1, + # Although base/allocator lets you select a heap library via an + # environment variable, the shim it uses sometimes gets in the way. + # To disable it entirely, and switch to normal msvcrt, do e.g. + # 'win_use_allocator_shim': 0, + # 'win_release_RuntimeLibrary': 2 + # to ~/.gyp/include.gypi, gclient runhooks --force, and do a release build. + 'win_use_allocator_shim%': 1, # 1 = shim allocator; 0 = msvcrt + # Enables the unified allocator shim (experimental) which routes all the + # alloc calls to base/. Right now is supported on Linux Desktop only. + # http://crbug.com/550886 . + 'use_experimental_allocator_shim%': 0, + # TODO(bradnelson): eliminate this when possible. + # To allow local gyp files to prevent release.vsprops from being included. + # Yes(1) means include release.vsprops. + # Once all vsprops settings are migrated into gyp, this can go away. + 'msvs_use_common_release%': 1, + # TODO(bradnelson): eliminate this when possible. + # To allow local gyp files to override additional linker options for msvs. + # Yes(1) means set use the common linker options. + 'msvs_use_common_linker_extras%': 1, + # TODO(sgk): eliminate this if possible. + # It would be nicer to support this via a setting in 'target_defaults' + # in chrome/app/locales/locales.gypi overriding the setting in the + # 'Debug' configuration in the 'target_defaults' dict below, + # but that doesn't work as we'd like. + 'msvs_debug_link_incremental%': '2', + # Needed for some of the largest modules. + 'msvs_debug_link_nonincremental%': '1', + # Turns on Use Library Dependency Inputs for linking chrome.dll on Windows + # to get incremental linking to be faster in debug builds. + 'incremental_chrome_dll%': '0', + # Experimental setting to break chrome.dll into multiple pieces based on + # process type. + 'chrome_multiple_dll%': '0', + # Whether the VS xtree header has been patched to disable warning 4702. If + # it has, then we don't need to disable 4702 (unreachable code warning). + # The patch is preapplied to the internal toolchain and hence all bots. + 'msvs_xtree_patched%': '. Additional + # documentation on these macros is available at + # http://developer.apple.com/mac/library/technotes/tn2002/tn2064.html#SECTION3 + # Chrome normally builds with the Mac OS X 10.10 SDK and sets the + # deployment target to 10.7. Other projects, such as O3D, may + # override these defaults. + # Normally, mac_sdk_min is used to find an SDK that Xcode knows + # about that is at least the specified version. In official builds, + # the SDK must match mac_sdk_min exactly. If the SDK is installed + # someplace that Xcode doesn't know about, set mac_sdk_path to the + # path to the SDK; when set to a non-empty string, SDK detection + # based on mac_sdk_min will be bypassed entirely. + 'mac_deployment_target%': '10.7', + 'mac_sdk_min%': '10.10', + 'mac_sdk_path%': '', + }, + 'mac_sdk_min': '<(mac_sdk_min)', + 'mac_sdk_path': '<(mac_sdk_path)', + 'mac_deployment_target': '<(mac_deployment_target)', + # Compile in Breakpad support by default so that it can be + # tested, even if it is not enabled by default at runtime. + 'mac_breakpad_compiled_in%': 1, + 'conditions': [ + # mac_product_name is set to the name of the .app bundle as it should + # appear on disk. This duplicates data from + # chrome/app/theme/chromium/BRANDING and + # chrome/app/theme/google_chrome/BRANDING, but is necessary to get + # these names into the build system. + ['branding=="Chrome"', { + 'mac_product_name%': 'Google Chrome', + }, { # else: branding!="Chrome" + 'mac_product_name%': 'Chromium', + }], + # Official mac builds require a specific OS X SDK, but iOS and + # non-official mac builds do not. + ['branding=="Chrome" and buildtype=="Official" and OS=="mac"', { + 'mac_sdk%': '(nacl_untrusted_build)==1', { + 'defines': [ + 'USE_OPENSSL_CERTS=1', + ], + }], + ['<(use_glib)==1 and >(nacl_untrusted_build)==0', { + 'defines': ['USE_GLIB=1'], + }], + ['<(use_nss_certs)==1 and >(nacl_untrusted_build)==0', { + 'defines': ['USE_NSS_CERTS=1'], + }], + ['<(chromeos)==1 and >(nacl_untrusted_build)==0', { + 'defines': ['OS_CHROMEOS=1'], + }], + ['<(asan)==1 and >(nacl_untrusted_build)==0', { + 'defines': [ + 'ADDRESS_SANITIZER', + 'MEMORY_TOOL_REPLACES_ALLOCATOR', + 'MEMORY_SANITIZER_INITIAL_SIZE', + ], + }], + ['enable_wexit_time_destructors==1 and OS!="win"', { + # TODO: Enable on Windows too, http://crbug.com/404525 + 'variables': { 'clang_warning_flags': ['-Wexit-time-destructors']}, + }], + ['chromium_code==0', { + 'variables': { + 'clang_warning_flags': [ + # Lots of third-party libraries have unused variables. Instead of + # suppressing them individually, we just blanket suppress them here. + '-Wno-unused-variable', + ], + }, + 'conditions': [ + [ 'os_posix==1 and OS!="mac" and OS!="ios"', { + # Remove -Wextra for third-party code. + 'cflags!': [ '-Wextra' ], + 'cflags_cc': [ + # Don't warn about hash_map in third-party code. + '-Wno-deprecated', + ], + }], + [ 'os_posix==1 and clang!=1 and OS!="mac" and OS!="ios"', { + # When we don't control the compiler, don't use -Wall for + # third-party code either. + 'cflags!': [ '-Wall' ], + }], + # TODO: Fix all warnings on chromeos too. + [ 'os_posix==1 and OS!="mac" and OS!="ios" and (clang!=1 or chromeos==1)', { + 'cflags!': [ + '-Werror', + ], + }], + [ 'OS=="win"', { + 'defines': [ + '_CRT_SECURE_NO_DEPRECATE', + '_CRT_NONSTDC_NO_WARNINGS', + '_CRT_NONSTDC_NO_DEPRECATE', + '_SCL_SECURE_NO_DEPRECATE', + ], + 'msvs_disabled_warnings': [ + # forcing value to bool 'true' or 'false' (performance warning) + 4800, + ], + 'msvs_settings': { + 'VCCLCompilerTool': { + 'WarningLevel': '3', + 'WarnAsError': 'true', + 'Detect64BitPortabilityProblems': 'false', + }, + }, + 'conditions': [ + ['buildtype=="Official"', { + 'msvs_settings': { + 'VCCLCompilerTool': { 'WarnAsError': 'false' }, + } + }], + [ 'component=="shared_library"', { + # TODO(darin): Unfortunately, some third_party code depends on base. + 'msvs_disabled_warnings': [ + 4251, # class 'std::xx' needs to have dll-interface. + ], + }], + ], + }], + [ 'OS=="mac" or OS=="ios"', { + 'xcode_settings': { + 'WARNING_CFLAGS!': ['-Wextra'], + }, + 'conditions': [ + ['buildtype=="Official"', { + 'xcode_settings': { + 'GCC_TREAT_WARNINGS_AS_ERRORS': 'NO', # -Werror + }, + }], + ], + }], + [ 'OS=="ios"', { + 'xcode_settings': { + 'RUN_CLANG_STATIC_ANALYZER': 'NO', + # Several internal ios directories generate numerous warnings for + # -Wobjc-missing-property-synthesis. + 'CLANG_WARN_OBJC_MISSING_PROPERTY_SYNTHESIS': 'NO', + }, + }], + ], + }, { + # In Chromium code, we define __STDC_foo_MACROS in order to get the + # C99 macros on Mac and Linux. + 'defines': [ + '__STDC_CONSTANT_MACROS', + '__STDC_FORMAT_MACROS', + ], + 'conditions': [ + ['OS=="win"', { + # turn on warnings for signed/unsigned mismatch on chromium code. + 'msvs_settings': { + 'VCCLCompilerTool': { + 'AdditionalOptions': ['/we4389'], + }, + }, + }], + ['OS=="win" and component=="shared_library"', { + 'msvs_disabled_warnings': [ + 4251, # class 'std::xx' needs to have dll-interface. + ], + }], + ], + }], + ], # target_conditions for 'target_defaults' + 'default_configuration': 'Debug', + 'configurations': { + # VCLinkerTool LinkIncremental values below: + # 0 == default + # 1 == /INCREMENTAL:NO + # 2 == /INCREMENTAL + # Debug links incremental, Release does not. + # + # Abstract base configurations to cover common attributes. + # + 'Common_Base': { + 'abstract': 1, + 'msvs_configuration_attributes': { + 'OutputDirectory': '<(DEPTH)\\build\\<(build_dir_prefix)$(ConfigurationName)', + 'IntermediateDirectory': '$(OutDir)\\obj\\$(ProjectName)', + 'CharacterSet': '1', + }, + 'msvs_settings':{ + 'VCCLCompilerTool': { + 'AdditionalOptions': [ + '/bigobj', + # Tell the compiler to crash on failures. This is undocumented + # and unsupported but very handy. + '/d2FastFail', + ], + }, + 'VCLinkerTool': { + # Add the default import libs. + 'AdditionalDependencies': [ + 'kernel32.lib', + 'gdi32.lib', + 'winspool.lib', + 'comdlg32.lib', + 'advapi32.lib', + 'shell32.lib', + 'ole32.lib', + 'oleaut32.lib', + 'user32.lib', + 'uuid.lib', + 'odbc32.lib', + 'odbccp32.lib', + 'delayimp.lib', + 'credui.lib', + ], + 'AdditionalOptions': [ + # Suggested by Microsoft Devrel to avoid + # LINK : fatal error LNK1248: image size (80000000) exceeds maximum allowable size (80000000) + # which started happening more regularly after VS2013 Update 4. + # Needs to be a bit lower for VS2015, or else errors out. + '/maxilksize:0x7ff00000', + # Tell the linker to crash on failures. + '/fastfail', + ], + }, + }, + 'conditions': [ + ['OS=="win" and win_fastlink==1 and MSVS_VERSION != "2013"', { + 'msvs_settings': { + 'VCLinkerTool': { + # /PROFILE is incompatible with /debug:fastlink + 'Profile': 'false', + 'AdditionalOptions': [ + # Tell VS 2015+ to create a PDB that references debug + # information in .obj and .lib files instead of copying + # it all. + '/DEBUG:FASTLINK', + ], + }, + }, + }], + ['OS=="win" and MSVS_VERSION == "2015"', { + 'msvs_settings': { + 'VCCLCompilerTool': { + 'AdditionalOptions': [ + # Work around crbug.com/526851, bug in VS 2015 RTM compiler. + '/Zc:sizedDealloc-', + # Disable thread-safe statics to avoid overhead and because + # they are disabled on other platforms. See crbug.com/587210 + # and -fno-threadsafe-statics. + '/Zc:threadSafeInit-', + ], + }, + }, + }], + ], + }, + 'x86_Base': { + 'abstract': 1, + 'msvs_settings': { + 'VCLinkerTool': { + 'MinimumRequiredVersion': '5.01', # XP. + 'TargetMachine': '1', + }, + 'VCLibrarianTool': { + 'TargetMachine': '1', + }, + }, + 'msvs_configuration_platform': 'Win32', + }, + 'x64_Base': { + 'abstract': 1, + 'msvs_configuration_platform': 'x64', + 'msvs_settings': { + 'VCLinkerTool': { + # Make sure to understand http://crbug.com/361720 if you want to + # increase this. + 'MinimumRequiredVersion': '5.02', # Server 2003. + 'TargetMachine': '17', # x86 - 64 + 'AdditionalLibraryDirectories!': + ['<(windows_sdk_path)/Lib/10.0.10586.0/um/x86'], + 'AdditionalLibraryDirectories': + ['<(windows_sdk_path)/Lib/10.0.10586.0/um/x64'], + # Doesn't exist x64 SDK. Should use oleaut32 in any case. + 'IgnoreDefaultLibraryNames': [ 'olepro32.lib' ], + }, + 'VCLibrarianTool': { + 'AdditionalLibraryDirectories!': + ['<(windows_sdk_path)/Lib/10.0.10586.0/um/x86'], + 'AdditionalLibraryDirectories': + ['<(windows_sdk_path)/Lib/10.0.10586.0/um/x64'], + 'TargetMachine': '17', # x64 + }, + }, + }, + 'Debug_Base': { + 'abstract': 1, + 'defines': [ + 'DYNAMIC_ANNOTATIONS_ENABLED=1', + 'WTF_USE_DYNAMIC_ANNOTATIONS=1', + ], + 'xcode_settings': { + 'GCC_OPTIMIZATION_LEVEL': '<(mac_debug_optimization)', + 'OTHER_CFLAGS': [ + '<@(debug_extra_cflags)', + ], + }, + 'msvs_settings': { + 'VCCLCompilerTool': { + 'Optimization': '<(win_debug_Optimization)', + 'PreprocessorDefinitions': ['_DEBUG'], + 'BasicRuntimeChecks': '<(win_debug_RuntimeChecks)', + 'RuntimeLibrary': '<(win_debug_RuntimeLibrary)', + 'conditions': [ + # According to MSVS, InlineFunctionExpansion=0 means + # "default inlining", not "/Ob0". + # Thus, we have to handle InlineFunctionExpansion==0 separately. + ['win_debug_InlineFunctionExpansion==0', { + 'AdditionalOptions': ['/Ob0'], + }], + ['win_debug_InlineFunctionExpansion!=""', { + 'InlineFunctionExpansion': + '<(win_debug_InlineFunctionExpansion)', + }], + ['win_debug_disable_iterator_debugging==1', { + 'PreprocessorDefinitions': ['_HAS_ITERATOR_DEBUGGING=0'], + }], + # if win_debug_OmitFramePointers is blank, leave as default + ['win_debug_OmitFramePointers==1', { + 'OmitFramePointers': 'true', + }], + ['win_debug_OmitFramePointers==0', { + 'OmitFramePointers': 'false', + # The above is not sufficient (http://crbug.com/106711): it + # simply eliminates an explicit "/Oy", but both /O2 and /Ox + # perform FPO regardless, so we must explicitly disable. + # We still want the false setting above to avoid having + # "/Oy /Oy-" and warnings about overriding. + 'AdditionalOptions': ['/Oy-'], + }], + ], + 'AdditionalOptions': [ '<@(win_debug_extra_cflags)', ], + }, + 'VCLinkerTool': { + 'LinkIncremental': '<(msvs_debug_link_incremental)', + # ASLR makes debugging with windbg difficult because Chrome.exe and + # Chrome.dll share the same base name. As result, windbg will + # name the Chrome.dll module like chrome_, where + # typically changes with each launch. This in turn + # means that breakpoints in Chrome.dll don't stick from one launch + # to the next. For this reason, we turn ASLR off in debug builds. + # Note that this is a three-way bool, where 0 means to pick up + # the default setting, 1 is off and 2 is on. + 'RandomizedBaseAddress': 1, + }, + 'VCResourceCompilerTool': { + 'PreprocessorDefinitions': ['_DEBUG'], + }, + }, + 'variables': { + 'clang_warning_flags': [ + # Allow comparing the address of references and 'this' against 0 + # in debug builds. Technically, these can never be null in + # well-defined C/C++ and Clang can optimize such checks away in + # release builds, but they may be used in asserts in debug builds. + '-Wno-undefined-bool-conversion', + '-Wno-tautological-undefined-compare', + ], + }, + 'conditions': [ + ['OS=="linux" or OS=="android"', { + 'target_conditions': [ + ['_toolset=="target"', { + 'cflags': [ + '<@(debug_extra_cflags)', + ], + }], + ], + }], + ['OS=="linux" and target_arch!="ia32" and disable_glibcxx_debug==0', { + # Enable libstdc++ debugging facilities to help catch problems + # early, see http://crbug.com/65151 . + # TODO(phajdan.jr): Should we enable this for all of POSIX? + 'defines': ['_GLIBCXX_DEBUG=1',], + }], + ['release_valgrind_build==0', { + 'xcode_settings': { + 'OTHER_CFLAGS': [ + '-fstack-protector-strong', # Implies -fstack-protector + ], + }, + }], + ], + }, + 'Release_Base': { + 'abstract': 1, + 'defines': [ + 'NDEBUG', + ], + 'xcode_settings': { + 'DEAD_CODE_STRIPPING': 'YES', # -Wl,-dead_strip + 'GCC_OPTIMIZATION_LEVEL': '<(mac_release_optimization)', + 'OTHER_CFLAGS': [ '<@(release_extra_cflags)', ], + }, + 'msvs_settings': { + 'VCCLCompilerTool': { + 'RuntimeLibrary': '<(win_release_RuntimeLibrary)', + 'conditions': [ + # In official builds, each target will self-select + # an optimization level. + ['buildtype!="Official"', { + 'Optimization': '<(win_release_Optimization)', + }, + ], + # According to MSVS, InlineFunctionExpansion=0 means + # "default inlining", not "/Ob0". + # Thus, we have to handle InlineFunctionExpansion==0 separately. + ['win_release_InlineFunctionExpansion==0', { + 'AdditionalOptions': ['/Ob0'], + }], + ['win_release_InlineFunctionExpansion!=""', { + 'InlineFunctionExpansion': + '<(win_release_InlineFunctionExpansion)', + }], + # if win_release_OmitFramePointers is blank, leave as default + ['win_release_OmitFramePointers==1', { + 'OmitFramePointers': 'true', + }], + ['win_release_OmitFramePointers==0', { + 'OmitFramePointers': 'false', + # The above is not sufficient (http://crbug.com/106711): it + # simply eliminates an explicit "/Oy", but both /O2 and /Ox + # perform FPO regardless, so we must explicitly disable. + # We still want the false setting above to avoid having + # "/Oy /Oy-" and warnings about overriding. + 'AdditionalOptions': ['/Oy-'], + }], + ['asan==0', { + # Put data in separate COMDATs. This allows the linker + # to put bit-identical constants at the same address even if + # they're unrelated constants, which saves binary size. + # This optimization can't be used when ASan is enabled because + # it is not compatible with the ASan ODR checker. + 'AdditionalOptions': ['/Gw'], + }], + ], + 'AdditionalOptions': [ + '/d2Zi+', # Improve debugging of Release builds. + '/Zc:inline', # Remove unreferenced COMDAT (faster links). + '<@(win_release_extra_cflags)', + ], + }, + 'VCLinkerTool': { + # LinkIncremental is a tri-state boolean, where 0 means default + # (i.e., inherit from parent solution), 1 means false, and + # 2 means true. + 'LinkIncremental': '1', + # This corresponds to the /PROFILE flag which ensures the PDB + # file contains FIXUP information (growing the PDB file by about + # 5%) but does not otherwise alter the output binary. This + # information is used by the Syzygy optimization tool when + # decomposing the release image. + 'Profile': 'true', + }, + }, + 'conditions': [ + ['release_valgrind_build==0 and tsan==0', { + 'defines': [ + 'NVALGRIND', + 'DYNAMIC_ANNOTATIONS_ENABLED=0', + ], + }, { + 'defines': [ + 'MEMORY_TOOL_REPLACES_ALLOCATOR', + 'MEMORY_SANITIZER_INITIAL_SIZE', + 'DYNAMIC_ANNOTATIONS_ENABLED=1', + 'WTF_USE_DYNAMIC_ANNOTATIONS=1', + ], + }], + ['OS=="win" and win_use_allocator_shim==1', { + 'defines': [ + 'ALLOCATOR_SHIM' + ], + }], + # _FORTIFY_SOURCE isn't really supported by Clang now, see + # http://llvm.org/bugs/show_bug.cgi?id=16821. + # It seems to work fine with Ubuntu 12 headers though, so use it + # in official builds. + ['os_posix==1 and (asan!=1 and msan!=1 and tsan!=1 and lsan!=1 and ubsan!=1) and (OS!="linux" or clang!=1 or buildtype=="Official")', { + 'target_conditions': [ + ['chromium_code==1', { + # Non-chromium code is not guaranteed to compile cleanly + # with _FORTIFY_SOURCE. Also, fortified build may fail + # when optimizations are disabled, so only do that for Release + # build. + 'defines': [ + '_FORTIFY_SOURCE=2', + ], + }], + ], + }], + ['OS=="linux" or OS=="android"', { + 'target_conditions': [ + ['_toolset=="target"', { + 'cflags': [ + '<@(release_extra_cflags)', + ], + 'conditions': [ + ['enable_resource_whitelist_generation==1', { + 'cflags': [ + '-Wunknown-pragmas -Wno-error=unknown-pragmas', + ], + }], + ], + }], + ], + }], + ['OS=="ios"', { + 'defines': [ + 'NS_BLOCK_ASSERTIONS=1', + ], + }], + ], + }, + # + # Concrete configurations + # + 'Debug': { + 'inherit_from': ['Common_Base', 'x86_Base', 'Debug_Base'], + }, + 'Release': { + 'inherit_from': ['Common_Base', 'x86_Base', 'Release_Base'], + }, + 'conditions': [ + [ 'OS=="ios"', { + 'Profile': { + 'inherit_from': ['Common_Base', 'x86_Base', 'Release_Base'], + 'target_conditions': [ + [ '_type=="executable"', { + # To get a real .dSYM bundle produced by dsymutil, set the + # debug information format to dwarf-with-dsym. Since + # strip_from_xcode will not be used, set Xcode to do the + # stripping as well. + 'xcode_settings': { + 'DEBUG_INFORMATION_FORMAT': 'dwarf-with-dsym', + 'DEPLOYMENT_POSTPROCESSING': 'YES', + 'STRIP_INSTALLED_PRODUCT': 'YES', + }, + }], + ], + }, + }], + [ 'OS=="win"', { + # TODO(bradnelson): add a gyp mechanism to make this more graceful. + 'Debug_x64': { + 'inherit_from': ['Common_Base', 'x64_Base', 'Debug_Base'], + }, + 'Release_x64': { + 'inherit_from': ['Common_Base', 'x64_Base', 'Release_Base'], + }, + }], + ], + }, + }, + 'conditions': [ + ['os_posix==1', { + 'target_defaults': { + 'ldflags': [ + '-Wl,-z,now', + '-Wl,-z,relro', + ], + # TODO(glider): enable the default options on other systems. + 'conditions': [ + ['use_sanitizer_options==1 and ((OS=="linux" and (chromeos==0 or target_arch!="ia32")) or OS=="mac")', { + 'dependencies': [ + '<(DEPTH)/build/sanitizers/sanitizers.gyp:sanitizer_options', + ], + }], + ], + }, + }], + # TODO(jochen): Enable this on chromeos on arm. http://crbug.com/356580 + ['os_posix==1 and disable_fatal_linker_warnings==0 and use_evdev_gestures==0 and (chromeos==0 or target_arch!="arm")', { + 'target_defaults': { + 'ldflags': [ + '-Wl,--fatal-warnings', + ], + }, + }], + # -Wl,-z,-defs doesn't work with the sanitiziers, http://crbug.com/452065 + ['(OS=="linux" or OS=="android") and asan==0 and msan==0 and tsan==0 and ubsan==0 and ubsan_security==0 and ubsan_vptr==0 and cfi_diag==0', { + 'target_defaults': { + 'ldflags': [ + '-Wl,-z,defs', + ], + }, + }], + ['os_posix==1 and chromeos==0', { + # Chrome OS enables -fstack-protector-strong via its build wrapper, + # and we want to avoid overriding this, so stack-protector is only + # enabled when not building on Chrome OS. + # TODO(phajdan.jr): Use -fstack-protector-strong when our gcc + # supports it. See also https://crbug.com/533294 + 'target_defaults': { + 'cflags': [ + '-fstack-protector', + '--param=ssp-buffer-size=4', + ], + }, + }], + ['os_posix==1 and OS=="linux"', { + 'defines': [ + '_LARGEFILE_SOURCE', + '_LARGEFILE64_SOURCE', + '_FILE_OFFSET_BITS=64', + ], + }], + ['os_posix==1 and OS!="mac" and OS!="ios"', { + 'target_defaults': { + # Enable -Werror by default, but put it in a variable so it can + # be disabled in ~/.gyp/include.gypi on the valgrind builders. + 'variables': { + 'werror%': '-Werror', + 'libraries_for_target%': '', + 'conditions' : [ + # Enable -Wextra for chromium_code when we control the compiler. + ['clang==1', { 'wextra': '-Wextra' }, { 'wextra': '-Wno-extra' }], + ], + }, + 'defines': [ + '_FILE_OFFSET_BITS=64', + ], + 'cflags': [ + '<(werror)', # See note above about the werror variable. + '-pthread', + '-fno-strict-aliasing', # See http://crbug.com/32204 + '-Wall', + '<(wextra)', + # Don't warn about unused function params. We use those everywhere. + '-Wno-unused-parameter', + # Don't warn about the "struct foo f = {0};" initialization pattern. + '-Wno-missing-field-initializers', + # Don't export any symbols (for example, to plugins we dlopen()). + # Note: this is *required* to make some plugins work. + '-fvisibility=hidden', + '-pipe', + ], + 'cflags_cc': [ + '-fno-exceptions', + '-fno-rtti', + # If this is removed then remove the corresponding /Zc:threadSafeInit- + # for Windows. + '-fno-threadsafe-statics', + # Make inline functions have hidden visiblity by default. + # Surprisingly, not covered by -fvisibility=hidden. + '-fvisibility-inlines-hidden', + ], + 'ldflags': [ + '-pthread', '-Wl,-z,noexecstack', + ], + 'libraries' : [ + '<(libraries_for_target)', + ], + 'configurations': { + 'Debug_Base': { + 'variables': { + 'debug_optimize%': '0', + }, + 'defines': [ + '_DEBUG', + ], + 'cflags': [ + '-O>(debug_optimize)', + '-g', + ], + 'conditions' : [ + ['OS=="android" and target_arch!="mipsel" and target_arch!="mips64el"', { + # TODO(jdduke) Re-enable on mips after resolving linking + # issues with libc++ (crbug.com/456380). + 'ldflags': [ + # Warn in case of text relocations. + '-Wl,--warn-shared-textrel', + ], + }], + ['OS=="android" and android_full_debug==0', { + # Some configurations are copied from Release_Base to reduce + # the binary size. + 'variables': { + 'debug_optimize%': 's', + }, + 'cflags': [ + '-fdata-sections', + '-ffunction-sections', + ], + 'ldflags': [ + '-Wl,-O1', + '-Wl,--as-needed', + ], + }], + ['OS=="android" and android_full_debug==0 and target_arch!="arm64"', { + # We don't omit frame pointers on arm64 since they are required + # to correctly unwind stackframes which contain system library + # function frames (crbug.com/391706). + 'cflags': [ + '-fomit-frame-pointer', + ], + }], + ['OS=="linux" and target_arch=="ia32"', { + 'ldflags': [ + '-Wl,--no-as-needed', + ], + }], + ['debug_unwind_tables==1', { + 'cflags': ['-funwind-tables'], + }, { + 'cflags': ['-fno-unwind-tables', '-fno-asynchronous-unwind-tables'], + 'defines': ['NO_UNWIND_TABLES'], + }], + ['linux_use_debug_fission==1 and linux_use_gold_flags==1 and binutils_version>=223', { + 'cflags': ['-gsplit-dwarf'], + }], + ], + }, + 'Release_Base': { + 'variables': { + 'release_optimize%': '2', + # Binaries become big and gold is unable to perform GC + # and remove unused sections for some of test targets + # on 32 bit platform. + # (This is currently observed only in chromeos valgrind bots) + # The following flag is to disable --gc-sections linker + # option for these bots. + 'no_gc_sections%': 0, + # TODO(bradnelson): reexamine how this is done if we change the + # expansion of configurations + 'release_valgrind_build%': 0, + }, + 'cflags': [ + '-O<(release_optimize)', + # Don't emit the GCC version ident directives, they just end up + # in the .comment section taking up binary size. + '-fno-ident', + # Put data and code in their own sections, so that unused symbols + # can be removed at link time with --gc-sections. + '-fdata-sections', + '-ffunction-sections', + ], + 'ldflags': [ + # Specifically tell the linker to perform optimizations. + # See http://lwn.net/Articles/192624/ . + '-Wl,-O1', + '-Wl,--as-needed', + ], + 'conditions' : [ + ['no_gc_sections==0', { + 'ldflags': [ + '-Wl,--gc-sections', + ], + }], + ['OS=="android" and target_arch!="arm64"', { + # We don't omit frame pointers on arm64 since they are required + # to correctly unwind stackframes which contain system library + # function frames (crbug.com/391706). + 'cflags': [ + '-fomit-frame-pointer', + ] + }], + ['OS=="android" and target_arch!="mipsel" and target_arch!="mips64el"', { + # TODO(jdduke) Re-enable on mips after resolving linking + # issues with libc++ (crbug.com/456380). + 'ldflags': [ + # Warn in case of text relocations. + '-Wl,--warn-shared-textrel', + ], + }], + ['OS=="android"', { + 'variables': { + 'release_optimize%': 's', + }, + }, { + 'ldflags': [ + # TODO(pcc): Fix linker bug which requires us to link pthread + # unconditionally here (crbug.com/623236). + '-Wl,--no-as-needed', + '-lpthread', + '-Wl,--as-needed', + ], + }], + ['profiling==1', { + 'cflags': [ + '-fno-omit-frame-pointer', + '-g', + ], + 'conditions' : [ + ['profiling_full_stack_frames==1', { + 'cflags': [ + '-fno-inline', + '-fno-optimize-sibling-calls', + ], + }], + ], + }], + ['release_unwind_tables==1', { + 'cflags': ['-funwind-tables'], + }, { + 'cflags': ['-fno-unwind-tables', '-fno-asynchronous-unwind-tables'], + 'defines': ['NO_UNWIND_TABLES'], + }], + ], + }, + }, + 'conditions': [ + ['target_arch=="ia32"', { + 'target_conditions': [ + ['_toolset=="target"', { + 'asflags': [ + # Needed so that libs with .s files (e.g. libicudata.a) + # are compatible with the general 32-bit-ness. + '-32', + ], + # All floating-point computations on x87 happens in 80-bit + # precision. Because the C and C++ language standards allow + # the compiler to keep the floating-point values in higher + # precision than what's specified in the source and doing so + # is more efficient than constantly rounding up to 64-bit or + # 32-bit precision as specified in the source, the compiler, + # especially in the optimized mode, tries very hard to keep + # values in x87 floating-point stack (in 80-bit precision) + # as long as possible. This has important side effects, that + # the real value used in computation may change depending on + # how the compiler did the optimization - that is, the value + # kept in 80-bit is different than the value rounded down to + # 64-bit or 32-bit. There are possible compiler options to + # make this behavior consistent (e.g. -ffloat-store would keep + # all floating-values in the memory, thus force them to be + # rounded to its original precision) but they have significant + # runtime performance penalty. + # + # -mfpmath=sse -msse2 makes the compiler use SSE instructions + # which keep floating-point values in SSE registers in its + # native precision (32-bit for single precision, and 64-bit + # for double precision values). This means the floating-point + # value used during computation does not change depending on + # how the compiler optimized the code, since the value is + # always kept in its specified precision. + # + # Refer to http://crbug.com/348761 for rationale behind SSE2 + # being a minimum requirement for 32-bit Linux builds and + # http://crbug.com/313032 for an example where this has "bit" + # us in the past. + 'cflags': [ + '-msse2', + '-mfpmath=sse', + '-mmmx', # Allows mmintrin.h for MMX intrinsics. + '-m32', + ], + 'ldflags': [ + '-m32', + ], + 'conditions': [ + # Use gold linker for Android ia32 target. + ['OS=="android"', { + # Use gold linker for Android ia32 target. + 'ldflags': [ + '-fuse-ld=gold', + ], + # Use -mstackrealign due to a bug on ia32 Jelly Bean. + # See crbug.com/521527 + 'cflags': [ + '-mstackrealign', + ], + }], + ], + }], + ], + }], + ['target_arch=="x64"', { + 'target_conditions': [ + ['_toolset=="target"', { + 'conditions': [ + # Use gold linker for Android x64 target. + ['OS=="android"', { + 'ldflags': [ + '-fuse-ld=gold', + ], + }], + ], + 'cflags': [ + '-m64', + '-march=x86-64', + ], + 'ldflags': [ + '-m64', + ], + }], + ], + }], + ['target_arch=="arm"', { + 'target_conditions': [ + ['_toolset=="target"', { + 'conditions': [ + ['clang==0', { + 'cflags': [ + # Don't warn about "maybe" uninitialized. Clang doesn't + # include this in -Wall but gcc does, and it gives false + # positives. + '-Wno-maybe-uninitialized', + ], + 'cflags_cc': [ + # The codesourcery arm-2009q3 toolchain warns at that the ABI + # has changed whenever it encounters a varargs function. This + # silences those warnings, as they are not helpful and + # clutter legitimate warnings. + '-Wno-abi', + ], + }], + ['clang==1 and arm_arch!="" and OS!="android"', { + 'cflags': [ + '-target arm-linux-gnueabihf', + ], + 'ldflags': [ + '-target arm-linux-gnueabihf', + ], + }], + ['arm_arch!=""', { + 'cflags': [ + '-march=<(arm_arch)', + ], + 'conditions': [ + ['use_lto==1 or use_lto_o2==1', { + 'ldflags': [ + '-march=<(arm_arch)', + ], + }], + ], + }], + ['arm_tune!=""', { + 'cflags': [ + '-mtune=<(arm_tune)', + ], + 'conditions': [ + ['use_lto==1 or use_lto_o2==1', { + 'ldflags': [ + '-mtune=<(arm_tune)', + ], + }], + ], + }], + ['arm_fpu!=""', { + 'cflags': [ + '-mfpu=<(arm_fpu)', + ], + 'conditions': [ + ['use_lto==1 or use_lto_o2==1', { + 'ldflags': [ + '-mfpu=<(arm_fpu)', + ], + }], + ], + }], + ['arm_float_abi!=""', { + 'cflags': [ + '-mfloat-abi=<(arm_float_abi)', + ], + 'conditions': [ + ['use_lto==1 or use_lto_o2==1', { + 'ldflags': [ + '-mfloat-abi=<(arm_float_abi)', + ], + }], + ], + }], + ['arm_thumb==1', { + 'cflags': [ + '-mthumb', + ], + 'conditions': [ + ['use_lto==1 or use_lto_o2==1', { + 'ldflags': [ + '-mthumb', + ], + }], + ], + }], + ['OS=="android"', { + # Most of the following flags are derived from what Android + # uses by default when building for arm, reference for which + # can be found in the following file in the Android NDK: + # toolchains/arm-linux-androideabi-4.9/setup.mk + 'cflags': [ + # The tree-sra optimization (scalar replacement for + # aggregates enabling subsequent optimizations) leads to + # invalid code generation when using the Android NDK's + # compiler (r5-r7). This can be verified using + # webkit_unit_tests' WTF.Checked_int8_t test. + '-fno-tree-sra', + # The following option is disabled to improve binary + # size and performance in gcc 4.9. + '-fno-caller-saves', + '-Wno-psabi', + ], + # Android now supports .relro sections properly. + # NOTE: While these flags enable the generation of .relro + # sections, the generated libraries can still be loaded on + # older Android platform versions. + 'ldflags': [ + '-Wl,-z,relro', + '-Wl,-z,now', + '-fuse-ld=gold', + ], + 'conditions': [ + ['arm_thumb==1', { + 'cflags': [ '-mthumb-interwork' ], + }], + ['profiling==1', { + 'cflags': [ + # Thumb code with frame pointer makes chrome crash + # early. + '-marm', + '-mapcs-frame', # Required by -fno-omit-frame-pointer. + # The perf report sometimes incorrectly attributes + # code from tail calls. + '-fno-optimize-sibling-calls', + ], + 'cflags!': [ + '-fomit-frame-pointer', + ], + }], + ['clang==1', { + 'cflags!': [ + # Clang does not support the following options. + '-mapcs-frame', + '-mthumb-interwork', + '-finline-limit=64', + '-fno-tree-sra', + '-fno-caller-saves', + '-Wno-psabi', + ], + }], + ['clang==1 and linux_use_bundled_gold==0', { + 'ldflags': [ + # Let clang find the ld.gold in the NDK. + '--gcc-toolchain=<(android_toolchain)/..', + ], + }], + ['asan==1', { + 'cflags': [ + '-marm', # Required for frame pointer based stack traces. + ], + }], + ], + }], + ['chromecast==1', { + 'cflags': [ + # We set arm_arch to "" so that -march compiler option + # is not set. Otherwise a gcc bug that would complain + # about it conflicting with '-mcpu=cortex-a9'. The flag + # '-march=armv7-a' is actually redundant anyway because + # it is enabled by default when we built the toolchain. + # And using '-mcpu=cortex-a9' should be sufficient. + '-mcpu=cortex-a9', + '-funwind-tables', + # Breakpad requires symbols with debugging information + '-g', + ], + 'ldflags': [ + # We want to statically link libstdc++/libgcc. + '-static-libstdc++', + '-static-libgcc', + # Don't allow visible symbols from libraries that contain + # assembly code with symbols that aren't hidden properly. + # http://b/26390825 + '-Wl,--exclude-libs=libffmpeg.a', + ], + 'cflags!': [ + # Some components in Chromium (e.g. v8, skia, ffmpeg) + # define their own cflags for arm builds that could + # conflict with the flags we set here (e.g. + # '-mcpu=cortex-a9'). Remove these flags explicitly. + '-march=armv7-a', + '-mtune=cortex-a8', + ], + 'target_conditions': [ + [ '_type=="executable" and OS!="android"', { + # Statically link whole libstdc++ and libgcc in + # executables to ensure only one copy at runtime. + 'ldflags': [ + # Note executables also get -static-stdlibc++/libgcc. + # Despite including libstdc++/libgcc archives, we + # still need to specify static linking for them in + # order to prevent the executable from having a + # dynamic dependency on them. + # Export stdlibc++ and libgcc symbols to force shlibs + # to refer to these symbols from the executable. + '-Wl,--export-dynamic', + '-lm', # stdlibc++ requires math.h + # In case we redefined stdlibc++ symbols + # (e.g. tc_malloc) + '-Wl,--allow-multiple-definition', + '-Wl,--whole-archive', + '-l:libstdc++.a', + '-l:libgcc.a', + '-Wl,--no-whole-archive', + ], + }] + ], + }], + ], + }], + ], + }], + ['target_arch=="arm64"', { + 'target_conditions': [ + ['_toolset=="target"', { + 'conditions': [ + ['OS=="android"', { + 'cflags!': [ + '-fstack-protector', # stack protector is always enabled on arm64. + ], + }], + ['clang==1 and arm_arch!="" and OS!="android"', { + 'cflags': [ + '-target aarch64-linux-gnu', + ], + 'ldflags': [ + '-target aarch64-linux-gnu', + ], + }], + ], + }], + ], + }], + ['target_arch=="mipsel"', { + 'target_conditions': [ + ['_toolset=="target"', { + 'conditions': [ + ['mips_arch_variant=="r6"', { + 'conditions': [ + ['clang==1', { + 'conditions': [ + ['OS=="android"', { + 'cflags': [ '-target mipsel-linux-android', '-march=mipsel', '-mcpu=mips32r6', ], + 'ldflags': [ '-target mipsel-linux-android', ], + }], + ], + }, { # clang==0 + 'cflags': ['-mips32r6', '-Wa,-mips32r6', ], + }], + ['clang==0 and OS=="android"', { + 'ldflags': ['-mips32r6', '-Wl,-melf32ltsmip',], + }], + ['mips_msa==1', { + 'cflags': ['-mmsa', '-mfp64', '-msched-weight', '-mload-store-pairs'], + }], + ], + 'cflags': [ '-mfp64', '-mno-odd-spreg' ], + 'ldflags': [ '-mfp64', '-mno-odd-spreg' ], + }], + ['mips_arch_variant=="r2"', { + 'conditions': [ + ['mips_float_abi=="hard" and mips_fpu_mode!=""', { + 'cflags': ['-m<(mips_fpu_mode)'], + }], + ['clang==1', { + 'conditions': [ + ['OS=="android"', { + 'cflags': [ '-target mipsel-linux-android', '-march=mipsel', '-mcpu=mips32r2'], + 'ldflags': [ '-target mipsel-linux-android', ], + }, { + 'cflags': [ '-target mipsel-linux-gnu', '-march=mipsel', '-mcpu=mips32r2'], + 'ldflags': [ '-target mipsel-linux-gnu', ], + }], + ], + }, { # clang==0 + 'cflags': ['-mips32r2', '-Wa,-mips32r2', ], + }], + ], + }], + ['mips_arch_variant=="r1"', { + 'conditions': [ + ['clang==1', { + 'conditions': [ + ['OS=="android"', { + 'cflags': [ '-target mipsel-linux-android', '-march=mipsel', '-mcpu=mips32'], + 'ldflags': [ '-target mipsel-linux-android', ], + }, { + 'cflags': [ '-target mipsel-linux-gnu', '-march=mipsel', '-mcpu=mips32'], + 'ldflags': [ '-target mipsel-linux-gnu', ], + }], + ], + }, { # clang==0 + 'cflags': ['-mips32', '-Wa,-mips32', ], + }], + ], + }], + ['clang==1', { + 'cflags!': [ + # Clang does not support the following options. + '-finline-limit=64', + ], + # TODO(gordanac) Enable integrated-as. + 'cflags': [ '-fno-integrated-as' ], + 'conditions': [ + ['OS=="android"', { + 'cflags': [ + # Else /usr/bin/as gets picked up. + '-B<(android_toolchain)', + ], + }], + ], + }], + ['clang==1 and OS=="android"', { + 'ldflags': [ + # Let clang find the ld in the NDK. + '--gcc-toolchain=<(android_toolchain)/..', + ], + }], + ['mips_dsp_rev==1', { + 'cflags': ['-mdsp'], + }], + ['mips_dsp_rev==2', { + 'cflags': ['-mdspr2'], + }], + ], + 'cflags': [ + '-m<(mips_float_abi)-float' + ], + 'ldflags': [ + '-Wl,--no-keep-memory' + ], + 'cflags_cc': [ + '-Wno-uninitialized', + ], + }], + ['_toolset=="target" and _type=="executable"', { + 'conditions': [ + ['OS=="linux"', { + 'ldflags': ['-pie'], + }], + ], + }], + ], + }], + ['target_arch=="mips64el"', { + 'target_conditions': [ + ['_toolset=="target"', { + 'conditions': [ + ['mips_arch_variant=="r6"', { + 'conditions': [ + ['clang==1', { + 'conditions': [ + ['OS=="android"', { + 'cflags': [ '-target mips64el-linux-android', '-march=mips64el', '-mcpu=mips64r6', ], + 'ldflags': [ '-target mips64el-linux-android', ], + }], + ], + }, { # clang==0 + 'cflags': ['-mips64r6', '-Wa,-mips64r6'], + 'ldflags': ['-mips64r6'], + }], + ['mips_msa==1', { + 'cflags': ['-mmsa', '-mfp64', '-msched-weight', '-mload-store-pairs'], + }], + ], + }], + ['mips_arch_variant=="r2"', { + 'cflags': ['-mips64r2', '-Wa,-mips64r2'], + 'ldflags': ['-mips64r2'], + }], + ['clang==1', { + 'cflags!': [ + # Clang does not support the following options. + '-finline-limit=64', + ], + # TODO(gordanac) Enable integrated-as. + 'cflags': [ '-fno-integrated-as' ], + 'conditions': [ + ['OS=="android"', { + 'cflags': [ + # Else /usr/bin/as gets picked up. + '-B<(android_toolchain)', + ], + }], + ], + }], + ['clang==1 and OS=="android"', { + 'ldflags': [ + # Let clang find the ld in the NDK. + '--gcc-toolchain=<(android_toolchain)/..', + ], + }], + ], + 'cflags_cc': [ + '-Wno-uninitialized', + ], + }], + ], + }], + ['linux_fpic==1', { + 'cflags': [ + '-fPIC', + ], + 'ldflags': [ + '-fPIC', + ], + }], + ['sysroot!=""', { + 'target_conditions': [ + ['_toolset=="target"', { + 'cflags': [ + '--sysroot=<(sysroot)', + ], + 'ldflags': [ + '--sysroot=<(sysroot)', + '=223', { + # Newer binutils don't set DT_RPATH unless you disable "new" dtags + # and the new DT_RUNPATH doesn't work without --no-as-needed flag. + # FIXME(mithro): Figure out the --as-needed/--no-as-needed flags + # inside this file to allow usage of --no-as-needed and removal of + # this flag. + 'ldflags': [ + '-Wl,--disable-new-dtags', + ], + }], + ['clang==0', { + 'target_conditions': [ + ['_toolset=="target"', { + 'cflags_cc': [ + '-std=gnu++11', + # See comment for -Wno-c++11-narrowing. + '-Wno-narrowing', + ], + }], + ], + }], + ['clang==0 and host_clang==0', { + 'target_conditions': [ + ['_toolset=="host"', { + 'cflags_cc': [ + '-std=gnu++11', + # See comment for -Wno-c++11-narrowing. + '-Wno-narrowing', + ], + }], + ], + }], + ['clang==0 and chromeos==1', { + 'target_conditions': [ + ['_toolset=="target"', { + 'cflags_cc': [ + # TODO(thakis): Remove, http://crbug.com/263960 + '-Wno-literal-suffix', + ], + }], + ], + }], + ['clang==0 and host_clang==0 and chromeos==1', { + 'target_conditions': [ + ['_toolset=="host"', { + 'cflags_cc': [ + # TODO(thakis): Remove, http://crbug.com/263960 + '-Wno-literal-suffix', + ], + }], + ], + }], + ], + }, + }], + # *BSD-specific options; note that most *BSD options are set above, + # with Linux. + ['OS=="openbsd" or OS=="freebsd"', { + 'target_defaults': { + 'ldflags': [ + '-Wl,--no-keep-memory', + ], + }, + }], + # Android-specific options; note that most are set above with Linux. + ['OS=="android"', { + 'variables': { + # Placing this variable here prevents from forking libvpx, used + # by remoting. Remoting is off, so it needn't built, + # so forking it's deps seems like overkill. + # But this variable need defined to properly run gyp. + # A proper solution is to have an OS==android conditional + # in third_party/libvpx/libvpx.gyp to define it. + 'libvpx_path': 'lib/linux/arm', + }, + 'target_defaults': { + 'variables': { + 'release_extra_cflags%': '', + 'conditions': [ + # If we're using the components build, append "cr" to all shared + # libraries to avoid naming collisions with android system library + # versions with the same name (e.g. skia, icu). + ['component=="shared_library"', { + 'android_product_extension': 'cr.so', + }, { + 'android_product_extension': 'so', + } ], + ], + }, + 'target_conditions': [ + ['_type=="shared_library"', { + 'product_extension': '<(android_product_extension)', + }], + # Settings for building device targets using Android's toolchain. + # These are based on the setup.mk file from the Android NDK. + # + # The NDK Android executable link step looks as follows: + # $LDFLAGS + # $(TARGET_CRTBEGIN_DYNAMIC_O) <-- crtbegin.o + # $(PRIVATE_OBJECTS) <-- The .o that we built + # $(PRIVATE_STATIC_LIBRARIES) <-- The .a that we built + # $(TARGET_LIBGCC) <-- libgcc.a + # $(PRIVATE_SHARED_LIBRARIES) <-- The .so that we built + # $(PRIVATE_LDLIBS) <-- System .so + # $(TARGET_CRTEND_O) <-- crtend.o + # + # For now the above are approximated for executables by adding + # crtbegin.o to the end of the ldflags and 'crtend.o' to the end + # of 'libraries'. + # + # The NDK Android shared library link step looks as follows: + # $LDFLAGS + # $(PRIVATE_OBJECTS) <-- The .o that we built + # -l,--whole-archive + # $(PRIVATE_WHOLE_STATIC_LIBRARIES) + # -l,--no-whole-archive + # $(PRIVATE_STATIC_LIBRARIES) <-- The .a that we built + # $(TARGET_LIBGCC) <-- libgcc.a + # $(PRIVATE_SHARED_LIBRARIES) <-- The .so that we built + # $(PRIVATE_LDLIBS) <-- System .so + # + # For now, assume that whole static libraries are not needed. + # + # For both executables and shared libraries, add the proper + # libgcc.a to the start of libraries which puts it in the + # proper spot after .o and .a files get linked in. + # + # TODO: The proper thing to do longer-tem would be proper gyp + # support for a custom link command line. + ['_toolset=="target"', { + 'cflags!': [ + '-pthread', # Not supported by Android toolchain. + ], + 'cflags': [ + '-ffunction-sections', + '-funwind-tables', + '-g', + '-fstack-protector', + '-fno-short-enums', + '-finline-limit=64', + '<@(release_extra_cflags)', + '--sysroot=<(android_ndk_sysroot)', + ], + 'cflags_cc': [ + # NOTE: The libc++ header include paths below are specified in + # cflags rather than include_dirs because they need to come + # after include_dirs. + # The include ordering here is important; change with caution. + '-isystem<(android_libcpp_include)', + '-isystem<(android_ndk_root)/sources/cxx-stl/llvm-libc++abi/libcxxabi/include', + '-isystem<(android_ndk_root)/sources/android/support/include', + ], + 'defines': [ + 'ANDROID', + '__GNU_SOURCE=1', # Necessary for clone() + # The NDK has these things, but doesn't define the constants + # to say that it does. Define them here instead. + 'HAVE_SYS_UIO_H', + 'ANDROID_NDK_VERSION=<(android_ndk_version)', + ], + 'ldflags!': [ + '-pthread', # Not supported by Android toolchain. + ], + 'ldflags': [ + '-Wl,--build-id=sha1', + '-Wl,--no-undefined', + '--sysroot=<(android_ndk_sysroot)', + '-nostdlib', + '-L<(android_libcpp_libs_dir)', + # Don't allow visible symbols from libgcc or libc++ to be + # re-exported. + '-Wl,--exclude-libs=libgcc.a', + '-Wl,--exclude-libs=libc++_static.a', + # Don't allow visible symbols from libraries that contain + # assembly code with symbols that aren't hidden properly. + # http://crbug.com/448386 + '-Wl,--exclude-libs=libcommon_audio.a', + '-Wl,--exclude-libs=libcommon_audio_neon.a', + '-Wl,--exclude-libs=libcommon_audio_sse2.a', + '-Wl,--exclude-libs=libiSACFix.a', + '-Wl,--exclude-libs=libisac_neon.a', + '-Wl,--exclude-libs=libopus.a', + '-Wl,--exclude-libs=libvpx.a', + ], + 'libraries': [ + '-l<(android_libcpp_library)', + '-latomic', + # Manually link the libgcc.a that the cross compiler uses. + '(_target_name).map', + ], + }, + }], + ], + }], + ['_mac_bundle', { + 'xcode_settings': {'OTHER_LDFLAGS': ['-Wl,-ObjC']}, + 'target_conditions': [ + ['_type=="executable"', { + 'conditions': [ + ['asan==1', { + 'postbuilds': [ + { + 'variables': { + # Define copy_asan_dylib_path in a variable ending in + # _path so that gyp understands it's a path and + # performs proper relativization during dict merging. + 'copy_asan_dylib_path': + 'mac/copy_asan_runtime_dylib.sh', + }, + 'postbuild_name': 'Copy ASan runtime dylib', + 'action': [ + '<(copy_asan_dylib_path)', + ], + }, + ], + }], + ], + }], + ], + }], + ], # target_conditions + }, # target_defaults + }], # OS=="mac" or OS=="ios" + ['OS=="mac"', { + 'target_defaults': { + 'defines': [ + # Prevent Mac OS X AssertMacros.h from defining macros that collide + # with common names, like 'check', 'require', and 'verify'. + # (Included by system header. Also exists on iOS but not included.) + # http://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/AssertMacros.h + '__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORE=0', + ], + 'variables': { + # These should end with %, but there seems to be a bug with % in + # variables that are intended to be set to different values in + # different targets, like these. + # Strip debugging symbols from the target. + 'mac_strip': '<(mac_strip_release)', + 'conditions': [ + ['asan==1', { + 'conditions': [ + ['mac_want_real_dsym=="default"', { + 'mac_real_dsym': 1, + }, { + 'mac_real_dsym': '<(mac_want_real_dsym)' + }], + ], + }, { + 'conditions': [ + ['mac_want_real_dsym=="default"', { + 'mac_real_dsym': 0, # Fake .dSYMs are fine in most cases. + }, { + 'mac_real_dsym': '<(mac_want_real_dsym)' + }], + ], + }], + ], + }, + 'configurations': { + 'Release_Base': { + 'conditions': [ + ['branding=="Chrome" and buildtype=="Official"', { + 'xcode_settings': { + 'OTHER_CFLAGS': [ + # The Google Chrome Framework dSYM generated by dsymutil has + # grown larger than 4GB, which dsymutil can't handle. Reduce + # the amount of debug symbols. + '-fno-standalone-debug', # See http://crbug.com/479841 + ] + }, + }], + ], + }, # configuration "Release" + }, # configurations + 'xcode_settings': { + # Tell the compiler to use libc++'s headers and the linker to link + # against libc++. The latter part normally requires OS X 10.7, + # but we still support running on 10.6. How does this work? Two + # parts: + # 1. Chromium's clang doesn't error on -mmacosx-version-min=10.6 + # combined with -stdlib=libc++ (it normally silently produced a + # binary that doesn't run on 10.6) + # 2. Further down, library_dirs is set to + # third_party/libc++-static, which contains a static + # libc++.a library. The linker then links against that instead + # of against /usr/lib/libc++.dylib when it sees the -lc++ flag + # added by the driver. + # + # In component builds, just link to the system libc++. This has + # the effect of making everything depend on libc++, which means + # component-build binaries won't run on 10.6 (no libc++ there), + # but for a developer-only configuration that's ok. (We don't + # want to raise the deployment target yet so that official and + # dev builds have the same deployment target. This affects + # things like which functions are considered deprecated.) + 'CLANG_CXX_LIBRARY': 'libc++', # -stdlib=libc++ + 'GCC_DYNAMIC_NO_PIC': 'NO', # No -mdynamic-no-pic + # (Equivalent to -fPIC) + # MACOSX_DEPLOYMENT_TARGET maps to -mmacosx-version-min + 'MACOSX_DEPLOYMENT_TARGET': '<(mac_deployment_target)', + # Keep pch files below xcodebuild/. + 'SHARED_PRECOMPS_DIR': '$(CONFIGURATION_BUILD_DIR)/SharedPrecompiledHeaders', + 'OTHER_CFLAGS': [ + # Someday this can be replaced by an 'GCC_STRICT_ALIASING': 'NO' + # xcode_setting, but not until all downstream projects' mac bots are + # using xcode >= 4.6, because that's when the default value of the + # flag in the compiler switched. Pre-4.6, the value 'NO' for that + # setting is a no-op as far as xcode is concerned, but the compiler + # behaves differently based on whether -fno-strict-aliasing is + # specified or not. + '-fno-strict-aliasing', # See http://crbug.com/32204. + ], + }, + 'target_conditions': [ + ['>(nacl_untrusted_build)==0 and component=="static_library"', { + # See the comment for CLANG_CXX_LIBRARY above for what this does. + # The NaCl toolchains have their own toolchain and don't need this. + # ASan requires 10.7+ and clang implicitly adds -lc++abi in ASan + # mode. Our libc++.a contains both libc++ and libc++abi in one + # library, so it doesn't work in that mode. + 'conditions': [ + ['asan==0', { + 'library_dirs': [ '<(DEPTH)/third_party/libc++-static' ], + }], + ], + }], + ['_type=="executable"', { + # Turn on position-independence (ASLR) for executables. When + # PIE is on for the Chrome executables, the framework will + # also be subject to ASLR. + 'xcode_settings': { + 'OTHER_LDFLAGS': [ + '-Wl,-pie', # Position-independent executable (MH_PIE) + ], + }, + }], + ['(_type=="executable" or _type=="shared_library" or \ + _type=="loadable_module") and mac_strip!=0', { + 'target_conditions': [ + ['mac_real_dsym == 1', { + # To get a real .dSYM bundle produced by dsymutil, set the + # debug information format to dwarf-with-dsym. Since + # strip_from_xcode will not be used, set Xcode to do the + # stripping as well. + 'configurations': { + 'Release_Base': { + 'xcode_settings': { + 'DEBUG_INFORMATION_FORMAT': 'dwarf-with-dsym', + 'DEPLOYMENT_POSTPROCESSING': 'YES', + 'STRIP_INSTALLED_PRODUCT': 'YES', + 'conditions': [ + # Only strip non-ASan builds. + ['asan==0', { + 'target_conditions': [ + ['_type=="shared_library" or _type=="loadable_module"', { + # The Xcode default is to strip debugging symbols + # only (-S). Local symbols should be stripped as + # well, which will be handled by -x. Xcode will + # continue to insert -S when stripping even when + # additional flags are added with STRIPFLAGS. + 'STRIPFLAGS': '-x', + }], # _type=="shared_library" or _type=="loadable_module" + ], # target_conditions + }, { # asan != 0 + 'STRIPFLAGS': '-S', + }], + ], + }, # xcode_settings + }, # configuration "Release" + }, # configurations + }, { # mac_real_dsym != 1 + # To get a fast fake .dSYM bundle, use a post-build step to + # produce the .dSYM and strip the executable. strip_from_xcode + # only operates in the Release configuration. + 'postbuilds': [ + { + 'variables': { + # Define strip_from_xcode in a variable ending in _path + # so that gyp understands it's a path and performs proper + # relativization during dict merging. + 'strip_from_xcode_path': 'mac/strip_from_xcode', + }, + 'postbuild_name': 'Strip If Needed', + 'action': ['<(strip_from_xcode_path)'], + }, + ], # postbuilds + }], # mac_real_dsym + ], # target_conditions + }], # (_type=="executable" or _type=="shared_library" or + # _type=="loadable_module") and mac_strip!=0 + ], # target_conditions + }, # target_defaults + }], # OS=="mac" + ['OS=="ios"', { + 'target_defaults': { + 'xcode_settings' : { + 'ENABLE_BITCODE': 'NO', + 'CLANG_CXX_LIBRARY': 'libc++', # -stdlib=libc++ + 'conditions': [ + # Older Xcodes do not support -Wno-deprecated-register, so pass an + # additional flag to suppress the "unknown compiler option" error. + # Restrict this flag to builds that are either compiling with Xcode + # or compiling with Xcode's Clang. This will allow Ninja builds to + # continue failing on unknown compiler options. + # TODO(rohitrao): This flag is temporary and should be removed as + # soon as the iOS bots are updated to use Xcode 5.1. + ['clang_xcode==1', { + 'WARNING_CFLAGS': [ + '-Wno-unknown-warning-option', + # It's not possible to achieve nullability completeness before + # all builders are running Xcode 7. crbug.com/499809 + '-Wno-nullability-completeness', + ], + 'OTHER_CPLUSPLUSFLAGS': [ + '$(inherited)', + # TODO(ios): Remove once Xcode's libc++ has LLVM r256325 + '-isystem (win_exe_compatibility_manifest)"!=""', { + 'VCManifestTool': { + 'AdditionalManifestFiles': [ + '>(win_exe_compatibility_manifest)', + ], + }, + }], + ], + 'conditions': [ + # Building with Clang on Windows is a work in progress and very + # experimental. See crbug.com/82385. + # Keep this in sync with the similar blocks in build/config/compiler/BUILD.gn + ['clang==1', { + 'VCCLCompilerTool': { + 'AdditionalOptions': [ + # Don't warn about unused function parameters. + # (This is also used on other platforms.) + '-Wno-unused-parameter', + # Don't warn about the "struct foo f = {0};" initialization + # pattern. + '-Wno-missing-field-initializers', + # TODO(hans): Make this list shorter eventually, http://crbug.com/504657 + '-Wno-microsoft-enum-value', # http://crbug.com/505296 + '-Wno-unknown-pragmas', # http://crbug.com/505314 + '-Wno-microsoft-cast', # http://crbug.com/550065 + ], + }, + }], + ['clang==1 and clang_use_chrome_plugins==1', { + 'VCCLCompilerTool': { + 'AdditionalOptions': [ + '<@(clang_chrome_plugins_flags)', + ], + }, + }], + ['clang==1 and MSVS_VERSION == "2013"', { + 'VCCLCompilerTool': { + 'AdditionalOptions': [ + '-fmsc-version=1800', + ], + }, + }], + ['clang==1 and MSVS_VERSION == "2015"', { + 'VCCLCompilerTool': { + 'AdditionalOptions': [ + '-fmsc-version=1900', + ], + }, + }], + ['clang==1 and " 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) + if os.environ.get('GYP_INCLUDE_FIRST') != None: + AddInclude(os.path.join(checkout_root, os.environ.get('GYP_INCLUDE_FIRST'))) + # Always include Chromium's common.gypi, which we now have a copy of. + AddInclude(os.path.join(script_dir, 'chromium_common.gypi')) + # Optionally add supplemental .gypi files if present. + for supplement in supplemental_files: + AddInclude(supplement) + if os.environ.get('GYP_INCLUDE_LAST') != None: + AddInclude(os.path.join(checkout_root, os.environ.get('GYP_INCLUDE_LAST'))) + return result + + def main(): # Disabling garbage collection saves about 5% processing time. Since this is a # short-lived process it's not a problem. @@ -102,9 +154,8 @@ def main(): 'GYP_CROSSCOMPILE' not in os.environ)): os.environ['GYP_CROSSCOMPILE'] = '1' - args.extend(['-I' + i for i in - gyp_chromium.additional_include_files(supplemental_includes, - args)]) + args.extend(['-I' + i for i in additional_include_files(supplemental_includes, + args)]) # Set the gyp depth variable to the root of the checkout. args.append('--depth=' + os.path.relpath(checkout_root)) @@ -119,7 +170,7 @@ def main(): # pylint: disable=unpacking-non-sequence x64_runtime, x86_runtime = vs2013_runtime_dll_dirs vs_toolchain.CopyVsRuntimeDlls( - os.path.join(checkout_root, gyp_chromium.GetOutputDirectory()), + os.path.join(checkout_root, GetOutputDirectory()), (x86_runtime, x64_runtime)) sys.exit(gyp_rc)