# Copyright 2016 The Fuchsia 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/dart/config.gni")

declare_args() {
  # Debug build.
  is_debug = true
}

if (target_os == "") {
  target_os = "fuchsia"
}
if (target_cpu == "") {
  target_cpu = host_cpu
}
if (current_cpu == "") {
  current_cpu = target_cpu
}
if (current_os == "") {
  current_os = target_os
}
host_platform = "${host_os}-${host_cpu}"

if (target_os == "fuchsia") {
  target_toolchain = "//build/toolchain/fuchsia:${target_cpu}"
} else {
  assert(false, "Target OS not supported")
}

if (host_os == "linux" || host_os == "mac") {
  host_toolchain = "//build/toolchain:host_${host_cpu}"
} else {
  assert(false, "Host OS not supported")
}

set_default_toolchain(target_toolchain)

# Some projects expect a default value for sources_assignment_filter.
sources_assignment_filter = []

declare_args() {
  # This should never be set as a build argument.  It exists only to be
  # set in toolchain_args when defining a toolchain.  These configs
  # will be appended to the default list common to all target types.
  toolchain_configs = []

  # This should never be set as a build argument.
  # It exists only to be set in toolchain_args.
  # See //build/toolchain/clang_toolchain.gni for details.
  is_pic_default = false

  # This should never be set as a build argument.
  # It exists only to be set in toolchain_args.
  # See //build/toolchain/clang_toolchain.gni for details.
  toolchain_variant = []

  # This should never be set as a build argument.
  # It exists only to be set in toolchain_args.
  # See //build/toolchain/clang_toolchain.gni for details.
  current_base_toolchain = target_toolchain

  # Zircon projects to target - must match the target architecture.
  zircon_projects = []

  # DEPRECATED: zircon build project
  # Use zircon_projects instead
  zircon_project = ""
}

if (zircon_project != "") {
  assert(zircon_projects == [], "Use zircon_projects instead of zircon_project")
  zircon_projects = [ zircon_project ]
} else if (zircon_projects == []) {
  if (current_cpu == "arm64") {
    zircon_projects = [ "zircon-qemu-arm64" ]
  } else if (current_cpu == "x64") {
    zircon_projects = [ "zircon-pc-x86-64" ]
  }
}
if (target_cpu == "x64") {
  zircon_sysroot =
      rebase_path("//out/build-zircon/build-zircon-pc-x86-64/sysroot")
} else {
  assert(target_cpu == "arm64", "Unsupported target architecture $target_cpu")
  zircon_sysroot =
      rebase_path("//out/build-zircon/build-zircon-qemu-arm64/sysroot")
}

is_android = false
is_fuchsia = false
is_fuchsia_host = false
is_ios = false
is_linux = false
is_mac = false
is_win = false
is_clang = true
is_component_build = false
is_official_build = false

if (current_os == "fuchsia") {
  is_fuchsia = true
} else if (current_os == "linux") {
  is_linux = true
  is_fuchsia_host = true
} else if (current_os == "mac") {
  is_mac = true
  is_fuchsia_host = true
}

# Each variant toolchain's name is formed by taking the base toolchain
# name and successively appending "-$name" for each config listed in
# the variant, where name is `get_label_name(config, "name")`.
# NOTE: This must match the method used in
# //build/toolchain/clang_toolchain.gni:clang_toolchain_suite
current_toolchain_variant = ""
foreach(subvariant, toolchain_variant) {
  current_toolchain_variant += "-" + get_label_info(subvariant, "name")
}

# When we are in a variant of host_toolchain, change the value of
# host_toolchain so that `if (current_toolchain == host_toolchain)`
# tests still match, since that is the conventional way to detect being
# in host context.  This means that any "...($host_toolchain)" label
# references from inside a variant of host_toolchain will refer to the
# variant (current_toolchain rather than host_toolchain).  To handle
# this, the executable() template below will define its target in other
# variant toolchains as a copy of the real executable.
if (is_fuchsia_host) {
  host_toolchain += current_toolchain_variant
}

# References should use "label($shlib_toolchain)" rather than
# "label(${target_toolchain}-shared)" or anything else.
shlib_toolchain = "${current_base_toolchain}${current_toolchain_variant}-shared"

# All binary targets will get this list of configs by default.
default_common_binary_configs = [
  "//build/config:compiler",
  "//build/config:relative_paths",
  "//build/config:default_include_dirs",
  "//build/config:default_warnings",
  "//build/config:no_exceptions",
  "//build/config:no_rtti",
  "//build/config:symbol_visibility_hidden",
]

if (is_debug) {
  default_common_binary_configs += [ "//build/config:debug" ]
} else {
  default_common_binary_configs += [ "//build/config:release" ]
}

