# Copyright 2024 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import argparse
import json
import os
import subprocess
import sys
import shutil
import tempfile
TARGET_CPU_MAPPING = {
'x64': 'x86_64',
'arm64': 'arm64',
}
METADATA_FILES = ('extract.actionsdata', 'version.json')
def read_json(path):
"""Reads JSON file at `path`."""
with open(path, encoding='utf8') as stream:
return json.load(stream)
def add_argument(parser, name, help, required=True):
"""Add argument --{name} to `parser` with description `help`."""
parser.add_argument(f'--{name}', required=required, help=help)
def extract_metadata(parsed, module_name, swift_files, const_files):
"""
Extracts metadata for `module_name` according to `parsed`.
If the extraction fails or no metadata is generated, terminate the script
with an error (after printing the command stdout/stderr to stderr).
"""
metadata_dir = os.path.join(parsed.output, 'Metadata.appintents')
if os.path.exists(metadata_dir):
shutil.rmtree(metadata_dir)
target_cpu = TARGET_CPU_MAPPING[parsed.target_cpu]
target_triple = f'{target_cpu}-apple-ios{parsed.deployment_target}'
if parsed.target_environment == 'simulator':
target_triple += '-simulator'
command = [
os.path.join(parsed.toolchain_dir, 'usr/bin/appintentsmetadataprocessor'),
'--toolchain-dir',
parsed.toolchain_dir,
'--sdk-root',
parsed.sdk_root,
'--deployment-target',
parsed.deployment_target,
'--target-triple',
target_triple,
'--module-name',
module_name,
'--output',
parsed.output,
'--binary-file',
parsed.binary_file,
'--compile-time-extraction',
]
inputs = set()
inputs.add(parsed.binary_file)
for swift_file in swift_files:
inputs.add(swift_file)
command.extend(('--source-files', swift_file))
for const_file in const_files:
inputs.add(const_file)
command.extend(('--swift-const-vals', const_file))
if parsed.xcode_version is not None:
command.extend(('--xcode-version', parsed.xcode_version))
process = subprocess.Popen(command,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
(stdout, stderr) = process.communicate()
if process.returncode:
sys.stderr.write(stdout.decode('utf8'))
sys.stderr.write(stderr.decode('utf8'))
return process.returncode
# Force failure if the tool extracted no data. This is because gn does
# not support optional outputs and thus it would consider the build as
# dirty if the output is missing.
if not os.path.exists(metadata_dir):
sys.stderr.write(f'error: no metadata generated for {module_name}\n')
sys.stderr.write(stdout.decode('utf8'))
sys.stderr.write(stderr.decode('utf8'))
return 1 # failure
output_files = METADATA_FILES
with open(parsed.depfile, 'w', encoding='utf8') as depfile:
for output in output_files:
depfile.write(f'{metadata_dir}/{output}:')
for item in sorted(inputs):
depfile.write(f' {item}')
depfile.write('\n')
return 0 # success
def main(args):
parser = argparse.ArgumentParser()
add_argument(parser, 'output', 'path to the output directory')
add_argument(parser, 'depfile', 'path to the output depfile')
add_argument(parser, 'toolchain-dir', 'path to the toolchain directory')
add_argument(parser, 'sdk-root', 'path to the SDK root directory')
add_argument(parser, 'target-cpu', 'target cpu architecture')
add_argument(parser, 'target-environment', 'target environment')
add_argument(parser, 'deployment-target', 'deployment target version')
add_argument(parser, 'binary-file', 'path to the binary to process')
add_argument(parser, 'module-info-path', 'path to the module info JSON file')
add_argument(parser, 'xcode-version', 'version of Xcode', required=False)
parsed = parser.parse_args(args)
module_info = read_json(parsed.module_info_path)
return extract_metadata(
parsed, #
module_info['module_name'],
module_info['swift_files'],
module_info['const_files'])
if __name__ == '__main__':
sys.exit(main(sys.argv[1:]))
Codebase Browser
chromium