BUILD.gn

# Copyright 2016 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("$flutter_root/lib/ui/dart_ui.gni")
import("//third_party/dart/utils/compile_platform.gni")
import("//third_party/dart/utils/generate_entry_points_json.gni")

if (is_fuchsia) {
  import("//build/dart/dart_library.gni")
  import("//build/dart/toolchain.gni")
  import("//topaz/public/dart-pkg/fuchsia/sdk_ext.gni")
  import("//topaz/public/dart-pkg/zircon/sdk_ext.gni")
  import("//topaz/public/lib/ui/flutter/sdk_ext/sdk_ext.gni")
}

bindings_output_dir = "$root_gen_dir/sky/bindings"

copy("generate_dart_ui") {
  sources = dart_ui_files

  outputs = [
    "$bindings_output_dir/dart_ui/{{source_file_part}}",
  ]
}

if (is_fuchsia) {
  dart_library("generate_package_map") {
    # The sole purpose of this target is to generate a .packages file.
    sources = []

    dot_packages_file = "$target_gen_dir/snapshot.packages"
    outputs = [
      dot_packages_file,
    ]
    deps = []
    foreach(dep, dart_deps) {
      deps += [ "$dep($dart_toolchain)" ]
    }

    disable_analysis = true

    script = "//build/dart/gen_dot_packages.py"
    args = [
             "--out",
             rebase_path(dot_packages_file, root_build_dir),
             "--source-dir",
             rebase_path("."),
             "--root-build-dir",
             rebase_path(root_build_dir),
             "--root-gen-dir",
             rebase_path(dart_root_gen_dir),
             "--package-name",
             "snapshot_root",
             "--depfile",
             rebase_path(depfile),
             "--deps",
           ] + dart_deps
  }
}

action("generate_snapshot_bin") {
  if (is_fuchsia) {
    snapshot_dart = "snapshot_fuchsia.dart"

    # TODO(rmacnak): Fuchsia cross builds use the wrong Dart target
    # architecture, and have added steps that depend on this error for
    # reasonable build times (e.g., invoking the analyzer).
    if (target_cpu == host_cpu) {
      snapshot_kind = "core-jit"
    } else {
      snapshot_kind = "core"
    }
  } else {
    snapshot_dart = "snapshot.dart"
    snapshot_kind = "core"
  }

  deps = [
    ":generate_dart_ui",
    "//third_party/dart/runtime/bin:gen_snapshot($host_toolchain)",
  ]
  depfile = "$target_gen_dir/core_snapshot.d"

  inputs = [
             "//third_party/dart/runtime/tools/create_snapshot_bin.py",
             snapshot_dart,
           ] + dart_ui_files
  if (is_fuchsia) {
    deps += [ ":generate_package_map" ]
    inputs += [ "fuchsia_compilation_trace.txt" ]
  }

  vm_snapshot_data = "$target_gen_dir/vm_isolate_snapshot.bin"
  vm_snapshot_instructions = "$target_gen_dir/vm_snapshot_instructions.bin"
  isolate_snapshot_data = "$target_gen_dir/isolate_snapshot.bin"
  isolate_snapshot_instructions =
      "$target_gen_dir/isolate_snapshot_instructions.bin"
  outputs = [
    vm_snapshot_data,
    vm_snapshot_instructions,
    isolate_snapshot_data,
    isolate_snapshot_instructions,
  ]

  rebased_dart_ui_path = rebase_path(dart_ui_path)

  gen_snapshot_dir = get_label_info(
          "//third_party/dart/runtime/bin:gen_snapshot($host_toolchain)",
          "root_out_dir")
  script = "//third_party/dart/runtime/tools/create_snapshot_bin.py"

  args = [
    "--executable",
    rebase_path("$gen_snapshot_dir/gen_snapshot"),
    "--script",
    rebase_path(snapshot_dart),
    "--snapshot_kind",
    snapshot_kind,
    "--vm_flag",
    "--await_is_keyword",
    "--vm_flag",
    "--enable_mirrors=false",
    "--vm_output_bin",
    rebase_path(vm_snapshot_data, root_build_dir),
    "--vm_instructions_output_bin",
    rebase_path(vm_snapshot_instructions, root_build_dir),
    "--isolate_output_bin",
    rebase_path(isolate_snapshot_data, root_build_dir),
    "--isolate_instructions_output_bin",
    rebase_path(isolate_snapshot_instructions, root_build_dir),
    "--url_mapping=dart:ui,$rebased_dart_ui_path",
    "--vm_flag",
    "--dependencies=" + rebase_path(depfile),
  ]

  if (is_debug) {
    args += [
      "--vm_flag",
      "--enable_asserts",
      "--vm_flag",
      "--enable_type_checks",
      "--vm_flag",
      "--error_on_bad_type",
      "--vm_flag",
      "--error_on_bad_override",
    ]
  }

  if (is_fuchsia) {
    package_gen_dir = get_label_info(":bogus($dart_toolchain)",
          "target_gen_dir")
    package_file = "$package_gen_dir/generate_package_map.packages"
    inputs += zircon_sdk_ext_files + mozart_dart_sdk_ext_files + [package_file]
    zircon_path = rebase_path(zircon_sdk_ext_lib)
    fuchsia_path = rebase_path(fuchsia_sdk_ext_lib)
    mozart_internal_path = rebase_path(mozart_dart_sdk_ext_lib)
    args += [
      "--url_mapping=dart:zircon,$zircon_path",
      "--url_mapping=dart:fuchsia,$fuchsia_path",
      "--url_mapping=dart:mozart.internal,$mozart_internal_path",
      "--packages",
      rebase_path(package_file),
      "--load_compilation_trace",
      rebase_path("fuchsia_compilation_trace.txt"),
    ]
  }
}

