| # Copyright (c) 2013 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. |
| |
| declare_args() { |
| # The optimization level to use for debug builds. |
| if (is_android) { |
| # On Android we kind of optimize some things that don't affect debugging |
| # much even when optimization is disabled to get the binary size down. |
| debug_optimization_level = "s" |
| } else { |
| debug_optimization_level = "2" |
| } |
| } |
| |
| import("//build/config/android/config.gni") |
| if (current_cpu == "arm") { |
| import("//build/config/arm.gni") |
| } |
| if (is_win) { |
| import("//build/config/win/visual_studio_version.gni") |
| } |
| |
| import("//build/toolchain/ccache.gni") |
| |
| # default_include_dirs --------------------------------------------------------- |
| # |
| # This is a separate config so that third_party code (which would not use the |
| # source root and might have conflicting versions of some headers) can remove |
| # this and specify their own include paths. |
| config("default_include_dirs") { |
| include_dirs = [ |
| "//", |
| root_gen_dir, |
| ] |
| } |
| |
| if (!is_win) { |
| using_sanitizer = is_asan || is_lsan || is_msan || is_tsan || is_ubsan |
| } |
| |
| # compiler --------------------------------------------------------------------- |
| # |
| # Base compiler configuration. |
| # |
| # See also "runtime_library" below for related stuff and a discussion about |
| # where stuff should go. Put warning related stuff in the "warnings" config. |
| |
| config("compiler") { |
| asmflags = [] |
| cflags = [] |
| cflags_c = [] |
| cflags_cc = [] |
| cflags_objcc = [] |
| ldflags = [] |
| defines = [] |
| |
| # In general, Windows is totally different, but all the other builds share |
| # some common GCC configuration. This section sets up Windows and the common |
| # GCC flags, and then we handle the other non-Windows platforms specifically |
| # below. |
| if (is_win) { |
| # Windows compiler flags setup. |
| # ----------------------------- |
| cflags += [ |
| "/Gy", # Enable function-level linking. |
| "/GS", # Enable buffer security checking. |
| "/FS", # Preserve previous PDB behavior. |
| ] |
| } else { |
| # Common GCC compiler flags setup. |
| # -------------------------------- |
| common_flags = [ |
| # Not exporting C++ inline functions can generally be applied anywhere |
| # so we do so here. Normal function visibility is controlled by |
| # //build/config/gcc:symbol_visibility_hidden. |
| "-fvisibility-inlines-hidden", |
| ] |
| if (!is_product) { |
| common_flags += [ |
| # We need the frame pointer for CPU and heap profiling. |
| "-fno-omit-frame-pointer", |
| ] |
| } |
| cflags_cc += common_flags |
| cflags_objcc += common_flags |
| |
| # Linker warnings. |
| if (current_cpu != "arm" && !is_mac) { |
| # TODO(jochen): Enable this on ChromeOS on arm. http://crbug.com/356580 |
| ldflags += [ "-Wl,--fatal-warnings" ] |
| } |
| |
| # Enable mitigations for Cortex-A53 Erratum #843419 bug. |
| if (current_cpu == "arm64" && is_clang && !is_mac) { |
| ldflags += [ "-Wl,--fix-cortex-a53-843419" ] |
| } |
| |
| # Common options for AddressSanitizer, LeakSanitizer, ThreadSanitizer and |
| # MemorySanitizer |
| if (using_sanitizer) { |
| cflags += [ "-gline-tables-only" ] |
| } |
| if (is_asan) { |
| cflags += [ "-fsanitize=address" ] |
| ldflags += [ "-fsanitize=address" ] |
| } |
| if (is_lsan) { |
| cflags += [ "-fsanitize=leak" ] |
| ldflags += [ "-fsanitize=leak" ] |
| } |
| if (is_msan) { |
| cflags += [ "-fsanitize=memory" ] |
| ldflags += [ "-fsanitize=memory" ] |
| } |
| if (is_tsan) { |
| cflags += [ "-fsanitize=thread" ] |
| ldflags += [ "-fsanitize=thread" ] |
| } |
| if (is_ubsan) { |
| cflags += [ "-fsanitize=undefined" ] |
| ldflags += [ "-fsanitize=undefined" ] |
| } |
| } |
| |
| if (is_clang && is_debug) { |
| # 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. |
| extra_flags = [ |
| "-Wno-undefined-bool-conversion", |
| "-Wno-tautological-undefined-compare", |
| ] |
| cflags_cc += extra_flags |
| cflags_objcc += extra_flags |
| } |
| |
| # Mac-specific compiler flags setup. |
| # ---------------------------------- |
| if (is_mac) { |
| # These flags are shared between the C compiler and linker. |
| common_mac_flags = [ "-fno-exceptions" ] |
| |
| # CPU architecture. |
| if (current_cpu == "x64") { |
| common_mac_flags += [ |
| "-arch", |
| "x86_64", |
| ] |
| } else if (current_cpu == "x86") { |
| common_mac_flags += [ |
| "-arch", |
| "i386", |
| ] |
| } else if (current_cpu == "arm") { |
| common_mac_flags += [ |
| "-arch", |
| "armv7", |
| ] |
| } else if (current_cpu == "arm64") { |
| common_mac_flags += [ |
| "-arch", |
| "arm64", |
| ] |
| } |
| |
| cflags += common_mac_flags |
| |
| # Without this, the constructors and destructors of a C++ object inside |
| # an Objective C struct won't be called, which is very bad. |
| cflags_objcc += [ "-fobjc-call-cxx-cdtors" ] |
| |
| cflags_c += [ "-std=c99" ] |
| |
| ldflags += common_mac_flags |
| } else if (is_posix) { |
| # CPU architecture. We may or may not be doing a cross compile now, so for |
| # simplicitly we always explicitly set the architecture. |
| if (current_cpu == "x64") { |
| cflags += [ |
| "-m64", |
| "-march=x86-64", |
| "-msse2", |
| ] |
| ldflags += [ "-m64" ] |
| } else if (current_cpu == "x86") { |
| cflags += [ |
| "-m32", |
| "-msse2", |
| "-mfpmath=sse", |
| ] |
| ldflags += [ "-m32" ] |
| if (is_clang) { |
| cflags += [ |
| # Else building libyuv gives clang's register allocator issues, |
| # see llvm.org/PR15798 / crbug.com/233709 |
| "-mno-omit-leaf-frame-pointer", |
| ] |
| } |
| } else if (current_cpu == "arm") { |
| cflags += [ |
| "-march=$arm_arch", |
| "-mfloat-abi=$arm_float_abi", |
| ] |
| if (arm_tune != "") { |
| cflags += [ "-mtune=$arm_tune" ] |
| } |
| if (!is_clang) { |
| # Clang doesn't support these flags. |
| 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", |
| ] |
| } |
| } |
| |
| cflags += [ "-fno-exceptions" ] |
| } |
| |
| # Linux/Android common flags setup. |
| # --------------------------------- |
| if (is_linux || is_android) { |
| ldflags += [ |
| "-Wl,-z,noexecstack", |
| "-Wl,-z,now", |
| "-Wl,-z,relro", |
| "-Wl,--build-id=none", |
| ] |
| } |
| |
| # We need -fPIC: |
| # 1. On ARM for tcmalloc. |
| # 2. On Android. |
| # 3. When using the sanitizers. |
| # Otherwise there is a performance hit, in particular on ia32. |
| if (is_android || is_asan || is_lsan || is_msan || is_tsan || is_ubsan || |
| (is_linux && current_cpu != "x86") || is_fuchsia) { |
| cflags += [ "-fPIC" ] |
| ldflags += [ "-fPIC" ] |
| } |
| |
| # Linux-specific compiler flags setup. |
| # ------------------------------------ |
| if (is_linux) { |
| if (is_clang) { |
| if (current_cpu == "arm") { |
| cflags += [ "--target=armv7-linux-gnueabihf" ] |
| ldflags += [ "--target=armv7-linux-gnueabihf" ] |
| } else if (current_cpu == "arm64") { |
| cflags += [ "--target=aarch64-linux-gnu" ] |
| ldflags += [ "--target=aarch64-linux-gnu" ] |
| } else if (current_cpu == "riscv32") { |
| cflags += [ "--target=riscv32-linux-gnu" ] |
| ldflags += [ "--target=riscv32-linux-gnu" ] |
| } else if (current_cpu == "riscv64") { |
| cflags += [ "--target=riscv64-linux-gnu" ] |
| ldflags += [ "--target=riscv64-linux-gnu" ] |
| } else if (current_cpu == "x86") { |
| cflags += [ "--target=i386-linux-gnu" ] |
| ldflags += [ "--target=i386-linux-gnu" ] |
| } |
| } |
| } |
| |
| # Clang-specific compiler flags setup. |
| # ------------------------------------ |
| if (is_clang) { |
| cflags += [ "-fcolor-diagnostics" ] |
| } |
| |
| # C++ standard compiler flags setup. |
| # --------------------------- |
| if (is_win) { |
| cc_std = [ "/std:c++17" ] |
| } else { |
| cc_std = [ "-std=c++17" ] |
| } |
| cflags_cc += cc_std |
| cflags_objcc += cc_std |
| |
| # Android-specific flags setup. |
| # ----------------------------- |
| if (is_android) { |
| cflags += [ |
| "-ffunction-sections", |
| "-funwind-tables", |
| "-fno-short-enums", |
| "-nostdinc++", |
| ] |
| if (!is_clang) { |
| # Clang doesn't support these flags. |
| cflags += [ "-finline-limit=64" ] |
| } |
| if (current_cpu == "arm64") { |
| # TODO (https://github.com/flutter/flutter/issues/75348). |
| cflags += [ "-mno-outline-atomics" ] |
| } |
| if (is_asan) { |
| # Android build relies on -Wl,--gc-sections removing unreachable code. |
| # ASan instrumentation for globals inhibits this and results in a library |
| # with unresolvable relocations. |
| # TODO(eugenis): find a way to reenable this. |
| cflags += [ "-mllvm -asan-globals=0" ] |
| } |
| |
| defines += [ "ANDROID" ] |
| |
| # The NDK has these things, but doesn't define the constants |
| # to say that it does. Define them here instead. |
| defines += [ "HAVE_SYS_UIO_H" ] |
| |
| # Use gold for Android for most CPU architectures. |
| if (current_cpu == "x86" || current_cpu == "x64" || current_cpu == "arm" || |
| current_cpu == "arm64") { |
| ldflags += [ "-fuse-ld=gold" ] |
| if (is_clang) { |
| # Let clang find the ld.gold in the NDK. |
| toolchain_root = rebase_path(android_toolchain_root, root_build_dir) |
| ldflags += [ "--gcc-toolchain=$toolchain_root" ] |
| ldflags += [ "-B${toolchain_root}/bin" ] |
| } |
| } |
| |
| ldflags += [ |
| # Don't allow visible symbols from libgcc or libc++ to be |
| # re-exported. |
| "-Wl,--exclude-libs=libgcc.a", |
| "-Wl,--exclude-libs=libc++_static.a", |
| ] |
| |
| if (is_clang) { |
| if (current_cpu == "arm") { |
| cflags += [ "--target=arm-linux-androideabi" ] |
| ldflags += [ "--target=arm-linux-androideabi" ] |
| } else if (current_cpu == "arm64") { |
| cflags += [ "--target=aarch64-linux-android" ] |
| ldflags += [ "--target=aarch64-linux-android" ] |
| } else if (current_cpu == "x86") { |
| cflags += [ "--target=i686-linux-androideabi" ] |
| ldflags += [ "--target=i686-linux-androideabi" ] |
| } else if (current_cpu == "x64") { |
| cflags += [ "--target=x86_64-linux-androideabi" ] |
| ldflags += [ "--target=x86_64-linux-androideabi" ] |
| } |
| } |
| } |
| |
| # We want to force a recompile and relink of the world whenever our toolchain |
| # changes since artifacts from an older version of the toolchain may or may |
| # not be compatible with newer ones. To achieve this, we insert a synthetic |
| # define into the compile line. |
| if (is_clang && (is_linux || is_mac)) { |
| if (is_linux && host_cpu == "arm64") { |
| toolchain_stamp_file = |
| "//buildtools/linux-arm64/clang/.versions/clang.cipd_version" |
| } else if (is_linux) { |
| toolchain_stamp_file = |
| "//buildtools/linux-x64/clang/.versions/clang.cipd_version" |
| } else { |
| toolchain_stamp_file = |
| "//buildtools/mac-x64/clang/.versions/clang.cipd_version" |
| } |
| cipd_version = read_file(toolchain_stamp_file, "json") |
| defines = [ "TOOLCHAIN_VERSION=${cipd_version.instance_id}" ] |
| } |
| |
| # Assign any flags set for the C compiler to asmflags so that they are sent |
| # to the assembler. The Windows assembler takes different types of flags |
| # so only do so for posix platforms. |
| if (is_posix) { |
| asmflags += cflags |
| asmflags += cflags_c |
| } |
| } |
| |
| # This is separate from :compiler_codegen (and not even a sub-config there) |
| # so that some targets can remove it from the list with: |
| # configs -= [ "//build/config/compiler:clang_stackrealign" ] |
| # See https://crbug.com/556393 for details of where it must be avoided. |
| config("clang_stackrealign") { |
| if (is_clang && current_cpu == "x86" && !is_nacl && !is_win) { |
| cflags = [ |
| # Align the stack on 16-byte boundaries, http://crbug.com/418554. |
| "-mstack-alignment=16", |
| "-mstackrealign", |
| ] |
| } |
| } |
| |
| config("compiler_arm_fpu") { |
| if (current_cpu == "arm") { |
| cflags = [ "-mfpu=$arm_fpu" ] |
| } |
| } |
| |
| config("compiler_arm_thumb") { |
| if (current_cpu == "arm") { |
| if (arm_use_thumb) { |
| cflags = [ "-mthumb" ] |
| if (is_android && !is_clang) { # Clang doesn't support this option. |
| cflags += [ "-mthumb-interwork" ] |
| } |
| asmflags = cflags |
| } |
| } |
| } |
| |
| # runtime_library ------------------------------------------------------------- |
| # |
| # Sets the runtime library and associated options. |
| # |
| # How do you determine what should go in here vs. "compiler" above? Consider if |
| # a target might choose to use a different runtime library (ignore for a moment |
| # if this is possible or reasonable on your system). If such a target would |
| # want to change or remove your option, put it in the runtime_library config. |
| # If a target wants the option regardless, put it in the compiler config. |
| |
| config("runtime_library") { |
| cflags = [] |
| defines = [] |
| ldflags = [] |
| lib_dirs = [] |
| libs = [] |
| |
| # Static CRT. |
| if (is_win) { |
| if (is_debug) { |
| cflags += [ "/MTd" ] |
| } else { |
| cflags += [ "/MT" ] |
| } |
| defines += [ |
| "__STD_C", |
| "_CRT_RAND_S", |
| "_CRT_SECURE_NO_DEPRECATE", |
| "_HAS_EXCEPTIONS=0", |
| "_SCL_SECURE_NO_DEPRECATE", |
| ] |
| } |
| |
| if (is_linux) { |
| libs += [ "dl" ] |
| } else if (is_android) { |
| # Android standard library setup. |
| if (is_clang) { |
| # Work around incompatibilities between bionic and clang headers. |
| defines += [ "__compiler_offsetof=__builtin_offsetof" ] |
| } |
| |
| defines += [ "__GNU_SOURCE=1" ] # Necessary for clone(). |
| |
| ldflags += [ |
| "-Wl,--warn-shared-textrel", |
| "-nostdlib", |
| ] |
| |
| # NOTE: The libc++ 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. |
| cflags += [ |
| "-isystem" + rebase_path("$android_libcpp_root/include", root_build_dir), |
| "-isystem" + rebase_path( |
| "$android_ndk_root/sources/cxx-stl/llvm-libc++abi/include", |
| root_build_dir), |
| "-isystem" + |
| rebase_path("$android_ndk_root/sources/android/support/include", |
| root_build_dir), |
| "-isystem" + rebase_path( |
| "$android_ndk_root/sysroot/usr/include/$android_target_triple", |
| root_build_dir), |
| "-D__ANDROID_API__=$android_api_level", |
| ] |
| |
| lib_dirs += [ "$android_libcpp_root/libs/$android_app_abi" ] |
| |
| libs += [ |
| "$android_libcpp_library", |
| "c++abi", |
| ] |
| |
| if (android_api_level < 21) { |
| libs += [ "android_support" ] |
| } |
| |
| if (current_cpu == "arm") { |
| libs += [ "unwind" ] |
| } |
| |
| libs += [ |
| "gcc", |
| "c", |
| "dl", |
| "m", |
| ] |
| |
| # Clang with libc++ does not require an explicit atomic library reference. |
| if (!is_clang) { |
| libs += [ "atomic" ] |
| } |
| } |
| } |
| |
| # default_warning_flags collects all warning flags that are used by default. |
| # This is in a variable instead of a config so that it can be used in |
| # both chromium_code and no_chromium_code. This way these flags are guaranteed |
| # to appear on the compile command line after -Wall. |
| |
| default_warning_flags = [] |
| default_warning_flags_cc = [] |
| if (is_win) { |
| if (current_cpu != "x86") { |
| default_warning_flags += [ "/WX" ] # Treat warnings as errors. |
| } |
| |
| if (is_clang) { |
| default_warning_flags += [ |
| "-Wno-deprecated-declarations", # crashpad |
| "-Wno-ignored-pragma-optimize", # icu, double-conversion |
| "-Wno-macro-redefined", |
| "-Wno-microsoft-cast", |
| "-Wno-microsoft-unqualified-friend", |
| "-Wno-unknown-argument", # icu |
| "-Wno-unused-value", # crashpad |
| ] |
| } else { |
| default_warning_flags += [ |
| # Permanent. |
| "/wd4091", # typedef warning from dbghelp.h |
| "/wd4722", # destructor never returns |
| |
| # Investigate. |
| "/wd4312", # int to pointer of greater size conversion. |
| "/wd4838", # Narrowing conversion required. |
| "/wd4172", # Returning address of local. |
| "/wd4005", # Redefinition of macros for PRId64 etc. |
| "/wd4311", # Pointer truncation from PVOID to DWORD. |
| "/wd4477", # Format string requires wchar_t* |
| ] |
| } |
| } else { |
| # Common GCC warning setup. |
| default_warning_flags += [ |
| # Enables. |
| "-Wendif-labels", # Weird old-style text after an #endif. |
| |
| # Disables. |
| "-Wno-missing-field-initializers", # "struct foo f = {0};" |
| "-Wno-unused-parameter", # Unused function parameters. |
| ] |
| |
| if (is_clang) { |
| default_warning_flags += [ |
| "-Wno-tautological-constant-compare", |
| "-Wno-unused-but-set-variable", # icu |
| ] |
| } else { |
| default_warning_flags += |
| [ "-Wno-ignored-qualifiers" ] # Warnings in BoringSSL headers |
| } |
| |
| if (is_mac) { |
| # TODO(abarth): Re-enable once https://github.com/domokit/mojo/issues/728 |
| # is fixed. |
| # default_warning_flags += [ "-Wnewline-eof" ] |
| |
| # When compiling Objective-C, warns if a method is used whose |
| # availability is newer than the deployment target. This is not |
| # required when compiling Chrome for iOS. |
| default_warning_flags += [ "-Wpartial-availability" ] |
| } |
| |
| # Suppress warnings about ABI changes on ARM (Clang doesn't give this |
| # warning). |
| if (current_cpu == "arm" && !is_clang) { |
| default_warning_flags += [ "-Wno-psabi" ] |
| } |
| |
| # The Raspberry Pi 1 toolchain enables this warning, but Dart doesn't build |
| # cleanly with it. |
| if (is_linux && !is_clang && current_cpu == "arm" && arm_version == 6) { |
| default_warning_flags += [ "-Wno-type-limits" ] |
| } |
| |
| if (is_android) { |
| # Disable any additional warnings enabled by the Android build system but |
| # which chromium does not build cleanly with (when treating warning as |
| # errors). |
| default_warning_flags += [ |
| "-Wno-extra", |
| "-Wno-ignored-qualifiers", |
| "-Wno-type-limits", |
| ] |
| default_warning_flags_cc += [ |
| # Other things unrelated to -Wextra: |
| "-Wno-non-virtual-dtor", |
| "-Wno-sign-promo", |
| ] |
| } |
| } |
| |
| # chromium_code --------------------------------------------------------------- |
| # |
| # Toggles between higher and lower warnings for code that is (or isn't) |
| # part of Chromium. |
| |
| config("chromium_code") { |
| if (is_win) { |
| # TODO(zra): Enable higher warning levels. |
| # cflags = [ "/W4" ] # Warning level 4. |
| cflags = [] |
| } else { |
| cflags = [ |
| "-Wall", |
| "-Wextra", |
| "-Werror", |
| ] |
| |
| defines = [] |
| if (!using_sanitizer && !is_clang) { |
| # _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. |
| # |
| # 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" ] |
| } |
| } |
| cflags += default_warning_flags |
| cflags_cc = default_warning_flags_cc |
| } |
| config("no_chromium_code") { |
| cflags = [] |
| cflags_cc = [] |
| defines = [] |
| |
| if (is_win) { |
| defines += [ |
| "_CRT_NONSTDC_NO_WARNINGS", |
| "_CRT_NONSTDC_NO_DEPRECATE", |
| ] |
| } |
| |
| cflags += default_warning_flags |
| cflags_cc += default_warning_flags_cc |
| } |
| |
| # rtti ------------------------------------------------------------------------ |
| # |
| # Allows turning Run-Time Type Identification on or off. |
| |
| config("rtti") { |
| if (is_win) { |
| cflags_cc = [ "/GR" ] |
| } |
| } |
| config("no_rtti") { |
| if (is_win) { |
| cflags_cc = [ "/GR-" ] |
| } else { |
| rtti_flags = [ "-fno-rtti" ] |
| cflags_cc = rtti_flags |
| cflags_objcc = rtti_flags |
| } |
| } |
| |
| # Optimization ----------------------------------------------------------------- |
| # |
| # Note that BUILDCONFIG.gn sets up a variable "default_optimization_config" |
| # which it will assign to the config it implicitly applies to every target. If |
| # you want to override the optimization level for your target, remove this |
| # config (which will expand differently for debug or release builds), and then |
| # add back the one you want to override it with: |
| # |
| # configs -= default_optimization_config |
| # configs += [ ":optimize_max" ] |
| |
| # Shared settings. |
| # IMPORTANT: On Windows "/O1" and "/O2" must go before the common flags. |
| if (is_win) { |
| common_optimize_on_cflags = [ |
| "/Ob2", # Both explicit and auto inlining. |
| "/Oy-", # Disable omitting frame pointers, must be after /O2. |
| ] |
| if (!is_asan) { |
| common_optimize_on_cflags += [ |
| # 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. |
| "/Gw", |
| ] |
| } |
| common_optimize_on_ldflags = [ |
| # Linker GC. |
| "/OPT:REF", |
| |
| # Identical code folding to reduce size. |
| # Warning: This changes C/C++ semantics of function pointer comparison. |
| "/OPT:ICF", |
| ] |
| } else { |
| common_optimize_on_cflags = [ |
| # 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", |
| ] |
| common_optimize_on_ldflags = [] |
| |
| if (is_android) { |
| common_optimize_on_ldflags += [ |
| # Warn in case of text relocations. |
| "-Wl,--warn-shared-textrel", |
| ] |
| } |
| |
| if (is_mac) { |
| # Mac dead code stripping requires symbols. |
| common_optimize_on_ldflags += [ "-Wl,-dead_strip" ] |
| } else { |
| # Non-Mac Posix linker flags. |
| common_optimize_on_ldflags += [ |
| # Specifically tell the linker to perform optimizations. |
| # See http://lwn.net/Articles/192624/ . |
| "-Wl,-O2", |
| "-Wl,--gc-sections", |
| ] |
| |
| if (is_clang && !using_sanitizer) { |
| # Identical code folding to reduce size. |
| # Warning: This changes C/C++ semantics of function pointer comparison. |
| common_optimize_on_ldflags += [ "-Wl,--icf=all" ] |
| } |
| |
| if (!using_sanitizer) { |
| # Functions interposed by the sanitizers can make ld think |
| # that some libraries aren't needed when they actually are, |
| # http://crbug.com/234010. As workaround, disable --as-needed. |
| common_optimize_on_ldflags += [ "-Wl,--as-needed" ] |
| } |
| } |
| } |
| |
| # Default "optimization on" config. On Windows, this favors size over speed. |
| config("optimize") { |
| if (is_win) { |
| # Favor size over speed, /O1 must be before the common flags. The GYP |
| # build also specifies /Os and /GF but these are implied by /O1. |
| cflags = [ "/O2" ] + common_optimize_on_cflags + [ "/Oi" ] |
| } else if (is_android) { |
| cflags = [ "-Os" ] + common_optimize_on_cflags # Favor size over speed. |
| } else { |
| cflags = [ "-O3" ] + common_optimize_on_cflags |
| } |
| ldflags = common_optimize_on_ldflags |
| } |
| |
| # Turn off optimizations. |
| config("no_optimize") { |
| if (is_win) { |
| # The only difference on windows is that the inlining is less aggressive. |
| # (We accept the default level). Otherwise it is very slow. |
| if (is_clang && debug_optimization_level != "2") { |
| cflags = [ |
| "-d${debug_optimization_level}", # Do some optimizations. |
| "/Oy-", # Disable omitting frame pointers, must be after /O2. |
| ] |
| } else { |
| cflags = [ |
| "/O${debug_optimization_level}", # Do some optimizations. |
| "/Oy-", # Disable omitting frame pointers, must be after /O2. |
| ] |
| } |
| } else if (is_android) { |
| # On Android we kind of optimize some things that don't affect debugging |
| # much even when optimization is disabled to get the binary size down. |
| cflags = [ |
| "-O${debug_optimization_level}", |
| "-fdata-sections", |
| "-ffunction-sections", |
| ] |
| ldflags = common_optimize_on_ldflags |
| } else { |
| cflags = [ |
| "-O${debug_optimization_level}", |
| "-fdata-sections", |
| "-ffunction-sections", |
| ] |
| } |
| } |
| |
| # These are two named configs that zlib's BUILD.gn expects to exist. |
| config("default_optimization") { |
| } |
| |
| config("optimize_speed") { |
| } |
| |
| # Symbols ---------------------------------------------------------------------- |
| |
| config("symbols") { |
| if (is_win) { |
| import("//build/toolchain/goma.gni") |
| if (use_goma) { |
| cflags = [ "/Z7" ] # No PDB file |
| } else { |
| cflags = [ "/Zi" ] # Produce PDB file, no edit and continue. |
| } |
| ldflags = [ "/DEBUG" ] |
| } else { |
| cflags = [ |
| "-g3", |
| "-ggdb3", |
| ] |
| } |
| } |