blob: 461fb0a56c14fd521f1a2af26ea3394a0ff864a2 [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
Patrick Rohr92d74122022-10-21 15:50:52 -070029import json
Patrick Rohr16228942022-10-26 14:00:26 -070030import logging as log
Patrick Rohr3a2c3dd2022-11-29 22:29:36 -080031import operator
Patrick Rohr92d74122022-10-21 15:50:52 -070032import os
33import re
34import sys
Motomu Utsumic6277d92022-11-07 15:15:17 +090035import copy
Mohannad Farrag9c2cee12022-12-06 17:11:25 +000036from pathlib import Path
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 Utsumiddcc9082022-12-22 15:53:28 +090045 '//components/cronet/android:cronet_android_mainline',
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 Rohr3d1059c2022-12-21 11:04:33 -080096 'third_party/zlib/',
Patrick Rohrd9dd3b92022-11-09 16:15:30 -080097]
98
Patrick Rohr3d1059c2022-12-21 11:04:33 -080099experimental_include_dirs_denylist = [
Patrick Rohrfeed2232022-12-15 11:38:12 -0800100 'third_party/brotli/include/',
Patrick Rohr10b746f2022-12-14 20:08:43 -0800101]
102
Patrick Rohr92d74122022-10-21 15:50:52 -0700103# Name of the module which settings such as compiler flags for all other
104# modules.
105defaults_module = module_prefix + 'defaults'
106
107# Location of the project in the Android source tree.
Motomu Utsumiad6323c2022-12-22 19:20:01 +0900108tree_path = 'external/cronet'
Patrick Rohr92d74122022-10-21 15:50:52 -0700109
110# Path for the protobuf sources in the standalone build.
111buildtools_protobuf_src = '//buildtools/protobuf/src'
112
113# Location of the protobuf src dir in the Android source tree.
114android_protobuf_src = 'external/protobuf/src'
115
Mohannad Farragc739dda2022-12-02 15:43:46 +0000116# put all args on a new line for better diffs.
117NEWLINE = ' " +\n "'
Mohannad Farrag00ecfb52022-12-02 14:44:15 +0000118
Patrick Rohr92d74122022-10-21 15:50:52 -0700119# Compiler flags which are passed through to the blueprint.
Motomu Utsumic8b7bea2022-11-16 18:12:44 +0900120cflag_allowlist = [
Motomu Utsumicf68d732022-11-16 18:15:21 +0900121 # needed for zlib:zlib
122 "-mpclmul",
123 # needed for zlib:zlib
124 "-mssse3",
Mohannad Farrag7f29d832022-11-23 19:52:41 +0000125 # needed for zlib:zlib
126 "-msse3",
127 # needed for zlib:zlib
128 "-msse4.2",
Motomu Utsumic8b7bea2022-11-16 18:12:44 +0900129]
Patrick Rohr92d74122022-10-21 15:50:52 -0700130
Motomu Utsumiab76aac2023-01-23 12:01:00 +0900131def get_linker_script_ldflag(script_path):
132 return f'-Wl,--script,{tree_path}/{script_path}'
133
Patrick Rohr92d74122022-10-21 15:50:52 -0700134# Additional arguments to apply to Android.bp rules.
135additional_args = {
Patrick Rohr2267a0a2022-11-08 18:59:34 -0800136 # TODO: remove if not needed.
Patrick Rohrd90025f2022-11-11 14:18:35 -0800137 'cronet_aml_components_cronet_android_cronet': [
Motomu Utsumiab76aac2023-01-23 12:01:00 +0900138 # linker_scripts property is not available in tm-mainline-prod.
139 # So use ldflags to specify linker script.
140 ('ldflags',{
141 get_linker_script_ldflag('base/android/library_loader/anchor_functions.lds'),
Patrick Rohrd90025f2022-11-11 14:18:35 -0800142 }),
143 ],
Patrick Rohrbb0956e2022-11-09 15:37:16 -0800144 'cronet_aml_net_net': [
Patrick Rohr9f4d3e32022-11-09 16:37:31 -0800145 ('export_static_lib_headers', {
146 'cronet_aml_net_third_party_quiche_quiche',
147 'cronet_aml_crypto_crypto',
148 }),
Mohannad Farrag37388fa2022-11-10 20:42:13 +0000149 ],
Patrick Rohrbaaf1602022-12-22 14:02:48 -0800150 # TODO: fix upstream. Both //base:base and
151 # //base/allocator/partition_allocator:partition_alloc do not create a
152 # dependency on gtest despite using gtest_prod.h.
153 'cronet_aml_base_base': [
154 ('header_libs', {
155 'libgtest_prod_headers',
156 }),
157 ('export_header_lib_headers', {
158 'libgtest_prod_headers',
159 }),
160 ],
161 'cronet_aml_base_allocator_partition_allocator_partition_alloc': [
162 ('header_libs', {
163 'libgtest_prod_headers',
164 }),
165 ],
Patrick Rohr92d74122022-10-21 15:50:52 -0700166}
167
Patrick Rohrfeed2232022-12-15 11:38:12 -0800168def enable_brotli(module, arch):
169 # Requires crrev/c/4111690
170 if arch is None:
171 module.static_libs.add('libbrotli')
172 else:
173 module.arch[arch].static_libs.add('libbrotli')
174
Patrick Rohrce210882022-12-15 16:24:39 -0800175def enable_modp_b64(module, arch):
176 # Requires crrev/c/4112845
177 # Requires aosp/2359455
178 # Requires aosp/2359456
179 if not module.is_compiled():
180 return
181 if arch is None:
182 module.static_libs.add('libmodpb64')
183 else:
184 module.arch[arch].static_libs.add('libmodpb64')
Patrick Rohrfeed2232022-12-15 11:38:12 -0800185
Patrick Rohr10b746f2022-12-14 20:08:43 -0800186def enable_zlib(module, arch):
187 # Requires crrev/c/4109079
188 if arch is None:
189 module.shared_libs.add('libz')
190 else:
191 module.arch[arch].shared_libs.add('libz')
192
Patrick Rohr92d74122022-10-21 15:50:52 -0700193# Android equivalents for third-party libraries that the upstream project
194# depends on.
195builtin_deps = {
Patrick Rohrdd10b432022-12-13 14:46:16 -0800196 '//buildtools/third_party/libunwind:libunwind':
Patrick Rohr25926e62022-12-14 19:55:57 -0800197 lambda m, a: None, # disable libunwind
Patrick Rohr7184dce2023-01-03 05:26:37 -0800198 '//net/data/ssl/chrome_root_store:gen_root_store_inc':
199 lambda m, a: None,
Patrick Rohr14ee0932022-11-15 12:10:27 -0800200 '//net/tools/root_store_tool:root_store_tool':
Patrick Rohr25926e62022-12-14 19:55:57 -0800201 lambda m, a: None,
Patrick Rohr3d1059c2022-12-21 11:04:33 -0800202 '//third_party/zlib:zlib':
203 enable_zlib,
Patrick Rohr92d74122022-10-21 15:50:52 -0700204}
205
Patrick Rohr3d1059c2022-12-21 11:04:33 -0800206experimental_android_deps = {
Patrick Rohrfeed2232022-12-15 11:38:12 -0800207 '//third_party/brotli:common':
208 enable_brotli,
209 '//third_party/brotli:dec':
210 enable_brotli,
Patrick Rohrce210882022-12-15 16:24:39 -0800211 '//third_party/modp_b64:modp_b64':
212 enable_modp_b64,
Patrick Rohr10b746f2022-12-14 20:08:43 -0800213}
214
215# Uncomment the following lines to use Android deps rather than their Chromium
216# equivalent:
Patrick Rohr3d1059c2022-12-21 11:04:33 -0800217#builtin_deps.update(experimental_android_deps)
218#local_include_dirs_denylist.extend(experimental_include_dirs_denylist)
Patrick Rohr10b746f2022-12-14 20:08:43 -0800219
Motomu Utsumi8ca12412022-11-30 16:27:30 +0900220# Name of tethering apex module
221tethering_apex = "com.android.tethering"
222
Motomu Utsumi1002cd82022-12-23 17:19:03 +0900223# Name of cronet api target
224java_api_target_name = "//components/cronet/android:cronet_api_java"
225
Patrick Rohr92d74122022-10-21 15:50:52 -0700226# ----------------------------------------------------------------------------
227# End of configuration.
228# ----------------------------------------------------------------------------
229
230
231class Error(Exception):
232 pass
233
234
235class ThrowingArgumentParser(argparse.ArgumentParser):
236
237 def __init__(self, context):
238 super(ThrowingArgumentParser, self).__init__()
239 self.context = context
240
241 def error(self, message):
242 raise Error('%s: %s' % (self.context, message))
243
244
245def write_blueprint_key_value(output, name, value, sort=True):
246 """Writes a Blueprint key-value pair to the output"""
247
248 if isinstance(value, bool):
249 if value:
250 output.append(' %s: true,' % name)
251 else:
252 output.append(' %s: false,' % name)
253 return
254 if not value:
255 return
256 if isinstance(value, set):
257 value = sorted(value)
258 if isinstance(value, list):
259 output.append(' %s: [' % name)
260 for item in sorted(value) if sort else value:
261 output.append(' "%s",' % item)
262 output.append(' ],')
263 return
264 if isinstance(value, Target):
265 value.to_string(output)
266 return
267 if isinstance(value, dict):
268 kv_output = []
269 for k, v in value.items():
270 write_blueprint_key_value(kv_output, k, v)
271
272 output.append(' %s: {' % name)
273 for line in kv_output:
274 output.append(' %s' % line)
275 output.append(' },')
276 return
277 output.append(' %s: "%s",' % (name, value))
278
279
280class Target(object):
281 """A target-scoped part of a module"""
282
283 def __init__(self, name):
284 self.name = name
Patrick Rohr5d399b32022-11-16 10:19:55 -0800285 self.srcs = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700286 self.shared_libs = set()
287 self.static_libs = set()
288 self.whole_static_libs = set()
Patrick Rohrc03f1bb2022-11-18 16:13:17 -0800289 self.header_libs = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700290 self.cflags = set()
291 self.dist = dict()
292 self.strip = dict()
293 self.stl = None
Motomu Utsumi50ad2172022-11-17 22:29:53 +0900294 self.cppflags = set()
Patrick Rohr3cd5ffb2022-11-18 17:40:55 -0800295 self.local_include_dirs = set()
Patrick Rohr81435162022-11-17 19:34:32 -0800296 self.export_system_include_dirs = set()
Mohannad Farrag631443e2022-11-21 16:17:01 +0000297 self.generated_headers = set()
298 self.export_generated_headers = set()
Motomu Utsumi3ff52fe2023-02-09 17:39:22 +0900299 self.ldflags = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700300
301 def to_string(self, output):
302 nested_out = []
Patrick Rohr5d399b32022-11-16 10:19:55 -0800303 self._output_field(nested_out, 'srcs')
Patrick Rohr92d74122022-10-21 15:50:52 -0700304 self._output_field(nested_out, 'shared_libs')
305 self._output_field(nested_out, 'static_libs')
306 self._output_field(nested_out, 'whole_static_libs')
Patrick Rohrc03f1bb2022-11-18 16:13:17 -0800307 self._output_field(nested_out, 'header_libs')
Patrick Rohr92d74122022-10-21 15:50:52 -0700308 self._output_field(nested_out, 'cflags')
309 self._output_field(nested_out, 'stl')
310 self._output_field(nested_out, 'dist')
311 self._output_field(nested_out, 'strip')
Motomu Utsumi50ad2172022-11-17 22:29:53 +0900312 self._output_field(nested_out, 'cppflags')
313 self._output_field(nested_out, 'local_include_dirs')
Patrick Rohr81435162022-11-17 19:34:32 -0800314 self._output_field(nested_out, 'export_system_include_dirs')
Mohannad Farrag631443e2022-11-21 16:17:01 +0000315 self._output_field(nested_out, 'generated_headers')
316 self._output_field(nested_out, 'export_generated_headers')
Motomu Utsumi3ff52fe2023-02-09 17:39:22 +0900317 self._output_field(nested_out, 'ldflags')
Patrick Rohr92d74122022-10-21 15:50:52 -0700318
319 if nested_out:
320 output.append(' %s: {' % self.name)
321 for line in nested_out:
322 output.append(' %s' % line)
323 output.append(' },')
324
325 def _output_field(self, output, name, sort=True):
326 value = getattr(self, name)
327 return write_blueprint_key_value(output, name, value, sort)
328
329
330class Module(object):
331 """A single module (e.g., cc_binary, cc_test) in a blueprint."""
332
333 def __init__(self, mod_type, name, gn_target):
334 self.type = mod_type
335 self.gn_target = gn_target
336 self.name = name
337 self.srcs = set()
Patrick Rohr07876662022-11-15 22:55:23 -0800338 self.comment = 'GN: ' + gn_target
Patrick Rohr92d74122022-10-21 15:50:52 -0700339 self.shared_libs = set()
340 self.static_libs = set()
341 self.whole_static_libs = set()
342 self.runtime_libs = set()
343 self.tools = set()
344 self.cmd = None
345 self.host_supported = False
Patrick Rohrcdda6322022-11-15 22:44:16 -0800346 self.device_supported = True
Patrick Rohr92d74122022-10-21 15:50:52 -0700347 self.vendor_available = False
348 self.init_rc = set()
349 self.out = set()
350 self.export_include_dirs = set()
351 self.generated_headers = set()
352 self.export_generated_headers = set()
Patrick Rohrbb0956e2022-11-09 15:37:16 -0800353 self.export_static_lib_headers = set()
Patrick Rohrbaaf1602022-12-22 14:02:48 -0800354 self.export_header_lib_headers = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700355 self.defaults = set()
356 self.cflags = set()
357 self.include_dirs = set()
Patrick Rohr3cd5ffb2022-11-18 17:40:55 -0800358 self.local_include_dirs = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700359 self.header_libs = set()
360 self.required = set()
Patrick Rohr3d8c7282022-10-27 13:36:31 -0700361 self.tool_files = set()
Patrick Rohrbfdc5fd2022-11-16 10:03:49 -0800362 # target contains a dict of Targets indexed by os_arch.
363 # example: { 'android_x86': Target('android_x86')
364 self.target = dict()
365 self.target['android'] = Target('android')
Patrick Rohr82e40742022-11-16 10:20:39 -0800366 self.target['android_x86'] = Target('android_x86')
367 self.target['android_x86_64'] = Target('android_x86_64')
368 self.target['android_arm'] = Target('android_arm')
369 self.target['android_arm64'] = Target('android_arm64')
Patrick Rohrbfdc5fd2022-11-16 10:03:49 -0800370 self.target['host'] = Target('host')
Patrick Rohr92d74122022-10-21 15:50:52 -0700371 self.stl = None
Patrick Rohrb8f830a2022-10-31 11:18:57 -0700372 self.cpp_std = None
Patrick Rohr92d74122022-10-21 15:50:52 -0700373 self.dist = dict()
374 self.strip = dict()
375 self.data = set()
376 self.apex_available = set()
377 self.min_sdk_version = None
378 self.proto = dict()
Patrick Rohrd90025f2022-11-11 14:18:35 -0800379 self.linker_scripts = set()
Motomu Utsumiab76aac2023-01-23 12:01:00 +0900380 self.ldflags = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700381 # The genrule_XXX below are properties that must to be propagated back
382 # on the module(s) that depend on the genrule.
383 self.genrule_headers = set()
384 self.genrule_srcs = set()
385 self.genrule_shared_libs = set()
Patrick Rohra1a27872022-10-31 11:57:14 -0700386 self.genrule_header_libs = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700387 self.version_script = None
388 self.test_suites = set()
389 self.test_config = None
390 self.stubs = {}
Mohannad Farrag37388fa2022-11-10 20:42:13 +0000391 self.cppflags = set()
392 self.rtti = False
Motomu Utsumiee47af62022-11-30 16:41:15 +0900393 # Name of the output. Used for setting .so file name for libcronet
Mohannad Farrage815d862022-12-06 17:51:43 +0000394 self.libs = set()
Motomu Utsumiee47af62022-11-30 16:41:15 +0900395 self.stem = None
Motomu Utsumi81bb8342022-12-08 11:47:42 +0900396 self.compile_multilib = None
Mohannad Farragb30d3712022-12-06 17:27:04 +0000397 self.aidl = dict()
Mohannad Farrag3d3d6132022-12-06 18:11:48 +0000398 self.plugins = set()
Mohannad Farrag89f38e42022-12-06 18:54:46 +0000399 self.processor_class = None
Motomu Utsumiba3be9e2022-12-09 15:32:12 +0900400 self.sdk_version = None
Patrick Rohr8d393192022-12-22 14:50:20 -0800401 self.javacflags = set()
Mohannad Farragce711af2022-12-28 18:18:33 +0000402 self.license_kinds = set()
403 self.license_text = set()
404 self.default_applicable_licenses = set()
Patrick Rohr92d74122022-10-21 15:50:52 -0700405
406 def to_string(self, output):
407 if self.comment:
408 output.append('// %s' % self.comment)
409 output.append('%s {' % self.type)
410 self._output_field(output, 'name')
411 self._output_field(output, 'srcs')
412 self._output_field(output, 'shared_libs')
413 self._output_field(output, 'static_libs')
414 self._output_field(output, 'whole_static_libs')
415 self._output_field(output, 'runtime_libs')
416 self._output_field(output, 'tools')
417 self._output_field(output, 'cmd', sort=False)
418 if self.host_supported:
419 self._output_field(output, 'host_supported')
Patrick Rohrcdda6322022-11-15 22:44:16 -0800420 if not self.device_supported:
421 self._output_field(output, 'device_supported')
Patrick Rohr92d74122022-10-21 15:50:52 -0700422 if self.vendor_available:
423 self._output_field(output, 'vendor_available')
424 self._output_field(output, 'init_rc')
425 self._output_field(output, 'out')
426 self._output_field(output, 'export_include_dirs')
427 self._output_field(output, 'generated_headers')
428 self._output_field(output, 'export_generated_headers')
Patrick Rohrbb0956e2022-11-09 15:37:16 -0800429 self._output_field(output, 'export_static_lib_headers')
Patrick Rohrbaaf1602022-12-22 14:02:48 -0800430 self._output_field(output, 'export_header_lib_headers')
Patrick Rohr92d74122022-10-21 15:50:52 -0700431 self._output_field(output, 'defaults')
432 self._output_field(output, 'cflags')
433 self._output_field(output, 'include_dirs')
Patrick Rohr3cd5ffb2022-11-18 17:40:55 -0800434 self._output_field(output, 'local_include_dirs')
Patrick Rohr92d74122022-10-21 15:50:52 -0700435 self._output_field(output, 'header_libs')
436 self._output_field(output, 'required')
437 self._output_field(output, 'dist')
438 self._output_field(output, 'strip')
439 self._output_field(output, 'tool_files')
440 self._output_field(output, 'data')
441 self._output_field(output, 'stl')
Patrick Rohrb8f830a2022-10-31 11:18:57 -0700442 self._output_field(output, 'cpp_std')
Patrick Rohr92d74122022-10-21 15:50:52 -0700443 self._output_field(output, 'apex_available')
444 self._output_field(output, 'min_sdk_version')
445 self._output_field(output, 'version_script')
446 self._output_field(output, 'test_suites')
447 self._output_field(output, 'test_config')
448 self._output_field(output, 'stubs')
449 self._output_field(output, 'proto')
Patrick Rohrd90025f2022-11-11 14:18:35 -0800450 self._output_field(output, 'linker_scripts')
Motomu Utsumiab76aac2023-01-23 12:01:00 +0900451 self._output_field(output, 'ldflags')
Mohannad Farrag37388fa2022-11-10 20:42:13 +0000452 self._output_field(output, 'cppflags')
Mohannad Farrage815d862022-12-06 17:51:43 +0000453 self._output_field(output, 'libs')
Motomu Utsumiee47af62022-11-30 16:41:15 +0900454 self._output_field(output, 'stem')
Motomu Utsumi81bb8342022-12-08 11:47:42 +0900455 self._output_field(output, 'compile_multilib')
Mohannad Farragb30d3712022-12-06 17:27:04 +0000456 self._output_field(output, 'aidl')
Mohannad Farrag3d3d6132022-12-06 18:11:48 +0000457 self._output_field(output, 'plugins')
Mohannad Farrag89f38e42022-12-06 18:54:46 +0000458 self._output_field(output, 'processor_class')
Motomu Utsumiba3be9e2022-12-09 15:32:12 +0900459 self._output_field(output, 'sdk_version')
Patrick Rohr8d393192022-12-22 14:50:20 -0800460 self._output_field(output, 'javacflags')
Mohannad Farragce711af2022-12-28 18:18:33 +0000461 self._output_field(output, 'license_kinds')
462 self._output_field(output, 'license_text')
463 self._output_field(output, 'default_applicable_licenses')
Mohannad Farrag37388fa2022-11-10 20:42:13 +0000464 if self.rtti:
465 self._output_field(output, 'rtti')
Patrick Rohr92d74122022-10-21 15:50:52 -0700466
467 target_out = []
Patrick Rohr09ee70e2022-11-16 15:20:03 -0800468 for arch, target in sorted(self.target.items()):
Patrick Rohrbfdc5fd2022-11-16 10:03:49 -0800469 # _output_field calls getattr(self, arch).
470 setattr(self, arch, target)
471 self._output_field(target_out, arch)
472
Patrick Rohr92d74122022-10-21 15:50:52 -0700473 if target_out:
474 output.append(' target: {')
475 for line in target_out:
476 output.append(' %s' % line)
477 output.append(' },')
478
Patrick Rohr92d74122022-10-21 15:50:52 -0700479 output.append('}')
480 output.append('')
481
482 def add_android_static_lib(self, lib):
483 if self.type == 'cc_binary_host':
484 raise Exception('Adding Android static lib for host tool is unsupported')
485 elif self.host_supported:
Patrick Rohrbfdc5fd2022-11-16 10:03:49 -0800486 self.target['android'].static_libs.add(lib)
Patrick Rohr92d74122022-10-21 15:50:52 -0700487 else:
488 self.static_libs.add(lib)
489
490 def add_android_shared_lib(self, lib):
491 if self.type == 'cc_binary_host':
492 raise Exception('Adding Android shared lib for host tool is unsupported')
493 elif self.host_supported:
Patrick Rohrbfdc5fd2022-11-16 10:03:49 -0800494 self.target['android'].shared_libs.add(lib)
Patrick Rohr92d74122022-10-21 15:50:52 -0700495 else:
496 self.shared_libs.add(lib)
497
498 def _output_field(self, output, name, sort=True):
499 value = getattr(self, name)
500 return write_blueprint_key_value(output, name, value, sort)
501
Patrick Rohra6ce0232022-11-16 22:09:01 -0800502 def is_compiled(self):
Mohannad Farrag7ff99912022-11-29 17:16:00 +0000503 return self.type not in ('cc_genrule', 'filegroup', 'java_genrule')
Mohannad Farrag1de6cb12022-11-28 12:27:26 +0000504
505 def is_genrule(self):
506 return self.type == "cc_genrule"
Patrick Rohra6ce0232022-11-16 22:09:01 -0800507
Mohannad Farrag7f29d832022-11-23 19:52:41 +0000508 def has_input_files(self):
Mohannad Farrag7f29d832022-11-23 19:52:41 +0000509 return len(self.srcs) > 0 or any([len(target.srcs) > 0 for target in self.target.values()])
510
Mohannad Farragf2391cc2022-11-29 13:26:32 +0000511 def merge_attribute(self, key, source_module, allowed_archs, source_key = None):
512 """
513 Merges the value of the attribute `source_key` for the `dep_module` with
514 the value of the attribute `key` for this module. If the value of the
515 `source_key` is equal to None. Then `key` is used for both modules.
516
517 This merges the attribute for both non-arch and archs
518 specified in `allowed_archs`.
519 :param key: The attribute used for merging in the calling module. Also
520 used for `dep_module` if the `source_key` is None.
521 :param source_module: The module where data is propagated from.
522 :param allowed_archs: A list of archs to merge the attribute on.
523 :param source_key: if the attribute merged from the `dep_module`
524 is different from the `key`
525 """
526 if not source_key:
527 source_key = key
528 self.__dict__[key].update(source_module.__dict__[source_key])
529 for arch_name in source_module.target.keys():
530 if arch_name in allowed_archs:
531 self.target[arch_name].__dict__[key].update(
532 source_module.target[arch_name].__dict__[source_key])
Patrick Rohr92d74122022-10-21 15:50:52 -0700533
534class Blueprint(object):
535 """In-memory representation of an Android.bp file."""
536
537 def __init__(self):
538 self.modules = {}
539
540 def add_module(self, module):
541 """Adds a new module to the blueprint, replacing any existing module
542 with the same name.
543
544 Args:
545 module: Module instance.
546 """
547 self.modules[module.name] = module
548
549 def to_string(self, output):
Patrick Rohr23f26192022-10-25 09:45:22 -0700550 for m in sorted(self.modules.values(), key=lambda m: m.name):
Mohannad Farragb6dbca92022-12-29 11:49:04 +0000551 if m.type != "cc_object" or m.has_input_files():
552 # Don't print cc_object with empty srcs. These attributes are already
553 # propagated up the tree. Printing them messes the presubmits because
554 # every module is compiled while those targets are not reachable in
555 # a normal compilation path.
556 m.to_string(output)
Patrick Rohr92d74122022-10-21 15:50:52 -0700557
558
559def label_to_module_name(label):
560 """Turn a GN label (e.g., //:perfetto_tests) into a module name."""
Patrick Rohr07876662022-11-15 22:55:23 -0800561 module = re.sub(r'^//:?', '', label)
Patrick Rohr92d74122022-10-21 15:50:52 -0700562 module = re.sub(r'[^a-zA-Z0-9_]', '_', module)
Motomu Utsumi3fde1482022-11-14 15:55:21 +0900563
Patrick Rohr92d74122022-10-21 15:50:52 -0700564 if not module.startswith(module_prefix):
565 return module_prefix + module
566 return module
567
568
569def is_supported_source_file(name):
570 """Returns True if |name| can appear in a 'srcs' list."""
Patrick Rohrf9f3a992022-11-10 19:40:32 -0800571 return os.path.splitext(name)[1] in ['.c', '.cc', '.cpp', '.java', '.proto', '.S']
Patrick Rohr92d74122022-10-21 15:50:52 -0700572
573
574def create_proto_modules(blueprint, gn, target):
575 """Generate genrules for a proto GN target.
576
577 GN actions are used to dynamically generate files during the build. The
578 Soong equivalent is a genrule. This function turns a specific kind of
579 genrule which turns .proto files into source and header files into a pair
580 equivalent genrules.
581
582 Args:
583 blueprint: Blueprint instance which is being generated.
584 target: gn_utils.Target object.
585
586 Returns:
587 The source_genrule module.
588 """
589 assert (target.type == 'proto_library')
590
Motomu Utsumibd4013f2022-11-17 16:06:05 +0900591 protoc_gn_target_name = gn.get_target('//third_party/protobuf:protoc').name
Motomu Utsumid58c1dc2022-11-16 18:04:46 +0900592 protoc_module_name = label_to_module_name(protoc_gn_target_name)
593 tools = {protoc_module_name}
Motomu Utsumid7e0e422022-11-08 17:49:52 +0900594 cpp_out_dir = '$(genDir)/%s/%s/' % (tree_path, target.proto_in_dir)
Patrick Rohr92d74122022-10-21 15:50:52 -0700595 target_module_name = label_to_module_name(target.name)
596
597 # In GN builds the proto path is always relative to the output directory
598 # (out/tmp.xxx).
Motomu Utsumid58c1dc2022-11-16 18:04:46 +0900599 cmd = ['$(location %s)' % protoc_module_name]
Motomu Utsumid7e0e422022-11-08 17:49:52 +0900600 cmd += ['--proto_path=%s/%s' % (tree_path, target.proto_in_dir)]
Patrick Rohr92d74122022-10-21 15:50:52 -0700601
602 if buildtools_protobuf_src in target.proto_paths:
603 cmd += ['--proto_path=%s' % android_protobuf_src]
604
605 # We don't generate any targets for source_set proto modules because
606 # they will be inlined into other modules if required.
607 if target.proto_plugin == 'source_set':
608 return None
609
610 # Descriptor targets only generate a single target.
611 if target.proto_plugin == 'descriptor':
612 out = '{}.bin'.format(target_module_name)
613
614 cmd += ['--descriptor_set_out=$(out)']
615 cmd += ['$(in)']
616
Mohannad Farrag1de6cb12022-11-28 12:27:26 +0000617 descriptor_module = Module('cc_genrule', target_module_name, target.name)
Patrick Rohr92d74122022-10-21 15:50:52 -0700618 descriptor_module.cmd = ' '.join(cmd)
619 descriptor_module.out = [out]
620 descriptor_module.tools = tools
621 blueprint.add_module(descriptor_module)
622
623 # Recursively extract the .proto files of all the dependencies and
624 # add them to srcs.
625 descriptor_module.srcs.update(
626 gn_utils.label_to_path(src) for src in target.sources)
627 for dep in target.transitive_proto_deps:
628 current_target = gn.get_target(dep)
629 descriptor_module.srcs.update(
630 gn_utils.label_to_path(src) for src in current_target.sources)
631
632 return descriptor_module
633
634 # We create two genrules for each proto target: one for the headers and
635 # another for the sources. This is because the module that depends on the
636 # generated files needs to declare two different types of dependencies --
637 # source files in 'srcs' and headers in 'generated_headers' -- and it's not
638 # valid to generate .h files from a source dependency and vice versa.
639 source_module_name = target_module_name + '_gen'
Mohannad Farrag1de6cb12022-11-28 12:27:26 +0000640 source_module = Module('cc_genrule', source_module_name, target.name)
Patrick Rohr92d74122022-10-21 15:50:52 -0700641 blueprint.add_module(source_module)
642 source_module.srcs.update(
643 gn_utils.label_to_path(src) for src in target.sources)
644
Mohannad Farrag1de6cb12022-11-28 12:27:26 +0000645 header_module = Module('cc_genrule', source_module_name + '_headers',
Patrick Rohr92d74122022-10-21 15:50:52 -0700646 target.name)
647 blueprint.add_module(header_module)
648 header_module.srcs = set(source_module.srcs)
649
650 # TODO(primiano): at some point we should remove this. This was introduced
651 # by aosp/1108421 when adding "protos/" to .proto include paths, in order to
652 # avoid doing multi-repo changes and allow old clients in the android tree
653 # to still do the old #include "perfetto/..." rather than
654 # #include "protos/perfetto/...".
655 header_module.export_include_dirs = {'.', 'protos'}
Patrick Rohr2267a0a2022-11-08 18:59:34 -0800656 # Since the .cc file and .h get created by a different gerule target, they
657 # are not put in the same intermediate path, so local includes do not work
658 # without explictily exporting the include dir.
659 header_module.export_include_dirs.add(target.proto_in_dir)
Patrick Rohr92d74122022-10-21 15:50:52 -0700660
Motomu Utsumi8ca12412022-11-30 16:27:30 +0900661 # This function does not return header_module so setting apex_available attribute here.
662 header_module.apex_available.add(tethering_apex)
663
Patrick Rohr92d74122022-10-21 15:50:52 -0700664 source_module.genrule_srcs.add(':' + source_module.name)
665 source_module.genrule_headers.add(header_module.name)
666
667 if target.proto_plugin == 'proto':
668 suffixes = ['pb']
669 source_module.genrule_shared_libs.add('libprotobuf-cpp-lite')
670 cmd += ['--cpp_out=lite=true:' + cpp_out_dir]
671 elif target.proto_plugin == 'protozero':
672 suffixes = ['pbzero']
673 plugin = create_modules_from_target(blueprint, gn, protozero_plugin)
674 tools.add(plugin.name)
675 cmd += ['--plugin=protoc-gen-plugin=$(location %s)' % plugin.name]
676 cmd += ['--plugin_out=wrapper_namespace=pbzero:' + cpp_out_dir]
677 elif target.proto_plugin == 'cppgen':
678 suffixes = ['gen']
679 plugin = create_modules_from_target(blueprint, gn, cppgen_plugin)
680 tools.add(plugin.name)
681 cmd += ['--plugin=protoc-gen-plugin=$(location %s)' % plugin.name]
682 cmd += ['--plugin_out=wrapper_namespace=gen:' + cpp_out_dir]
683 elif target.proto_plugin == 'ipc':
684 suffixes = ['ipc']
685 plugin = create_modules_from_target(blueprint, gn, ipc_plugin)
686 tools.add(plugin.name)
687 cmd += ['--plugin=protoc-gen-plugin=$(location %s)' % plugin.name]
688 cmd += ['--plugin_out=wrapper_namespace=gen:' + cpp_out_dir]
689 else:
690 raise Error('Unsupported proto plugin: %s' % target.proto_plugin)
691
692 cmd += ['$(in)']
693 source_module.cmd = ' '.join(cmd)
694 header_module.cmd = source_module.cmd
695 source_module.tools = tools
696 header_module.tools = tools
697
698 for sfx in suffixes:
699 source_module.out.update('%s/%s' %
700 (tree_path, src.replace('.proto', '.%s.cc' % sfx))
701 for src in source_module.srcs)
702 header_module.out.update('%s/%s' %
703 (tree_path, src.replace('.proto', '.%s.h' % sfx))
704 for src in header_module.srcs)
705 return source_module
706
707
Patrick Rohr92d74122022-10-21 15:50:52 -0700708def create_proto_group_modules(blueprint, gn, module_name, target_names):
709 # TODO(lalitm): today, we're only adding a Java lite module because that's
710 # the only one used in practice. In the future, if we need other target types
711 # (e.g. C++, Java full etc.) add them here.
712 bp_module_name = label_to_module_name(module_name) + '_java_protos'
713 module = Module('java_library', bp_module_name, bp_module_name)
714 module.comment = f'''GN: [{', '.join(target_names)}]'''
715 module.proto = {'type': 'lite', 'canonical_path_from_root': False}
716
717 for name in target_names:
718 target = gn.get_target(name)
719 module.srcs.update(gn_utils.label_to_path(src) for src in target.sources)
720 for dep_label in target.transitive_proto_deps:
721 dep = gn.get_target(dep_label)
722 module.srcs.update(gn_utils.label_to_path(src) for src in dep.sources)
723
724 blueprint.add_module(module)
725
Mohannad Farrag9c2cee12022-12-06 17:11:25 +0000726def create_gcc_preprocess_modules(blueprint, target):
727 # gcc_preprocess.py internally execute host gcc which is not allowed in genrule.
728 # So, this function create multiple modules and realize equivalent processing
729 # TODO: Consider to support gcc_preprocess.py in different way
730 # It's not great to have genrule and cc_object in the dependency from java_library
731 assert (len(target.sources) == 1)
732 source = list(target.sources)[0]
733 assert (Path(source).suffix == '.template')
734 stem = Path(source).stem
735
736 bp_module_name = label_to_module_name(target.name)
737
738 # Rename .template to .cc since cc_object does not accept .template file as srcs
739 rename_module = Module('genrule', bp_module_name + '_rename', target.name)
740 rename_module.srcs.add(gn_utils.label_to_path(source))
741 rename_module.out.add(stem + '.cc')
742 rename_module.cmd = 'cp $(in) $(out)'
743 blueprint.add_module(rename_module)
744
745 # Preprocess template file and generates java file
746 preprocess_module = Module('cc_object', bp_module_name + '_preprocess', target.name)
747 # -E: stop after preprocessing.
748 # -P: disable line markers, i.e. '#line 309'
749 preprocess_module.cflags.update(['-E', '-P', '-DANDROID'])
750 preprocess_module.srcs.add(':' + rename_module.name)
751 defines = ['-D' + target.args[i+1] for i, arg in enumerate(target.args) if arg == '--define']
752 preprocess_module.cflags.update(defines)
753 # HACK: Specifying compile_multilib to build cc_object only once.
754 # Without this, soong complain to genrule that depends on cc_object when built for 64bit target.
755 # It seems this is because cc object is a module with per-architecture variants and genrule is a
756 # module with default variant. For 64bit target, cc_object is built multiple times for 32/64bit
757 # modes and genrule doesn't know which one to depend on.
Motomu Utsumi4fb65c72022-12-09 17:08:48 +0900758 preprocess_module.compile_multilib = 'first'
Mohannad Farrag9c2cee12022-12-06 17:11:25 +0000759 blueprint.add_module(preprocess_module)
760
761 # Generates srcjar using soong_zip
762 module = Module('genrule', bp_module_name, target.name)
763 module.srcs.add(':' + preprocess_module.name)
764 module.out.add(stem + '.srcjar')
765 module.cmd = NEWLINE.join([
766 f'cp $(in) $(genDir)/{stem}.java &&',
Motomu Utsumidfb67ba2023-01-27 12:02:18 +0900767 f'$(location soong_zip) -o $(out) -srcjar -C $(genDir) -f $(genDir)/{stem}.java'
Mohannad Farrag9c2cee12022-12-06 17:11:25 +0000768 ])
769 module.tools.add('soong_zip')
770 blueprint.add_module(module)
771 return module
772
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800773
Mohannad Farrag420c14e2022-11-30 17:13:15 +0000774class BaseActionSanitizer():
Motomu Utsumi0facea52022-12-16 17:25:30 +0900775 def __init__(self, target, arch):
Patrick Rohr9e414b52022-11-29 22:12:18 -0800776 # Just to be on the safe side, create a deep-copy.
777 self.target = copy.deepcopy(target)
Motomu Utsumi0facea52022-12-16 17:25:30 +0900778 if arch:
779 # Merge arch specific attributes
780 self.target.sources |= arch.sources
781 self.target.inputs |= arch.inputs
782 self.target.outputs |= arch.outputs
783 self.target.script = self.target.script or arch.script
784 self.target.args = self.target.args or arch.args
785 self.target.response_file_contents = \
786 self.target.response_file_contents or arch.response_file_contents
Motomu Utsumi9752bd32022-12-02 15:16:55 +0900787 self.target.args = self._normalize_args()
788
Mohannad Farrag7f7c9b42022-12-02 14:37:56 +0000789 def get_name(self):
790 return label_to_module_name(self.target.name)
791
Motomu Utsumi9752bd32022-12-02 15:16:55 +0900792 def _normalize_args(self):
Patrick Rohr9e414b52022-11-29 22:12:18 -0800793 # Convert ['--param=value'] to ['--param', 'value'] for consistency.
Mohannad Farrag60b37702022-12-02 14:07:33 +0000794 # Escape quotations.
Motomu Utsumi9752bd32022-12-02 15:16:55 +0900795 normalized_args = []
796 for arg in self.target.args:
Mohannad Farrag60b37702022-12-02 14:07:33 +0000797 arg = arg.replace('"', r'\"')
Motomu Utsumi13399322022-12-02 15:36:48 +0900798 if arg.startswith('-'):
799 normalized_args.extend(arg.split('='))
800 else:
801 normalized_args.append(arg)
Motomu Utsumi9752bd32022-12-02 15:16:55 +0900802 return normalized_args
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800803
Patrick Rohr2cad9332022-11-30 14:27:40 -0800804 # There are three types of args:
805 # - flags (--flag)
806 # - value args (--arg value)
807 # - list args (--arg value1 --arg value2)
Motomu Utsumi8be8a262022-12-02 14:35:15 +0900808 # 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 +0900809 # Note that the set of list args contains the set of value args.
Motomu Utsumi8be8a262022-12-02 14:35:15 +0900810 # 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 -0800811 # Some functions provide special implementations for each type, while others
812 # work on all of them.
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800813 def _has_arg(self, arg):
814 return arg in self.target.args
815
Motomu Utsumi923688c2022-12-01 15:51:05 +0900816 def _get_arg_indices(self, target_arg):
817 return [i for i, arg in enumerate(self.target.args) if arg == target_arg]
Patrick Rohr3a2c3dd2022-11-29 22:29:36 -0800818
Motomu Utsumi923688c2022-12-01 15:51:05 +0900819 # Whether an arg value pair appears once or more times
820 def _is_list_arg(self, arg):
821 indices = self._get_arg_indices(arg)
822 return len(indices) > 0 and all([not self.target.args[i + 1].startswith('--') for i in indices])
823
Motomu Utsumic363b412022-12-01 16:01:58 +0900824 def _update_list_arg(self, arg, func, throw_if_absent = True):
825 if self._should_fail_silently(arg, throw_if_absent):
826 return
827 assert(self._is_list_arg(arg))
828 indices = self._get_arg_indices(arg)
829 for i in indices:
830 self._set_arg_at(i + 1, func(self.target.args[i + 1]))
831
Motomu Utsumi923688c2022-12-01 15:51:05 +0900832 # Whether an arg value pair appears exactly once
Patrick Rohref4f2bf2022-11-30 14:22:40 -0800833 def _is_value_arg(self, arg):
Motomu Utsumid75b8b52022-12-02 14:29:00 +0900834 return operator.countOf(self.target.args, arg) == 1 and self._is_list_arg(arg)
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800835
Patrick Rohr2cad9332022-11-30 14:27:40 -0800836 def _get_value_arg(self, arg):
Patrick Rohref4f2bf2022-11-30 14:22:40 -0800837 assert(self._is_value_arg(arg))
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800838 i = self.target.args.index(arg)
839 return self.target.args[i + 1]
840
Patrick Rohrf0abead2022-11-30 19:44:10 -0800841 # used to check whether a function call should cause an error when an arg is
842 # missing.
843 def _should_fail_silently(self, arg, throw_if_absent):
844 return not throw_if_absent and not self._has_arg(arg)
845
846 def _set_value_arg(self, arg, value, throw_if_absent = True):
847 if self._should_fail_silently(arg, throw_if_absent):
Patrick Rohr4d74aed2022-11-30 15:42:16 -0800848 return
Patrick Rohref4f2bf2022-11-30 14:22:40 -0800849 assert(self._is_value_arg(arg))
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800850 i = self.target.args.index(arg)
851 self.target.args[i + 1] = value
852
Patrick Rohrf0abead2022-11-30 19:44:10 -0800853 def _update_value_arg(self, arg, func, throw_if_absent = True):
854 if self._should_fail_silently(arg, throw_if_absent):
Patrick Rohr4d74aed2022-11-30 15:42:16 -0800855 return
Patrick Rohr1bedf6c2022-11-30 15:12:57 -0800856 self._set_value_arg(arg, func(self._get_value_arg(arg)))
857
Patrick Rohr77c4f5c2022-11-30 12:56:29 -0800858 def _set_arg_at(self, position, value):
Mohannad Farrag9ab17932022-11-30 17:28:35 +0000859 self.target.args[position] = value
860
Patrick Rohr357b25c2022-11-30 19:46:26 -0800861 def _delete_value_arg(self, arg, throw_if_absent = True):
Patrick Rohrf0abead2022-11-30 19:44:10 -0800862 if self._should_fail_silently(arg, throw_if_absent):
Patrick Rohr4d74aed2022-11-30 15:42:16 -0800863 return
Patrick Rohr357b25c2022-11-30 19:46:26 -0800864 assert(self._is_value_arg(arg))
Patrick Rohr9f439322022-11-30 15:56:15 -0800865 i = self.target.args.index(arg)
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800866 self.target.args.pop(i)
Patrick Rohr357b25c2022-11-30 19:46:26 -0800867 self.target.args.pop(i)
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800868
Patrick Rohr1f7dd582022-11-30 13:44:07 -0800869 def _append_arg(self, arg, value):
870 self.target.args.append(arg)
871 self.target.args.append(value)
872
Mohannad Farrag8fa90652022-12-01 15:40:40 +0000873 def _sanitize_filepath_with_location_tag(self, arg):
874 if arg.startswith('../../'):
875 arg = self._sanitize_filepath(arg)
876 arg = self._add_location_tag(arg)
877 return arg
878
Patrick Rohr73ef7ae2022-11-29 22:33:09 -0800879 # wrap filename in location tag.
Patrick Rohrfda026732022-11-30 16:07:11 -0800880 def _add_location_tag(self, filename):
Patrick Rohr73ef7ae2022-11-29 22:33:09 -0800881 return '$(location %s)' % filename
882
Patrick Rohr0e24c5f2022-11-30 15:20:21 -0800883 # applies common directory transformation that *should* be universally applicable.
884 # TODO: verify if it actually *is* universally applicable.
Patrick Rohr872a2812022-11-30 19:28:22 -0800885 def _sanitize_filepath(self, filepath):
Patrick Rohr0e24c5f2022-11-30 15:20:21 -0800886 # Careful, order matters!
Patrick Rohr8bcd7832022-11-30 19:48:56 -0800887 # delete all leading ../
Patrick Rohr9e5a3c72022-11-30 15:51:30 -0800888 filepath = re.sub('^(\.\./)+', '', filepath)
Patrick Rohr0e24c5f2022-11-30 15:20:21 -0800889 filepath = re.sub('^gen/jni_headers', '$(genDir)', filepath)
890 filepath = re.sub('^gen', '$(genDir)', filepath)
891 return filepath
Patrick Rohr32276892022-11-29 22:38:13 -0800892
Motomu Utsumi21485ba2022-12-01 17:01:50 +0900893 # Iterate through all the args and apply function
894 def _update_all_args(self, func):
895 self.target.args = [func(arg) for arg in self.target.args]
896
Mohannad Farragd5515ca2022-12-02 15:39:53 +0000897 def get_cmd(self):
Mohannad Farragc739dda2022-12-02 15:43:46 +0000898 arg_string = NEWLINE.join(self.target.args)
899 cmd = '$(location %s) %s' % (
900 gn_utils.label_to_path(self.target.script), arg_string)
901
902 if self.use_response_file:
903 # Pipe response file contents into script
904 cmd = 'echo \'%s\' |%s%s' % (self.target.response_file_contents, NEWLINE, cmd)
905 return cmd
Mohannad Farragd5515ca2022-12-02 15:39:53 +0000906
Motomu Utsumi5afd0812022-12-02 15:43:36 +0900907 def get_outputs(self):
908 return self.target.outputs
909
Motomu Utsumi80fa0b02022-12-05 12:50:57 +0900910 def get_srcs(self):
911 # gn treats inputs and sources for actions equally.
912 # soong only supports source files inside srcs, non-source files are added as
913 # tool_files dependency.
914 files = self.target.sources.union(self.target.inputs)
915 return {gn_utils.label_to_path(file) for file in files if is_supported_source_file(file)}
916
Motomu Utsumiaaf42cf2022-12-05 12:55:02 +0900917 def get_tool_files(self):
918 # gn treats inputs and sources for actions equally.
919 # soong only supports source files inside srcs, non-source files are added as
920 # tool_files dependency.
921 files = self.target.sources.union(self.target.inputs)
Motomu Utsumi69975862022-12-05 12:59:06 +0900922 tool_files = {gn_utils.label_to_path(file)
923 for file in files if not is_supported_source_file(file)}
924 tool_files.add(gn_utils.label_to_path(self.target.script))
925 return tool_files
Motomu Utsumiaaf42cf2022-12-05 12:55:02 +0900926
Motomu Utsumicdb45ea2022-12-02 17:05:07 +0900927 def _sanitize_args(self):
Mohannad Farrag00ecfb52022-12-02 14:44:15 +0000928 # Handle passing parameters via response file by piping them into the script
929 # and reading them from /dev/stdin.
930
Mohannad Farraga0e37c12022-12-02 14:46:08 +0000931 self.use_response_file = gn_utils.RESPONSE_FILE in self.target.args
Mohannad Farrag00ecfb52022-12-02 14:44:15 +0000932 if self.use_response_file:
933 # Replace {{response_file_contents}} with /dev/stdin
Mohannad Farraga0e37c12022-12-02 14:46:08 +0000934 self.target.args = ['/dev/stdin' if it == gn_utils.RESPONSE_FILE else it
935 for it in self.target.args]
Motomu Utsumicdb45ea2022-12-02 17:05:07 +0900936
937 def _sanitize_outputs(self):
938 pass
939
Motomu Utsumi735a5a42022-12-05 12:15:07 +0900940 def _sanitize_inputs(self):
941 pass
942
Motomu Utsumicdb45ea2022-12-02 17:05:07 +0900943 def sanitize(self):
944 self._sanitize_args()
945 self._sanitize_outputs()
Motomu Utsumi735a5a42022-12-05 12:15:07 +0900946 self._sanitize_inputs()
Motomu Utsumicdb45ea2022-12-02 17:05:07 +0900947
Motomu Utsumi7db75832022-12-02 16:46:22 +0900948 # Whether this target generates header files
949 def is_header_generated(self):
Motomu Utsumia91ade62022-12-02 16:58:36 +0900950 return any(os.path.splitext(it)[1] == '.h' for it in self.target.outputs)
Motomu Utsumi7db75832022-12-02 16:46:22 +0900951
Mohannad Farrag9ab17932022-11-30 17:28:35 +0000952class WriteBuildDateHeaderSanitizer(BaseActionSanitizer):
Motomu Utsumi805591d2022-12-02 17:17:16 +0900953 def _sanitize_args(self):
Patrick Rohr77c4f5c2022-11-30 12:56:29 -0800954 self._set_arg_at(0, '$(out)')
Motomu Utsumi805591d2022-12-02 17:17:16 +0900955 super()._sanitize_args()
Mohannad Farrag9ab17932022-11-30 17:28:35 +0000956
Mohannad Farrag71353f92022-11-30 17:20:48 +0000957class WriteBuildFlagHeaderSanitizer(BaseActionSanitizer):
Motomu Utsumi805591d2022-12-02 17:17:16 +0900958 def _sanitize_args(self):
Patrick Rohr2cad9332022-11-30 14:27:40 -0800959 self._set_value_arg('--gen-dir', '.')
960 self._set_value_arg('--output', '$(out)')
Motomu Utsumi805591d2022-12-02 17:17:16 +0900961 super()._sanitize_args()
Patrick Rohrf6de33f2022-11-29 22:02:55 -0800962
Patrick Rohr0242a3f2022-11-30 13:48:59 -0800963class JniGeneratorSanitizer(BaseActionSanitizer):
Motomu Utsumi4d551d72022-12-01 16:18:23 +0900964 def _add_location_tag_to_filepath(self, arg):
965 if not arg.endswith('.class'):
966 # --input_file supports both .class specifiers or source files as arguments.
967 # Only source files need to be wrapped inside a $(location <label>) tag.
968 arg = self._add_location_tag(arg)
969 return arg
970
Motomu Utsumi805591d2022-12-02 17:17:16 +0900971 def _sanitize_args(self):
Patrick Rohr7d2cdf42022-12-22 11:39:35 -0800972 self._set_value_arg('--jar_file', '$(location :current_android_jar)', False)
Patrick Rohr0242a3f2022-11-30 13:48:59 -0800973 if self._has_arg('--jar_file'):
Motomu Utsumiad0df0c2023-01-27 11:57:33 +0900974 self._append_arg('--javap', '$$(find $${OUT_DIR:-out}/.path -name javap)')
Patrick Rohr872a2812022-11-30 19:28:22 -0800975 self._update_value_arg('--output_dir', self._sanitize_filepath)
Patrick Rohrf0abead2022-11-30 19:44:10 -0800976 self._update_value_arg('--includes', self._sanitize_filepath, False)
Patrick Rohr357b25c2022-11-30 19:46:26 -0800977 self._delete_value_arg('--prev_output_dir', False)
Motomu Utsumi4d551d72022-12-01 16:18:23 +0900978 self._update_list_arg('--input_file', self._sanitize_filepath)
979 self._update_list_arg('--input_file', self._add_location_tag_to_filepath)
Mohannad Farraga4191eb2023-01-04 14:41:17 +0000980 self._append_arg('--package_prefix', 'android.net.http.internal')
Motomu Utsumi805591d2022-12-02 17:17:16 +0900981 super()._sanitize_args()
Patrick Rohr0242a3f2022-11-30 13:48:59 -0800982
Motomu Utsumi94019962022-12-02 17:18:58 +0900983 def _sanitize_outputs(self):
Motomu Utsumid4f72642022-12-02 16:01:59 +0900984 # fix target.output directory to match #include statements.
985 self.target.outputs = {re.sub('^jni_headers/', '', out) for out in self.target.outputs}
Motomu Utsumi94019962022-12-02 17:18:58 +0900986 super()._sanitize_outputs()
Motomu Utsumid4f72642022-12-02 16:01:59 +0900987
Motomu Utsumia6824ea2022-12-05 14:53:11 +0900988 def get_tool_files(self):
989 tool_files = super().get_tool_files()
990 # android_jar.classes should be part of the tools as it list implicit classes
991 # for the script to generate JNI headers.
992 tool_files.add("base/android/jni_generator/android_jar.classes")
Patrick Rohr7d2cdf42022-12-22 11:39:35 -0800993
994 # Filter android.jar and add :current_android_jar
995 tool_files = {file if not file.endswith('android.jar') else ':current_android_jar'
996 for file in tool_files }
Motomu Utsumia6824ea2022-12-05 14:53:11 +0900997 return tool_files
998
Motomu Utsumib80903c2022-12-01 16:21:55 +0900999class JniRegistrationGeneratorSanitizer(BaseActionSanitizer):
Motomu Utsumi07027f62022-12-05 12:16:53 +09001000 def _sanitize_inputs(self):
1001 self.target.inputs = [file for file in self.target.inputs if not file.startswith('//out/')]
1002
Motomu Utsumi805591d2022-12-02 17:17:16 +09001003 def _sanitize_args(self):
Motomu Utsumi28cbf2f2022-12-01 16:24:29 +09001004 self._update_value_arg('--depfile', self._sanitize_filepath)
1005 self._update_value_arg('--srcjar-path', self._sanitize_filepath)
1006 self._update_value_arg('--header-path', self._sanitize_filepath)
Motomu Utsumi55907472022-12-01 16:26:21 +09001007 self._set_value_arg('--sources-files', '$(genDir)/java.sources')
Motomu Utsumi4fe0b952022-12-01 16:29:15 +09001008 # update_jni_registration_module removes them from the srcs of the module
1009 # It might be better to remove sources by '--sources-exclusions'
1010 self._delete_value_arg('--sources-exclusions')
Mohannad Farraga4191eb2023-01-04 14:41:17 +00001011 self._append_arg('--package_prefix', 'android.net.http.internal')
Motomu Utsumi805591d2022-12-02 17:17:16 +09001012 super()._sanitize_args()
Patrick Rohr0242a3f2022-11-30 13:48:59 -08001013
Mohannad Farrag291f5672022-12-02 15:49:00 +00001014 def get_cmd(self):
1015 # jni_registration_generator.py doesn't work with python2
1016 cmd = "python3 " + super().get_cmd()
1017 # Path in the original sources file does not work in genrule.
1018 # So creating sources file in cmd based on the srcs of this target.
1019 # Adding ../$(current_dir)/ to the head because jni_registration_generator.py uses the files
1020 # whose path startswith(..)
1021 commands = ["current_dir=`basename \\\`pwd\\\``;",
1022 "for f in $(in);",
1023 "do",
1024 "echo \\\"../$$current_dir/$$f\\\" >> $(genDir)/java.sources;",
1025 "done;",
1026 cmd]
1027
1028 # .h file jni_registration_generator.py generates has #define with directory name.
1029 # With the genrule env that contains "." which is invalid. So replace that at the end of cmd.
1030 commands.append(";sed -i -e 's/OUT_SOONG_.TEMP_SBOX_.*_OUT/GEN/g' ")
1031 commands.append("$(genDir)/components/cronet/android/cronet_jni_registration.h")
1032 return NEWLINE.join(commands)
1033
Mohannad Farrag457bc022022-12-02 14:31:22 +00001034class JavaJniRegistrationGeneratorSanitizer(JniRegistrationGeneratorSanitizer):
Mohannad Farrag7f7c9b42022-12-02 14:37:56 +00001035 def get_name(self):
1036 return label_to_module_name(self.target.name) + "__java"
1037
Mohannad Farrag457bc022022-12-02 14:31:22 +00001038 def _sanitize_outputs(self):
1039 self.target.outputs = [out for out in self.target.outputs if
1040 out.endswith(".srcjar")]
1041 super()._sanitize_outputs()
1042
Motomu Utsumi6af5b2a2022-12-01 16:33:42 +09001043class VersionSanitizer(BaseActionSanitizer):
Motomu Utsumi805591d2022-12-02 17:17:16 +09001044 def _sanitize_args(self):
Motomu Utsumic6b08b82022-12-01 16:48:19 +09001045 self._set_value_arg('-o', '$(out)')
Motomu Utsumi21485ba2022-12-01 17:01:50 +09001046 # args for the version.py contain file path without leading --arg key. So apply sanitize
1047 # function for all the args.
Mohannad Farrag8fa90652022-12-01 15:40:40 +00001048 self._update_all_args(self._sanitize_filepath_with_location_tag)
Mohannad Farrag25697342022-12-02 18:01:48 +00001049 self._set_value_arg('-e', "'%s'" % self._get_value_arg('-e'))
Motomu Utsumi805591d2022-12-02 17:17:16 +09001050 super()._sanitize_args()
Motomu Utsumi6af5b2a2022-12-01 16:33:42 +09001051
Motomu Utsumidf634142022-12-05 15:02:44 +09001052 def get_tool_files(self):
1053 tool_files = super().get_tool_files()
1054 # android_chrome_version.py is not specified in anywhere but version.py imports this file
1055 tool_files.add('build/util/android_chrome_version.py')
1056 return tool_files
1057
Mohannad Farragb73ce0f2022-12-01 15:43:58 +00001058class JavaCppEnumSanitizer(BaseActionSanitizer):
Motomu Utsumi805591d2022-12-02 17:17:16 +09001059 def _sanitize_args(self):
Mohannad Farragb73ce0f2022-12-01 15:43:58 +00001060 self._update_all_args(self._sanitize_filepath_with_location_tag)
1061 self._set_value_arg('--srcjar', '$(out)')
Motomu Utsumi805591d2022-12-02 17:17:16 +09001062 super()._sanitize_args()
Mohannad Farragb73ce0f2022-12-01 15:43:58 +00001063
Motomu Utsumi9701d2f2022-12-02 16:53:06 +09001064class MakeDafsaSanitizer(BaseActionSanitizer):
1065 def is_header_generated(self):
Motomu Utsumi1e028b82022-12-02 16:54:20 +09001066 # This script generates .cc files but they are #included by other sources
1067 # (e.g. registry_controlled_domain.cc)
1068 return True
Motomu Utsumi9701d2f2022-12-02 16:53:06 +09001069
Motomu Utsumi56a2f442022-12-05 16:01:34 +09001070class JavaCppFeatureSanitizer(BaseActionSanitizer):
Motomu Utsumid7c36772022-12-05 16:04:37 +09001071 def _sanitize_args(self):
1072 self._update_all_args(self._sanitize_filepath_with_location_tag)
1073 self._set_value_arg('--srcjar', '$(out)')
1074 super()._sanitize_args()
Motomu Utsumi56a2f442022-12-05 16:01:34 +09001075
Motomu Utsumice5166b2022-12-05 16:08:37 +09001076class JavaCppStringSanitizer(BaseActionSanitizer):
Motomu Utsumi3f7ab312022-12-05 16:12:21 +09001077 def _sanitize_args(self):
1078 self._update_all_args(self._sanitize_filepath_with_location_tag)
1079 self._set_value_arg('--srcjar', '$(out)')
1080 super()._sanitize_args()
Motomu Utsumice5166b2022-12-05 16:08:37 +09001081
Motomu Utsumib90a76b2022-12-05 16:17:26 +09001082class WriteNativeLibrariesJavaSanitizer(BaseActionSanitizer):
Motomu Utsumi3dbc2762022-12-05 16:20:21 +09001083 def _sanitize_args(self):
1084 self._set_value_arg('--output', '$(out)')
1085 super()._sanitize_args()
Motomu Utsumib90a76b2022-12-05 16:17:26 +09001086
Motomu Utsumi0facea52022-12-16 17:25:30 +09001087def get_action_sanitizer(target, type, arch):
Patrick Rohr7f117152022-11-30 13:58:05 -08001088 if target.script == "//build/write_buildflag_header.py":
Motomu Utsumi0facea52022-12-16 17:25:30 +09001089 return WriteBuildFlagHeaderSanitizer(target, arch)
Patrick Rohr7f117152022-11-30 13:58:05 -08001090 elif target.script == "//build/write_build_date_header.py":
Motomu Utsumi0facea52022-12-16 17:25:30 +09001091 return WriteBuildDateHeaderSanitizer(target, arch)
Patrick Rohr7f117152022-11-30 13:58:05 -08001092 elif target.script == '//base/android/jni_generator/jni_generator.py':
Motomu Utsumi0facea52022-12-16 17:25:30 +09001093 return JniGeneratorSanitizer(target, arch)
Motomu Utsumib80903c2022-12-01 16:21:55 +09001094 elif target.script == '//base/android/jni_generator/jni_registration_generator.py':
Mohannad Farrag457bc022022-12-02 14:31:22 +00001095 if type == 'java_genrule':
Motomu Utsumi0facea52022-12-16 17:25:30 +09001096 return JavaJniRegistrationGeneratorSanitizer(target, arch)
Mohannad Farrag457bc022022-12-02 14:31:22 +00001097 else:
Motomu Utsumi0facea52022-12-16 17:25:30 +09001098 return JniRegistrationGeneratorSanitizer(target, arch)
Motomu Utsumi6af5b2a2022-12-01 16:33:42 +09001099 elif target.script == "//build/util/version.py":
Motomu Utsumi0facea52022-12-16 17:25:30 +09001100 return VersionSanitizer(target, arch)
Mohannad Farragb73ce0f2022-12-01 15:43:58 +00001101 elif target.script == "//build/android/gyp/java_cpp_enum.py":
Motomu Utsumi0facea52022-12-16 17:25:30 +09001102 return JavaCppEnumSanitizer(target, arch)
Motomu Utsumi9701d2f2022-12-02 16:53:06 +09001103 elif target.script == "//net/tools/dafsa/make_dafsa.py":
Motomu Utsumi0facea52022-12-16 17:25:30 +09001104 return MakeDafsaSanitizer(target, arch)
Motomu Utsumi56a2f442022-12-05 16:01:34 +09001105 elif target.script == '//build/android/gyp/java_cpp_features.py':
Motomu Utsumi0facea52022-12-16 17:25:30 +09001106 return JavaCppFeatureSanitizer(target, arch)
Motomu Utsumice5166b2022-12-05 16:08:37 +09001107 elif target.script == '//build/android/gyp/java_cpp_strings.py':
Motomu Utsumi0facea52022-12-16 17:25:30 +09001108 return JavaCppStringSanitizer(target, arch)
Motomu Utsumib90a76b2022-12-05 16:17:26 +09001109 elif target.script == '//build/android/gyp/write_native_libraries_java.py':
Motomu Utsumi0facea52022-12-16 17:25:30 +09001110 return WriteNativeLibrariesJavaSanitizer(target, arch)
Patrick Rohr7f117152022-11-30 13:58:05 -08001111 else:
1112 # TODO: throw exception here once all script hacks have been converted.
Motomu Utsumi0facea52022-12-16 17:25:30 +09001113 return BaseActionSanitizer(target, arch)
Patrick Rohr7f117152022-11-30 13:58:05 -08001114
Mohannad Farragbab6c892022-11-02 14:09:46 +00001115def create_action_foreach_modules(blueprint, target):
1116 """ The following assumes that rebase_path exists in the args.
1117 The args of an action_foreach contains hints about which output files are generated
1118 by which source files.
1119 This is copied directly from the args
1120 "gen/net/base/registry_controlled_domains/{{source_name_part}}-reversed-inc.cc"
1121 So each source file will generate an output whose name is the {source_name-reversed-inc.cc}
1122 """
1123 new_args = []
Motomu Utsumi56afcac2022-11-04 12:58:30 +09001124 for i, src in enumerate(sorted(target.sources)):
Mohannad Farragbab6c892022-11-02 14:09:46 +00001125 # don't add script arg for the first source -- create_action_module
1126 # already does this.
1127 if i != 0:
1128 new_args.append('&& python3 $(location %s)' %
1129 gn_utils.label_to_path(target.script))
1130 for arg in target.args:
1131 if '{{source}}' in arg:
1132 new_args.append('$(location %s)' % (gn_utils.label_to_path(src)))
1133 elif '{{source_name_part}}' in arg:
1134 source_name_part = src.split("/")[-1] # Get the file name only
1135 source_name_part = source_name_part.split(".")[0] # Remove the extension (Ex: .cc)
1136 file_name = arg.replace('{{source_name_part}}', source_name_part).split("/")[-1]
1137 # file_name represent the output file name. But we need the whole path
1138 # This can be found from target.outputs.
1139 for out in target.outputs:
1140 if out.endswith(file_name):
1141 new_args.append('$(location %s)' % out)
1142 else:
1143 new_args.append(arg)
1144
1145 target.args = new_args
Mohannad Farrag7ff99912022-11-29 17:16:00 +00001146 return create_action_module(blueprint, target, 'cc_genrule')
Motomu Utsumia6c33152022-11-02 18:21:55 +09001147
Motomu Utsumi877e6f02022-12-16 17:53:51 +09001148def create_action_module_internal(target, type, arch=None):
Motomu Utsumi0facea52022-12-16 17:25:30 +09001149 sanitizer = get_action_sanitizer(target, type, arch)
Motomu Utsumicdb45ea2022-12-02 17:05:07 +09001150 sanitizer.sanitize()
Motomu Utsumi47fd40a2022-12-05 15:07:31 +09001151
Mohannad Farrag7f7c9b42022-12-02 14:37:56 +00001152 module = Module(type, sanitizer.get_name(), target.name)
Mohannad Farragc739dda2022-12-02 15:43:46 +00001153 module.cmd = sanitizer.get_cmd()
Motomu Utsumi24213232022-12-02 16:04:05 +09001154 module.out = sanitizer.get_outputs()
Motomu Utsumi7db75832022-12-02 16:46:22 +09001155 if sanitizer.is_header_generated():
1156 module.genrule_headers.add(module.name)
Motomu Utsumi80fa0b02022-12-05 12:50:57 +09001157 module.srcs = sanitizer.get_srcs()
Motomu Utsumiaaf42cf2022-12-05 12:55:02 +09001158 module.tool_files = sanitizer.get_tool_files()
Patrick Rohr9b99a982022-10-28 11:00:57 -07001159
Patrick Rohre1a853e2022-10-26 12:31:39 -07001160 return module
1161
Motomu Utsumi170cc2d2022-12-16 17:31:28 +09001162def get_cmd_condition(arch):
1163 '''
1164 :param arch: archtecture name e.g. android_x86_64, android_arm64
1165 :return: condition that can be used in cc_genrule cmd to switch the behavior based on arch
1166 '''
1167 if arch == "android_x86_64":
1168 return "( $$CC_ARCH == 'x86_64' && $$CC_OS == 'android' )"
1169 elif arch == "android_x86":
1170 return "( $$CC_ARCH == 'x86' && $$CC_OS == 'android' )"
1171 elif arch == "android_arm":
1172 return "( $$CC_ARCH == 'arm' && $$CC_OS == 'android' )"
1173 elif arch == "android_arm64":
1174 return "( $$CC_ARCH == 'arm64' && $$CC_OS == 'android' )"
1175 elif arch == "host":
1176 return "$$CC_OS != 'android'"
1177 else:
1178 raise Error(f'Unknown architecture type {arch}')
Patrick Rohre1a853e2022-10-26 12:31:39 -07001179
Motomu Utsumid32f9aa2022-12-16 17:41:26 +09001180def merge_cmd(modules, genrule_type):
1181 '''
1182 :param modules: dictionary whose key is arch name and value is module
1183 :param genrule_type: cc_genrule or java_genrule
1184 :return: merged command or common command if all the archs have the same command.
1185 '''
1186 commands = list({module.cmd for module in modules.values()})
1187 if len(commands) == 1:
1188 # If all the archs have the same command, return the command
1189 return commands[0]
1190
1191 if genrule_type != 'cc_genrule':
1192 raise Error(f'{genrule_type} can not have different cmd between archs')
1193
1194 merged_cmd = []
1195 for arch, module in modules.items():
1196 merged_cmd.append(f'if [[ {get_cmd_condition(arch)} ]];')
1197 merged_cmd.append('then')
1198 merged_cmd.append(module.cmd + ';')
1199 merged_cmd.append('fi;')
1200 return NEWLINE.join(merged_cmd)
Patrick Rohr92d74122022-10-21 15:50:52 -07001201
Motomu Utsumi822bfc42022-12-16 17:48:00 +09001202def merge_modules(modules, genrule_type):
1203 '''
1204 :param modules: dictionary whose key is arch name and value is module
1205 :param genrule_type: cc_genrule or java_genrule
1206 :return: merged module of input modules
1207 '''
1208 merged_module = list(modules.values())[0]
1209
1210 # Following attributes must be the same between archs
1211 for key in ('out', 'genrule_headers', 'srcs', 'tool_files'):
1212 if any([getattr(merged_module, key) != getattr(module, key) for module in modules.values()]):
1213 raise Error(f'{merged_module.name} has different values for {key} between archs')
1214
1215 merged_module.cmd = merge_cmd(modules, genrule_type)
1216 return merged_module
1217
Motomu Utsumi877e6f02022-12-16 17:53:51 +09001218def create_action_module(blueprint, target, genrule_type):
1219 '''
1220 Create module for action target and add to the blueprint. If target has arch specific attributes
1221 this function merge them and create a single module.
1222 :param blueprint:
1223 :param target: target which is converted to the module.
1224 :param genrule_type: cc_genrule or java_genrule
1225 :return: created module
1226 '''
Motomu Utsumi3029ac92022-12-16 18:04:57 +09001227 # TODO: Handle this target correctly, this target generates java_genrule but this target has
1228 # different value for cpu-family arg between archs
1229 if target.name == '//build/android:native_libraries_gen':
1230 module = create_action_module_internal(target, genrule_type, target.arch['android_arm'])
1231 blueprint.add_module(module)
1232 return module
1233
Motomu Utsumi877e6f02022-12-16 17:53:51 +09001234 modules = {arch_name: create_action_module_internal(target, genrule_type, arch)
1235 for arch_name, arch in target.arch.items()}
1236 module = merge_modules(modules, genrule_type)
1237 blueprint.add_module(module)
1238 return module
1239
1240
Motomu Utsumic34b1372022-11-17 22:15:51 +09001241def _get_cflags(cflags, defines):
1242 cflags = {flag for flag in cflags if flag in cflag_allowlist}
Motomu Utsumifa7e9262022-10-26 19:43:02 +09001243 # Consider proper allowlist or denylist if needed
Motomu Utsumic34b1372022-11-17 22:15:51 +09001244 cflags |= set("-D%s" % define.replace("\"", "\\\"") for define in defines)
Patrick Rohr92d74122022-10-21 15:50:52 -07001245 return cflags
1246
Motomu Utsumic34b1372022-11-17 22:15:51 +09001247def set_module_flags(module, cflags, defines):
1248 module.cflags.update(_get_cflags(cflags, defines))
1249 # TODO: implement proper cflag parsing.
1250 for flag in cflags:
1251 if '-std=' in flag:
1252 module.cpp_std = flag[len('-std='):]
Motomu Utsumic34b1372022-11-17 22:15:51 +09001253 if '-fexceptions' in flag:
1254 module.cppflags.add('-fexceptions')
Patrick Rohr92d74122022-10-21 15:50:52 -07001255
Motomu Utsumi88efbb42022-11-17 22:18:15 +09001256def set_module_include_dirs(module, cflags, include_dirs):
Motomu Utsumi88efbb42022-11-17 22:18:15 +09001257 for flag in cflags:
1258 if '-isystem' in flag:
Patrick Rohr3cd5ffb2022-11-18 17:40:55 -08001259 module.local_include_dirs.add(flag[len('-isystem../../'):])
Motomu Utsumi88efbb42022-11-17 22:18:15 +09001260
1261 # Adding local_include_dirs is necessary due to source_sets / filegroups
1262 # which do not properly propagate include directories.
1263 # Filter any directory inside //out as a) this directory does not exist for
1264 # aosp / soong builds and b) the include directory should already be
1265 # configured via library dependency.
Patrick Rohr3cd5ffb2022-11-18 17:40:55 -08001266 module.local_include_dirs.update([gn_utils.label_to_path(d)
Motomu Utsumi7841c802023-01-06 11:46:14 +09001267 for d in include_dirs if not d.startswith('//out')])
Patrick Rohr9d7539e2022-12-14 19:31:33 -08001268 # Remove prohibited include directories
1269 module.local_include_dirs = [d for d in module.local_include_dirs
1270 if d not in local_include_dirs_denylist]
1271
Motomu Utsumi88efbb42022-11-17 22:18:15 +09001272
Patrick Rohr92d74122022-10-21 15:50:52 -07001273def create_modules_from_target(blueprint, gn, gn_target_name):
1274 """Generate module(s) for a given GN target.
1275
1276 Given a GN target name, generate one or more corresponding modules into a
1277 blueprint. The only case when this generates >1 module is proto libraries.
1278
1279 Args:
1280 blueprint: Blueprint instance which is being generated.
1281 gn: gn_utils.GnParser object.
1282 gn_target_name: GN target for module generation.
1283 """
1284 bp_module_name = label_to_module_name(gn_target_name)
1285 if bp_module_name in blueprint.modules:
1286 return blueprint.modules[bp_module_name]
1287 target = gn.get_target(gn_target_name)
Patrick Rohr16228942022-10-26 14:00:26 -07001288 log.info('create modules for %s (%s)', target.name, target.type)
Patrick Rohr92d74122022-10-21 15:50:52 -07001289
Patrick Rohr92d74122022-10-21 15:50:52 -07001290 if target.type == 'executable':
Patrick Rohrc8f41cd2022-11-15 22:46:10 -08001291 if target.testonly:
Patrick Rohr92d74122022-10-21 15:50:52 -07001292 module_type = 'cc_test'
1293 else:
Patrick Rohrc8f41cd2022-11-15 22:46:10 -08001294 # Can be used for both host and device targets.
Patrick Rohr92d74122022-10-21 15:50:52 -07001295 module_type = 'cc_binary'
1296 module = Module(module_type, bp_module_name, gn_target_name)
1297 elif target.type == 'static_library':
1298 module = Module('cc_library_static', bp_module_name, gn_target_name)
1299 elif target.type == 'shared_library':
1300 module = Module('cc_library_shared', bp_module_name, gn_target_name)
1301 elif target.type == 'source_set':
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001302 module = Module('cc_object', bp_module_name, gn_target_name)
Patrick Rohr92d74122022-10-21 15:50:52 -07001303 elif target.type == 'group':
1304 # "group" targets are resolved recursively by gn_utils.get_target().
1305 # There's nothing we need to do at this level for them.
1306 return None
1307 elif target.type == 'proto_library':
1308 module = create_proto_modules(blueprint, gn, target)
1309 if module is None:
1310 return None
1311 elif target.type == 'action':
Mohannad Farrag4b89a822022-12-02 14:25:44 +00001312 module = create_action_module(blueprint, target, 'cc_genrule')
Mohannad Farragf076f3e2022-10-31 17:45:28 +00001313 elif target.type == 'action_foreach':
Mohannad Farragbab6c892022-11-02 14:09:46 +00001314 module = create_action_foreach_modules(blueprint, target)
Patrick Rohr59a76652022-10-26 12:36:56 -07001315 elif target.type == 'copy':
1316 # TODO: careful now! copy targets are not supported yet, but this will stop
1317 # traversing the dependency tree. For //base:base, this is not a big
1318 # problem as libicu contains the only copy target which happens to be a
1319 # leaf node.
1320 return None
Patrick Rohrad440602022-11-10 22:09:04 -08001321 elif target.type == 'java_group':
1322 # Java targets are handled outside of create_modules_from_target.
1323 return None
Patrick Rohr92d74122022-10-21 15:50:52 -07001324 else:
1325 raise Error('Unknown target %s (%s)' % (target.name, target.type))
1326
1327 blueprint.add_module(module)
Patrick Rohr92d74122022-10-21 15:50:52 -07001328 module.init_rc = target_initrc.get(target.name, [])
Motomu Utsumi4424f342023-01-06 11:42:36 +09001329 module.srcs.update(gn_utils.label_to_path(src)
1330 for src in target.sources if is_supported_source_file(src))
Patrick Rohr92d74122022-10-21 15:50:52 -07001331
Patrick Rohr3b5ff762022-11-16 10:22:16 -08001332 # Add arch-specific properties
1333 for arch_name, arch in target.arch.items():
Motomu Utsumi4424f342023-01-06 11:42:36 +09001334 module.target[arch_name].srcs.update(gn_utils.label_to_path(src)
1335 for src in arch.sources if is_supported_source_file(src))
Patrick Rohr3b5ff762022-11-16 10:22:16 -08001336
Mohannad Farragbaf0d572022-11-22 11:53:54 +00001337 module.rtti = target.rtti
1338
Patrick Rohr92d74122022-10-21 15:50:52 -07001339 if target.type in gn_utils.LINKER_UNIT_TYPES:
Motomu Utsumic34b1372022-11-17 22:15:51 +09001340 set_module_flags(module, target.cflags, target.defines)
Motomu Utsumi88efbb42022-11-17 22:18:15 +09001341 set_module_include_dirs(module, target.cflags, target.include_dirs)
Motomu Utsumif0f47682022-11-17 22:34:39 +09001342 # TODO: set_module_xxx is confusing, apply similar function to module and target in better way.
1343 for arch_name, arch in target.arch.items():
1344 set_module_flags(module.target[arch_name], arch.cflags, arch.defines)
Motomu Utsumi3371d682022-11-28 16:56:52 +09001345 # -Xclang -target-feature -Xclang +mte are used to enable MTE (Memory Tagging Extensions).
1346 # Flags which does not start with '-' could not be in the cflags so enabling MTE by
1347 # -march and -mcpu Feature Modifiers. MTE is only available on arm64. This is needed for
1348 # building //base/allocator/partition_allocator:partition_alloc for arm64.
1349 if '+mte' in arch.cflags and arch_name == 'android_arm64':
1350 module.target[arch_name].cflags.add('-march=armv8-a+memtag')
Motomu Utsumif0f47682022-11-17 22:34:39 +09001351 set_module_include_dirs(module.target[arch_name], arch.cflags, arch.include_dirs)
Patrick Rohr92d74122022-10-21 15:50:52 -07001352
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001353 module.host_supported = target.host_supported()
1354 module.device_supported = target.device_supported()
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001355
Motomu Utsumi8ca12412022-11-30 16:27:30 +09001356 if module.is_genrule():
1357 module.apex_available.add(tethering_apex)
1358
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001359 if module.is_compiled():
Patrick Rohr92d74122022-10-21 15:50:52 -07001360 # Don't try to inject library/source dependencies into genrules or
1361 # filegroups because they are not compiled in the traditional sense.
1362 module.defaults = [defaults_module]
1363 for lib in target.libs:
1364 # Generally library names should be mangled as 'libXXX', unless they
1365 # are HAL libraries (e.g., android.hardware.health@2.0) or AIDL c++ / NDK
1366 # libraries (e.g. "android.hardware.power.stats-V1-cpp")
1367 android_lib = lib if '@' in lib or "-cpp" in lib or "-ndk" in lib \
1368 else 'lib' + lib
1369 if lib in shared_library_allowlist:
1370 module.add_android_shared_lib(android_lib)
1371 if lib in static_library_allowlist:
1372 module.add_android_static_lib(android_lib)
1373
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001374 # If the module is a static library, export all the generated headers.
1375 if module.type == 'cc_library_static':
1376 module.export_generated_headers = module.generated_headers
1377
Motomu Utsumiee47af62022-11-30 16:41:15 +09001378 if module.name == 'cronet_aml_components_cronet_android_cronet':
1379 if target.output_name is None:
1380 raise Error('Failed to get output_name for libcronet name')
1381 # .so file name needs to match with CronetLibraryLoader.java (e.g. libcronet.109.0.5386.0.so)
1382 # So setting the output name based on the output_name from the desc.json
1383 module.stem = 'lib' + target.output_name
1384
Patrick Rohr92d74122022-10-21 15:50:52 -07001385 # dep_name is an unmangled GN target name (e.g. //foo:bar(toolchain)).
Motomu Utsumif1daa232022-11-08 13:28:37 +09001386 # Currently, only one module is generated from target even target has multiple toolchains.
1387 # And module is generated based on the first visited target.
1388 # Sort deps before iteration to make result deterministic.
1389 all_deps = sorted(target.deps | target.source_set_deps | target.transitive_proto_deps)
Patrick Rohr92d74122022-10-21 15:50:52 -07001390 for dep_name in all_deps:
Patrick Rohr5cc46e02022-10-26 14:32:45 -07001391 # |builtin_deps| override GN deps with Android-specific ones. See the
1392 # config in the top of this file.
Patrick Rohr07876662022-11-15 22:55:23 -08001393 if dep_name in builtin_deps:
Patrick Rohr25926e62022-12-14 19:55:57 -08001394 builtin_deps[dep_name](module, None)
Patrick Rohr5cc46e02022-10-26 14:32:45 -07001395 continue
1396
Patrick Rohr92d74122022-10-21 15:50:52 -07001397 dep_module = create_modules_from_target(blueprint, gn, dep_name)
1398
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001399 if dep_module is None:
1400 continue
Motomu Utsumie246feb2022-11-01 17:25:56 +09001401 # TODO: Proper dependency check for genrule.
1402 # Currently, only propagating genrule dependencies.
1403 # Also, currently, all the dependencies are propagated upwards.
1404 # in gn, public_deps should be propagated but deps should not.
1405 # Not sure this information is available in the desc.json.
1406 # Following rule works for adding android_runtime_jni_headers to base:base.
1407 # If this doesn't work for other target, hardcoding for specific target
1408 # might be better.
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001409 if module.is_genrule() and dep_module.is_genrule():
1410 module.genrule_headers.add(dep_module.name)
1411 module.genrule_headers.update(dep_module.genrule_headers)
Motomu Utsumie246feb2022-11-01 17:25:56 +09001412
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001413 # For filegroups, and genrule, recurse but don't apply the
Patrick Rohra6ce0232022-11-16 22:09:01 -08001414 # deps.
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001415 if not module.is_compiled() or module.is_genrule():
Patrick Rohr92d74122022-10-21 15:50:52 -07001416 continue
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001417
Patrick Rohr92d74122022-10-21 15:50:52 -07001418 if dep_module.type == 'cc_library_shared':
1419 module.shared_libs.add(dep_module.name)
1420 elif dep_module.type == 'cc_library_static':
1421 module.static_libs.add(dep_module.name)
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001422 elif dep_module.type == 'cc_object':
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001423 module.merge_attribute('generated_headers', dep_module, target.arch.keys())
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001424 if module.type != 'cc_object':
1425 if dep_module.has_input_files():
1426 # Only add it as part of srcs if the dep_module has input files otherwise
1427 # this would throw an error.
1428 module.srcs.add(":" + dep_module.name)
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001429 module.merge_attribute('export_generated_headers', dep_module,
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001430 target.arch.keys(), 'generated_headers')
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001431 elif dep_module.type == 'cc_genrule':
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001432 module.merge_attribute('generated_headers', dep_module, [], 'genrule_headers')
1433 module.merge_attribute('srcs', dep_module, [], 'genrule_srcs')
1434 module.merge_attribute('shared_libs', dep_module, [], 'genrule_shared_libs')
1435 module.merge_attribute('header_libs', dep_module, [], 'genrule_header_libs')
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001436 if module.type not in ["cc_object"]:
Mohannad Farragf2391cc2022-11-29 13:26:32 +00001437 module.merge_attribute('export_generated_headers', dep_module, [],
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001438 'genrule_headers')
Patrick Rohr92d74122022-10-21 15:50:52 -07001439 elif dep_module.type == 'cc_binary':
1440 continue # Ignore executables deps (used by cmdline integration tests).
1441 else:
1442 raise Error('Unknown dep %s (%s) for target %s' %
1443 (dep_module.name, dep_module.type, module.name))
1444
Patrick Rohrb51878f2022-11-16 23:49:03 -08001445 for arch_name, arch in target.arch.items():
1446 for dep_name in arch.deps:
Patrick Rohr25926e62022-12-14 19:55:57 -08001447 # |builtin_deps| override GN deps with Android-specific ones. See the
1448 # config in the top of this file.
1449 if dep_name in builtin_deps:
1450 builtin_deps[dep_name](module, arch_name)
1451 continue
Patrick Rohrb51878f2022-11-16 23:49:03 -08001452 dep_module = create_modules_from_target(blueprint, gn, dep_name)
1453 # Arch-specific dependencies currently only include cc_library_static.
1454 # Revisit this approach once we need to support more target types.
1455 if dep_module.type == 'cc_library_static':
1456 module.target[arch_name].static_libs.add(dep_module.name)
Mohannad Farrag1de6cb12022-11-28 12:27:26 +00001457 elif dep_module.type == 'cc_genrule':
1458 if dep_module.name.endswith(arch_name):
1459 module.target[arch_name].generated_headers.update(dep_module.genrule_headers)
1460 module.target[arch_name].srcs.update(dep_module.genrule_srcs)
1461 module.target[arch_name].shared_libs.update(dep_module.genrule_shared_libs)
1462 module.target[arch_name].header_libs.update(dep_module.genrule_header_libs)
1463 if module.type not in ["cc_object"]:
1464 module.target[arch_name].export_generated_headers.update(
1465 dep_module.genrule_headers)
Patrick Rohr70695562022-12-14 19:45:34 -08001466 elif dep_module.type == 'cc_object':
1467 if dep_module.has_input_files():
1468 # Only add it as part of srcs if the dep_module has input files otherwise
1469 # this would throw an error.
1470 module.target[arch_name].srcs.add(":" + dep_module.name)
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001471 else:
1472 raise Error('Unsupported arch-specific dependency %s of target %s with type %s' %
1473 (dep_module.name, target.name, dep_module.type))
Patrick Rohr92d74122022-10-21 15:50:52 -07001474 return module
1475
Mohannad Farrag3d3d6132022-12-06 18:11:48 +00001476def create_java_jni_preprocessor(blueprint):
1477 bp_module_name = module_prefix + 'java_jni_annotation_preprocessor'
1478 module = Module('java_plugin', bp_module_name, '//base/android/jni_generator:jni_processor')
1479 module.srcs.update(
1480 [
1481 "base/android/jni_generator/java/src/org/chromium/jni_generator/JniProcessor.java",
1482 # Avoids a circular dependency with base:base_java. This is okay because
1483 # no target should ever expect to package an annotation processor.
1484 "build/android/java/src/org/chromium/build/annotations/CheckDiscard.java",
1485 "build/android/java/src/org/chromium/build/annotations/MainDex.java",
Mohannad Farrag89f38e42022-12-06 18:54:46 +00001486 "base/android/java/src/org/chromium/base/JniStaticTestMocker.java",
1487 "base/android/java/src/org/chromium/base/NativeLibraryLoadedStatus.java",
1488 "base/android/java/src/org/chromium/base/annotations/NativeMethods.java",
1489 "base/android/java/src/org/chromium/base/JniException.java",
1490 ":cronet_aml_build_android_build_config_gen",
Mohannad Farrag3d3d6132022-12-06 18:11:48 +00001491 ])
Mohannad Farrag89f38e42022-12-06 18:54:46 +00001492 module.static_libs.update({
1493 "javapoet",
1494 "guava",
1495 "auto_service_annotations",
1496 })
1497 module.processor_class = "org.chromium.jni_generator.JniProcessor"
Mohannad Farrag3d3d6132022-12-06 18:11:48 +00001498 blueprint.add_module(module)
1499 return module
1500
Motomu Utsumi1002cd82022-12-23 17:19:03 +09001501def get_java_sources(gn, predicate):
Motomu Utsumiea729d32022-12-23 17:06:41 +09001502 java_sources = set()
Motomu Utsumi1002cd82022-12-23 17:19:03 +09001503 for target_name, sources in gn.java_sources.items():
1504 if predicate(target_name):
1505 java_sources.update(sources)
Motomu Utsumiea729d32022-12-23 17:06:41 +09001506 return java_sources
1507
Motomu Utsumi1002cd82022-12-23 17:19:03 +09001508def get_java_actions(gn, predicate):
Motomu Utsumiea729d32022-12-23 17:06:41 +09001509 java_actions = set()
Motomu Utsumi1002cd82022-12-23 17:19:03 +09001510 for target_name, actions in gn.java_actions.items():
1511 if predicate(target_name):
1512 java_actions.update(actions)
Motomu Utsumiea729d32022-12-23 17:06:41 +09001513 return java_actions
1514
Motomu Utsumi1002cd82022-12-23 17:19:03 +09001515def get_non_api_java_sources(gn):
1516 return get_java_sources(gn, lambda name: name != java_api_target_name)
1517
1518def get_non_api_java_actions(gn):
1519 return get_java_actions(gn, lambda name: name != java_api_target_name)
1520
Motomu Utsumia0a3dbe2022-12-23 17:23:34 +09001521def get_api_java_sources(gn):
1522 return get_java_sources(gn, lambda name: name == java_api_target_name)
1523
1524def get_api_java_actions(gn):
1525 return get_java_actions(gn, lambda name: name == java_api_target_name)
1526
Patrick Rohrb18aca22022-11-04 15:07:32 -07001527def create_java_module(blueprint, gn):
1528 bp_module_name = module_prefix + 'java'
1529 module = Module('java_library', bp_module_name, '//gn:java')
Motomu Utsumi1002cd82022-12-23 17:19:03 +09001530 module.srcs.update([gn_utils.label_to_path(source) for source in get_non_api_java_sources(gn)])
Mohannad Farrage815d862022-12-06 17:51:43 +00001531 module.libs = {
Motomu Utsumidf6024d2022-12-07 16:39:11 +09001532 "androidx.annotation_annotation",
1533 "jsr305",
Motomu Utsumi05a49a52022-12-09 18:21:13 +09001534 "androidx.annotation_annotation-experimental-nodeps",
Motomu Utsumif985e032022-12-09 15:53:39 +09001535 "framework-connectivity.stubs.module_lib",
1536 "framework-connectivity-t.stubs.module_lib",
1537 "framework-tethering.stubs.module_lib",
1538 "framework-wifi.stubs.module_lib",
1539 "framework-mediaprovider.stubs.module_lib",
Mohannad Farrage815d862022-12-06 17:51:43 +00001540 }
Stefano Duo0978c072023-01-09 14:22:29 +00001541 module.static_libs = {
1542 "modules-utils-build_system",
1543 }
Mohannad Farragb30d3712022-12-06 17:27:04 +00001544 module.aidl["include_dirs"] = {"frameworks/base/core/java/"}
1545 module.aidl["local_include_dirs"] = {"base/android/java/src/"}
Motomu Utsumif985e032022-12-09 15:53:39 +09001546 module.sdk_version = "module_current"
Motomu Utsumi00bebb62023-01-16 15:12:38 +09001547 module.min_sdk_version = 30
Motomu Utsumi42acf6d2022-12-09 16:04:10 +09001548 module.apex_available.add(tethering_apex)
Patrick Rohr8d393192022-12-22 14:50:20 -08001549 # TODO: support for this flag is removed upstream in crrev/c/4062652.
1550 # Consider reverting this change upstream, or worst-case downstream. As an
1551 # alternative hack, we could rename the generated file to not conflict. This
1552 # would be less likely to conflict with upstream changes if the revert is not
1553 # accepted.
1554 module.javacflags.add("-Aorg.chromium.chrome.skipGenJni")
Mohannad Farraga4191eb2023-01-04 14:41:17 +00001555 module.javacflags.add("-Apackage_prefix=android.net.http.internal")
Motomu Utsumi1002cd82022-12-23 17:19:03 +09001556 for dep in get_non_api_java_actions(gn):
Mohannad Farrag9c2cee12022-12-06 17:11:25 +00001557 target = gn.get_target(dep)
1558 if target.script == '//build/android/gyp/gcc_preprocess.py':
1559 module.srcs.add(':' + create_gcc_preprocess_modules(blueprint, target).name)
1560 else:
1561 module.srcs.add(':' + create_action_module(blueprint, target, 'java_genrule').name)
Mohannad Farrag3d3d6132022-12-06 18:11:48 +00001562 preprocessor_module = create_java_jni_preprocessor(blueprint)
1563 module.plugins.add(preprocessor_module.name)
Patrick Rohrb18aca22022-11-04 15:07:32 -07001564 blueprint.add_module(module)
Motomu Utsumi46ec15c2022-12-23 19:41:02 +09001565 return module
Patrick Rohr92d74122022-10-21 15:50:52 -07001566
Motomu Utsumia0a3dbe2022-12-23 17:23:34 +09001567def create_java_api_module(blueprint, gn):
1568 source_module = Module('filegroup', module_prefix + 'api_sources', java_api_target_name)
Motomu Utsumi0fa31272023-01-23 12:24:23 +09001569 # TODO add the API helpers separately after the main API is checked in and thoroughly reviewed
Motomu Utsumia0a3dbe2022-12-23 17:23:34 +09001570 source_module.srcs.update([gn_utils.label_to_path(source)
Motomu Utsumi0fa31272023-01-23 12:24:23 +09001571 for source in get_api_java_sources(gn)
1572 if "apihelpers" not in source])
1573 source_module.comment += "\n// TODO(danstahr): add the API helpers separately after the main" \
1574 " API is checked in and thoroughly reviewed"
Motomu Utsumia0a3dbe2022-12-23 17:23:34 +09001575 source_module.srcs.update([
1576 ':' + create_action_module(blueprint, gn.get_target(dep), 'java_genrule').name
1577 for dep in get_api_java_actions(gn)])
1578 blueprint.add_module(source_module)
1579
Motomu Utsumi46ec15c2022-12-23 19:41:02 +09001580 java_module = Module('java_library', module_prefix + 'api_java', java_api_target_name)
1581 java_module.srcs.add(":" + source_module.name)
1582 java_module.sdk_version = "module_current"
1583 java_module.libs = {
1584 "androidx.annotation_annotation",
Motomu Utsumiffba2872023-01-23 12:15:11 +09001585 "framework-annotations-lib",
Motomu Utsumi46ec15c2022-12-23 19:41:02 +09001586 }
1587 blueprint.add_module(java_module)
1588 return java_module
1589
Patrick Rohr6ef22722022-11-18 18:24:01 -08001590def update_jni_registration_module(module, gn):
Motomu Utsumie3ce7702022-11-10 16:22:11 +09001591 # TODO: java_sources might not contain all the required java files
Motomu Utsumi47d122f2022-11-10 17:32:23 +09001592 module.srcs.update([gn_utils.label_to_path(source)
Motomu Utsumi1002cd82022-12-23 17:19:03 +09001593 for source in get_non_api_java_sources(gn)
Patrick Rohrf20b5ed2022-12-22 14:57:50 -08001594 if source.endswith('.java')])
Motomu Utsumie3ce7702022-11-10 16:22:11 +09001595
Motomu Utsumia71281c2022-11-18 15:19:00 +09001596def create_blueprint_for_targets(gn, targets):
Patrick Rohr92d74122022-10-21 15:50:52 -07001597 """Generate a blueprint for a list of GN targets."""
1598 blueprint = Blueprint()
1599
1600 # Default settings used by all modules.
1601 defaults = Module('cc_defaults', defaults_module, '//gn:default_deps')
Patrick Rohr92d74122022-10-21 15:50:52 -07001602 defaults.cflags = [
Patrick Rohr3ce74772022-11-11 14:19:58 -08001603 '-DGOOGLE_PROTOBUF_NO_RTTI',
Patrick Rohr92d74122022-10-21 15:50:52 -07001604 '-Wno-error=return-type',
Patrick Rohr3a1ec1d2022-10-31 13:30:17 -07001605 '-Wno-non-virtual-dtor',
Patrick Rohr5c700022022-11-08 19:33:07 -08001606 '-Wno-macro-redefined',
Patrick Rohr98065152022-10-31 14:49:58 -07001607 '-Wno-missing-field-initializers',
Patrick Rohr92d74122022-10-21 15:50:52 -07001608 '-Wno-sign-compare',
1609 '-Wno-sign-promo',
1610 '-Wno-unused-parameter',
Mohannad Farrag54d52442022-11-21 16:27:02 +00001611 '-Wno-null-pointer-subtraction', # Needed to libevent
Patrick Rohr92d74122022-10-21 15:50:52 -07001612 '-fvisibility=hidden',
Motomu Utsumiba020942022-11-14 15:15:41 +09001613 '-Wno-ambiguous-reversed-operator', # needed for icui18n
Motomu Utsumib1ec8782022-11-14 15:25:57 +09001614 '-Wno-unreachable-code-loop-increment', # needed for icui18n
Patrick Rohr92d74122022-10-21 15:50:52 -07001615 '-O2',
Mohannad Farrag7f29d832022-11-23 19:52:41 +00001616 '-fPIC',
Patrick Rohr92d74122022-10-21 15:50:52 -07001617 ]
Patrick Rohrc03f1bb2022-11-18 16:13:17 -08001618 # Chromium builds do not add a dependency for headers found inside the
1619 # sysroot, so they are added globally via defaults.
1620 defaults.target['android'].header_libs = [
Patrick Rohrc03f1bb2022-11-18 16:13:17 -08001621 'jni_headers',
1622 ]
Motomu Utsumidbf28632022-12-23 21:03:21 +09001623 defaults.target['android'].shared_libs = [
1624 'libmediandk'
1625 ]
Patrick Rohr5446df82022-11-18 14:54:55 -08001626 defaults.target['host'].cflags = [
1627 # -DANDROID is added by default but target.defines contain -DANDROID if
1628 # it's required. So adding -UANDROID to cancel default -DANDROID if it's
1629 # not specified.
1630 # Note: -DANDROID is not consistently applied across the chromium code
1631 # base, so it is removed unconditionally for host targets.
1632 '-UANDROID',
1633 ]
Patrick Rohr61f2acb2022-10-31 14:08:18 -07001634 defaults.stl = 'none'
Motomu Utsumi8ca12412022-11-30 16:27:30 +09001635 defaults.min_sdk_version = 29
1636 defaults.apex_available.add(tethering_apex)
Patrick Rohr92d74122022-10-21 15:50:52 -07001637 blueprint.add_module(defaults)
Patrick Rohr344b2472022-10-25 11:32:15 -07001638
Patrick Rohr92d74122022-10-21 15:50:52 -07001639 for target in targets:
1640 create_modules_from_target(blueprint, gn, target)
Patrick Rohrb18aca22022-11-04 15:07:32 -07001641
Motomu Utsumi46ec15c2022-12-23 19:41:02 +09001642 java_api_module = create_java_api_module(blueprint, gn)
1643 java_module = create_java_module(blueprint, gn)
1644 java_module.libs.add(java_api_module.name)
Patrick Rohr6ef22722022-11-18 18:24:01 -08001645 for module in blueprint.modules.values():
1646 if 'cronet_jni_registration' in module.name:
1647 update_jni_registration_module(module, gn)
Patrick Rohra7d029d2022-11-08 12:23:11 -08001648
1649 # Merge in additional hardcoded arguments.
1650 for module in blueprint.modules.values():
1651 for key, add_val in additional_args.get(module.name, []):
1652 curr = getattr(module, key)
1653 if add_val and isinstance(add_val, set) and isinstance(curr, set):
1654 curr.update(add_val)
1655 elif isinstance(add_val, str) and (not curr or isinstance(curr, str)):
1656 setattr(module, key, add_val)
1657 elif isinstance(add_val, bool) and (not curr or isinstance(curr, bool)):
1658 setattr(module, key, add_val)
1659 elif isinstance(add_val, dict) and isinstance(curr, dict):
1660 curr.update(add_val)
1661 elif isinstance(add_val, dict) and isinstance(curr, Target):
1662 curr.__dict__.update(add_val)
1663 else:
1664 raise Error('Unimplemented type %r of additional_args: %r' %
1665 (type(add_val), key))
1666
Patrick Rohr92d74122022-10-21 15:50:52 -07001667 return blueprint
1668
Mohannad Farragce711af2022-12-28 18:18:33 +00001669def create_license_module(blueprint):
1670 module = Module("license", "external_cronet_license", "LICENSE")
1671 module.license_kinds.update({
Mohannad Farragce711af2022-12-28 18:18:33 +00001672 'SPDX-license-identifier-MPL',
Mohannad Farrag0e2a1e12023-01-30 16:55:10 +00001673 'SPDX-license-identifier-MPL-1.1',
Mohannad Farragce711af2022-12-28 18:18:33 +00001674 'SPDX-license-identifier-ISC',
Mohannad Farragce711af2022-12-28 18:18:33 +00001675 'SPDX-license-identifier-AFL-2.0',
1676 'SPDX-license-identifier-MPL-2.0',
1677 'SPDX-license-identifier-BSD',
1678 'SPDX-license-identifier-Apache-2.0',
1679 'SPDX-license-identifier-BSL-1.0',
Mohannad Farragce711af2022-12-28 18:18:33 +00001680 'SPDX-license-identifier-Unicode-DFS',
1681 'SPDX-license-identifier-NCSA',
1682 'SPDX-license-identifier-OpenSSL',
1683 'SPDX-license-identifier-MIT',
1684 "SPDX-license-identifier-ICU",
Mohannad Farrag0e2a1e12023-01-30 16:55:10 +00001685 'legacy_unencumbered',
Mohannad Farragce711af2022-12-28 18:18:33 +00001686 })
1687 module.license_text.update({
1688 "LICENSE",
1689 "net/third_party/uri_template/LICENSE",
1690 "net/third_party/quiche/src/LICENSE",
1691 "base/third_party/symbolize/LICENSE",
1692 "base/third_party/superfasthash/LICENSE",
1693 "base/third_party/xdg_user_dirs/LICENSE",
1694 "base/third_party/double_conversion/LICENSE",
1695 "base/third_party/nspr/LICENSE",
1696 "base/third_party/dynamic_annotations/LICENSE",
1697 "base/third_party/icu/LICENSE",
1698 "base/third_party/valgrind/LICENSE",
1699 "third_party/brotli/LICENSE",
1700 "third_party/protobuf/LICENSE",
1701 "third_party/protobuf/third_party/utf8_range/LICENSE",
1702 "third_party/metrics_proto/LICENSE",
1703 "third_party/boringssl/src/LICENSE",
1704 "third_party/boringssl/src/third_party/googletest/LICENSE",
1705 "third_party/boringssl/src/third_party/wycheproof_testvectors/LICENSE",
1706 "third_party/boringssl/src/third_party/fiat/LICENSE",
1707 "third_party/libevent/LICENSE",
1708 "third_party/ashmem/LICENSE",
1709 "third_party/icu/LICENSE",
1710 "third_party/icu/scripts/LICENSE",
1711 "third_party/abseil-cpp/LICENSE",
1712 "third_party/modp_b64/LICENSE",
1713 })
1714 default_license = Module("package", "", "PACKAGE")
1715 default_license.default_applicable_licenses.add(module.name)
1716 blueprint.add_module(module)
1717 blueprint.add_module(default_license)
Patrick Rohr92d74122022-10-21 15:50:52 -07001718
1719def main():
1720 parser = argparse.ArgumentParser(
1721 description='Generate Android.bp from a GN description.')
1722 parser.add_argument(
Patrick Rohr92d74122022-10-21 15:50:52 -07001723 '--desc',
Motomu Utsumi879dec82022-11-18 15:25:12 +09001724 help='GN description (e.g., gn desc out --format=json --all-toolchains "//*".' +
1725 'You can specify multiple --desc options for different target_cpu',
1726 required=True,
1727 action='append'
Patrick Rohr92d74122022-10-21 15:50:52 -07001728 )
1729 parser.add_argument(
1730 '--extras',
1731 help='Extra targets to include at the end of the Blueprint file',
1732 default=os.path.join(gn_utils.repo_root(), 'Android.bp.extras'),
1733 )
1734 parser.add_argument(
1735 '--output',
1736 help='Blueprint file to create',
1737 default=os.path.join(gn_utils.repo_root(), 'Android.bp'),
1738 )
1739 parser.add_argument(
Patrick Rohr16228942022-10-26 14:00:26 -07001740 '-v',
1741 '--verbose',
1742 help='Print debug logs.',
1743 action='store_true',
1744 )
1745 parser.add_argument(
Patrick Rohr92d74122022-10-21 15:50:52 -07001746 'targets',
1747 nargs=argparse.REMAINDER,
Patrick Rohr1aa504a2022-10-25 10:30:42 -07001748 help='Targets to include in the blueprint (e.g., "//:perfetto_tests")'
1749 )
Patrick Rohr92d74122022-10-21 15:50:52 -07001750 args = parser.parse_args()
1751
Patrick Rohr16228942022-10-26 14:00:26 -07001752 if args.verbose:
1753 log.basicConfig(format='%(levelname)s:%(funcName)s:%(message)s', level=log.DEBUG)
1754
Patrick Rohrd0077b72022-11-15 12:43:26 -08001755 targets = args.targets or default_targets
Patrick Rohr0913f0b2022-12-13 09:13:20 -08001756 gn = gn_utils.GnParser(builtin_deps)
Motomu Utsumi879dec82022-11-18 15:25:12 +09001757 for desc_file in args.desc:
1758 with open(desc_file) as f:
1759 desc = json.load(f)
1760 for target in targets:
1761 gn.parse_gn_desc(desc, target)
Motomu Utsumia71281c2022-11-18 15:19:00 +09001762 blueprint = create_blueprint_for_targets(gn, targets)
Patrick Rohr92d74122022-10-21 15:50:52 -07001763 project_root = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
1764 tool_name = os.path.relpath(os.path.abspath(__file__), project_root)
1765
Patrick Rohr92d74122022-10-21 15:50:52 -07001766 # Add any proto groups to the blueprint.
1767 for l_name, t_names in proto_groups.items():
1768 create_proto_group_modules(blueprint, gn, l_name, t_names)
Mohannad Farragce711af2022-12-28 18:18:33 +00001769 create_license_module(blueprint)
Patrick Rohr92d74122022-10-21 15:50:52 -07001770 output = [
Patrick Rohr5478b392022-10-25 09:58:50 -07001771 """// Copyright (C) 2022 The Android Open Source Project
Patrick Rohr92d74122022-10-21 15:50:52 -07001772//
1773// Licensed under the Apache License, Version 2.0 (the "License");
1774// you may not use this file except in compliance with the License.
1775// You may obtain a copy of the License at
1776//
1777// http://www.apache.org/licenses/LICENSE-2.0
1778//
1779// Unless required by applicable law or agreed to in writing, software
1780// distributed under the License is distributed on an "AS IS" BASIS,
1781// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1782// See the License for the specific language governing permissions and
1783// limitations under the License.
1784//
1785// This file is automatically generated by %s. Do not edit.
1786""" % (tool_name)
1787 ]
1788 blueprint.to_string(output)
Patrick Rohrcb98e9b2022-10-25 09:57:02 -07001789 if os.path.exists(args.extras):
1790 with open(args.extras, 'r') as r:
1791 for line in r:
1792 output.append(line.rstrip("\n\r"))
Patrick Rohr92d74122022-10-21 15:50:52 -07001793
1794 out_files = []
1795
1796 # Generate the Android.bp file.
1797 out_files.append(args.output + '.swp')
1798 with open(out_files[-1], 'w') as f:
1799 f.write('\n'.join(output))
1800 # Text files should have a trailing EOL.
1801 f.write('\n')
1802
Patrick Rohr94693eb2022-10-25 10:09:16 -07001803 return 0
Patrick Rohr92d74122022-10-21 15:50:52 -07001804
1805
1806if __name__ == '__main__':
1807 sys.exit(main())