blob: 1e1f150a22a16a5e541d70e367c5422f2e4d9d88 [file] [log] [blame]
Patrick Rohr92d74122022-10-21 15:50:52 -07001#!/usr/bin/env python3
2# Copyright (C) 2022 The Android Open Source Project
3#
4# Licensed under the Apache License, Version 2.0 (the "License");
5# you may not use this file except in compliance with the License.
6# You may obtain a copy of the License at
7#
8# http://www.apache.org/licenses/LICENSE-2.0
9#
10# Unless required by applicable law or agreed to in writing, software
11# distributed under the License is distributed on an "AS IS" BASIS,
12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13# See the License for the specific language governing permissions and
14# limitations under the License.
15
16# This tool translates a collection of BUILD.gn files into a mostly equivalent
17# Android.bp file for the Android Soong build system. The input to the tool is a
18# JSON description of the GN build definition generated with the following
19# command:
20#
21# gn desc out --format=json --all-toolchains "//*" > desc.json
22#
23# The tool is then given a list of GN labels for which to generate Android.bp
24# build rules. The dependencies for the GN labels are squashed to the generated
25# Android.bp target, except for actions which get their own genrule. Some
26# libraries are also mapped to their Android equivalents -- see |builtin_deps|.
27
28import argparse
29import collections
30import json
Patrick Rohr16228942022-10-26 14:00:26 -070031import logging as log
Patrick Rohr3a2c3dd2022-11-29 22:29:36 -080032import operator
Patrick Rohr92d74122022-10-21 15:50:52 -070033import os
34import re
35import sys
Motomu Utsumic6277d92022-11-07 15:15:17 +090036import copy
Patrick Rohr92d74122022-10-21 15:50:52 -070037
38import gn_utils
39
Patrick Rohr92d74122022-10-21 15:50:52 -070040ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
41
Patrick Rohr06296362022-11-10 21:37:33 -080042# Default targets to translate to the blueprint file.
43default_targets = [
44 '//components/cronet/android:cronet',
Motomu Utsumiabbfdc32022-11-25 12:19:23 +090045 '//components/cronet:cronet_package',
Patrick Rohr06296362022-11-10 21:37:33 -080046]
47
Patrick Rohr92d74122022-10-21 15:50:52 -070048# Defines a custom init_rc argument to be applied to the corresponding output
49# blueprint target.
50target_initrc = {
Patrick Rohrc36ef422022-10-25 10:38:05 -070051 # TODO: this can probably be removed.
Patrick Rohr92d74122022-10-21 15:50:52 -070052}
53
54target_host_supported = [
Patrick Rohrdc383942022-10-25 10:45:29 -070055 # TODO: remove if this is not useful for the cronet build.
Patrick Rohr92d74122022-10-21 15:50:52 -070056]
57
Patrick Rohr92d74122022-10-21 15:50:52 -070058# Proto target groups which will be made public.
59proto_groups = {
Patrick Rohr95212a22022-10-25 09:53:13 -070060 # TODO: remove if this is not used for the cronet build.
Patrick Rohr92d74122022-10-21 15:50:52 -070061}
62
63# All module names are prefixed with this string to avoid collisions.
Patrick Rohr61b2bad2022-10-25 10:49:20 -070064module_prefix = 'cronet_aml_'
Patrick Rohr92d74122022-10-21 15:50:52 -070065
66# Shared libraries which are directly translated to Android system equivalents.
67shared_library_allowlist = [
68 'android',
69 'android.hardware.atrace@1.0',
70 'android.hardware.health@2.0',
71 'android.hardware.health-V1-ndk',
72 'android.hardware.power.stats@1.0',
73 "android.hardware.power.stats-V1-cpp",
74 'base',
75 'binder',
76 'binder_ndk',
77 'cutils',
78 'hidlbase',
79 'hidltransport',
80 'hwbinder',
81 'incident',
82 'log',
83 'services',
84 'statssocket',
85 "tracingproxy",
86 'utils',
87]
88
89# Static libraries which are directly translated to Android system equivalents.
90static_library_allowlist = [
91 'statslog_perfetto',
92]
93
Patrick Rohrd9dd3b92022-11-09 16:15:30 -080094# Include directories that will be removed from all targets.
95local_include_dirs_denylist = [
Patrick Rohrd9dd3b92022-11-09 16:15:30 -080096]
97
Patrick Rohr92d74122022-10-21 15:50:52 -070098# Name of the module which settings such as compiler flags for all other
99# modules.
100defaults_module = module_prefix + 'defaults'
101
102# Location of the project in the Android source tree.
Patrick Rohr76ceeb52022-11-07 14:18:58 -0800103tree_path = 'external/chromium_org'
Patrick Rohr92d74122022-10-21 15:50:52 -0700104
105# Path for the protobuf sources in the standalone build.
106buildtools_protobuf_src = '//buildtools/protobuf/src'
107
108# Location of the protobuf src dir in the Android source tree.
109android_protobuf_src = 'external/protobuf/src'
110
111# Compiler flags which are passed through to the blueprint.
Motomu Utsumic8b7bea2022-11-16 18:12:44 +0900112cflag_allowlist = [
Motomu Utsumicf68d732022-11-16 18:15:21 +0900113 # needed for zlib:zlib
114 "-mpclmul",
115 # needed for zlib:zlib
116 "-mssse3",
Mohannad Farrag7f29d832022-11-23 19:52:41 +0000117 # needed for zlib:zlib
118 "-msse3",
119 # needed for zlib:zlib
120 "-msse4.2",
Motomu Utsumic8b7bea2022-11-16 18:12:44 +0900121]
Patrick Rohr92d74122022-10-21 15:50:52 -0700122
Patrick Rohr92d74122022-10-21 15:50:52 -0700123# Additional arguments to apply to Android.bp rules.
124additional_args = {
Patrick Rohr2267a0a2022-11-08 18:59:34 -0800125 # TODO: remove if not needed.
Patrick Rohrd90025f2022-11-11 14:18:35 -0800126 'cronet_aml_components_cronet_android_cronet': [
127 ('linker_scripts', {
128 'base/android/library_loader/anchor_functions.lds',
129 }),
130 ],
Patrick Rohrbb0956e2022-11-09 15:37:16 -0800131 'cronet_aml_net_net': [
Patrick Rohr9f4d3e32022-11-09 16:37:31 -0800132 ('export_static_lib_headers', {
133 'cronet_aml_net_third_party_quiche_quiche',
134 'cronet_aml_crypto_crypto',
135 }),
Mohannad Farrag37388fa2022-11-10 20:42:13 +0000136 ],
Patrick Rohr92d74122022-10-21 15:50:52 -0700137}
138
Patrick Rohr92d74122022-10-21 15:50:52 -0700139# Android equivalents for third-party libraries that the upstream project
140# depends on.
141builtin_deps = {
Patrick Rohr14ee0932022-11-15 12:10:27 -0800142 '//net/tools/root_store_tool:root_store_tool':
143 lambda x: None,
Patrick Rohr92d74122022-10-21 15:50:52 -0700144}
145
Motomu Utsumi8ca12412022-11-30 16:27:30 +0900146# Name of tethering apex module
147tethering_apex = "com.android.tethering"
148
Patrick Rohr92d74122022-10-21 15:50:52 -0700149# ----------------------------------------------------------------------------
150# End of configuration.
151# ----------------------------------------------------------------------------
152
153
154class Error(Exception):
155 pass
156
157
158class ThrowingArgumentParser(argparse.ArgumentParser):
159
160 def __init__(self, context):
161 super(ThrowingArgumentParser, self).__init__()
162 self.context = context
163
164 def error(self, message):
165 raise Error('%s: %s' % (self.context, message))
166
167
168def write_blueprint_key_value(output, name, value, sort=True):
169 """Writes a Blueprint key-value pair to the output"""
170
171 if isinstance(value, bool):
172 if value:
173 output.append(' %s: true,' % name)
174 else:
175 output.append(' %s: false,' % name)
176 return
177 if not value:
178 return
179 if isinstance(value, set):
180 value = sorted(value)
181 if isinstance(value, list):
182 output.append(' %s: [' % name)
183 for item in sorted(value) if sort else value:
184 output.append(' "%s",' % item)
185 output.append(' ],')
186 return
187 if isinstance(value, Target):
188 value.to_string(output)
189 return
190 if isinstance(value, dict):
191 kv_output = []
192 for k, v in value.items():
193 write_blueprint_key_value(kv_output, k, v)
194
195 output.append(' %s: {' % name)
196 for line in kv_output:
197 output.append(' %s' % line)
198 output.append(' },')
199 return
200 output.append(' %s: "%s",' % (name, value))
201
202
203class Target(object):
204 """A target-scoped part of a module"""
205
206 def __init__(self, name):
207 self.name = name
Patrick Rohr5d399b32022-11-16 10:19:55 -0800208 self.srcs = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700209 self.shared_libs = set()
210 self.static_libs = set()
211 self.whole_static_libs = set()
Patrick Rohrc03f1bb2022-11-18 16:13:17 -0800212 self.header_libs = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700213 self.cflags = set()
214 self.dist = dict()
215 self.strip = dict()
216 self.stl = None
Motomu Utsumi50ad2172022-11-17 22:29:53 +0900217 self.cppflags = set()
Patrick Rohr3cd5ffb2022-11-18 17:40:55 -0800218 self.local_include_dirs = set()
Patrick Rohr81435162022-11-17 19:34:32 -0800219 self.export_system_include_dirs = set()
Mohannad Farrag631443e2022-11-21 16:17:01 +0000220 self.generated_headers = set()
221 self.export_generated_headers = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700222
223 def to_string(self, output):
224 nested_out = []
Patrick Rohr5d399b32022-11-16 10:19:55 -0800225 self._output_field(nested_out, 'srcs')
Patrick Rohr92d74122022-10-21 15:50:52 -0700226 self._output_field(nested_out, 'shared_libs')
227 self._output_field(nested_out, 'static_libs')
228 self._output_field(nested_out, 'whole_static_libs')
Patrick Rohrc03f1bb2022-11-18 16:13:17 -0800229 self._output_field(nested_out, 'header_libs')
Patrick Rohr92d74122022-10-21 15:50:52 -0700230 self._output_field(nested_out, 'cflags')
231 self._output_field(nested_out, 'stl')
232 self._output_field(nested_out, 'dist')
233 self._output_field(nested_out, 'strip')
Motomu Utsumi50ad2172022-11-17 22:29:53 +0900234 self._output_field(nested_out, 'cppflags')
235 self._output_field(nested_out, 'local_include_dirs')
Patrick Rohr81435162022-11-17 19:34:32 -0800236 self._output_field(nested_out, 'export_system_include_dirs')
Mohannad Farrag631443e2022-11-21 16:17:01 +0000237 self._output_field(nested_out, 'generated_headers')
238 self._output_field(nested_out, 'export_generated_headers')
Patrick Rohr92d74122022-10-21 15:50:52 -0700239
240 if nested_out:
241 output.append(' %s: {' % self.name)
242 for line in nested_out:
243 output.append(' %s' % line)
244 output.append(' },')
245
246 def _output_field(self, output, name, sort=True):
247 value = getattr(self, name)
248 return write_blueprint_key_value(output, name, value, sort)
249
250
251class Module(object):
252 """A single module (e.g., cc_binary, cc_test) in a blueprint."""
253
254 def __init__(self, mod_type, name, gn_target):
255 self.type = mod_type
256 self.gn_target = gn_target
257 self.name = name
258 self.srcs = set()
Patrick Rohr07876662022-11-15 22:55:23 -0800259 self.comment = 'GN: ' + gn_target
Patrick Rohr92d74122022-10-21 15:50:52 -0700260 self.shared_libs = set()
261 self.static_libs = set()
262 self.whole_static_libs = set()
263 self.runtime_libs = set()
264 self.tools = set()
265 self.cmd = None
266 self.host_supported = False
Patrick Rohrcdda6322022-11-15 22:44:16 -0800267 self.device_supported = True
Patrick Rohr92d74122022-10-21 15:50:52 -0700268 self.vendor_available = False
269 self.init_rc = set()
270 self.out = set()
271 self.export_include_dirs = set()
272 self.generated_headers = set()
273 self.export_generated_headers = set()
Patrick Rohrbb0956e2022-11-09 15:37:16 -0800274 self.export_static_lib_headers = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700275 self.defaults = set()
276 self.cflags = set()
277 self.include_dirs = set()
Patrick Rohr3cd5ffb2022-11-18 17:40:55 -0800278 self.local_include_dirs = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700279 self.header_libs = set()
280 self.required = set()
Patrick Rohr3d8c7282022-10-27 13:36:31 -0700281 self.tool_files = set()
Patrick Rohrbfdc5fd2022-11-16 10:03:49 -0800282 # target contains a dict of Targets indexed by os_arch.
283 # example: { 'android_x86': Target('android_x86')
284 self.target = dict()
285 self.target['android'] = Target('android')
Patrick Rohr82e40742022-11-16 10:20:39 -0800286 self.target['android_x86'] = Target('android_x86')
287 self.target['android_x86_64'] = Target('android_x86_64')
288 self.target['android_arm'] = Target('android_arm')
289 self.target['android_arm64'] = Target('android_arm64')
Patrick Rohrbfdc5fd2022-11-16 10:03:49 -0800290 self.target['host'] = Target('host')
Patrick Rohr92d74122022-10-21 15:50:52 -0700291 self.stl = None
Patrick Rohrb8f830a2022-10-31 11:18:57 -0700292 self.cpp_std = None
Patrick Rohr92d74122022-10-21 15:50:52 -0700293 self.dist = dict()
294 self.strip = dict()
295 self.data = set()
296 self.apex_available = set()
297 self.min_sdk_version = None
298 self.proto = dict()
Patrick Rohrd90025f2022-11-11 14:18:35 -0800299 self.linker_scripts = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700300 # The genrule_XXX below are properties that must to be propagated back
301 # on the module(s) that depend on the genrule.
302 self.genrule_headers = set()
303 self.genrule_srcs = set()
304 self.genrule_shared_libs = set()
Patrick Rohra1a27872022-10-31 11:57:14 -0700305 self.genrule_header_libs = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700306 self.version_script = None
307 self.test_suites = set()
308 self.test_config = None
309 self.stubs = {}
Mohannad Farrag37388fa2022-11-10 20:42:13 +0000310 self.cppflags = set()
311 self.rtti = False
Motomu Utsumiee47af62022-11-30 16:41:15 +0900312 # Name of the output. Used for setting .so file name for libcronet
313 self.stem = None
Patrick Rohr92d74122022-10-21 15:50:52 -0700314
315 def to_string(self, output):
316 if self.comment:
317 output.append('// %s' % self.comment)
318 output.append('%s {' % self.type)
319 self._output_field(output, 'name')
320 self._output_field(output, 'srcs')
321 self._output_field(output, 'shared_libs')
322 self._output_field(output, 'static_libs')
323 self._output_field(output, 'whole_static_libs')
324 self._output_field(output, 'runtime_libs')
325 self._output_field(output, 'tools')
326 self._output_field(output, 'cmd', sort=False)
327 if self.host_supported:
328 self._output_field(output, 'host_supported')
Patrick Rohrcdda6322022-11-15 22:44:16 -0800329 if not self.device_supported:
330 self._output_field(output, 'device_supported')
Patrick Rohr92d74122022-10-21 15:50:52 -0700331 if self.vendor_available:
332 self._output_field(output, 'vendor_available')
333 self._output_field(output, 'init_rc')
334 self._output_field(output, 'out')
335 self._output_field(output, 'export_include_dirs')
336 self._output_field(output, 'generated_headers')
337 self._output_field(output, 'export_generated_headers')
Patrick Rohrbb0956e2022-11-09 15:37:16 -0800338 self._output_field(output, 'export_static_lib_headers')
Patrick Rohr92d74122022-10-21 15:50:52 -0700339 self._output_field(output, 'defaults')
340 self._output_field(output, 'cflags')
341 self._output_field(output, 'include_dirs')
Patrick Rohr3cd5ffb2022-11-18 17:40:55 -0800342 self._output_field(output, 'local_include_dirs')
Patrick Rohr92d74122022-10-21 15:50:52 -0700343 self._output_field(output, 'header_libs')
344 self._output_field(output, 'required')
345 self._output_field(output, 'dist')
346 self._output_field(output, 'strip')
347 self._output_field(output, 'tool_files')
348 self._output_field(output, 'data')
349 self._output_field(output, 'stl')
Patrick Rohrb8f830a2022-10-31 11:18:57 -0700350 self._output_field(output, 'cpp_std')
Patrick Rohr92d74122022-10-21 15:50:52 -0700351 self._output_field(output, 'apex_available')
352 self._output_field(output, 'min_sdk_version')
353 self._output_field(output, 'version_script')
354 self._output_field(output, 'test_suites')
355 self._output_field(output, 'test_config')
356 self._output_field(output, 'stubs')
357 self._output_field(output, 'proto')
Patrick Rohrd90025f2022-11-11 14:18:35 -0800358 self._output_field(output, 'linker_scripts')
Mohannad Farrag37388fa2022-11-10 20:42:13 +0000359 self._output_field(output, 'cppflags')
Motomu Utsumiee47af62022-11-30 16:41:15 +0900360 self._output_field(output, 'stem')
Mohannad Farrag37388fa2022-11-10 20:42:13 +0000361 if self.rtti:
362 self._output_field(output, 'rtti')
Patrick Rohr92d74122022-10-21 15:50:52 -0700363
364 target_out = []
Patrick Rohr09ee70e2022-11-16 15:20:03 -0800365 for arch, target in sorted(self.target.items()):
Patrick Rohrbfdc5fd2022-11-16 10:03:49 -0800366 # _output_field calls getattr(self, arch).
367 setattr(self, arch, target)
368 self._output_field(target_out, arch)
369
Patrick Rohr92d74122022-10-21 15:50:52 -0700370 if target_out:
371 output.append(' target: {')
372 for line in target_out:
373 output.append(' %s' % line)
374 output.append(' },')
375
Patrick Rohr92d74122022-10-21 15:50:52 -0700376 output.append('}')
377 output.append('')
378
379 def add_android_static_lib(self, lib):
380 if self.type == 'cc_binary_host':
381 raise Exception('Adding Android static lib for host tool is unsupported')
382 elif self.host_supported:
Patrick Rohrbfdc5fd2022-11-16 10:03:49 -0800383 self.target['android'].static_libs.add(lib)
Patrick Rohr92d74122022-10-21 15:50:52 -0700384 else:
385 self.static_libs.add(lib)
386
387 def add_android_shared_lib(self, lib):
388 if self.type == 'cc_binary_host':
389 raise Exception('Adding Android shared lib for host tool is unsupported')
390 elif self.host_supported:
Patrick Rohrbfdc5fd2022-11-16 10:03:49 -0800391 self.target['android'].shared_libs.add(lib)
Patrick Rohr92d74122022-10-21 15:50:52 -0700392 else:
393 self.shared_libs.add(lib)
394
395 def _output_field(self, output, name, sort=True):
396 value = getattr(self, name)
397 return write_blueprint_key_value(output, name, value, sort)
398
Patrick Rohra6ce0232022-11-16 22:09:01 -0800399 def is_compiled(self):
Mohannad Farrag7ff99912022-11-29 17:16:00 +0000400 return self.type not in ('cc_genrule', 'filegroup', 'java_genrule')
Mohannad Farrag1de6cb12022-11-28 12:27:26 +0000401
402 def is_genrule(self):
403 return self.type == "cc_genrule"
Patrick Rohra6ce0232022-11-16 22:09:01 -0800404
Mohannad Farrag7f29d832022-11-23 19:52:41 +0000405 def has_input_files(self):
Mohannad Farrag7f29d832022-11-23 19:52:41 +0000406 return len(self.srcs) > 0 or any([len(target.srcs) > 0 for target in self.target.values()])
407
Mohannad Farragf2391cc2022-11-29 13:26:32 +0000408 def merge_attribute(self, key, source_module, allowed_archs, source_key = None):
409 """
410 Merges the value of the attribute `source_key` for the `dep_module` with
411 the value of the attribute `key` for this module. If the value of the
412 `source_key` is equal to None. Then `key` is used for both modules.
413
414 This merges the attribute for both non-arch and archs
415 specified in `allowed_archs`.
416 :param key: The attribute used for merging in the calling module. Also
417 used for `dep_module` if the `source_key` is None.
418 :param source_module: The module where data is propagated from.
419 :param allowed_archs: A list of archs to merge the attribute on.
420 :param source_key: if the attribute merged from the `dep_module`
421 is different from the `key`
422 """
423 if not source_key:
424 source_key = key
425 self.__dict__[key].update(source_module.__dict__[source_key])
426 for arch_name in source_module.target.keys():
427 if arch_name in allowed_archs:
428 self.target[arch_name].__dict__[key].update(
429 source_module.target[arch_name].__dict__[source_key])
Patrick Rohr92d74122022-10-21 15:50:52 -0700430
431class Blueprint(object):
432 """In-memory representation of an Android.bp file."""
433
434 def __init__(self):
435 self.modules = {}
436
437 def add_module(self, module):
438 """Adds a new module to the blueprint, replacing any existing module
439 with the same name.
440
441 Args:
442 module: Module instance.
443 """
444 self.modules[module.name] = module
445
446 def to_string(self, output):
Patrick Rohr23f26192022-10-25 09:45:22 -0700447 for m in sorted(self.modules.values(), key=lambda m: m.name):
Patrick Rohr92d74122022-10-21 15:50:52 -0700448 m.to_string(output)
449
450
451def label_to_module_name(label):
452 """Turn a GN label (e.g., //:perfetto_tests) into a module name."""
Patrick Rohr07876662022-11-15 22:55:23 -0800453 module = re.sub(r'^//:?', '', label)
Patrick Rohr92d74122022-10-21 15:50:52 -0700454 module = re.sub(r'[^a-zA-Z0-9_]', '_', module)
Motomu Utsumi3fde1482022-11-14 15:55:21 +0900455
Patrick Rohr92d74122022-10-21 15:50:52 -0700456 if not module.startswith(module_prefix):
457 return module_prefix + module
458 return module
459
460
461def is_supported_source_file(name):
462 """Returns True if |name| can appear in a 'srcs' list."""
Patrick Rohrf9f3a992022-11-10 19:40:32 -0800463 return os.path.splitext(name)[1] in ['.c', '.cc', '.cpp', '.java', '.proto', '.S']
Patrick Rohr92d74122022-10-21 15:50:52 -0700464
465
466def create_proto_modules(blueprint, gn, target):
467 """Generate genrules for a proto GN target.
468
469 GN actions are used to dynamically generate files during the build. The
470 Soong equivalent is a genrule. This function turns a specific kind of
471 genrule which turns .proto files into source and header files into a pair
472 equivalent genrules.
473
474 Args:
475 blueprint: Blueprint instance which is being generated.
476 target: gn_utils.Target object.
477
478 Returns:
479 The source_genrule module.
480 """
481 assert (target.type == 'proto_library')
482
Motomu Utsumibd4013f2022-11-17 16:06:05 +0900483 protoc_gn_target_name = gn.get_target('//third_party/protobuf:protoc').name
Motomu Utsumid58c1dc2022-11-16 18:04:46 +0900484 protoc_module_name = label_to_module_name(protoc_gn_target_name)
485 tools = {protoc_module_name}
Motomu Utsumid7e0e422022-11-08 17:49:52 +0900486 cpp_out_dir = '$(genDir)/%s/%s/' % (tree_path, target.proto_in_dir)
Patrick Rohr92d74122022-10-21 15:50:52 -0700487 target_module_name = label_to_module_name(target.name)
488
489 # In GN builds the proto path is always relative to the output directory
490 # (out/tmp.xxx).
Motomu Utsumid58c1dc2022-11-16 18:04:46 +0900491 cmd = ['$(location %s)' % protoc_module_name]
Motomu Utsumid7e0e422022-11-08 17:49:52 +0900492 cmd += ['--proto_path=%s/%s' % (tree_path, target.proto_in_dir)]
Patrick Rohr92d74122022-10-21 15:50:52 -0700493
494 if buildtools_protobuf_src in target.proto_paths:
495 cmd += ['--proto_path=%s' % android_protobuf_src]
496
497 # We don't generate any targets for source_set proto modules because
498 # they will be inlined into other modules if required.
499 if target.proto_plugin == 'source_set':
500 return None
501
502 # Descriptor targets only generate a single target.
503 if target.proto_plugin == 'descriptor':
504 out = '{}.bin'.format(target_module_name)
505
506 cmd += ['--descriptor_set_out=$(out)']
507 cmd += ['$(in)']
508
Mohannad Farrag1de6cb12022-11-28 12:27:26 +0000509 descriptor_module = Module('cc_genrule', target_module_name, target.name)
Patrick Rohr92d74122022-10-21 15:50:52 -0700510 descriptor_module.cmd = ' '.join(cmd)
511 descriptor_module.out = [out]
512 descriptor_module.tools = tools
513 blueprint.add_module(descriptor_module)
514
515 # Recursively extract the .proto files of all the dependencies and
516 # add them to srcs.
517 descriptor_module.srcs.update(
518 gn_utils.label_to_path(src) for src in target.sources)
519 for dep in target.transitive_proto_deps:
520 current_target = gn.get_target(dep)
521 descriptor_module.srcs.update(
522 gn_utils.label_to_path(src) for src in current_target.sources)
523
524 return descriptor_module
525
526 # We create two genrules for each proto target: one for the headers and
527 # another for the sources. This is because the module that depends on the
528 # generated files needs to declare two different types of dependencies --
529 # source files in 'srcs' and headers in 'generated_headers' -- and it's not
530 # valid to generate .h files from a source dependency and vice versa.
531 source_module_name = target_module_name + '_gen'
Mohannad Farrag1de6cb12022-11-28 12:27:26 +0000532 source_module = Module('cc_genrule', source_module_name, target.name)
Patrick Rohr92d74122022-10-21 15:50:52 -0700533 blueprint.add_module(source_module)
534 source_module.srcs.update(
535 gn_utils.label_to_path(src) for src in target.sources)
536
Mohannad Farrag1de6cb12022-11-28 12:27:26 +0000537 header_module = Module('cc_genrule', source_module_name + '_headers',
Patrick Rohr92d74122022-10-21 15:50:52 -0700538 target.name)
539 blueprint.add_module(header_module)
540 header_module.srcs = set(source_module.srcs)
541
542 # TODO(primiano): at some point we should remove this. This was introduced
543 # by aosp/1108421 when adding "protos/" to .proto include paths, in order to
544 # avoid doing multi-repo changes and allow old clients in the android tree
545 # to still do the old #include "perfetto/..." rather than
546 # #include "protos/perfetto/...".
547 header_module.export_include_dirs = {'.', 'protos'}
Patrick Rohr2267a0a2022-11-08 18:59:34 -0800548 # Since the .cc file and .h get created by a different gerule target, they
549 # are not put in the same intermediate path, so local includes do not work
550 # without explictily exporting the include dir.
551 header_module.export_include_dirs.add(target.proto_in_dir)
Patrick Rohr92d74122022-10-21 15:50:52 -0700552
Motomu Utsumi8ca12412022-11-30 16:27:30 +0900553 # This function does not return header_module so setting apex_available attribute here.
554 header_module.apex_available.add(tethering_apex)
555
Patrick Rohr92d74122022-10-21 15:50:52 -0700556 source_module.genrule_srcs.add(':' + source_module.name)
557 source_module.genrule_headers.add(header_module.name)
558
559 if target.proto_plugin == 'proto':
560 suffixes = ['pb']
561 source_module.genrule_shared_libs.add('libprotobuf-cpp-lite')
562 cmd += ['--cpp_out=lite=true:' + cpp_out_dir]
563 elif target.proto_plugin == 'protozero':
564 suffixes = ['pbzero']
565 plugin = create_modules_from_target(blueprint, gn, protozero_plugin)
566 tools.add(plugin.name)
567 cmd += ['--plugin=protoc-gen-plugin=$(location %s)' % plugin.name]
568 cmd += ['--plugin_out=wrapper_namespace=pbzero:' + cpp_out_dir]
569 elif target.proto_plugin == 'cppgen':
570 suffixes = ['gen']
571 plugin = create_modules_from_target(blueprint, gn, cppgen_plugin)
572 tools.add(plugin.name)
573 cmd += ['--plugin=protoc-gen-plugin=$(location %s)' % plugin.name]
574 cmd += ['--plugin_out=wrapper_namespace=gen:' + cpp_out_dir]
575 elif target.proto_plugin == 'ipc':
576 suffixes = ['ipc']
577 plugin = create_modules_from_target(blueprint, gn, ipc_plugin)
578 tools.add(plugin.name)
579 cmd += ['--plugin=protoc-gen-plugin=$(location %s)' % plugin.name]
580 cmd += ['--plugin_out=wrapper_namespace=gen:' + cpp_out_dir]
581 else:
582 raise Error('Unsupported proto plugin: %s' % target.proto_plugin)
583
584 cmd += ['$(in)']
585 source_module.cmd = ' '.join(cmd)
586 header_module.cmd = source_module.cmd
587 source_module.tools = tools
588 header_module.tools = tools
589
590 for sfx in suffixes:
591 source_module.out.update('%s/%s' %
592 (tree_path, src.replace('.proto', '.%s.cc' % sfx))
593 for src in source_module.srcs)
594 header_module.out.update('%s/%s' %
595 (tree_path, src.replace('.proto', '.%s.h' % sfx))
596 for src in header_module.srcs)
597 return source_module
598
599
Patrick Rohr92d74122022-10-21 15:50:52 -0700600def create_proto_group_modules(blueprint, gn, module_name, target_names):
601 # TODO(lalitm): today, we're only adding a Java lite module because that's
602 # the only one used in practice. In the future, if we need other target types
603 # (e.g. C++, Java full etc.) add them here.
604 bp_module_name = label_to_module_name(module_name) + '_java_protos'
605 module = Module('java_library', bp_module_name, bp_module_name)
606 module.comment = f'''GN: [{', '.join(target_names)}]'''
607 module.proto = {'type': 'lite', 'canonical_path_from_root': False}
608
609 for name in target_names:
610 target = gn.get_target(name)
611 module.srcs.update(gn_utils.label_to_path(src) for src in target.sources)
612 for dep_label in target.transitive_proto_deps:
613 dep = gn.get_target(dep_label)
614 module.srcs.update(gn_utils.label_to_path(src) for src in dep.sources)
615
616 blueprint.add_module(module)
617
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800618
Mohannad Farrag420c14e2022-11-30 17:13:15 +0000619class BaseActionSanitizer():
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800620 def __init__(self, target):
Patrick Rohr9e414b52022-11-29 22:12:18 -0800621 # Just to be on the safe side, create a deep-copy.
622 self.target = copy.deepcopy(target)
623 # Convert ['--param=value'] to ['--param', 'value'] for consistency.
Patrick Rohr3d377802022-11-30 13:42:02 -0800624 self.target.args = [str for it in self.target.args for str in it.split('=')]
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800625
Patrick Rohr2cad9332022-11-30 14:27:40 -0800626 # There are three types of args:
627 # - flags (--flag)
628 # - value args (--arg value)
629 # - list args (--arg value1 --arg value2)
Motomu Utsumi923688c2022-12-01 15:51:05 +0900630 # Note that the set of list args contains the set of value args.
631 # value args must have exactly one arg value pair but list args could have one arg value pair.
632 # This is because list args with one arg value pair and value args can not be distinguished only
633 # from the desc.json
Patrick Rohr2cad9332022-11-30 14:27:40 -0800634 # Some functions provide special implementations for each type, while others
635 # work on all of them.
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800636 def _has_arg(self, arg):
637 return arg in self.target.args
638
Motomu Utsumi923688c2022-12-01 15:51:05 +0900639 def _get_arg_indices(self, target_arg):
640 return [i for i, arg in enumerate(self.target.args) if arg == target_arg]
Patrick Rohr3a2c3dd2022-11-29 22:29:36 -0800641
Motomu Utsumi923688c2022-12-01 15:51:05 +0900642 # Whether an arg value pair appears once or more times
643 def _is_list_arg(self, arg):
644 indices = self._get_arg_indices(arg)
645 return len(indices) > 0 and all([not self.target.args[i + 1].startswith('--') for i in indices])
646
Motomu Utsumic363b412022-12-01 16:01:58 +0900647 def _update_list_arg(self, arg, func, throw_if_absent = True):
648 if self._should_fail_silently(arg, throw_if_absent):
649 return
650 assert(self._is_list_arg(arg))
651 indices = self._get_arg_indices(arg)
652 for i in indices:
653 self._set_arg_at(i + 1, func(self.target.args[i + 1]))
654
Motomu Utsumi923688c2022-12-01 15:51:05 +0900655 # Whether an arg value pair appears exactly once
Patrick Rohref4f2bf2022-11-30 14:22:40 -0800656 def _is_value_arg(self, arg):
Motomu Utsumi923688c2022-12-01 15:51:05 +0900657 if operator.countOf(self.target.args, arg) != 1:
658 return False
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800659 i = self.target.args.index(arg)
660 return not self.target.args[i + 1].startswith('--')
661
Patrick Rohr2cad9332022-11-30 14:27:40 -0800662 def _get_value_arg(self, arg):
Patrick Rohref4f2bf2022-11-30 14:22:40 -0800663 assert(self._is_value_arg(arg))
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800664 i = self.target.args.index(arg)
665 return self.target.args[i + 1]
666
Patrick Rohrf0abead2022-11-30 19:44:10 -0800667 # used to check whether a function call should cause an error when an arg is
668 # missing.
669 def _should_fail_silently(self, arg, throw_if_absent):
670 return not throw_if_absent and not self._has_arg(arg)
671
672 def _set_value_arg(self, arg, value, throw_if_absent = True):
673 if self._should_fail_silently(arg, throw_if_absent):
Patrick Rohr4d74aed2022-11-30 15:42:16 -0800674 return
Patrick Rohref4f2bf2022-11-30 14:22:40 -0800675 assert(self._is_value_arg(arg))
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800676 i = self.target.args.index(arg)
677 self.target.args[i + 1] = value
678
Patrick Rohrf0abead2022-11-30 19:44:10 -0800679 def _update_value_arg(self, arg, func, throw_if_absent = True):
680 if self._should_fail_silently(arg, throw_if_absent):
Patrick Rohr4d74aed2022-11-30 15:42:16 -0800681 return
Patrick Rohr1bedf6c2022-11-30 15:12:57 -0800682 self._set_value_arg(arg, func(self._get_value_arg(arg)))
683
Patrick Rohr77c4f5c2022-11-30 12:56:29 -0800684 def _set_arg_at(self, position, value):
Mohannad Farrag9ab17932022-11-30 17:28:35 +0000685 self.target.args[position] = value
686
Patrick Rohr357b25c2022-11-30 19:46:26 -0800687 def _delete_value_arg(self, arg, throw_if_absent = True):
Patrick Rohrf0abead2022-11-30 19:44:10 -0800688 if self._should_fail_silently(arg, throw_if_absent):
Patrick Rohr4d74aed2022-11-30 15:42:16 -0800689 return
Patrick Rohr357b25c2022-11-30 19:46:26 -0800690 assert(self._is_value_arg(arg))
Patrick Rohr9f439322022-11-30 15:56:15 -0800691 i = self.target.args.index(arg)
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800692 self.target.args.pop(i)
Patrick Rohr357b25c2022-11-30 19:46:26 -0800693 self.target.args.pop(i)
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800694
Patrick Rohr1f7dd582022-11-30 13:44:07 -0800695 def _append_arg(self, arg, value):
696 self.target.args.append(arg)
697 self.target.args.append(value)
698
Mohannad Farrag8fa90652022-12-01 15:40:40 +0000699 def _sanitize_filepath_with_location_tag(self, arg):
700 if arg.startswith('../../'):
701 arg = self._sanitize_filepath(arg)
702 arg = self._add_location_tag(arg)
703 return arg
704
Patrick Rohr73ef7ae2022-11-29 22:33:09 -0800705 # wrap filename in location tag.
Patrick Rohrfda026732022-11-30 16:07:11 -0800706 def _add_location_tag(self, filename):
Patrick Rohr73ef7ae2022-11-29 22:33:09 -0800707 return '$(location %s)' % filename
708
Patrick Rohr0e24c5f2022-11-30 15:20:21 -0800709 # applies common directory transformation that *should* be universally applicable.
710 # TODO: verify if it actually *is* universally applicable.
Patrick Rohr872a2812022-11-30 19:28:22 -0800711 def _sanitize_filepath(self, filepath):
Patrick Rohr0e24c5f2022-11-30 15:20:21 -0800712 # Careful, order matters!
Patrick Rohr8bcd7832022-11-30 19:48:56 -0800713 # delete all leading ../
Patrick Rohr9e5a3c72022-11-30 15:51:30 -0800714 filepath = re.sub('^(\.\./)+', '', filepath)
Patrick Rohr0e24c5f2022-11-30 15:20:21 -0800715 filepath = re.sub('^gen/jni_headers', '$(genDir)', filepath)
716 filepath = re.sub('^gen', '$(genDir)', filepath)
717 return filepath
Patrick Rohr32276892022-11-29 22:38:13 -0800718
Motomu Utsumi21485ba2022-12-01 17:01:50 +0900719 # Iterate through all the args and apply function
720 def _update_all_args(self, func):
721 self.target.args = [func(arg) for arg in self.target.args]
722
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800723 def get_args(self):
Patrick Rohr9e414b52022-11-29 22:12:18 -0800724 return self.target.args
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800725
Mohannad Farrag9ab17932022-11-30 17:28:35 +0000726class WriteBuildDateHeaderSanitizer(BaseActionSanitizer):
727 def get_args(self):
Patrick Rohr77c4f5c2022-11-30 12:56:29 -0800728 self._set_arg_at(0, '$(out)')
Mohannad Farrag9ab17932022-11-30 17:28:35 +0000729 return super().get_args()
730
Mohannad Farrag71353f92022-11-30 17:20:48 +0000731class WriteBuildFlagHeaderSanitizer(BaseActionSanitizer):
732 def get_args(self):
Patrick Rohr2cad9332022-11-30 14:27:40 -0800733 self._set_value_arg('--gen-dir', '.')
734 self._set_value_arg('--output', '$(out)')
Mohannad Farrag71353f92022-11-30 17:20:48 +0000735 return super().get_args()
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800736
Patrick Rohr0242a3f2022-11-30 13:48:59 -0800737class JniGeneratorSanitizer(BaseActionSanitizer):
Motomu Utsumi4d551d72022-12-01 16:18:23 +0900738 def _add_location_tag_to_filepath(self, arg):
739 if not arg.endswith('.class'):
740 # --input_file supports both .class specifiers or source files as arguments.
741 # Only source files need to be wrapped inside a $(location <label>) tag.
742 arg = self._add_location_tag(arg)
743 return arg
744
Patrick Rohr0242a3f2022-11-30 13:48:59 -0800745 def get_args(self):
Patrick Rohrf0abead2022-11-30 19:44:10 -0800746 self._update_value_arg('--jar_file', self._sanitize_filepath, False)
747 self._update_value_arg('--jar_file', self._add_location_tag, False)
Patrick Rohr0242a3f2022-11-30 13:48:59 -0800748 if self._has_arg('--jar_file'):
749 self._append_arg('--javap', '$$(find out/.path -name javap)')
Patrick Rohr872a2812022-11-30 19:28:22 -0800750 self._update_value_arg('--output_dir', self._sanitize_filepath)
Patrick Rohrf0abead2022-11-30 19:44:10 -0800751 self._update_value_arg('--includes', self._sanitize_filepath, False)
Patrick Rohr357b25c2022-11-30 19:46:26 -0800752 self._delete_value_arg('--prev_output_dir', False)
Motomu Utsumi4d551d72022-12-01 16:18:23 +0900753 self._update_list_arg('--input_file', self._sanitize_filepath)
754 self._update_list_arg('--input_file', self._add_location_tag_to_filepath)
Patrick Rohr0242a3f2022-11-30 13:48:59 -0800755 return super().get_args()
756
Motomu Utsumib80903c2022-12-01 16:21:55 +0900757class JniRegistrationGeneratorSanitizer(BaseActionSanitizer):
758 def get_args(self):
Motomu Utsumi28cbf2f2022-12-01 16:24:29 +0900759 self._update_value_arg('--depfile', self._sanitize_filepath)
760 self._update_value_arg('--srcjar-path', self._sanitize_filepath)
761 self._update_value_arg('--header-path', self._sanitize_filepath)
Motomu Utsumi55907472022-12-01 16:26:21 +0900762 self._set_value_arg('--sources-files', '$(genDir)/java.sources')
Motomu Utsumi4fe0b952022-12-01 16:29:15 +0900763 # update_jni_registration_module removes them from the srcs of the module
764 # It might be better to remove sources by '--sources-exclusions'
765 self._delete_value_arg('--sources-exclusions')
Motomu Utsumib80903c2022-12-01 16:21:55 +0900766 return super().get_args()
Patrick Rohr0242a3f2022-11-30 13:48:59 -0800767
Motomu Utsumi6af5b2a2022-12-01 16:33:42 +0900768class VersionSanitizer(BaseActionSanitizer):
Motomu Utsumi0f368572022-12-01 17:09:45 +0900769 def _sanitize_eval(self):
770 assert (self._is_value_arg('-e'))
771 # arg for -e EVAL option should be passed in -e PATCH_HI=int(PATCH)//256 format.
772 index = self.target.args.index('-e')
773 value = '%s=\'%s\'' % (self.target.args[index + 1], self.target.args[index + 2])
Motomu Utsumi297c29b2022-12-01 17:46:28 +0900774 # escape '"' in the value
775 value = value.replace('"', r'\"')
Motomu Utsumi0f368572022-12-01 17:09:45 +0900776 self._set_arg_at(index + 1, value)
777 self.target.args.pop(index + 2)
778
Motomu Utsumi6af5b2a2022-12-01 16:33:42 +0900779 def get_args(self):
Motomu Utsumic6b08b82022-12-01 16:48:19 +0900780 self._set_value_arg('-o', '$(out)')
Motomu Utsumi21485ba2022-12-01 17:01:50 +0900781 # args for the version.py contain file path without leading --arg key. So apply sanitize
782 # function for all the args.
Mohannad Farrag8fa90652022-12-01 15:40:40 +0000783 self._update_all_args(self._sanitize_filepath_with_location_tag)
Motomu Utsumi0f368572022-12-01 17:09:45 +0900784 self._sanitize_eval()
Motomu Utsumi6af5b2a2022-12-01 16:33:42 +0900785 return super().get_args()
786
Mohannad Farragb73ce0f2022-12-01 15:43:58 +0000787class JavaCppEnumSanitizer(BaseActionSanitizer):
788 def get_args(self):
789 self._update_all_args(self._sanitize_filepath_with_location_tag)
790 self._set_value_arg('--srcjar', '$(out)')
791 return super().get_args()
792
Patrick Rohr7f117152022-11-30 13:58:05 -0800793def get_action_sanitizer(target):
794 if target.script == "//build/write_buildflag_header.py":
795 return WriteBuildFlagHeaderSanitizer(target)
796 elif target.script == "//build/write_build_date_header.py":
797 return WriteBuildDateHeaderSanitizer(target)
798 elif target.script == '//base/android/jni_generator/jni_generator.py':
799 return JniGeneratorSanitizer(target)
Motomu Utsumib80903c2022-12-01 16:21:55 +0900800 elif target.script == '//base/android/jni_generator/jni_registration_generator.py':
801 return JniRegistrationGeneratorSanitizer(target)
Motomu Utsumi6af5b2a2022-12-01 16:33:42 +0900802 elif target.script == "//build/util/version.py":
803 return VersionSanitizer(target)
Mohannad Farragb73ce0f2022-12-01 15:43:58 +0000804 elif target.script == "//build/android/gyp/java_cpp_enum.py":
805 return JavaCppEnumSanitizer(target)
Patrick Rohr7f117152022-11-30 13:58:05 -0800806 else:
807 # TODO: throw exception here once all script hacks have been converted.
808 return BaseActionSanitizer(target)
809
Mohannad Farragbab6c892022-11-02 14:09:46 +0000810def create_action_foreach_modules(blueprint, target):
811 """ The following assumes that rebase_path exists in the args.
812 The args of an action_foreach contains hints about which output files are generated
813 by which source files.
814 This is copied directly from the args
815 "gen/net/base/registry_controlled_domains/{{source_name_part}}-reversed-inc.cc"
816 So each source file will generate an output whose name is the {source_name-reversed-inc.cc}
817 """
818 new_args = []
Motomu Utsumi56afcac2022-11-04 12:58:30 +0900819 for i, src in enumerate(sorted(target.sources)):
Mohannad Farragbab6c892022-11-02 14:09:46 +0000820 # don't add script arg for the first source -- create_action_module
821 # already does this.
822 if i != 0:
823 new_args.append('&& python3 $(location %s)' %
824 gn_utils.label_to_path(target.script))
825 for arg in target.args:
826 if '{{source}}' in arg:
827 new_args.append('$(location %s)' % (gn_utils.label_to_path(src)))
828 elif '{{source_name_part}}' in arg:
829 source_name_part = src.split("/")[-1] # Get the file name only
830 source_name_part = source_name_part.split(".")[0] # Remove the extension (Ex: .cc)
831 file_name = arg.replace('{{source_name_part}}', source_name_part).split("/")[-1]
832 # file_name represent the output file name. But we need the whole path
833 # This can be found from target.outputs.
834 for out in target.outputs:
835 if out.endswith(file_name):
836 new_args.append('$(location %s)' % out)
837 else:
838 new_args.append(arg)
839
840 target.args = new_args
Mohannad Farrag7ff99912022-11-29 17:16:00 +0000841 return create_action_module(blueprint, target, 'cc_genrule')
Motomu Utsumia6c33152022-11-02 18:21:55 +0900842
Mohannad Farrag7ff99912022-11-29 17:16:00 +0000843def create_action_module(blueprint, target, type):
Patrick Rohr7be99032022-10-31 11:54:19 -0700844 bp_module_name = label_to_module_name(target.name)
Mohannad Farrag7ff99912022-11-29 17:16:00 +0000845 module = Module(type, bp_module_name, target.name)
Patrick Rohr7be99032022-10-31 11:54:19 -0700846
Patrick Rohrd7de3dd2022-11-30 12:53:26 -0800847 sanitizer = get_action_sanitizer(target)
Patrick Rohr9e414b52022-11-29 22:12:18 -0800848 target.args = sanitizer.get_args()
Patrick Rohr9b99a982022-10-28 11:00:57 -0700849
Mohannad Farrag9ab17932022-11-30 17:28:35 +0000850 if target.script == '//base/android/jni_generator/jni_generator.py':
Patrick Rohrf1d08f82022-10-31 14:43:59 -0700851 # fix target.output directory to match #include statements.
852 target.outputs = [re.sub('^jni_headers/', '', out) for out in target.outputs]
Patrick Rohr8acccca2022-10-28 10:39:06 -0700853
Motomu Utsumi747030b2022-12-01 17:47:57 +0900854 # android_jar.classes should be part of the tools as it list implicit classes
855 # for the script to generate JNI headers.
856 module.tool_files.add("base/android/jni_generator/android_jar.classes")
857
Patrick Rohrf6d2b612022-11-09 12:30:26 -0800858 elif target.script == '//base/android/jni_generator/jni_registration_generator.py':
859 # jni_registration_generator.py pulls in some config dependencies that we
860 # do not handle. Remove them.
861 # TODO: find a better way to do this.
862 target.deps.clear()
863
Motomu Utsumied009082022-11-10 16:26:44 +0900864 target.inputs = [file for file in target.inputs if not file.startswith('//out/')]
Motomu Utsumia0cc6662022-11-09 15:22:27 +0900865 elif target.script == "//net/tools/dafsa/make_dafsa.py":
866 # This script generates .cc files but source (registry_controlled_domain.cc) in the target that
867 # depends on this target includes .cc file this script generates.
868 module.genrule_headers.add(module.name)
Motomu Utsumi847a6d32022-11-09 17:32:06 +0900869 elif target.script == "//build/util/version.py":
Motomu Utsumib0a49e42022-11-09 18:12:27 +0900870 # android_chrome_version.py is not specified in anywhere but version.py imports this file
871 module.tool_files.add('build/util/android_chrome_version.py')
Patrick Rohr245df582022-11-01 16:59:45 -0700872
Patrick Rohr2041d5b2022-10-26 15:07:53 -0700873 script = gn_utils.label_to_path(target.script)
Patrick Rohr3d8c7282022-10-27 13:36:31 -0700874 module.tool_files.add(script)
Patrick Rohre1a853e2022-10-26 12:31:39 -0700875
Patrick Rohr8a4e2bd2022-10-27 13:06:16 -0700876 # Handle passing parameters via response file by piping them into the script
877 # and reading them from /dev/stdin.
878 response_file = '{{response_file_name}}'
879 use_response_file = response_file in target.args
880 if use_response_file:
881 # Replace {{response_file_contents}} with /dev/stdin
882 target.args = ['/dev/stdin' if it == response_file else it for it in target.args]
883
Patrick Rohr9b99a982022-10-28 11:00:57 -0700884 # put all args on a new line for better diffs.
885 NEWLINE = ' " +\n "'
886 arg_string = NEWLINE.join(target.args)
Patrick Rohr2041d5b2022-10-26 15:07:53 -0700887 module.cmd = '$(location %s) %s' % (script, arg_string)
Patrick Rohre1a853e2022-10-26 12:31:39 -0700888
Patrick Rohr8a4e2bd2022-10-27 13:06:16 -0700889 if use_response_file:
890 # Pipe response file contents into script
Patrick Rohr9b99a982022-10-28 11:00:57 -0700891 module.cmd = 'echo \'%s\' |%s%s' % (target.response_file_contents, NEWLINE, module.cmd)
Patrick Rohr8a4e2bd2022-10-27 13:06:16 -0700892
Motomu Utsumi7e983832022-11-10 16:04:46 +0900893 if any(os.path.splitext(it)[1] == '.h' for it in target.outputs):
Patrick Rohr67f4d432022-10-26 16:04:15 -0700894 module.genrule_headers.add(bp_module_name)
Patrick Rohre1a853e2022-10-26 12:31:39 -0700895
Patrick Rohr0db9f852022-10-27 13:49:57 -0700896 # gn treats inputs and sources for actions equally.
897 # soong only supports source files inside srcs, non-source files are added as
898 # tool_files dependency.
899 for it in target.sources or target.inputs:
900 if is_supported_source_file(it):
901 module.srcs.add(gn_utils.label_to_path(it))
902 else:
903 module.tool_files.add(gn_utils.label_to_path(it))
Patrick Rohre1a853e2022-10-26 12:31:39 -0700904
Patrick Rohr15a2c302022-10-26 15:08:57 -0700905 # Actions using template "action_with_pydeps" also put script inside inputs.
906 # TODO: it might make sense to filter inputs inside GnParser.
907 if script in module.srcs:
908 module.srcs.remove(script)
909
Patrick Rohre1a853e2022-10-26 12:31:39 -0700910 module.out.update(target.outputs)
Motomu Utsumia6c33152022-11-02 18:21:55 +0900911
Motomu Utsumi747030b2022-12-01 17:47:57 +0900912 if target.script == '//base/android/jni_generator/jni_registration_generator.py':
Motomu Utsumi9ca466b2022-11-10 17:12:29 +0900913 # jni_registration_generator.py doesn't work with python2
914 module.cmd = "python3 " + module.cmd
Motomu Utsumi7bc2fcc2022-11-10 17:09:54 +0900915 # Path in the original sources file does not work in genrule.
916 # So creating sources file in cmd based on the srcs of this target.
917 # Adding ../$(current_dir)/ to the head because jni_registration_generator.py uses the files
918 # whose path startswith(..)
919 commands = ["current_dir=`basename \\\`pwd\\\``;",
920 "for f in $(in);",
921 "do",
922 "echo \\\"../$$current_dir/$$f\\\" >> $(genDir)/java.sources;",
923 "done;",
924 module.cmd]
Motomu Utsumi2a892d22022-11-10 18:03:20 +0900925
926 # .h file jni_registration_generator.py generates has #define with directory name.
927 # With the genrule env that contains "." which is invalid. So replace that at the end of cmd.
Mohannad Farrag7c0f0982022-11-10 14:39:49 +0000928 commands.append(";sed -i -e 's/OUT_SOONG_.TEMP_SBOX_.*_OUT/GEN/g' ")
Motomu Utsumi2a892d22022-11-10 18:03:20 +0900929 commands.append("$(genDir)/components/cronet/android/cronet_jni_registration.h")
Motomu Utsumi7bc2fcc2022-11-10 17:09:54 +0900930 module.cmd = NEWLINE.join(commands)
Motomu Utsumia6c33152022-11-02 18:21:55 +0900931
Patrick Rohre1a853e2022-10-26 12:31:39 -0700932 blueprint.add_module(module)
933 return module
934
935
Patrick Rohr92d74122022-10-21 15:50:52 -0700936
Motomu Utsumic34b1372022-11-17 22:15:51 +0900937def _get_cflags(cflags, defines):
938 cflags = {flag for flag in cflags if flag in cflag_allowlist}
Motomu Utsumifa7e9262022-10-26 19:43:02 +0900939 # Consider proper allowlist or denylist if needed
Motomu Utsumic34b1372022-11-17 22:15:51 +0900940 cflags |= set("-D%s" % define.replace("\"", "\\\"") for define in defines)
Patrick Rohr92d74122022-10-21 15:50:52 -0700941 return cflags
942
Motomu Utsumic34b1372022-11-17 22:15:51 +0900943def set_module_flags(module, cflags, defines):
944 module.cflags.update(_get_cflags(cflags, defines))
945 # TODO: implement proper cflag parsing.
946 for flag in cflags:
947 if '-std=' in flag:
948 module.cpp_std = flag[len('-std='):]
Motomu Utsumic34b1372022-11-17 22:15:51 +0900949 if '-fexceptions' in flag:
950 module.cppflags.add('-fexceptions')
Patrick Rohr92d74122022-10-21 15:50:52 -0700951
Mohannad Farrag631443e2022-11-21 16:17:01 +0000952def add_genrule_per_arch(module, dep_module, type):
953 module.generated_headers.update(dep_module.genrule_headers)
954 # If the module is a static library, export all the generated headers.
955 if type == 'cc_library_static':
956 module.export_generated_headers.update(dep_module.genrule_headers)
957 module.srcs.update(dep_module.genrule_srcs)
958 module.shared_libs.update(dep_module.genrule_shared_libs)
959 module.header_libs.update(dep_module.genrule_header_libs)
960
Motomu Utsumi88efbb42022-11-17 22:18:15 +0900961def set_module_include_dirs(module, cflags, include_dirs):
Motomu Utsumi88efbb42022-11-17 22:18:15 +0900962 for flag in cflags:
963 if '-isystem' in flag:
Patrick Rohr3cd5ffb2022-11-18 17:40:55 -0800964 module.local_include_dirs.add(flag[len('-isystem../../'):])
Motomu Utsumi88efbb42022-11-17 22:18:15 +0900965
966 # Adding local_include_dirs is necessary due to source_sets / filegroups
967 # which do not properly propagate include directories.
968 # Filter any directory inside //out as a) this directory does not exist for
969 # aosp / soong builds and b) the include directory should already be
970 # configured via library dependency.
Patrick Rohr3cd5ffb2022-11-18 17:40:55 -0800971 module.local_include_dirs.update([gn_utils.label_to_path(d)
Motomu Utsumi88efbb42022-11-17 22:18:15 +0900972 for d in include_dirs
973 if not re.match('^//out/.*', d)])
Motomu Utsumi88efbb42022-11-17 22:18:15 +0900974
Patrick Rohr92d74122022-10-21 15:50:52 -0700975def create_modules_from_target(blueprint, gn, gn_target_name):
976 """Generate module(s) for a given GN target.
977
978 Given a GN target name, generate one or more corresponding modules into a
979 blueprint. The only case when this generates >1 module is proto libraries.
980
981 Args:
982 blueprint: Blueprint instance which is being generated.
983 gn: gn_utils.GnParser object.
984 gn_target_name: GN target for module generation.
985 """
986 bp_module_name = label_to_module_name(gn_target_name)
987 if bp_module_name in blueprint.modules:
988 return blueprint.modules[bp_module_name]
989 target = gn.get_target(gn_target_name)
Patrick Rohr16228942022-10-26 14:00:26 -0700990 log.info('create modules for %s (%s)', target.name, target.type)
Patrick Rohr92d74122022-10-21 15:50:52 -0700991
Patrick Rohr92d74122022-10-21 15:50:52 -0700992 if target.type == 'executable':
Patrick Rohrc8f41cd2022-11-15 22:46:10 -0800993 if target.testonly:
Patrick Rohr92d74122022-10-21 15:50:52 -0700994 module_type = 'cc_test'
995 else:
Patrick Rohrc8f41cd2022-11-15 22:46:10 -0800996 # Can be used for both host and device targets.
Patrick Rohr92d74122022-10-21 15:50:52 -0700997 module_type = 'cc_binary'
998 module = Module(module_type, bp_module_name, gn_target_name)
999 elif target.type == 'static_library':
1000 module = Module('cc_library_static', bp_module_name, gn_target_name)
1001 elif target.type == 'shared_library':
1002 module = Module('cc_library_shared', bp_module_name, gn_target_name)
1003 elif target.type == 'source_set':
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001004 module = Module('cc_object', bp_module_name, gn_target_name)
Patrick Rohr92d74122022-10-21 15:50:52 -07001005 elif target.type == 'group':
1006 # "group" targets are resolved recursively by gn_utils.get_target().
1007 # There's nothing we need to do at this level for them.
1008 return None
1009 elif target.type == 'proto_library':
1010 module = create_proto_modules(blueprint, gn, target)
1011 if module is None:
1012 return None
1013 elif target.type == 'action':
Mohannad Farrag7ff99912022-11-29 17:16:00 +00001014 if gn_utils.is_java_action(target.script, target.outputs) and \
1015 target.name != "//components/cronet/android:cronet_jni_registration":
1016 # This is a cc_genrule that generates both a c++ header file and
1017 # srcjar for java. Treat it as a cc_genrule for the time being while
1018 # making anothe deep copy of the module and append _java to it for
1019 # the java_library.
1020 module = create_action_module(blueprint, target, 'java_genrule')
1021 else:
1022 module = create_action_module(blueprint, target, 'cc_genrule')
Mohannad Farragf076f3e2022-10-31 17:45:28 +00001023 elif target.type == 'action_foreach':
Mohannad Farragbab6c892022-11-02 14:09:46 +00001024 module = create_action_foreach_modules(blueprint, target)
Patrick Rohr59a76652022-10-26 12:36:56 -07001025 elif target.type == 'copy':
1026 # TODO: careful now! copy targets are not supported yet, but this will stop
1027 # traversing the dependency tree. For //base:base, this is not a big
1028 # problem as libicu contains the only copy target which happens to be a
1029 # leaf node.
1030 return None
Patrick Rohrad440602022-11-10 22:09:04 -08001031 elif target.type == 'java_group':
1032 # Java targets are handled outside of create_modules_from_target.
1033 return None
Patrick Rohr92d74122022-10-21 15:50:52 -07001034 else:
1035 raise Error('Unknown target %s (%s)' % (target.name, target.type))
1036
1037 blueprint.add_module(module)
Patrick Rohr92d74122022-10-21 15:50:52 -07001038 module.init_rc = target_initrc.get(target.name, [])
1039 module.srcs.update(
1040 gn_utils.label_to_path(src)
1041 for src in target.sources
Motomu Utsumif951e502022-11-07 19:31:15 +09001042 if is_supported_source_file(src) and not src.startswith("//out/test"))
Patrick Rohr92d74122022-10-21 15:50:52 -07001043
Patrick Rohr3b5ff762022-11-16 10:22:16 -08001044 # Add arch-specific properties
1045 for arch_name, arch in target.arch.items():
Motomu Utsumi40f95c52022-11-17 19:39:13 +09001046 module.target[arch_name].srcs.update(
1047 gn_utils.label_to_path(src)
1048 for src in arch.sources
1049 if is_supported_source_file(src) and not src.startswith("//out/test"))
Patrick Rohr3b5ff762022-11-16 10:22:16 -08001050
Mohannad Farragbaf0d572022-11-22 11:53:54 +00001051 module.rtti = target.rtti
1052
Patrick Rohr92d74122022-10-21 15:50:52 -07001053 if target.type in gn_utils.LINKER_UNIT_TYPES:
Motomu Utsumic34b1372022-11-17 22:15:51 +09001054 set_module_flags(module, target.cflags, target.defines)
Motomu Utsumi88efbb42022-11-17 22:18:15 +09001055 set_module_include_dirs(module, target.cflags, target.include_dirs)
Motomu Utsumif0f47682022-11-17 22:34:39 +09001056 # TODO: set_module_xxx is confusing, apply similar function to module and target in better way.
1057 for arch_name, arch in target.arch.items():
1058 set_module_flags(module.target[arch_name], arch.cflags, arch.defines)
Motomu Utsumi3371d682022-11-28 16:56:52 +09001059 # -Xclang -target-feature -Xclang +mte are used to enable MTE (Memory Tagging Extensions).
1060 # Flags which does not start with '-' could not be in the cflags so enabling MTE by
1061 # -march and -mcpu Feature Modifiers. MTE is only available on arm64. This is needed for
1062 # building //base/allocator/partition_allocator:partition_alloc for arm64.
1063 if '+mte' in arch.cflags and arch_name == 'android_arm64':
1064 module.target[arch_name].cflags.add('-march=armv8-a+memtag')
Motomu Utsumif0f47682022-11-17 22:34:39 +09001065 set_module_include_dirs(module.target[arch_name], arch.cflags, arch.include_dirs)
Patrick Rohr92d74122022-10-21 15:50:52 -07001066
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001067 module.host_supported = target.host_supported()
1068 module.device_supported = target.device_supported()
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001069
Motomu Utsumi8ca12412022-11-30 16:27:30 +09001070 if module.is_genrule():
1071 module.apex_available.add(tethering_apex)
1072
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001073 if module.is_compiled():
Patrick Rohr92d74122022-10-21 15:50:52 -07001074 # Don't try to inject library/source dependencies into genrules or
1075 # filegroups because they are not compiled in the traditional sense.
1076 module.defaults = [defaults_module]
1077 for lib in target.libs:
1078 # Generally library names should be mangled as 'libXXX', unless they
1079 # are HAL libraries (e.g., android.hardware.health@2.0) or AIDL c++ / NDK
1080 # libraries (e.g. "android.hardware.power.stats-V1-cpp")
1081 android_lib = lib if '@' in lib or "-cpp" in lib or "-ndk" in lib \
1082 else 'lib' + lib
1083 if lib in shared_library_allowlist:
1084 module.add_android_shared_lib(android_lib)
1085 if lib in static_library_allowlist:
1086 module.add_android_static_lib(android_lib)
1087
Patrick Rohrd9dd3b92022-11-09 16:15:30 -08001088 # Remove prohibited include directories
1089 module.local_include_dirs = [d for d in module.local_include_dirs
1090 if d not in local_include_dirs_denylist]
1091
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001092 # If the module is a static library, export all the generated headers.
1093 if module.type == 'cc_library_static':
1094 module.export_generated_headers = module.generated_headers
1095
Motomu Utsumiee47af62022-11-30 16:41:15 +09001096 if module.name == 'cronet_aml_components_cronet_android_cronet':
1097 if target.output_name is None:
1098 raise Error('Failed to get output_name for libcronet name')
1099 # .so file name needs to match with CronetLibraryLoader.java (e.g. libcronet.109.0.5386.0.so)
1100 # So setting the output name based on the output_name from the desc.json
1101 module.stem = 'lib' + target.output_name
1102
Patrick Rohr92d74122022-10-21 15:50:52 -07001103 # dep_name is an unmangled GN target name (e.g. //foo:bar(toolchain)).
Motomu Utsumif1daa232022-11-08 13:28:37 +09001104 # Currently, only one module is generated from target even target has multiple toolchains.
1105 # And module is generated based on the first visited target.
1106 # Sort deps before iteration to make result deterministic.
1107 all_deps = sorted(target.deps | target.source_set_deps | target.transitive_proto_deps)
Patrick Rohr92d74122022-10-21 15:50:52 -07001108 for dep_name in all_deps:
Patrick Rohr5cc46e02022-10-26 14:32:45 -07001109 # |builtin_deps| override GN deps with Android-specific ones. See the
1110 # config in the top of this file.
Patrick Rohr07876662022-11-15 22:55:23 -08001111 if dep_name in builtin_deps:
1112 builtin_deps[dep_name](module)
Patrick Rohr5cc46e02022-10-26 14:32:45 -07001113 continue
1114
Patrick Rohr92d74122022-10-21 15:50:52 -07001115 dep_module = create_modules_from_target(blueprint, gn, dep_name)
1116
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001117 if dep_module is None:
1118 continue
Motomu Utsumie246feb2022-11-01 17:25:56 +09001119 # TODO: Proper dependency check for genrule.
1120 # Currently, only propagating genrule dependencies.
1121 # Also, currently, all the dependencies are propagated upwards.
1122 # in gn, public_deps should be propagated but deps should not.
1123 # Not sure this information is available in the desc.json.
1124 # Following rule works for adding android_runtime_jni_headers to base:base.
1125 # If this doesn't work for other target, hardcoding for specific target
1126 # might be better.
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001127 if module.is_genrule() and dep_module.is_genrule():
1128 module.genrule_headers.add(dep_module.name)
1129 module.genrule_headers.update(dep_module.genrule_headers)
Motomu Utsumie246feb2022-11-01 17:25:56 +09001130
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001131 # For filegroups, and genrule, recurse but don't apply the
Patrick Rohra6ce0232022-11-16 22:09:01 -08001132 # deps.
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001133 if not module.is_compiled() or module.is_genrule():
Patrick Rohr92d74122022-10-21 15:50:52 -07001134 continue
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001135
Patrick Rohr92d74122022-10-21 15:50:52 -07001136 if dep_module.type == 'cc_library_shared':
1137 module.shared_libs.add(dep_module.name)
1138 elif dep_module.type == 'cc_library_static':
1139 module.static_libs.add(dep_module.name)
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001140 elif dep_module.type == 'cc_object':
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001141 module.merge_attribute('generated_headers', dep_module, target.arch.keys())
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001142 if module.type != 'cc_object':
1143 if dep_module.has_input_files():
1144 # Only add it as part of srcs if the dep_module has input files otherwise
1145 # this would throw an error.
1146 module.srcs.add(":" + dep_module.name)
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001147 module.merge_attribute('export_generated_headers', dep_module,
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001148 target.arch.keys(), 'generated_headers')
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001149 elif dep_module.type == 'cc_genrule':
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001150 module.merge_attribute('generated_headers', dep_module, [], 'genrule_headers')
1151 module.merge_attribute('srcs', dep_module, [], 'genrule_srcs')
1152 module.merge_attribute('shared_libs', dep_module, [], 'genrule_shared_libs')
1153 module.merge_attribute('header_libs', dep_module, [], 'genrule_header_libs')
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001154 if module.type not in ["cc_object"]:
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001155 module.merge_attribute('export_generated_headers', dep_module, [],
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001156 'genrule_headers')
Patrick Rohr92d74122022-10-21 15:50:52 -07001157 elif dep_module.type == 'cc_binary':
1158 continue # Ignore executables deps (used by cmdline integration tests).
1159 else:
1160 raise Error('Unknown dep %s (%s) for target %s' %
1161 (dep_module.name, dep_module.type, module.name))
1162
Patrick Rohrb51878f2022-11-16 23:49:03 -08001163 for arch_name, arch in target.arch.items():
1164 for dep_name in arch.deps:
1165 dep_module = create_modules_from_target(blueprint, gn, dep_name)
1166 # Arch-specific dependencies currently only include cc_library_static.
1167 # Revisit this approach once we need to support more target types.
1168 if dep_module.type == 'cc_library_static':
1169 module.target[arch_name].static_libs.add(dep_module.name)
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001170 elif dep_module.type == 'cc_genrule':
1171 if dep_module.name.endswith(arch_name):
1172 module.target[arch_name].generated_headers.update(dep_module.genrule_headers)
1173 module.target[arch_name].srcs.update(dep_module.genrule_srcs)
1174 module.target[arch_name].shared_libs.update(dep_module.genrule_shared_libs)
1175 module.target[arch_name].header_libs.update(dep_module.genrule_header_libs)
1176 if module.type not in ["cc_object"]:
1177 module.target[arch_name].export_generated_headers.update(
1178 dep_module.genrule_headers)
Patrick Rohrb51878f2022-11-16 23:49:03 -08001179 else:
1180 raise Error('Unsupported arch-specific dependency %s of target %s with type %s' %
1181 (dep_module.name, target.name, dep_module.type))
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001182 for dep_name in arch.source_set_deps:
1183 dep_module = create_modules_from_target(blueprint, gn, dep_name)
1184 if dep_module.type == 'cc_object':
1185 if module.type != 'cc_object':
1186 # We only want to bubble up cc_objects for modules that are not cc_objects
1187 # otherwise they'd be recompiled and that would cause multiple symbol redefinitions.
1188 if dep_module.has_input_files():
1189 # Only add it as part of srcs if the dep_module has input files otherwise
1190 # this would throw an error.
1191 module.target[arch_name].srcs.add(":" + dep_module.name)
1192 else:
1193 raise Error('Unsupported arch-specific dependency %s of target %s with type %s' %
1194 (dep_module.name, target.name, dep_module.type))
Patrick Rohr92d74122022-10-21 15:50:52 -07001195 return module
1196
Patrick Rohrb18aca22022-11-04 15:07:32 -07001197def create_java_module(blueprint, gn):
1198 bp_module_name = module_prefix + 'java'
1199 module = Module('java_library', bp_module_name, '//gn:java')
Mohannad Farrag21562d62022-11-07 13:09:31 +00001200 module.srcs.update([gn_utils.label_to_path(source) for source in gn.java_sources])
Mohannad Farrag6a2d88a2022-11-28 19:33:48 +00001201 for dep in gn.java_actions:
1202 create_modules_from_target(blueprint, gn, dep)
Patrick Rohrb18aca22022-11-04 15:07:32 -07001203 blueprint.add_module(module)
Patrick Rohr92d74122022-10-21 15:50:52 -07001204
Patrick Rohr6ef22722022-11-18 18:24:01 -08001205def update_jni_registration_module(module, gn):
Motomu Utsumi47d122f2022-11-10 17:32:23 +09001206 # TODO: deny list is in the arg of jni_registration_generator.py. Should not be hardcoded
1207 deny_list = [
1208 '//base/android/java/src/org/chromium/base/library_loader/LibraryLoader.java',
1209 '//base/android/java/src/org/chromium/base/library_loader/LibraryPrefetcher.java',
1210 '//base/android/java/src/org/chromium/base/process_launcher/ChildProcessService.java',
1211 '//base/android/java/src/org/chromium/base/SysUtils.java']
1212
Motomu Utsumie3ce7702022-11-10 16:22:11 +09001213 # TODO: java_sources might not contain all the required java files
Motomu Utsumi47d122f2022-11-10 17:32:23 +09001214 module.srcs.update([gn_utils.label_to_path(source)
1215 for source in gn.java_sources if source not in deny_list])
Motomu Utsumie3ce7702022-11-10 16:22:11 +09001216
Motomu Utsumia71281c2022-11-18 15:19:00 +09001217def create_blueprint_for_targets(gn, targets):
Patrick Rohr92d74122022-10-21 15:50:52 -07001218 """Generate a blueprint for a list of GN targets."""
1219 blueprint = Blueprint()
1220
1221 # Default settings used by all modules.
1222 defaults = Module('cc_defaults', defaults_module, '//gn:default_deps')
Patrick Rohr92d74122022-10-21 15:50:52 -07001223 defaults.cflags = [
Patrick Rohr3ce74772022-11-11 14:19:58 -08001224 '-DGOOGLE_PROTOBUF_NO_RTTI',
Patrick Rohr92d74122022-10-21 15:50:52 -07001225 '-Wno-error=return-type',
Patrick Rohr3a1ec1d2022-10-31 13:30:17 -07001226 '-Wno-non-virtual-dtor',
Patrick Rohr5c700022022-11-08 19:33:07 -08001227 '-Wno-macro-redefined',
Patrick Rohr98065152022-10-31 14:49:58 -07001228 '-Wno-missing-field-initializers',
Patrick Rohr92d74122022-10-21 15:50:52 -07001229 '-Wno-sign-compare',
1230 '-Wno-sign-promo',
1231 '-Wno-unused-parameter',
Mohannad Farrag54d52442022-11-21 16:27:02 +00001232 '-Wno-null-pointer-subtraction', # Needed to libevent
Mohannad Farragd98a96d2022-11-10 14:56:19 +00001233 '-Wno-deprecated-non-prototype', # needed for zlib
Patrick Rohr92d74122022-10-21 15:50:52 -07001234 '-fvisibility=hidden',
Motomu Utsumiba020942022-11-14 15:15:41 +09001235 '-Wno-ambiguous-reversed-operator', # needed for icui18n
Motomu Utsumib1ec8782022-11-14 15:25:57 +09001236 '-Wno-unreachable-code-loop-increment', # needed for icui18n
Patrick Rohr92d74122022-10-21 15:50:52 -07001237 '-O2',
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001238 '-fPIC',
Patrick Rohr92d74122022-10-21 15:50:52 -07001239 ]
Patrick Rohrc03f1bb2022-11-18 16:13:17 -08001240 # Chromium builds do not add a dependency for headers found inside the
1241 # sysroot, so they are added globally via defaults.
1242 defaults.target['android'].header_libs = [
1243 'media_ndk_headers',
1244 'jni_headers',
1245 ]
Patrick Rohr5446df82022-11-18 14:54:55 -08001246 defaults.target['host'].cflags = [
1247 # -DANDROID is added by default but target.defines contain -DANDROID if
1248 # it's required. So adding -UANDROID to cancel default -DANDROID if it's
1249 # not specified.
1250 # Note: -DANDROID is not consistently applied across the chromium code
1251 # base, so it is removed unconditionally for host targets.
1252 '-UANDROID',
1253 ]
Patrick Rohr61f2acb2022-10-31 14:08:18 -07001254 defaults.stl = 'none'
Motomu Utsumi8ca12412022-11-30 16:27:30 +09001255 defaults.min_sdk_version = 29
1256 defaults.apex_available.add(tethering_apex)
Patrick Rohr92d74122022-10-21 15:50:52 -07001257 blueprint.add_module(defaults)
Patrick Rohr344b2472022-10-25 11:32:15 -07001258
Patrick Rohr92d74122022-10-21 15:50:52 -07001259 for target in targets:
1260 create_modules_from_target(blueprint, gn, target)
Patrick Rohrb18aca22022-11-04 15:07:32 -07001261
1262 create_java_module(blueprint, gn)
Patrick Rohr6ef22722022-11-18 18:24:01 -08001263 for module in blueprint.modules.values():
1264 if 'cronet_jni_registration' in module.name:
1265 update_jni_registration_module(module, gn)
Patrick Rohra7d029d2022-11-08 12:23:11 -08001266
1267 # Merge in additional hardcoded arguments.
1268 for module in blueprint.modules.values():
1269 for key, add_val in additional_args.get(module.name, []):
1270 curr = getattr(module, key)
1271 if add_val and isinstance(add_val, set) and isinstance(curr, set):
1272 curr.update(add_val)
1273 elif isinstance(add_val, str) and (not curr or isinstance(curr, str)):
1274 setattr(module, key, add_val)
1275 elif isinstance(add_val, bool) and (not curr or isinstance(curr, bool)):
1276 setattr(module, key, add_val)
1277 elif isinstance(add_val, dict) and isinstance(curr, dict):
1278 curr.update(add_val)
1279 elif isinstance(add_val, dict) and isinstance(curr, Target):
1280 curr.__dict__.update(add_val)
1281 else:
1282 raise Error('Unimplemented type %r of additional_args: %r' %
1283 (type(add_val), key))
1284
Patrick Rohr92d74122022-10-21 15:50:52 -07001285 return blueprint
1286
1287
1288def main():
1289 parser = argparse.ArgumentParser(
1290 description='Generate Android.bp from a GN description.')
1291 parser.add_argument(
Patrick Rohr92d74122022-10-21 15:50:52 -07001292 '--desc',
Motomu Utsumi879dec82022-11-18 15:25:12 +09001293 help='GN description (e.g., gn desc out --format=json --all-toolchains "//*".' +
1294 'You can specify multiple --desc options for different target_cpu',
1295 required=True,
1296 action='append'
Patrick Rohr92d74122022-10-21 15:50:52 -07001297 )
1298 parser.add_argument(
1299 '--extras',
1300 help='Extra targets to include at the end of the Blueprint file',
1301 default=os.path.join(gn_utils.repo_root(), 'Android.bp.extras'),
1302 )
1303 parser.add_argument(
1304 '--output',
1305 help='Blueprint file to create',
1306 default=os.path.join(gn_utils.repo_root(), 'Android.bp'),
1307 )
1308 parser.add_argument(
Patrick Rohr16228942022-10-26 14:00:26 -07001309 '-v',
1310 '--verbose',
1311 help='Print debug logs.',
1312 action='store_true',
1313 )
1314 parser.add_argument(
Patrick Rohr92d74122022-10-21 15:50:52 -07001315 'targets',
1316 nargs=argparse.REMAINDER,
Patrick Rohr1aa504a2022-10-25 10:30:42 -07001317 help='Targets to include in the blueprint (e.g., "//:perfetto_tests")'
1318 )
Patrick Rohr92d74122022-10-21 15:50:52 -07001319 args = parser.parse_args()
1320
Patrick Rohr16228942022-10-26 14:00:26 -07001321 if args.verbose:
1322 log.basicConfig(format='%(levelname)s:%(funcName)s:%(message)s', level=log.DEBUG)
1323
Patrick Rohrd0077b72022-11-15 12:43:26 -08001324 targets = args.targets or default_targets
Motomu Utsumi879dec82022-11-18 15:25:12 +09001325 gn = gn_utils.GnParser()
1326 for desc_file in args.desc:
1327 with open(desc_file) as f:
1328 desc = json.load(f)
1329 for target in targets:
1330 gn.parse_gn_desc(desc, target)
Motomu Utsumia71281c2022-11-18 15:19:00 +09001331 blueprint = create_blueprint_for_targets(gn, targets)
Patrick Rohr92d74122022-10-21 15:50:52 -07001332 project_root = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
1333 tool_name = os.path.relpath(os.path.abspath(__file__), project_root)
1334
Patrick Rohr92d74122022-10-21 15:50:52 -07001335 # Add any proto groups to the blueprint.
1336 for l_name, t_names in proto_groups.items():
1337 create_proto_group_modules(blueprint, gn, l_name, t_names)
1338
1339 output = [
Patrick Rohr5478b392022-10-25 09:58:50 -07001340 """// Copyright (C) 2022 The Android Open Source Project
Patrick Rohr92d74122022-10-21 15:50:52 -07001341//
1342// Licensed under the Apache License, Version 2.0 (the "License");
1343// you may not use this file except in compliance with the License.
1344// You may obtain a copy of the License at
1345//
1346// http://www.apache.org/licenses/LICENSE-2.0
1347//
1348// Unless required by applicable law or agreed to in writing, software
1349// distributed under the License is distributed on an "AS IS" BASIS,
1350// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1351// See the License for the specific language governing permissions and
1352// limitations under the License.
1353//
1354// This file is automatically generated by %s. Do not edit.
1355""" % (tool_name)
1356 ]
1357 blueprint.to_string(output)
Patrick Rohrcb98e9b2022-10-25 09:57:02 -07001358 if os.path.exists(args.extras):
1359 with open(args.extras, 'r') as r:
1360 for line in r:
1361 output.append(line.rstrip("\n\r"))
Patrick Rohr92d74122022-10-21 15:50:52 -07001362
1363 out_files = []
1364
1365 # Generate the Android.bp file.
1366 out_files.append(args.output + '.swp')
1367 with open(out_files[-1], 'w') as f:
1368 f.write('\n'.join(output))
1369 # Text files should have a trailing EOL.
1370 f.write('\n')
1371
Patrick Rohr94693eb2022-10-25 10:09:16 -07001372 return 0
Patrick Rohr92d74122022-10-21 15:50:52 -07001373
1374
1375if __name__ == '__main__':
1376 sys.exit(main())