#

# Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.

# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

#

# This code is free software; you can redistribute it and/or modify it

# under the terms of the GNU General Public License version 2 only, as

# published by the Free Software Foundation.  Oracle designates this

# particular file as subject to the "Classpath" exception as provided

# by Oracle in the LICENSE file that accompanied this code.

#

# This code is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

# version 2 for more details (a copy is included in the LICENSE file that

# accompanied this code).

#

# You should have received a copy of the GNU General Public License version

# 2 along with this work; if not, write to the Free Software Foundation,

# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

#

# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

# or visit www.oracle.com if you need additional information or have any

# questions.

#

################################################################################

#

# Setup flags for C/C++ compiler

#

###############################################################################

#

# How to compile shared libraries.

#

AC_DEFUN([FLAGS_SETUP_SHARED_LIBS],

[

  if test "x$TOOLCHAIN_TYPE" = xgcc; then

    C_FLAG_REORDER=''

    # Default works for linux, might work on other platforms as well.

    SHARED_LIBRARY_FLAGS='-shared'

    SET_EXECUTABLE_ORIGIN='-Wl,-rpath,\$$ORIGIN[$]1'

    SET_SHARED_LIBRARY_ORIGIN="-Wl,-z,origin $SET_EXECUTABLE_ORIGIN"

    SET_SHARED_LIBRARY_NAME='-Wl,-soname=[$]1'

    SET_SHARED_LIBRARY_MAPFILE='-Wl,-version-script=[$]1'

  elif test "x$TOOLCHAIN_TYPE" = xclang; then

    C_FLAG_REORDER=''

    if test "x$OPENJDK_TARGET_OS" = xmacosx; then

      # Linking is different on MacOSX

      SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0"

      SET_EXECUTABLE_ORIGIN='-Wl,-rpath,@loader_path$(or [$]1,/.)'

      SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN"

      SET_SHARED_LIBRARY_NAME='-Wl,-install_name,@rpath/[$]1'

      SET_SHARED_LIBRARY_MAPFILE='-Wl,-exported_symbols_list,[$]1'

    else

      # Default works for linux, might work on other platforms as well.

      SHARED_LIBRARY_FLAGS='-shared'

      SET_EXECUTABLE_ORIGIN='-Wl,-rpath,\$$ORIGIN[$]1'

      SET_SHARED_LIBRARY_NAME='-Wl,-soname=[$]1'

      SET_SHARED_LIBRARY_MAPFILE='-Wl,-version-script=[$]1'

      # arm specific settings

      if test "x$OPENJDK_TARGET_CPU" = "xarm"; then

        # '-Wl,-z,origin' isn't used on arm.

        SET_SHARED_LIBRARY_ORIGIN='-Wl,-rpath,\$$$$ORIGIN[$]1'

      else

        SET_SHARED_LIBRARY_ORIGIN="-Wl,-z,origin $SET_EXECUTABLE_ORIGIN"

      fi

    fi

  elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then

    C_FLAG_REORDER='-xF'

    SHARED_LIBRARY_FLAGS="-G"

    SET_EXECUTABLE_ORIGIN='-R\$$ORIGIN[$]1'

    SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN"

    SET_SHARED_LIBRARY_NAME='-h [$]1'

    SET_SHARED_LIBRARY_MAPFILE='-M[$]1'

  elif test "x$TOOLCHAIN_TYPE" = xxlc; then

    C_FLAG_REORDER=''

    SHARED_LIBRARY_FLAGS="-qmkshrobj -bM:SRE -bnoentry"

    SET_EXECUTABLE_ORIGIN=""

    SET_SHARED_LIBRARY_ORIGIN=''

    SET_SHARED_LIBRARY_NAME=''

    SET_SHARED_LIBRARY_MAPFILE=''

  elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then

    C_FLAG_REORDER=''

    SHARED_LIBRARY_FLAGS="-dll"

    SET_EXECUTABLE_ORIGIN=''

    SET_SHARED_LIBRARY_ORIGIN=''

    SET_SHARED_LIBRARY_NAME=''

    SET_SHARED_LIBRARY_MAPFILE='-def:[$]1'

  fi

  AC_SUBST(C_FLAG_REORDER)

  AC_SUBST(SET_EXECUTABLE_ORIGIN)

  AC_SUBST(SET_SHARED_LIBRARY_ORIGIN)

  AC_SUBST(SET_SHARED_LIBRARY_NAME)

  AC_SUBST(SET_SHARED_LIBRARY_MAPFILE)

  AC_SUBST(SHARED_LIBRARY_FLAGS)

])

