1# Copyright (c) 2021 Huawei Device Co., Ltd. 2# Licensed under the Apache License, Version 2.0 (the "License"); 3# you may not use this file except in compliance with the License. 4# You may obtain a copy of the License at 5# 6# http://www.apache.org/licenses/LICENSE-2.0 7# 8# Unless required by applicable law or agreed to in writing, software 9# distributed under the License is distributed on an "AS IS" BASIS, 10# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11# See the License for the specific language governing permissions and 12# limitations under the License. 13 14import("//build/config/clang/clang.gni") 15import("//build/config/ohos/config.gni") 16import("//build/config/security/security_config.gni") 17import("//build/ohos/notice/notice.gni") 18import("//build/ohos_var.gni") 19import("//build/templates/common/check_target.gni") 20import("//build/templates/metadata/module_info.gni") 21 22default_opt_configs = [ 23 "//build/config/compiler:default_symbols", 24 "//build/config/compiler:default_optimization", 25] 26 27debug_level_configs = [ 28 "//build/config/compiler:symbols", 29 "//build/config/compiler:no_optimize", 30] 31 32template("ohos_executable") { 33 assert(!defined(invoker.output_dir), 34 "output_dir is not allowed to be defined.") 35 36 if (defined(invoker.subsystem_name) && defined(invoker.part_name)) { 37 subsystem_name = invoker.subsystem_name 38 part_name = invoker.part_name 39 } else if (defined(invoker.part_name)) { 40 part_name = invoker.part_name 41 _part_subsystem_info_file = 42 "$root_build_dir/build_configs/parts_info/part_subsystem.json" 43 _arguments = [ 44 "--part-name", 45 part_name, 46 "--part-subsystem-info-file", 47 rebase_path(_part_subsystem_info_file, root_build_dir), 48 ] 49 get_subsystem_script = "//build/templates/common/get_subsystem_name.py" 50 subsystem_name = 51 exec_script(get_subsystem_script, _arguments, "trim string") 52 if (is_use_check_deps) { 53 skip_check_subsystem = true 54 } 55 } else if (defined(invoker.subsystem_name)) { 56 subsystem_name = invoker.subsystem_name 57 part_name = subsystem_name 58 } else { 59 subsystem_name = "common" 60 part_name = subsystem_name 61 } 62 assert(subsystem_name != "") 63 assert(part_name != "") 64 65 if (is_use_check_deps) { 66 _check_target = "${target_name}__check" 67 target_path = get_label_info(":${target_name}", "label_no_toolchain") 68 check_target(_check_target) { 69 module_deps = [] 70 if (defined(invoker.deps)) { 71 module_deps += invoker.deps 72 } 73 if (defined(invoker.public_deps)) { 74 module_deps += invoker.public_deps 75 } 76 if (defined(invoker.external_deps)) { 77 module_ex_deps = invoker.external_deps 78 } 79 } 80 } 81 82 if (check_deps) { 83 deps_data = { 84 } 85 module_label = get_label_info(":${target_name}", "label_with_toolchain") 86 module_deps = [] 87 if (defined(invoker.deps)) { 88 foreach(dep, invoker.deps) { 89 module_deps += [ get_label_info(dep, "label_no_toolchain") ] 90 } 91 } 92 module_ex_deps = [] 93 if (defined(invoker.external_deps) && invoker.external_deps != []) { 94 module_ex_deps = invoker.external_deps 95 } 96 deps_data = { 97 part_name = part_name 98 module_label = module_label 99 deps = module_deps 100 external_deps = module_ex_deps 101 } 102 103 write_file("${root_out_dir}/deps_files/${part_name}__${target_name}.json", 104 deps_data, 105 "json") 106 } 107 108 _ohos_test = false 109 if (defined(invoker.ohos_test) && invoker.ohos_test) { 110 output_dir = invoker.test_output_dir 111 _ohos_test = true 112 } else { 113 if (is_standard_system) { 114 output_dir = "${root_out_dir}/${subsystem_name}/${part_name}" 115 } else { 116 output_dir = "${root_out_dir}" 117 } 118 } 119 120 _security_config_target = "${target_name}__security_config" 121 ohos_security_config(_security_config_target) { 122 forward_variables_from(invoker, [ "auto_var_init" ]) 123 } 124 125 _sanitize_config_target = "${target_name}__sanitizer_config" 126 ohos_sanitizer_config(_sanitize_config_target) { 127 forward_variables_from(invoker, [ "sanitize" ]) 128 } 129 130 _test_target = defined(invoker.testonly) && invoker.testonly 131 if (!_test_target) { 132 _main_target_name = target_name 133 _notice_target = "${_main_target_name}__notice" 134 collect_notice(_notice_target) { 135 forward_variables_from(invoker, 136 [ 137 "testonly", 138 "license_as_sources", 139 "license_file", 140 ]) 141 142 module_name = _main_target_name 143 module_source_dir = get_label_info(":${_main_target_name}", "dir") 144 } 145 } 146 target_label = get_label_info(":${target_name}", "label_with_toolchain") 147 target_toolchain = get_label_info(target_label, "toolchain") 148 149 if (!_ohos_test) { 150 ohos_module_name = target_name 151 _module_info_target = "${target_name}_info" 152 generate_module_info(_module_info_target) { 153 module_name = ohos_module_name 154 module_type = "bin" 155 156 module_source_dir = "$root_out_dir" 157 if (defined(output_dir)) { 158 module_source_dir = output_dir 159 } 160 161 module_install_name = ohos_module_name 162 if (defined(invoker.output_name)) { 163 module_install_name = invoker.output_name 164 } 165 166 module_install_images = [ "system" ] 167 if (defined(invoker.install_images)) { 168 module_install_images = [] 169 module_install_images += invoker.install_images 170 } 171 172 module_output_extension = executable_extension 173 if (defined(invoker.output_extension)) { 174 module_output_extension = "." + invoker.output_extension 175 } 176 177 if (is_double_framework) { 178 install_enable = false 179 } else { 180 install_enable = true 181 } 182 if (defined(invoker.install_enable)) { 183 install_enable = invoker.install_enable 184 } 185 186 if (defined(invoker.module_install_dir)) { 187 module_install_dir = invoker.module_install_dir 188 } 189 190 if (defined(invoker.relative_install_dir)) { 191 relative_install_dir = invoker.relative_install_dir 192 } 193 194 if (defined(invoker.symlink_target_name)) { 195 symlink_target_name = invoker.symlink_target_name 196 } 197 198 if (defined(invoker.version_script)) { 199 version_script = rebase_path(invoker.version_script, root_build_dir) 200 } 201 notice = "$target_out_dir/$ohos_module_name.notice.txt" 202 } 203 } 204 205 if (!defined(invoker.stable)) { 206 stable = false 207 } 208 209 executable("${target_name}") { 210 forward_variables_from(invoker, 211 "*", 212 [ 213 "configs", 214 "remove_configs", 215 "static_link", 216 "external_deps", 217 "install_images", 218 "module_install_dir", 219 "relative_install_dir", 220 "symlink_target_name", 221 "output_dir", 222 "install_enable", 223 "version_script", 224 "license_file", 225 "license_as_sources", 226 "use_exceptions", 227 "use_rtti", 228 229 # Sanitizer variables 230 "sanitize", 231 "crate_type", 232 "stack_protector_ret", 233 ]) 234 output_dir = output_dir 235 236 if (defined(invoker.configs)) { 237 configs += invoker.configs 238 } 239 if (defined(invoker.remove_configs)) { 240 configs -= invoker.remove_configs 241 } 242 configs += [ ":$_sanitize_config_target" ] 243 configs += [ ":$_security_config_target" ] 244 245 if (defined(invoker.use_exceptions) && invoker.use_exceptions) { 246 configs += [ "//build/config/compiler:exceptions" ] 247 configs -= [ "//build/config/compiler:no_exceptions" ] 248 } 249 250 if (defined(invoker.use_rtti) && invoker.use_rtti) { 251 configs += [ "//build/config/compiler:rtti" ] 252 configs -= [ "//build/config/compiler:no_rtti" ] 253 } 254 255 if (support_stack_protector_ret) { 256 if (defined(invoker.stack_protector_ret)) { 257 configs -= 258 [ "//build/config/security:stack_protector_ret_strong_config" ] 259 if (invoker.stack_protector_ret) { 260 configs += 261 [ "//build/config/security:stack_protector_ret_all_config" ] 262 } else { 263 configs += [ "//build/config/security:stack_protector_config" ] 264 } 265 } 266 } 267 268 if (!defined(deps)) { 269 deps = [] 270 } 271 if (is_use_check_deps) { 272 deps += [ ":$_check_target" ] 273 } 274 if (!_ohos_test && !skip_gen_module_info) { 275 deps += [ ":$_module_info_target" ] 276 } 277 if (!defined(libs)) { 278 libs = [] 279 } 280 if (!defined(include_dirs)) { 281 include_dirs = [] 282 } 283 if (!defined(ldflags)) { 284 ldflags = [] 285 } 286 287 if (defined(invoker.static_link) && invoker.static_link) { 288 no_default_deps = true 289 configs -= [ "//build/config:executable_config" ] 290 ldflags += [ "-static" ] 291 if (is_ohos && use_musl) { 292 import("//build/config/ohos/musl.gni") 293 deps += [ "//third_party/musl:soft_static_libs" ] 294 } 295 } else if (is_ohos) { 296 if (current_cpu == "arm" || current_cpu == "arm64") { 297 libs += [ "unwind" ] 298 } 299 libs += [ 300 rebase_path(libclang_rt_file), 301 "c++", 302 ] 303 } 304 305 if (!defined(output_name)) { 306 output_name = target_name 307 } 308 309 if (defined(invoker.version_script)) { 310 _version_script = rebase_path(invoker.version_script, root_build_dir) 311 if (!defined(ldflags)) { 312 ldflags = [] 313 } 314 ldflags += [ 315 "-rdynamic", 316 "-Wl,--version-script=${_version_script}", 317 ] 318 } 319 320 if (defined(invoker.external_deps) && invoker.external_deps != [] && 321 !build_cross_platform_version) { 322 external_deps_temp_file = 323 "$target_gen_dir/${part_name}__${target_name}_external_deps_temp.json" 324 if (!ohos_skip_parse_external_deps) { 325 component_override_map = rebase_path( 326 "${root_build_dir}/build_configs/component_override_map.json") 327 external_deps_script = 328 rebase_path("//build/templates/common/external_deps_handler.py") 329 arguments = [ "--external-deps" ] 330 arguments += invoker.external_deps 331 arguments += [ 332 "--parts-src-flag-file", 333 rebase_path(parts_src_flag_file, root_build_dir), 334 "--external-deps-temp-file", 335 rebase_path(external_deps_temp_file, root_build_dir), 336 "--sdk-base-dir", 337 rebase_path("${innersdk_base_dir}", root_build_dir), 338 "--sdk-dir-name", 339 "${innersdk_dir_name}", 340 "--current-toolchain", 341 current_toolchain, 342 "--innerkits-adapter-info-file", 343 rebase_path("//build/ohos/inner_kits_adapter.json", root_build_dir), 344 "--component-override-map", 345 component_override_map, 346 ] 347 if (is_use_sdk) { 348 arguments += [ "--use-sdk" ] 349 } 350 handler_result = exec_script(external_deps_script, arguments, "string") 351 if (handler_result != "") { 352 print(handler_result) 353 } 354 } 355 356 external_deps_info = read_file(external_deps_temp_file, "json") 357 if (defined(external_deps_info.deps)) { 358 deps += external_deps_info.deps 359 } 360 if (defined(external_deps_info.libs)) { 361 libs += external_deps_info.libs 362 } 363 if (defined(external_deps_info.include_dirs)) { 364 include_dirs += external_deps_info.include_dirs 365 } 366 } 367 368 # We don't need to change config when "is_debug==true" 369 # "enable_debug_components" isn't blank means some components using debug level compilation 370 if (defined(is_debug) && !is_debug && enable_debug_components != "") { 371 foreach(component_name, debug_components) { 372 if (part_name == component_name) { 373 configs -= default_opt_configs 374 configs += debug_level_configs 375 } 376 } 377 } 378 if (target_toolchain == "${current_toolchain}") { 379 install_module_info = { 380 module_def = target_label 381 part_name = part_name 382 module_info_file = 383 rebase_path(get_label_info(module_def, "target_out_dir"), 384 root_build_dir) + "/${target_name}_module_info.json" 385 subsystem_name = subsystem_name 386 part_name = part_name 387 toolchain = current_toolchain 388 toolchain_out_dir = rebase_path(root_out_dir, root_build_dir) 389 } 390 metadata = { 391 install_modules = [ install_module_info ] 392 } 393 } 394 if (!_test_target) { 395 deps += [ ":$_notice_target" ] 396 } 397 398 module_label = get_label_info(":${target_name}", "label_with_toolchain") 399 400 deps_info = [] 401 foreach(dep, deps) { 402 info = { 403 } 404 info = { 405 target_out_dir = 406 rebase_path(get_label_info(dep, "target_out_dir"), root_build_dir) 407 target_name = get_label_info(dep, "name") 408 } 409 deps_info += [ info ] 410 } 411 target_deps_data = { 412 label = module_label 413 module_deps_info = deps_info 414 module_libs = libs 415 type = "executable" 416 prebuilt = false 417 stable = stable 418 toolchain = get_label_info(":${target_name}", "toolchain") 419 } 420 write_file("${target_out_dir}/${target_name}_deps_data.json", 421 target_deps_data, 422 "json") 423 } 424} 425 426# Defines a shared_library 427# 428# The shared_library template is used to generated so file. 429# 430# Parameters 431# 432# subsystem_name (required) 433# [string] 434# configs (optional) 435# [list] 436# remove_cnofigs (optional) 437# [list] 438# version_script (optional) 439# [string] 440template("ohos_shared_library") { 441 assert(!defined(invoker.output_dir), 442 "output_dir is not allowed to be defined.") 443 444 if (defined(invoker.subsystem_name) && defined(invoker.part_name)) { 445 subsystem_name = invoker.subsystem_name 446 part_name = invoker.part_name 447 } else if (defined(invoker.part_name)) { 448 part_name = invoker.part_name 449 _part_subsystem_info_file = 450 "$root_build_dir/build_configs/parts_info/part_subsystem.json" 451 _arguments = [ 452 "--part-name", 453 part_name, 454 "--part-subsystem-info-file", 455 rebase_path(_part_subsystem_info_file, root_build_dir), 456 ] 457 get_subsystem_script = "//build/templates/common/get_subsystem_name.py" 458 subsystem_name = 459 exec_script(get_subsystem_script, _arguments, "trim string") 460 if (is_use_check_deps) { 461 skip_check_subsystem = true 462 } 463 } else if (defined(invoker.subsystem_name)) { 464 subsystem_name = invoker.subsystem_name 465 part_name = subsystem_name 466 } else { 467 subsystem_name = "common" 468 part_name = subsystem_name 469 } 470 assert(subsystem_name != "") 471 assert(part_name != "") 472 473 if (is_use_check_deps) { 474 _check_target = "${target_name}__check" 475 target_path = get_label_info(":${target_name}", "label_no_toolchain") 476 check_target(_check_target) { 477 module_deps = [] 478 if (defined(invoker.deps)) { 479 module_deps += invoker.deps 480 } 481 if (defined(invoker.public_deps)) { 482 module_deps += invoker.public_deps 483 } 484 if (defined(invoker.external_deps)) { 485 module_ex_deps = invoker.external_deps 486 } 487 } 488 } 489 490 # auto set auto_relative_install_dir by innerapi_tags 491 if (defined(invoker.innerapi_tags)) { 492 is_chipsetsdk = false 493 is_platformsdk = false 494 is_passthrough = false 495 foreach(tag, filter_include(invoker.innerapi_tags, [ "chipsetsdk*" ])) { 496 is_chipsetsdk = true 497 } 498 foreach(tag, filter_include(invoker.innerapi_tags, [ "platformsdk*" ])) { 499 is_platformsdk = true 500 } 501 foreach(tag, filter_include(invoker.innerapi_tags, [ "passthrough*" ])) { 502 is_passthrough = true 503 } 504 505 if (is_chipsetsdk && is_platformsdk) { 506 auto_relative_install_dir = "chipset-pub-sdk" 507 } else if (is_chipsetsdk) { 508 auto_relative_install_dir = "chipset-sdk" 509 } else if (is_platformsdk) { 510 auto_relative_install_dir = "platformsdk" 511 } 512 if (is_passthrough) { 513 auto_relative_install_dir = chipset_passthrough_dir 514 } 515 516 is_ndk = false 517 foreach(tag, filter_include(invoker.innerapi_tags, [ "ndk" ])) { 518 is_ndk = true 519 } 520 if (is_ndk) { 521 auto_relative_install_dir = "ndk" 522 } 523 } 524 525 if (check_deps) { 526 deps_data = { 527 } 528 module_label = get_label_info(":${target_name}", "label_with_toolchain") 529 module_deps = [] 530 if (defined(invoker.deps)) { 531 foreach(dep, invoker.deps) { 532 module_deps += [ get_label_info(dep, "label_no_toolchain") ] 533 } 534 } 535 module_ex_deps = [] 536 if (defined(invoker.external_deps) && invoker.external_deps != []) { 537 module_ex_deps = invoker.external_deps 538 } 539 deps_data = { 540 part_name = part_name 541 module_label = module_label 542 deps = module_deps 543 external_deps = module_ex_deps 544 } 545 write_file("${root_out_dir}/deps_files/${part_name}__${target_name}.json", 546 deps_data, 547 "json") 548 } 549 550 if (is_standard_system) { 551 output_dir = "${root_out_dir}/${subsystem_name}/${part_name}" 552 } else { 553 output_dir = "${root_out_dir}" 554 } 555 556 _security_config_target = "${target_name}__security_config" 557 ohos_security_config(_security_config_target) { 558 forward_variables_from(invoker, [ "auto_var_init" ]) 559 } 560 561 _sanitize_config_target = "${target_name}__sanitizer_config" 562 ohos_sanitizer_config(_sanitize_config_target) { 563 forward_variables_from(invoker, [ "sanitize" ]) 564 } 565 566 _test_target = defined(invoker.testonly) && invoker.testonly 567 if (!_test_target) { 568 _notice_target = "${target_name}__notice" 569 _main_target_name = target_name 570 collect_notice(_notice_target) { 571 forward_variables_from(invoker, 572 [ 573 "testonly", 574 "license_as_sources", 575 "license_file", 576 ]) 577 578 module_name = _main_target_name 579 module_source_dir = get_label_info(":${_main_target_name}", "dir") 580 } 581 } 582 583 target_label = get_label_info(":${target_name}", "label_with_toolchain") 584 target_toolchain = get_label_info(target_label, "toolchain") 585 586 if (target_toolchain == "${current_toolchain}") { 587 ohos_module_name = target_name 588 _module_info_target = "${target_name}_info" 589 generate_module_info(_module_info_target) { 590 module_name = ohos_module_name 591 module_type = "lib" 592 module_source_dir = "$root_out_dir" 593 if (defined(output_dir)) { 594 module_source_dir = output_dir 595 } 596 597 module_install_name = ohos_module_name 598 if (defined(invoker.output_name)) { 599 module_install_name = invoker.output_name 600 } 601 602 module_install_images = [ "system" ] 603 if (defined(invoker.install_images)) { 604 module_install_images = [] 605 module_install_images += invoker.install_images 606 } 607 608 module_output_extension = shlib_extension 609 if (defined(invoker.output_extension)) { 610 module_output_extension = "." + invoker.output_extension 611 } 612 613 install_enable = true 614 if (defined(invoker.install_enable)) { 615 install_enable = invoker.install_enable 616 } 617 618 if (defined(invoker.module_install_dir)) { 619 module_install_dir = invoker.module_install_dir 620 } 621 622 if (defined(invoker.relative_install_dir)) { 623 relative_install_dir = invoker.relative_install_dir 624 } 625 626 if (defined(invoker.symlink_target_name)) { 627 symlink_target_name = invoker.symlink_target_name 628 } 629 630 if (defined(invoker.output_prefix_override)) { 631 output_prefix_override = invoker.output_prefix_override 632 } 633 notice = "$target_out_dir/$ohos_module_name.notice.txt" 634 635 # update relative_install_dir if auto_relative_install_dir defined 636 if (defined(auto_relative_install_dir)) { 637 relative_install_dir = auto_relative_install_dir 638 } 639 640 # Passing shlib_type and innerapi_tags to generate_module_info 641 if (defined(invoker.shlib_type)) { 642 invalid = true 643 valid_types = [ 644 "sa", 645 "sa_stub", 646 "sa_proxy", 647 "hdi", 648 "hdi_stub", 649 "hdi_proxy", 650 "innerapi", 651 "napi", 652 ] 653 foreach(t, filter_include(valid_types, [ invoker.shlib_type ])) { 654 if (t == invoker.shlib_type) { 655 invalid = false 656 } 657 } 658 shlib_type = invoker.shlib_type 659 assert( 660 invalid != true, 661 "$target_label has invalid shlib_type value: $shlib_type, allowed values: $valid_types") 662 } 663 if (defined(invoker.innerapi_tags)) { 664 invalid = false 665 valid_tags = [ 666 "ndk", 667 "chipsetsdk", 668 "chipsetsdk_indirect", 669 "platformsdk", 670 "platformsdk_indirect", 671 "passthrough", 672 "passthrough_indirect", 673 "sasdk", 674 ] 675 foreach(tag, filter_exclude(invoker.innerapi_tags, valid_tags)) { 676 if (tag != "") { 677 invalid = true 678 } 679 } 680 innerapi_tags = invoker.innerapi_tags 681 assert( 682 invalid != true, 683 "$target_label has invalid innerapi_tags $innerapi_tags, allowed values: $valid_tags") 684 } 685 686 if (defined(invoker.version_script)) { 687 version_script = rebase_path(invoker.version_script, root_build_dir) 688 } 689 } 690 } 691 692 if (!defined(invoker.stable)) { 693 stable = false 694 } 695 696 shared_library("${target_name}") { 697 forward_variables_from(invoker, 698 "*", 699 [ 700 "configs", 701 "remove_configs", 702 "no_default_deps", 703 "external_deps", 704 "install_images", 705 "module_install_dir", 706 "relative_install_dir", 707 "symlink_target_name", 708 "output_dir", 709 "install_enable", 710 "version_script", 711 "exported_symbols_list", 712 "license_file", 713 "license_as_sources", 714 "use_exceptions", 715 "use_rtti", 716 "stl", 717 718 # Sanitizer variables 719 "sanitize", 720 "stack_protector_ret", 721 ]) 722 output_dir = output_dir 723 724 if (!defined(inputs)) { 725 inputs = [] 726 } 727 728 if (!defined(ldflags)) { 729 ldflags = [] 730 } 731 732 if (defined(invoker.configs)) { 733 configs += invoker.configs 734 } 735 if (defined(invoker.remove_configs)) { 736 configs -= invoker.remove_configs 737 } 738 739 configs += [ ":$_sanitize_config_target" ] 740 configs += [ ":$_security_config_target" ] 741 742 if (defined(invoker.use_exceptions) && invoker.use_exceptions) { 743 configs += [ "//build/config/compiler:exceptions" ] 744 configs -= [ "//build/config/compiler:no_exceptions" ] 745 } 746 747 if (defined(invoker.use_rtti) && invoker.use_rtti) { 748 configs += [ "//build/config/compiler:rtti" ] 749 configs -= [ "//build/config/compiler:no_rtti" ] 750 } 751 752 if (support_stack_protector_ret) { 753 if (defined(invoker.stack_protector_ret)) { 754 configs -= 755 [ "//build/config/security:stack_protector_ret_strong_config" ] 756 if (invoker.stack_protector_ret) { 757 configs += 758 [ "//build/config/security:stack_protector_ret_all_config" ] 759 } else { 760 configs += [ "//build/config/security:stack_protector_config" ] 761 } 762 } 763 } 764 765 if (!defined(output_name)) { 766 output_name = target_name 767 } 768 769 if (defined(invoker.no_default_deps)) { 770 no_default_deps = invoker.no_default_deps 771 } 772 773 if (defined(invoker.version_script)) { 774 _version_script = rebase_path(invoker.version_script, root_build_dir) 775 inputs += [ invoker.version_script ] 776 ldflags += [ "-Wl,--version-script=${_version_script}" ] 777 } 778 779 if (target_os == "ios" && defined(invoker.exported_symbols_list)) { 780 _exported_symbols_list = 781 rebase_path(invoker.exported_symbols_list, root_build_dir) 782 inputs += [ invoker.exported_symbols_list ] 783 ldflags += [ 784 "-exported_symbols_list", 785 "${_exported_symbols_list}", 786 ] 787 } 788 789 if (!defined(ldflags)) { 790 ldflags = [] 791 } 792 if (!defined(libs)) { 793 libs = [] 794 } 795 if (!defined(cflags_cc)) { 796 cflags_cc = [] 797 } 798 if (!defined(deps)) { 799 deps = [] 800 } 801 if (is_use_check_deps) { 802 deps += [ ":$_check_target" ] 803 } 804 if (target_toolchain == "${current_toolchain}" && !skip_gen_module_info) { 805 deps += [ ":$_module_info_target" ] 806 } 807 if (is_ohos) { 808 if (defined(invoker.stl)) { 809 cflags_cc += [ 810 "-nostdinc++", 811 "-I" + rebase_path( 812 "//prebuilts/clang/ohos/${host_platform_dir}/llvm_ndk/include/libcxx-ohos/include/c++/v1", 813 root_build_dir), 814 ] 815 ldflags += [ 816 "-nostdlib++", 817 "-L" + rebase_path("${clang_stl_path}/${abi_target}", root_build_dir), 818 ] 819 820 libs += [ invoker.stl ] 821 } else { 822 if (current_cpu == "arm" || current_cpu == "arm64") { 823 libs += [ "unwind" ] 824 } 825 826 libs += [ 827 rebase_path(libclang_rt_file), 828 "c++", 829 ] 830 } 831 } 832 833 if (!_test_target) { 834 deps += [ ":$_notice_target" ] 835 } 836 if (!defined(include_dirs)) { 837 include_dirs = [] 838 } 839 if (defined(invoker.external_deps) && invoker.external_deps != [] && 840 !build_cross_platform_version) { 841 external_deps_temp_file = 842 "$target_gen_dir/${part_name}__${target_name}_external_deps_temp.json" 843 if (!ohos_skip_parse_external_deps) { 844 component_override_map = rebase_path( 845 "${root_build_dir}/build_configs/component_override_map.json") 846 external_deps_script = 847 rebase_path("//build/templates/common/external_deps_handler.py") 848 arguments = [ "--external-deps" ] 849 arguments += invoker.external_deps 850 arguments += [ 851 "--parts-src-flag-file", 852 rebase_path(parts_src_flag_file, root_build_dir), 853 "--external-deps-temp-file", 854 rebase_path(external_deps_temp_file, root_build_dir), 855 "--sdk-base-dir", 856 rebase_path("${innersdk_base_dir}", root_build_dir), 857 "--sdk-dir-name", 858 "${innersdk_dir_name}", 859 "--current-toolchain", 860 current_toolchain, 861 "--innerkits-adapter-info-file", 862 rebase_path("//build/ohos/inner_kits_adapter.json", root_build_dir), 863 "--component-override-map", 864 component_override_map, 865 ] 866 if (is_use_sdk) { 867 arguments += [ "--use-sdk" ] 868 } 869 870 handler_result = exec_script(external_deps_script, arguments, "string") 871 if (handler_result != "") { 872 print(handler_result) 873 } 874 } 875 876 external_deps_info = read_file(external_deps_temp_file, "json") 877 if (defined(external_deps_info.deps)) { 878 deps += external_deps_info.deps 879 } 880 if (defined(external_deps_info.libs)) { 881 libs += external_deps_info.libs 882 } 883 if (defined(external_deps_info.include_dirs)) { 884 include_dirs += external_deps_info.include_dirs 885 } 886 } 887 888 install_module_info = { 889 module_def = target_label 890 module_info_file = 891 rebase_path(get_label_info(module_def, "target_out_dir"), 892 root_build_dir) + "/${target_name}_module_info.json" 893 subsystem_name = subsystem_name 894 part_name = part_name 895 toolchain = current_toolchain 896 toolchain_out_dir = rebase_path(root_out_dir, root_build_dir) 897 } 898 metadata = { 899 install_modules = [ install_module_info ] 900 } 901 if (defined(is_debug) && !is_debug && enable_debug_components != "") { 902 foreach(component_name, debug_components) { 903 if (part_name == component_name) { 904 configs -= default_opt_configs 905 configs += debug_level_configs 906 } 907 } 908 } 909 910 # Hide symbols for all sa libraries if not specified by version_script 911 if (defined(invoker.shlib_type) && invoker.shlib_type == "sa") { 912 if (!defined(invoker.version_script)) { 913 _version_script = 914 rebase_path("//build/templates/cxx/singleton.versionscript") 915 inputs += [ _version_script ] 916 ldflags += [ "-Wl,--version-script=${_version_script}" ] 917 } 918 } 919 920 # Set version_script for hdi service libraries 921 if (defined(invoker.shlib_type) && invoker.shlib_type == "hdi") { 922 if (!defined(invoker.version_script)) { 923 _version_script = rebase_path("//build/templates/cxx/hdi.versionscript") 924 inputs += [ _version_script ] 925 ldflags += [ "-Wl,--version-script=${_version_script}" ] 926 } 927 } 928 929 module_type_napi = false 930 if (defined(invoker.relative_install_dir) && 931 (build_ohos_sdk != true && build_ohos_ndk != true)) { 932 relative_paths = string_split(invoker.relative_install_dir, "/") 933 foreach(p, relative_paths) { 934 if (p == "module") { 935 module_type_napi = true 936 } 937 } 938 if (module_type_napi) { 939 foreach(m, filter_include(napi_white_list, [ target_name ])) { 940 if (m == target_name) { 941 module_type_napi = false 942 } 943 } 944 } 945 } 946 if (module_type_napi) { 947 if (!defined(invoker.version_script)) { 948 _version_script = 949 rebase_path("//build/templates/cxx/napi.versionscript") 950 inputs += [ _version_script ] 951 ldflags += [ "-Wl,--version-script=${_version_script}" ] 952 } 953 } 954 955 deps_info = [] 956 foreach(dep, deps) { 957 info = { 958 } 959 info = { 960 target_out_dir = 961 rebase_path(get_label_info(dep, "target_out_dir"), root_build_dir) 962 target_name = get_label_info(dep, "name") 963 } 964 deps_info += [ info ] 965 } 966 module_label = get_label_info(":${target_name}", "label_with_toolchain") 967 target_deps_data = { 968 label = module_label 969 module_deps_info = deps_info 970 module_libs = libs 971 type = "shared_library" 972 prebuilt = false 973 stable = stable 974 toolchain = get_label_info(":${target_name}", "toolchain") 975 } 976 write_file("${target_out_dir}/${target_name}_deps_data.json", 977 target_deps_data, 978 "json") 979 } 980} 981 982template("ohos_static_library") { 983 if (defined(invoker.subsystem_name) && defined(invoker.part_name)) { 984 subsystem_name = invoker.subsystem_name 985 part_name = invoker.part_name 986 } else if (defined(invoker.part_name)) { 987 part_name = invoker.part_name 988 _part_subsystem_info_file = 989 "$root_build_dir/build_configs/parts_info/part_subsystem.json" 990 _arguments = [ 991 "--part-name", 992 part_name, 993 "--part-subsystem-info-file", 994 rebase_path(_part_subsystem_info_file, root_build_dir), 995 ] 996 get_subsystem_script = "//build/templates/common/get_subsystem_name.py" 997 subsystem_name = 998 exec_script(get_subsystem_script, _arguments, "trim string") 999 if (is_use_check_deps) { 1000 skip_check_subsystem = true 1001 } 1002 } else if (defined(invoker.subsystem_name)) { 1003 subsystem_name = invoker.subsystem_name 1004 part_name = subsystem_name 1005 } else { 1006 subsystem_name = "common" 1007 part_name = subsystem_name 1008 } 1009 assert(subsystem_name != "") 1010 assert(part_name != "") 1011 1012 if (is_use_check_deps) { 1013 _check_target = "${target_name}__check" 1014 target_path = get_label_info(":${target_name}", "label_no_toolchain") 1015 check_target(_check_target) { 1016 module_deps = [] 1017 if (defined(invoker.deps)) { 1018 module_deps += invoker.deps 1019 } 1020 if (defined(invoker.public_deps)) { 1021 module_deps += invoker.public_deps 1022 } 1023 if (defined(invoker.external_deps)) { 1024 module_ex_deps = invoker.external_deps 1025 } 1026 } 1027 } 1028 if (check_deps) { 1029 deps_data = { 1030 } 1031 module_label = get_label_info(":${target_name}", "label_with_toolchain") 1032 module_deps = [] 1033 if (defined(invoker.deps)) { 1034 foreach(dep, invoker.deps) { 1035 module_deps += [ get_label_info(dep, "label_no_toolchain") ] 1036 } 1037 } 1038 module_ex_deps = [] 1039 if (defined(invoker.external_deps) && invoker.external_deps != []) { 1040 module_ex_deps = invoker.external_deps 1041 } 1042 deps_data = { 1043 part_name = part_name 1044 module_label = module_label 1045 deps = module_deps 1046 external_deps = module_ex_deps 1047 } 1048 1049 write_file("${root_out_dir}/deps_files/${part_name}__${target_name}.json", 1050 deps_data, 1051 "json") 1052 } 1053 1054 _security_config_target = "${target_name}__security_config" 1055 ohos_security_config(_security_config_target) { 1056 forward_variables_from(invoker, [ "auto_var_init" ]) 1057 } 1058 1059 _sanitize_config_target = "${target_name}__sanitizer_config" 1060 ohos_sanitizer_config(_sanitize_config_target) { 1061 forward_variables_from(invoker, [ "sanitize" ]) 1062 } 1063 1064 _test_target = defined(invoker.testonly) && invoker.testonly 1065 if (!_test_target) { 1066 _notice_target = "${target_name}__notice" 1067 _main_target_name = target_name 1068 collect_notice(_notice_target) { 1069 forward_variables_from(invoker, 1070 [ 1071 "testonly", 1072 "license_as_sources", 1073 "license_file", 1074 ]) 1075 module_type = "static_library" 1076 module_name = _main_target_name 1077 module_source_dir = get_label_info(":${_main_target_name}", "dir") 1078 } 1079 } 1080 1081 static_library(target_name) { 1082 forward_variables_from(invoker, 1083 "*", 1084 [ 1085 "configs", 1086 "remove_configs", 1087 "no_default_deps", 1088 "external_deps", 1089 "license_file", 1090 "license_as_sources", 1091 "use_exceptions", 1092 "use_rtti", 1093 "subsystem_name", 1094 1095 # Sanitizer variables 1096 "sanitize", 1097 "stack_protector_ret", 1098 ]) 1099 if (defined(invoker.configs)) { 1100 configs += invoker.configs 1101 } 1102 if (defined(invoker.remove_configs)) { 1103 configs -= invoker.remove_configs 1104 } 1105 if (is_standard_system) { 1106 configs -= [ "//build/config/compiler:thin_archive" ] 1107 } 1108 configs += [ ":$_sanitize_config_target" ] 1109 configs += [ ":$_security_config_target" ] 1110 1111 if (defined(invoker.use_exceptions) && invoker.use_exceptions) { 1112 configs += [ "//build/config/compiler:exceptions" ] 1113 configs -= [ "//build/config/compiler:no_exceptions" ] 1114 } 1115 1116 if (defined(invoker.use_rtti) && invoker.use_rtti) { 1117 configs += [ "//build/config/compiler:rtti" ] 1118 configs -= [ "//build/config/compiler:no_rtti" ] 1119 } 1120 1121 if (support_stack_protector_ret) { 1122 if (defined(invoker.stack_protector_ret)) { 1123 configs -= 1124 [ "//build/config/security:stack_protector_ret_strong_config" ] 1125 if (invoker.stack_protector_ret) { 1126 configs += 1127 [ "//build/config/security:stack_protector_ret_all_config" ] 1128 } else { 1129 configs += [ "//build/config/security:stack_protector_config" ] 1130 } 1131 } 1132 } 1133 1134 if (defined(invoker.no_default_deps)) { 1135 no_default_deps = invoker.no_default_deps 1136 } 1137 1138 if (!defined(deps)) { 1139 deps = [] 1140 } 1141 if (is_use_check_deps) { 1142 deps += [ ":$_check_target" ] 1143 } 1144 if (!_test_target) { 1145 deps += [ ":$_notice_target" ] 1146 } 1147 if (!defined(libs)) { 1148 libs = [] 1149 } 1150 if (!defined(include_dirs)) { 1151 include_dirs = [] 1152 } 1153 if (defined(invoker.external_deps) && invoker.external_deps != [] && 1154 !build_cross_platform_version) { 1155 external_deps_temp_file = 1156 "$target_gen_dir/${part_name}__${target_name}_external_deps_temp.json" 1157 if (!ohos_skip_parse_external_deps) { 1158 component_override_map = rebase_path( 1159 "${root_build_dir}/build_configs/component_override_map.json") 1160 external_deps_script = 1161 rebase_path("//build/templates/common/external_deps_handler.py") 1162 arguments = [ "--external-deps" ] 1163 arguments += invoker.external_deps 1164 arguments += [ 1165 "--parts-src-flag-file", 1166 rebase_path(parts_src_flag_file, root_build_dir), 1167 "--external-deps-temp-file", 1168 rebase_path(external_deps_temp_file, root_build_dir), 1169 "--sdk-base-dir", 1170 rebase_path("${innersdk_base_dir}", root_build_dir), 1171 "--sdk-dir-name", 1172 "${innersdk_dir_name}", 1173 "--current-toolchain", 1174 current_toolchain, 1175 "--innerkits-adapter-info-file", 1176 rebase_path("//build/ohos/inner_kits_adapter.json", root_build_dir), 1177 "--component-override-map", 1178 component_override_map, 1179 ] 1180 if (is_use_sdk) { 1181 arguments += [ "--use-sdk" ] 1182 } 1183 1184 handler_result = exec_script(external_deps_script, arguments, "string") 1185 if (handler_result != "") { 1186 print(handler_result) 1187 } 1188 } 1189 1190 external_deps_info = read_file(external_deps_temp_file, "json") 1191 if (defined(external_deps_info.deps)) { 1192 deps += external_deps_info.deps 1193 } 1194 if (defined(external_deps_info.libs)) { 1195 libs += external_deps_info.libs 1196 } 1197 if (defined(external_deps_info.include_dirs)) { 1198 include_dirs += external_deps_info.include_dirs 1199 } 1200 } 1201 if (defined(is_debug) && !is_debug && enable_debug_components != "") { 1202 foreach(component_name, debug_components) { 1203 if (part_name == component_name) { 1204 configs -= default_opt_configs 1205 configs += debug_level_configs 1206 } 1207 } 1208 } 1209 1210 deps_info = [] 1211 foreach(dep, deps) { 1212 info = { 1213 } 1214 info = { 1215 target_out_dir = 1216 rebase_path(get_label_info(dep, "target_out_dir"), root_build_dir) 1217 target_name = get_label_info(dep, "name") 1218 } 1219 deps_info += [ info ] 1220 } 1221 module_label = get_label_info(":${target_name}", "label_with_toolchain") 1222 target_deps_data = { 1223 label = module_label 1224 module_deps_info = deps_info 1225 module_libs = libs 1226 type = "static_library" 1227 prebuilt = false 1228 toolchain = get_label_info(":${target_name}", "toolchain") 1229 } 1230 write_file("${target_out_dir}/${target_name}_deps_data.json", 1231 target_deps_data, 1232 "json") 1233 } 1234} 1235 1236template("ohos_source_set") { 1237 if (defined(invoker.subsystem_name) && defined(invoker.part_name)) { 1238 subsystem_name = invoker.subsystem_name 1239 part_name = invoker.part_name 1240 } else if (defined(invoker.part_name)) { 1241 part_name = invoker.part_name 1242 _part_subsystem_info_file = 1243 "$root_build_dir/build_configs/parts_info/part_subsystem.json" 1244 _arguments = [ 1245 "--part-name", 1246 part_name, 1247 "--part-subsystem-info-file", 1248 rebase_path(_part_subsystem_info_file, root_build_dir), 1249 ] 1250 get_subsystem_script = "//build/templates/common/get_subsystem_name.py" 1251 subsystem_name = 1252 exec_script(get_subsystem_script, _arguments, "trim string") 1253 if (is_use_check_deps) { 1254 skip_check_subsystem = true 1255 } 1256 } else if (defined(invoker.subsystem_name)) { 1257 subsystem_name = invoker.subsystem_name 1258 part_name = subsystem_name 1259 } else { 1260 subsystem_name = "common" 1261 part_name = subsystem_name 1262 } 1263 assert(subsystem_name != "") 1264 assert(part_name != "") 1265 1266 if (is_use_check_deps) { 1267 _check_target = "${target_name}__check" 1268 target_path = get_label_info(":${target_name}", "label_no_toolchain") 1269 check_target(_check_target) { 1270 module_deps = [] 1271 if (defined(invoker.deps)) { 1272 module_deps += invoker.deps 1273 } 1274 if (defined(invoker.public_deps)) { 1275 module_deps += invoker.public_deps 1276 } 1277 if (defined(invoker.external_deps)) { 1278 module_ex_deps = invoker.external_deps 1279 } 1280 } 1281 } 1282 1283 if (check_deps) { 1284 deps_data = { 1285 } 1286 module_label = get_label_info(":${target_name}", "label_with_toolchain") 1287 module_deps = [] 1288 if (defined(invoker.deps)) { 1289 foreach(dep, invoker.deps) { 1290 module_deps += [ get_label_info(dep, "label_no_toolchain") ] 1291 } 1292 } 1293 module_ex_deps = [] 1294 if (defined(invoker.external_deps) && invoker.external_deps != []) { 1295 module_ex_deps = invoker.external_deps 1296 } 1297 deps_data = { 1298 part_name = part_name 1299 module_label = module_label 1300 deps = module_deps 1301 external_deps = module_ex_deps 1302 } 1303 write_file("${root_out_dir}/deps_files/${part_name}__${target_name}.json", 1304 deps_data, 1305 "json") 1306 } 1307 1308 _security_config_target = "${target_name}__security_config" 1309 ohos_security_config(_security_config_target) { 1310 forward_variables_from(invoker, [ "auto_var_init" ]) 1311 } 1312 1313 _sanitize_config_target = "${target_name}__sanitizer_config" 1314 ohos_sanitizer_config(_sanitize_config_target) { 1315 forward_variables_from(invoker, [ "sanitize" ]) 1316 } 1317 1318 _test_target = defined(invoker.testonly) && invoker.testonly 1319 if (!_test_target) { 1320 _main_target_name = target_name 1321 _notice_target = "${_main_target_name}__notice" 1322 collect_notice(_notice_target) { 1323 forward_variables_from(invoker, 1324 [ 1325 "testonly", 1326 "license_as_sources", 1327 "license_file", 1328 ]) 1329 1330 module_type = "source_set" 1331 module_name = _main_target_name 1332 module_source_dir = get_label_info(":${_main_target_name}", "dir") 1333 } 1334 } 1335 1336 source_set(target_name) { 1337 forward_variables_from(invoker, 1338 "*", 1339 [ 1340 "configs", 1341 "remove_configs", 1342 "no_default_deps", 1343 "external_deps", 1344 "license_file", 1345 "license_as_sources", 1346 "use_exceptions", 1347 "use_rtti", 1348 "subsystem_name", 1349 1350 # Sanitizer variables 1351 "sanitize", 1352 "stack_protector_ret", 1353 ]) 1354 if (defined(invoker.configs)) { 1355 configs += invoker.configs 1356 } 1357 if (defined(invoker.remove_configs)) { 1358 configs -= invoker.remove_configs 1359 } 1360 1361 configs += [ ":$_sanitize_config_target" ] 1362 configs += [ ":$_security_config_target" ] 1363 1364 if (defined(invoker.use_exceptions) && invoker.use_exceptions) { 1365 configs += [ "//build/config/compiler:exceptions" ] 1366 configs -= [ "//build/config/compiler:no_exceptions" ] 1367 } 1368 1369 if (defined(invoker.use_rtti) && invoker.use_rtti) { 1370 configs += [ "//build/config/compiler:rtti" ] 1371 configs -= [ "//build/config/compiler:no_rtti" ] 1372 } 1373 1374 if (support_stack_protector_ret) { 1375 if (defined(invoker.stack_protector_ret)) { 1376 configs -= 1377 [ "//build/config/security:stack_protector_ret_strong_config" ] 1378 if (invoker.stack_protector_ret) { 1379 configs += 1380 [ "//build/config/security:stack_protector_ret_all_config" ] 1381 } else { 1382 configs += [ "//build/config/security:stack_protector_config" ] 1383 } 1384 } 1385 } 1386 1387 if (defined(invoker.no_default_deps)) { 1388 no_default_deps = invoker.no_default_deps 1389 } 1390 1391 if (!defined(deps)) { 1392 deps = [] 1393 } 1394 if (is_use_check_deps) { 1395 deps += [ ":$_check_target" ] 1396 } 1397 if (!_test_target) { 1398 deps += [ ":$_notice_target" ] 1399 } 1400 1401 if (!defined(libs)) { 1402 libs = [] 1403 } 1404 if (!defined(include_dirs)) { 1405 include_dirs = [] 1406 } 1407 if (defined(invoker.external_deps) && invoker.external_deps != [] && 1408 !build_cross_platform_version) { 1409 external_deps_temp_file = 1410 "$target_gen_dir/${part_name}__${target_name}_external_deps_temp.json" 1411 if (!ohos_skip_parse_external_deps) { 1412 component_override_map = rebase_path( 1413 "${root_build_dir}/build_configs/component_override_map.json") 1414 external_deps_script = 1415 rebase_path("//build/templates/common/external_deps_handler.py") 1416 arguments = [ "--external-deps" ] 1417 arguments += invoker.external_deps 1418 arguments += [ 1419 "--parts-src-flag-file", 1420 rebase_path(parts_src_flag_file, root_build_dir), 1421 "--external-deps-temp-file", 1422 rebase_path(external_deps_temp_file, root_build_dir), 1423 "--sdk-base-dir", 1424 rebase_path("${innersdk_base_dir}", root_build_dir), 1425 "--sdk-dir-name", 1426 "${innersdk_dir_name}", 1427 "--current-toolchain", 1428 current_toolchain, 1429 "--innerkits-adapter-info-file", 1430 rebase_path("//build/ohos/inner_kits_adapter.json", root_build_dir), 1431 "--component-override-map", 1432 component_override_map, 1433 ] 1434 if (is_use_sdk) { 1435 arguments += [ "--use-sdk" ] 1436 } 1437 1438 handler_result = exec_script(external_deps_script, arguments, "string") 1439 if (handler_result != "") { 1440 print(handler_result) 1441 } 1442 } 1443 1444 external_deps_info = read_file(external_deps_temp_file, "json") 1445 if (defined(external_deps_info.deps)) { 1446 deps += external_deps_info.deps 1447 } 1448 if (defined(external_deps_info.libs)) { 1449 libs += external_deps_info.libs 1450 } 1451 if (defined(external_deps_info.include_dirs)) { 1452 include_dirs += external_deps_info.include_dirs 1453 } 1454 } 1455 if (defined(is_debug) && !is_debug && enable_debug_components != "") { 1456 foreach(component_name, debug_components) { 1457 if (part_name == component_name) { 1458 configs -= default_opt_configs 1459 configs += debug_level_configs 1460 } 1461 } 1462 } 1463 1464 deps_info = [] 1465 foreach(dep, deps) { 1466 info = { 1467 } 1468 info = { 1469 target_out_dir = 1470 rebase_path(get_label_info(dep, "target_out_dir"), root_build_dir) 1471 target_name = get_label_info(dep, "name") 1472 } 1473 deps_info += [ info ] 1474 } 1475 module_label = get_label_info(":${target_name}", "label_with_toolchain") 1476 target_deps_data = { 1477 label = module_label 1478 module_deps_info = deps_info 1479 module_libs = libs 1480 type = "source_set" 1481 toolchain = get_label_info(":${target_name}", "toolchain") 1482 } 1483 write_file("${target_out_dir}/${target_name}_deps_data.json", 1484 target_deps_data, 1485 "json") 1486 } 1487} 1488