1 #
   2 # Copyright (c) 2011, 2015, 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 # $1 = compiler to test (CC or CXX)
  27 # $2 = human readable name of compiler (C or C++)
  28 AC_DEFUN([TOOLCHAIN_CHECK_COMPILER_VERSION],
  29 [
  30   COMPILER=[$]$1
  31   COMPILER_NAME=$2
  32 
  33   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
  34     # Make sure we use the Sun Studio compiler and not gcc on Solaris, which won't work
  35     COMPILER_VERSION_TEST=`$COMPILER -V 2>&1 | $HEAD -n 1`
  36     $ECHO $COMPILER_VERSION_TEST | $GREP "^.*: Sun $COMPILER_NAME" > /dev/null
  37     if test $? -ne 0; then
  38       GCC_VERSION_TEST=`$COMPILER --version 2>&1 | $HEAD -n 1`
  39 
  40       AC_MSG_NOTICE([The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required Sun Studio compiler.])
  41       AC_MSG_NOTICE([The result from running with -V was: "$COMPILER_VERSION_TEST" and with --version: "$GCC_VERSION_TEST"])
  42       AC_MSG_ERROR([Sun Studio compiler is required. Try setting --with-tools-dir.])
  43     else
  44       COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.*@<:@ ,\t@:>@$COMPILER_NAME@<:@ ,\t@:>@\(@<:@1-9@:>@\.@<:@0-9@:>@@<:@0-9@:>@*\).*/\1/p"`
  45       COMPILER_VENDOR="Sun Studio"
  46     fi
  47   elif test  "x$OPENJDK_TARGET_OS" = xaix; then
  48       COMPILER_VERSION_TEST=`$COMPILER -qversion  2>&1 | $TAIL -n 1`
  49       $ECHO $COMPILER_VERSION_TEST | $GREP "^Version: " > /dev/null
  50       if test $? -ne 0; then
  51         AC_MSG_ERROR([Failed to detect the compiler version of $COMPILER ....])
  52       else
  53         COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n 's/Version: \([0-9][0-9]\.[0-9][0-9]*\).*/\1/p'`
  54         COMPILER_VENDOR='IBM'
  55       fi
  56   elif test  "x$OPENJDK_TARGET_OS" = xwindows; then
  57     # First line typically looks something like:
  58     # Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86
  59     COMPILER_VERSION_TEST=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
  60     COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.*Version \(@<:@1-9@:>@@<:@0-9.@:>@*\) .*/\1/p"`
  61     COMPILER_VENDOR="Microsoft CL.EXE"
  62     COMPILER_CPU_TEST=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.* for \(.*\)$/\1/p"`
  63     if test "x$OPENJDK_TARGET_CPU" = "xx86"; then
  64       if test "x$COMPILER_CPU_TEST" != "x80x86"; then
  65         AC_MSG_ERROR([Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for "$COMPILER_CPU_TEST"; expected "80x86".])
  66       fi
  67     elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then
  68       if test "x$COMPILER_CPU_TEST" != "xx64"; then
  69         AC_MSG_ERROR([Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for "$COMPILER_CPU_TEST"; expected "x64".])
  70       fi
  71     fi
  72   else
  73     COMPILER_VERSION_TEST=`$COMPILER --version 2>&1 | $HEAD -n 1`
  74     # Check that this is likely to be GCC.
  75     $COMPILER --version 2>&1 | $GREP "Free Software Foundation" > /dev/null
  76     if test $? -ne 0; then
  77       AC_MSG_NOTICE([The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required GCC compiler.])
  78       AC_MSG_NOTICE([The result from running with --version was: "$COMPILER_VERSION_TEST"])
  79       AC_MSG_ERROR([GCC compiler is required. Try setting --with-tools-dir.])
  80     fi
  81 
  82     # First line typically looks something like:
  83     # gcc (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2
  84     COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.* \(@<:@1-9@:>@@<:@0-9.@:>@*\)/\1/p"`
  85     COMPILER_VENDOR=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^\(.*\) @<:@1-9@:>@@<:@0-9.@:>@*/\1/p"`
  86   fi
  87   # This sets CC_VERSION or CXX_VERSION. (This comment is a grep marker)
  88   $1_VERSION="$COMPILER_VERSION"
  89   # This sets CC_VENDOR or CXX_VENDOR. (This comment is a grep marker)
  90   $1_VENDOR="$COMPILER_VENDOR"
  91 
  92   AC_MSG_NOTICE([Using $COMPILER_VENDOR $COMPILER_NAME compiler version $COMPILER_VERSION (located at $COMPILER)])
  93 ])
  94 
  95 
  96 AC_DEFUN_ONCE([TOOLCHAIN_SETUP_SYSROOT_AND_OUT_OPTIONS],
  97 [
  98   ###############################################################################
  99   #
 100   # Configure the development tool paths and potential sysroot.
 101   #
 102   AC_LANG(C++)
 103 
 104   # The option used to specify the target .o,.a or .so file.
 105   # When compiling, how to specify the to be created object file.
 106   CC_OUT_OPTION='-o$(SPACE)'
 107   # When linking, how to specify the to be created executable.
 108   EXE_OUT_OPTION='-o$(SPACE)'
 109   # When linking, how to specify the to be created dynamically linkable library.
 110   LD_OUT_OPTION='-o$(SPACE)'
 111   # When archiving, how to specify the to be create static archive for object files.
 112   AR_OUT_OPTION='rcs$(SPACE)'
 113   AC_SUBST(CC_OUT_OPTION)
 114   AC_SUBST(EXE_OUT_OPTION)
 115   AC_SUBST(LD_OUT_OPTION)
 116   AC_SUBST(AR_OUT_OPTION)
 117 ])
 118 
 119 # $1 = compiler to test (CC or CXX)
 120 # $2 = human readable name of compiler (C or C++)
 121 # $3 = list of compiler names to search for
 122 AC_DEFUN([TOOLCHAIN_FIND_COMPILER],
 123 [
 124   COMPILER_NAME=$2
 125 
 126   $1=
 127   # If TOOLS_DIR is set, check for all compiler names in there first
 128   # before checking the rest of the PATH.
 129   if test -n "$TOOLS_DIR"; then
 130     PATH_save="$PATH"
 131     PATH="$TOOLS_DIR"
 132     AC_PATH_PROGS(TOOLS_DIR_$1, $3)
 133     $1=$TOOLS_DIR_$1
 134     PATH="$PATH_save"
 135   fi
 136 
 137   # AC_PATH_PROGS can't be run multiple times with the same variable,
 138   # so create a new name for this run.
 139   if test "x[$]$1" = x; then
 140     AC_PATH_PROGS(POTENTIAL_$1, $3)
 141     $1=$POTENTIAL_$1
 142   fi
 143 
 144   if test "x[$]$1" = x; then
 145     HELP_MSG_MISSING_DEPENDENCY([devkit])
 146     AC_MSG_ERROR([Could not find a $COMPILER_NAME compiler. $HELP_MSG])
 147   fi
 148   BASIC_FIXUP_EXECUTABLE($1)
 149   TEST_COMPILER="[$]$1"
 150   # Don't remove symbolic links on AIX because 'xlc_r' and 'xlC_r' may all be links
 151   # to 'xlc' but it is crucial that we invoke the compiler with the right name!
 152   if test "x$OPENJDK_BUILD_OS" != xaix; then
 153     AC_MSG_CHECKING([resolved symbolic links for $1])
 154     BASIC_REMOVE_SYMBOLIC_LINKS(TEST_COMPILER)
 155     AC_MSG_RESULT([$TEST_COMPILER])
 156   fi
 157   AC_MSG_CHECKING([if $1 is disguised ccache])
 158 
 159   COMPILER_BASENAME=`$BASENAME "$TEST_COMPILER"`
 160   if test "x$COMPILER_BASENAME" = "xccache"; then
 161     AC_MSG_RESULT([yes, trying to find proper $COMPILER_NAME compiler])
 162     # We /usr/lib/ccache in the path, so cc is a symlink to /usr/bin/ccache.
 163     # We want to control ccache invocation ourselves, so ignore this cc and try
 164     # searching again.
 165 
 166     # Remove the path to the fake ccache cc from the PATH
 167     RETRY_COMPILER_SAVED_PATH="$PATH"
 168     COMPILER_DIRNAME=`$DIRNAME [$]$1`
 169     PATH="`$ECHO $PATH | $SED -e "s,$COMPILER_DIRNAME,,g" -e "s,::,:,g" -e "s,^:,,g"`"
 170 
 171     # Try again looking for our compiler
 172     AC_CHECK_TOOLS(PROPER_COMPILER_$1, $3)
 173     BASIC_FIXUP_EXECUTABLE(PROPER_COMPILER_$1)
 174     PATH="$RETRY_COMPILER_SAVED_PATH"
 175 
 176     AC_MSG_CHECKING([for resolved symbolic links for $1])
 177     BASIC_REMOVE_SYMBOLIC_LINKS(PROPER_COMPILER_$1)
 178     AC_MSG_RESULT([$PROPER_COMPILER_$1])
 179     $1="$PROPER_COMPILER_$1"
 180   else
 181     AC_MSG_RESULT([no, keeping $1])
 182     $1="$TEST_COMPILER"
 183   fi
 184   TOOLCHAIN_CHECK_COMPILER_VERSION([$1], [$COMPILER_NAME])
 185 ])
 186 
 187 
 188 AC_DEFUN([TOOLCHAIN_SETUP_PATHS],
 189 [
 190   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
 191     TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV
 192     TOOLCHAIN_SETUP_MSVCR_DLL
 193     BASIC_DEPRECATED_ARG_WITH([dxsdk])
 194     BASIC_DEPRECATED_ARG_WITH([dxsdk-lib])
 195     BASIC_DEPRECATED_ARG_WITH([dxsdk-include])
 196   fi
 197 
 198   AC_SUBST(MSVCR_DLL)
 199 
 200   # If --build AND --host is set, then the configure script will find any
 201   # cross compilation tools in the PATH. Cross compilation tools
 202   # follows the cross compilation standard where they are prefixed with ${host}.
 203   # For example the binary i686-sun-solaris2.10-gcc
 204   # will cross compile for i686-sun-solaris2.10
 205   # If neither of build and host is not set, then build=host and the
 206   # default compiler found in the path will be used.
 207   # Setting only --host, does not seem to be really supported.
 208   # Please set both --build and --host if you want to cross compile.
 209 
 210   if test "x$COMPILE_TYPE" = "xcross"; then
 211     # Now we to find a C/C++ compiler that can build executables for the build
 212     # platform. We can't use the AC_PROG_CC macro, since it can only be used
 213     # once. Also, we need to do this before adding a tools dir to the path,
 214     # otherwise we might pick up cross-compilers which don't use standard naming.
 215     # Otherwise, we'll set the BUILD_tools to the native tools, but that'll have
 216     # to wait until they are properly discovered.
 217     AC_PATH_PROGS(BUILD_CC, [cl cc gcc])
 218     BASIC_FIXUP_EXECUTABLE(BUILD_CC)
 219     AC_PATH_PROGS(BUILD_CXX, [cl CC g++])
 220     BASIC_FIXUP_EXECUTABLE(BUILD_CXX)
 221     AC_PATH_PROG(BUILD_LD, ld)
 222     BASIC_FIXUP_EXECUTABLE(BUILD_LD)
 223   fi
 224   AC_SUBST(BUILD_CC)
 225   AC_SUBST(BUILD_CXX)
 226   AC_SUBST(BUILD_LD)
 227 
 228   # If a devkit is found on the builddeps server, then prepend its path to the
 229   # PATH variable. If there are cross compilers available in the devkit, these
 230   # will be found by AC_PROG_CC et al.
 231   DEVKIT=
 232   BDEPS_CHECK_MODULE(DEVKIT, devkit, xxx,
 233       [
 234         # Found devkit
 235         PATH="$DEVKIT/bin:$PATH"
 236         SYS_ROOT="$DEVKIT/${rewritten_target}/sys-root"
 237         if test "x$x_includes" = "xNONE"; then
 238           x_includes="$SYS_ROOT/usr/include/X11"
 239         fi
 240         if test "x$x_libraries" = "xNONE"; then
 241           x_libraries="$SYS_ROOT/usr/lib"
 242         fi
 243       ],
 244       [])
 245 
 246   # Store the CFLAGS etal passed to the configure script.
 247   ORG_CFLAGS="$CFLAGS"
 248   ORG_CXXFLAGS="$CXXFLAGS"
 249   ORG_OBJCFLAGS="$OBJCFLAGS"
 250 
 251   # autoconf magic only relies on PATH, so update it if tools dir is specified
 252   OLD_PATH="$PATH"
 253   if test "x$TOOLS_DIR" != x; then
 254     PATH=$TOOLS_DIR:$PATH
 255   fi
 256 
 257   # Before we locate the compilers, we need to sanitize the Xcode build environment
 258   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
 259     # determine path to Xcode developer directory
 260     # can be empty in which case all the tools will rely on a sane Xcode 4 installation
 261     SET_DEVELOPER_DIR=
 262 
 263     if test -n "$XCODE_PATH"; then
 264       DEVELOPER_DIR="$XCODE_PATH"/Contents/Developer
 265     fi
 266 
 267     # DEVELOPER_DIR could also be provided directly
 268     AC_MSG_CHECKING([Determining if we need to set DEVELOPER_DIR])
 269     if test -n "$DEVELOPER_DIR"; then
 270       if test ! -d "$DEVELOPER_DIR"; then
 271         AC_MSG_ERROR([Xcode Developer path does not exist: $DEVELOPER_DIR, please provide a path to the Xcode 4 application bundle using --with-xcode-path])
 272       fi
 273       if test ! -f "$DEVELOPER_DIR"/usr/bin/xcodebuild; then
 274         AC_MSG_ERROR([Xcode Developer path is not valid: $DEVELOPER_DIR, it must point to Contents/Developer inside an Xcode application bundle])
 275       fi
 276       # make it visible to all the tools immediately
 277       export DEVELOPER_DIR
 278       SET_DEVELOPER_DIR="export DEVELOPER_DIR := $DEVELOPER_DIR"
 279       AC_MSG_RESULT([yes ($DEVELOPER_DIR)])
 280     else
 281       AC_MSG_RESULT([no])
 282     fi
 283     AC_SUBST(SET_DEVELOPER_DIR)
 284 
 285     AC_PATH_PROG(XCODEBUILD, xcodebuild)
 286     if test -z "$XCODEBUILD"; then
 287       AC_MSG_ERROR([The xcodebuild tool was not found, the Xcode command line tools are required to build on Mac OS X])
 288     fi
 289 
 290     # Fail-fast: verify we're building on Xcode 4, we cannot build with Xcode 5 or later
 291     XCODE_VERSION=`$XCODEBUILD -version | grep '^Xcode ' | sed 's/Xcode //'`
 292     XC_VERSION_PARTS=( ${XCODE_VERSION//./ } )
 293     if test ! "${XC_VERSION_PARTS[[0]]}" = "4"; then
 294       AC_MSG_ERROR([Xcode 4 is required to build JDK 8, the version found was $XCODE_VERSION. Use --with-xcode-path to specify the location of Xcode 4 or make Xcode 4 active by using xcode-select.])
 295     fi
 296 
 297     # Some versions of Xcode 5 command line tools install gcc and g++ as symlinks to
 298     # clang and clang++, which will break the build. So handle that here if we need to.
 299     if test -L "/usr/bin/gcc" -o -L "/usr/bin/g++"; then
 300       # use xcrun to find the real gcc and add it's directory to PATH
 301       # then autoconf magic will find it
 302       AC_MSG_NOTICE([Found gcc symlinks to clang in /usr/bin, adding path to real gcc to PATH])
 303       XCODE_BIN_PATH=$(dirname `xcrun -find gcc`)
 304       PATH="$XCODE_BIN_PATH":$PATH
 305     fi
 306 
 307     # Determine appropriate SDKPATH, don't use SDKROOT as it interferes with the stub tools
 308     AC_MSG_CHECKING([Determining Xcode SDK path])
 309     # allow SDKNAME to be set to override the default SDK selection
 310     SDKPATH=`"$XCODEBUILD" -sdk ${SDKNAME:-macosx} -version | grep '^Path: ' | sed 's/Path: //'`
 311     if test -n "$SDKPATH"; then
 312       AC_MSG_RESULT([$SDKPATH])
 313     else
 314       AC_MSG_RESULT([(none, will use system headers and frameworks)])
 315     fi
 316     AC_SUBST(SDKPATH)
 317 
 318     # Perform a basic sanity test
 319     if test ! -f "$SDKPATH/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h"; then
 320       AC_MSG_ERROR([Unable to find required framework headers, provide a valid path to Xcode 4 using --with-xcode-path])
 321     fi
 322 
 323     # if SDKPATH is non-empty then we need to add -isysroot and -iframework for gcc and g++
 324     if test -n "$SDKPATH"; then
 325       # We need -isysroot <path> and -iframework<path>/System/Library/Frameworks
 326       CFLAGS_JDK="${CFLAGS_JDK} -isysroot \"$SDKPATH\" -iframework\"$SDKPATH/System/Library/Frameworks\""
 327       CXXFLAGS_JDK="${CXXFLAGS_JDK} -isysroot \"$SDKPATH\" -iframework\"$SDKPATH/System/Library/Frameworks\""
 328       LDFLAGS_JDK="${LDFLAGS_JDK} -isysroot \"$SDKPATH\" -iframework\"$SDKPATH/System/Library/Frameworks\""
 329     fi
 330     
 331     # These always need to be set, or we can't find the frameworks embedded in JavaVM.framework
 332     # setting this here means it doesn't have to be peppered throughout the forest
 333     CFLAGS_JDK="$CFLAGS_JDK -F\"$SDKPATH/System/Library/Frameworks/JavaVM.framework/Frameworks\""
 334     CXXFLAGS_JDK="$CXXFLAGS_JDK -F\"$SDKPATH/System/Library/Frameworks/JavaVM.framework/Frameworks\""
 335     LDFLAGS_JDK="$LDFLAGS_JDK -F\"$SDKPATH/System/Library/Frameworks/JavaVM.framework/Frameworks\""
 336   fi
 337 
 338   ### Locate C compiler (CC)
 339 
 340   # On windows, only cl.exe is supported.
 341   # On Solaris, cc is preferred to gcc.
 342   # Elsewhere, gcc is preferred to cc.
 343 
 344   if test "x$CC" != x; then
 345     COMPILER_CHECK_LIST="$CC"
 346   elif test "x$OPENJDK_TARGET_OS" = "xwindows"; then
 347     COMPILER_CHECK_LIST="cl"
 348   elif test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
 349     COMPILER_CHECK_LIST="cc gcc"
 350   elif test "x$OPENJDK_TARGET_OS" = "xaix"; then
 351     # Do not probe for cc on AIX.
 352     COMPILER_CHECK_LIST="xlc_r"
 353   else
 354     COMPILER_CHECK_LIST="gcc cc"
 355   fi
 356 
 357   TOOLCHAIN_FIND_COMPILER([CC],[C],[$COMPILER_CHECK_LIST])
 358   # Now that we have resolved CC ourself, let autoconf have its go at it
 359   AC_PROG_CC([$CC])
 360 
 361   # Option used to tell the compiler whether to create 32- or 64-bit executables
 362   # Notice that CC contains the full compiler path at this point.
 363   case $CC in
 364     *xlc_r) COMPILER_TARGET_BITS_FLAG="-q";;
 365     *)      COMPILER_TARGET_BITS_FLAG="-m";;
 366   esac
 367   AC_SUBST(COMPILER_TARGET_BITS_FLAG)
 368 
 369   ### Locate C++ compiler (CXX)
 370 
 371   if test "x$CXX" != x; then
 372     COMPILER_CHECK_LIST="$CXX"
 373   elif test "x$OPENJDK_TARGET_OS" = "xwindows"; then
 374     COMPILER_CHECK_LIST="cl"
 375   elif test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
 376     COMPILER_CHECK_LIST="CC g++"
 377   elif test "x$OPENJDK_TARGET_OS" = "xaix"; then
 378     # Do not probe for CC on AIX .
 379     COMPILER_CHECK_LIST="xlC_r"
 380   else
 381     COMPILER_CHECK_LIST="g++ CC"
 382   fi
 383 
 384   TOOLCHAIN_FIND_COMPILER([CXX],[C++],[$COMPILER_CHECK_LIST])
 385   # Now that we have resolved CXX ourself, let autoconf have its go at it
 386   AC_PROG_CXX([$CXX])
 387 
 388   ### Locate other tools
 389 
 390   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 391     AC_PROG_OBJC
 392     BASIC_FIXUP_EXECUTABLE(OBJC)
 393   else
 394     OBJC=
 395   fi
 396 
 397   # Restore the flags to the user specified values.
 398   # This is necessary since AC_PROG_CC defaults CFLAGS to "-g -O2"
 399   CFLAGS="$ORG_CFLAGS"
 400   CXXFLAGS="$ORG_CXXFLAGS"
 401   OBJCFLAGS="$ORG_OBJCFLAGS"
 402 
 403   LD="$CC"
 404   LDEXE="$CC"
 405   LDCXX="$CXX"
 406   LDEXECXX="$CXX"
 407   AC_SUBST(LD)
 408   # LDEXE is the linker to use, when creating executables.
 409   AC_SUBST(LDEXE)
 410   # Linking C++ libraries.
 411   AC_SUBST(LDCXX)
 412   # Linking C++ executables.
 413   AC_SUBST(LDEXECXX)
 414 
 415   if test "x$OPENJDK_TARGET_OS" != xwindows; then
 416     AC_CHECK_TOOL(AR, ar)
 417     BASIC_FIXUP_EXECUTABLE(AR)
 418   fi
 419   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 420     ARFLAGS="-r"
 421   elif test "x$OPENJDK_TARGET_OS" = xaix; then
 422     ARFLAGS="-X64"
 423   else
 424     ARFLAGS=""
 425   fi
 426   AC_SUBST(ARFLAGS)
 427 
 428   # For hotspot, we need these in Windows mixed path; other platforms keep them the same
 429   HOTSPOT_CXX="$CXX"
 430   HOTSPOT_LD="$LD"
 431   AC_SUBST(HOTSPOT_CXX)
 432   AC_SUBST(HOTSPOT_LD)
 433 
 434   COMPILER_NAME=gcc
 435   COMPILER_TYPE=CC
 436   AS_IF([test "x$OPENJDK_TARGET_OS" = xwindows], [
 437     # For now, assume that we are always compiling using cl.exe.
 438     CC_OUT_OPTION=-Fo
 439     EXE_OUT_OPTION=-out:
 440     LD_OUT_OPTION=-out:
 441     AR_OUT_OPTION=-out:
 442     # On Windows, reject /usr/bin/link (as determined in CYGWIN_LINK), which is a cygwin
 443     # program for something completely different.
 444     AC_CHECK_PROG([WINLD], [link],[link],,, [$CYGWIN_LINK])
 445     # Since we must ignore the first found link, WINLD will contain
 446     # the full path to the link.exe program.
 447     BASIC_FIXUP_EXECUTABLE(WINLD)
 448     printf "Windows linker was found at $WINLD\n"
 449     AC_MSG_CHECKING([if the found link.exe is actually the Visual Studio linker])
 450     "$WINLD" --version > /dev/null
 451     if test $? -eq 0 ; then
 452       AC_MSG_RESULT([no])
 453       AC_MSG_ERROR([This is the Cygwin link tool. Please check your PATH and rerun configure.])
 454     else
 455       AC_MSG_RESULT([yes])
 456     fi
 457     LD="$WINLD"
 458     LDEXE="$WINLD"
 459     LDCXX="$WINLD"
 460     LDEXECXX="$WINLD"
 461 
 462     AC_CHECK_PROG([MT], [mt], [mt],,, [/usr/bin/mt])
 463     BASIC_FIXUP_EXECUTABLE(MT)
 464     # The resource compiler
 465     AC_CHECK_PROG([RC], [rc], [rc],,, [/usr/bin/rc])
 466     BASIC_FIXUP_EXECUTABLE(RC)
 467 
 468     # For hotspot, we need these in Windows mixed path,
 469     # so rewrite them all. Need added .exe suffix.
 470     HOTSPOT_CXX="$CXX.exe"
 471     HOTSPOT_LD="$LD.exe"
 472     HOTSPOT_MT="$MT.exe"
 473     HOTSPOT_RC="$RC.exe"
 474     BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH(HOTSPOT_CXX)
 475     BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH(HOTSPOT_LD)
 476     BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH(HOTSPOT_MT)
 477     BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH(HOTSPOT_RC)
 478     AC_SUBST(HOTSPOT_MT)
 479     AC_SUBST(HOTSPOT_RC)
 480 
 481     RC_FLAGS="-nologo -l 0x409 -r"
 482     AS_IF([test "x$VARIANT" = xOPT], [
 483     RC_FLAGS="$RC_FLAGS -d NDEBUG"
 484   ])
 485 
 486   # The version variables used to create RC_FLAGS may be overridden
 487   # in a custom configure script, or possibly the command line.
 488   # Let those variables be expanded at make time in spec.gmk.
 489   # The \$ are escaped to the shell, and the $(...) variables
 490   # are evaluated by make.
 491   RC_FLAGS="$RC_FLAGS \
 492       -d \"JDK_BUILD_ID=\$(FULL_VERSION)\" \
 493       -d \"JDK_COMPANY=\$(COMPANY_NAME)\" \
 494       -d \"JDK_COMPONENT=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) binary\" \
 495       -d \"JDK_VER=\$(JDK_MINOR_VERSION).\$(JDK_MICRO_VERSION).\$(if \$(JDK_UPDATE_VERSION),\$(JDK_UPDATE_VERSION),0).\$(COOKED_BUILD_NUMBER)\" \
 496       -d \"JDK_COPYRIGHT=Copyright \xA9 $COPYRIGHT_YEAR\" \
 497       -d \"JDK_NAME=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) \$(JDK_MINOR_VERSION) \$(JDK_UPDATE_META_TAG)\" \
 498       -d \"JDK_FVER=\$(JDK_MINOR_VERSION),\$(JDK_MICRO_VERSION),\$(if \$(JDK_UPDATE_VERSION),\$(JDK_UPDATE_VERSION),0),\$(COOKED_BUILD_NUMBER)\""
 499 
 500   # lib.exe is used to create static libraries.
 501   AC_CHECK_PROG([WINAR], [lib],[lib],,,)
 502   BASIC_FIXUP_EXECUTABLE(WINAR)
 503   AR="$WINAR"
 504   ARFLAGS="-nologo -NODEFAULTLIB:MSVCRT"
 505 
 506   AC_CHECK_PROG([DUMPBIN], [dumpbin], [dumpbin],,,)
 507       BASIC_FIXUP_EXECUTABLE(DUMPBIN)
 508 
 509       COMPILER_TYPE=CL
 510       CCXXFLAGS="$CCXXFLAGS -nologo"
 511   ])
 512   AC_SUBST(RC_FLAGS)
 513   AC_SUBST(COMPILER_TYPE)
 514 
 515   AC_PROG_CPP
 516   BASIC_FIXUP_EXECUTABLE(CPP)
 517 
 518   AC_PROG_CXXCPP
 519   BASIC_FIXUP_EXECUTABLE(CXXCPP)
 520 
 521   if test "x$COMPILE_TYPE" != "xcross"; then
 522     # If we are not cross compiling, use the same compilers for
 523     # building the build platform executables. The cross-compilation
 524     # case needed to be done earlier, but this can only be done after
 525     # the native tools have been localized.
 526     BUILD_CC="$CC"
 527     BUILD_CXX="$CXX"
 528     BUILD_LD="$LD"
 529   fi
 530 
 531   # for solaris we really need solaris tools, and not gnu equivalent
 532   #   these seems to normally reside in /usr/ccs/bin so add that to path before
 533   #   starting to probe
 534   #
 535   #   NOTE: I add this /usr/ccs/bin after TOOLS but before OLD_PATH
 536   #         so that it can be overriden --with-tools-dir
 537   if test "x$OPENJDK_BUILD_OS" = xsolaris; then
 538     PATH="${TOOLS_DIR}:/usr/ccs/bin:${OLD_PATH}"
 539   fi
 540 
 541   # Find the right assembler.
 542   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
 543     AC_PATH_PROG(AS, as)
 544     BASIC_FIXUP_EXECUTABLE(AS)
 545   else
 546     AS="$CC -c"
 547   fi
 548   AC_SUBST(AS)
 549 
 550   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
 551     AC_PATH_PROG(NM, nm)
 552     BASIC_FIXUP_EXECUTABLE(NM)
 553     AC_PATH_PROG(GNM, gnm)
 554     BASIC_FIXUP_EXECUTABLE(GNM)
 555     AC_PATH_PROG(STRIP, strip)
 556     BASIC_FIXUP_EXECUTABLE(STRIP)
 557     AC_PATH_PROG(MCS, mcs)
 558     BASIC_FIXUP_EXECUTABLE(MCS)
 559   elif test "x$OPENJDK_TARGET_OS" != xwindows; then
 560     AC_PATH_PROG(OTOOL, otool)
 561     if test "x$OTOOL" = "x"; then
 562       OTOOL="true"
 563     fi
 564     AC_CHECK_TOOL(NM, nm)
 565     BASIC_FIXUP_EXECUTABLE(NM)
 566     GNM="$NM"
 567     AC_SUBST(GNM)
 568     AC_CHECK_TOOL(STRIP, strip)
 569     BASIC_FIXUP_EXECUTABLE(STRIP)
 570   fi
 571 
 572   # objcopy is used for moving debug symbols to separate files when
 573   # full debug symbols are enabled.
 574   if test "x$OPENJDK_TARGET_OS" = xsolaris || test "x$OPENJDK_TARGET_OS" = xlinux; then
 575     AC_CHECK_TOOLS(OBJCOPY, [gobjcopy objcopy])
 576     # Only call fixup if objcopy was found.
 577     if test -n "$OBJCOPY"; then
 578       BASIC_FIXUP_EXECUTABLE(OBJCOPY)
 579     fi
 580   fi
 581 
 582   AC_CHECK_TOOLS(OBJDUMP, [gobjdump objdump])
 583   if test "x$OBJDUMP" != x; then
 584     # Only used for compare.sh; we can live without it. BASIC_FIXUP_EXECUTABLE bails if argument is missing.
 585     BASIC_FIXUP_EXECUTABLE(OBJDUMP)
 586   fi
 587 
 588   TOOLCHAIN_SETUP_JTREG
 589 
 590   # Restore old path without tools dir
 591   PATH="$OLD_PATH"
 592 ])
 593 
 594 
 595 AC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_FOR_LIBS],
 596 [
 597 
 598   ###############################################################################
 599   #
 600   # How to compile shared libraries.
 601   #
 602 
 603   if test "x$GCC" = xyes; then
 604     COMPILER_NAME=gcc
 605     PICFLAG="-fPIC"
 606     LIBRARY_PREFIX=lib
 607     SHARED_LIBRARY='lib[$]1.so'
 608     STATIC_LIBRARY='lib[$]1.a'
 609     SHARED_LIBRARY_FLAGS="-shared"
 610     SHARED_LIBRARY_SUFFIX='.so'
 611     STATIC_LIBRARY_SUFFIX='.a'
 612     OBJ_SUFFIX='.o'
 613     EXE_SUFFIX=''
 614     SET_SHARED_LIBRARY_NAME='-Xlinker -soname=[$]1'
 615     SET_SHARED_LIBRARY_MAPFILE='-Xlinker -version-script=[$]1'
 616     C_FLAG_REORDER=''
 617     CXX_FLAG_REORDER=''
 618     SET_SHARED_LIBRARY_ORIGIN='-Xlinker -z -Xlinker origin -Xlinker -rpath -Xlinker \$$$$ORIGIN[$]1'
 619     SET_EXECUTABLE_ORIGIN='-Xlinker -rpath -Xlinker \$$$$ORIGIN[$]1'
 620     LD="$CC"
 621     LDEXE="$CC"
 622     LDCXX="$CXX"
 623     LDEXECXX="$CXX"
 624     POST_STRIP_CMD="$STRIP -g"
 625 
 626     # Linking is different on MacOSX
 627     if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 628       # Might change in the future to clang.
 629       COMPILER_NAME=gcc
 630       SHARED_LIBRARY='lib[$]1.dylib'
 631       SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG"
 632       SHARED_LIBRARY_SUFFIX='.dylib'
 633       EXE_SUFFIX=''
 634       SET_SHARED_LIBRARY_NAME='-Xlinker -install_name -Xlinker @rpath/[$]1'
 635       SET_SHARED_LIBRARY_MAPFILE=''
 636       SET_SHARED_LIBRARY_ORIGIN='-Xlinker -rpath -Xlinker @loader_path/.'
 637       SET_EXECUTABLE_ORIGIN="$SET_SHARED_LIBRARY_ORIGIN"
 638       POST_STRIP_CMD="$STRIP -S"
 639     fi
 640   else
 641     if test "x$OPENJDK_TARGET_OS" = xsolaris; then
 642       # If it is not gcc, then assume it is the Oracle Solaris Studio Compiler
 643       COMPILER_NAME=ossc
 644       PICFLAG="-KPIC"
 645       LIBRARY_PREFIX=lib
 646       SHARED_LIBRARY='lib[$]1.so'
 647       STATIC_LIBRARY='lib[$]1.a'
 648       SHARED_LIBRARY_FLAGS="-G"
 649       SHARED_LIBRARY_SUFFIX='.so'
 650       STATIC_LIBRARY_SUFFIX='.a'
 651       OBJ_SUFFIX='.o'
 652       EXE_SUFFIX=''
 653       SET_SHARED_LIBRARY_NAME=''
 654       SET_SHARED_LIBRARY_MAPFILE='-M[$]1'
 655       C_FLAG_REORDER='-xF'
 656       CXX_FLAG_REORDER='-xF'
 657       SET_SHARED_LIBRARY_ORIGIN='-R\$$$$ORIGIN[$]1'
 658       SET_EXECUTABLE_ORIGIN="$SET_SHARED_LIBRARY_ORIGIN"
 659       CFLAGS_JDK="${CFLAGS_JDK} -D__solaris__"
 660       CXXFLAGS_JDK="${CXXFLAGS_JDK} -D__solaris__"
 661       CFLAGS_JDKLIB_EXTRA='-xstrconst'
 662       POST_STRIP_CMD="$STRIP -x"
 663       POST_MCS_CMD="$MCS -d -a \"JDK $FULL_VERSION\""
 664     fi
 665     if test "x$OPENJDK_TARGET_OS" = xaix; then
 666         COMPILER_NAME=xlc
 667         PICFLAG="-qpic=large"
 668         LIBRARY_PREFIX=lib
 669         SHARED_LIBRARY='lib[$]1.so'
 670         STATIC_LIBRARY='lib[$]1.a'
 671         SHARED_LIBRARY_FLAGS="-qmkshrobj"
 672         SHARED_LIBRARY_SUFFIX='.so'
 673         STATIC_LIBRARY_SUFFIX='.a'
 674         OBJ_SUFFIX='.o'
 675         EXE_SUFFIX=''
 676         SET_SHARED_LIBRARY_NAME=''
 677         SET_SHARED_LIBRARY_MAPFILE=''
 678         C_FLAG_REORDER=''
 679         CXX_FLAG_REORDER=''
 680         SET_SHARED_LIBRARY_ORIGIN=''
 681         SET_EXECUTABLE_ORIGIN=""
 682         CFLAGS_JDK=""
 683         CXXFLAGS_JDK=""
 684         CFLAGS_JDKLIB_EXTRA=''
 685         POST_STRIP_CMD="$STRIP -X32_64"
 686         POST_MCS_CMD=""
 687     fi
 688     if test "x$OPENJDK_TARGET_OS" = xwindows; then
 689       # If it is not gcc, then assume it is the MS Visual Studio compiler
 690       COMPILER_NAME=cl
 691       PICFLAG=""
 692       LIBRARY_PREFIX=
 693       SHARED_LIBRARY='[$]1.dll'
 694       STATIC_LIBRARY='[$]1.lib'
 695       SHARED_LIBRARY_FLAGS="-LD"
 696       SHARED_LIBRARY_SUFFIX='.dll'
 697       STATIC_LIBRARY_SUFFIX='.lib'
 698       OBJ_SUFFIX='.obj'
 699       EXE_SUFFIX='.exe'
 700       SET_SHARED_LIBRARY_NAME=''
 701       SET_SHARED_LIBRARY_MAPFILE=''
 702       SET_SHARED_LIBRARY_ORIGIN=''
 703       SET_EXECUTABLE_ORIGIN=''
 704     fi
 705   fi
 706 
 707   AC_SUBST(COMPILER_NAME)
 708   AC_SUBST(OBJ_SUFFIX)
 709   AC_SUBST(SHARED_LIBRARY)
 710   AC_SUBST(STATIC_LIBRARY)
 711   AC_SUBST(LIBRARY_PREFIX)
 712   AC_SUBST(SHARED_LIBRARY_SUFFIX)
 713   AC_SUBST(STATIC_LIBRARY_SUFFIX)
 714   AC_SUBST(EXE_SUFFIX)
 715   AC_SUBST(SHARED_LIBRARY_FLAGS)
 716   AC_SUBST(SET_SHARED_LIBRARY_NAME)
 717   AC_SUBST(SET_SHARED_LIBRARY_MAPFILE)
 718   AC_SUBST(C_FLAG_REORDER)
 719   AC_SUBST(CXX_FLAG_REORDER)
 720   AC_SUBST(SET_SHARED_LIBRARY_ORIGIN)
 721   AC_SUBST(SET_EXECUTABLE_ORIGIN)
 722   AC_SUBST(POST_STRIP_CMD)
 723   AC_SUBST(POST_MCS_CMD)
 724 
 725   # The (cross) compiler is now configured, we can now test capabilities
 726   # of the target platform.
 727 ])
 728 
 729 AC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
 730 [
 731 
 732   ###############################################################################
 733   #
 734   # Setup the opt flags for different compilers
 735   # and different operating systems.
 736   #
 737 
 738   #
 739   # NOTE: check for -mstackrealign needs to be below potential addition of -m32
 740   #
 741   if test "x$OPENJDK_TARGET_CPU_BITS" = x32 && test "x$OPENJDK_TARGET_OS" = xmacosx; then
 742     # On 32-bit MacOSX the OS requires C-entry points to be 16 byte aligned.
 743     # While waiting for a better solution, the current workaround is to use -mstackrealign.
 744     CFLAGS="$CFLAGS -mstackrealign"
 745     AC_MSG_CHECKING([if 32-bit compiler supports -mstackrealign])
 746     AC_LINK_IFELSE([AC_LANG_SOURCE([[int main() { return 0; }]])],
 747         [
 748           AC_MSG_RESULT([yes])
 749         ],
 750         [
 751           AC_MSG_RESULT([no])
 752           AC_MSG_ERROR([The selected compiler $CXX does not support -mstackrealign! Try to put another compiler in the path.])
 753         ]
 754     )
 755   fi
 756 
 757   C_FLAG_DEPS="-MMD -MF"
 758   CXX_FLAG_DEPS="-MMD -MF"
 759 
 760   case $COMPILER_TYPE in
 761     CC )
 762       case $COMPILER_NAME in
 763         gcc )
 764           case $OPENJDK_TARGET_OS in
 765             macosx )
 766               # On MacOSX we optimize for size, something
 767               # we should do for all platforms?
 768               C_O_FLAG_HI="-Os"
 769               C_O_FLAG_NORM="-Os"
 770               C_O_FLAG_NONE=""
 771               ;;
 772             *)
 773               C_O_FLAG_HI="-O3"
 774               C_O_FLAG_NORM="-O2"
 775               C_O_FLAG_NONE="-O0"
 776               ;;
 777           esac
 778           CXX_O_FLAG_HI="$C_O_FLAG_HI"
 779           CXX_O_FLAG_NORM="$C_O_FLAG_NORM"
 780           CXX_O_FLAG_NONE="$C_O_FLAG_NONE"
 781           CFLAGS_DEBUG_SYMBOLS="-g"
 782           CXXFLAGS_DEBUG_SYMBOLS="-g"
 783           if test "x$OPENJDK_TARGET_CPU_BITS" = "x64" && test "x$DEBUG_LEVEL" = "xfastdebug"; then
 784             CFLAGS_DEBUG_SYMBOLS="-g1"
 785             CXXFLAGS_DEBUG_SYMBOLS="-g1"
 786           fi
 787           ;;
 788         ossc )
 789           #
 790           # Forte has different names for this with their C++ compiler...
 791           #
 792           C_FLAG_DEPS="-xMMD -xMF"
 793           CXX_FLAG_DEPS="-xMMD -xMF"
 794 
 795           # Extra options used with HIGHEST
 796           #
 797           # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
 798           #          done with care, there are some assumptions below that need to
 799           #          be understood about the use of pointers, and IEEE behavior.
 800           #
 801           # Use non-standard floating point mode (not IEEE 754)
 802           CC_HIGHEST="$CC_HIGHEST -fns"
 803           # Do some simplification of floating point arithmetic (not IEEE 754)
 804           CC_HIGHEST="$CC_HIGHEST -fsimple"
 805           # Use single precision floating point with 'float'
 806           CC_HIGHEST="$CC_HIGHEST -fsingle"
 807           # Assume memory references via basic pointer types do not alias
 808           #   (Source with excessing pointer casting and data access with mixed
 809           #    pointer types are not recommended)
 810           CC_HIGHEST="$CC_HIGHEST -xalias_level=basic"
 811           # Use intrinsic or inline versions for math/std functions
 812           #   (If you expect perfect errno behavior, do not use this)
 813           CC_HIGHEST="$CC_HIGHEST -xbuiltin=%all"
 814           # Loop data dependency optimizations (need -xO3 or higher)
 815           CC_HIGHEST="$CC_HIGHEST -xdepend"
 816           # Pointer parameters to functions do not overlap
 817           #   (Similar to -xalias_level=basic usage, but less obvious sometimes.
 818           #    If you pass in multiple pointers to the same data, do not use this)
 819           CC_HIGHEST="$CC_HIGHEST -xrestrict"
 820           # Inline some library routines
 821           #   (If you expect perfect errno behavior, do not use this)
 822           CC_HIGHEST="$CC_HIGHEST -xlibmil"
 823           # Use optimized math routines
 824           #   (If you expect perfect errno behavior, do not use this)
 825           #  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
 826           #CC_HIGHEST="$CC_HIGHEST -xlibmopt"
 827 
 828           if test "x$OPENJDK_TARGET_CPU" = xsparc; then
 829             CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
 830             CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
 831           fi
 832 
 833           case $OPENJDK_TARGET_CPU_ARCH in
 834             x86)
 835               C_O_FLAG_HIGHEST="-xO4 -Wu,-O4~yz $CC_HIGHEST -xregs=no%frameptr"
 836               C_O_FLAG_HI="-xO4 -Wu,-O4~yz -xregs=no%frameptr"
 837               C_O_FLAG_NORM="-xO2 -Wu,-O2~yz -xregs=no%frameptr"
 838               C_O_FLAG_NONE="-xregs=no%frameptr"
 839               CXX_O_FLAG_HIGHEST="-xO4 -Qoption ube -O4~yz $CC_HIGHEST -xregs=no%frameptr"
 840               CXX_O_FLAG_HI="-xO4 -Qoption ube -O4~yz -xregs=no%frameptr"
 841               CXX_O_FLAG_NORM="-xO2 -Qoption ube -O2~yz -xregs=no%frameptr"
 842               CXX_O_FLAG_NONE="-xregs=no%frameptr"
 843               if test "x$OPENJDK_TARGET_CPU" = xx86; then
 844                 C_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST -xchip=pentium"
 845                 CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HIGHEST -xchip=pentium"
 846               fi
 847               ;;
 848             sparc)
 849               CFLAGS_JDKLIB_EXTRA="${CFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
 850               CXXFLAGS_JDKLIB_EXTRA="${CXXFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
 851               C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra"
 852               C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0"
 853               C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0"
 854               C_O_FLAG_NONE=""
 855               CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra"
 856               CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
 857               CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
 858               CXX_O_FLAG_NONE=""
 859               ;;
 860           esac
 861 
 862           CFLAGS_DEBUG_SYMBOLS="-g -xs"
 863           CXXFLAGS_DEBUG_SYMBOLS="-g0 -xs"
 864           ;;
 865         xlc )
 866           C_FLAG_DEPS="-qmakedep=gcc -MF"
 867           CXX_FLAG_DEPS="-qmakedep=gcc -MF"
 868           C_O_FLAG_HIGHEST="-O3"
 869           C_O_FLAG_HI="-O3 -qstrict"
 870           C_O_FLAG_NORM="-O2"
 871           C_O_FLAG_NONE=""
 872           CXX_O_FLAG_HIGHEST="-O3"
 873           CXX_O_FLAG_HI="-O3 -qstrict"
 874           CXX_O_FLAG_NORM="-O2"
 875           CXX_O_FLAG_NONE=""
 876           CFLAGS_DEBUG_SYMBOLS="-g"
 877           CXXFLAGS_DEBUG_SYMBOLS="-g"
 878           LDFLAGS_JDK="${LDFLAGS_JDK} -q64 -brtl -bnolibpath -liconv -bexpall"
 879           CFLAGS_JDK="${CFLAGS_JDK} -qchars=signed -q64 -qfullpath -qsaveopt"
 880           CXXFLAGS_JDK="${CXXFLAGS_JDK} -qchars=signed -q64 -qfullpath -qsaveopt"
 881           ;;
 882       esac
 883       ;;
 884     CL )
 885       C_O_FLAG_HIGHEST="-O2"
 886       C_O_FLAG_HI="-O1"
 887       C_O_FLAG_NORM="-O1"
 888       C_O_FLAG_NONE="-Od"
 889       CXX_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST"
 890       CXX_O_FLAG_HI="$C_O_FLAG_HI"
 891       CXX_O_FLAG_NORM="$C_O_FLAG_NORM"
 892       CXX_O_FLAG_NONE="$C_O_FLAG_NONE"
 893       ;;
 894   esac
 895 
 896   if test -z "$C_O_FLAG_HIGHEST"; then
 897     C_O_FLAG_HIGHEST="$C_O_FLAG_HI"
 898   fi
 899 
 900   if test -z "$CXX_O_FLAG_HIGHEST"; then
 901     CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HI"
 902   fi
 903 
 904   AC_SUBST(C_O_FLAG_HIGHEST)
 905   AC_SUBST(C_O_FLAG_HI)
 906   AC_SUBST(C_O_FLAG_NORM)
 907   AC_SUBST(C_O_FLAG_NONE)
 908   AC_SUBST(CXX_O_FLAG_HIGHEST)
 909   AC_SUBST(CXX_O_FLAG_HI)
 910   AC_SUBST(CXX_O_FLAG_NORM)
 911   AC_SUBST(CXX_O_FLAG_NONE)
 912   AC_SUBST(C_FLAG_DEPS)
 913   AC_SUBST(CXX_FLAG_DEPS)
 914 ])
 915 
 916 AC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_FOR_JDK],
 917 [
 918 
 919   if test "x$CFLAGS" != "x${ADDED_CFLAGS}"; then
 920     AC_MSG_WARN([Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags])
 921   fi
 922 
 923   if test "x$CXXFLAGS" != "x${ADDED_CXXFLAGS}"; then
 924     AC_MSG_WARN([Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags])
 925   fi
 926 
 927   if test "x$LDFLAGS" != "x${ADDED_LDFLAGS}"; then
 928     AC_MSG_WARN([Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags])
 929   fi
 930 
 931   AC_ARG_WITH(extra-cflags, [AS_HELP_STRING([--with-extra-cflags],
 932       [extra flags to be used when compiling jdk c-files])])
 933 
 934   AC_ARG_WITH(extra-cxxflags, [AS_HELP_STRING([--with-extra-cxxflags],
 935       [extra flags to be used when compiling jdk c++-files])])
 936 
 937   AC_ARG_WITH(extra-ldflags, [AS_HELP_STRING([--with-extra-ldflags],
 938       [extra flags to be used when linking jdk])])
 939 
 940   CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags"
 941   CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags"
 942   LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags"
 943 
 944   # Hotspot needs these set in their legacy form
 945   LEGACY_EXTRA_CFLAGS=$with_extra_cflags
 946   LEGACY_EXTRA_CXXFLAGS=$with_extra_cxxflags
 947   LEGACY_EXTRA_LDFLAGS=$with_extra_ldflags
 948 
 949   AC_SUBST(LEGACY_EXTRA_CFLAGS)
 950   AC_SUBST(LEGACY_EXTRA_CXXFLAGS)
 951   AC_SUBST(LEGACY_EXTRA_LDFLAGS)
 952 
 953   ###############################################################################
 954   #
 955   # Now setup the CFLAGS and LDFLAGS for the JDK build.
 956   # Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build.
 957   #
 958   case $COMPILER_NAME in
 959     gcc )
 960       CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -W -Wall -Wno-unused -Wno-parentheses \
 961       -pipe \
 962       -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
 963       case $OPENJDK_TARGET_CPU_ARCH in
 964         arm )
 965           # on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing
 966           CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
 967           ;;
 968         ppc )
 969           # on ppc we don't prevent gcc to omit frame pointer nor strict-aliasing
 970           ;;
 971         * )
 972           CCXXFLAGS_JDK="$CCXXFLAGS_JDK -fno-omit-frame-pointer"
 973           CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
 974           ;;
 975       esac
 976       ;;
 977     ossc )
 978       CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
 979       case $OPENJDK_TARGET_CPU_ARCH in
 980         x86 )
 981           CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
 982           CFLAGS_JDK="$CFLAGS_JDK -erroff=E_BAD_PRAGMA_PACK_VALUE"
 983           ;;
 984       esac
 985 
 986       CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
 987       CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
 988 
 989       LDFLAGS_JDK="$LDFLAGS_JDK -z defs -xildoff -ztext"
 990       LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK -norunpath -xnolib"
 991       ;;
 992     xlc )
 993       CFLAGS_JDK="$CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
 994       CXXFLAGS_JDK="$CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
 995 
 996       LDFLAGS_JDK="$LDFLAGS_JDK"
 997       LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK"
 998       ;;
 999     cl )
