kc3-lang/angle/BUILD.gn

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Jonah Ryan-Davis
  Date : 2019-04-25 10:49:05
  Hash : 66e4850d
  Message : Use EnumAdapters to properly detect primary GPU on Win EnumDisplayDevicesA returns the card that's connected to the display, but EnumAdapters return the adapter which the desktop primary is displayed at index 0. We can use this to determine the device used for graphics. Also cleans up the discrepancy between platforms on finding "primary" vs "active" GPU. Asserts that the GPU expected to run ANGLE commands is the active GPU, and deprecates the primary GPU to be equal to the active GPU. Bug: angleproject:3383 Change-Id: I422fba1bbe47d85b7c09e378d559eaebf89e2625 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1584360 Commit-Queue: Jonah Ryan-Davis <jonahr@google.com> Reviewed-by: Geoff Lang <geofflang@chromium.org>

• BUILD.gn

• # 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_vulkan_conformant_configs_only) {
        defines += [ "ANGLE_VULKAN_CONFORMANT_CONFIGS_ONLY=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.
        "/we4715",  # not all control paths return a value
        "/we4800",  # forcing value to bool.
        "/we4838",  # narrowing conversion.
      ]
    }
    if (is_clang) {
      cflags += [
        # Enable after anglebug.com/3128 is fixed.
        # "-Wextra-semi-stmt",
  
        "-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") {
    # We also ship an older DLL for compatiblity with Windows 7 machines without
    # the UCRT. This DLL isn't available in the standard SDK distribution.
    _old_compiler = "$windows_sdk_path/Redist/D3D/$target_cpu/d3dcompiler_old.dll"
    _has_old_compiler =
        exec_script("scripts/file_exists.py", [ _old_compiler ], "value")
  
    copy("copy_compiler_dll") {
      sources = [
        "$windows_sdk_path/Redist/D3D/$target_cpu/d3dcompiler_47.dll",
      ]
  
      if (_has_old_compiler) {
        sources += [ _old_compiler ]
      }
  
      outputs = [
        "$root_out_dir/{{source_file_part}}",
      ]
    }
  }
  
  # Holds the shared includes so we only need to list them once.
  config("includes_config") {
    include_dirs = [ "include" ]
  }
  
  angle_source_set("includes") {
    sources = libangle_includes
    public_configs = [ ":includes_config" ]
  }
  
  angle_static_library("preprocessor") {
    sources = angle_preprocessor_sources
  
    public_deps = [
      ":angle_common",
    ]
  }
  
  config("angle_disable_pool_alloc") {
    defines = [ "ANGLE_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" ]
    if (use_fuzzing_engine) {
      all_dependent_configs += [ ":angle_disable_pool_alloc" ]
    }
  }
  
  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",
      ":angle_backend_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" ]
      libs += [ "dxgi.lib" ]
    }
  
    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" ]
  
    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("angle_backend_config") {
    defines = []
  
    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_custom_vulkan_cmd_buffers) {
        defines += [ "ANGLE_USE_CUSTOM_VULKAN_CMD_BUFFERS=1" ]
      }
    }
    if (angle_enable_null) {
      defines += [ "ANGLE_ENABLE_NULL" ]
    }
  }
  
  config("libANGLE_config") {
    cflags = []
    defines = []
    libs = []
    ldflags = []
    if (angle_enable_d3d9) {
      ldflags += [ "/DELAYLOAD:d3d9.dll" ]
    }
    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)) {
      # In API level 26 ANativeWindow APIs were moved from libandroid.so
      # into a separate library, libnativewindow.so
      if (ndk_api_level_at_least_26) {
        libs += [ "nativewindow" ]
      } else {
        libs += [ "android" ]
      }
    }
  }
  
  if (angle_enable_vulkan) {
    config("vulkan_config") {
      if (is_android) {
        libs = [ "vulkan" ]
      }
    }
  
    # 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",
      ":angle_backend_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_policy",
          "//third_party/fuchsia-sdk/sdk:ui_scenic",
          "//third_party/fuchsia-sdk/sdk:ui_views",
        ]
      } 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
    angle_apk("angle_chromium_apk") {
      package_name = "com.chromium.angle"
      apk_name = "AngleLibraries"
    }
  
    group("angle_apks") {
      deps = [
        ":angle_chromium_apk",
      ]
    }
  }