# 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.

# =============================================================================
# WHAT IS THIS FILE?
# =============================================================================
#
# This is the master GN build configuration. This file is loaded after the
# build args (args.gn) for the build directory and after the toplevel ".gn"
# file (which points to this file as the build configuration).
#
# This file will be executed and the resulting context will be used to execute
# every other file in the build. So variables declared here (that don't start
# with an underscore) will be implicitly global.

# =============================================================================
# PLATFORM SELECTION
# =============================================================================
#
# There are two main things to set: "os" and "cpu". The "toolchain" is the name
# of the GN thing that encodes combinations of these things.
#
# Users typically only set the variables "target_os" and "target_cpu" in "gn
# args", the rest are set up by our build and internal to GN.
#
# There are three different types of each of these things: The "host"
# represents the computer doing the compile and never changes. The "target"
# represents the main thing we're trying to build. The "current" represents
# which configuration is currently being defined, which can be either the
# host, the target, or something completely different (like nacl). GN will
# run the same build file multiple times for the different required
# configuration in the same build.
#
# This gives the following variables:
#  - host_os, host_cpu, host_toolchain
#  - target_os, target_cpu, default_toolchain
#  - current_os, current_cpu, current_toolchain.
#
# Note the default_toolchain isn't symmetrical (you would expect
# target_toolchain). This is because the "default" toolchain is a GN built-in
# concept, and "target" is something our build sets up that's symmetrical with
# its GYP counterpart. Potentially the built-in default_toolchain variable
# could be renamed in the future.
#
# When writing build files, to do something only for the host:
#   if (current_toolchain == host_toolchain) { ...

if (target_os == "") {
  target_os = host_os
}

if (target_cpu == "") {
  if (target_os == "android") {
    # If we're building for Android, we should assume that we want to
    # build for ARM by default, not the host_cpu (which is likely x64).
    # This allows us to not have to specify both target_os and target_cpu
    # on the command line.
    target_cpu = "arm"
  } else {
    target_cpu = host_cpu
  }
}

if (current_cpu == "") {
  current_cpu = target_cpu
}
if (current_os == "") {
  current_os = target_os
}

# =============================================================================
# BUILD FLAGS
# =============================================================================
#
# This block lists input arguments to the build, along with their default
# values.
#
# If a value is specified on the command line, it will overwrite the defaults
# given in a declare_args block, otherwise the default will be used.
#
# YOU SHOULD ALMOST NEVER NEED TO ADD FLAGS TO THIS FILE. GN allows any file in
# the build to declare build flags. If you need a flag for a single component,
# you can just declare it in the corresponding BUILD.gn file.
#
# - If your feature is a single target, say //components/foo, you can put
#   a declare_args() block in //components/foo/BUILD.gn and use it there.
#   Nobody else in the build needs to see the flag.
#
# - Defines based on build variables should be implemented via the generated
#   build flag header system. See //build/buildflag_header.gni. You can put
#   the buildflag_header target in the same file as the build flag itself. You
#   should almost never set "defines" directly.
#
# - If your flag toggles a target on and off or toggles between different
#   versions of similar things, write a "group" target that forwards to the
#   right target (or no target) depending on the value of the build flag. This
#   group can be in the same BUILD.gn file as the build flag, and targets can
#   depend unconditionally on the group rather than duplicating flag checks
#   across many targets.
#
# - If a semi-random set of build files REALLY needs to know about a define and
#   the above pattern for isolating the build logic in a forwarding group
#   doesn't work, you can put the argument in a .gni file. This should be put
#   in the lowest level of the build that knows about this feature (which should
#   almost always be outside of the //build directory!).
#
# Other flag advice:
#
# - Use boolean values when possible. If you need a default value that expands
#   to some complex thing in the default case (like the location of the
#   compiler which would be computed by a script), use a default value of -1 or
#   the empty string. Outside of the declare_args block, conditionally expand
#   the default value as necessary.
#
# - Use a name like "use_foo" or "is_foo" (whatever is more appropriate for
#   your feature) rather than just "foo".
#
# - Write good comments directly above the declaration with no blank line.
#   These comments will appear as documentation in "gn args --list".
#
# - Don't call exec_script inside declare_args. This will execute the script
#   even if the value is overridden, which is wasteful. See first bullet.

