437c78593c
Previously we assumed that FIDL libraries always have "fuchsia.*" prefix, however the "zx" library recently added to SDK doesn't start with this prefix and caused build failure. This change fixes the issue by always using full name of all the FIDL libraries. TEST=build Skia and SkQP for fuchsia.x64 and arm64. Change-Id: I1643bba94263d285eb9dbc222667b884cad6610d Reviewed-on: https://skia-review.googlesource.com/c/skia/+/295409 Auto-Submit: Yilong Li <liyl@google.com> Commit-Queue: John Rosasco <rosasco@google.com> Reviewed-by: John Rosasco <rosasco@google.com>
387 lines
9.6 KiB
Plaintext
387 lines
9.6 KiB
Plaintext
# Copyright 2019 Google LLC. All rights reserved.
|
|
# Use of this source code is governed by a BSD-style license that can be
|
|
# found in the LICENSE file.
|
|
|
|
# import("//gn/skia.gni")
|
|
|
|
declare_args() {
|
|
using_fuchsia_sdk = true
|
|
|
|
# Fuchsia SDK install dir.
|
|
fuchsia_sdk_path = "//fuchsia/sdk/$host_os"
|
|
|
|
# Clang install dir.
|
|
fuchsia_toolchain_path = "//fuchsia/toolchain/$host_os"
|
|
|
|
# Path to GN-generated GN targets derived from parsing json file at
|
|
# |fuchsia_sdk_manifest_path|. The parsing logic can be found in sdk.gni.
|
|
fuchsia_sdk_root = "//build/fuchsia"
|
|
}
|
|
|
|
declare_args() {
|
|
fuchsia_sdk_manifest_path = "${fuchsia_sdk_path}/meta/manifest.json"
|
|
}
|
|
|
|
template("_fuchsia_sysroot") {
|
|
assert(defined(invoker.meta), "The meta.json file path must be specified.")
|
|
assert(target_cpu == "x64" || target_cpu == "arm64",
|
|
"We currently only support 'x64' and 'arm64' targets for fuchsia.")
|
|
|
|
meta_json = read_file(invoker.meta, "json")
|
|
|
|
assert(meta_json.type == "sysroot")
|
|
|
|
meta_json_versions = meta_json.versions
|
|
if (target_cpu == "x64") {
|
|
defs = meta_json_versions.x64
|
|
} else {
|
|
defs = meta_json_versions.arm64
|
|
}
|
|
|
|
_libs = []
|
|
_lib_dirs = []
|
|
_include_dirs = []
|
|
|
|
foreach(link_lib, defs.link_libs) {
|
|
if (link_lib != "arch/${target_cpu}/sysroot/lib/Scrt1.o") {
|
|
_libs += [ rebase_path("$fuchsia_sdk_path/$link_lib") ]
|
|
}
|
|
}
|
|
|
|
defs_include_dir = defs.include_dir
|
|
_include_dirs += [ rebase_path("$fuchsia_sdk_path/$defs_include_dir") ]
|
|
|
|
config_name = "config_$target_name"
|
|
config(config_name) {
|
|
lib_dirs = _lib_dirs
|
|
libs = _libs
|
|
include_dirs = _include_dirs
|
|
}
|
|
|
|
group(target_name) {
|
|
public_configs = [ ":$config_name" ]
|
|
}
|
|
}
|
|
|
|
template("_fuchsia_fidl_library") {
|
|
assert(defined(invoker.meta), "The meta.json file path must be specified.")
|
|
assert(target_cpu == "x64" || target_cpu == "arm64",
|
|
"We currently only support 'x64' and 'arm64' targets for fuchsia.")
|
|
|
|
meta_json = read_file(invoker.meta, "json")
|
|
|
|
assert(meta_json.type == "fidl_library")
|
|
|
|
_deps = [ "../pkg:fidl_cpp" ]
|
|
|
|
library_name = meta_json.name
|
|
library_name_json = "$library_name.json"
|
|
|
|
foreach(dep, meta_json.deps) {
|
|
_deps += [ ":$dep" ]
|
|
}
|
|
|
|
config_name = "config_$target_name"
|
|
config(config_name) {
|
|
include_dirs = [ target_gen_dir ]
|
|
}
|
|
|
|
fidl_gen_target_name = "fidlgen_$target_name"
|
|
action(fidl_gen_target_name) {
|
|
script = "//build/fuchsia/fidl_gen_cpp"
|
|
|
|
library_name_slashes = string_replace(library_name, ".", "/")
|
|
|
|
inputs = [ invoker.meta ]
|
|
|
|
outputs = [
|
|
"$target_gen_dir/$library_name_slashes/c/tables.c",
|
|
"$target_gen_dir/$library_name_slashes/cpp/fidl.h",
|
|
"$target_gen_dir/$library_name_slashes/cpp/fidl.cc",
|
|
]
|
|
|
|
args = [
|
|
"--fidlc-bin",
|
|
rebase_path("$fuchsia_sdk_path/tools/fidlc"),
|
|
"--fidlgen-bin",
|
|
rebase_path("$fuchsia_sdk_path/tools/fidlgen"),
|
|
"--sdk-base",
|
|
rebase_path("$fuchsia_sdk_path"),
|
|
"--root",
|
|
rebase_path(invoker.meta),
|
|
"--json",
|
|
rebase_path("$target_gen_dir/$library_name_json"),
|
|
"--include-base",
|
|
rebase_path("$target_gen_dir"),
|
|
"--output-base-cc",
|
|
rebase_path("$target_gen_dir/$library_name_slashes/cpp/fidl"),
|
|
"--output-c-tables",
|
|
rebase_path("$target_gen_dir/$library_name_slashes/c/tables.c"),
|
|
]
|
|
}
|
|
|
|
source_set(target_name) {
|
|
public_configs = [ ":$config_name" ]
|
|
|
|
sources = get_target_outputs(":$fidl_gen_target_name")
|
|
|
|
deps = [ ":$fidl_gen_target_name" ]
|
|
|
|
public_deps = _deps
|
|
}
|
|
}
|
|
|
|
#
|
|
# Produce a cc source library from invoker's json file.
|
|
# Primary output is the source_set.
|
|
#
|
|
template("_fuchsia_cc_source_library") {
|
|
assert(defined(invoker.meta), "The meta.json file path must be specified.")
|
|
|
|
meta_json = read_file(invoker.meta, "json")
|
|
|
|
assert(meta_json.type == "cc_source_library")
|
|
|
|
_output_name = meta_json.name
|
|
_include_dirs = []
|
|
_public_headers = []
|
|
_sources = []
|
|
_deps = []
|
|
|
|
meta_json_include_dir = meta_json.include_dir
|
|
_include_dirs += [ rebase_path("$fuchsia_sdk_path/$meta_json_include_dir") ]
|
|
|
|
foreach(header, meta_json.headers) {
|
|
rebased_header = []
|
|
rebased_header = [ rebase_path("$fuchsia_sdk_path/$header") ]
|
|
_public_headers += rebased_header
|
|
_sources += rebased_header
|
|
}
|
|
|
|
foreach(source, meta_json.sources) {
|
|
_sources += [ "$fuchsia_sdk_path/$source" ]
|
|
}
|
|
|
|
config_name = "config_$target_name"
|
|
config(config_name) {
|
|
include_dirs = _include_dirs
|
|
}
|
|
|
|
foreach(dep, meta_json.deps) {
|
|
_deps += [ "../pkg:$dep" ]
|
|
}
|
|
|
|
foreach(dep, meta_json.fidl_deps) {
|
|
_deps += [ "../fidl:$dep" ]
|
|
}
|
|
|
|
source_set(target_name) {
|
|
output_name = _output_name
|
|
public = _public_headers
|
|
sources = _sources
|
|
public_configs = [ ":$config_name" ]
|
|
public_deps = _deps
|
|
}
|
|
}
|
|
|
|
template("_fuchsia_cc_prebuilt_library") {
|
|
assert(defined(invoker.meta), "The meta.json file path must be specified.")
|
|
meta_json = read_file(invoker.meta, "json")
|
|
|
|
_include_dirs = []
|
|
_deps = []
|
|
_libs = []
|
|
|
|
meta_json_include_dir = meta_json.include_dir
|
|
_include_dirs += [ "$fuchsia_sdk_path/$meta_json_include_dir" ]
|
|
|
|
foreach(dep, meta_json.deps) {
|
|
_deps += [ ":$dep" ]
|
|
}
|
|
|
|
meta_json_binaries = meta_json.binaries
|
|
if (target_cpu == "x64") {
|
|
meta_json_binaries_arch = meta_json_binaries.x64
|
|
} else {
|
|
meta_json_binaries_arch = meta_json_binaries.arm64
|
|
}
|
|
prebuilt_lib = meta_json_binaries_arch.link
|
|
_libs = [ "$fuchsia_sdk_path/$prebuilt_lib" ]
|
|
|
|
config_name = "config_$target_name"
|
|
config(config_name) {
|
|
include_dirs = _include_dirs
|
|
libs = _libs
|
|
}
|
|
|
|
group(target_name) {
|
|
public_configs = [ ":$config_name" ]
|
|
public_deps = _deps
|
|
}
|
|
}
|
|
|
|
#
|
|
# Read SDK manifest json file and produce gn build targets for all
|
|
# "enabled_parts" as specified by the template invoker.
|
|
#
|
|
# Fuchsia SDK manifest is primarily a "parts" array.
|
|
#
|
|
template("fuchsia_sdk") {
|
|
assert(defined(invoker.meta), "The meta.json file path must be specified.")
|
|
assert(defined(invoker.enabled_parts),
|
|
"A list containing the parts of the SDK to generate targets for.")
|
|
|
|
meta_json = read_file(invoker.meta, "json")
|
|
|
|
foreach(part, meta_json.parts) {
|
|
part_meta_json = {
|
|
}
|
|
|
|
part_meta = part.meta
|
|
part_meta_rebased = "$fuchsia_sdk_path/$part_meta"
|
|
|
|
part_meta_json = read_file(part_meta_rebased, "json")
|
|
subtarget_name = part_meta_json.name
|
|
|
|
foreach(enabled_part, invoker.enabled_parts) {
|
|
if (part.type == "cc_source_library") {
|
|
if (part.type == enabled_part) {
|
|
_fuchsia_cc_source_library(subtarget_name) {
|
|
meta = part_meta_rebased
|
|
}
|
|
}
|
|
} else if (part.type == "sysroot") {
|
|
if (part.type == enabled_part) {
|
|
_fuchsia_sysroot(subtarget_name) {
|
|
meta = part_meta_rebased
|
|
}
|
|
}
|
|
} else if (part.type == "fidl_library") {
|
|
if (part.type == enabled_part) {
|
|
_fuchsia_fidl_library(subtarget_name) {
|
|
meta = part_meta_rebased
|
|
}
|
|
}
|
|
} else if (part.type == "cc_prebuilt_library") {
|
|
if (part.type == enabled_part) {
|
|
_fuchsia_cc_prebuilt_library(subtarget_name) {
|
|
meta = part_meta_rebased
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
group(target_name) {
|
|
}
|
|
}
|
|
|
|
#
|
|
# Create package in 'gen' directory.
|
|
#
|
|
template("fuchsia_package") {
|
|
assert(defined(invoker.name), "The name of the package must be specified.")
|
|
assert(defined(invoker.version), "The package version must be specified.")
|
|
|
|
pkg_dir = target_gen_dir
|
|
pkg_name = invoker.name
|
|
pkg_version = invoker.version
|
|
pkg_manifest = invoker.pkg_manifest
|
|
|
|
pkg_id_path = "${pkg_dir}/meta/package"
|
|
gen_far_target_name = "gen_far_${target_name}"
|
|
pkg_archive = "${pkg_dir}/${pkg_name}-${pkg_version}.far"
|
|
|
|
action(gen_far_target_name) {
|
|
script = "//build/fuchsia/gen_package"
|
|
|
|
pm_binary = rebase_path("$fuchsia_sdk_path/tools/pm")
|
|
|
|
inputs = [ pm_binary ]
|
|
|
|
outputs = [
|
|
pkg_id_path,
|
|
pkg_archive,
|
|
]
|
|
|
|
args = [
|
|
"--pm-bin",
|
|
pm_binary,
|
|
"--pkg-dir",
|
|
rebase_path(pkg_dir),
|
|
"--pkg-name",
|
|
pkg_name,
|
|
"--pkg-version",
|
|
"$pkg_version",
|
|
"--pkg-manifest",
|
|
rebase_path(pkg_manifest),
|
|
]
|
|
|
|
if (defined(invoker.deps)) {
|
|
deps = invoker.deps
|
|
}
|
|
if (defined(invoker.testonly)) {
|
|
testonly = invoker.testonly
|
|
}
|
|
}
|
|
|
|
copy(target_name) {
|
|
if (defined(invoker.testonly)) {
|
|
testonly = invoker.testonly
|
|
}
|
|
|
|
sources = [ pkg_archive ]
|
|
|
|
output_name = "${root_out_dir}/far/${pkg_name}.far"
|
|
outputs = [ output_name ]
|
|
|
|
deps = [ ":$gen_far_target_name" ]
|
|
}
|
|
}
|
|
|
|
#
|
|
# Places repo in output ('obj') directory.
|
|
#
|
|
template("fuchsia_repo") {
|
|
assert(defined(invoker.archives),
|
|
"The list of archives to publish must be specified.")
|
|
assert(defined(invoker.repo), "The location of the repo should be specified.")
|
|
|
|
action(target_name) {
|
|
if (defined(invoker.testonly)) {
|
|
testonly = invoker.testonly
|
|
}
|
|
script = "//build/fuchsia/gen_repo"
|
|
|
|
pm_binary = rebase_path("$fuchsia_sdk_path/tools/pm")
|
|
repo_directory = invoker.repo
|
|
|
|
inputs = [ pm_binary ]
|
|
|
|
archive_flags = []
|
|
|
|
foreach(archive, invoker.archives) {
|
|
assert(get_path_info(archive, "extension") == "far",
|
|
"Archive '$archive' does not have the .far extension.")
|
|
inputs += [ archive ]
|
|
archive_flags += [
|
|
"--archive",
|
|
rebase_path(archive),
|
|
]
|
|
}
|
|
|
|
outputs = [ repo_directory ]
|
|
|
|
args = [
|
|
"--pm-bin",
|
|
pm_binary,
|
|
"--repo-dir",
|
|
rebase_path(repo_directory),
|
|
] + archive_flags
|
|
|
|
if (defined(invoker.deps)) {
|
|
deps = invoker.deps
|
|
}
|
|
}
|
|
}
|