#

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

#

m4_include([flags-cflags.m4])

m4_include([flags-ldflags.m4])

m4_include([flags-other.m4])

# Sort the flags in a given variable, and remove superfluous whitespace.

#

# $1 = name of variable to sort

AC_DEFUN([FLAGS_SORT_FLAGS], [

  $1=`$ECHO ${$1} | $TR ' ' '\n' | $SORT | $TR '\n' ' '`

])

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

#

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

  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"; then

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

  fi

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

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

  fi

  if test "x$LDFLAGS" != "x"; 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])])

  USER_CFLAGS="$with_extra_cflags"

  USER_CXXFLAGS="$with_extra_cxxflags"

  USER_LDFLAGS="$with_extra_ldflags"

])

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

        # If the devkit contains the ld linker, make sure we use it.

        AC_PATH_PROG(SOLARIS_LD, ld, , $DEVKIT_TOOLCHAIN_PATH:$DEVKIT_EXTRA_PATH)

        # Make sure this ld is runnable.

        if test -f "$SOLARIS_LD"; then

          if "$SOLARIS_LD" -V > /dev/null 2> /dev/null; then

            $1SYSROOT_LDFLAGS="[$]$1SYSROOT_LDFLAGS -Yl,$(dirname $SOLARIS_LD)"

          else

            AC_MSG_WARN([Could not run $SOLARIS_LD found in devkit, reverting to system ld])

          fi

        fi

      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

  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_GLOBAL_FLAGS],

[

  if test "x$TOOLCHAIN_TYPE" = xxlc; then

    MACHINE_FLAG="-q${OPENJDK_TARGET_CPU_BITS}"

  elif test "x$TOOLCHAIN_TYPE" != xmicrosoft; then

    MACHINE_FLAG="-m${OPENJDK_TARGET_CPU_BITS}"

  fi

  # FIXME: global flags are not used yet...

  # The "global" flags will *always* be set. Without them, it is not possible to

  # get a working compilation.

  GLOBAL_CFLAGS="$MACHINE_FLAG $SYSROOT_CFLAGS $USER_CFLAGS"

  GLOBAL_CXXFLAGS="$MACHINE_FLAG $SYSROOT_CFLAGS $USER_CXXFLAGS"

  GLOBAL_LDFLAGS="$MACHINE_FLAG $SYSROOT_LDFLAGS $USER_LDFLAGS"

  # FIXME: Don't really know how to do with this, but this was the old behavior

  GLOBAL_CPPFLAGS="$SYSROOT_CFLAGS"

  AC_SUBST(GLOBAL_CFLAGS)

  AC_SUBST(GLOBAL_CXXFLAGS)

  AC_SUBST(GLOBAL_LDFLAGS)

  AC_SUBST(GLOBAL_CPPFLAGS)

  # FIXME: For compatilibity, export this as EXTRA_CFLAGS for now.

  EXTRA_CFLAGS="$MACHINE_FLAG $USER_CFLAGS"

  EXTRA_CXXFLAGS="$MACHINE_FLAG $USER_CXXFLAGS"

  EXTRA_LDFLAGS="$MACHINE_FLAG $USER_LDFLAGS"

  AC_SUBST(EXTRA_CFLAGS)

  AC_SUBST(EXTRA_CXXFLAGS)

  AC_SUBST(EXTRA_LDFLAGS)

  # For autoconf testing to work, the global flags must also be stored in the

  # "unnamed" CFLAGS etc.

  CFLAGS="$GLOBAL_CFLAGS"

  CXXFLAGS="$GLOBAL_CXXFLAGS"

  LDFLAGS="$GLOBAL_LDFLAGS"

  CPPFLAGS="$GLOBAL_CPPFLAGS"

])

