BUILD.gn

# Copyright (C) 2018-2019 The ANGLE Project Authors.
# Copyright (C) 2019 LunarG, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import("//build_overrides/vulkan_validation_layers.gni")

# Fuchsia has non-upstream changes to the vulkan layers, so we don't want
# to build it from upstream sources.
assert(!is_fuchsia)

vulkan_registry_script_files = [
  "$vulkan_headers_dir/registry/cgenerator.py",
  "$vulkan_headers_dir/registry/conventions.py",
  "$vulkan_headers_dir/registry/generator.py",
  "$vulkan_headers_dir/registry/reg.py",
  "$vulkan_headers_dir/registry/vkconventions.py",
  "$vulkan_headers_dir/registry/vk.xml",
]

vulkan_undefine_configs = []
if (is_win) {
  vulkan_undefine_configs += [
    "//build/config/win:nominmax",
    "//build/config/win:unicode",
  ]
}

raw_vulkan_headers_dir = rebase_path("$vulkan_headers_dir", root_build_dir)

vulkan_gen_dir = "$target_gen_dir/$vulkan_gen_subdir"
raw_vulkan_gen_dir = rebase_path(vulkan_gen_dir, root_build_dir)

vulkan_data_dir = "$root_out_dir/$vulkan_data_subdir"
raw_vulkan_data_dir = rebase_path(vulkan_data_dir, root_build_dir)

raw_root_out_dir = rebase_path(root_out_dir, root_build_dir)

# Vulkan helper scripts
# ---------------------

helper_script_and_deps = [
  [
    "vulkan_gen_dispatch_table_helper_h",
    "vk_dispatch_table_helper.h",
    "dispatch_table_helper_generator.py",
  ],
  [
    "vulkan_gen_enum_string_helper",
    "vk_enum_string_helper.h",
    "helper_file_generator.py",
  ],
  [
    "vulkan_gen_extension_helper",
    "vk_extension_helper.h",
    "helper_file_generator.py",
  ],
  [
    "vulkan_gen_layer_dispatch_table_h",
    "vk_layer_dispatch_table.h",
    "layer_dispatch_table_generator.py",
  ],
  [
    "vulkan_gen_object_types_h",
    "vk_object_types.h",
    "helper_file_generator.py",
  ],
  [
    "vulkan_gen_safe_struct_cpp",
    "vk_safe_struct.cpp",
    "helper_file_generator.py",
  ],
  [
    "vulkan_gen_safe_struct_h",
    "vk_safe_struct.h",
    "helper_file_generator.py",
  ],
  [
    "vulkan_gen_thread_safety_h",
    "thread_safety.h",
    "thread_safety_generator.py",
  ],
  [
    "vulkan_gen_thread_safety_cpp",
    "thread_safety.cpp",
    "thread_safety_generator.py",
  ],
  [
    "vulkan_gen_typemap_helper",
    "vk_typemap_helper.h",
    "helper_file_generator.py",
  ],
  [
    "vulkan_gen_object_tracker_h",
    "object_tracker.h",
    "object_tracker_generator.py",
  ],
  [
    "vulkan_gen_object_tracker_cpp",
    "object_tracker.cpp",
    "object_tracker_generator.py",
  ],
  [
    "vulkan_gen_parameter_validation_cpp",
    "parameter_validation.cpp",
    "parameter_validation_generator.py",
  ],
  [
    "vulkan_gen_parameter_validation_h",
    "parameter_validation.h",
    "parameter_validation_generator.py",
  ],
  [
    "vulkan_gen_layer_chassis_h",
    "chassis.h",
    "layer_chassis_generator.py",
  ],
  [
    "vulkan_gen_layer_chassis_cpp",
    "chassis.cpp",
    "layer_chassis_generator.py",
  ],
  [
    "vulkan_gen_layer_chassis_dispatch_h",
    "layer_chassis_dispatch.h",
    "layer_chassis_dispatch_generator.py",
  ],
  [
    "vulkan_gen_layer_chassis_dispatch_cpp",
    "layer_chassis_dispatch.cpp",
    "layer_chassis_dispatch_generator.py",
  ],
]