if (is_fuchsia) {
  default_common_binary_configs += [
    "//build/config/fuchsia:icf",
    "//build/config/fuchsia:thread_safety_annotations",
    "//build/config/fuchsia:werror",

    # TODO(mcgrathr): Perhaps restrict this to only affected code.
    # For now, safest to do it everywhere.
    "//build/config/fuchsia:zircon_asserts",
  ]

  # Add safestack when not using a variant that's incompatible.
  # TODO(mcgrathr): When -fsanitize=safe-stack is the default in the
  # compiler, this will not be necessary: -fsanitize=address et al will
  # implicitly disable safestack.
  _safestack_compatible = true
  foreach(subvariant, toolchain_variant) {
    if (subvariant == "//build/config/sanitizers:asan" ||
        subvariant == "//build/config/sanitizers:asan_no_detect_leaks" ||
        subvariant == "//build/config/sanitizers:sancov") {
      _safestack_compatible = false
    }
  }
  if (_safestack_compatible) {
    default_common_binary_configs += [ "//build/config/fuchsia:safestack" ]
  }
}

default_common_binary_configs += [ "//build/config/lto:default" ]

# Add configs set by the toolchain definition.
default_common_binary_configs += toolchain_configs + toolchain_variant

default_shared_library_configs =
    default_common_binary_configs + [ "//build/config:shared_library_config" ]

# On most systems, the sanitizer runtimes are normally linked statically
# and so -shared links do not include them.  Using -shared --no-undefined
# with sanitized code will get undefined references for the sanitizer
# runtime calls generated by the compiler.  Assuming that variants are
# likely sanitizers prone to this issue, avoid that config for variants.
# It shouldn't do much harm, since the non-variant builds will catch the
# real undefined reference bugs.
if (toolchain_variant == []) {
  default_shared_library_configs += [ "//build/config:symbol_no_undefined" ]
}

default_executable_configs = default_common_binary_configs + [
                               "//build/config:executable_config",
                               "//build/config:default_libs",
                             ]

if (is_pic_default) {
  default_common_binary_configs += [ "//build/config:shared_library_config" ]
}

# Apply that default list to the binary target types.
set_defaults("source_set") {
  configs = default_common_binary_configs
}
set_defaults("static_library") {
  configs = default_common_binary_configs
}
set_defaults("shared_library") {
  configs = default_shared_library_configs
}
set_defaults("loadable_module") {
  configs = default_shared_library_configs
}
set_defaults("executable") {
  configs = default_executable_configs
}

if (is_fuchsia) {
  if (!is_pic_default) {
    # In the main toolchain, shared_library just redirects to the same
    # target in the -shared toolchain.
    template("shared_library") {
      group(target_name) {
        # Mark all variables as not needed to suppress errors for unused
        # variables.  The other variables normally passed to shared_library
        # are actually used by the shared_library instantiation in the
        # -shared toolchain, so any going truly unused will be caught there.
        not_needed(invoker, "*")
        forward_variables_from(invoker,
                               [
                                 "data_deps",
                                 "deps",
                                 "public_deps",
                                 "all_dependent_configs",
                                 "public_configs",
                                 "testonly",
                                 "visibility",
                               ])

        if (!defined(public_deps)) {
          public_deps = []
        }
        public_deps += [ ":$target_name(${current_toolchain}-shared)" ]
      }
    }
  } else {
    # In the -shared toolchain, shared_library is just its normal self,
    # but if the invoker constrained the visibility, we must make sure
    # the dependency from the main toolchain is still allowed.
    template("shared_library") {
      shared_library(target_name) {
        # Explicitly forward visibility, implicitly forward everything
        # else.  Forwarding "*" doesn't recurse into nested scopes (to
        # avoid copying all globals into each template invocation), so
        # won't pick up file-scoped variables.  Normally this isn't too
        # bad, but visibility is commonly defined at the file scope.
        # Explicitly forwarding visibility and then excluding it from the
        # "*" set works around this problem.  See http://crbug.com/594610
        # for rationale on why this GN behavior is not considered a bug.
        forward_variables_from(invoker, [ "visibility" ])
        forward_variables_from(invoker, "*", [ "visibility" ])
        if (defined(visibility)) {
          visibility += [ ":$target_name" ]
        }
      }
    }
  }
}

