#

# 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 ABI profile (for arm)

#

AC_DEFUN([FLAGS_SETUP_ABI_PROFILE],

[

  AC_ARG_WITH(abi-profile, [AS_HELP_STRING([--with-abi-profile],

      [specify ABI profile for ARM builds (arm-vfp-sflt,arm-vfp-hflt,arm-sflt, armv5-vfp-sflt,armv6-vfp-hflt,arm64,aarch64) @<:@toolchain dependent@:>@ ])])

  if test "x$with_abi_profile" != x; then

    if test "x$OPENJDK_TARGET_CPU" != xarm && \

        test "x$OPENJDK_TARGET_CPU" != xaarch64; then

      AC_MSG_ERROR([--with-abi-profile only available on arm/aarch64])

    fi

    OPENJDK_TARGET_ABI_PROFILE=$with_abi_profile

    AC_MSG_CHECKING([for ABI profle])

    AC_MSG_RESULT([$OPENJDK_TARGET_ABI_PROFILE])

    if test "x$OPENJDK_TARGET_ABI_PROFILE" = xarm-vfp-sflt; then

      ARM_FLOAT_TYPE=vfp-sflt

      ARM_ARCH_TYPE_FLAGS='-march=armv7-a -mthumb'

    elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xarm-vfp-hflt; then

      ARM_FLOAT_TYPE=vfp-hflt

      ARM_ARCH_TYPE_FLAGS='-march=armv7-a -mthumb'

    elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xarm-sflt; then

      ARM_FLOAT_TYPE=sflt

      ARM_ARCH_TYPE_FLAGS='-march=armv5t -marm'

    elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xarmv5-vfp-sflt; then

      ARM_FLOAT_TYPE=vfp-sflt

      ARM_ARCH_TYPE_FLAGS='-march=armv5t -marm'

    elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xarmv6-vfp-hflt; then

      ARM_FLOAT_TYPE=vfp-hflt

      ARM_ARCH_TYPE_FLAGS='-march=armv6 -marm'

    elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xarm64; then

      # No special flags, just need to trigger setting JDK_ARCH_ABI_PROP_NAME

      ARM_FLOAT_TYPE=

      ARM_ARCH_TYPE_FLAGS=

    elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xaarch64; then

      # No special flags, just need to trigger setting JDK_ARCH_ABI_PROP_NAME

      ARM_FLOAT_TYPE=

      ARM_ARCH_TYPE_FLAGS=

    else

      AC_MSG_ERROR([Invalid ABI profile: "$OPENJDK_TARGET_ABI_PROFILE"])

    fi

    if test "x$ARM_FLOAT_TYPE" = xvfp-sflt; then

      ARM_FLOAT_TYPE_FLAGS='-mfloat-abi=softfp -mfpu=vfp -DFLOAT_ARCH=-vfp-sflt'

    elif test "x$ARM_FLOAT_TYPE" = xvfp-hflt; then

      ARM_FLOAT_TYPE_FLAGS='-mfloat-abi=hard -mfpu=vfp -DFLOAT_ARCH=-vfp-hflt'

    elif test "x$ARM_FLOAT_TYPE" = xsflt; then

      ARM_FLOAT_TYPE_FLAGS='-msoft-float -mfpu=vfp'

    fi

    AC_MSG_CHECKING([for $ARM_FLOAT_TYPE floating point flags])

    AC_MSG_RESULT([$ARM_FLOAT_TYPE_FLAGS])

    AC_MSG_CHECKING([for arch type flags])

    AC_MSG_RESULT([$ARM_ARCH_TYPE_FLAGS])

    # Now set JDK_ARCH_ABI_PROP_NAME. This is equivalent to the last part of the

    # autoconf target triplet.

    [ JDK_ARCH_ABI_PROP_NAME=`$ECHO $OPENJDK_TARGET_AUTOCONF_NAME | $SED -e 's/.*-\([^-]*\)$/\1/'` ]

    # Sanity check that it is a known ABI.

    if test "x$JDK_ARCH_ABI_PROP_NAME" != xgnu && \

        test "x$JDK_ARCH_ABI_PROP_NAME" != xgnueabi  && \

        test "x$JDK_ARCH_ABI_PROP_NAME" != xgnueabihf; then

          AC_MSG_WARN([Unknown autoconf target triplet ABI: "$JDK_ARCH_ABI_PROP_NAME"])

    fi

    AC_MSG_CHECKING([for ABI property name])

    AC_MSG_RESULT([$JDK_ARCH_ABI_PROP_NAME])

    AC_SUBST(JDK_ARCH_ABI_PROP_NAME)

    # Pass these on to the open part of configure as if they were set using

    # --with-extra-c[xx]flags.

    EXTRA_CFLAGS="$EXTRA_CFLAGS $ARM_ARCH_TYPE_FLAGS $ARM_FLOAT_TYPE_FLAGS"

    EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS $ARM_ARCH_TYPE_FLAGS $ARM_FLOAT_TYPE_FLAGS"

    # Get rid of annoying "note: the mangling of 'va_list' has changed in GCC 4.4"

    # FIXME: This should not really be set using extra_cflags.

    if test "x$OPENJDK_TARGET_CPU" = xarm; then

        EXTRA_CFLAGS="$EXTRA_CFLAGS -Wno-psabi"

        EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -Wno-psabi"

    fi

    # Also add JDK_ARCH_ABI_PROP_NAME define, but only to CFLAGS.

    EXTRA_CFLAGS="$EXTRA_CFLAGS -DJDK_ARCH_ABI_PROP_NAME='\"\$(JDK_ARCH_ABI_PROP_NAME)\"'"

    # And pass the architecture flags to the linker as well

    EXTRA_LDFLAGS="$EXTRA_LDFLAGS $ARM_ARCH_TYPE_FLAGS $ARM_FLOAT_TYPE_FLAGS"

  fi

  # When building with an abi profile, the name of that profile is appended on the

  # bundle platform, which is used in bundle names.

  if test "x$OPENJDK_TARGET_ABI_PROFILE" != x; then

    OPENJDK_TARGET_BUNDLE_PLATFORM="$OPENJDK_TARGET_OS_BUNDLE-$OPENJDK_TARGET_ABI_PROFILE"

  fi

])

