# Copyright 2019 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("//zircon/public/gn/prebuilt.gni")
import("breakpad.gni")
import("ccache.gni")
import("clang.gni")
import("gcc.gni")
import("goma.gni")
import("gsym.gni")
import("toolchain.gni")

declare_args() {
  # Directory to populate with `xx/yyy` and `xx/yyy.debug` links to ELF
  # files.  For every ELF binary built, with build ID `xxyyy` (lowercase
  # hexadecimal of any length), `xx/yyy` is a hard link to the stripped
  # file and `xx/yyy.debug` is a hard link to the unstripped file.
  # Symbolization tools and debuggers find symbolic information this way.
  build_id_dir = "$root_build_dir/.build-id"
}

_buildidtool =
    rebase_path("$prebuilt_dir/tools/buildidtool/$host_platform/buildidtool",
                root_build_dir)
_id_dir = rebase_path(build_id_dir, root_build_dir)

# Define a toolchain for compiling C/C++ code.
#
# This is mostly a subroutine of environment() and not really used separately.
#
# Parameters
#
#   cpu, os
#     Required: $current_cpu and $current_os values for the toolchain.
#     Type: string
#
#   gcc
#     Optional: If true, this toolchain uses GCC rather than Clang.
#     Type: bool
#     Default: false
#
#   host
#     Optional: If true, this is doing "host" compiles.  This only matters
#     if $os == $host_os and $cpu == $host_cpu, i.e. native compilation for
#     the build host.  In that case, when using GCC, this says to use plain
#     "gcc" et al rather than "<triple>-gcc" et al.
#     Type: bool
#     Default: false
#
#   strip
#     Optional: If not false, linked binaries will be stripped.
#     If this is a string rather than true, it's a switch to the `objcopy`
#     tool, e.g. "--strip-sections".
#     Type: bool or string
#     Default: false
#
#   tool_dir, tool_prefix
#     Optional: If one of these is provided, then both must be provided.
#     $tool_dir is the directory where compiler tools are found, or "" if they
#     are found by searching `PATH`.  $tool_prefix is the prefix prepended to
#     each tool's name.  If $gcc is true, then $tool_dir defaults to "" if
#     $host is true and $gcc_tool_dir otherwise.  If $gcc is true and $host is
#     not true or $cpu != $host_cpu or $os != $host_os, then $tool_prefix
#     defaults to the "<tuple>-" prefix appropriate for $cpu and $os;
#     otherwise it defaults to "".
#     Type: string
#
#   shlib
#     Optional: If true, the toolchain will support the "solink" and
#     "solink_module" (for shared_library() and loadable_module() targets,
#     respectively).
#     Type: bool
#     Default: false
#
#   use_goma
#     Optional: If defined, overrides the $use_goma build argument.
#     If true, compilation commands are prefixed with "$goma_dir/gomacc".
#     Type: bool
#     Default: $use_goma
#
#   use_ccache
#     Optional: If defined, overrides the $use_ccache build argument.
#     If true, compilation commands are prefixed with "ccache".
#     Type: bool
#     Default: $use_ccache
#
#   toolchain_vars
#     Optional: Additional keys/values to export in the $toolchain scope.
#     The $toolchain global variable is a scope that provides various fields
#     describing how things are done in this toolchain.  Several standard
#     fields are set automatically.  This can supply others.
#     Type: scope
#     Default: {}
#
#   deps, toolchain_args
#     Optional: See toolchain().
#
template("c_toolchain") {
  # Translate GN cpu/os to GNU config tuple.
  if (invoker.cpu == "arm64") {
    tc_cpu = "aarch64"
  } else if (invoker.cpu == "x64") {
    tc_cpu = "x86_64"
  } else {
    tc_cpu = invoker.cpu
  }
  tc_target = "${tc_cpu}-"
  if (invoker.os == "mac") {
    tc_target += "apple-darwin"
  } else if (invoker.os == "win") {
    tc_target += "windows-msvc"
  } else if (invoker.os == "linux") {
    tc_target += "linux-gnu"
  } else {
    tc_target += invoker.os
  }

  # Cached and distributed wrappers just go on the front of compiler commands.
  compiler_prefix = ""
  if (defined(invoker.use_goma)) {
    use_goma = invoker.use_goma
  }
  if (use_goma) {
    goma_dir = rebase_path(goma_dir)
    compiler_prefix = "$goma_dir/gomacc "
  } else {
    if (defined(invoker.use_ccache)) {
      use_ccache = invoker.use_ccache
    }
    if (use_ccache) {
      compiler_prefix = "ccache "
    }
  }

  use_gcc = defined(invoker.gcc) && invoker.gcc
  use_strip = defined(invoker.strip) && invoker.strip != false

  # These are used in some, but not all, of the if branches below.
  if (clang_tool_dir == "") {
    clangxx_exec_inputs = []
    clangxx_exec_command = "clang++"
  } else {
    clangxx_exec_inputs = [ "${clang_tool_dir}/clang++" ]
    clangxx_exec_command = rebase_path(clangxx_exec_inputs[0], root_build_dir)
  }
  clangxx_args = [
    clangxx_exec_command,
    "--target=$tc_target",

    # This affects the multilib selection so that we get the right
    # libc++.a binary.  It's not really proper that we have to encode here
    # the multilib-affecting switches we presume all configs actually will
    # use in the toolchain being defined.  But since everything in this
    # codebase (certainly everything we support being compiled by GCC) is
    # definitely compiled with -fno-exceptions, we can live with it.  An
    # alternative would be to add the lib_dirs in a config() instead and
    # then somehow tie it to exceptions vs no-exceptions configs, but we
    # have no present need for any such complexity.
    "-fno-exceptions",
  ]
  not_needed([ "clangxx_args" ])

  # If either $tool_dir or $tool_prefix is supplied then both must be supplied.
  if (defined(invoker.tool_dir) || defined(invoker.tool_prefix)) {
    tc = {
      tool_dir = invoker.tool_dir
      tool_prefix = invoker.tool_prefix
    }
  } else if (use_gcc) {
    if (defined(invoker.host) && invoker.host) {
      tc = {
        tool_dir = ""
        if (invoker.cpu == host_cpu && invoker.os == host_os) {
          tool_prefix = ""
        } else {
          tool_prefix = "${tc_target}-"
        }
      }
    } else {
      tc = {
        tool_dir = gcc_tool_dir
        tool_prefix = "${tc_cpu}-elf-"
        version_string = gcc_version_string
        include_dirs = [ rebase_path(
                exec_script(
                    "/usr/bin/env",
                    clangxx_args + [ "-print-file-name=include/c++/v1" ],
                    "trim string",
                    clangxx_exec_inputs),
                "",
                root_build_dir) ]
        lib_dirs = [ rebase_path(
                get_path_info(
                    exec_script("/usr/bin/env",
                                clangxx_args + [ "-print-file-name=libc++.a" ],
                                "trim string",
                                clangxx_exec_inputs),
                    "dir"),
                "",
                root_build_dir) ]
      }
    }
  } else {
    tc = {
      tool_dir = clang_tool_dir
      tool_prefix = "llvm-"
      version_string = clang_version_string

      # TODO(fxbug.dev/27328): The MSVC target in the clang driver never uses the
      # -stdlib=libc++ switch or the toolchain's own libc++ include path.
      if (invoker.os == "win") {
        include_dirs = [ rebase_path(
                exec_script(
                    "/usr/bin/env",
                    clangxx_args + [ "-print-file-name=include/c++/v1" ],
                    "trim string",
                    clangxx_exec_inputs),
                "",
                root_build_dir) ]
      }
    }
  }

  if (defined(invoker.host)) {
    not_needed(invoker, [ "host" ])
  }

  if (use_gcc) {
    tc.cc = "${tc.tool_prefix}gcc"
    tc.cxx = "${tc.tool_prefix}g++"
  } else {
    tc.cc = "clang"
    tc.cxx = "clang++"
  }

  if (tc.tool_dir == "") {
    dir_prefix = ""
    if (use_goma) {
      # GOMA requires an absolute path to the compiler.
      compiler_prefix = ""
    }
  } else {
    dir_prefix = rebase_path(tc.tool_dir, root_build_dir) + "/"
  }

  cc = "$dir_prefix${tc.cc}"
  cxx = "$dir_prefix${tc.cxx}"
  ld = cxx
  ar = "$dir_prefix${tc.tool_prefix}ar"

  # All other OS possibilities are ELF and so might have ELF build IDs.
  is_elf = invoker.os != "mac" && invoker.os != "win"

  # buildidtool only supports ELF build IDs.
  use_buildidtool = is_elf

  # The prebuilt dump_syms tool is the one that only supports ELF.
  # Breakpad has dump_syms tools for Mach-O (macOS) and PE-COFF
  # (Windows/EFI) too, but the PE-COFF tool only runs on Windows.  The
  # Mach-O tool can be cross compiled, though we can't cross compile to
  # macOS anyway.  But we also don't have a prebuilt of the macOS
  # self-targetting Breakpad dump_syms tool on hand.
  use_breakpad = output_breakpad_syms && is_elf && use_buildidtool
  if (use_breakpad) {
    dump_syms = rebase_path(breakpad_dump_syms, root_build_dir)
    foreach(arg, breakpad_args) {
      dump_syms += " \"$arg\""
    }
    if (invoker.os == "fuchsia") {
      foreach(arg, breakpad_fuchsia_args) {
        dump_syms += " \"$arg\""
      }
    } else {
      # Use what's probably installation name, not the ".debug" name.
      dump_syms += " -n \"{{target_output_name}}{{output_extension}}\""
    }
  }

  # TODO(fxbug.dev/58294): enable for other targets and binary formats.
  use_gsym = output_gsym && is_elf && invoker.os == "fuchsia"
  if (use_gsym) {
    gsymutil = rebase_path("$clang_tool_dir/llvm-gsymutil", root_build_dir)
  }

  _compile_common = {
    outputs =
        [ "{{source_out_dir}}/{{target_output_name}}.{{source_file_part}}.o" ]
    depfile = "{{output}}.d"
    depsformat = "gcc"
    switches = "-MD -MF $depfile -o {{output}} {{defines}} {{include_dirs}}"
  }

  _link_common = {
    lib_switch = "-l"
    lib_dir_switch = "-L"
    default_output_dir = "{{target_out_dir}}"
    outfile_base = "{{output_dir}}/{{target_output_name}}"
    outfile = "$outfile_base{{output_extension}}"
    runtime_outputs = [ outfile ]
    outputs = runtime_outputs

    if (use_strip) {
      # This doesn't use ${outfile_base} so that it's consistent that
      # toolchain.link_output_suffix is appended whether "" or ".debug",
      # rather than replacing output_extension, which requires more logic.
      unstripped_outfile = "${outfile}.debug"
      outputs += [ unstripped_outfile ]
      strip_command = " && "
      if (invoker.strip == true) {
        if (invoker.os == "mac") {
          # Only the host native tool works on macOS.
          strip_tool = "strip"
        } else {
          strip_tool = "$dir_prefix${tc.tool_prefix}strip"
        }
        strip_command += "$strip_tool -o \"$outfile\" \"$unstripped_outfile\""
      } else {
        strip_command +=
            "$dir_prefix${tc.tool_prefix}objcopy ${invoker.strip}" +
            " \"$unstripped_outfile\" \"$outfile\""
      }
    } else {
      unstripped_outfile = outfile
      strip_command = ""
    }

    rspfile = "${outfile_base}.rsp"
    switches = "-o $unstripped_outfile {{ldflags}}"
    if (invoker.os == "mac") {
      rspfile_content = "{{inputs_newline}}"
      link_inputs = "-Wl,-filelist,$rspfile {{libs}} {{solibs}}"
    } else {
      rspfile_content = "{{inputs}}"
      link_inputs = "'@$rspfile'"
      if (invoker.os == "win") {
        link_inputs += " {{libs}} {{solibs}}"
      } else {
        link_inputs = "-Wl,--start-group " + link_inputs +
                      " {{libs}} -Wl,--end-group {{solibs}}"
        depfile = "$outfile.d"
        depsformat = "gcc"
        switches += " -Wl,--dependency-file=$depfile"
        mapfile = "${outfile_base}.map"
        outputs += [ mapfile ]
        switches += " -Wl,-Map,$mapfile"
      }
    }

    if (invoker.os == "win") {
      # This assumes "-Wl,/debug" or suchlike is in ldflags.  If it's not
      # but nothing depends on the .pdb file, then it should be OK that
      # Ninja thinks it's an additional output but it doesn't get created.
      outputs += [ "{{output_dir}}/{{target_output_name}}.pdb" ]
    }

    if (use_buildidtool) {
      buildid_stampfile = "${outfile_base}.build-id.stamp"
      strip_command +=
          " && $_buildidtool -build-id-dir \"$_id_dir\"" +
          " -stamp \"$buildid_stampfile\"" +
          " -entry \"=$outfile\" -entry \".debug=$unstripped_outfile\""
    }

    if (use_breakpad) {
      breakpad_outfile = "${outfile_base}.sym"
      outputs += [ breakpad_outfile ]

      # dump_syms will fail if there is no build ID.  buildidtool succeeds and
      # writes an empty stamp file for that case, so use it to tell whether
      # dump_syms should be run. In any case, always create a .sym, because we
      # told ninja we would create one above.
      assert(use_buildidtool)
      strip_command +=
          " && { " +  # The brace group is superfluous.
          "test ! -s \"$buildid_stampfile\" && " +
          "touch \"$breakpad_outfile\" || " +
          "$dump_syms \"$unstripped_outfile\" > \"$breakpad_outfile\"" +
          "; }"  # But makes the control flow a little clearer.
    }

    if (use_gsym) {
      gsym_outfile = "${outfile_base}.gsym"
      outputs += [ gsym_outfile ]
      strip_command += " && $gsymutil --convert=\"$unstripped_outfile\" --out-file=\"$gsym_outfile.gsym\""
    }
  }

  toolchain_with_tools(target_name) {
    propagates_configs = true

    tools = [
      {
        name = "asm"
        description = "ASM {{output}}"
        forward_variables_from(_compile_common, "*")
        command = "$cc $switches {{asmflags}} -c {{source}}"
        command_launcher = compiler_prefix
      },

      {
        name = "cc"
        description = "CC {{output}}"
        forward_variables_from(_compile_common, "*")
        command = "$cc $switches {{cflags}} {{cflags_c}} -c {{source}}"
        command_launcher = compiler_prefix
      },

      {
        name = "cxx"
        description = "CXX {{output}}"
        forward_variables_from(_compile_common, "*")
        command = "$cxx $switches {{cflags}} {{cflags_cc}} -c {{source}}"
        command_launcher = compiler_prefix
      },

      {
        name = "objc"
        description = "OBJC {{output}}"
        forward_variables_from(_compile_common, "*")
        command = "$cc $switches {{cflags}} {{cflags_c}} {{cflags_objc}} -c {{source}}"
        command_launcher = compiler_prefix
      },

      {
        name = "objcxx"
        description = "OBJCXX {{output}}"
        forward_variables_from(_compile_common, "*")
        command = "$cxx $switches {{cflags}} {{cflags_cc}} {{cflags_objcc}} -c {{source}}"
        command_launcher = compiler_prefix
      },

      {
        name = "alink"
        description = "AR {{output}}"
        rspfile = "{{output}}.rsp"
        command =
            "rm -f {{output}} && $ar {{arflags}} cqsD {{output}} '@$rspfile'"
        rspfile_content = "{{inputs}}"
        default_output_dir = "{{target_out_dir}}"
        default_output_extension = ".a"
        output_prefix = "lib"
        outputs =
            [ "{{output_dir}}/{{target_output_name}}{{output_extension}}" ]
      },

      {
        forward_variables_from(_link_common, "*")
        name = "link"
        description = "LINK $outfile"
        if (invoker.os == "win") {
          default_output_extension = ".exe"
        }
        command = "$ld $switches $link_inputs$strip_command"
      },
    ]

    if (defined(invoker.shlib) && invoker.shlib) {
      # We don't support building shared libraries for host tools.
      assert(invoker.os == "fuchsia",
             "shared library creation not supported for ${invoker.os}")

      solink_common = {
        forward_variables_from(_link_common, "*")
        depend_output = outfile
        link_output = unstripped_outfile
      }

      tools += [
        {
          forward_variables_from(solink_common, "*")

          name = "solink"
          description = "LINK_SHLIB $outfile"

          output_prefix = "lib"
          default_output_extension = ".so"

          # Put the automatic -soname first so that ldflags can override it.
          soname = "{{target_output_name}}{{output_extension}}"
          switches = "-shared -Wl,-soname,$soname $switches"
          if (use_gcc && tc.tool_prefix == "${tc_cpu}-elf-") {
            # The *-elf-gcc driver doesn't handle -shared properly.
            # Just force it through to the linker.
            switches = "-Wl,$switches"
          }

          command = "$ld $switches $link_inputs$strip_command"

          # TODO: abi stubs
        },

        {
          forward_variables_from(solink_common, "*")

          name = "solink_module"
          description = "LINK_MODULE $outfile"

          default_output_extension = ".so"

          switches = "-shared $switches"
          if (use_gcc && tc.tool_prefix == "${tc_cpu}-elf-") {
            # The *-elf-gcc driver doesn't handle -shared properly.
            # Just force it through to the linker.
            switches = "-Wl,$switches"
          }

          command = "$ld $switches $link_inputs$strip_command"
        },
      ]
    }

    forward_variables_from(invoker, [ "deps" ])

    toolchain_args = {
      current_cpu = invoker.cpu
      current_os = invoker.os

      if (defined(invoker.toolchain_args)) {
        forward_variables_from(invoker.toolchain_args,
                               "*",
                               [
                                 "current_cpu",
                                 "current_os",
                                 "toolchain",
                               ])
      }

      # This shadows the global and so has to be cleared first.
      toolchain = {
      }
      toolchain = {
        name = target_name
        label = get_label_info(":$target_name", "label_no_toolchain")

        # These are provided by BUILDCONFIG.gn so they are expected in
        # every toolchain.
        globals = {
        }
        public_deps = []

        # This gets `tool_dir` et al as expected by c_utils.gni (set above).
        forward_variables_from(tc, "*")
        cpu = tc_cpu
        target_tuple = tc_target

        if (invoker.os == "win") {
          executable_extension = "exe"
        } else {
          executable_extension = ""
        }

        # The invoker can override.  See toolchain_runtime_deps().
        runtime_deps_cflags = []
        runtime_deps_rustflags = []

        if (defined(invoker.toolchain_vars)) {
          forward_variables_from(invoker.toolchain_vars, "*")
        }

        if (!defined(include_dirs)) {
          include_dirs = []
        }
        if (!defined(lib_dirs)) {
          lib_dirs = []
        }
        if (!defined(output_name_suffix)) {
          output_name_suffix = ""
        }

        # This is used in setting metadata.link_output.
        if (use_strip) {
          link_output_suffix = ".debug"
        } else {
          link_output_suffix = ""
        }

        # This is checked in the templates in BUILDCONFIG.gn because
        # it can't import breakpad.gni directly.
        breakpad_syms = use_breakpad
      }
    }
  }
}