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