# Reset the global CFLAGS/LDFLAGS variables and initialize them with the

# corresponding configure arguments instead

AC_DEFUN_ONCE([FLAGS_SETUP_USER_SUPPLIED_FLAGS],

[

  if test "x$CFLAGS" != "x${ADDED_CFLAGS}"; then

    AC_MSG_WARN([Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags])

  fi

  if test "x$CXXFLAGS" != "x${ADDED_CXXFLAGS}"; then

    AC_MSG_WARN([Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags])

  fi

  if test "x$LDFLAGS" != "x${ADDED_LDFLAGS}"; then

    AC_MSG_WARN([Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags])

  fi

  AC_ARG_WITH(extra-cflags, [AS_HELP_STRING([--with-extra-cflags],

      [extra flags to be used when compiling jdk c-files])])

  AC_ARG_WITH(extra-cxxflags, [AS_HELP_STRING([--with-extra-cxxflags],

      [extra flags to be used when compiling jdk c++-files])])

  AC_ARG_WITH(extra-ldflags, [AS_HELP_STRING([--with-extra-ldflags],

      [extra flags to be used when linking jdk])])

  EXTRA_CFLAGS="$with_extra_cflags"

  EXTRA_CXXFLAGS="$with_extra_cxxflags"

  EXTRA_LDFLAGS="$with_extra_ldflags"

  AC_SUBST(EXTRA_CFLAGS)

  AC_SUBST(EXTRA_CXXFLAGS)

  AC_SUBST(EXTRA_LDFLAGS)

  # The global CFLAGS and LDLAGS variables are used by configure tests and

  # should include the extra parameters

  CFLAGS="$EXTRA_CFLAGS"

  CXXFLAGS="$EXTRA_CXXFLAGS"

  LDFLAGS="$EXTRA_LDFLAGS"

  CPPFLAGS=""

])

# Setup the sysroot flags and add them to global CFLAGS and LDFLAGS so

# that configure can use them while detecting compilers.

# TOOLCHAIN_TYPE is available here.

# Param 1 - Optional prefix to all variables. (e.g BUILD_)

