| # Copyright 2013 The Flutter Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| # This file has rules for making Dart packages and snapshots. |
| |
| import("//build/compiled_action.gni") |
| import("//build/module_args/dart.gni") |
| import("//flutter/common/config.gni") |
| import("//third_party/dart/build/dart/dart_action.gni") |
| |
| # Creates a dart kernel (dill) file suitable for use with gen_snapshot, as well |
| # as the app-jit, aot-elf, or aot-assembly snapshot for Android or iOS. |
| # |
| # Invoker must supply dart_main and package_config. Invoker may optionally |
| # supply aot as a boolean and product as a boolean. |
| template("dart_snapshot") { |
| assert(!is_fuchsia) |
| assert(defined(invoker.main_dart), "main_dart is a required parameter.") |
| assert(defined(invoker.package_config), |
| "package_config is a required parameter.") |
| |
| kernel_target = "_${target_name}_kernel" |
| snapshot_target = "_${target_name}_snapshot" |
| is_aot = |
| flutter_runtime_mode == "profile" || flutter_runtime_mode == "release" |
| |
| kernel_output = "$target_gen_dir/kernel_blob.bin" |
| |
| prebuilt_dart_action(kernel_target) { |
| script = "//flutter/flutter_frontend_server/bin/starter.dart" |
| |
| main_dart = rebase_path(invoker.main_dart) |
| package_config = rebase_path(invoker.package_config) |
| flutter_patched_sdk = rebase_path("$root_out_dir/flutter_patched_sdk") |
| |
| deps = [ "//flutter/lib/snapshot:strong_platform" ] |
| |
| inputs = [ |
| main_dart, |
| package_config, |
| ] |
| |
| outputs = [ kernel_output ] |
| |
| depfile = "$kernel_output.d" |
| abs_depfile = rebase_path(depfile) |
| rebased_output = rebase_path(kernel_output, root_build_dir) |
| vm_args = [ |
| "--depfile=$abs_depfile", |
| "--depfile_output_filename=$rebased_output", |
| "--disable-dart-dev", |
| ] |
| |
| args = [ |
| "--packages=" + rebase_path(package_config), |
| "--target=flutter", |
| "--sdk-root=" + flutter_patched_sdk, |
| "--output-dill=" + rebase_path(kernel_output), |
| ] |
| |
| if (is_aot) { |
| args += [ |
| "--aot", |
| "--tfa", |
| ] |
| } else { |
| # --no-link-platform is only valid when --aot isn't specified |
| args += [ "--no-link-platform" ] |
| } |
| |
| if (defined(invoker.product) && invoker.product) { |
| # Setting this flag in a non-product release build for AOT (a "profile" |
| # build) causes the vm service isolate code to be tree-shaken from an app. |
| # See the pragma on the entrypoint here: |
| # |
| # https://github.com/dart-lang/sdk/blob/master/sdk/lib/_internal/vm/bin/vmservice_io.dart#L240 |
| # |
| # Also, this define excludes debugging and profiling code from Flutter. |
| args += [ "-Ddart.vm.product=true" ] |
| } else { |
| if (!is_debug) { |
| # The following define excludes debugging code from Flutter. |
| args += [ "-Ddart.vm.profile=true" ] |
| } |
| } |
| |
| args += [ rebase_path(main_dart) ] |
| } |
| |
| compiled_action(snapshot_target) { |
| if (target_cpu == "x86" && host_os == "linux") { |
| # By default Dart will create a 32-bit gen_snapshot host binary if the target |
| # platform is 32-bit. Override this to create a 64-bit gen_snapshot for x86 |
| # targets because some host platforms may not support 32-bit binaries. |
| tool = "//third_party/dart/runtime/bin:gen_snapshot_host_targeting_host" |
| toolchain = "//build/toolchain/$host_os:clang_x64" |
| } else { |
| tool = "//third_party/dart/runtime/bin:gen_snapshot" |
| } |
| |
| inputs = [ kernel_output ] |
| deps = [ ":$kernel_target" ] |
| outputs = [] |
| |
| args = [ "--lazy_async_stacks" ] |
| |
| if (is_debug && flutter_runtime_mode != "profile" && |
| flutter_runtime_mode != "release" && |
| flutter_runtime_mode != "jit_release") { |
| args += [ "--enable_asserts" ] |
| } |
| |
| if (is_aot) { |
| args += [ "--deterministic" ] |
| if (is_ios) { |
| snapshot_assembly = "$target_gen_dir/ios/snapshot_assembly.S" |
| outputs += [ snapshot_assembly ] |
| args += [ |
| "--snapshot_kind=app-aot-assembly", |
| "--assembly=" + rebase_path(snapshot_assembly), |
| ] |
| } else if (is_android) { |
| libapp = "$target_gen_dir/android/libs/$android_app_abi/libapp.so" |
| outputs += [ libapp ] |
| args += [ |
| "--snapshot_kind=app-aot-elf", |
| "--elf=" + rebase_path(libapp), |
| ] |
| } else { |
| assert(false) |
| } |
| } else { |
| deps += [ "//flutter/lib/snapshot:generate_snapshot_bin" ] |
| vm_snapshot_data = |
| "$root_gen_dir/flutter/lib/snapshot/vm_isolate_snapshot.bin" |
| snapshot_data = "$root_gen_dir/flutter/lib/snapshot/isolate_snapshot.bin" |
| isolate_snapshot_data = "$target_gen_dir/isolate_snapshot_data" |
| isolate_snapshot_instructions = "$target_gen_dir/isolate_snapshot_instr" |
| |
| inputs += [ |
| vm_snapshot_data, |
| snapshot_data, |
| ] |
| |
| outputs += [ |
| isolate_snapshot_data, |
| isolate_snapshot_instructions, |
| ] |
| args += [ |
| "--snapshot_kind=app-jit", |
| "--load_vm_snapshot_data=" + rebase_path(vm_snapshot_data), |
| "--load_isolate_snapshot_data=" + rebase_path(snapshot_data), |
| "--isolate_snapshot_data=" + rebase_path(isolate_snapshot_data), |
| "--isolate_snapshot_instructions=" + |
| rebase_path(isolate_snapshot_instructions), |
| ] |
| } |
| |
| args += [ rebase_path(kernel_output) ] |
| } |
| |
| group(target_name) { |
| public_deps = [ |
| ":$kernel_target", |
| ":$snapshot_target", |
| ] |
| } |
| } |
| |
| template("dart_pkg_helper") { |
| assert(defined(invoker.package_name)) |
| package_name = invoker.package_name |
| pkg_directory = rebase_path("$root_gen_dir/dart-pkg") |
| package_root = rebase_path("$root_gen_dir/dart-pkg/packages") |
| stamp_file = "$root_gen_dir/dart-pkg/${package_name}.stamp" |
| entries_file = "$root_gen_dir/dart-pkg/${package_name}.entries" |
| |
| assert(defined(invoker.sources) || defined(invoker.apps) || |
| defined(invoker.libs) || defined(invoker.pkg_dir)) |
| |
| action(target_name) { |
| deps = [] |
| if (defined(invoker.deps)) { |
| deps += invoker.deps |
| } |
| |
| datadeps = [] |
| if (defined(invoker.datadeps)) { |
| datadeps += invoker.datadeps |
| } |
| |
| sdk_ext_directory = [] |
| if (defined(invoker.sdk_ext_directory)) { |
| sdk_ext_directory += [ invoker.sdk_ext_directory ] |
| } |
| |
| sdk_ext_files = [] |
| if (defined(invoker.sdk_ext_files)) { |
| sdk_ext_files += invoker.sdk_ext_files |
| } |
| |
| sdk_ext_mappings = [] |
| if (defined(invoker.sdk_ext_mappings)) { |
| sdk_ext_mappings += invoker.sdk_ext_mappings |
| } |
| |
| script = rebase_path("//flutter/build/dart/tools/dart_pkg.py", ".", "//") |
| |
| entrypoints = [] |
| if (defined(invoker.apps)) { |
| foreach(app, invoker.apps) { |
| entrypoints += [ app[1] ] |
| } |
| } |
| if (defined(invoker.libs)) { |
| entrypoints += invoker.libs |
| } |
| |
| sources = entrypoints |
| extra_flags = [] |
| if (defined(invoker.sources)) { |
| sources += invoker.sources |
| } else if (defined(invoker.pkg_dir)) { |
| list_script = rebase_path("//flutter/build/dart/tools/ls.py", ".", "//") |
| extra_flags += [ "--read_only" ] |
| ls_sources = exec_script(list_script, |
| [ |
| "--target-directory", |
| rebase_path(invoker.pkg_dir), |
| ], |
| "list lines") |
| sources += ls_sources |
| } |
| |
| # We have to use foreach to set up outputs instead of rebase_path because |
| # GN doesn't like assignments to outputs that aren't obviously under |
| # $root_gen_dir somewhere. |
| outputs = [ |
| "$root_gen_dir/dart-pkg/${package_name}", |
| "$root_gen_dir/dart-pkg/${package_name}/pubspec.yaml", |
| "$root_gen_dir/dart-pkg/packages/${package_name}", |
| stamp_file, |
| ] |
| |
| inputs = [ script ] + rebase_path(sources) |
| |
| args = [ |
| "--package-name", |
| package_name, |
| "--dart-sdk", |
| rebase_path(dart_sdk_root), |
| "--pkg-directory", |
| pkg_directory, |
| "--package-root", |
| package_root, |
| "--stamp-file", |
| rebase_path(stamp_file), |
| "--entries-file", |
| rebase_path(entries_file), |
| "--package-sources", |
| ] + rebase_path(sources) + [ "--package-entrypoints" ] + |
| rebase_path(entrypoints) + [ "--sdk-ext-directories" ] + |
| rebase_path(sdk_ext_directory) + [ "--sdk-ext-files" ] + |
| rebase_path(sdk_ext_files) + [ "--sdk-ext-mappings" ] + |
| sdk_ext_mappings + extra_flags |
| } |
| } |
| |
| template("dart_pkg") { |
| if (defined(invoker.pkg_dir)) { |
| pubspec_yaml_path = rebase_path("pubspec.yaml", "", invoker.pkg_dir) |
| } else { |
| pubspec_yaml_path = rebase_path("pubspec.yaml") |
| } |
| dart_package_name_script = |
| rebase_path("//flutter/build/dart/tools/dart_package_name.py", ".", "//") |
| dart_package_name = exec_script(dart_package_name_script, |
| [ |
| "--pubspec", |
| pubspec_yaml_path, |
| ], |
| "trim string", |
| [ pubspec_yaml_path ]) |
| |
| dart_pkg_target_name = "${target_name}_pkg_helper" |
| dart_pkg_helper(dart_pkg_target_name) { |
| package_name = dart_package_name |
| if (defined(invoker.sources)) { |
| sources = invoker.sources |
| } |
| if (defined(invoker.apps)) { |
| apps = invoker.apps |
| } |
| if (defined(invoker.libs)) { |
| libs = invoker.libs |
| } |
| if (defined(invoker.pkg_dir)) { |
| pkg_dir = invoker.pkg_dir |
| } |
| if (defined(invoker.deps)) { |
| deps = invoker.deps |
| } |
| if (defined(invoker.datadeps)) { |
| datadeps = invoker.datadeps |
| } |
| if (defined(invoker.sdk_ext_directory)) { |
| sdk_ext_directory = invoker.sdk_ext_directory |
| } |
| if (defined(invoker.sdk_ext_files)) { |
| sdk_ext_files = invoker.sdk_ext_files |
| } |
| if (defined(invoker.sdk_ext_mappings)) { |
| sdk_ext_mappings = invoker.sdk_ext_mappings |
| } |
| } |
| |
| if (defined(invoker.apps)) { |
| pkg_helper_output_dir = "$root_gen_dir/dart-pkg/${dart_package_name}" |
| foreach(app, invoker.apps) { |
| app_name = app[0] |
| app_entrypoint = app[1] |
| dartx_output_name = app_name |
| dartx_application("${app_name}_dart_app") { |
| output_name = dartx_output_name |
| main_dart = rebase_path(app_entrypoint, "", pkg_helper_output_dir) |
| sources = [ "$root_gen_dir/dart-pkg/${dart_package_name}.stamp" ] |
| deps = [ ":$dart_pkg_target_name" ] |
| deps += invoker.deps |
| if (defined(invoker.strict)) { |
| strict = invoker.strict |
| } |
| } |
| } |
| } |
| |
| group(target_name) { |
| public_deps = [ ":$dart_pkg_target_name" ] |
| if (defined(invoker.apps)) { |
| foreach(app, invoker.apps) { |
| app_name = app[0] |
| dartx_target_name = "${app_name}_dart_app" |
| deps += [ ":$dartx_target_name" ] |
| } |
| } |
| } |
| } |
| |
| # Used to create dart_pkgs from a directory populated by fetch_dart_packages.py |
| # |
| # This build rule will result in a many packages under $root_gen_dir/dart-pkg/. |
| # |
| # base_dir (optional) |
| # Directory populated by fetch_dart_packages.py. Defaults to BUILD.gn |
| # directory. |
| template("dart_packages") { |
| base_dir = "." |
| if (defined(invoker.base_dir)) { |
| base_dir = invoker.base_dir |
| } |
| |
| # Determine list of packages. |
| list_script = |
| rebase_path("build/dart/dart/tools/fetch_dart_packages.py", ".", "//") |
| packages = exec_script(list_script, |
| [ |
| "--directory", |
| rebase_path(base_dir), |
| "--list", |
| ], |
| "list lines", |
| [ |
| rebase_path("pubspec.yaml"), |
| rebase_path("pubspec.lock"), |
| ]) |
| |
| # Generate dart_pkg for each package. |
| foreach(package_dir, packages) { |
| dart_pkg("$package_dir") { |
| pkg_dir = rebase_path("$package_dir") |
| } |
| } |
| |
| # Generate target group. |
| group(target_name) { |
| deps = [] |
| foreach(package_dir, packages) { |
| deps += [ ":$package_dir" ] |
| } |
| if (defined(invoker.deps)) { |
| deps += invoker.deps |
| } |
| } |
| } |
