| # Copyright 2022 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import("//build/config/clang/clang.gni") |
| import("//build/config/compiler/compiler.gni") |
| import("//build/config/rust.gni") |
| import("//build/config/sanitizers/sanitizers.gni") |
| import("//build/config/win/visual_studio_version.gni") |
| import("//build/toolchain/cc_wrapper.gni") |
| import("//build/toolchain/goma.gni") |
| import("//build/toolchain/rbe.gni") |
| import("//build/toolchain/toolchain.gni") |
| import("//build/toolchain/win/win_toolchain_data.gni") |
| |
| assert(is_win, "Should only be running on Windows") |
| |
| # This tool will is used as a wrapper for various commands below. |
| _tool_wrapper_path = |
| rebase_path("//build/toolchain/win/tool_wrapper.py", root_build_dir) |
| |
| if (host_os == "win") { |
| _exe = ".exe" |
| } else { |
| _exe = "" |
| } |
| |
| _clang_bin_path = rebase_path("$clang_base_path/bin", root_build_dir) |
| |
| # Makes a single MSVC toolchain. Callers should normally instead invoke |
| # "msvc_toolchain" which might make an additional toolchain available |
| # without sanitizers if required. |
| # |
| # Parameters: |
| # environment: File name of environment file. |
| # |
| # You would also define a toolchain_args variable with at least these set: |
| # current_cpu: current_cpu to pass as a build arg |
| # current_os: current_os to pass as a build arg |
| template("single_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 = { |
| forward_variables_from(invoker.toolchain_args, "*") |
| |
| # This value needs to be passed through unchanged. |
| host_toolchain = host_toolchain |
| |
| # This value needs to be passed through unchanged. |
| host_toolchain_no_sanitizers = host_toolchain_no_sanitizers |
| } |
| |
| if (defined(toolchain_args.is_clang)) { |
| toolchain_is_clang = toolchain_args.is_clang |
| } else { |
| toolchain_is_clang = is_clang |
| } |
| |
| # When the invoker has explicitly overridden use_goma or cc_wrapper in the |
| # toolchain args, use those values, otherwise default to the global one. |
| # This works because the only reasonable override that toolchains might |
| # supply for these values are to force-disable them. |
| if (defined(toolchain_args.use_remoteexec)) { |
| toolchain_uses_remoteexec = toolchain_args.use_remoteexec |
| } else { |
| toolchain_uses_remoteexec = use_remoteexec |
| } |
| if (defined(toolchain_args.use_goma)) { |
| toolchain_uses_goma = toolchain_args.use_goma |
| } else { |
| toolchain_uses_goma = use_goma |
| } |
| if (defined(toolchain_args.cc_wrapper)) { |
| toolchain_cc_wrapper = toolchain_args.cc_wrapper |
| } else { |
| toolchain_cc_wrapper = cc_wrapper |
| } |
| assert(!(toolchain_uses_remoteexec && toolchain_uses_goma), |
| "Goma and re-client can't be used together.") |
| assert(!(toolchain_cc_wrapper != "" && toolchain_uses_remoteexec), |
| "re-client and cc_wrapper can't be used together.") |
| assert(!(toolchain_cc_wrapper != "" && toolchain_uses_goma), |
| "Goma and cc_wrapper can't be used together.") |
| |
| if (toolchain_uses_remoteexec) { |
| if (toolchain_is_clang) { |
| cl_prefix = "${rbe_bin_dir}/rewrapper -cfg=${rbe_cc_cfg_file} -exec_root=${rbe_exec_root} " |
| } else { |
| cl_prefix = "" |
| } |
| } else if (toolchain_uses_goma) { |
| cl_prefix = "${goma_dir}/gomacc${_exe} " |
| } else if (toolchain_cc_wrapper != "" && toolchain_is_clang) { |
| cl_prefix = toolchain_cc_wrapper + " " |
| } else { |
| cl_prefix = "" |
| } |
| |
| cl = "${cl_prefix}${invoker.cl}" |
| if (host_os == "win") { |
| # Flip the slashes so that copy/paste of the command works. |
| cl = string_replace(cl, "/", "\\") |
| } |
| |
| # Make these apply to all tools below. |
| lib_switch = "" |
| lib_dir_switch = "/LIBPATH:" |
| |
| # Object files go in this directory. |
| object_subdir = "{{target_out_dir}}/{{label_name}}" |
| |
| env = invoker.environment |
| |
| if (use_lld) { |
| # lld-link includes a replacement for lib.exe that can produce thin |
| # archives and understands bitcode (for lto builds). |
| link = "${_clang_bin_path}/lld-link${_exe}" |
| if (host_os == "win") { |
| # Flip the slashes so that copy/paste of the commands works. |
| link = string_replace(link, "/", "\\") |
| } |
| lib = "$link /lib" |
| if (host_os != "win") { |
| # See comment adding --rsp-quoting to $cl above for more information. |
| link = "$link --rsp-quoting=posix" |
| } |
| } else { |
| lib = "lib.exe" |
| link = "link.exe" |
| } |
| |
| # 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)) { |
| 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 = "" |
| } |
| |
| if (host_os != "win" || (use_lld && defined(invoker.sys_lib_flags))) { |
| linker_wrapper = "" |
| sys_lib_flags = "${invoker.sys_lib_flags} " # Note trailing space. |
| } else { |
| # link.exe must be run under a wrapper to set up the environment |
| # (it needs %LIB% set to find libraries), and to work around its bugs. |
| # Note trailing space: |
| linker_wrapper = |
| "\"$python_path\" $_tool_wrapper_path link-wrapper $env False " |
| sys_lib_flags = "" |
| } |
| |
| if (defined(toolchain_args.use_clang_coverage)) { |
| toolchain_use_clang_coverage = toolchain_args.use_clang_coverage |
| } else { |
| toolchain_use_clang_coverage = use_clang_coverage |
| } |
| |
| if (toolchain_use_clang_coverage) { |
| assert(toolchain_is_clang, |
| "use_clang_coverage should only be used with Clang") |
| if (defined(toolchain_args.coverage_instrumentation_input_file)) { |
| toolchain_coverage_instrumentation_input_file = |
| toolchain_args.coverage_instrumentation_input_file |
| } else { |
| toolchain_coverage_instrumentation_input_file = |
| coverage_instrumentation_input_file |
| } |
| |
| coverage_wrapper = |
| rebase_path("//build/toolchain/clang_code_coverage_wrapper.py", |
| root_build_dir) |
| coverage_wrapper = coverage_wrapper + " --target-os=" + target_os |
| if (toolchain_coverage_instrumentation_input_file != "") { |
| coverage_wrapper = |
| coverage_wrapper + " --files-to-instrument=" + |
| rebase_path(toolchain_coverage_instrumentation_input_file, |
| root_build_dir) |
| } |
| coverage_wrapper = "\"$python_path\" " + coverage_wrapper + " " |
| } else { |
| coverage_wrapper = "" |
| } |
| |
| # Disabled with cc_wrapper because of |
| # https://github.com/mozilla/sccache/issues/1013 |
| if (toolchain_is_clang && toolchain_cc_wrapper == "") { |
| # This flag omits system includes from /showIncludes output, to reduce |
| # the amount of data to parse and store in .ninja_deps. We do this on |
| # non-Windows too, and already make sure rebuilds after winsdk/libc++/ |
| # clang header updates happen via changing command line flags. |
| show_includes = "/showIncludes:user" |
| } else { |
| show_includes = "/showIncludes" |
| } |
| |
| tool("cc") { |
| precompiled_header_type = "msvc" |
| pdbname = "{{target_out_dir}}/{{label_name}}_c.pdb" |
| |
| # 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. |
| depsformat = "msvc" |
| description = "CC {{output}}" |
| outputs = [ "$object_subdir/{{source_name_part}}.obj" ] |
| |
| # Note that the code coverage wrapper scripts assumes that {{source}} |
| # comes immediately after /c. |
| command = "$coverage_wrapper$env_wrapper$cl /c {{source}} /nologo $show_includes $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" |
| |
| # See comment in CC tool about quoting. |
| depsformat = "msvc" |
| description = "CXX {{output}}" |
| outputs = [ "$object_subdir/{{source_name_part}}.obj" ] |
| |
| # Note that the code coverage wrapper scripts assumes that {{source}} |
| # comes immediately after /c. |
| command = "$coverage_wrapper$env_wrapper$cl /c {{source}} /Fo{{output}} /nologo $show_includes $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 $sys_include_flags{{defines}} {{include_dirs}} /fo{{output}} {{source}}" |
| depsformat = "msvc" |
| outputs = [ "$object_subdir/{{source_name_part}}.res" ] |
| description = "RC {{output}}" |
| } |
| |
| tool("asm") { |
| is_msvc_assembler = true |
| |
| if (toolchain_args.current_cpu == "arm64") { |
| if (toolchain_is_clang) { |
| ml = "${cl_prefix}${_clang_bin_path}/clang-cl${_exe} --target=arm64-windows" |
| if (host_os == "win") { |
| # Flip the slashes so that copy/paste of the command works. |
| ml = string_replace(ml, "/", "\\") |
| } |
| ml += " -c -o{{output}}" |
| is_msvc_assembler = false |
| } else { |
| # Only affects Arm builds with is_clang = false, implemented for |
| # building V8 for Windows on Arm systems with the MSVC toolchain. |
| ml = "armasm64.exe" |
| } |
| } else { |
| if (toolchain_is_clang && !disable_llvm_ml) { |
| prefix = rebase_path("$clang_base_path/bin", root_build_dir) |
| ml = "$prefix/llvm-ml${_exe}" |
| if (toolchain_args.current_cpu == "x64") { |
| ml += " -m64" |
| } else { |
| ml += " -m32" |
| } |
| } else { |
| if (toolchain_args.current_cpu == "x64") { |
| ml = "ml64.exe" |
| } else { |
| ml = "ml.exe" |
| } |
| } |
| } |
| |
| if (is_msvc_assembler) { |
| ml += " /nologo /Fo{{output}}" |
| |
| # Suppress final-stage linking on x64/x86 builds. (Armasm64 does not |
| # require /c because it doesn't support linking.) |
| if (toolchain_args.current_cpu != "arm64") { |
| ml += " /c" |
| } |
| if (use_lld && (!toolchain_is_clang || disable_llvm_ml)) { |
| # Wrap ml(64).exe with a script that makes its output deterministic. |
| # It's lld only because the script zaps obj Timestamp which |
| # link.exe /incremental looks at. |
| ml_py = rebase_path("//build/toolchain/win/ml.py", root_build_dir) |
| ml = "\"$python_path\" $ml_py $ml" |
| } |
| } |
| if (toolchain_args.current_cpu != "arm64" || toolchain_is_clang) { |
| # TODO(thakis): Stop using asm-wrapper when using clang. |
| command = "\"$python_path\" $_tool_wrapper_path asm-wrapper $env $ml {{defines}} {{include_dirs}} {{asmflags}} {{source}}" |
| } else { |
| # armasm64.exe does not support definitions passed via the command |
| # line. (Fortunately, they're not needed for compiling the V8 |
| # snapshot, which is the only time this assembler is required.) |
| command = "\"$python_path\" $_tool_wrapper_path asm-wrapper $env $ml {{include_dirs}} {{asmflags}} {{source}}" |
| } |
| |
| description = "ASM {{output}}" |
| outputs = [ "$object_subdir/{{source_name_part}}.obj" ] |
| } |
| |
| if (toolchain_has_rust) { |
| rustc_wrapper = rebase_path("//build/rust/rustc_wrapper.py") |
| rustc = rebase_path("${rust_sysroot}/bin/rustc", root_build_dir) |
| rust_sysroot_relative_to_out = rebase_path(rust_sysroot, root_out_dir) |
| rustc_windows_args = " -Clinker=$link $rustc_common_args" |
| |
| tool("rust_staticlib") { |
| libname = "{{output_dir}}/{{target_output_name}}{{output_extension}}" |
| rspfile = "$libname.rsp" |
| depfile = "$libname.d" |
| |
| default_output_extension = ".lib" |
| output_prefix = "lib" |
| default_output_dir = "{{root_out_dir}}" |
| description = "RUST(STATICLIB) {{output}}" |
| outputs = [ libname ] |
| |
| rspfile_content = "{{rustdeps}} {{externs}}" |
| command = "\"$python_path\" \"$rustc_wrapper\" --rustc=$rustc --depfile=$depfile --rsp=$rspfile -- $rustc_windows_args --emit=dep-info=$depfile,link -o $libname LDFLAGS RUSTENV {{rustenv}}" |
| rust_sysroot = rust_sysroot_relative_to_out |
| } |
| |
| tool("rust_rlib") { |
| # We must always prefix with `lib` even if the library already starts |
| # with that prefix or else our stdlib is unable to find libc.rlib (or |
| # actually liblibc.rlib). |
| rlibname = |
| "{{output_dir}}/lib{{target_output_name}}{{output_extension}}" |
| depfile = "$rlibname.d" |
| |
| # Do not use rsp files in this (common) case because they occupy the |
| # ninja main thread, and {{rlibs}} have shorter command lines than |
| # fully linked targets. |
| |
| default_output_extension = ".rlib" |
| |
| # This is prefixed unconditionally in `rlibname`. |
| # output_prefix = "lib" |
| default_output_dir = "{{root_out_dir}}" |
| description = "RUST {{output}}" |
| outputs = [ rlibname ] |
| |
| command = "\"$python_path\" \"$rustc_wrapper\" --rustc=$rustc --depfile=$depfile -- $rustc_windows_args --emit=dep-info=$depfile,link -o $rlibname {{rustdeps}} {{externs}} LDFLAGS RUSTENV {{rustenv}}" |
| rust_sysroot = rust_sysroot_relative_to_out |
| } |
| |
| tool("rust_bin") { |
| exename = "{{output_dir}}/{{target_output_name}}{{output_extension}}" |
| pdbname = "$exename.pdb" |
| rspfile = "$exename.rsp" |
| depfile = "$exename.d" |
| pool = "//build/toolchain:link_pool($default_toolchain)" |
| |
| default_output_extension = ".exe" |
| default_output_dir = "{{root_out_dir}}" |
| description = "RUST(BIN) {{output}}" |
| outputs = [ |
| # The first entry here is used for dependency tracking. |
| exename, |
| pdbname, |
| ] |
| runtime_outputs = outputs |
| |
| rspfile_content = "{{rustdeps}} {{externs}}" |
| command = "\"$python_path\" \"$rustc_wrapper\" --rustc=$rustc --depfile=$depfile --rsp=$rspfile -- $rustc_windows_args --emit=dep-info=$depfile,link -o $exename LDFLAGS {{ldflags}} $sys_lib_flags /PDB:$pdbname RUSTENV {{rustenv}}" |
| rust_sysroot = rust_sysroot_relative_to_out |
| } |
| |
| tool("rust_cdylib") { |
| # E.g. "foo.dll": |
| dllname = "{{output_dir}}/{{target_output_name}}{{output_extension}}" |
| libname = "$dllname.lib" # e.g. foo.dll.lib |
| pdbname = "$dllname.pdb" |
| rspfile = "$dllname.rsp" |
| depfile = "$dllname.d" |
| pool = "//build/toolchain:link_pool($default_toolchain)" |
| |
| default_output_extension = ".dll" |
| default_output_dir = "{{root_out_dir}}" |
| description = "RUST(CDYLIB) {{output}}" |
| outputs = [ |
| # The first entry here is used for dependency tracking. Dylibs are |
| # linked into other targets and that linking must be done through |
| # the .lib file, not the .dll file. So the .lib file is the primary |
| # output here. |
| libname, |
| dllname, |
| pdbname, |
| ] |
| runtime_outputs = [ |
| dllname, |
| pdbname, |
| ] |
| |
| rspfile_content = "{{rustdeps}} {{externs}}" |
| command = "\"$python_path\" \"$rustc_wrapper\" --rustc=$rustc --depfile=$depfile --rsp=$rspfile -- $rustc_windows_args --emit=dep-info=$depfile,link -o $dllname LDFLAGS {{ldflags}} $sys_lib_flags /PDB:$pdbname /IMPLIB:$libname RUSTENV {{rustenv}}" |
| rust_sysroot = rust_sysroot_relative_to_out |
| |
| # Since the above commands only updates the .lib file when it changes, |
| # ask Ninja to check if the timestamp actually changed to know if |
| # downstream dependencies should be recompiled. |
| restat = true |
| } |
| |
| tool("rust_macro") { |
| # E.g. "foo.dll": |
| dllname = "{{output_dir}}/{{target_output_name}}{{output_extension}}" |
| pdbname = "$dllname.pdb" |
| rspfile = "$dllname.rsp" |
| depfile = "$dllname.d" |
| pool = "//build/toolchain:link_pool($default_toolchain)" |
| |
| default_output_extension = ".dll" |
| default_output_dir = "{{root_out_dir}}" |
| description = "RUST(MACRO) {{output}}" |
| outputs = [ |
| # The first entry here is used for dependency tracking. Proc macros |
| # are consumed as dlls directly, loaded a runtime, so the dll is the |
| # primary output here. If we make a .lib file the primary output, we |
| # end up trying to load the .lib file as a procmacro which fails. |
| # |
| # Since depending on a macro target for linking would fail (it would |
| # try to link primary .dll target) we omit the .lib here entirely. |
| dllname, |
| pdbname, |
| ] |
| runtime_outputs = outputs |
| |
| rspfile_content = "{{rustdeps}} {{externs}}" |
| command = "\"$python_path\" \"$rustc_wrapper\" --rustc=$rustc --depfile=$depfile --rsp=$rspfile -- $rustc_windows_args --emit=dep-info=$depfile,link -o $dllname LDFLAGS {{ldflags}} $sys_lib_flags /PDB:$pdbname RUSTENV {{rustenv}}" |
| rust_sysroot = rust_sysroot_relative_to_out |
| |
| # Since the above commands only updates the .lib file when it changes, |
| # ask Ninja to check if the timestamp actually changed to know if |
| # downstream dependencies should be recompiled. |
| restat = true |
| } |
| } |
| |
| tool("alink") { |
| rspfile = "{{output}}.rsp" |
| command = |
| "$linker_wrapper$lib /OUT:{{output}} /nologo {{arflags}} @$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. |
| "{{output_dir}}/{{target_output_name}}.lib", |
| ] |
| default_output_extension = ".lib" |
| default_output_dir = "{{target_out_dir}}" |
| |
| # 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 = "{{output_dir}}/{{target_output_name}}{{output_extension}}" |
| libname = "${dllname}.lib" # e.g. foo.dll.lib |
| pdbname = "${dllname}.pdb" |
| rspfile = "${dllname}.rsp" |
| pool = "//build/toolchain:link_pool($default_toolchain)" |
| |
| command = "$linker_wrapper$link /OUT:$dllname /nologo ${sys_lib_flags}/IMPLIB:$libname /DLL /PDB:$pdbname @$rspfile" |
| |
| default_output_extension = ".dll" |
| default_output_dir = "{{root_out_dir}}" |
| description = "LINK(DLL) {{output}}" |
| outputs = [ |
| dllname, |
| libname, |
| pdbname, |
| ] |
| link_output = libname |
| depend_output = libname |
| runtime_outputs = [ |
| dllname, |
| pdbname, |
| ] |
| |
| # Since the above commands only updates the .lib file when it changes, |
| # ask Ninja to check if the timestamp actually changed to know if |
| # downstream dependencies should be recompiled. |
| restat = true |
| |
| # 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}} {{rlibs}}" |
| } |
| |
| tool("solink_module") { |
| # E.g. "foo.dll": |
| dllname = "{{output_dir}}/{{target_output_name}}{{output_extension}}" |
| pdbname = "${dllname}.pdb" |
| rspfile = "${dllname}.rsp" |
| pool = "//build/toolchain:link_pool($default_toolchain)" |
| |
| command = "$linker_wrapper$link /OUT:$dllname /nologo ${sys_lib_flags}/DLL /PDB:$pdbname @$rspfile" |
| |
| default_output_extension = ".dll" |
| default_output_dir = "{{root_out_dir}}" |
| description = "LINK_MODULE(DLL) {{output}}" |
| outputs = [ |
| dllname, |
| pdbname, |
| ] |
| runtime_outputs = outputs |
| |
| # 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}} {{rlibs}}" |
| } |
| |
| tool("link") { |
| exename = "{{output_dir}}/{{target_output_name}}{{output_extension}}" |
| pdbname = "$exename.pdb" |
| rspfile = "$exename.rsp" |
| pool = "//build/toolchain:link_pool($default_toolchain)" |
| |
| command = "$linker_wrapper$link /OUT:$exename /nologo ${sys_lib_flags} /PDB:$pdbname @$rspfile" |
| |
| default_output_extension = ".exe" |
| default_output_dir = "{{root_out_dir}}" |
| description = "LINK {{output}}" |
| outputs = [ |
| exename, |
| pdbname, |
| ] |
| runtime_outputs = outputs |
| |
| # 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}} {{rlibs}}" |
| } |
| |
| # These two are really entirely generic, but have to be repeated in |
| # each toolchain because GN doesn't allow a template to be used here. |
| # See //build/toolchain/toolchain.gni for details. |
| tool("stamp") { |
| command = stamp_command |
| description = stamp_description |
| pool = "//build/toolchain:action_pool($default_toolchain)" |
| } |
| tool("copy") { |
| command = copy_command |
| description = copy_description |
| pool = "//build/toolchain:action_pool($default_toolchain)" |
| } |
| |
| tool("action") { |
| pool = "//build/toolchain:action_pool($default_toolchain)" |
| } |
| } |
| } |
| |
| # Makes a single MSVC toolchain, or possibly two if we |
| # need an additional toolchain without sanitizers enabled. |
| template("msvc_toolchain") { |
| single_msvc_toolchain(target_name) { |
| assert(defined(invoker.toolchain_args), |
| "Toolchains must declare toolchain_args") |
| forward_variables_from(invoker, |
| "*", |
| [ |
| "visibility", |
| "test_only", |
| ]) |
| |
| # No need to forward visibility and test_only as they apply to targets not |
| # toolchains, but presubmit checks require that we explicitly exclude them |
| } |
| |
| if (using_sanitizer) { |
| # Make an additional toolchain with no sanitizers. |
| single_msvc_toolchain("${target_name}_no_sanitizers") { |
| assert(defined(invoker.toolchain_args), |
| "Toolchains must declare toolchain_args") |
| forward_variables_from(invoker, |
| "*", |
| [ |
| "toolchain_args", |
| "visibility", |
| "test_only", |
| ]) |
| toolchain_args = { |
| # Populate toolchain args from the invoker. |
| forward_variables_from(invoker.toolchain_args, "*") |
| toolchain_disables_sanitizers = true |
| } |
| } |
| } |
| } |
| |
| template("win_toolchains") { |
| assert(defined(invoker.toolchain_arch)) |
| toolchain_arch = invoker.toolchain_arch |
| |
| 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") |
| } |
| |
| # The toolchain using MSVC only makes sense when not doing cross builds. |
| # Chromium exclusively uses the win_clang_ toolchain below, but V8 and |
| # WebRTC still use this MSVC toolchain in some cases. |
| if (host_os == "win") { |
| if (defined(invoker.cl_toolchain_prefix)) { |
| cl_toolchain_prefix = invoker.cl_toolchain_prefix |
| } else { |
| cl_toolchain_prefix = "" |
| } |
| msvc_toolchain(cl_toolchain_prefix + target_name) { |
| environment = "environment." + toolchain_arch |
| cl = "\"${win_toolchain_data.vc_bin_dir}/cl.exe\"" |
| |
| toolchain_args = { |
| if (defined(invoker.toolchain_args)) { |
| forward_variables_from(invoker.toolchain_args, "*") |
| } |
| is_clang = false |
| use_clang_coverage = false |
| current_os = "win" |
| current_cpu = toolchain_arch |
| } |
| } |
| } |
| |
| if (defined(invoker.clang_toolchain_prefix)) { |
| clang_toolchain_prefix = invoker.clang_toolchain_prefix |
| } else { |
| clang_toolchain_prefix = "win_clang_" |
| } |
| msvc_toolchain(clang_toolchain_prefix + target_name) { |
| environment = "environment." + toolchain_arch |
| cl = "${_clang_bin_path}/clang-cl${_exe}" |
| _clang_lib_dir = |
| rebase_path("$clang_base_path/lib/clang/$clang_version/lib/windows", |
| root_build_dir) |
| if (host_os == "win") { |
| # And to match the other -libpath flags. |
| _clang_lib_dir = string_replace(_clang_lib_dir, "/", "\\") |
| } |
| |
| sys_include_flags = "${win_toolchain_data.include_flags_imsvc}" |
| if (use_lld) { |
| sys_lib_flags = |
| "-libpath:$_clang_lib_dir ${win_toolchain_data.libpath_lldlink_flags}" |
| |
| # TODO(thakis): Remove once crbug.com/1300005 is fixed |
| assert(toolchain_arch == "x64" || toolchain_arch == "x86" || |
| toolchain_arch == "arm" || toolchain_arch == "arm64", |
| "Only supports x64, x86, arm and arm64 CPUs") |
| if (toolchain_arch == "x64") { |
| sys_lib_flags += " /MACHINE:X64" |
| } else if (toolchain_arch == "x86") { |
| sys_lib_flags += " /MACHINE:X86" |
| } else if (toolchain_arch == "arm") { |
| sys_lib_flags += " /MACHINE:ARM" |
| } else if (toolchain_arch == "arm64") { |
| sys_lib_flags += " /MACHINE:ARM64" |
| } |
| } |
| |
| toolchain_args = { |
| if (defined(invoker.toolchain_args)) { |
| forward_variables_from(invoker.toolchain_args, "*") |
| } |
| is_clang = true |
| current_os = "win" |
| current_cpu = toolchain_arch |
| } |
| } |
| } |
