| # Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file |
| # for details. All rights reserved. Use of this source code is governed by a |
| # BSD-style license that can be found in the LICENSE file. |
| |
| import("../sdk_args.gni") |
| import("configs.gni") |
| import("runtime_args.gni") |
| |
| import("//build/config/sysroot.gni") |
| |
| config("dart_public_config") { |
| include_dirs = [ |
| ".", |
| "include", |
| ] |
| } |
| |
| # Adds PRODUCT define if Flutter has specified "release" for dart_runtime_mode |
| config("dart_maybe_product_config") { |
| defines = [] |
| |
| if (dart_runtime_mode != "develop" && dart_runtime_mode != "profile" && |
| dart_runtime_mode != "release") { |
| print("Invalid |dart_runtime_mode|") |
| assert(false) |
| } |
| |
| if (dart_runtime_mode == "release") { |
| if (dart_debug) { |
| print("Debug and release mode are mutually exclusive.") |
| } |
| assert(!dart_debug) |
| defines += [ "PRODUCT" ] |
| } |
| } |
| |
| # This is a config to use to build PRODUCT mode artifacts in a RELEASE build. |
| # If a DEBUG build has been specified it will be ignored. |
| config("dart_product_config") { |
| defines = [] |
| cflags = [] |
| if (!dart_debug) { |
| defines += [ "PRODUCT" ] |
| if (is_posix) { |
| cflags = [ |
| # This is the equivalent from `build/config/BUILDCONFIG.gn` which includes |
| # `build/config/gcc:symbol_visibility_hidden` in product mode. |
| "-fvisibility=hidden", |
| ] |
| } |
| } |
| } |
| |
| config("dart_precompiled_runtime_config") { |
| defines = [] |
| defines += [ |
| "DART_PRECOMPILED_RUNTIME", |
| "EXCLUDE_CFE_AND_KERNEL_PLATFORM", |
| ] |
| } |
| |
| config("add_empty_macho_section_config") { |
| if (is_mac) { |
| # We create an empty __space_for_note section in a __CUSTOM segment to |
| # reserve the header space needed for inserting a snapshot into the |
| # executable when creating standalone executables. This segment and section |
| # is removed in standalone executables, replaced with a note that points to |
| # the snapshot in the file. |
| # |
| # (A segment load command with a single section is 132 bytes in 32-bit |
| # executables and 152 bytes in 64-bit ones, and a note load command is |
| # always 40 bytes.) |
| # |
| # Keep this in sync with the constants reservedSegmentName and |
| # reservedSectionName in pkg/dart2native/lib/macho_utils.dart. |
| ldflags = [ "-Wl,-add_empty_section,__CUSTOM,__space_for_note" ] |
| } |
| } |
| |
| # Controls DART_PRECOMPILER #define. |
| config("dart_precompiler_config") { |
| defines = [] |
| defines += [ "DART_PRECOMPILER" ] |
| if (is_clang) { |
| cflags = [ "-fno-omit-frame-pointer" ] |
| } |
| |
| # In our GN build rules we'll always compile AOT compiler & AOT runtime in |
| # the same mode (TSAN or non-TSAN). |
| if (is_tsan) { |
| defines += [ "TARGET_USES_THREAD_SANITIZER" ] |
| } else if (is_msan) { |
| defines += [ "TARGET_USES_MEMORY_SANITIZER" ] |
| } |
| } |
| |
| config("dart_os_config") { |
| defines = [] |
| |
| if (target_os == "android") { |
| defines += [ "DART_TARGET_OS_ANDROID" ] |
| } else if (target_os == "fuchsia") { |
| defines += [ "DART_TARGET_OS_FUCHSIA" ] |
| } else if (target_os == "ios") { |
| defines += [ "DART_TARGET_OS_MACOS" ] |
| defines += [ "DART_TARGET_OS_MACOS_IOS" ] |
| } else if (target_os == "linux") { |
| defines += [ "DART_TARGET_OS_LINUX" ] |
| } else if (target_os == "mac") { |
| defines += [ "DART_TARGET_OS_MACOS" ] |
| } else if (target_os == "win") { |
| defines += [ "DART_TARGET_OS_WINDOWS" ] |
| } else if (target_os == "winuwp") { |
| defines += [ |
| "DART_TARGET_OS_WINDOWS", |
| "DART_TARGET_OS_WINDOWS_UWP", |
| ] |
| } else { |
| print("Unknown target_os: $target_os") |
| assert(false) |
| } |
| } |
| |
| # We need to build gen_snapshot targeting Fuchsia during a build of the SDK |
| # targeting Mac and Linux. This configuration is used to unconditionally target |
| # Fuchsia. It should not be combined with dart_os_config. |
| config("dart_os_fuchsia_config") { |
| defines = [ "DART_TARGET_OS_FUCHSIA" ] |
| } |
| |
| config("dart_arch_config") { |
| defines = [] |
| |
| if (dart_target_arch == "arm") { |
| defines += [ "TARGET_ARCH_ARM" ] |
| } else if (dart_target_arch == "arm64") { |
| defines += [ "TARGET_ARCH_ARM64" ] |
| } else if (dart_target_arch == "x64") { |
| defines += [ "TARGET_ARCH_X64" ] |
| } else if (dart_target_arch == "ia32" || dart_target_arch == "x86") { |
| defines += [ "TARGET_ARCH_IA32" ] |
| } else if (dart_target_arch == "riscv32") { |
| defines += [ "TARGET_ARCH_RISCV32" ] |
| } else if (dart_target_arch == "riscv64") { |
| defines += [ "TARGET_ARCH_RISCV64" ] |
| } else { |
| print("Invalid dart_target_arch: $dart_target_arch") |
| assert(false) |
| } |
| } |
| |
| config("dart_config") { |
| defines = [] |
| |
| if (dart_debug) { |
| defines += [ "DEBUG" ] |
| } else { |
| defines += [ "NDEBUG" ] |
| } |
| |
| include_dirs = [ "include" ] |
| |
| if (dart_include_sampling_heap_profiler) { |
| defines += [ "FORCE_FORCE_INCLUDE_SAMPLING_HEAP_PROFILER" ] |
| } |
| |
| if (dart_use_compressed_pointers) { |
| defines += [ "DART_COMPRESSED_POINTERS" ] |
| } |
| |
| if (dart_support_perfetto) { |
| defines += [ "SUPPORT_PERFETTO" ] |
| } |
| |
| if (is_fuchsia) { |
| lib_dirs = [ "${fuchsia_arch_root}/lib" ] |
| |
| # TODO(chinmaygarde): Currently these targets need to be build in the |
| # Fuchsia tree as well as outside it using the SDK. However, not all |
| # Fuchsia features are available in the SDK. As these features are added, |
| # the guards can be removed. Eventually, only SDK builds will be present. |
| # Then, this flag can be removed completely. |
| defines += [ "FUCHSIA_SDK" ] |
| } |
| |
| # Below are flags copied from ../build/config/compiler/BUILD.gn that should |
| # be preserved even when the Dart VM and runtime are compiled out-of-tree, |
| # for example in the Flutter Engine build. They ensure that the Dart VM |
| # and runtime are compiled with optimizations unless explicitly requested |
| # otherwise with the `dart_debug` and `dart_debug_optimization_level` |
| # flags. |
| if (is_win) { |
| if (dart_debug) { |
| if (is_clang && dart_debug_optimization_level != "2") { |
| cflags = [ |
| "-d${dart_debug_optimization_level}", |
| "/Oy-", |
| ] |
| } else { |
| cflags = [ |
| "/O${dart_debug_optimization_level}", |
| "/Oy-", |
| ] |
| } |
| } else { |
| cflags = [ |
| "/O${dart_default_optimization_level}", |
| "/Ob2", |
| "/Oy-", |
| "/Oi", |
| "/Gw", |
| ] |
| } |
| } else { |
| cflags = [ |
| "-Wno-unused-parameter", |
| "-Wno-unused-private-field", |
| "-Wnon-virtual-dtor", |
| "-Wvla", |
| "-Woverloaded-virtual", |
| "-Wno-comments", # Conflicts with clang-format. |
| "-g3", |
| "-ggdb3", |
| "-fno-rtti", |
| "-fno-exceptions", |
| ] |
| if (is_clang) { |
| cflags += [ |
| "-Wimplicit-fallthrough", |
| "-fno-strict-vtable-pointers", # Handle assignment updates vtable |
| # pointers. |
| ] |
| } else { |
| cflags += [ |
| "-Wno-cast-function-type", |
| "-Wno-dangling-reference", |
| ] |
| } |
| |
| ldflags = [] |
| if (is_clang && dart_vm_code_coverage) { |
| cflags += [ |
| "-O0", |
| "-fprofile-arcs", |
| "-ftest-coverage", |
| ] |
| ldflags += [ "--coverage" ] |
| } else if (dart_debug) { |
| cflags += [ "-O${dart_debug_optimization_level}" ] |
| } else { |
| cflags += [ "-O${dart_default_optimization_level}" ] |
| } |
| |
| if (is_fuchsia) { |
| # safe-stack does not work with the interpreter. |
| cflags += [ |
| "-fno-sanitize=safe-stack", |
| "-Wno-deprecated-copy", |
| ] |
| } |
| } |
| } |
| |
| config("dart_testing_config") { |
| defines = [ "TESTING" ] |
| } |
| |
| config("dart_shared_lib") { |
| if (dart_lib_export_symbols) { |
| defines = [ "DART_SHARED_LIB" ] |
| } |
| } |
| |
| config("dart_libfuzzer_config") { |
| defines = [ "FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION" ] |
| cflags = [ "-fsanitize=address,fuzzer-no-link" ] |
| ldflags = [ "-fsanitize=address,fuzzer" ] |
| } |
| |
| source_set("dart_api") { |
| public_configs = [ ":dart_public_config" ] |
| sources = [ |
| "include/analyze_snapshot_api.h", |
| "include/dart_api.h", |
| "include/dart_api_dl.c", |
| "include/dart_api_dl.h", |
| "include/dart_native_api.h", |
| "include/dart_tools_api.h", |
| "include/dart_version.h", |
| "include/internal/dart_api_dl_impl.h", |
| ] |
| } |
| |
| library_for_all_configs("libdart") { |
| target_type = dart_component_kind |
| extra_nonproduct_deps = [ "vm:libprotozero" ] |
| extra_deps = [ |
| ":generate_version_cc_file", |
| "../third_party/double-conversion/src:libdouble_conversion", |
| ] |
| if (is_fuchsia) { |
| extra_deps += [ |
| "$fuchsia_sdk/pkg/fdio", |
| "$fuchsia_sdk/pkg/trace-engine", |
| ] |
| } |
| configurable_deps = [ |
| "platform:libdart_platform", |
| "vm:libdart_lib", |
| "vm:libdart_vm", |
| ] |
| compiler_lib = "vm:libdart_compiler" |
| extra_configs = [ ":dart_shared_lib" ] |
| include_dirs = [ "." ] |
| public_configs = [ ":dart_public_config" ] |
| sources = [ |
| "$target_gen_dir/version.cc", |
| "include/analyze_snapshot_api.h", |
| "include/dart_api.h", |
| "include/dart_native_api.h", |
| "include/dart_tools_api.h", |
| "vm/analyze_snapshot_api_impl.cc", |
| "vm/dart_api_impl.cc", |
| "vm/native_api_impl.cc", |
| "vm/version.h", |
| ] |
| } |
| |
| action("generate_version_cc_file") { |
| inputs = [ |
| "../tools/utils.py", |
| "../tools/VERSION", |
| "vm/version_in.cc", |
| ] |
| if (dart_version_git_info) { |
| inputs += [ "$default_git_folder/logs/HEAD" ] |
| } |
| output = "$target_gen_dir/version.cc" |
| outputs = [ output ] |
| |
| script = "../tools/make_version.py" |
| args = [ |
| "--quiet", |
| "--output", |
| rebase_path(output, root_build_dir), |
| "--input", |
| rebase_path("vm/version_in.cc", root_build_dir), |
| ] |
| if (!dart_version_git_info) { |
| args += [ "--no-git-hash" ] |
| } |
| if (!verify_sdk_hash) { |
| args += [ "--no-sdk-hash" ] |
| } |
| } |