declare_args() {
  # List of "selectors" to request variant builds of certain targets.
  # Each selector specifies matching criteria and a chosen variant.
  # The first selector in the list to match a given target determines
  # which variant is used for that target.  Each selector is a scope,
  # defining some of these:
  #
  #   variant
  #     Required: The variant that applies if this selector matches.
  #     This can be false to choose no variant, or a string that names
  #     the variant.  Variant names are composed of the names of configs
  #     that make up the variant, separated by "-" if there is more than
  #     one config.  `known_variants + extra_variants` is the set of
  #     available variants; see those build arguments.
  #
  # The rest below are matching criteria.
  # The selector matches if and only if all of its criteria match.
  # If none of these is defined, then the selector always matches.
  # Each "Strings" criterion is a list of strings, and the criterion
  # is satisfied if any of the strings match against the candidate string.
  #
  #   host
  #     Boolean: If true, the selector matches in the host toolchain.
  #     If false, the selector matches in the target toolchain.
  #
  #   testonly
  #     Boolean: If true, the selector matches targets with testonly=true.
  #     If false, the selector matches in targets without testonly=true.
  #
  #   target_type
  #     Strings: Matches "executable", "loadable_module", or "driver_module"
  #
  #   output_name
  #     Strings: Matches the target's `output_name` (default: its target name).
  #
  #   label
  #     Strings: Matches the target's full label (without toolchain).
  #
  #   name
  #     Strings: Matches the target's simple name (label after last / or :).
  #
  #   dir
  #     Strings: Matches target's label directory.
  select_variant = []
}

template("variant_target") {
  target_type = target_name
  target_name = invoker.target_name
  target_invoker = {
    # Explicitly forward visibility, implicitly forward everything else.
    # See comment in template("shared_library") above for details.
    forward_variables_from(invoker, [ "visibility" ])
    forward_variables_from(invoker,
                           "*",
                           [
                             "_target_type",
                             "target_name",
                             "visibility",
                           ])

    if (!defined(output_name)) {
      output_name = target_name
    }
  }

  # target_type is the real GN target type that builds the thing.
  # selector_target_type is the name matched against target_type selectors.
  if (defined(invoker._target_type)) {
    selector_target_type = invoker._target_type
  } else {
    selector_target_type = target_type
  }

  target_label = get_label_info(":$target_name", "label_no_toolchain")

  # These are not actually used in all possible if branches below,
  # so defang GN's extremely sensitive "unused variable" errors.
  not_needed([
               "selector_target_type",
               "target_invoker",
               "target_label",
               "target_type",
             ])

  target_variant = false
  if (select_variant != []) {
    # See if there is a selector that matches this target.
    selected = false
    foreach(selector, select_variant) {
      # The first match wins.
      # GN's loops don't have "break", so do nothing on later iterations.
      if (!selected) {
        # Expand the selector so we don't have to do a lot of defined(...)
        # tests below.
        select = {
        }
        select = {
          target_type = []
          output_name = []
          label = []
          name = []
          dir = []
          forward_variables_from(selector, "*")
        }

        selected = true
        if (selected && defined(selector.host)) {
          selected = is_fuchsia_host == selector.host
        }

        if (selected && defined(selector.testonly)) {
          selected = (defined(target_invoker.testonly) &&
                      target_invoker.testonly) == selector.testonly
        }

        if (selected && select.target_type != []) {
          selected = false
          candidate = selector_target_type
          foreach(try, select.target_type) {
            if (try == candidate) {
              selected = true
            }
          }
        }

        if (selected && select.output_name != []) {
          selected = false
          candidate = target_invoker.output_name
          foreach(try, select.output_name) {
            if (try == candidate) {
              selected = true
            }
          }
        }

        if (selected && select.label != []) {
          selected = false
          candidate = target_label
          foreach(try, select.label) {
            if (try == candidate) {
              selected = true
            }
          }
        }

        if (selected && select.name != []) {
          selected = false
          candidate = get_label_info(target_label, "name")
          foreach(try, select.name) {
            if (try == candidate) {
              selected = true
            }
          }
        }

        if (selected && select.dir != []) {
          selected = false
          candidate = get_label_info(target_label, "dir")
          foreach(try, select.dir) {
            if (try == candidate) {
              selected = true
            }
          }
        }

        if (selected && selector.variant != false) {
          target_variant = "-${selector.variant}"
        }
      }
    }
  }
  if (target_variant == false) {
    target_variant = ""
  }

  builder_toolchain = current_base_toolchain + target_variant
  if (invoker._variant_shared) {
    builder_toolchain += "-shared"
  }

  if (current_toolchain == builder_toolchain) {
    # This is the toolchain selected to actually build this target.
    target(target_type, target_name) {
      deps = []
      forward_variables_from(target_invoker, "*")
      foreach(variant, toolchain_variant) {
        # Expand the label so it always has a :name part.
        variant = get_label_info(variant, "label_no_toolchain")
        deps += [ "${variant}_deps" ]
      }
      if (defined(visibility)) {
        # Other toolchains will define this target as a group or copy
        # rule that depends on this toolchain's definition.  If the
        # invoker constrained the visibility, make sure those
        # dependencies from other toolchains are still allowed.
        visibility += [ ":${target_name}" ]
      }
    }
  } else if (current_toolchain == shlib_toolchain) {
    # Don't copy from a variant into a -shared toolchain, because nobody
    # looks for an executable or loadable_module there.  Instead, just
    # forward any deps to the real target.
    group(target_name) {
      forward_variables_from(target_invoker,
                             [
                               "testonly",
                               "visibility",
                             ])
      if (defined(visibility)) {
        visibility += [ ":${target_name}" ]
      }
      deps = [
        ":${target_name}(${builder_toolchain})",
      ]
    }
  } else {
    # When some variant was selected, then this target in all other
    # toolchains is actually just this copy rule.  The target is built in
    # the selected variant toolchain, but then copied to its usual name in
    # $root_out_dir so that things can find it there.
    copy_vars = {
      forward_variables_from(target_invoker,
                             [
                               "testonly",
                               "visibility",
                             ])
      if (defined(visibility)) {
        visibility += [ ":${target_name}" ]
      }

      deps = [
        ":${target_name}(${builder_toolchain})",
      ]
      variant_out_dir = get_label_info(deps[0], "root_out_dir")

      full_output_name = target_invoker.output_name
      if (defined(target_invoker.output_extension) &&
          target_invoker.output_extension != "") {
        full_output_name += ".${target_invoker.output_extension}"
      }

      sources = [
        "$variant_out_dir/$full_output_name",
      ]
      outputs = [
        "$root_out_dir/$full_output_name",
      ]
    }

    # In the host toolchain, make a symlink rather than a hard link
    # (which is what "copy" rules really do).  Host tools are built with
    # an embedded shared library lookup path based on $ORIGIN on Linux
    # (//build/config/linux:compiler) and the equivalent @loader_path on
    # macOS (//build/config/mac:mac_dynamic_flags).  The dynamic linker
    # translates this to "the directory containing the executable".
    # With hard links, this gets the directory used to invoke the
    # executable, which is host_toolchain's $root_out_dir.  With
    # symlinks, it instead gets the directory containing the actual
    # executable file, which is builder_toolchain's $root_out_dir.
    # Hence the program uses the variant builds of shared libraries that
    # go with the variant build of the executable, rather using than the
    # vanilla host_toolchain builds with the variant executable.
    if (current_toolchain == host_toolchain) {
      action(target_name) {
        forward_variables_from(copy_vars, "*")
        script = "/bin/ln"
        args = [
          "-snf",
          rebase_path(sources[0], root_out_dir),
          rebase_path(outputs[0]),
        ]
      }
    } else {
      # For Fuchsia, //packages/gn/variant.py depends on hard links to
      # identify the variants.
      copy(target_name) {
        forward_variables_from(copy_vars, "*")
      }
    }
  }
}

