62ace59d8c
Change-Id: I8d3d04a20f8a696dd9d4d0c6f2808155fb7da5b4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/295469 Reviewed-by: John Rosasco <rosasco@google.com> Commit-Queue: John Rosasco <rosasco@google.com>
389 lines
9.6 KiB
Plaintext
389 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"),
|
|
"--output-c-header",
|
|
rebase_path("$target_gen_dir/$library_name_slashes/c/fidl.h"),
|
|
]
|
|
}
|
|
|
|
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
|
|
}
|
|
}
|
|
}
|