declare_args() {
  # Set to enable the official build level of optimization. This has nothing
  # to do with branding, but enables an additional level of optimization above
  # release (!is_debug). This might be better expressed as a tri-state
  # (debug, release, official) but for historical reasons there are two
  # separate flags.
  is_official_build = false

  # Set to true when compiling with the Clang compiler.
  is_clang = false

  # Allows the path to a custom target toolchain to be injected as a single
  # argument, and set as the default toolchain.
  custom_toolchain = ""

  # This should not normally be set as a build argument.  It's here so that
  # every toolchain can pass through the "global" value via toolchain_args().
  host_toolchain = ""

  # Label of the external projects directory.
  # By convention, all 3rd-party projects should end up in this directory, so they
  # can depend on each other (e.g. $external/mysql_connector -> $external/zlib)
  external = "//external"

  # DON'T ADD MORE FLAGS HERE. Read the comment above.
}

declare_args() {
  # Debug build. Enabling official builds automatically sets is_debug to false.
  is_debug = !is_official_build
}

assert(!(is_debug && is_official_build), "Can't do official debug builds")

# ==============================================================================
# TOOLCHAIN SETUP
# ==============================================================================
#
# Here we set the default toolchain, as well as the variable host_toolchain
# which will identify the toolchain corresponding to the local system when
# doing cross-compiles. When not cross-compiling, this will be the same as the
# default toolchain.
#
# We do this before anything else to make sure we complain about any
# unsupported os/cpu combinations as early as possible.

if (host_toolchain == "") {
  # This should only happen in the top-level context.
  # In a specific toolchain context, the toolchain_args()
  # block should have propagated a value down.
  # TODO(dpranke): Add some sort of assert here that verifies that
  # no toolchain omitted host_toolchain from its toolchain_args().

  if (host_os == "mac") {
    host_toolchain = "//build/toolchain/mac:clang_$host_cpu"
  } else if (host_os == "win") {
    # On Windows always use the target CPU for host builds. On the
    # configurations we support this will always work and it saves build steps.
    if (is_clang) {
      host_toolchain = "//build/toolchain/win:clang_$target_cpu"
    } else {
      host_toolchain = "//build/toolchain/win:$target_cpu"
    }
  } else {
    if (target_os != host_os) {
      # TODO(dpranke) - is_clang normally applies only to the target
      # build, and there is no way to indicate that you want to override
      # it for both the target build *and* the host build. Do we need to
      # support this?
      host_toolchain = "//build/toolchain/posix:clang_$host_cpu"
    } else if (is_clang) {
      host_toolchain = "//build/toolchain/posix:clang_$host_cpu"
    } else {
      host_toolchain = "//build/toolchain/posix:$host_cpu"
    }
  }
}

_default_toolchain = ""

if (target_os == "android") {
  if (is_clang) {
    _default_toolchain = "//build/toolchain/android:android_clang_$target_cpu"
  } else {
    _default_toolchain = "//build/toolchain/android:android_$target_cpu"
  }
} else if (target_os == "ios") {
  _default_toolchain = "//build/toolchain/mac:ios_clang_$target_cpu"
} else if (target_os == "mac") {
  assert(host_os == "mac", "Mac cross-compiles are unsupported.")
  _default_toolchain = host_toolchain
} else if (target_os == "win") {
  # On Windows we use the same toolchain for host and target by default.
  assert(target_os == host_os, "Win cross-compiles only work on win hosts.")
  if (is_clang) {
    _default_toolchain = "//build/toolchain/win:clang_$target_cpu"
  } else {
    _default_toolchain = "//build/toolchain/win:$target_cpu"
  }
} else if (target_os == "winrt_81" || target_os == "winrt_81_phone" ||
           target_os == "winrt_10") {
  _default_toolchain = "//build/toolchain/win:winrt_$target_cpu"
} else {
  if (is_clang) {
    _default_toolchain = "//build/toolchain/posix:clang_$target_cpu"
  } else {
    _default_toolchain = "//build/toolchain/posix:$target_cpu"
  }
}

# If a custom toolchain has been set in the args, set it as default. Otherwise,
# set the default toolchain for the platform (if any).
if (custom_toolchain != "") {
  set_default_toolchain(custom_toolchain)
} else if (_default_toolchain != "") {
  set_default_toolchain(_default_toolchain)
}

# =============================================================================
# OS DEFINITIONS
# =============================================================================
#
# We set these various is_FOO booleans for convenience in writing OS-based
# conditions.
#
# - is_android, is_freebsd, is_ios, and is_win should be obvious.
# - is_mac is set only for desktop Mac. It is not set on iOS.
# - is_posix is true for mac and any Unix-like system (basically everything
#   except Windows).
# - is_linux is true for desktop Linux, but not Android (which is
#   generally too different despite being based on the Linux kernel).