# Python scripts needed for codegen, copy them to a temp dir
# so that all dependencies are together
copy("python_gen_deps") {
  sources = vulkan_registry_script_files + [
              "scripts/common_codegen.py",
              "scripts/dispatch_table_helper_generator.py",
              "scripts/helper_file_generator.py",
              "scripts/layer_dispatch_table_generator.py",
              "scripts/lvl_genvk.py",
              "scripts/object_tracker_generator.py",
              "scripts/parameter_validation_generator.py",
              "scripts/thread_safety_generator.py",
              "scripts/layer_chassis_generator.py",
              "scripts/layer_chassis_dispatch_generator.py",
            ]
  outputs = [
    "$vulkan_gen_dir/{{source_file_part}}",
  ]
}

# This special action is needed to remove previously-generated header files.
# Otherwise the cpp files can pick up the old header files and cause build
# failures.
action("vulkan_clean_gen_headers") {
  script = "build-gn/remove_files.py"
  deps = [
    ":python_gen_deps",
  ]
  outputs = [
    "$vulkan_gen_dir/vk_validation_error_messages_h_is_removed",
  ]
  args = [
    "$raw_vulkan_gen_dir/vk_validation_error_messages_h_is_removed",
    "$raw_vulkan_gen_dir/vk_validation_error_messages.h",
  ]
}

# This special action is needed to remove old VVL objects that are now renamed.
action("vulkan_clean_old_validation_layer_objects") {
  script = "build-gn/remove_files.py"

  # inputs is a (random) new file since the vvl roll, used to ensure the cleanup is done only once
  inputs = [
    "layers/gpu_validation.cpp",
  ]
  outputs = [
    "$vulkan_gen_dir/old_vvl_files_are_removed",
  ]
  args = [
    "$raw_vulkan_gen_dir/old_vvl_files_are_removed",
    "$raw_root_out_dir/libVkLayer*",
    "$raw_root_out_dir/VkLayer*",
    "$raw_vulkan_data_dir/VkLayer*.json",
  ]
}

foreach(script_and_dep, helper_script_and_deps) {
  target_name = script_and_dep[0]
  file = script_and_dep[1]
  dep = script_and_dep[2]
  target("action", target_name) {
    public_deps = [
      ":python_gen_deps",
      ":vulkan_clean_gen_headers",
      ":vulkan_clean_old_validation_layer_objects",
    ]
    script = "$vulkan_gen_dir/lvl_genvk.py"
    inputs = [
      "$vulkan_gen_dir/$dep",
      "$vulkan_gen_dir/common_codegen.py",
      "layers/vk_validation_error_messages.h",
    ]
    outputs = [
      "$vulkan_gen_dir/$file",
    ]
    args = [
      "-o",
      raw_vulkan_gen_dir,
      "-registry",
      "$raw_vulkan_headers_dir/registry/vk.xml",
      "-scripts",
      "$raw_vulkan_headers_dir/registry",
      "$file",
      "-quiet",
    ]
  }
}

raw_spirv_tools_dir = rebase_path("${vvl_spirv_tools_dir}", root_build_dir)

spirv_git_is_present = exec_script("build-gn/commit_id.py",
                                   [
                                     "check",
                                     raw_spirv_tools_dir,
                                   ],
                                   "value")

# This could be generalized to a foreach if other revisions are added.
action("spirv_tools_external_revision_generate") {
  script = "scripts/external_revision_generator.py"
  public_deps = [
    "${vvl_spirv_tools_dir}:spvtools",
    "${vvl_spirv_tools_dir}:spvtools_opt",
    "${vvl_spirv_tools_dir}:spvtools_val",
  ]
  outputs = [
    "$vulkan_gen_dir/spirv_tools_commit_id.h",
  ]
  args = [
    "-s",
    "SPIRV_TOOLS_COMMIT_ID",
    "-o",
    "$raw_vulkan_gen_dir/spirv_tools_commit_id.h",
  ]
  if (spirv_git_is_present == 1) {
    args += [
      "--git_dir",
      "$raw_spirv_tools_dir",
    ]
  } else {
    args += [ "--from_uuid" ]
  }
}

config("vulkan_generated_files_config") {
  include_dirs = [ vulkan_gen_dir ]
}

group("vulkan_generate_helper_files") {
  public_deps = [
    ":spirv_tools_external_revision_generate",
    "$vulkan_headers_dir:vulkan_headers",
  ]
  public_configs = [ ":vulkan_generated_files_config" ]
  foreach(script_and_dep, helper_script_and_deps) {
    target_name = script_and_dep[0]
    public_deps += [ ":$target_name" ]
  }
}