AC_DEFUN([FLAGS_SETUP_SYSROOT_FLAGS],

[

  if test "x[$]$1SYSROOT" != "x"; then

    if test "x$TOOLCHAIN_TYPE" = xsolstudio; then

      if test "x$OPENJDK_TARGET_OS" = xsolaris; then

        # Solaris Studio does not have a concept of sysroot. Instead we must

        # make sure the default include and lib dirs are appended to each

        # compile and link command line. Must also add -I-xbuiltin to enable

        # inlining of system functions and intrinsics.

        $1SYSROOT_CFLAGS="-I-xbuiltin -I[$]$1SYSROOT/usr/include"

        $1SYSROOT_LDFLAGS="-L[$]$1SYSROOT/usr/lib$OPENJDK_TARGET_CPU_ISADIR \

            -L[$]$1SYSROOT/lib$OPENJDK_TARGET_CPU_ISADIR"

      fi

    elif test "x$TOOLCHAIN_TYPE" = xgcc; then

      $1SYSROOT_CFLAGS="--sysroot=[$]$1SYSROOT"

      $1SYSROOT_LDFLAGS="--sysroot=[$]$1SYSROOT"

    elif test "x$TOOLCHAIN_TYPE" = xclang; then

      $1SYSROOT_CFLAGS="-isysroot [$]$1SYSROOT"

      $1SYSROOT_LDFLAGS="-isysroot [$]$1SYSROOT"

    fi

    # The global CFLAGS and LDFLAGS variables need these for configure to function

    $1CFLAGS="[$]$1CFLAGS [$]$1SYSROOT_CFLAGS"

    $1CPPFLAGS="[$]$1CPPFLAGS [$]$1SYSROOT_CFLAGS"

    $1CXXFLAGS="[$]$1CXXFLAGS [$]$1SYSROOT_CFLAGS"

    $1LDFLAGS="[$]$1LDFLAGS [$]$1SYSROOT_LDFLAGS"

  fi

  if test "x$OPENJDK_TARGET_OS" = xmacosx; then

    # We also need -iframework<path>/System/Library/Frameworks

    $1SYSROOT_CFLAGS="[$]$1SYSROOT_CFLAGS -iframework [$]$1SYSROOT/System/Library/Frameworks"

    $1SYSROOT_LDFLAGS="[$]$1SYSROOT_LDFLAGS -iframework [$]$1SYSROOT/System/Library/Frameworks"

    # These always need to be set, or we can't find the frameworks embedded in JavaVM.framework

    # set this here so it doesn't have to be peppered throughout the forest

    $1SYSROOT_CFLAGS="[$]$1SYSROOT_CFLAGS -F [$]$1SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks"

    $1SYSROOT_LDFLAGS="[$]$1SYSROOT_LDFLAGS -F [$]$1SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks"

  fi

  AC_SUBST($1SYSROOT_CFLAGS)

  AC_SUBST($1SYSROOT_LDFLAGS)

])

AC_DEFUN_ONCE([FLAGS_SETUP_INIT_FLAGS],

[

  if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then

    # silence copyright notice and other headers.

    COMMON_CCXXFLAGS="$COMMON_CCXXFLAGS -nologo"

  fi

])

AC_DEFUN([FLAGS_SETUP_COMPILER_FLAGS_FOR_LIBS],

[

  if test "x$TOOLCHAIN_TYPE" = xgcc; then

    if test "x$OPENJDK_TARGET_OS" = xmacosx; then

        JVM_CFLAGS="$JVM_CFLAGS $PICFLAG"

      fi

    fi

  elif test "x$TOOLCHAIN_TYPE" = xclang; then

    if test "x$OPENJDK_TARGET_OS" = xmacosx; then

      if test "x$STATIC_BUILD" = xfalse; then

        JVM_CFLAGS="$JVM_CFLAGS -fPIC"

      fi

    fi

  elif test "x$TOOLCHAIN_TYPE" = xxlc; then

    JVM_CFLAGS="$JVM_CFLAGS $PICFLAG"

  fi

  # The (cross) compiler is now configured, we can now test capabilities

  # of the target platform.

])

# Documentation on common flags used for solstudio in HIGHEST.

#

# WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be

#          done with care, there are some assumptions below that need to

#          be understood about the use of pointers, and IEEE behavior.

#

# -fns: Use non-standard floating point mode (not IEEE 754)

# -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)

# -fsingle: Use single precision floating point with 'float'

# -xalias_level=basic: Assume memory references via basic pointer types do not alias

