From 089d6fc01690cff295d7459ce56af524ab70dc4a Mon Sep 17 00:00:00 2001 From: Liam Appelbe Date: Fri, 10 Jul 2020 18:10:05 +0000 Subject: [PATCH] [vm] Build a runnable Fuchsia package containing Dart Everything in the build/fuchsia director (except for tests.cmx) was copied and modified from: https://fuchsia.googlesource.com/samples/+/refs/heads/master/build This doesn't include any tests yet, but its runnable on the emulator. Change-Id: Id64ae71062447c789ca4d10ed3a4a09e0a6d7b99 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/152589 Reviewed-by: Siva Annamalai Reviewed-by: Ryan Macnak Commit-Queue: Liam Appelbe --- BUILD.gn | 18 + build/config/BUILDCONFIG.gn | 6 + build/fuchsia/BUILD.gn | 19 + build/fuchsia/BUILDCONFIG.gn | 162 +++++++ build/fuchsia/config/BUILD.gn | 37 ++ build/fuchsia/config/clang/BUILD.gn | 31 ++ build/fuchsia/config/clang/clang.gni | 7 + build/fuchsia/config/compiler/BUILD.gn | 235 ++++++++++ build/fuchsia/testing.gni | 40 ++ build/fuchsia/tests.cmx | 5 + build/fuchsia/toolchain/clang_toolchain.gni | 473 ++++++++++++++++++++ build/fuchsia/toolchain/fuchsia/BUILD.gn | 39 ++ build/fuchsia/toolchain/linux/BUILD.gn | 21 + runtime/BUILD.gn | 2 + 14 files changed, 1095 insertions(+) create mode 100644 build/fuchsia/BUILD.gn create mode 100644 build/fuchsia/BUILDCONFIG.gn create mode 100644 build/fuchsia/config/BUILD.gn create mode 100644 build/fuchsia/config/clang/BUILD.gn create mode 100644 build/fuchsia/config/clang/clang.gni create mode 100644 build/fuchsia/config/compiler/BUILD.gn create mode 100644 build/fuchsia/testing.gni create mode 100644 build/fuchsia/tests.cmx create mode 100644 build/fuchsia/toolchain/clang_toolchain.gni create mode 100644 build/fuchsia/toolchain/fuchsia/BUILD.gn create mode 100644 build/fuchsia/toolchain/linux/BUILD.gn diff --git a/BUILD.gn b/BUILD.gn index c758c49815b0..12fb95c6e4b3 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -149,3 +149,21 @@ group("observatory_archive") { group("compressed_observatory_archive") { deps = [ "runtime/observatory:copy_compressed_observatory_archive" ] } + +if (is_fuchsia) { + import("third_party/fuchsia/sdk/linux/build/component.gni") + import("third_party/fuchsia/sdk/linux/build/package.gni") + + fuchsia_component("dart_sdk_fuchsia_test_component") { + testonly = true + data_deps = [ + "runtime/bin:dart", + ] + manifest = "build/fuchsia/tests.cmx" + } + + fuchsia_package("dart_sdk_fuchsia_test_package") { + testonly = true + deps = [ ":dart_sdk_fuchsia_test_component" ] + } +} diff --git a/build/config/BUILDCONFIG.gn b/build/config/BUILDCONFIG.gn index 10a97c71be91..336445ebad72 100644 --- a/build/config/BUILDCONFIG.gn +++ b/build/config/BUILDCONFIG.gn @@ -258,6 +258,12 @@ if (is_posix) { [ "//build/config/gcc:symbol_visibility_hidden" ] } } +if (is_fuchsia) { + _native_compiler_configs += [ + "//third_party/fuchsia/sdk/linux/build/config:compiler", + "//third_party/fuchsia/sdk/linux/build/config:runtime_library", + ] +} if (is_linux) { _native_compiler_configs += [ "//build/config/linux:sdk" ] diff --git a/build/fuchsia/BUILD.gn b/build/fuchsia/BUILD.gn new file mode 100644 index 000000000000..f5eb9345a964 --- /dev/null +++ b/build/fuchsia/BUILD.gn @@ -0,0 +1,19 @@ +# Copyright 2019 The Fuchsia Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +config("compiler_defaults") { + if (current_os == "linux") { + cflags = [ + "-fPIC", + "-pthread", + ] + } +} + +config("executable_ldconfig") { + ldflags = [ + "-Wl,-rpath=\$ORIGIN/", + "-Wl,-rpath-link=", + ] +} diff --git a/build/fuchsia/BUILDCONFIG.gn b/build/fuchsia/BUILDCONFIG.gn new file mode 100644 index 000000000000..4ea7b8484ef4 --- /dev/null +++ b/build/fuchsia/BUILDCONFIG.gn @@ -0,0 +1,162 @@ +# Copyright 2019 The Fuchsia Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +if (target_os == "") { + target_os = host_os +} + +if (target_cpu == "") { + target_cpu = host_cpu +} + +if (current_cpu == "") { + current_cpu = target_cpu +} +if (current_os == "") { + current_os = target_os +} + +is_fuchsia = current_os == "fuchsia" +is_linux = current_os == "linux" + +declare_args() { + is_debug = true +} + +# Set the host_toolchain +declare_args() { + host_toolchain = "" +} + +# ============================================================================== +# TOOLCHAIN SETUP +# ============================================================================== +# +# Here we set the default toolchain, as well as the variable host_toolchain +# which will identify the toolchain corresponding to the local system when +# doing cross-compiles. When not cross-compiling, this will be the same as the +# default toolchain. +# +# We do this before anything else to make sure we complain about any +# unsupported os/cpu combinations as early as possible. + +if (host_toolchain == "") { + # This should only happen in the top-level context. + # In a specific toolchain context, the toolchain_args() + # block should have propagated a value down. + + if (host_os == "linux") { + host_toolchain = "//build/fuchsia/toolchain/linux:clang_$host_cpu" + } else if (host_os == "mac") { + host_toolchain = "//build/fuchsia/toolchain/mac:$host_cpu" + } else { + assert(false, "Unsupported host_os: $host_os") + } +} + +# Set toolchain based on target_os and target_cpu +_default_toolchain = "" + +if (target_os == "linux") { + _default_toolchain = "//build/fuchsia/toolchain/linux:clang_$target_cpu" +} else if (target_os == "fuchsia") { + _default_toolchain = "//build/fuchsia/toolchain/fuchsia:$target_cpu" +} else { + assert(false, "Unsupported target_os: $target_os") +} + +set_default_toolchain(_default_toolchain) + +# Set compiler defaults + +# Holds all configs used for running the compiler. +default_compiler_configs = [ + "//build/fuchsia:compiler_defaults", + "//build/fuchsia/config/compiler:assembler_debug_dir", + "//build/fuchsia/config/compiler:compiler", + "//build/fuchsia/config/compiler:compiler_arm_fpu", + "//build/fuchsia/config/compiler:c++", + "//build/fuchsia/config/compiler:default_include_dirs", + "//build/fuchsia/config/compiler:default_optimization", + "//build/fuchsia/config/compiler:default_symbols", + "//build/fuchsia/config/compiler:no_exceptions", + "//build/fuchsia/config/compiler:no_rtti", + "//build/fuchsia/config/compiler:runtime_library", + "//build/fuchsia/config/compiler:extra_warnings", + "//build/fuchsia/config/compiler:symbol_visibility_hidden", +] + +if (is_fuchsia) { + default_compiler_configs += [ + "//third_party/fuchsia-sdk/build/config:compiler", + "//third_party/fuchsia-sdk/build/config:runtime_library", + ] + + # these are additional flags recommended + default_compiler_configs += [ "//build/fuchsia/config/compiler:default_stack_frames" ] +} + +# Debug/release-related defines. +if (is_debug) { + default_compiler_configs += [ "//build/fuchsia/config:debug" ] +} else { + default_compiler_configs += [ "//build/fuchsia/config:release" ] +} + +# Static libraries and source sets use only the compiler ones. +set_defaults("static_library") { + configs = default_compiler_configs +} +set_defaults("source_set") { + configs = default_compiler_configs +} + +# Executable defaults. +default_executable_configs = default_compiler_configs + [ + "//build/fuchsia:executable_ldconfig", + "//build/fuchsia/config:default_libs", + ] +set_defaults("executable") { + configs = default_executable_configs +} + +# Shared library and loadable module defaults (also for components in component +# mode). +default_shared_library_configs = + default_compiler_configs + [ "//build/fuchsia/config:default_libs" ] + +set_defaults("shared_library") { + configs = default_shared_library_configs +} +set_defaults("loadable_module") { + configs = default_shared_library_configs +} + +if (is_fuchsia) { + # Sets default dependencies for executable and shared_library targets. + # + # Variables + # no_default_deps: If true, no standard dependencies will be added. + foreach(_target_type, + [ + "executable", + "shared_library", + ]) { + template(_target_type) { + target(_target_type, target_name) { + forward_variables_from(invoker, "*", [ "no_default_deps" ]) + if (!defined(deps)) { + deps = [] + } + if (!defined(data_deps)) { + data_deps = [] + } + if (!defined(invoker.no_default_deps) || !invoker.no_default_deps) { + data_deps += [ "//build/fuchsia/config/clang:c++-runtime-deps" ] + deps += [ "//third_party/fuchsia-sdk/build/config:runtime_library_group" ] + } + } + } + } +} diff --git a/build/fuchsia/config/BUILD.gn b/build/fuchsia/config/BUILD.gn new file mode 100644 index 000000000000..73babcbdc869 --- /dev/null +++ b/build/fuchsia/config/BUILD.gn @@ -0,0 +1,37 @@ +# Copyright 2019 The Fuchsia Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +# Debug/release ---------------------------------------------------------------- + +config("debug") { + defines = [ + "_DEBUG", + "DYNAMIC_ANNOTATIONS_ENABLED=1", + "WTF_USE_DYNAMIC_ANNOTATIONS=1", + ] + + if (current_cpu == "x64") { + # Enable libstdc++ debugging facilities to help catch problems early. + defines += [ "_GLIBCXX_DEBUG=1" ] + } +} + +config("release") { + defines = [ "NDEBUG" ] + defines += [ "NVALGRIND" ] + defines += [ "DYNAMIC_ANNOTATIONS_ENABLED=0" ] +} + +# Default libraries ------------------------------------------------------------ + +# This config defines the default libraries applied to all targets. +config("default_libs") { + if (is_linux) { + libs = [ + "dl", + "pthread", + "rt", + ] + } +} diff --git a/build/fuchsia/config/clang/BUILD.gn b/build/fuchsia/config/clang/BUILD.gn new file mode 100644 index 000000000000..be74d083b134 --- /dev/null +++ b/build/fuchsia/config/clang/BUILD.gn @@ -0,0 +1,31 @@ +# Copyright 2019 The Fuchsia Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +import("//build/fuchsia/config/clang/clang.gni") + +# This adds the runtime deps for C++ for usage when cross compiling. +group("c++-runtime-deps") { + data_deps = [ + ":clang-runtime-libs", + ] +} + +copy("clang-runtime-libs") { + if (target_cpu == "arm64") { + arch = "aarch64" + } else if (target_cpu == "x64") { + arch = "x86_64" + } + vendor = "unknown" + + sys = target_os + sources = [ + "${clang_base_path}/lib/${arch}-${vendor}-${sys}/c++/libc++.so.2.0", + "${clang_base_path}/lib/${arch}-${vendor}-${sys}/c++/libc++abi.so.1.0", + "${clang_base_path}/lib/${arch}-${vendor}-${sys}/c++/libunwind.so.1.0", + ] + outputs = [ + "${root_out_dir}/lib/{{source_name_part}}", + ] +} diff --git a/build/fuchsia/config/clang/clang.gni b/build/fuchsia/config/clang/clang.gni new file mode 100644 index 000000000000..8617aa52eaaf --- /dev/null +++ b/build/fuchsia/config/clang/clang.gni @@ -0,0 +1,7 @@ +# Copyright 2019 The Fuchsia Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +declare_args() { + clang_base_path = "//buildtools/linux-x64/clang" +} diff --git a/build/fuchsia/config/compiler/BUILD.gn b/build/fuchsia/config/compiler/BUILD.gn new file mode 100644 index 000000000000..ab686581fd7e --- /dev/null +++ b/build/fuchsia/config/compiler/BUILD.gn @@ -0,0 +1,235 @@ +# Copyright 2019 The Fuchsia Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +# compiler --------------------------------------------------------------------- +# +# Base compiler configuration. +# +# See also "runtime_library" below for related stuff and a discussion about +# where stuff should go. Put warning related stuff in the "warnings" config. + +import("//build/fuchsia/config/clang/clang.gni") + +config("compiler") { + asmflags = [] + cflags = [] + cflags_c = [] + cflags_cc = [] + cflags_objc = [] + cflags_objcc = [] + ldflags = [] + defines = [] + configs = [] + + # System-specific flags. If your compiler flags apply to one of the + # categories here, add it to the associated file to keep this shared config + # smaller. + + cflags += [ "-fno-strict-aliasing" ] # See http://crbug.com/32204 + cflags += [ "-fcolor-diagnostics" ] + cflags += [ "-fmerge-all-constants" ] + cflags += [ "-fcomplete-member-pointers" ] + + cflags += [ + "-Xclang", + "-mllvm", + "-Xclang", + "-instcombine-lower-dbg-declare=0", + ] + + asmflags += [ "-fPIC" ] + cflags += [ "-fPIC" ] + ldflags += [ "-fPIC" ] + + ldflags += [ + "-Wl,-z,noexecstack", + "-Wl,-z,relro", + ] + + ldflags += [ "-Wl,-z,now" ] + + # Compiler instrumentation can introduce dependencies in DSOs to symbols in + # the executable they are loaded into, so they are unresolved at link-time. + ldflags += [ + "-Wl,-z,defs", + "-Wl,--as-needed", + ] + + if (is_debug) { + # Allow comparing the address of references and 'this' against 0 + # in debug builds. Technically, these can never be null in + # well-defined C/C++ and Clang can optimize such checks away in + # release builds, but they may be used in asserts in debug builds. + cflags_cc += [ + "-Wno-undefined-bool-conversion", + "-Wno-tautological-undefined-compare", + ] + } + + cflags_c += [ "-std=c11" ] + cflags_cc += [ "-std=c++14" ] + + # Pass the same C/C++ flags to the objective C/C++ compiler. + cflags_objc += cflags_c + cflags_objcc += cflags_cc +} + +config("c++") { + cflags_cc = [ "-isystem" + rebase_path(clang_base_path, root_build_dir) ] +} + +config("assembler_debug_dir") { + asmflags = [ "-Wa,-fdebug-compilation-dir,." ] +} + +# This config causes functions not to be automatically exported from shared +# libraries. By default, all symbols are exported but this means there are +# lots of exports that slow everything down. In general we explicitly mark +# which functions we want to export from components. +# +# Some third_party code assumes all functions are exported so this is separated +# into its own config so such libraries can remove this config to make symbols +# public again. +# +# See http://gcc.gnu.org/wiki/Visibility +config("symbol_visibility_hidden") { + cflags = [ "-fvisibility=hidden" ] + cflags_cc = [ "-fvisibility-inlines-hidden" ] + cflags_objcc = cflags_cc +} + +config("compiler_arm_fpu") { + if (current_cpu == "arm") { + cflags = [ "-mfpu=$arm_fpu" ] + asmflags = cflags + } +} + +# export_dynamic --------------------------------------------------------------- +# +# Ensures all exported symbols are added to the dynamic symbol table. This is +# necessary to expose Chrome's custom operator new() and operator delete() (and +# other memory-related symbols) to libraries. Otherwise, they might +# (de)allocate memory on a different heap, which would spell trouble if pointers +# to heap-allocated memory are passed over shared library boundaries. +config("export_dynamic") { +} + +# default_include_dirs --------------------------------------------------------- +# +# This is a separate config so that third_party code (which would not use the +# source root and might have conflicting versions of some headers) can remove +# this and specify their own include paths. +config("default_include_dirs") { + include_dirs = [ + "//", + root_gen_dir, + ] +} + +config("default_stack_frames") { + cflags = [ "-fomit-frame-pointer" ] +} + +# The default optimization applied to all targets. This will be equivalent to +# either "optimize" or "no_optimize", depending on the build flags. +config("default_optimization") { + if (is_debug) { + configs = [ ":no_optimize" ] + } else { + configs = [ ":optimize" ] + } +} + +config("optimize") { + cflags = [ + "-O2", + "-fno-ident", + "-fdata-sections", + "-ffunction-sections", + ] + ldflags = [ + "-Wl,-O2", + "-Wl,--gc-sections", + ] +} + +# Turn off optimizations. +config("no_optimize") { + cflags = [ "-O0" ] + ldflags = [] +} + +# Full symbols. +config("symbols") { + cflags = [] + if (current_cpu == "arm") { + cflags += [ "-gdwarf-3" ] + } + cflags += [ "-g2" ] + + asmflags = cflags + ldflags = [] + + cflags += [ "-ggnu-pubnames" ] +} + +# No symbols. +config("no_symbols") { + cflags = [ "-g0" ] + asmflags = cflags +} + +# Default symbols. +config("default_symbols") { + if (is_debug) { + configs = [ ":symbols" ] + } else { + configs = [ ":no_symbols" ] + } +} + +config("no_exceptions") { + cflags_cc = [ "-fno-exceptions" ] + cflags_objcc = cflags_cc +} + +config("exceptions") { + cflags_cc = [ "-fexceptions" ] + cflags_objcc = cflags_cc +} + +config("no_rtti") { + cflags_cc = [ "-fno-rtti" ] + cflags_objcc = cflags_cc +} + +config("rtti") { + cflags_cc = [ "-frtti" ] + cflags_objcc = cflags_cc +} + +config("runtime_library") { + libs = [ "pthread" ] +} + +# Enables some extra Clang-specific warnings. Some third-party code won't +# compile with these so may want to remove this config. +config("extra_warnings") { + cflags = [ + "-Wheader-hygiene", + + # Warns when a const char[] is converted to bool. + "-Wstring-conversion", + + "-Wtautological-overlap-compare", + ] +} + +# Settings for executables. +config("executable_config") { + configs = [] + ldflags = [ "-pie" ] + ldflags += [ "-Wl,--disable-new-dtags" ] +} diff --git a/build/fuchsia/testing.gni b/build/fuchsia/testing.gni new file mode 100644 index 000000000000..09374153e6e8 --- /dev/null +++ b/build/fuchsia/testing.gni @@ -0,0 +1,40 @@ +# Copyright 2019 The Fuchsia Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +# ============================================================================== +# TEST SETUP +# ============================================================================== + +# Define a test as an executable with the "testonly" flag +# set. +# Variable: +template("test") { + executable(target_name + "_exe") { + forward_variables_from(invoker, "*") + if (!defined(deps)) { + deps = [] + } + + testonly = true + metadata = { + if (current_toolchain == default_toolchain) { + host_test_name = [ "./" + target_name + "_exe" ] + } else { + host_test_name = [ get_label_info(current_toolchain, "name") + "/" + + target_name + "_exe" ] + } + } + } + group(target_name) { + testonly = true + deps = [ + ":" + target_name + "_exe($host_toolchain)", + ] + } +} + +# Test defaults. +set_defaults("test") { + configs = default_executable_configs +} diff --git a/build/fuchsia/tests.cmx b/build/fuchsia/tests.cmx new file mode 100644 index 000000000000..e2fd14516821 --- /dev/null +++ b/build/fuchsia/tests.cmx @@ -0,0 +1,5 @@ +{ + "program": { + "binary": "exe.stripped/dart" + } +} diff --git a/build/fuchsia/toolchain/clang_toolchain.gni b/build/fuchsia/toolchain/clang_toolchain.gni new file mode 100644 index 000000000000..c33b97157a51 --- /dev/null +++ b/build/fuchsia/toolchain/clang_toolchain.gni @@ -0,0 +1,473 @@ +# Copyright 2019 The Fuchsia Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +import("//build/fuchsia/config/clang/clang.gni") + +# This template defines a toolchain. +# +# It requires the following variables specifying the executables to run: +# - ar +# - cc +# - cxx +# - ld +# +# Optional parameters that control the tools: +# +# - extra_cflags +# Extra flags to be appended when compiling C files (but not C++ files). +# - extra_cppflags +# Extra flags to be appended when compiling both C and C++ files. "CPP" +# stands for "C PreProcessor" in this context, although it can be +# used for non-preprocessor flags as well. Not to be confused with +# "CXX" (which follows). +# - extra_cxxflags +# Extra flags to be appended when compiling C++ files (but not C files). +# - extra_asmflags +# Extra flags to be appended when compiling assembly. +# - extra_ldflags +# Extra flags to be appended when linking +# +# - libs_section_prefix +# - libs_section_postfix +# The contents of these strings, if specified, will be placed around +# the libs section of the linker line. It allows one to inject libraries +# at the beginning and end for all targets in a toolchain. +# - solink_libs_section_prefix +# - solink_libs_section_postfix +# Same as libs_section_{pre,post}fix except used for solink instead of link. +# - link_outputs +# The content of this array, if specified, will be added to the list of +# outputs from the link command. This can be useful in conjunction with +# the post_link parameter. +# - use_unstripped_as_runtime_outputs +# When |strip| is set, mark unstripped executables as runtime deps rather +# than stripped ones. +# - post_link +# The content of this string, if specified, will be run as a separate +# command following the the link command. +# - deps +# Just forwarded to the toolchain definition. +# - executable_extension +# If this string is specified it will be used for the file extension +# for an executable, rather than using no extension; targets will +# still be able to override the extension using the output_extension +# variable. +# - rebuild_define +# The contents of this string, if specified, will be passed as a #define +# to the toolchain. It can be used to force recompiles whenever a +# toolchain is updated. +# - shlib_extension +# If this string is specified it will be used for the file extension +# for a shared library, rather than default value specified in +# toolchain.gni +# - use_strip +# Enable stripping symbols out of binaries. The pre-stripped +# artifacts will be put in lib.unstripped/ and exe.unstripped/. +template("clang_toolchain") { + declare_args() { + shlib_prefix = "lib" + shlib_extension = ".so" + } + + params = { + if (defined(invoker.prefix)) { + prefix = invoker.prefix + } else { + prefix = rebase_path("$clang_base_path/bin", root_build_dir) + } + if (defined(invoker.ar)) { + ar = invoker.ar + } else { + ar = "${prefix}/llvm-ar" + } + + if (defined(invoker.cc)) { + cc = invoker.cc + } else { + cc = "${prefix}/clang" + } + + if (defined(invoker.cxx)) { + cxx = invoker.cxx + } else { + cxx = "${prefix}/clang++" + } + + if (defined(invoker.ld)) { + ld = invoker.ld + } else { + ld = cxx + } + } + + toolchain(target_name) { + assert(defined(params.ar), "clang_toolchain() must specify a \"ar\" value") + assert(defined(params.cc), "clang_toolchain() must specify a \"cc\" value") + assert(defined(params.cxx), + "clang_toolchain() must specify a \"cxx\" value") + assert(defined(params.ld), "clang_toolchain() must specify a \"ld\" value") + + # This define changes when the toolchain changes, forcing a rebuild. + # Nothing should ever use this define. + if (defined(invoker.rebuild_define)) { + rebuild_string = "-D" + invoker.rebuild_define + " " + } else { + rebuild_string = "" + } + + # GN's syntax can't handle more than one scope dereference at once, like + # "invoker.toolchain_args.foo", so make a temporary to hold the toolchain + # args so we can do "invoker_toolchain_args.foo". + assert(defined(invoker.toolchain_args), + "Toolchains must specify toolchain_args") + invoker_toolchain_args = invoker.toolchain_args + assert(defined(invoker_toolchain_args.current_cpu), + "toolchain_args must specify a current_cpu") + assert(defined(invoker_toolchain_args.current_os), + "toolchain_args must specify a current_os") + + # When invoking this toolchain not as the default one, these args will be + # passed to the build. They are ignored when this is the default toolchain. + toolchain_args = { + # Populate toolchain args from the invoker. + forward_variables_from(invoker_toolchain_args, "*") + + # The host toolchain value computed by the default toolchain's setup + # needs to be passed through unchanged to all secondary toolchains to + # ensure that it's always the same, regardless of the values that may be + # set on those toolchains. + host_toolchain = host_toolchain + } + + compiler_prefix = " " + + # Create a distinct variable for "asm", since analysis runs pass # a bunch + # of flags to clang/clang++ that are nonsensical on assembler runs. + asm_prefix = compiler_prefix + + cc = compiler_prefix + params.cc + cxx = compiler_prefix + params.cxx + asm = asm_prefix + params.cc + ar = params.ar + ld = params.ld + + if (defined(invoker.shlib_extension)) { + default_shlib_extension = invoker.shlib_extension + } else { + default_shlib_extension = shlib_extension + } + + if (defined(invoker.default_shlib_subdir)) { + default_shlib_subdir = invoker.default_shlib_subdir + } else { + default_shlib_subdir = "" + } + + if (defined(invoker.executable_extension)) { + default_executable_extension = invoker.executable_extension + } else { + default_executable_extension = "" + } + + # Bring these into our scope for string interpolation with default values. + if (defined(invoker.libs_section_prefix)) { + libs_section_prefix = invoker.libs_section_prefix + } else { + libs_section_prefix = "" + } + + if (defined(invoker.libs_section_postfix)) { + libs_section_postfix = invoker.libs_section_postfix + } else { + libs_section_postfix = "" + } + + if (defined(invoker.solink_libs_section_prefix)) { + solink_libs_section_prefix = invoker.solink_libs_section_prefix + } else { + solink_libs_section_prefix = "" + } + + if (defined(invoker.solink_libs_section_postfix)) { + solink_libs_section_postfix = invoker.solink_libs_section_postfix + } else { + solink_libs_section_postfix = "" + } + + if (defined(invoker.extra_cflags) && invoker.extra_cflags != "") { + extra_cflags = " " + invoker.extra_cflags + } else { + extra_cflags = "" + } + + if (defined(invoker.extra_cppflags) && invoker.extra_cppflags != "") { + extra_cppflags = " " + invoker.extra_cppflags + } else { + extra_cppflags = "" + } + + if (defined(invoker.extra_cxxflags) && invoker.extra_cxxflags != "") { + extra_cxxflags = " " + invoker.extra_cxxflags + } else { + extra_cxxflags = "" + } + + if (defined(invoker.extra_asmflags) && invoker.extra_asmflags != "") { + extra_asmflags = " " + invoker.extra_asmflags + } else { + extra_asmflags = "" + } + + if (defined(invoker.extra_ldflags) && invoker.extra_ldflags != "") { + extra_ldflags = " " + invoker.extra_ldflags + } else { + extra_ldflags = "" + } + + use_strip = false + if (defined(invoker.use_strip)) { + use_strip = invoker.use_strip + } + if (use_strip) { + if (toolchain_args.current_os == "mac") { + strip = "xcrun strip -Sx" + } else { + strip = "${params.prefix}/llvm-objcopy" + buildidtool = + rebase_path("//buildtools/linux64/buildidtool", root_build_dir) + } + } + + # These library switches can apply to all tools below. + lib_switch = "-l" + lib_dir_switch = "-L" + + # Object files go in this directory. + object_subdir = "{{target_out_dir}}/{{label_name}}" + + tool("cc") { + depfile = "{{output}}.d" + command = "$cc -MMD -MF $depfile ${rebuild_string}{{defines}} {{include_dirs}} {{cflags}} {{cflags_c}}${extra_cppflags}${extra_cflags} -c {{source}} -o {{output}}" + depsformat = "gcc" + description = "CC {{output}}" + outputs = [ "$object_subdir/{{source_name_part}}.o" ] + } + + tool("cxx") { + depfile = "{{output}}.d" + command = "$cxx -MMD -MF $depfile ${rebuild_string}{{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}}${extra_cppflags}${extra_cxxflags} -c {{source}} -o {{output}}" + depsformat = "gcc" + description = "CXX {{output}}" + outputs = [ "$object_subdir/{{source_name_part}}.o" ] + } + + tool("asm") { + # For clang we can just use the C compiler to compile assembly. + depfile = "{{output}}.d" + command = "$asm -MMD -MF $depfile ${rebuild_string}{{defines}} {{include_dirs}} {{asmflags}}${extra_asmflags} -c {{source}} -o {{output}}" + depsformat = "gcc" + description = "ASM {{output}}" + outputs = [ "$object_subdir/{{source_name_part}}.o" ] + } + + tool("alink") { + rspfile = "{{output}}.rsp" + rspfile_content = "{{inputs}}" + command = "\"$ar\" {{arflags}} -r -c -s -D {{output}} @\"$rspfile\"" + + # Remove the output file first so that ar doesn't try to modify the + # existing file. + command = "rm -f {{output}} && $command" + + # Almost all targets build with //build/fuchsia/config/compiler:thin_archive which + # adds -T to arflags. + description = "AR {{output}}" + outputs = [ "{{output_dir}}/{{target_output_name}}{{output_extension}}" ] + + # Shared libraries go in the target out directory by default so we can + # generate different targets with the same name and not have them collide. + default_output_dir = "{{target_out_dir}}" + default_output_extension = ".a" + output_prefix = "lib" + } + + tool("solink") { + soname = "{{target_output_name}}{{output_extension}}" # e.g. "libfoo.so". + sofile = "{{output_dir}}/$soname" # Possibly including toolchain dir. + rspfile = sofile + ".rsp" + + if (defined(invoker.use_strip)) { + unstripped_sofile = "{{root_out_dir}}/lib.unstripped/$soname" + } else { + unstripped_sofile = sofile + } + + # These variables are not built into GN but are helpers that + # implement (1) linking to produce a .so, (2) extracting the symbols + # from that file (3) if the extracted list differs from the existing + # .TOC file, overwrite it, otherwise, don't change it. + tocfile = sofile + ".TOC" + + link_command = "$ld -shared {{ldflags}}${extra_ldflags} -o \"$unstripped_sofile\" -Wl,-soname=\"$soname\" @\"$rspfile\"" + + command = "$link_command" + + if (defined(invoker.use_strip)) { + strip_command = "$strip --strip-all \"$unstripped_sofile\" \"$sofile\"" + command += " && " + strip_command + command += + " && $buildidtool -build-id-dir .build-id" + + " -stamp \"$sofile.build-id.stamp\"" + " -entry \"=$sofile\"" + + " -entry \".debug=$unstripped_sofile\"" + } + rspfile_content = "-Wl,--whole-archive {{inputs}} {{solibs}} -Wl,--no-whole-archive $solink_libs_section_prefix {{libs}} $solink_libs_section_postfix" + description = "SOLINK $sofile" + + # Use this for {{output_extension}} expansions unless a target manually + # overrides it (in which case {{output_extension}} will be what the target + # specifies). + default_output_extension = default_shlib_extension + + default_output_dir = "{{root_out_dir}}${default_shlib_subdir}" + + output_prefix = "lib" + + # Since the above commands only updates the .TOC file when it changes, ask + # Ninja to check if the timestamp actually changed to know if downstream + # dependencies should be recompiled. + restat = true + + # Tell GN about the output files. It will link to the sofile but use the + # tocfile for dependency management. + outputs = [ + sofile, + tocfile, + ] + if (sofile != unstripped_sofile) { + outputs += [ unstripped_sofile ] + if (defined(invoker.use_unstripped_as_runtime_outputs) && + invoker.use_unstripped_as_runtime_outputs) { + runtime_outputs = [ unstripped_sofile ] + } + } + if (defined(map_file)) { + outputs += [ map_file ] + } + link_output = sofile + depend_output = tocfile + } + + tool("solink_module") { + soname = "{{target_output_name}}{{output_extension}}" # e.g. "libfoo.so". + sofile = "{{output_dir}}/$soname" + rspfile = sofile + ".rsp" + + if (defined(invoker.use_strip)) { + unstripped_sofile = "{{root_out_dir}}/lib.unstripped/$soname" + } else { + unstripped_sofile = sofile + } + + command = "$ld -shared {{ldflags}}${extra_ldflags} -o \"$unstripped_sofile\" -Wl,-soname=\"$soname\" @\"$rspfile\"" + + if (defined(invoker.use_strip)) { + strip_command = + "$strip --strip-sections \"$unstripped_sofile\" \"$sofile\"" + command += " && " + strip_command + command += + " && $buildidtool -build-id-dir .build-id" + + " -stamp \"$sofile.build-id.stamp\"" + " -entry \"=$sofile\"" + + " -entry \".debug=$unstripped_sofile\"" + } + rspfile_content = "-Wl,--whole-archive {{inputs}} {{solibs}} -Wl,--no-whole-archive $solink_libs_section_prefix {{libs}} $solink_libs_section_postfix" + + description = "SOLINK_MODULE $sofile" + + # Use this for {{output_extension}} expansions unless a target manually + # overrides it (in which case {{output_extension}} will be what the target + # specifies). + if (defined(invoker.loadable_module_extension)) { + default_output_extension = invoker.loadable_module_extension + } else { + default_output_extension = default_shlib_extension + } + + default_output_dir = "{{root_out_dir}}${default_shlib_subdir}" + + output_prefix = "lib" + + outputs = [ sofile ] + if (sofile != unstripped_sofile) { + outputs += [ unstripped_sofile ] + if (defined(invoker.use_unstripped_as_runtime_outputs) && + invoker.use_unstripped_as_runtime_outputs) { + runtime_outputs = [ unstripped_sofile ] + } + } + } + + tool("link") { + exename = "{{target_output_name}}{{output_extension}}" + outfile = "{{output_dir}}/$exename" + rspfile = "$outfile.rsp" + unstripped_outfile = outfile + + # Use this for {{output_extension}} expansions unless a target manually + # overrides it (in which case {{output_extension}} will be what the target + # specifies). + default_output_extension = default_executable_extension + + default_output_dir = "{{root_out_dir}}" + + if (defined(invoker.use_strip)) { + unstripped_outfile = "{{root_out_dir}}/exe.unstripped/$exename" + } + + # Generate a map file to be used for binary size analysis. + # Map file adds ~10% to the link time on a z620. + # With target_os="android", libchrome.so.map.gz is ~20MB. + start_group_flag = "-Wl,--start-group" + end_group_flag = "-Wl,--end-group " + link_command = "$ld {{ldflags}}${extra_ldflags} -o \"$unstripped_outfile\" $start_group_flag @\"$rspfile\" {{solibs}} $end_group_flag $libs_section_prefix {{libs}} $libs_section_postfix" + + command = "$link_command" + + if (defined(invoker.use_strip)) { + strip_command = + "$strip --strip-sections \"$unstripped_outfile\" \"$outfile\"" + command += " && " + strip_command + command += + " && $buildidtool -build-id-dir .build-id" + + " -stamp \"$outfile.build-id.stamp\"" + " -entry \"=$outfile\"" + + " -entry \".debug=$unstripped_outfile\"" + } + description = "LINK $outfile" + rspfile_content = "{{inputs}}" + outputs = [ outfile ] + if (outfile != unstripped_outfile) { + outputs += [ unstripped_outfile ] + } + if (defined(invoker.link_outputs)) { + outputs += invoker.link_outputs + } + if (defined(map_file)) { + outputs += [ map_file ] + } + } + + # These two are really entirely generic, but have to be repeated in + # each toolchain because GN doesn't allow a template to be used here. + # See //build/fuchsia/toolchain/toolchain.gni for details. + tool("stamp") { + command = "touch {{output}}" + description = "STAMP {{output}}" + } + tool("copy") { + command = "ln -f {{source}} {{output}} 2>/dev/null || (rm -rf {{output}} && cp -af {{source}} {{output}})" + description = "COPY {{source}} {{output}}" + } + + forward_variables_from(invoker, [ "deps" ]) + } +} diff --git a/build/fuchsia/toolchain/fuchsia/BUILD.gn b/build/fuchsia/toolchain/fuchsia/BUILD.gn new file mode 100644 index 000000000000..5135cb34f318 --- /dev/null +++ b/build/fuchsia/toolchain/fuchsia/BUILD.gn @@ -0,0 +1,39 @@ +# Copyright 2019 The Fuchsia Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +import("//build/fuchsia/toolchain/clang_toolchain.gni") + +# Fuchsia builds using the Clang toolchain, with most parameters common across +# the different target architectures. +template("fuchsia_toolchain") { + clang_toolchain(target_name) { + assert(host_os == "linux" || host_os == "mac") + assert(defined(invoker.toolchain_args), + "toolchain_args must be defined for fuchsia_clang_toolchain()") + + default_shlib_subdir = "/lib" + toolchain_args = invoker.toolchain_args + toolchain_args.current_os = "fuchsia" + + # + # We want to build and strip binaries, but retain the unstripped binaries + # in runtime_deps to make them available for isolates. + if (host_os == "linux") { + use_strip = true + use_unstripped_as_runtime_outputs = true + } + } +} + +fuchsia_toolchain("x64") { + toolchain_args = { + current_cpu = "x64" + } +} + +fuchsia_toolchain("arm64") { + toolchain_args = { + current_cpu = "arm64" + } +} diff --git a/build/fuchsia/toolchain/linux/BUILD.gn b/build/fuchsia/toolchain/linux/BUILD.gn new file mode 100644 index 000000000000..6f20264eced4 --- /dev/null +++ b/build/fuchsia/toolchain/linux/BUILD.gn @@ -0,0 +1,21 @@ +# Copyright 2019 The Fuchsia Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +import("//build/fuchsia/toolchain/clang_toolchain.gni") + +template("linux_toolchain") { + clang_toolchain(target_name) { + assert(host_os == "linux") + assert(defined(invoker.toolchain_args), + "toolchain_args must be defined for linux_toolchain()") + + toolchain_args = invoker.toolchain_args + toolchain_args.current_os = "linux" + } +} +linux_toolchain("clang_x64") { + toolchain_args = { + current_cpu = "x64" + } +} diff --git a/runtime/BUILD.gn b/runtime/BUILD.gn index 6da22fbf5f73..20efa7250aec 100644 --- a/runtime/BUILD.gn +++ b/runtime/BUILD.gn @@ -228,6 +228,8 @@ library_for_all_configs("libdart") { if (is_fuchsia) { if (using_fuchsia_gn_sdk) { extra_deps += [ + "//build/fuchsia/config/clang:c++-runtime-deps", + "$fuchsia_sdk_root/build/config:runtime_library_group", "$fuchsia_sdk_root/pkg/fdio", "$fuchsia_sdk_root/pkg/trace-engine", ]