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