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 if (use_goma) {
  43   goma_prefix = "$goma_dir/gomacc.exe "
  44 } else {
  45   goma_prefix = ""
  46 }
  47
  48 # This value will be inherited in the toolchain below.
  49 concurrent_links = exec_script("../get_concurrent_links.py", [], "value")
  50
  51 # Copy the VS runtime DLL for the default toolchain the root build directory so
  52 # things will run.
  53 if (current_toolchain == default_toolchain) {
  54   if (is_debug) {
  55     configuration_name = "Debug"
  56   } else {
  57     configuration_name = "Release"
  58   }
  59   exec_script("../../vs_toolchain.py",
  60               [
  61                 "copy_dlls",
  62                 rebase_path(root_build_dir),
  63                 configuration_name,
  64                 target_cpu,
  65               ])
  66 }
  67
  68 # Parameters:
  69 #  current_cpu: current_cpu to pass as a build arg
  70 #  current_os: current_os to pass as a build arg
  71 #  environment: File name of environment file.
  72 template("msvc_toolchain") {
  73   if (defined(invoker.concurrent_links)) {
  74     concurrent_links = invoker.concurrent_links
  75   }
  76
  77   env = invoker.environment
  78
  79   cl = invoker.cl
  80
  81   toolchain(target_name) {
  82     # Make these apply to all tools below.
  83     lib_switch = ""
  84     lib_dir_switch = "/LIBPATH:"
  85
  86     tool("cc") {
  87       rspfile = "{{output}}.rsp"
  88       precompiled_header_type = "msvc"
  89       pdbname = "{{target_out_dir}}/{{target_output_name}}_c.pdb"
  90       command = "ninja -t msvc -e $env -- $cl /nologo /showIncludes /FC @$rspfile /c {{source}} /Fo{{output}} /Fd$pdbname"
  91       depsformat = "msvc"
  92       description = "CC {{output}}"
  93       outputs = [
  94         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.obj",
  95       ]
  96       rspfile_content = "{{defines}} {{include_dirs}} {{cflags}} {{cflags_c}}"
  97     }
  98
  99     tool("cxx") {
 100       rspfile = "{{output}}.rsp"
 101       precompiled_header_type = "msvc"
 102
 103       # The PDB name needs to be different between C and C++ compiled files.
 104       pdbname = "{{target_out_dir}}/{{target_output_name}}_cc.pdb"
 105       command = "ninja -t msvc -e $env -- $cl /nologo /showIncludes /FC @$rspfile /c {{source}} /Fo{{output}} /Fd$pdbname"
 106       depsformat = "msvc"
 107       description = "CXX {{output}}"
 108       outputs = [
 109         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.obj",
 110       ]
 111       rspfile_content = "{{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}}"
 112     }
 113
 114     tool("rc") {
 115       command = "$python_path gyp-win-tool rc-wrapper $env rc.exe {{defines}} {{include_dirs}} /fo{{output}} {{source}}"
 116       outputs = [
 117         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.res",
 118       ]
 119       description = "RC {{output}}"
 120     }
 121
 122     tool("asm") {
 123       # TODO(brettw): "/safeseh" assembler argument is hardcoded here. Extract
 124       # assembler flags to a variable like cflags. crbug.com/418613
 125       command = "$python_path gyp-win-tool asm-wrapper $env ml.exe {{defines}} {{include_dirs}} /safeseh /c /Fo {{output}} {{source}}"
 126       description = "ASM {{output}}"
 127       outputs = [
 128         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.obj",
 129       ]
 130     }
 131
 132     tool("alink") {
 133       rspfile = "{{output}}.rsp"
 134       command = "$python_path gyp-win-tool link-wrapper $env False lib.exe /nologo /ignore:4221 /OUT:{{output}} @$rspfile"
 135       description = "LIB {{output}}"
 136       outputs = [
 137         # Ignore {{output_extension}} and always use .lib, there's no reason to
 138         # allow targets to override this extension on Windows.
 139         "{{target_out_dir}}/{{target_output_name}}.lib",
 140       ]
 141       default_output_extension = ".lib"
 142
 143       # The use of inputs_newline is to work around a fixed per-line buffer
 144       # size in the linker.
 145       rspfile_content = "{{inputs_newline}}"
 146     }
 147
 148     tool("solink") {
 149       dllname = "{{root_out_dir}}/{{target_output_name}}{{output_extension}}"  # e.g. foo.dll
 150       libname =
 151           "{{root_out_dir}}/{{target_output_name}}{{output_extension}}.lib"  # e.g. foo.dll.lib
 152       rspfile = "${dllname}.rsp"
 153
 154       link_command = "$python_path gyp-win-tool link-wrapper $env False link.exe /nologo /IMPLIB:$libname /DLL /OUT:$dllname /PDB:${dllname}.pdb @$rspfile"
 155
 156       # TODO(brettw) support manifests
 157       #manifest_command = "$python_path gyp-win-tool manifest-wrapper $env mt.exe -nologo -manifest $manifests -out:${dllname}.manifest"
 158       #command = "cmd /c $link_command && $manifest_command"
 159       command = link_command
 160
 161       default_output_extension = ".dll"
 162       description = "LINK(DLL) {{output}}"
 163       outputs = [
 164         dllname,
 165         libname,
 166       ]
 167       link_output = libname
 168       depend_output = libname
 169
 170       # Since the above commands only updates the .lib file when it changes, ask
 171       # Ninja to check if the timestamp actually changed to know if downstream
 172       # dependencies should be recompiled.
 173       restat = true
 174
 175       # The use of inputs_newline is to work around a fixed per-line buffer
 176       # size in the linker.
 177       rspfile_content = "{{libs}} {{solibs}} {{inputs_newline}} {{ldflags}}"
 178     }
 179
 180     tool("link") {
 181       rspfile = "{{output}}.rsp"
 182
 183       link_command = "$python_path gyp-win-tool link-wrapper $env False link.exe /nologo /OUT:{{output}} /PDB:{{output}}.pdb @$rspfile"
 184
 185       # TODO(brettw) support manifests
 186       #manifest_command = "$python_path gyp-win-tool manifest-wrapper $env mt.exe -nologo -manifest $manifests -out:{{output}}.manifest"
 187       #command = "cmd /c $link_command && $manifest_command"
 188       command = link_command
 189
 190       default_output_extension = ".exe"
 191       description = "LINK {{output}}"
 192       outputs = [
 193         "{{root_out_dir}}/{{target_output_name}}{{output_extension}}",
 194       ]
 195
 196       # The use of inputs_newline is to work around a fixed per-line buffer
 197       # size in the linker.
 198       rspfile_content = "{{inputs_newline}} {{libs}} {{solibs}} {{ldflags}}"
 199     }
 200
 201     tool("stamp") {
 202       command = "$python_path gyp-win-tool stamp {{output}}"
 203       description = "STAMP {{output}}"
 204     }
 205
 206     tool("copy") {
 207       command =
 208           "$python_path gyp-win-tool recursive-mirror {{source}} {{output}}"
 209       description = "COPY {{source}} {{output}}"
 210     }
 211
 212     # When invoking this toolchain not as the default one, these args will be
 213     # passed to the build. They are ignored when this is the default toolchain.
 214     toolchain_args() {
 215       current_cpu = invoker.current_cpu
 216       if (defined(invoker.is_clang)) {
 217         is_clang = invoker.is_clang
 218       }
 219       current_os = invoker.current_os
 220     }
 221   }
 222 }
 223
 224 # TODO(dpranke): Declare both toolchains all of the time when we
 225 # get it sorted out how we want to support them both in a single build.
 226 # Right now only one of these can be enabled at a time because the
 227 # runtime libraries get copied to root_build_dir and would collide.
 228 if (current_cpu == "x86") {
 229   msvc_toolchain("x86") {
 230     environment = "environment.x86"
 231     current_cpu = "x86"
 232     cl = "${goma_prefix}\"${vc_bin_dir}/cl.exe\""
 233     is_clang = false
 234   }
 235   msvc_toolchain("clang_x86") {
 236     environment = "environment.x86"
 237     current_cpu = "x86"
 238     prefix = rebase_path("//third_party/llvm-build/Release+Asserts/bin",
 239                          root_build_dir)
 240     cl = "${goma_prefix}$prefix/clang-cl.exe"
 241     current_os = "win"
 242     is_clang = true
 243   }
 244 }
 245
 246 if (current_cpu == "x64") {
 247   msvc_toolchain("x64") {
 248     environment = "environment.x64"
 249     current_cpu = "x64"
 250     cl = "${goma_prefix}\"${vc_bin_dir}/cl.exe\""
 251     is_clang = false
 252   }
 253   msvc_toolchain("clang_x64") {
 254     environment = "environment.x64"
 255     current_cpu = "x64"
 256     prefix = rebase_path("//third_party/llvm-build/Release+Asserts/bin",
 257                          root_build_dir)
 258     cl = "${goma_prefix}$prefix/clang-cl.exe"
 259     current_os = "win"
 260     is_clang = true
 261   }
 262 }
 263
 264 # WinRT toolchains
 265 msvc_toolchain("winrt_x86") {
 266   environment = "environment.winrt_x86"
 267   cl = "${goma_prefix}\"${vc_bin_dir}/cl.exe\""
 268   is_clang = false
 269
 270   current_cpu = "x86"
 271   current_os = current_os
 272 }
 273
 274 msvc_toolchain("winrt_x64") {
 275   environment = "environment.winrt_x64"
 276   cl = "${goma_prefix}\"${vc_bin_dir}/cl.exe\""
 277   is_clang = false
 278
 279   current_cpu = "x64"
 280   current_os = current_os
 281 }