template("executable") {
  _executable_name = target_name
  _variant_shared = false
  variant_target("executable") {
    target_name = _executable_name

    # Explicitly forward visibility, implicitly forward everything else.
    # See comment in template("shared_library") above for details.
    forward_variables_from(invoker, [ "visibility" ])
    forward_variables_from(invoker, "*", [ "visibility" ])
  }
}

template("loadable_module") {
  _module_name = target_name
  _variant_shared = true
  variant_target("loadable_module") {
    target_name = _module_name
    if (defined(invoker._target_type)) {
      _target_type = invoker._target_type
    }

    # Explicitly forward visibility, implicitly forward everything else.
    # See comment in template("shared_library") above for details.
    forward_variables_from(invoker, [ "visibility" ])
    forward_variables_from(invoker, "*", [ "visibility" ])
    if (!defined(output_extension)) {
      output_extension = "so"
    }
  }
}

# Some targets we share with Chromium declare themselves to be components,
# which means they can build either as shared libraries or as static libraries.
# We build them as static libraries.
template("component") {
  if (!defined(invoker.sources)) {
    # When there are no sources defined, use a source set to avoid creating
    # an empty static library (which generally don't work).
    _component_mode = "source_set"
  } else {
    _component_mode = "static_library"
  }

  target(_component_mode, target_name) {
    # Explicitly forward visibility, implicitly forward everything else.
    # See comment in template("shared_library") above for details.
    forward_variables_from(invoker, [ "visibility" ])
    forward_variables_from(invoker, "*", [ "visibility" ])
  }
}

set_defaults("component") {
  configs = default_common_binary_configs
}