blob: 50c98fa8beebc119f2e953f2bdd6ae4e7f8160ec [file]
#!/usr/bin/env python3
# Copyright 2025 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Modularize modularizes a platform."""
import argparse
import concurrent.futures
import logging
import pathlib
import re
import subprocess
import sys
import traceback
from compiler import Compiler
from config import fix_graph
from graph import IncludeDir
from graph import run_build
from platforms import Cpu
from platforms import Os
import render
SOURCE_ROOT = pathlib.Path(__file__).parents[3].resolve()
_OS_OPTS = '|'.join(os.value for os in Os)
_CPU_OPTS = '|'.join(cpu.value for cpu in Cpu)
_PLATFORM = re.compile(
'^'
+ ''.join(
[
f'(?P<os>{_OS_OPTS})',
f'(?:-(?P<cpu>{_CPU_OPTS}))?',
r'(?P<xcode_suffix>_xcode\d+)?',
]
)
+ '$'
)
def main(args):
logging.basicConfig(level=logging.getLevelNamesMapping()[args.verbosity])
existing_platforms = [
f.name for f in (SOURCE_ROOT / 'build/modules').iterdir()
]
filter = {
'os': args.os,
'cpu': args.cpu,
}
calls = {}
for platform in existing_platforms:
match = _PLATFORM.match(platform)
if match is None:
continue
props = match.groupdict()
os = Os(props['os'])
# If no CPU is provided, we support all CPUs with a single BUILD.gn.
# But we do need to be consistent about the CPU we target, so we arbitrarily
# pick x64 since it's probably the most supported CPU.
cpu = Cpu(props['cpu'] or 'x64')
# We want to reconstruct the platform to dedupe xcode versions, and ensure
# that we always have the correct cpu arch.
platform = f"{os.value}-{cpu.value}"
skip = False
for k, v in filter.items():
if v is not None and props[k] != v:
skip = True
if skip:
continue
out_dir = SOURCE_ROOT / 'out' / platform
args_gn = out_dir / 'args.gn'
if not args_gn.exists():
out_dir.mkdir(exist_ok=True, parents=True)
args_gn.write_text(
'\n'.join(
[
# These are required
f'target_os = "{os.value}"',
f'target_cpu = "{cpu.value}"',
# This is required (see README.md)
'use_clang_modules = true',
# This is strongly recommended, otherwise you may accidentally
# test manual modules.
'use_autogenerated_modules = true',
# Some useful defaults. User is free to change these.
'use_remoteexec = true',
'symbol_level = 0',
'is_debug = false',
'running_modularize = true',
]
)
)
error_log = (
None if args.error_log is None else args.error_log / platform
)
calls[platform] = dict(
out_dir=out_dir,
error_log=error_log,
use_cache=args.cache,
compile=args.compile,
os=os,
cpu=cpu,
)
if not calls:
print(
'No matching platforms. Try copying an existing one',
file=sys.stderr,
)
elif len(calls) == 1:
_modularize(**next(iter(calls.values())))
return
# Use a ProcessPoolExecutor rather than a ThreadPoolExecutor because:
# * No shared state between instances
# * GIL prevents a performance benefit from a thread pool executor.
with concurrent.futures.ProcessPoolExecutor() as executor:
futures = {
k: executor.submit(_modularize, **kwargs)
for k, kwargs in calls.items()
}
success = True
for platform, future in sorted(futures.items()):
exc = future.exception()
if exc is not None:
success = False
print(f'{platform} raised an exception:', file=sys.stderr)
traceback.print_exception(exc)
if not success:
exit(1)
def _modularize(
out_dir: pathlib.Path,
error_log: pathlib.Path | None,
use_cache: bool,
compile: bool,
cpu: Cpu,
os: Os,
):
# Modularize requires gn gen to have been run at least once.
if not (out_dir / 'build.ninja').is_file():
subprocess.run(['gn', 'gen', out_dir], check=True)
compiler = Compiler(
source_root=SOURCE_ROOT,
gn_out=out_dir,
error_dir=error_log,
use_cache=use_cache,
cpu=cpu,
os=os,
)
if compile:
ps, files = compiler.compile_one(compile)
print('stderr:', ps.stderr.decode('utf-8'), file=sys.stderr)
print('Files used:')
print('\n'.join(sorted(map(str, files))))
print('Setting breakpoint to allow further debugging')
breakpoint()
return
graph = compiler.compile_all()
replacements = fix_graph(graph, compiler)
targets = run_build(graph)
platform = (out_dir / 'gen/module_platform.txt').read_text()
logging.info('Detected platform %s', platform)
out_dir = SOURCE_ROOT / 'build/modules' / platform
out_dir.mkdir(exist_ok=True, parents=False)
if compiler.sysroot_dir == IncludeDir.Sysroot:
render.render_modulemap(
out_dir=out_dir, replacements=replacements, targets=targets
)
render.render_build_gn(
out_dir=out_dir,
targets=targets,
compiler=compiler,
)
def _optional_path(s: str) -> pathlib.Path | None:
if s:
return pathlib.Path(s).resolve()
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
'--cpu',
help='Only update platforms matching this cpu',
type=lambda x: None if x is None else Cpu(x),
default=None,
choices=[cpu.value for cpu in Cpu],
)
parser.add_argument(
'--os',
help='Only update platforms matching this cpu',
type=lambda x: None if x is None else Os(x),
default=None,
choices=[os.value for os in Os],
)
# Make it required so the user understands how compilation works.
cache = parser.add_mutually_exclusive_group(required=True)
cache.add_argument(
'--cache',
action='store_true',
help='Enable caching. Will attempt to reuse the compilation results.',
)
cache.add_argument(
'--no-cache',
action='store_false',
dest='cache',
help='Disable caching. Will attempt to recompile the whole libcxx, '
+ 'builtins, and sysroot on every invocation',
)
parser.add_argument(
'--compile',
help='Compile a single header file (eg. --compile=sys/types.h) instead '
+ 'of the whole sysroot. Useful for debugging.',
)
parser.add_argument('--error-log', type=_optional_path)
parser.add_argument(
'--verbosity',
help='Verbosity of logging',
default='INFO',
choices=logging.getLevelNamesMapping().keys(),
type=lambda x: x.upper(),
)
main(parser.parse_args())