#   (Source with excessing pointer casting and data access with mixed

#    pointer types are not recommended)

# -xbuiltin=%all: Use intrinsic or inline versions for math/std functions

#   (If you expect perfect errno behavior, do not use this)

# -xdepend: Loop data dependency optimizations (need -xO3 or higher)

# -xrestrict: Pointer parameters to functions do not overlap

#   (Similar to -xalias_level=basic usage, but less obvious sometimes.

#    If you pass in multiple pointers to the same data, do not use this)

# -xlibmil: Inline some library routines

#   (If you expect perfect errno behavior, do not use this)

# -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)

#   (If you expect perfect errno behavior, do not use this)

#  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now

AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],

[

  # Debug symbols for JVM_CFLAGS

  if test "x$TOOLCHAIN_TYPE" = xsolstudio; then

    JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -xs"

    if test "x$DEBUG_LEVEL" = xslowdebug; then

      JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -g"

    else

      # -g0 does not disable inlining, which -g does.

      JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -g0"

    fi

  elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then

    JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -Z7 -d2Zi+"

  else

    JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -g"

  fi

  AC_SUBST(JVM_CFLAGS_SYMBOLS)

  # bounds, memory and behavior checking options

  if test "x$TOOLCHAIN_TYPE" = xgcc; then

    case $DEBUG_LEVEL in

    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.

      if test "x$STACK_PROTECTOR_CFLAG" != x; then

        JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS $STACK_PROTECTOR_CFLAG --param ssp-buffer-size=1"

      fi

      ;;

    esac

  fi

  if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then

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

      if test "x$OPENJDK_TARGET_CPU" = xx86_64; then

        JVM_CFLAGS="$JVM_CFLAGS -homeparams"

      fi

    fi

  fi

])

AC_DEFUN([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],

[

  FLAGS_SETUP_ABI_PROFILE

  # Optional POSIX functionality needed by the JVM

  #

  # Check if clock_gettime is available and in which library. This indicates

  # availability of CLOCK_MONOTONIC for hotspot. But we don't need to link, so

  # don't let it update LIBS.

  save_LIBS="$LIBS"

  AC_SEARCH_LIBS(clock_gettime, rt, [HAS_CLOCK_GETTIME=true], [])

  if test "x$LIBS" = "x-lrt "; then

    CLOCK_GETTIME_IN_LIBRT=true

  fi

  LIBS="$save_LIBS"

  FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_HELPER([TARGET])

  FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_HELPER([BUILD], [OPENJDK_BUILD_])

  # Tests are only ever compiled for TARGET

  # Flags for compiling test libraries

  CFLAGS_TESTLIB="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"

  CXXFLAGS_TESTLIB="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA"

  # Flags for compiling test executables

  CFLAGS_TESTEXE="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK"

  CXXFLAGS_TESTEXE="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK"

  AC_SUBST(CFLAGS_TESTLIB)

  AC_SUBST(CFLAGS_TESTEXE)

  AC_SUBST(CXXFLAGS_TESTLIB)

  AC_SUBST(CXXFLAGS_TESTEXE)

  LDFLAGS_TESTLIB="$LDFLAGS_JDKLIB"

  LDFLAGS_TESTEXE="$LDFLAGS_JDKEXE $JAVA_BASE_LDFLAGS"

  AC_SUBST(LDFLAGS_TESTLIB)

  AC_SUBST(LDFLAGS_TESTEXE)

])

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

# $1 - Either BUILD or TARGET to pick the correct OS/CPU variables to check

#      conditionals against.

# $2 - Optional prefix for each variable defined.