AC_DEFUN([FLAGS_SETUP_DEBUG_SYMBOLS],

[

  # Debug symbols

  if test "x$TOOLCHAIN_TYPE" = xgcc; then

    CFLAGS_DEBUG_SYMBOLS="-g"

  elif test "x$TOOLCHAIN_TYPE" = xclang; then

    CFLAGS_DEBUG_SYMBOLS="-g"

  elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then

    # -g0 enables debug symbols without disabling inlining.

    CFLAGS_DEBUG_SYMBOLS="-g0 -xs"

  elif test "x$TOOLCHAIN_TYPE" = xxlc; then

    CFLAGS_DEBUG_SYMBOLS="-g"

  elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then

    CFLAGS_DEBUG_SYMBOLS="-Z7 -d2Zi+"

  fi

  AC_SUBST(CFLAGS_DEBUG_SYMBOLS)

])

AC_DEFUN([FLAGS_SETUP_WARNINGS],

[

  AC_ARG_ENABLE([warnings-as-errors], [AS_HELP_STRING([--disable-warnings-as-errors],

      [do not consider native warnings to be an error @<:@enabled@:>@])])

  # Set default value.

  if test "x$TOOLCHAIN_TYPE" = xxlc; then

    WARNINGS_AS_ERRORS=false

  else

    WARNINGS_AS_ERRORS=true

  fi

  AC_MSG_CHECKING([if native warnings are errors])

  if test "x$enable_warnings_as_errors" = "xyes"; then

    AC_MSG_RESULT([yes (explicitly set)])

    WARNINGS_AS_ERRORS=true

  elif test "x$enable_warnings_as_errors" = "xno"; then

    AC_MSG_RESULT([no (explicitly set)])

    WARNINGS_AS_ERRORS=false

  elif test "x$enable_warnings_as_errors" = "x"; then

    AC_MSG_RESULT([${WARNINGS_AS_ERRORS} (default)])

  else

    AC_MSG_ERROR([--enable-warnings-as-errors accepts no argument])

  fi

  AC_SUBST(WARNINGS_AS_ERRORS)

  LDFLAGS_WARNINGS_ARE_ERRORS=""

  case "${TOOLCHAIN_TYPE}" in

    microsoft)

      DISABLE_WARNING_PREFIX="-wd"

      CFLAGS_WARNINGS_ARE_ERRORS="-WX"

      # 4061

      #WARNINGS_ENABLE_ALL="-Wall"

      WARNINGS_ENABLE_ALL="-W4"

      # 4061, 4062 = enum not handled

      # 4130

      #EVEN_MORE="4054 4055 4057 4100 4127 4131 4132 4152 4201 4204 4206 4210 4232 4244 4255 4263 4264 4295 4302 4306 4311 4324 4366 4388 4512 4548 4555 4574 4800 4986 4987"

      #INIT_DISABLE=" 4189 4191 4211 4242 4245 4265 4287 4296 4310 4312 4350 4355 4365 4389 4505 4510 4514 4571 4610 4619 4623 4625 4626 4640 4668 4701 4702 4703 4706 4710 4711 4820 4917 4946 $EVEN_MORE"

      #DISABLED_WARNINGS_WALL="4061 4062 $INIT_DISABLE"

      RETRY_W4_HOTSPOT="4189 4211 4245 4310 4389 4505 4510 4610 4701 4702 4703 4706"

      RETRY_W4_JDK="4054 4055 4057 4100 4127 4130 4131 4132 4152 4201 4204 4206 4210 4232 4244 4295 4306 4324 4366 4512 4800"

      DISABLED_WARNINGS="$RETRY_W4_HOTSPOT $RETRY_W4_JDK"

      ;;

    solstudio)

      DISABLE_WARNING_PREFIX="-erroff="

      CFLAGS_WARNINGS_ARE_ERRORS="-errwarn=%all"

      LDFLAGS_WARNINGS_ARE_ERRORS="-Wl,-z,fatal-warnings"

      WARNINGS_ENABLE_ALL_CFLAGS="-v -fd -xtransition"

      WARNINGS_ENABLE_ALL_CXXFLAGS="+w +w2"

      DISABLED_WARNINGS_C="E_OLD_STYLE_FUNC_DECL E_OLD_STYLE_FUNC_DEF E_SEMANTICS_OF_OP_CHG_IN_ANSI_C E_NO_REPLACEMENT_IN_STRING E_DECLARATION_IN_CODE"

      DISABLED_WARNINGS_CXX="inllargeuse inllargeint notused wemptydecl notemsource"

      # helpful quality checks, should not be disabled: inllargeuse inllargeint

      ;;

    gcc)

      DISABLE_WARNING_PREFIX="-Wno-"

      CFLAGS_WARNINGS_ARE_ERRORS="-Werror"

      # -Wall -Wextra does not enable all warnings. We add some more that we

      # consider relevant:

      WARNINGS_ENABLE_ADDITIONAL="-Wpointer-arith -Wundef -Wlogical-op -Winit-self -Wpacked -Wdisabled-optimization -Wtrampolines"

      WARNINGS_ENABLE_ADDITIONAL_CXX="-Wc++0x-compat -Wreorder -Wnoexcept -Woverloaded-virtual -Wdelete-non-virtual-dtor -Wwrite-strings -Wstrict-null-sentinel"

      WARNINGS_ENABLE_ALL="-Wall -Wextra -Wformat=2 $WARNINGS_ENABLE_ADDITIONAL"

      WARNINGS_ENABLE_ALL_CXXFLAGS="$WARNINGS_ENABLE_ADDITIONAL_CXX"

      DISABLED_WARNINGS_JUST_GET_THIS_PASS="unused-variable unused-function unused-but-set-variable undef unused-value unused-label pointer-arith"

      DISABLED_WARNINGS="unknown-warning unused-parameter $DISABLED_WARNINGS_JUST_GET_THIS_PASS"

      # Repeate the check for the BUILD_CC and BUILD_CXX. Need to also reset

      # CFLAGS since any target specific flags will likely not work with the

      # build compiler

      CC_OLD="$CC"

      CXX_OLD="$CXX"

      CC="$BUILD_CC"

      CXX="$BUILD_CXX"

      CFLAGS_OLD="$CFLAGS"

      CFLAGS=""

      BUILD_CC_DISABLE_WARNING_PREFIX="-Wno-"

      CC="$CC_OLD"

      CXX="$CXX_OLD"

      CFLAGS="$CFLAGS_OLD"

      ;;

    clang)

      DISABLE_WARNING_PREFIX="-Wno-"

      CFLAGS_WARNINGS_ARE_ERRORS="-Werror"

      ;;

    xlc)

      DISABLE_WARNING_PREFIX="-qsuppress="

      CFLAGS_WARNINGS_ARE_ERRORS="-qhalt=w"

      ;;

  esac

  AC_SUBST(DISABLE_WARNING_PREFIX)

  AC_SUBST(BUILD_CC_DISABLE_WARNING_PREFIX)

  AC_SUBST(CFLAGS_WARNINGS_ARE_ERRORS)

  AC_SUBST(LDFLAGS_WARNINGS_ARE_ERRORS)

  AC_SUBST(DISABLED_WARNINGS)

  AC_SUBST(DISABLED_WARNINGS_C)

  AC_SUBST(DISABLED_WARNINGS_CXX)

])

