xref: /aosp_15_r20/external/angle/build/config/ios/extract_metadata.py (revision 8975f5c5ed3d1c378011245431ada316dfb6f244)

# 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:]))