config("vulkan_internal_config") {
  defines = [
    "VULKAN_NON_CMAKE_BUILD",
    "API_NAME=\"Vulkan\"",
  ]
  if (is_clang || !is_win) {
    cflags = [ "-Wno-unused-function" ]
  }
  if (is_linux) {
    defines += [
      "SYSCONFDIR=\"/etc\"",
      "FALLBACK_CONFIG_DIRS=\"/etc/xdg\"",
      "FALLBACK_DATA_DIRS=\"/usr/local/share:/usr/share\"",
    ]
  }
}

# The validation layers
# ---------------------

config("vulkan_layer_config") {
  include_dirs = [ "layers" ]
}

core_validation_sources = [
  # This file is manually included in the layer
  # "$vulkan_gen_dir/vk_safe_struct.cpp",
  "$vulkan_gen_dir/vk_safe_struct.h",
  "layers/buffer_validation.cpp",
  "layers/buffer_validation.h",
  "layers/core_validation.cpp",
  "layers/core_validation.h",
  "layers/convert_to_renderpass2.cpp",
  "layers/descriptor_sets.cpp",
  "layers/descriptor_sets.h",
  "layers/drawdispatch.cpp",
  "layers/gpu_validation.cpp",
  "layers/gpu_validation.h",
  "layers/shader_validation.cpp",
  "layers/shader_validation.h",
  "layers/xxhash.c",
  "layers/xxhash.h",
]

object_lifetimes_sources = [
  "$vulkan_gen_dir/object_tracker.cpp",
  "$vulkan_gen_dir/object_tracker.h",
  "layers/object_tracker_utils.cpp",
]

stateless_validation_sources = [
  "$vulkan_gen_dir/parameter_validation.cpp",
  "$vulkan_gen_dir/parameter_validation.h",
  "layers/parameter_validation_utils.cpp",
]

thread_safety_sources = [
  "$vulkan_gen_dir/thread_safety.cpp",
  "$vulkan_gen_dir/thread_safety.h",
]

unique_objects_sources = []

chassis_sources = [
  "$vulkan_gen_dir/chassis.cpp",
  "$vulkan_gen_dir/chassis.h",
  "$vulkan_gen_dir/layer_chassis_dispatch.cpp",
  "$vulkan_gen_dir/layer_chassis_dispatch.h",
]

core_validation_deps = [ ":vulkan_core_validation_glslang" ]

object_lifetimes_deps = [
  ":vulkan_gen_object_tracker_cpp",
  ":vulkan_gen_object_tracker_h",
]

stateless_validation_deps = [ ":vulkan_gen_stateless_validation" ]

thread_safety_deps = [
  ":vulkan_gen_thread_safety_cpp",
  ":vulkan_gen_thread_safety_h",
]

unique_objects_deps = []

chassis_deps = [
  ":vulkan_gen_layer_chassis_cpp",
  ":vulkan_gen_layer_chassis_h",
  ":vulkan_gen_layer_chassis_dispatch_cpp",
  ":vulkan_gen_layer_chassis_dispatch_h",
]

layers = [
  [
    "core_validation",
    core_validation_sources + chassis_sources,
    core_validation_deps + chassis_deps,
    [ "BUILD_CORE_VALIDATION" ],
  ],
  [
    "object_lifetimes",
    object_lifetimes_sources + chassis_sources,
    object_lifetimes_deps + chassis_deps,
    [ "BUILD_OBJECT_TRACKER" ],
  ],
  [
    "stateless_validation",
    stateless_validation_sources + chassis_sources,
    stateless_validation_deps + chassis_deps,
    [ "BUILD_PARAMETER_VALIDATION" ],
  ],
  [
    "thread_safety",
    thread_safety_sources + chassis_sources,
    thread_safety_deps + chassis_deps,
    [ "BUILD_THREAD_SAFETY" ],
  ],
  [
    "unique_objects",
    unique_objects_sources + chassis_sources,
    unique_objects_deps + chassis_deps,
    [ "LAYER_CHASSIS_CAN_WRAP_HANDLES" ],
  ],
  [
    "khronos_validation",
    core_validation_sources + object_lifetimes_sources +
        stateless_validation_sources + thread_safety_sources +
        unique_objects_sources + chassis_sources,
    core_validation_deps + object_lifetimes_deps + stateless_validation_deps +
        thread_safety_deps + unique_objects_deps + chassis_deps,
    [
      "BUILD_KHRONOS_VALIDATION",
      "BUILD_CORE_VALIDATION",
      "BUILD_OBJECT_TRACKER",
      "BUILD_THREAD_SAFETY",
      "BUILD_PARAMETER_VALIDATION",
      "LAYER_CHASSIS_CAN_WRAP_HANDLES",
    ],
  ],
]

