runtime/BUILD.gn

# 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 || is_ios) {
    # 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 (dart_dynamic_modules) {
    defines += [ "DART_DYNAMIC_MODULES" ]
  }

  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",
  ]
}

shared_library("dart_jit_library") {
  output_name = "dart_jit"
  ldflags = [ "-Wl,-install_name,@rpath/Dart.framework/Dart" ]
  public = [ "include/dart_api.h" ]
  deps = [ ":libdart_jit" ]
  public_configs = [
    ":dart_public_config",
    ":dart_shared_lib",
  ]
}

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" ]
  }
}