# Copyright 2016 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/config/sysroot.gni")
import("//build/toolchain/ccache.gni")

assert(current_os == "fuchsia")

config("werror") {
  if (!use_ccache) {
    cflags = [
      "-Werror",

      # Declarations marked as deprecated should cause build failures, rather
      # they should emit warnings to notify developers about the use of
      # deprecated interfaces.
      "-Wno-error=deprecated-declarations",

      # Do not add additional -Wno-error to this config.
    ]
  }
}

config("icf") {
  # This changes C/C++ semantics and might be incompatible with third-party
  # code that relies on function pointers comparison.
  ldflags = [ "-Wl,--icf=all" ]
}

config("safestack") {
  # This may cause issues in code that makes assumptions about stack layout
  # such as garbage collectors.
  cflags = [
    "-fsanitize=safe-stack",
    "-fstack-protector-strong",
  ]
  asmflags = cflags
  ldflags = cflags
}

# ccache, at least in some configurations, caches preprocessed content. This
# means that by the time the compiler sees it, macros are unrolled. A number
# of gcc and clang diagnostics are conditioned on whether the source is part
# of a macro or not. This is because a "reasonable" looking macro invocation
# may end up doing something silly internally. This can mean self assignment
# and tautological comparisons, since macros are not typed. Macros also tend
# to over-parenthesize, and so on. This particular list of options was found
# via trial and error, and might be the best way of keeping the build quiet.
config("ccache") {
  cflags = [
    "-Wno-error",
    "-Qunused-arguments",
    "-Wno-parentheses-equality",
    "-Wno-self-assign",
    "-Wno-tautological-compare",
    "-Wno-unused-command-line-argument",
  ]
  asmflags = cflags
}

config("compiler") {
  cflags = []
  cflags_c = [ "-std=c11" ]
  cflags_cc = [ "-std=c++14" ]
  ldflags = [ "-Wl,--threads" ]
  configs = [
    ":compiler_sysroot",
    ":compiler_target",
    ":toolchain_version_stamp",
  ]
  if (use_ccache) {
    configs += [ ":ccache" ]
  }
  asmflags = cflags + cflags_c
}

config("toolchain_version_stamp") {
  # We want to force a recompile and relink of the world whenever our toolchain changes since
  # artifacts from an older version of the toolchain may or may not be compatible with newer ones.
  # To achieve this, we insert a synthetic define into the compile line.
  if (host_os == "linux") {
    toolchain_stamp_file = "//buildtools/linux64/toolchain.stamp"
  } else if (host_os == "mac") {
    toolchain_stamp_file = "//buildtools/mac/toolchain.stamp"
  } else {
    assert(false, "Unsupported host OS")
  }
  toolchain_version = read_file(toolchain_stamp_file, "trim string")
  defines = [ "TOOLCHAIN_VERSION=$toolchain_version" ]
}

config("compiler_sysroot") {
  # The sysroot for fuchsia lives in a directory called 'sysroot' at the root of
  # the build directory, which is also the current working directory for the
  # build. This specifies the sysroot flag as a relative path, which is important
  # so it matches the output names for the sysroot assembly build edges in ninja,
  # which doesn't canonicalize paths.
  cflags = [ "--sysroot=sysroot" ]
  ldflags = [ "--sysroot=sysroot" ]
  asmflags = cflags
}

config("compiler_target") {
  cflags = []
  ldflags = []
  if (current_cpu == "arm64") {
    cflags += [ "--target=aarch64-fuchsia" ]
    ldflags += [ "--target=aarch64-fuchsia" ]
  } else if (current_cpu == "x64") {
    cflags += [ "--target=x86_64-fuchsia" ]
    ldflags += [ "--target=x86_64-fuchsia" ]
  } else {
    assert(false, "Unsupported architecture")
  }
  asmflags = cflags
}

config("shared_library_config") {
  cflags = [ "-fPIC" ]
}

config("mxio_config") {
  libs = [ "mxio" ]
}

config("executable_config") {
}

config("thread_safety_annotations") {
  cflags_cc = [ "-Wthread-safety" ]
  defines = [ "_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS" ]
}