if (!is_android) {
  action("vulkan_gen_json_files") {
    script = "build-gn/generate_vulkan_layers_json.py"
    public_deps = [
      ":vulkan_clean_old_validation_layer_objects",
    ]
    json_names = [
      "VkLayer_core_validation.json",
      "VkLayer_object_lifetimes.json",
      "VkLayer_stateless_validation.json",
      "VkLayer_standard_validation.json",
      "VkLayer_thread_safety.json",
      "VkLayer_unique_objects.json",
      "VkLayer_khronos_validation.json",
    ]
    sources = [
      "$vulkan_headers_dir/include/vulkan/vulkan_core.h",
    ]
    outputs = []
    foreach(json_name, json_names) {
      sources += [ "layers/json/$json_name.in" ]
      outputs += [ "$vulkan_data_dir/$json_name" ]
    }
    args = [
             rebase_path("layers/json", root_build_dir),
             rebase_path(vulkan_data_dir, root_build_dir),
           ] + rebase_path(sources, root_build_dir)

    # The layer JSON files are part of the necessary data deps.
    data = outputs
  }
}

source_set("vulkan_layer_utils") {
  include_dirs = [ "layers" ]
  sources = [
    "layers/vk_format_utils.cpp",
    "layers/vk_format_utils.h",
    "layers/vk_layer_config.cpp",
    "layers/vk_layer_config.h",
    "layers/vk_layer_extension_utils.cpp",
    "layers/vk_layer_extension_utils.h",
    "layers/vk_layer_utils.cpp",
    "layers/vk_layer_utils.h",
  ]
  public_configs = [
    "$vulkan_headers_dir:vulkan_headers_config",
    ":vulkan_internal_config",
  ]
  configs -= [ "//build/config/compiler:chromium_code" ]
  configs += [ "//build/config/compiler:no_chromium_code" ]
  public_deps = [
    ":vulkan_generate_helper_files",
  ]
  configs -= vulkan_undefine_configs
}

config("vulkan_core_validation_config") {
  include_dirs = [ "$vvl_glslang_dir" ]
}

source_set("vulkan_core_validation_glslang") {
  public_deps = [
    "${vvl_spirv_tools_dir}:spvtools",
    "${vvl_spirv_tools_dir}:spvtools_opt",
    "${vvl_spirv_tools_dir}:spvtools_val",
  ]
  public_configs = [
    "$vulkan_headers_dir:vulkan_headers_config",
    ":vulkan_core_validation_config",
  ]
}

config("vulkan_stateless_validation_config") {
  if (is_clang) {
    cflags_cc = [ "-Wno-unused-const-variable" ]
  }
}

source_set("vulkan_gen_stateless_validation") {
  deps = [
    ":vulkan_gen_parameter_validation_cpp",
    ":vulkan_gen_parameter_validation_h",
  ]
  public_configs = [ ":vulkan_stateless_validation_config" ]
}

foreach(layer_info, layers) {
  name = layer_info[0]
  shared_library("VkLayer_$name") {
    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [ "//build/config/compiler:no_chromium_code" ]
    configs -= vulkan_undefine_configs
    public_configs = [ ":vulkan_layer_config" ]
    deps = [
      ":vulkan_layer_utils",
    ]
    if (layer_info[2] != "") {
      deps += layer_info[2]
    }
    sources = layer_info[1]
    if (is_win) {
      sources += [ "layers/VkLayer_$name.def" ]
    }
    if (is_linux || is_android) {
      ldflags = [ "-Wl,-Bsymbolic,--exclude-libs,ALL" ]
    }
    if (is_android) {
      libs = [
        "log",
        "nativewindow",
      ]
      configs -= [ "//build/config/android:hide_all_but_jni_onload" ]
    }
    defines = layer_info[3]
  }
}

group("vulkan_validation_layers") {
  data_deps = []
  foreach(layer_info, layers) {
    name = layer_info[0]
    data_deps += [ ":VkLayer_$name" ]
  }
}