Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1 | #!/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 | |
| 28 | import argparse |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 29 | import json |
Patrick Rohr | 1622894 | 2022-10-26 14:00:26 -0700 | [diff] [blame] | 30 | import logging as log |
Patrick Rohr | 3a2c3dd | 2022-11-29 22:29:36 -0800 | [diff] [blame] | 31 | import operator |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 32 | import os |
| 33 | import re |
| 34 | import sys |
Motomu Utsumi | c6277d9 | 2022-11-07 15:15:17 +0900 | [diff] [blame] | 35 | import copy |
Mohannad Farrag | 9c2cee1 | 2022-12-06 17:11:25 +0000 | [diff] [blame] | 36 | from pathlib import Path |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 37 | |
| 38 | import gn_utils |
| 39 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 40 | ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) |
| 41 | |
Patrick Rohr | 0629636 | 2022-11-10 21:37:33 -0800 | [diff] [blame] | 42 | # Default targets to translate to the blueprint file. |
| 43 | default_targets = [ |
| 44 | '//components/cronet/android:cronet', |
Motomu Utsumi | abbfdc3 | 2022-11-25 12:19:23 +0900 | [diff] [blame] | 45 | '//components/cronet:cronet_package', |
Patrick Rohr | 0629636 | 2022-11-10 21:37:33 -0800 | [diff] [blame] | 46 | ] |
| 47 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 48 | # Defines a custom init_rc argument to be applied to the corresponding output |
| 49 | # blueprint target. |
| 50 | target_initrc = { |
Patrick Rohr | c36ef42 | 2022-10-25 10:38:05 -0700 | [diff] [blame] | 51 | # TODO: this can probably be removed. |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 52 | } |
| 53 | |
| 54 | target_host_supported = [ |
Patrick Rohr | dc38394 | 2022-10-25 10:45:29 -0700 | [diff] [blame] | 55 | # TODO: remove if this is not useful for the cronet build. |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 56 | ] |
| 57 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 58 | # Proto target groups which will be made public. |
| 59 | proto_groups = { |
Patrick Rohr | 95212a2 | 2022-10-25 09:53:13 -0700 | [diff] [blame] | 60 | # TODO: remove if this is not used for the cronet build. |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 61 | } |
| 62 | |
| 63 | # All module names are prefixed with this string to avoid collisions. |
Patrick Rohr | 61b2bad | 2022-10-25 10:49:20 -0700 | [diff] [blame] | 64 | module_prefix = 'cronet_aml_' |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 65 | |
| 66 | # Shared libraries which are directly translated to Android system equivalents. |
| 67 | shared_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. |
| 90 | static_library_allowlist = [ |
| 91 | 'statslog_perfetto', |
| 92 | ] |
| 93 | |
Patrick Rohr | d9dd3b9 | 2022-11-09 16:15:30 -0800 | [diff] [blame] | 94 | # Include directories that will be removed from all targets. |
| 95 | local_include_dirs_denylist = [ |
Patrick Rohr | d9dd3b9 | 2022-11-09 16:15:30 -0800 | [diff] [blame] | 96 | ] |
| 97 | |
Patrick Rohr | 10b746f | 2022-12-14 20:08:43 -0800 | [diff] [blame] | 98 | android_include_dirs_denylist = [ |
Patrick Rohr | feed223 | 2022-12-15 11:38:12 -0800 | [diff] [blame] | 99 | 'third_party/brotli/include/', |
Patrick Rohr | 10b746f | 2022-12-14 20:08:43 -0800 | [diff] [blame] | 100 | 'third_party/zlib/', |
| 101 | ] |
| 102 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 103 | # Name of the module which settings such as compiler flags for all other |
| 104 | # modules. |
| 105 | defaults_module = module_prefix + 'defaults' |
| 106 | |
| 107 | # Location of the project in the Android source tree. |
Patrick Rohr | 76ceeb5 | 2022-11-07 14:18:58 -0800 | [diff] [blame] | 108 | tree_path = 'external/chromium_org' |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 109 | |
| 110 | # Path for the protobuf sources in the standalone build. |
| 111 | buildtools_protobuf_src = '//buildtools/protobuf/src' |
| 112 | |
| 113 | # Location of the protobuf src dir in the Android source tree. |
| 114 | android_protobuf_src = 'external/protobuf/src' |
| 115 | |
Mohannad Farrag | c739dda | 2022-12-02 15:43:46 +0000 | [diff] [blame] | 116 | # put all args on a new line for better diffs. |
| 117 | NEWLINE = ' " +\n "' |
Mohannad Farrag | 00ecfb5 | 2022-12-02 14:44:15 +0000 | [diff] [blame] | 118 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 119 | # Compiler flags which are passed through to the blueprint. |
Motomu Utsumi | c8b7bea | 2022-11-16 18:12:44 +0900 | [diff] [blame] | 120 | cflag_allowlist = [ |
Motomu Utsumi | cf68d73 | 2022-11-16 18:15:21 +0900 | [diff] [blame] | 121 | # needed for zlib:zlib |
| 122 | "-mpclmul", |
| 123 | # needed for zlib:zlib |
| 124 | "-mssse3", |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 125 | # needed for zlib:zlib |
| 126 | "-msse3", |
| 127 | # needed for zlib:zlib |
| 128 | "-msse4.2", |
Motomu Utsumi | c8b7bea | 2022-11-16 18:12:44 +0900 | [diff] [blame] | 129 | ] |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 130 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 131 | # Additional arguments to apply to Android.bp rules. |
| 132 | additional_args = { |
Patrick Rohr | 2267a0a | 2022-11-08 18:59:34 -0800 | [diff] [blame] | 133 | # TODO: remove if not needed. |
Patrick Rohr | d90025f | 2022-11-11 14:18:35 -0800 | [diff] [blame] | 134 | 'cronet_aml_components_cronet_android_cronet': [ |
| 135 | ('linker_scripts', { |
| 136 | 'base/android/library_loader/anchor_functions.lds', |
| 137 | }), |
| 138 | ], |
Patrick Rohr | bb0956e | 2022-11-09 15:37:16 -0800 | [diff] [blame] | 139 | 'cronet_aml_net_net': [ |
Patrick Rohr | 9f4d3e3 | 2022-11-09 16:37:31 -0800 | [diff] [blame] | 140 | ('export_static_lib_headers', { |
| 141 | 'cronet_aml_net_third_party_quiche_quiche', |
| 142 | 'cronet_aml_crypto_crypto', |
| 143 | }), |
Mohannad Farrag | 37388fa | 2022-11-10 20:42:13 +0000 | [diff] [blame] | 144 | ], |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 145 | } |
| 146 | |
Patrick Rohr | feed223 | 2022-12-15 11:38:12 -0800 | [diff] [blame] | 147 | def enable_brotli(module, arch): |
| 148 | # Requires crrev/c/4111690 |
| 149 | if arch is None: |
| 150 | module.static_libs.add('libbrotli') |
| 151 | else: |
| 152 | module.arch[arch].static_libs.add('libbrotli') |
| 153 | |
Patrick Rohr | ce21088 | 2022-12-15 16:24:39 -0800 | [diff] [blame] | 154 | def enable_modp_b64(module, arch): |
| 155 | # Requires crrev/c/4112845 |
| 156 | # Requires aosp/2359455 |
| 157 | # Requires aosp/2359456 |
| 158 | if not module.is_compiled(): |
| 159 | return |
| 160 | if arch is None: |
| 161 | module.static_libs.add('libmodpb64') |
| 162 | else: |
| 163 | module.arch[arch].static_libs.add('libmodpb64') |
Patrick Rohr | feed223 | 2022-12-15 11:38:12 -0800 | [diff] [blame] | 164 | |
Patrick Rohr | 10b746f | 2022-12-14 20:08:43 -0800 | [diff] [blame] | 165 | def enable_zlib(module, arch): |
| 166 | # Requires crrev/c/4109079 |
| 167 | if arch is None: |
| 168 | module.shared_libs.add('libz') |
| 169 | else: |
| 170 | module.arch[arch].shared_libs.add('libz') |
| 171 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 172 | # Android equivalents for third-party libraries that the upstream project |
| 173 | # depends on. |
| 174 | builtin_deps = { |
Patrick Rohr | dd10b43 | 2022-12-13 14:46:16 -0800 | [diff] [blame] | 175 | '//buildtools/third_party/libunwind:libunwind': |
Patrick Rohr | 25926e6 | 2022-12-14 19:55:57 -0800 | [diff] [blame] | 176 | lambda m, a: None, # disable libunwind |
Patrick Rohr | 14ee093 | 2022-11-15 12:10:27 -0800 | [diff] [blame] | 177 | '//net/tools/root_store_tool:root_store_tool': |
Patrick Rohr | 25926e6 | 2022-12-14 19:55:57 -0800 | [diff] [blame] | 178 | lambda m, a: None, |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 179 | } |
| 180 | |
Patrick Rohr | 10b746f | 2022-12-14 20:08:43 -0800 | [diff] [blame] | 181 | android_deps = { |
Patrick Rohr | feed223 | 2022-12-15 11:38:12 -0800 | [diff] [blame] | 182 | '//third_party/brotli:common': |
| 183 | enable_brotli, |
| 184 | '//third_party/brotli:dec': |
| 185 | enable_brotli, |
Patrick Rohr | ce21088 | 2022-12-15 16:24:39 -0800 | [diff] [blame] | 186 | '//third_party/modp_b64:modp_b64': |
| 187 | enable_modp_b64, |
Patrick Rohr | 10b746f | 2022-12-14 20:08:43 -0800 | [diff] [blame] | 188 | '//third_party/zlib:zlib': |
| 189 | enable_zlib, |
| 190 | } |
| 191 | |
| 192 | # Uncomment the following lines to use Android deps rather than their Chromium |
| 193 | # equivalent: |
| 194 | #builtin_deps.update(android_deps) |
| 195 | #local_include_dirs_denylist.extend(android_include_dirs_denylist) |
| 196 | |
Motomu Utsumi | 8ca1241 | 2022-11-30 16:27:30 +0900 | [diff] [blame] | 197 | # Name of tethering apex module |
| 198 | tethering_apex = "com.android.tethering" |
| 199 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 200 | # ---------------------------------------------------------------------------- |
| 201 | # End of configuration. |
| 202 | # ---------------------------------------------------------------------------- |
| 203 | |
| 204 | |
| 205 | class Error(Exception): |
| 206 | pass |
| 207 | |
| 208 | |
| 209 | class ThrowingArgumentParser(argparse.ArgumentParser): |
| 210 | |
| 211 | def __init__(self, context): |
| 212 | super(ThrowingArgumentParser, self).__init__() |
| 213 | self.context = context |
| 214 | |
| 215 | def error(self, message): |
| 216 | raise Error('%s: %s' % (self.context, message)) |
| 217 | |
| 218 | |
| 219 | def write_blueprint_key_value(output, name, value, sort=True): |
| 220 | """Writes a Blueprint key-value pair to the output""" |
| 221 | |
| 222 | if isinstance(value, bool): |
| 223 | if value: |
| 224 | output.append(' %s: true,' % name) |
| 225 | else: |
| 226 | output.append(' %s: false,' % name) |
| 227 | return |
| 228 | if not value: |
| 229 | return |
| 230 | if isinstance(value, set): |
| 231 | value = sorted(value) |
| 232 | if isinstance(value, list): |
| 233 | output.append(' %s: [' % name) |
| 234 | for item in sorted(value) if sort else value: |
| 235 | output.append(' "%s",' % item) |
| 236 | output.append(' ],') |
| 237 | return |
| 238 | if isinstance(value, Target): |
| 239 | value.to_string(output) |
| 240 | return |
| 241 | if isinstance(value, dict): |
| 242 | kv_output = [] |
| 243 | for k, v in value.items(): |
| 244 | write_blueprint_key_value(kv_output, k, v) |
| 245 | |
| 246 | output.append(' %s: {' % name) |
| 247 | for line in kv_output: |
| 248 | output.append(' %s' % line) |
| 249 | output.append(' },') |
| 250 | return |
| 251 | output.append(' %s: "%s",' % (name, value)) |
| 252 | |
| 253 | |
| 254 | class Target(object): |
| 255 | """A target-scoped part of a module""" |
| 256 | |
| 257 | def __init__(self, name): |
| 258 | self.name = name |
Patrick Rohr | 5d399b3 | 2022-11-16 10:19:55 -0800 | [diff] [blame] | 259 | self.srcs = set() |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 260 | self.shared_libs = set() |
| 261 | self.static_libs = set() |
| 262 | self.whole_static_libs = set() |
Patrick Rohr | c03f1bb | 2022-11-18 16:13:17 -0800 | [diff] [blame] | 263 | self.header_libs = set() |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 264 | self.cflags = set() |
| 265 | self.dist = dict() |
| 266 | self.strip = dict() |
| 267 | self.stl = None |
Motomu Utsumi | 50ad217 | 2022-11-17 22:29:53 +0900 | [diff] [blame] | 268 | self.cppflags = set() |
Patrick Rohr | 3cd5ffb | 2022-11-18 17:40:55 -0800 | [diff] [blame] | 269 | self.local_include_dirs = set() |
Patrick Rohr | 8143516 | 2022-11-17 19:34:32 -0800 | [diff] [blame] | 270 | self.export_system_include_dirs = set() |
Mohannad Farrag | 631443e | 2022-11-21 16:17:01 +0000 | [diff] [blame] | 271 | self.generated_headers = set() |
| 272 | self.export_generated_headers = set() |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 273 | |
| 274 | def to_string(self, output): |
| 275 | nested_out = [] |
Patrick Rohr | 5d399b3 | 2022-11-16 10:19:55 -0800 | [diff] [blame] | 276 | self._output_field(nested_out, 'srcs') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 277 | self._output_field(nested_out, 'shared_libs') |
| 278 | self._output_field(nested_out, 'static_libs') |
| 279 | self._output_field(nested_out, 'whole_static_libs') |
Patrick Rohr | c03f1bb | 2022-11-18 16:13:17 -0800 | [diff] [blame] | 280 | self._output_field(nested_out, 'header_libs') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 281 | self._output_field(nested_out, 'cflags') |
| 282 | self._output_field(nested_out, 'stl') |
| 283 | self._output_field(nested_out, 'dist') |
| 284 | self._output_field(nested_out, 'strip') |
Motomu Utsumi | 50ad217 | 2022-11-17 22:29:53 +0900 | [diff] [blame] | 285 | self._output_field(nested_out, 'cppflags') |
| 286 | self._output_field(nested_out, 'local_include_dirs') |
Patrick Rohr | 8143516 | 2022-11-17 19:34:32 -0800 | [diff] [blame] | 287 | self._output_field(nested_out, 'export_system_include_dirs') |
Mohannad Farrag | 631443e | 2022-11-21 16:17:01 +0000 | [diff] [blame] | 288 | self._output_field(nested_out, 'generated_headers') |
| 289 | self._output_field(nested_out, 'export_generated_headers') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 290 | |
| 291 | if nested_out: |
| 292 | output.append(' %s: {' % self.name) |
| 293 | for line in nested_out: |
| 294 | output.append(' %s' % line) |
| 295 | output.append(' },') |
| 296 | |
| 297 | def _output_field(self, output, name, sort=True): |
| 298 | value = getattr(self, name) |
| 299 | return write_blueprint_key_value(output, name, value, sort) |
| 300 | |
| 301 | |
| 302 | class Module(object): |
| 303 | """A single module (e.g., cc_binary, cc_test) in a blueprint.""" |
| 304 | |
| 305 | def __init__(self, mod_type, name, gn_target): |
| 306 | self.type = mod_type |
| 307 | self.gn_target = gn_target |
| 308 | self.name = name |
| 309 | self.srcs = set() |
Patrick Rohr | 0787666 | 2022-11-15 22:55:23 -0800 | [diff] [blame] | 310 | self.comment = 'GN: ' + gn_target |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 311 | self.shared_libs = set() |
| 312 | self.static_libs = set() |
| 313 | self.whole_static_libs = set() |
| 314 | self.runtime_libs = set() |
| 315 | self.tools = set() |
| 316 | self.cmd = None |
| 317 | self.host_supported = False |
Patrick Rohr | cdda632 | 2022-11-15 22:44:16 -0800 | [diff] [blame] | 318 | self.device_supported = True |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 319 | self.vendor_available = False |
| 320 | self.init_rc = set() |
| 321 | self.out = set() |
| 322 | self.export_include_dirs = set() |
| 323 | self.generated_headers = set() |
| 324 | self.export_generated_headers = set() |
Patrick Rohr | bb0956e | 2022-11-09 15:37:16 -0800 | [diff] [blame] | 325 | self.export_static_lib_headers = set() |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 326 | self.defaults = set() |
| 327 | self.cflags = set() |
| 328 | self.include_dirs = set() |
Patrick Rohr | 3cd5ffb | 2022-11-18 17:40:55 -0800 | [diff] [blame] | 329 | self.local_include_dirs = set() |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 330 | self.header_libs = set() |
| 331 | self.required = set() |
Patrick Rohr | 3d8c728 | 2022-10-27 13:36:31 -0700 | [diff] [blame] | 332 | self.tool_files = set() |
Patrick Rohr | bfdc5fd | 2022-11-16 10:03:49 -0800 | [diff] [blame] | 333 | # target contains a dict of Targets indexed by os_arch. |
| 334 | # example: { 'android_x86': Target('android_x86') |
| 335 | self.target = dict() |
| 336 | self.target['android'] = Target('android') |
Patrick Rohr | 82e4074 | 2022-11-16 10:20:39 -0800 | [diff] [blame] | 337 | self.target['android_x86'] = Target('android_x86') |
| 338 | self.target['android_x86_64'] = Target('android_x86_64') |
| 339 | self.target['android_arm'] = Target('android_arm') |
| 340 | self.target['android_arm64'] = Target('android_arm64') |
Patrick Rohr | bfdc5fd | 2022-11-16 10:03:49 -0800 | [diff] [blame] | 341 | self.target['host'] = Target('host') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 342 | self.stl = None |
Patrick Rohr | b8f830a | 2022-10-31 11:18:57 -0700 | [diff] [blame] | 343 | self.cpp_std = None |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 344 | self.dist = dict() |
| 345 | self.strip = dict() |
| 346 | self.data = set() |
| 347 | self.apex_available = set() |
| 348 | self.min_sdk_version = None |
| 349 | self.proto = dict() |
Patrick Rohr | d90025f | 2022-11-11 14:18:35 -0800 | [diff] [blame] | 350 | self.linker_scripts = set() |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 351 | # The genrule_XXX below are properties that must to be propagated back |
| 352 | # on the module(s) that depend on the genrule. |
| 353 | self.genrule_headers = set() |
| 354 | self.genrule_srcs = set() |
| 355 | self.genrule_shared_libs = set() |
Patrick Rohr | a1a2787 | 2022-10-31 11:57:14 -0700 | [diff] [blame] | 356 | self.genrule_header_libs = set() |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 357 | self.version_script = None |
| 358 | self.test_suites = set() |
| 359 | self.test_config = None |
| 360 | self.stubs = {} |
Mohannad Farrag | 37388fa | 2022-11-10 20:42:13 +0000 | [diff] [blame] | 361 | self.cppflags = set() |
| 362 | self.rtti = False |
Motomu Utsumi | ee47af6 | 2022-11-30 16:41:15 +0900 | [diff] [blame] | 363 | # Name of the output. Used for setting .so file name for libcronet |
Mohannad Farrag | e815d86 | 2022-12-06 17:51:43 +0000 | [diff] [blame] | 364 | self.libs = set() |
Motomu Utsumi | ee47af6 | 2022-11-30 16:41:15 +0900 | [diff] [blame] | 365 | self.stem = None |
Motomu Utsumi | 81bb834 | 2022-12-08 11:47:42 +0900 | [diff] [blame] | 366 | self.compile_multilib = None |
Mohannad Farrag | b30d371 | 2022-12-06 17:27:04 +0000 | [diff] [blame] | 367 | self.aidl = dict() |
Mohannad Farrag | 3d3d613 | 2022-12-06 18:11:48 +0000 | [diff] [blame] | 368 | self.plugins = set() |
Mohannad Farrag | 89f38e4 | 2022-12-06 18:54:46 +0000 | [diff] [blame] | 369 | self.processor_class = None |
Motomu Utsumi | ba3be9e | 2022-12-09 15:32:12 +0900 | [diff] [blame] | 370 | self.sdk_version = None |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 371 | |
| 372 | def to_string(self, output): |
| 373 | if self.comment: |
| 374 | output.append('// %s' % self.comment) |
| 375 | output.append('%s {' % self.type) |
| 376 | self._output_field(output, 'name') |
| 377 | self._output_field(output, 'srcs') |
| 378 | self._output_field(output, 'shared_libs') |
| 379 | self._output_field(output, 'static_libs') |
| 380 | self._output_field(output, 'whole_static_libs') |
| 381 | self._output_field(output, 'runtime_libs') |
| 382 | self._output_field(output, 'tools') |
| 383 | self._output_field(output, 'cmd', sort=False) |
| 384 | if self.host_supported: |
| 385 | self._output_field(output, 'host_supported') |
Patrick Rohr | cdda632 | 2022-11-15 22:44:16 -0800 | [diff] [blame] | 386 | if not self.device_supported: |
| 387 | self._output_field(output, 'device_supported') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 388 | if self.vendor_available: |
| 389 | self._output_field(output, 'vendor_available') |
| 390 | self._output_field(output, 'init_rc') |
| 391 | self._output_field(output, 'out') |
| 392 | self._output_field(output, 'export_include_dirs') |
| 393 | self._output_field(output, 'generated_headers') |
| 394 | self._output_field(output, 'export_generated_headers') |
Patrick Rohr | bb0956e | 2022-11-09 15:37:16 -0800 | [diff] [blame] | 395 | self._output_field(output, 'export_static_lib_headers') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 396 | self._output_field(output, 'defaults') |
| 397 | self._output_field(output, 'cflags') |
| 398 | self._output_field(output, 'include_dirs') |
Patrick Rohr | 3cd5ffb | 2022-11-18 17:40:55 -0800 | [diff] [blame] | 399 | self._output_field(output, 'local_include_dirs') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 400 | self._output_field(output, 'header_libs') |
| 401 | self._output_field(output, 'required') |
| 402 | self._output_field(output, 'dist') |
| 403 | self._output_field(output, 'strip') |
| 404 | self._output_field(output, 'tool_files') |
| 405 | self._output_field(output, 'data') |
| 406 | self._output_field(output, 'stl') |
Patrick Rohr | b8f830a | 2022-10-31 11:18:57 -0700 | [diff] [blame] | 407 | self._output_field(output, 'cpp_std') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 408 | self._output_field(output, 'apex_available') |
| 409 | self._output_field(output, 'min_sdk_version') |
| 410 | self._output_field(output, 'version_script') |
| 411 | self._output_field(output, 'test_suites') |
| 412 | self._output_field(output, 'test_config') |
| 413 | self._output_field(output, 'stubs') |
| 414 | self._output_field(output, 'proto') |
Patrick Rohr | d90025f | 2022-11-11 14:18:35 -0800 | [diff] [blame] | 415 | self._output_field(output, 'linker_scripts') |
Mohannad Farrag | 37388fa | 2022-11-10 20:42:13 +0000 | [diff] [blame] | 416 | self._output_field(output, 'cppflags') |
Mohannad Farrag | e815d86 | 2022-12-06 17:51:43 +0000 | [diff] [blame] | 417 | self._output_field(output, 'libs') |
Motomu Utsumi | ee47af6 | 2022-11-30 16:41:15 +0900 | [diff] [blame] | 418 | self._output_field(output, 'stem') |
Motomu Utsumi | 81bb834 | 2022-12-08 11:47:42 +0900 | [diff] [blame] | 419 | self._output_field(output, 'compile_multilib') |
Mohannad Farrag | b30d371 | 2022-12-06 17:27:04 +0000 | [diff] [blame] | 420 | self._output_field(output, 'aidl') |
Mohannad Farrag | 3d3d613 | 2022-12-06 18:11:48 +0000 | [diff] [blame] | 421 | self._output_field(output, 'plugins') |
Mohannad Farrag | 89f38e4 | 2022-12-06 18:54:46 +0000 | [diff] [blame] | 422 | self._output_field(output, 'processor_class') |
Motomu Utsumi | ba3be9e | 2022-12-09 15:32:12 +0900 | [diff] [blame] | 423 | self._output_field(output, 'sdk_version') |
Mohannad Farrag | 37388fa | 2022-11-10 20:42:13 +0000 | [diff] [blame] | 424 | if self.rtti: |
| 425 | self._output_field(output, 'rtti') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 426 | |
| 427 | target_out = [] |
Patrick Rohr | 09ee70e | 2022-11-16 15:20:03 -0800 | [diff] [blame] | 428 | for arch, target in sorted(self.target.items()): |
Patrick Rohr | bfdc5fd | 2022-11-16 10:03:49 -0800 | [diff] [blame] | 429 | # _output_field calls getattr(self, arch). |
| 430 | setattr(self, arch, target) |
| 431 | self._output_field(target_out, arch) |
| 432 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 433 | if target_out: |
| 434 | output.append(' target: {') |
| 435 | for line in target_out: |
| 436 | output.append(' %s' % line) |
| 437 | output.append(' },') |
| 438 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 439 | output.append('}') |
| 440 | output.append('') |
| 441 | |
| 442 | def add_android_static_lib(self, lib): |
| 443 | if self.type == 'cc_binary_host': |
| 444 | raise Exception('Adding Android static lib for host tool is unsupported') |
| 445 | elif self.host_supported: |
Patrick Rohr | bfdc5fd | 2022-11-16 10:03:49 -0800 | [diff] [blame] | 446 | self.target['android'].static_libs.add(lib) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 447 | else: |
| 448 | self.static_libs.add(lib) |
| 449 | |
| 450 | def add_android_shared_lib(self, lib): |
| 451 | if self.type == 'cc_binary_host': |
| 452 | raise Exception('Adding Android shared lib for host tool is unsupported') |
| 453 | elif self.host_supported: |
Patrick Rohr | bfdc5fd | 2022-11-16 10:03:49 -0800 | [diff] [blame] | 454 | self.target['android'].shared_libs.add(lib) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 455 | else: |
| 456 | self.shared_libs.add(lib) |
| 457 | |
| 458 | def _output_field(self, output, name, sort=True): |
| 459 | value = getattr(self, name) |
| 460 | return write_blueprint_key_value(output, name, value, sort) |
| 461 | |
Patrick Rohr | a6ce023 | 2022-11-16 22:09:01 -0800 | [diff] [blame] | 462 | def is_compiled(self): |
Mohannad Farrag | 7ff9991 | 2022-11-29 17:16:00 +0000 | [diff] [blame] | 463 | return self.type not in ('cc_genrule', 'filegroup', 'java_genrule') |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 464 | |
| 465 | def is_genrule(self): |
| 466 | return self.type == "cc_genrule" |
Patrick Rohr | a6ce023 | 2022-11-16 22:09:01 -0800 | [diff] [blame] | 467 | |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 468 | def has_input_files(self): |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 469 | return len(self.srcs) > 0 or any([len(target.srcs) > 0 for target in self.target.values()]) |
| 470 | |
Mohannad Farrag | f2391cc | 2022-11-29 13:26:32 +0000 | [diff] [blame] | 471 | def merge_attribute(self, key, source_module, allowed_archs, source_key = None): |
| 472 | """ |
| 473 | Merges the value of the attribute `source_key` for the `dep_module` with |
| 474 | the value of the attribute `key` for this module. If the value of the |
| 475 | `source_key` is equal to None. Then `key` is used for both modules. |
| 476 | |
| 477 | This merges the attribute for both non-arch and archs |
| 478 | specified in `allowed_archs`. |
| 479 | :param key: The attribute used for merging in the calling module. Also |
| 480 | used for `dep_module` if the `source_key` is None. |
| 481 | :param source_module: The module where data is propagated from. |
| 482 | :param allowed_archs: A list of archs to merge the attribute on. |
| 483 | :param source_key: if the attribute merged from the `dep_module` |
| 484 | is different from the `key` |
| 485 | """ |
| 486 | if not source_key: |
| 487 | source_key = key |
| 488 | self.__dict__[key].update(source_module.__dict__[source_key]) |
| 489 | for arch_name in source_module.target.keys(): |
| 490 | if arch_name in allowed_archs: |
| 491 | self.target[arch_name].__dict__[key].update( |
| 492 | source_module.target[arch_name].__dict__[source_key]) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 493 | |
| 494 | class Blueprint(object): |
| 495 | """In-memory representation of an Android.bp file.""" |
| 496 | |
| 497 | def __init__(self): |
| 498 | self.modules = {} |
| 499 | |
| 500 | def add_module(self, module): |
| 501 | """Adds a new module to the blueprint, replacing any existing module |
| 502 | with the same name. |
| 503 | |
| 504 | Args: |
| 505 | module: Module instance. |
| 506 | """ |
| 507 | self.modules[module.name] = module |
| 508 | |
| 509 | def to_string(self, output): |
Patrick Rohr | 23f2619 | 2022-10-25 09:45:22 -0700 | [diff] [blame] | 510 | for m in sorted(self.modules.values(), key=lambda m: m.name): |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 511 | m.to_string(output) |
| 512 | |
| 513 | |
| 514 | def label_to_module_name(label): |
| 515 | """Turn a GN label (e.g., //:perfetto_tests) into a module name.""" |
Patrick Rohr | 0787666 | 2022-11-15 22:55:23 -0800 | [diff] [blame] | 516 | module = re.sub(r'^//:?', '', label) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 517 | module = re.sub(r'[^a-zA-Z0-9_]', '_', module) |
Motomu Utsumi | 3fde148 | 2022-11-14 15:55:21 +0900 | [diff] [blame] | 518 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 519 | if not module.startswith(module_prefix): |
| 520 | return module_prefix + module |
| 521 | return module |
| 522 | |
| 523 | |
| 524 | def is_supported_source_file(name): |
| 525 | """Returns True if |name| can appear in a 'srcs' list.""" |
Patrick Rohr | f9f3a99 | 2022-11-10 19:40:32 -0800 | [diff] [blame] | 526 | return os.path.splitext(name)[1] in ['.c', '.cc', '.cpp', '.java', '.proto', '.S'] |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 527 | |
| 528 | |
| 529 | def create_proto_modules(blueprint, gn, target): |
| 530 | """Generate genrules for a proto GN target. |
| 531 | |
| 532 | GN actions are used to dynamically generate files during the build. The |
| 533 | Soong equivalent is a genrule. This function turns a specific kind of |
| 534 | genrule which turns .proto files into source and header files into a pair |
| 535 | equivalent genrules. |
| 536 | |
| 537 | Args: |
| 538 | blueprint: Blueprint instance which is being generated. |
| 539 | target: gn_utils.Target object. |
| 540 | |
| 541 | Returns: |
| 542 | The source_genrule module. |
| 543 | """ |
| 544 | assert (target.type == 'proto_library') |
| 545 | |
Motomu Utsumi | bd4013f | 2022-11-17 16:06:05 +0900 | [diff] [blame] | 546 | protoc_gn_target_name = gn.get_target('//third_party/protobuf:protoc').name |
Motomu Utsumi | d58c1dc | 2022-11-16 18:04:46 +0900 | [diff] [blame] | 547 | protoc_module_name = label_to_module_name(protoc_gn_target_name) |
| 548 | tools = {protoc_module_name} |
Motomu Utsumi | d7e0e42 | 2022-11-08 17:49:52 +0900 | [diff] [blame] | 549 | cpp_out_dir = '$(genDir)/%s/%s/' % (tree_path, target.proto_in_dir) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 550 | target_module_name = label_to_module_name(target.name) |
| 551 | |
| 552 | # In GN builds the proto path is always relative to the output directory |
| 553 | # (out/tmp.xxx). |
Motomu Utsumi | d58c1dc | 2022-11-16 18:04:46 +0900 | [diff] [blame] | 554 | cmd = ['$(location %s)' % protoc_module_name] |
Motomu Utsumi | d7e0e42 | 2022-11-08 17:49:52 +0900 | [diff] [blame] | 555 | cmd += ['--proto_path=%s/%s' % (tree_path, target.proto_in_dir)] |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 556 | |
| 557 | if buildtools_protobuf_src in target.proto_paths: |
| 558 | cmd += ['--proto_path=%s' % android_protobuf_src] |
| 559 | |
| 560 | # We don't generate any targets for source_set proto modules because |
| 561 | # they will be inlined into other modules if required. |
| 562 | if target.proto_plugin == 'source_set': |
| 563 | return None |
| 564 | |
| 565 | # Descriptor targets only generate a single target. |
| 566 | if target.proto_plugin == 'descriptor': |
| 567 | out = '{}.bin'.format(target_module_name) |
| 568 | |
| 569 | cmd += ['--descriptor_set_out=$(out)'] |
| 570 | cmd += ['$(in)'] |
| 571 | |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 572 | descriptor_module = Module('cc_genrule', target_module_name, target.name) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 573 | descriptor_module.cmd = ' '.join(cmd) |
| 574 | descriptor_module.out = [out] |
| 575 | descriptor_module.tools = tools |
| 576 | blueprint.add_module(descriptor_module) |
| 577 | |
| 578 | # Recursively extract the .proto files of all the dependencies and |
| 579 | # add them to srcs. |
| 580 | descriptor_module.srcs.update( |
| 581 | gn_utils.label_to_path(src) for src in target.sources) |
| 582 | for dep in target.transitive_proto_deps: |
| 583 | current_target = gn.get_target(dep) |
| 584 | descriptor_module.srcs.update( |
| 585 | gn_utils.label_to_path(src) for src in current_target.sources) |
| 586 | |
| 587 | return descriptor_module |
| 588 | |
| 589 | # We create two genrules for each proto target: one for the headers and |
| 590 | # another for the sources. This is because the module that depends on the |
| 591 | # generated files needs to declare two different types of dependencies -- |
| 592 | # source files in 'srcs' and headers in 'generated_headers' -- and it's not |
| 593 | # valid to generate .h files from a source dependency and vice versa. |
| 594 | source_module_name = target_module_name + '_gen' |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 595 | source_module = Module('cc_genrule', source_module_name, target.name) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 596 | blueprint.add_module(source_module) |
| 597 | source_module.srcs.update( |
| 598 | gn_utils.label_to_path(src) for src in target.sources) |
| 599 | |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 600 | header_module = Module('cc_genrule', source_module_name + '_headers', |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 601 | target.name) |
| 602 | blueprint.add_module(header_module) |
| 603 | header_module.srcs = set(source_module.srcs) |
| 604 | |
| 605 | # TODO(primiano): at some point we should remove this. This was introduced |
| 606 | # by aosp/1108421 when adding "protos/" to .proto include paths, in order to |
| 607 | # avoid doing multi-repo changes and allow old clients in the android tree |
| 608 | # to still do the old #include "perfetto/..." rather than |
| 609 | # #include "protos/perfetto/...". |
| 610 | header_module.export_include_dirs = {'.', 'protos'} |
Patrick Rohr | 2267a0a | 2022-11-08 18:59:34 -0800 | [diff] [blame] | 611 | # Since the .cc file and .h get created by a different gerule target, they |
| 612 | # are not put in the same intermediate path, so local includes do not work |
| 613 | # without explictily exporting the include dir. |
| 614 | header_module.export_include_dirs.add(target.proto_in_dir) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 615 | |
Motomu Utsumi | 8ca1241 | 2022-11-30 16:27:30 +0900 | [diff] [blame] | 616 | # This function does not return header_module so setting apex_available attribute here. |
| 617 | header_module.apex_available.add(tethering_apex) |
| 618 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 619 | source_module.genrule_srcs.add(':' + source_module.name) |
| 620 | source_module.genrule_headers.add(header_module.name) |
| 621 | |
| 622 | if target.proto_plugin == 'proto': |
| 623 | suffixes = ['pb'] |
| 624 | source_module.genrule_shared_libs.add('libprotobuf-cpp-lite') |
| 625 | cmd += ['--cpp_out=lite=true:' + cpp_out_dir] |
| 626 | elif target.proto_plugin == 'protozero': |
| 627 | suffixes = ['pbzero'] |
| 628 | plugin = create_modules_from_target(blueprint, gn, protozero_plugin) |
| 629 | tools.add(plugin.name) |
| 630 | cmd += ['--plugin=protoc-gen-plugin=$(location %s)' % plugin.name] |
| 631 | cmd += ['--plugin_out=wrapper_namespace=pbzero:' + cpp_out_dir] |
| 632 | elif target.proto_plugin == 'cppgen': |
| 633 | suffixes = ['gen'] |
| 634 | plugin = create_modules_from_target(blueprint, gn, cppgen_plugin) |
| 635 | tools.add(plugin.name) |
| 636 | cmd += ['--plugin=protoc-gen-plugin=$(location %s)' % plugin.name] |
| 637 | cmd += ['--plugin_out=wrapper_namespace=gen:' + cpp_out_dir] |
| 638 | elif target.proto_plugin == 'ipc': |
| 639 | suffixes = ['ipc'] |
| 640 | plugin = create_modules_from_target(blueprint, gn, ipc_plugin) |
| 641 | tools.add(plugin.name) |
| 642 | cmd += ['--plugin=protoc-gen-plugin=$(location %s)' % plugin.name] |
| 643 | cmd += ['--plugin_out=wrapper_namespace=gen:' + cpp_out_dir] |
| 644 | else: |
| 645 | raise Error('Unsupported proto plugin: %s' % target.proto_plugin) |
| 646 | |
| 647 | cmd += ['$(in)'] |
| 648 | source_module.cmd = ' '.join(cmd) |
| 649 | header_module.cmd = source_module.cmd |
| 650 | source_module.tools = tools |
| 651 | header_module.tools = tools |
| 652 | |
| 653 | for sfx in suffixes: |
| 654 | source_module.out.update('%s/%s' % |
| 655 | (tree_path, src.replace('.proto', '.%s.cc' % sfx)) |
| 656 | for src in source_module.srcs) |
| 657 | header_module.out.update('%s/%s' % |
| 658 | (tree_path, src.replace('.proto', '.%s.h' % sfx)) |
| 659 | for src in header_module.srcs) |
| 660 | return source_module |
| 661 | |
| 662 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 663 | def create_proto_group_modules(blueprint, gn, module_name, target_names): |
| 664 | # TODO(lalitm): today, we're only adding a Java lite module because that's |
| 665 | # the only one used in practice. In the future, if we need other target types |
| 666 | # (e.g. C++, Java full etc.) add them here. |
| 667 | bp_module_name = label_to_module_name(module_name) + '_java_protos' |
| 668 | module = Module('java_library', bp_module_name, bp_module_name) |
| 669 | module.comment = f'''GN: [{', '.join(target_names)}]''' |
| 670 | module.proto = {'type': 'lite', 'canonical_path_from_root': False} |
| 671 | |
| 672 | for name in target_names: |
| 673 | target = gn.get_target(name) |
| 674 | module.srcs.update(gn_utils.label_to_path(src) for src in target.sources) |
| 675 | for dep_label in target.transitive_proto_deps: |
| 676 | dep = gn.get_target(dep_label) |
| 677 | module.srcs.update(gn_utils.label_to_path(src) for src in dep.sources) |
| 678 | |
| 679 | blueprint.add_module(module) |
| 680 | |
Mohannad Farrag | 9c2cee1 | 2022-12-06 17:11:25 +0000 | [diff] [blame] | 681 | def create_gcc_preprocess_modules(blueprint, target): |
| 682 | # gcc_preprocess.py internally execute host gcc which is not allowed in genrule. |
| 683 | # So, this function create multiple modules and realize equivalent processing |
| 684 | # TODO: Consider to support gcc_preprocess.py in different way |
| 685 | # It's not great to have genrule and cc_object in the dependency from java_library |
| 686 | assert (len(target.sources) == 1) |
| 687 | source = list(target.sources)[0] |
| 688 | assert (Path(source).suffix == '.template') |
| 689 | stem = Path(source).stem |
| 690 | |
| 691 | bp_module_name = label_to_module_name(target.name) |
| 692 | |
| 693 | # Rename .template to .cc since cc_object does not accept .template file as srcs |
| 694 | rename_module = Module('genrule', bp_module_name + '_rename', target.name) |
| 695 | rename_module.srcs.add(gn_utils.label_to_path(source)) |
| 696 | rename_module.out.add(stem + '.cc') |
| 697 | rename_module.cmd = 'cp $(in) $(out)' |
| 698 | blueprint.add_module(rename_module) |
| 699 | |
| 700 | # Preprocess template file and generates java file |
| 701 | preprocess_module = Module('cc_object', bp_module_name + '_preprocess', target.name) |
| 702 | # -E: stop after preprocessing. |
| 703 | # -P: disable line markers, i.e. '#line 309' |
| 704 | preprocess_module.cflags.update(['-E', '-P', '-DANDROID']) |
| 705 | preprocess_module.srcs.add(':' + rename_module.name) |
| 706 | defines = ['-D' + target.args[i+1] for i, arg in enumerate(target.args) if arg == '--define'] |
| 707 | preprocess_module.cflags.update(defines) |
| 708 | # HACK: Specifying compile_multilib to build cc_object only once. |
| 709 | # Without this, soong complain to genrule that depends on cc_object when built for 64bit target. |
| 710 | # It seems this is because cc object is a module with per-architecture variants and genrule is a |
| 711 | # module with default variant. For 64bit target, cc_object is built multiple times for 32/64bit |
| 712 | # modes and genrule doesn't know which one to depend on. |
Motomu Utsumi | 4fb65c7 | 2022-12-09 17:08:48 +0900 | [diff] [blame] | 713 | preprocess_module.compile_multilib = 'first' |
Mohannad Farrag | 9c2cee1 | 2022-12-06 17:11:25 +0000 | [diff] [blame] | 714 | blueprint.add_module(preprocess_module) |
| 715 | |
| 716 | # Generates srcjar using soong_zip |
| 717 | module = Module('genrule', bp_module_name, target.name) |
| 718 | module.srcs.add(':' + preprocess_module.name) |
| 719 | module.out.add(stem + '.srcjar') |
| 720 | module.cmd = NEWLINE.join([ |
| 721 | f'cp $(in) $(genDir)/{stem}.java &&', |
| 722 | f'$(location soong_zip) -o $(out) -srcjar -f $(genDir)/{stem}.java' |
| 723 | ]) |
| 724 | module.tools.add('soong_zip') |
| 725 | blueprint.add_module(module) |
| 726 | return module |
| 727 | |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 728 | |
Mohannad Farrag | 420c14e | 2022-11-30 17:13:15 +0000 | [diff] [blame] | 729 | class BaseActionSanitizer(): |
Motomu Utsumi | 0facea5 | 2022-12-16 17:25:30 +0900 | [diff] [blame] | 730 | def __init__(self, target, arch): |
Patrick Rohr | 9e414b5 | 2022-11-29 22:12:18 -0800 | [diff] [blame] | 731 | # Just to be on the safe side, create a deep-copy. |
| 732 | self.target = copy.deepcopy(target) |
Motomu Utsumi | 0facea5 | 2022-12-16 17:25:30 +0900 | [diff] [blame] | 733 | if arch: |
| 734 | # Merge arch specific attributes |
| 735 | self.target.sources |= arch.sources |
| 736 | self.target.inputs |= arch.inputs |
| 737 | self.target.outputs |= arch.outputs |
| 738 | self.target.script = self.target.script or arch.script |
| 739 | self.target.args = self.target.args or arch.args |
| 740 | self.target.response_file_contents = \ |
| 741 | self.target.response_file_contents or arch.response_file_contents |
Motomu Utsumi | 9752bd3 | 2022-12-02 15:16:55 +0900 | [diff] [blame] | 742 | self.target.args = self._normalize_args() |
| 743 | |
Mohannad Farrag | 7f7c9b4 | 2022-12-02 14:37:56 +0000 | [diff] [blame] | 744 | def get_name(self): |
| 745 | return label_to_module_name(self.target.name) |
| 746 | |
Motomu Utsumi | 9752bd3 | 2022-12-02 15:16:55 +0900 | [diff] [blame] | 747 | def _normalize_args(self): |
Patrick Rohr | 9e414b5 | 2022-11-29 22:12:18 -0800 | [diff] [blame] | 748 | # Convert ['--param=value'] to ['--param', 'value'] for consistency. |
Mohannad Farrag | 60b3770 | 2022-12-02 14:07:33 +0000 | [diff] [blame] | 749 | # Escape quotations. |
Motomu Utsumi | 9752bd3 | 2022-12-02 15:16:55 +0900 | [diff] [blame] | 750 | normalized_args = [] |
| 751 | for arg in self.target.args: |
Mohannad Farrag | 60b3770 | 2022-12-02 14:07:33 +0000 | [diff] [blame] | 752 | arg = arg.replace('"', r'\"') |
Motomu Utsumi | 1339932 | 2022-12-02 15:36:48 +0900 | [diff] [blame] | 753 | if arg.startswith('-'): |
| 754 | normalized_args.extend(arg.split('=')) |
| 755 | else: |
| 756 | normalized_args.append(arg) |
Motomu Utsumi | 9752bd3 | 2022-12-02 15:16:55 +0900 | [diff] [blame] | 757 | return normalized_args |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 758 | |
Patrick Rohr | 2cad933 | 2022-11-30 14:27:40 -0800 | [diff] [blame] | 759 | # There are three types of args: |
| 760 | # - flags (--flag) |
| 761 | # - value args (--arg value) |
| 762 | # - list args (--arg value1 --arg value2) |
Motomu Utsumi | 8be8a26 | 2022-12-02 14:35:15 +0900 | [diff] [blame] | 763 | # value args have exactly one arg value pair and list args have one or more arg value pairs. |
Motomu Utsumi | 923688c | 2022-12-01 15:51:05 +0900 | [diff] [blame] | 764 | # Note that the set of list args contains the set of value args. |
Motomu Utsumi | 8be8a26 | 2022-12-02 14:35:15 +0900 | [diff] [blame] | 765 | # This is because list and value args are identical when the list args has only one arg value pair |
Patrick Rohr | 2cad933 | 2022-11-30 14:27:40 -0800 | [diff] [blame] | 766 | # Some functions provide special implementations for each type, while others |
| 767 | # work on all of them. |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 768 | def _has_arg(self, arg): |
| 769 | return arg in self.target.args |
| 770 | |
Motomu Utsumi | 923688c | 2022-12-01 15:51:05 +0900 | [diff] [blame] | 771 | def _get_arg_indices(self, target_arg): |
| 772 | return [i for i, arg in enumerate(self.target.args) if arg == target_arg] |
Patrick Rohr | 3a2c3dd | 2022-11-29 22:29:36 -0800 | [diff] [blame] | 773 | |
Motomu Utsumi | 923688c | 2022-12-01 15:51:05 +0900 | [diff] [blame] | 774 | # Whether an arg value pair appears once or more times |
| 775 | def _is_list_arg(self, arg): |
| 776 | indices = self._get_arg_indices(arg) |
| 777 | return len(indices) > 0 and all([not self.target.args[i + 1].startswith('--') for i in indices]) |
| 778 | |
Motomu Utsumi | c363b41 | 2022-12-01 16:01:58 +0900 | [diff] [blame] | 779 | def _update_list_arg(self, arg, func, throw_if_absent = True): |
| 780 | if self._should_fail_silently(arg, throw_if_absent): |
| 781 | return |
| 782 | assert(self._is_list_arg(arg)) |
| 783 | indices = self._get_arg_indices(arg) |
| 784 | for i in indices: |
| 785 | self._set_arg_at(i + 1, func(self.target.args[i + 1])) |
| 786 | |
Motomu Utsumi | 923688c | 2022-12-01 15:51:05 +0900 | [diff] [blame] | 787 | # Whether an arg value pair appears exactly once |
Patrick Rohr | ef4f2bf | 2022-11-30 14:22:40 -0800 | [diff] [blame] | 788 | def _is_value_arg(self, arg): |
Motomu Utsumi | d75b8b5 | 2022-12-02 14:29:00 +0900 | [diff] [blame] | 789 | return operator.countOf(self.target.args, arg) == 1 and self._is_list_arg(arg) |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 790 | |
Patrick Rohr | 2cad933 | 2022-11-30 14:27:40 -0800 | [diff] [blame] | 791 | def _get_value_arg(self, arg): |
Patrick Rohr | ef4f2bf | 2022-11-30 14:22:40 -0800 | [diff] [blame] | 792 | assert(self._is_value_arg(arg)) |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 793 | i = self.target.args.index(arg) |
| 794 | return self.target.args[i + 1] |
| 795 | |
Patrick Rohr | f0abead | 2022-11-30 19:44:10 -0800 | [diff] [blame] | 796 | # used to check whether a function call should cause an error when an arg is |
| 797 | # missing. |
| 798 | def _should_fail_silently(self, arg, throw_if_absent): |
| 799 | return not throw_if_absent and not self._has_arg(arg) |
| 800 | |
| 801 | def _set_value_arg(self, arg, value, throw_if_absent = True): |
| 802 | if self._should_fail_silently(arg, throw_if_absent): |
Patrick Rohr | 4d74aed | 2022-11-30 15:42:16 -0800 | [diff] [blame] | 803 | return |
Patrick Rohr | ef4f2bf | 2022-11-30 14:22:40 -0800 | [diff] [blame] | 804 | assert(self._is_value_arg(arg)) |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 805 | i = self.target.args.index(arg) |
| 806 | self.target.args[i + 1] = value |
| 807 | |
Patrick Rohr | f0abead | 2022-11-30 19:44:10 -0800 | [diff] [blame] | 808 | def _update_value_arg(self, arg, func, throw_if_absent = True): |
| 809 | if self._should_fail_silently(arg, throw_if_absent): |
Patrick Rohr | 4d74aed | 2022-11-30 15:42:16 -0800 | [diff] [blame] | 810 | return |
Patrick Rohr | 1bedf6c | 2022-11-30 15:12:57 -0800 | [diff] [blame] | 811 | self._set_value_arg(arg, func(self._get_value_arg(arg))) |
| 812 | |
Patrick Rohr | 77c4f5c | 2022-11-30 12:56:29 -0800 | [diff] [blame] | 813 | def _set_arg_at(self, position, value): |
Mohannad Farrag | 9ab1793 | 2022-11-30 17:28:35 +0000 | [diff] [blame] | 814 | self.target.args[position] = value |
| 815 | |
Patrick Rohr | 357b25c | 2022-11-30 19:46:26 -0800 | [diff] [blame] | 816 | def _delete_value_arg(self, arg, throw_if_absent = True): |
Patrick Rohr | f0abead | 2022-11-30 19:44:10 -0800 | [diff] [blame] | 817 | if self._should_fail_silently(arg, throw_if_absent): |
Patrick Rohr | 4d74aed | 2022-11-30 15:42:16 -0800 | [diff] [blame] | 818 | return |
Patrick Rohr | 357b25c | 2022-11-30 19:46:26 -0800 | [diff] [blame] | 819 | assert(self._is_value_arg(arg)) |
Patrick Rohr | 9f43932 | 2022-11-30 15:56:15 -0800 | [diff] [blame] | 820 | i = self.target.args.index(arg) |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 821 | self.target.args.pop(i) |
Patrick Rohr | 357b25c | 2022-11-30 19:46:26 -0800 | [diff] [blame] | 822 | self.target.args.pop(i) |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 823 | |
Patrick Rohr | 1f7dd58 | 2022-11-30 13:44:07 -0800 | [diff] [blame] | 824 | def _append_arg(self, arg, value): |
| 825 | self.target.args.append(arg) |
| 826 | self.target.args.append(value) |
| 827 | |
Mohannad Farrag | 8fa9065 | 2022-12-01 15:40:40 +0000 | [diff] [blame] | 828 | def _sanitize_filepath_with_location_tag(self, arg): |
| 829 | if arg.startswith('../../'): |
| 830 | arg = self._sanitize_filepath(arg) |
| 831 | arg = self._add_location_tag(arg) |
| 832 | return arg |
| 833 | |
Patrick Rohr | 73ef7ae | 2022-11-29 22:33:09 -0800 | [diff] [blame] | 834 | # wrap filename in location tag. |
Patrick Rohr | fda02673 | 2022-11-30 16:07:11 -0800 | [diff] [blame] | 835 | def _add_location_tag(self, filename): |
Patrick Rohr | 73ef7ae | 2022-11-29 22:33:09 -0800 | [diff] [blame] | 836 | return '$(location %s)' % filename |
| 837 | |
Patrick Rohr | 0e24c5f | 2022-11-30 15:20:21 -0800 | [diff] [blame] | 838 | # applies common directory transformation that *should* be universally applicable. |
| 839 | # TODO: verify if it actually *is* universally applicable. |
Patrick Rohr | 872a281 | 2022-11-30 19:28:22 -0800 | [diff] [blame] | 840 | def _sanitize_filepath(self, filepath): |
Patrick Rohr | 0e24c5f | 2022-11-30 15:20:21 -0800 | [diff] [blame] | 841 | # Careful, order matters! |
Patrick Rohr | 8bcd783 | 2022-11-30 19:48:56 -0800 | [diff] [blame] | 842 | # delete all leading ../ |
Patrick Rohr | 9e5a3c7 | 2022-11-30 15:51:30 -0800 | [diff] [blame] | 843 | filepath = re.sub('^(\.\./)+', '', filepath) |
Patrick Rohr | 0e24c5f | 2022-11-30 15:20:21 -0800 | [diff] [blame] | 844 | filepath = re.sub('^gen/jni_headers', '$(genDir)', filepath) |
| 845 | filepath = re.sub('^gen', '$(genDir)', filepath) |
| 846 | return filepath |
Patrick Rohr | 3227689 | 2022-11-29 22:38:13 -0800 | [diff] [blame] | 847 | |
Motomu Utsumi | 21485ba | 2022-12-01 17:01:50 +0900 | [diff] [blame] | 848 | # Iterate through all the args and apply function |
| 849 | def _update_all_args(self, func): |
| 850 | self.target.args = [func(arg) for arg in self.target.args] |
| 851 | |
Mohannad Farrag | d5515ca | 2022-12-02 15:39:53 +0000 | [diff] [blame] | 852 | def get_cmd(self): |
Mohannad Farrag | c739dda | 2022-12-02 15:43:46 +0000 | [diff] [blame] | 853 | arg_string = NEWLINE.join(self.target.args) |
| 854 | cmd = '$(location %s) %s' % ( |
| 855 | gn_utils.label_to_path(self.target.script), arg_string) |
| 856 | |
| 857 | if self.use_response_file: |
| 858 | # Pipe response file contents into script |
| 859 | cmd = 'echo \'%s\' |%s%s' % (self.target.response_file_contents, NEWLINE, cmd) |
| 860 | return cmd |
Mohannad Farrag | d5515ca | 2022-12-02 15:39:53 +0000 | [diff] [blame] | 861 | |
Motomu Utsumi | 5afd081 | 2022-12-02 15:43:36 +0900 | [diff] [blame] | 862 | def get_outputs(self): |
| 863 | return self.target.outputs |
| 864 | |
Motomu Utsumi | 80fa0b0 | 2022-12-05 12:50:57 +0900 | [diff] [blame] | 865 | def get_srcs(self): |
| 866 | # gn treats inputs and sources for actions equally. |
| 867 | # soong only supports source files inside srcs, non-source files are added as |
| 868 | # tool_files dependency. |
| 869 | files = self.target.sources.union(self.target.inputs) |
| 870 | return {gn_utils.label_to_path(file) for file in files if is_supported_source_file(file)} |
| 871 | |
Motomu Utsumi | aaf42cf | 2022-12-05 12:55:02 +0900 | [diff] [blame] | 872 | def get_tool_files(self): |
| 873 | # gn treats inputs and sources for actions equally. |
| 874 | # soong only supports source files inside srcs, non-source files are added as |
| 875 | # tool_files dependency. |
| 876 | files = self.target.sources.union(self.target.inputs) |
Motomu Utsumi | 6997586 | 2022-12-05 12:59:06 +0900 | [diff] [blame] | 877 | tool_files = {gn_utils.label_to_path(file) |
| 878 | for file in files if not is_supported_source_file(file)} |
| 879 | tool_files.add(gn_utils.label_to_path(self.target.script)) |
| 880 | return tool_files |
Motomu Utsumi | aaf42cf | 2022-12-05 12:55:02 +0900 | [diff] [blame] | 881 | |
Motomu Utsumi | cdb45ea | 2022-12-02 17:05:07 +0900 | [diff] [blame] | 882 | def _sanitize_args(self): |
Mohannad Farrag | 00ecfb5 | 2022-12-02 14:44:15 +0000 | [diff] [blame] | 883 | # Handle passing parameters via response file by piping them into the script |
| 884 | # and reading them from /dev/stdin. |
| 885 | |
Mohannad Farrag | a0e37c1 | 2022-12-02 14:46:08 +0000 | [diff] [blame] | 886 | self.use_response_file = gn_utils.RESPONSE_FILE in self.target.args |
Mohannad Farrag | 00ecfb5 | 2022-12-02 14:44:15 +0000 | [diff] [blame] | 887 | if self.use_response_file: |
| 888 | # Replace {{response_file_contents}} with /dev/stdin |
Mohannad Farrag | a0e37c1 | 2022-12-02 14:46:08 +0000 | [diff] [blame] | 889 | self.target.args = ['/dev/stdin' if it == gn_utils.RESPONSE_FILE else it |
| 890 | for it in self.target.args] |
Motomu Utsumi | cdb45ea | 2022-12-02 17:05:07 +0900 | [diff] [blame] | 891 | |
| 892 | def _sanitize_outputs(self): |
| 893 | pass |
| 894 | |
Motomu Utsumi | 735a5a4 | 2022-12-05 12:15:07 +0900 | [diff] [blame] | 895 | def _sanitize_inputs(self): |
| 896 | pass |
| 897 | |
Motomu Utsumi | cdb45ea | 2022-12-02 17:05:07 +0900 | [diff] [blame] | 898 | def sanitize(self): |
| 899 | self._sanitize_args() |
| 900 | self._sanitize_outputs() |
Motomu Utsumi | 735a5a4 | 2022-12-05 12:15:07 +0900 | [diff] [blame] | 901 | self._sanitize_inputs() |
Motomu Utsumi | cdb45ea | 2022-12-02 17:05:07 +0900 | [diff] [blame] | 902 | |
Motomu Utsumi | 7db7583 | 2022-12-02 16:46:22 +0900 | [diff] [blame] | 903 | # Whether this target generates header files |
| 904 | def is_header_generated(self): |
Motomu Utsumi | a91ade6 | 2022-12-02 16:58:36 +0900 | [diff] [blame] | 905 | return any(os.path.splitext(it)[1] == '.h' for it in self.target.outputs) |
Motomu Utsumi | 7db7583 | 2022-12-02 16:46:22 +0900 | [diff] [blame] | 906 | |
Mohannad Farrag | 9ab1793 | 2022-11-30 17:28:35 +0000 | [diff] [blame] | 907 | class WriteBuildDateHeaderSanitizer(BaseActionSanitizer): |
Motomu Utsumi | 805591d | 2022-12-02 17:17:16 +0900 | [diff] [blame] | 908 | def _sanitize_args(self): |
Patrick Rohr | 77c4f5c | 2022-11-30 12:56:29 -0800 | [diff] [blame] | 909 | self._set_arg_at(0, '$(out)') |
Motomu Utsumi | 805591d | 2022-12-02 17:17:16 +0900 | [diff] [blame] | 910 | super()._sanitize_args() |
Mohannad Farrag | 9ab1793 | 2022-11-30 17:28:35 +0000 | [diff] [blame] | 911 | |
Mohannad Farrag | 71353f9 | 2022-11-30 17:20:48 +0000 | [diff] [blame] | 912 | class WriteBuildFlagHeaderSanitizer(BaseActionSanitizer): |
Motomu Utsumi | 805591d | 2022-12-02 17:17:16 +0900 | [diff] [blame] | 913 | def _sanitize_args(self): |
Patrick Rohr | 2cad933 | 2022-11-30 14:27:40 -0800 | [diff] [blame] | 914 | self._set_value_arg('--gen-dir', '.') |
| 915 | self._set_value_arg('--output', '$(out)') |
Motomu Utsumi | 805591d | 2022-12-02 17:17:16 +0900 | [diff] [blame] | 916 | super()._sanitize_args() |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 917 | |
Patrick Rohr | 0242a3f | 2022-11-30 13:48:59 -0800 | [diff] [blame] | 918 | class JniGeneratorSanitizer(BaseActionSanitizer): |
Motomu Utsumi | 4d551d7 | 2022-12-01 16:18:23 +0900 | [diff] [blame] | 919 | def _add_location_tag_to_filepath(self, arg): |
| 920 | if not arg.endswith('.class'): |
| 921 | # --input_file supports both .class specifiers or source files as arguments. |
| 922 | # Only source files need to be wrapped inside a $(location <label>) tag. |
| 923 | arg = self._add_location_tag(arg) |
| 924 | return arg |
| 925 | |
Motomu Utsumi | 805591d | 2022-12-02 17:17:16 +0900 | [diff] [blame] | 926 | def _sanitize_args(self): |
Patrick Rohr | f0abead | 2022-11-30 19:44:10 -0800 | [diff] [blame] | 927 | self._update_value_arg('--jar_file', self._sanitize_filepath, False) |
| 928 | self._update_value_arg('--jar_file', self._add_location_tag, False) |
Patrick Rohr | 0242a3f | 2022-11-30 13:48:59 -0800 | [diff] [blame] | 929 | if self._has_arg('--jar_file'): |
| 930 | self._append_arg('--javap', '$$(find out/.path -name javap)') |
Patrick Rohr | 872a281 | 2022-11-30 19:28:22 -0800 | [diff] [blame] | 931 | self._update_value_arg('--output_dir', self._sanitize_filepath) |
Patrick Rohr | f0abead | 2022-11-30 19:44:10 -0800 | [diff] [blame] | 932 | self._update_value_arg('--includes', self._sanitize_filepath, False) |
Patrick Rohr | 357b25c | 2022-11-30 19:46:26 -0800 | [diff] [blame] | 933 | self._delete_value_arg('--prev_output_dir', False) |
Motomu Utsumi | 4d551d7 | 2022-12-01 16:18:23 +0900 | [diff] [blame] | 934 | self._update_list_arg('--input_file', self._sanitize_filepath) |
| 935 | self._update_list_arg('--input_file', self._add_location_tag_to_filepath) |
Motomu Utsumi | 805591d | 2022-12-02 17:17:16 +0900 | [diff] [blame] | 936 | super()._sanitize_args() |
Patrick Rohr | 0242a3f | 2022-11-30 13:48:59 -0800 | [diff] [blame] | 937 | |
Motomu Utsumi | 9401996 | 2022-12-02 17:18:58 +0900 | [diff] [blame] | 938 | def _sanitize_outputs(self): |
Motomu Utsumi | d4f7264 | 2022-12-02 16:01:59 +0900 | [diff] [blame] | 939 | # fix target.output directory to match #include statements. |
| 940 | self.target.outputs = {re.sub('^jni_headers/', '', out) for out in self.target.outputs} |
Motomu Utsumi | 9401996 | 2022-12-02 17:18:58 +0900 | [diff] [blame] | 941 | super()._sanitize_outputs() |
Motomu Utsumi | d4f7264 | 2022-12-02 16:01:59 +0900 | [diff] [blame] | 942 | |
Motomu Utsumi | a6824ea | 2022-12-05 14:53:11 +0900 | [diff] [blame] | 943 | def get_tool_files(self): |
| 944 | tool_files = super().get_tool_files() |
| 945 | # android_jar.classes should be part of the tools as it list implicit classes |
| 946 | # for the script to generate JNI headers. |
| 947 | tool_files.add("base/android/jni_generator/android_jar.classes") |
| 948 | return tool_files |
| 949 | |
Motomu Utsumi | b80903c | 2022-12-01 16:21:55 +0900 | [diff] [blame] | 950 | class JniRegistrationGeneratorSanitizer(BaseActionSanitizer): |
Motomu Utsumi | 07027f6 | 2022-12-05 12:16:53 +0900 | [diff] [blame] | 951 | def _sanitize_inputs(self): |
| 952 | self.target.inputs = [file for file in self.target.inputs if not file.startswith('//out/')] |
| 953 | |
Motomu Utsumi | 805591d | 2022-12-02 17:17:16 +0900 | [diff] [blame] | 954 | def _sanitize_args(self): |
Motomu Utsumi | 28cbf2f | 2022-12-01 16:24:29 +0900 | [diff] [blame] | 955 | self._update_value_arg('--depfile', self._sanitize_filepath) |
| 956 | self._update_value_arg('--srcjar-path', self._sanitize_filepath) |
| 957 | self._update_value_arg('--header-path', self._sanitize_filepath) |
Motomu Utsumi | 5590747 | 2022-12-01 16:26:21 +0900 | [diff] [blame] | 958 | self._set_value_arg('--sources-files', '$(genDir)/java.sources') |
Motomu Utsumi | 4fe0b95 | 2022-12-01 16:29:15 +0900 | [diff] [blame] | 959 | # update_jni_registration_module removes them from the srcs of the module |
| 960 | # It might be better to remove sources by '--sources-exclusions' |
| 961 | self._delete_value_arg('--sources-exclusions') |
Motomu Utsumi | 805591d | 2022-12-02 17:17:16 +0900 | [diff] [blame] | 962 | super()._sanitize_args() |
Patrick Rohr | 0242a3f | 2022-11-30 13:48:59 -0800 | [diff] [blame] | 963 | |
Mohannad Farrag | 291f567 | 2022-12-02 15:49:00 +0000 | [diff] [blame] | 964 | def get_cmd(self): |
| 965 | # jni_registration_generator.py doesn't work with python2 |
| 966 | cmd = "python3 " + super().get_cmd() |
| 967 | # Path in the original sources file does not work in genrule. |
| 968 | # So creating sources file in cmd based on the srcs of this target. |
| 969 | # Adding ../$(current_dir)/ to the head because jni_registration_generator.py uses the files |
| 970 | # whose path startswith(..) |
| 971 | commands = ["current_dir=`basename \\\`pwd\\\``;", |
| 972 | "for f in $(in);", |
| 973 | "do", |
| 974 | "echo \\\"../$$current_dir/$$f\\\" >> $(genDir)/java.sources;", |
| 975 | "done;", |
| 976 | cmd] |
| 977 | |
| 978 | # .h file jni_registration_generator.py generates has #define with directory name. |
| 979 | # With the genrule env that contains "." which is invalid. So replace that at the end of cmd. |
| 980 | commands.append(";sed -i -e 's/OUT_SOONG_.TEMP_SBOX_.*_OUT/GEN/g' ") |
| 981 | commands.append("$(genDir)/components/cronet/android/cronet_jni_registration.h") |
| 982 | return NEWLINE.join(commands) |
| 983 | |
Mohannad Farrag | 457bc02 | 2022-12-02 14:31:22 +0000 | [diff] [blame] | 984 | class JavaJniRegistrationGeneratorSanitizer(JniRegistrationGeneratorSanitizer): |
Mohannad Farrag | 7f7c9b4 | 2022-12-02 14:37:56 +0000 | [diff] [blame] | 985 | def get_name(self): |
| 986 | return label_to_module_name(self.target.name) + "__java" |
| 987 | |
Mohannad Farrag | 457bc02 | 2022-12-02 14:31:22 +0000 | [diff] [blame] | 988 | def _sanitize_outputs(self): |
| 989 | self.target.outputs = [out for out in self.target.outputs if |
| 990 | out.endswith(".srcjar")] |
| 991 | super()._sanitize_outputs() |
| 992 | |
Motomu Utsumi | 6af5b2a | 2022-12-01 16:33:42 +0900 | [diff] [blame] | 993 | class VersionSanitizer(BaseActionSanitizer): |
Motomu Utsumi | 805591d | 2022-12-02 17:17:16 +0900 | [diff] [blame] | 994 | def _sanitize_args(self): |
Motomu Utsumi | c6b08b8 | 2022-12-01 16:48:19 +0900 | [diff] [blame] | 995 | self._set_value_arg('-o', '$(out)') |
Motomu Utsumi | 21485ba | 2022-12-01 17:01:50 +0900 | [diff] [blame] | 996 | # args for the version.py contain file path without leading --arg key. So apply sanitize |
| 997 | # function for all the args. |
Mohannad Farrag | 8fa9065 | 2022-12-01 15:40:40 +0000 | [diff] [blame] | 998 | self._update_all_args(self._sanitize_filepath_with_location_tag) |
Mohannad Farrag | 2569734 | 2022-12-02 18:01:48 +0000 | [diff] [blame] | 999 | self._set_value_arg('-e', "'%s'" % self._get_value_arg('-e')) |
Motomu Utsumi | 805591d | 2022-12-02 17:17:16 +0900 | [diff] [blame] | 1000 | super()._sanitize_args() |
Motomu Utsumi | 6af5b2a | 2022-12-01 16:33:42 +0900 | [diff] [blame] | 1001 | |
Motomu Utsumi | df63414 | 2022-12-05 15:02:44 +0900 | [diff] [blame] | 1002 | def get_tool_files(self): |
| 1003 | tool_files = super().get_tool_files() |
| 1004 | # android_chrome_version.py is not specified in anywhere but version.py imports this file |
| 1005 | tool_files.add('build/util/android_chrome_version.py') |
| 1006 | return tool_files |
| 1007 | |
Mohannad Farrag | b73ce0f | 2022-12-01 15:43:58 +0000 | [diff] [blame] | 1008 | class JavaCppEnumSanitizer(BaseActionSanitizer): |
Motomu Utsumi | 805591d | 2022-12-02 17:17:16 +0900 | [diff] [blame] | 1009 | def _sanitize_args(self): |
Mohannad Farrag | b73ce0f | 2022-12-01 15:43:58 +0000 | [diff] [blame] | 1010 | self._update_all_args(self._sanitize_filepath_with_location_tag) |
| 1011 | self._set_value_arg('--srcjar', '$(out)') |
Motomu Utsumi | 805591d | 2022-12-02 17:17:16 +0900 | [diff] [blame] | 1012 | super()._sanitize_args() |
Mohannad Farrag | b73ce0f | 2022-12-01 15:43:58 +0000 | [diff] [blame] | 1013 | |
Motomu Utsumi | 9701d2f | 2022-12-02 16:53:06 +0900 | [diff] [blame] | 1014 | class MakeDafsaSanitizer(BaseActionSanitizer): |
| 1015 | def is_header_generated(self): |
Motomu Utsumi | 1e028b8 | 2022-12-02 16:54:20 +0900 | [diff] [blame] | 1016 | # This script generates .cc files but they are #included by other sources |
| 1017 | # (e.g. registry_controlled_domain.cc) |
| 1018 | return True |
Motomu Utsumi | 9701d2f | 2022-12-02 16:53:06 +0900 | [diff] [blame] | 1019 | |
Motomu Utsumi | 56a2f44 | 2022-12-05 16:01:34 +0900 | [diff] [blame] | 1020 | class JavaCppFeatureSanitizer(BaseActionSanitizer): |
Motomu Utsumi | d7c3677 | 2022-12-05 16:04:37 +0900 | [diff] [blame] | 1021 | def _sanitize_args(self): |
| 1022 | self._update_all_args(self._sanitize_filepath_with_location_tag) |
| 1023 | self._set_value_arg('--srcjar', '$(out)') |
| 1024 | super()._sanitize_args() |
Motomu Utsumi | 56a2f44 | 2022-12-05 16:01:34 +0900 | [diff] [blame] | 1025 | |
Motomu Utsumi | ce5166b | 2022-12-05 16:08:37 +0900 | [diff] [blame] | 1026 | class JavaCppStringSanitizer(BaseActionSanitizer): |
Motomu Utsumi | 3f7ab31 | 2022-12-05 16:12:21 +0900 | [diff] [blame] | 1027 | def _sanitize_args(self): |
| 1028 | self._update_all_args(self._sanitize_filepath_with_location_tag) |
| 1029 | self._set_value_arg('--srcjar', '$(out)') |
| 1030 | super()._sanitize_args() |
Motomu Utsumi | ce5166b | 2022-12-05 16:08:37 +0900 | [diff] [blame] | 1031 | |
Motomu Utsumi | b90a76b | 2022-12-05 16:17:26 +0900 | [diff] [blame] | 1032 | class WriteNativeLibrariesJavaSanitizer(BaseActionSanitizer): |
Motomu Utsumi | 3dbc276 | 2022-12-05 16:20:21 +0900 | [diff] [blame] | 1033 | def _sanitize_args(self): |
| 1034 | self._set_value_arg('--output', '$(out)') |
| 1035 | super()._sanitize_args() |
Motomu Utsumi | b90a76b | 2022-12-05 16:17:26 +0900 | [diff] [blame] | 1036 | |
Motomu Utsumi | 0facea5 | 2022-12-16 17:25:30 +0900 | [diff] [blame] | 1037 | def get_action_sanitizer(target, type, arch): |
Patrick Rohr | 7f11715 | 2022-11-30 13:58:05 -0800 | [diff] [blame] | 1038 | if target.script == "//build/write_buildflag_header.py": |
Motomu Utsumi | 0facea5 | 2022-12-16 17:25:30 +0900 | [diff] [blame] | 1039 | return WriteBuildFlagHeaderSanitizer(target, arch) |
Patrick Rohr | 7f11715 | 2022-11-30 13:58:05 -0800 | [diff] [blame] | 1040 | elif target.script == "//build/write_build_date_header.py": |
Motomu Utsumi | 0facea5 | 2022-12-16 17:25:30 +0900 | [diff] [blame] | 1041 | return WriteBuildDateHeaderSanitizer(target, arch) |
Patrick Rohr | 7f11715 | 2022-11-30 13:58:05 -0800 | [diff] [blame] | 1042 | elif target.script == '//base/android/jni_generator/jni_generator.py': |
Motomu Utsumi | 0facea5 | 2022-12-16 17:25:30 +0900 | [diff] [blame] | 1043 | return JniGeneratorSanitizer(target, arch) |
Motomu Utsumi | b80903c | 2022-12-01 16:21:55 +0900 | [diff] [blame] | 1044 | elif target.script == '//base/android/jni_generator/jni_registration_generator.py': |
Mohannad Farrag | 457bc02 | 2022-12-02 14:31:22 +0000 | [diff] [blame] | 1045 | if type == 'java_genrule': |
Motomu Utsumi | 0facea5 | 2022-12-16 17:25:30 +0900 | [diff] [blame] | 1046 | return JavaJniRegistrationGeneratorSanitizer(target, arch) |
Mohannad Farrag | 457bc02 | 2022-12-02 14:31:22 +0000 | [diff] [blame] | 1047 | else: |
Motomu Utsumi | 0facea5 | 2022-12-16 17:25:30 +0900 | [diff] [blame] | 1048 | return JniRegistrationGeneratorSanitizer(target, arch) |
Motomu Utsumi | 6af5b2a | 2022-12-01 16:33:42 +0900 | [diff] [blame] | 1049 | elif target.script == "//build/util/version.py": |
Motomu Utsumi | 0facea5 | 2022-12-16 17:25:30 +0900 | [diff] [blame] | 1050 | return VersionSanitizer(target, arch) |
Mohannad Farrag | b73ce0f | 2022-12-01 15:43:58 +0000 | [diff] [blame] | 1051 | elif target.script == "//build/android/gyp/java_cpp_enum.py": |
Motomu Utsumi | 0facea5 | 2022-12-16 17:25:30 +0900 | [diff] [blame] | 1052 | return JavaCppEnumSanitizer(target, arch) |
Motomu Utsumi | 9701d2f | 2022-12-02 16:53:06 +0900 | [diff] [blame] | 1053 | elif target.script == "//net/tools/dafsa/make_dafsa.py": |
Motomu Utsumi | 0facea5 | 2022-12-16 17:25:30 +0900 | [diff] [blame] | 1054 | return MakeDafsaSanitizer(target, arch) |
Motomu Utsumi | 56a2f44 | 2022-12-05 16:01:34 +0900 | [diff] [blame] | 1055 | elif target.script == '//build/android/gyp/java_cpp_features.py': |
Motomu Utsumi | 0facea5 | 2022-12-16 17:25:30 +0900 | [diff] [blame] | 1056 | return JavaCppFeatureSanitizer(target, arch) |
Motomu Utsumi | ce5166b | 2022-12-05 16:08:37 +0900 | [diff] [blame] | 1057 | elif target.script == '//build/android/gyp/java_cpp_strings.py': |
Motomu Utsumi | 0facea5 | 2022-12-16 17:25:30 +0900 | [diff] [blame] | 1058 | return JavaCppStringSanitizer(target, arch) |
Motomu Utsumi | b90a76b | 2022-12-05 16:17:26 +0900 | [diff] [blame] | 1059 | elif target.script == '//build/android/gyp/write_native_libraries_java.py': |
Motomu Utsumi | 0facea5 | 2022-12-16 17:25:30 +0900 | [diff] [blame] | 1060 | return WriteNativeLibrariesJavaSanitizer(target, arch) |
Patrick Rohr | 7f11715 | 2022-11-30 13:58:05 -0800 | [diff] [blame] | 1061 | else: |
| 1062 | # TODO: throw exception here once all script hacks have been converted. |
Motomu Utsumi | 0facea5 | 2022-12-16 17:25:30 +0900 | [diff] [blame] | 1063 | return BaseActionSanitizer(target, arch) |
Patrick Rohr | 7f11715 | 2022-11-30 13:58:05 -0800 | [diff] [blame] | 1064 | |
Mohannad Farrag | bab6c89 | 2022-11-02 14:09:46 +0000 | [diff] [blame] | 1065 | def create_action_foreach_modules(blueprint, target): |
| 1066 | """ The following assumes that rebase_path exists in the args. |
| 1067 | The args of an action_foreach contains hints about which output files are generated |
| 1068 | by which source files. |
| 1069 | This is copied directly from the args |
| 1070 | "gen/net/base/registry_controlled_domains/{{source_name_part}}-reversed-inc.cc" |
| 1071 | So each source file will generate an output whose name is the {source_name-reversed-inc.cc} |
| 1072 | """ |
| 1073 | new_args = [] |
Motomu Utsumi | 56afcac | 2022-11-04 12:58:30 +0900 | [diff] [blame] | 1074 | for i, src in enumerate(sorted(target.sources)): |
Mohannad Farrag | bab6c89 | 2022-11-02 14:09:46 +0000 | [diff] [blame] | 1075 | # don't add script arg for the first source -- create_action_module |
| 1076 | # already does this. |
| 1077 | if i != 0: |
| 1078 | new_args.append('&& python3 $(location %s)' % |
| 1079 | gn_utils.label_to_path(target.script)) |
| 1080 | for arg in target.args: |
| 1081 | if '{{source}}' in arg: |
| 1082 | new_args.append('$(location %s)' % (gn_utils.label_to_path(src))) |
| 1083 | elif '{{source_name_part}}' in arg: |
| 1084 | source_name_part = src.split("/")[-1] # Get the file name only |
| 1085 | source_name_part = source_name_part.split(".")[0] # Remove the extension (Ex: .cc) |
| 1086 | file_name = arg.replace('{{source_name_part}}', source_name_part).split("/")[-1] |
| 1087 | # file_name represent the output file name. But we need the whole path |
| 1088 | # This can be found from target.outputs. |
| 1089 | for out in target.outputs: |
| 1090 | if out.endswith(file_name): |
| 1091 | new_args.append('$(location %s)' % out) |
| 1092 | else: |
| 1093 | new_args.append(arg) |
| 1094 | |
| 1095 | target.args = new_args |
Mohannad Farrag | 7ff9991 | 2022-11-29 17:16:00 +0000 | [diff] [blame] | 1096 | return create_action_module(blueprint, target, 'cc_genrule') |
Motomu Utsumi | a6c3315 | 2022-11-02 18:21:55 +0900 | [diff] [blame] | 1097 | |
Motomu Utsumi | 0facea5 | 2022-12-16 17:25:30 +0900 | [diff] [blame] | 1098 | def create_action_module(blueprint, target, type, arch=None): |
| 1099 | sanitizer = get_action_sanitizer(target, type, arch) |
Motomu Utsumi | cdb45ea | 2022-12-02 17:05:07 +0900 | [diff] [blame] | 1100 | sanitizer.sanitize() |
Motomu Utsumi | 47fd40a | 2022-12-05 15:07:31 +0900 | [diff] [blame] | 1101 | |
Mohannad Farrag | 7f7c9b4 | 2022-12-02 14:37:56 +0000 | [diff] [blame] | 1102 | module = Module(type, sanitizer.get_name(), target.name) |
Mohannad Farrag | c739dda | 2022-12-02 15:43:46 +0000 | [diff] [blame] | 1103 | module.cmd = sanitizer.get_cmd() |
Motomu Utsumi | 2421323 | 2022-12-02 16:04:05 +0900 | [diff] [blame] | 1104 | module.out = sanitizer.get_outputs() |
Motomu Utsumi | 7db7583 | 2022-12-02 16:46:22 +0900 | [diff] [blame] | 1105 | if sanitizer.is_header_generated(): |
| 1106 | module.genrule_headers.add(module.name) |
Motomu Utsumi | 80fa0b0 | 2022-12-05 12:50:57 +0900 | [diff] [blame] | 1107 | module.srcs = sanitizer.get_srcs() |
Motomu Utsumi | aaf42cf | 2022-12-05 12:55:02 +0900 | [diff] [blame] | 1108 | module.tool_files = sanitizer.get_tool_files() |
Patrick Rohr | 9b99a98 | 2022-10-28 11:00:57 -0700 | [diff] [blame] | 1109 | |
Patrick Rohr | e1a853e | 2022-10-26 12:31:39 -0700 | [diff] [blame] | 1110 | blueprint.add_module(module) |
| 1111 | return module |
| 1112 | |
Motomu Utsumi | 170cc2d | 2022-12-16 17:31:28 +0900 | [diff] [blame^] | 1113 | def get_cmd_condition(arch): |
| 1114 | ''' |
| 1115 | :param arch: archtecture name e.g. android_x86_64, android_arm64 |
| 1116 | :return: condition that can be used in cc_genrule cmd to switch the behavior based on arch |
| 1117 | ''' |
| 1118 | if arch == "android_x86_64": |
| 1119 | return "( $$CC_ARCH == 'x86_64' && $$CC_OS == 'android' )" |
| 1120 | elif arch == "android_x86": |
| 1121 | return "( $$CC_ARCH == 'x86' && $$CC_OS == 'android' )" |
| 1122 | elif arch == "android_arm": |
| 1123 | return "( $$CC_ARCH == 'arm' && $$CC_OS == 'android' )" |
| 1124 | elif arch == "android_arm64": |
| 1125 | return "( $$CC_ARCH == 'arm64' && $$CC_OS == 'android' )" |
| 1126 | elif arch == "host": |
| 1127 | return "$$CC_OS != 'android'" |
| 1128 | else: |
| 1129 | raise Error(f'Unknown architecture type {arch}') |
Patrick Rohr | e1a853e | 2022-10-26 12:31:39 -0700 | [diff] [blame] | 1130 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1131 | |
Motomu Utsumi | c34b137 | 2022-11-17 22:15:51 +0900 | [diff] [blame] | 1132 | def _get_cflags(cflags, defines): |
| 1133 | cflags = {flag for flag in cflags if flag in cflag_allowlist} |
Motomu Utsumi | fa7e926 | 2022-10-26 19:43:02 +0900 | [diff] [blame] | 1134 | # Consider proper allowlist or denylist if needed |
Motomu Utsumi | c34b137 | 2022-11-17 22:15:51 +0900 | [diff] [blame] | 1135 | cflags |= set("-D%s" % define.replace("\"", "\\\"") for define in defines) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1136 | return cflags |
| 1137 | |
Motomu Utsumi | c34b137 | 2022-11-17 22:15:51 +0900 | [diff] [blame] | 1138 | def set_module_flags(module, cflags, defines): |
| 1139 | module.cflags.update(_get_cflags(cflags, defines)) |
| 1140 | # TODO: implement proper cflag parsing. |
| 1141 | for flag in cflags: |
| 1142 | if '-std=' in flag: |
| 1143 | module.cpp_std = flag[len('-std='):] |
Motomu Utsumi | c34b137 | 2022-11-17 22:15:51 +0900 | [diff] [blame] | 1144 | if '-fexceptions' in flag: |
| 1145 | module.cppflags.add('-fexceptions') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1146 | |
Motomu Utsumi | 88efbb4 | 2022-11-17 22:18:15 +0900 | [diff] [blame] | 1147 | def set_module_include_dirs(module, cflags, include_dirs): |
Motomu Utsumi | 88efbb4 | 2022-11-17 22:18:15 +0900 | [diff] [blame] | 1148 | for flag in cflags: |
| 1149 | if '-isystem' in flag: |
Patrick Rohr | 3cd5ffb | 2022-11-18 17:40:55 -0800 | [diff] [blame] | 1150 | module.local_include_dirs.add(flag[len('-isystem../../'):]) |
Motomu Utsumi | 88efbb4 | 2022-11-17 22:18:15 +0900 | [diff] [blame] | 1151 | |
| 1152 | # Adding local_include_dirs is necessary due to source_sets / filegroups |
| 1153 | # which do not properly propagate include directories. |
| 1154 | # Filter any directory inside //out as a) this directory does not exist for |
| 1155 | # aosp / soong builds and b) the include directory should already be |
| 1156 | # configured via library dependency. |
Patrick Rohr | 3cd5ffb | 2022-11-18 17:40:55 -0800 | [diff] [blame] | 1157 | module.local_include_dirs.update([gn_utils.label_to_path(d) |
Motomu Utsumi | 88efbb4 | 2022-11-17 22:18:15 +0900 | [diff] [blame] | 1158 | for d in include_dirs |
| 1159 | if not re.match('^//out/.*', d)]) |
Patrick Rohr | 9d7539e | 2022-12-14 19:31:33 -0800 | [diff] [blame] | 1160 | # Remove prohibited include directories |
| 1161 | module.local_include_dirs = [d for d in module.local_include_dirs |
| 1162 | if d not in local_include_dirs_denylist] |
| 1163 | |
Motomu Utsumi | 88efbb4 | 2022-11-17 22:18:15 +0900 | [diff] [blame] | 1164 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1165 | def create_modules_from_target(blueprint, gn, gn_target_name): |
| 1166 | """Generate module(s) for a given GN target. |
| 1167 | |
| 1168 | Given a GN target name, generate one or more corresponding modules into a |
| 1169 | blueprint. The only case when this generates >1 module is proto libraries. |
| 1170 | |
| 1171 | Args: |
| 1172 | blueprint: Blueprint instance which is being generated. |
| 1173 | gn: gn_utils.GnParser object. |
| 1174 | gn_target_name: GN target for module generation. |
| 1175 | """ |
| 1176 | bp_module_name = label_to_module_name(gn_target_name) |
| 1177 | if bp_module_name in blueprint.modules: |
| 1178 | return blueprint.modules[bp_module_name] |
| 1179 | target = gn.get_target(gn_target_name) |
Patrick Rohr | 1622894 | 2022-10-26 14:00:26 -0700 | [diff] [blame] | 1180 | log.info('create modules for %s (%s)', target.name, target.type) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1181 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1182 | if target.type == 'executable': |
Patrick Rohr | c8f41cd | 2022-11-15 22:46:10 -0800 | [diff] [blame] | 1183 | if target.testonly: |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1184 | module_type = 'cc_test' |
| 1185 | else: |
Patrick Rohr | c8f41cd | 2022-11-15 22:46:10 -0800 | [diff] [blame] | 1186 | # Can be used for both host and device targets. |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1187 | module_type = 'cc_binary' |
| 1188 | module = Module(module_type, bp_module_name, gn_target_name) |
| 1189 | elif target.type == 'static_library': |
| 1190 | module = Module('cc_library_static', bp_module_name, gn_target_name) |
| 1191 | elif target.type == 'shared_library': |
| 1192 | module = Module('cc_library_shared', bp_module_name, gn_target_name) |
| 1193 | elif target.type == 'source_set': |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 1194 | module = Module('cc_object', bp_module_name, gn_target_name) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1195 | elif target.type == 'group': |
| 1196 | # "group" targets are resolved recursively by gn_utils.get_target(). |
| 1197 | # There's nothing we need to do at this level for them. |
| 1198 | return None |
| 1199 | elif target.type == 'proto_library': |
| 1200 | module = create_proto_modules(blueprint, gn, target) |
| 1201 | if module is None: |
| 1202 | return None |
| 1203 | elif target.type == 'action': |
Mohannad Farrag | 4b89a82 | 2022-12-02 14:25:44 +0000 | [diff] [blame] | 1204 | module = create_action_module(blueprint, target, 'cc_genrule') |
Mohannad Farrag | f076f3e | 2022-10-31 17:45:28 +0000 | [diff] [blame] | 1205 | elif target.type == 'action_foreach': |
Mohannad Farrag | bab6c89 | 2022-11-02 14:09:46 +0000 | [diff] [blame] | 1206 | module = create_action_foreach_modules(blueprint, target) |
Patrick Rohr | 59a7665 | 2022-10-26 12:36:56 -0700 | [diff] [blame] | 1207 | elif target.type == 'copy': |
| 1208 | # TODO: careful now! copy targets are not supported yet, but this will stop |
| 1209 | # traversing the dependency tree. For //base:base, this is not a big |
| 1210 | # problem as libicu contains the only copy target which happens to be a |
| 1211 | # leaf node. |
| 1212 | return None |
Patrick Rohr | ad44060 | 2022-11-10 22:09:04 -0800 | [diff] [blame] | 1213 | elif target.type == 'java_group': |
| 1214 | # Java targets are handled outside of create_modules_from_target. |
| 1215 | return None |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1216 | else: |
| 1217 | raise Error('Unknown target %s (%s)' % (target.name, target.type)) |
| 1218 | |
| 1219 | blueprint.add_module(module) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1220 | module.init_rc = target_initrc.get(target.name, []) |
| 1221 | module.srcs.update( |
| 1222 | gn_utils.label_to_path(src) |
| 1223 | for src in target.sources |
Motomu Utsumi | f951e50 | 2022-11-07 19:31:15 +0900 | [diff] [blame] | 1224 | if is_supported_source_file(src) and not src.startswith("//out/test")) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1225 | |
Patrick Rohr | 3b5ff76 | 2022-11-16 10:22:16 -0800 | [diff] [blame] | 1226 | # Add arch-specific properties |
| 1227 | for arch_name, arch in target.arch.items(): |
Motomu Utsumi | 40f95c5 | 2022-11-17 19:39:13 +0900 | [diff] [blame] | 1228 | module.target[arch_name].srcs.update( |
| 1229 | gn_utils.label_to_path(src) |
| 1230 | for src in arch.sources |
| 1231 | if is_supported_source_file(src) and not src.startswith("//out/test")) |
Patrick Rohr | 3b5ff76 | 2022-11-16 10:22:16 -0800 | [diff] [blame] | 1232 | |
Mohannad Farrag | baf0d57 | 2022-11-22 11:53:54 +0000 | [diff] [blame] | 1233 | module.rtti = target.rtti |
| 1234 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1235 | if target.type in gn_utils.LINKER_UNIT_TYPES: |
Motomu Utsumi | c34b137 | 2022-11-17 22:15:51 +0900 | [diff] [blame] | 1236 | set_module_flags(module, target.cflags, target.defines) |
Motomu Utsumi | 88efbb4 | 2022-11-17 22:18:15 +0900 | [diff] [blame] | 1237 | set_module_include_dirs(module, target.cflags, target.include_dirs) |
Motomu Utsumi | f0f4768 | 2022-11-17 22:34:39 +0900 | [diff] [blame] | 1238 | # TODO: set_module_xxx is confusing, apply similar function to module and target in better way. |
| 1239 | for arch_name, arch in target.arch.items(): |
| 1240 | set_module_flags(module.target[arch_name], arch.cflags, arch.defines) |
Motomu Utsumi | 3371d68 | 2022-11-28 16:56:52 +0900 | [diff] [blame] | 1241 | # -Xclang -target-feature -Xclang +mte are used to enable MTE (Memory Tagging Extensions). |
| 1242 | # Flags which does not start with '-' could not be in the cflags so enabling MTE by |
| 1243 | # -march and -mcpu Feature Modifiers. MTE is only available on arm64. This is needed for |
| 1244 | # building //base/allocator/partition_allocator:partition_alloc for arm64. |
| 1245 | if '+mte' in arch.cflags and arch_name == 'android_arm64': |
| 1246 | module.target[arch_name].cflags.add('-march=armv8-a+memtag') |
Motomu Utsumi | f0f4768 | 2022-11-17 22:34:39 +0900 | [diff] [blame] | 1247 | set_module_include_dirs(module.target[arch_name], arch.cflags, arch.include_dirs) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1248 | |
Mohannad Farrag | f2391cc | 2022-11-29 13:26:32 +0000 | [diff] [blame] | 1249 | module.host_supported = target.host_supported() |
| 1250 | module.device_supported = target.device_supported() |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1251 | |
Motomu Utsumi | 8ca1241 | 2022-11-30 16:27:30 +0900 | [diff] [blame] | 1252 | if module.is_genrule(): |
| 1253 | module.apex_available.add(tethering_apex) |
| 1254 | |
Mohannad Farrag | f2391cc | 2022-11-29 13:26:32 +0000 | [diff] [blame] | 1255 | if module.is_compiled(): |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1256 | # Don't try to inject library/source dependencies into genrules or |
| 1257 | # filegroups because they are not compiled in the traditional sense. |
| 1258 | module.defaults = [defaults_module] |
| 1259 | for lib in target.libs: |
| 1260 | # Generally library names should be mangled as 'libXXX', unless they |
| 1261 | # are HAL libraries (e.g., android.hardware.health@2.0) or AIDL c++ / NDK |
| 1262 | # libraries (e.g. "android.hardware.power.stats-V1-cpp") |
| 1263 | android_lib = lib if '@' in lib or "-cpp" in lib or "-ndk" in lib \ |
| 1264 | else 'lib' + lib |
| 1265 | if lib in shared_library_allowlist: |
| 1266 | module.add_android_shared_lib(android_lib) |
| 1267 | if lib in static_library_allowlist: |
| 1268 | module.add_android_static_lib(android_lib) |
| 1269 | |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1270 | # If the module is a static library, export all the generated headers. |
| 1271 | if module.type == 'cc_library_static': |
| 1272 | module.export_generated_headers = module.generated_headers |
| 1273 | |
Motomu Utsumi | ee47af6 | 2022-11-30 16:41:15 +0900 | [diff] [blame] | 1274 | if module.name == 'cronet_aml_components_cronet_android_cronet': |
| 1275 | if target.output_name is None: |
| 1276 | raise Error('Failed to get output_name for libcronet name') |
| 1277 | # .so file name needs to match with CronetLibraryLoader.java (e.g. libcronet.109.0.5386.0.so) |
| 1278 | # So setting the output name based on the output_name from the desc.json |
| 1279 | module.stem = 'lib' + target.output_name |
| 1280 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1281 | # dep_name is an unmangled GN target name (e.g. //foo:bar(toolchain)). |
Motomu Utsumi | f1daa23 | 2022-11-08 13:28:37 +0900 | [diff] [blame] | 1282 | # Currently, only one module is generated from target even target has multiple toolchains. |
| 1283 | # And module is generated based on the first visited target. |
| 1284 | # Sort deps before iteration to make result deterministic. |
| 1285 | all_deps = sorted(target.deps | target.source_set_deps | target.transitive_proto_deps) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1286 | for dep_name in all_deps: |
Patrick Rohr | 5cc46e0 | 2022-10-26 14:32:45 -0700 | [diff] [blame] | 1287 | # |builtin_deps| override GN deps with Android-specific ones. See the |
| 1288 | # config in the top of this file. |
Patrick Rohr | 0787666 | 2022-11-15 22:55:23 -0800 | [diff] [blame] | 1289 | if dep_name in builtin_deps: |
Patrick Rohr | 25926e6 | 2022-12-14 19:55:57 -0800 | [diff] [blame] | 1290 | builtin_deps[dep_name](module, None) |
Patrick Rohr | 5cc46e0 | 2022-10-26 14:32:45 -0700 | [diff] [blame] | 1291 | continue |
| 1292 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1293 | dep_module = create_modules_from_target(blueprint, gn, dep_name) |
| 1294 | |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 1295 | if dep_module is None: |
| 1296 | continue |
Motomu Utsumi | e246feb | 2022-11-01 17:25:56 +0900 | [diff] [blame] | 1297 | # TODO: Proper dependency check for genrule. |
| 1298 | # Currently, only propagating genrule dependencies. |
| 1299 | # Also, currently, all the dependencies are propagated upwards. |
| 1300 | # in gn, public_deps should be propagated but deps should not. |
| 1301 | # Not sure this information is available in the desc.json. |
| 1302 | # Following rule works for adding android_runtime_jni_headers to base:base. |
| 1303 | # If this doesn't work for other target, hardcoding for specific target |
| 1304 | # might be better. |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1305 | if module.is_genrule() and dep_module.is_genrule(): |
| 1306 | module.genrule_headers.add(dep_module.name) |
| 1307 | module.genrule_headers.update(dep_module.genrule_headers) |
Motomu Utsumi | e246feb | 2022-11-01 17:25:56 +0900 | [diff] [blame] | 1308 | |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 1309 | # For filegroups, and genrule, recurse but don't apply the |
Patrick Rohr | a6ce023 | 2022-11-16 22:09:01 -0800 | [diff] [blame] | 1310 | # deps. |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1311 | if not module.is_compiled() or module.is_genrule(): |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1312 | continue |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1313 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1314 | if dep_module.type == 'cc_library_shared': |
| 1315 | module.shared_libs.add(dep_module.name) |
| 1316 | elif dep_module.type == 'cc_library_static': |
| 1317 | module.static_libs.add(dep_module.name) |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 1318 | elif dep_module.type == 'cc_object': |
Mohannad Farrag | f2391cc | 2022-11-29 13:26:32 +0000 | [diff] [blame] | 1319 | module.merge_attribute('generated_headers', dep_module, target.arch.keys()) |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 1320 | if module.type != 'cc_object': |
| 1321 | if dep_module.has_input_files(): |
| 1322 | # Only add it as part of srcs if the dep_module has input files otherwise |
| 1323 | # this would throw an error. |
| 1324 | module.srcs.add(":" + dep_module.name) |
Mohannad Farrag | f2391cc | 2022-11-29 13:26:32 +0000 | [diff] [blame] | 1325 | module.merge_attribute('export_generated_headers', dep_module, |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 1326 | target.arch.keys(), 'generated_headers') |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1327 | elif dep_module.type == 'cc_genrule': |
Mohannad Farrag | f2391cc | 2022-11-29 13:26:32 +0000 | [diff] [blame] | 1328 | module.merge_attribute('generated_headers', dep_module, [], 'genrule_headers') |
| 1329 | module.merge_attribute('srcs', dep_module, [], 'genrule_srcs') |
| 1330 | module.merge_attribute('shared_libs', dep_module, [], 'genrule_shared_libs') |
| 1331 | module.merge_attribute('header_libs', dep_module, [], 'genrule_header_libs') |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1332 | if module.type not in ["cc_object"]: |
Mohannad Farrag | f2391cc | 2022-11-29 13:26:32 +0000 | [diff] [blame] | 1333 | module.merge_attribute('export_generated_headers', dep_module, [], |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1334 | 'genrule_headers') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1335 | elif dep_module.type == 'cc_binary': |
| 1336 | continue # Ignore executables deps (used by cmdline integration tests). |
| 1337 | else: |
| 1338 | raise Error('Unknown dep %s (%s) for target %s' % |
| 1339 | (dep_module.name, dep_module.type, module.name)) |
| 1340 | |
Patrick Rohr | b51878f | 2022-11-16 23:49:03 -0800 | [diff] [blame] | 1341 | for arch_name, arch in target.arch.items(): |
| 1342 | for dep_name in arch.deps: |
Patrick Rohr | 25926e6 | 2022-12-14 19:55:57 -0800 | [diff] [blame] | 1343 | # |builtin_deps| override GN deps with Android-specific ones. See the |
| 1344 | # config in the top of this file. |
| 1345 | if dep_name in builtin_deps: |
| 1346 | builtin_deps[dep_name](module, arch_name) |
| 1347 | continue |
Patrick Rohr | b51878f | 2022-11-16 23:49:03 -0800 | [diff] [blame] | 1348 | dep_module = create_modules_from_target(blueprint, gn, dep_name) |
| 1349 | # Arch-specific dependencies currently only include cc_library_static. |
| 1350 | # Revisit this approach once we need to support more target types. |
| 1351 | if dep_module.type == 'cc_library_static': |
| 1352 | module.target[arch_name].static_libs.add(dep_module.name) |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1353 | elif dep_module.type == 'cc_genrule': |
| 1354 | if dep_module.name.endswith(arch_name): |
| 1355 | module.target[arch_name].generated_headers.update(dep_module.genrule_headers) |
| 1356 | module.target[arch_name].srcs.update(dep_module.genrule_srcs) |
| 1357 | module.target[arch_name].shared_libs.update(dep_module.genrule_shared_libs) |
| 1358 | module.target[arch_name].header_libs.update(dep_module.genrule_header_libs) |
| 1359 | if module.type not in ["cc_object"]: |
| 1360 | module.target[arch_name].export_generated_headers.update( |
| 1361 | dep_module.genrule_headers) |
Patrick Rohr | 7069556 | 2022-12-14 19:45:34 -0800 | [diff] [blame] | 1362 | elif dep_module.type == 'cc_object': |
| 1363 | if dep_module.has_input_files(): |
| 1364 | # Only add it as part of srcs if the dep_module has input files otherwise |
| 1365 | # this would throw an error. |
| 1366 | module.target[arch_name].srcs.add(":" + dep_module.name) |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 1367 | else: |
| 1368 | raise Error('Unsupported arch-specific dependency %s of target %s with type %s' % |
| 1369 | (dep_module.name, target.name, dep_module.type)) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1370 | return module |
| 1371 | |
Mohannad Farrag | 3d3d613 | 2022-12-06 18:11:48 +0000 | [diff] [blame] | 1372 | def create_java_jni_preprocessor(blueprint): |
| 1373 | bp_module_name = module_prefix + 'java_jni_annotation_preprocessor' |
| 1374 | module = Module('java_plugin', bp_module_name, '//base/android/jni_generator:jni_processor') |
| 1375 | module.srcs.update( |
| 1376 | [ |
| 1377 | "base/android/jni_generator/java/src/org/chromium/jni_generator/JniProcessor.java", |
| 1378 | # Avoids a circular dependency with base:base_java. This is okay because |
| 1379 | # no target should ever expect to package an annotation processor. |
| 1380 | "build/android/java/src/org/chromium/build/annotations/CheckDiscard.java", |
| 1381 | "build/android/java/src/org/chromium/build/annotations/MainDex.java", |
Mohannad Farrag | 89f38e4 | 2022-12-06 18:54:46 +0000 | [diff] [blame] | 1382 | "base/android/java/src/org/chromium/base/JniStaticTestMocker.java", |
| 1383 | "base/android/java/src/org/chromium/base/NativeLibraryLoadedStatus.java", |
| 1384 | "base/android/java/src/org/chromium/base/annotations/NativeMethods.java", |
| 1385 | "base/android/java/src/org/chromium/base/JniException.java", |
| 1386 | ":cronet_aml_build_android_build_config_gen", |
Mohannad Farrag | 3d3d613 | 2022-12-06 18:11:48 +0000 | [diff] [blame] | 1387 | ]) |
Mohannad Farrag | 89f38e4 | 2022-12-06 18:54:46 +0000 | [diff] [blame] | 1388 | module.static_libs.update({ |
| 1389 | "javapoet", |
| 1390 | "guava", |
| 1391 | "auto_service_annotations", |
| 1392 | }) |
| 1393 | module.processor_class = "org.chromium.jni_generator.JniProcessor" |
Mohannad Farrag | 3d3d613 | 2022-12-06 18:11:48 +0000 | [diff] [blame] | 1394 | blueprint.add_module(module) |
| 1395 | return module |
| 1396 | |
Patrick Rohr | b18aca2 | 2022-11-04 15:07:32 -0700 | [diff] [blame] | 1397 | def create_java_module(blueprint, gn): |
| 1398 | bp_module_name = module_prefix + 'java' |
| 1399 | module = Module('java_library', bp_module_name, '//gn:java') |
Mohannad Farrag | 21562d6 | 2022-11-07 13:09:31 +0000 | [diff] [blame] | 1400 | module.srcs.update([gn_utils.label_to_path(source) for source in gn.java_sources]) |
Mohannad Farrag | e815d86 | 2022-12-06 17:51:43 +0000 | [diff] [blame] | 1401 | module.libs = { |
Motomu Utsumi | df6024d | 2022-12-07 16:39:11 +0900 | [diff] [blame] | 1402 | "androidx.annotation_annotation", |
| 1403 | "jsr305", |
Motomu Utsumi | 05a49a5 | 2022-12-09 18:21:13 +0900 | [diff] [blame] | 1404 | "androidx.core_core-nodeps", |
Motomu Utsumi | df6024d | 2022-12-07 16:39:11 +0900 | [diff] [blame] | 1405 | "androidx.collection_collection", |
Motomu Utsumi | 05a49a5 | 2022-12-09 18:21:13 +0900 | [diff] [blame] | 1406 | "androidx.annotation_annotation-experimental-nodeps", |
Motomu Utsumi | df6024d | 2022-12-07 16:39:11 +0900 | [diff] [blame] | 1407 | "android-support-multidex", |
Motomu Utsumi | f985e03 | 2022-12-09 15:53:39 +0900 | [diff] [blame] | 1408 | "framework-connectivity.stubs.module_lib", |
| 1409 | "framework-connectivity-t.stubs.module_lib", |
| 1410 | "framework-tethering.stubs.module_lib", |
| 1411 | "framework-wifi.stubs.module_lib", |
| 1412 | "framework-mediaprovider.stubs.module_lib", |
Mohannad Farrag | e815d86 | 2022-12-06 17:51:43 +0000 | [diff] [blame] | 1413 | } |
Mohannad Farrag | b30d371 | 2022-12-06 17:27:04 +0000 | [diff] [blame] | 1414 | module.aidl["include_dirs"] = {"frameworks/base/core/java/"} |
| 1415 | module.aidl["local_include_dirs"] = {"base/android/java/src/"} |
Motomu Utsumi | f985e03 | 2022-12-09 15:53:39 +0900 | [diff] [blame] | 1416 | module.sdk_version = "module_current" |
Motomu Utsumi | 42acf6d | 2022-12-09 16:04:10 +0900 | [diff] [blame] | 1417 | module.apex_available.add(tethering_apex) |
| 1418 | # TODO: remove following workaround required to make this module visible to make (b/203203405) |
| 1419 | module.apex_available.add("//apex_available:platform") |
Mohannad Farrag | 6a2d88a | 2022-11-28 19:33:48 +0000 | [diff] [blame] | 1420 | for dep in gn.java_actions: |
Mohannad Farrag | 9c2cee1 | 2022-12-06 17:11:25 +0000 | [diff] [blame] | 1421 | target = gn.get_target(dep) |
| 1422 | if target.script == '//build/android/gyp/gcc_preprocess.py': |
| 1423 | module.srcs.add(':' + create_gcc_preprocess_modules(blueprint, target).name) |
| 1424 | else: |
| 1425 | module.srcs.add(':' + create_action_module(blueprint, target, 'java_genrule').name) |
Mohannad Farrag | 3d3d613 | 2022-12-06 18:11:48 +0000 | [diff] [blame] | 1426 | preprocessor_module = create_java_jni_preprocessor(blueprint) |
| 1427 | module.plugins.add(preprocessor_module.name) |
Patrick Rohr | b18aca2 | 2022-11-04 15:07:32 -0700 | [diff] [blame] | 1428 | blueprint.add_module(module) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1429 | |
Patrick Rohr | 6ef2272 | 2022-11-18 18:24:01 -0800 | [diff] [blame] | 1430 | def update_jni_registration_module(module, gn): |
Motomu Utsumi | 47d122f | 2022-11-10 17:32:23 +0900 | [diff] [blame] | 1431 | # TODO: deny list is in the arg of jni_registration_generator.py. Should not be hardcoded |
| 1432 | deny_list = [ |
| 1433 | '//base/android/java/src/org/chromium/base/library_loader/LibraryLoader.java', |
| 1434 | '//base/android/java/src/org/chromium/base/library_loader/LibraryPrefetcher.java', |
| 1435 | '//base/android/java/src/org/chromium/base/process_launcher/ChildProcessService.java', |
| 1436 | '//base/android/java/src/org/chromium/base/SysUtils.java'] |
| 1437 | |
Motomu Utsumi | e3ce770 | 2022-11-10 16:22:11 +0900 | [diff] [blame] | 1438 | # TODO: java_sources might not contain all the required java files |
Motomu Utsumi | 47d122f | 2022-11-10 17:32:23 +0900 | [diff] [blame] | 1439 | module.srcs.update([gn_utils.label_to_path(source) |
Motomu Utsumi | 6e51412 | 2022-12-05 17:51:40 +0900 | [diff] [blame] | 1440 | for source in gn.java_sources |
| 1441 | if source.endswith('.java') and source not in deny_list]) |
Motomu Utsumi | e3ce770 | 2022-11-10 16:22:11 +0900 | [diff] [blame] | 1442 | |
Motomu Utsumi | a71281c | 2022-11-18 15:19:00 +0900 | [diff] [blame] | 1443 | def create_blueprint_for_targets(gn, targets): |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1444 | """Generate a blueprint for a list of GN targets.""" |
| 1445 | blueprint = Blueprint() |
| 1446 | |
| 1447 | # Default settings used by all modules. |
| 1448 | defaults = Module('cc_defaults', defaults_module, '//gn:default_deps') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1449 | defaults.cflags = [ |
Patrick Rohr | 3ce7477 | 2022-11-11 14:19:58 -0800 | [diff] [blame] | 1450 | '-DGOOGLE_PROTOBUF_NO_RTTI', |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1451 | '-Wno-error=return-type', |
Patrick Rohr | 3a1ec1d | 2022-10-31 13:30:17 -0700 | [diff] [blame] | 1452 | '-Wno-non-virtual-dtor', |
Patrick Rohr | 5c70002 | 2022-11-08 19:33:07 -0800 | [diff] [blame] | 1453 | '-Wno-macro-redefined', |
Patrick Rohr | 9806515 | 2022-10-31 14:49:58 -0700 | [diff] [blame] | 1454 | '-Wno-missing-field-initializers', |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1455 | '-Wno-sign-compare', |
| 1456 | '-Wno-sign-promo', |
| 1457 | '-Wno-unused-parameter', |
Mohannad Farrag | 54d5244 | 2022-11-21 16:27:02 +0000 | [diff] [blame] | 1458 | '-Wno-null-pointer-subtraction', # Needed to libevent |
Mohannad Farrag | d98a96d | 2022-11-10 14:56:19 +0000 | [diff] [blame] | 1459 | '-Wno-deprecated-non-prototype', # needed for zlib |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1460 | '-fvisibility=hidden', |
Motomu Utsumi | ba02094 | 2022-11-14 15:15:41 +0900 | [diff] [blame] | 1461 | '-Wno-ambiguous-reversed-operator', # needed for icui18n |
Motomu Utsumi | b1ec878 | 2022-11-14 15:25:57 +0900 | [diff] [blame] | 1462 | '-Wno-unreachable-code-loop-increment', # needed for icui18n |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1463 | '-O2', |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 1464 | '-fPIC', |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1465 | ] |
Patrick Rohr | c03f1bb | 2022-11-18 16:13:17 -0800 | [diff] [blame] | 1466 | # Chromium builds do not add a dependency for headers found inside the |
| 1467 | # sysroot, so they are added globally via defaults. |
| 1468 | defaults.target['android'].header_libs = [ |
| 1469 | 'media_ndk_headers', |
| 1470 | 'jni_headers', |
| 1471 | ] |
Patrick Rohr | 5446df8 | 2022-11-18 14:54:55 -0800 | [diff] [blame] | 1472 | defaults.target['host'].cflags = [ |
| 1473 | # -DANDROID is added by default but target.defines contain -DANDROID if |
| 1474 | # it's required. So adding -UANDROID to cancel default -DANDROID if it's |
| 1475 | # not specified. |
| 1476 | # Note: -DANDROID is not consistently applied across the chromium code |
| 1477 | # base, so it is removed unconditionally for host targets. |
| 1478 | '-UANDROID', |
| 1479 | ] |
Patrick Rohr | 61f2acb | 2022-10-31 14:08:18 -0700 | [diff] [blame] | 1480 | defaults.stl = 'none' |
Motomu Utsumi | 8ca1241 | 2022-11-30 16:27:30 +0900 | [diff] [blame] | 1481 | defaults.min_sdk_version = 29 |
| 1482 | defaults.apex_available.add(tethering_apex) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1483 | blueprint.add_module(defaults) |
Patrick Rohr | 344b247 | 2022-10-25 11:32:15 -0700 | [diff] [blame] | 1484 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1485 | for target in targets: |
| 1486 | create_modules_from_target(blueprint, gn, target) |
Patrick Rohr | b18aca2 | 2022-11-04 15:07:32 -0700 | [diff] [blame] | 1487 | |
| 1488 | create_java_module(blueprint, gn) |
Patrick Rohr | 6ef2272 | 2022-11-18 18:24:01 -0800 | [diff] [blame] | 1489 | for module in blueprint.modules.values(): |
| 1490 | if 'cronet_jni_registration' in module.name: |
| 1491 | update_jni_registration_module(module, gn) |
Patrick Rohr | a7d029d | 2022-11-08 12:23:11 -0800 | [diff] [blame] | 1492 | |
| 1493 | # Merge in additional hardcoded arguments. |
| 1494 | for module in blueprint.modules.values(): |
| 1495 | for key, add_val in additional_args.get(module.name, []): |
| 1496 | curr = getattr(module, key) |
| 1497 | if add_val and isinstance(add_val, set) and isinstance(curr, set): |
| 1498 | curr.update(add_val) |
| 1499 | elif isinstance(add_val, str) and (not curr or isinstance(curr, str)): |
| 1500 | setattr(module, key, add_val) |
| 1501 | elif isinstance(add_val, bool) and (not curr or isinstance(curr, bool)): |
| 1502 | setattr(module, key, add_val) |
| 1503 | elif isinstance(add_val, dict) and isinstance(curr, dict): |
| 1504 | curr.update(add_val) |
| 1505 | elif isinstance(add_val, dict) and isinstance(curr, Target): |
| 1506 | curr.__dict__.update(add_val) |
| 1507 | else: |
| 1508 | raise Error('Unimplemented type %r of additional_args: %r' % |
| 1509 | (type(add_val), key)) |
| 1510 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1511 | return blueprint |
| 1512 | |
| 1513 | |
| 1514 | def main(): |
| 1515 | parser = argparse.ArgumentParser( |
| 1516 | description='Generate Android.bp from a GN description.') |
| 1517 | parser.add_argument( |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1518 | '--desc', |
Motomu Utsumi | 879dec8 | 2022-11-18 15:25:12 +0900 | [diff] [blame] | 1519 | help='GN description (e.g., gn desc out --format=json --all-toolchains "//*".' + |
| 1520 | 'You can specify multiple --desc options for different target_cpu', |
| 1521 | required=True, |
| 1522 | action='append' |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1523 | ) |
| 1524 | parser.add_argument( |
| 1525 | '--extras', |
| 1526 | help='Extra targets to include at the end of the Blueprint file', |
| 1527 | default=os.path.join(gn_utils.repo_root(), 'Android.bp.extras'), |
| 1528 | ) |
| 1529 | parser.add_argument( |
| 1530 | '--output', |
| 1531 | help='Blueprint file to create', |
| 1532 | default=os.path.join(gn_utils.repo_root(), 'Android.bp'), |
| 1533 | ) |
| 1534 | parser.add_argument( |
Patrick Rohr | 1622894 | 2022-10-26 14:00:26 -0700 | [diff] [blame] | 1535 | '-v', |
| 1536 | '--verbose', |
| 1537 | help='Print debug logs.', |
| 1538 | action='store_true', |
| 1539 | ) |
| 1540 | parser.add_argument( |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1541 | 'targets', |
| 1542 | nargs=argparse.REMAINDER, |
Patrick Rohr | 1aa504a | 2022-10-25 10:30:42 -0700 | [diff] [blame] | 1543 | help='Targets to include in the blueprint (e.g., "//:perfetto_tests")' |
| 1544 | ) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1545 | args = parser.parse_args() |
| 1546 | |
Patrick Rohr | 1622894 | 2022-10-26 14:00:26 -0700 | [diff] [blame] | 1547 | if args.verbose: |
| 1548 | log.basicConfig(format='%(levelname)s:%(funcName)s:%(message)s', level=log.DEBUG) |
| 1549 | |
Patrick Rohr | d0077b7 | 2022-11-15 12:43:26 -0800 | [diff] [blame] | 1550 | targets = args.targets or default_targets |
Patrick Rohr | 0913f0b | 2022-12-13 09:13:20 -0800 | [diff] [blame] | 1551 | gn = gn_utils.GnParser(builtin_deps) |
Motomu Utsumi | 879dec8 | 2022-11-18 15:25:12 +0900 | [diff] [blame] | 1552 | for desc_file in args.desc: |
| 1553 | with open(desc_file) as f: |
| 1554 | desc = json.load(f) |
| 1555 | for target in targets: |
| 1556 | gn.parse_gn_desc(desc, target) |
Motomu Utsumi | a71281c | 2022-11-18 15:19:00 +0900 | [diff] [blame] | 1557 | blueprint = create_blueprint_for_targets(gn, targets) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1558 | project_root = os.path.abspath(os.path.dirname(os.path.dirname(__file__))) |
| 1559 | tool_name = os.path.relpath(os.path.abspath(__file__), project_root) |
| 1560 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1561 | # Add any proto groups to the blueprint. |
| 1562 | for l_name, t_names in proto_groups.items(): |
| 1563 | create_proto_group_modules(blueprint, gn, l_name, t_names) |
| 1564 | |
| 1565 | output = [ |
Patrick Rohr | 5478b39 | 2022-10-25 09:58:50 -0700 | [diff] [blame] | 1566 | """// Copyright (C) 2022 The Android Open Source Project |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1567 | // |
| 1568 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 1569 | // you may not use this file except in compliance with the License. |
| 1570 | // You may obtain a copy of the License at |
| 1571 | // |
| 1572 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 1573 | // |
| 1574 | // Unless required by applicable law or agreed to in writing, software |
| 1575 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 1576 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 1577 | // See the License for the specific language governing permissions and |
| 1578 | // limitations under the License. |
| 1579 | // |
| 1580 | // This file is automatically generated by %s. Do not edit. |
| 1581 | """ % (tool_name) |
| 1582 | ] |
| 1583 | blueprint.to_string(output) |
Patrick Rohr | cb98e9b | 2022-10-25 09:57:02 -0700 | [diff] [blame] | 1584 | if os.path.exists(args.extras): |
| 1585 | with open(args.extras, 'r') as r: |
| 1586 | for line in r: |
| 1587 | output.append(line.rstrip("\n\r")) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1588 | |
| 1589 | out_files = [] |
| 1590 | |
| 1591 | # Generate the Android.bp file. |
| 1592 | out_files.append(args.output + '.swp') |
| 1593 | with open(out_files[-1], 'w') as f: |
| 1594 | f.write('\n'.join(output)) |
| 1595 | # Text files should have a trailing EOL. |
| 1596 | f.write('\n') |
| 1597 | |
Patrick Rohr | 94693eb | 2022-10-25 10:09:16 -0700 | [diff] [blame] | 1598 | return 0 |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1599 | |
| 1600 | |
| 1601 | if __name__ == '__main__': |
| 1602 | sys.exit(main()) |