AC_DEFUN([FLAGS_SETUP_QUALITY_CHECKS],

[

  # bounds, memory and behavior checking options

  if test "x$TOOLCHAIN_TYPE" = xgcc; then

    case $DEBUG_LEVEL in

    release )

      # no adjustment

      ;;

    fastdebug )

      # no adjustment

      ;;

    slowdebug )

      # FIXME: By adding this to C(XX)FLAGS_DEBUG_OPTIONS/JVM_CFLAGS_SYMBOLS it

      # get's added conditionally on whether we produce debug symbols or not.

      # This is most likely not really correct.

      # Add runtime stack smashing and undefined behavior checks.

      CFLAGS_DEBUG_OPTIONS="-fstack-protector-all --param ssp-buffer-size=1 -Wstack-protector"

      CXXFLAGS_DEBUG_OPTIONS="-fstack-protector-all --param ssp-buffer-size=1 -Wstack-protector"

      JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -fstack-protector-all --param ssp-buffer-size=1 -Wstack-protector"

      ;;

    esac

  fi

])

AC_DEFUN([FLAGS_SETUP_OPTIMIZATION],

[

  if test "x$TOOLCHAIN_TYPE" = xsolstudio; then

    CC_HIGHEST="-fns -fsimple -fsingle -xbuiltin=%all -xdepend -xrestrict -xlibmil"

    C_O_FLAG_HIGHEST_JVM="-xO4"

    C_O_FLAG_DEBUG_JVM=""

    C_O_FLAG_SIZE=""

    C_O_FLAG_DEBUG=""

    C_O_FLAG_NONE=""

    if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then

      C_O_FLAG_HIGHEST="-xO4 -Wu,-O4~yz $CC_HIGHEST"

      C_O_FLAG_HI="-xO4 -Wu,-O4~yz"

      C_O_FLAG_NORM="-xO2 -Wu,-O2~yz"

    elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then

      C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 \

          -xprefetch=auto,explicit -xchip=ultra $CC_HIGHEST"

      C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0"

      C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0"

    fi

  elif test "x$TOOLCHAIN_TYPE" = xgcc; then

    C_O_FLAG_HIGHEST_JVM="-O3"

    C_O_FLAG_HIGHEST="-O3"

    C_O_FLAG_HI="-O3"

    C_O_FLAG_NORM="-O2"

    C_O_FLAG_SIZE="-Os"

    C_O_FLAG_DEBUG="-O0"

    C_O_FLAG_DEBUG_JVM="-O0"

    C_O_FLAG_NONE="-O0"

  elif test "x$TOOLCHAIN_TYPE" = xclang; then

    if test "x$OPENJDK_TARGET_OS" = xmacosx; then

      # On MacOSX we optimize for size, something

      # we should do for all platforms?

      C_O_FLAG_HIGHEST_JVM="-Os"

      C_O_FLAG_HIGHEST="-Os"

      C_O_FLAG_HI="-Os"

      C_O_FLAG_NORM="-Os"

      C_O_FLAG_DEBUG_JVM=""

    else

      C_O_FLAG_HIGHEST_JVM="-O3"

      C_O_FLAG_HIGHEST="-O3"

      C_O_FLAG_HI="-O3"

      C_O_FLAG_NORM="-O2"

      C_O_FLAG_DEBUG_JVM="-O0"

    fi

    C_O_FLAG_SIZE="-Os"

    C_O_FLAG_DEBUG="-O0"

    C_O_FLAG_NONE="-O0"

  elif test "x$TOOLCHAIN_TYPE" = xxlc; then

    C_O_FLAG_HIGHEST_JVM="-O3 -qhot=level=1 -qinline -qinlglue"

    C_O_FLAG_HIGHEST="-O3 -qhot=level=1 -qinline -qinlglue"

    C_O_FLAG_HI="-O3 -qinline -qinlglue"

    C_O_FLAG_NORM="-O2"

    C_O_FLAG_DEBUG="-qnoopt"

    # FIXME: Value below not verified.

    C_O_FLAG_DEBUG_JVM=""

    C_O_FLAG_NONE="-qnoopt"

  elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then

    C_O_FLAG_HIGHEST_JVM="-O2 -Oy-"

    C_O_FLAG_HIGHEST="-O2"

    C_O_FLAG_HI="-O1"

    C_O_FLAG_NORM="-O1"

    C_O_FLAG_DEBUG="-Od"

    C_O_FLAG_DEBUG_JVM=""

    C_O_FLAG_NONE="-Od"

    C_O_FLAG_SIZE="-Os"

  fi

  # Now copy to C++ flags

  CXX_O_FLAG_HIGHEST_JVM="$C_O_FLAG_HIGHEST_JVM"

  CXX_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST"

  CXX_O_FLAG_HI="$C_O_FLAG_HI"

  CXX_O_FLAG_NORM="$C_O_FLAG_NORM"

  CXX_O_FLAG_DEBUG="$C_O_FLAG_DEBUG"

  CXX_O_FLAG_DEBUG_JVM="$C_O_FLAG_DEBUG_JVM"

  CXX_O_FLAG_NONE="$C_O_FLAG_NONE"

  CXX_O_FLAG_SIZE="$C_O_FLAG_SIZE"

  if test "x$TOOLCHAIN_TYPE" = xsolstudio; then

    # In solstudio, also add this to C (but not C++) flags...

    C_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST -xalias_level=basic"

  fi

  # Adjust optimization flags according to debug level.

  case $DEBUG_LEVEL in

    release )

      # no adjustment

      ;;

    fastdebug )

      # Not quite so much optimization

      C_O_FLAG_HI="$C_O_FLAG_NORM"

      CXX_O_FLAG_HI="$CXX_O_FLAG_NORM"

      ;;

    slowdebug )

      # Disable optimization

      C_O_FLAG_HIGHEST_JVM="$C_O_FLAG_DEBUG_JVM"

      C_O_FLAG_HIGHEST="$C_O_FLAG_DEBUG"

      C_O_FLAG_HI="$C_O_FLAG_DEBUG"

      C_O_FLAG_NORM="$C_O_FLAG_DEBUG"

      C_O_FLAG_SIZE="$C_O_FLAG_DEBUG"

      CXX_O_FLAG_HIGHEST_JVM="$CXX_O_FLAG_DEBUG_JVM"

      CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_DEBUG"

      CXX_O_FLAG_HI="$CXX_O_FLAG_DEBUG"

      CXX_O_FLAG_NORM="$CXX_O_FLAG_DEBUG"

      CXX_O_FLAG_SIZE="$CXX_O_FLAG_DEBUG"

      ;;

  esac

  AC_SUBST(C_O_FLAG_HIGHEST_JVM)

  AC_SUBST(C_O_FLAG_HIGHEST)

  AC_SUBST(C_O_FLAG_HI)

  AC_SUBST(C_O_FLAG_NORM)

  AC_SUBST(C_O_FLAG_NONE)

  AC_SUBST(C_O_FLAG_SIZE)

  AC_SUBST(CXX_O_FLAG_HIGHEST_JVM)

  AC_SUBST(CXX_O_FLAG_HIGHEST)

  AC_SUBST(CXX_O_FLAG_HI)

  AC_SUBST(CXX_O_FLAG_NORM)

  AC_SUBST(CXX_O_FLAG_NONE)

  AC_SUBST(CXX_O_FLAG_SIZE)

])

