# Copyright 2017 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/config/clang/clang.gni")
import("//build/config/sysroot.gni")
import("//build/host.gni")
import("//build/sdk/sdk_host_tool.gni")
import("//build/toolchain/breakpad.gni")
import("//build/toolchain/concurrent_jobs.gni")
import("//zircon/public/sysroot/go.gni")

declare_args() {
  #   gocache_dir
  #     Directory GOCACHE environment variable will be set to. This directory
  #     will have build and test results cached, and is safe to be written to
  #     concurrently. If overridden, this directory must be a full path.
  gocache_dir = rebase_path("$root_out_dir/.gocache")

  #   go_vet_enabled
  #     [bool] if false, go vet invocations are disabled for all builds.
  go_vet_enabled = false
}

# A template for an action that builds a Go binary. Users should instead use the
# go_binary or go_test rules.
#
# Parameters
#
#   gopackages (required)
#     List of packages to build.
#
#   use_prebuilt_go (optional)
#     If true, use a prebuilt go toolchain, rather than building the toolchain.
#     If not set, defaults to false when targeting Fuchsia and true otherwise.
#
#   sdk_category (optional)
#     Publication level of the library in SDKs.
#     See //build/sdk/sdk_atom.gni.
#
#   sdk_name (optional)
#     Name of the library in the SDK.
#
#   deps (optional)
#     List of labels representing go_library targets this target depends on.
#
#   non_go_deps (optional)
#     List of labels this target depends on that are not Go libraries.
#
#   include_dirs (optional)
#     List of directories this target depends on being in the C compiler include path.
#
#   lib_dirs (optional)
#     List of directories this target depends on being in the C compiler library path.
#
#   skip_vet (optional)
#     Whether to skip running go vet for this target. This flag should _only_
#     be used for packages in the Go source tree itself that otherwise match
#     whitelist entries in go vet all. Go vet is only run if go_vet_enabled is
#     true.
#
#   test (optional, default: false)
#     Whether this target defines a test.
#
#   carchive (optional, default: false)
#     Whether to build this target as a C archive.
#
#   gcflags (optional)
#     List of go compiler flags to pass.
#
#   ldflags (optional)
#     List of go linker flags to pass.
#
#   tags (optional)
#     List of go build tags to include in the build.
#
#   cgo (optional, default: true)
#     If true, will support linking against C code. Set to false for
#     pure Go code to support cross-compilation.
#
#   output_name (optional)
#     The name of the binary that that will be generated.
#     It defaults to the target name.
#
#   output_dir (optional)
#     Directory that the resulting binary should be placed in.
#     See: `gn help output_dir`
#
template("go_build") {
  assert(defined(invoker.gopackages),
         "gopackages must be defined for $target_name")
  gopackages = invoker.gopackages
  assert(
      gopackages == [ gopackages[0] ],
      "gopackages currently only supports one package because of http://crbug.com/fuchsia/8088")

  main_target_name = target_name
  is_test = defined(invoker.test) && invoker.test
  carchive = defined(invoker.carchive) && invoker.carchive
  assert(!(is_test && carchive),
         "cannot specify both test=true and carchive=true")

  output_name = target_name
  if (defined(invoker.output_name)) {
    output_name = invoker.output_name
  }
  if (carchive) {
    output_name = "${output_name}.a"
  }

  if (defined(invoker.output_dir)) {
    output_dir = invoker.output_dir
  } else {
    output_dir = root_out_dir
  }

  define_sdk_target = defined(invoker.sdk_category) &&
                      invoker.sdk_category != "excluded" && !is_test

  # Strip target binaries and binaries that are included in the SDK.
  use_strip = (is_fuchsia || define_sdk_target) && !carchive

  output_path = "${output_dir}/${output_name}"
  if (use_strip) {
    output_path = "${output_dir}/exe.unstripped/${output_name}"
    stripped_output_path = "${output_dir}/${output_name}"
  }

  use_prebuilt_go = !is_fuchsia
  if (defined(invoker.use_prebuilt_go)) {
    use_prebuilt_go = invoker.use_prebuilt_go
  }
  goroot_deps = []
  if (use_prebuilt_go) {
    goroot = rebase_path("//prebuilt/third_party/go/${host_platform}",
                         root_build_dir)
  } else {
    goroot = rebase_path("$host_tools_dir/goroot", root_build_dir)
    goroot_deps = [ "//third_party/go:go_runtime" ]
  }

  if (defined(invoker.deps)) {
    go_deps_paths = []
    go_deps_inputs = []
    foreach(dep, invoker.deps) {
      gen_dir = get_label_info(dep, "target_gen_dir")
      name = get_label_info(dep, "name")
      path = "${gen_dir}/${name}.go_deps"
      go_deps_paths += [ rebase_path(path, root_build_dir) ]
      go_deps_inputs += [ path ]
    }
  }

  hermetic_inputs_target_name = "${main_target_name}_hermetic_inputs"
  hermetic_inputs_target_output =
      "${target_gen_dir}/${output_name}.hermetic_inputs"
  hermetic_inputs_action(hermetic_inputs_target_name) {
    visibility = [ ":${main_target_name}" ]
    forward_variables_from(invoker, [ "testonly" ])

    script = "//build/go/gen_hermetic_inputs.py"
    sources = [ "//build/go/gen_library_metadata.py" ]
    outputs = [ hermetic_inputs_target_output ]
    args = [
      "--output",
      rebase_path(hermetic_inputs_target_output, root_build_dir),
      "--go-root",
      goroot,
    ]

    deps = goroot_deps
    if (defined(invoker.deps)) {
      deps += invoker.deps
      args += [ "--go-dep-files" ]
      args += go_deps_paths
      inputs = go_deps_inputs
    }

    if (is_test) {
      testonly = true
      args += [ "--is-test=true" ]
    }
  }

  variant_target("action") {
    target_name = main_target_name
    _variant_shared = false

    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])
    forward_variables_from(concurrent_jobs.local, "*")

    deps = goroot_deps
    if (defined(invoker.non_go_deps)) {
      deps += invoker.non_go_deps
    }

    if (use_strip) {
      # Ensure that the 'canonical' output path of $root_out_dir/$output_name
      # always first among outputs, as this path has to be reconstructed within
      # go_test.gni and it can canonically compare that with outputs[0].
      outputs = [
        stripped_output_path,
        output_path,
      ]
    } else {
      outputs = [ output_path ]
    }

    output_name = output_name

    # NOTE: output_dir is needed for variant_target(), but not for this action().
    output_dir = output_dir
    not_needed([ "output_dir" ])

    script = "//build/go/build.py"
    sources = [ "//build/go/gen_library_metadata.py" ]

    hermetic_inputs_target = ":${hermetic_inputs_target_name}"
    hermetic_inputs_file = hermetic_inputs_target_output

    if (is_fuchsia) {
      # For Fuchsia binaries, use a Go-specific sysroot instead of the
      # standard one which only contains empty linker stubs (see
      # comments in //zircon/public/sysroot/BUILD.gn for details).
      sysroot = go_sysroot_dir
    }

    args = [
      "--root-out-dir",
      rebase_path(root_out_dir, root_build_dir),
      "--current-cpu",
      current_cpu,
      "--current-os",
      current_os,
      "--binname",
      output_name,
      "--output-path",
      rebase_path(output_path, root_build_dir),
      "--go-cache",
      rebase_path(gocache_dir, root_build_dir),
      "--go-root",
      goroot,
      "--cc",
      "$rebased_clang_prefix/clang",
      "--cxx",
      "$rebased_clang_prefix/clang++",
      "--objcopy",
      "$rebased_clang_prefix/llvm-objcopy",
      "--ar",
      "$rebased_clang_prefix/llvm-ar",
      "--sysroot",
      rebase_path(sysroot, root_build_dir),
      "--target",
      current_target_tuple,
      "--golibs-dir",
      rebase_path("//third_party/golibs", root_build_dir),
    ]

    include_dirs = []
    if (defined(invoker.include_dirs)) {
      include_dirs = rebase_path(invoker.include_dirs, root_build_dir)
    }
    lib_dirs = []
    if (defined(invoker.lib_dirs)) {
      lib_dirs = rebase_path(invoker.lib_dirs, root_build_dir)
    }
    lib_dirs +=
        [ rebase_path(get_label_info(":any($shlib_toolchain)", "root_out_dir"),
                      root_build_dir) ]

    if (!(defined(invoker.cgo) && !invoker.cgo)) {
      args += [ "--cgo" ]

      if (is_fuchsia) {
        # Inject a dependency to libfdio.so. Note that as a special case,
        # when building fuzzing binaries, this library should be built in
        # a non-fuzzing variant (because the fuzzing runtime depends on it).
        # So compute the correct toolchain for it directly here.
        _fdio_toolchain =
            string_replace(current_toolchain, "-fuzzer", "") + "-shared"
        _fdio_label_with_toolchain = "//sdk/lib/fdio($_fdio_toolchain)"

        deps += [
          "//zircon/public/sysroot:go_binary_deps",
          _fdio_label_with_toolchain,
        ]

        if (_fdio_toolchain != current_toolchain + "-shared") {
          lib_dirs += [ rebase_path(
                  get_label_info(_fdio_label_with_toolchain, "root_out_dir"),
                  root_build_dir) ]
        }

        include_dirs +=
            [ rebase_path("//sdk/lib/fdio/include", root_build_dir) ]

        # See //build/config/fuchsia:fdio_config.
        lib_dirs +=
            [ rebase_path(get_label_info("//build/config/fuchsia:fdio_config",
                                         "target_gen_dir"),
                          root_build_dir) ]
      }
    }

    foreach(include_dir, include_dirs) {
      args += [
        "--include-dir",
        include_dir,
      ]
    }
    foreach(lib_dir, lib_dirs) {
      args += [
        "--lib-dir",
        lib_dir,
      ]
    }

    if (use_strip) {
      args += [
        "--stripped-output-path",
        rebase_path(stripped_output_path, root_build_dir),
      ]
    }

    if (defined(invoker.skip_vet) && !invoker.skip_vet && go_vet_enabled) {
      args += [ "--vet" ]
    }

    # Go build tags
    if (defined(invoker.tags)) {
      foreach(tag, invoker.tags) {
        args += [
          "--tag",
          tag,
        ]
      }
    }

    # Go compiler flags
    if (defined(invoker.gcflags)) {
      foreach(gcflag, invoker.gcflags) {
        args += [ "--gcflag=${gcflag}" ]
      }
    }

    if (is_fuchsia) {
      # TODO(phosek): drop -Wl,--pack-dyn-relocs=relr once it's the default in Clang.
      extldflags = "-Wl,--pack-dyn-relocs=relr"

      # TODO(fxbug.dev/53078): Eventually the default in the compler driver.
      extldflags += ",-zrel"

      # When building with an instrumented variant, ensure the binary embeds a reference
      # to the right dynamic linker path.
      if (toolchain_variant.libprefix != "") {
        extldflags += ",--dynamic-linker=${toolchain_variant.libprefix}ld.so.1"
      }
      args += [ "--ldflag=-linkmode=external \"-extldflags=$extldflags\"" ]
    }

    if (defined(invoker.ldflags)) {
      foreach(ldflag, invoker.ldflags) {
        args += [ "--ldflag=${ldflag}" ]
      }
    }

    if (carchive) {
      args += [ "--buildmode=c-archive" ]

      # carchive is only set when building go fuzzers as static libraries,
      # that is then linked into a fuzzer executables. Make sure that it
      # is built in the same build variant as the one used for these, to
      # ensure they grab the right dependencies.
      variant_selector_target_type = "fuzzed_executable"
    }

    inputs = []
    if (is_fuchsia) {
      if (!carchive && output_breakpad_syms && host_os != "mac") {
        args += [
          "--dump-syms",
          breakpad_dump_syms,
        ]
        inputs += [ breakpad_dump_syms_prebuilt ]
      }
    }

    if (!carchive) {
      # Add needed arguments for the buildidtool. We should add the stamp file
      # output by buildidtool to the list of outputs for this action but because
      # Ninja (and by consequence GN) limits us to one depfile where that depfile
      # has only one output and we need the depfile for other things we don't
      # list it as an output.
      args += [
        "--buildidtool",
        rebase_path("//prebuilt/tools/buildidtool/${host_platform}/buildidtool",
                    root_build_dir),
        "--build-id-dir",
        ".build-id",
      ]
    }

    if (is_test) {
      testonly = true
      args += [ "--is-test=true" ]
    }

    if (defined(invoker.deps)) {
      deps += invoker.deps
      args += [ "--go-dep-files" ]
      args += go_deps_paths
      inputs += go_deps_inputs
    }

    foreach(gopackage, invoker.gopackages) {
      args += [
        "--package",
        gopackage,
      ]
    }

    metadata = {
      tool_paths = []

      # Record metadata for the //:tool_paths build API for all non-tests.
      if (!is_test) {
        tool_paths = [
          {
            cpu = current_cpu
            label = get_label_info(":$main_target_name", "label_with_toolchain")
            name = output_name
            os = current_os
            path = rebase_path(output_path, root_build_dir)
          },
        ]
      }

      binaries = [
        {
          type = "executable"
          label = get_label_info(":$target_name", "label_with_toolchain")
          cpu = current_cpu
          os = current_os
          debug = rebase_path(output_path, root_build_dir)
          if (use_strip) {
            dist = rebase_path(stripped_output_path, root_build_dir)
          } else {
            dist = debug
          }

          # TODO(fxbug.dev/27215): Update when we add linux go binaries
          # to .build-id.
          if (is_fuchsia) {
            elf_build_id = "$dist.build-id.stamp"
          }
          if (output_breakpad_syms && is_fuchsia) {
            breakpad = "$dist.sym"
          }
        },
      ]

      # Used by the distribution_manifest template.
      if (is_fuchsia) {
        distribution_entries = [
          {
            source = rebase_path(output_path, root_build_dir)
            if (use_strip) {
              source = rebase_path(stripped_output_path, root_build_dir)
            }
            destination = "bin/$output_name"
            if (is_test) {
              destination = "test/$output_name"
            }
            label = get_label_info(":$target_name", "label_with_toolchain")
            elf_runtime_dir = "lib/${toolchain_variant.libprefix}"
          },
        ]

        # Used by the fuchsia_test_component_manifest() template.
        test_component_manifest_program = [
          {
            program = {
              binary = "bin/$output_name"
              if (is_test) {
                binary = "test/$output_name"
              }
            }
          },
        ]
        test_component_manifest_program_barrier = []

        if (is_test) {
          # Used by the fuchsia_test_component_manifest() template.
          test_component_manifest_cml = [
            {
              include = [ "//src/sys/test_runners/gotests/default.shard.cml" ]
            },
          ]
        }
      }
    }
    if (output_breakpad_syms && is_fuchsia) {
      metadata_binaries = metadata.binaries
      b = metadata_binaries[0]
      outputs += [ root_out_dir + "/" + b.breakpad ]
    }

    # The binaries embed absolute paths to the source file,
    # which is copied into a subdir of root_build_dir.
    no_output_dir_leaks = false
  }

  if (define_sdk_target) {
    sdk_host_tool("${target_name}_sdk") {
      forward_variables_from(invoker, "*", [ "deps" ])
      category = invoker.sdk_category
      deps = [ ":$target_name" ]
    }
  }
}