| #!/usr/bin/env python3 | |
| # Copyright 2014 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. | |
| """Helper script for GN to run `dart compile exe` and produce a depfile. | |
| Run with: | |
| python3 gn_dart_compile_exe.py \ | |
| --dart-binary <path to dart binary> \ | |
| --entry-point <path to dart entry point> \ | |
| --output <path to resulting executable> \ | |
| --sdk-hash <SDK hash> \ | |
| --packages <path to package config file> \ | |
| --depfile <path to depfile to write> | |
| This is workaround for `dart compile exe` not supporting --depfile option | |
| in the current version of prebuilt SDK. Once we roll in a new version | |
| of checked in SDK we can remove this helper. | |
| """ | |
| import argparse | |
| import os | |
| import sys | |
| import subprocess | |
| from tempfile import TemporaryDirectory | |
| def parse_args(argv): | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument("--dart-sdk", | |
| required=True, | |
| help="Path to the prebuilt Dart SDK") | |
| parser.add_argument("--sdk-hash", required=True, help="SDK hash") | |
| parser.add_argument("--entry-point", | |
| required=True, | |
| help="Dart entry point to precompile") | |
| parser.add_argument("--output", | |
| required=True, | |
| help="Path to resulting executable ") | |
| parser.add_argument("--packages", | |
| required=True, | |
| help="Path to package config file") | |
| parser.add_argument("--depfile", | |
| required=True, | |
| help="Path to depfile to write") | |
| return parser.parse_args(argv) | |
| # Run a command, swallowing the output unless there is an error. | |
| def run_command(command): | |
| try: | |
| subprocess.check_output(command, stderr=subprocess.STDOUT) | |
| return True | |
| except subprocess.CalledProcessError as e: | |
| print("Command failed: " + " ".join(command) + "\n" + "output: " + | |
| _decode(e.output)) | |
| return False | |
| except OSError as e: | |
| print("Command failed: " + " ".join(command) + "\n" + "output: " + | |
| _decode(e.strerror)) | |
| return False | |
| def _decode(bytes): | |
| return bytes.decode("utf-8") | |
| def main(argv): | |
| args = parse_args(argv[1:]) | |
| # Unless the path is absolute, this script is designed to run binaries | |
| # produced by the current build, which is the current working directory when | |
| # this script is run. | |
| prebuilt_sdk = os.path.abspath(args.dart_sdk) | |
| dart_binary = os.path.join(prebuilt_sdk, "bin", "dart") | |
| if not os.path.isfile(dart_binary): | |
| print("Binary not found: " + dart_binary) | |
| return 1 | |
| dartaotruntime_binary = os.path.join(prebuilt_sdk, "bin", "dartaotruntime") | |
| if not os.path.isfile(dartaotruntime_binary): | |
| print("Binary not found: " + dartaotruntime_binary) | |
| return 1 | |
| gen_kernel_snapshot = os.path.join(prebuilt_sdk, "bin", "snapshots", | |
| "gen_kernel_aot.dart.snapshot") | |
| if not os.path.isfile(gen_kernel_snapshot): | |
| print("Binary not found: " + gen_kernel_snapshot) | |
| return 1 | |
| platform_dill = os.path.join(prebuilt_sdk, "lib", "_internal", | |
| "vm_platform_strong.dill") | |
| if not os.path.isfile(platform_dill): | |
| print("Binary not found: " + platform_dill) | |
| return 1 | |
| # Compile the executable. | |
| ok = run_command([ | |
| dart_binary, | |
| "compile", | |
| "exe", | |
| "--packages", | |
| args.packages, | |
| f"-Dsdk_hash={args.sdk_hash}", | |
| "-o", | |
| args.output, | |
| args.entry_point, | |
| ]) | |
| if not ok: | |
| return 1 | |
| # Collect dependencies by using gen_kernel. | |
| with TemporaryDirectory() as tmpdir: | |
| output_dill = os.path.join(tmpdir, "output.dill") | |
| ok = run_command([ | |
| dartaotruntime_binary, | |
| gen_kernel_snapshot, | |
| "--platform", | |
| platform_dill, | |
| "--packages", | |
| args.packages, | |
| "--depfile", | |
| args.depfile, | |
| "-o", | |
| output_dill, | |
| args.entry_point, | |
| ]) | |
| if not ok: | |
| return 1 | |
| # Fix generated depfile to refer to the output file name instead | |
| # of referring to the temporary dill file we have generated. | |
| with open(args.depfile, "r") as f: | |
| content = f.read() | |
| (target_name, deps) = content.split(": ", 1) | |
| if target_name != output_dill: | |
| print( | |
| "ERROR: Something is wrong with generated depfile: expected {output_dill} as target, but got {target_name}" | |
| ) | |
| return 1 | |
| with open(args.depfile, "w") as f: | |
| f.write(args.output) | |
| f.write(": ") | |
| f.write(deps) | |
| return 0 | |
| if __name__ == "__main__": | |
| sys.exit(main(sys.argv)) |