AC_DEFUN([FLAGS_SETUP_CFLAGS],

[

  ### CFLAGS

  FLAGS_SETUP_CFLAGS_HELPER

  FLAGS_OS=$OPENJDK_TARGET_OS

  FLAGS_OS_TYPE=$OPENJDK_TARGET_OS_TYPE

  FLAGS_CPU=$OPENJDK_TARGET_CPU

  FLAGS_CPU_ARCH=$OPENJDK_TARGET_CPU_ARCH

  FLAGS_CPU_BITS=$OPENJDK_TARGET_CPU_BITS

  FLAGS_CPU_ENDIAN=$OPENJDK_TARGET_CPU_ENDIAN

  FLAGS_CPU_LEGACY=$OPENJDK_TARGET_CPU_LEGACY

  FLAGS_CPU_LEGACY_LIB=$OPENJDK_TARGET_CPU_LEGACY_LIB

  FLAGS_SETUP_CFLAGS_CPU_DEP([TARGET])

  FLAGS_OS=$OPENJDK_BUILD_OS

  FLAGS_OS_TYPE=$OPENJDK_BUILD_OS_TYPE

  FLAGS_CPU=$OPENJDK_BUILD_CPU

  FLAGS_CPU_ARCH=$OPENJDK_BUILD_CPU_ARCH

  FLAGS_CPU_BITS=$OPENJDK_BUILD_CPU_BITS

  FLAGS_CPU_ENDIAN=$OPENJDK_BUILD_CPU_ENDIAN

  FLAGS_CPU_LEGACY=$OPENJDK_BUILD_CPU_LEGACY

  FLAGS_CPU_LEGACY_LIB=$OPENJDK_BUILD_CPU_LEGACY_LIB

  FLAGS_SETUP_CFLAGS_CPU_DEP([BUILD], [OPENJDK_BUILD_])

  # Tests are only ever compiled for TARGET

  CFLAGS_TESTLIB="$CFLAGS_JDKLIB"

  CXXFLAGS_TESTLIB="$CXXFLAGS_JDKLIB"

  CFLAGS_TESTEXE="$CFLAGS_JDKEXE"

  CXXFLAGS_TESTEXE="$CXXFLAGS_JDKEXE"

  AC_SUBST(CFLAGS_TESTLIB)

  AC_SUBST(CFLAGS_TESTEXE)

  AC_SUBST(CXXFLAGS_TESTLIB)

  AC_SUBST(CXXFLAGS_TESTEXE)

])

