0266c8a4e6
This lets it be something other than cxx,
e.g. to compile with Goma but to link with the NDK locally,
declare_args() {
home = getenv("HOME")
use_goma = true
_target = "aarch64-linux-android21"
}
ndk = "$home/ndk"
extra_asmflags = []
extra_cflags = []
extra_ldflags = []
if (use_goma) {
cc = "$home/chromium/src/third_party/llvm-build/Release+Asserts/bin/clang"
cxx = "$home/chromium/src/third_party/llvm-build/Release+Asserts/bin/clang++"
cc_wrapper = "$home/depot_tools/.cipd_bin/gomacc"
target_cc = cc
target_cxx = cxx
target_link = "$ndk/toolchains/llvm/prebuilt/darwin-x86_64/bin/clang++ --target=$_target"
extra_asmflags += [ "--target=$_target" ]
extra_cflags += [ "--target=$_target" ]
} else {
cc_wrapper = "ccache"
}
is_debug = true
if (is_debug) {
extra_cflags += [ "-Os" ]
}
Change-Id: I17b9c3f72bc308e40c1565536d04d0673efd4ef1
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/332616
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Mike Klein <mtklein@google.com>
422 lines
13 KiB
Plaintext
422 lines
13 KiB
Plaintext
if (is_fuchsia) {
|
|
import("//build/fuchsia/sdk.gni")
|
|
}
|
|
|
|
declare_args() {
|
|
host_ar = ar
|
|
host_cc = cc
|
|
host_cxx = cxx
|
|
|
|
if (is_android) {
|
|
_prefix = "$ndk/toolchains/llvm/prebuilt/$ndk_host/bin"
|
|
if (host_os == "win") {
|
|
target_ar = "$_prefix/llvm-ar.exe"
|
|
target_cc = "$_prefix/clang.exe --target=$ndk_target$ndk_api -fno-addrsig"
|
|
target_cxx =
|
|
"$_prefix/clang++.exe --target=$ndk_target$ndk_api -fno-addrsig"
|
|
} else {
|
|
target_ar = "$_prefix/llvm-ar"
|
|
target_cc = "$_prefix/$ndk_target$ndk_api-clang"
|
|
target_cxx = "$_prefix/$ndk_target$ndk_api-clang++"
|
|
}
|
|
} else if (is_fuchsia && using_fuchsia_sdk) {
|
|
target_ar = rebase_path("$fuchsia_toolchain_path/bin/llvm-ar")
|
|
target_cc = rebase_path("$fuchsia_toolchain_path/bin/clang")
|
|
target_cxx = rebase_path("$fuchsia_toolchain_path/bin/clang++")
|
|
cflags = "--sysroot=" +
|
|
rebase_path("$fuchsia_toolchain_path/$target_cpu/sysroot")
|
|
link = rebase_path("$fuchsia_toolchain_path/bin/ld.lld")
|
|
} else {
|
|
target_ar = ar
|
|
target_cc = cc
|
|
target_cxx = cxx
|
|
}
|
|
|
|
cc_wrapper = ""
|
|
|
|
# dsymutil seems to kill the machine when too many processes are run in
|
|
# parallel, so we need to use a pool to limit the concurrency when passing
|
|
# large -j to Ninja (e.g. Goma build). Unfortunately this is also one of the
|
|
# slowest steps in a build, so we don't want to limit too much. Use the number
|
|
# of CPUs as a default.
|
|
dlsymutil_pool_depth = exec_script("num_cpus.py", [], "value")
|
|
|
|
# Too many linkers running at once causes issues for some builders. Allow
|
|
# such builders to limit the number of concurrent link steps.
|
|
# link_pool_depth < 0 means no pool, 0 means cpu count, > 0 sets pool size.
|
|
link_pool_depth = -1
|
|
}
|
|
|
|
declare_args() {
|
|
host_link = host_cxx
|
|
target_link = target_cxx
|
|
}
|
|
|
|
# For 'shell' see https://ninja-build.org/manual.html#ref_rule_command
|
|
if (host_os == "win") {
|
|
shell = "cmd.exe /c "
|
|
stamp = "$shell echo >"
|
|
} else {
|
|
shell = ""
|
|
stamp = "touch"
|
|
}
|
|
|
|
if (current_toolchain == default_toolchain) {
|
|
pool("dsymutil_pool") {
|
|
depth = dlsymutil_pool_depth
|
|
}
|
|
if (0 <= link_pool_depth) {
|
|
pool("link_pool") {
|
|
if (link_pool_depth == 0) {
|
|
depth = exec_script("num_cpus.py", [], "value")
|
|
} else {
|
|
depth = link_pool_depth
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
toolchain("msvc") {
|
|
lib_switch = ""
|
|
lib_dir_switch = "/LIBPATH:"
|
|
|
|
bin = "$win_vc/Tools/MSVC/$win_toolchain_version/bin/HostX64/$target_cpu"
|
|
|
|
env_setup = ""
|
|
if (target_cpu == "x86") {
|
|
# Toolchain asset includes a script that configures for x86 building.
|
|
# We don't support x86 builds with local MSVC installations.
|
|
env_setup = "$shell $win_sdk/bin/SetEnv.cmd /x86 && "
|
|
} else if (target_cpu == "arm64") {
|
|
# ARM64 compiler is incomplete - it relies on DLLs located in the host toolchain directory.
|
|
env_setup = "$shell set \"PATH=%PATH%;$win_vc\\Tools\\MSVC\\$win_toolchain_version\\bin\\HostX64\\x64\" && "
|
|
}
|
|
|
|
cl_m32_flag = ""
|
|
|
|
if (clang_win != "") {
|
|
if (target_cpu == "x86") {
|
|
# cl.exe knows implicitly by the choice of executable that it's targeting
|
|
# x86, but clang-cl.exe needs to be told when targeting non-host
|
|
# platforms. (All our builders are x86-64, so x86 is always non-host.)
|
|
cl_m32_flag = "-m32"
|
|
}
|
|
if (host_os == "win") {
|
|
cl = "\"$clang_win/bin/clang-cl.exe\""
|
|
lib = "\"$clang_win/bin/lld-link.exe\" /lib"
|
|
link = "\"$clang_win/bin/lld-link.exe\""
|
|
} else {
|
|
cl = "\"$clang_win/bin/clang-cl\""
|
|
lib = "\"$clang_win/bin/lld-link\" /lib"
|
|
link = "\"$clang_win/bin/lld-link\""
|
|
}
|
|
} else {
|
|
cl = "\"$bin/cl.exe\""
|
|
lib = "\"$bin/lib.exe\""
|
|
link = "\"$bin/link.exe\""
|
|
}
|
|
|
|
tool("asm") {
|
|
_ml = "ml"
|
|
if (target_cpu == "x64") {
|
|
_ml += "64"
|
|
}
|
|
command = "$env_setup \"$bin/$_ml.exe\" {{asmflags}} /nologo /c /Fo {{output}} {{source}}"
|
|
outputs =
|
|
[ "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.obj" ]
|
|
description = "assemble {{source}}"
|
|
}
|
|
|
|
tool("cc") {
|
|
precompiled_header_type = "msvc"
|
|
pdbname = "{{target_out_dir}}/{{label_name}}_c.pdb"
|
|
|
|
# Label names may have spaces so pdbname must be quoted.
|
|
command = "$env_setup $cc_wrapper $cl /nologo /showIncludes /FC {{defines}} {{include_dirs}} {{cflags}} $cl_m32_flag {{cflags_c}} /c {{source}} /Fo{{output}} /Fd\"$pdbname\""
|
|
depsformat = "msvc"
|
|
outputs =
|
|
[ "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.obj" ]
|
|
description = "compile {{source}}"
|
|
}
|
|
|
|
tool("cxx") {
|
|
precompiled_header_type = "msvc"
|
|
pdbname = "{{target_out_dir}}/{{label_name}}_c.pdb"
|
|
|
|
# Label names may have spaces so pdbname must be quoted.
|
|
command = "$env_setup $cc_wrapper $cl /nologo /showIncludes /FC {{defines}} {{include_dirs}} {{cflags}} $cl_m32_flag {{cflags_cc}} /c {{source}} /Fo{{output}} /Fd\"$pdbname\""
|
|
depsformat = "msvc"
|
|
outputs =
|
|
[ "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.obj" ]
|
|
description = "compile {{source}}"
|
|
}
|
|
|
|
tool("alink") {
|
|
rspfile = "{{output}}.rsp"
|
|
|
|
command = "$env_setup $lib /nologo /ignore:4221 {{arflags}} /OUT:{{output}} @$rspfile"
|
|
outputs = [
|
|
# Ignore {{output_extension}} and always use .lib, there's no reason to
|
|
# allow targets to override this extension on Windows.
|
|
"{{root_out_dir}}/{{target_output_name}}{{output_extension}}",
|
|
]
|
|
default_output_extension = ".lib"
|
|
default_output_dir = "{{target_out_dir}}"
|
|
|
|
# inputs_newline works around a fixed per-line buffer size in the linker.
|
|
rspfile_content = "{{inputs_newline}}"
|
|
description = "link {{output}}"
|
|
if (0 <= link_pool_depth) {
|
|
pool = ":link_pool($default_toolchain)"
|
|
}
|
|
}
|
|
|
|
tool("solink") {
|
|
dllname = "{{output_dir}}/{{target_output_name}}{{output_extension}}"
|
|
libname = "${dllname}.lib"
|
|
pdbname = "${dllname}.pdb"
|
|
rspfile = "${dllname}.rsp"
|
|
|
|
command = "$env_setup $link /nologo /IMPLIB:$libname /DLL /OUT:$dllname /PDB:$pdbname @$rspfile"
|
|
outputs = [
|
|
dllname,
|
|
libname,
|
|
pdbname,
|
|
]
|
|
default_output_extension = ".dll"
|
|
default_output_dir = "{{root_out_dir}}"
|
|
|
|
link_output = libname
|
|
depend_output = libname
|
|
runtime_outputs = [
|
|
dllname,
|
|
pdbname,
|
|
]
|
|
|
|
# I don't quite understand this. Aping Chrome's toolchain/win/BUILD.gn.
|
|
restat = true
|
|
|
|
# inputs_newline works around a fixed per-line buffer size in the linker.
|
|
rspfile_content = "{{inputs_newline}} {{libs}} {{solibs}} {{ldflags}}"
|
|
description = "link {{output}}"
|
|
if (0 <= link_pool_depth) {
|
|
pool = ":link_pool($default_toolchain)"
|
|
}
|
|
}
|
|
|
|
tool("link") {
|
|
exename = "{{root_out_dir}}/{{target_output_name}}{{output_extension}}"
|
|
pdbname = "$exename.pdb"
|
|
rspfile = "$exename.rsp"
|
|
|
|
command = "$env_setup $link /nologo /OUT:$exename /PDB:$pdbname @$rspfile"
|
|
default_output_extension = ".exe"
|
|
default_output_dir = "{{root_out_dir}}"
|
|
outputs = [ exename ]
|
|
|
|
# inputs_newline works around a fixed per-line buffer size in the linker.
|
|
rspfile_content = "{{inputs_newline}} {{libs}} {{solibs}} {{ldflags}}"
|
|
description = "link {{output}}"
|
|
if (0 <= link_pool_depth) {
|
|
pool = ":link_pool($default_toolchain)"
|
|
}
|
|
}
|
|
|
|
tool("stamp") {
|
|
command = "$stamp {{output}}"
|
|
description = "stamp {{output}}"
|
|
}
|
|
|
|
tool("copy") {
|
|
cp_py = rebase_path("../cp.py")
|
|
command = "$shell python \"$cp_py\" {{source}} {{output}}"
|
|
description = "copy {{source}} {{output}}"
|
|
}
|
|
}
|
|
|
|
template("gcc_like_toolchain") {
|
|
toolchain(target_name) {
|
|
ar = invoker.ar
|
|
cc = invoker.cc
|
|
cxx = invoker.cxx
|
|
link = invoker.link
|
|
lib_switch = "-l"
|
|
lib_dir_switch = "-L"
|
|
|
|
tool("cc") {
|
|
depfile = "{{output}}.d"
|
|
command = "$cc_wrapper $cc -MD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} -c {{source}} -o {{output}}"
|
|
depsformat = "gcc"
|
|
outputs =
|
|
[ "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o" ]
|
|
description = "compile {{source}}"
|
|
}
|
|
|
|
tool("cxx") {
|
|
depfile = "{{output}}.d"
|
|
command = "$cc_wrapper $cxx -MD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}} -c {{source}} -o {{output}}"
|
|
depsformat = "gcc"
|
|
outputs =
|
|
[ "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o" ]
|
|
description = "compile {{source}}"
|
|
}
|
|
|
|
tool("objc") {
|
|
depfile = "{{output}}.d"
|
|
command = "$cc_wrapper $cc -MD -MF $depfile {{defines}} {{include_dirs}} {{framework_dirs}} {{cflags}} {{cflags_objc}} -c {{source}} -o {{output}}"
|
|
depsformat = "gcc"
|
|
outputs =
|
|
[ "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o" ]
|
|
description = "compile {{source}}"
|
|
}
|
|
|
|
tool("objcxx") {
|
|
depfile = "{{output}}.d"
|
|
command = "$cc_wrapper $cxx -MD -MF $depfile {{defines}} {{include_dirs}} {{framework_dirs}} {{cflags}} {{cflags_cc}} {{cflags_objcc}} -c {{source}} -o {{output}}"
|
|
depsformat = "gcc"
|
|
outputs =
|
|
[ "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o" ]
|
|
description = "compile {{source}}"
|
|
}
|
|
|
|
tool("asm") {
|
|
depfile = "{{output}}.d"
|
|
command = "$cc_wrapper $cc -MD -MF $depfile {{defines}} {{include_dirs}} {{asmflags}} -c {{source}} -o {{output}}"
|
|
depsformat = "gcc"
|
|
outputs =
|
|
[ "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o" ]
|
|
description = "assemble {{source}}"
|
|
}
|
|
|
|
if (is_mac || is_ios) {
|
|
not_needed([ "ar" ]) # We use libtool instead.
|
|
}
|
|
|
|
tool("alink") {
|
|
if (is_mac || is_ios) {
|
|
command = "libtool -static -o {{output}} -no_warning_for_no_symbols {{inputs}}"
|
|
} else {
|
|
rspfile = "{{output}}.rsp"
|
|
rspfile_content = "{{inputs}}"
|
|
rm_py = rebase_path("../rm.py")
|
|
command = "$shell python \"$rm_py\" \"{{output}}\" && $ar rcs {{output}} @$rspfile"
|
|
}
|
|
|
|
outputs =
|
|
[ "{{root_out_dir}}/{{target_output_name}}{{output_extension}}" ]
|
|
default_output_extension = ".a"
|
|
output_prefix = "lib"
|
|
description = "link {{output}}"
|
|
if (0 <= link_pool_depth) {
|
|
pool = ":link_pool($default_toolchain)"
|
|
}
|
|
}
|
|
|
|
tool("solink") {
|
|
soname = "{{target_output_name}}{{output_extension}}"
|
|
|
|
rpath = "-Wl,-soname,$soname"
|
|
if (is_mac || is_ios) {
|
|
rpath = "-Wl,-install_name,@rpath/$soname"
|
|
}
|
|
|
|
rspfile = "{{output}}.rsp"
|
|
rspfile_content = "{{inputs}}"
|
|
|
|
# --start-group/--end-group let us link multiple .a {{inputs}}
|
|
# without worrying about their relative order on the link line.
|
|
#
|
|
# This is mostly important for traditional linkers like GNU ld and Gold.
|
|
# The Mac/iOS linker neither needs nor accepts these flags.
|
|
# LLD doesn't need these flags, but accepts and ignores them.
|
|
_start_group = "-Wl,--start-group"
|
|
_end_group = "-Wl,--end-group"
|
|
if (is_mac || is_ios || is_fuchsia) {
|
|
_start_group = ""
|
|
_end_group = ""
|
|
}
|
|
|
|
command = "$link -shared {{ldflags}} $_start_group @$rspfile {{frameworks}} {{solibs}} $_end_group {{libs}} $rpath -o {{output}}"
|
|
outputs = [ "{{root_out_dir}}/$soname" ]
|
|
output_prefix = "lib"
|
|
default_output_extension = ".so"
|
|
description = "link {{output}}"
|
|
if (0 <= link_pool_depth) {
|
|
pool = ":link_pool($default_toolchain)"
|
|
}
|
|
}
|
|
|
|
tool("link") {
|
|
exe_name = "{{root_out_dir}}/{{target_output_name}}{{output_extension}}"
|
|
rspfile = "$exe_name.rsp"
|
|
rspfile_content = "{{inputs}}"
|
|
|
|
# --start-group/--end-group let us link multiple .a {{inputs}}
|
|
# without worrying about their relative order on the link line.
|
|
#
|
|
# This is mostly important for traditional linkers like GNU ld and Gold.
|
|
# The Mac/iOS linker neither needs nor accepts these flags.
|
|
# LLD doesn't need these flags, but accepts and ignores them.
|
|
_start_group = "-Wl,--start-group"
|
|
_end_group = "-Wl,--end-group"
|
|
if (is_mac || is_ios || is_fuchsia) {
|
|
_start_group = ""
|
|
_end_group = ""
|
|
}
|
|
command = "$link {{ldflags}} $_start_group @$rspfile {{frameworks}} {{solibs}} $_end_group {{libs}} -o $exe_name"
|
|
|
|
outputs = [ "$exe_name" ]
|
|
description = "link {{output}}"
|
|
if (0 <= link_pool_depth) {
|
|
pool = ":link_pool($default_toolchain)"
|
|
}
|
|
}
|
|
|
|
tool("stamp") {
|
|
command = "$stamp {{output}}"
|
|
description = "stamp {{output}}"
|
|
}
|
|
|
|
tool("copy") {
|
|
cp_py = rebase_path("../cp.py")
|
|
command = "python \"$cp_py\" {{source}} {{output}}"
|
|
description = "copy {{source}} {{output}}"
|
|
}
|
|
|
|
tool("copy_bundle_data") {
|
|
cp_py = rebase_path("../cp.py")
|
|
command = "python \"$cp_py\" {{source}} {{output}}"
|
|
description = "copy_bundle_data {{source}} {{output}}"
|
|
}
|
|
|
|
# We don't currently have any xcasset files so make this a NOP
|
|
tool("compile_xcassets") {
|
|
command = "true"
|
|
description = "compile_xcassets {{output}}"
|
|
}
|
|
|
|
toolchain_args = {
|
|
current_cpu = invoker.cpu
|
|
current_os = invoker.os
|
|
}
|
|
}
|
|
}
|
|
|
|
gcc_like_toolchain("gcc_like") {
|
|
cpu = current_cpu
|
|
os = current_os
|
|
ar = target_ar
|
|
cc = target_cc
|
|
cxx = target_cxx
|
|
link = target_link
|
|
}
|
|
|
|
gcc_like_toolchain("gcc_like_host") {
|
|
cpu = host_cpu
|
|
os = host_os
|
|
ar = host_ar
|
|
cc = host_cc
|
|
cxx = host_cxx
|
|
link = host_link
|
|
}
|