# Generates an assembly file defining a given symbol with the bytes from a
# binary file. Places the symbol in a text section if 'executable' is true,
# otherwise places the symbol in a read-only data section.
template("bin_to_assembly") {
  assert(defined(invoker.deps), "Must define deps")
  assert(defined(invoker.input), "Must define input binary file")
  assert(defined(invoker.output), "Must define output assembly file")
  assert(defined(invoker.symbol), "Must define symbol name")
  assert(defined(invoker.executable), "Must define boolean executable")

  action(target_name) {
    deps = invoker.deps
    script = "//third_party/dart/runtime/tools/bin_to_assembly.py"
    args = [
      "--input",
      rebase_path(invoker.input),
      "--output",
      rebase_path(invoker.output),
      "--symbol_name",
      invoker.symbol,
      "--target_os",
      current_os,
    ]
    if (invoker.executable) {
      args += [ "--executable" ]
    }
    inputs = [
      script,
      invoker.input,
    ]
    outputs = [
      invoker.output,
    ]
  }
}

bin_to_assembly("vm_snapshot_data_assembly") {
  deps = [
    ":generate_snapshot_bin",
  ]
  input = "$target_gen_dir/vm_isolate_snapshot.bin"
  output = "$target_gen_dir/vm_snapshot_data.S"
  symbol = "kDartVmSnapshotData"
  executable = false
}

bin_to_assembly("vm_snapshot_instructions_assembly") {
  deps = [
    ":generate_snapshot_bin",
  ]
  input = "$target_gen_dir/vm_snapshot_instructions.bin"
  output = "$target_gen_dir/vm_snapshot_instructions.S"
  symbol = "kDartVmSnapshotInstructions"
  executable = true
}

bin_to_assembly("isolate_snapshot_data_assembly") {
  deps = [
    ":generate_snapshot_bin",
  ]
  input = "$target_gen_dir/isolate_snapshot.bin"
  output = "$target_gen_dir/isolate_snapshot_data.S"
  symbol = "kDartIsolateSnapshotData"
  executable = false
}

bin_to_assembly("isolate_snapshot_instructions_assembly") {
  deps = [
    ":generate_snapshot_bin",
  ]
  input = "$target_gen_dir/isolate_snapshot_instructions.bin"
  output = "$target_gen_dir/isolate_snapshot_instructions.S"
  symbol = "kDartIsolateSnapshotInstructions"
  executable = true
}

source_set("snapshot") {
  deps = [
    ":isolate_snapshot_data_assembly",
    ":isolate_snapshot_instructions_assembly",
    ":vm_snapshot_data_assembly",
    ":vm_snapshot_instructions_assembly",
  ]
  sources = [
    "$target_gen_dir/isolate_snapshot_data.S",
    "$target_gen_dir/isolate_snapshot_instructions.S",
    "$target_gen_dir/vm_snapshot_data.S",
    "$target_gen_dir/vm_snapshot_instructions.S",
  ]
}

compile_platform("non_strong_platform") {
  sources = [
    "libraries.json",
  ]

  outputs = [
    "$root_out_dir/flutter_patched_sdk/platform.dill",
    "$root_out_dir/flutter_patched_sdk/vm_outline.dill",
  ]

  args = [
    "--target=flutter",
    "dart:core",
  ]
}

compile_platform("strong_platform") {
  sources = [
    "libraries.json",
  ]

  outputs = [
    "$root_out_dir/flutter_patched_sdk/platform_strong.dill",
    "$root_out_dir/flutter_patched_sdk/vm_outline_strong.dill",
  ]

  args = [
    "--target=flutter",
    "--strong",
    "dart:core",
  ]
}

group("kernel_platform_files") {
  public_deps = [
    ":non_strong_platform",
    ":strong_platform",
  ]
}

generate_entry_points_json_with_gen_snapshot("entry_points_json") {
  input = "$flutter_root/lib/snapshot/snapshot.dart"
  output = "$root_out_dir/dart_entry_points/entry_points.json"
  dart_ui = "$flutter_root/lib/ui/ui.dart"
  vmservice_io = "//third_party/dart/runtime/bin/vmservice/vmservice_io.dart"
  dart_vm_entry_points_txt = "$flutter_root/runtime/dart_vm_entry_points.txt"
  dart_io_entries_txt = "//third_party/dart/runtime/bin/dart_io_entries.txt"

  extra_inputs = [
    dart_ui,
    vmservice_io,
    dart_vm_entry_points_txt,
    dart_io_entries_txt,
  ]

  extra_args = [
    "--await_is_keyword",
    "--url_mapping=dart:ui," + rebase_path(dart_ui),
    "--url_mapping=dart:vmservice_io," + rebase_path(vmservice_io),
    "--causal_async_stacks",
    "--embedder_entry_points_manifest=" + rebase_path(dart_vm_entry_points_txt),
    "--embedder_entry_points_manifest=" + rebase_path(dart_io_entries_txt),
  ]
}

copy_entry_points_extra_json("entry_points_extra_json") {
  output = "$root_out_dir/dart_entry_points/entry_points_extra.json"
}

group("entry_points_json_files") {
  public_deps = [
    ":entry_points_json",
    ":entry_points_extra_json",
  ]
}