if (current_os == "win" || current_os == "winrt_81" ||
    current_os == "winrt_81_phone" || current_os == "winrt_10") {
  is_android = false
  is_ios = false
  is_linux = false
  is_mac = false
  is_posix = false
  is_win = true
  is_freebsd = false
} else if (current_os == "mac") {
  is_android = false
  is_ios = false
  is_linux = false
  is_mac = true
  is_posix = true
  is_win = false
  is_freebsd = false
} else if (current_os == "android") {
  is_android = true
  is_ios = false
  is_linux = false
  is_mac = false
  is_nacl = false
  is_posix = true
  is_win = false
  is_freebsd = false
} else if (current_os == "ios") {
  is_android = false
  is_ios = true
  is_linux = false
  is_mac = false
  is_posix = true
  is_win = false
  is_freebsd = false
} else if (current_os == "linux") {
  is_android = false
  is_ios = false
  is_linux = true
  is_mac = false
  is_posix = true
  is_win = false
  is_freebsd = false
} else if (current_os == "freebsd") {
  is_android = false
  is_ios = false
  is_linux = false
  is_mac = false
  is_posix = true
  is_win = false
  is_freebsd = true
}

# =============================================================================
# TARGET DEFAULTS
# =============================================================================
#
# Set up the default configuration for every build target of the given type.
# The values configured here will be automatically set on the scope of the
# corresponding target. Target definitions can add or remove to the settings
# here as needed.

# Holds all configs used for running the compiler.
default_compiler_configs = [
  "//build/config:extra_flags",
  "//build/config:afdo",
  "//build/config:compiler",
  "//build/config:pthread",
  "//build/config:stackrealign",
  "//build/config:compiler_arm_fpu",
  "//build/config:compiler_arm_thumb",
  "//build/config:default_optimization",
  "//build/config:default_stack_frames",
  "//build/config:default_symbols",
  "//build/config:c++11",
  "//build/config:rtti",
  "//build/config:exceptions",
  "//build/config:runtime_library",
  "//build/config:symbol_visibility_hidden",
]
if (is_win) {
  default_compiler_configs += [
    "//build/config/win:default_crt",
    "//build/config/win:lean_and_mean",
    "//build/config/win:nominmax",
    "//build/config/win:winver",
    "//build/config/win:vs_code_analysis",
  ]
}
if (current_os == "winrt_81" || current_os == "winrt_81_phone" ||
    current_os == "winrt_10") {
  default_compiler_configs += [ "//build/config/win:target_winrt" ]
}

if (is_android) {
  default_compiler_configs +=
      [ "//build/config/android:default_cygprofile_instrumentation" ]
}

# Debug/release-related defines.
if (is_debug) {
  default_compiler_configs += [ "//build/config:debug" ]
} else {
  default_compiler_configs += [ "//build/config:release" ]
}

# Static libraries and source sets use only the compiler ones.
set_defaults("static_library") {
  configs = default_compiler_configs
}
set_defaults("source_set") {
  configs = default_compiler_configs
}

# Compute the set of configs common to all linked targets (shared libraries,
# loadable modules, executables) to avoid duplication below.
if (is_win) {
  # Windows linker setup for EXEs and DLLs.
  # Many targets remove these configs, so they are not contained within
  # //build/config:executable_config for easy removal.
  _linker_configs = [
    "//build/config/win:default_incremental_linking",

    # Default to console-mode apps. Most of our targets are tests and such
    # that shouldn't use the windows subsystem.
    "//build/config/win:console",
  ]
} else if (is_mac || is_ios) {
  _linker_configs = [ "//build/config/mac:strip_all" ]
} else {
  _linker_configs = []
}

# Executable defaults.
default_executable_configs = default_compiler_configs + [
                               "//build/config:default_libs",
                               "//build/config:executable_config",
                             ] + _linker_configs
set_defaults("executable") {
  configs = default_executable_configs
}

# Shared library and loadable module defaults (also for components in component
# mode).
default_shared_library_configs = default_compiler_configs + [
                                   "//build/config:default_libs",
                                   "//build/config:shared_library_config",
                                 ] + _linker_configs

set_defaults("shared_library") {
  configs = default_shared_library_configs
}

set_defaults("loadable_module") {
  configs = default_shared_library_configs
}