build/toolchain/win/BUILD.gn

# 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/win/visual_studio_version.gni")
import("//build/toolchain/goma.gni")

# Should only be running on Windows.
assert(is_win)

# Setup the Visual Studio state.
#
# Its arguments are the VS path and the compiler wrapper tool. It will write
# "environment.x86" and "environment.x64" to the build directory and return a
# list to us.
gyp_win_tool_path = rebase_path("//tools/gyp/pylib/gyp/win_tool.py",
                                root_build_dir)
exec_script("setup_toolchain.py",
            [ visual_studio_path, gyp_win_tool_path, windows_sdk_path ])

# Parameters:
#  cpu_arch: cpu_arch to pass as a build arg
#  environment: File name of environment file.
#  force_win64 (optional): value for this build arg.
template("msvc_toolchain") {
  env = invoker.environment

  toolchain(target_name) {
    # Make these apply to all tools below.
    lib_switch = ""
    lib_dir_switch="/LIBPATH:"

    tool("cc") {
      rspfile = "{{output}}.rsp"
      pdbname = "{{target_out_dir}}/{{target_output_name}}_c.pdb"
      command = "ninja -t msvc -e $env -- cl.exe /nologo /showIncludes /FC @$rspfile /c {{source}} /Fo{{output}} /Fd$pdbname"
      depsformat = "msvc"
      description = "CC {{output}}"
      outputs = [
        "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.obj",
      ]
      rspfile_content = "{{defines}} {{include_dirs}} {{cflags}} {{cflags_c}}"
    }

    tool("cxx") {
      rspfile = "{{output}}.rsp"
      # The PDB name needs to be different between C and C++ compiled files.
      pdbname = "{{target_out_dir}}/{{target_output_name}}_cc.pdb"
      command = "ninja -t msvc -e $env -- cl.exe /nologo /showIncludes /FC @$rspfile /c {{source}} /Fo{{output}} /Fd$pdbname"
      depsformat = "msvc"
      description = "CXX {{output}}"
      outputs = [
        "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.obj",
      ]
      rspfile_content = "{{defines}} {{include_dirs}} {{cflags}} {{cflags_c}}"
    }

    tool("rc") {
      command = "$python_path gyp-win-tool rc-wrapper $env rc.exe {{defines}} {{include_dirs}} /fo{{output}} {{source}}"
      outputs = [
        "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.res",
      ]
      description = "RC {{output}}"
    }

    tool("asm") {
      command = "$python_path gyp-win-tool asm-wrapper $env ml.exe {{defines}} {{include_dirs}} /c /Fo {{output}} {{source}}"
      description = "ASM {{output}}"
      outputs = [
        "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.obj",
      ]
    }

    tool("alink") {
      rspfile = "{{output}}.rsp"
      command = "$python_path gyp-win-tool link-wrapper $env False lib.exe /nologo /ignore:4221 /OUT:{{output}} @$rspfile"
      description = "LIB {{output}}"
      outputs = [
        # Ignore {{output_extension}} and always use .lib, there's no reason to
        # allow targets to override this extension on Windows.
        "{{target_out_dir}}/{{target_output_name}}.lib",
      ]
      default_output_extension = ".lib"
      # The use of inputs_newline is to work around a fixed per-line buffer
      # size in the linker.
      rspfile_content = "{{inputs_newline}}"
    }

    tool("solink") {
      dllname = "{{target_output_name}}{{output_extension}}"  # e.g. foo.dll
      libname = "{{target_output_name}}{{output_extension}}.lib"  # e.g. foo.dll.lib
      rspfile = "${dllname}.rsp"

      link_command = "$python_path gyp-win-tool link-wrapper $env False link.exe /nologo /IMPLIB:$libname /DLL /OUT:$dllname /PDB:${dllname}.pdb @$rspfile"

      # TODO(brettw) support manifests
      #manifest_command = "$python_path gyp-win-tool manifest-wrapper $env mt.exe -nologo -manifest $manifests -out:${dllname}.manifest"
      #command = "cmd /c $link_command && $manifest_command"
      command = link_command

      default_output_extension = ".dll"
      description = "LINK(DLL) {{output}}"
      outputs = [
        dllname,
        libname,
      ]
      # The use of inputs_newline is to work around a fixed per-line buffer
      # size in the linker.
      rspfile_content = "{{libs}} {{solibs}} {{inputs_newline}} {{ldflags}}"
    }

    tool("link") {
      rspfile = "{{output}}.rsp"

      link_command = "$python_path gyp-win-tool link-wrapper $env False link.exe /nologo /OUT:{{output}} /PDB:{{output}}.pdb @$rspfile"

      # TODO(brettw) support manifests
      #manifest_command = "$python_path gyp-win-tool manifest-wrapper $env mt.exe -nologo -manifest $manifests -out:{{output}}.manifest"
      #command = "cmd /c $link_command && $manifest_command"
      command = link_command

      default_output_extension = ".exe"
      description = "LINK {{output}}"
      outputs = [
        "{{target_output_name}}{{output_extension}}",
      ]
      # The use of inputs_newline is to work around a fixed per-line buffer
      # size in the linker.
      rspfile_content = "{{inputs_newline}} {{libs}} {{solibs}} {{ldflags}}"
    }

    tool("stamp") {
      command = "$python_path gyp-win-tool stamp {{output}}"
      description = "STAMP {{output}}"
    }

    tool("copy") {
      command =  "$python_path gyp-win-tool recursive-mirror {{source}} {{output}}"
      description = "COPY {{source}} {{output}}"
    }

    # When invoking this toolchain not as the default one, these args will be
    # passed to the build. They are ignored when this is the default toolchain.
    toolchain_args() {
      cpu_arch = invoker.cpu_arch

      # Normally the build config resets the CPU architecture to 32-bits. Setting
      # this flag overrides that behavior.
      if (defined(invoker.force_win64)) {
        force_win64 = invoker.force_win64
      }
    }
  }
}

msvc_toolchain("32") {
  environment = "environment.x86"
  cpu_arch = "x64"
}

msvc_toolchain("64") {
  environment = "environment.x64"
  cpu_arch = "x64"
  force_win64 = true
}