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