| # 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. |
| |
| import("//build/config/android/config.gni") |
| if (current_cpu == "arm") { |
| import("//build/config/arm.gni") |
| } |
| if (current_cpu == "mipsel" || current_cpu == "mips64el") { |
| import("//build/config/mips.gni") |
| } |
| if (is_posix) { |
| import("//build/config/gcc/gcc_version.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_tsan || is_msan |
| } |
| |
| # 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", |
| |
| # 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" ] |
| } |
| |
| # 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_tsan) { |
| cflags += [ "-fsanitize=thread" ] |
| ldflags += [ "-fsanitize=thread" ] |
| } |
| if (is_msan) { |
| cflags += [ "-fsanitize=memory" ] |
| ldflags += [ "-fsanitize=memory" ] |
| } |
| } |
| |
| 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 |
| } |
| |
| if (is_clang) { |
| # This is here so that all files get recompiled after a clang roll and |
| # when turning clang on or off. (defines are passed via the command line, |
| # and build system rebuild things when their commandline changes). Nothing |
| # should ever read this define. |
| defines += |
| [ "CR_CLANG_REVISION=" + exec_script("//tools/clang/scripts/update.py", |
| [ "--print-revision" ], |
| "trim string") ] |
| } |
| |
| # 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 |
| # simplicity 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", |
| |
| # Align the stack on 16-byte boundaries, http://crbug.com/418554. |
| "-mstack-alignment=16", |
| "-mstackrealign", |
| ] |
| } |
| } else if (current_cpu == "arm") { |
| cflags += [ |
| "-march=$arm_arch", |
| "-mfloat-abi=$arm_float_abi", |
| ] |
| if (arm_tune != "") { |
| cflags += [ "-mtune=$arm_tune" ] |
| } |
| if (arm_use_thumb) { |
| cflags += [ "-mthumb" ] |
| if (is_android && !is_clang) { # Clang doesn't support this option. |
| cflags += [ "-mthumb-interwork" ] |
| } |
| } |
| 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", |
| ] |
| } |
| } else if (current_cpu == "mipsel") { |
| # We have to explicitly request exceptions to get good heap profiles from |
| # tcmalloc. |
| if (is_debug || is_release) { |
| cflags += [ |
| "-fexceptions", |
| "-funwind-tables", |
| ] |
| } |
| |
| if (mips_arch_variant == "r6") { |
| cflags += [ |
| "-mips32r6", |
| "-Wa,-mips32r6", |
| ] |
| if (is_android) { |
| ldflags += [ |
| "-mips32r6", |
| "-Wl,-melf32ltsmip", |
| ] |
| } |
| } else if (mips_arch_variant == "r2") { |
| cflags += [ |
| "-mips32r2", |
| "-Wa,-mips32r2", |
| ] |
| if (mips_float_abi == "hard" && mips_fpu_mode != "") { |
| cflags += [ "-m$mips_fpu_mode" ] |
| } |
| } else if (mips_arch_variant == "r1") { |
| cflags += [ |
| "-mips32", |
| "-Wa,-mips32", |
| ] |
| } |
| |
| if (mips_dsp_rev == 1) { |
| cflags += [ "-mdsp" ] |
| } else if (mips_dsp_rev == 2) { |
| cflags += [ "-mdspr2" ] |
| } |
| |
| cflags += [ "-m${mips_float_abi}-float" ] |
| } else if (current_cpu == "mips64el") { |
| if (mips_arch_variant == "r6") { |
| cflags += [ |
| "-mips64r6", |
| "-Wa,-mips64r6", |
| ] |
| ldflags += [ "-mips64r6" ] |
| } else if (mips_arch_variant == "r2") { |
| cflags += [ |
| "-mips64r2", |
| "-Wa,-mips64r2", |
| ] |
| ldflags += [ "-mips64r2" ] |
| } |
| } |
| |
| if (current_cpu != "mipsel") { |
| cflags += [ "-fno-exceptions" ] |
| } |
| } |
| |
| # Linux/Android common flags setup. |
| # --------------------------------- |
| if (is_linux || is_android) { |
| cflags += [ "-fPIC" ] |
| |
| ldflags += [ |
| "-fPIC", |
| "-Wl,-z,noexecstack", |
| "-Wl,-z,now", |
| "-Wl,-z,relro", |
| ] |
| } |
| |
| # Linux-specific compiler flags setup. |
| # ------------------------------------ |
| if (is_linux) { |
| cflags += [ "-pthread" ] |
| ldflags += [ "-pthread" ] |
| } |
| |
| # Clang-specific compiler flags setup. |
| # ------------------------------------ |
| if (is_clang) { |
| cflags += [ "-fcolor-diagnostics" ] |
| } |
| |
| # Android-specific flags setup. |
| # ----------------------------- |
| if (is_android) { |
| cflags += [ |
| "-ffunction-sections", |
| "-funwind-tables", |
| "-fno-short-enums", |
| ] |
| if (!is_clang) { |
| # Clang doesn't support these flags. |
| cflags += [ "-finline-limit=64" ] |
| } |
| 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") { |
| ldflags += [ "-fuse-ld=gold" ] |
| if (is_clang) { |
| # Let clang find the ld.gold in the NDK. |
| ldflags += [ "--gcc-toolchain=" + |
| rebase_path(android_toolchain_root, root_build_dir) ] |
| } |
| } |
| |
| 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 (current_cpu == "arm") { |
| ldflags += [ |
| # Enable identical code folding to reduce size. |
| "-Wl,--icf=safe", |
| ] |
| } |
| |
| if (is_clang) { |
| if (current_cpu == "arm") { |
| cflags += [ "--target=arm-linux-androideabi" ] |
| ldflags += [ "--target=arm-linux-androideabi" ] |
| } else if (current_cpu == "x86") { |
| cflags += [ "--target=x86-linux-androideabi" ] |
| ldflags += [ "--target=x86-linux-androideabi" ] |
| } |
| } |
| } |
| |
| # 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 |
| } |
| } |
| |
| config("compiler_arm_fpu") { |
| if (current_cpu == "arm") { |
| cflags = [ "-mfpu=$arm_fpu" ] |
| } |
| } |
| |
| # 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", |
| ] |
| } |
| |
| # Android standard library setup. |
| if (is_android) { |
| if (is_clang) { |
| # Work around incompatibilities between bionic and clang headers. |
| defines += [ |
| "__compiler_offsetof=__builtin_offsetof", |
| "nan=__builtin_nan", |
| ] |
| } |
| |
| defines += [ "__GNU_SOURCE=1" ] # Necessary for clone(). |
| |
| # TODO(jdduke) Re-enable on mips after resolving linking |
| # issues with libc++ (crbug.com/456380). |
| if (current_cpu != "mipsel" && current_cpu != "mips64el") { |
| ldflags += [ "-Wl,--warn-shared-textrel" ] |
| } |
| ldflags += [ "-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/libcxx/include", root_build_dir), |
| "-isystem" + rebase_path( |
| "$android_ndk_root/sources/cxx-stl/llvm-libc++abi/libcxxabi/include", |
| root_build_dir), |
| "-isystem" + |
| rebase_path("$android_ndk_root/sources/android/support/include", |
| root_build_dir), |
| ] |
| |
| lib_dirs += [ "$android_libcpp_root/libs/$android_app_abi" ] |
| libs += [ "$android_libcpp_library" ] |
| |
| if (current_cpu == "mipsel") { |
| libs += [ |
| # ld linker is used for mips Android, and ld does not accept library |
| # absolute path prefixed by "-l"; Since libgcc does not exist in mips |
| # sysroot the proper library will be linked. |
| # TODO(gordanac): Remove once gold linker is used for mips Android. |
| "gcc", |
| ] |
| } else { |
| libs += [ |
| # Manually link the libgcc.a that the cross compiler uses. This is |
| # absolute because the linker will look inside the sysroot if it's not. |
| rebase_path(android_libgcc_file), |
| ] |
| } |
| |
| libs += [ |
| "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. |
| } |
| |
| default_warning_flags += [ |
| # Permanent. |
| "/wd4091", # typedef warning from dbghelp.h |
| |
| # 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_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" ] |
| } |
| |
| 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 += [ |
| # 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", |
| |
| # Other things unrelated to -Wextra: |
| "-Wno-non-virtual-dtor", |
| "-Wno-sign-promo", |
| ] |
| } |
| |
| if (gcc_version >= 48) { |
| # Don't warn about the "typedef 'foo' locally defined but not used" |
| # for gcc 4.8. |
| # TODO: remove this flag once all builds work. See crbug.com/227506 |
| default_warning_flags += [ "-Wno-unused-local-typedefs" ] |
| } |
| } |
| |
| # 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_linux || !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 = [ "/OPT:REF" ] |
| } 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,-O1", |
| "-Wl,--gc-sections", |
| ] |
| |
| 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. |
| cflags = [ |
| "/O2", # 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 = [ |
| "-Os", |
| "-fdata-sections", |
| "-ffunction-sections", |
| ] |
| ldflags = common_optimize_on_ldflags |
| } else { |
| cflags = [ |
| "-O1", |
| "-fdata-sections", |
| "-ffunction-sections", |
| ] |
| } |
| } |
| |
| # 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", |
| ] |
| } |
| } |