1# Copyright (c) 2022 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_root/ark_var.gni")
15
16template("ohos_executable") {
17  if (defined(invoker.subsystem_name) && defined(invoker.part_name)) {
18    subsystem_name = invoker.subsystem_name
19    part_name = invoker.part_name
20  } else if (defined(invoker.subsystem_name)) {
21    subsystem_name = invoker.subsystem_name
22    part_name = subsystem_name
23  } else {
24    subsystem_name = "arkcompiler"
25    part_name = "common"
26  }
27  assert(part_name != "")
28  assert(subsystem_name != "")
29
30  if (defined(invoker.unit_test) && invoker.unit_test) {
31    output_dir = invoker.test_output_dir
32  } else {
33    output_dir = "${root_out_dir}/${subsystem_name}/${part_name}"
34  }
35
36  executable(target_name) {
37    forward_variables_from(invoker,
38                           "*",
39                           [
40                             "configs",
41                             "remove_configs",
42                             "subsystem_name",
43                             "install_enable",
44                             "part_name",
45                             "use_exceptions",
46                             "static_link",
47                             "output_dir",
48                             "unit_test",
49                             "external_deps",
50                             "stack_protector_ret",
51                             "use_rtti",
52                           ])
53    output_dir = output_dir
54    if (defined(invoker.configs)) {
55      configs += invoker.configs
56    }
57
58    if (defined(invoker.remove_configs)) {
59      configs -= invoker.remove_configs
60    }
61
62    if (defined(invoker.use_exceptions) && invoker.use_exceptions) {
63      configs += [ "//arkcompiler/toolchain/build/config/compiler:exceptions" ]
64      ldflags = []
65    }
66    if (defined(invoker.use_rtti) && invoker.use_rtti) {
67      configs += [ "//arkcompiler/toolchain/build/config/compiler:rtti" ]
68    }
69    if (!defined(libs)) {
70      libs = []
71    }
72    if (!defined(ldflags)) {
73      ldflags = []
74    }
75    if (!defined(inputs)) {
76      inputs = []
77    }
78
79    if (defined(version_script)) {
80      _version_script = rebase_path(version_script, root_build_dir)
81      inputs += [ version_script ]
82      ldflags += [ "-Wl,--version-script=${_version_script}" ]
83    }
84
85    if (defined(invoker.static_link) && invoker.static_link) {
86      no_default_deps = true
87      ldflags += [ "-static" ]
88      configs -= [ "$build_root/config:executable_config" ]
89      if (is_ohos) {
90        import("$build_root/config/ohos/musl.gni")
91        deps += [ "$build_root/third_party_gn/musl:soft_static_libs" ]
92      }
93    } else if (is_ohos) {
94      if (current_cpu == "arm" || current_cpu == "arm64") {
95        libs += [ "unwind" ]
96      }
97      libs += [ "c++" ]
98    }
99
100    if (defined(invoker.external_deps) && invoker.external_deps != []) {
101      if (!defined(deps)) {
102        deps = []
103      }
104
105      external_deps_temp_file =
106          "$target_gen_dir/${part_name}__${target_name}_external_deps_temp.json"
107      arguments = [
108        "--root-src-dir",
109        rebase_path("//", root_build_dir),
110        "--external-deps-temp-file",
111        rebase_path(external_deps_temp_file, root_build_dir),
112        "--external-deps",
113      ]
114      arguments += invoker.external_deps
115      exec_script("$build_root/templates/cxx/external_deps_handler.py",
116                  arguments,
117                  "string")
118      external_deps_info = read_file(external_deps_temp_file, "json")
119      if (defined(external_deps_info.deps)) {
120        deps += external_deps_info.deps
121      }
122    }
123  }
124}
125
126template("ohos_static_library") {
127  if (defined(invoker.subsystem_name) && defined(invoker.part_name)) {
128    part_name = invoker.part_name
129  } else if (defined(invoker.part_name)) {
130    part_name = invoker.part_name
131  } else if (defined(invoker.subsystem_name)) {
132    part_name = invoker.subsystem_name
133  } else {
134    part_name = "common"
135  }
136  assert(part_name != "")
137
138  static_library(target_name) {
139    forward_variables_from(invoker,
140                           "*",
141                           [
142                             "configs",
143                             "remove_configs",
144                             "subsystem_name",
145                             "part_name",
146                             "use_exceptions",
147                             "external_deps",
148                             "stack_protector_ret",
149                             "use_rtti",
150                           ])
151    if (defined(invoker.configs)) {
152      configs += invoker.configs
153    }
154
155    if (defined(invoker.remove_configs)) {
156      configs -= invoker.remove_configs
157    }
158
159    if (defined(invoker.use_exceptions) && invoker.use_exceptions) {
160      configs += [ "//arkcompiler/toolchain/build/config/compiler:exceptions" ]
161      ldflags = []
162    }
163
164    if (defined(invoker.use_rtti) && invoker.use_rtti) {
165      configs += [ "//arkcompiler/toolchain/build/config/compiler:rtti" ]
166    }
167    if (!defined(libs)) {
168      libs = []
169    }
170    if (!defined(include_dirs)) {
171      include_dirs = []
172    }
173
174    if (defined(invoker.external_deps) && invoker.external_deps != []) {
175      if (!defined(deps)) {
176        deps = []
177      }
178
179      external_deps_temp_file =
180          "$target_gen_dir/${part_name}__${target_name}_external_deps_temp.json"
181      arguments = [
182        "--root-src-dir",
183        rebase_path("//", root_build_dir),
184        "--external-deps-temp-file",
185        rebase_path(external_deps_temp_file, root_build_dir),
186        "--external-deps",
187      ]
188      arguments += invoker.external_deps
189      exec_script("$build_root/templates/cxx/external_deps_handler.py",
190                  arguments,
191                  "string")
192      external_deps_info = read_file(external_deps_temp_file, "json")
193      if (defined(external_deps_info.deps)) {
194        deps += external_deps_info.deps
195      }
196    }
197  }
198}
199
200template("ohos_shared_library") {
201  if (defined(invoker.subsystem_name) && defined(invoker.part_name)) {
202    subsystem_name = invoker.subsystem_name
203    part_name = invoker.part_name
204  } else if (defined(invoker.subsystem_name)) {
205    subsystem_name = invoker.subsystem_name
206    part_name = subsystem_name
207  } else {
208    subsystem_name = "arkcompiler"
209    part_name = "common"
210  }
211  output_dir = "${root_out_dir}/${subsystem_name}/${part_name}"
212  shared_library(target_name) {
213    forward_variables_from(invoker,
214                           "*",
215                           [
216                             "relative_install_dir",
217                             "configs",
218                             "subsystem_name",
219                             "install_enable",
220                             "part_name",
221                             "output_dir",
222                             "install_images",
223                             "use_exceptions",
224                             "external_deps",
225                             "stack_protector_ret",
226                             "innerapi_tags",
227                             "use_rtti",
228                           ])
229    output_dir = output_dir
230    if (defined(invoker.configs)) {
231      configs += invoker.configs
232    }
233    if (defined(invoker.remove_configs)) {
234      configs -= invoker.remove_configs
235    }
236
237    if (!defined(libs)) {
238      libs = []
239    }
240    if (!defined(ldflags)) {
241      ldflags = []
242    }
243    if (!defined(inputs)) {
244      inputs = []
245    }
246    if (defined(invoker.use_rtti) && invoker.use_rtti) {
247      configs += [ "//arkcompiler/toolchain/build/config/compiler:rtti" ]
248    }
249
250    if (defined(version_script)) {
251      _version_script = rebase_path(version_script, root_build_dir)
252      inputs += [ version_script ]
253      ldflags += [ "-Wl,--version-script=${_version_script}" ]
254    }
255
256    if (is_ohos) {
257      if (defined(invoker.stl)) {
258        cflags_cc += [
259          "-nostdinc++",
260          "-I" + rebase_path(
261                  "//prebuilts/clang/ohos/${host_platform_dir}/llvm_ndk/include/c++/v1",
262                  root_build_dir),
263        ]
264        ldflags += [
265          "-nostdlib++",
266          "-L" + rebase_path("${clang_stl_path}/${abi_target}/c++",
267                             root_build_dir),
268        ]
269        libs += [ invoker.stl ]
270      } else {
271        if (current_cpu == "arm" || current_cpu == "arm64") {
272          libs += [ "unwind" ]
273        }
274        libs += [ "c++" ]
275      }
276    }
277
278    if (defined(invoker.external_deps) && invoker.external_deps != []) {
279      if (!defined(deps)) {
280        deps = []
281      }
282
283      external_deps_temp_file =
284          "$target_gen_dir/${part_name}__${target_name}_external_deps_temp.json"
285      arguments = [
286        "--root-src-dir",
287        rebase_path("//", root_build_dir),
288        "--external-deps-temp-file",
289        rebase_path(external_deps_temp_file, root_build_dir),
290        "--external-deps",
291      ]
292      arguments += invoker.external_deps
293      exec_script("$build_root/templates/cxx/external_deps_handler.py",
294                  arguments,
295                  "string")
296      external_deps_info = read_file(external_deps_temp_file, "json")
297      if (defined(external_deps_info.deps)) {
298        deps += external_deps_info.deps
299      }
300    }
301  }
302}
303
304template("ohos_source_set") {
305  if (defined(invoker.subsystem_name) && defined(invoker.part_name)) {
306    subsystem_name = invoker.subsystem_name
307    part_name = invoker.part_name
308  } else if (defined(invoker.subsystem_name)) {
309    subsystem_name = invoker.subsystem_name
310    part_name = subsystem_name
311  } else {
312    subsystem_name = "arkcompiler"
313    part_name = "common"
314  }
315  assert(subsystem_name != "")
316  assert(part_name != "")
317
318  source_set(target_name) {
319    forward_variables_from(invoker,
320                           "*",
321                           [
322                             "configs",
323                             "remove_configs",
324                             "no_default_deps",
325                             "external_deps",
326                             "license_file",
327                             "license_as_sources",
328                             "use_exceptions",
329                             "subsystem_name",
330                             "part_name",
331                             "stack_protector_ret",
332                             "use_rtti",
333                           ])
334    if (defined(invoker.configs)) {
335      configs += invoker.configs
336    }
337    if (defined(invoker.use_rtti) && invoker.use_rtti) {
338      configs += [ "//arkcompiler/toolchain/build/config/compiler:rtti" ]
339    }
340    if (defined(invoker.remove_configs)) {
341      configs -= invoker.remove_configs
342    }
343    if (defined(invoker.external_deps) && invoker.external_deps != []) {
344      if (!defined(deps)) {
345        deps = []
346      }
347      external_deps_temp_file =
348          "$target_gen_dir/${part_name}__${target_name}_external_deps_temp.json"
349      arguments = [
350        "--root-src-dir",
351        rebase_path("//", root_build_dir),
352        "--external-deps-temp-file",
353        rebase_path(external_deps_temp_file, root_build_dir),
354        "--external-deps",
355      ]
356      arguments += invoker.external_deps
357      exec_script("$build_root/templates/cxx/external_deps_handler.py",
358                  arguments,
359                  "string")
360      external_deps_info = read_file(external_deps_temp_file, "json")
361      if (defined(external_deps_info.deps)) {
362        deps += external_deps_info.deps
363      }
364    }
365  }
366}
367
368template("ohos_copy") {
369  assert(defined(invoker.sources),
370         "sources must be defined for ${target_name}.")
371  assert(defined(invoker.outputs),
372         "outputs must be defined for ${target_name}.")
373  if (defined(invoker.subsystem_name) && defined(invoker.part_name)) {
374    copy_subsystem_name = invoker.subsystem_name
375    copy_part_name = invoker.part_name
376  } else if (defined(invoker.subsystem_name)) {
377    copy_subsystem_name = invoker.subsystem_name
378    copy_part_name = copy_subsystem_name
379  } else {
380    copy_subsystem_name = "common"
381    copy_part_name = copy_subsystem_name
382  }
383  assert(copy_subsystem_name != "")
384  assert(copy_part_name != "")
385
386  copy(target_name) {
387    forward_variables_from(invoker,
388                           "*",
389                           [
390                             "relative_install_dir",
391                             "module_source_dir",
392                             "module_install_name",
393                             "license_file",
394                             "install_enable",
395                             "module_type",
396                           ])
397  }
398}
399