blob: 1fbd1984fc81bf297446f6ec2c5ec3c0490c81f1 [file] [log] [blame]
# Copyright 2019 The ANGLE Project 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 the use_x11 variable
import("//build/config/dcheck_always_on.gni")
import("//build/config/linux/pkg_config.gni")
import("//build/config/ui.gni")
import("//testing/libfuzzer/fuzzer_test.gni")
import("gni/angle.gni")
if (is_android) {
# android/rules.gni can only be imported for Android targets
import("//build/config/android/config.gni")
import("//build/config/android/rules.gni")
import("android/angle_apk.gni")
}
declare_args() {
# Use the PCI lib to collect GPU information on Linux.
use_libpci = is_linux && (!is_chromecast || is_cast_desktop_build) &&
(use_x11 || use_ozone)
# Link in system libGL, to work with apitrace. See doc/DebuggingTips.md.
angle_link_glx = false
}
if (!build_with_chromium) {
group("all") {
testonly = true
deps = [
":angle_shader_translator",
":translator_fuzzer",
":xxhash_fuzzer",
"//samples:all",
"//src/tests:all",
]
}
}
if (ozone_platform_gbm) {
pkg_config("libdrm") {
packages = [ "libdrm" ]
}
}
angle_git_is_present = exec_script("src/commit_id.py",
[
"check",
rebase_path(".", root_build_dir),
],
"value")
angle_use_commit_id = angle_git_is_present == 1
import("src/compiler.gni")
import("src/libGLESv2.gni")
# This config is exported to dependent targets (and also applied to internal
# ones).
config("external_config") {
include_dirs = [ "include" ]
}
# Prevent the GL headers from redeclaring ANGLE entry points.
config("no_gl_prototypes") {
defines = [
"GL_GLES_PROTOTYPES=0",
"EGL_EGL_PROTOTYPES=0",
]
}
config("gl_prototypes") {
defines = [
"GL_GLES_PROTOTYPES=1",
"EGL_EGL_PROTOTYPES=1",
"GL_GLEXT_PROTOTYPES",
"EGL_EGLEXT_PROTOTYPES",
]
}
# This config is applied to internal Angle targets (not pushed to dependents).
config("internal_config") {
include_dirs = [
"include",
"src",
]
defines = []
if (angle_64bit_current_cpu) {
defines += [ "ANGLE_IS_64_BIT_CPU" ]
} else {
defines += [ "ANGLE_IS_32_BIT_CPU" ]
}
if (angle_force_thread_safety) {
defines += [ "ANGLE_FORCE_THREAD_SAFETY=1" ]
}
if (angle_enable_vulkan) {
if (angle_enable_vulkan_gpu_trace_events) {
defines += [ "ANGLE_ENABLE_VULKAN_GPU_TRACE_EVENTS=1" ]
}
}
if (angle_enable_trace) {
defines += [ "ANGLE_ENABLE_DEBUG_TRACE=1" ]
}
}
config("extra_warnings") {
cflags = []
# Enable more default warnings on Windows.
if (is_win) {
cflags += [
"/we4244", # Conversion: possible loss of data.
"/we4456", # Variable shadowing.
"/we4458", # declaration hides class member.
"/we4800", # forcing value to bool.
"/we4838", # narrowing conversion.
]
}
if (is_clang) {
cflags += [
# Remove when crbug.com/926235 is resolved.
"-Wextra-semi",
# Enable after anglebug.com/3128 is fixed.
# "-Wextra-semi-stmt",
# Remove when crbug.com/428099 is resolved.
"-Winconsistent-missing-override",
"-Wnon-virtual-dtor",
"-Wunneeded-internal-declaration",
]
}
}
# This config adds build-ids to the associated library.
# -Wl is a special option that indicates that clang should pass the associated
# option --build-id to the linker. This will cause a build-id section to be added
# to the associated library. The build-id makes it possible for a debugger to
# find the right symbol file to use.
config("build_id_config") {
ldflags = [ "-Wl,--build-id" ]
}
# Windows ARM64 is available since 10.0.16299 so no need to copy
# d3dcompiler_47.dll because this file is available as inbox.
if (is_win && target_cpu != "arm64") {
copy("copy_compiler_dll") {
sources = [
"$windows_sdk_path/Redist/D3D/$target_cpu/d3dcompiler_47.dll",
]
outputs = [
"$root_out_dir/d3dcompiler_47.dll",
]
}
}
config("includes_config") {
include_dirs = [ "include" ]
}
# Holds the shared includes so we only need to list them once.
angle_source_set("includes") {
sources = libangle_includes
public_configs = [ ":includes_config" ]
}
angle_static_library("preprocessor") {
sources = angle_preprocessor_sources
public_deps = [
":angle_common",
]
}
config("translator_disable_pool_alloc") {
defines = [ "ANGLE_TRANSLATOR_DISABLE_POOL_ALLOC" ]
}
config("debug_annotations_config") {
if (is_debug) {
defines = [ "ANGLE_ENABLE_DEBUG_ANNOTATIONS" ]
}
}
config("angle_release_asserts_config") {
if (dcheck_always_on) {
defines = [ "ANGLE_ENABLE_RELEASE_ASSERTS" ]
}
}
config("angle_common_config") {
include_dirs = [ "src/common/third_party/base" ]
if (is_android) {
libs = [ "log" ]
}
}
angle_source_set("angle_system_utils") {
sources = angle_system_utils_sources
}
angle_source_set("xxhash") {
sources = xxhash_sources
configs -= [ "${angle_root}:extra_warnings" ]
}
fuzzer_test("xxhash_fuzzer") {
sources = [
"src/common/third_party/xxhash/xxhash_fuzzer.cpp",
]
deps = [
":xxhash",
]
}
angle_static_library("angle_common") {
sources = libangle_common_sources
configs += [
":angle_common_config",
":debug_annotations_config",
]
deps = [
":xxhash",
]
public_deps = [
":angle_system_utils",
":angle_version",
":includes",
]
public_configs += [ ":angle_common_config" ]
all_dependent_configs = [ ":angle_release_asserts_config" ]
}
config("angle_image_util_config") {
include_dirs = [
"include",
"src",
]
}
angle_static_library("angle_image_util") {
sources = libangle_image_util_sources
public_configs += [ ":angle_image_util_config" ]
public_deps = [
":angle_common",
]
}
config("angle_gl_visibility_config") {
if (is_win) {
defines = [
"GL_APICALL=",
"GL_API=",
]
} else {
defines = [
"GL_APICALL=__attribute__((visibility(\"default\")))",
"GL_API=__attribute__((visibility(\"default\")))",
]
}
}
config("angle_gpu_info_util_config") {
include_dirs = [
"include",
"src",
]
}
angle_static_library("angle_gpu_info_util") {
public_configs += [ ":angle_gpu_info_util_config" ]
public_deps = [
":angle_common",
]
sources = libangle_gpu_info_util_sources
deps = []
libs = []
defines = []
if (is_android) {
sources += [ "src/gpu_info_util/SystemInfo_android.cpp" ]
}
if (is_win) {
sources += libangle_gpu_info_util_win_sources
libs += [ "setupapi.lib" ]
defines += [ "GPU_INFO_USE_SETUPAPI" ]
}
if (is_linux || is_fuchsia) {
sources += libangle_gpu_info_util_linux_sources
if (use_x11) {
sources += libangle_gpu_info_util_x11_sources
deps += [ "src/third_party/libXNVCtrl:libXNVCtrl" ]
defines += [ "GPU_INFO_USE_X11" ]
libs += [
"X11",
"Xi",
"Xext",
]
}
}
if (use_libpci) {
sources += libangle_gpu_info_util_libpci_sources
defines += [ "GPU_INFO_USE_LIBPCI" ]
libs += [ "pci" ]
}
if (is_mac) {
sources += libangle_gpu_info_util_mac_sources
libs += [
"IOKit.framework",
"CoreFoundation.framework",
"CoreGraphics.framework",
]
}
}
angle_static_library("translator") {
sources = angle_translator_sources
defines = []
if (angle_enable_essl || use_fuzzing_engine) {
sources += angle_translator_essl_sources
defines += [ "ANGLE_ENABLE_ESSL" ]
}
if (angle_enable_glsl || use_fuzzing_engine) {
sources += angle_translator_glsl_sources
defines += [ "ANGLE_ENABLE_GLSL" ]
}
if (angle_enable_hlsl || use_fuzzing_engine) {
sources += angle_translator_hlsl_sources
defines += [ "ANGLE_ENABLE_HLSL" ]
}
if (angle_enable_vulkan || use_fuzzing_engine) {
sources += angle_translator_lib_vulkan_sources
defines += [ "ANGLE_ENABLE_VULKAN" ]
}
public_configs += [ ":external_config" ]
if (use_fuzzing_engine) {
all_dependent_configs = [ ":translator_disable_pool_alloc" ]
}
deps = [
":includes",
":preprocessor",
]
public_deps = [
":angle_common",
]
if (is_win) {
# Necessary to suppress some system header xtree warnigns in Release.
# For some reason this warning doesn't get triggered in Chromium
cflags = [ "/wd4718" ]
}
}
angle_source_set("translator_fuzzer") {
sources = [
"src/compiler/fuzz/translator_fuzzer.cpp",
]
include_dirs = [
"include",
"src",
]
deps = [
":translator",
]
}
config("commit_id_config") {
include_dirs = [ "$root_gen_dir/angle" ]
visibility = [ ":commit_id" ]
}
commit_id_output_file = "$root_gen_dir/angle/id/commit.h"
if (angle_use_commit_id) {
action("commit_id") {
script = "src/commit_id.py"
outputs = [
commit_id_output_file,
]
# commit id should depend on angle's HEAD revision
inputs = [
".git/HEAD",
]
args = [
"gen",
rebase_path(".", root_build_dir),
rebase_path(commit_id_output_file, root_build_dir),
]
public_configs = [ ":commit_id_config" ]
}
} else {
copy("commit_id") {
sources = [
"src/commit.h",
]
outputs = [
commit_id_output_file,
]
public_configs = [ ":commit_id_config" ]
}
}
angle_source_set("angle_version") {
sources = [
"src/common/version.h",
]
public_deps = [
":commit_id",
]
}
config("libANGLE_config") {
cflags = []
defines = []
libs = []
if (angle_enable_d3d9) {
defines += [ "ANGLE_ENABLE_D3D9" ]
}
if (angle_enable_d3d11) {
defines += [ "ANGLE_ENABLE_D3D11" ]
}
if (angle_enable_gl) {
defines += [ "ANGLE_ENABLE_OPENGL" ]
if (use_x11) {
defines += [ "ANGLE_USE_X11" ]
}
if (angle_enable_gl_null) {
defines += [ "ANGLE_ENABLE_OPENGL_NULL" ]
}
}
if (angle_enable_vulkan) {
defines += [ "ANGLE_ENABLE_VULKAN" ]
}
if (angle_enable_null) {
defines += [ "ANGLE_ENABLE_NULL" ]
}
defines += [ "LIBANGLE_IMPLEMENTATION" ]
if (is_win) {
cflags += [ "/wd4530" ] # C++ exception handler used, but unwind semantics are not enabled.
}
if (is_android && (angle_enable_gl || angle_enable_vulkan)) {
if (ndk_supports_nativewindow) {
libs += [ "nativewindow" ]
} else {
libs += [ "android" ]
}
}
}
if (angle_enable_vulkan) {
config("vulkan_config") {
if (is_win) {
defines = [
"VK_USE_PLATFORM_WIN32_KHR",
"VK_USE_PLATFORM_WIN32_KHX",
]
}
if (is_linux) {
defines = [
"VK_USE_PLATFORM_XCB_KHR",
"VK_USE_PLATFORM_XCB_KHX",
]
}
if (is_android) {
defines = [
"VK_USE_PLATFORM_ANDROID_KHR",
"VK_USE_PLATFORM_ANDROID_KHX",
]
libs = [ "vulkan" ]
}
if (is_fuchsia) {
defines = [ "VK_USE_PLATFORM_FUCHSIA" ]
}
}
# Use this target to include everything ANGLE needs for Vulkan.
group("angle_vulkan") {
public_deps = [
"$angle_root/third_party/vulkan-headers:vulkan_headers",
]
public_configs = [ ":vulkan_config" ]
data_deps = []
if (!is_android && !is_fuchsia) {
deps = [
"$angle_root/third_party/vulkan-loader:libvulkan",
]
data_deps += [ "$angle_root/third_party/vulkan-tools:VkICD_mock_icd" ]
public_configs +=
[ "$angle_root/third_party/vulkan-loader:vulkan_loader_config" ]
}
if (is_fuchsia) {
public_deps += [
"$angle_root/src/common/fuchsia_egl",
"//third_party/fuchsia-sdk:vulkan_base",
"//third_party/fuchsia-sdk/sdk:vulkan",
]
}
if (angle_enable_vulkan_validation_layers) {
if (is_fuchsia) {
deps = [
"//third_party/fuchsia-sdk:vulkan_validation",
]
} else {
data_deps += [ "$angle_root/third_party/vulkan-validation-layers:vulkan_validation_layers" ]
if (!is_android) {
data_deps += [ "$angle_root/third_party/vulkan-validation-layers:vulkan_gen_json_files" ]
}
}
}
}
}
angle_static_library("libANGLE") {
sources = libangle_sources
include_dirs = []
libs = []
defines = []
if (angle_link_glx) {
libs += [ "GL" ]
defines += [ "ANGLE_LINK_GLX" ]
}
public_deps = [
":angle_common",
":angle_gpu_info_util",
":angle_version",
":translator",
]
deps = [
":angle_image_util",
":includes",
]
# Enable extra Chromium style warnings for libANGLE.
if (is_clang) {
suppressed_configs -= [ "//build/config/clang:find_bad_constructs" ]
}
# Shared D3D sources.
if (angle_enable_d3d9 || angle_enable_d3d11) {
sources += libangle_d3d_shared_sources
defines += [ "ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES={ " + "\"d3dcompiler_47.dll\", \"d3dcompiler_46.dll\", \"d3dcompiler_43.dll\" }" ]
}
if (angle_enable_d3d9) {
sources += libangle_d3d9_sources
libs += [ "d3d9.lib" ]
}
if (angle_enable_d3d11) {
sources += libangle_d3d11_sources
sources += libangle_d3d11_win32_sources
libs += [ "dxguid.lib" ]
import("src/libANGLE/renderer/d3d/d3d11/d3d11_blit_shaders_autogen.gni")
sources += libangle_d3d11_blit_shaders
}
if (angle_enable_gl) {
sources += libangle_gl_sources
include_dirs += [ "src/third_party/khronos" ]
if (angle_enable_gl_null) {
sources += libangle_gl_null_sources
}
if (is_win) {
sources += libangle_gl_wgl_sources
}
if (use_x11) {
sources += libangle_gl_glx_sources
deps += [ "src/third_party/libXNVCtrl:libXNVCtrl" ]
libs += [
"X11",
"Xi",
"Xext",
]
}
if (is_mac) {
sources += libangle_gl_cgl_sources
libs += [
"Cocoa.framework",
"IOSurface.framework",
"OpenGL.framework",
"QuartzCore.framework",
]
}
if (is_android) {
sources += libangle_gl_egl_sources
sources += libangle_gl_egl_dl_sources
sources += libangle_gl_egl_android_sources
}
if (ozone_platform_gbm) {
configs += [ ":libdrm" ]
defines += [ "ANGLE_USE_OZONE" ]
deps += [ "//third_party/minigbm" ]
sources += libangle_gl_egl_sources
sources += libangle_gl_egl_dl_sources
sources += libangle_gl_ozone_sources
}
}
if (angle_enable_vulkan) {
sources += libangle_vulkan_sources
if (is_win) {
sources += libangle_vulkan_win32_sources
}
if (is_linux) {
sources += libangle_vulkan_xcb_sources
}
if (is_fuchsia) {
sources += libangle_vulkan_fuchsia_sources
deps += [
"$angle_root/src/common/fuchsia_egl",
"$angle_root/src/common/fuchsia_egl:backend",
]
}
if (is_android) {
sources += libangle_vulkan_android_sources
libs += [ "vulkan" ]
}
deps += [
":angle_vulkan",
"${angle_glslang_dir}:glslang_default_resource_limits_sources",
"${angle_glslang_dir}:glslang_sources",
"${angle_spirv_tools_dir}:spvtools_val",
]
public_deps += [ "$angle_root/third_party/vulkan-headers:vulkan_headers" ]
# Include generated shaders.
import("src/libANGLE/renderer/vulkan/vk_internal_shaders_autogen.gni")
sources += angle_vulkan_internal_shaders
}
if (angle_enable_null) {
sources += libangle_null_sources
}
if (is_debug) {
defines += [ "ANGLE_GENERATE_SHADER_DEBUG_INFO" ]
}
configs += [ ":debug_annotations_config" ]
public_configs += [ ":libANGLE_config" ]
# Windows ARM64 is available since 10.0.16299 so no need to copy
# d3dcompiler_47.dll because this file is available as inbox.
if (is_win && target_cpu != "arm64") {
data_deps = [
":copy_compiler_dll",
]
}
}
config("shared_library_public_config") {
if (is_mac && !is_component_build) {
# Executable targets that depend on the shared libraries below need to have
# the rpath setup in non-component build configurations.
ldflags = [
"-rpath",
"@executable_path/",
]
}
}
config("library_name_config") {
defines = [
"ANGLE_EGL_LIBRARY_NAME=\"libEGL${angle_libs_suffix}\"",
"ANGLE_GLESV2_LIBRARY_NAME=\"libGLESv2${angle_libs_suffix}\"",
]
}
# This config controls export definitions on ANGLE API calls.
config("angle_static") {
defines = [
"ANGLE_EXPORT=",
"ANGLE_UTIL_EXPORT=",
"EGLAPI=",
"GL_APICALL=",
"GL_API=",
]
}
angle_shared_library("libGLESv2${angle_libs_suffix}") {
sources = libglesv2_sources
if (is_win) {
sources += [ "src/libGLESv2/libGLESv2_autogen.def" ]
}
configs += [
":angle_gl_visibility_config",
":debug_annotations_config",
":gl_prototypes",
]
defines = [ "LIBGLESV2_IMPLEMENTATION" ]
deps = [
":includes",
":libANGLE",
]
public_deps = [
":angle_version",
]
}
angle_static_library("libGLESv2_static") {
sources = libglesv2_sources
configs += [ ":debug_annotations_config" ]
public_configs += [ ":angle_static" ]
deps = [
":includes",
]
public_deps = [
":libANGLE",
]
}
angle_shared_library("libGLESv1_CM${angle_libs_suffix}") {
sources = libglesv1_cm_sources
configs += [
":angle_gl_visibility_config",
":debug_annotations_config",
":gl_prototypes",
]
defines = []
deps = [
":includes",
":libGLESv2${angle_libs_suffix}",
]
}
angle_static_library("libGLESv1_CM_static") {
sources = libglesv1_cm_sources
configs += [ ":debug_annotations_config" ]
public_configs += [ ":angle_static" ]
deps = [
":includes",
":libGLESv2_static",
]
}
config("libEGL_egl_loader_config") {
defines = [ "ANGLE_USE_EGL_LOADER" ]
}
angle_source_set("libEGL_egl_loader") {
sources = [
"src/libEGL/egl_loader_autogen.cpp",
"src/libEGL/egl_loader_autogen.h",
]
public_configs += [
":libEGL_egl_loader_config",
":gl_prototypes",
]
deps = [
":includes",
]
}
angle_shared_library("libEGL${angle_libs_suffix}") {
sources = libegl_sources
configs += [
":debug_annotations_config",
":library_name_config",
]
defines = [ "LIBEGL_IMPLEMENTATION" ]
if (is_win) {
defines += [ "EGLAPI=" ]
} else {
defines += [ "EGLAPI=__attribute__((visibility(\"default\")))" ]
}
if (is_win) {
sources += [ "src/libEGL/libEGL.def" ]
}
deps = [
":angle_system_utils",
":angle_version",
":libEGL_egl_loader",
]
public_deps = [
":includes",
]
data_deps = [
":libGLESv2${angle_libs_suffix}",
]
}
angle_static_library("libEGL_static") {
sources = libegl_sources
configs += [
":debug_annotations_config",
":library_name_config",
]
public_configs += [ ":angle_static" ]
deps = [
":includes",
":libGLESv2_static",
]
}
import("util/util.gni")
config("angle_util_loader_config") {
defines = [ "ANGLE_USE_UTIL_LOADER" ]
}
angle_source_set("angle_util_loader_headers") {
sources = [
"util/egl_loader_autogen.h",
"util/gles_loader_autogen.h",
"util/util_export.h",
]
if (is_win) {
sources += [ "util/windows/wgl_loader_autogen.h" ]
}
public_deps = [
":includes",
]
}
angle_source_set("angle_util_loader") {
defines = [ "LIBANGLE_UTIL_IMPLEMENTATION" ]
sources = [
"util/egl_loader_autogen.cpp",
"util/gles_loader_autogen.cpp",
]
if (is_win) {
sources += [ "util/windows/wgl_loader_autogen.cpp" ]
}
deps = [
":angle_util_loader_headers",
]
public_configs += [
":angle_util_config",
":angle_util_loader_config",
":no_gl_prototypes",
]
}
config("angle_util_config") {
include_dirs = [ "." ]
if (is_linux && use_x11) {
libs = [ "X11" ]
}
}
foreach(is_shared_library,
[
true,
false,
]) {
if (is_shared_library) {
library_type = "angle_shared_library"
library_name = "angle_util"
dep_suffix = "${angle_libs_suffix}"
} else {
library_type = "angle_static_library"
library_name = "angle_util_static"
dep_suffix = "_static"
}
target(library_type, library_name) {
sources = util_sources
if (is_win) {
sources += util_win_sources
}
libs = []
if (is_linux) {
sources += util_linux_sources
libs += [
"rt",
"dl",
]
}
if (is_mac) {
sources += util_osx_sources
libs += [
"AppKit.framework",
"QuartzCore.framework",
]
}
if (use_x11) {
sources += util_x11_sources
}
if (is_android) {
# To prevent linux sources filtering on android
set_sources_assignment_filter([])
sources += util_linux_sources
sources += util_android_sources
libs += [
"android",
"log",
]
}
configs += [ ":debug_annotations_config" ]
public_configs += [ ":angle_util_config" ]
deps = [
":angle_common",
":angle_util_loader_headers",
]
public_deps = []
if (is_fuchsia) {
sources += util_fuchsia_sources
public_deps += [
"$angle_root/src/common/fuchsia_egl",
"//third_party/fuchsia-sdk/sdk:async_loop_cpp",
"//third_party/fuchsia-sdk/sdk:fdio",
"//third_party/fuchsia-sdk/sdk:images",
"//third_party/fuchsia-sdk/sdk:scenic_cpp",
"//third_party/fuchsia-sdk/sdk:ui_gfx",
"//third_party/fuchsia-sdk/sdk:ui_policy",
"//third_party/fuchsia-sdk/sdk:ui_scenic",
"//third_party/fuchsia-sdk/sdk:ui_viewsv1",
]
} else if (use_ozone) {
sources += util_ozone_sources
}
if (is_shared_library) {
defines = [ "LIBANGLE_UTIL_IMPLEMENTATION" ]
if (is_win) {
sources += util_win_shared_sources
}
public_deps += [ ":angle_util_loader" ]
if (is_mac && !is_component_build) {
ldflags = [
"-install_name",
"@rpath/libangle_util.dylib",
]
}
} else {
public_configs += [
":angle_static",
":gl_prototypes",
]
}
}
}
# Convenience targets for some of the samples so they can be built
# with Chromium's toolchain.
angle_executable("angle_shader_translator") {
testonly = true
sources = [
"samples/shader_translator/shader_translator.cpp",
]
deps = [
":translator",
]
}
config("angle_feature_support_config") {
include_dirs = [
"include",
"src",
]
defines = [ "LIBFEATURE_SUPPORT_IMPLEMENTATION" ]
if (is_debug) {
defines += [ "ANGLE_FEATURE_UTIL_LOG_VERBOSE" ]
}
}
angle_shared_library("libfeature_support${angle_libs_suffix}") {
if (is_android) {
libs = [ "log" ]
}
public_configs += [
":angle_feature_support_config",
"${angle_jsoncpp_dir}:jsoncpp_config",
]
if (is_mac && !is_component_build) {
ldflags = [
"-install_name",
"@rpath/${target_name}.dylib",
]
}
sources = [
"src/feature_support_util/feature_support_util.cpp",
"src/feature_support_util/feature_support_util.h",
]
deps = [
":angle_gpu_info_util",
"${angle_jsoncpp_dir}:jsoncpp",
]
}
if (!is_component_build && is_android && symbol_level != 0) {
action_foreach("compressed_symbols") {
sources = []
foreach(_library, angle_libraries) {
sources += [ "${root_out_dir}/lib${_library}${angle_libs_suffix}.so" ]
}
if (angle_enable_vulkan_validation_layers) {
foreach(_layer, vulkan_validation_layers) {
sources += [ "${root_out_dir}/lib${_layer}.so" ]
}
}
script = rebase_path("${root_build_dir}/android/compress_symbols.py",
root_build_dir)
deps = []
foreach(_library, angle_libraries) {
deps += [ "${angle_root}:lib${_library}${angle_libs_suffix}" ]
}
if (angle_enable_vulkan_validation_layers) {
foreach(_layer, vulkan_validation_layers) {
deps +=
[ "${angle_root}/third_party/vulkan-validation-layers:${_layer}" ]
}
}
outputs = [
"$root_out_dir/lib.compressed/{{source_file_part}}",
]
android_nm = "${android_tool_prefix}nm"
args = [
"--objcopy",
rebase_path(android_objcopy, root_build_dir),
"--nm",
rebase_path(android_nm, root_build_dir),
"--sofile",
"{{source}}",
"--unstrippedsofile",
"{{source_dir}}/lib.unstripped/{{source_file_part}}",
"--output",
"{{source_dir}}/lib.compressed/{{source_file_part}}",
]
}
}
if (!is_component_build && is_android &&
current_toolchain == default_toolchain) {
# Package ANGLE libraries for pre-installed system image
angle_apk("aosp_apk") {
package_name = "com.android.angle"
apk_name = "AngleAosp"
}
angle_apk("google_apk") {
package_name = "com.google.android.angle"
apk_name = "ANGLEPrebuilt"
}
group("angle_apks") {
deps = [
":aosp_apk",
":google_apk",
]
}
# Include a temporary target until we update builders to use angle_apks
group("angle_apk") {
deps = [
":angle_apks",
]
}
}