kc3-lang/angle/BUILD.gn

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Jamie Madill
  Date : 2017-10-21 22:19:40
  Hash : 6d94f064
  Message : Add more complete NULL driver for the GL back-end. This implements a NULL driver in OpenGL by stubbing out most of the GL functions in FunctionsGL except a few static "Gets" that are needed for initialization with Chromium and the tests. It is intended to be used for performance testing ONLY and will not have correct behaviour. It also adds a define to enable conditionally excluding the null entry points for implementations that wish to save on a bit of binary size. Also fixes some of the typedefs in functionsgl_typesdefs.h that were turned up after implementing the direct assignment from NULL stub entry point, generated from gl.xml, to the function pointer with type defined from functionsgl_typedefs.h. BUG=angleproject:2188 Change-Id: Ifa1e4739cb471ab6b52a4bf24c16d9eb4b334ac5 Reviewed-on: https://chromium-review.googlesource.com/727530 Commit-Queue: Jamie Madill <jmadill@chromium.org> Reviewed-by: Geoff Lang <geofflang@chromium.org>

• BUILD.gn

• # Copyright 2014-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 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")
  
  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)
  }
  
  if (!build_with_chromium) {
    group("all") {
      testonly = true
      deps = [
        ":angle_shader_translator",
        ":translator_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
  
  gles_gypi = exec_script("//build/gypi_to_gn.py",
                          [ rebase_path("src/libGLESv2.gypi") ],
                          "scope",
                          [ "src/libGLESv2.gypi" ])
  
  compiler_gypi = exec_script("//build/gypi_to_gn.py",
                              [ rebase_path("src/compiler.gypi") ],
                              "scope",
                              [ "src/compiler.gypi" ])
  
  # This config is exported to dependent targets (and also applied to internal
  # ones).
  config("external_config") {
    include_dirs = [ "include" ]
  }
  
  # This config is applied to internal Angle targets (not pushed to dependents).
  config("internal_config") {
    include_dirs = [
      "include",
      "src",
    ]
  
    # Prevent the GL headers from redeclaring ANGLE entry points.
    defines = [
      "GL_GLEXT_PROTOTYPES",
      "EGL_EGLEXT_PROTOTYPES",
    ]
  
    if (target_cpu == "x86") {
      defines += [ "ANGLE_X86_CPU" ]
    }
    if (target_cpu == "x64") {
      defines += [ "ANGLE_X64_CPU" ]
    }
  }
  
  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.
      ]
    }
    if (is_clang) {
      # Remove when crbug.com/428099 is resolved.
      cflags += [ "-Winconsistent-missing-override" ]
    }
  }
  
  if (is_win) {
    copy("copy_compiler_dll") {
      sources = [
        "$windows_sdk_path/Redist/D3D/$target_cpu/d3dcompiler_47.dll",
      ]
      outputs = [
        "$root_out_dir/d3dcompiler_47.dll",
      ]
    }
  }
  
  angle_undefine_configs = [ "//build/config/compiler:default_include_dirs" ]
  
  # Holds the shared includes so we only need to list them once.
  source_set("includes") {
    sources = [
      "include/EGL/egl.h",
      "include/EGL/eglext.h",
      "include/EGL/eglplatform.h",
      "include/GLES2/gl2.h",
      "include/GLES2/gl2ext.h",
      "include/GLES2/gl2platform.h",
      "include/GLES3/gl3.h",
      "include/GLES3/gl31.h",
      "include/GLES3/gl32.h",
      "include/GLES3/gl3platform.h",
      "include/GLSLANG/ShaderLang.h",
      "include/KHR/khrplatform.h",
    ]
  }
  
  static_library("preprocessor") {
    sources = rebase_path(compiler_gypi.angle_preprocessor_sources, ".", "src")
  
    configs -= angle_undefine_configs
    configs += [
      ":extra_warnings",
      ":internal_config",
    ]
  
    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" ]
  }
  
  static_library("angle_common") {
    sources = rebase_path(gles_gypi.libangle_common_sources, ".", "src")
  
    if (is_linux || is_android) {
      sources += rebase_path(gles_gypi.libangle_common_linux_sources, ".", "src")
    }
  
    if (is_mac) {
      sources += rebase_path(gles_gypi.libangle_common_mac_sources, ".", "src")
    }
  
    if (is_win) {
      sources += rebase_path(gles_gypi.libangle_common_win_sources, ".", "src")
    }
  
    configs -= angle_undefine_configs
    configs += [
      ":angle_common_config",
      ":debug_annotations_config",
      ":extra_warnings",
      ":internal_config",
    ]
  
    public_deps = [
      ":commit_id",
    ]
    public_configs = [ ":angle_common_config" ]
    all_dependent_configs = [ ":angle_release_asserts_config" ]
  }
  
  config("angle_image_util_config") {
    include_dirs = [
      "include",
      "src",
    ]
  }
  
  static_library("angle_image_util") {
    sources = rebase_path(gles_gypi.libangle_image_util_sources, ".", "src")
  
    configs -= angle_undefine_configs
    configs += [
      ":internal_config",
      ":extra_warnings",
    ]
  
    public_configs = [ ":angle_image_util_config" ]
  
    public_deps = [
      ":angle_common",
    ]
  }
  
  config("angle_gpu_info_util_config") {
    include_dirs = [
      "include",
      "src",
    ]
  }
  
  static_library("angle_gpu_info_util") {
    configs -= angle_undefine_configs
    configs += [
      ":internal_config",
      ":extra_warnings",
    ]
  
    public_configs = [ ":angle_gpu_info_util_config" ]
  
    public_deps = [
      ":angle_common",
    ]
  
    sources = rebase_path(gles_gypi.libangle_gpu_info_util_sources, ".", "src")
    deps = []
    libs = []
    defines = []
  
    if (is_win) {
      sources +=
          rebase_path(gles_gypi.libangle_gpu_info_util_win_sources, ".", "src")
      libs += [ "setupapi.lib" ]
      defines += [ "GPU_INFO_USE_SETUPAPI" ]
    }
  
    if (is_linux) {
      sources +=
          rebase_path(gles_gypi.libangle_gpu_info_util_linux_sources, ".", "src")
  
      if (use_x11) {
        sources +=
            rebase_path(gles_gypi.libangle_gpu_info_util_x11_sources, ".", "src")
        deps += [ "src/third_party/libXNVCtrl:libXNVCtrl" ]
        defines += [ "GPU_INFO_USE_X11" ]
        libs += [
          "X11",
          "Xi",
          "Xext",
        ]
      }
    }
  
    if (use_libpci) {
      sources +=
          rebase_path(gles_gypi.libangle_gpu_info_util_libpci_sources, ".", "src")
      defines += [ "GPU_INFO_USE_LIBPCI" ]
      libs += [ "pci" ]
    }
  
    if (is_mac) {
      sources +=
          rebase_path(gles_gypi.libangle_gpu_info_util_mac_sources, ".", "src")
      libs += [
        "IOKit.framework",
        "CoreFoundation.framework",
      ]
    }
  }
  
  static_library("translator") {
    sources = rebase_path(compiler_gypi.angle_translator_sources, ".", "src")
    defines = []
  
    if (angle_enable_essl || use_fuzzing_engine) {
      sources +=
          rebase_path(compiler_gypi.angle_translator_essl_sources, ".", "src")
      defines += [ "ANGLE_ENABLE_ESSL" ]
    }
  
    if (angle_enable_glsl || use_fuzzing_engine) {
      sources +=
          rebase_path(compiler_gypi.angle_translator_glsl_sources, ".", "src")
      defines += [ "ANGLE_ENABLE_GLSL" ]
    }
  
    if (angle_enable_hlsl || use_fuzzing_engine) {
      sources +=
          rebase_path(compiler_gypi.angle_translator_hlsl_sources, ".", "src")
      defines += [ "ANGLE_ENABLE_HLSL" ]
    }
  
    if (angle_enable_vulkan || use_fuzzing_engine) {
      sources += rebase_path(compiler_gypi.angle_translator_lib_vulkan_sources,
                             ".",
                             "src")
      defines += [ "ANGLE_ENABLE_VULKAN" ]
    }
  
    configs -= angle_undefine_configs
    configs += [
      ":internal_config",
      ":extra_warnings",
    ]
    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" ]
    }
  }
  
  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" ]
  }
  
  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,
      ]
  
      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" ]
    }
  }
  
  config("libANGLE_config") {
    cflags = []
    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_null) {
      defines += [ "ANGLE_ENABLE_NULL" ]
    }
    defines += [ "LIBANGLE_IMPLEMENTATION" ]
  
    if (is_win) {
      cflags += [ "/wd4530" ]  # C++ exception handler used, but unwind semantics are not enabled.
    }
  }
  
  static_library("libANGLE") {
    sources = rebase_path(gles_gypi.libangle_sources, ".", "src")
  
    include_dirs = []
    libs = []
    defines = []
    public_deps = [
      ":angle_common",
    ]
    deps = [
      ":angle_gpu_info_util",
      ":angle_image_util",
      ":commit_id",
      ":includes",
      ":translator",
    ]
  
    # Shared D3D sources.
    if (angle_enable_d3d9 || angle_enable_d3d11) {
      sources += rebase_path(gles_gypi.libangle_d3d_shared_sources, ".", "src")
  
      defines += [ "ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES={ " + "\"d3dcompiler_47.dll\", \"d3dcompiler_46.dll\", \"d3dcompiler_43.dll\" }" ]
    }
  
    if (angle_enable_d3d9) {
      sources += rebase_path(gles_gypi.libangle_d3d9_sources, ".", "src")
      libs += [ "d3d9.lib" ]
    }
  
    if (angle_enable_d3d11) {
      sources += rebase_path(gles_gypi.libangle_d3d11_sources, ".", "src")
      sources += rebase_path(gles_gypi.libangle_d3d11_win32_sources, ".", "src")
      libs += [ "dxguid.lib" ]
    }
  
    if (angle_enable_gl) {
      sources += rebase_path(gles_gypi.libangle_gl_sources, ".", "src")
      include_dirs += [ "src/third_party/khronos" ]
  
      if (angle_enable_gl_null) {
        sources += rebase_path(gles_gypi.libangle_gl_null_sources, ".", "src")
      }
      if (is_win) {
        sources += rebase_path(gles_gypi.libangle_gl_wgl_sources, ".", "src")
      }
      if (use_x11) {
        sources += rebase_path(gles_gypi.libangle_gl_glx_sources, ".", "src")
        deps += [ "src/third_party/libXNVCtrl:libXNVCtrl" ]
        libs += [
          "X11",
          "Xi",
          "Xext",
        ]
      }
      if (is_mac) {
        sources += rebase_path(gles_gypi.libangle_gl_cgl_sources, ".", "src")
        libs += [
          "Cocoa.framework",
          "IOSurface.framework",
          "OpenGL.framework",
          "QuartzCore.framework",
        ]
      }
      if (is_android) {
        sources += rebase_path(gles_gypi.libangle_gl_egl_sources, ".", "src")
        sources += rebase_path(gles_gypi.libangle_gl_egl_dl_sources, ".", "src")
        sources +=
            rebase_path(gles_gypi.libangle_gl_egl_android_sources, ".", "src")
        libs += [
          "android",
          "log",
        ]
      }
      if (ozone_platform_gbm) {
        configs += [ ":libdrm" ]
        defines += [ "ANGLE_USE_OZONE" ]
        deps += [ "//third_party/minigbm" ]
        sources += rebase_path(gles_gypi.libangle_gl_egl_sources, ".", "src")
        sources += rebase_path(gles_gypi.libangle_gl_egl_dl_sources, ".", "src")
        sources += rebase_path(gles_gypi.libangle_gl_ozone_sources, ".", "src")
      }
    }
  
    if (angle_enable_vulkan) {
      sources += rebase_path(gles_gypi.libangle_vulkan_sources, ".", "src")
      if (is_win) {
        sources +=
            rebase_path(gles_gypi.libangle_vulkan_win32_sources, ".", "src")
      }
      if (is_linux) {
        sources += rebase_path(gles_gypi.libangle_vulkan_xcb_sources, ".", "src")
      }
      deps += [ "src/vulkan_support:angle_vulkan" ]
    }
  
    if (angle_enable_null) {
      sources += rebase_path(gles_gypi.libangle_null_sources, ".", "src")
    }
  
    if (is_debug) {
      defines += [ "ANGLE_GENERATE_SHADER_DEBUG_INFO" ]
    }
  
    configs -= angle_undefine_configs
  
    configs += [
      ":commit_id_config",
      ":debug_annotations_config",
      ":extra_warnings",
      ":internal_config",
    ]
  
    public_configs = [ ":libANGLE_config" ]
  
    if (is_win) {
      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/",
      ]
    }
  }
  
  # This config controls export definitions on ANGLE API calls.
  config("angle_static") {
    defines = [
      "ANGLE_EXPORT=",
      "EGLAPI=",
      "GL_APICALL=",
    ]
  }
  
  shared_library("libGLESv2") {
    sources = rebase_path(gles_gypi.libglesv2_sources, ".", "src")
  
    if (is_android) {
      configs -= [ "//build/config/android:hide_all_but_jni_onload" ]
    }
  
    if (is_win) {
      ldflags =
          [ "/DEF:" + rebase_path("src/libGLESv2/libGLESv2.def", root_build_dir) ]
    }
  
    if (is_mac && !is_component_build) {
      ldflags = [
        "-install_name",
        "@rpath/${target_name}.dylib",
      ]
      public_configs = [ ":shared_library_public_config" ]
    }
  
    configs -= angle_undefine_configs
    configs += [
      ":commit_id_config",
      ":debug_annotations_config",
      ":extra_warnings",
      ":internal_config",
    ]
  
    defines = [ "LIBGLESV2_IMPLEMENTATION" ]
    if (is_win) {
      defines += [ "GL_APICALL=" ]
    } else {
      defines += [ "GL_APICALL=__attribute__((visibility(\"default\")))" ]
    }
  
    deps = [
      ":includes",
      ":libANGLE",
      "//build/config:exe_and_shlib_deps",
    ]
  }
  
  static_library("libGLESv2_static") {
    sources = rebase_path(gles_gypi.libglesv2_sources, ".", "src")
  
    configs -= angle_undefine_configs
    configs += [
      ":commit_id_config",
      ":debug_annotations_config",
      ":extra_warnings",
      ":internal_config",
    ]
  
    public_configs = [ ":angle_static" ]
  
    deps = [
      ":includes",
      ":libANGLE",
    ]
  }
  
  shared_library("libEGL") {
    sources = rebase_path(gles_gypi.libegl_sources, ".", "src")
  
    if (is_android) {
      configs -= [ "//build/config/android:hide_all_but_jni_onload" ]
    }
    configs -= angle_undefine_configs
    configs += [
      ":commit_id_config",
      ":debug_annotations_config",
      ":extra_warnings",
      ":internal_config",
    ]
  
    defines = [ "LIBEGL_IMPLEMENTATION" ]
    if (is_win) {
      defines += [ "EGLAPI=" ]
    } else {
      defines += [ "EGLAPI=__attribute__((visibility(\"default\")))" ]
    }
  
    if (is_win) {
      ldflags = [ "/DEF:" + rebase_path("src/libEGL/libEGL.def", root_build_dir) ]
    }
  
    if (is_mac && !is_component_build) {
      ldflags = [
        "-install_name",
        "@rpath/${target_name}.dylib",
      ]
      public_configs = [ ":shared_library_public_config" ]
    }
  
    deps = [
      ":includes",
      ":libGLESv2",
      "//build/config:exe_and_shlib_deps",
    ]
  }
  
  static_library("libEGL_static") {
    sources = rebase_path(gles_gypi.libegl_sources, ".", "src")
  
    configs -= angle_undefine_configs
    configs += [
      ":commit_id_config",
      ":debug_annotations_config",
      ":extra_warnings",
      ":internal_config",
    ]
  
    public_configs = [ ":angle_static" ]
  
    deps = [
      ":includes",
      ":libGLESv2_static",
    ]
  }
  
  util_gypi = exec_script("//build/gypi_to_gn.py",
                          [ rebase_path("util/util.gyp") ],
                          "scope",
                          [ "util/util.gyp" ])
  
  config("angle_util_config") {
    include_dirs = [ "util" ]
    if (is_linux && use_x11) {
      libs = [ "X11" ]
    }
  }
  
  foreach(is_shared_library,
          [
            true,
            false,
          ]) {
    if (is_shared_library) {
      library_type = "shared_library"
      library_name = "angle_util"
      dep_suffix = ""
    } else {
      library_type = "static_library"
      library_name = "angle_util_static"
      dep_suffix = "_static"
    }
  
    target(library_type, library_name) {
      sources = rebase_path(util_gypi.util_sources, ".", "util")
  
      if (is_win) {
        sources += rebase_path(util_gypi.util_win32_sources, ".", "util")
      }
  
      if (is_linux) {
        sources += rebase_path(util_gypi.util_linux_sources, ".", "util")
        libs = [
          "rt",
          "dl",
        ]
      }
  
      if (is_mac) {
        sources += rebase_path(util_gypi.util_osx_sources, ".", "util")
        libs = [
          "AppKit.framework",
          "QuartzCore.framework",
        ]
      }
  
      if (use_x11) {
        sources += rebase_path(util_gypi.util_x11_sources, ".", "util")
      }
  
      if (is_android) {
        if (is_shared_library) {
          configs -= [ "//build/config/android:hide_all_but_jni_onload" ]
        }
  
        # To prevent linux sources filtering on android
        set_sources_assignment_filter([])
        sources += rebase_path(util_gypi.util_linux_sources, ".", "util")
        sources += rebase_path(util_gypi.util_android_sources, ".", "util")
        libs = [
          "android",
          "log",
        ]
      }
  
      if (use_ozone) {
        sources += rebase_path(util_gypi.util_ozone_sources, ".", "util")
      }
  
      configs += [
        ":debug_annotations_config",
        ":extra_warnings",
      ]
  
      public_configs = [
        ":angle_util_config",
        ":internal_config",
      ]
  
      deps = [
        ":angle_common",
        ":libEGL${dep_suffix}",
        ":libGLESv2${dep_suffix}",
      ]
  
      if (is_shared_library) {
        defines = [ "LIBANGLE_UTIL_IMPLEMENTATION" ]
  
        deps += [ "//build/config:exe_and_shlib_deps" ]
  
        if (is_mac && !is_component_build) {
          ldflags = [
            "-install_name",
            "@rpath/lib${target_name}.dylib",
          ]
          public_configs += [ ":shared_library_public_config" ]
        }
      }
    }
  }
  
  # Convenience targets for some of the samples so they can be built
  # with Chromium's toolchain.
  
  executable("angle_shader_translator") {
    testonly = true
  
    sources = [
      "samples/shader_translator/shader_translator.cpp",
    ]
  
    deps = [
      ":translator",
      "//build/config:exe_and_shlib_deps",
    ]
  }