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 |
| 29 | import collections |
| 30 | import json |
Patrick Rohr | 1622894 | 2022-10-26 14:00:26 -0700 | [diff] [blame] | 31 | import logging as log |
Patrick Rohr | 3a2c3dd | 2022-11-29 22:29:36 -0800 | [diff] [blame] | 32 | import operator |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 33 | import os |
| 34 | import re |
| 35 | import sys |
Motomu Utsumi | c6277d9 | 2022-11-07 15:15:17 +0900 | [diff] [blame] | 36 | import copy |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 37 | |
| 38 | import gn_utils |
| 39 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 40 | ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) |
| 41 | |
Patrick Rohr | 0629636 | 2022-11-10 21:37:33 -0800 | [diff] [blame] | 42 | # Default targets to translate to the blueprint file. |
| 43 | default_targets = [ |
| 44 | '//components/cronet/android:cronet', |
Motomu Utsumi | abbfdc3 | 2022-11-25 12:19:23 +0900 | [diff] [blame] | 45 | '//components/cronet:cronet_package', |
Patrick Rohr | 0629636 | 2022-11-10 21:37:33 -0800 | [diff] [blame] | 46 | ] |
| 47 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 48 | # Defines a custom init_rc argument to be applied to the corresponding output |
| 49 | # blueprint target. |
| 50 | target_initrc = { |
Patrick Rohr | c36ef42 | 2022-10-25 10:38:05 -0700 | [diff] [blame] | 51 | # TODO: this can probably be removed. |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 52 | } |
| 53 | |
| 54 | target_host_supported = [ |
Patrick Rohr | dc38394 | 2022-10-25 10:45:29 -0700 | [diff] [blame] | 55 | # TODO: remove if this is not useful for the cronet build. |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 56 | ] |
| 57 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 58 | # Proto target groups which will be made public. |
| 59 | proto_groups = { |
Patrick Rohr | 95212a2 | 2022-10-25 09:53:13 -0700 | [diff] [blame] | 60 | # TODO: remove if this is not used for the cronet build. |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 61 | } |
| 62 | |
| 63 | # All module names are prefixed with this string to avoid collisions. |
Patrick Rohr | 61b2bad | 2022-10-25 10:49:20 -0700 | [diff] [blame] | 64 | module_prefix = 'cronet_aml_' |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 65 | |
| 66 | # Shared libraries which are directly translated to Android system equivalents. |
| 67 | shared_library_allowlist = [ |
| 68 | 'android', |
| 69 | 'android.hardware.atrace@1.0', |
| 70 | 'android.hardware.health@2.0', |
| 71 | 'android.hardware.health-V1-ndk', |
| 72 | 'android.hardware.power.stats@1.0', |
| 73 | "android.hardware.power.stats-V1-cpp", |
| 74 | 'base', |
| 75 | 'binder', |
| 76 | 'binder_ndk', |
| 77 | 'cutils', |
| 78 | 'hidlbase', |
| 79 | 'hidltransport', |
| 80 | 'hwbinder', |
| 81 | 'incident', |
| 82 | 'log', |
| 83 | 'services', |
| 84 | 'statssocket', |
| 85 | "tracingproxy", |
| 86 | 'utils', |
| 87 | ] |
| 88 | |
| 89 | # Static libraries which are directly translated to Android system equivalents. |
| 90 | static_library_allowlist = [ |
| 91 | 'statslog_perfetto', |
| 92 | ] |
| 93 | |
Patrick Rohr | d9dd3b9 | 2022-11-09 16:15:30 -0800 | [diff] [blame] | 94 | # Include directories that will be removed from all targets. |
| 95 | local_include_dirs_denylist = [ |
Patrick Rohr | d9dd3b9 | 2022-11-09 16:15:30 -0800 | [diff] [blame] | 96 | ] |
| 97 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 98 | # Name of the module which settings such as compiler flags for all other |
| 99 | # modules. |
| 100 | defaults_module = module_prefix + 'defaults' |
| 101 | |
| 102 | # Location of the project in the Android source tree. |
Patrick Rohr | 76ceeb5 | 2022-11-07 14:18:58 -0800 | [diff] [blame] | 103 | tree_path = 'external/chromium_org' |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 104 | |
| 105 | # Path for the protobuf sources in the standalone build. |
| 106 | buildtools_protobuf_src = '//buildtools/protobuf/src' |
| 107 | |
| 108 | # Location of the protobuf src dir in the Android source tree. |
| 109 | android_protobuf_src = 'external/protobuf/src' |
| 110 | |
| 111 | # Compiler flags which are passed through to the blueprint. |
Motomu Utsumi | c8b7bea | 2022-11-16 18:12:44 +0900 | [diff] [blame] | 112 | cflag_allowlist = [ |
Motomu Utsumi | cf68d73 | 2022-11-16 18:15:21 +0900 | [diff] [blame] | 113 | # needed for zlib:zlib |
| 114 | "-mpclmul", |
| 115 | # needed for zlib:zlib |
| 116 | "-mssse3", |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 117 | # needed for zlib:zlib |
| 118 | "-msse3", |
| 119 | # needed for zlib:zlib |
| 120 | "-msse4.2", |
Motomu Utsumi | c8b7bea | 2022-11-16 18:12:44 +0900 | [diff] [blame] | 121 | ] |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 122 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 123 | # Additional arguments to apply to Android.bp rules. |
| 124 | additional_args = { |
Patrick Rohr | 2267a0a | 2022-11-08 18:59:34 -0800 | [diff] [blame] | 125 | # TODO: remove if not needed. |
Patrick Rohr | d90025f | 2022-11-11 14:18:35 -0800 | [diff] [blame] | 126 | 'cronet_aml_components_cronet_android_cronet': [ |
| 127 | ('linker_scripts', { |
| 128 | 'base/android/library_loader/anchor_functions.lds', |
| 129 | }), |
| 130 | ], |
Patrick Rohr | bb0956e | 2022-11-09 15:37:16 -0800 | [diff] [blame] | 131 | 'cronet_aml_net_net': [ |
Patrick Rohr | 9f4d3e3 | 2022-11-09 16:37:31 -0800 | [diff] [blame] | 132 | ('export_static_lib_headers', { |
| 133 | 'cronet_aml_net_third_party_quiche_quiche', |
| 134 | 'cronet_aml_crypto_crypto', |
| 135 | }), |
Mohannad Farrag | 37388fa | 2022-11-10 20:42:13 +0000 | [diff] [blame] | 136 | ], |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 137 | } |
| 138 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 139 | # Android equivalents for third-party libraries that the upstream project |
| 140 | # depends on. |
| 141 | builtin_deps = { |
Patrick Rohr | 14ee093 | 2022-11-15 12:10:27 -0800 | [diff] [blame] | 142 | '//net/tools/root_store_tool:root_store_tool': |
| 143 | lambda x: None, |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 144 | } |
| 145 | |
Motomu Utsumi | 8ca1241 | 2022-11-30 16:27:30 +0900 | [diff] [blame] | 146 | # Name of tethering apex module |
| 147 | tethering_apex = "com.android.tethering" |
| 148 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 149 | # ---------------------------------------------------------------------------- |
| 150 | # End of configuration. |
| 151 | # ---------------------------------------------------------------------------- |
| 152 | |
| 153 | |
| 154 | class Error(Exception): |
| 155 | pass |
| 156 | |
| 157 | |
| 158 | class ThrowingArgumentParser(argparse.ArgumentParser): |
| 159 | |
| 160 | def __init__(self, context): |
| 161 | super(ThrowingArgumentParser, self).__init__() |
| 162 | self.context = context |
| 163 | |
| 164 | def error(self, message): |
| 165 | raise Error('%s: %s' % (self.context, message)) |
| 166 | |
| 167 | |
| 168 | def write_blueprint_key_value(output, name, value, sort=True): |
| 169 | """Writes a Blueprint key-value pair to the output""" |
| 170 | |
| 171 | if isinstance(value, bool): |
| 172 | if value: |
| 173 | output.append(' %s: true,' % name) |
| 174 | else: |
| 175 | output.append(' %s: false,' % name) |
| 176 | return |
| 177 | if not value: |
| 178 | return |
| 179 | if isinstance(value, set): |
| 180 | value = sorted(value) |
| 181 | if isinstance(value, list): |
| 182 | output.append(' %s: [' % name) |
| 183 | for item in sorted(value) if sort else value: |
| 184 | output.append(' "%s",' % item) |
| 185 | output.append(' ],') |
| 186 | return |
| 187 | if isinstance(value, Target): |
| 188 | value.to_string(output) |
| 189 | return |
| 190 | if isinstance(value, dict): |
| 191 | kv_output = [] |
| 192 | for k, v in value.items(): |
| 193 | write_blueprint_key_value(kv_output, k, v) |
| 194 | |
| 195 | output.append(' %s: {' % name) |
| 196 | for line in kv_output: |
| 197 | output.append(' %s' % line) |
| 198 | output.append(' },') |
| 199 | return |
| 200 | output.append(' %s: "%s",' % (name, value)) |
| 201 | |
| 202 | |
| 203 | class Target(object): |
| 204 | """A target-scoped part of a module""" |
| 205 | |
| 206 | def __init__(self, name): |
| 207 | self.name = name |
Patrick Rohr | 5d399b3 | 2022-11-16 10:19:55 -0800 | [diff] [blame] | 208 | self.srcs = set() |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 209 | self.shared_libs = set() |
| 210 | self.static_libs = set() |
| 211 | self.whole_static_libs = set() |
Patrick Rohr | c03f1bb | 2022-11-18 16:13:17 -0800 | [diff] [blame] | 212 | self.header_libs = set() |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 213 | self.cflags = set() |
| 214 | self.dist = dict() |
| 215 | self.strip = dict() |
| 216 | self.stl = None |
Motomu Utsumi | 50ad217 | 2022-11-17 22:29:53 +0900 | [diff] [blame] | 217 | self.cppflags = set() |
Patrick Rohr | 3cd5ffb | 2022-11-18 17:40:55 -0800 | [diff] [blame] | 218 | self.local_include_dirs = set() |
Patrick Rohr | 8143516 | 2022-11-17 19:34:32 -0800 | [diff] [blame] | 219 | self.export_system_include_dirs = set() |
Mohannad Farrag | 631443e | 2022-11-21 16:17:01 +0000 | [diff] [blame] | 220 | self.generated_headers = set() |
| 221 | self.export_generated_headers = set() |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 222 | |
| 223 | def to_string(self, output): |
| 224 | nested_out = [] |
Patrick Rohr | 5d399b3 | 2022-11-16 10:19:55 -0800 | [diff] [blame] | 225 | self._output_field(nested_out, 'srcs') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 226 | self._output_field(nested_out, 'shared_libs') |
| 227 | self._output_field(nested_out, 'static_libs') |
| 228 | self._output_field(nested_out, 'whole_static_libs') |
Patrick Rohr | c03f1bb | 2022-11-18 16:13:17 -0800 | [diff] [blame] | 229 | self._output_field(nested_out, 'header_libs') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 230 | self._output_field(nested_out, 'cflags') |
| 231 | self._output_field(nested_out, 'stl') |
| 232 | self._output_field(nested_out, 'dist') |
| 233 | self._output_field(nested_out, 'strip') |
Motomu Utsumi | 50ad217 | 2022-11-17 22:29:53 +0900 | [diff] [blame] | 234 | self._output_field(nested_out, 'cppflags') |
| 235 | self._output_field(nested_out, 'local_include_dirs') |
Patrick Rohr | 8143516 | 2022-11-17 19:34:32 -0800 | [diff] [blame] | 236 | self._output_field(nested_out, 'export_system_include_dirs') |
Mohannad Farrag | 631443e | 2022-11-21 16:17:01 +0000 | [diff] [blame] | 237 | self._output_field(nested_out, 'generated_headers') |
| 238 | self._output_field(nested_out, 'export_generated_headers') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 239 | |
| 240 | if nested_out: |
| 241 | output.append(' %s: {' % self.name) |
| 242 | for line in nested_out: |
| 243 | output.append(' %s' % line) |
| 244 | output.append(' },') |
| 245 | |
| 246 | def _output_field(self, output, name, sort=True): |
| 247 | value = getattr(self, name) |
| 248 | return write_blueprint_key_value(output, name, value, sort) |
| 249 | |
| 250 | |
| 251 | class Module(object): |
| 252 | """A single module (e.g., cc_binary, cc_test) in a blueprint.""" |
| 253 | |
| 254 | def __init__(self, mod_type, name, gn_target): |
| 255 | self.type = mod_type |
| 256 | self.gn_target = gn_target |
| 257 | self.name = name |
| 258 | self.srcs = set() |
Patrick Rohr | 0787666 | 2022-11-15 22:55:23 -0800 | [diff] [blame] | 259 | self.comment = 'GN: ' + gn_target |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 260 | self.shared_libs = set() |
| 261 | self.static_libs = set() |
| 262 | self.whole_static_libs = set() |
| 263 | self.runtime_libs = set() |
| 264 | self.tools = set() |
| 265 | self.cmd = None |
| 266 | self.host_supported = False |
Patrick Rohr | cdda632 | 2022-11-15 22:44:16 -0800 | [diff] [blame] | 267 | self.device_supported = True |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 268 | self.vendor_available = False |
| 269 | self.init_rc = set() |
| 270 | self.out = set() |
| 271 | self.export_include_dirs = set() |
| 272 | self.generated_headers = set() |
| 273 | self.export_generated_headers = set() |
Patrick Rohr | bb0956e | 2022-11-09 15:37:16 -0800 | [diff] [blame] | 274 | self.export_static_lib_headers = set() |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 275 | self.defaults = set() |
| 276 | self.cflags = set() |
| 277 | self.include_dirs = set() |
Patrick Rohr | 3cd5ffb | 2022-11-18 17:40:55 -0800 | [diff] [blame] | 278 | self.local_include_dirs = set() |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 279 | self.header_libs = set() |
| 280 | self.required = set() |
Patrick Rohr | 3d8c728 | 2022-10-27 13:36:31 -0700 | [diff] [blame] | 281 | self.tool_files = set() |
Patrick Rohr | bfdc5fd | 2022-11-16 10:03:49 -0800 | [diff] [blame] | 282 | # target contains a dict of Targets indexed by os_arch. |
| 283 | # example: { 'android_x86': Target('android_x86') |
| 284 | self.target = dict() |
| 285 | self.target['android'] = Target('android') |
Patrick Rohr | 82e4074 | 2022-11-16 10:20:39 -0800 | [diff] [blame] | 286 | self.target['android_x86'] = Target('android_x86') |
| 287 | self.target['android_x86_64'] = Target('android_x86_64') |
| 288 | self.target['android_arm'] = Target('android_arm') |
| 289 | self.target['android_arm64'] = Target('android_arm64') |
Patrick Rohr | bfdc5fd | 2022-11-16 10:03:49 -0800 | [diff] [blame] | 290 | self.target['host'] = Target('host') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 291 | self.stl = None |
Patrick Rohr | b8f830a | 2022-10-31 11:18:57 -0700 | [diff] [blame] | 292 | self.cpp_std = None |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 293 | self.dist = dict() |
| 294 | self.strip = dict() |
| 295 | self.data = set() |
| 296 | self.apex_available = set() |
| 297 | self.min_sdk_version = None |
| 298 | self.proto = dict() |
Patrick Rohr | d90025f | 2022-11-11 14:18:35 -0800 | [diff] [blame] | 299 | self.linker_scripts = set() |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 300 | # The genrule_XXX below are properties that must to be propagated back |
| 301 | # on the module(s) that depend on the genrule. |
| 302 | self.genrule_headers = set() |
| 303 | self.genrule_srcs = set() |
| 304 | self.genrule_shared_libs = set() |
Patrick Rohr | a1a2787 | 2022-10-31 11:57:14 -0700 | [diff] [blame] | 305 | self.genrule_header_libs = set() |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 306 | self.version_script = None |
| 307 | self.test_suites = set() |
| 308 | self.test_config = None |
| 309 | self.stubs = {} |
Mohannad Farrag | 37388fa | 2022-11-10 20:42:13 +0000 | [diff] [blame] | 310 | self.cppflags = set() |
| 311 | self.rtti = False |
Motomu Utsumi | ee47af6 | 2022-11-30 16:41:15 +0900 | [diff] [blame] | 312 | # Name of the output. Used for setting .so file name for libcronet |
| 313 | self.stem = None |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 314 | |
| 315 | def to_string(self, output): |
| 316 | if self.comment: |
| 317 | output.append('// %s' % self.comment) |
| 318 | output.append('%s {' % self.type) |
| 319 | self._output_field(output, 'name') |
| 320 | self._output_field(output, 'srcs') |
| 321 | self._output_field(output, 'shared_libs') |
| 322 | self._output_field(output, 'static_libs') |
| 323 | self._output_field(output, 'whole_static_libs') |
| 324 | self._output_field(output, 'runtime_libs') |
| 325 | self._output_field(output, 'tools') |
| 326 | self._output_field(output, 'cmd', sort=False) |
| 327 | if self.host_supported: |
| 328 | self._output_field(output, 'host_supported') |
Patrick Rohr | cdda632 | 2022-11-15 22:44:16 -0800 | [diff] [blame] | 329 | if not self.device_supported: |
| 330 | self._output_field(output, 'device_supported') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 331 | if self.vendor_available: |
| 332 | self._output_field(output, 'vendor_available') |
| 333 | self._output_field(output, 'init_rc') |
| 334 | self._output_field(output, 'out') |
| 335 | self._output_field(output, 'export_include_dirs') |
| 336 | self._output_field(output, 'generated_headers') |
| 337 | self._output_field(output, 'export_generated_headers') |
Patrick Rohr | bb0956e | 2022-11-09 15:37:16 -0800 | [diff] [blame] | 338 | self._output_field(output, 'export_static_lib_headers') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 339 | self._output_field(output, 'defaults') |
| 340 | self._output_field(output, 'cflags') |
| 341 | self._output_field(output, 'include_dirs') |
Patrick Rohr | 3cd5ffb | 2022-11-18 17:40:55 -0800 | [diff] [blame] | 342 | self._output_field(output, 'local_include_dirs') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 343 | self._output_field(output, 'header_libs') |
| 344 | self._output_field(output, 'required') |
| 345 | self._output_field(output, 'dist') |
| 346 | self._output_field(output, 'strip') |
| 347 | self._output_field(output, 'tool_files') |
| 348 | self._output_field(output, 'data') |
| 349 | self._output_field(output, 'stl') |
Patrick Rohr | b8f830a | 2022-10-31 11:18:57 -0700 | [diff] [blame] | 350 | self._output_field(output, 'cpp_std') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 351 | self._output_field(output, 'apex_available') |
| 352 | self._output_field(output, 'min_sdk_version') |
| 353 | self._output_field(output, 'version_script') |
| 354 | self._output_field(output, 'test_suites') |
| 355 | self._output_field(output, 'test_config') |
| 356 | self._output_field(output, 'stubs') |
| 357 | self._output_field(output, 'proto') |
Patrick Rohr | d90025f | 2022-11-11 14:18:35 -0800 | [diff] [blame] | 358 | self._output_field(output, 'linker_scripts') |
Mohannad Farrag | 37388fa | 2022-11-10 20:42:13 +0000 | [diff] [blame] | 359 | self._output_field(output, 'cppflags') |
Motomu Utsumi | ee47af6 | 2022-11-30 16:41:15 +0900 | [diff] [blame] | 360 | self._output_field(output, 'stem') |
Mohannad Farrag | 37388fa | 2022-11-10 20:42:13 +0000 | [diff] [blame] | 361 | if self.rtti: |
| 362 | self._output_field(output, 'rtti') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 363 | |
| 364 | target_out = [] |
Patrick Rohr | 09ee70e | 2022-11-16 15:20:03 -0800 | [diff] [blame] | 365 | for arch, target in sorted(self.target.items()): |
Patrick Rohr | bfdc5fd | 2022-11-16 10:03:49 -0800 | [diff] [blame] | 366 | # _output_field calls getattr(self, arch). |
| 367 | setattr(self, arch, target) |
| 368 | self._output_field(target_out, arch) |
| 369 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 370 | if target_out: |
| 371 | output.append(' target: {') |
| 372 | for line in target_out: |
| 373 | output.append(' %s' % line) |
| 374 | output.append(' },') |
| 375 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 376 | output.append('}') |
| 377 | output.append('') |
| 378 | |
| 379 | def add_android_static_lib(self, lib): |
| 380 | if self.type == 'cc_binary_host': |
| 381 | raise Exception('Adding Android static lib for host tool is unsupported') |
| 382 | elif self.host_supported: |
Patrick Rohr | bfdc5fd | 2022-11-16 10:03:49 -0800 | [diff] [blame] | 383 | self.target['android'].static_libs.add(lib) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 384 | else: |
| 385 | self.static_libs.add(lib) |
| 386 | |
| 387 | def add_android_shared_lib(self, lib): |
| 388 | if self.type == 'cc_binary_host': |
| 389 | raise Exception('Adding Android shared lib for host tool is unsupported') |
| 390 | elif self.host_supported: |
Patrick Rohr | bfdc5fd | 2022-11-16 10:03:49 -0800 | [diff] [blame] | 391 | self.target['android'].shared_libs.add(lib) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 392 | else: |
| 393 | self.shared_libs.add(lib) |
| 394 | |
| 395 | def _output_field(self, output, name, sort=True): |
| 396 | value = getattr(self, name) |
| 397 | return write_blueprint_key_value(output, name, value, sort) |
| 398 | |
Patrick Rohr | a6ce023 | 2022-11-16 22:09:01 -0800 | [diff] [blame] | 399 | def is_compiled(self): |
Mohannad Farrag | f2391cc | 2022-11-29 13:26:32 +0000 | [diff] [blame] | 400 | return self.type not in ('cc_genrule', 'filegroup', 'cc_defaults') |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 401 | |
| 402 | def is_genrule(self): |
| 403 | return self.type == "cc_genrule" |
Patrick Rohr | a6ce023 | 2022-11-16 22:09:01 -0800 | [diff] [blame] | 404 | |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 405 | def has_input_files(self): |
| 406 | for target in self.target.values(): |
| 407 | if len(target.srcs) > 0: |
| 408 | return True |
| 409 | return len(self.srcs) > 0 or any([len(target.srcs) > 0 for target in self.target.values()]) |
| 410 | |
Mohannad Farrag | f2391cc | 2022-11-29 13:26:32 +0000 | [diff] [blame] | 411 | def merge_attribute(self, key, source_module, allowed_archs, source_key = None): |
| 412 | """ |
| 413 | Merges the value of the attribute `source_key` for the `dep_module` with |
| 414 | the value of the attribute `key` for this module. If the value of the |
| 415 | `source_key` is equal to None. Then `key` is used for both modules. |
| 416 | |
| 417 | This merges the attribute for both non-arch and archs |
| 418 | specified in `allowed_archs`. |
| 419 | :param key: The attribute used for merging in the calling module. Also |
| 420 | used for `dep_module` if the `source_key` is None. |
| 421 | :param source_module: The module where data is propagated from. |
| 422 | :param allowed_archs: A list of archs to merge the attribute on. |
| 423 | :param source_key: if the attribute merged from the `dep_module` |
| 424 | is different from the `key` |
| 425 | """ |
| 426 | if not source_key: |
| 427 | source_key = key |
| 428 | self.__dict__[key].update(source_module.__dict__[source_key]) |
| 429 | for arch_name in source_module.target.keys(): |
| 430 | if arch_name in allowed_archs: |
| 431 | self.target[arch_name].__dict__[key].update( |
| 432 | source_module.target[arch_name].__dict__[source_key]) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 433 | |
| 434 | class Blueprint(object): |
| 435 | """In-memory representation of an Android.bp file.""" |
| 436 | |
| 437 | def __init__(self): |
| 438 | self.modules = {} |
| 439 | |
| 440 | def add_module(self, module): |
| 441 | """Adds a new module to the blueprint, replacing any existing module |
| 442 | with the same name. |
| 443 | |
| 444 | Args: |
| 445 | module: Module instance. |
| 446 | """ |
| 447 | self.modules[module.name] = module |
| 448 | |
| 449 | def to_string(self, output): |
Patrick Rohr | 23f2619 | 2022-10-25 09:45:22 -0700 | [diff] [blame] | 450 | for m in sorted(self.modules.values(), key=lambda m: m.name): |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 451 | m.to_string(output) |
| 452 | |
| 453 | |
| 454 | def label_to_module_name(label): |
| 455 | """Turn a GN label (e.g., //:perfetto_tests) into a module name.""" |
Patrick Rohr | 0787666 | 2022-11-15 22:55:23 -0800 | [diff] [blame] | 456 | module = re.sub(r'^//:?', '', label) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 457 | module = re.sub(r'[^a-zA-Z0-9_]', '_', module) |
Motomu Utsumi | 3fde148 | 2022-11-14 15:55:21 +0900 | [diff] [blame] | 458 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 459 | if not module.startswith(module_prefix): |
| 460 | return module_prefix + module |
| 461 | return module |
| 462 | |
| 463 | |
| 464 | def is_supported_source_file(name): |
| 465 | """Returns True if |name| can appear in a 'srcs' list.""" |
Patrick Rohr | f9f3a99 | 2022-11-10 19:40:32 -0800 | [diff] [blame] | 466 | 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] | 467 | |
| 468 | |
| 469 | def create_proto_modules(blueprint, gn, target): |
| 470 | """Generate genrules for a proto GN target. |
| 471 | |
| 472 | GN actions are used to dynamically generate files during the build. The |
| 473 | Soong equivalent is a genrule. This function turns a specific kind of |
| 474 | genrule which turns .proto files into source and header files into a pair |
| 475 | equivalent genrules. |
| 476 | |
| 477 | Args: |
| 478 | blueprint: Blueprint instance which is being generated. |
| 479 | target: gn_utils.Target object. |
| 480 | |
| 481 | Returns: |
| 482 | The source_genrule module. |
| 483 | """ |
| 484 | assert (target.type == 'proto_library') |
| 485 | |
Motomu Utsumi | bd4013f | 2022-11-17 16:06:05 +0900 | [diff] [blame] | 486 | protoc_gn_target_name = gn.get_target('//third_party/protobuf:protoc').name |
Motomu Utsumi | d58c1dc | 2022-11-16 18:04:46 +0900 | [diff] [blame] | 487 | protoc_module_name = label_to_module_name(protoc_gn_target_name) |
| 488 | tools = {protoc_module_name} |
Motomu Utsumi | d7e0e42 | 2022-11-08 17:49:52 +0900 | [diff] [blame] | 489 | cpp_out_dir = '$(genDir)/%s/%s/' % (tree_path, target.proto_in_dir) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 490 | target_module_name = label_to_module_name(target.name) |
| 491 | |
| 492 | # In GN builds the proto path is always relative to the output directory |
| 493 | # (out/tmp.xxx). |
Motomu Utsumi | d58c1dc | 2022-11-16 18:04:46 +0900 | [diff] [blame] | 494 | cmd = ['$(location %s)' % protoc_module_name] |
Motomu Utsumi | d7e0e42 | 2022-11-08 17:49:52 +0900 | [diff] [blame] | 495 | cmd += ['--proto_path=%s/%s' % (tree_path, target.proto_in_dir)] |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 496 | |
| 497 | if buildtools_protobuf_src in target.proto_paths: |
| 498 | cmd += ['--proto_path=%s' % android_protobuf_src] |
| 499 | |
| 500 | # We don't generate any targets for source_set proto modules because |
| 501 | # they will be inlined into other modules if required. |
| 502 | if target.proto_plugin == 'source_set': |
| 503 | return None |
| 504 | |
| 505 | # Descriptor targets only generate a single target. |
| 506 | if target.proto_plugin == 'descriptor': |
| 507 | out = '{}.bin'.format(target_module_name) |
| 508 | |
| 509 | cmd += ['--descriptor_set_out=$(out)'] |
| 510 | cmd += ['$(in)'] |
| 511 | |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 512 | descriptor_module = Module('cc_genrule', target_module_name, target.name) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 513 | descriptor_module.cmd = ' '.join(cmd) |
| 514 | descriptor_module.out = [out] |
| 515 | descriptor_module.tools = tools |
| 516 | blueprint.add_module(descriptor_module) |
| 517 | |
| 518 | # Recursively extract the .proto files of all the dependencies and |
| 519 | # add them to srcs. |
| 520 | descriptor_module.srcs.update( |
| 521 | gn_utils.label_to_path(src) for src in target.sources) |
| 522 | for dep in target.transitive_proto_deps: |
| 523 | current_target = gn.get_target(dep) |
| 524 | descriptor_module.srcs.update( |
| 525 | gn_utils.label_to_path(src) for src in current_target.sources) |
| 526 | |
| 527 | return descriptor_module |
| 528 | |
| 529 | # We create two genrules for each proto target: one for the headers and |
| 530 | # another for the sources. This is because the module that depends on the |
| 531 | # generated files needs to declare two different types of dependencies -- |
| 532 | # source files in 'srcs' and headers in 'generated_headers' -- and it's not |
| 533 | # valid to generate .h files from a source dependency and vice versa. |
| 534 | source_module_name = target_module_name + '_gen' |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 535 | source_module = Module('cc_genrule', source_module_name, target.name) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 536 | blueprint.add_module(source_module) |
| 537 | source_module.srcs.update( |
| 538 | gn_utils.label_to_path(src) for src in target.sources) |
| 539 | |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 540 | header_module = Module('cc_genrule', source_module_name + '_headers', |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 541 | target.name) |
| 542 | blueprint.add_module(header_module) |
| 543 | header_module.srcs = set(source_module.srcs) |
| 544 | |
| 545 | # TODO(primiano): at some point we should remove this. This was introduced |
| 546 | # by aosp/1108421 when adding "protos/" to .proto include paths, in order to |
| 547 | # avoid doing multi-repo changes and allow old clients in the android tree |
| 548 | # to still do the old #include "perfetto/..." rather than |
| 549 | # #include "protos/perfetto/...". |
| 550 | header_module.export_include_dirs = {'.', 'protos'} |
Patrick Rohr | 2267a0a | 2022-11-08 18:59:34 -0800 | [diff] [blame] | 551 | # Since the .cc file and .h get created by a different gerule target, they |
| 552 | # are not put in the same intermediate path, so local includes do not work |
| 553 | # without explictily exporting the include dir. |
| 554 | header_module.export_include_dirs.add(target.proto_in_dir) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 555 | |
Motomu Utsumi | 8ca1241 | 2022-11-30 16:27:30 +0900 | [diff] [blame] | 556 | # This function does not return header_module so setting apex_available attribute here. |
| 557 | header_module.apex_available.add(tethering_apex) |
| 558 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 559 | source_module.genrule_srcs.add(':' + source_module.name) |
| 560 | source_module.genrule_headers.add(header_module.name) |
| 561 | |
| 562 | if target.proto_plugin == 'proto': |
| 563 | suffixes = ['pb'] |
| 564 | source_module.genrule_shared_libs.add('libprotobuf-cpp-lite') |
| 565 | cmd += ['--cpp_out=lite=true:' + cpp_out_dir] |
| 566 | elif target.proto_plugin == 'protozero': |
| 567 | suffixes = ['pbzero'] |
| 568 | plugin = create_modules_from_target(blueprint, gn, protozero_plugin) |
| 569 | tools.add(plugin.name) |
| 570 | cmd += ['--plugin=protoc-gen-plugin=$(location %s)' % plugin.name] |
| 571 | cmd += ['--plugin_out=wrapper_namespace=pbzero:' + cpp_out_dir] |
| 572 | elif target.proto_plugin == 'cppgen': |
| 573 | suffixes = ['gen'] |
| 574 | plugin = create_modules_from_target(blueprint, gn, cppgen_plugin) |
| 575 | tools.add(plugin.name) |
| 576 | cmd += ['--plugin=protoc-gen-plugin=$(location %s)' % plugin.name] |
| 577 | cmd += ['--plugin_out=wrapper_namespace=gen:' + cpp_out_dir] |
| 578 | elif target.proto_plugin == 'ipc': |
| 579 | suffixes = ['ipc'] |
| 580 | plugin = create_modules_from_target(blueprint, gn, ipc_plugin) |
| 581 | tools.add(plugin.name) |
| 582 | cmd += ['--plugin=protoc-gen-plugin=$(location %s)' % plugin.name] |
| 583 | cmd += ['--plugin_out=wrapper_namespace=gen:' + cpp_out_dir] |
| 584 | else: |
| 585 | raise Error('Unsupported proto plugin: %s' % target.proto_plugin) |
| 586 | |
| 587 | cmd += ['$(in)'] |
| 588 | source_module.cmd = ' '.join(cmd) |
| 589 | header_module.cmd = source_module.cmd |
| 590 | source_module.tools = tools |
| 591 | header_module.tools = tools |
| 592 | |
| 593 | for sfx in suffixes: |
| 594 | source_module.out.update('%s/%s' % |
| 595 | (tree_path, src.replace('.proto', '.%s.cc' % sfx)) |
| 596 | for src in source_module.srcs) |
| 597 | header_module.out.update('%s/%s' % |
| 598 | (tree_path, src.replace('.proto', '.%s.h' % sfx)) |
| 599 | for src in header_module.srcs) |
| 600 | return source_module |
| 601 | |
| 602 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 603 | def create_proto_group_modules(blueprint, gn, module_name, target_names): |
| 604 | # TODO(lalitm): today, we're only adding a Java lite module because that's |
| 605 | # the only one used in practice. In the future, if we need other target types |
| 606 | # (e.g. C++, Java full etc.) add them here. |
| 607 | bp_module_name = label_to_module_name(module_name) + '_java_protos' |
| 608 | module = Module('java_library', bp_module_name, bp_module_name) |
| 609 | module.comment = f'''GN: [{', '.join(target_names)}]''' |
| 610 | module.proto = {'type': 'lite', 'canonical_path_from_root': False} |
| 611 | |
| 612 | for name in target_names: |
| 613 | target = gn.get_target(name) |
| 614 | module.srcs.update(gn_utils.label_to_path(src) for src in target.sources) |
| 615 | for dep_label in target.transitive_proto_deps: |
| 616 | dep = gn.get_target(dep_label) |
| 617 | module.srcs.update(gn_utils.label_to_path(src) for src in dep.sources) |
| 618 | |
| 619 | blueprint.add_module(module) |
| 620 | |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 621 | |
Mohannad Farrag | 420c14e | 2022-11-30 17:13:15 +0000 | [diff] [blame] | 622 | class BaseActionSanitizer(): |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 623 | def __init__(self, target): |
Patrick Rohr | 9e414b5 | 2022-11-29 22:12:18 -0800 | [diff] [blame] | 624 | # Just to be on the safe side, create a deep-copy. |
| 625 | self.target = copy.deepcopy(target) |
| 626 | # Convert ['--param=value'] to ['--param', 'value'] for consistency. |
Patrick Rohr | 3d37780 | 2022-11-30 13:42:02 -0800 | [diff] [blame] | 627 | self.target.args = [str for it in self.target.args for str in it.split('=')] |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 628 | |
| 629 | def _has_arg(self, arg): |
| 630 | return arg in self.target.args |
| 631 | |
Patrick Rohr | 501af22 | 2022-11-30 13:38:13 -0800 | [diff] [blame] | 632 | # Whether an arg has multiple occurences (e.g. see argparse action='append') |
| 633 | def _is_list_arg(self, arg): |
Patrick Rohr | 3a2c3dd | 2022-11-29 22:29:36 -0800 | [diff] [blame] | 634 | return operator.countOf(arg, self.target.args) > 1 |
| 635 | |
Patrick Rohr | ef4f2bf | 2022-11-30 14:22:40 -0800 | [diff] [blame^] | 636 | def _is_value_arg(self, arg): |
Patrick Rohr | 3a2c3dd | 2022-11-29 22:29:36 -0800 | [diff] [blame] | 637 | # TODO: we'll probably need a set of helper functions to deal with append |
| 638 | # args as well. |
Patrick Rohr | 501af22 | 2022-11-30 13:38:13 -0800 | [diff] [blame] | 639 | assert(not self._is_list_arg(arg)) |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 640 | i = self.target.args.index(arg) |
| 641 | return not self.target.args[i + 1].startswith('--') |
| 642 | |
| 643 | def _get_arg_value(self, arg): |
Patrick Rohr | ef4f2bf | 2022-11-30 14:22:40 -0800 | [diff] [blame^] | 644 | assert(self._is_value_arg(arg)) |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 645 | i = self.target.args.index(arg) |
| 646 | return self.target.args[i + 1] |
| 647 | |
| 648 | def _set_arg_value(self, arg, value): |
Patrick Rohr | ef4f2bf | 2022-11-30 14:22:40 -0800 | [diff] [blame^] | 649 | assert(self._is_value_arg(arg)) |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 650 | i = self.target.args.index(arg) |
| 651 | self.target.args[i + 1] = value |
| 652 | |
Patrick Rohr | 77c4f5c | 2022-11-30 12:56:29 -0800 | [diff] [blame] | 653 | def _set_arg_at(self, position, value): |
Mohannad Farrag | 9ab1793 | 2022-11-30 17:28:35 +0000 | [diff] [blame] | 654 | self.target.args[position] = value |
| 655 | |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 656 | def _delete_arg(self, arg): |
Patrick Rohr | 501af22 | 2022-11-30 13:38:13 -0800 | [diff] [blame] | 657 | assert(not self._is_list_arg(arg)) |
Patrick Rohr | ef4f2bf | 2022-11-30 14:22:40 -0800 | [diff] [blame^] | 658 | hasValue = self._is_value_arg(arg) |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 659 | i = self.target.index(arg) |
| 660 | self.target.args.pop(i) |
| 661 | if hasValue: |
| 662 | self.target.args.pop(i) |
| 663 | |
Patrick Rohr | 1f7dd58 | 2022-11-30 13:44:07 -0800 | [diff] [blame] | 664 | def _append_arg(self, arg, value): |
| 665 | self.target.args.append(arg) |
| 666 | self.target.args.append(value) |
| 667 | |
Patrick Rohr | 73ef7ae | 2022-11-29 22:33:09 -0800 | [diff] [blame] | 668 | # wrap filename in location tag. |
| 669 | def _location_tag(self, filename): |
| 670 | return '$(location %s)' % filename |
| 671 | |
Patrick Rohr | 3227689 | 2022-11-29 22:38:13 -0800 | [diff] [blame] | 672 | # deletes the leading ../../ |
| 673 | def _rebase_directory(self, filename): |
Patrick Rohr | 15aa692 | 2022-11-30 13:17:50 -0800 | [diff] [blame] | 674 | return re.sub('^\.\./\.\./', '', filename) |
Patrick Rohr | 3227689 | 2022-11-29 22:38:13 -0800 | [diff] [blame] | 675 | |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 676 | def get_args(self): |
Patrick Rohr | 9e414b5 | 2022-11-29 22:12:18 -0800 | [diff] [blame] | 677 | return self.target.args |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 678 | |
Mohannad Farrag | 9ab1793 | 2022-11-30 17:28:35 +0000 | [diff] [blame] | 679 | class WriteBuildDateHeaderSanitizer(BaseActionSanitizer): |
| 680 | def get_args(self): |
Patrick Rohr | 77c4f5c | 2022-11-30 12:56:29 -0800 | [diff] [blame] | 681 | self._set_arg_at(0, '$(out)') |
Mohannad Farrag | 9ab1793 | 2022-11-30 17:28:35 +0000 | [diff] [blame] | 682 | return super().get_args() |
| 683 | |
Mohannad Farrag | 71353f9 | 2022-11-30 17:20:48 +0000 | [diff] [blame] | 684 | class WriteBuildFlagHeaderSanitizer(BaseActionSanitizer): |
| 685 | def get_args(self): |
| 686 | self._set_arg_value('--gen-dir', '.') |
| 687 | self._set_arg_value('--output', '$(out)') |
| 688 | return super().get_args() |
Patrick Rohr | f6de33f | 2022-11-29 22:02:55 -0800 | [diff] [blame] | 689 | |
Patrick Rohr | 0242a3f | 2022-11-30 13:48:59 -0800 | [diff] [blame] | 690 | class JniGeneratorSanitizer(BaseActionSanitizer): |
| 691 | def get_args(self): |
| 692 | if self._has_arg('--jar_file'): |
| 693 | self._append_arg('--javap', '$$(find out/.path -name javap)') |
| 694 | return super().get_args() |
| 695 | |
| 696 | |
Patrick Rohr | 7f11715 | 2022-11-30 13:58:05 -0800 | [diff] [blame] | 697 | def get_action_sanitizer(target): |
| 698 | if target.script == "//build/write_buildflag_header.py": |
| 699 | return WriteBuildFlagHeaderSanitizer(target) |
| 700 | elif target.script == "//build/write_build_date_header.py": |
| 701 | return WriteBuildDateHeaderSanitizer(target) |
| 702 | elif target.script == '//base/android/jni_generator/jni_generator.py': |
| 703 | return JniGeneratorSanitizer(target) |
| 704 | else: |
| 705 | # TODO: throw exception here once all script hacks have been converted. |
| 706 | return BaseActionSanitizer(target) |
| 707 | |
Mohannad Farrag | bab6c89 | 2022-11-02 14:09:46 +0000 | [diff] [blame] | 708 | def create_action_foreach_modules(blueprint, target): |
| 709 | """ The following assumes that rebase_path exists in the args. |
| 710 | The args of an action_foreach contains hints about which output files are generated |
| 711 | by which source files. |
| 712 | This is copied directly from the args |
| 713 | "gen/net/base/registry_controlled_domains/{{source_name_part}}-reversed-inc.cc" |
| 714 | So each source file will generate an output whose name is the {source_name-reversed-inc.cc} |
| 715 | """ |
| 716 | new_args = [] |
Motomu Utsumi | 56afcac | 2022-11-04 12:58:30 +0900 | [diff] [blame] | 717 | for i, src in enumerate(sorted(target.sources)): |
Mohannad Farrag | bab6c89 | 2022-11-02 14:09:46 +0000 | [diff] [blame] | 718 | # don't add script arg for the first source -- create_action_module |
| 719 | # already does this. |
| 720 | if i != 0: |
| 721 | new_args.append('&& python3 $(location %s)' % |
| 722 | gn_utils.label_to_path(target.script)) |
| 723 | for arg in target.args: |
| 724 | if '{{source}}' in arg: |
| 725 | new_args.append('$(location %s)' % (gn_utils.label_to_path(src))) |
| 726 | elif '{{source_name_part}}' in arg: |
| 727 | source_name_part = src.split("/")[-1] # Get the file name only |
| 728 | source_name_part = source_name_part.split(".")[0] # Remove the extension (Ex: .cc) |
| 729 | file_name = arg.replace('{{source_name_part}}', source_name_part).split("/")[-1] |
| 730 | # file_name represent the output file name. But we need the whole path |
| 731 | # This can be found from target.outputs. |
| 732 | for out in target.outputs: |
| 733 | if out.endswith(file_name): |
| 734 | new_args.append('$(location %s)' % out) |
| 735 | else: |
| 736 | new_args.append(arg) |
| 737 | |
| 738 | target.args = new_args |
| 739 | return create_action_module(blueprint, target) |
Motomu Utsumi | a6c3315 | 2022-11-02 18:21:55 +0900 | [diff] [blame] | 740 | |
Patrick Rohr | 7be9903 | 2022-10-31 11:54:19 -0700 | [diff] [blame] | 741 | def create_action_module(blueprint, target): |
| 742 | bp_module_name = label_to_module_name(target.name) |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 743 | module = Module('cc_genrule', bp_module_name, target.name) |
Patrick Rohr | 7be9903 | 2022-10-31 11:54:19 -0700 | [diff] [blame] | 744 | |
Patrick Rohr | d7de3dd | 2022-11-30 12:53:26 -0800 | [diff] [blame] | 745 | sanitizer = get_action_sanitizer(target) |
Patrick Rohr | 9e414b5 | 2022-11-29 22:12:18 -0800 | [diff] [blame] | 746 | target.args = sanitizer.get_args() |
Patrick Rohr | 9b99a98 | 2022-10-28 11:00:57 -0700 | [diff] [blame] | 747 | |
Mohannad Farrag | 9ab1793 | 2022-11-30 17:28:35 +0000 | [diff] [blame] | 748 | if target.script == '//base/android/jni_generator/jni_generator.py': |
Patrick Rohr | 8acccca | 2022-10-28 10:39:06 -0700 | [diff] [blame] | 749 | for i, val in enumerate(target.args): |
Motomu Utsumi | 6f9139d | 2022-10-31 12:15:19 +0900 | [diff] [blame] | 750 | if val == '--output_dir': |
Patrick Rohr | f1d08f8 | 2022-10-31 14:43:59 -0700 | [diff] [blame] | 751 | # replace --output_dir gen/jni_headers/... with --output_dir $(genDir)/... |
| 752 | target.args[i + 1] = re.sub('^gen/jni_headers', '$(genDir)', target.args[i + 1]) |
Patrick Rohr | bec0c8c | 2022-11-01 11:56:38 -0700 | [diff] [blame] | 753 | elif val == '--input_file': |
Patrick Rohr | 8acccca | 2022-10-28 10:39:06 -0700 | [diff] [blame] | 754 | # --input_file supports both .class specifiers or source files as arguments. |
| 755 | # Only source files need to be wrapped inside a $(location <label>) tag. |
| 756 | if re.match('.*\.class$', target.args[i + 1]): |
| 757 | continue |
| 758 | # replace --input_file ../../... with --input_file $(location ...) |
| 759 | # TODO: put inside function |
| 760 | filename = re.sub('^\.\./\.\./', '', target.args[i + 1]) |
| 761 | target.args[i + 1] = '$(location %s)' % filename |
Patrick Rohr | bec0c8c | 2022-11-01 11:56:38 -0700 | [diff] [blame] | 762 | elif val == '--includes' and 'jni_generator_helper' in target.args[i + 1]: |
Patrick Rohr | d89e8bf | 2022-10-31 14:51:05 -0700 | [diff] [blame] | 763 | # delete all leading ../ |
| 764 | target.args[i + 1] = re.sub('^(\.\./)+', '', target.args[i + 1]) |
Patrick Rohr | bec0c8c | 2022-11-01 11:56:38 -0700 | [diff] [blame] | 765 | elif val == '--prev_output_dir': |
Patrick Rohr | 131ba28 | 2022-10-31 16:36:20 -0700 | [diff] [blame] | 766 | # this is not needed for aosp builds. |
| 767 | target.args[i] = '' |
| 768 | target.args[i + 1] = '' |
Patrick Rohr | bec0c8c | 2022-11-01 11:56:38 -0700 | [diff] [blame] | 769 | elif val == '--jar_file': |
Patrick Rohr | 131ba28 | 2022-10-31 16:36:20 -0700 | [diff] [blame] | 770 | # delete leading ../../ and add path to javap |
| 771 | filename = re.sub('^\.\./\.\./', '', target.args[i + 1]) |
| 772 | target.args[i + 1] = '$(location %s)' % filename |
Patrick Rohr | f1d08f8 | 2022-10-31 14:43:59 -0700 | [diff] [blame] | 773 | # fix target.output directory to match #include statements. |
| 774 | target.outputs = [re.sub('^jni_headers/', '', out) for out in target.outputs] |
Patrick Rohr | 8acccca | 2022-10-28 10:39:06 -0700 | [diff] [blame] | 775 | |
Patrick Rohr | f6d2b61 | 2022-11-09 12:30:26 -0800 | [diff] [blame] | 776 | elif target.script == '//base/android/jni_generator/jni_registration_generator.py': |
| 777 | # jni_registration_generator.py pulls in some config dependencies that we |
| 778 | # do not handle. Remove them. |
| 779 | # TODO: find a better way to do this. |
| 780 | target.deps.clear() |
| 781 | |
Motomu Utsumi | ed00908 | 2022-11-10 16:26:44 +0900 | [diff] [blame] | 782 | target.inputs = [file for file in target.inputs if not file.startswith('//out/')] |
Motomu Utsumi | 6b4acaa | 2022-11-10 16:13:24 +0900 | [diff] [blame] | 783 | for i, val in enumerate(target.args): |
| 784 | if val in ['--depfile', '--srcjar-path', '--header-path']: |
| 785 | target.args[i + 1] = re.sub('^gen', '$(genDir)', target.args[i + 1]) |
Motomu Utsumi | 7bc2fcc | 2022-11-10 17:09:54 +0900 | [diff] [blame] | 786 | if val == '--sources-files': |
| 787 | target.args[i + 1] = '$(genDir)/java.sources' |
Motomu Utsumi | 47d122f | 2022-11-10 17:32:23 +0900 | [diff] [blame] | 788 | elif val == '--sources-exclusions': |
| 789 | # update_jni_registration_module removes them from the srcs of the module |
| 790 | # It might be better to remove sources by '--sources-exclusions' |
| 791 | target.args[i] = '' |
| 792 | target.args[i + 1] = '' |
Motomu Utsumi | a0cc666 | 2022-11-09 15:22:27 +0900 | [diff] [blame] | 793 | elif target.script == "//net/tools/dafsa/make_dafsa.py": |
| 794 | # This script generates .cc files but source (registry_controlled_domain.cc) in the target that |
| 795 | # depends on this target includes .cc file this script generates. |
| 796 | module.genrule_headers.add(module.name) |
Motomu Utsumi | 847a6d3 | 2022-11-09 17:32:06 +0900 | [diff] [blame] | 797 | elif target.script == "//build/util/version.py": |
Motomu Utsumi | b0a49e4 | 2022-11-09 18:12:27 +0900 | [diff] [blame] | 798 | # android_chrome_version.py is not specified in anywhere but version.py imports this file |
| 799 | module.tool_files.add('build/util/android_chrome_version.py') |
Motomu Utsumi | 847a6d3 | 2022-11-09 17:32:06 +0900 | [diff] [blame] | 800 | for i, val in enumerate(target.args): |
| 801 | if val.startswith('../../'): |
| 802 | filename = re.sub('^\.\./\.\./', '', val) |
| 803 | target.args[i] = '$(location %s)' % filename |
Motomu Utsumi | ee279c5 | 2022-11-09 17:46:27 +0900 | [diff] [blame] | 804 | elif val == '-e': |
| 805 | # arg for -e EVAL option should be passed in -e PATCH_HI=int(PATCH)//256 format. |
| 806 | target.args[i + 1] = '%s=\'%s\'' % (target.args[i + 1], target.args[i + 2]) |
| 807 | target.args[i + 2] = '' |
Motomu Utsumi | 438f2c2 | 2022-11-09 18:16:40 +0900 | [diff] [blame] | 808 | elif val == '-o': |
| 809 | target.args[i + 1] = '$(out)' |
Patrick Rohr | 245df58 | 2022-11-01 16:59:45 -0700 | [diff] [blame] | 810 | |
Patrick Rohr | 2041d5b | 2022-10-26 15:07:53 -0700 | [diff] [blame] | 811 | script = gn_utils.label_to_path(target.script) |
Patrick Rohr | 3d8c728 | 2022-10-27 13:36:31 -0700 | [diff] [blame] | 812 | module.tool_files.add(script) |
Patrick Rohr | e1a853e | 2022-10-26 12:31:39 -0700 | [diff] [blame] | 813 | |
Patrick Rohr | 8a4e2bd | 2022-10-27 13:06:16 -0700 | [diff] [blame] | 814 | # Handle passing parameters via response file by piping them into the script |
| 815 | # and reading them from /dev/stdin. |
| 816 | response_file = '{{response_file_name}}' |
| 817 | use_response_file = response_file in target.args |
| 818 | if use_response_file: |
| 819 | # Replace {{response_file_contents}} with /dev/stdin |
| 820 | target.args = ['/dev/stdin' if it == response_file else it for it in target.args] |
| 821 | |
Patrick Rohr | 4b0952d | 2022-11-01 12:42:31 -0700 | [diff] [blame] | 822 | # escape " and \$ in target.args. |
| 823 | # once all actions are properly implemented, this may not be necessary anymore. |
| 824 | # TODO: is this the right place to do this? |
| 825 | target.args = [arg.replace('"', r'\"') for arg in target.args] |
| 826 | target.args = [arg.replace(r'\$', r'\\$') for arg in target.args] |
| 827 | |
Patrick Rohr | 9b99a98 | 2022-10-28 11:00:57 -0700 | [diff] [blame] | 828 | # put all args on a new line for better diffs. |
| 829 | NEWLINE = ' " +\n "' |
| 830 | arg_string = NEWLINE.join(target.args) |
Patrick Rohr | 2041d5b | 2022-10-26 15:07:53 -0700 | [diff] [blame] | 831 | module.cmd = '$(location %s) %s' % (script, arg_string) |
Patrick Rohr | e1a853e | 2022-10-26 12:31:39 -0700 | [diff] [blame] | 832 | |
Patrick Rohr | 8a4e2bd | 2022-10-27 13:06:16 -0700 | [diff] [blame] | 833 | if use_response_file: |
| 834 | # Pipe response file contents into script |
Patrick Rohr | 9b99a98 | 2022-10-28 11:00:57 -0700 | [diff] [blame] | 835 | module.cmd = 'echo \'%s\' |%s%s' % (target.response_file_contents, NEWLINE, module.cmd) |
Patrick Rohr | 8a4e2bd | 2022-10-27 13:06:16 -0700 | [diff] [blame] | 836 | |
Motomu Utsumi | 7e98383 | 2022-11-10 16:04:46 +0900 | [diff] [blame] | 837 | if any(os.path.splitext(it)[1] == '.h' for it in target.outputs): |
Patrick Rohr | 67f4d43 | 2022-10-26 16:04:15 -0700 | [diff] [blame] | 838 | module.genrule_headers.add(bp_module_name) |
Patrick Rohr | e1a853e | 2022-10-26 12:31:39 -0700 | [diff] [blame] | 839 | |
Patrick Rohr | 0db9f85 | 2022-10-27 13:49:57 -0700 | [diff] [blame] | 840 | # gn treats inputs and sources for actions equally. |
| 841 | # soong only supports source files inside srcs, non-source files are added as |
| 842 | # tool_files dependency. |
| 843 | for it in target.sources or target.inputs: |
| 844 | if is_supported_source_file(it): |
| 845 | module.srcs.add(gn_utils.label_to_path(it)) |
| 846 | else: |
| 847 | module.tool_files.add(gn_utils.label_to_path(it)) |
Patrick Rohr | e1a853e | 2022-10-26 12:31:39 -0700 | [diff] [blame] | 848 | |
Patrick Rohr | 15a2c30 | 2022-10-26 15:08:57 -0700 | [diff] [blame] | 849 | # Actions using template "action_with_pydeps" also put script inside inputs. |
| 850 | # TODO: it might make sense to filter inputs inside GnParser. |
| 851 | if script in module.srcs: |
| 852 | module.srcs.remove(script) |
| 853 | |
Patrick Rohr | e1a853e | 2022-10-26 12:31:39 -0700 | [diff] [blame] | 854 | module.out.update(target.outputs) |
Motomu Utsumi | a6c3315 | 2022-11-02 18:21:55 +0900 | [diff] [blame] | 855 | |
Motomu Utsumi | 4b35a32 | 2022-11-25 11:55:37 +0900 | [diff] [blame] | 856 | if target.script == "//base/android/jni_generator/jni_generator.py": |
Mohannad Farrag | 18d7b51 | 2022-11-07 13:26:30 +0000 | [diff] [blame] | 857 | # android_jar.classes should be part of the tools as it list implicit classes |
| 858 | # for the script to generate JNI headers. |
| 859 | module.tool_files.add("base/android/jni_generator/android_jar.classes") |
Motomu Utsumi | 7bc2fcc | 2022-11-10 17:09:54 +0900 | [diff] [blame] | 860 | elif target.script == '//base/android/jni_generator/jni_registration_generator.py': |
Motomu Utsumi | 9ca466b | 2022-11-10 17:12:29 +0900 | [diff] [blame] | 861 | # jni_registration_generator.py doesn't work with python2 |
| 862 | module.cmd = "python3 " + module.cmd |
Motomu Utsumi | 7bc2fcc | 2022-11-10 17:09:54 +0900 | [diff] [blame] | 863 | # Path in the original sources file does not work in genrule. |
| 864 | # So creating sources file in cmd based on the srcs of this target. |
| 865 | # Adding ../$(current_dir)/ to the head because jni_registration_generator.py uses the files |
| 866 | # whose path startswith(..) |
| 867 | commands = ["current_dir=`basename \\\`pwd\\\``;", |
| 868 | "for f in $(in);", |
| 869 | "do", |
| 870 | "echo \\\"../$$current_dir/$$f\\\" >> $(genDir)/java.sources;", |
| 871 | "done;", |
| 872 | module.cmd] |
Motomu Utsumi | 2a892d2 | 2022-11-10 18:03:20 +0900 | [diff] [blame] | 873 | |
| 874 | # .h file jni_registration_generator.py generates has #define with directory name. |
| 875 | # With the genrule env that contains "." which is invalid. So replace that at the end of cmd. |
Mohannad Farrag | 7c0f098 | 2022-11-10 14:39:49 +0000 | [diff] [blame] | 876 | commands.append(";sed -i -e 's/OUT_SOONG_.TEMP_SBOX_.*_OUT/GEN/g' ") |
Motomu Utsumi | 2a892d2 | 2022-11-10 18:03:20 +0900 | [diff] [blame] | 877 | commands.append("$(genDir)/components/cronet/android/cronet_jni_registration.h") |
Motomu Utsumi | 7bc2fcc | 2022-11-10 17:09:54 +0900 | [diff] [blame] | 878 | module.cmd = NEWLINE.join(commands) |
Motomu Utsumi | a6c3315 | 2022-11-02 18:21:55 +0900 | [diff] [blame] | 879 | |
Patrick Rohr | e1a853e | 2022-10-26 12:31:39 -0700 | [diff] [blame] | 880 | blueprint.add_module(module) |
| 881 | return module |
| 882 | |
| 883 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 884 | |
Motomu Utsumi | c34b137 | 2022-11-17 22:15:51 +0900 | [diff] [blame] | 885 | def _get_cflags(cflags, defines): |
| 886 | cflags = {flag for flag in cflags if flag in cflag_allowlist} |
Motomu Utsumi | fa7e926 | 2022-10-26 19:43:02 +0900 | [diff] [blame] | 887 | # Consider proper allowlist or denylist if needed |
Motomu Utsumi | c34b137 | 2022-11-17 22:15:51 +0900 | [diff] [blame] | 888 | cflags |= set("-D%s" % define.replace("\"", "\\\"") for define in defines) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 889 | return cflags |
| 890 | |
Motomu Utsumi | c34b137 | 2022-11-17 22:15:51 +0900 | [diff] [blame] | 891 | def set_module_flags(module, cflags, defines): |
| 892 | module.cflags.update(_get_cflags(cflags, defines)) |
| 893 | # TODO: implement proper cflag parsing. |
| 894 | for flag in cflags: |
| 895 | if '-std=' in flag: |
| 896 | module.cpp_std = flag[len('-std='):] |
Motomu Utsumi | c34b137 | 2022-11-17 22:15:51 +0900 | [diff] [blame] | 897 | if '-fexceptions' in flag: |
| 898 | module.cppflags.add('-fexceptions') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 899 | |
Mohannad Farrag | 631443e | 2022-11-21 16:17:01 +0000 | [diff] [blame] | 900 | def add_genrule_per_arch(module, dep_module, type): |
| 901 | module.generated_headers.update(dep_module.genrule_headers) |
| 902 | # If the module is a static library, export all the generated headers. |
| 903 | if type == 'cc_library_static': |
| 904 | module.export_generated_headers.update(dep_module.genrule_headers) |
| 905 | module.srcs.update(dep_module.genrule_srcs) |
| 906 | module.shared_libs.update(dep_module.genrule_shared_libs) |
| 907 | module.header_libs.update(dep_module.genrule_header_libs) |
| 908 | |
Motomu Utsumi | 88efbb4 | 2022-11-17 22:18:15 +0900 | [diff] [blame] | 909 | def set_module_include_dirs(module, cflags, include_dirs): |
Motomu Utsumi | 88efbb4 | 2022-11-17 22:18:15 +0900 | [diff] [blame] | 910 | for flag in cflags: |
| 911 | if '-isystem' in flag: |
Patrick Rohr | 3cd5ffb | 2022-11-18 17:40:55 -0800 | [diff] [blame] | 912 | module.local_include_dirs.add(flag[len('-isystem../../'):]) |
Motomu Utsumi | 88efbb4 | 2022-11-17 22:18:15 +0900 | [diff] [blame] | 913 | |
| 914 | # Adding local_include_dirs is necessary due to source_sets / filegroups |
| 915 | # which do not properly propagate include directories. |
| 916 | # Filter any directory inside //out as a) this directory does not exist for |
| 917 | # aosp / soong builds and b) the include directory should already be |
| 918 | # configured via library dependency. |
Patrick Rohr | 3cd5ffb | 2022-11-18 17:40:55 -0800 | [diff] [blame] | 919 | module.local_include_dirs.update([gn_utils.label_to_path(d) |
Motomu Utsumi | 88efbb4 | 2022-11-17 22:18:15 +0900 | [diff] [blame] | 920 | for d in include_dirs |
| 921 | if not re.match('^//out/.*', d)]) |
Motomu Utsumi | 88efbb4 | 2022-11-17 22:18:15 +0900 | [diff] [blame] | 922 | |
Motomu Utsumi | 88efbb4 | 2022-11-17 22:18:15 +0900 | [diff] [blame] | 923 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 924 | def create_modules_from_target(blueprint, gn, gn_target_name): |
| 925 | """Generate module(s) for a given GN target. |
| 926 | |
| 927 | Given a GN target name, generate one or more corresponding modules into a |
| 928 | blueprint. The only case when this generates >1 module is proto libraries. |
| 929 | |
| 930 | Args: |
| 931 | blueprint: Blueprint instance which is being generated. |
| 932 | gn: gn_utils.GnParser object. |
| 933 | gn_target_name: GN target for module generation. |
| 934 | """ |
| 935 | bp_module_name = label_to_module_name(gn_target_name) |
| 936 | if bp_module_name in blueprint.modules: |
| 937 | return blueprint.modules[bp_module_name] |
| 938 | target = gn.get_target(gn_target_name) |
Patrick Rohr | 1622894 | 2022-10-26 14:00:26 -0700 | [diff] [blame] | 939 | log.info('create modules for %s (%s)', target.name, target.type) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 940 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 941 | if target.type == 'executable': |
Patrick Rohr | c8f41cd | 2022-11-15 22:46:10 -0800 | [diff] [blame] | 942 | if target.testonly: |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 943 | module_type = 'cc_test' |
| 944 | else: |
Patrick Rohr | c8f41cd | 2022-11-15 22:46:10 -0800 | [diff] [blame] | 945 | # Can be used for both host and device targets. |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 946 | module_type = 'cc_binary' |
| 947 | module = Module(module_type, bp_module_name, gn_target_name) |
| 948 | elif target.type == 'static_library': |
| 949 | module = Module('cc_library_static', bp_module_name, gn_target_name) |
| 950 | elif target.type == 'shared_library': |
| 951 | module = Module('cc_library_shared', bp_module_name, gn_target_name) |
| 952 | elif target.type == 'source_set': |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 953 | module = Module('cc_object', bp_module_name, gn_target_name) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 954 | elif target.type == 'group': |
| 955 | # "group" targets are resolved recursively by gn_utils.get_target(). |
| 956 | # There's nothing we need to do at this level for them. |
| 957 | return None |
| 958 | elif target.type == 'proto_library': |
| 959 | module = create_proto_modules(blueprint, gn, target) |
| 960 | if module is None: |
| 961 | return None |
| 962 | elif target.type == 'action': |
Motomu Utsumi | 7f765cf | 2022-11-25 13:42:42 +0900 | [diff] [blame] | 963 | module = create_action_module(blueprint, target) |
Mohannad Farrag | f076f3e | 2022-10-31 17:45:28 +0000 | [diff] [blame] | 964 | elif target.type == 'action_foreach': |
Mohannad Farrag | bab6c89 | 2022-11-02 14:09:46 +0000 | [diff] [blame] | 965 | module = create_action_foreach_modules(blueprint, target) |
Patrick Rohr | 59a7665 | 2022-10-26 12:36:56 -0700 | [diff] [blame] | 966 | elif target.type == 'copy': |
| 967 | # TODO: careful now! copy targets are not supported yet, but this will stop |
| 968 | # traversing the dependency tree. For //base:base, this is not a big |
| 969 | # problem as libicu contains the only copy target which happens to be a |
| 970 | # leaf node. |
| 971 | return None |
Patrick Rohr | ad44060 | 2022-11-10 22:09:04 -0800 | [diff] [blame] | 972 | elif target.type == 'java_group': |
| 973 | # Java targets are handled outside of create_modules_from_target. |
| 974 | return None |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 975 | else: |
| 976 | raise Error('Unknown target %s (%s)' % (target.name, target.type)) |
| 977 | |
| 978 | blueprint.add_module(module) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 979 | module.init_rc = target_initrc.get(target.name, []) |
| 980 | module.srcs.update( |
| 981 | gn_utils.label_to_path(src) |
| 982 | for src in target.sources |
Motomu Utsumi | f951e50 | 2022-11-07 19:31:15 +0900 | [diff] [blame] | 983 | if is_supported_source_file(src) and not src.startswith("//out/test")) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 984 | |
Patrick Rohr | 3b5ff76 | 2022-11-16 10:22:16 -0800 | [diff] [blame] | 985 | # Add arch-specific properties |
| 986 | for arch_name, arch in target.arch.items(): |
Motomu Utsumi | 40f95c5 | 2022-11-17 19:39:13 +0900 | [diff] [blame] | 987 | module.target[arch_name].srcs.update( |
| 988 | gn_utils.label_to_path(src) |
| 989 | for src in arch.sources |
| 990 | if is_supported_source_file(src) and not src.startswith("//out/test")) |
Patrick Rohr | 3b5ff76 | 2022-11-16 10:22:16 -0800 | [diff] [blame] | 991 | |
Mohannad Farrag | baf0d57 | 2022-11-22 11:53:54 +0000 | [diff] [blame] | 992 | module.rtti = target.rtti |
| 993 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 994 | if target.type in gn_utils.LINKER_UNIT_TYPES: |
Motomu Utsumi | c34b137 | 2022-11-17 22:15:51 +0900 | [diff] [blame] | 995 | set_module_flags(module, target.cflags, target.defines) |
Motomu Utsumi | 88efbb4 | 2022-11-17 22:18:15 +0900 | [diff] [blame] | 996 | set_module_include_dirs(module, target.cflags, target.include_dirs) |
Motomu Utsumi | f0f4768 | 2022-11-17 22:34:39 +0900 | [diff] [blame] | 997 | # TODO: set_module_xxx is confusing, apply similar function to module and target in better way. |
| 998 | for arch_name, arch in target.arch.items(): |
| 999 | set_module_flags(module.target[arch_name], arch.cflags, arch.defines) |
Motomu Utsumi | 3371d68 | 2022-11-28 16:56:52 +0900 | [diff] [blame] | 1000 | # -Xclang -target-feature -Xclang +mte are used to enable MTE (Memory Tagging Extensions). |
| 1001 | # Flags which does not start with '-' could not be in the cflags so enabling MTE by |
| 1002 | # -march and -mcpu Feature Modifiers. MTE is only available on arm64. This is needed for |
| 1003 | # building //base/allocator/partition_allocator:partition_alloc for arm64. |
| 1004 | if '+mte' in arch.cflags and arch_name == 'android_arm64': |
| 1005 | module.target[arch_name].cflags.add('-march=armv8-a+memtag') |
Motomu Utsumi | f0f4768 | 2022-11-17 22:34:39 +0900 | [diff] [blame] | 1006 | 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] | 1007 | |
Mohannad Farrag | f2391cc | 2022-11-29 13:26:32 +0000 | [diff] [blame] | 1008 | module.host_supported = target.host_supported() |
| 1009 | module.device_supported = target.device_supported() |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1010 | |
Motomu Utsumi | 8ca1241 | 2022-11-30 16:27:30 +0900 | [diff] [blame] | 1011 | if module.is_genrule(): |
| 1012 | module.apex_available.add(tethering_apex) |
| 1013 | |
Mohannad Farrag | f2391cc | 2022-11-29 13:26:32 +0000 | [diff] [blame] | 1014 | if module.is_compiled(): |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1015 | # Don't try to inject library/source dependencies into genrules or |
| 1016 | # filegroups because they are not compiled in the traditional sense. |
| 1017 | module.defaults = [defaults_module] |
| 1018 | for lib in target.libs: |
| 1019 | # Generally library names should be mangled as 'libXXX', unless they |
| 1020 | # are HAL libraries (e.g., android.hardware.health@2.0) or AIDL c++ / NDK |
| 1021 | # libraries (e.g. "android.hardware.power.stats-V1-cpp") |
| 1022 | android_lib = lib if '@' in lib or "-cpp" in lib or "-ndk" in lib \ |
| 1023 | else 'lib' + lib |
| 1024 | if lib in shared_library_allowlist: |
| 1025 | module.add_android_shared_lib(android_lib) |
| 1026 | if lib in static_library_allowlist: |
| 1027 | module.add_android_static_lib(android_lib) |
| 1028 | |
Patrick Rohr | d9dd3b9 | 2022-11-09 16:15:30 -0800 | [diff] [blame] | 1029 | # Remove prohibited include directories |
| 1030 | module.local_include_dirs = [d for d in module.local_include_dirs |
| 1031 | if d not in local_include_dirs_denylist] |
| 1032 | |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1033 | # If the module is a static library, export all the generated headers. |
| 1034 | if module.type == 'cc_library_static': |
| 1035 | module.export_generated_headers = module.generated_headers |
| 1036 | |
Motomu Utsumi | ee47af6 | 2022-11-30 16:41:15 +0900 | [diff] [blame] | 1037 | if module.name == 'cronet_aml_components_cronet_android_cronet': |
| 1038 | if target.output_name is None: |
| 1039 | raise Error('Failed to get output_name for libcronet name') |
| 1040 | # .so file name needs to match with CronetLibraryLoader.java (e.g. libcronet.109.0.5386.0.so) |
| 1041 | # So setting the output name based on the output_name from the desc.json |
| 1042 | module.stem = 'lib' + target.output_name |
| 1043 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1044 | # 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] | 1045 | # Currently, only one module is generated from target even target has multiple toolchains. |
| 1046 | # And module is generated based on the first visited target. |
| 1047 | # Sort deps before iteration to make result deterministic. |
| 1048 | 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] | 1049 | for dep_name in all_deps: |
Patrick Rohr | 5cc46e0 | 2022-10-26 14:32:45 -0700 | [diff] [blame] | 1050 | # |builtin_deps| override GN deps with Android-specific ones. See the |
| 1051 | # config in the top of this file. |
Patrick Rohr | 0787666 | 2022-11-15 22:55:23 -0800 | [diff] [blame] | 1052 | if dep_name in builtin_deps: |
| 1053 | builtin_deps[dep_name](module) |
Patrick Rohr | 5cc46e0 | 2022-10-26 14:32:45 -0700 | [diff] [blame] | 1054 | continue |
| 1055 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1056 | dep_module = create_modules_from_target(blueprint, gn, dep_name) |
| 1057 | |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 1058 | if dep_module is None: |
| 1059 | continue |
Motomu Utsumi | e246feb | 2022-11-01 17:25:56 +0900 | [diff] [blame] | 1060 | # TODO: Proper dependency check for genrule. |
| 1061 | # Currently, only propagating genrule dependencies. |
| 1062 | # Also, currently, all the dependencies are propagated upwards. |
| 1063 | # in gn, public_deps should be propagated but deps should not. |
| 1064 | # Not sure this information is available in the desc.json. |
| 1065 | # Following rule works for adding android_runtime_jni_headers to base:base. |
| 1066 | # If this doesn't work for other target, hardcoding for specific target |
| 1067 | # might be better. |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1068 | if module.is_genrule() and dep_module.is_genrule(): |
| 1069 | module.genrule_headers.add(dep_module.name) |
| 1070 | module.genrule_headers.update(dep_module.genrule_headers) |
Motomu Utsumi | e246feb | 2022-11-01 17:25:56 +0900 | [diff] [blame] | 1071 | |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 1072 | # For filegroups, and genrule, recurse but don't apply the |
Patrick Rohr | a6ce023 | 2022-11-16 22:09:01 -0800 | [diff] [blame] | 1073 | # deps. |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1074 | if not module.is_compiled() or module.is_genrule(): |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1075 | continue |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1076 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1077 | if dep_module.type == 'cc_library_shared': |
| 1078 | module.shared_libs.add(dep_module.name) |
| 1079 | elif dep_module.type == 'cc_library_static': |
| 1080 | module.static_libs.add(dep_module.name) |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 1081 | elif dep_module.type == 'cc_object': |
Mohannad Farrag | f2391cc | 2022-11-29 13:26:32 +0000 | [diff] [blame] | 1082 | module.merge_attribute('generated_headers', dep_module, target.arch.keys()) |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 1083 | if module.type != 'cc_object': |
| 1084 | if dep_module.has_input_files(): |
| 1085 | # Only add it as part of srcs if the dep_module has input files otherwise |
| 1086 | # this would throw an error. |
| 1087 | module.srcs.add(":" + dep_module.name) |
Mohannad Farrag | f2391cc | 2022-11-29 13:26:32 +0000 | [diff] [blame] | 1088 | module.merge_attribute('export_generated_headers', dep_module, |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 1089 | target.arch.keys(), 'generated_headers') |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1090 | elif dep_module.type == 'cc_genrule': |
Mohannad Farrag | f2391cc | 2022-11-29 13:26:32 +0000 | [diff] [blame] | 1091 | module.merge_attribute('generated_headers', dep_module, [], 'genrule_headers') |
| 1092 | module.merge_attribute('srcs', dep_module, [], 'genrule_srcs') |
| 1093 | module.merge_attribute('shared_libs', dep_module, [], 'genrule_shared_libs') |
| 1094 | module.merge_attribute('header_libs', dep_module, [], 'genrule_header_libs') |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1095 | if module.type not in ["cc_object"]: |
Mohannad Farrag | f2391cc | 2022-11-29 13:26:32 +0000 | [diff] [blame] | 1096 | module.merge_attribute('export_generated_headers', dep_module, [], |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1097 | 'genrule_headers') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1098 | elif dep_module.type == 'cc_binary': |
| 1099 | continue # Ignore executables deps (used by cmdline integration tests). |
| 1100 | else: |
| 1101 | raise Error('Unknown dep %s (%s) for target %s' % |
| 1102 | (dep_module.name, dep_module.type, module.name)) |
| 1103 | |
Patrick Rohr | b51878f | 2022-11-16 23:49:03 -0800 | [diff] [blame] | 1104 | for arch_name, arch in target.arch.items(): |
| 1105 | for dep_name in arch.deps: |
| 1106 | dep_module = create_modules_from_target(blueprint, gn, dep_name) |
| 1107 | # Arch-specific dependencies currently only include cc_library_static. |
| 1108 | # Revisit this approach once we need to support more target types. |
| 1109 | if dep_module.type == 'cc_library_static': |
| 1110 | module.target[arch_name].static_libs.add(dep_module.name) |
Mohannad Farrag | 1de6cb1 | 2022-11-28 12:27:26 +0000 | [diff] [blame] | 1111 | elif dep_module.type == 'cc_genrule': |
| 1112 | if dep_module.name.endswith(arch_name): |
| 1113 | module.target[arch_name].generated_headers.update(dep_module.genrule_headers) |
| 1114 | module.target[arch_name].srcs.update(dep_module.genrule_srcs) |
| 1115 | module.target[arch_name].shared_libs.update(dep_module.genrule_shared_libs) |
| 1116 | module.target[arch_name].header_libs.update(dep_module.genrule_header_libs) |
| 1117 | if module.type not in ["cc_object"]: |
| 1118 | module.target[arch_name].export_generated_headers.update( |
| 1119 | dep_module.genrule_headers) |
Patrick Rohr | b51878f | 2022-11-16 23:49:03 -0800 | [diff] [blame] | 1120 | else: |
| 1121 | raise Error('Unsupported arch-specific dependency %s of target %s with type %s' % |
| 1122 | (dep_module.name, target.name, dep_module.type)) |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 1123 | for dep_name in arch.source_set_deps: |
| 1124 | dep_module = create_modules_from_target(blueprint, gn, dep_name) |
| 1125 | if dep_module.type == 'cc_object': |
| 1126 | if module.type != 'cc_object': |
| 1127 | # We only want to bubble up cc_objects for modules that are not cc_objects |
| 1128 | # otherwise they'd be recompiled and that would cause multiple symbol redefinitions. |
| 1129 | if dep_module.has_input_files(): |
| 1130 | # Only add it as part of srcs if the dep_module has input files otherwise |
| 1131 | # this would throw an error. |
| 1132 | module.target[arch_name].srcs.add(":" + dep_module.name) |
| 1133 | else: |
| 1134 | raise Error('Unsupported arch-specific dependency %s of target %s with type %s' % |
| 1135 | (dep_module.name, target.name, dep_module.type)) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1136 | return module |
| 1137 | |
Patrick Rohr | b18aca2 | 2022-11-04 15:07:32 -0700 | [diff] [blame] | 1138 | def create_java_module(blueprint, gn): |
| 1139 | bp_module_name = module_prefix + 'java' |
| 1140 | module = Module('java_library', bp_module_name, '//gn:java') |
Mohannad Farrag | 21562d6 | 2022-11-07 13:09:31 +0000 | [diff] [blame] | 1141 | module.srcs.update([gn_utils.label_to_path(source) for source in gn.java_sources]) |
Patrick Rohr | b18aca2 | 2022-11-04 15:07:32 -0700 | [diff] [blame] | 1142 | blueprint.add_module(module) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1143 | |
Patrick Rohr | 6ef2272 | 2022-11-18 18:24:01 -0800 | [diff] [blame] | 1144 | def update_jni_registration_module(module, gn): |
Motomu Utsumi | 47d122f | 2022-11-10 17:32:23 +0900 | [diff] [blame] | 1145 | # TODO: deny list is in the arg of jni_registration_generator.py. Should not be hardcoded |
| 1146 | deny_list = [ |
| 1147 | '//base/android/java/src/org/chromium/base/library_loader/LibraryLoader.java', |
| 1148 | '//base/android/java/src/org/chromium/base/library_loader/LibraryPrefetcher.java', |
| 1149 | '//base/android/java/src/org/chromium/base/process_launcher/ChildProcessService.java', |
| 1150 | '//base/android/java/src/org/chromium/base/SysUtils.java'] |
| 1151 | |
Motomu Utsumi | e3ce770 | 2022-11-10 16:22:11 +0900 | [diff] [blame] | 1152 | # TODO: java_sources might not contain all the required java files |
Motomu Utsumi | 47d122f | 2022-11-10 17:32:23 +0900 | [diff] [blame] | 1153 | module.srcs.update([gn_utils.label_to_path(source) |
| 1154 | for source in gn.java_sources if source not in deny_list]) |
Motomu Utsumi | e3ce770 | 2022-11-10 16:22:11 +0900 | [diff] [blame] | 1155 | |
Motomu Utsumi | a71281c | 2022-11-18 15:19:00 +0900 | [diff] [blame] | 1156 | def create_blueprint_for_targets(gn, targets): |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1157 | """Generate a blueprint for a list of GN targets.""" |
| 1158 | blueprint = Blueprint() |
| 1159 | |
| 1160 | # Default settings used by all modules. |
| 1161 | defaults = Module('cc_defaults', defaults_module, '//gn:default_deps') |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1162 | defaults.cflags = [ |
Patrick Rohr | 3ce7477 | 2022-11-11 14:19:58 -0800 | [diff] [blame] | 1163 | '-DGOOGLE_PROTOBUF_NO_RTTI', |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1164 | '-Wno-error=return-type', |
Patrick Rohr | 3a1ec1d | 2022-10-31 13:30:17 -0700 | [diff] [blame] | 1165 | '-Wno-non-virtual-dtor', |
Patrick Rohr | 5c70002 | 2022-11-08 19:33:07 -0800 | [diff] [blame] | 1166 | '-Wno-macro-redefined', |
Patrick Rohr | 9806515 | 2022-10-31 14:49:58 -0700 | [diff] [blame] | 1167 | '-Wno-missing-field-initializers', |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1168 | '-Wno-sign-compare', |
| 1169 | '-Wno-sign-promo', |
| 1170 | '-Wno-unused-parameter', |
Mohannad Farrag | 54d5244 | 2022-11-21 16:27:02 +0000 | [diff] [blame] | 1171 | '-Wno-null-pointer-subtraction', # Needed to libevent |
Mohannad Farrag | d98a96d | 2022-11-10 14:56:19 +0000 | [diff] [blame] | 1172 | '-Wno-deprecated-non-prototype', # needed for zlib |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1173 | '-fvisibility=hidden', |
Motomu Utsumi | ba02094 | 2022-11-14 15:15:41 +0900 | [diff] [blame] | 1174 | '-Wno-ambiguous-reversed-operator', # needed for icui18n |
Motomu Utsumi | b1ec878 | 2022-11-14 15:25:57 +0900 | [diff] [blame] | 1175 | '-Wno-unreachable-code-loop-increment', # needed for icui18n |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1176 | '-O2', |
Mohannad Farrag | 7f29d83 | 2022-11-23 19:52:41 +0000 | [diff] [blame] | 1177 | '-fPIC', |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1178 | ] |
Patrick Rohr | c03f1bb | 2022-11-18 16:13:17 -0800 | [diff] [blame] | 1179 | # Chromium builds do not add a dependency for headers found inside the |
| 1180 | # sysroot, so they are added globally via defaults. |
| 1181 | defaults.target['android'].header_libs = [ |
| 1182 | 'media_ndk_headers', |
| 1183 | 'jni_headers', |
| 1184 | ] |
Patrick Rohr | 5446df8 | 2022-11-18 14:54:55 -0800 | [diff] [blame] | 1185 | defaults.target['host'].cflags = [ |
| 1186 | # -DANDROID is added by default but target.defines contain -DANDROID if |
| 1187 | # it's required. So adding -UANDROID to cancel default -DANDROID if it's |
| 1188 | # not specified. |
| 1189 | # Note: -DANDROID is not consistently applied across the chromium code |
| 1190 | # base, so it is removed unconditionally for host targets. |
| 1191 | '-UANDROID', |
| 1192 | ] |
Patrick Rohr | 61f2acb | 2022-10-31 14:08:18 -0700 | [diff] [blame] | 1193 | defaults.stl = 'none' |
Motomu Utsumi | 8ca1241 | 2022-11-30 16:27:30 +0900 | [diff] [blame] | 1194 | defaults.min_sdk_version = 29 |
| 1195 | defaults.apex_available.add(tethering_apex) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1196 | blueprint.add_module(defaults) |
Patrick Rohr | 344b247 | 2022-10-25 11:32:15 -0700 | [diff] [blame] | 1197 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1198 | for target in targets: |
| 1199 | create_modules_from_target(blueprint, gn, target) |
Patrick Rohr | b18aca2 | 2022-11-04 15:07:32 -0700 | [diff] [blame] | 1200 | |
| 1201 | create_java_module(blueprint, gn) |
Patrick Rohr | 6ef2272 | 2022-11-18 18:24:01 -0800 | [diff] [blame] | 1202 | for module in blueprint.modules.values(): |
| 1203 | if 'cronet_jni_registration' in module.name: |
| 1204 | update_jni_registration_module(module, gn) |
Patrick Rohr | a7d029d | 2022-11-08 12:23:11 -0800 | [diff] [blame] | 1205 | |
| 1206 | # Merge in additional hardcoded arguments. |
| 1207 | for module in blueprint.modules.values(): |
| 1208 | for key, add_val in additional_args.get(module.name, []): |
| 1209 | curr = getattr(module, key) |
| 1210 | if add_val and isinstance(add_val, set) and isinstance(curr, set): |
| 1211 | curr.update(add_val) |
| 1212 | elif isinstance(add_val, str) and (not curr or isinstance(curr, str)): |
| 1213 | setattr(module, key, add_val) |
| 1214 | elif isinstance(add_val, bool) and (not curr or isinstance(curr, bool)): |
| 1215 | setattr(module, key, add_val) |
| 1216 | elif isinstance(add_val, dict) and isinstance(curr, dict): |
| 1217 | curr.update(add_val) |
| 1218 | elif isinstance(add_val, dict) and isinstance(curr, Target): |
| 1219 | curr.__dict__.update(add_val) |
| 1220 | else: |
| 1221 | raise Error('Unimplemented type %r of additional_args: %r' % |
| 1222 | (type(add_val), key)) |
| 1223 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1224 | return blueprint |
| 1225 | |
| 1226 | |
| 1227 | def main(): |
| 1228 | parser = argparse.ArgumentParser( |
| 1229 | description='Generate Android.bp from a GN description.') |
| 1230 | parser.add_argument( |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1231 | '--desc', |
Motomu Utsumi | 879dec8 | 2022-11-18 15:25:12 +0900 | [diff] [blame] | 1232 | help='GN description (e.g., gn desc out --format=json --all-toolchains "//*".' + |
| 1233 | 'You can specify multiple --desc options for different target_cpu', |
| 1234 | required=True, |
| 1235 | action='append' |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1236 | ) |
| 1237 | parser.add_argument( |
| 1238 | '--extras', |
| 1239 | help='Extra targets to include at the end of the Blueprint file', |
| 1240 | default=os.path.join(gn_utils.repo_root(), 'Android.bp.extras'), |
| 1241 | ) |
| 1242 | parser.add_argument( |
| 1243 | '--output', |
| 1244 | help='Blueprint file to create', |
| 1245 | default=os.path.join(gn_utils.repo_root(), 'Android.bp'), |
| 1246 | ) |
| 1247 | parser.add_argument( |
Patrick Rohr | 1622894 | 2022-10-26 14:00:26 -0700 | [diff] [blame] | 1248 | '-v', |
| 1249 | '--verbose', |
| 1250 | help='Print debug logs.', |
| 1251 | action='store_true', |
| 1252 | ) |
| 1253 | parser.add_argument( |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1254 | 'targets', |
| 1255 | nargs=argparse.REMAINDER, |
Patrick Rohr | 1aa504a | 2022-10-25 10:30:42 -0700 | [diff] [blame] | 1256 | help='Targets to include in the blueprint (e.g., "//:perfetto_tests")' |
| 1257 | ) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1258 | args = parser.parse_args() |
| 1259 | |
Patrick Rohr | 1622894 | 2022-10-26 14:00:26 -0700 | [diff] [blame] | 1260 | if args.verbose: |
| 1261 | log.basicConfig(format='%(levelname)s:%(funcName)s:%(message)s', level=log.DEBUG) |
| 1262 | |
Patrick Rohr | d0077b7 | 2022-11-15 12:43:26 -0800 | [diff] [blame] | 1263 | targets = args.targets or default_targets |
Motomu Utsumi | 879dec8 | 2022-11-18 15:25:12 +0900 | [diff] [blame] | 1264 | gn = gn_utils.GnParser() |
| 1265 | for desc_file in args.desc: |
| 1266 | with open(desc_file) as f: |
| 1267 | desc = json.load(f) |
| 1268 | for target in targets: |
| 1269 | gn.parse_gn_desc(desc, target) |
Motomu Utsumi | a71281c | 2022-11-18 15:19:00 +0900 | [diff] [blame] | 1270 | blueprint = create_blueprint_for_targets(gn, targets) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1271 | project_root = os.path.abspath(os.path.dirname(os.path.dirname(__file__))) |
| 1272 | tool_name = os.path.relpath(os.path.abspath(__file__), project_root) |
| 1273 | |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1274 | # Add any proto groups to the blueprint. |
| 1275 | for l_name, t_names in proto_groups.items(): |
| 1276 | create_proto_group_modules(blueprint, gn, l_name, t_names) |
| 1277 | |
| 1278 | output = [ |
Patrick Rohr | 5478b39 | 2022-10-25 09:58:50 -0700 | [diff] [blame] | 1279 | """// Copyright (C) 2022 The Android Open Source Project |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1280 | // |
| 1281 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 1282 | // you may not use this file except in compliance with the License. |
| 1283 | // You may obtain a copy of the License at |
| 1284 | // |
| 1285 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 1286 | // |
| 1287 | // Unless required by applicable law or agreed to in writing, software |
| 1288 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 1289 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 1290 | // See the License for the specific language governing permissions and |
| 1291 | // limitations under the License. |
| 1292 | // |
| 1293 | // This file is automatically generated by %s. Do not edit. |
| 1294 | """ % (tool_name) |
| 1295 | ] |
| 1296 | blueprint.to_string(output) |
Patrick Rohr | cb98e9b | 2022-10-25 09:57:02 -0700 | [diff] [blame] | 1297 | if os.path.exists(args.extras): |
| 1298 | with open(args.extras, 'r') as r: |
| 1299 | for line in r: |
| 1300 | output.append(line.rstrip("\n\r")) |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1301 | |
| 1302 | out_files = [] |
| 1303 | |
| 1304 | # Generate the Android.bp file. |
| 1305 | out_files.append(args.output + '.swp') |
| 1306 | with open(out_files[-1], 'w') as f: |
| 1307 | f.write('\n'.join(output)) |
| 1308 | # Text files should have a trailing EOL. |
| 1309 | f.write('\n') |
| 1310 | |
Patrick Rohr | 94693eb | 2022-10-25 10:09:16 -0700 | [diff] [blame] | 1311 | return 0 |
Patrick Rohr | 92d7412 | 2022-10-21 15:50:52 -0700 | [diff] [blame] | 1312 | |
| 1313 | |
| 1314 | if __name__ == '__main__': |
| 1315 | sys.exit(main()) |