cpp/prebuilt_shared_library.gni

# Copyright 2018 The Fuchsia 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("//build/sdk/sdk_atom.gni")

# A shared library that can be exported to an SDK in binary form.
#
# Parameters
#
#   category (required)
#     Publication level of the library in SDKs.
#     See //build/sdk/sdk_atom.gni.
#
#   no_headers (optional)
#     Whether to include the library's headers in the SDK.
#     Defaults to false.
#
#   sdk_name (optional)
#     Name of the library in the SDK.
#     If not specified, a name is inferred from the target's label.
#
#   include_base (optional)
#     Path to the root directory for includes.
#     Defaults to ".".
#
#   runtime_deps (optional)
#     List of labels representing the library's runtime dependencies. This is
#     only needed for runtime dependencies inherited from private dependencies.
#     Note that these labels should represent SDK targets.

# The defaults for a prebuilt_shared_library should match that of a shared_library.
set_defaults("prebuilt_shared_library") {
  configs = default_shared_library_configs
}

template("prebuilt_shared_library") {
  assert(defined(invoker.category), "Must define an SDK category")

  main_target_name = target_name
  manifest_target_name = "${target_name}_sdk_manifest"
  sdk_target_name = "${target_name}_sdk"

  shared_library(main_target_name) {
    forward_variables_from(invoker,
                           "*",
                           [
                             "category",
                             "include_base",
                             "no_headers",
                             "runtime_deps",
                             "sdk_name",
                           ])

    if (defined(visibility)) {
      visibility += [ ":$manifest_target_name" ]
    }

    # Request that the runtime deps be written out to a file. This file will be
    # used later to verify that all runtime deps are available in the SDK.
    write_runtime_deps = "$target_out_dir/$target_name.runtime_deps"
  }

  compute_name = false
  if (defined(invoker.sdk_name)) {
    atom_name = invoker.sdk_name
  } else if (defined(invoker.output_name)) {
    atom_name = invoker.output_name
  } else {
    compute_name = true
    name_target_name = "${target_name}_name"
    default_name = target_name
    target_label = get_label_info(":$target_name", "label_no_toolchain")
    atom_name_file = "$target_gen_dir/${target_name}_sdk_name.txt"

    action(name_target_name) {
      script = "//build/cpp/compute_sdk_name.py"

      outputs = [
        atom_name_file,
      ]

      args = [
        "--out",
        rebase_path(atom_name_file),
        "--default-name",
        default_name,
        "--label",
        target_label,
      ]
    }
  }

  sdk_manifest_file = "$target_gen_dir/$sdk_target_name.sdk"

  output_name = target_name
  if (defined(invoker.output_name)) {
    output_name = invoker.output_name
  }

  sdk_atom(manifest_target_name) {
    forward_variables_from(invoker,
                           "*",
                           [
                             "headers_only",
                             "include_base",
                             "prebuilt",
                             "sdk_name",
                           ])

    # Specify the path to the generated manifest file so that it matches the
    # label of the SDK (group) target below. This way the file will be found in
    # the location that the build system expects.
    manifest_file = sdk_manifest_file

    domain = "cpp"
    if (compute_name) {
      name_file = atom_name_file
    } else {
      name = atom_name
    }
    tags = [ "type:compiled_shared" ]

    category = invoker.category

    if (is_fuchsia) {
      tags += [ "arch:target" ]
    } else {
      tags += [ "arch:host" ]
    }

    no_headers = defined(invoker.no_headers) && invoker.no_headers

    files = []
    if ((defined(invoker.public) || defined(invoker.sources)) && !no_headers) {
      headers = []
      if (defined(invoker.public)) {
        headers += invoker.public
      } else {
        foreach(source_file, invoker.sources) {
          extension = get_path_info(source_file, "extension")
          if (extension == "h") {
            headers += [ source_file ]
          }
        }
      }
      foreach(header, headers) {
        include_base = "include"
        if (defined(invoker.include_base)) {
          include_base = invoker.include_base
        }
        destination = rebase_path(header, include_base)
        files += [
          {
            source = header
            dest = "include/$destination"
          },
        ]
      }
    }

    shared_out_dir = get_label_info(":bogus($shlib_toolchain)", "root_out_dir")
    lib_name = "lib$output_name.so"

    # TODO(TO-791): put ABI stubs under lib/, not the full thing.
    files += [
      {
        source = "$shared_out_dir/$lib_name"
        dest = "dist/$lib_name"
        packaged = true
      },
      {
        source = "$shared_out_dir/$lib_name"
        dest = "lib/$lib_name"
      },
      {
        source = "$shared_out_dir/lib.unstripped/$lib_name"
        dest = "debug/$lib_name"
      },
    ]

    deps = []

    # If a prebuilt library is only provided for packaging purposes (by not
    # exposing headers) then its dependencies need not be included in an SDK.
    if (defined(invoker.public_deps) && !no_headers) {
      foreach(dep, invoker.public_deps) {
        full_label = get_label_info(dep, "label_no_toolchain")
        deps += [ "${full_label}_sdk" ]
      }
    }

    if (defined(invoker.runtime_deps)) {
      package_deps = invoker.runtime_deps
    }

    non_sdk_deps = [ ":$main_target_name" ]
    if (compute_name) {
      non_sdk_deps += [ ":$name_target_name" ]
    }

    # Explicitly add non-public dependencies, in case some of the source files
    # are generated.
    if (defined(invoker.deps)) {
      non_sdk_deps += invoker.deps
    }
  }

  shared_gen_dir = get_label_info(":bogus($shlib_toolchain)", "target_out_dir")
  runtime_deps_file = "$shared_gen_dir/$target_name.runtime_deps"
  verify_target_name = "${target_name}_verify"

  # Verify that the SDK manifest for this target includes all of the expected
  # runtime dependencies.
  # TODO(pylaligand): also check that everything in there is either prebuilt or
  # headers only.
  action(verify_target_name) {
    script = "//build/cpp/verify_runtime_deps.py"

    inputs = [
      sdk_manifest_file,
      runtime_deps_file,
    ]

    stamp_file = "$target_gen_dir/$target_name.stamp"

    outputs = [
      stamp_file,
    ]

    args = [
      "--stamp",
      rebase_path(stamp_file),
      "--manifest",
      rebase_path(sdk_manifest_file),
      "--runtime-deps-file",
      rebase_path(runtime_deps_file),
      "--root-out-dir",
      rebase_path(root_out_dir),
    ]

    deps = [
      ":$main_target_name",
      ":$manifest_target_name",
    ]
  }

  group(sdk_target_name) {
    public_deps = [
      ":$manifest_target_name",
    ]

    deps = [
      ":$verify_target_name",
    ]
  }
}