#

# 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@:>@])])

  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])

    WARNINGS_AS_ERRORS=false

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

    AC_MSG_RESULT([yes (default)])

    WARNINGS_AS_ERRORS=true

  else

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

  fi

  AC_SUBST(WARNINGS_AS_ERRORS)

  case "${TOOLCHAIN_TYPE}" in

    microsoft)

      DISABLE_WARNING_PREFIX="-wd"

      CFLAGS_WARNINGS_ARE_ERRORS="-WX"

      ;;

    solstudio)

      DISABLE_WARNING_PREFIX="-erroff="

      CFLAGS_WARNINGS_ARE_ERRORS="-errtags -errwarn=%all"

      ;;

    gcc)

      DISABLE_WARNING_PREFIX="-Wno-"

      CFLAGS_WARNINGS_ARE_ERRORS="-Werror"

      # 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_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"

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

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

      ;;

    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

  # Setup target OS define. Use OS target name but in upper case.

  OPENJDK_TARGET_OS_UPPERCASE=`$ECHO $OPENJDK_TARGET_OS | $TR 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`

  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"

  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"

    ADLC_CXXFLAG="$CXXSTD_CXXFLAG"

  elif test "x$TOOLCHAIN_TYPE" = xclang; then

    # Restrict the debug information created by Clang to avoid

    # too big object files and speed the build up a little bit

    # (see http://llvm.org/bugs/show_bug.cgi?id=7554)

    TOOLCHAIN_CFLAGS_JVM="$TOOLCHAIN_CFLAGS_JVM -flimit-debug-info"

    if test "x$OPENJDK_TARGET_OS" = xlinux; then

      TOOLCHAIN_CFLAGS_JDK="-pipe"

      TOOLCHAIN_CFLAGS_JDK_CONLY="-fno-strict-aliasing" # technically NOT for CXX

    fi

  elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then

    TOOLCHAIN_CFLAGS_JDK="-mt"

    TOOLCHAIN_CFLAGS_JDK_CONLY="-xc99=%none -xCC -Xa -v -W0,-noglobal" # C only

    TOOLCHAIN_CFLAGS_JDK_CXXONLY="-features=no%except -norunpath -xnolib" # CXX only

    TOOLCHAIN_CFLAGS_JVM="-template=no%extdef -features=no%split_init \

        -library=stlport4 -mt -features=no%except"

    if test "x$DEBUG_LEVEL" = xslowdebug; then

      # Previously -g was used instead of -g0 for slowdebug; this is equivalent

      # to setting +d.

      TOOLCHAIN_CFLAGS_JVM="$TOOLCHAIN_CFLAGS_JVM +d"

    fi

  elif test "x$TOOLCHAIN_TYPE" = xxlc; then

    TOOLCHAIN_CFLAGS_JDK="-qchars=signed -qfullpath -qsaveopt"  # add on both CFLAGS

    TOOLCHAIN_CFLAGS_JVM="-qtune=balanced \

        -qalias=noansi -qstrict -qtls=default -qlanglvl=c99vla \

        -qlanglvl=noredefmac -qnortti -qnoeh -qignerrno"

  elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then

    TOOLCHAIN_CFLAGS_JVM="-nologo -MD -MP"

    TOOLCHAIN_CFLAGS_JDK="-nologo -MD -Zc:wchar_t-"

  fi

  # CFLAGS WARNINGS STUFF

  # Set JVM_CFLAGS warning handling

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

    # COMMON to gcc and clang

    WARNING_CFLAGS_JVM="-Wpointer-arith -Wsign-compare -Wunused-function"

    if ! HOTSPOT_CHECK_JVM_VARIANT(zero); then

      # Non-zero builds have stricter warnings

      WARNING_CFLAGS_JVM="$WARNING_CFLAGS_JVM -Wundef -Wformat=2"

    fi

  fi