1 #
   2 # Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
   3 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4 #
   5 # This code is free software; you can redistribute it and/or modify it
   6 # under the terms of the GNU General Public License version 2 only, as
   7 # published by the Free Software Foundation.  Oracle designates this
   8 # particular file as subject to the "Classpath" exception as provided
   9 # by Oracle in the LICENSE file that accompanied this code.
  10 #
  11 # This code is distributed in the hope that it will be useful, but WITHOUT
  12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 # version 2 for more details (a copy is included in the LICENSE file that
  15 # accompanied this code).
  16 #
  17 # You should have received a copy of the GNU General Public License version
  18 # 2 along with this work; if not, write to the Free Software Foundation,
  19 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20 #
  21 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22 # or visit www.oracle.com if you need additional information or have any
  23 # questions.
  24 #
  25 
  26 ################################################################################
  27 #
  28 # Setup ABI profile (for arm)
  29 #
  30 AC_DEFUN([FLAGS_SETUP_ABI_PROFILE],
  31 [
  32   AC_ARG_WITH(abi-profile, [AS_HELP_STRING([--with-abi-profile],
  33       [specify ABI profile for ARM builds (arm-vfp-sflt,arm-vfp-hflt,arm-sflt, armv5-vfp-sflt,armv6-vfp-hflt,arm64,aarch64) @<:@toolchain dependent@:>@ ])])
  34 
  35   if test "x$with_abi_profile" != x; then
  36     if test "x$OPENJDK_TARGET_CPU" != xarm && \
  37         test "x$OPENJDK_TARGET_CPU" != xaarch64; then
  38       AC_MSG_ERROR([--with-abi-profile only available on arm/aarch64])
  39     fi
  40 
  41     OPENJDK_TARGET_ABI_PROFILE=$with_abi_profile
  42     AC_MSG_CHECKING([for ABI profle])
  43     AC_MSG_RESULT([$OPENJDK_TARGET_ABI_PROFILE])
  44 
  45     if test "x$OPENJDK_TARGET_ABI_PROFILE" = xarm-vfp-sflt; then
  46       ARM_FLOAT_TYPE=vfp-sflt
  47       ARM_ARCH_TYPE_FLAGS='-march=armv7-a -mthumb'
  48     elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xarm-vfp-hflt; then
  49       ARM_FLOAT_TYPE=vfp-hflt
  50       ARM_ARCH_TYPE_FLAGS='-march=armv7-a -mthumb'
  51     elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xarm-sflt; then
  52       ARM_FLOAT_TYPE=sflt
  53       ARM_ARCH_TYPE_FLAGS='-march=armv5t -marm'
  54     elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xarmv5-vfp-sflt; then
  55       ARM_FLOAT_TYPE=vfp-sflt
  56       ARM_ARCH_TYPE_FLAGS='-march=armv5t -marm'
  57     elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xarmv6-vfp-hflt; then
  58       ARM_FLOAT_TYPE=vfp-hflt
  59       ARM_ARCH_TYPE_FLAGS='-march=armv6 -marm'
  60     elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xarm64; then
  61       # No special flags, just need to trigger setting JDK_ARCH_ABI_PROP_NAME
  62       ARM_FLOAT_TYPE=
  63       ARM_ARCH_TYPE_FLAGS=
  64     elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xaarch64; then
  65       # No special flags, just need to trigger setting JDK_ARCH_ABI_PROP_NAME
  66       ARM_FLOAT_TYPE=
  67       ARM_ARCH_TYPE_FLAGS=
  68     else
  69       AC_MSG_ERROR([Invalid ABI profile: "$OPENJDK_TARGET_ABI_PROFILE"])
  70     fi
  71 
  72     if test "x$ARM_FLOAT_TYPE" = xvfp-sflt; then
  73       ARM_FLOAT_TYPE_FLAGS='-mfloat-abi=softfp -mfpu=vfp -DFLOAT_ARCH=-vfp-sflt'
  74     elif test "x$ARM_FLOAT_TYPE" = xvfp-hflt; then
  75       ARM_FLOAT_TYPE_FLAGS='-mfloat-abi=hard -mfpu=vfp -DFLOAT_ARCH=-vfp-hflt'
  76     elif test "x$ARM_FLOAT_TYPE" = xsflt; then
  77       ARM_FLOAT_TYPE_FLAGS='-msoft-float -mfpu=vfp'
  78     fi
  79     AC_MSG_CHECKING([for $ARM_FLOAT_TYPE floating point flags])
  80     AC_MSG_RESULT([$ARM_FLOAT_TYPE_FLAGS])
  81 
  82     AC_MSG_CHECKING([for arch type flags])
  83     AC_MSG_RESULT([$ARM_ARCH_TYPE_FLAGS])
  84 
  85     # Now set JDK_ARCH_ABI_PROP_NAME. This is equivalent to the last part of the
  86     # autoconf target triplet.
  87     [ JDK_ARCH_ABI_PROP_NAME=`$ECHO $OPENJDK_TARGET_AUTOCONF_NAME | $SED -e 's/.*-\([^-]*\)$/\1/'` ]
  88     # Sanity check that it is a known ABI.
  89     if test "x$JDK_ARCH_ABI_PROP_NAME" != xgnu && \
  90         test "x$JDK_ARCH_ABI_PROP_NAME" != xgnueabi  && \
  91         test "x$JDK_ARCH_ABI_PROP_NAME" != xgnueabihf; then
  92           AC_MSG_WARN([Unknown autoconf target triplet ABI: "$JDK_ARCH_ABI_PROP_NAME"])
  93     fi
  94     AC_MSG_CHECKING([for ABI property name])
  95     AC_MSG_RESULT([$JDK_ARCH_ABI_PROP_NAME])
  96     AC_SUBST(JDK_ARCH_ABI_PROP_NAME)
  97 
  98     # Pass these on to the open part of configure as if they were set using
  99     # --with-extra-c[xx]flags.
 100     EXTRA_CFLAGS="$EXTRA_CFLAGS $ARM_ARCH_TYPE_FLAGS $ARM_FLOAT_TYPE_FLAGS"
 101     EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS $ARM_ARCH_TYPE_FLAGS $ARM_FLOAT_TYPE_FLAGS"
 102     # Get rid of annoying "note: the mangling of 'va_list' has changed in GCC 4.4"
 103     # FIXME: This should not really be set using extra_cflags.
 104     if test "x$OPENJDK_TARGET_CPU" = xarm; then
 105         EXTRA_CFLAGS="$EXTRA_CFLAGS -Wno-psabi"
 106         EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -Wno-psabi"
 107     fi
 108     # Also add JDK_ARCH_ABI_PROP_NAME define, but only to CFLAGS.
 109     EXTRA_CFLAGS="$EXTRA_CFLAGS -DJDK_ARCH_ABI_PROP_NAME='\"\$(JDK_ARCH_ABI_PROP_NAME)\"'"
 110     # And pass the architecture flags to the linker as well
 111     EXTRA_LDFLAGS="$EXTRA_LDFLAGS $ARM_ARCH_TYPE_FLAGS $ARM_FLOAT_TYPE_FLAGS"
 112   fi
 113 
 114   # When building with an abi profile, the name of that profile is appended on the
 115   # bundle platform, which is used in bundle names.
 116   if test "x$OPENJDK_TARGET_ABI_PROFILE" != x; then
 117     OPENJDK_TARGET_BUNDLE_PLATFORM="$OPENJDK_TARGET_OS_BUNDLE-$OPENJDK_TARGET_ABI_PROFILE"
 118   fi
 119 ])
 120 
 121 # Reset the global CFLAGS/LDFLAGS variables and initialize them with the
 122 # corresponding configure arguments instead
 123 AC_DEFUN_ONCE([FLAGS_SETUP_USER_SUPPLIED_FLAGS],
 124 [
 125   if test "x$CFLAGS" != "x${ADDED_CFLAGS}"; then
 126     AC_MSG_WARN([Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags])
 127   fi
 128 
 129   if test "x$CXXFLAGS" != "x${ADDED_CXXFLAGS}"; then
 130     AC_MSG_WARN([Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags])
 131   fi
 132 
 133   if test "x$LDFLAGS" != "x${ADDED_LDFLAGS}"; then
 134     AC_MSG_WARN([Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags])
 135   fi
 136 
 137   AC_ARG_WITH(extra-cflags, [AS_HELP_STRING([--with-extra-cflags],
 138       [extra flags to be used when compiling jdk c-files])])
 139 
 140   AC_ARG_WITH(extra-cxxflags, [AS_HELP_STRING([--with-extra-cxxflags],
 141       [extra flags to be used when compiling jdk c++-files])])
 142 
 143   AC_ARG_WITH(extra-ldflags, [AS_HELP_STRING([--with-extra-ldflags],
 144       [extra flags to be used when linking jdk])])
 145 
 146   EXTRA_CFLAGS="$with_extra_cflags"
 147   EXTRA_CXXFLAGS="$with_extra_cxxflags"
 148   EXTRA_LDFLAGS="$with_extra_ldflags"
 149 
 150   AC_SUBST(EXTRA_CFLAGS)
 151   AC_SUBST(EXTRA_CXXFLAGS)
 152   AC_SUBST(EXTRA_LDFLAGS)
 153 
 154   # The global CFLAGS and LDLAGS variables are used by configure tests and
 155   # should include the extra parameters
 156   CFLAGS="$EXTRA_CFLAGS"
 157   CXXFLAGS="$EXTRA_CXXFLAGS"
 158   LDFLAGS="$EXTRA_LDFLAGS"
 159   CPPFLAGS=""
 160 ])
 161 
 162 # Setup the sysroot flags and add them to global CFLAGS and LDFLAGS so
 163 # that configure can use them while detecting compilers.
 164 # TOOLCHAIN_TYPE is available here.
 165 # Param 1 - Optional prefix to all variables. (e.g BUILD_)
 166 AC_DEFUN([FLAGS_SETUP_SYSROOT_FLAGS],
 167 [
 168   if test "x[$]$1SYSROOT" != "x"; then
 169     if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 170       if test "x$OPENJDK_TARGET_OS" = xsolaris; then
 171         # Solaris Studio does not have a concept of sysroot. Instead we must
 172         # make sure the default include and lib dirs are appended to each
 173         # compile and link command line. Must also add -I-xbuiltin to enable
 174         # inlining of system functions and intrinsics.
 175         $1SYSROOT_CFLAGS="-I-xbuiltin -I[$]$1SYSROOT/usr/include"
 176         $1SYSROOT_LDFLAGS="-L[$]$1SYSROOT/usr/lib$OPENJDK_TARGET_CPU_ISADIR \
 177             -L[$]$1SYSROOT/lib$OPENJDK_TARGET_CPU_ISADIR"
 178       fi
 179     elif test "x$TOOLCHAIN_TYPE" = xgcc; then
 180       $1SYSROOT_CFLAGS="--sysroot=[$]$1SYSROOT"
 181       $1SYSROOT_LDFLAGS="--sysroot=[$]$1SYSROOT"
 182     elif test "x$TOOLCHAIN_TYPE" = xclang; then
 183       $1SYSROOT_CFLAGS="-isysroot [$]$1SYSROOT"
 184       $1SYSROOT_LDFLAGS="-isysroot [$]$1SYSROOT"
 185     fi
 186     # The global CFLAGS and LDFLAGS variables need these for configure to function
 187     $1CFLAGS="[$]$1CFLAGS [$]$1SYSROOT_CFLAGS"
 188     $1CPPFLAGS="[$]$1CPPFLAGS [$]$1SYSROOT_CFLAGS"
 189     $1CXXFLAGS="[$]$1CXXFLAGS [$]$1SYSROOT_CFLAGS"
 190     $1LDFLAGS="[$]$1LDFLAGS [$]$1SYSROOT_LDFLAGS"
 191   fi
 192 
 193   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 194     # We also need -iframework<path>/System/Library/Frameworks
 195     $1SYSROOT_CFLAGS="[$]$1SYSROOT_CFLAGS -iframework [$]$1SYSROOT/System/Library/Frameworks"
 196     $1SYSROOT_LDFLAGS="[$]$1SYSROOT_LDFLAGS -iframework [$]$1SYSROOT/System/Library/Frameworks"
 197     # These always need to be set, or we can't find the frameworks embedded in JavaVM.framework
 198     # set this here so it doesn't have to be peppered throughout the forest
 199     $1SYSROOT_CFLAGS="[$]$1SYSROOT_CFLAGS -F [$]$1SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks"
 200     $1SYSROOT_LDFLAGS="[$]$1SYSROOT_LDFLAGS -F [$]$1SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks"
 201   fi
 202 
 203   AC_SUBST($1SYSROOT_CFLAGS)
 204   AC_SUBST($1SYSROOT_LDFLAGS)
 205 ])
 206 
 207 AC_DEFUN_ONCE([FLAGS_SETUP_INIT_FLAGS],
 208 [
 209   # COMPILER_TARGET_BITS_FLAG  : option for selecting 32- or 64-bit output
 210   # COMPILER_COMMAND_FILE_FLAG : option for passing a command file to the compiler
 211   # COMPILER_BINDCMD_FILE_FLAG : option for specifying a file which saves the binder
 212   #                              commands produced by the link step (currently AIX only)
 213   if test "x$TOOLCHAIN_TYPE" = xxlc; then
 214     COMPILER_TARGET_BITS_FLAG="-q"
 215     COMPILER_COMMAND_FILE_FLAG="-f"
 216     COMPILER_BINDCMD_FILE_FLAG="-bloadmap:"
 217   else
 218     COMPILER_TARGET_BITS_FLAG="-m"
 219     COMPILER_COMMAND_FILE_FLAG="@"
 220     COMPILER_BINDCMD_FILE_FLAG=""
 221 
 222     # The solstudio linker does not support @-files.
 223     if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 224       COMPILER_COMMAND_FILE_FLAG=
 225     fi
 226 
 227     # Check if @file is supported by gcc
 228     if test "x$TOOLCHAIN_TYPE" = xgcc; then
 229       AC_MSG_CHECKING([if @file is supported by gcc])
 230       # Extra emtpy "" to prevent ECHO from interpreting '--version' as argument
 231       $ECHO "" "--version" > command.file
 232       if $CXX @command.file 2>&AS_MESSAGE_LOG_FD >&AS_MESSAGE_LOG_FD; then
 233         AC_MSG_RESULT(yes)
 234         COMPILER_COMMAND_FILE_FLAG="@"
 235       else
 236         AC_MSG_RESULT(no)
 237         COMPILER_COMMAND_FILE_FLAG=
 238       fi
 239       $RM command.file
 240     fi
 241   fi
 242   AC_SUBST(COMPILER_TARGET_BITS_FLAG)
 243   AC_SUBST(COMPILER_COMMAND_FILE_FLAG)
 244   AC_SUBST(COMPILER_BINDCMD_FILE_FLAG)
 245 
 246   # FIXME: figure out if we should select AR flags depending on OS or toolchain.
 247   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 248     ARFLAGS="-r"
 249   elif test "x$OPENJDK_TARGET_OS" = xaix; then
 250     ARFLAGS="-X64"
 251   elif test "x$OPENJDK_TARGET_OS" = xwindows; then
 252     # lib.exe is used as AR to create static libraries.
 253     ARFLAGS="-nologo -NODEFAULTLIB:MSVCRT"
 254   else
 255     ARFLAGS=""
 256   fi
 257   AC_SUBST(ARFLAGS)
 258 
 259   ## Setup strip.
 260   # FIXME: should this really be per platform, or should it be per toolchain type?
 261   # strip is not provided by clang or solstudio; so guessing platform makes most sense.
 262   # FIXME: we should really only export STRIPFLAGS from here, not POST_STRIP_CMD.
 263   if test "x$OPENJDK_TARGET_OS" = xlinux; then
 264     STRIPFLAGS="-g"
 265   elif test "x$OPENJDK_TARGET_OS" = xsolaris; then
 266     STRIPFLAGS="-x"
 267   elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
 268     STRIPFLAGS="-S"
 269   elif test "x$OPENJDK_TARGET_OS" = xaix; then
 270     STRIPFLAGS="-X32_64"
 271   fi
 272 
 273   AC_SUBST(STRIPFLAGS)
 274 
 275   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 276     CC_OUT_OPTION=-Fo
 277     EXE_OUT_OPTION=-out:
 278     LD_OUT_OPTION=-out:
 279     AR_OUT_OPTION=-out:
 280   else
 281     # The option used to specify the target .o,.a or .so file.
 282     # When compiling, how to specify the to be created object file.
 283     CC_OUT_OPTION='-o$(SPACE)'
 284     # When linking, how to specify the to be created executable.
 285     EXE_OUT_OPTION='-o$(SPACE)'
 286     # When linking, how to specify the to be created dynamically linkable library.
 287     LD_OUT_OPTION='-o$(SPACE)'
 288     # When archiving, how to specify the to be create static archive for object files.
 289     AR_OUT_OPTION='rcs$(SPACE)'
 290   fi
 291   AC_SUBST(CC_OUT_OPTION)
 292   AC_SUBST(EXE_OUT_OPTION)
 293   AC_SUBST(LD_OUT_OPTION)
 294   AC_SUBST(AR_OUT_OPTION)
 295 
 296   # On Windows, we need to set RC flags.
 297   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 298     RC_FLAGS="-nologo -l0x409"
 299     JVM_RCFLAGS="-nologo"
 300     if test "x$DEBUG_LEVEL" = xrelease; then
 301       RC_FLAGS="$RC_FLAGS -DNDEBUG"
 302       JVM_RCFLAGS="$JVM_RCFLAGS -DNDEBUG"
 303     fi
 304 
 305     # The version variables used to create RC_FLAGS may be overridden
 306     # in a custom configure script, or possibly the command line.
 307     # Let those variables be expanded at make time in spec.gmk.
 308     # The \$ are escaped to the shell, and the $(...) variables
 309     # are evaluated by make.
 310     RC_FLAGS="$RC_FLAGS \
 311         -D\"JDK_VERSION_STRING=\$(VERSION_STRING)\" \
 312         -D\"JDK_COMPANY=\$(COMPANY_NAME)\" \
 313         -D\"JDK_COMPONENT=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) binary\" \
 314         -D\"JDK_VER=\$(VERSION_NUMBER)\" \
 315         -D\"JDK_COPYRIGHT=Copyright \xA9 $COPYRIGHT_YEAR\" \
 316         -D\"JDK_NAME=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) \$(VERSION_FEATURE)\" \
 317         -D\"JDK_FVER=\$(subst .,\$(COMMA),\$(VERSION_NUMBER_FOUR_POSITIONS))\""
 318 
 319     JVM_RCFLAGS="$JVM_RCFLAGS \
 320         -D\"HS_BUILD_ID=\$(VERSION_STRING)\" \
 321         -D\"HS_COMPANY=\$(COMPANY_NAME)\" \
 322         -D\"JDK_DOTVER=\$(VERSION_NUMBER_FOUR_POSITIONS)\" \
 323         -D\"HS_COPYRIGHT=Copyright $COPYRIGHT_YEAR\" \
 324         -D\"HS_NAME=\$(PRODUCT_NAME) \$(VERSION_SHORT)\" \
 325         -D\"JDK_VER=\$(subst .,\$(COMMA),\$(VERSION_NUMBER_FOUR_POSITIONS))\" \
 326         -D\"HS_FNAME=jvm.dll\" \
 327         -D\"HS_INTERNAL_NAME=jvm\""
 328   fi
 329   AC_SUBST(RC_FLAGS)
 330   AC_SUBST(JVM_RCFLAGS)
 331 
 332   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 333     # silence copyright notice and other headers.
 334     COMMON_CCXXFLAGS="$COMMON_CCXXFLAGS -nologo"
 335   fi
 336 ])
 337 
 338 AC_DEFUN([FLAGS_SETUP_COMPILER_FLAGS_FOR_LIBS],
 339 [
 340   ###############################################################################
 341   #
 342   # How to compile shared libraries.
 343   #
 344 
 345   if test "x$TOOLCHAIN_TYPE" = xgcc; then
 346     PICFLAG="-fPIC"
 347     C_FLAG_REORDER=''
 348     CXX_FLAG_REORDER=''
 349 
 350     if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 351       # Linking is different on MacOSX
 352       if test "x$STATIC_BUILD" = xtrue; then
 353         SHARED_LIBRARY_FLAGS ='-undefined dynamic_lookup'
 354       else
 355         SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG"
 356         JVM_CFLAGS="$JVM_CFLAGS $PICFLAG"
 357       fi
 358       SET_EXECUTABLE_ORIGIN='-Wl,-rpath,@loader_path$(or [$]1,/.)'
 359       SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN"
 360       SET_SHARED_LIBRARY_NAME='-Wl,-install_name,@rpath/[$]1'
 361       SET_SHARED_LIBRARY_MAPFILE='-Wl,-exported_symbols_list,[$]1'
 362     else
 363       # Default works for linux, might work on other platforms as well.
 364       SHARED_LIBRARY_FLAGS='-shared'
 365       SET_EXECUTABLE_ORIGIN='-Wl,-rpath,\$$ORIGIN[$]1'
 366       SET_SHARED_LIBRARY_ORIGIN="-Wl,-z,origin $SET_EXECUTABLE_ORIGIN"
 367       SET_SHARED_LIBRARY_NAME='-Wl,-soname=[$]1'
 368       SET_SHARED_LIBRARY_MAPFILE='-Wl,-version-script=[$]1'
 369     fi
 370   elif test "x$TOOLCHAIN_TYPE" = xclang; then
 371     C_FLAG_REORDER=''
 372     CXX_FLAG_REORDER=''
 373 
 374     if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 375       # Linking is different on MacOSX
 376       PICFLAG=''
 377       SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG"
 378       SET_EXECUTABLE_ORIGIN='-Wl,-rpath,@loader_path$(or [$]1,/.)'
 379       SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN"
 380       SET_SHARED_LIBRARY_NAME='-Wl,-install_name,@rpath/[$]1'
 381       SET_SHARED_LIBRARY_MAPFILE='-Wl,-exported_symbols_list,[$]1'
 382 
 383       if test "x$STATIC_BUILD" = xfalse; then
 384         JVM_CFLAGS="$JVM_CFLAGS -fPIC"
 385       fi
 386     else
 387       # Default works for linux, might work on other platforms as well.
 388       PICFLAG='-fPIC'
 389       SHARED_LIBRARY_FLAGS='-shared'
 390       SET_EXECUTABLE_ORIGIN='-Wl,-rpath,\$$ORIGIN[$]1'
 391       SET_SHARED_LIBRARY_NAME='-Wl,-soname=[$]1'
 392       SET_SHARED_LIBRARY_MAPFILE='-Wl,-version-script=[$]1'
 393 
 394       # arm specific settings
 395       if test "x$OPENJDK_TARGET_CPU" = "xarm"; then
 396         # '-Wl,-z,origin' isn't used on arm.
 397         SET_SHARED_LIBRARY_ORIGIN='-Wl,-rpath,\$$$$ORIGIN[$]1'
 398       else
 399         SET_SHARED_LIBRARY_ORIGIN="-Wl,-z,origin $SET_EXECUTABLE_ORIGIN"
 400       fi
 401 
 402     fi
 403   elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 404     if test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
 405       PICFLAG="-xcode=pic32"
 406     else
 407       PICFLAG="-KPIC"
 408     fi
 409     C_FLAG_REORDER='-xF'
 410     CXX_FLAG_REORDER='-xF'
 411     SHARED_LIBRARY_FLAGS="-G"
 412     SET_EXECUTABLE_ORIGIN='-R\$$ORIGIN[$]1'
 413     SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN"
 414     SET_SHARED_LIBRARY_NAME='-h [$]1'
 415     SET_SHARED_LIBRARY_MAPFILE='-M[$]1'
 416   elif test "x$TOOLCHAIN_TYPE" = xxlc; then
 417     # '-qpic' defaults to 'qpic=small'. This means that the compiler generates only
 418     # one instruction for accessing the TOC. If the TOC grows larger than 64K, the linker
 419     # will have to patch this single instruction with a call to some out-of-order code which
 420     # does the load from the TOC. This is of course slow. But in that case we also would have
 421     # to use '-bbigtoc' for linking anyway so we could also change the PICFLAG to 'qpic=large'.
 422     # With 'qpic=large' the compiler will by default generate a two-instruction sequence which
 423     # can be patched directly by the linker and does not require a jump to out-of-order code.
 424     # Another alternative instead of using 'qpic=large -bbigtoc' may be to use '-qminimaltoc'
 425     # instead. This creates a distinct TOC for every compilation unit (and thus requires two
 426     # loads for accessing a global variable). But there are rumors that this may be seen as a
 427     # 'performance feature' because of improved code locality of the symbols used in a
 428     # compilation unit.
 429     PICFLAG="-qpic"
 430     JVM_CFLAGS="$JVM_CFLAGS $PICFLAG"
 431     C_FLAG_REORDER=''
 432     CXX_FLAG_REORDER=''
 433     SHARED_LIBRARY_FLAGS="-qmkshrobj -bM:SRE -bnoentry"
 434     SET_EXECUTABLE_ORIGIN=""
 435     SET_SHARED_LIBRARY_ORIGIN=''
 436     SET_SHARED_LIBRARY_NAME=''
 437     SET_SHARED_LIBRARY_MAPFILE=''
 438   elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 439     PICFLAG=""
 440     C_FLAG_REORDER=''
 441     CXX_FLAG_REORDER=''
 442     SHARED_LIBRARY_FLAGS="-dll"
 443     SET_EXECUTABLE_ORIGIN=''
 444     SET_SHARED_LIBRARY_ORIGIN=''
 445     SET_SHARED_LIBRARY_NAME=''
 446     SET_SHARED_LIBRARY_MAPFILE='-def:[$]1'
 447   fi
 448 
 449   AC_SUBST(C_FLAG_REORDER)
 450   AC_SUBST(CXX_FLAG_REORDER)
 451   AC_SUBST(SET_EXECUTABLE_ORIGIN)
 452   AC_SUBST(SET_SHARED_LIBRARY_ORIGIN)
 453   AC_SUBST(SET_SHARED_LIBRARY_NAME)
 454   AC_SUBST(SET_SHARED_LIBRARY_MAPFILE)
 455   AC_SUBST(SHARED_LIBRARY_FLAGS)
 456 
 457   # The (cross) compiler is now configured, we can now test capabilities
 458   # of the target platform.
 459 ])
 460 
 461 # Documentation on common flags used for solstudio in HIGHEST.
 462 #
 463 # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
 464 #          done with care, there are some assumptions below that need to
 465 #          be understood about the use of pointers, and IEEE behavior.
 466 #
 467 # -fns: Use non-standard floating point mode (not IEEE 754)
 468 # -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
 469 # -fsingle: Use single precision floating point with 'float'
 470 # -xalias_level=basic: Assume memory references via basic pointer types do not alias
 471 #   (Source with excessing pointer casting and data access with mixed
 472 #    pointer types are not recommended)
 473 # -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
 474 #   (If you expect perfect errno behavior, do not use this)
 475 # -xdepend: Loop data dependency optimizations (need -xO3 or higher)
 476 # -xrestrict: Pointer parameters to functions do not overlap
 477 #   (Similar to -xalias_level=basic usage, but less obvious sometimes.
 478 #    If you pass in multiple pointers to the same data, do not use this)
 479 # -xlibmil: Inline some library routines
 480 #   (If you expect perfect errno behavior, do not use this)
 481 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
 482 #   (If you expect perfect errno behavior, do not use this)
 483 #  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
 484 
 485     # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
 486     # Bug?
 487     #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
 488     #  CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
 489     #  CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
 490     #fi
 491 
 492 AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
 493 [
 494 
 495   ###############################################################################
 496   #
 497   # Setup the opt flags for different compilers
 498   # and different operating systems.
 499   #
 500 
 501   # FIXME: this was indirectly the old default, but just inherited.
 502   # if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 503   #   C_FLAG_DEPS="-MMD -MF"
 504   # fi
 505 
 506   # Generate make dependency files
 507   if test "x$TOOLCHAIN_TYPE" = xgcc; then
 508     C_FLAG_DEPS="-MMD -MF"
 509   elif test "x$TOOLCHAIN_TYPE" = xclang; then
 510     C_FLAG_DEPS="-MMD -MF"
 511   elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 512     C_FLAG_DEPS="-xMMD -xMF"
 513   elif test "x$TOOLCHAIN_TYPE" = xxlc; then
 514     C_FLAG_DEPS="-qmakedep=gcc -MF"
 515   fi
 516   CXX_FLAG_DEPS="$C_FLAG_DEPS"
 517   AC_SUBST(C_FLAG_DEPS)
 518   AC_SUBST(CXX_FLAG_DEPS)
 519 
 520   # Debug symbols
 521   if test "x$TOOLCHAIN_TYPE" = xgcc; then
 522     if test "x$OPENJDK_TARGET_CPU_BITS" = "x64" && test "x$DEBUG_LEVEL" = "xfastdebug"; then
 523       # reduce from default "-g2" option to save space
 524       CFLAGS_DEBUG_SYMBOLS="-g1"
 525       CXXFLAGS_DEBUG_SYMBOLS="-g1"
 526     else
 527       CFLAGS_DEBUG_SYMBOLS="-g"
 528       CXXFLAGS_DEBUG_SYMBOLS="-g"
 529     fi
 530   elif test "x$TOOLCHAIN_TYPE" = xclang; then
 531     CFLAGS_DEBUG_SYMBOLS="-g"
 532     CXXFLAGS_DEBUG_SYMBOLS="-g"
 533   elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 534     CFLAGS_DEBUG_SYMBOLS="-g -xs"
 535     # -g0 enables debug symbols without disabling inlining.
 536     CXXFLAGS_DEBUG_SYMBOLS="-g0 -xs"
 537   elif test "x$TOOLCHAIN_TYPE" = xxlc; then
 538     CFLAGS_DEBUG_SYMBOLS="-g"
 539     CXXFLAGS_DEBUG_SYMBOLS="-g"
 540   elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 541     CFLAGS_DEBUG_SYMBOLS="-Zi"
 542     CXXFLAGS_DEBUG_SYMBOLS="-Zi"
 543   fi
 544   AC_SUBST(CFLAGS_DEBUG_SYMBOLS)
 545   AC_SUBST(CXXFLAGS_DEBUG_SYMBOLS)
 546 
 547   # Debug symbols for JVM_CFLAGS
 548   if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 549     JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -xs"
 550     if test "x$DEBUG_LEVEL" = xslowdebug; then
 551       JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -g"
 552     else
 553       # -g0 does not disable inlining, which -g does.
 554       JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -g0"
 555     fi
 556   elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 557     JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -Z7 -d2Zi+"
 558   else
 559     JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -g"
 560   fi
 561   AC_SUBST(JVM_CFLAGS_SYMBOLS)
 562 
 563   # bounds, memory and behavior checking options
 564   if test "x$TOOLCHAIN_TYPE" = xgcc; then
 565     case $DEBUG_LEVEL in
 566     release )
 567       # no adjustment
 568       ;;
 569     fastdebug )
 570       # no adjustment
 571       ;;
 572     slowdebug )
 573       # FIXME: By adding this to C(XX)FLAGS_DEBUG_OPTIONS/JVM_CFLAGS_SYMBOLS it
 574       # get's added conditionally on whether we produce debug symbols or not.
 575       # This is most likely not really correct.
 576 
 577       # Add runtime stack smashing and undefined behavior checks.
 578       # Not all versions of gcc support -fstack-protector
 579       STACK_PROTECTOR_CFLAG="-fstack-protector-all"
 580       FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [$STACK_PROTECTOR_CFLAG -Werror], IF_FALSE: [STACK_PROTECTOR_CFLAG=""])
 581 
 582       CFLAGS_DEBUG_OPTIONS="$STACK_PROTECTOR_CFLAG --param ssp-buffer-size=1"
 583       CXXFLAGS_DEBUG_OPTIONS="$STACK_PROTECTOR_CFLAG --param ssp-buffer-size=1"
 584       if test "x$STACK_PROTECTOR_CFLAG" != x; then
 585         JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS $STACK_PROTECTOR_CFLAG --param ssp-buffer-size=1"
 586       fi
 587       ;;
 588     esac
 589   fi
 590 
 591   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 592     if test "x$DEBUG_LEVEL" != xrelease; then
 593       if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
 594         JVM_CFLAGS="$JVM_CFLAGS -homeparams"
 595       fi
 596     fi
 597   fi
 598 
 599   # Optimization levels
 600   if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 601     CC_HIGHEST="$CC_HIGHEST -fns -fsimple -fsingle -xbuiltin=%all -xdepend -xrestrict -xlibmil"
 602 
 603     if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
 604       # FIXME: seems we always set -xregs=no%frameptr; put it elsewhere more global?
 605       C_O_FLAG_HIGHEST_JVM="-xO4"
 606       C_O_FLAG_HIGHEST="-xO4 -Wu,-O4~yz $CC_HIGHEST -xalias_level=basic -xregs=no%frameptr"
 607       C_O_FLAG_HI="-xO4 -Wu,-O4~yz -xregs=no%frameptr"
 608       C_O_FLAG_NORM="-xO2 -Wu,-O2~yz -xregs=no%frameptr"
 609       C_O_FLAG_DEBUG="-xregs=no%frameptr"
 610       C_O_FLAG_DEBUG_JVM=""
 611       C_O_FLAG_NONE="-xregs=no%frameptr"
 612       CXX_O_FLAG_HIGHEST_JVM="-xO4"
 613       CXX_O_FLAG_HIGHEST="-xO4 -Qoption ube -O4~yz $CC_HIGHEST -xregs=no%frameptr"
 614       CXX_O_FLAG_HI="-xO4 -Qoption ube -O4~yz -xregs=no%frameptr"
 615       CXX_O_FLAG_NORM="-xO2 -Qoption ube -O2~yz -xregs=no%frameptr"
 616       CXX_O_FLAG_DEBUG="-xregs=no%frameptr"
 617       CXX_O_FLAG_DEBUG_JVM=""
 618       CXX_O_FLAG_NONE="-xregs=no%frameptr"
 619       if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then
 620         C_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST -xchip=pentium"
 621         CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HIGHEST -xchip=pentium"
 622       fi
 623     elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
 624       C_O_FLAG_HIGHEST_JVM="-xO4"
 625       C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xalias_level=basic -xprefetch=auto,explicit -xchip=ultra"
 626       C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0"
 627       C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0"
 628       C_O_FLAG_DEBUG=""
 629       C_O_FLAG_DEBUG_JVM=""
 630       C_O_FLAG_NONE=""
 631       CXX_O_FLAG_HIGHEST_JVM="-xO4"
 632       CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra"
 633       CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
 634       CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
 635       CXX_O_FLAG_DEBUG=""
 636       CXX_O_FLAG_DEBUG_JVM=""
 637       CXX_O_FLAG_NONE=""
 638     fi
 639   else
 640     # The remaining toolchains share opt flags between CC and CXX;
 641     # setup for C and duplicate afterwards.
 642     if test "x$TOOLCHAIN_TYPE" = xgcc; then
 643       if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 644         # On MacOSX we optimize for size, something
 645         # we should do for all platforms?
 646         C_O_FLAG_HIGHEST_JVM="-Os"
 647         C_O_FLAG_HIGHEST="-Os"
 648         C_O_FLAG_HI="-Os"
 649         C_O_FLAG_NORM="-Os"
 650         C_O_FLAG_SIZE="-Os"
 651       else
 652         C_O_FLAG_HIGHEST_JVM="-O3"
 653         C_O_FLAG_HIGHEST="-O3"
 654         C_O_FLAG_HI="-O3"
 655         C_O_FLAG_NORM="-O2"
 656         C_O_FLAG_SIZE="-Os"
 657       fi
 658       C_O_FLAG_DEBUG="-O0"
 659       if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 660         C_O_FLAG_DEBUG_JVM=""
 661       elif test "x$OPENJDK_TARGET_OS" = xlinux; then
 662         C_O_FLAG_DEBUG_JVM="-O0"
 663       fi
 664       C_O_FLAG_NONE="-O0"
 665     elif test "x$TOOLCHAIN_TYPE" = xclang; then
 666       if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 667         # On MacOSX we optimize for size, something
 668         # we should do for all platforms?
 669         C_O_FLAG_HIGHEST_JVM="-Os"
 670         C_O_FLAG_HIGHEST="-Os"
 671         C_O_FLAG_HI="-Os"
 672         C_O_FLAG_NORM="-Os"
 673         C_O_FLAG_SIZE="-Os"
 674       else
 675         C_O_FLAG_HIGHEST_JVM="-O3"
 676         C_O_FLAG_HIGHEST="-O3"
 677         C_O_FLAG_HI="-O3"
 678         C_O_FLAG_NORM="-O2"
 679         C_O_FLAG_SIZE="-Os"
 680       fi
 681       C_O_FLAG_DEBUG="-O0"
 682       if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 683         C_O_FLAG_DEBUG_JVM=""
 684       elif test "x$OPENJDK_TARGET_OS" = xlinux; then
 685         C_O_FLAG_DEBUG_JVM="-O0"
 686       fi
 687       C_O_FLAG_NONE="-O0"
 688     elif test "x$TOOLCHAIN_TYPE" = xxlc; then
 689       C_O_FLAG_HIGHEST_JVM="-O3 -qhot=level=1 -qinline -qinlglue"
 690       C_O_FLAG_HIGHEST="-O3 -qhot=level=1 -qinline -qinlglue"
 691       C_O_FLAG_HI="-O3 -qinline -qinlglue"
 692       C_O_FLAG_NORM="-O2"
 693       C_O_FLAG_DEBUG="-qnoopt"
 694       # FIXME: Value below not verified.
 695       C_O_FLAG_DEBUG_JVM=""
 696       C_O_FLAG_NONE="-qnoopt"
 697     elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 698       C_O_FLAG_HIGHEST_JVM="-O2 -Oy-"
 699       C_O_FLAG_HIGHEST="-O2"
 700       C_O_FLAG_HI="-O1"
 701       C_O_FLAG_NORM="-O1"
 702       C_O_FLAG_DEBUG="-Od"
 703       C_O_FLAG_DEBUG_JVM=""
 704       C_O_FLAG_NONE="-Od"
 705       C_O_FLAG_SIZE="-Os"
 706     fi
 707     CXX_O_FLAG_HIGHEST_JVM="$C_O_FLAG_HIGHEST_JVM"
 708     CXX_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST"
 709     CXX_O_FLAG_HI="$C_O_FLAG_HI"
 710     CXX_O_FLAG_NORM="$C_O_FLAG_NORM"
 711     CXX_O_FLAG_DEBUG="$C_O_FLAG_DEBUG"
 712     CXX_O_FLAG_DEBUG_JVM="$C_O_FLAG_DEBUG_JVM"
 713     CXX_O_FLAG_NONE="$C_O_FLAG_NONE"
 714     CXX_O_FLAG_SIZE="$C_O_FLAG_SIZE"
 715   fi
 716 
 717   # Adjust optimization flags according to debug level.
 718   case $DEBUG_LEVEL in
 719     release )
 720       # no adjustment
 721       ;;
 722     fastdebug )
 723       # Not quite so much optimization
 724       C_O_FLAG_HI="$C_O_FLAG_NORM"
 725       CXX_O_FLAG_HI="$CXX_O_FLAG_NORM"
 726       ;;
 727     slowdebug )
 728       # Disable optimization
 729       C_O_FLAG_HIGHEST_JVM="$C_O_FLAG_DEBUG_JVM"
 730       C_O_FLAG_HIGHEST="$C_O_FLAG_DEBUG"
 731       C_O_FLAG_HI="$C_O_FLAG_DEBUG"
 732       C_O_FLAG_NORM="$C_O_FLAG_DEBUG"
 733       C_O_FLAG_SIZE="$C_O_FLAG_DEBUG"
 734       CXX_O_FLAG_HIGHEST_JVM="$CXX_O_FLAG_DEBUG_JVM"
 735       CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_DEBUG"
 736       CXX_O_FLAG_HI="$CXX_O_FLAG_DEBUG"
 737       CXX_O_FLAG_NORM="$CXX_O_FLAG_DEBUG"
 738       CXX_O_FLAG_SIZE="$CXX_O_FLAG_DEBUG"
 739       ;;
 740   esac
 741 
 742   AC_SUBST(C_O_FLAG_HIGHEST_JVM)
 743   AC_SUBST(C_O_FLAG_HIGHEST)
 744   AC_SUBST(C_O_FLAG_HI)
 745   AC_SUBST(C_O_FLAG_NORM)
 746   AC_SUBST(C_O_FLAG_DEBUG)
 747   AC_SUBST(C_O_FLAG_NONE)
 748   AC_SUBST(C_O_FLAG_SIZE)
 749   AC_SUBST(CXX_O_FLAG_HIGHEST_JVM)
 750   AC_SUBST(CXX_O_FLAG_HIGHEST)
 751   AC_SUBST(CXX_O_FLAG_HI)
 752   AC_SUBST(CXX_O_FLAG_NORM)
 753   AC_SUBST(CXX_O_FLAG_DEBUG)
 754   AC_SUBST(CXX_O_FLAG_NONE)
 755   AC_SUBST(CXX_O_FLAG_SIZE)
 756 ])
 757 
 758 
 759 AC_DEFUN([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
 760 [
 761 
 762   FLAGS_SETUP_ABI_PROFILE
 763 
 764   # Optional POSIX functionality needed by the JVM
 765   #
 766   # Check if clock_gettime is available and in which library. This indicates
 767   # availability of CLOCK_MONOTONIC for hotspot. But we don't need to link, so
 768   # don't let it update LIBS.
 769   save_LIBS="$LIBS"
 770   AC_SEARCH_LIBS(clock_gettime, rt, [HAS_CLOCK_GETTIME=true], [])
 771   if test "x$LIBS" = "x-lrt "; then
 772     CLOCK_GETTIME_IN_LIBRT=true
 773   fi
 774   LIBS="$save_LIBS"
 775 
 776   FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_HELPER([TARGET])
 777   FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_HELPER([BUILD], [OPENJDK_BUILD_])
 778 
 779   # Tests are only ever compiled for TARGET
 780   # Flags for compiling test libraries
 781   CFLAGS_TESTLIB="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
 782   CXXFLAGS_TESTLIB="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA"
 783 
 784   # Flags for compiling test executables
 785   CFLAGS_TESTEXE="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK"
 786   CXXFLAGS_TESTEXE="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK"
 787 
 788   AC_SUBST(CFLAGS_TESTLIB)
 789   AC_SUBST(CFLAGS_TESTEXE)
 790   AC_SUBST(CXXFLAGS_TESTLIB)
 791   AC_SUBST(CXXFLAGS_TESTEXE)
 792 
 793   LDFLAGS_TESTLIB="$LDFLAGS_JDKLIB"
 794   LDFLAGS_TESTEXE="$LDFLAGS_JDKEXE $JAVA_BASE_LDFLAGS"
 795 
 796   AC_SUBST(LDFLAGS_TESTLIB)
 797   AC_SUBST(LDFLAGS_TESTEXE)
 798 
 799 ])
 800 
 801 ################################################################################
 802 # $1 - Either BUILD or TARGET to pick the correct OS/CPU variables to check
 803 #      conditionals against.
 804 # $2 - Optional prefix for each variable defined.
 805 AC_DEFUN([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_HELPER],
 806 [
 807   # Special extras...
 808   if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 809     if test "x$OPENJDK_$1_CPU_ARCH" = "xsparc"; then
 810       $2CFLAGS_JDKLIB_EXTRA="${$2CFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
 811       $2CXXFLAGS_JDKLIB_EXTRA="${$2CXXFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
 812     fi
 813     $2CFLAGS_JDKLIB_EXTRA="${$2CFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt"
 814     $2CXXFLAGS_JDKLIB_EXTRA="${$2CXXFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt"
 815   elif test "x$TOOLCHAIN_TYPE" = xxlc; then
 816     $2CFLAGS_JDK="${$2CFLAGS_JDK} -qchars=signed -qfullpath -qsaveopt"
 817     $2CXXFLAGS_JDK="${$2CXXFLAGS_JDK} -qchars=signed -qfullpath -qsaveopt"
 818   elif test "x$TOOLCHAIN_TYPE" = xgcc; then
 819     $2CXXSTD_CXXFLAG="-std=gnu++98"
 820     FLAGS_CXX_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [[$]$2CXXSTD_CXXFLAG -Werror],
 821                                                  IF_FALSE: [$2CXXSTD_CXXFLAG=""])
 822     $2CXXFLAGS_JDK="${$2CXXFLAGS_JDK} ${$2CXXSTD_CXXFLAG}"
 823     $2JVM_CFLAGS="${$2JVM_CFLAGS} ${$2CXXSTD_CXXFLAG}"
 824     AC_SUBST($2CXXSTD_CXXFLAG)
 825   fi
 826   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
 827     $2CFLAGS_JDK="${$2CFLAGS_JDK} -D__solaris__"
 828     $2CXXFLAGS_JDK="${$2CXXFLAGS_JDK} -D__solaris__"
 829   fi
 830 
 831   $2CFLAGS_JDK="${$2CFLAGS_JDK} ${$2EXTRA_CFLAGS}"
 832   $2CXXFLAGS_JDK="${$2CXXFLAGS_JDK} ${$2EXTRA_CXXFLAGS}"
 833   $2LDFLAGS_JDK="${$2LDFLAGS_JDK} ${$2EXTRA_LDFLAGS}"
 834 
 835   ###############################################################################
 836   #
 837   # Now setup the CFLAGS and LDFLAGS for the JDK build.
 838   # Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build.
 839   #
 840 
 841   # Setup compiler/platform specific flags into
 842   #    $2CFLAGS_JDK    - C Compiler flags
 843   #    $2CXXFLAGS_JDK  - C++ Compiler flags
 844   #    $2COMMON_CCXXFLAGS_JDK - common to C and C++
 845   if test "x$TOOLCHAIN_TYPE" = xgcc; then
 846     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_GNU_SOURCE"
 847     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_REENTRANT"
 848     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -fcheck-new"
 849     if test "x$OPENJDK_$1_CPU" = xx86; then
 850       # Force compatibility with i586 on 32 bit intel platforms.
 851       $2COMMON_CCXXFLAGS="${$2COMMON_CCXXFLAGS} -march=i586"
 852       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -march=i586"
 853     fi
 854     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS [$]$2COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
 855         -pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
 856     case $OPENJDK_$1_CPU_ARCH in
 857       arm )
 858         # on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing
 859         $2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"
 860         $2COMMON_CCXXFLAGS_JDK="${$2COMMON_CCXXFLAGS_JDK} -fsigned-char"
 861         ;;
 862       ppc )
 863         # on ppc we don't prevent gcc to omit frame pointer but do prevent strict aliasing
 864         $2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"
 865         ;;
 866       s390 )
 867         $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer -mbackchain -march=z10"
 868         $2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"
 869         ;;
 870       * )
 871         $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
 872         $2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"
 873         ;;
 874     esac
 875     TOOLCHAIN_CHECK_COMPILER_VERSION(VERSION: 6, PREFIX: $2, IF_AT_LEAST: FLAGS_SETUP_GCC6_COMPILER_FLAGS($2))
 876   elif test "x$TOOLCHAIN_TYPE" = xclang; then
 877     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_GNU_SOURCE"
 878 
 879     # Restrict the debug information created by Clang to avoid
 880     # too big object files and speed the build up a little bit
 881     # (see http://llvm.org/bugs/show_bug.cgi?id=7554)
 882     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -flimit-debug-info"
 883     if test "x$OPENJDK_$1_OS" = xlinux; then
 884       if test "x$OPENJDK_$1_CPU" = xx86; then
 885         # Force compatibility with i586 on 32 bit intel platforms.
 886         $2COMMON_CCXXFLAGS="${$2COMMON_CCXXFLAGS} -march=i586"
 887         $2JVM_CFLAGS="[$]$2JVM_CFLAGS -march=i586"
 888       fi
 889       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -Wno-sometimes-uninitialized"
 890       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS [$]$2COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
 891           -pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
 892       case $OPENJDK_$1_CPU_ARCH in
 893         ppc )
 894           # on ppc we don't prevent gcc to omit frame pointer but do prevent strict aliasing
 895           $2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"
 896           ;;
 897         * )
 898           $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
 899           $2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"
 900           ;;
 901       esac
 902     fi
 903   elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 904     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DSPARC_WORKS"
 905     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS [$]$2COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
 906     if test "x$OPENJDK_$1_CPU_ARCH" = xx86; then
 907       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_$1_CPU_LEGACY_LIB"
 908     fi
 909 
 910     $2CFLAGS_JDK="[$]$2CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
 911     $2CXXFLAGS_JDK="[$]$2CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
 912   elif test "x$TOOLCHAIN_TYPE" = xxlc; then
 913     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_REENTRANT"
 914     $2CFLAGS_JDK="[$]$2CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
 915     $2CXXFLAGS_JDK="[$]$2CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
 916   elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 917     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS [$]$2COMMON_CCXXFLAGS_JDK \
 918         -MD -Zc:wchar_t- -W3 -wd4800 \
 919         -DWIN32_LEAN_AND_MEAN \
 920         -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
 921         -D_WINSOCK_DEPRECATED_NO_WARNINGS \
 922         -DWIN32 -DIAL"
 923     if test "x$OPENJDK_$1_CPU" = xx86_64; then
 924       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_AMD64_ -Damd64"
 925     else
 926       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_X86_ -Dx86"
 927     fi
 928     # If building with Visual Studio 2010, we can still use _STATIC_CPPLIB to
 929     # avoid bundling msvcpNNN.dll. Doesn't work with newer versions of visual
 930     # studio.
 931     if test "x$TOOLCHAIN_VERSION" = "x2010"; then
 932       STATIC_CPPLIB_FLAGS="-D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB"
 933       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK $STATIC_CPPLIB_FLAGS"
 934       $2JVM_CFLAGS="[$]$2JVM_CFLAGS $STATIC_CPPLIB_FLAGS"
 935     fi
 936   fi
 937 
 938   ###############################################################################
 939 
 940   # Adjust flags according to debug level.
 941   case $DEBUG_LEVEL in
 942     fastdebug | slowdebug )
 943       $2CFLAGS_JDK="[$]$2CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS $CFLAGS_DEBUG_OPTIONS"
 944       $2CXXFLAGS_JDK="[$]$2CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS $CXXFLAGS_DEBUG_OPTIONS"
 945       ;;
 946     release )
 947       ;;
 948     * )
 949       AC_MSG_ERROR([Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL])
 950       ;;
 951   esac
 952 
 953   # Set some common defines. These works for all compilers, but assume
 954   # -D is universally accepted.
 955 
 956   # Setup endianness
 957   if test "x$OPENJDK_$1_CPU_ENDIAN" = xlittle; then
 958     # The macro _LITTLE_ENDIAN needs to be defined the same to avoid the
 959     #   Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN
 960     #   (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h).
 961     #   Note: -Dmacro         is the same as    #define macro 1
 962     #         -Dmacro=        is the same as    #define macro
 963     if test "x$OPENJDK_$1_OS" = xsolaris; then
 964       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
 965     else
 966       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
 967     fi
 968   else
 969     # Same goes for _BIG_ENDIAN. Do we really need to set *ENDIAN on Solaris if they
 970     # are defined in the system?
 971     if test "x$OPENJDK_$1_OS" = xsolaris; then
 972       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN="
 973     else
 974       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN"
 975     fi
 976   fi
 977 
 978   # Always enable optional macros for VM.
 979   $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D__STDC_FORMAT_MACROS"
 980   $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D__STDC_LIMIT_MACROS"
 981   $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D__STDC_CONSTANT_MACROS"
 982 
 983   # Setup target OS define. Use OS target name but in upper case.
 984   OPENJDK_$1_OS_UPPERCASE=`$ECHO $OPENJDK_$1_OS | $TR 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
 985   $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D$OPENJDK_$1_OS_UPPERCASE"
 986 
 987   # Setup target CPU
 988   $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK \
 989       $OPENJDK_$1_ADD_LP64 \
 990       -DARCH='\"$OPENJDK_$1_CPU_LEGACY\"' -D$OPENJDK_$1_CPU_LEGACY"
 991 
 992   # Setup debug/release defines
 993   if test "x$DEBUG_LEVEL" = xrelease; then
 994     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -DNDEBUG"
 995     if test "x$OPENJDK_$1_OS" = xsolaris; then
 996       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -DTRIMMED"
 997     fi
 998   else
 999     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -DDEBUG"
1000   fi
1001 
1002   # Optional POSIX functionality needed by the VM
1003 
1004   if test "x$HAS_CLOCK_GETTIME" = "xtrue"; then
1005     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DSUPPORTS_CLOCK_MONOTONIC"
1006     if test "x$CLOCK_GETTIME_IN_LIBRT" = "xtrue"; then
1007       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DNEEDS_LIBRT"
1008     fi
1009   fi
1010 
1011 
1012   # Set some additional per-OS defines.
1013   if test "x$OPENJDK_$1_OS" = xlinux; then
1014     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DLINUX"
1015     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -pipe $PICFLAG -fno-rtti -fno-exceptions \
1016         -fvisibility=hidden -fno-strict-aliasing -fno-omit-frame-pointer"
1017   elif test "x$OPENJDK_$1_OS" = xsolaris; then
1018     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DSOLARIS"
1019     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -template=no%extdef -features=no%split_init \
1020         -D_Crun_inline_placement -library=stlport4 $PICFLAG -mt -features=no%except"
1021   elif test "x$OPENJDK_$1_OS" = xmacosx; then
1022     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
1023     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_ALLBSD_SOURCE"
1024     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_DARWIN_C_SOURCE -D_XOPEN_SOURCE"
1025     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -fno-rtti -fno-exceptions -fvisibility=hidden \
1026         -mno-omit-leaf-frame-pointer -mstack-alignment=16 -pipe -fno-strict-aliasing \
1027         -fno-omit-frame-pointer"
1028   elif test "x$OPENJDK_$1_OS" = xaix; then
1029     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DAIX"
1030     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -qtune=balanced \
1031         -qalias=noansi -qstrict -qtls=default -qlanglvl=c99vla \
1032         -qlanglvl=noredefmac -qnortti -qnoeh -qignerrno"
1033     # We need '-qminimaltoc' or '-qpic=large -bbigtoc' if the TOC overflows.
1034     # Hotspot now overflows its 64K TOC (currently only for slowdebug),
1035     # so for slowdebug we build with '-qpic=large -bbigtoc'.
1036     if test "x$DEBUG_LEVEL" = xslowdebug; then
1037       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -qpic=large"
1038     fi
1039   elif test "x$OPENJDK_$1_OS" = xbsd; then
1040     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE"
1041   elif test "x$OPENJDK_$1_OS" = xwindows; then
1042     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_WINDOWS -DWIN32 -D_JNI_IMPLEMENTATION_"
1043     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -nologo -W3 -MD -MP"
1044   fi
1045 
1046   # Set some additional per-CPU defines.
1047   if test "x$OPENJDK_$1_OS-$OPENJDK_$1_CPU" = xwindows-x86; then
1048     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -arch:IA32"
1049   elif test "x$OPENJDK_$1_OS-$OPENJDK_$1_CPU" = xsolaris-sparcv9; then
1050     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -xarch=sparc"
1051   elif test "x$OPENJDK_$1_CPU" = xppc64; then
1052     if test "x$OPENJDK_$1_OS" = xlinux; then
1053       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -minsert-sched-nops=regroup_exact -mno-multiple -mno-string"
1054       # fixes `relocation truncated to fit' error for gcc 4.1.
1055       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -mminimal-toc"
1056       # Use ppc64 instructions, but schedule for power5
1057       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -mcpu=powerpc64 -mtune=power5"
1058     elif test "x$OPENJDK_$1_OS" = xaix; then
1059       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -qarch=ppc64"
1060     fi
1061   elif test "x$OPENJDK_$1_CPU" = xppc64le; then
1062     if test "x$OPENJDK_$1_OS" = xlinux; then
1063       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -minsert-sched-nops=regroup_exact -mno-multiple -mno-string"
1064       # Little endian machine uses ELFv2 ABI.
1065       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DABI_ELFv2"
1066       # Use Power8, this is the first CPU to support PPC64 LE with ELFv2 ABI.
1067       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -mcpu=power8 -mtune=power8"
1068     fi
1069   elif test "x$OPENJDK_$1_CPU" = xs390x; then
1070     if test "x$OPENJDK_$1_OS" = xlinux; then
1071       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -mbackchain -march=z10"
1072     fi
1073   fi
1074 
1075   if test "x$OPENJDK_$1_CPU_ENDIAN" = xlittle; then
1076     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DVM_LITTLE_ENDIAN"
1077   fi
1078 
1079   if test "x$OPENJDK_$1_CPU_BITS" = x64; then
1080     if test "x$OPENJDK_$1_OS" != xsolaris && test "x$OPENJDK_$1_OS" != xaix; then
1081       # Solaris does not have _LP64=1 in the old build.
1082       # xlc on AIX defines _LP64=1 by default and issues a warning if we redefine it.
1083       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_LP64=1"
1084     fi
1085   fi
1086 
1087   # Set $2JVM_CFLAGS warning handling
1088   if test "x$OPENJDK_$1_OS" = xlinux; then
1089     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -Wpointer-arith -Wsign-compare -Wunused-function \
1090         -Wunused-value -Woverloaded-virtual"
1091 
1092     if test "x$TOOLCHAIN_TYPE" = xgcc; then
1093       TOOLCHAIN_CHECK_COMPILER_VERSION(VERSION: [4.8], PREFIX: $2,
1094           IF_AT_LEAST: [
1095             # These flags either do not work or give spurious warnings prior to gcc 4.8.
1096             $2JVM_CFLAGS="[$]$2JVM_CFLAGS -Wno-format-zero-length -Wtype-limits -Wuninitialized"
1097           ]
1098       )
1099     fi
1100     if ! HOTSPOT_CHECK_JVM_VARIANT(zero); then
1101       # Non-zero builds have stricter warnings
1102       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -Wreturn-type -Wundef -Wformat=2"
1103     else
1104       if test "x$TOOLCHAIN_TYPE" = xclang; then
1105         # Some versions of llvm do not like -Wundef
1106         $2JVM_CFLAGS="[$]$2JVM_CFLAGS -Wno-undef"
1107       fi
1108     fi
1109   elif test "x$OPENJDK_$1_OS" = xmacosx; then
1110     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -Wno-deprecated -Wpointer-arith \
1111         -Wsign-compare -Wundef -Wunused-function -Wformat=2"
1112   fi
1113 
1114   # Additional macosx handling
1115   if test "x$OPENJDK_$1_OS" = xmacosx; then
1116     # MACOSX_VERSION_MIN specifies the lowest version of Macosx that the built
1117     # binaries should be compatible with, even if compiled on a newer version
1118     # of the OS. It currently has a hard coded value. Setting this also limits
1119     # exposure to API changes in header files. Bumping this is likely to
1120     # require code changes to build.
1121     MACOSX_VERSION_MIN=10.7.0
1122     AC_SUBST(MACOSX_VERSION_MIN)
1123 
1124     # Setting --with-macosx-version-max=<version> makes it an error to build or
1125     # link to macosx APIs that are newer than the given OS version. The expected
1126     # format for <version> is either nn.n.n or nn.nn.nn. See /usr/include/AvailabilityMacros.h.
1127     AC_ARG_WITH([macosx-version-max], [AS_HELP_STRING([--with-macosx-version-max],
1128         [error on use of newer functionality. @<:@macosx@:>@])],
1129         [
1130           if echo "$with_macosx_version_max" | $GREP -q "^[[0-9]][[0-9]]\.[[0-9]]\.[[0-9]]\$"; then
1131               MACOSX_VERSION_MAX=$with_macosx_version_max
1132           elif echo "$with_macosx_version_max" | $GREP -q "^[[0-9]][[0-9]]\.[[0-9]][[0-9]]\.[[0-9]][[0-9]]\$"; then
1133               MACOSX_VERSION_MAX=$with_macosx_version_max
1134           elif test "x$with_macosx_version_max" = "xno"; then
1135               # Use build system default
1136               MACOSX_VERSION_MAX=
1137           else
1138               AC_MSG_ERROR([osx version format must be nn.n.n or nn.nn.nn])
1139           fi
1140         ],
1141         [MACOSX_VERSION_MAX=]
1142     )
1143     AC_SUBST(MACOSX_VERSION_MAX)
1144 
1145     # Let the flags variables get resolved in make for easier override on make
1146     # command line. AvailabilityMacros.h versions have no dots, ex: 1070.
1147     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK \
1148         -DMAC_OS_X_VERSION_MIN_REQUIRED=\$(subst .,,\$(MACOSX_VERSION_MIN)) \
1149         -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
1150     $2LDFLAGS_JDK="[$]$2LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
1151     $2JVM_CFLAGS="[$]$2JVM_CFLAGS \
1152         -DMAC_OS_X_VERSION_MIN_REQUIRED=\$(subst .,,\$(MACOSX_VERSION_MIN)) \
1153         -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
1154     $2ARFLAGS="$2$ARFLAGS -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
1155 
1156     if test -n "$MACOSX_VERSION_MAX"; then
1157         $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK \
1158             -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MAX))"
1159         $2JVM_CFLAGS="[$]$2JVM_CFLAGS \
1160             -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MAX))"
1161     fi
1162   fi
1163 
1164   # Setup some hard coded includes
1165   $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK \
1166       -I\$(SUPPORT_OUTPUTDIR)/modules_include/java.base \
1167       -I\$(SUPPORT_OUTPUTDIR)/modules_include/java.base/\$(OPENJDK_TARGET_OS_INCLUDE_SUBDIR) \
1168       -I${TOPDIR}/src/java.base/share/native/libjava \
1169       -I${TOPDIR}/src/java.base/$OPENJDK_$1_OS_TYPE/native/libjava \
1170       -I${TOPDIR}/src/hotspot/share/include \
1171       -I${TOPDIR}/src/hotspot/os/${HOTSPOT_$1_OS_TYPE}/include"
1172 
1173   # The shared libraries are compiled using the picflag.
1174   $2CFLAGS_JDKLIB="[$]$2COMMON_CCXXFLAGS_JDK \
1175       [$]$2CFLAGS_JDK [$]$2EXTRA_CFLAGS_JDK $PICFLAG [$]$2CFLAGS_JDKLIB_EXTRA"
1176   $2CXXFLAGS_JDKLIB="[$]$2COMMON_CCXXFLAGS_JDK \
1177       [$]$2CXXFLAGS_JDK [$]$2EXTRA_CXXFLAGS_JDK $PICFLAG [$]$2CXXFLAGS_JDKLIB_EXTRA"
1178 
1179   # Executable flags
1180   $2CFLAGS_JDKEXE="[$]$2COMMON_CCXXFLAGS_JDK [$]$2CFLAGS_JDK [$]$2EXTRA_CFLAGS_JDK"
1181   $2CXXFLAGS_JDKEXE="[$]$2COMMON_CCXXFLAGS_JDK [$]$2CXXFLAGS_JDK [$]$2EXTRA_CXXFLAGS_JDK"
1182 
1183   AC_SUBST($2CFLAGS_JDKLIB)
1184   AC_SUBST($2CFLAGS_JDKEXE)
1185   AC_SUBST($2CXXFLAGS_JDKLIB)
1186   AC_SUBST($2CXXFLAGS_JDKEXE)
1187 
1188   # Setup LDFLAGS et al.
1189   #
1190 
1191   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
1192     LDFLAGS_MICROSOFT="-nologo -opt:ref"
1193     $2LDFLAGS_JDK="[$]$2LDFLAGS_JDK $LDFLAGS_MICROSOFT -incremental:no"
1194     $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LDFLAGS_MICROSOFT -opt:icf,8 -subsystem:windows -base:0x8000000"
1195     if test "x$OPENJDK_$1_CPU_BITS" = "x32"; then
1196       LDFLAGS_SAFESH="-safeseh"
1197       $2LDFLAGS_JDK="[$]$2LDFLAGS_JDK $LDFLAGS_SAFESH"
1198       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LDFLAGS_SAFESH"
1199       # NOTE: Old build added -machine. Probably not needed.
1200       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -machine:I386"
1201     else
1202       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -machine:AMD64"
1203     fi
1204   elif test "x$TOOLCHAIN_TYPE" = xclang; then
1205       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -mno-omit-leaf-frame-pointer -mstack-alignment=16 -stdlib=libstdc++ -fPIC"
1206       if test "x$OPENJDK_$1_OS" = xmacosx; then
1207         # FIXME: We should really generalize SET_SHARED_LIBRARY_ORIGIN instead.
1208         $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -Wl,-rpath,@loader_path/. -Wl,-rpath,@loader_path/.."
1209     fi
1210   elif test "x$TOOLCHAIN_TYPE" = xgcc; then
1211     # If this is a --hash-style=gnu system, use --hash-style=both, why?
1212     # We have previously set HAS_GNU_HASH if this is the case
1213     if test -n "$HAS_GNU_HASH"; then
1214       $2LDFLAGS_HASH_STYLE="-Wl,--hash-style=both"
1215       $2LDFLAGS_JDK="${$2LDFLAGS_JDK} [$]$2LDFLAGS_HASH_STYLE"
1216       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS [$]$2LDFLAGS_HASH_STYLE"
1217     fi
1218       if test "x$OPENJDK_$1_OS" = xmacosx; then
1219         $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -Wl,-rpath,@loader_path/. -Wl,-rpath,@loader_path/.."
1220     fi
1221     if test "x$OPENJDK_$1_OS" = xlinux; then
1222       # And since we now know that the linker is gnu, then add -z defs, to forbid
1223       # undefined symbols in object files.
1224       LDFLAGS_NO_UNDEF_SYM="-Wl,-z,defs"
1225       $2LDFLAGS_JDK="${$2LDFLAGS_JDK} $LDFLAGS_NO_UNDEF_SYM"
1226       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS  $LDFLAGS_NO_UNDEF_SYM"
1227       LDFLAGS_NO_EXEC_STACK="-Wl,-z,noexecstack"
1228       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LDFLAGS_NO_EXEC_STACK"
1229       if test "x$OPENJDK_$1_CPU" = xx86; then
1230         $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -march=i586"
1231       fi
1232       case $DEBUG_LEVEL in
1233         release )
1234           # tell linker to optimize libraries.
1235           # Should this be supplied to the OSS linker as well?
1236           LDFLAGS_DEBUGLEVEL_release="-Wl,-O1"
1237           $2LDFLAGS_JDK="${$2LDFLAGS_JDK} $LDFLAGS_DEBUGLEVEL_release"
1238           $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LDFLAGS_DEBUGLEVEL_release"
1239           if test "x$HAS_LINKER_RELRO" = "xtrue"; then
1240             $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LINKER_RELRO_FLAG"
1241           fi
1242           ;;
1243         slowdebug )
1244           # Hotspot always let the linker optimize
1245           $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -Wl,-O1"
1246           if test "x$HAS_LINKER_NOW" = "xtrue"; then
1247             # do relocations at load
1248             $2LDFLAGS_JDK="[$]$2LDFLAGS_JDK $LINKER_NOW_FLAG"
1249             $2LDFLAGS_CXX_JDK="[$]$2LDFLAGS_CXX_JDK $LINKER_NOW_FLAG"
1250             $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LINKER_NOW_FLAG"
1251           fi
1252           if test "x$HAS_LINKER_RELRO" = "xtrue"; then
1253             # mark relocations read only
1254             $2LDFLAGS_JDK="[$]$2LDFLAGS_JDK $LINKER_RELRO_FLAG"
1255             $2LDFLAGS_CXX_JDK="[$]$2LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG"
1256             $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LINKER_RELRO_FLAG"
1257           fi
1258           ;;
1259         fastdebug )
1260           # Hotspot always let the linker optimize
1261           $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -Wl,-O1"
1262           if test "x$HAS_LINKER_RELRO" = "xtrue"; then
1263             # mark relocations read only
1264             $2LDFLAGS_JDK="[$]$2LDFLAGS_JDK $LINKER_RELRO_FLAG"
1265             $2LDFLAGS_CXX_JDK="[$]$2LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG"
1266             $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LINKER_RELRO_FLAG"
1267           fi
1268           ;;
1269         * )
1270           AC_MSG_ERROR([Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL])
1271           ;;
1272         esac
1273     fi
1274   elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
1275     LDFLAGS_SOLSTUDIO="-Wl,-z,defs"
1276     $2LDFLAGS_JDK="[$]$2LDFLAGS_JDK $LDFLAGS_SOLSTUDIO -ztext"
1277     LDFLAGS_CXX_SOLSTUDIO="-norunpath"
1278     $2LDFLAGS_CXX_JDK="[$]$2LDFLAGS_CXX_JDK $LDFLAGS_CXX_SOLSTUDIO -xnolib"
1279     $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LDFLAGS_SOLSTUDIO -library=%none -mt $LDFLAGS_CXX_SOLSTUDIO -z noversion"
1280     if test "x$OPENJDK_$1_CPU_ARCH" = "xsparc"; then
1281       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -xarch=sparc"
1282     fi
1283   elif test "x$TOOLCHAIN_TYPE" = xxlc; then
1284     LDFLAGS_XLC="-b64 -brtl -bnolibpath -bexpall -bernotok -btextpsize:64K -bdatapsize:64K -bstackpsize:64K"
1285     $2LDFLAGS_JDK="${$2LDFLAGS_JDK} $LDFLAGS_XLC"
1286     $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LDFLAGS_XLC"
1287     # We need '-qminimaltoc' or '-qpic=large -bbigtoc' if the TOC overflows.
1288     # Hotspot now overflows its 64K TOC (currently only for slowdebug),
1289     # so for slowdebug we build with '-qpic=large -bbigtoc'.
1290     if test "x$DEBUG_LEVEL" = xslowdebug; then
1291       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -bbigtoc"
1292     fi
1293   fi
1294 
1295   # Customize LDFLAGS for executables
1296 
1297   $2LDFLAGS_JDKEXE="${$2LDFLAGS_JDK}"
1298 
1299   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
1300     if test "x$OPENJDK_$1_CPU_BITS" = "x64"; then
1301       LDFLAGS_STACK_SIZE=1048576
1302     else
1303       LDFLAGS_STACK_SIZE=327680
1304     fi
1305     $2LDFLAGS_JDKEXE="${$2LDFLAGS_JDKEXE} /STACK:$LDFLAGS_STACK_SIZE"
1306   elif test "x$OPENJDK_$1_OS" = xlinux; then
1307     $2LDFLAGS_JDKEXE="[$]$2LDFLAGS_JDKEXE -Wl,--allow-shlib-undefined"
1308   fi
1309 
1310   $2LDFLAGS_JDKEXE="${$2LDFLAGS_JDKEXE} ${$2EXTRA_LDFLAGS_JDK}"
1311 
1312   # Customize LDFLAGS for libs
1313   $2LDFLAGS_JDKLIB="${$2LDFLAGS_JDK}"
1314 
1315   $2LDFLAGS_JDKLIB="${$2LDFLAGS_JDKLIB} ${SHARED_LIBRARY_FLAGS}"
1316   $2LDFLAGS_JDKLIB="${$2LDFLAGS_JDKLIB} ${LDFLAGS_NO_EXEC_STACK}"
1317   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
1318     $2JAVA_BASE_LDFLAGS="${$2JAVA_BASE_LDFLAGS} \
1319         -libpath:${OUTPUTDIR}/support/modules_libs/java.base"
1320     $2JDKLIB_LIBS=""
1321   else
1322     $2JAVA_BASE_LDFLAGS="${$2JAVA_BASE_LDFLAGS} \
1323         -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base"
1324 
1325     if test "x$1" = "xTARGET"; then
1326       # On some platforms (mac) the linker warns about non existing -L dirs.
1327       # For any of the variants server, client or minimal, the dir matches the
1328       # variant name. The "main" variant should be used for linking. For the
1329       # rest, the dir is just server.
1330       if HOTSPOT_CHECK_JVM_VARIANT(server) || HOTSPOT_CHECK_JVM_VARIANT(client) \
1331           || HOTSPOT_CHECK_JVM_VARIANT(minimal); then
1332         $2JAVA_BASE_LDFLAGS="${$2JAVA_BASE_LDFLAGS} \
1333             -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base/$JVM_VARIANT_MAIN"
1334       else
1335         $2JAVA_BASE_LDFLAGS="${$2JAVA_BASE_LDFLAGS} \
1336             -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base/server"
1337       fi
1338     elif test "x$1" = "xBUILD"; then
1339       # When building a buildjdk, it's always only the server variant
1340       $2JAVA_BASE_LDFLAGS="${$2JAVA_BASE_LDFLAGS} \
1341           -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base/server"
1342     fi
1343 
1344     $2JDKLIB_LIBS="-ljava -ljvm"
1345     if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
1346       $2JDKLIB_LIBS="[$]$2JDKLIB_LIBS -lc"
1347     fi
1348 
1349   fi
1350 
1351 $2LDFLAGS_JDKLIB="${$2LDFLAGS_JDKLIB} ${$2JAVA_BASE_LDFLAGS}"
1352 
1353   # Set $2JVM_LIBS (per os)
1354   if test "x$OPENJDK_$1_OS" = xlinux; then
1355     $2JVM_LIBS="[$]$2JVM_LIBS -lm -ldl -lpthread"
1356   elif test "x$OPENJDK_$1_OS" = xsolaris; then
1357     # FIXME: This hard-coded path is not really proper.
1358     if test "x$OPENJDK_$1_CPU" = xx86_64; then
1359       $2SOLARIS_LIBM_LIBS="/usr/lib/amd64/libm.so.1"
1360     elif test "x$OPENJDK_$1_CPU" = xsparcv9; then
1361       $2SOLARIS_LIBM_LIBS="/usr/lib/sparcv9/libm.so.1"
1362     fi
1363     $2JVM_LIBS="[$]$2JVM_LIBS -lsocket -lsched -ldl $SOLARIS_LIBM_LIBS -lCrun \
1364         -lthread -ldoor -lc -ldemangle -lnsl -lrt"
1365   elif test "x$OPENJDK_$1_OS" = xmacosx; then
1366     $2JVM_LIBS="[$]$2JVM_LIBS -lm"
1367   elif test "x$OPENJDK_$1_OS" = xaix; then
1368     $2JVM_LIBS="[$]$2JVM_LIBS -Wl,-lC_r -lm -ldl -lpthread"
1369   elif test "x$OPENJDK_$1_OS" = xbsd; then
1370     $2JVM_LIBS="[$]$2JVM_LIBS -lm"
1371   elif test "x$OPENJDK_$1_OS" = xwindows; then
1372     $2JVM_LIBS="[$]$2JVM_LIBS kernel32.lib user32.lib gdi32.lib winspool.lib \
1373         comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib \
1374         wsock32.lib winmm.lib version.lib psapi.lib"
1375     fi
1376 
1377   # Set $2JVM_ASFLAGS
1378   if test "x$OPENJDK_$1_OS" = xlinux; then
1379     if test "x$OPENJDK_$1_CPU" = xx86; then
1380       $2JVM_ASFLAGS="[$]$2JVM_ASFLAGS -march=i586"
1381     fi
1382   elif test "x$OPENJDK_$1_OS" = xmacosx; then
1383     $2JVM_ASFLAGS="[$]$2JVM_ASFLAGS -x assembler-with-cpp -mno-omit-leaf-frame-pointer -mstack-alignment=16"
1384   fi
1385 
1386   $2LDFLAGS_JDKLIB="${$2LDFLAGS_JDKLIB} ${$2EXTRA_LDFLAGS_JDK}"
1387 
1388   AC_SUBST($2LDFLAGS_JDKLIB)
1389   AC_SUBST($2LDFLAGS_JDKEXE)
1390   AC_SUBST($2JDKLIB_LIBS)
1391   AC_SUBST($2JDKEXE_LIBS)
1392   AC_SUBST($2LDFLAGS_CXX_JDK)
1393   AC_SUBST($2LDFLAGS_HASH_STYLE)
1394   AC_SUBST($2LDFLAGS_NO_EXEC_STACK)
1395 
1396   AC_SUBST($2JVM_CFLAGS)
1397   AC_SUBST($2JVM_LDFLAGS)
1398   AC_SUBST($2JVM_ASFLAGS)
1399   AC_SUBST($2JVM_LIBS)
1400 
1401 ])
1402 
1403 # FLAGS_C_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
1404 #                                  IF_FALSE: [RUN-IF-FALSE])
1405 # ------------------------------------------------------------
1406 # Check that the C compiler supports an argument
1407 BASIC_DEFUN_NAMED([FLAGS_C_COMPILER_CHECK_ARGUMENTS],
1408     [*ARGUMENT IF_TRUE IF_FALSE], [$@],
1409 [
1410   AC_MSG_CHECKING([if the C compiler supports "ARG_ARGUMENT"])
1411   supports=yes
1412 
1413   saved_cflags="$CFLAGS"
1414   CFLAGS="$CFLAGS ARG_ARGUMENT"
1415   AC_LANG_PUSH([C])
1416   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [],
1417       [supports=no])
1418   AC_LANG_POP([C])
1419   CFLAGS="$saved_cflags"
1420 
1421   AC_MSG_RESULT([$supports])
1422   if test "x$supports" = "xyes" ; then
1423     :
1424     ARG_IF_TRUE
1425   else
1426     :
1427     ARG_IF_FALSE
1428   fi
1429 ])
1430 
1431 # FLAGS_CXX_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
1432 #                                    IF_FALSE: [RUN-IF-FALSE])
1433 # ------------------------------------------------------------
1434 # Check that the C++ compiler supports an argument
1435 BASIC_DEFUN_NAMED([FLAGS_CXX_COMPILER_CHECK_ARGUMENTS],
1436     [*ARGUMENT IF_TRUE IF_FALSE], [$@],
1437 [
1438   AC_MSG_CHECKING([if the C++ compiler supports "ARG_ARGUMENT"])
1439   supports=yes
1440 
1441   saved_cxxflags="$CXXFLAGS"
1442   CXXFLAGS="$CXXFLAG ARG_ARGUMENT"
1443   AC_LANG_PUSH([C++])
1444   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [],
1445       [supports=no])
1446   AC_LANG_POP([C++])
1447   CXXFLAGS="$saved_cxxflags"
1448 
1449   AC_MSG_RESULT([$supports])
1450   if test "x$supports" = "xyes" ; then
1451     :
1452     ARG_IF_TRUE
1453   else
1454     :
1455     ARG_IF_FALSE
1456   fi
1457 ])
1458 
1459 # FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
1460 #                                IF_FALSE: [RUN-IF-FALSE])
1461 # ------------------------------------------------------------
1462 # Check that the C and C++ compilers support an argument
1463 BASIC_DEFUN_NAMED([FLAGS_COMPILER_CHECK_ARGUMENTS],
1464     [*ARGUMENT IF_TRUE IF_FALSE], [$@],
1465 [
1466   FLAGS_C_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARG_ARGUMENT],
1467                                              IF_TRUE: [C_COMP_SUPPORTS="yes"],
1468                                              IF_FALSE: [C_COMP_SUPPORTS="no"])
1469   FLAGS_CXX_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARG_ARGUMENT],
1470                                                IF_TRUE: [CXX_COMP_SUPPORTS="yes"],
1471                                                IF_FALSE: [CXX_COMP_SUPPORTS="no"])
1472 
1473   AC_MSG_CHECKING([if both compilers support "ARG_ARGUMENT"])
1474   supports=no
1475   if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
1476 
1477   AC_MSG_RESULT([$supports])
1478   if test "x$supports" = "xyes" ; then
1479     :
1480     ARG_IF_TRUE
1481   else
1482     :
1483     ARG_IF_FALSE
1484   fi
1485 ])
1486 
1487 # FLAGS_LINKER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
1488 #                                   IF_FALSE: [RUN-IF-FALSE])
1489 # ------------------------------------------------------------
1490 # Check that the linker support an argument
1491 BASIC_DEFUN_NAMED([FLAGS_LINKER_CHECK_ARGUMENTS],
1492     [*ARGUMENT IF_TRUE IF_FALSE], [$@],
1493 [
1494   AC_MSG_CHECKING([if linker supports "ARG_ARGUMENT"])
1495   supports=yes
1496 
1497   saved_ldflags="$LDFLAGS"
1498   LDFLAGS="$LDFLAGS ARG_ARGUMENT"
1499   AC_LANG_PUSH([C])
1500   AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],
1501       [], [supports=no])
1502   AC_LANG_POP([C])
1503   LDFLAGS="$saved_ldflags"
1504 
1505   AC_MSG_RESULT([$supports])
1506   if test "x$supports" = "xyes" ; then
1507     :
1508     ARG_IF_TRUE
1509   else
1510     :
1511     ARG_IF_FALSE
1512   fi
1513 ])
1514 
1515 AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_MISC],
1516 [
1517   # Check that the compiler supports -mX (or -qX on AIX) flags
1518   # Set COMPILER_SUPPORTS_TARGET_BITS_FLAG to 'true' if it does
1519   FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}],
1520       IF_TRUE: [COMPILER_SUPPORTS_TARGET_BITS_FLAG=true],
1521       IF_FALSE: [COMPILER_SUPPORTS_TARGET_BITS_FLAG=false])
1522   AC_SUBST(COMPILER_SUPPORTS_TARGET_BITS_FLAG)
1523 
1524   AC_ARG_ENABLE([warnings-as-errors], [AS_HELP_STRING([--disable-warnings-as-errors],
1525       [do not consider native warnings to be an error @<:@enabled@:>@])])
1526 
1527   AC_MSG_CHECKING([if native warnings are errors])
1528   if test "x$enable_warnings_as_errors" = "xyes"; then
1529     AC_MSG_RESULT([yes (explicitly set)])
1530     WARNINGS_AS_ERRORS=true
1531   elif test "x$enable_warnings_as_errors" = "xno"; then
1532     AC_MSG_RESULT([no])
1533     WARNINGS_AS_ERRORS=false
1534   elif test "x$enable_warnings_as_errors" = "x"; then
1535     AC_MSG_RESULT([yes (default)])
1536     WARNINGS_AS_ERRORS=true
1537   else
1538     AC_MSG_ERROR([--enable-warnings-as-errors accepts no argument])
1539   fi
1540 
1541   AC_SUBST(WARNINGS_AS_ERRORS)
1542 
1543   case "${TOOLCHAIN_TYPE}" in
1544     microsoft)
1545       DISABLE_WARNING_PREFIX="-wd"
1546       CFLAGS_WARNINGS_ARE_ERRORS="-WX"
1547       ;;
1548     solstudio)
1549       DISABLE_WARNING_PREFIX="-erroff="
1550       CFLAGS_WARNINGS_ARE_ERRORS="-errtags -errwarn=%all"
1551       ;;
1552     gcc)
1553       # Prior to gcc 4.4, a -Wno-X where X is unknown for that version of gcc will cause an error
1554       FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [-Wno-this-is-a-warning-that-do-not-exist],
1555           IF_TRUE: [GCC_CAN_DISABLE_WARNINGS=true],
1556           IF_FALSE: [GCC_CAN_DISABLE_WARNINGS=false]
1557       )
1558       if test "x$GCC_CAN_DISABLE_WARNINGS" = "xtrue"; then
1559         DISABLE_WARNING_PREFIX="-Wno-"
1560       else
1561         DISABLE_WARNING_PREFIX=
1562       fi
1563       CFLAGS_WARNINGS_ARE_ERRORS="-Werror"
1564       # Repeate the check for the BUILD_CC and BUILD_CXX. Need to also reset
1565       # CFLAGS since any target specific flags will likely not work with the
1566       # build compiler
1567       CC_OLD="$CC"
1568       CXX_OLD="$CXX"
1569       CC="$BUILD_CC"
1570       CXX="$BUILD_CXX"
1571       CFLAGS_OLD="$CFLAGS"
1572       CFLAGS=""
1573       FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [-Wno-this-is-a-warning-that-do-not-exist],
1574           IF_TRUE: [BUILD_CC_CAN_DISABLE_WARNINGS=true],
1575           IF_FALSE: [BUILD_CC_CAN_DISABLE_WARNINGS=false]
1576       )
1577       if test "x$BUILD_CC_CAN_DISABLE_WARNINGS" = "xtrue"; then
1578         BUILD_CC_DISABLE_WARNING_PREFIX="-Wno-"
1579       else
1580         BUILD_CC_DISABLE_WARNING_PREFIX=
1581       fi
1582       CC="$CC_OLD"
1583       CXX="$CXX_OLD"
1584       CFLAGS="$CFLAGS_OLD"
1585       ;;
1586     clang)
1587       DISABLE_WARNING_PREFIX="-Wno-"
1588       CFLAGS_WARNINGS_ARE_ERRORS="-Werror"
1589       ;;
1590     xlc)
1591       DISABLE_WARNING_PREFIX="-qsuppress="
1592       CFLAGS_WARNINGS_ARE_ERRORS="-qhalt=w"
1593       ;;
1594   esac
1595   AC_SUBST(DISABLE_WARNING_PREFIX)
1596   AC_SUBST(BUILD_CC_DISABLE_WARNING_PREFIX)
1597   AC_SUBST(CFLAGS_WARNINGS_ARE_ERRORS)
1598 ])
1599 
1600 # FLAGS_SETUP_GCC6_COMPILER_FLAGS([PREFIX])
1601 # Arguments:
1602 # $1 - Optional prefix for each variable defined.
1603 AC_DEFUN([FLAGS_SETUP_GCC6_COMPILER_FLAGS],
1604 [
1605   # These flags are required for GCC 6 builds as undefined behaviour in OpenJDK code
1606   # runs afoul of the more aggressive versions of these optimisations.
1607   # Notably, value range propagation now assumes that the this pointer of C++
1608   # member functions is non-null.
1609   NO_DELETE_NULL_POINTER_CHECKS_CFLAG="-fno-delete-null-pointer-checks"
1610   dnl Argument check is disabled until FLAGS_COMPILER_CHECK_ARGUMENTS handles cross-compilation
1611   dnl FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror],
1612   dnl                                        IF_FALSE: [NO_DELETE_NULL_POINTER_CHECKS_CFLAG=""])
1613   NO_LIFETIME_DSE_CFLAG="-fno-lifetime-dse"
1614   dnl Argument check is disabled until FLAGS_COMPILER_CHECK_ARGUMENTS handles cross-compilation
1615   dnl FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [$NO_LIFETIME_DSE_CFLAG -Werror],
1616   dnl                                        IF_FALSE: [NO_LIFETIME_DSE_CFLAG=""])
1617   AC_MSG_NOTICE([GCC >= 6 detected; adding ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} and ${NO_LIFETIME_DSE_CFLAG}])
1618   $1CFLAGS_JDK="[$]$1CFLAGS_JDK ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} ${NO_LIFETIME_DSE_CFLAG}"
1619   $1JVM_CFLAGS="[$]$1JVM_CFLAGS ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} ${NO_LIFETIME_DSE_CFLAG}"
1620 ])