mirror of
https://github.com/klzgrad/naiveproxy.git
synced 2024-11-24 06:16:30 +03:00
403 lines
13 KiB
Plaintext
403 lines
13 KiB
Plaintext
# Copyright 2015 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/config/nacl/config.gni")
|
|
import("//build/config/nacl/rules.gni")
|
|
import("//components/nacl/features.gni")
|
|
|
|
assert(enable_nacl)
|
|
|
|
if (current_cpu == "pnacl") {
|
|
if (is_nacl_nonsfi) {
|
|
nacl_toolchain_variant = "nonsfi"
|
|
} else {
|
|
nacl_toolchain_variant = "pnacl"
|
|
}
|
|
} else if (is_nacl_glibc) {
|
|
nacl_toolchain_variant = "glibc"
|
|
} else {
|
|
nacl_toolchain_variant = "newlib"
|
|
}
|
|
|
|
# Assemble data for Native Client based test
|
|
#
|
|
# Build a Native Client based test, including any additional support files
|
|
# and copy them over to a toolchain-specific target directory.
|
|
#
|
|
# Variables:
|
|
# output_name: name of the ouput file other than the default
|
|
# sources: source files for a target
|
|
# generate_nmf: whether to generate a manifest (default true)
|
|
# pretranslate_pexe: whether to pre-translate pexe to nexe during build
|
|
# (default true for Non-SFI, otherwise false)
|
|
# nonstable_pexe: use non-finalized pexe (default false)
|
|
# debug_pexe: copy both non-finalized and finalized pexe (default false)
|
|
# destination_dir: the output directory relative to the $root_build_dir,
|
|
# if ommitted the output directory is $root_build_dir and the manifest
|
|
# will be suffixed with the name of the toolchain (optional)
|
|
# test_files: additional test files to copy to $destination_dir (optional)
|
|
# nmfflags: additional flags for the nmf generator (optional)
|
|
template("nacl_test_data") {
|
|
assert(defined(invoker.sources))
|
|
forward_variables_from(invoker, [ "destination_dir" ])
|
|
|
|
if (defined(invoker.output_name)) {
|
|
output_name = invoker.output_name
|
|
} else {
|
|
output_name = target_name
|
|
}
|
|
|
|
if (current_cpu == "x64") {
|
|
nmf_cpu = "x86_64"
|
|
} else if (current_cpu == "x86") {
|
|
nmf_cpu = "x86_32"
|
|
} else {
|
|
nmf_cpu = current_cpu
|
|
}
|
|
|
|
if (current_cpu == "pnacl") {
|
|
if (defined(invoker.pretranslate_pexe)) {
|
|
pretranslate_pexe = invoker.pretranslate_pexe
|
|
} else {
|
|
pretranslate_pexe = is_nacl_nonsfi
|
|
}
|
|
} else {
|
|
pretranslate_pexe = false
|
|
}
|
|
|
|
# Note this can't test "is_win" because it's evaluated in the NaCl
|
|
# toolchain context where is_win==false because current_os=="nacl".
|
|
# It tests target_cpu rather than current_cpu because it's also
|
|
# needed in the current_cpu=="pnacl" && pretranslate_pexe case.
|
|
if (target_os == "win" && target_cpu == "x86" && !is_nacl_nonsfi &&
|
|
(current_cpu == "x86" || pretranslate_pexe)) {
|
|
# x86 Windows builds of Chrome run on both x86 Windows and x64
|
|
# Windows. On x64 Windows, only x64 NaCl is supported, so those
|
|
# tests are needed too.
|
|
extra_tc_cpu = "x64"
|
|
if (current_cpu == "x86") {
|
|
extra_nmf_cpu = "x86_64"
|
|
}
|
|
}
|
|
|
|
if (is_nacl_glibc) {
|
|
suffix = "glibc_${nmf_cpu}"
|
|
if (defined(extra_nmf_cpu)) {
|
|
extra_suffix = "glibc_${extra_nmf_cpu}"
|
|
glibc_tc = "//build/toolchain/nacl:glibc"
|
|
assert(current_toolchain == "${glibc_tc}_${current_cpu}")
|
|
extra_toolchain = "${glibc_tc}_${extra_tc_cpu}"
|
|
}
|
|
} else {
|
|
suffix = "newlib_${nmf_cpu}"
|
|
if (defined(extra_nmf_cpu)) {
|
|
extra_suffix = "newlib_${extra_nmf_cpu}"
|
|
newlib_tc = "//build/toolchain/nacl:clang_newlib"
|
|
assert(current_toolchain == "${newlib_tc}_${current_cpu}")
|
|
extra_toolchain = "${newlib_tc}_${extra_tc_cpu}"
|
|
}
|
|
}
|
|
suffixed_output_name = "${output_name}_${suffix}"
|
|
if (defined(extra_nmf_cpu)) {
|
|
extra_suffixed_output_name = "${output_name}_${extra_suffix}"
|
|
}
|
|
if (pretranslate_pexe) {
|
|
pexe_translate_target_name = target_name + "_translate_pexe_"
|
|
if (defined(extra_tc_cpu)) {
|
|
# There will be an extra pretranslation done below for the
|
|
# extra CPU (i.e. for x64 on x86 Windows).
|
|
extra_pexe_translate_target_name =
|
|
pexe_translate_target_name + extra_tc_cpu
|
|
}
|
|
pexe_translate_target_name += target_cpu
|
|
}
|
|
if (defined(invoker.generate_nmf)) {
|
|
generate_nmf = invoker.generate_nmf
|
|
} else {
|
|
generate_nmf = true
|
|
}
|
|
nexe_target_name = target_name + "_nexe"
|
|
nexe_copy_target_name = target_name + "_copy_nexe"
|
|
if (current_cpu == "pnacl" && !is_nacl_nonsfi) {
|
|
if (defined(invoker.debug_pexe) && invoker.debug_pexe) {
|
|
pexe_copy_debug_target_name = target_name + "_copy_pexe_debug"
|
|
}
|
|
}
|
|
if (generate_nmf) {
|
|
nmf_target_name = target_name + "_nmf"
|
|
}
|
|
if (defined(invoker.test_files)) {
|
|
test_files_target_name = target_name + "_test_files"
|
|
}
|
|
final_target_name = target_name
|
|
|
|
# When the destination_dir is specified, the build artifacts end up
|
|
# in the that directory and the manifest is the same as the target name.
|
|
# When the destination_dir is not specified, the artifacts end up
|
|
# in the root build directory and the manifests are suffixed to ensure
|
|
# they do not overlap in case when we build the same test using multiple
|
|
# different toolchains.
|
|
if (defined(invoker.destination_dir)) {
|
|
target_dir =
|
|
"${root_build_dir}/${destination_dir}/${nacl_toolchain_variant}"
|
|
if (generate_nmf) {
|
|
nmf_name = output_name
|
|
}
|
|
} else {
|
|
target_dir = root_build_dir
|
|
if (generate_nmf) {
|
|
if (is_nacl_nonsfi) {
|
|
nacl_toolchain_name = "pnacl_${nacl_toolchain_variant}"
|
|
} else {
|
|
nacl_toolchain_name = nacl_toolchain_variant
|
|
}
|
|
nmf_name = "${output_name}_${nacl_toolchain_name}"
|
|
}
|
|
}
|
|
|
|
executable(nexe_target_name) {
|
|
visibility = [ ":*" ]
|
|
output_name = suffixed_output_name
|
|
sources = invoker.sources
|
|
forward_variables_from(invoker,
|
|
[
|
|
"cflags",
|
|
"defines",
|
|
"include_dirs",
|
|
"ldflags",
|
|
"libs",
|
|
])
|
|
deps = [
|
|
"//build/config/nacl:nacl_base",
|
|
"//ppapi/native_client:ppapi_lib",
|
|
]
|
|
ldflags = [ "-pthread" ]
|
|
if (defined(invoker.deps)) {
|
|
deps += invoker.deps
|
|
}
|
|
}
|
|
|
|
if (current_cpu == "pnacl" && pretranslate_pexe) {
|
|
# This is a template so it can be invoked twice in the
|
|
# defined(extra_tc_cpu) case below.
|
|
template("nacl_test_data_pretranslate_pexe") {
|
|
action(target_name) {
|
|
translate_cpu = invoker.translate_cpu
|
|
|
|
visibility = [ ":$nexe_copy_target_name" ]
|
|
|
|
# We specify the toolchain explicitly because in the Non-SFI case, we
|
|
# still want to use the pexe built using the newlib_pnacl toolchain.
|
|
tests = ":ppapi_nacl_tests_nexe(//build/toolchain/nacl:newlib_pnacl)"
|
|
|
|
pexe = get_label_info(tests, "root_out_dir") +
|
|
"/${suffixed_output_name}.pexe"
|
|
if (translate_cpu == "x86" ||
|
|
(is_nacl_nonsfi &&
|
|
(translate_cpu == "x86" || translate_cpu == "x64"))) {
|
|
nmf_cpu = "x32"
|
|
} else {
|
|
nmf_cpu = translate_cpu
|
|
}
|
|
if (is_nacl_nonsfi) {
|
|
suffix = "pnacl_newlib_${nmf_cpu}_nonsfi"
|
|
} else {
|
|
suffix = "pnacl_newlib_${nmf_cpu}"
|
|
}
|
|
nexe = "${root_out_dir}/${output_name}_${suffix}.nexe"
|
|
|
|
script = "${nacl_toolchain_bindir}/pydir/loader.py"
|
|
sources = [
|
|
pexe,
|
|
]
|
|
outputs = [
|
|
nexe,
|
|
]
|
|
|
|
if (is_nacl_nonsfi) {
|
|
if (translate_cpu == "x86" || translate_cpu == "x64") {
|
|
arch = "x86-32-nonsfi"
|
|
} else if (translate_cpu == "arm") {
|
|
arch = "arm-nonsfi"
|
|
}
|
|
} else {
|
|
# TODO(phosek): remove the following once change 1360243003 is rolled
|
|
# into Chrome and use translate_cpu directly.
|
|
if (translate_cpu == "x86") {
|
|
arch = "i686"
|
|
} else if (translate_cpu == "x64") {
|
|
arch = "x86-64"
|
|
} else if (translate_cpu == "arm") {
|
|
arch = "armv7"
|
|
} else if (translate_cpu == "mipsel") {
|
|
arch = "mipsel"
|
|
}
|
|
}
|
|
|
|
# The pre-translated object file has to be linked with an IRT shim to
|
|
# get a runnable nexe. This is handled by pnacl-translate, which passes
|
|
# -l:libpnacl_irt_shim.a to native linker, and we need to ensure the
|
|
# linker can find the correct library.
|
|
if (is_nacl_nonsfi) {
|
|
pnacl_irt_shim = "//ppapi/native_client/src/untrusted/pnacl_irt_shim:aot(//build/toolchain/nacl:newlib_pnacl_nonsfi)"
|
|
} else {
|
|
pnacl_irt_shim = "//ppapi/native_client/src/untrusted/pnacl_irt_shim:aot(//build/toolchain/nacl:clang_newlib_${translate_cpu})"
|
|
}
|
|
|
|
args = [
|
|
"pnacl-translate",
|
|
rebase_path(pexe, root_build_dir),
|
|
"-o",
|
|
rebase_path(nexe, root_build_dir),
|
|
"-arch",
|
|
arch,
|
|
"-Wl,-L" +
|
|
rebase_path(get_label_info(pnacl_irt_shim, "target_out_dir"),
|
|
root_build_dir),
|
|
]
|
|
deps = [
|
|
":$nexe_target_name(//build/toolchain/nacl:newlib_pnacl)",
|
|
]
|
|
data_deps = [
|
|
pnacl_irt_shim,
|
|
]
|
|
}
|
|
}
|
|
|
|
nacl_test_data_pretranslate_pexe(pexe_translate_target_name) {
|
|
translate_cpu = target_cpu
|
|
}
|
|
if (defined(extra_tc_cpu)) {
|
|
nacl_test_data_pretranslate_pexe(extra_pexe_translate_target_name) {
|
|
translate_cpu = extra_tc_cpu
|
|
}
|
|
}
|
|
}
|
|
|
|
copy(nexe_copy_target_name) {
|
|
visibility = [ ":$final_target_name" ]
|
|
if (generate_nmf) {
|
|
visibility += [ ":$nmf_target_name" ]
|
|
}
|
|
if (current_cpu == "pnacl") {
|
|
if (pretranslate_pexe) {
|
|
sources = get_target_outputs(":${pexe_translate_target_name}")
|
|
if (defined(extra_tc_cpu)) {
|
|
sources += get_target_outputs(":${extra_pexe_translate_target_name}")
|
|
}
|
|
} else if (defined(invoker.nonstable_pexe) && invoker.nonstable_pexe) {
|
|
sources = [
|
|
"${root_out_dir}/exe.unstripped/${suffixed_output_name}.pexe",
|
|
]
|
|
} else {
|
|
sources = [
|
|
"${root_out_dir}/${suffixed_output_name}.pexe",
|
|
]
|
|
}
|
|
} else {
|
|
sources = [
|
|
"${root_out_dir}/${suffixed_output_name}.nexe",
|
|
]
|
|
if (defined(extra_nmf_cpu)) {
|
|
extra_root_out_dir =
|
|
get_label_info(":${nexe_target_name}(${extra_toolchain})",
|
|
"root_out_dir")
|
|
sources +=
|
|
[ "${extra_root_out_dir}/${extra_suffixed_output_name}.nexe" ]
|
|
}
|
|
}
|
|
outputs = [
|
|
"${target_dir}/{{source_file_part}}",
|
|
]
|
|
if (current_cpu == "pnacl" && pretranslate_pexe) {
|
|
deps = [
|
|
":$pexe_translate_target_name",
|
|
]
|
|
if (defined(extra_tc_cpu)) {
|
|
deps += [ ":$extra_pexe_translate_target_name" ]
|
|
}
|
|
} else {
|
|
deps = [
|
|
":$nexe_target_name",
|
|
]
|
|
if (defined(extra_nmf_cpu)) {
|
|
deps += [ ":${nexe_target_name}(${extra_toolchain})" ]
|
|
}
|
|
}
|
|
}
|
|
|
|
if (current_cpu == "pnacl" && !is_nacl_nonsfi) {
|
|
if (defined(invoker.debug_pexe) && invoker.debug_pexe) {
|
|
copy(pexe_copy_debug_target_name) {
|
|
visibility = [ ":$final_target_name" ]
|
|
sources = [
|
|
"${root_out_dir}/exe.unstripped/${suffixed_output_name}.pexe",
|
|
]
|
|
outputs = [
|
|
"${target_dir}/{{source_name_part}}.pexe.debug",
|
|
]
|
|
deps = [
|
|
":$nexe_target_name",
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
if (generate_nmf) {
|
|
if (is_nacl_nonsfi) {
|
|
generate_nonsfi_test_nmf(nmf_target_name) {
|
|
visibility = [ ":$final_target_name" ]
|
|
forward_variables_from(invoker, [ "nmfflags" ])
|
|
nmf = "${target_dir}/${nmf_name}.nmf"
|
|
files = get_target_outputs(":$nexe_copy_target_name")
|
|
executable = files[0]
|
|
deps = [
|
|
":$nexe_copy_target_name",
|
|
]
|
|
}
|
|
} else {
|
|
generate_nmf(nmf_target_name) {
|
|
visibility = [ ":$final_target_name" ]
|
|
forward_variables_from(invoker, [ "nmfflags" ])
|
|
nmf = "${target_dir}/${nmf_name}.nmf"
|
|
executables = get_target_outputs(":$nexe_copy_target_name")
|
|
if (is_nacl_glibc) {
|
|
lib_prefix = "${output_name}_libs"
|
|
stage_dependencies = target_dir
|
|
}
|
|
deps = [
|
|
":$nexe_copy_target_name",
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
if (defined(invoker.test_files)) {
|
|
copy(test_files_target_name) {
|
|
visibility = [ ":$final_target_name" ]
|
|
sources = invoker.test_files
|
|
outputs = [
|
|
"${target_dir}/{{source_file_part}}",
|
|
]
|
|
}
|
|
}
|
|
|
|
group(final_target_name) {
|
|
data_deps = [
|
|
":$nexe_copy_target_name",
|
|
]
|
|
if (current_cpu == "pnacl" && !is_nacl_nonsfi) {
|
|
if (defined(invoker.debug_pexe) && invoker.debug_pexe) {
|
|
data_deps += [ ":$pexe_copy_debug_target_name" ]
|
|
}
|
|
}
|
|
if (generate_nmf) {
|
|
data_deps += [ ":$nmf_target_name" ]
|
|
}
|
|
if (defined(invoker.test_files)) {
|
|
data_deps += [ ":$test_files_target_name" ]
|
|
}
|
|
}
|
|
}
|