kc3-lang/angle/BUILD.gn

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Jamie Madill
  Date : 2017-01-05 14:47:34
  Hash : dcab56a1
  Message : Move some file utils to common. Since common is shared through all ANGLE code (libANGLE/tests/samples) this is the most general place for these utils, and will give libANGLE access to them. We'll need them to get the current executable dir for loading the Vulkan layers. This also means we'll need to fix the global static variable use when we have the ability. BUG=angleproject:1319 BUG=chromium:677841 Change-Id: I7af61920635135b28a2f02f4a8d019ee88c9dd28 Reviewed-on: https://chromium-review.googlesource.com/425440 Commit-Queue: Jamie Madill <jmadill@chromium.org> Reviewed-by: Jamie Madill <jmadill@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("//third_party/angle/gni/angle.gni")
  import("//ui/ozone/ozone.gni")
  
  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",
    ]
  }
  
  config("extra_warnings") {
    # 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_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 += [ ":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/numerics" ]
  }
  
  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_release_asserts_config",
      ":angle_common_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" ]
  
    public_configs = [ ":angle_image_util_config" ]
  
    public_deps = [
      ":angle_common",
    ]
  }
  
  static_library("translator") {
    sources = rebase_path(compiler_gypi.angle_translator_sources, ".", "src")
    defines = []
  
    if (angle_enable_essl || use_libfuzzer) {
      sources +=
          rebase_path(compiler_gypi.angle_translator_essl_sources, ".", "src")
      defines += [ "ANGLE_ENABLE_ESSL" ]
    }
  
    if (angle_enable_glsl || use_libfuzzer) {
      sources +=
          rebase_path(compiler_gypi.angle_translator_glsl_sources, ".", "src")
      defines += [ "ANGLE_ENABLE_GLSL" ]
    }
  
    if (angle_enable_hlsl || use_libfuzzer) {
      sources +=
          rebase_path(compiler_gypi.angle_translator_hlsl_sources, ".", "src")
      defines += [ "ANGLE_ENABLE_HLSL" ]
    }
    configs -= angle_undefine_configs
    configs += [ ":internal_config" ]
    public_configs = [ ":external_config" ]
    if (use_libfuzzer) {
      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_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_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 (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")
      deps += [ "//third_party/angle/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_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",
      ":internal_config",
    ]
  
    defines = [ "LIBGLESV2_IMPLEMENTATION" ]
    if (is_win) {
      defines += [ "GL_APICALL=" ]
    } else {
      defines += [ "GL_APICALL=__attribute__((visibility(\"default\")))" ]
    }
  
    deps = [
      ":includes",
      ":libANGLE",
    ]
  }
  
  static_library("libGLESv2_static") {
    sources = rebase_path(gles_gypi.libglesv2_sources, ".", "src")
  
    configs -= angle_undefine_configs
    configs += [
      ":commit_id_config",
      ":debug_annotations_config",
      ":internal_config",
    ]
  
    public_configs = [ ":angle_static" ]
  
    deps = [
      ":includes",
      ":libANGLE",
    ]
  }
  
  shared_library("libEGL") {
    sources = rebase_path(gles_gypi.libegl_sources, ".", "src")
  
    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",
    ]
  }
  
  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) {
        # 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" ]
  
        if (is_mac && !is_component_build) {
          ldflags = [
            "-install_name",
            "@rpath/lib${target_name}.dylib",
          ]
          public_configs += [ ":shared_library_public_config" ]
        }
      }
    }
  }