engine/src/build/toolchain/win/BUILD.gn - mirrors/flutter - Git at Google

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

 default_clang_base_path = "$buildtools_path/windows-x64/clang"

 declare_args() {
   # Path to the directory containing the VC binaries for the right
   # combination of host and target architectures. Currently only the
   # 64-bit host toolchain is supported, with either 32-bit or 64-bit targets.
   # If vc_bin_dir is not specified on the command line (and it normally
   # isn't), we will dynamically determine the right value to use at runtime.
   vc_bin_dir = ""

   # Path to the clang toolchain.
   clang_base_path = default_clang_base_path
 }

 import("//build/config/win/visual_studio_version.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.

 # This tool will is used as a wrapper for various commands below.
 tool_wrapper_path = rebase_path("tool_wrapper.py", root_build_dir)

 if (use_rbe) {
   compiler_args = rewrapper_command + [
     "--labels=type=compile,compiler=clang-cl,lang=cpp ",
   ]
   compiler_prefix = string_join(" ", compiler_args)
   asm_prefix = " "
 } else {
   compiler_prefix = ""
   asm_prefix = ""
 }

 if (current_toolchain == default_toolchain) {
   if (is_debug) {
     configuration = "Debug"
   } else {
     configuration = "Release"
   }
   exec_script("//build/vs_toolchain.py",
               [
                 "copy_dlls",
                 rebase_path(root_build_dir),
                 configuration,
                 current_cpu,
               ])
 }

 # Parameters:
 #  toolchain_args: Settings for the toolchain, including at least:
 #     current_cpu: current_cpu to pass as a build arg
 #  environment: File name of environment file.
 template("msvc_toolchain") {
   toolchain(target_name) {
     # 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.
     assert(defined(invoker.toolchain_args))
     toolchain_args = {
       if (defined(invoker.toolchain_args)) {
         forward_variables_from(invoker.toolchain_args, "*")
       }
     }

     # TODO(zanderso): Assert that clang is always used or remove this logic.
     if (defined(toolchain_args.is_clang)) {
       toolchain_is_clang = toolchain_args.is_clang
     } else {
       toolchain_is_clang = is_clang
     }

     env = invoker.environment
     env_path = "$root_out_dir/$env"
     print(env_path)
     env_file = read_file(env_path, "string")
     print(env_file)

     cl = invoker.cl

     # Make these apply to all tools below.
     lib_switch = ""
     lib_dir_switch = "/LIBPATH:"

     # If possible, pass system includes as flags to the compiler.  When that's
     # not possible, load a full environment file (containing %INCLUDE% and
     # %PATH%) -- e.g. 32-bit MSVS builds require %PATH% to be set and just
     # passing in a list of include directories isn't enough.
     if (defined(invoker.sys_include_flags)) {
       assert(toolchain_is_clang)
       env_wrapper = ""
       sys_include_flags =
           "${invoker.sys_include_flags} "  # Note trailing space.
     } else {
       # clang-cl doesn't need this env hoop, so omit it there.
       assert(!toolchain_is_clang)
       env_wrapper = "ninja -t msvc -e $env -- "  # Note trailing space.
       sys_include_flags = ""
     }

     tool("cc") {
       precompiled_header_type = "msvc"
       pdbname = "{{target_out_dir}}/{{label_name}}_c.pdb"
       depsformat = "msvc"
       description = "CC {{output}}"
       outputs = [ "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.obj" ]

       # Label names may have spaces in them so the pdbname must be quoted. The
       # source and output don't need to be quoted because GN knows they're a
       # full file name and will quote automatically when necessary.
       command = "$env_wrapper$cl /c {{source}} /nologo /showIncludes:user $sys_include_flags{{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} /Fo{{output}} /Fd\"$pdbname\""
     }

     tool("cxx") {
       precompiled_header_type = "msvc"

       # The PDB name needs to be different between C and C++ compiled files.
       pdbname = "{{target_out_dir}}/{{label_name}}_cc.pdb"

       # TODO(zanderso): This logic should be moved to be with the other compiler
       # flag logic in build/config/compiler/BUILD.gn or so.
       flags = ""
       if (is_clang && invoker.current_cpu == "x86") {
         flags = "-m32"
       }

       depsformat = "msvc"
       description = "CXX {{output}}"
       outputs = [ "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.obj" ]

       # See comment in CC tool about quoting.
       command = "$env_wrapper$cl /c {{source}} /Fo{{output}} $flags /nologo /showIncludes:user $sys_include_flags{{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}} /Fd\"$pdbname\""
     }

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

     tool("asm") {
       is_msvc_assembler = true
       if (toolchain_args.current_cpu == "x64") {
         ml = "ml64.exe"
         x64 = "-D_ML64_X64"
       } else if (toolchain_args.current_cpu == "arm64") {
         is_msvc_assembler = false
         prefix = rebase_path("$clang_base_path/bin", root_build_dir)
         ml = "${compiler_prefix}${prefix}/clang-cl.exe --target=arm64-windows"
         x64 = ""
       } else {
         ml = "ml.exe"
         x64 = ""
       }
       command = "\"$python_path\" $tool_wrapper_path asm-wrapper $env $ml $x64 {{defines}} {{include_dirs}} {{asmflags}} "
       if (is_msvc_assembler) {
         command += "-c -o{{output}} {{source}}"
       } else {
         command += "/c /Fo{{output}} {{source}}"
       }
       outputs = [
         "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.obj",
       ]
     }

     tool("alink") {
       rspfile = "{{output}}.rsp"
       command = "\"$python_path\" $tool_wrapper_path 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") {
       # E.g. "foo.dll":
       dllname = "{{root_out_dir}}/{{target_output_name}}{{output_extension}}"
       libname = "${dllname}.lib"  # e.g. foo.dll.lib
       expname = "${dllname}.exp"
       pdbname = "${dllname}.pdb"
       rspfile = "${dllname}.rsp"

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

       # TODO(brettw) support manifests
       #manifest_command = "\"$python_path\" $tool_wrapper_path 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,
         expname,
         libname,
         pdbname,
       ]
       link_output = libname
       depend_output = 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}}"

       restat = true
     }

     tool("link") {
       binary_output =
           "{{root_out_dir}}/{{target_output_name}}{{output_extension}}"
       rspfile = "$binary_output.rsp"
       pdbfile = "$binary_output.pdb"

       link_command = "\"$python_path\" $tool_wrapper_path link-wrapper $env False link.exe /nologo /OUT:$binary_output /PDB:$pdbfile @$rspfile"

       # TODO(brettw) support manifests
       #manifest_command = "\"$python_path\" $tool_wrapper_path 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 $binary_output"
       outputs = [
         binary_output,
         pdbfile,
       ]

       # 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}}"

       restat = true
     }

     tool("stamp") {
       command = "cmd /c type nul > \"{{output}}\""
       description = "STAMP {{output}}"
     }

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

 template("win_toolchains") {
   assert(defined(invoker.toolchain_arch))
   toolchain_arch = invoker.toolchain_arch

   # The toolchain data for `msvc_toolchain()`.
   if (toolchain_arch == "x86") {
     win_toolchain_data = win_toolchain_data_x86
   } else if (toolchain_arch == "x64") {
     win_toolchain_data = win_toolchain_data_x64
   } else if (toolchain_arch == "arm64") {
     win_toolchain_data = win_toolchain_data_arm64
   } else {
     error("Unsupported toolchain_arch, add it to win_toolchain_data.gni")
   }

   msvc_toolchain("clang_" + target_name) {
     environment = "environment." + toolchain_arch
     prefix = rebase_path("$clang_base_path/bin", root_build_dir)
     cl = "${compiler_prefix}$prefix/clang-cl.exe"
     sys_include_flags = "${win_toolchain_data.include_flags_imsvc}"
     toolchain_args = {
       if (defined(invoker.toolchain_args)) {
         forward_variables_from(invoker.toolchain_args, "*")
       }
       current_cpu = toolchain_arch
       is_clang = true
     }
   }
 }

 if (target_cpu == "x86") {
   win_toolchains("x86") {
     toolchain_arch = "x86"
   }
 }

 if (target_cpu == "x64") {
   win_toolchains("x64") {
     toolchain_arch = "x64"
   }
 }

 if (target_cpu == "arm") {
   # When the target cpu is "arm", we use the 32-bit intel toolchain "x86".
   win_toolchains("x86") {
     toolchain_arch = "x86"
   }
 }

 if (target_cpu == "arm64") {
   win_toolchains("arm64") {
     toolchain_arch = "arm64"
   }

   # Cross-compilation support for x64 hosts.
   if (host_cpu != "arm64") {
     win_toolchains(host_cpu) {
       toolchain_arch = host_cpu
     }
   }
 }
	# 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/toolchain/rbe.gni")
	import("//build/toolchain/toolchain.gni")
	import("//build/toolchain/win/win_toolchain_data.gni")

	default_clang_base_path = "$buildtools_path/windows-x64/clang"

	declare_args() {
	# Path to the directory containing the VC binaries for the right
	# combination of host and target architectures. Currently only the
	# 64-bit host toolchain is supported, with either 32-bit or 64-bit targets.
	# If vc_bin_dir is not specified on the command line (and it normally
	# isn't), we will dynamically determine the right value to use at runtime.
	vc_bin_dir = ""

	# Path to the clang toolchain.
	clang_base_path = default_clang_base_path
	}

	import("//build/config/win/visual_studio_version.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.

	# This tool will is used as a wrapper for various commands below.
	tool_wrapper_path = rebase_path("tool_wrapper.py", root_build_dir)

	if (use_rbe) {
	compiler_args = rewrapper_command + [
	"--labels=type=compile,compiler=clang-cl,lang=cpp ",
	]
	compiler_prefix = string_join(" ", compiler_args)
	asm_prefix = " "
	} else {
	compiler_prefix = ""
	asm_prefix = ""
	}

	if (current_toolchain == default_toolchain) {
	if (is_debug) {
	configuration = "Debug"
	} else {
	configuration = "Release"
	}
	exec_script("//build/vs_toolchain.py",
	[
	"copy_dlls",
	rebase_path(root_build_dir),
	configuration,
	current_cpu,
	])
	}

	# Parameters:
	# toolchain_args: Settings for the toolchain, including at least:
	# current_cpu: current_cpu to pass as a build arg
	# environment: File name of environment file.
	template("msvc_toolchain") {
	toolchain(target_name) {
	# 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.
	assert(defined(invoker.toolchain_args))
	toolchain_args = {
	if (defined(invoker.toolchain_args)) {
	forward_variables_from(invoker.toolchain_args, "*")
	}
	}

	# TODO(zanderso): Assert that clang is always used or remove this logic.
	if (defined(toolchain_args.is_clang)) {
	toolchain_is_clang = toolchain_args.is_clang
	} else {
	toolchain_is_clang = is_clang
	}

	env = invoker.environment
	env_path = "$root_out_dir/$env"
	print(env_path)
	env_file = read_file(env_path, "string")
	print(env_file)

	cl = invoker.cl

	# Make these apply to all tools below.
	lib_switch = ""
	lib_dir_switch = "/LIBPATH:"

	# If possible, pass system includes as flags to the compiler. When that's
	# not possible, load a full environment file (containing %INCLUDE% and
	# %PATH%) -- e.g. 32-bit MSVS builds require %PATH% to be set and just
	# passing in a list of include directories isn't enough.
	if (defined(invoker.sys_include_flags)) {
	assert(toolchain_is_clang)
	env_wrapper = ""
	sys_include_flags =
	"${invoker.sys_include_flags} " # Note trailing space.
	} else {
	# clang-cl doesn't need this env hoop, so omit it there.
	assert(!toolchain_is_clang)
	env_wrapper = "ninja -t msvc -e $env -- " # Note trailing space.
	sys_include_flags = ""
	}

	tool("cc") {
	precompiled_header_type = "msvc"
	pdbname = "{{target_out_dir}}/{{label_name}}_c.pdb"
	depsformat = "msvc"
	description = "CC {{output}}"
	outputs = [ "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.obj" ]

	# Label names may have spaces in them so the pdbname must be quoted. The
	# source and output don't need to be quoted because GN knows they're a
	# full file name and will quote automatically when necessary.
	command = "$env_wrapper$cl /c {{source}} /nologo /showIncludes:user $sys_include_flags{{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} /Fo{{output}} /Fd\"$pdbname\""
	}

	tool("cxx") {
	precompiled_header_type = "msvc"

	# The PDB name needs to be different between C and C++ compiled files.
	pdbname = "{{target_out_dir}}/{{label_name}}_cc.pdb"

	# TODO(zanderso): This logic should be moved to be with the other compiler
	# flag logic in build/config/compiler/BUILD.gn or so.
	flags = ""
	if (is_clang && invoker.current_cpu == "x86") {
	flags = "-m32"
	}

	depsformat = "msvc"
	description = "CXX {{output}}"
	outputs = [ "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.obj" ]

	# See comment in CC tool about quoting.
	command = "$env_wrapper$cl /c {{source}} /Fo{{output}} $flags /nologo /showIncludes:user $sys_include_flags{{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}} /Fd\"$pdbname\""
	}

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

	tool("asm") {
	is_msvc_assembler = true
	if (toolchain_args.current_cpu == "x64") {
	ml = "ml64.exe"
	x64 = "-D_ML64_X64"
	} else if (toolchain_args.current_cpu == "arm64") {
	is_msvc_assembler = false
	prefix = rebase_path("$clang_base_path/bin", root_build_dir)
	ml = "${compiler_prefix}${prefix}/clang-cl.exe --target=arm64-windows"
	x64 = ""
	} else {
	ml = "ml.exe"
	x64 = ""
	}
	command = "\"$python_path\" $tool_wrapper_path asm-wrapper $env $ml $x64 {{defines}} {{include_dirs}} {{asmflags}} "
	if (is_msvc_assembler) {
	command += "-c -o{{output}} {{source}}"
	} else {
	command += "/c /Fo{{output}} {{source}}"
	}
	outputs = [
	"{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.obj",
	]
	}

	tool("alink") {
	rspfile = "{{output}}.rsp"
	command = "\"$python_path\" $tool_wrapper_path 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") {
	# E.g. "foo.dll":
	dllname = "{{root_out_dir}}/{{target_output_name}}{{output_extension}}"
	libname = "${dllname}.lib" # e.g. foo.dll.lib
	expname = "${dllname}.exp"
	pdbname = "${dllname}.pdb"
	rspfile = "${dllname}.rsp"

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

	# TODO(brettw) support manifests
	#manifest_command = "\"$python_path\" $tool_wrapper_path 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,
	expname,
	libname,
	pdbname,
	]
	link_output = libname
	depend_output = 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}}"

	restat = true
	}

	tool("link") {
	binary_output =
	"{{root_out_dir}}/{{target_output_name}}{{output_extension}}"
	rspfile = "$binary_output.rsp"
	pdbfile = "$binary_output.pdb"

	link_command = "\"$python_path\" $tool_wrapper_path link-wrapper $env False link.exe /nologo /OUT:$binary_output /PDB:$pdbfile @$rspfile"

	# TODO(brettw) support manifests
	#manifest_command = "\"$python_path\" $tool_wrapper_path 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 $binary_output"
	outputs = [
	binary_output,
	pdbfile,
	]

	# 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}}"

	restat = true
	}

	tool("stamp") {
	command = "cmd /c type nul > \"{{output}}\""
	description = "STAMP {{output}}"
	}

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

	template("win_toolchains") {
	assert(defined(invoker.toolchain_arch))
	toolchain_arch = invoker.toolchain_arch

	# The toolchain data for `msvc_toolchain()`.
	if (toolchain_arch == "x86") {
	win_toolchain_data = win_toolchain_data_x86
	} else if (toolchain_arch == "x64") {
	win_toolchain_data = win_toolchain_data_x64
	} else if (toolchain_arch == "arm64") {
	win_toolchain_data = win_toolchain_data_arm64
	} else {
	error("Unsupported toolchain_arch, add it to win_toolchain_data.gni")
	}

	msvc_toolchain("clang_" + target_name) {
	environment = "environment." + toolchain_arch
	prefix = rebase_path("$clang_base_path/bin", root_build_dir)
	cl = "${compiler_prefix}$prefix/clang-cl.exe"
	sys_include_flags = "${win_toolchain_data.include_flags_imsvc}"
	toolchain_args = {
	if (defined(invoker.toolchain_args)) {
	forward_variables_from(invoker.toolchain_args, "*")
	}
	current_cpu = toolchain_arch
	is_clang = true
	}
	}
	}

	if (target_cpu == "x86") {
	win_toolchains("x86") {
	toolchain_arch = "x86"
	}
	}

	if (target_cpu == "x64") {
	win_toolchains("x64") {
	toolchain_arch = "x64"
	}
	}

	if (target_cpu == "arm") {
	# When the target cpu is "arm", we use the 32-bit intel toolchain "x86".
	win_toolchains("x86") {
	toolchain_arch = "x86"
	}
	}

	if (target_cpu == "arm64") {
	win_toolchains("arm64") {
	toolchain_arch = "arm64"
	}

	# Cross-compilation support for x64 hosts.
	if (host_cpu != "arm64") {
	win_toolchains(host_cpu) {
	toolchain_arch = host_cpu
	}
	}
	}