build/toolchain/win/BUILD.gn

   1 # Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 declare_args() {
   6   # Path to the directory containing the VC binaries for the right
   7   # combination of host and target architectures. Currently only the
   8   # 64-bit host toolchain is supported, with either 32-bit or 64-bit targets.
   9   # If vc_bin_dir is not specified on the command line (and it normally
  10   # isn't), we will dynamically determine the right value to use at runtime.
  11   vc_bin_dir = ""
  12 }
  13
  14 import("//build/config/win/visual_studio_version.gni")
  15 import("//build/toolchain/goma.gni")
  16
  17 # Should only be running on Windows.
  18 assert(is_win)
  19
  20 # Setup the Visual Studio state.
  21 #
  22 # Its arguments are the VS path and the compiler wrapper tool. It will write
  23 # "environment.x86" and "environment.x64" to the build directory and return a
  24 # list to us.
  25 gyp_win_tool_path =
  26     rebase_path("//tools/gyp/pylib/gyp/win_tool.py", root_build_dir)
  27
  28 toolchain_data = exec_script("setup_toolchain.py",
  29                              [
  30                                visual_studio_path,
  31                                gyp_win_tool_path,
  32                                windows_sdk_path,
  33                                visual_studio_runtime_dirs,
  34                                current_cpu,
  35                              ],
  36                              "scope")
  37
  38 if (vc_bin_dir == "") {
  39   vc_bin_dir = toolchain_data.vc_bin_dir
  40 }
  41
  42 # This value will be inherited in the toolchain below.
  43 concurrent_links = exec_script("../get_concurrent_links.py", [], "value")
  44
  45 # Parameters:
  46 #  current_cpu: current_cpu to pass as a build arg
  47 #  environment: File name of environment file.
  48 template("msvc_toolchain") {
  49   if (defined(invoker.concurrent_links)) {
  50     concurrent_links = invoker.concurrent_links
  51   }
  52
  53   env = invoker.environment
  54
  55   if (is_debug) {
  56     configuration = "Debug"
  57   } else {
  58     configuration = "Release"
  59   }
  60   exec_script("../../vs_toolchain.py",
  61               [
  62                 "copy_dlls",
  63                 rebase_path(root_build_dir),
  64                 configuration,
  65                 invoker.current_cpu,
  66               ])
  67
  68   if (use_goma) {
  69     goma_prefix = "$goma_dir/gomacc.exe "
  70   } else {
  71     goma_prefix = ""
  72   }
  73
  74   cl = "${goma_prefix}\"${vc_bin_dir}/cl.exe\""
  75
  76   toolchain(target_name) {
  77     # Make these apply to all tools below.
  78     lib_switch = ""
  79     lib_dir_switch = "/LIBPATH:"
  80
  81     tool("cc") {
  82       rspfile = "{{output}}.rsp"
  83       pdbname = "{{target_out_dir}}/{{target_output_name}}_c.pdb"
  84       command = "ninja -t msvc -e $env -- $cl /nologo /showIncludes /FC @$rspfile /c {{source}} /Fo{{output}} /Fd$pdbname"
  85       depsformat = "msvc"
  86       description = "CC {{output}}"
  87       outputs = [
  88         "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.obj",
  89       ]
  90       rspfile_content = "{{defines}} {{include_dirs}} {{cflags}} {{cflags_c}}"
  91     }
  92
  93     tool("cxx") {
  94       rspfile = "{{output}}.rsp"
  95
  96       # The PDB name needs to be different between C and C++ compiled files.
  97       pdbname = "{{target_out_dir}}/{{target_output_name}}_cc.pdb"
  98       command = "ninja -t msvc -e $env -- $cl /nologo /showIncludes /FC @$rspfile /c {{source}} /Fo{{output}} /Fd$pdbname"
  99       depsformat = "msvc"
 100       description = "CXX {{output}}"
 101       outputs = [
 102         "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.obj",
 103       ]
 104       rspfile_content = "{{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}}"
 105     }
 106
 107     tool("rc") {
 108       command = "$python_path gyp-win-tool rc-wrapper $env rc.exe {{defines}} {{include_dirs}} /fo{{output}} {{source}}"
 109       outputs = [
 110         "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.res",
 111       ]
 112       description = "RC {{output}}"
 113     }
 114
 115     tool("asm") {
 116       # TODO(brettw): "/safeseh" assembler argument is hardcoded here. Extract
 117       # assembler flags to a variable like cflags. crbug.com/418613
 118       command = "$python_path gyp-win-tool asm-wrapper $env ml.exe {{defines}} {{include_dirs}} /safeseh /c /Fo {{output}} {{source}}"
 119       description = "ASM {{output}}"
 120       outputs = [
 121         "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.obj",
 122       ]
 123     }
 124
 125     tool("alink") {
 126       rspfile = "{{output}}.rsp"
 127       command = "$python_path gyp-win-tool link-wrapper $env False lib.exe /nologo /ignore:4221 /OUT:{{output}} @$rspfile"
 128       description = "LIB {{output}}"
 129       outputs = [
 130         # Ignore {{output_extension}} and always use .lib, there's no reason to
 131         # allow targets to override this extension on Windows.
 132         "{{target_out_dir}}/{{target_output_name}}.lib",
 133       ]
 134       default_output_extension = ".lib"
 135
 136       # The use of inputs_newline is to work around a fixed per-line buffer
 137       # size in the linker.
 138       rspfile_content = "{{inputs_newline}}"
 139     }
 140
 141     tool("solink") {
 142       dllname = "{{root_out_dir}}/{{target_output_name}}{{output_extension}}"  # e.g. foo.dll
 143       libname =
 144           "{{root_out_dir}}/{{target_output_name}}{{output_extension}}.lib"  # e.g. foo.dll.lib
 145       rspfile = "${dllname}.rsp"
 146
 147       link_command = "$python_path gyp-win-tool link-wrapper $env False link.exe /nologo /IMPLIB:$libname /DLL /OUT:$dllname /PDB:${dllname}.pdb @$rspfile"
 148
 149       # TODO(brettw) support manifests
 150       #manifest_command = "$python_path gyp-win-tool manifest-wrapper $env mt.exe -nologo -manifest $manifests -out:${dllname}.manifest"
 151       #command = "cmd /c $link_command && $manifest_command"
 152       command = link_command
 153
 154       default_output_extension = ".dll"
 155       description = "LINK(DLL) {{output}}"
 156       outputs = [
 157         dllname,
 158         libname,
 159       ]
 160       link_output = libname
 161       depend_output = libname
 162
 163       # The use of inputs_newline is to work around a fixed per-line buffer
 164       # size in the linker.
 165       rspfile_content = "{{libs}} {{solibs}} {{inputs_newline}} {{ldflags}}"
 166     }
 167
 168     tool("link") {
 169       rspfile = "{{output}}.rsp"
 170
 171       link_command = "$python_path gyp-win-tool link-wrapper $env False link.exe /nologo /OUT:{{output}} /PDB:{{output}}.pdb @$rspfile"
 172
 173       # TODO(brettw) support manifests
 174       #manifest_command = "$python_path gyp-win-tool manifest-wrapper $env mt.exe -nologo -manifest $manifests -out:{{output}}.manifest"
 175       #command = "cmd /c $link_command && $manifest_command"
 176       command = link_command
 177
 178       default_output_extension = ".exe"
 179       description = "LINK {{output}}"
 180       outputs = [
 181         "{{root_out_dir}}/{{target_output_name}}{{output_extension}}",
 182       ]
 183
 184       # The use of inputs_newline is to work around a fixed per-line buffer
 185       # size in the linker.
 186       rspfile_content = "{{inputs_newline}} {{libs}} {{solibs}} {{ldflags}}"
 187     }
 188
 189     tool("stamp") {
 190       command = "$python_path gyp-win-tool stamp {{output}}"
 191       description = "STAMP {{output}}"
 192     }
 193
 194     tool("copy") {
 195       command =
 196           "$python_path gyp-win-tool recursive-mirror {{source}} {{output}}"
 197       description = "COPY {{source}} {{output}}"
 198     }
 199
 200     # When invoking this toolchain not as the default one, these args will be
 201     # passed to the build. They are ignored when this is the default toolchain.
 202     toolchain_args() {
 203       current_cpu = invoker.current_cpu
 204     }
 205   }
 206 }
 207
 208 # TODO(dpranke): Declare both toolchains all of the time when we
 209 # get it sorted out how we want to support them both in a single build.
 210 # Right now only one of these can be enabled at a time because the
 211 # runtime libraries get copied to root_build_dir and would collide.
 212 if (current_cpu == "x86") {
 213   msvc_toolchain("32") {
 214     environment = "environment.x86"
 215
 216     current_cpu = "x86"
 217   }
 218 }
 219
 220 if (current_cpu == "x64") {
 221   msvc_toolchain("64") {
 222     environment = "environment.x64"
 223
 224     current_cpu = "x64"
 225   }
 226 }