################################################################################

# platform independent

AC_DEFUN([FLAGS_SETUP_CFLAGS_HELPER],

[

  #### OS DEFINES, these should be independent on toolchain

  if test "x$OPENJDK_TARGET_OS" = xlinux; then

    CFLAGS_OS_DEF_JVM="-DLINUX"

    CFLAGS_OS_DEF_JDK="-D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"

  elif test "x$OPENJDK_TARGET_OS" = xsolaris; then

    CFLAGS_OS_DEF_JVM="-DSOLARIS"

    CFLAGS_OS_DEF_JDK="-D__solaris__"

  elif test "x$OPENJDK_TARGET_OS" = xmacosx; then

    CFLAGS_OS_DEF_JVM="-D_ALLBSD_SOURCE -D_DARWIN_C_SOURCE -D_XOPEN_SOURCE"

    CFLAGS_OS_DEF_JDK="-D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"

  elif test "x$OPENJDK_TARGET_OS" = xaix; then

    CFLAGS_OS_DEF_JVM="-DAIX"

  elif test "x$OPENJDK_TARGET_OS" = xbsd; then

    CFLAGS_OS_DEF_JDK="-D_ALLBSD_SOURCE"

  elif test "x$OPENJDK_TARGET_OS" = xwindows; then

    CFLAGS_OS_DEF_JVM="-D_WINDOWS -DWIN32 -D_JNI_IMPLEMENTATION_"

  fi

  CFLAGS_OS_DEF_JDK="$CFLAGS_OS_DEF_JDK -D$OPENJDK_TARGET_OS_UPPERCASE"

  #### GLOBAL DEFINES

  # Set some common defines. These works for all compilers, but assume

  # -D is universally accepted.

  # Always enable optional macros for VM.

  ALWAYS_CFLAGS_JVM="-D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D__STDC_CONSTANT_MACROS"

  # Setup some hard coded includes

  ALWAYS_CFLAGS_JDK=" \

      -I\$(SUPPORT_OUTPUTDIR)/modules_include/java.base \

      -I\$(SUPPORT_OUTPUTDIR)/modules_include/java.base/\$(OPENJDK_TARGET_OS_INCLUDE_SUBDIR) \

      -I${TOPDIR}/src/java.base/share/native/libjava \

      -I${TOPDIR}/src/java.base/$OPENJDK_TARGET_OS_TYPE/native/libjava \

      -I${TOPDIR}/src/hotspot/share/include \

      -I${TOPDIR}/src/hotspot/os/${HOTSPOT_TARGET_OS_TYPE}/include"

  ###############################################################################

  # Adjust flags according to debug level.

  # Setup debug/release defines

  if test "x$DEBUG_LEVEL" = xrelease; then

    DEBUG_CFLAGS_JDK="-DNDEBUG"

    if test "x$OPENJDK_TARGET_OS" = xsolaris; then

      DEBUG_CFLAGS_JDK="$DEBUG_CFLAGS_JDK -DTRIMMED"

    fi

  else

    DEBUG_CFLAGS_JDK="-DDEBUG"

    if test "x$TOOLCHAIN_TYPE" = xxlc; then

      # We need '-qminimaltoc' or '-qpic=large -bbigtoc' if the TOC overflows.

      # Hotspot now overflows its 64K TOC (currently only for debug),

      # so for debug we build with '-qpic=large -bbigtoc'.

      DEBUG_CFLAGS_JVM="-qpic=large"

    fi

  fi

  if test "x$DEBUG_LEVEL" != xrelease; then

    DEBUG_OPTIONS_FLAGS_JDK="$CFLAGS_DEBUG_OPTIONS"

    DEBUG_SYMBOLS_CFLAGS_JDK="$CFLAGS_DEBUG_SYMBOLS"

  fi

  #### TOOLCHAIN DEFINES

  if test "x$TOOLCHAIN_TYPE" = xgcc; then

    ALWAYS_DEFINES_JVM="-D_GNU_SOURCE -D_REENTRANT"

  elif test "x$TOOLCHAIN_TYPE" = xclang; then

    ALWAYS_DEFINES_JVM="-D_GNU_SOURCE"

  elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then

    ALWAYS_DEFINES_JVM="-DSPARC_WORKS -D_Crun_inline_placement"

    ALWAYS_DEFINES_JDK="-DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"

    ALWAYS_DEFINES_JDK_CXXONLY="-DCC_NOEX"

  elif test "x$TOOLCHAIN_TYPE" = xxlc; then

    ALWAYS_DEFINES_JVM="-D_REENTRANT"

    ALWAYS_DEFINES_JDK="-D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"

  elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then

    ALWAYS_DEFINES_JDK="-DWIN32_LEAN_AND_MEAN -D_CRT_SECURE_NO_DEPRECATE \

        -D_CRT_NONSTDC_NO_DEPRECATE -DWIN32 -DIAL"

    ALWAYS_DEFINES_JVM="-DNOMINMAX -DWIN32_LEAN_AND_MEAN"

  fi

  ###############################################################################

  #

  #

  # CFLAGS BASIC

  if test "x$TOOLCHAIN_TYPE" = xgcc || test "x$TOOLCHAIN_TYPE" = xclang; then

    # COMMON to gcc and clang

    TOOLCHAIN_CFLAGS_JVM="-pipe -fno-rtti -fno-exceptions \

        -fvisibility=hidden -fno-strict-aliasing -fno-omit-frame-pointer"

  fi

  if test "x$TOOLCHAIN_TYPE" = xgcc; then

    TOOLCHAIN_CFLAGS_JVM="$TOOLCHAIN_CFLAGS_JVM -fcheck-new"

    TOOLCHAIN_CFLAGS_JDK="-pipe"

    TOOLCHAIN_CFLAGS_JDK_CONLY="-fno-strict-aliasing" # technically NOT for CXX (but since this gives *worse* performance, use no-strict-aliasing everywhere!)

    CXXSTD_CXXFLAG="-std=gnu++98"

    FLAGS_CXX_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [$CXXSTD_CXXFLAG -Werror],

    						 IF_FALSE: [CXXSTD_CXXFLAG=""])

    TOOLCHAIN_CFLAGS_JDK_CXXONLY="$CXXSTD_CXXFLAG"

    TOOLCHAIN_CFLAGS_JVM="$TOOLCHAIN_CFLAGS_JVM $CXXSTD_CXXFLAG"