AC_DEFUN([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_HELPER],

[

  # Special extras...

  if test "x$TOOLCHAIN_TYPE" = xsolstudio; then

      $2CFLAGS_JDKLIB_EXTRA="${$2CFLAGS_JDKLIB_EXTRA} -xregs=no%appl"

      $2CXXFLAGS_JDKLIB_EXTRA="${$2CXXFLAGS_JDKLIB_EXTRA} -xregs=no%appl"

    fi

    $2CFLAGS_JDKLIB_EXTRA="${$2CFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt"

    $2CXXFLAGS_JDKLIB_EXTRA="${$2CXXFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt"

  elif test "x$TOOLCHAIN_TYPE" = xxlc; then

    $2CFLAGS_JDK="${$2CFLAGS_JDK} -qchars=signed -qfullpath -qsaveopt"

    $2CXXFLAGS_JDK="${$2CXXFLAGS_JDK} -qchars=signed -qfullpath -qsaveopt"

  elif test "x$TOOLCHAIN_TYPE" = xgcc; then

    $2CXXSTD_CXXFLAG="-std=gnu++98"

    FLAGS_CXX_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [[$]$2CXXSTD_CXXFLAG -Werror],

    						 IF_FALSE: [$2CXXSTD_CXXFLAG=""])

    $2CXXFLAGS_JDK="${$2CXXFLAGS_JDK} ${$2CXXSTD_CXXFLAG}"

    $2JVM_CFLAGS="${$2JVM_CFLAGS} ${$2CXXSTD_CXXFLAG}"

    AC_SUBST($2CXXSTD_CXXFLAG)

  fi

  if test "x$OPENJDK_TARGET_OS" = xsolaris; then

    $2CFLAGS_JDK="${$2CFLAGS_JDK} -D__solaris__"

    $2CXXFLAGS_JDK="${$2CXXFLAGS_JDK} -D__solaris__"

  fi

  $2CFLAGS_JDK="${$2CFLAGS_JDK} ${$2EXTRA_CFLAGS}"

  $2CXXFLAGS_JDK="${$2CXXFLAGS_JDK} ${$2EXTRA_CXXFLAGS}"

  $2LDFLAGS_JDK="${$2LDFLAGS_JDK} ${$2EXTRA_LDFLAGS}"

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

  #

  # Now setup the CFLAGS and LDFLAGS for the JDK build.

  # Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build.

  #

  # Setup compiler/platform specific flags into

  #    $2CFLAGS_JDK    - C Compiler flags

  #    $2CXXFLAGS_JDK  - C++ Compiler flags

  #    $2COMMON_CCXXFLAGS_JDK - common to C and C++

  if test "x$TOOLCHAIN_TYPE" = xgcc; then

    $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_GNU_SOURCE"

    $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_REENTRANT"

    $2JVM_CFLAGS="[$]$2JVM_CFLAGS -fcheck-new"

      # Force compatibility with i586 on 32 bit intel platforms.

      $2COMMON_CCXXFLAGS="${$2COMMON_CCXXFLAGS} -march=i586"

      $2JVM_CFLAGS="[$]$2JVM_CFLAGS -march=i586"

    fi

    $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS [$]$2COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \

        -pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"

      arm )

        # on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing

        $2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"

        $2COMMON_CCXXFLAGS_JDK="${$2COMMON_CCXXFLAGS_JDK} -fsigned-char"

        ;;

      ppc )

        # on ppc we don't prevent gcc to omit frame pointer but do prevent strict aliasing

        $2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"

        ;;

      s390 )

        $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer -mbackchain -march=z10"

        $2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"

        ;;

      * )

        $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"

        $2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"

        ;;

    esac

    TOOLCHAIN_CHECK_COMPILER_VERSION(VERSION: 6, PREFIX: $2, IF_AT_LEAST: FLAGS_SETUP_GCC6_COMPILER_FLAGS($2))

  elif test "x$TOOLCHAIN_TYPE" = xclang; then

    $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_GNU_SOURCE"

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

    $2JVM_CFLAGS="[$]$2JVM_CFLAGS -flimit-debug-info"

        # Force compatibility with i586 on 32 bit intel platforms.

        $2COMMON_CCXXFLAGS="${$2COMMON_CCXXFLAGS} -march=i586"

        $2JVM_CFLAGS="[$]$2JVM_CFLAGS -march=i586"

      fi

      $2JVM_CFLAGS="[$]$2JVM_CFLAGS -Wno-sometimes-uninitialized"

      $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS [$]$2COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \

          -pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"

        ppc )

          # on ppc we don't prevent gcc to omit frame pointer but do prevent strict aliasing

          $2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"

          ;;

        * )

          $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"

          $2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"

          ;;

      esac

    fi

  elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then

    $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DSPARC_WORKS"

    $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS [$]$2COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"

    fi

    $2CFLAGS_JDK="[$]$2CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"

    $2CXXFLAGS_JDK="[$]$2CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"