blob: 3f1fb832fc88699806ab35f9a7d4d713408b11eb [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
Mohannad Farrag9c2cee12022-12-06 17:11:25 +000037from pathlib import Path
Patrick Rohr92d74122022-10-21 15:50:52 -070038
39import gn_utils
40
Patrick Rohr92d74122022-10-21 15:50:52 -070041ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
42
Patrick Rohr06296362022-11-10 21:37:33 -080043# Default targets to translate to the blueprint file.
44default_targets = [
45 '//components/cronet/android:cronet',
Motomu Utsumiabbfdc32022-11-25 12:19:23 +090046 '//components/cronet:cronet_package',
Patrick Rohr06296362022-11-10 21:37:33 -080047]
48
Patrick Rohr92d74122022-10-21 15:50:52 -070049# Defines a custom init_rc argument to be applied to the corresponding output
50# blueprint target.
51target_initrc = {
Patrick Rohrc36ef422022-10-25 10:38:05 -070052 # TODO: this can probably be removed.
Patrick Rohr92d74122022-10-21 15:50:52 -070053}
54
55target_host_supported = [
Patrick Rohrdc383942022-10-25 10:45:29 -070056 # TODO: remove if this is not useful for the cronet build.
Patrick Rohr92d74122022-10-21 15:50:52 -070057]
58
Patrick Rohr92d74122022-10-21 15:50:52 -070059# Proto target groups which will be made public.
60proto_groups = {
Patrick Rohr95212a22022-10-25 09:53:13 -070061 # TODO: remove if this is not used for the cronet build.
Patrick Rohr92d74122022-10-21 15:50:52 -070062}
63
64# All module names are prefixed with this string to avoid collisions.
Patrick Rohr61b2bad2022-10-25 10:49:20 -070065module_prefix = 'cronet_aml_'
Patrick Rohr92d74122022-10-21 15:50:52 -070066
67# Shared libraries which are directly translated to Android system equivalents.
68shared_library_allowlist = [
69 'android',
70 'android.hardware.atrace@1.0',
71 'android.hardware.health@2.0',
72 'android.hardware.health-V1-ndk',
73 'android.hardware.power.stats@1.0',
74 "android.hardware.power.stats-V1-cpp",
75 'base',
76 'binder',
77 'binder_ndk',
78 'cutils',
79 'hidlbase',
80 'hidltransport',
81 'hwbinder',
82 'incident',
83 'log',
84 'services',
85 'statssocket',
86 "tracingproxy",
87 'utils',
88]
89
90# Static libraries which are directly translated to Android system equivalents.
91static_library_allowlist = [
92 'statslog_perfetto',
93]
94
Patrick Rohrd9dd3b92022-11-09 16:15:30 -080095# Include directories that will be removed from all targets.
96local_include_dirs_denylist = [
Patrick Rohrd9dd3b92022-11-09 16:15:30 -080097]
98
Patrick Rohr92d74122022-10-21 15:50:52 -070099# Name of the module which settings such as compiler flags for all other
100# modules.
101defaults_module = module_prefix + 'defaults'
102
103# Location of the project in the Android source tree.
Patrick Rohr76ceeb52022-11-07 14:18:58 -0800104tree_path = 'external/chromium_org'
Patrick Rohr92d74122022-10-21 15:50:52 -0700105
106# Path for the protobuf sources in the standalone build.
107buildtools_protobuf_src = '//buildtools/protobuf/src'
108
109# Location of the protobuf src dir in the Android source tree.
110android_protobuf_src = 'external/protobuf/src'
111
Mohannad Farragc739dda2022-12-02 15:43:46 +0000112# put all args on a new line for better diffs.
113NEWLINE = ' " +\n "'
Mohannad Farrag00ecfb52022-12-02 14:44:15 +0000114
Patrick Rohr92d74122022-10-21 15:50:52 -0700115# Compiler flags which are passed through to the blueprint.
Motomu Utsumic8b7bea2022-11-16 18:12:44 +0900116cflag_allowlist = [
Motomu Utsumicf68d732022-11-16 18:15:21 +0900117 # needed for zlib:zlib
118 "-mpclmul",
119 # needed for zlib:zlib
120 "-mssse3",
Mohannad Farrag7f29d832022-11-23 19:52:41 +0000121 # needed for zlib:zlib
122 "-msse3",
123 # needed for zlib:zlib
124 "-msse4.2",
Motomu Utsumic8b7bea2022-11-16 18:12:44 +0900125]
Patrick Rohr92d74122022-10-21 15:50:52 -0700126
Patrick Rohr92d74122022-10-21 15:50:52 -0700127# Additional arguments to apply to Android.bp rules.
128additional_args = {
Patrick Rohr2267a0a2022-11-08 18:59:34 -0800129 # TODO: remove if not needed.
Patrick Rohrd90025f2022-11-11 14:18:35 -0800130 'cronet_aml_components_cronet_android_cronet': [
131 ('linker_scripts', {
132 'base/android/library_loader/anchor_functions.lds',
133 }),
134 ],
Patrick Rohrbb0956e2022-11-09 15:37:16 -0800135 'cronet_aml_net_net': [
Patrick Rohr9f4d3e32022-11-09 16:37:31 -0800136 ('export_static_lib_headers', {
137 'cronet_aml_net_third_party_quiche_quiche',
138 'cronet_aml_crypto_crypto',
139 }),
Mohannad Farrag37388fa2022-11-10 20:42:13 +0000140 ],
Patrick Rohr92d74122022-10-21 15:50:52 -0700141}
142
Patrick Rohr92d74122022-10-21 15:50:52 -0700143# Android equivalents for third-party libraries that the upstream project
144# depends on.
145builtin_deps = {
Patrick Rohr14ee0932022-11-15 12:10:27 -0800146 '//net/tools/root_store_tool:root_store_tool':
147 lambda x: None,
Patrick Rohr92d74122022-10-21 15:50:52 -0700148}
149
Motomu Utsumi8ca12412022-11-30 16:27:30 +0900150# Name of tethering apex module
151tethering_apex = "com.android.tethering"
152
Patrick Rohr92d74122022-10-21 15:50:52 -0700153# ----------------------------------------------------------------------------
154# End of configuration.
155# ----------------------------------------------------------------------------
156
157
158class Error(Exception):
159 pass
160
161
162class ThrowingArgumentParser(argparse.ArgumentParser):
163
164 def __init__(self, context):
165 super(ThrowingArgumentParser, self).__init__()
166 self.context = context
167
168 def error(self, message):
169 raise Error('%s: %s' % (self.context, message))
170
171
172def write_blueprint_key_value(output, name, value, sort=True):
173 """Writes a Blueprint key-value pair to the output"""
174
175 if isinstance(value, bool):
176 if value:
177 output.append(' %s: true,' % name)
178 else:
179 output.append(' %s: false,' % name)
180 return
181 if not value:
182 return
183 if isinstance(value, set):
184 value = sorted(value)
185 if isinstance(value, list):
186 output.append(' %s: [' % name)
187 for item in sorted(value) if sort else value:
188 output.append(' "%s",' % item)
189 output.append(' ],')
190 return
191 if isinstance(value, Target):
192 value.to_string(output)
193 return
194 if isinstance(value, dict):
195 kv_output = []
196 for k, v in value.items():
197 write_blueprint_key_value(kv_output, k, v)
198
199 output.append(' %s: {' % name)
200 for line in kv_output:
201 output.append(' %s' % line)
202 output.append(' },')
203 return
204 output.append(' %s: "%s",' % (name, value))
205
206
207class Target(object):
208 """A target-scoped part of a module"""
209
210 def __init__(self, name):
211 self.name = name
Patrick Rohr5d399b32022-11-16 10:19:55 -0800212 self.srcs = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700213 self.shared_libs = set()
214 self.static_libs = set()
215 self.whole_static_libs = set()
Patrick Rohrc03f1bb2022-11-18 16:13:17 -0800216 self.header_libs = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700217 self.cflags = set()
218 self.dist = dict()
219 self.strip = dict()
220 self.stl = None
Motomu Utsumi50ad2172022-11-17 22:29:53 +0900221 self.cppflags = set()
Patrick Rohr3cd5ffb2022-11-18 17:40:55 -0800222 self.local_include_dirs = set()
Patrick Rohr81435162022-11-17 19:34:32 -0800223 self.export_system_include_dirs = set()
Mohannad Farrag631443e2022-11-21 16:17:01 +0000224 self.generated_headers = set()
225 self.export_generated_headers = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700226
227 def to_string(self, output):
228 nested_out = []
Patrick Rohr5d399b32022-11-16 10:19:55 -0800229 self._output_field(nested_out, 'srcs')
Patrick Rohr92d74122022-10-21 15:50:52 -0700230 self._output_field(nested_out, 'shared_libs')
231 self._output_field(nested_out, 'static_libs')
232 self._output_field(nested_out, 'whole_static_libs')
Patrick Rohrc03f1bb2022-11-18 16:13:17 -0800233 self._output_field(nested_out, 'header_libs')
Patrick Rohr92d74122022-10-21 15:50:52 -0700234 self._output_field(nested_out, 'cflags')
235 self._output_field(nested_out, 'stl')
236 self._output_field(nested_out, 'dist')
237 self._output_field(nested_out, 'strip')
Motomu Utsumi50ad2172022-11-17 22:29:53 +0900238 self._output_field(nested_out, 'cppflags')
239 self._output_field(nested_out, 'local_include_dirs')
Patrick Rohr81435162022-11-17 19:34:32 -0800240 self._output_field(nested_out, 'export_system_include_dirs')
Mohannad Farrag631443e2022-11-21 16:17:01 +0000241 self._output_field(nested_out, 'generated_headers')
242 self._output_field(nested_out, 'export_generated_headers')
Patrick Rohr92d74122022-10-21 15:50:52 -0700243
244 if nested_out:
245 output.append(' %s: {' % self.name)
246 for line in nested_out:
247 output.append(' %s' % line)
248 output.append(' },')
249
250 def _output_field(self, output, name, sort=True):
251 value = getattr(self, name)
252 return write_blueprint_key_value(output, name, value, sort)
253
254
255class Module(object):
256 """A single module (e.g., cc_binary, cc_test) in a blueprint."""
257
258 def __init__(self, mod_type, name, gn_target):
259 self.type = mod_type
260 self.gn_target = gn_target
261 self.name = name
262 self.srcs = set()
Patrick Rohr07876662022-11-15 22:55:23 -0800263 self.comment = 'GN: ' + gn_target
Patrick Rohr92d74122022-10-21 15:50:52 -0700264 self.shared_libs = set()
265 self.static_libs = set()
266 self.whole_static_libs = set()
267 self.runtime_libs = set()
268 self.tools = set()
269 self.cmd = None
270 self.host_supported = False
Patrick Rohrcdda6322022-11-15 22:44:16 -0800271 self.device_supported = True
Patrick Rohr92d74122022-10-21 15:50:52 -0700272 self.vendor_available = False
273 self.init_rc = set()
274 self.out = set()
275 self.export_include_dirs = set()
276 self.generated_headers = set()
277 self.export_generated_headers = set()
Patrick Rohrbb0956e2022-11-09 15:37:16 -0800278 self.export_static_lib_headers = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700279 self.defaults = set()
280 self.cflags = set()
281 self.include_dirs = set()
Patrick Rohr3cd5ffb2022-11-18 17:40:55 -0800282 self.local_include_dirs = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700283 self.header_libs = set()
284 self.required = set()
Patrick Rohr3d8c7282022-10-27 13:36:31 -0700285 self.tool_files = set()
Patrick Rohrbfdc5fd2022-11-16 10:03:49 -0800286 # target contains a dict of Targets indexed by os_arch.
287 # example: { 'android_x86': Target('android_x86')
288 self.target = dict()
289 self.target['android'] = Target('android')
Patrick Rohr82e40742022-11-16 10:20:39 -0800290 self.target['android_x86'] = Target('android_x86')
291 self.target['android_x86_64'] = Target('android_x86_64')
292 self.target['android_arm'] = Target('android_arm')
293 self.target['android_arm64'] = Target('android_arm64')
Patrick Rohrbfdc5fd2022-11-16 10:03:49 -0800294 self.target['host'] = Target('host')
Patrick Rohr92d74122022-10-21 15:50:52 -0700295 self.stl = None
Patrick Rohrb8f830a2022-10-31 11:18:57 -0700296 self.cpp_std = None
Patrick Rohr92d74122022-10-21 15:50:52 -0700297 self.dist = dict()
298 self.strip = dict()
299 self.data = set()
300 self.apex_available = set()
301 self.min_sdk_version = None
302 self.proto = dict()
Patrick Rohrd90025f2022-11-11 14:18:35 -0800303 self.linker_scripts = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700304 # The genrule_XXX below are properties that must to be propagated back
305 # on the module(s) that depend on the genrule.
306 self.genrule_headers = set()
307 self.genrule_srcs = set()
308 self.genrule_shared_libs = set()
Patrick Rohra1a27872022-10-31 11:57:14 -0700309 self.genrule_header_libs = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700310 self.version_script = None
311 self.test_suites = set()
312 self.test_config = None
313 self.stubs = {}
Mohannad Farrag37388fa2022-11-10 20:42:13 +0000314 self.cppflags = set()
315 self.rtti = False
Motomu Utsumiee47af62022-11-30 16:41:15 +0900316 # Name of the output. Used for setting .so file name for libcronet
Mohannad Farrage815d862022-12-06 17:51:43 +0000317 self.libs = set()
Motomu Utsumiee47af62022-11-30 16:41:15 +0900318 self.stem = None
Motomu Utsumi81bb8342022-12-08 11:47:42 +0900319 self.compile_multilib = None
Mohannad Farragb30d3712022-12-06 17:27:04 +0000320 self.aidl = dict()
Patrick Rohr92d74122022-10-21 15:50:52 -0700321
322 def to_string(self, output):
323 if self.comment:
324 output.append('// %s' % self.comment)
325 output.append('%s {' % self.type)
326 self._output_field(output, 'name')
327 self._output_field(output, 'srcs')
328 self._output_field(output, 'shared_libs')
329 self._output_field(output, 'static_libs')
330 self._output_field(output, 'whole_static_libs')
331 self._output_field(output, 'runtime_libs')
332 self._output_field(output, 'tools')
333 self._output_field(output, 'cmd', sort=False)
334 if self.host_supported:
335 self._output_field(output, 'host_supported')
Patrick Rohrcdda6322022-11-15 22:44:16 -0800336 if not self.device_supported:
337 self._output_field(output, 'device_supported')
Patrick Rohr92d74122022-10-21 15:50:52 -0700338 if self.vendor_available:
339 self._output_field(output, 'vendor_available')
340 self._output_field(output, 'init_rc')
341 self._output_field(output, 'out')
342 self._output_field(output, 'export_include_dirs')
343 self._output_field(output, 'generated_headers')
344 self._output_field(output, 'export_generated_headers')
Patrick Rohrbb0956e2022-11-09 15:37:16 -0800345 self._output_field(output, 'export_static_lib_headers')
Patrick Rohr92d74122022-10-21 15:50:52 -0700346 self._output_field(output, 'defaults')
347 self._output_field(output, 'cflags')
348 self._output_field(output, 'include_dirs')
Patrick Rohr3cd5ffb2022-11-18 17:40:55 -0800349 self._output_field(output, 'local_include_dirs')
Patrick Rohr92d74122022-10-21 15:50:52 -0700350 self._output_field(output, 'header_libs')
351 self._output_field(output, 'required')
352 self._output_field(output, 'dist')
353 self._output_field(output, 'strip')
354 self._output_field(output, 'tool_files')
355 self._output_field(output, 'data')
356 self._output_field(output, 'stl')
Patrick Rohrb8f830a2022-10-31 11:18:57 -0700357 self._output_field(output, 'cpp_std')
Patrick Rohr92d74122022-10-21 15:50:52 -0700358 self._output_field(output, 'apex_available')
359 self._output_field(output, 'min_sdk_version')
360 self._output_field(output, 'version_script')
361 self._output_field(output, 'test_suites')
362 self._output_field(output, 'test_config')
363 self._output_field(output, 'stubs')
364 self._output_field(output, 'proto')
Patrick Rohrd90025f2022-11-11 14:18:35 -0800365 self._output_field(output, 'linker_scripts')
Mohannad Farrag37388fa2022-11-10 20:42:13 +0000366 self._output_field(output, 'cppflags')
Mohannad Farrage815d862022-12-06 17:51:43 +0000367 self._output_field(output, 'libs')
Motomu Utsumiee47af62022-11-30 16:41:15 +0900368 self._output_field(output, 'stem')
Motomu Utsumi81bb8342022-12-08 11:47:42 +0900369 self._output_field(output, 'compile_multilib')
Mohannad Farragb30d3712022-12-06 17:27:04 +0000370 self._output_field(output, 'aidl')
Mohannad Farrag37388fa2022-11-10 20:42:13 +0000371 if self.rtti:
372 self._output_field(output, 'rtti')
Patrick Rohr92d74122022-10-21 15:50:52 -0700373
374 target_out = []
Patrick Rohr09ee70e2022-11-16 15:20:03 -0800375 for arch, target in sorted(self.target.items()):
Patrick Rohrbfdc5fd2022-11-16 10:03:49 -0800376 # _output_field calls getattr(self, arch).
377 setattr(self, arch, target)
378 self._output_field(target_out, arch)
379
Patrick Rohr92d74122022-10-21 15:50:52 -0700380 if target_out:
381 output.append(' target: {')
382 for line in target_out:
383 output.append(' %s' % line)
384 output.append(' },')
385
Patrick Rohr92d74122022-10-21 15:50:52 -0700386 output.append('}')
387 output.append('')
388
389 def add_android_static_lib(self, lib):
390 if self.type == 'cc_binary_host':
391 raise Exception('Adding Android static lib for host tool is unsupported')
392 elif self.host_supported:
Patrick Rohrbfdc5fd2022-11-16 10:03:49 -0800393 self.target['android'].static_libs.add(lib)
Patrick Rohr92d74122022-10-21 15:50:52 -0700394 else:
395 self.static_libs.add(lib)
396
397 def add_android_shared_lib(self, lib):
398 if self.type == 'cc_binary_host':
399 raise Exception('Adding Android shared lib for host tool is unsupported')
400 elif self.host_supported:
Patrick Rohrbfdc5fd2022-11-16 10:03:49 -0800401 self.target['android'].shared_libs.add(lib)
Patrick Rohr92d74122022-10-21 15:50:52 -0700402 else:
403 self.shared_libs.add(lib)
404
405 def _output_field(self, output, name, sort=True):
406 value = getattr(self, name)
407 return write_blueprint_key_value(output, name, value, sort)
408
Patrick Rohra6ce0232022-11-16 22:09:01 -0800409 def is_compiled(self):
Mohannad Farrag7ff99912022-11-29 17:16:00 +0000410 return self.type not in ('cc_genrule', 'filegroup', 'java_genrule')
Mohannad Farrag1de6cb12022-11-28 12:27:26 +0000411
412 def is_genrule(self):
413 return self.type == "cc_genrule"
Patrick Rohra6ce0232022-11-16 22:09:01 -0800414
Mohannad Farrag7f29d832022-11-23 19:52:41 +0000415 def has_input_files(self):
Mohannad Farrag7f29d832022-11-23 19:52:41 +0000416 return len(self.srcs) > 0 or any([len(target.srcs) > 0 for target in self.target.values()])
417
Mohannad Farragf2391cc2022-11-29 13:26:32 +0000418 def merge_attribute(self, key, source_module, allowed_archs, source_key = None):
419 """
420 Merges the value of the attribute `source_key` for the `dep_module` with
421 the value of the attribute `key` for this module. If the value of the
422 `source_key` is equal to None. Then `key` is used for both modules.
423
424 This merges the attribute for both non-arch and archs
425 specified in `allowed_archs`.
426 :param key: The attribute used for merging in the calling module. Also
427 used for `dep_module` if the `source_key` is None.
428 :param source_module: The module where data is propagated from.
429 :param allowed_archs: A list of archs to merge the attribute on.
430 :param source_key: if the attribute merged from the `dep_module`
431 is different from the `key`
432 """
433 if not source_key:
434 source_key = key
435 self.__dict__[key].update(source_module.__dict__[source_key])
436 for arch_name in source_module.target.keys():
437 if arch_name in allowed_archs:
438 self.target[arch_name].__dict__[key].update(
439 source_module.target[arch_name].__dict__[source_key])
Patrick Rohr92d74122022-10-21 15:50:52 -0700440
441class Blueprint(object):
442 """In-memory representation of an Android.bp file."""
443
444 def __init__(self):
445 self.modules = {}
446
447 def add_module(self, module):
448 """Adds a new module to the blueprint, replacing any existing module
449 with the same name.
450
451 Args:
452 module: Module instance.
453 """
454 self.modules[module.name] = module
455
456 def to_string(self, output):
Patrick Rohr23f26192022-10-25 09:45:22 -0700457 for m in sorted(self.modules.values(), key=lambda m: m.name):
Patrick Rohr92d74122022-10-21 15:50:52 -0700458 m.to_string(output)
459
460
461def label_to_module_name(label):
462 """Turn a GN label (e.g., //:perfetto_tests) into a module name."""
Patrick Rohr07876662022-11-15 22:55:23 -0800463 module = re.sub(r'^//:?', '', label)
Patrick Rohr92d74122022-10-21 15:50:52 -0700464 module = re.sub(r'[^a-zA-Z0-9_]', '_', module)
Motomu Utsumi3fde1482022-11-14 15:55:21 +0900465
Patrick Rohr92d74122022-10-21 15:50:52 -0700466 if not module.startswith(module_prefix):
467 return module_prefix + module
468 return module
469
470
471def is_supported_source_file(name):
472 """Returns True if |name| can appear in a 'srcs' list."""
Patrick Rohrf9f3a992022-11-10 19:40:32 -0800473 return os.path.splitext(name)[1] in ['.c', '.cc', '.cpp', '.java', '.proto', '.S']
Patrick Rohr92d74122022-10-21 15:50:52 -0700474
475
476def create_proto_modules(blueprint, gn, target):
477 """Generate genrules for a proto GN target.
478
479 GN actions are used to dynamically generate files during the build. The
480 Soong equivalent is a genrule. This function turns a specific kind of
481 genrule which turns .proto files into source and header files into a pair
482 equivalent genrules.
483
484 Args:
485 blueprint: Blueprint instance which is being generated.
486 target: gn_utils.Target object.
487
488 Returns:
489 The source_genrule module.
490 """
491 assert (target.type == 'proto_library')
492
Motomu Utsumibd4013f2022-11-17 16:06:05 +0900493 protoc_gn_target_name = gn.get_target('//third_party/protobuf:protoc').name
Motomu Utsumid58c1dc2022-11-16 18:04:46 +0900494 protoc_module_name = label_to_module_name(protoc_gn_target_name)
495 tools = {protoc_module_name}
Motomu Utsumid7e0e422022-11-08 17:49:52 +0900496 cpp_out_dir = '$(genDir)/%s/%s/' % (tree_path, target.proto_in_dir)
Patrick Rohr92d74122022-10-21 15:50:52 -0700497 target_module_name = label_to_module_name(target.name)
498
499 # In GN builds the proto path is always relative to the output directory
500 # (out/tmp.xxx).
Motomu Utsumid58c1dc2022-11-16 18:04:46 +0900501 cmd = ['$(location %s)' % protoc_module_name]
Motomu Utsumid7e0e422022-11-08 17:49:52 +0900502 cmd += ['--proto_path=%s/%s' % (tree_path, target.proto_in_dir)]
Patrick Rohr92d74122022-10-21 15:50:52 -0700503
504 if buildtools_protobuf_src in target.proto_paths:
505 cmd += ['--proto_path=%s' % android_protobuf_src]
506
507 # We don't generate any targets for source_set proto modules because
508 # they will be inlined into other modules if required.
509 if target.proto_plugin == 'source_set':
510 return None
511
512 # Descriptor targets only generate a single target.
513 if target.proto_plugin == 'descriptor':
514 out = '{}.bin'.format(target_module_name)
515
516 cmd += ['--descriptor_set_out=$(out)']
517 cmd += ['$(in)']
518
Mohannad Farrag1de6cb12022-11-28 12:27:26 +0000519 descriptor_module = Module('cc_genrule', target_module_name, target.name)
Patrick Rohr92d74122022-10-21 15:50:52 -0700520 descriptor_module.cmd = ' '.join(cmd)
521 descriptor_module.out = [out]
522 descriptor_module.tools = tools
523 blueprint.add_module(descriptor_module)
524
525 # Recursively extract the .proto files of all the dependencies and
526 # add them to srcs.
527 descriptor_module.srcs.update(
528 gn_utils.label_to_path(src) for src in target.sources)
529 for dep in target.transitive_proto_deps:
530 current_target = gn.get_target(dep)
531 descriptor_module.srcs.update(
532 gn_utils.label_to_path(src) for src in current_target.sources)
533
534 return descriptor_module
535
536 # We create two genrules for each proto target: one for the headers and
537 # another for the sources. This is because the module that depends on the
538 # generated files needs to declare two different types of dependencies --
539 # source files in 'srcs' and headers in 'generated_headers' -- and it's not
540 # valid to generate .h files from a source dependency and vice versa.
541 source_module_name = target_module_name + '_gen'
Mohannad Farrag1de6cb12022-11-28 12:27:26 +0000542 source_module = Module('cc_genrule', source_module_name, target.name)
Patrick Rohr92d74122022-10-21 15:50:52 -0700543 blueprint.add_module(source_module)
544 source_module.srcs.update(
545 gn_utils.label_to_path(src) for src in target.sources)
546
Mohannad Farrag1de6cb12022-11-28 12:27:26 +0000547 header_module = Module('cc_genrule', source_module_name + '_headers',
Patrick Rohr92d74122022-10-21 15:50:52 -0700548 target.name)
549 blueprint.add_module(header_module)
550 header_module.srcs = set(source_module.srcs)
551
552 # TODO(primiano): at some point we should remove this. This was introduced
553 # by aosp/1108421 when adding "protos/" to .proto include paths, in order to
554 # avoid doing multi-repo changes and allow old clients in the android tree
555 # to still do the old #include "perfetto/..." rather than
556 # #include "protos/perfetto/...".
557 header_module.export_include_dirs = {'.', 'protos'}
Patrick Rohr2267a0a2022-11-08 18:59:34 -0800558 # Since the .cc file and .h get created by a different gerule target, they
559 # are not put in the same intermediate path, so local includes do not work
560 # without explictily exporting the include dir.
561 header_module.export_include_dirs.add(target.proto_in_dir)
Patrick Rohr92d74122022-10-21 15:50:52 -0700562
Motomu Utsumi8ca12412022-11-30 16:27:30 +0900563 # This function does not return header_module so setting apex_available attribute here.
564 header_module.apex_available.add(tethering_apex)
565
Patrick Rohr92d74122022-10-21 15:50:52 -0700566 source_module.genrule_srcs.add(':' + source_module.name)
567 source_module.genrule_headers.add(header_module.name)
568
569 if target.proto_plugin == 'proto':
570 suffixes = ['pb']
571 source_module.genrule_shared_libs.add('libprotobuf-cpp-lite')
572 cmd += ['--cpp_out=lite=true:' + cpp_out_dir]
573 elif target.proto_plugin == 'protozero':
574 suffixes = ['pbzero']
575 plugin = create_modules_from_target(blueprint, gn, protozero_plugin)
576 tools.add(plugin.name)
577 cmd += ['--plugin=protoc-gen-plugin=$(location %s)' % plugin.name]
578 cmd += ['--plugin_out=wrapper_namespace=pbzero:' + cpp_out_dir]
579 elif target.proto_plugin == 'cppgen':
580 suffixes = ['gen']
581 plugin = create_modules_from_target(blueprint, gn, cppgen_plugin)
582 tools.add(plugin.name)
583 cmd += ['--plugin=protoc-gen-plugin=$(location %s)' % plugin.name]
584 cmd += ['--plugin_out=wrapper_namespace=gen:' + cpp_out_dir]
585 elif target.proto_plugin == 'ipc':
586 suffixes = ['ipc']
587 plugin = create_modules_from_target(blueprint, gn, ipc_plugin)
588 tools.add(plugin.name)
589 cmd += ['--plugin=protoc-gen-plugin=$(location %s)' % plugin.name]
590 cmd += ['--plugin_out=wrapper_namespace=gen:' + cpp_out_dir]
591 else:
592 raise Error('Unsupported proto plugin: %s' % target.proto_plugin)
593
594 cmd += ['$(in)']
595 source_module.cmd = ' '.join(cmd)
596 header_module.cmd = source_module.cmd
597 source_module.tools = tools
598 header_module.tools = tools
599
600 for sfx in suffixes:
601 source_module.out.update('%s/%s' %
602 (tree_path, src.replace('.proto', '.%s.cc' % sfx))
603 for src in source_module.srcs)
604 header_module.out.update('%s/%s' %
605 (tree_path, src.replace('.proto', '.%s.h' % sfx))
606 for src in header_module.srcs)
607 return source_module
608
609
Patrick Rohr92d74122022-10-21 15:50:52 -0700610def create_proto_group_modules(blueprint, gn, module_name, target_names):
611 # TODO(lalitm): today, we're only adding a Java lite module because that's
612 # the only one used in practice. In the future, if we need other target types
613 # (e.g. C++, Java full etc.) add them here.
614 bp_module_name = label_to_module_name(module_name) + '_java_protos'
615 module = Module('java_library', bp_module_name, bp_module_name)
616 module.comment = f'''GN: [{', '.join(target_names)}]'''
617 module.proto = {'type': 'lite', 'canonical_path_from_root': False}
618
619 for name in target_names:
620 target = gn.get_target(name)
621 module.srcs.update(gn_utils.label_to_path(src) for src in target.sources)
622 for dep_label in target.transitive_proto_deps:
623 dep = gn.get_target(dep_label)
624 module.srcs.update(gn_utils.label_to_path(src) for src in dep.sources)
625
626 blueprint.add_module(module)
627
Mohannad Farrag9c2cee12022-12-06 17:11:25 +0000628def create_gcc_preprocess_modules(blueprint, target):
629 # gcc_preprocess.py internally execute host gcc which is not allowed in genrule.
630 # So, this function create multiple modules and realize equivalent processing
631 # TODO: Consider to support gcc_preprocess.py in different way
632 # It's not great to have genrule and cc_object in the dependency from java_library
633 assert (len(target.sources) == 1)
634 source = list(target.sources)[0]
635 assert (Path(source).suffix == '.template')
636 stem = Path(source).stem
637
638 bp_module_name = label_to_module_name(target.name)
639
640 # Rename .template to .cc since cc_object does not accept .template file as srcs
641 rename_module = Module('genrule', bp_module_name + '_rename', target.name)
642 rename_module.srcs.add(gn_utils.label_to_path(source))
643 rename_module.out.add(stem + '.cc')
644 rename_module.cmd = 'cp $(in) $(out)'
645 blueprint.add_module(rename_module)
646
647 # Preprocess template file and generates java file
648 preprocess_module = Module('cc_object', bp_module_name + '_preprocess', target.name)
649 # -E: stop after preprocessing.
650 # -P: disable line markers, i.e. '#line 309'
651 preprocess_module.cflags.update(['-E', '-P', '-DANDROID'])
652 preprocess_module.srcs.add(':' + rename_module.name)
653 defines = ['-D' + target.args[i+1] for i, arg in enumerate(target.args) if arg == '--define']
654 preprocess_module.cflags.update(defines)
655 # HACK: Specifying compile_multilib to build cc_object only once.
656 # Without this, soong complain to genrule that depends on cc_object when built for 64bit target.
657 # It seems this is because cc object is a module with per-architecture variants and genrule is a
658 # module with default variant. For 64bit target, cc_object is built multiple times for 32/64bit
659 # modes and genrule doesn't know which one to depend on.
660 preprocess_module.compile_multilib = 32
661 blueprint.add_module(preprocess_module)
662
663 # Generates srcjar using soong_zip
664 module = Module('genrule', bp_module_name, target.name)
665 module.srcs.add(':' + preprocess_module.name)
666 module.out.add(stem + '.srcjar')
667 module.cmd = NEWLINE.join([
668 f'cp $(in) $(genDir)/{stem}.java &&',
669 f'$(location soong_zip) -o $(out) -srcjar -f $(genDir)/{stem}.java'
670 ])
671 module.tools.add('soong_zip')
672 blueprint.add_module(module)
673 return module
674
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800675
Mohannad Farrag420c14e2022-11-30 17:13:15 +0000676class BaseActionSanitizer():
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800677 def __init__(self, target):
Patrick Rohr9e414b52022-11-29 22:12:18 -0800678 # Just to be on the safe side, create a deep-copy.
679 self.target = copy.deepcopy(target)
Motomu Utsumi9752bd32022-12-02 15:16:55 +0900680 self.target.args = self._normalize_args()
681
Mohannad Farrag7f7c9b42022-12-02 14:37:56 +0000682 def get_name(self):
683 return label_to_module_name(self.target.name)
684
Motomu Utsumi9752bd32022-12-02 15:16:55 +0900685 def _normalize_args(self):
Patrick Rohr9e414b52022-11-29 22:12:18 -0800686 # Convert ['--param=value'] to ['--param', 'value'] for consistency.
Mohannad Farrag60b37702022-12-02 14:07:33 +0000687 # Escape quotations.
Motomu Utsumi9752bd32022-12-02 15:16:55 +0900688 normalized_args = []
689 for arg in self.target.args:
Mohannad Farrag60b37702022-12-02 14:07:33 +0000690 arg = arg.replace('"', r'\"')
Motomu Utsumi13399322022-12-02 15:36:48 +0900691 if arg.startswith('-'):
692 normalized_args.extend(arg.split('='))
693 else:
694 normalized_args.append(arg)
Motomu Utsumi9752bd32022-12-02 15:16:55 +0900695 return normalized_args
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800696
Patrick Rohr2cad9332022-11-30 14:27:40 -0800697 # There are three types of args:
698 # - flags (--flag)
699 # - value args (--arg value)
700 # - list args (--arg value1 --arg value2)
Motomu Utsumi8be8a262022-12-02 14:35:15 +0900701 # value args have exactly one arg value pair and list args have one or more arg value pairs.
Motomu Utsumi923688c2022-12-01 15:51:05 +0900702 # Note that the set of list args contains the set of value args.
Motomu Utsumi8be8a262022-12-02 14:35:15 +0900703 # This is because list and value args are identical when the list args has only one arg value pair
Patrick Rohr2cad9332022-11-30 14:27:40 -0800704 # Some functions provide special implementations for each type, while others
705 # work on all of them.
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800706 def _has_arg(self, arg):
707 return arg in self.target.args
708
Motomu Utsumi923688c2022-12-01 15:51:05 +0900709 def _get_arg_indices(self, target_arg):
710 return [i for i, arg in enumerate(self.target.args) if arg == target_arg]
Patrick Rohr3a2c3dd2022-11-29 22:29:36 -0800711
Motomu Utsumi923688c2022-12-01 15:51:05 +0900712 # Whether an arg value pair appears once or more times
713 def _is_list_arg(self, arg):
714 indices = self._get_arg_indices(arg)
715 return len(indices) > 0 and all([not self.target.args[i + 1].startswith('--') for i in indices])
716
Motomu Utsumic363b412022-12-01 16:01:58 +0900717 def _update_list_arg(self, arg, func, throw_if_absent = True):
718 if self._should_fail_silently(arg, throw_if_absent):
719 return
720 assert(self._is_list_arg(arg))
721 indices = self._get_arg_indices(arg)
722 for i in indices:
723 self._set_arg_at(i + 1, func(self.target.args[i + 1]))
724
Motomu Utsumi923688c2022-12-01 15:51:05 +0900725 # Whether an arg value pair appears exactly once
Patrick Rohref4f2bf2022-11-30 14:22:40 -0800726 def _is_value_arg(self, arg):
Motomu Utsumid75b8b52022-12-02 14:29:00 +0900727 return operator.countOf(self.target.args, arg) == 1 and self._is_list_arg(arg)
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800728
Patrick Rohr2cad9332022-11-30 14:27:40 -0800729 def _get_value_arg(self, arg):
Patrick Rohref4f2bf2022-11-30 14:22:40 -0800730 assert(self._is_value_arg(arg))
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800731 i = self.target.args.index(arg)
732 return self.target.args[i + 1]
733
Patrick Rohrf0abead2022-11-30 19:44:10 -0800734 # used to check whether a function call should cause an error when an arg is
735 # missing.
736 def _should_fail_silently(self, arg, throw_if_absent):
737 return not throw_if_absent and not self._has_arg(arg)
738
739 def _set_value_arg(self, arg, value, throw_if_absent = True):
740 if self._should_fail_silently(arg, throw_if_absent):
Patrick Rohr4d74aed2022-11-30 15:42:16 -0800741 return
Patrick Rohref4f2bf2022-11-30 14:22:40 -0800742 assert(self._is_value_arg(arg))
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800743 i = self.target.args.index(arg)
744 self.target.args[i + 1] = value
745
Patrick Rohrf0abead2022-11-30 19:44:10 -0800746 def _update_value_arg(self, arg, func, throw_if_absent = True):
747 if self._should_fail_silently(arg, throw_if_absent):
Patrick Rohr4d74aed2022-11-30 15:42:16 -0800748 return
Patrick Rohr1bedf6c2022-11-30 15:12:57 -0800749 self._set_value_arg(arg, func(self._get_value_arg(arg)))
750
Patrick Rohr77c4f5c2022-11-30 12:56:29 -0800751 def _set_arg_at(self, position, value):
Mohannad Farrag9ab17932022-11-30 17:28:35 +0000752 self.target.args[position] = value
753
Patrick Rohr357b25c2022-11-30 19:46:26 -0800754 def _delete_value_arg(self, arg, throw_if_absent = True):
Patrick Rohrf0abead2022-11-30 19:44:10 -0800755 if self._should_fail_silently(arg, throw_if_absent):
Patrick Rohr4d74aed2022-11-30 15:42:16 -0800756 return
Patrick Rohr357b25c2022-11-30 19:46:26 -0800757 assert(self._is_value_arg(arg))
Patrick Rohr9f439322022-11-30 15:56:15 -0800758 i = self.target.args.index(arg)
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800759 self.target.args.pop(i)
Patrick Rohr357b25c2022-11-30 19:46:26 -0800760 self.target.args.pop(i)
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800761
Patrick Rohr1f7dd582022-11-30 13:44:07 -0800762 def _append_arg(self, arg, value):
763 self.target.args.append(arg)
764 self.target.args.append(value)
765
Mohannad Farrag8fa90652022-12-01 15:40:40 +0000766 def _sanitize_filepath_with_location_tag(self, arg):
767 if arg.startswith('../../'):
768 arg = self._sanitize_filepath(arg)
769 arg = self._add_location_tag(arg)
770 return arg
771
Patrick Rohr73ef7ae2022-11-29 22:33:09 -0800772 # wrap filename in location tag.
Patrick Rohrfda026732022-11-30 16:07:11 -0800773 def _add_location_tag(self, filename):
Patrick Rohr73ef7ae2022-11-29 22:33:09 -0800774 return '$(location %s)' % filename
775
Patrick Rohr0e24c5f2022-11-30 15:20:21 -0800776 # applies common directory transformation that *should* be universally applicable.
777 # TODO: verify if it actually *is* universally applicable.
Patrick Rohr872a2812022-11-30 19:28:22 -0800778 def _sanitize_filepath(self, filepath):
Patrick Rohr0e24c5f2022-11-30 15:20:21 -0800779 # Careful, order matters!
Patrick Rohr8bcd7832022-11-30 19:48:56 -0800780 # delete all leading ../
Patrick Rohr9e5a3c72022-11-30 15:51:30 -0800781 filepath = re.sub('^(\.\./)+', '', filepath)
Patrick Rohr0e24c5f2022-11-30 15:20:21 -0800782 filepath = re.sub('^gen/jni_headers', '$(genDir)', filepath)
783 filepath = re.sub('^gen', '$(genDir)', filepath)
784 return filepath
Patrick Rohr32276892022-11-29 22:38:13 -0800785
Motomu Utsumi21485ba2022-12-01 17:01:50 +0900786 # Iterate through all the args and apply function
787 def _update_all_args(self, func):
788 self.target.args = [func(arg) for arg in self.target.args]
789
Mohannad Farragd5515ca2022-12-02 15:39:53 +0000790 def get_cmd(self):
Mohannad Farragc739dda2022-12-02 15:43:46 +0000791 arg_string = NEWLINE.join(self.target.args)
792 cmd = '$(location %s) %s' % (
793 gn_utils.label_to_path(self.target.script), arg_string)
794
795 if self.use_response_file:
796 # Pipe response file contents into script
797 cmd = 'echo \'%s\' |%s%s' % (self.target.response_file_contents, NEWLINE, cmd)
798 return cmd
Mohannad Farragd5515ca2022-12-02 15:39:53 +0000799
Motomu Utsumi5afd0812022-12-02 15:43:36 +0900800 def get_outputs(self):
801 return self.target.outputs
802
Motomu Utsumi80fa0b02022-12-05 12:50:57 +0900803 def get_srcs(self):
804 # gn treats inputs and sources for actions equally.
805 # soong only supports source files inside srcs, non-source files are added as
806 # tool_files dependency.
807 files = self.target.sources.union(self.target.inputs)
808 return {gn_utils.label_to_path(file) for file in files if is_supported_source_file(file)}
809
Motomu Utsumiaaf42cf2022-12-05 12:55:02 +0900810 def get_tool_files(self):
811 # gn treats inputs and sources for actions equally.
812 # soong only supports source files inside srcs, non-source files are added as
813 # tool_files dependency.
814 files = self.target.sources.union(self.target.inputs)
Motomu Utsumi69975862022-12-05 12:59:06 +0900815 tool_files = {gn_utils.label_to_path(file)
816 for file in files if not is_supported_source_file(file)}
817 tool_files.add(gn_utils.label_to_path(self.target.script))
818 return tool_files
Motomu Utsumiaaf42cf2022-12-05 12:55:02 +0900819
Motomu Utsumicdb45ea2022-12-02 17:05:07 +0900820 def _sanitize_args(self):
Mohannad Farrag00ecfb52022-12-02 14:44:15 +0000821 # Handle passing parameters via response file by piping them into the script
822 # and reading them from /dev/stdin.
823
Mohannad Farraga0e37c12022-12-02 14:46:08 +0000824 self.use_response_file = gn_utils.RESPONSE_FILE in self.target.args
Mohannad Farrag00ecfb52022-12-02 14:44:15 +0000825 if self.use_response_file:
826 # Replace {{response_file_contents}} with /dev/stdin
Mohannad Farraga0e37c12022-12-02 14:46:08 +0000827 self.target.args = ['/dev/stdin' if it == gn_utils.RESPONSE_FILE else it
828 for it in self.target.args]
Motomu Utsumicdb45ea2022-12-02 17:05:07 +0900829
830 def _sanitize_outputs(self):
831 pass
832
Motomu Utsumi735a5a42022-12-05 12:15:07 +0900833 def _sanitize_inputs(self):
834 pass
835
Motomu Utsumicdb45ea2022-12-02 17:05:07 +0900836 def sanitize(self):
837 self._sanitize_args()
838 self._sanitize_outputs()
Motomu Utsumi735a5a42022-12-05 12:15:07 +0900839 self._sanitize_inputs()
Motomu Utsumicdb45ea2022-12-02 17:05:07 +0900840
Motomu Utsumi7db75832022-12-02 16:46:22 +0900841 # Whether this target generates header files
842 def is_header_generated(self):
Motomu Utsumia91ade62022-12-02 16:58:36 +0900843 return any(os.path.splitext(it)[1] == '.h' for it in self.target.outputs)
Motomu Utsumi7db75832022-12-02 16:46:22 +0900844
Mohannad Farrag9ab17932022-11-30 17:28:35 +0000845class WriteBuildDateHeaderSanitizer(BaseActionSanitizer):
Motomu Utsumi805591d2022-12-02 17:17:16 +0900846 def _sanitize_args(self):
Patrick Rohr77c4f5c2022-11-30 12:56:29 -0800847 self._set_arg_at(0, '$(out)')
Motomu Utsumi805591d2022-12-02 17:17:16 +0900848 super()._sanitize_args()
Mohannad Farrag9ab17932022-11-30 17:28:35 +0000849
Mohannad Farrag71353f92022-11-30 17:20:48 +0000850class WriteBuildFlagHeaderSanitizer(BaseActionSanitizer):
Motomu Utsumi805591d2022-12-02 17:17:16 +0900851 def _sanitize_args(self):
Patrick Rohr2cad9332022-11-30 14:27:40 -0800852 self._set_value_arg('--gen-dir', '.')
853 self._set_value_arg('--output', '$(out)')
Motomu Utsumi805591d2022-12-02 17:17:16 +0900854 super()._sanitize_args()
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800855
Patrick Rohr0242a3f2022-11-30 13:48:59 -0800856class JniGeneratorSanitizer(BaseActionSanitizer):
Motomu Utsumi4d551d72022-12-01 16:18:23 +0900857 def _add_location_tag_to_filepath(self, arg):
858 if not arg.endswith('.class'):
859 # --input_file supports both .class specifiers or source files as arguments.
860 # Only source files need to be wrapped inside a $(location <label>) tag.
861 arg = self._add_location_tag(arg)
862 return arg
863
Motomu Utsumi805591d2022-12-02 17:17:16 +0900864 def _sanitize_args(self):
Patrick Rohrf0abead2022-11-30 19:44:10 -0800865 self._update_value_arg('--jar_file', self._sanitize_filepath, False)
866 self._update_value_arg('--jar_file', self._add_location_tag, False)
Patrick Rohr0242a3f2022-11-30 13:48:59 -0800867 if self._has_arg('--jar_file'):
868 self._append_arg('--javap', '$$(find out/.path -name javap)')
Patrick Rohr872a2812022-11-30 19:28:22 -0800869 self._update_value_arg('--output_dir', self._sanitize_filepath)
Patrick Rohrf0abead2022-11-30 19:44:10 -0800870 self._update_value_arg('--includes', self._sanitize_filepath, False)
Patrick Rohr357b25c2022-11-30 19:46:26 -0800871 self._delete_value_arg('--prev_output_dir', False)
Motomu Utsumi4d551d72022-12-01 16:18:23 +0900872 self._update_list_arg('--input_file', self._sanitize_filepath)
873 self._update_list_arg('--input_file', self._add_location_tag_to_filepath)
Motomu Utsumi805591d2022-12-02 17:17:16 +0900874 super()._sanitize_args()
Patrick Rohr0242a3f2022-11-30 13:48:59 -0800875
Motomu Utsumi94019962022-12-02 17:18:58 +0900876 def _sanitize_outputs(self):
Motomu Utsumid4f72642022-12-02 16:01:59 +0900877 # fix target.output directory to match #include statements.
878 self.target.outputs = {re.sub('^jni_headers/', '', out) for out in self.target.outputs}
Motomu Utsumi94019962022-12-02 17:18:58 +0900879 super()._sanitize_outputs()
Motomu Utsumid4f72642022-12-02 16:01:59 +0900880
Motomu Utsumia6824ea2022-12-05 14:53:11 +0900881 def get_tool_files(self):
882 tool_files = super().get_tool_files()
883 # android_jar.classes should be part of the tools as it list implicit classes
884 # for the script to generate JNI headers.
885 tool_files.add("base/android/jni_generator/android_jar.classes")
886 return tool_files
887
Motomu Utsumib80903c2022-12-01 16:21:55 +0900888class JniRegistrationGeneratorSanitizer(BaseActionSanitizer):
Motomu Utsumi07027f62022-12-05 12:16:53 +0900889 def _sanitize_inputs(self):
890 self.target.inputs = [file for file in self.target.inputs if not file.startswith('//out/')]
891
Motomu Utsumi805591d2022-12-02 17:17:16 +0900892 def _sanitize_args(self):
Motomu Utsumi28cbf2f2022-12-01 16:24:29 +0900893 self._update_value_arg('--depfile', self._sanitize_filepath)
894 self._update_value_arg('--srcjar-path', self._sanitize_filepath)
895 self._update_value_arg('--header-path', self._sanitize_filepath)
Motomu Utsumi55907472022-12-01 16:26:21 +0900896 self._set_value_arg('--sources-files', '$(genDir)/java.sources')
Motomu Utsumi4fe0b952022-12-01 16:29:15 +0900897 # update_jni_registration_module removes them from the srcs of the module
898 # It might be better to remove sources by '--sources-exclusions'
899 self._delete_value_arg('--sources-exclusions')
Motomu Utsumi805591d2022-12-02 17:17:16 +0900900 super()._sanitize_args()
Patrick Rohr0242a3f2022-11-30 13:48:59 -0800901
Mohannad Farrag291f5672022-12-02 15:49:00 +0000902 def get_cmd(self):
903 # jni_registration_generator.py doesn't work with python2
904 cmd = "python3 " + super().get_cmd()
905 # Path in the original sources file does not work in genrule.
906 # So creating sources file in cmd based on the srcs of this target.
907 # Adding ../$(current_dir)/ to the head because jni_registration_generator.py uses the files
908 # whose path startswith(..)
909 commands = ["current_dir=`basename \\\`pwd\\\``;",
910 "for f in $(in);",
911 "do",
912 "echo \\\"../$$current_dir/$$f\\\" >> $(genDir)/java.sources;",
913 "done;",
914 cmd]
915
916 # .h file jni_registration_generator.py generates has #define with directory name.
917 # With the genrule env that contains "." which is invalid. So replace that at the end of cmd.
918 commands.append(";sed -i -e 's/OUT_SOONG_.TEMP_SBOX_.*_OUT/GEN/g' ")
919 commands.append("$(genDir)/components/cronet/android/cronet_jni_registration.h")
920 return NEWLINE.join(commands)
921
Mohannad Farrag457bc022022-12-02 14:31:22 +0000922class JavaJniRegistrationGeneratorSanitizer(JniRegistrationGeneratorSanitizer):
Mohannad Farrag7f7c9b42022-12-02 14:37:56 +0000923 def get_name(self):
924 return label_to_module_name(self.target.name) + "__java"
925
Mohannad Farrag457bc022022-12-02 14:31:22 +0000926 def _sanitize_outputs(self):
927 self.target.outputs = [out for out in self.target.outputs if
928 out.endswith(".srcjar")]
929 super()._sanitize_outputs()
930
Motomu Utsumi6af5b2a2022-12-01 16:33:42 +0900931class VersionSanitizer(BaseActionSanitizer):
Motomu Utsumi805591d2022-12-02 17:17:16 +0900932 def _sanitize_args(self):
Motomu Utsumic6b08b82022-12-01 16:48:19 +0900933 self._set_value_arg('-o', '$(out)')
Motomu Utsumi21485ba2022-12-01 17:01:50 +0900934 # args for the version.py contain file path without leading --arg key. So apply sanitize
935 # function for all the args.
Mohannad Farrag8fa90652022-12-01 15:40:40 +0000936 self._update_all_args(self._sanitize_filepath_with_location_tag)
Mohannad Farrag25697342022-12-02 18:01:48 +0000937 self._set_value_arg('-e', "'%s'" % self._get_value_arg('-e'))
Motomu Utsumi805591d2022-12-02 17:17:16 +0900938 super()._sanitize_args()
Motomu Utsumi6af5b2a2022-12-01 16:33:42 +0900939
Motomu Utsumidf634142022-12-05 15:02:44 +0900940 def get_tool_files(self):
941 tool_files = super().get_tool_files()
942 # android_chrome_version.py is not specified in anywhere but version.py imports this file
943 tool_files.add('build/util/android_chrome_version.py')
944 return tool_files
945
Mohannad Farragb73ce0f2022-12-01 15:43:58 +0000946class JavaCppEnumSanitizer(BaseActionSanitizer):
Motomu Utsumi805591d2022-12-02 17:17:16 +0900947 def _sanitize_args(self):
Mohannad Farragb73ce0f2022-12-01 15:43:58 +0000948 self._update_all_args(self._sanitize_filepath_with_location_tag)
949 self._set_value_arg('--srcjar', '$(out)')
Motomu Utsumi805591d2022-12-02 17:17:16 +0900950 super()._sanitize_args()
Mohannad Farragb73ce0f2022-12-01 15:43:58 +0000951
Motomu Utsumi9701d2f2022-12-02 16:53:06 +0900952class MakeDafsaSanitizer(BaseActionSanitizer):
953 def is_header_generated(self):
Motomu Utsumi1e028b82022-12-02 16:54:20 +0900954 # This script generates .cc files but they are #included by other sources
955 # (e.g. registry_controlled_domain.cc)
956 return True
Motomu Utsumi9701d2f2022-12-02 16:53:06 +0900957
Motomu Utsumi56a2f442022-12-05 16:01:34 +0900958class JavaCppFeatureSanitizer(BaseActionSanitizer):
Motomu Utsumid7c36772022-12-05 16:04:37 +0900959 def _sanitize_args(self):
960 self._update_all_args(self._sanitize_filepath_with_location_tag)
961 self._set_value_arg('--srcjar', '$(out)')
962 super()._sanitize_args()
Motomu Utsumi56a2f442022-12-05 16:01:34 +0900963
Motomu Utsumice5166b2022-12-05 16:08:37 +0900964class JavaCppStringSanitizer(BaseActionSanitizer):
Motomu Utsumi3f7ab312022-12-05 16:12:21 +0900965 def _sanitize_args(self):
966 self._update_all_args(self._sanitize_filepath_with_location_tag)
967 self._set_value_arg('--srcjar', '$(out)')
968 super()._sanitize_args()
Motomu Utsumice5166b2022-12-05 16:08:37 +0900969
Motomu Utsumib90a76b2022-12-05 16:17:26 +0900970class WriteNativeLibrariesJavaSanitizer(BaseActionSanitizer):
Motomu Utsumi3dbc2762022-12-05 16:20:21 +0900971 def _sanitize_args(self):
972 self._set_value_arg('--output', '$(out)')
973 super()._sanitize_args()
Motomu Utsumib90a76b2022-12-05 16:17:26 +0900974
Mohannad Farrag457bc022022-12-02 14:31:22 +0000975def get_action_sanitizer(target, type):
Patrick Rohr7f117152022-11-30 13:58:05 -0800976 if target.script == "//build/write_buildflag_header.py":
977 return WriteBuildFlagHeaderSanitizer(target)
978 elif target.script == "//build/write_build_date_header.py":
979 return WriteBuildDateHeaderSanitizer(target)
980 elif target.script == '//base/android/jni_generator/jni_generator.py':
981 return JniGeneratorSanitizer(target)
Motomu Utsumib80903c2022-12-01 16:21:55 +0900982 elif target.script == '//base/android/jni_generator/jni_registration_generator.py':
Mohannad Farrag457bc022022-12-02 14:31:22 +0000983 if type == 'java_genrule':
984 return JavaJniRegistrationGeneratorSanitizer(target)
985 else:
986 return JniRegistrationGeneratorSanitizer(target)
Motomu Utsumi6af5b2a2022-12-01 16:33:42 +0900987 elif target.script == "//build/util/version.py":
988 return VersionSanitizer(target)
Mohannad Farragb73ce0f2022-12-01 15:43:58 +0000989 elif target.script == "//build/android/gyp/java_cpp_enum.py":
990 return JavaCppEnumSanitizer(target)
Motomu Utsumi9701d2f2022-12-02 16:53:06 +0900991 elif target.script == "//net/tools/dafsa/make_dafsa.py":
992 return MakeDafsaSanitizer(target)
Motomu Utsumi56a2f442022-12-05 16:01:34 +0900993 elif target.script == '//build/android/gyp/java_cpp_features.py':
994 return JavaCppFeatureSanitizer(target)
Motomu Utsumice5166b2022-12-05 16:08:37 +0900995 elif target.script == '//build/android/gyp/java_cpp_strings.py':
996 return JavaCppStringSanitizer(target)
Motomu Utsumib90a76b2022-12-05 16:17:26 +0900997 elif target.script == '//build/android/gyp/write_native_libraries_java.py':
998 return WriteNativeLibrariesJavaSanitizer(target)
Patrick Rohr7f117152022-11-30 13:58:05 -0800999 else:
1000 # TODO: throw exception here once all script hacks have been converted.
1001 return BaseActionSanitizer(target)
1002
Mohannad Farragbab6c892022-11-02 14:09:46 +00001003def create_action_foreach_modules(blueprint, target):
1004 """ The following assumes that rebase_path exists in the args.
1005 The args of an action_foreach contains hints about which output files are generated
1006 by which source files.
1007 This is copied directly from the args
1008 "gen/net/base/registry_controlled_domains/{{source_name_part}}-reversed-inc.cc"
1009 So each source file will generate an output whose name is the {source_name-reversed-inc.cc}
1010 """
1011 new_args = []
Motomu Utsumi56afcac2022-11-04 12:58:30 +09001012 for i, src in enumerate(sorted(target.sources)):
Mohannad Farragbab6c892022-11-02 14:09:46 +00001013 # don't add script arg for the first source -- create_action_module
1014 # already does this.
1015 if i != 0:
1016 new_args.append('&& python3 $(location %s)' %
1017 gn_utils.label_to_path(target.script))
1018 for arg in target.args:
1019 if '{{source}}' in arg:
1020 new_args.append('$(location %s)' % (gn_utils.label_to_path(src)))
1021 elif '{{source_name_part}}' in arg:
1022 source_name_part = src.split("/")[-1] # Get the file name only
1023 source_name_part = source_name_part.split(".")[0] # Remove the extension (Ex: .cc)
1024 file_name = arg.replace('{{source_name_part}}', source_name_part).split("/")[-1]
1025 # file_name represent the output file name. But we need the whole path
1026 # This can be found from target.outputs.
1027 for out in target.outputs:
1028 if out.endswith(file_name):
1029 new_args.append('$(location %s)' % out)
1030 else:
1031 new_args.append(arg)
1032
1033 target.args = new_args
Mohannad Farrag7ff99912022-11-29 17:16:00 +00001034 return create_action_module(blueprint, target, 'cc_genrule')
Motomu Utsumia6c33152022-11-02 18:21:55 +09001035
Mohannad Farrag7ff99912022-11-29 17:16:00 +00001036def create_action_module(blueprint, target, type):
Mohannad Farrag457bc022022-12-02 14:31:22 +00001037 sanitizer = get_action_sanitizer(target, type)
Motomu Utsumicdb45ea2022-12-02 17:05:07 +09001038 sanitizer.sanitize()
Motomu Utsumi47fd40a2022-12-05 15:07:31 +09001039
Mohannad Farrag7f7c9b42022-12-02 14:37:56 +00001040 module = Module(type, sanitizer.get_name(), target.name)
Mohannad Farragc739dda2022-12-02 15:43:46 +00001041 module.cmd = sanitizer.get_cmd()
Motomu Utsumi24213232022-12-02 16:04:05 +09001042 module.out = sanitizer.get_outputs()
Motomu Utsumi7db75832022-12-02 16:46:22 +09001043 if sanitizer.is_header_generated():
1044 module.genrule_headers.add(module.name)
Motomu Utsumi80fa0b02022-12-05 12:50:57 +09001045 module.srcs = sanitizer.get_srcs()
Motomu Utsumiaaf42cf2022-12-05 12:55:02 +09001046 module.tool_files = sanitizer.get_tool_files()
Patrick Rohr9b99a982022-10-28 11:00:57 -07001047
Patrick Rohre1a853e2022-10-26 12:31:39 -07001048 blueprint.add_module(module)
1049 return module
1050
1051
Patrick Rohr92d74122022-10-21 15:50:52 -07001052
Motomu Utsumic34b1372022-11-17 22:15:51 +09001053def _get_cflags(cflags, defines):
1054 cflags = {flag for flag in cflags if flag in cflag_allowlist}
Motomu Utsumifa7e9262022-10-26 19:43:02 +09001055 # Consider proper allowlist or denylist if needed
Motomu Utsumic34b1372022-11-17 22:15:51 +09001056 cflags |= set("-D%s" % define.replace("\"", "\\\"") for define in defines)
Patrick Rohr92d74122022-10-21 15:50:52 -07001057 return cflags
1058
Motomu Utsumic34b1372022-11-17 22:15:51 +09001059def set_module_flags(module, cflags, defines):
1060 module.cflags.update(_get_cflags(cflags, defines))
1061 # TODO: implement proper cflag parsing.
1062 for flag in cflags:
1063 if '-std=' in flag:
1064 module.cpp_std = flag[len('-std='):]
Motomu Utsumic34b1372022-11-17 22:15:51 +09001065 if '-fexceptions' in flag:
1066 module.cppflags.add('-fexceptions')
Patrick Rohr92d74122022-10-21 15:50:52 -07001067
Mohannad Farrag631443e2022-11-21 16:17:01 +00001068def add_genrule_per_arch(module, dep_module, type):
1069 module.generated_headers.update(dep_module.genrule_headers)
1070 # If the module is a static library, export all the generated headers.
1071 if type == 'cc_library_static':
1072 module.export_generated_headers.update(dep_module.genrule_headers)
1073 module.srcs.update(dep_module.genrule_srcs)
1074 module.shared_libs.update(dep_module.genrule_shared_libs)
1075 module.header_libs.update(dep_module.genrule_header_libs)
1076
Motomu Utsumi88efbb42022-11-17 22:18:15 +09001077def set_module_include_dirs(module, cflags, include_dirs):
Motomu Utsumi88efbb42022-11-17 22:18:15 +09001078 for flag in cflags:
1079 if '-isystem' in flag:
Patrick Rohr3cd5ffb2022-11-18 17:40:55 -08001080 module.local_include_dirs.add(flag[len('-isystem../../'):])
Motomu Utsumi88efbb42022-11-17 22:18:15 +09001081
1082 # Adding local_include_dirs is necessary due to source_sets / filegroups
1083 # which do not properly propagate include directories.
1084 # Filter any directory inside //out as a) this directory does not exist for
1085 # aosp / soong builds and b) the include directory should already be
1086 # configured via library dependency.
Patrick Rohr3cd5ffb2022-11-18 17:40:55 -08001087 module.local_include_dirs.update([gn_utils.label_to_path(d)
Motomu Utsumi88efbb42022-11-17 22:18:15 +09001088 for d in include_dirs
1089 if not re.match('^//out/.*', d)])
Motomu Utsumi88efbb42022-11-17 22:18:15 +09001090
Patrick Rohr92d74122022-10-21 15:50:52 -07001091def create_modules_from_target(blueprint, gn, gn_target_name):
1092 """Generate module(s) for a given GN target.
1093
1094 Given a GN target name, generate one or more corresponding modules into a
1095 blueprint. The only case when this generates >1 module is proto libraries.
1096
1097 Args:
1098 blueprint: Blueprint instance which is being generated.
1099 gn: gn_utils.GnParser object.
1100 gn_target_name: GN target for module generation.
1101 """
1102 bp_module_name = label_to_module_name(gn_target_name)
1103 if bp_module_name in blueprint.modules:
1104 return blueprint.modules[bp_module_name]
1105 target = gn.get_target(gn_target_name)
Patrick Rohr16228942022-10-26 14:00:26 -07001106 log.info('create modules for %s (%s)', target.name, target.type)
Patrick Rohr92d74122022-10-21 15:50:52 -07001107
Patrick Rohr92d74122022-10-21 15:50:52 -07001108 if target.type == 'executable':
Patrick Rohrc8f41cd2022-11-15 22:46:10 -08001109 if target.testonly:
Patrick Rohr92d74122022-10-21 15:50:52 -07001110 module_type = 'cc_test'
1111 else:
Patrick Rohrc8f41cd2022-11-15 22:46:10 -08001112 # Can be used for both host and device targets.
Patrick Rohr92d74122022-10-21 15:50:52 -07001113 module_type = 'cc_binary'
1114 module = Module(module_type, bp_module_name, gn_target_name)
1115 elif target.type == 'static_library':
1116 module = Module('cc_library_static', bp_module_name, gn_target_name)
1117 elif target.type == 'shared_library':
1118 module = Module('cc_library_shared', bp_module_name, gn_target_name)
1119 elif target.type == 'source_set':
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001120 module = Module('cc_object', bp_module_name, gn_target_name)
Patrick Rohr92d74122022-10-21 15:50:52 -07001121 elif target.type == 'group':
1122 # "group" targets are resolved recursively by gn_utils.get_target().
1123 # There's nothing we need to do at this level for them.
1124 return None
1125 elif target.type == 'proto_library':
1126 module = create_proto_modules(blueprint, gn, target)
1127 if module is None:
1128 return None
1129 elif target.type == 'action':
Mohannad Farrag4b89a822022-12-02 14:25:44 +00001130 module = create_action_module(blueprint, target, 'cc_genrule')
Mohannad Farragf076f3e2022-10-31 17:45:28 +00001131 elif target.type == 'action_foreach':
Mohannad Farragbab6c892022-11-02 14:09:46 +00001132 module = create_action_foreach_modules(blueprint, target)
Patrick Rohr59a76652022-10-26 12:36:56 -07001133 elif target.type == 'copy':
1134 # TODO: careful now! copy targets are not supported yet, but this will stop
1135 # traversing the dependency tree. For //base:base, this is not a big
1136 # problem as libicu contains the only copy target which happens to be a
1137 # leaf node.
1138 return None
Patrick Rohrad440602022-11-10 22:09:04 -08001139 elif target.type == 'java_group':
1140 # Java targets are handled outside of create_modules_from_target.
1141 return None
Patrick Rohr92d74122022-10-21 15:50:52 -07001142 else:
1143 raise Error('Unknown target %s (%s)' % (target.name, target.type))
1144
1145 blueprint.add_module(module)
Patrick Rohr92d74122022-10-21 15:50:52 -07001146 module.init_rc = target_initrc.get(target.name, [])
1147 module.srcs.update(
1148 gn_utils.label_to_path(src)
1149 for src in target.sources
Motomu Utsumif951e502022-11-07 19:31:15 +09001150 if is_supported_source_file(src) and not src.startswith("//out/test"))
Patrick Rohr92d74122022-10-21 15:50:52 -07001151
Patrick Rohr3b5ff762022-11-16 10:22:16 -08001152 # Add arch-specific properties
1153 for arch_name, arch in target.arch.items():
Motomu Utsumi40f95c52022-11-17 19:39:13 +09001154 module.target[arch_name].srcs.update(
1155 gn_utils.label_to_path(src)
1156 for src in arch.sources
1157 if is_supported_source_file(src) and not src.startswith("//out/test"))
Patrick Rohr3b5ff762022-11-16 10:22:16 -08001158
Mohannad Farragbaf0d572022-11-22 11:53:54 +00001159 module.rtti = target.rtti
1160
Patrick Rohr92d74122022-10-21 15:50:52 -07001161 if target.type in gn_utils.LINKER_UNIT_TYPES:
Motomu Utsumic34b1372022-11-17 22:15:51 +09001162 set_module_flags(module, target.cflags, target.defines)
Motomu Utsumi88efbb42022-11-17 22:18:15 +09001163 set_module_include_dirs(module, target.cflags, target.include_dirs)
Motomu Utsumif0f47682022-11-17 22:34:39 +09001164 # TODO: set_module_xxx is confusing, apply similar function to module and target in better way.
1165 for arch_name, arch in target.arch.items():
1166 set_module_flags(module.target[arch_name], arch.cflags, arch.defines)
Motomu Utsumi3371d682022-11-28 16:56:52 +09001167 # -Xclang -target-feature -Xclang +mte are used to enable MTE (Memory Tagging Extensions).
1168 # Flags which does not start with '-' could not be in the cflags so enabling MTE by
1169 # -march and -mcpu Feature Modifiers. MTE is only available on arm64. This is needed for
1170 # building //base/allocator/partition_allocator:partition_alloc for arm64.
1171 if '+mte' in arch.cflags and arch_name == 'android_arm64':
1172 module.target[arch_name].cflags.add('-march=armv8-a+memtag')
Motomu Utsumif0f47682022-11-17 22:34:39 +09001173 set_module_include_dirs(module.target[arch_name], arch.cflags, arch.include_dirs)
Patrick Rohr92d74122022-10-21 15:50:52 -07001174
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001175 module.host_supported = target.host_supported()
1176 module.device_supported = target.device_supported()
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001177
Motomu Utsumi8ca12412022-11-30 16:27:30 +09001178 if module.is_genrule():
1179 module.apex_available.add(tethering_apex)
1180
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001181 if module.is_compiled():
Patrick Rohr92d74122022-10-21 15:50:52 -07001182 # Don't try to inject library/source dependencies into genrules or
1183 # filegroups because they are not compiled in the traditional sense.
1184 module.defaults = [defaults_module]
1185 for lib in target.libs:
1186 # Generally library names should be mangled as 'libXXX', unless they
1187 # are HAL libraries (e.g., android.hardware.health@2.0) or AIDL c++ / NDK
1188 # libraries (e.g. "android.hardware.power.stats-V1-cpp")
1189 android_lib = lib if '@' in lib or "-cpp" in lib or "-ndk" in lib \
1190 else 'lib' + lib
1191 if lib in shared_library_allowlist:
1192 module.add_android_shared_lib(android_lib)
1193 if lib in static_library_allowlist:
1194 module.add_android_static_lib(android_lib)
1195
Patrick Rohrd9dd3b92022-11-09 16:15:30 -08001196 # Remove prohibited include directories
1197 module.local_include_dirs = [d for d in module.local_include_dirs
1198 if d not in local_include_dirs_denylist]
1199
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001200 # If the module is a static library, export all the generated headers.
1201 if module.type == 'cc_library_static':
1202 module.export_generated_headers = module.generated_headers
1203
Motomu Utsumiee47af62022-11-30 16:41:15 +09001204 if module.name == 'cronet_aml_components_cronet_android_cronet':
1205 if target.output_name is None:
1206 raise Error('Failed to get output_name for libcronet name')
1207 # .so file name needs to match with CronetLibraryLoader.java (e.g. libcronet.109.0.5386.0.so)
1208 # So setting the output name based on the output_name from the desc.json
1209 module.stem = 'lib' + target.output_name
1210
Patrick Rohr92d74122022-10-21 15:50:52 -07001211 # dep_name is an unmangled GN target name (e.g. //foo:bar(toolchain)).
Motomu Utsumif1daa232022-11-08 13:28:37 +09001212 # Currently, only one module is generated from target even target has multiple toolchains.
1213 # And module is generated based on the first visited target.
1214 # Sort deps before iteration to make result deterministic.
1215 all_deps = sorted(target.deps | target.source_set_deps | target.transitive_proto_deps)
Patrick Rohr92d74122022-10-21 15:50:52 -07001216 for dep_name in all_deps:
Patrick Rohr5cc46e02022-10-26 14:32:45 -07001217 # |builtin_deps| override GN deps with Android-specific ones. See the
1218 # config in the top of this file.
Patrick Rohr07876662022-11-15 22:55:23 -08001219 if dep_name in builtin_deps:
1220 builtin_deps[dep_name](module)
Patrick Rohr5cc46e02022-10-26 14:32:45 -07001221 continue
1222
Patrick Rohr92d74122022-10-21 15:50:52 -07001223 dep_module = create_modules_from_target(blueprint, gn, dep_name)
1224
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001225 if dep_module is None:
1226 continue
Motomu Utsumie246feb2022-11-01 17:25:56 +09001227 # TODO: Proper dependency check for genrule.
1228 # Currently, only propagating genrule dependencies.
1229 # Also, currently, all the dependencies are propagated upwards.
1230 # in gn, public_deps should be propagated but deps should not.
1231 # Not sure this information is available in the desc.json.
1232 # Following rule works for adding android_runtime_jni_headers to base:base.
1233 # If this doesn't work for other target, hardcoding for specific target
1234 # might be better.
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001235 if module.is_genrule() and dep_module.is_genrule():
1236 module.genrule_headers.add(dep_module.name)
1237 module.genrule_headers.update(dep_module.genrule_headers)
Motomu Utsumie246feb2022-11-01 17:25:56 +09001238
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001239 # For filegroups, and genrule, recurse but don't apply the
Patrick Rohra6ce0232022-11-16 22:09:01 -08001240 # deps.
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001241 if not module.is_compiled() or module.is_genrule():
Patrick Rohr92d74122022-10-21 15:50:52 -07001242 continue
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001243
Patrick Rohr92d74122022-10-21 15:50:52 -07001244 if dep_module.type == 'cc_library_shared':
1245 module.shared_libs.add(dep_module.name)
1246 elif dep_module.type == 'cc_library_static':
1247 module.static_libs.add(dep_module.name)
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001248 elif dep_module.type == 'cc_object':
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001249 module.merge_attribute('generated_headers', dep_module, target.arch.keys())
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001250 if module.type != 'cc_object':
1251 if dep_module.has_input_files():
1252 # Only add it as part of srcs if the dep_module has input files otherwise
1253 # this would throw an error.
1254 module.srcs.add(":" + dep_module.name)
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001255 module.merge_attribute('export_generated_headers', dep_module,
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001256 target.arch.keys(), 'generated_headers')
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001257 elif dep_module.type == 'cc_genrule':
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001258 module.merge_attribute('generated_headers', dep_module, [], 'genrule_headers')
1259 module.merge_attribute('srcs', dep_module, [], 'genrule_srcs')
1260 module.merge_attribute('shared_libs', dep_module, [], 'genrule_shared_libs')
1261 module.merge_attribute('header_libs', dep_module, [], 'genrule_header_libs')
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001262 if module.type not in ["cc_object"]:
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001263 module.merge_attribute('export_generated_headers', dep_module, [],
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001264 'genrule_headers')
Patrick Rohr92d74122022-10-21 15:50:52 -07001265 elif dep_module.type == 'cc_binary':
1266 continue # Ignore executables deps (used by cmdline integration tests).
1267 else:
1268 raise Error('Unknown dep %s (%s) for target %s' %
1269 (dep_module.name, dep_module.type, module.name))
1270
Patrick Rohrb51878f2022-11-16 23:49:03 -08001271 for arch_name, arch in target.arch.items():
1272 for dep_name in arch.deps:
1273 dep_module = create_modules_from_target(blueprint, gn, dep_name)
1274 # Arch-specific dependencies currently only include cc_library_static.
1275 # Revisit this approach once we need to support more target types.
1276 if dep_module.type == 'cc_library_static':
1277 module.target[arch_name].static_libs.add(dep_module.name)
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001278 elif dep_module.type == 'cc_genrule':
1279 if dep_module.name.endswith(arch_name):
1280 module.target[arch_name].generated_headers.update(dep_module.genrule_headers)
1281 module.target[arch_name].srcs.update(dep_module.genrule_srcs)
1282 module.target[arch_name].shared_libs.update(dep_module.genrule_shared_libs)
1283 module.target[arch_name].header_libs.update(dep_module.genrule_header_libs)
1284 if module.type not in ["cc_object"]:
1285 module.target[arch_name].export_generated_headers.update(
1286 dep_module.genrule_headers)
Patrick Rohrb51878f2022-11-16 23:49:03 -08001287 else:
1288 raise Error('Unsupported arch-specific dependency %s of target %s with type %s' %
1289 (dep_module.name, target.name, dep_module.type))
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001290 for dep_name in arch.source_set_deps:
1291 dep_module = create_modules_from_target(blueprint, gn, dep_name)
1292 if dep_module.type == 'cc_object':
1293 if module.type != 'cc_object':
1294 # We only want to bubble up cc_objects for modules that are not cc_objects
1295 # otherwise they'd be recompiled and that would cause multiple symbol redefinitions.
1296 if dep_module.has_input_files():
1297 # Only add it as part of srcs if the dep_module has input files otherwise
1298 # this would throw an error.
1299 module.target[arch_name].srcs.add(":" + dep_module.name)
1300 else:
1301 raise Error('Unsupported arch-specific dependency %s of target %s with type %s' %
1302 (dep_module.name, target.name, dep_module.type))
Patrick Rohr92d74122022-10-21 15:50:52 -07001303 return module
1304
Patrick Rohrb18aca22022-11-04 15:07:32 -07001305def create_java_module(blueprint, gn):
1306 bp_module_name = module_prefix + 'java'
1307 module = Module('java_library', bp_module_name, '//gn:java')
Mohannad Farrag21562d62022-11-07 13:09:31 +00001308 module.srcs.update([gn_utils.label_to_path(source) for source in gn.java_sources])
Mohannad Farrage815d862022-12-06 17:51:43 +00001309 module.libs = {
1310 "androidx.annotation_annotation",
1311 "jsr305",
1312 }
Mohannad Farragb30d3712022-12-06 17:27:04 +00001313 module.aidl["include_dirs"] = {"frameworks/base/core/java/"}
1314 module.aidl["local_include_dirs"] = {"base/android/java/src/"}
Mohannad Farrag6a2d88a2022-11-28 19:33:48 +00001315 for dep in gn.java_actions:
Mohannad Farrag9c2cee12022-12-06 17:11:25 +00001316 target = gn.get_target(dep)
1317 if target.script == '//build/android/gyp/gcc_preprocess.py':
1318 module.srcs.add(':' + create_gcc_preprocess_modules(blueprint, target).name)
1319 else:
1320 module.srcs.add(':' + create_action_module(blueprint, target, 'java_genrule').name)
Patrick Rohrb18aca22022-11-04 15:07:32 -07001321 blueprint.add_module(module)
Patrick Rohr92d74122022-10-21 15:50:52 -07001322
Patrick Rohr6ef22722022-11-18 18:24:01 -08001323def update_jni_registration_module(module, gn):
Motomu Utsumi47d122f2022-11-10 17:32:23 +09001324 # TODO: deny list is in the arg of jni_registration_generator.py. Should not be hardcoded
1325 deny_list = [
1326 '//base/android/java/src/org/chromium/base/library_loader/LibraryLoader.java',
1327 '//base/android/java/src/org/chromium/base/library_loader/LibraryPrefetcher.java',
1328 '//base/android/java/src/org/chromium/base/process_launcher/ChildProcessService.java',
1329 '//base/android/java/src/org/chromium/base/SysUtils.java']
1330
Motomu Utsumie3ce7702022-11-10 16:22:11 +09001331 # TODO: java_sources might not contain all the required java files
Motomu Utsumi47d122f2022-11-10 17:32:23 +09001332 module.srcs.update([gn_utils.label_to_path(source)
Motomu Utsumi6e514122022-12-05 17:51:40 +09001333 for source in gn.java_sources
1334 if source.endswith('.java') and source not in deny_list])
Motomu Utsumie3ce7702022-11-10 16:22:11 +09001335
Motomu Utsumia71281c2022-11-18 15:19:00 +09001336def create_blueprint_for_targets(gn, targets):
Patrick Rohr92d74122022-10-21 15:50:52 -07001337 """Generate a blueprint for a list of GN targets."""
1338 blueprint = Blueprint()
1339
1340 # Default settings used by all modules.
1341 defaults = Module('cc_defaults', defaults_module, '//gn:default_deps')
Patrick Rohr92d74122022-10-21 15:50:52 -07001342 defaults.cflags = [
Patrick Rohr3ce74772022-11-11 14:19:58 -08001343 '-DGOOGLE_PROTOBUF_NO_RTTI',
Patrick Rohr92d74122022-10-21 15:50:52 -07001344 '-Wno-error=return-type',
Patrick Rohr3a1ec1d2022-10-31 13:30:17 -07001345 '-Wno-non-virtual-dtor',
Patrick Rohr5c700022022-11-08 19:33:07 -08001346 '-Wno-macro-redefined',
Patrick Rohr98065152022-10-31 14:49:58 -07001347 '-Wno-missing-field-initializers',
Patrick Rohr92d74122022-10-21 15:50:52 -07001348 '-Wno-sign-compare',
1349 '-Wno-sign-promo',
1350 '-Wno-unused-parameter',
Mohannad Farrag54d52442022-11-21 16:27:02 +00001351 '-Wno-null-pointer-subtraction', # Needed to libevent
Mohannad Farragd98a96d2022-11-10 14:56:19 +00001352 '-Wno-deprecated-non-prototype', # needed for zlib
Patrick Rohr92d74122022-10-21 15:50:52 -07001353 '-fvisibility=hidden',
Motomu Utsumiba020942022-11-14 15:15:41 +09001354 '-Wno-ambiguous-reversed-operator', # needed for icui18n
Motomu Utsumib1ec8782022-11-14 15:25:57 +09001355 '-Wno-unreachable-code-loop-increment', # needed for icui18n
Patrick Rohr92d74122022-10-21 15:50:52 -07001356 '-O2',
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001357 '-fPIC',
Patrick Rohr92d74122022-10-21 15:50:52 -07001358 ]
Patrick Rohrc03f1bb2022-11-18 16:13:17 -08001359 # Chromium builds do not add a dependency for headers found inside the
1360 # sysroot, so they are added globally via defaults.
1361 defaults.target['android'].header_libs = [
1362 'media_ndk_headers',
1363 'jni_headers',
1364 ]
Patrick Rohr5446df82022-11-18 14:54:55 -08001365 defaults.target['host'].cflags = [
1366 # -DANDROID is added by default but target.defines contain -DANDROID if
1367 # it's required. So adding -UANDROID to cancel default -DANDROID if it's
1368 # not specified.
1369 # Note: -DANDROID is not consistently applied across the chromium code
1370 # base, so it is removed unconditionally for host targets.
1371 '-UANDROID',
1372 ]
Patrick Rohr61f2acb2022-10-31 14:08:18 -07001373 defaults.stl = 'none'
Motomu Utsumi8ca12412022-11-30 16:27:30 +09001374 defaults.min_sdk_version = 29
1375 defaults.apex_available.add(tethering_apex)
Patrick Rohr92d74122022-10-21 15:50:52 -07001376 blueprint.add_module(defaults)
Patrick Rohr344b2472022-10-25 11:32:15 -07001377
Patrick Rohr92d74122022-10-21 15:50:52 -07001378 for target in targets:
1379 create_modules_from_target(blueprint, gn, target)
Patrick Rohrb18aca22022-11-04 15:07:32 -07001380
1381 create_java_module(blueprint, gn)
Patrick Rohr6ef22722022-11-18 18:24:01 -08001382 for module in blueprint.modules.values():
1383 if 'cronet_jni_registration' in module.name:
1384 update_jni_registration_module(module, gn)
Patrick Rohra7d029d2022-11-08 12:23:11 -08001385
1386 # Merge in additional hardcoded arguments.
1387 for module in blueprint.modules.values():
1388 for key, add_val in additional_args.get(module.name, []):
1389 curr = getattr(module, key)
1390 if add_val and isinstance(add_val, set) and isinstance(curr, set):
1391 curr.update(add_val)
1392 elif isinstance(add_val, str) and (not curr or isinstance(curr, str)):
1393 setattr(module, key, add_val)
1394 elif isinstance(add_val, bool) and (not curr or isinstance(curr, bool)):
1395 setattr(module, key, add_val)
1396 elif isinstance(add_val, dict) and isinstance(curr, dict):
1397 curr.update(add_val)
1398 elif isinstance(add_val, dict) and isinstance(curr, Target):
1399 curr.__dict__.update(add_val)
1400 else:
1401 raise Error('Unimplemented type %r of additional_args: %r' %
1402 (type(add_val), key))
1403
Patrick Rohr92d74122022-10-21 15:50:52 -07001404 return blueprint
1405
1406
1407def main():
1408 parser = argparse.ArgumentParser(
1409 description='Generate Android.bp from a GN description.')
1410 parser.add_argument(
Patrick Rohr92d74122022-10-21 15:50:52 -07001411 '--desc',
Motomu Utsumi879dec82022-11-18 15:25:12 +09001412 help='GN description (e.g., gn desc out --format=json --all-toolchains "//*".' +
1413 'You can specify multiple --desc options for different target_cpu',
1414 required=True,
1415 action='append'
Patrick Rohr92d74122022-10-21 15:50:52 -07001416 )
1417 parser.add_argument(
1418 '--extras',
1419 help='Extra targets to include at the end of the Blueprint file',
1420 default=os.path.join(gn_utils.repo_root(), 'Android.bp.extras'),
1421 )
1422 parser.add_argument(
1423 '--output',
1424 help='Blueprint file to create',
1425 default=os.path.join(gn_utils.repo_root(), 'Android.bp'),
1426 )
1427 parser.add_argument(
Patrick Rohr16228942022-10-26 14:00:26 -07001428 '-v',
1429 '--verbose',
1430 help='Print debug logs.',
1431 action='store_true',
1432 )
1433 parser.add_argument(
Patrick Rohr92d74122022-10-21 15:50:52 -07001434 'targets',
1435 nargs=argparse.REMAINDER,
Patrick Rohr1aa504a2022-10-25 10:30:42 -07001436 help='Targets to include in the blueprint (e.g., "//:perfetto_tests")'
1437 )
Patrick Rohr92d74122022-10-21 15:50:52 -07001438 args = parser.parse_args()
1439
Patrick Rohr16228942022-10-26 14:00:26 -07001440 if args.verbose:
1441 log.basicConfig(format='%(levelname)s:%(funcName)s:%(message)s', level=log.DEBUG)
1442
Patrick Rohrd0077b72022-11-15 12:43:26 -08001443 targets = args.targets or default_targets
Motomu Utsumi879dec82022-11-18 15:25:12 +09001444 gn = gn_utils.GnParser()
1445 for desc_file in args.desc:
1446 with open(desc_file) as f:
1447 desc = json.load(f)
1448 for target in targets:
1449 gn.parse_gn_desc(desc, target)
Motomu Utsumia71281c2022-11-18 15:19:00 +09001450 blueprint = create_blueprint_for_targets(gn, targets)
Patrick Rohr92d74122022-10-21 15:50:52 -07001451 project_root = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
1452 tool_name = os.path.relpath(os.path.abspath(__file__), project_root)
1453
Patrick Rohr92d74122022-10-21 15:50:52 -07001454 # Add any proto groups to the blueprint.
1455 for l_name, t_names in proto_groups.items():
1456 create_proto_group_modules(blueprint, gn, l_name, t_names)
1457
1458 output = [
Patrick Rohr5478b392022-10-25 09:58:50 -07001459 """// Copyright (C) 2022 The Android Open Source Project
Patrick Rohr92d74122022-10-21 15:50:52 -07001460//
1461// Licensed under the Apache License, Version 2.0 (the "License");
1462// you may not use this file except in compliance with the License.
1463// You may obtain a copy of the License at
1464//
1465// http://www.apache.org/licenses/LICENSE-2.0
1466//
1467// Unless required by applicable law or agreed to in writing, software
1468// distributed under the License is distributed on an "AS IS" BASIS,
1469// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1470// See the License for the specific language governing permissions and
1471// limitations under the License.
1472//
1473// This file is automatically generated by %s. Do not edit.
1474""" % (tool_name)
1475 ]
1476 blueprint.to_string(output)
Patrick Rohrcb98e9b2022-10-25 09:57:02 -07001477 if os.path.exists(args.extras):
1478 with open(args.extras, 'r') as r:
1479 for line in r:
1480 output.append(line.rstrip("\n\r"))
Patrick Rohr92d74122022-10-21 15:50:52 -07001481
1482 out_files = []
1483
1484 # Generate the Android.bp file.
1485 out_files.append(args.output + '.swp')
1486 with open(out_files[-1], 'w') as f:
1487 f.write('\n'.join(output))
1488 # Text files should have a trailing EOL.
1489 f.write('\n')
1490
Patrick Rohr94693eb2022-10-25 10:09:16 -07001491 return 0
Patrick Rohr92d74122022-10-21 15:50:52 -07001492
1493
1494if __name__ == '__main__':
1495 sys.exit(main())