AC_DEFUN_ONCE([FLAGS_SETUP_INIT_FLAGS],

[

  FLAGS_SETUP_TOOLCHAIN_CONTROL

  FLAGS_SETUP_ARFLAGS

  FLAGS_SETUP_STRIPFLAGS

  FLAGS_SETUP_RCFLAGS

  if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then

    # silence copyright notice and other headers.

    COMMON_CCXXFLAGS="$COMMON_CCXXFLAGS -nologo"

  fi

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

    FLAGS_SETUP_SYSROOT_FLAGS([BUILD_])

  else

    BUILD_SYSROOT_CFLAGS="$SYSROOT_CFLAGS"

    BUILD_SYSROOT_LDFLAGS="$SYSROOT_LDFLAGS"

  fi

  AC_SUBST(BUILD_SYSROOT_CFLAGS)

  AC_SUBST(BUILD_SYSROOT_LDFLAGS)

])

AC_DEFUN([FLAGS_SETUP_COMPILER_FLAGS_FOR_LIBS],

[

  FLAGS_SETUP_SHARED_LIBS

  # 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],

[

  FLAGS_SETUP_DEBUG_SYMBOLS

  FLAGS_SETUP_QUALITY_CHECKS

  FLAGS_SETUP_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],

[

  # Additional macosx handling

    # MACOSX_VERSION_MIN specifies the lowest version of Macosx that the built

    # binaries should be compatible with, even if compiled on a newer version

    # of the OS. It currently has a hard coded value. Setting this also limits

    # exposure to API changes in header files. Bumping this is likely to

    # require code changes to build.

    MACOSX_VERSION_MIN=10.7.0

    MACOSX_VERSION_MIN_NODOTS=1070

    AC_SUBST(MACOSX_VERSION_MIN)

    # Setting --with-macosx-version-max=<version> makes it an error to build or

    # link to macosx APIs that are newer than the given OS version. The expected

    # format for <version> is either nn.n.n or nn.nn.nn. See /usr/include/AvailabilityMacros.h.

    AC_ARG_WITH([macosx-version-max], [AS_HELP_STRING([--with-macosx-version-max],

        [error on use of newer functionality. @<:@macosx@:>@])],

        [

          if echo "$with_macosx_version_max" | $GREP -q "^[[0-9]][[0-9]]\.[[0-9]]\.[[0-9]]\$"; then

              MACOSX_VERSION_MAX=$with_macosx_version_max

          elif echo "$with_macosx_version_max" | $GREP -q "^[[0-9]][[0-9]]\.[[0-9]][[0-9]]\.[[0-9]][[0-9]]\$"; then

              MACOSX_VERSION_MAX=$with_macosx_version_max

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

              # Use build system default

              MACOSX_VERSION_MAX=

          else

              AC_MSG_ERROR([osx version format must be nn.n.n or nn.nn.nn])

          fi

        ],

        [MACOSX_VERSION_MAX=]

    )

    MACOSX_VERSION_MAX_NODOTS=`$ECHO $MACOSX_VERSION_MAX | $TR -d .`

    AC_SUBST(MACOSX_VERSION_MAX)

  fi

  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_LINKER_FLAGS_FOR_JDK

  ### CFLAGS

  FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_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_ADD_LP64=$OPENJDK_TARGET_ADD_LP64

  FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_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_ADD_LP64=$OPENJDK_BUILD_ADD_LP64

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

   ############## ARFLAGS

  # Additional macosx handling

  if test "x$OPENJDK_TARGET_OS" = xmacosx; then

    ARFLAGS="$ARFLAGS -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"

  fi

   ############## ASFLAGS

  # Set JVM_ASFLAGS

  if test "x$OPENJDK_TARGET_OS" = xmacosx; then

    JVM_ASFLAGS="-x assembler-with-cpp -mno-omit-leaf-frame-pointer -mstack-alignment=16"

  fi

  JVM_ASFLAGS="$JVM_ASFLAGS $MACHINE_FLAG"

  AC_SUBST(JVM_ASFLAGS)

])

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

# platform independent

AC_DEFUN([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_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"

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