| # Copyright 2020 The Fuchsia 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/clang/clang.gni") |
| import("//build/config/compiler.gni") |
| import("//build/config/zircon/levels.gni") |
| import("//build/toolchain/breakpad.gni") |
| import("//build/toolchain/ccache.gni") |
| import("//build/toolchain/default_tools.gni") |
| import("//build/toolchain/goma.gni") |
| import("//build/toolchain/rbe.gni") |
| import("//build/toolchain/zircon/clang.gni") |
| import("//build/toolchain/zircon/gcc.gni") |
| import("//build/zircon/build_args.gni") |
| |
| _buildidtool = |
| rebase_path("//prebuilt/tools/buildidtool/${host_platform}/buildidtool", |
| root_build_dir) |
| |
| # IMPORTANT: The zircon_toolchain() template does not use clang_toolchain() |
| # defined in //build/toolchain/clang_toolchain.gni, because there are several |
| # important differences between their tool() commands. A few examples: |
| # |
| # - clang_toolchain() does not support GCC builds. |
| # |
| # - The 'alink' command differs slightly between the build systems: |
| # GN: .../llvm-ar ${arflags} rcsD ${out} @"${out}.rsp" |
| # ZN: .../llvm-ar ${arflags} cqsD ${out} '@${out}.rsp' |
| # |
| # - The response file paths slightly differ: |
| # GN: ${output_dir}/${target_output_name}${output_extension}.rsp |
| # ZN: ${output_dir}/${target_output_name}.rsp |
| # |
| # - Stripping works differently as well, e.g. on host Linux: |
| # GN: .../llvm-objcopy --strip-all <src> <dst> |
| # ZN: .../llvm-strip -o <dst> <src> |
| # |
| # - Many trivial differences, like the position of option like '-o <output>' |
| # or {{cflags}}, {{ldflags}} etc, escaping some paths with quotes in one |
| # build but not the other make comparing final build commands difficult. |
| # |
| # - Static and shared libraries are ordered differently in link inputs: |
| # GN: -Wl,--start-group <inputs> {{solibs}} -Wl,--end-group {{libs}} |
| # ZN: -Wl,--start-group <inputs> {{libs}} -Wl,--end-group {{solibs}} |
| # |
| # - Slightly different flags to specify the link map file: |
| # GN: -Wl,--Map=<file> |
| # ZN: -Wl,-Map=<file> |
| # |
| # - Different naming conventions for debug binaries: |
| # GN: {{output_dir}}/exe.unstripped/{{target_output_name}}{{output_extension}} |
| # ZN: {{output_dir}}/{{target_output_name}}{{output_extension}}.debug |
| # |
| # IMPORTANT: The zircon_toolchain global variable is defined as a scope for |
| # Zircon-specific toolchains, otherwise it is just 'false'. See below for the |
| # detailed schema for this scope. |
| |
| # Defines a Clang-based Zircon toolchain. |
| # |
| # Parameters (same as the ZN build c_toolchain() template): |
| # |
| # cpu, os |
| # Required: $current_cpu and $current_os values for the toolchain. |
| # Type: string |
| # |
| # strip |
| # Optional: If not false, linked binaries will be stripped. |
| # If this is a string rather than true, it's a switch to the `objcopy` |
| # tool, e.g. "--strip-sections". |
| # Type: bool or string |
| # Default: false |
| # |
| # tool_dir, tool_prefix |
| # Optional: If one of these is provided, then both must be provided. |
| # $tool_dir is the directory where compiler tools are found, or "" if they |
| # are found by searching `PATH`. $tool_prefix is the prefix prepended to |
| # each tool's name. If $gcc is true, then $tool_dir defaults to "" if |
| # $host is true and $gcc_tool_dir otherwise. If $gcc is true and $host is |
| # not true or $cpu != $host_cpu or $os != $host_os, then $tool_prefix |
| # defaults to the "<tuple>-" prefix appropriate for $cpu and $os; |
| # otherwise it defaults to "". |
| # Type: string |
| # |
| # use_goma |
| # Optional: If defined, overrides the $use_goma build argument. |
| # If true, compilation commands are prefixed with "$goma_dir/gomacc". |
| # Type: bool |
| # Default: $use_goma |
| # |
| # use_ccache |
| # Optional: If defined, overrides the $use_ccache build argument. |
| # If true, compilation commands are prefixed with "ccache". |
| # Type: bool |
| # Default: $use_ccache |
| # |
| # deps, toolchain_args |
| # Optional: See toolchain(). |
| # |
| # The following parameters are specific to the Fuchsia build and were not |
| # part of the original Zircon build. |
| # |
| # environment |
| # Required: A string describing the runtime environment of the code |
| # generated by this toolchain. This is a label like "kernel" or "multiboot" |
| # that will appear in as `zircon_toolchain.environment` and can be checked |
| # in build rules, as requested by several Zircon artefacts. |
| # |
| # The following parameters from the original Zircon builds are NOT SUPPORTED |
| # and documented here for historical reasons! |
| # |
| # gcc |
| # Optional: If true, this toolchain uses GCC rather than Clang. |
| # This template will instead look for 'gcc' in the list of tags. |
| # Type: bool |
| # Default: false |
| # |
| # host |
| # Optional: If true, this is doing "host" compiles. This only matters |
| # if $os == $host_os and $cpu == $host_cpu, i.e. native compilation for |
| # the build host. In that case, when using GCC, this says to use plain |
| # "gcc" et al rather than "<triple>-gcc" et al. |
| # Type: bool |
| # Default: false |
| # |
| # shlib |
| # Optional: If true, the toolchain will support the "solink" and |
| # "solink_module" (for shared_library() and loadable_module() targets, |
| # respectively). This is now determined by the values of with_shared |
| # and is_pic_default in toolchain_variant. |
| # Type: bool |
| # Default: false |
| # |
| # toolchain_vars |
| # Optional: Additional keys/values to export in the $zircon_toolchain scope. |
| # The $zircon_toolchain global variable is a scope that provides various\ |
| # fields describing how things are done in this toolchain. Several standard |
| # fields are set automatically. This can supply others. |
| # Type: scope |
| # Default: {} |
| # |
| template("zircon_toolchain") { |
| # Translate GN cpu/os to GNU config tuple. |
| if (invoker.cpu == "arm64") { |
| tc_cpu = "aarch64" |
| } else if (invoker.cpu == "x64") { |
| tc_cpu = "x86_64" |
| } else { |
| tc_cpu = invoker.cpu |
| } |
| tc_target = "${tc_cpu}-" |
| if (invoker.os == "mac") { |
| tc_target += "apple-darwin" |
| } else if (invoker.os == "win") { |
| tc_target += "windows-msvc" |
| } else if (invoker.os == "linux") { |
| tc_target += "linux-gnu" |
| } else { |
| tc_target += invoker.os |
| } |
| |
| assert(defined(invoker.environment), "'environment' argument is required!") |
| |
| # Cached and distributed wrappers just go on the front of compiler commands. |
| compiler_prefix = "" |
| if (defined(invoker.cxx_rbe_enable)) { |
| cxx_rbe_enable = invoker.cxx_rbe_enable |
| } |
| if (defined(invoker.use_goma)) { |
| use_goma = invoker.use_goma |
| } |
| if (cxx_rbe_enable) { |
| compiler_prefix = rebase_path(cxx_remote_wrapper, root_build_dir) + " -- " |
| not_needed([ "use_goma" ]) |
| } else if (use_goma) { |
| compiler_prefix = rebase_path(goma_dir, root_build_dir) + "/gomacc" |
| } else { |
| if (defined(invoker.use_ccache)) { |
| use_ccache = invoker.use_ccache |
| } |
| if (use_ccache) { |
| compiler_prefix = "ccache " |
| } |
| } |
| |
| # Compute what will be the value of `toolchain_variant` for this instance. |
| # This is invoker.toolchain_args.toolchain_variant, eventually augmented |
| # by default key values. |
| if (defined(invoker.toolchain_args)) { |
| _t_args = invoker.toolchain_args |
| if (defined(_t_args.toolchain_variant)) { |
| _tv_args = _t_args.toolchain_variant |
| } |
| } |
| _toolchain_variant = { |
| # Default non-list values |
| base = get_label_info(":$target_name", "label_no_toolchain") |
| name = "" |
| suffix = "" |
| is_pic_default = false |
| with_shared = false |
| instrumented = false |
| |
| # Forward values from invoker.toolchain_args.toolchain_variant, if any. |
| if (defined(_tv_args)) { |
| forward_variables_from(_tv_args, "*") |
| } |
| |
| # Create empty lists if they were not forwarded above. |
| if (!defined(configs)) { |
| configs = [] |
| } |
| if (!defined(prefix_configs)) { |
| prefix_configs = [] |
| } |
| if (!defined(remove_common_configs)) { |
| remove_common_configs = [] |
| } |
| if (!defined(remove_shared_configs)) { |
| remove_shared_configs = [] |
| } |
| if (!defined(tags)) { |
| tags = [] |
| } |
| } |
| |
| use_gcc = |
| _toolchain_variant.tags + [ "gcc" ] - [ "gcc" ] != _toolchain_variant.tags |
| |
| use_strip = defined(invoker.strip) && invoker.strip != false |
| |
| # These are used in some, but not all, of the if branches below. |
| if (clang_tool_dir == "") { |
| clangxx_exec_inputs = [] |
| clangxx_exec_command = "clang++" |
| } else { |
| clangxx_exec_inputs = [ "${clang_tool_dir}/clang++" ] |
| clangxx_exec_command = rebase_path(clangxx_exec_inputs[0], root_build_dir) |
| } |
| clangxx_args = [ |
| clangxx_exec_command, |
| "--target=$tc_target", |
| |
| # This affects the multilib selection so that we get the right |
| # libc++.a binary. It's not really proper that we have to encode here |
| # the multilib-affecting switches we presume all configs actually will |
| # use in the toolchain being defined. But since everything in this |
| # codebase (certainly everything we support being compiled by GCC) is |
| # definitely compiled with -fno-exceptions, we can live with it. An |
| # alternative would be to add the lib_dirs in a config() instead and |
| # then somehow tie it to exceptions vs no-exceptions configs, but we |
| # have no present need for any such complexity. |
| "-fno-exceptions", |
| ] |
| not_needed([ "clangxx_args" ]) |
| |
| # If either $tool_dir or $tool_prefix is supplied then both must be supplied. |
| if (defined(invoker.tool_dir) || defined(invoker.tool_prefix)) { |
| tc = { |
| tool_dir = invoker.tool_dir |
| tool_prefix = invoker.tool_prefix |
| } |
| } else if (use_gcc) { |
| if (defined(invoker.host) && invoker.host) { |
| tc = { |
| tool_dir = "" |
| if (invoker.cpu == host_cpu && invoker.os == host_os) { |
| tool_prefix = "" |
| } else { |
| tool_prefix = "${tc_target}-" |
| } |
| } |
| } else { |
| tc = { |
| tool_dir = gcc_tool_dir |
| tool_prefix = "${tc_cpu}-elf-" |
| version_string = gcc_version_string |
| include_dirs_cc = rebase_path( |
| [ |
| exec_script( |
| "/usr/bin/env", |
| clangxx_args + [ "-print-file-name=include/${current_target_tuple}/c++/v1" ], |
| "trim string", |
| clangxx_exec_inputs), |
| exec_script( |
| "/usr/bin/env", |
| clangxx_args + [ "-print-file-name=include/c++/v1" ], |
| "trim string", |
| clangxx_exec_inputs), |
| ], |
| "", |
| root_build_dir) |
| lib_dirs = [ rebase_path( |
| get_path_info( |
| exec_script("/usr/bin/env", |
| clangxx_args + [ "-print-file-name=libc++.a" ], |
| "trim string", |
| clangxx_exec_inputs), |
| "dir"), |
| "", |
| root_build_dir) ] |
| } |
| } |
| } else { |
| tc = { |
| tool_dir = clang_tool_dir |
| tool_prefix = "llvm-" |
| version_string = clang_version_string |
| |
| # TODO(fxbug.dev/27328): The MSVC target in the clang driver never uses the |
| # -stdlib=libc++ switch or the toolchain's own libc++ include path. |
| if (invoker.os == "win") { |
| include_dirs_cc = rebase_path( |
| [ |
| exec_script( |
| "/usr/bin/env", |
| clangxx_args + [ "-print-file-name=include/${current_target_tuple}/c++/v1" ], |
| "trim string", |
| clangxx_exec_inputs), |
| exec_script( |
| "/usr/bin/env", |
| clangxx_args + [ "-print-file-name=include/c++/v1" ], |
| "trim string", |
| clangxx_exec_inputs), |
| ], |
| "", |
| root_build_dir) |
| } |
| } |
| } |
| |
| if (use_gcc) { |
| tc.cc = "${tc.tool_prefix}gcc" |
| tc.cxx = "${tc.tool_prefix}g++" |
| } else { |
| tc.cc = "clang" |
| tc.cxx = "clang++" |
| } |
| |
| if (tc.tool_dir == "") { |
| dir_prefix = "" |
| if (use_goma) { |
| # GOMA requires an absolute path to the compiler. |
| compiler_prefix = "" |
| } |
| } else { |
| dir_prefix = rebase_path(tc.tool_dir, root_build_dir) + "/" |
| } |
| |
| cc = "$dir_prefix${tc.cc}" |
| cxx = "$dir_prefix${tc.cxx}" |
| ld = cxx |
| ar = "$dir_prefix${tc.tool_prefix}ar" |
| |
| # All other OS possibilities are ELF and so might have ELF build IDs. |
| is_elf = invoker.os != "mac" && invoker.os != "win" |
| |
| # buildidtool supports ELF build IDs and PE-COFF PDB GUIDs. |
| # TODO(mcgrathr): broken for aarch64 PE-COFF |
| use_buildidtool = is_elf || (invoker.os == "win" && invoker.cpu != "arm64") |
| |
| # The prebuilt dump_syms tool is the one that only supports ELF. |
| # Breakpad has dump_syms tools for Mach-O (macOS) and PE-COFF |
| # (Windows/EFI) too, but the PE-COFF tool only runs on Windows. The |
| # Mach-O tool can be cross compiled, though we can't cross compile to |
| # macOS anyway. But we also don't have a prebuilt of the macOS |
| # self-targetting Breakpad dump_syms tool on hand. |
| use_breakpad = output_breakpad_syms && is_elf && use_buildidtool |
| if (use_breakpad) { |
| dump_syms = breakpad_dump_syms |
| dump_syms += " -r " |
| if (invoker.os == "fuchsia") { |
| dump_syms += " -n \"<_>\" -o Fuchsia" |
| } else { |
| # Use what's probably installation name, not the ".debug" name. |
| dump_syms += |
| " -n \"{{output_dir}}/{{target_output_name}}{{output_extension}}\"" |
| } |
| } |
| |
| # TODO(fxbug.dev/58294): enable for other targets and binary formats. |
| use_gsym = output_gsym && is_elf && invoker.os == "fuchsia" |
| if (use_gsym) { |
| gsymutil = rebase_path("$clang_tool_dir/llvm-gsymutil", root_build_dir) |
| } |
| |
| _compile_common = { |
| outputs = |
| [ "{{source_out_dir}}/{{target_output_name}}.{{source_file_part}}.o" ] |
| depfile = "{{output}}.d" |
| depsformat = "gcc" |
| switches = "-MD -MF $depfile -o {{output}} {{defines}} {{include_dirs}}" |
| } |
| |
| _link_common = { |
| lib_switch = "-l" |
| lib_dir_switch = "-L" |
| default_output_dir = "{{target_out_dir}}" |
| outfile = "{{output_dir}}/{{target_output_name}}{{output_extension}}" |
| runtime_outputs = [ outfile ] |
| outputs = runtime_outputs |
| |
| if (use_strip) { |
| unstripped_outfile = "${outfile}.debug" |
| outputs += [ unstripped_outfile ] |
| strip_command = " && " |
| |
| _strip = invoker.strip |
| if (use_gcc && _strip == "--strip-sections") { |
| # GNU strip/objcopy doesn't support --strip-sections. |
| _strip = true |
| } |
| |
| if (_strip == true) { |
| if (invoker.os == "mac") { |
| # Only the host native tool works on macOS. |
| strip_tool = "strip" |
| } else { |
| strip_tool = "$dir_prefix${tc.tool_prefix}strip" |
| } |
| strip_command += "$strip_tool -o \"$outfile\" \"$unstripped_outfile\"" |
| } else { |
| strip_command += "$dir_prefix${tc.tool_prefix}objcopy ${_strip}" + |
| " \"$unstripped_outfile\" \"$outfile\"" |
| } |
| } else { |
| unstripped_outfile = outfile |
| strip_command = "" |
| } |
| |
| rspfile = "${outfile}.rsp" |
| switches = "-o $unstripped_outfile {{ldflags}}" |
| if (invoker.os == "mac") { |
| rspfile_content = "{{inputs_newline}}" |
| link_inputs = "-Wl,-filelist,$rspfile {{libs}} {{solibs}}" |
| } else { |
| rspfile_content = "{{inputs}}" |
| link_inputs = "'@$rspfile'" |
| if (invoker.os == "win") { |
| link_inputs += " {{libs}} {{solibs}}" |
| } else { |
| link_inputs = "-Wl,--start-group " + link_inputs + |
| " {{libs}} -Wl,--end-group {{solibs}}" |
| depfile = "$outfile.d" |
| depsformat = "gcc" |
| switches += " -Wl,--dependency-file=$depfile" |
| mapfile = "${outfile}.map" |
| outputs += [ mapfile ] |
| switches += " -Wl,-Map,$mapfile" |
| } |
| } |
| |
| if (invoker.os == "win") { |
| # This assumes "-Wl,/debug" or suchlike is in ldflags. If it's not |
| # but nothing depends on the .pdb file, then it should be OK that |
| # Ninja thinks it's an additional output but it doesn't get created. |
| debug_outfile = "{{output_dir}}/{{target_output_name}}.pdb" |
| outputs += [ debug_outfile ] |
| } |
| |
| if (use_buildidtool) { |
| if (!defined(debug_outfile)) { |
| debug_outfile = unstripped_outfile |
| } |
| buildid_stampfile = "${outfile}.build-id.stamp" |
| strip_command += " && $_buildidtool -build-id-dir \".build-id\"" + |
| " -stamp \"$buildid_stampfile\"" + |
| " -entry \"=$outfile\" -entry \".debug=$debug_outfile\"" |
| outputs += [ buildid_stampfile ] |
| } |
| |
| if (use_breakpad) { |
| breakpad_outfile = "${outfile}.sym" |
| outputs += [ breakpad_outfile ] |
| |
| # dump_syms will fail if there is no build ID. buildidtool succeeds and |
| # writes an empty stamp file for that case, so use it to tell whether |
| # dump_syms should be run. In any case always create a .sym because we |
| # told ninja we would create one above. |
| assert(use_buildidtool) |
| strip_command += |
| " && { " + # The brace group is superfluous. |
| "test ! -s \"$buildid_stampfile\" && " + |
| "touch \"$breakpad_outfile\" || " + |
| "$dump_syms \"$unstripped_outfile\" > \"$breakpad_outfile\"" + |
| "; }" # But makes the control flow a little clearer. |
| } |
| |
| if (use_gsym) { |
| gsym_outfile = "${outfile}.gsym" |
| outputs += [ gsym_outfile ] |
| strip_command += " && $gsymutil --convert=\"$unstripped_outfile\" --out-file=\"$gsym_outfile.gsym\"" |
| } |
| } |
| |
| not_needed(invoker, [ "propagates_configs" ]) |
| |
| toolchain(target_name) { |
| propagates_configs = true |
| |
| forward_variables_from(invoker, [ "deps" ]) |
| |
| # Every toolchain needs the standard stamp and copy tools. |
| tool("stamp") { |
| command = stamp_command |
| description = stamp_description |
| } |
| |
| tool("copy") { |
| # We use link instead of copy; the way the "copy" tool is used is |
| # compatible with links since Ninja tracks changes to the source. |
| command = copy_command |
| description = copy_description |
| } |
| |
| tool("asm") { |
| description = "ASM {{output}}" |
| forward_variables_from(_compile_common, "*") |
| command = "$cc $switches {{asmflags}} -c {{source}}" |
| command_launcher = compiler_prefix |
| } |
| |
| tool("cc") { |
| description = "CC {{output}}" |
| forward_variables_from(_compile_common, "*") |
| command = "$cc $switches {{cflags}} {{cflags_c}} -c {{source}}" |
| command_launcher = compiler_prefix |
| } |
| |
| tool("cxx") { |
| description = "CXX {{output}}" |
| forward_variables_from(_compile_common, "*") |
| command = "$cxx $switches {{cflags}} {{cflags_cc}} -c {{source}}" |
| command_launcher = compiler_prefix |
| } |
| |
| tool("alink") { |
| description = "AR {{output}}" |
| rspfile = "{{output}}.rsp" |
| command = |
| "rm -f {{output}} && $ar {{arflags}} cqsD {{output}} '@$rspfile'" |
| rspfile_content = "{{inputs}}" |
| default_output_dir = "{{target_out_dir}}" |
| default_output_extension = ".a" |
| output_prefix = "lib" |
| outputs = [ "{{output_dir}}/{{target_output_name}}{{output_extension}}" ] |
| } |
| |
| tool("link") { |
| forward_variables_from(_link_common, "*") |
| description = "LINK $outfile" |
| if (invoker.os == "win") { |
| default_output_extension = ".exe" |
| } |
| command = "$ld $switches $link_inputs$strip_command" |
| } |
| |
| if (_toolchain_variant.with_shared || _toolchain_variant.is_pic_default) { |
| # We don't support building shared libraries for host tools. |
| assert(invoker.os == "fuchsia", |
| "shared library creation not supported for ${invoker.os}") |
| |
| use_llvm_ifs = is_elf |
| if (use_llvm_ifs) { |
| llvm_ifs = rebase_path("$clang_tool_dir/llvm-ifs", root_build_dir) |
| } |
| |
| solink_common = { |
| forward_variables_from(_link_common, "*") |
| depend_output = outfile |
| link_output = unstripped_outfile |
| } |
| |
| tool("solink") { |
| forward_variables_from(solink_common, "*") |
| |
| description = "LINK_SHLIB $outfile" |
| |
| output_prefix = "lib" |
| if (current_os == "mac") { |
| default_output_extension = ".dylib" |
| } else if (current_os == "win") { |
| default_output_extension = ".dll" |
| } else { |
| default_output_extension = ".so" |
| } |
| |
| # Put the automatic -soname first so that ldflags can override it. |
| soname = "{{target_output_name}}{{output_extension}}" |
| switches = "-shared -Wl,-soname,$soname $switches" |
| if (use_gcc && tc.tool_prefix == "${tc_cpu}-elf-") { |
| # The *-elf-gcc driver doesn't handle -shared properly. |
| # Just force it through to the linker. |
| switches = "-Wl,$switches" |
| } |
| |
| command = "$ld $switches $link_inputs$strip_command" |
| |
| if (use_llvm_ifs) { |
| # The Ninja dependency for linking in the shared library will be |
| # the .ifs file (depend_output), though the actual linking *input* |
| # will be the original .so file (link_output). Ninja will restat |
| # the output files after running the commands. llvm-ifs will |
| # not touch the .ifs file if its contents haven't changed. Hence |
| # Ninja will only re-run any linking commands depending on this |
| # shared library if the .ifs file has actually changed, indicating |
| # that the linking ABI has actually changed. |
| restat = true |
| depend_output = "{{output_dir}}/{{target_output_name}}.ifs" |
| unstripped_output = link_output |
| link_output = "{{output_dir}}/link_stub/{{target_output_name}}.so" |
| outputs += [ |
| depend_output, |
| link_output, |
| ] |
| command += " && $llvm_ifs --write-if-changed --output-ifs=$depend_output --output-elf=$link_output $unstripped_output" |
| } |
| } |
| |
| tool("solink_module") { |
| forward_variables_from(solink_common, "*") |
| |
| description = "LINK_MODULE $outfile" |
| |
| if (current_os == "mac") { |
| default_output_extension = ".dylib" |
| } else if (current_os == "win") { |
| default_output_extension = ".dll" |
| } else { |
| default_output_extension = ".so" |
| } |
| |
| switches = "-shared $switches" |
| if (use_gcc && tc.tool_prefix == "${tc_cpu}-elf-") { |
| # The *-elf-gcc driver doesn't handle -shared properly. |
| # Just force it through to the linker. |
| switches = "-Wl,$switches" |
| } |
| |
| command = "$ld $switches $link_inputs$strip_command" |
| } |
| } |
| |
| # IMPORTANT: The toolchain_args variables in the Fuchsia and Zircon builds |
| # are very distinct. |
| |
| _zircon_optimize = zircon_optimize |
| if (optimize == "sanitizer" || optimize == "profile") { |
| _zircon_optimize = optimize |
| } |
| |
| toolchain_args = { |
| current_cpu = invoker.cpu |
| current_os = invoker.os |
| |
| optimize = _zircon_optimize |
| |
| if (defined(invoker.toolchain_args)) { |
| forward_variables_from(invoker.toolchain_args, |
| "*", |
| [ |
| "cpu", |
| "os", |
| "toolchain_variant", |
| ]) |
| } |
| |
| # toolchain_variant is specific to the Fuchsia build, and documented in |
| # //build/config/BUILDCONFIG.gn. |
| toolchain_variant = { |
| } |
| toolchain_variant = _toolchain_variant |
| |
| # 'zircon_toolchain' is a scope that will only be defined for Zircon |
| # toolchains, as a scope holding various keys used by misc targets to |
| # select build settings. This corresponds to the Zircon build |
| # 'toolchain' global toolchain variable, as well as a few Zircon global |
| # variables that have been moved here: |
| # |
| # cpu: [string] Target CPU using Clang conventions. |
| # target_tuple: [string] Target tuple using Clang conventions. |
| # environment: [string] The runtime environment that the binaries |
| # generated by this toolchain instance will run in. Used by the |
| # Zircon build rules in several places. |
| # link_output_suffix: [string] Suffix to append to linkable binaries |
| # with debug information. |
| # |
| # include_dirs_cc: [list of paths] |
| # Supported to add `-isystem <dir>` switches to C++ compilations. |
| # This locates C++ toolchain headers when the compiler driver doesn't |
| # use them by default (GCC and EFI). |
| # |
| # lib_dirs: [list of paths] |
| # Supported to add standard library search directories. This locates |
| # C++ toolchain libraries when the compiler driver doesn't use them |
| # by default (GCC). |
| # |
| zircon_toolchain = { |
| } |
| zircon_toolchain = { |
| # This gets `tool_dir` et al as expected by c_utils.gni (set above). |
| forward_variables_from(tc, "*") |
| |
| cpu = tc_cpu |
| target_tuple = tc_target |
| environment = invoker.environment |
| |
| # This is used in setting metadata.link_output. |
| if (use_strip) { |
| link_output_suffix = ".debug" |
| } else { |
| link_output_suffix = "" |
| } |
| |
| if (!defined(include_dirs_cc)) { |
| include_dirs_cc = [] |
| } |
| |
| if (!defined(lib_dirs)) { |
| lib_dirs = [] |
| } |
| } |
| } |
| } |
| } |
