From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- build/gyp_includes/common.gypi | 3589 ++++++++++++++++++++ build/gyp_includes/filename_rules.gypi | 96 + build/gyp_includes/internal/release_defaults.gypi | 18 + build/gyp_includes/internal/release_impl.gypi | 17 + .../internal/release_impl_official.gypi | 43 + build/gyp_includes/release.gypi | 17 + 6 files changed, 3780 insertions(+) create mode 100644 build/gyp_includes/common.gypi create mode 100644 build/gyp_includes/filename_rules.gypi create mode 100644 build/gyp_includes/internal/release_defaults.gypi create mode 100644 build/gyp_includes/internal/release_impl.gypi create mode 100644 build/gyp_includes/internal/release_impl_official.gypi create mode 100644 build/gyp_includes/release.gypi (limited to 'build/gyp_includes') diff --git a/build/gyp_includes/common.gypi b/build/gyp_includes/common.gypi new file mode 100644 index 0000000000..457059e446 --- /dev/null +++ b/build/gyp_includes/common.gypi @@ -0,0 +1,3589 @@ +# 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. + +# IMPORTANT: +# Please don't directly include this file if you are building via gyp_chromium, +# since gyp_chromium is automatically forcing its inclusion. +{ + # 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 or not we are using the Aura windowing framework. + 'use_aura%': 0, + + # Whether or not we are building the Ash shell. + 'use_ash%': 0, + }, + # Copy conditionally-set variables out one scope. + 'chromeos%': '<(chromeos)', + 'use_aura%': '<(use_aura)', + 'use_ash%': '<(use_ash)', + + # Whether we are using Views Toolkit + 'toolkit_views%': 0, + + # Use OpenSSL instead of NSS. Under development: see http://crbug.com/62803 + 'use_openssl%': 0, + + 'use_ibus%': 0, + + # Disable viewport meta tag by default. + 'enable_viewport%': 0, + + # Enable HiDPI support. + 'enable_hidpi%': 0, + + # Enable touch optimized art assets and metrics. + 'enable_touch_ui%': 0, + + # Is this change part of the android upstream bringup? + # Allows us to *temporarily* disable certain things for + # staging. Only set to 1 in a GYP_DEFINES. + 'android_upstream_bringup%': 0, + + # Override buildtype to select the desired build flavor. + # Dev - everyday build for development/testing + # Official - release build (generally implies additional processing) + # TODO(mmoss) Once 'buildtype' is fully supported (e.g. Windows gyp + # conversion is done), some of the things which are now controlled by + # 'branding', such as symbol generation, will need to be refactored + # based on 'buildtype' (i.e. we don't care about saving symbols for + # non-Official # builds). + 'buildtype%': 'Dev', + + 'conditions': [ + # ChromeOS implies ash. + ['chromeos==1', { + 'use_ash%': 1, + 'use_aura%': 1, + }], + + # For now, Windows builds that |use_aura| should also imply using + # ash. This rule should be removed for the future when Windows is + # using the aura windows without the ash interface. + ['use_aura==1 and OS=="win"', { + 'use_ash%': 1, + }], + ['use_ash==1', { + 'use_aura%': 1, + }], + + # A flag for BSD platforms + ['OS=="dragonfly" or OS=="freebsd" or OS=="netbsd" or \ + OS=="openbsd"', { + 'os_bsd%': 1, + }, { + 'os_bsd%': 0, + }], + ], + }, + # Copy conditionally-set variables out one scope. + 'chromeos%': '<(chromeos)', + 'use_aura%': '<(use_aura)', + 'use_ash%': '<(use_ash)', + 'os_bsd%': '<(os_bsd)', + 'use_openssl%': '<(use_openssl)', + 'use_ibus%': '<(use_ibus)', + 'enable_viewport%': '<(enable_viewport)', + 'enable_hidpi%': '<(enable_hidpi)', + 'enable_touch_ui%': '<(enable_touch_ui)', + 'android_upstream_bringup%': '<(android_upstream_bringup)', + 'buildtype%': '<(buildtype)', + + # Sets whether we're building with the Android SDK/NDK (and hence with + # Ant, value 0), or as part of the Android system (and hence with the + # Android build system, value 1). + 'android_build_type%': 0, + + # Compute the architecture that we're building on. + 'conditions': [ + ['OS=="win" or OS=="ios"', { + 'host_arch%': 'ia32', + }, { + # This handles the Unix platforms for which there is some support. + # Anything else gets passed through, which probably won't work very + # well; such hosts should pass an explicit target_arch to gyp. + 'host_arch%': + '. 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.6 SDK and sets the + # deployment target to 10.6. 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_sdk_min%': '10.6', + 'mac_sdk_path%': '', + + 'mac_deployment_target%': '10.6', + }, + + 'mac_sdk_min': '<(mac_sdk_min)', + 'mac_sdk_path': '<(mac_sdk_path)', + 'mac_deployment_target': '<(mac_deployment_target)', + + # Enable clang on mac by default! + 'clang%': 1, + + # 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', + }], + + ['branding=="Chrome" and buildtype=="Official"', { + 'mac_sdk%': ', 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'], + }, + }, + 'conditions': [ + ['OS=="linux" or OS=="android"', { + 'target_conditions': [ + ['_toolset=="target"', { + 'cflags': [ + '<@(debug_extra_cflags)', + ], + }], + ], + }], + # Disabled on iOS because it was causing a crash on startup. + # TODO(michelea): investigate, create a reduced test and possibly + # submit a radar. + ['release_valgrind_build==0 and OS!="ios"', { + 'xcode_settings': { + 'OTHER_CFLAGS': [ + '-fstack-protector-all', # 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-'], + }], + ], + 'AdditionalOptions': [ '<@(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': [ + ['msvs_use_common_release', { + 'includes': ['release.gypi'], + }], + ['release_valgrind_build==0', { + 'defines': [ + 'NVALGRIND', + 'DYNAMIC_ANNOTATIONS_ENABLED=0', + ], + }, { + 'defines': [ + 'DYNAMIC_ANNOTATIONS_ENABLED=1', + 'WTF_USE_DYNAMIC_ANNOTATIONS=1', + ], + }], + ['win_use_allocator_shim==0', { + 'defines': ['NO_TCMALLOC'], + }], + ['OS=="linux"', { + 'target_conditions': [ + ['_toolset=="target"', { + 'cflags': [ + '<@(release_extra_cflags)', + ], + }], + ], + }], + ], + }, + # + # Concrete configurations + # + 'Debug': { + 'inherit_from': ['Common_Base', 'x86_Base', 'Debug_Base'], + }, + 'Release': { + 'inherit_from': ['Common_Base', 'x86_Base', 'Release_Base'], + }, + 'conditions': [ + [ '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 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%': '', + }, + 'defines': [ + '_FILE_OFFSET_BITS=64', + ], + 'cflags': [ + '<(werror)', # See note above about the werror variable. + '-pthread', + '-fno-exceptions', + '-fno-strict-aliasing', # See http://crbug.com/32204 + '-Wall', + # TODO(evan): turn this back on once all the builds work. + # '-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-rtti', + '-fno-threadsafe-statics', + # Make inline functions have hidden visiblity by default. + # Surprisingly, not covered by -fvisibility=hidden. + '-fvisibility-inlines-hidden', + # GCC turns on -Wsign-compare for C++ under -Wall, but clang doesn't, + # so we specify it explicitly. + # TODO(fischman): remove this if http://llvm.org/PR10448 obsoletes it. + # http://code.google.com/p/chromium/issues/detail?id=90453 + '-Wsign-compare', + ], + '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 android_full_debug==0', { + # Some configurations are copied from Release_Base to reduce + # the binary size. + 'variables': { + 'debug_optimize%': 's', + }, + 'cflags': [ + '-fomit-frame-pointer', + '-fdata-sections', + '-ffunction-sections', + ], + 'ldflags': [ + '-Wl,-O1', + '-Wl,--as-needed', + '-Wl,--gc-sections', + ], + }], + ], + }, + '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"', { + 'variables': { + 'release_optimize%': 's', + }, + 'cflags': [ + '-fomit-frame-pointer', + ], + }], + ['clang==1', { + 'cflags!': [ + '-fno-ident', + ], + }], + ['profiling==1', { + 'cflags': [ + '-fno-omit-frame-pointer', + '-g', + ], + }], + ], + }, + }, + 'variants': { + 'coverage': { + 'cflags': ['-fprofile-arcs', '-ftest-coverage'], + 'ldflags': ['-fprofile-arcs'], + }, + 'profile': { + 'cflags': ['-pg', '-g'], + 'ldflags': ['-pg'], + }, + 'symbols': { + 'cflags': ['-g'], + }, + }, + '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. + 'conditions': [ + ['branding=="Chromium" and disable_sse2==0', { + 'cflags': [ + '-march=pentium4', + '-msse2', + '-mfpmath=sse', + ], + }], + # ChromeOS targets Pinetrail, which is sse3, but most of the + # benefit comes from sse2 so this setting allows ChromeOS + # to build on other CPUs. In the future -march=atom would + # help but requires a newer compiler. + ['chromeos==1 and disable_sse2==0', { + 'cflags': [ + '-msse2', + ], + }], + # Install packages have started cropping up with + # different headers between the 32-bit and 64-bit + # versions, so we have to shadow those differences off + # and make sure a 32-bit-on-64-bit build picks up the + # right files. + # For android build, use NDK headers instead of host headers + ['host_arch!="ia32" and OS!="android"', { + 'include_dirs+': [ + '/usr/include32', + ], + }], + ], + 'target_conditions': [ + ['_toolset=="target" and OS!="android"', { + # -mmmx allows mmintrin.h to be used for mmx intrinsics. + # video playback is mmx and sse2 optimized. + 'cflags': [ + '-m32', + '-mmmx', + ], + 'ldflags': [ + '-m32', + ], + 'cflags_mozilla': [ + '-m32', + '-mmmx', + ], + }], + ], + }], + ], + }], + ['target_arch=="arm"', { + 'target_conditions': [ + ['_toolset=="target"', { + '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', + ], + 'conditions': [ + ['arm_thumb==1', { + 'cflags': [ + '-mthumb', + ] + }], + ['armv7==1', { + 'cflags': [ + '-march=armv7-a', + '-mtune=cortex-a8', + '-mfloat-abi=<(arm_float_abi)', + ], + 'conditions': [ + ['arm_neon==1', { + 'cflags': [ '-mfpu=neon', ], + }, { + 'cflags': [ '-mfpu=<(arm_fpu)', ], + }], + ], + }], + ['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.4.3/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 + # TestWebKitAPI's WTF.Checked_int8_t test. + '-fno-tree-sra', + '-fuse-ld=gold', + '-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', { + # Android toolchain doesn't support -mimplicit-it=thumb + 'cflags!': [ '-Wa,-mimplicit-it=thumb', ], + 'cflags': [ '-mthumb-interwork', ], + }], + ['armv7==0', { + # Flags suitable for Android emulator + 'cflags': [ + '-march=armv5te', + '-mtune=xscale', + '-msoft-float', + ], + 'defines': [ + '__ARM_ARCH_5__', + '__ARM_ARCH_5T__', + '__ARM_ARCH_5E__', + '__ARM_ARCH_5TE__', + ], + }], + ['clang==1', { + 'cflags!': [ + # Clang does not support the following options. + '-mthumb-interwork', + '-finline-limit=64', + '-fno-tree-sra', + '-fuse-ld=gold', + '-Wno-psabi', + ], + }], + ], + }], + ], + }], + ], + }], + ['linux_fpic==1', { + 'cflags': [ + '-fPIC', + ], + 'ldflags': [ + '-fPIC', + ], + }], + ['sysroot!=""', { + 'target_conditions': [ + ['_toolset=="target"', { + 'cflags': [ + '--sysroot=<(sysroot)', + ], + 'ldflags': [ + '--sysroot=<(sysroot)', + ], + }]] + }], + ['clang==1', { + 'cflags': [ + '-Wheader-hygiene', + # Clang spots more unused functions. + '-Wno-unused-function', + # Don't die on dtoa code that uses a char as an array index. + '-Wno-char-subscripts', + # Especially needed for gtest macros using enum values from Mac + # system headers. + # TODO(pkasting): In C++11 this is legal, so this should be + # removed when we change to that. (This is also why we don't + # bother fixing all these cases today.) + '-Wno-unnamed-type-template-args', + # This (rightyfully) complains about 'override', which we use + # heavily. + '-Wno-c++11-extensions', + + # Warns on switches on enums that cover all enum values but + # also contain a default: branch. Chrome is full of that. + '-Wno-covered-switch-default', + + # TODO(thakis): Remove this. + '-Wno-implicit-conversion-floating-point-to-bool', + ], + 'cflags!': [ + # Clang doesn't seem to know know this flag. + '-mfpmath=sse', + ], + }], + ['clang==1 and clang_use_chrome_plugins==1', { + 'cflags': [ + '<@(clang_chrome_plugins_flags)', + ], + }], + ['clang==1 and clang_load!=""', { + 'cflags': [ + '-Xclang', '-load', '-Xclang', '<(clang_load)', + ], + }], + ['clang==1 and clang_add_plugin!=""', { + 'cflags': [ + '-Xclang', '-add-plugin', '-Xclang', '<(clang_add_plugin)', + ], + }], + ['clang==1 and "<(GENERATOR)"=="ninja"', { + 'cflags': [ + # See http://crbug.com/110262 + '-fcolor-diagnostics', + ], + }], + ['asan==1', { + 'target_conditions': [ + ['_toolset=="target"', { + 'cflags': [ + '-faddress-sanitizer', + '-fno-omit-frame-pointer', + ], + 'ldflags': [ + '-faddress-sanitizer', + ], + 'defines': [ + 'ADDRESS_SANITIZER', + ], + }], + ], + }], + ['tsan==1', { + 'target_conditions': [ + ['_toolset=="target"', { + 'cflags': [ + '-fthread-sanitizer', + '-fno-omit-frame-pointer', + '-fPIE', + ], + 'ldflags': [ + '-fthread-sanitizer', + ], + 'defines': [ + 'THREAD_SANITIZER', + 'DYNAMIC_ANNOTATIONS_EXTERNAL_IMPL=1', + ], + 'target_conditions': [ + ['_type=="executable"', { + 'ldflags': [ + '-pie', + ], + }], + ], + }], + ], + }], + ['order_profiling!=0 and (chromeos==1 or OS=="linux")', { + 'target_conditions' : [ + ['_toolset=="target"', { + 'cflags': [ + '-finstrument-functions', + # Allow mmx intrinsics to inline, so that the + # compiler can expand the intrinsics. + '-finstrument-functions-exclude-file-list=mmintrin.h', + ], + }], + ], + }], + ['linux_breakpad==1', { + 'cflags': [ '-g' ], + 'defines': ['USE_LINUX_BREAKPAD'], + }], + ['linux_use_heapchecker==1', { + 'variables': {'linux_use_tcmalloc%': 1}, + 'defines': ['USE_HEAPCHECKER'], + }], + ['linux_use_tcmalloc==0', { + 'defines': ['NO_TCMALLOC'], + }], + ['linux_keep_shadow_stacks==1', { + 'defines': ['KEEP_SHADOW_STACKS'], + 'cflags': [ + '-finstrument-functions', + # Allow mmx intrinsics to inline, so that the compiler can expand + # the intrinsics. + '-finstrument-functions-exclude-file-list=mmintrin.h', + ], + }], + ['linux_use_gold_flags==1', { + 'ldflags': [ + # Experimentation found that using four linking threads + # saved ~20% of link time. + # https://groups.google.com/a/chromium.org/group/chromium-dev/browse_thread/thread/281527606915bb36 + '-Wl,--threads', + '-Wl,--thread-count=4', + ], + 'conditions': [ + ['release_valgrind_build==0', { + 'target_conditions': [ + ['_toolset=="target"', { + 'ldflags': [ + # There seems to be a conflict of --icf and -pie + # in gold which can generate crashy binaries. As + # a security measure, -pie takes precendence for + # now. + #'-Wl,--icf=safe', + '-Wl,--icf=none', + ], + }], + ], + }], + ], + }], + ['linux_use_gold_binary==1', { + 'variables': { + 'conditions': [ + ['inside_chromium_build==1', { + # We pass the path to gold to the compiler. gyp leaves + # unspecified what the cwd is when running the compiler, + # so the normal gyp path-munging fails us. This hack + # gets the right path. + 'gold_path': '<(PRODUCT_DIR)/../../third_party/gold', + }, { + 'gold_path': '<(PRODUCT_DIR)/../../Source/WebKit/chromium/third_party/gold', + }] + ] + }, + 'ldflags': [ + # Put our gold binary in the search path for the linker. + '-B<(gold_path)', + ], + }], + ], + }, + }], + # FreeBSD-specific options; note that most FreeBSD options are set above, + # with Linux. + ['OS=="freebsd"', { + 'target_defaults': { + 'ldflags': [ + '-Wl,--no-keep-memory', + ], + }, + }], + # Android-specific options; note that most are set above with Linux. + ['OS=="android"', { + 'variables': { + # This is the id for the archived chrome symbols. Each build that + # archives symbols is assigned an id which is then added to GYP_DEFINES. + # This is written to the device log on crashes just prior to dropping a + # tombstone. Tools can determine the location of the archived symbols + # from the id. + 'chrome_symbols_id%': '', + 'conditions': [ + # Use shared stlport library when system one used. + # Figure this out early since it needs symbols from libgcc.a, so it + # has to be before that in the set of libraries. + ['use_system_stlport==1', { + 'android_stlport_library': 'stlport', + }, { + 'android_stlport_library': 'stlport_static', + }], + ], + + # 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%': '', + }, + + 'target_conditions': [ + # 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"', { + 'conditions': [ + ['build_with_mozilla==0', { + 'cflags!': [ + '-pthread', # Not supported by Android toolchain. + ], + 'cflags': [ + '-ffunction-sections', + '-funwind-tables', + '-g', + '-fstack-protector', + '-fno-short-enums', + '-finline-limit=64', + '-Wa,--noexecstack', + '<@(release_extra_cflags)', + ], + 'ldflags!': [ + '-pthread', # Not supported by Android toolchain. + ], + 'ldflags': [ + '-nostdlib', + '-Wl,--no-undefined', + # Don't export symbols from statically linked libraries. + '-Wl,--exclude-libs=ALL', + ], + 'libraries': [ + '-l<(android_stlport_library)', + '-lc', + '-ldl', + '-lstdc++', + '-lm', + ], + 'conditions': [ + ['android_upstream_bringup==1', { + 'defines': ['ANDROID_UPSTREAM_BRINGUP=1',], + }], + ['clang==1', { + 'cflags': [ + # Work around incompatibilities between bionic and clang + # headers. + '-D__compiler_offsetof=__builtin_offsetof', + '-Dnan=__builtin_nan', + ], + 'conditions': [ + ['target_arch=="arm"', { + 'cflags': [ + '-target arm-linux-androideabi', + '-mllvm -arm-enable-ehabi', + ], + 'ldflags': [ + '-target arm-linux-androideabi', + ], + }], + ['target_arch=="ia32"', { + 'cflags': [ + '-target x86-linux-androideabi', + ], + 'ldflags': [ + '-target x86-linux-androideabi', + ], + }], + ], + }], + ['android_build_type==0', { + 'defines': [ + # The NDK has these things, but doesn't define the constants + # to say that it does. Define them here instead. + 'HAVE_SYS_UIO_H', + ], + 'cflags': [ + '--sysroot=<(android_ndk_sysroot)', + ], + 'ldflags': [ + '--sysroot=<(android_ndk_sysroot)', + ], + }], + ['android_build_type==1', { + 'include_dirs': [ + # OpenAL headers from the Android tree. + '<(android_src)/frameworks/wilhelm/include', + ], + 'cflags': [ + # Chromium builds its own (non-third-party) code with + # -Werror to make all warnings into errors. However, Android + # enables warnings that Chromium doesn't, so some of these + # extra warnings trip and break things. + # For now, we leave these warnings enabled but prevent them + # from being treated as errors. + # + # Things that are part of -Wextra: + '-Wno-error=extra', # Enabled by -Wextra, but no specific flag + '-Wno-error=ignored-qualifiers', + '-Wno-error=type-limits', + # Other things unrelated to -Wextra: + '-Wno-error=non-virtual-dtor', + '-Wno-error=sign-promo', + ], + 'cflags_cc': [ + # Disabling c++0x-compat should be handled in WebKit, but + # this currently doesn't work because gcc_version is not set + # correctly when building with the Android build system. + # TODO(torne): Fix this in WebKit. + '-Wno-error=c++0x-compat', + ], + }], + ['android_build_type==1 and chromium_code==0', { + 'cflags': [ + # There is a class of warning which: + # 1) Android always enables and also treats as errors + # 2) Chromium ignores in third party code + # For now, I am leaving these warnings enabled but preventing + # them from being treated as errors here. + '-Wno-error=address', + '-Wno-error=format-security', + '-Wno-error=non-virtual-dtor', + '-Wno-error=return-type', + '-Wno-error=sequence-point', + ], + }], + ['target_arch == "arm"', { + 'ldflags': [ + # Enable identical code folding to reduce size. + '-Wl,--icf=safe', + ], + }], + # NOTE: The stlport header include paths below are specified in + # cflags rather than include_dirs because they need to come + # after include_dirs. Think of them like system headers, but + # don't use '-isystem' because the arm-linux-androideabi-4.4.3 + # toolchain (circa Gingerbread) will exhibit strange errors. + # The include ordering here is important; change with caution. + ['use_system_stlport==1', { + 'cflags': [ + # For libstdc++/include, which is used by stlport. + '-I<(android_src)/bionic', + '-I<(android_src)/external/stlport/stlport', + ], + }, { # else: use_system_stlport!=1 + 'cflags': [ + '-I<(android_ndk_root)/sources/cxx-stl/stlport/stlport', + ], + 'conditions': [ + ['target_arch=="arm" and armv7==1', { + 'ldflags': [ + '-L<(android_ndk_root)/sources/cxx-stl/stlport/libs/armeabi-v7a', + ], + }], + ['target_arch=="arm" and armv7==0', { + 'ldflags': [ + '-L<(android_ndk_root)/sources/cxx-stl/stlport/libs/armeabi', + ], + }], + ['target_arch=="ia32"', { + 'ldflags': [ + '-L<(android_ndk_root)/sources/cxx-stl/stlport/libs/x86', + ], + }], + ], + }], + ['target_arch=="ia32"', { + # The x86 toolchain currently has problems with stack-protector. + 'cflags!': [ + '-fstack-protector', + ], + 'cflags': [ + '-fno-stack-protector', + ], + }], + ], + 'target_conditions': [ + ['_type=="executable"', { + 'ldflags': [ + '-Bdynamic', + '-Wl,-dynamic-linker,/system/bin/linker', + '-Wl,--gc-sections', + '-Wl,-z,nocopyreloc', + # crtbegin_dynamic.o should be the last item in ldflags. + '<(android_ndk_lib)/crtbegin_dynamic.o', + ], + 'libraries': [ + # crtend_android.o needs to be the last item in libraries. + # Do not add any libraries after this! + '<(android_ndk_lib)/crtend_android.o', + ], + }], + ['_type=="shared_library" or _type=="loadable_module"', { + 'ldflags': [ + '-Wl,-shared,-Bsymbolic', + # crtbegin_so.o should be the last item in ldflags. + '<(android_ndk_lib)/crtbegin_so.o', + ], + 'libraries': [ + # crtend_so.o needs to be the last item in libraries. + # Do not add any libraries after this! + '<(android_ndk_lib)/crtend_so.o', + ], + }], + ], + + }], # build_with_mozilla== 0 + + ], + 'defines': [ + 'ANDROID', + '__GNU_SOURCE=1', # Necessary for clone() + 'USE_STLPORT=1', + '_STLP_USE_PTR_SPECIALIZATIONS=1', + 'CHROME_SYMBOLS_ID="<(chrome_symbols_id)"', + ], + }], + # Settings for building host targets using the system toolchain. + ['_toolset=="host"', { + 'cflags!': [ + # Due to issues in Clang build system, using ASan on 32-bit + # binaries on x86_64 host is problematic. + # TODO(eugenis): re-enable. + '-faddress-sanitizer', + ], + 'ldflags!': [ + '-faddress-sanitizer', + '-Wl,-z,noexecstack', + '-Wl,--gc-sections', + '-Wl,-O1', + '-Wl,--as-needed', + ], + 'sources/': [ + ['exclude', '_android(_unittest)?\\.cc$'], + ['exclude', '(^|/)android/'] + ], + }], + ], + }, + }], + ['OS=="solaris"', { + 'cflags!': ['-fvisibility=hidden'], + 'cflags_cc!': ['-fvisibility-inlines-hidden'], + }], + ['OS=="mac" or OS=="ios"', { + 'target_defaults': { + 'mac_bundle': 0, + 'xcode_settings': { + 'ALWAYS_SEARCH_USER_PATHS': 'NO', + 'GCC_C_LANGUAGE_STANDARD': 'c99', # -std=c99 + 'GCC_CW_ASM_SYNTAX': 'NO', # No -fasm-blocks + 'GCC_ENABLE_CPP_EXCEPTIONS': 'NO', # -fno-exceptions + 'GCC_ENABLE_CPP_RTTI': 'NO', # -fno-rtti + 'GCC_ENABLE_PASCAL_STRINGS': 'NO', # No -mpascal-strings + # GCC_INLINES_ARE_PRIVATE_EXTERN maps to -fvisibility-inlines-hidden + 'GCC_INLINES_ARE_PRIVATE_EXTERN': 'YES', + 'GCC_OBJC_CALL_CXX_CDTORS': 'YES', # -fobjc-call-cxx-cdtors + 'GCC_SYMBOLS_PRIVATE_EXTERN': 'YES', # -fvisibility=hidden + 'GCC_THREADSAFE_STATICS': 'NO', # -fno-threadsafe-statics + 'GCC_TREAT_WARNINGS_AS_ERRORS': 'YES', # -Werror + 'GCC_VERSION': '4.2', + 'GCC_WARN_ABOUT_MISSING_NEWLINE': 'YES', # -Wnewline-eof + 'USE_HEADERMAP': 'NO', + 'WARNING_CFLAGS': [ + '-Wall', + '-Wendif-labels', + '-Wextra', + # Don't warn about unused function parameters. + '-Wno-unused-parameter', + # Don't warn about the "struct foo f = {0};" initialization + # pattern. + '-Wno-missing-field-initializers', + ], + 'conditions': [ + ['chromium_mac_pch', {'GCC_PRECOMPILE_PREFIX_HEADER': 'YES'}, + {'GCC_PRECOMPILE_PREFIX_HEADER': 'NO'} + ], + ], + }, + 'target_conditions': [ + ['_type!="static_library"', { + 'xcode_settings': {'OTHER_LDFLAGS': ['-Wl,-search_paths_first']}, + }], + ['_mac_bundle', { + 'xcode_settings': {'OTHER_LDFLAGS': ['-Wl,-ObjC']}, + }], + ], # target_conditions + }, # target_defaults + }], # OS=="mac" or OS=="ios" + ['OS=="mac"', { + 'target_defaults': { + '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. + 'mac_pie': 1, # Most executables can be position-independent. + 'mac_real_dsym': 0, # Fake .dSYMs are fine in most cases. + # Strip debugging symbols from the target. + 'mac_strip': '<(mac_strip_release)', + }, + 'xcode_settings': { + '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': [ + '-fno-strict-aliasing', # See http://crbug.com/32204 + ], + 'conditions': [ + ['clang==1', { + 'CC': '$(SOURCE_ROOT)/<(clang_dir)/clang', + 'LDPLUSPLUS': '$(SOURCE_ROOT)/<(clang_dir)/clang++', + + # Don't use -Wc++0x-extensions, which Xcode 4 enables by default + # when buliding with clang. This warning is triggered when the + # override keyword is used via the OVERRIDE macro from + # base/compiler_specific.h. + 'CLANG_WARN_CXX0X_EXTENSIONS': 'NO', + + 'GCC_VERSION': 'com.apple.compilers.llvm.clang.1_0', + 'WARNING_CFLAGS': [ + '-Wheader-hygiene', + # Don't die on dtoa code that uses a char as an array index. + # This is required solely for base/third_party/dmg_fp/dtoa.cc. + '-Wno-char-subscripts', + # Clang spots more unused functions. + '-Wno-unused-function', + # See comments on this flag higher up in this file. + '-Wno-unnamed-type-template-args', + # This (rightyfully) complains about 'override', which we use + # heavily. + '-Wno-c++11-extensions', + + # Warns on switches on enums that cover all enum values but + # also contain a default: branch. Chrome is full of that. + '-Wno-covered-switch-default', + + # TODO(thakis): Remove this. + '-Wno-implicit-conversion-floating-point-to-bool', + ], + }], + ['clang==1 and clang_use_chrome_plugins==1', { + 'OTHER_CFLAGS': [ + '<@(clang_chrome_plugins_flags)', + ], + }], + ['clang==1 and clang_load!=""', { + 'OTHER_CFLAGS': [ + '-Xclang', '-load', '-Xclang', '<(clang_load)', + ], + }], + ['clang==1 and clang_add_plugin!=""', { + 'OTHER_CFLAGS': [ + '-Xclang', '-add-plugin', '-Xclang', '<(clang_add_plugin)', + ], + }], + ['clang==1 and "<(GENERATOR)"=="ninja"', { + 'OTHER_CFLAGS': [ + # See http://crbug.com/110262 + '-fcolor-diagnostics', + ], + }], + ], + }, + 'conditions': [ + ['clang==1', { + 'variables': { + 'clang_dir': '../third_party/llvm-build/Release+Asserts/bin', + }, + }], + ['asan==1', { + 'xcode_settings': { + 'OTHER_CFLAGS': [ + '-faddress-sanitizer', + ], + }, + 'defines': [ + 'ADDRESS_SANITIZER', + ], + }], + ], + 'target_conditions': [ + ['_type!="static_library"', { + 'xcode_settings': {'OTHER_LDFLAGS': ['-Wl,-search_paths_first']}, + 'conditions': [ + ['asan==1', { + 'xcode_settings': { + 'OTHER_LDFLAGS': [ + '-faddress-sanitizer', + ], + }, + }], + ], + }], + ['_mac_bundle', { + 'xcode_settings': {'OTHER_LDFLAGS': ['-Wl,-ObjC']}, + }], + ['_type=="executable"', { + 'postbuilds': [ + { + # Arranges for data (heap) pages to be protected against + # code execution when running on Mac OS X 10.7 ("Lion"), and + # ensures that the position-independent executable (PIE) bit + # is set for ASLR when running on Mac OS X 10.5 ("Leopard"). + 'variables': { + # Define change_mach_o_flags in a variable ending in _path + # so that GYP understands it's a path and performs proper + # relativization during dict merging. + 'change_mach_o_flags': + 'mac/change_mach_o_flags_from_xcode.sh', + 'change_mach_o_flags_options%': [ + ], + 'target_conditions': [ + ['mac_pie==0 or release_valgrind_build==1', { + # Don't enable PIE if it's unwanted. It's unwanted if + # the target specifies mac_pie=0 or if building for + # Valgrind, because Valgrind doesn't understand slide. + # See the similar mac_pie/release_valgrind_build check + # below. + 'change_mach_o_flags_options': [ + '--no-pie', + ], + }], + ], + }, + 'postbuild_name': 'Change Mach-O Flags', + 'action': [ + '$(srcdir)$(os_sep)build$(os_sep)<(change_mach_o_flags)', + '>@(change_mach_o_flags_options)', + ], + }, + ], + 'conditions': [ + ['asan==1', { + 'variables': { + 'asan_saves_file': 'asan.saves', + }, + 'xcode_settings': { + 'CHROMIUM_STRIP_SAVE_FILE': '<(asan_saves_file)', + }, + }], + ], + 'target_conditions': [ + ['mac_pie==1 and release_valgrind_build==0', { + # Turn on position-independence (ASLR) for executables. When + # PIE is on for the Chrome executables, the framework will + # also be subject to ASLR. + # Don't do this when building for Valgrind, because Valgrind + # doesn't understand slide. TODO: Make Valgrind on Mac OS X + # understand slide, and get rid of the Valgrind check. + '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', + '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 + }, # 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': 'mac/strip_from_xcode', + }, + 'postbuild_name': 'Strip If Needed', + 'action': ['$(srcdir)$(os_sep)build$(os_sep)<(strip_from_xcode)'], + }, + ], # 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' : { + 'GCC_VERSION': 'com.apple.compilers.llvm.clang.1_0', + + # This next block is mostly common with the 'mac' section above, + # but keying off (or setting) 'clang' isn't valid for iOS as it + # also seems to mean using the custom build of clang. + + # Don't use -Wc++0x-extensions, which Xcode 4 enables by default + # when buliding with clang. This warning is triggered when the + # override keyword is used via the OVERRIDE macro from + # base/compiler_specific.h. + 'CLANG_WARN_CXX0X_EXTENSIONS': 'NO', + 'WARNING_CFLAGS': [ + '-Wheader-hygiene', + # Don't die on dtoa code that uses a char as an array index. + # This is required solely for base/third_party/dmg_fp/dtoa.cc. + '-Wno-char-subscripts', + # Clang spots more unused functions. + '-Wno-unused-function', + # See comments on this flag higher up in this file. + '-Wno-unnamed-type-template-args', + # This (rightyfully) complains about 'override', which we use + # heavily. + '-Wno-c++11-extensions', + ], + }, + 'target_conditions': [ + ['_type=="executable"', { + 'configurations': { + 'Release_Base': { + 'xcode_settings': { + 'DEPLOYMENT_POSTPROCESSING': 'YES', + 'STRIP_INSTALLED_PRODUCT': 'YES', + }, + }, + }, + 'xcode_settings': { + 'conditions': [ + ['chromium_ios_signing', { + # iOS SDK wants everything for device signed. + 'CODE_SIGN_IDENTITY[sdk=iphoneos*]': 'iPhone Developer', + }, { + 'CODE_SIGNING_REQUIRED': 'NO', + 'CODE_SIGN_IDENTITY[sdk=iphoneos*]': '', + }], + ], + }, + }], + ], # target_conditions + }, # target_defaults + }], # OS=="ios" + ['OS=="win"', { + 'target_defaults': { + 'defines': [ + 'WIN32', + '_WINDOWS', + 'NOMINMAX', + '_CRT_RAND_S', + 'CERT_CHAIN_PARA_HAS_EXTRA_FIELDS', + 'WIN32_LEAN_AND_MEAN', + '_ATL_NO_OPENGL', + ], + 'conditions': [ + ['build_with_mozilla==0', { + 'defines': [ + '_WIN32_WINNT=0x0602', + 'WINVER=0x0602', + ], + }], + ['buildtype=="Official"', { + # In official builds, targets can self-select an optimization + # level by defining a variable named 'optimize', and setting it + # to one of + # - "size", optimizes for minimal code size - the default. + # - "speed", optimizes for speed over code size. + # - "max", whole program optimization and link-time code + # generation. This is very expensive and should be used + # sparingly. + 'variables': { + 'optimize%': 'size', + }, + 'target_conditions': [ + ['optimize=="size"', { + 'msvs_settings': { + 'VCCLCompilerTool': { + # 1, optimizeMinSpace, Minimize Size (/O1) + 'Optimization': '1', + # 2, favorSize - Favor small code (/Os) + 'FavorSizeOrSpeed': '2', + }, + }, + }, + ], + ['optimize=="speed"', { + 'msvs_settings': { + 'VCCLCompilerTool': { + # 2, optimizeMaxSpeed, Maximize Speed (/O2) + 'Optimization': '2', + # 1, favorSpeed - Favor fast code (/Ot) + 'FavorSizeOrSpeed': '1', + }, + }, + }, + ], + ['optimize=="max"', { + 'msvs_settings': { + 'VCCLCompilerTool': { + # 2, optimizeMaxSpeed, Maximize Speed (/O2) + 'Optimization': '2', + # 1, favorSpeed - Favor fast code (/Ot) + 'FavorSizeOrSpeed': '1', + # This implies link time code generation. + 'WholeProgramOptimization': 'true', + }, + }, + }, + ], + ], + }, + ], + ['component=="static_library"', { + 'defines': [ + '_HAS_EXCEPTIONS=0', + ], + }], + ['MSVS_VERSION=="2008"', { + 'defines': [ + '_HAS_TR1=0', + ], + }], + ['secure_atl', { + 'defines': [ + '_SECURE_ATL', + ], + }], + ], + 'msvs_system_include_dirs': [ + '<(windows_sdk_path)/Include/shared', + '<(windows_sdk_path)/Include/um', + '<(windows_sdk_path)/Include/winrt', +# '<(directx_sdk_path)/Include', + '$(VSInstallDir)/VC/atlmfc/include', + ], + 'msvs_cygwin_dirs': ['<(DEPTH)/third_party/cygwin'], + 'msvs_disabled_warnings': [4351, 4396, 4503, 4819, + # TODO(maruel): These warnings are level 4. They will be slowly + # removed as code is fixed. + 4100, 4121, 4125, 4127, 4130, 4131, 4189, 4201, 4238, 4244, 4245, + 4310, 4355, 4428, 4481, 4505, 4510, 4512, 4530, 4610, 4611, 4701, + 4702, 4706, + ], + 'msvs_settings': { + 'VCCLCompilerTool': { + 'AdditionalOptions': ['/MP'], + 'MinimalRebuild': 'false', + 'BufferSecurityCheck': 'true', + 'EnableFunctionLevelLinking': 'true', + 'RuntimeTypeInfo': 'false', + 'WarningLevel': '4', + 'WarnAsError': 'true', + 'DebugInformationFormat': '3', + 'conditions': [ + ['component=="shared_library"', { + 'ExceptionHandling': '1', # /EHsc + }, { + 'ExceptionHandling': '0', + }], + ], + }, + 'VCLibrarianTool': { + 'AdditionalOptions': ['/ignore:4221'], + 'AdditionalLibraryDirectories': [ +# '<(directx_sdk_path)/Lib/x86', + '<(windows_sdk_path)/Lib/win8/um/x86', + ], + }, + 'VCLinkerTool': { + 'AdditionalDependencies': [ + 'wininet.lib', + 'dnsapi.lib', + 'version.lib', + 'msimg32.lib', + 'ws2_32.lib', + 'usp10.lib', + 'dbghelp.lib', + 'winmm.lib', + 'shlwapi.lib', + ], + + 'conditions': [ + ['msvs_express', { + # Explicitly required when using the ATL with express + 'AdditionalDependencies': [ + 'atlthunk.lib', + ], + + # ATL 8.0 included in WDK 7.1 makes the linker to generate + # almost eight hundred LNK4254 and LNK4078 warnings: + # - warning LNK4254: section 'ATL' (50000040) merged into + # '.rdata' (40000040) with different attributes + # - warning LNK4078: multiple 'ATL' sections found with + # different attributes + 'AdditionalOptions': ['/ignore:4254', '/ignore:4078'], + }], + ['MSVS_VERSION=="2005e"', { + # Non-express versions link automatically to these + 'AdditionalDependencies': [ + 'advapi32.lib', + 'comdlg32.lib', + 'ole32.lib', + 'shell32.lib', + 'user32.lib', + 'winspool.lib', + ], + }], + ], + 'AdditionalLibraryDirectories': [ +# '<(directx_sdk_path)/Lib/x86', XXXX + '<(windows_sdk_path)/Lib/win8/um/x86', + ], + 'GenerateDebugInformation': 'true', + 'MapFileName': '$(OutDir)\\$(TargetName).map', + 'ImportLibrary': '$(OutDir)\\lib\\$(TargetName).lib', + 'FixedBaseAddress': '1', + # SubSystem values: + # 0 == not set + # 1 == /SUBSYSTEM:CONSOLE + # 2 == /SUBSYSTEM:WINDOWS + # Most of the executables we'll ever create are tests + # and utilities with console output. + 'SubSystem': '1', + }, + 'VCMIDLTool': { + 'GenerateStublessProxies': 'true', + 'TypeLibraryName': '$(InputName).tlb', + 'OutputDirectory': '$(IntDir)', + 'HeaderFileName': '$(InputName).h', + 'DLLDataFileName': '$(InputName).dlldata.c', + 'InterfaceIdentifierFileName': '$(InputName)_i.c', + 'ProxyFileName': '$(InputName)_p.c', + }, + 'VCResourceCompilerTool': { + 'Culture' : '1033', + 'AdditionalIncludeDirectories': [ + '<(DEPTH)', + '<(SHARED_INTERMEDIATE_DIR)', + ], + }, + }, + }, + }], + ['disable_nacl==1', { + 'target_defaults': { + 'defines': [ + 'DISABLE_NACL', + ], + }, + }], + ['OS=="win" and msvs_use_common_linker_extras', { + 'target_defaults': { + 'msvs_settings': { + 'VCLinkerTool': { + 'DelayLoadDLLs': [ + 'dbghelp.dll', + 'dwmapi.dll', + 'shell32.dll', + 'uxtheme.dll', + ], + }, + }, + 'configurations': { + 'x86_Base': { + 'msvs_settings': { + 'VCLinkerTool': { + 'AdditionalOptions': [ + '/safeseh', + '/dynamicbase', + '/ignore:4199', + '/ignore:4221', + '/nxcompat', + ], + }, + }, + }, + 'x64_Base': { + 'msvs_settings': { + 'VCLinkerTool': { + 'AdditionalOptions': [ + # safeseh is not compatible with x64 + '/dynamicbase', + '/ignore:4199', + '/ignore:4221', + '/nxcompat', + ], + }, + }, + }, + }, + }, + }], + ['enable_new_npdevice_api==1', { + 'target_defaults': { + 'defines': [ + 'ENABLE_NEW_NPDEVICE_API', + ], + }, + }], + ], + 'xcode_settings': { + # DON'T ADD ANYTHING NEW TO THIS BLOCK UNLESS YOU REALLY REALLY NEED IT! + # This block adds *project-wide* configuration settings to each project + # file. It's almost always wrong to put things here. Specify your + # custom xcode_settings in target_defaults to add them to targets instead. + + 'conditions': [ + # In an Xcode Project Info window, the "Base SDK for All Configurations" + # setting sets the SDK on a project-wide basis. In order to get the + # configured SDK to show properly in the Xcode UI, SDKROOT must be set + # here at the project level. + ['OS=="mac"', { + 'conditions': [ + ['mac_sdk_path==""', { + 'SDKROOT': 'macosx<(mac_sdk)', # -isysroot + }, { + 'SDKROOT': '<(mac_sdk_path)', # -isysroot + }], + ], + }], + ['OS=="ios"', { + 'conditions': [ + ['ios_sdk_path==""', { + 'SDKROOT': 'iphoneos<(ios_sdk)', # -isysroot + }, { + 'SDKROOT': '<(ios_sdk_path)', # -isysroot + }], + ], + }], + ['OS=="ios"', { + # Just build armv7 since iOS 4.3+ only supports armv7. + 'ARCHS': '$(ARCHS_UNIVERSAL_IPHONE_OS)', + 'IPHONEOS_DEPLOYMENT_TARGET': '<(ios_deployment_target)', + # Target both iPhone and iPad. + 'TARGETED_DEVICE_FAMILY': '1,2', + }], + ], + + # The Xcode generator will look for an xcode_settings section at the root + # of each dict and use it to apply settings on a file-wide basis. Most + # settings should not be here, they should be in target-specific + # xcode_settings sections, or better yet, should use non-Xcode-specific + # settings in target dicts. SYMROOT is a special case, because many other + # Xcode variables depend on it, including variables such as + # PROJECT_DERIVED_FILE_DIR. When a source group corresponding to something + # like PROJECT_DERIVED_FILE_DIR is added to a project, in order for the + # files to appear (when present) in the UI as actual files and not red + # red "missing file" proxies, the correct path to PROJECT_DERIVED_FILE_DIR, + # and therefore SYMROOT, needs to be set at the project level. + 'SYMROOT': '<(DEPTH)/xcodebuild', + }, +} diff --git a/build/gyp_includes/filename_rules.gypi b/build/gyp_includes/filename_rules.gypi new file mode 100644 index 0000000000..7b16a15595 --- /dev/null +++ b/build/gyp_includes/filename_rules.gypi @@ -0,0 +1,96 @@ +# 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 gypi file defines the patterns used for determining whether a +# file is excluded from the build on a given platform. It is +# included by common.gypi for chromium_code. + +{ + 'target_conditions': [ + ['OS!="win" or >(nacl_untrusted_build)==1', { + 'sources/': [ ['exclude', '_win(_unittest)?\\.(h|cc)$'], + ['exclude', '(^|/)win/'], + ['exclude', '(^|/)win_[^/]*\\.(h|cc)$'] ], + }], + ['OS!="mac" or >(nacl_untrusted_build)==1', { + 'sources/': [ ['exclude', '_(cocoa|mac)(_unittest)?\\.(h|cc|mm?)$'], + ['exclude', '(^|/)(cocoa|mac)/'] ], + }], + ['OS!="ios" or >(nacl_untrusted_build)==1', { + 'sources/': [ ['exclude', '_ios(_unittest)?\\.(h|cc|mm?)$'], + ['exclude', '(^|/)ios/'] ], + }], + ['(OS!="mac" and OS!="ios") or >(nacl_untrusted_build)==1', { + 'sources/': [ ['exclude', '\\.mm?$' ] ], + }], + # Do not exclude the linux files on *BSD since most of them can be + # shared at this point. + # In case a file is not needed, it is going to be excluded later on. + # TODO(evan): the above is not correct; we shouldn't build _linux + # files on non-linux. + ['OS!="linux" and OS!="solaris" and <(os_bsd)!=1 or >(nacl_untrusted_build)==1', { + 'sources/': [ + ['exclude', '_linux(_unittest)?\\.(h|cc)$'], + ['exclude', '(^|/)linux/'], + ], + }], + ['OS!="android"', { + 'sources/': [ + ['exclude', '_android(_unittest)?\\.cc$'], + ['exclude', '(^|/)android/'], + ], + }], + ['OS=="win" and >(nacl_untrusted_build)==0', { + 'sources/': [ + ['exclude', '_posix(_unittest)?\\.(h|cc)$'], + ['exclude', '(^|/)posix/'], + ], + }], + ['<(chromeos)!=1 or >(nacl_untrusted_build)==1', { + 'sources/': [ ['exclude', '_chromeos(_unittest)?\\.(h|cc)$'] ] + }], + ['>(nacl_untrusted_build)==0', { + 'sources/': [ + ['exclude', '_nacl(_unittest)?\\.(h|cc)$'], + ], + }], + ['OS!="linux" and OS!="solaris" and <(os_bsd)!=1 or >(nacl_untrusted_build)==1', { + 'sources/': [ + ['exclude', '_xdg(_unittest)?\\.(h|cc)$'], + ], + }], + ['<(use_x11)!=1 or >(nacl_untrusted_build)==1', { + 'sources/': [ + ['exclude', '_(x|x11)(_unittest)?\\.(h|cc)$'], + ['exclude', '(^|/)x11_[^/]*\\.(h|cc)$'], + ], + }], + ['(<(toolkit_uses_gtk)!=1 or >(nacl_untrusted_build)==1) and (build_with_mozilla==0)', { + 'sources/': [ + ['exclude', '_gtk(_browsertest|_unittest)?\\.(h|cc)$'], + ['exclude', '(^|/)gtk/'], + ['exclude', '(^|/)gtk_[^/]*\\.(h|cc)$'], + ], + }], + ['<(toolkit_views)==0 or >(nacl_untrusted_build)==1', { + 'sources/': [ ['exclude', '_views\\.(h|cc)$'] ] + }], + ['<(use_aura)==0 or >(nacl_untrusted_build)==1', { + 'sources/': [ ['exclude', '_aura(_unittest)?\\.(h|cc)$'], + ['exclude', '(^|/)aura/'], + ] + }], + ['<(use_aura)==0 or <(use_x11)==0 or >(nacl_untrusted_build)==1', { + 'sources/': [ ['exclude', '_aurax11\\.(h|cc)$'] ] + }], + ['<(use_aura)==0 or OS!="win" or >(nacl_untrusted_build)==1', { + 'sources/': [ ['exclude', '_aurawin\\.(h|cc)$'] ] + }], + ['<(use_ash)==0 or >(nacl_untrusted_build)==1', { + 'sources/': [ ['exclude', '_ash(_unittest)?\\.(h|cc)$'], + ['exclude', '(^|/)ash/'], + ] + }], + ] +} diff --git a/build/gyp_includes/internal/release_defaults.gypi b/build/gyp_includes/internal/release_defaults.gypi new file mode 100644 index 0000000000..1bf674ac12 --- /dev/null +++ b/build/gyp_includes/internal/release_defaults.gypi @@ -0,0 +1,18 @@ +# Copyright (c) 2011 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. +{ + 'msvs_settings': { + 'VCCLCompilerTool': { + 'StringPooling': 'true', + }, + 'VCLinkerTool': { + # No incremental linking. + 'LinkIncremental': '1', + # Eliminate Unreferenced Data (/OPT:REF). + 'OptimizeReferences': '2', + # Folding on (/OPT:ICF). + 'EnableCOMDATFolding': '2', + }, + }, +} diff --git a/build/gyp_includes/internal/release_impl.gypi b/build/gyp_includes/internal/release_impl.gypi new file mode 100644 index 0000000000..5ac0e09d1e --- /dev/null +++ b/build/gyp_includes/internal/release_impl.gypi @@ -0,0 +1,17 @@ +# Copyright (c) 2011 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. +{ + 'includes': ['release_defaults.gypi'], + 'msvs_settings': { + 'VCCLCompilerTool': { + '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-'], + }, + }, +} diff --git a/build/gyp_includes/internal/release_impl_official.gypi b/build/gyp_includes/internal/release_impl_official.gypi new file mode 100644 index 0000000000..d084ae32cf --- /dev/null +++ b/build/gyp_includes/internal/release_impl_official.gypi @@ -0,0 +1,43 @@ +# Copyright (c) 2011 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. +{ + 'includes': ['release_defaults.gypi'], + 'defines': ['OFFICIAL_BUILD'], + 'msvs_settings': { + 'VCCLCompilerTool': { + 'InlineFunctionExpansion': '2', + 'EnableIntrinsicFunctions': 'true', + 'EnableFiberSafeOptimizations': 'true', + '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-'], + }, + 'VCLibrarianTool': { + 'AdditionalOptions': [ + '/ltcg', + '/expectedoutputsize:120000000' + ], + }, + 'VCLinkerTool': { + 'AdditionalOptions': [ + '/time', + # This may reduce memory fragmentation during linking. + # The expected size is 40*1024*1024, which gives us about 10M of + # headroom as of Dec 16, 2011. + '/expectedoutputsize:41943040', + ], + 'LinkTimeCodeGeneration': '1', + # The /PROFILE flag causes the linker to add a "FIXUP" debug stream to + # the generated PDB. According to MSDN documentation, this flag is only + # available (or perhaps supported) in the Enterprise (team development) + # version of Visual Studio. If this blocks your official build, simply + # comment out this line, then re-run "gclient runhooks". + 'Profile': 'true', + }, + }, +} diff --git a/build/gyp_includes/release.gypi b/build/gyp_includes/release.gypi new file mode 100644 index 0000000000..7595ef5a29 --- /dev/null +++ b/build/gyp_includes/release.gypi @@ -0,0 +1,17 @@ +{ + 'conditions': [ + # Handle build types. + ['buildtype=="Dev"', { + 'includes': ['internal/release_impl.gypi'], + }], + ['buildtype=="Official"', { + 'includes': ['internal/release_impl_official.gypi'], + }], + # TODO(bradnelson): may also need: + # checksenabled + # coverage + # dom_stats + # pgo_instrument + # pgo_optimize + ], +} -- cgit v1.2.3