1000       CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \
1001       -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \
1002       -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
1003       -DWIN32 -DIAL"
1004       case $OPENJDK_TARGET_CPU in
1005         x86 )
1006           CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_X86_ -Dx86"
1007           ;;
1008         x86_64 )
1009           CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_AMD64_ -Damd64"
1010           ;;
1011       esac
1012       ;;
1013   esac
1014 
1015   ###############################################################################
1016 
1017   # Adjust flags according to debug level.
1018   case $DEBUG_LEVEL in
1019     fastdebug )
1020       CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS"
1021       CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS"
1022       C_O_FLAG_HI="$C_O_FLAG_NORM"
1023       C_O_FLAG_NORM="$C_O_FLAG_NORM"
1024       CXX_O_FLAG_HI="$CXX_O_FLAG_NORM"
1025       CXX_O_FLAG_NORM="$CXX_O_FLAG_NORM"
1026       JAVAC_FLAGS="$JAVAC_FLAGS -g"
1027       ;;
1028     slowdebug )
1029       CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS"
1030       CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS"
1031       C_O_FLAG_HI="$C_O_FLAG_NONE"
1032       C_O_FLAG_NORM="$C_O_FLAG_NONE"
1033       CXX_O_FLAG_HI="$CXX_O_FLAG_NONE"
1034       CXX_O_FLAG_NORM="$CXX_O_FLAG_NONE"
1035       JAVAC_FLAGS="$JAVAC_FLAGS -g"
1036       ;;
1037   esac
1038 
1039   CCXXFLAGS_JDK="$CCXXFLAGS_JDK $ADD_LP64"
1040 
1041   # The package path is used only on macosx?
1042   PACKAGE_PATH=/opt/local
1043   AC_SUBST(PACKAGE_PATH)
1044 
1045   if test "x$OPENJDK_TARGET_CPU_ENDIAN" = xlittle; then
1046     # The macro _LITTLE_ENDIAN needs to be defined the same to avoid the
1047     #   Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN
1048     #   (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h).
1049     #   Note: -Dmacro         is the same as    #define macro 1
1050     #         -Dmacro=        is the same as    #define macro
1051     if test "x$OPENJDK_TARGET_OS" = xsolaris; then
1052       CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
1053     else
1054       CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
1055     fi
1056   else
1057     CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN"
1058   fi
1059   if test "x$OPENJDK_TARGET_OS" = xlinux; then
1060     CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DLINUX"
1061   fi
1062   if test "x$OPENJDK_TARGET_OS" = xwindows; then
1063     CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DWINDOWS"
1064   fi
1065   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
1066     CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DSOLARIS"
1067   fi
1068   if test "x$OPENJDK_TARGET_OS" = xaix; then
1069     CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DAIX -DPPC64"
1070   fi
1071   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
1072     CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMACOSX -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
1073     # Setting these parameters makes it an error to link to macosx APIs that are
1074     # newer than the given OS version and makes the linked binaries compatible even
1075     # if built on a newer version of the OS.
1076     # The expected format is X.Y.Z
1077     MACOSX_VERSION_MIN=10.7.0
1078     AC_SUBST(MACOSX_VERSION_MIN)
1079     # The macro takes the version with no dots, ex: 1070
1080     # Let the flags variables get resolved in make for easier override on make
1081     # command line.
1082     CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
1083     LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
1084   fi
1085   if test "x$OPENJDK_TARGET_OS" = xbsd; then
1086     CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DBSD -D_ALLBSD_SOURCE"
1087   fi
1088   if test "x$DEBUG_LEVEL" = xrelease; then
1089     CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DNDEBUG"
1090   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
1091     CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DTRIMMED"
1092   fi
1093   else
1094     CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DDEBUG"
1095   fi
1096 
1097   CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DARCH='\"$OPENJDK_TARGET_CPU_LEGACY\"' -D$OPENJDK_TARGET_CPU_LEGACY"
1098   CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DRELEASE='\"\$(RELEASE)\"'"
1099 
1100   CCXXFLAGS_JDK="$CCXXFLAGS_JDK \
1101       -I${JDK_OUTPUTDIR}/include \
1102       -I${JDK_OUTPUTDIR}/include/$OPENJDK_TARGET_OS \
1103       -I${JDK_TOPDIR}/src/share/javavm/export \
1104       -I${JDK_TOPDIR}/src/$OPENJDK_TARGET_OS_EXPORT_DIR/javavm/export \
1105       -I${JDK_TOPDIR}/src/share/native/common \
1106       -I${JDK_TOPDIR}/src/$OPENJDK_TARGET_OS_API_DIR/native/common"
1107 
1108   # The shared libraries are compiled using the picflag.
1109   CFLAGS_JDKLIB="$CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
1110   CXXFLAGS_JDKLIB="$CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA "
1111 
1112   # Executable flags
1113   CFLAGS_JDKEXE="$CCXXFLAGS_JDK $CFLAGS_JDK"
1114   CXXFLAGS_JDKEXE="$CCXXFLAGS_JDK $CXXFLAGS_JDK"
1115 
1116   # Now this is odd. The JDK native libraries have to link against libjvm.so
1117   # On 32-bit machines there is normally two distinct libjvm.so:s, client and server.
1118   # Which should we link to? Are we lucky enough that the binary api to the libjvm.so library
1119   # is identical for client and server? Yes. Which is picked at runtime (client or server)?
1120   # Neither, since the chosen libjvm.so has already been loaded by the launcher, all the following
1121   # libraries will link to whatever is in memory. Yuck.
1122   #
1123   # Thus we offer the compiler to find libjvm.so first in server then in client. It works. Ugh.
1124   if test "x$COMPILER_NAME" = xcl; then
1125     LDFLAGS_JDK="$LDFLAGS_JDK -nologo -opt:ref -incremental:no"
1126     if test "x$OPENJDK_TARGET_CPU" = xx86; then
1127       LDFLAGS_JDK="$LDFLAGS_JDK -safeseh"
1128     fi
1129     # TODO: make -debug optional "--disable-full-debug-symbols"
1130     LDFLAGS_JDK="$LDFLAGS_JDK -debug"
1131     LDFLAGS_JDKLIB="${LDFLAGS_JDK} -dll -libpath:${JDK_OUTPUTDIR}/lib"
1132     LDFLAGS_JDKLIB_SUFFIX=""
1133     if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
1134       LDFLAGS_STACK_SIZE=1048576
1135     else
1136       LDFLAGS_STACK_SIZE=327680
1137     fi
1138     LDFLAGS_JDKEXE="${LDFLAGS_JDK} /STACK:$LDFLAGS_STACK_SIZE"
1139   else
1140     if test "x$COMPILER_NAME" = xgcc; then
1141       # If this is a --hash-style=gnu system, use --hash-style=both, why?
1142       HAS_GNU_HASH=`$CC -dumpspecs 2>/dev/null | $GREP 'hash-style=gnu'`
1143       if test -n "$HAS_GNU_HASH"; then
1144         LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker --hash-style=both "
1145       fi
1146       if test "x$OPENJDK_TARGET_OS" = xlinux; then
1147         # And since we now know that the linker is gnu, then add -z defs, to forbid
1148         # undefined symbols in object files.
1149         LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -z -Xlinker defs"
1150         if test "x$DEBUG_LEVEL" = "xrelease"; then
1151           # When building release libraries, tell the linker optimize them.
1152           # Should this be supplied to the OSS linker as well?
1153           LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -O1"
1154         fi
1155       fi
1156     fi
1157     LDFLAGS_JDKLIB="${LDFLAGS_JDK} $SHARED_LIBRARY_FLAGS \
1158         -L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}"
1159 
1160     # On some platforms (mac) the linker warns about non existing -L dirs.
1161     # Add server first if available. Linking aginst client does not always produce the same results.
1162     # Only add client dir if client is being built. Add minimal (note not minimal1) if only building minimal1.
1163     # Default to server for other variants.
1164     if test "x$JVM_VARIANT_SERVER" = xtrue; then
1165       LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}/server"
1166     elif test "x$JVM_VARIANT_CLIENT" = xtrue; then
1167       LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}/client"
1168     elif test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
1169       LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}/minimal"
1170     else
1171       LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}/server"
1172     fi
1173 
1174     LDFLAGS_JDKLIB_SUFFIX="-ljava -ljvm"
1175     if test "x$COMPILER_NAME" = xossc; then
1176       LDFLAGS_JDKLIB_SUFFIX="$LDFLAGS_JDKLIB_SUFFIX -lc"
1177     fi
1178 
1179     LDFLAGS_JDKEXE="${LDFLAGS_JDK}"
1180     if test "x$OPENJDK_TARGET_OS" = xlinux; then
1181       LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -Xlinker --allow-shlib-undefined"
1182     fi
1183   fi
1184 
1185   AC_SUBST(CFLAGS_JDKLIB)
1186   AC_SUBST(CFLAGS_JDKEXE)
1187 
1188   AC_SUBST(CXXFLAGS_JDKLIB)
1189   AC_SUBST(CXXFLAGS_JDKEXE)
1190 
1191   AC_SUBST(LDFLAGS_JDKLIB)
1192   AC_SUBST(LDFLAGS_JDKEXE)
1193   AC_SUBST(LDFLAGS_JDKLIB_SUFFIX)
1194   AC_SUBST(LDFLAGS_JDKEXE_SUFFIX)
1195   AC_SUBST(LDFLAGS_CXX_JDK)
1196 ])
1197 
1198 
1199 # TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
1200 #                                   [RUN-IF-FALSE])
1201 # ------------------------------------------------------------
1202 # Check that the c and c++ compilers support an argument
1203 AC_DEFUN([TOOLCHAIN_COMPILER_CHECK_ARGUMENTS],
1204 [
1205   AC_MSG_CHECKING([if compiler supports "$1"])
1206   supports=yes
1207 
1208   saved_cflags="$CFLAGS"
1209   CFLAGS="$CFLAGS $1"
1210   AC_LANG_PUSH([C])
1211   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [], 
1212       [supports=no])
1213   AC_LANG_POP([C])
1214   CFLAGS="$saved_cflags"
1215 
1216   saved_cxxflags="$CXXFLAGS"
1217   CXXFLAGS="$CXXFLAG $1"
1218   AC_LANG_PUSH([C++])
1219   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [], 
1220       [supports=no])
1221   AC_LANG_POP([C++])
1222   CXXFLAGS="$saved_cxxflags"
1223 
1224   AC_MSG_RESULT([$supports])
1225   if test "x$supports" = "xyes" ; then
1226     m4_ifval([$2], [$2], [:])
1227   else
1228     m4_ifval([$3], [$3], [:])
1229   fi
1230 ])
1231 
1232 AC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_MISC],
1233 [
1234   # Some Zero and Shark settings.
1235   # ZERO_ARCHFLAG tells the compiler which mode to build for
1236   case "${OPENJDK_TARGET_CPU}" in
1237     s390)
1238       ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}31"
1239       ;;
1240     *)
1241       ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
1242   esac
1243   TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([$ZERO_ARCHFLAG], [], [ZERO_ARCHFLAG=""])
1244   AC_SUBST(ZERO_ARCHFLAG)
1245 
1246   # Check that the compiler supports -mX (or -qX on AIX) flags
1247   # Set COMPILER_SUPPORTS_TARGET_BITS_FLAG to 'true' if it does
1248   TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}],
1249       [COMPILER_SUPPORTS_TARGET_BITS_FLAG=true],
1250       [COMPILER_SUPPORTS_TARGET_BITS_FLAG=false])
1251   AC_SUBST(COMPILER_SUPPORTS_TARGET_BITS_FLAG)
1252 
1253 
1254   # Check for broken SuSE 'ld' for which 'Only anonymous version tag is allowed in executable.'
1255   USING_BROKEN_SUSE_LD=no
1256   if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$GCC" = xyes; then
1257     AC_MSG_CHECKING([for broken SuSE 'ld' which only understands anonymous version tags in executables])
1258     echo "SUNWprivate_1.1 { local: *; };" > version-script.map
1259     echo "int main() { }" > main.c
1260     if $CXX -Xlinker -version-script=version-script.map main.c 2>&AS_MESSAGE_LOG_FD >&AS_MESSAGE_LOG_FD; then
1261       AC_MSG_RESULT(no)
1262       USING_BROKEN_SUSE_LD=no
1263     else
1264       AC_MSG_RESULT(yes)
1265       USING_BROKEN_SUSE_LD=yes
1266     fi
1267     rm -rf version-script.map main.c
1268   fi
1269   AC_SUBST(USING_BROKEN_SUSE_LD)
1270 ])
1271 
1272 # Setup the JTREG paths
1273 AC_DEFUN_ONCE([TOOLCHAIN_SETUP_JTREG],
1274 [
1275   AC_ARG_WITH(jtreg, [AS_HELP_STRING([--with-jtreg],
1276       [Regression Test Harness @<:@probed@:>@])],
1277       [],
1278       [with_jtreg=no])
1279 
1280   if test "x$with_jtreg" = xno; then
1281     # jtreg disabled
1282     AC_MSG_CHECKING([for jtreg])
1283     AC_MSG_RESULT(no)
1284   else
1285     if test "x$with_jtreg" != xyes; then
1286       # with path specified.
1287       JT_HOME="$with_jtreg"
1288     fi
1289 
1290     if test "x$JT_HOME" != x; then
1291       AC_MSG_CHECKING([for jtreg])
1292 
1293       # use JT_HOME enviroment var.
1294       BASIC_FIXUP_PATH([JT_HOME])
1295 
1296       # jtreg win32 script works for everybody
1297       JTREGEXE="$JT_HOME/win32/bin/jtreg"
1298 
1299       if test ! -f "$JTREGEXE"; then
1300         AC_MSG_ERROR([JTReg executable does not exist: $JTREGEXE])
1301       fi
1302 
1303       AC_MSG_RESULT($JTREGEXE)
1304     else
1305       # try to find jtreg on path
1306       BASIC_REQUIRE_PROG(JTREGEXE, jtreg)
1307       JT_HOME="`$DIRNAME $JTREGEXE`"
1308     fi
1309   fi
1310 
1311   AC_SUBST(JT_HOME)
1312   AC_SUBST(JTREGEXE)
1313 ])