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