toolchain.m4 revision 697:e1a929afcfc4
1189251Ssam# 2189251Ssam# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. 3189251Ssam# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4189251Ssam# 5252726Srpaulo# This code is free software; you can redistribute it and/or modify it 6252726Srpaulo# under the terms of the GNU General Public License version 2 only, as 7189251Ssam# published by the Free Software Foundation. Oracle designates this 8189251Ssam# particular file as subject to the "Classpath" exception as provided 9189251Ssam# by Oracle in the LICENSE file that accompanied this code. 10189251Ssam# 11289549Srpaulo# This code is distributed in the hope that it will be useful, but WITHOUT 12189251Ssam# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13189251Ssam# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14189251Ssam# version 2 for more details (a copy is included in the LICENSE file that 15189251Ssam# accompanied this code). 16189251Ssam# 17189251Ssam# You should have received a copy of the GNU General Public License version 18189251Ssam# 2 along with this work; if not, write to the Free Software Foundation, 19189251Ssam# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20189251Ssam# 21189251Ssam# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22189251Ssam# or visit www.oracle.com if you need additional information or have any 23189251Ssam# questions. 24189251Ssam# 25189251Ssam 26189251Ssam# $1 = compiler to test (CC or CXX) 27252726Srpaulo# $2 = human readable name of compiler (C or C++) 28189251SsamAC_DEFUN([TOOLCHAIN_CHECK_COMPILER_VERSION], 29189251Ssam[ 30189251Ssam COMPILER=[$]$1 31189251Ssam COMPILER_NAME=$2 32189251Ssam 33189251Ssam if test "x$OPENJDK_TARGET_OS" = xsolaris; then 34189251Ssam # Make sure we use the Sun Studio compiler and not gcc on Solaris, which won't work 35189251Ssam COMPILER_VERSION_TEST=`$COMPILER -V 2>&1 | $HEAD -n 1` 36189251Ssam $ECHO $COMPILER_VERSION_TEST | $GREP "^.*: Sun $COMPILER_NAME" > /dev/null 37189251Ssam if test $? -ne 0; then 38189251Ssam GCC_VERSION_TEST=`$COMPILER --version 2>&1 | $HEAD -n 1` 39189251Ssam 40281806Srpaulo AC_MSG_NOTICE([The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required Sun Studio compiler.]) 41281806Srpaulo AC_MSG_NOTICE([The result from running with -V was: "$COMPILER_VERSION_TEST" and with --version: "$GCC_VERSION_TEST"]) 42281806Srpaulo AC_MSG_ERROR([Sun Studio compiler is required. Try setting --with-tools-dir.]) 43281806Srpaulo else 44281806Srpaulo COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.*@<:@ ,\t@:>@$COMPILER_NAME@<:@ ,\t@:>@\(@<:@1-9@:>@\.@<:@0-9@:>@@<:@0-9@:>@*\).*/\1/p"` 45281806Srpaulo COMPILER_VENDOR="Sun Studio" 46281806Srpaulo fi 47281806Srpaulo elif test "x$OPENJDK_TARGET_OS" = xwindows; then 48281806Srpaulo # First line typically looks something like: 49281806Srpaulo # Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.30319.01 for 80x86 50281806Srpaulo COMPILER_VERSION_TEST=`$COMPILER 2>&1 | $HEAD -n 1` 51281806Srpaulo COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.*Version \(@<:@1-9@:>@@<:@0-9.@:>@*\) .*/\1/p"` 52281806Srpaulo COMPILER_VENDOR="Microsoft CL.EXE" 53281806Srpaulo COMPILER_CPU_TEST=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.* for \(.*\)$/\1/p"` 54281806Srpaulo if test "x$OPENJDK_TARGET_CPU" = "xx86"; then 55281806Srpaulo if test "x$COMPILER_CPU_TEST" != "x80x86"; then 56281806Srpaulo AC_MSG_ERROR([Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for "$COMPILER_CPU_TEST"; expected "80x86".]) 57281806Srpaulo fi 58281806Srpaulo elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then 59189251Ssam if test "x$COMPILER_CPU_TEST" != "xx64"; then 60214734Srpaulo AC_MSG_ERROR([Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for "$COMPILER_CPU_TEST"; expected "x64".]) 61189251Ssam fi 62189251Ssam fi 63189251Ssam else 64189251Ssam COMPILER_VERSION_TEST=`$COMPILER --version 2>&1 | $HEAD -n 1` 65189251Ssam # Check that this is likely to be GCC. 66189251Ssam $COMPILER --version 2>&1 | $GREP "Free Software Foundation" > /dev/null 67281806Srpaulo if test $? -ne 0; then 68281806Srpaulo AC_MSG_NOTICE([The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required GCC compiler.]) 69189251Ssam AC_MSG_NOTICE([The result from running with --version was: "$COMPILER_VERSION_TEST"]) 70189251Ssam AC_MSG_ERROR([GCC compiler is required. Try setting --with-tools-dir.]) 71281806Srpaulo fi 72281806Srpaulo 73281806Srpaulo # First line typically looks something like: 74281806Srpaulo # gcc (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2 75281806Srpaulo COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.* \(@<:@1-9@:>@@<:@0-9.@:>@*\)/\1/p"` 76281806Srpaulo COMPILER_VENDOR=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^\(.*\) @<:@1-9@:>@@<:@0-9.@:>@*/\1/p"` 77281806Srpaulo fi 78281806Srpaulo # This sets CC_VERSION or CXX_VERSION. (This comment is a grep marker) 79281806Srpaulo $1_VERSION="$COMPILER_VERSION" 80281806Srpaulo # This sets CC_VENDOR or CXX_VENDOR. (This comment is a grep marker) 81281806Srpaulo $1_VENDOR="$COMPILER_VENDOR" 82281806Srpaulo 83281806Srpaulo AC_MSG_NOTICE([Using $COMPILER_VENDOR $COMPILER_NAME compiler version $COMPILER_VERSION (located at $COMPILER)]) 84281806Srpaulo]) 85281806Srpaulo 86281806Srpaulo 87281806SrpauloAC_DEFUN_ONCE([TOOLCHAIN_SETUP_SYSROOT_AND_OUT_OPTIONS], 88281806Srpaulo[ 89281806Srpaulo############################################################################### 90281806Srpaulo# 91281806Srpaulo# Configure the development tool paths and potential sysroot. 92281806Srpaulo# 93281806SrpauloAC_LANG(C++) 94281806Srpaulo 95281806Srpaulo# The option used to specify the target .o,.a or .so file. 96281806Srpaulo# When compiling, how to specify the to be created object file. 97189251SsamCC_OUT_OPTION='-o$(SPACE)' 98281806Srpaulo# When linking, how to specify the to be created executable. 99281806SrpauloEXE_OUT_OPTION='-o$(SPACE)' 100281806Srpaulo# When linking, how to specify the to be created dynamically linkable library. 101189251SsamLD_OUT_OPTION='-o$(SPACE)' 102189251Ssam# When archiving, how to specify the to be create static archive for object files. 103189251SsamAR_OUT_OPTION='rcs$(SPACE)' 104189251SsamAC_SUBST(CC_OUT_OPTION) 105189251SsamAC_SUBST(EXE_OUT_OPTION) 106281806SrpauloAC_SUBST(LD_OUT_OPTION) 107252726SrpauloAC_SUBST(AR_OUT_OPTION) 108252726Srpaulo]) 109252726Srpaulo 110252726Srpaulo# $1 = compiler to test (CC or CXX) 111252726Srpaulo# $2 = human readable name of compiler (C or C++) 112252726Srpaulo# $3 = list of compiler names to search for 113252726SrpauloAC_DEFUN([TOOLCHAIN_FIND_COMPILER], 114252726Srpaulo[ 115252726Srpaulo COMPILER_NAME=$2 116189251Ssam 117252726Srpaulo $1= 118252726Srpaulo # If TOOLS_DIR is set, check for all compiler names in there first 119252726Srpaulo # before checking the rest of the PATH. 120252726Srpaulo if test -n "$TOOLS_DIR"; then 121252726Srpaulo PATH_save="$PATH" 122252726Srpaulo PATH="$TOOLS_DIR" 123252726Srpaulo AC_PATH_PROGS(TOOLS_DIR_$1, $3) 124252726Srpaulo $1=$TOOLS_DIR_$1 125252726Srpaulo PATH="$PATH_save" 126252726Srpaulo fi 127252726Srpaulo 128252726Srpaulo # AC_PATH_PROGS can't be run multiple times with the same variable, 129252726Srpaulo # so create a new name for this run. 130252726Srpaulo if test "x[$]$1" = x; then 131252726Srpaulo AC_PATH_PROGS(POTENTIAL_$1, $3) 132189251Ssam $1=$POTENTIAL_$1 133214734Srpaulo fi 134214734Srpaulo 135214734Srpaulo if test "x[$]$1" = x; then 136214734Srpaulo HELP_MSG_MISSING_DEPENDENCY([devkit]) 137214734Srpaulo AC_MSG_ERROR([Could not find a $COMPILER_NAME compiler. $HELP_MSG]) 138214734Srpaulo fi 139214734Srpaulo BASIC_FIXUP_EXECUTABLE($1) 140214734Srpaulo AC_MSG_CHECKING([resolved symbolic links for $1]) 141214734Srpaulo TEST_COMPILER="[$]$1" 142214734Srpaulo BASIC_REMOVE_SYMBOLIC_LINKS(TEST_COMPILER) 143214734Srpaulo AC_MSG_RESULT([$TEST_COMPILER]) 144214734Srpaulo AC_MSG_CHECKING([if $1 is disguised ccache]) 145214734Srpaulo 146214734Srpaulo COMPILER_BASENAME=`$BASENAME "$TEST_COMPILER"` 147214734Srpaulo if test "x$COMPILER_BASENAME" = "xccache"; then 148214734Srpaulo AC_MSG_RESULT([yes, trying to find proper $COMPILER_NAME compiler]) 149214734Srpaulo # We /usr/lib/ccache in the path, so cc is a symlink to /usr/bin/ccache. 150214734Srpaulo # We want to control ccache invocation ourselves, so ignore this cc and try 151214734Srpaulo # searching again. 152214734Srpaulo 153214734Srpaulo # Remove the path to the fake ccache cc from the PATH 154214734Srpaulo RETRY_COMPILER_SAVED_PATH="$PATH" 155214734Srpaulo COMPILER_DIRNAME=`$DIRNAME [$]$1` 156214734Srpaulo PATH="`$ECHO $PATH | $SED -e "s,$COMPILER_DIRNAME,,g" -e "s,::,:,g" -e "s,^:,,g"`" 157214734Srpaulo 158214734Srpaulo # Try again looking for our compiler 159214734Srpaulo AC_CHECK_TOOLS(PROPER_COMPILER_$1, $3) 160214734Srpaulo BASIC_FIXUP_EXECUTABLE(PROPER_COMPILER_$1) 161214734Srpaulo PATH="$RETRY_COMPILER_SAVED_PATH" 162214734Srpaulo 163189251Ssam AC_MSG_CHECKING([for resolved symbolic links for $1]) 164189251Ssam BASIC_REMOVE_SYMBOLIC_LINKS(PROPER_COMPILER_$1) 165189251Ssam AC_MSG_RESULT([$PROPER_COMPILER_$1]) 166189251Ssam $1="$PROPER_COMPILER_$1" 167189251Ssam else 168189251Ssam AC_MSG_RESULT([no, keeping $1]) 169189251Ssam $1="$TEST_COMPILER" 170189251Ssam fi 171189251Ssam TOOLCHAIN_CHECK_COMPILER_VERSION([$1], [$COMPILER_NAME]) 172189251Ssam]) 173189251Ssam 174189251Ssam 175189251SsamAC_DEFUN([TOOLCHAIN_SETUP_PATHS], 176189251Ssam[ 177189251Ssamif test "x$OPENJDK_TARGET_OS" = "xwindows"; then 178189251Ssam TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV 179189251Ssam TOOLCHAIN_SETUP_DXSDK 180189251Ssamfi 181189251Ssam 182189251SsamAC_SUBST(MSVCR_DLL) 183189251Ssam 184189251Ssam# If --build AND --host is set, then the configure script will find any 185189251Ssam# cross compilation tools in the PATH. Cross compilation tools 186189251Ssam# follows the cross compilation standard where they are prefixed with ${host}. 187189251Ssam# For example the binary i686-sun-solaris2.10-gcc 188281806Srpaulo# will cross compile for i686-sun-solaris2.10 189281806Srpaulo# If neither of build and host is not set, then build=host and the 190281806Srpaulo# default compiler found in the path will be used. 191281806Srpaulo# Setting only --host, does not seem to be really supported. 192281806Srpaulo# Please set both --build and --host if you want to cross compile. 193281806Srpaulo 194281806Srpauloif test "x$COMPILE_TYPE" = "xcross"; then 195281806Srpaulo # Now we to find a C/C++ compiler that can build executables for the build 196281806Srpaulo # platform. We can't use the AC_PROG_CC macro, since it can only be used 197281806Srpaulo # once. Also, we need to do this before adding a tools dir to the path, 198281806Srpaulo # otherwise we might pick up cross-compilers which don't use standard naming. 199281806Srpaulo # Otherwise, we'll set the BUILD_tools to the native tools, but that'll have 200281806Srpaulo # to wait until they are properly discovered. 201281806Srpaulo AC_PATH_PROGS(BUILD_CC, [cl cc gcc]) 202281806Srpaulo BASIC_FIXUP_EXECUTABLE(BUILD_CC) 203281806Srpaulo AC_PATH_PROGS(BUILD_CXX, [cl CC g++]) 204281806Srpaulo BASIC_FIXUP_EXECUTABLE(BUILD_CXX) 205281806Srpaulo AC_PATH_PROG(BUILD_LD, ld) 206281806Srpaulo BASIC_FIXUP_EXECUTABLE(BUILD_LD) 207281806Srpaulofi 208281806SrpauloAC_SUBST(BUILD_CC) 209281806SrpauloAC_SUBST(BUILD_CXX) 210281806SrpauloAC_SUBST(BUILD_LD) 211281806Srpaulo 212189251Ssam# If a devkit is found on the builddeps server, then prepend its path to the 213189251Ssam# PATH variable. If there are cross compilers available in the devkit, these 214189251Ssam# will be found by AC_PROG_CC et al. 215189251SsamDEVKIT= 216189251SsamBDEPS_CHECK_MODULE(DEVKIT, devkit, xxx, 217189251Ssam [# Found devkit 218189251Ssam PATH="$DEVKIT/bin:$PATH" 219189251Ssam SYS_ROOT="$DEVKIT/${rewritten_target}/sys-root" 220189251Ssam if test "x$x_includes" = "xNONE"; then 221189251Ssam x_includes="$SYS_ROOT/usr/include/X11" 222189251Ssam fi 223189251Ssam if test "x$x_libraries" = "xNONE"; then 224189251Ssam x_libraries="$SYS_ROOT/usr/lib" 225189251Ssam fi 226189251Ssam ], 227189251Ssam []) 228189251Ssam 229189251Ssamif test "x$SYS_ROOT" != "x/" ; then 230189251Ssam CFLAGS="--sysroot=$SYS_ROOT $CFLAGS" 231189251Ssam CXXFLAGS="--sysroot=$SYS_ROOT $CXXFLAGS" 232189251Ssam OBJCFLAGS="--sysroot=$SYS_ROOT $OBJCFLAGS" 233189251Ssam OBJCXXFLAGS="--sysroot=$SYS_ROOT $OBJCFLAGS" 234189251Ssam CPPFLAGS="--sysroot=$SYS_ROOT $CPPFLAGS" 235189251Ssam LDFLAGS="--sysroot=$SYS_ROOT $LDFLAGS" 236189251Ssamfi 237189251Ssam 238189251Ssam# Store the CFLAGS etal passed to the configure script. 239189251SsamORG_CFLAGS="$CFLAGS" 240189251SsamORG_CXXFLAGS="$CXXFLAGS" 241189251SsamORG_OBJCFLAGS="$OBJCFLAGS" 242189251Ssam 243189251Ssam# autoconf magic only relies on PATH, so update it if tools dir is specified 244189251SsamOLD_PATH="$PATH" 245189251Ssamif test "x$TOOLS_DIR" != x; then 246189251Ssam PATH=$TOOLS_DIR:$PATH 247189251Ssamfi 248189251Ssam 249189251Ssam 250189251Ssam### Locate C compiler (CC) 251281806Srpaulo 252281806Srpaulo# On windows, only cl.exe is supported. 253281806Srpaulo# On Solaris, cc is preferred to gcc. 254281806Srpaulo# Elsewhere, gcc is preferred to cc. 255281806Srpaulo 256281806Srpauloif test "x$CC" != x; then 257281806Srpaulo COMPILER_CHECK_LIST="$CC" 258281806Srpauloelif test "x$OPENJDK_TARGET_OS" = "xwindows"; then 259281806Srpaulo COMPILER_CHECK_LIST="cl" 260281806Srpauloelif test "x$OPENJDK_TARGET_OS" = "xsolaris"; then 261281806Srpaulo COMPILER_CHECK_LIST="cc gcc" 262281806Srpauloelse 263281806Srpaulo COMPILER_CHECK_LIST="gcc cc" 264281806Srpaulofi 265189251Ssam 266281806SrpauloTOOLCHAIN_FIND_COMPILER([CC],[C],[$COMPILER_CHECK_LIST]) 267281806Srpaulo# Now that we have resolved CC ourself, let autoconf have its go at it 268281806SrpauloAC_PROG_CC([$CC]) 269281806Srpaulo 270281806Srpaulo### Locate C++ compiler (CXX) 271281806Srpaulo 272281806Srpauloif test "x$CXX" != x; then 273281806Srpaulo COMPILER_CHECK_LIST="$CXX" 274281806Srpauloelif test "x$OPENJDK_TARGET_OS" = "xwindows"; then 275281806Srpaulo COMPILER_CHECK_LIST="cl" 276281806Srpauloelif test "x$OPENJDK_TARGET_OS" = "xsolaris"; then 277281806Srpaulo COMPILER_CHECK_LIST="CC g++" 278281806Srpauloelse 279281806Srpaulo COMPILER_CHECK_LIST="g++ CC" 280281806Srpaulofi 281289549Srpaulo 282289549SrpauloTOOLCHAIN_FIND_COMPILER([CXX],[C++],[$COMPILER_CHECK_LIST]) 283289549Srpaulo# Now that we have resolved CXX ourself, let autoconf have its go at it 284289549SrpauloAC_PROG_CXX([$CXX]) 285289549Srpaulo 286289549Srpaulo### Locate other tools 287289549Srpaulo 288289549Srpauloif test "x$OPENJDK_TARGET_OS" = xmacosx; then 289289549Srpaulo AC_PROG_OBJC 290289549Srpaulo BASIC_FIXUP_EXECUTABLE(OBJC) 291289549Srpauloelse 292289549Srpaulo OBJC= 293289549Srpaulofi 294289549Srpaulo 295289549Srpaulo# Restore the flags to the user specified values. 296289549Srpaulo# This is necessary since AC_PROG_CC defaults CFLAGS to "-g -O2" 297289549SrpauloCFLAGS="$ORG_CFLAGS" 298289549SrpauloCXXFLAGS="$ORG_CXXFLAGS" 299289549SrpauloOBJCFLAGS="$ORG_OBJCFLAGS" 300289549Srpaulo 301289549SrpauloLD="$CC" 302289549SrpauloLDEXE="$CC" 303289549SrpauloLDCXX="$CXX" 304289549SrpauloLDEXECXX="$CXX" 305289549SrpauloAC_SUBST(LD) 306189251Ssam# LDEXE is the linker to use, when creating executables. 307189251SsamAC_SUBST(LDEXE) 308189251Ssam# Linking C++ libraries. 309189251SsamAC_SUBST(LDCXX) 310189251Ssam# Linking C++ executables. 311189251SsamAC_SUBST(LDEXECXX) 312189251Ssam 313189251Ssamif test "x$OPENJDK_TARGET_OS" != xwindows; then 314189251Ssam AC_CHECK_TOOL(AR, ar) 315189251Ssam BASIC_FIXUP_EXECUTABLE(AR) 316189251Ssamfi 317281806Srpauloif test "x$OPENJDK_TARGET_OS" = xmacosx; then 318189251Ssam ARFLAGS="-r" 319189251Ssamelse 320189251Ssam ARFLAGS="" 321189251Ssamfi 322189251SsamAC_SUBST(ARFLAGS) 323189251Ssam 324189251Ssam# For hotspot, we need these in Windows mixed path; other platforms keep them the same 325189251SsamHOTSPOT_CXX="$CXX" 326189251SsamHOTSPOT_LD="$LD" 327189251SsamAC_SUBST(HOTSPOT_CXX) 328189251SsamAC_SUBST(HOTSPOT_LD) 329189251Ssam 330189251SsamCOMPILER_NAME=gcc 331189251SsamCOMPILER_TYPE=CC 332189251SsamAS_IF([test "x$OPENJDK_TARGET_OS" = xwindows], [ 333189251Ssam # For now, assume that we are always compiling using cl.exe. 334189251Ssam CC_OUT_OPTION=-Fo 335189251Ssam EXE_OUT_OPTION=-out: 336189251Ssam LD_OUT_OPTION=-out: 337189251Ssam AR_OUT_OPTION=-out: 338189251Ssam # On Windows, reject /usr/bin/link (as determined in CYGWIN_LINK), which is a cygwin 339189251Ssam # program for something completely different. 340189251Ssam AC_CHECK_PROG([WINLD], [link],[link],,, [$CYGWIN_LINK]) 341189251Ssam # Since we must ignore the first found link, WINLD will contain 342189251Ssam # the full path to the link.exe program. 343189251Ssam BASIC_FIXUP_EXECUTABLE(WINLD) 344189251Ssam printf "Windows linker was found at $WINLD\n" 345189251Ssam AC_MSG_CHECKING([if the found link.exe is actually the Visual Studio linker]) 346189251Ssam "$WINLD" --version > /dev/null 347189251Ssam if test $? -eq 0 ; then 348189251Ssam AC_MSG_RESULT([no]) 349189251Ssam AC_MSG_ERROR([This is the Cygwin link tool. Please check your PATH and rerun configure.]) 350189251Ssam else 351189251Ssam AC_MSG_RESULT([yes]) 352189251Ssam fi 353189251Ssam LD="$WINLD" 354189251Ssam LDEXE="$WINLD" 355189251Ssam LDCXX="$WINLD" 356189251Ssam LDEXECXX="$WINLD" 357189251Ssam 358189251Ssam AC_CHECK_PROG([MT], [mt], [mt],,, [/usr/bin/mt]) 359189251Ssam BASIC_FIXUP_EXECUTABLE(MT) 360189251Ssam # The resource compiler 361189251Ssam AC_CHECK_PROG([RC], [rc], [rc],,, [/usr/bin/rc]) 362189251Ssam BASIC_FIXUP_EXECUTABLE(RC) 363189251Ssam 364189251Ssam # For hotspot, we need these in Windows mixed path, 365189251Ssam # so rewrite them all. Need added .exe suffix. 366189251Ssam HOTSPOT_CXX="$CXX.exe" 367189251Ssam HOTSPOT_LD="$LD.exe" 368189251Ssam HOTSPOT_MT="$MT.exe" 369189251Ssam HOTSPOT_RC="$RC.exe" 370189251Ssam BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH(HOTSPOT_CXX) 371189251Ssam BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH(HOTSPOT_LD) 372189251Ssam BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH(HOTSPOT_MT) 373189251Ssam BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH(HOTSPOT_RC) 374189251Ssam AC_SUBST(HOTSPOT_MT) 375189251Ssam AC_SUBST(HOTSPOT_RC) 376189251Ssam 377189251Ssam RC_FLAGS="-nologo -l 0x409 -r" 378189251Ssam AS_IF([test "x$VARIANT" = xOPT], [ 379189251Ssam RC_FLAGS="$RC_FLAGS -d NDEBUG" 380189251Ssam ]) 381189251Ssam JDK_UPDATE_VERSION_NOTNULL=$JDK_UPDATE_VERSION 382189251Ssam AS_IF([test "x$JDK_UPDATE_VERSION" = x], [ 383189251Ssam JDK_UPDATE_VERSION_NOTNULL=0 384189251Ssam ]) 385189251Ssam RC_FLAGS="$RC_FLAGS -d \"JDK_BUILD_ID=$FULL_VERSION\"" 386189251Ssam RC_FLAGS="$RC_FLAGS -d \"JDK_COMPANY=$COMPANY_NAME\"" 387189251Ssam RC_FLAGS="$RC_FLAGS -d \"JDK_COMPONENT=$PRODUCT_NAME $JDK_RC_PLATFORM_NAME binary\"" 388189251Ssam RC_FLAGS="$RC_FLAGS -d \"JDK_VER=$JDK_MINOR_VERSION.$JDK_MICRO_VERSION.$JDK_UPDATE_VERSION_NOTNULL.$COOKED_BUILD_NUMBER\"" 389189251Ssam RC_FLAGS="$RC_FLAGS -d \"JDK_COPYRIGHT=Copyright \xA9 $COPYRIGHT_YEAR\"" 390189251Ssam RC_FLAGS="$RC_FLAGS -d \"JDK_NAME=$PRODUCT_NAME $JDK_RC_PLATFORM_NAME $JDK_MINOR_VERSION $JDK_UPDATE_META_TAG\"" 391189251Ssam RC_FLAGS="$RC_FLAGS -d \"JDK_FVER=$JDK_MINOR_VERSION,$JDK_MICRO_VERSION,$JDK_UPDATE_VERSION_NOTNULL,$COOKED_BUILD_NUMBER\"" 392189251Ssam 393189251Ssam # lib.exe is used to create static libraries. 394189251Ssam AC_CHECK_PROG([WINAR], [lib],[lib],,,) 395189251Ssam BASIC_FIXUP_EXECUTABLE(WINAR) 396189251Ssam AR="$WINAR" 397189251Ssam ARFLAGS="-nologo -NODEFAULTLIB:MSVCRT" 398189251Ssam 399189251Ssam AC_CHECK_PROG([DUMPBIN], [dumpbin], [dumpbin],,,) 400189251Ssam BASIC_FIXUP_EXECUTABLE(DUMPBIN) 401189251Ssam 402189251Ssam COMPILER_TYPE=CL 403189251Ssam CCXXFLAGS="$CCXXFLAGS -nologo" 404189251Ssam]) 405189251SsamAC_SUBST(RC_FLAGS) 406189251SsamAC_SUBST(COMPILER_TYPE) 407189251Ssam 408189251SsamAC_PROG_CPP 409189251SsamBASIC_FIXUP_EXECUTABLE(CPP) 410189251Ssam 411189251SsamAC_PROG_CXXCPP 412189251SsamBASIC_FIXUP_EXECUTABLE(CXXCPP) 413189251Ssam 414189251Ssamif test "x$COMPILE_TYPE" != "xcross"; then 415189251Ssam # If we are not cross compiling, use the same compilers for 416189251Ssam # building the build platform executables. The cross-compilation 417189251Ssam # case needed to be done earlier, but this can only be done after 418189251Ssam # the native tools have been localized. 419189251Ssam BUILD_CC="$CC" 420189251Ssam BUILD_CXX="$CXX" 421189251Ssam BUILD_LD="$LD" 422189251Ssamfi 423189251Ssam 424189251Ssam# for solaris we really need solaris tools, and not gnu equivalent 425189251Ssam# these seems to normally reside in /usr/ccs/bin so add that to path before 426189251Ssam# starting to probe 427189251Ssam# 428189251Ssam# NOTE: I add this /usr/ccs/bin after TOOLS but before OLD_PATH 429189251Ssam# so that it can be overriden --with-tools-dir 430189251Ssamif test "x$OPENJDK_BUILD_OS" = xsolaris; then 431189251Ssam PATH="${TOOLS_DIR}:/usr/ccs/bin:${OLD_PATH}" 432189251Ssamfi 433189251Ssam 434189251Ssam# Find the right assembler. 435189251Ssamif test "x$OPENJDK_TARGET_OS" = xsolaris; then 436189251Ssam AC_PATH_PROG(AS, as) 437189251Ssam BASIC_FIXUP_EXECUTABLE(AS) 438189251Ssamelse 439189251Ssam AS="$CC -c" 440189251Ssamfi 441189251SsamAC_SUBST(AS) 442189251Ssam 443189251Ssamif test "x$OPENJDK_TARGET_OS" = xsolaris; then 444189251Ssam AC_PATH_PROG(NM, nm) 445189251Ssam BASIC_FIXUP_EXECUTABLE(NM) 446189251Ssam AC_PATH_PROG(GNM, gnm) 447189251Ssam BASIC_FIXUP_EXECUTABLE(GNM) 448189251Ssam AC_PATH_PROG(STRIP, strip) 449189251Ssam BASIC_FIXUP_EXECUTABLE(STRIP) 450189251Ssam AC_PATH_PROG(MCS, mcs) 451189251Ssam BASIC_FIXUP_EXECUTABLE(MCS) 452189251Ssamelif test "x$OPENJDK_TARGET_OS" != xwindows; then 453189251Ssam AC_CHECK_TOOL(NM, nm) 454189251Ssam BASIC_FIXUP_EXECUTABLE(NM) 455189251Ssam GNM="$NM" 456189251Ssam AC_SUBST(GNM) 457189251Ssam AC_CHECK_TOOL(STRIP, strip) 458189251Ssam BASIC_FIXUP_EXECUTABLE(STRIP) 459189251Ssamfi 460189251Ssam 461189251Ssam# objcopy is used for moving debug symbols to separate files when 462189251Ssam# full debug symbols are enabled. 463189251Ssamif test "x$OPENJDK_TARGET_OS" = xsolaris || test "x$OPENJDK_TARGET_OS" = xlinux; then 464189251Ssam AC_CHECK_TOOLS(OBJCOPY, [gobjcopy objcopy]) 465189251Ssam # Only call fixup if objcopy was found. 466252726Srpaulo if test -n "$OBJCOPY"; then 467252726Srpaulo BASIC_FIXUP_EXECUTABLE(OBJCOPY) 468252726Srpaulo fi 469252726Srpaulofi 470252726Srpaulo 471252726SrpauloAC_CHECK_TOOLS(OBJDUMP, [gobjdump objdump]) 472281806Srpauloif test "x$OBJDUMP" != x; then 473252726Srpaulo # Only used for compare.sh; we can live without it. BASIC_FIXUP_EXECUTABLE bails if argument is missing. 474252726Srpaulo BASIC_FIXUP_EXECUTABLE(OBJDUMP) 475252726Srpaulofi 476252726Srpaulo 477252726Srpauloif test "x$OPENJDK_TARGET_OS" = "xmacosx"; then 478252726Srpaulo AC_PATH_PROG(LIPO, lipo) 479252726Srpaulo BASIC_FIXUP_EXECUTABLE(LIPO) 480252726Srpaulofi 481252726Srpaulo 482252726Srpaulo# Restore old path without tools dir 483252726SrpauloPATH="$OLD_PATH" 484281806Srpaulo]) 485252726Srpaulo 486252726Srpaulo 487252726SrpauloAC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_FOR_LIBS], 488252726Srpaulo[ 489252726Srpaulo 490252726Srpaulo############################################################################### 491252726Srpaulo# 492252726Srpaulo# How to compile shared libraries. 493252726Srpaulo# 494252726Srpaulo 495252726Srpauloif test "x$GCC" = xyes; then 496252726Srpaulo COMPILER_NAME=gcc 497252726Srpaulo PICFLAG="-fPIC" 498252726Srpaulo LIBRARY_PREFIX=lib 499252726Srpaulo SHARED_LIBRARY='lib[$]1.so' 500252726Srpaulo STATIC_LIBRARY='lib[$]1.a' 501252726Srpaulo SHARED_LIBRARY_FLAGS="-shared" 502252726Srpaulo SHARED_LIBRARY_SUFFIX='.so' 503252726Srpaulo STATIC_LIBRARY_SUFFIX='.a' 504252726Srpaulo OBJ_SUFFIX='.o' 505252726Srpaulo EXE_SUFFIX='' 506252726Srpaulo SET_SHARED_LIBRARY_NAME='-Xlinker -soname=[$]1' 507252726Srpaulo SET_SHARED_LIBRARY_MAPFILE='-Xlinker -version-script=[$]1' 508252726Srpaulo C_FLAG_REORDER='' 509252726Srpaulo CXX_FLAG_REORDER='' 510252726Srpaulo SET_SHARED_LIBRARY_ORIGIN='-Xlinker -z -Xlinker origin -Xlinker -rpath -Xlinker \$$$$ORIGIN[$]1' 511252726Srpaulo SET_EXECUTABLE_ORIGIN='-Xlinker -rpath -Xlinker \$$$$ORIGIN[$]1' 512252726Srpaulo LD="$CC" 513252726Srpaulo LDEXE="$CC" 514252726Srpaulo LDCXX="$CXX" 515252726Srpaulo LDEXECXX="$CXX" 516252726Srpaulo POST_STRIP_CMD="$STRIP -g" 517252726Srpaulo 518252726Srpaulo # Linking is different on MacOSX 519252726Srpaulo if test "x$OPENJDK_TARGET_OS" = xmacosx; then 520252726Srpaulo # Might change in the future to clang. 521252726Srpaulo COMPILER_NAME=gcc 522281806Srpaulo SHARED_LIBRARY='lib[$]1.dylib' 523252726Srpaulo SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG" 524252726Srpaulo SHARED_LIBRARY_SUFFIX='.dylib' 525252726Srpaulo EXE_SUFFIX='' 526252726Srpaulo SET_SHARED_LIBRARY_NAME='-Xlinker -install_name -Xlinker @rpath/[$]1' 527252726Srpaulo SET_SHARED_LIBRARY_MAPFILE='' 528252726Srpaulo SET_SHARED_LIBRARY_ORIGIN='-Xlinker -rpath -Xlinker @loader_path/.' 529252726Srpaulo SET_EXECUTABLE_ORIGIN="$SET_SHARED_LIBRARY_ORIGIN" 530252726Srpaulo POST_STRIP_CMD="$STRIP -S" 531252726Srpaulo fi 532252726Srpauloelse 533252726Srpaulo if test "x$OPENJDK_TARGET_OS" = xsolaris; then 534252726Srpaulo # If it is not gcc, then assume it is the Oracle Solaris Studio Compiler 535252726Srpaulo COMPILER_NAME=ossc 536252726Srpaulo PICFLAG="-KPIC" 537252726Srpaulo LIBRARY_PREFIX=lib 538252726Srpaulo SHARED_LIBRARY='lib[$]1.so' 539252726Srpaulo STATIC_LIBRARY='lib[$]1.a' 540252726Srpaulo SHARED_LIBRARY_FLAGS="-G" 541252726Srpaulo SHARED_LIBRARY_SUFFIX='.so' 542252726Srpaulo STATIC_LIBRARY_SUFFIX='.a' 543252726Srpaulo OBJ_SUFFIX='.o' 544252726Srpaulo EXE_SUFFIX='' 545252726Srpaulo SET_SHARED_LIBRARY_NAME='' 546252726Srpaulo SET_SHARED_LIBRARY_MAPFILE='-M[$]1' 547252726Srpaulo C_FLAG_REORDER='-xF' 548252726Srpaulo CXX_FLAG_REORDER='-xF' 549281806Srpaulo SET_SHARED_LIBRARY_ORIGIN='-R\$$$$ORIGIN[$]1' 550252726Srpaulo SET_EXECUTABLE_ORIGIN="$SET_SHARED_LIBRARY_ORIGIN" 551252726Srpaulo CFLAGS_JDK="${CFLAGS_JDK} -D__solaris__" 552252726Srpaulo CXXFLAGS_JDK="${CXXFLAGS_JDK} -D__solaris__" 553252726Srpaulo CFLAGS_JDKLIB_EXTRA='-xstrconst' 554252726Srpaulo POST_STRIP_CMD="$STRIP -x" 555252726Srpaulo POST_MCS_CMD="$MCS -d -a \"JDK $FULL_VERSION\"" 556252726Srpaulo fi 557252726Srpaulo if test "x$OPENJDK_TARGET_OS" = xwindows; then 558252726Srpaulo # If it is not gcc, then assume it is the MS Visual Studio compiler 559252726Srpaulo COMPILER_NAME=cl 560252726Srpaulo PICFLAG="" 561252726Srpaulo LIBRARY_PREFIX= 562252726Srpaulo SHARED_LIBRARY='[$]1.dll' 563252726Srpaulo STATIC_LIBRARY='[$]1.lib' 564252726Srpaulo SHARED_LIBRARY_FLAGS="-LD" 565252726Srpaulo SHARED_LIBRARY_SUFFIX='.dll' 566252726Srpaulo STATIC_LIBRARY_SUFFIX='.lib' 567252726Srpaulo OBJ_SUFFIX='.obj' 568252726Srpaulo EXE_SUFFIX='.exe' 569252726Srpaulo SET_SHARED_LIBRARY_NAME='' 570252726Srpaulo SET_SHARED_LIBRARY_MAPFILE='' 571252726Srpaulo SET_SHARED_LIBRARY_ORIGIN='' 572252726Srpaulo SET_EXECUTABLE_ORIGIN='' 573252726Srpaulo fi 574252726Srpaulofi 575252726Srpaulo 576252726SrpauloAC_SUBST(COMPILER_NAME) 577252726SrpauloAC_SUBST(OBJ_SUFFIX) 578252726SrpauloAC_SUBST(SHARED_LIBRARY) 579252726SrpauloAC_SUBST(STATIC_LIBRARY) 580252726SrpauloAC_SUBST(LIBRARY_PREFIX) 581252726SrpauloAC_SUBST(SHARED_LIBRARY_SUFFIX) 582252726SrpauloAC_SUBST(STATIC_LIBRARY_SUFFIX) 583252726SrpauloAC_SUBST(EXE_SUFFIX) 584252726SrpauloAC_SUBST(SHARED_LIBRARY_FLAGS) 585252726SrpauloAC_SUBST(SET_SHARED_LIBRARY_NAME) 586252726SrpauloAC_SUBST(SET_SHARED_LIBRARY_MAPFILE) 587252726SrpauloAC_SUBST(C_FLAG_REORDER) 588252726SrpauloAC_SUBST(CXX_FLAG_REORDER) 589252726SrpauloAC_SUBST(SET_SHARED_LIBRARY_ORIGIN) 590281806SrpauloAC_SUBST(SET_EXECUTABLE_ORIGIN) 591281806SrpauloAC_SUBST(POST_STRIP_CMD) 592252726SrpauloAC_SUBST(POST_MCS_CMD) 593252726Srpaulo 594252726Srpaulo# The (cross) compiler is now configured, we can now test capabilities 595252726Srpaulo# of the target platform. 596252726Srpaulo]) 597189251Ssam 598189251SsamAC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION], 599189251Ssam[ 600189251Ssam 601189251Ssam############################################################################### 602189251Ssam# 603189251Ssam# Setup the opt flags for different compilers 604189251Ssam# and different operating systems. 605189251Ssam# 606189251Ssam 607189251Ssam# 608189251Ssam# NOTE: check for -mstackrealign needs to be below potential addition of -m32 609189251Ssam# 610189251Ssamif test "x$OPENJDK_TARGET_CPU_BITS" = x32 && test "x$OPENJDK_TARGET_OS" = xmacosx; then 611189251Ssam # On 32-bit MacOSX the OS requires C-entry points to be 16 byte aligned. 612189251Ssam # While waiting for a better solution, the current workaround is to use -mstackrealign. 613289549Srpaulo CFLAGS="$CFLAGS -mstackrealign" 614189251Ssam AC_MSG_CHECKING([if 32-bit compiler supports -mstackrealign]) 615252726Srpaulo AC_LINK_IFELSE([AC_LANG_SOURCE([[int main() { return 0; }]])], 616252726Srpaulo [ 617252726Srpaulo AC_MSG_RESULT([yes]) 618189251Ssam ], 619252726Srpaulo [ 620252726Srpaulo AC_MSG_RESULT([no]) 621189251Ssam AC_MSG_ERROR([The selected compiler $CXX does not support -mstackrealign! Try to put another compiler in the path.]) 622189251Ssam ]) 623209158Srpaulofi 624209158Srpaulo 625209158SrpauloC_FLAG_DEPS="-MMD -MF" 626209158SrpauloCXX_FLAG_DEPS="-MMD -MF" 627209158Srpaulo 628209158Srpaulocase $COMPILER_TYPE in 629252726Srpaulo CC ) 630252726Srpaulo D_FLAG="-g" 631252726Srpaulo case $COMPILER_NAME in 632252726Srpaulo gcc ) 633252726Srpaulo case $OPENJDK_TARGET_OS in 634252726Srpaulo macosx ) 635252726Srpaulo # On MacOSX we optimize for size, something 636252726Srpaulo # we should do for all platforms? 637252726Srpaulo C_O_FLAG_HI="-Os" 638252726Srpaulo C_O_FLAG_NORM="-Os" 639252726Srpaulo C_O_FLAG_NONE="" 640252726Srpaulo ;; 641281806Srpaulo *) 642252726Srpaulo C_O_FLAG_HI="-O3" 643252726Srpaulo C_O_FLAG_NORM="-O2" 644252726Srpaulo C_O_FLAG_NONE="-O0" 645252726Srpaulo CFLAGS_DEBUG_SYMBOLS="-g" 646252726Srpaulo CXXFLAGS_DEBUG_SYMBOLS="-g" 647252726Srpaulo if test "x$OPENJDK_TARGET_CPU_BITS" = "x64" && test "x$DEBUG_LEVEL" = "xfastdebug"; then 648252726Srpaulo CFLAGS_DEBUG_SYMBOLS="-g1" 649252726Srpaulo CXXFLAGS_DEBUG_SYMBOLS="-g1" 650252726Srpaulo fi 651252726Srpaulo ;; 652252726Srpaulo esac 653252726Srpaulo CXX_O_FLAG_HI="$C_O_FLAG_HI" 654281806Srpaulo CXX_O_FLAG_NORM="$C_O_FLAG_NORM" 655252726Srpaulo CXX_O_FLAG_NONE="$C_O_FLAG_NONE" 656252726Srpaulo ;; 657252726Srpaulo ossc ) 658252726Srpaulo # 659252726Srpaulo # Forte has different names for this with their C++ compiler... 660252726Srpaulo # 661252726Srpaulo C_FLAG_DEPS="-xMMD -xMF" 662252726Srpaulo CXX_FLAG_DEPS="-xMMD -xMF" 663252726Srpaulo 664252726Srpaulo # Extra options used with HIGHEST 665252726Srpaulo # 666252726Srpaulo # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be 667252726Srpaulo # done with care, there are some assumptions below that need to 668252726Srpaulo # be understood about the use of pointers, and IEEE behavior. 669252726Srpaulo # 670252726Srpaulo # Use non-standard floating point mode (not IEEE 754) 671252726Srpaulo CC_HIGHEST="$CC_HIGHEST -fns" 672252726Srpaulo # Do some simplification of floating point arithmetic (not IEEE 754) 673252726Srpaulo CC_HIGHEST="$CC_HIGHEST -fsimple" 674252726Srpaulo # Use single precision floating point with 'float' 675252726Srpaulo CC_HIGHEST="$CC_HIGHEST -fsingle" 676252726Srpaulo # Assume memory references via basic pointer types do not alias 677252726Srpaulo # (Source with excessing pointer casting and data access with mixed 678252726Srpaulo # pointer types are not recommended) 679252726Srpaulo CC_HIGHEST="$CC_HIGHEST -xalias_level=basic" 680252726Srpaulo # Use intrinsic or inline versions for math/std functions 681252726Srpaulo # (If you expect perfect errno behavior, do not use this) 682252726Srpaulo CC_HIGHEST="$CC_HIGHEST -xbuiltin=%all" 683252726Srpaulo # Loop data dependency optimizations (need -xO3 or higher) 684252726Srpaulo CC_HIGHEST="$CC_HIGHEST -xdepend" 685252726Srpaulo # Pointer parameters to functions do not overlap 686252726Srpaulo # (Similar to -xalias_level=basic usage, but less obvious sometimes. 687252726Srpaulo # If you pass in multiple pointers to the same data, do not use this) 688252726Srpaulo CC_HIGHEST="$CC_HIGHEST -xrestrict" 689252726Srpaulo # Inline some library routines 690252726Srpaulo # (If you expect perfect errno behavior, do not use this) 691252726Srpaulo CC_HIGHEST="$CC_HIGHEST -xlibmil" 692252726Srpaulo # Use optimized math routines 693252726Srpaulo # (If you expect perfect errno behavior, do not use this) 694252726Srpaulo # Can cause undefined external on Solaris 8 X86 on __sincos, removing for now 695252726Srpaulo #CC_HIGHEST="$CC_HIGHEST -xlibmopt" 696252726Srpaulo 697252726Srpaulo if test "x$OPENJDK_TARGET_CPU" = xsparc; then 698252726Srpaulo CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s" 699252726Srpaulo CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s" 700252726Srpaulo fi 701252726Srpaulo 702252726Srpaulo case $OPENJDK_TARGET_CPU_ARCH in 703252726Srpaulo x86) 704252726Srpaulo C_O_FLAG_HIGHEST="-xO4 -Wu,-O4~yz $CC_HIGHEST -xregs=no%frameptr" 705252726Srpaulo C_O_FLAG_HI="-xO4 -Wu,-O4~yz -xregs=no%frameptr" 706252726Srpaulo C_O_FLAG_NORM="-xO2 -Wu,-O2~yz -xregs=no%frameptr" 707252726Srpaulo C_O_FLAG_NONE="-xregs=no%frameptr" 708252726Srpaulo CXX_O_FLAG_HIGHEST="-xO4 -Qoption ube -O4~yz $CC_HIGHEST -xregs=no%frameptr" 709252726Srpaulo CXX_O_FLAG_HI="-xO4 -Qoption ube -O4~yz -xregs=no%frameptr" 710252726Srpaulo CXX_O_FLAG_NORM="-xO2 -Qoption ube -O2~yz -xregs=no%frameptr" 711252726Srpaulo CXX_O_FLAG_NONE="-xregs=no%frameptr" 712252726Srpaulo if test "x$OPENJDK_TARGET_CPU" = xx86; then 713252726Srpaulo C_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST -xchip=pentium" 714252726Srpaulo CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HIGHEST -xchip=pentium" 715252726Srpaulo fi 716252726Srpaulo ;; 717252726Srpaulo sparc) 718252726Srpaulo CFLAGS_JDKLIB_EXTRA="${CFLAGS_JDKLIB_EXTRA} -xregs=no%appl" 719252726Srpaulo CXXFLAGS_JDKLIB_EXTRA="${CXXFLAGS_JDKLIB_EXTRA} -xregs=no%appl" 720252726Srpaulo C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra" 721252726Srpaulo C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0" 722252726Srpaulo C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0" 723252726Srpaulo C_O_FLAG_NONE="" 724252726Srpaulo CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra" 725252726Srpaulo CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0" 726252726Srpaulo CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0" 727252726Srpaulo CXX_O_FLAG_NONE="" 728252726Srpaulo ;; 729252726Srpaulo esac 730281806Srpaulo 731281806Srpaulo CFLAGS_DEBUG_SYMBOLS="-g -xs" 732281806Srpaulo CXXFLAGS_DEBUG_SYMBOLS="-g0 -xs" 733281806Srpaulo esac 734281806Srpaulo ;; 735281806Srpaulo CL ) 736281806Srpaulo D_FLAG= 737281806Srpaulo C_O_FLAG_HIGHEST="-O2" 738281806Srpaulo C_O_FLAG_HI="-O1" 739281806Srpaulo C_O_FLAG_NORM="-O1" 740281806Srpaulo C_O_FLAG_NONE="-Od" 741281806Srpaulo CXX_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST" 742281806Srpaulo CXX_O_FLAG_HI="$C_O_FLAG_HI" 743281806Srpaulo CXX_O_FLAG_NORM="$C_O_FLAG_NORM" 744281806Srpaulo CXX_O_FLAG_NONE="$C_O_FLAG_NONE" 745281806Srpaulo ;; 746281806Srpauloesac 747281806Srpaulo 748281806Srpauloif test -z "$C_O_FLAG_HIGHEST"; then 749281806Srpaulo C_O_FLAG_HIGHEST="$C_O_FLAG_HI" 750281806Srpaulofi 751281806Srpaulo 752281806Srpauloif test -z "$CXX_O_FLAG_HIGHEST"; then 753281806Srpaulo CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HI" 754281806Srpaulofi 755281806Srpaulo 756281806SrpauloAC_SUBST(C_O_FLAG_HIGHEST) 757281806SrpauloAC_SUBST(C_O_FLAG_HI) 758281806SrpauloAC_SUBST(C_O_FLAG_NORM) 759281806SrpauloAC_SUBST(C_O_FLAG_NONE) 760281806SrpauloAC_SUBST(CXX_O_FLAG_HIGHEST) 761281806SrpauloAC_SUBST(CXX_O_FLAG_HI) 762281806SrpauloAC_SUBST(CXX_O_FLAG_NORM) 763281806SrpauloAC_SUBST(CXX_O_FLAG_NONE) 764281806SrpauloAC_SUBST(C_FLAG_DEPS) 765281806SrpauloAC_SUBST(CXX_FLAG_DEPS) 766281806Srpaulo]) 767281806Srpaulo 768281806SrpauloAC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_FOR_JDK], 769281806Srpaulo[ 770281806Srpaulo 771281806Srpauloif test "x$CFLAGS" != "x${ADDED_CFLAGS}"; then 772281806Srpaulo AC_MSG_WARN([Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags]) 773281806Srpaulofi 774281806Srpaulo 775281806Srpauloif test "x$CXXFLAGS" != "x${ADDED_CXXFLAGS}"; then 776281806Srpaulo AC_MSG_WARN([Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags]) 777281806Srpaulofi 778281806Srpaulo 779281806Srpauloif test "x$LDFLAGS" != "x${ADDED_LDFLAGS}"; then 780281806Srpaulo AC_MSG_WARN([Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags]) 781281806Srpaulofi 782281806Srpaulo 783281806SrpauloAC_ARG_WITH(extra-cflags, [AS_HELP_STRING([--with-extra-cflags], 784281806Srpaulo [extra flags to be used when compiling jdk c-files])]) 785281806Srpaulo 786281806SrpauloAC_ARG_WITH(extra-cxxflags, [AS_HELP_STRING([--with-extra-cxxflags], 787281806Srpaulo [extra flags to be used when compiling jdk c++-files])]) 788281806Srpaulo 789281806SrpauloAC_ARG_WITH(extra-ldflags, [AS_HELP_STRING([--with-extra-ldflags], 790281806Srpaulo [extra flags to be used when linking jdk])]) 791281806Srpaulo 792281806SrpauloCFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags" 793281806SrpauloCXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags" 794281806SrpauloLDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags" 795281806Srpaulo 796281806Srpaulo# Hotspot needs these set in their legacy form 797281806SrpauloLEGACY_EXTRA_CFLAGS=$with_extra_cflags 798281806SrpauloLEGACY_EXTRA_CXXFLAGS=$with_extra_cxxflags 799281806SrpauloLEGACY_EXTRA_LDFLAGS=$with_extra_ldflags 800281806Srpaulo 801281806SrpauloAC_SUBST(LEGACY_EXTRA_CFLAGS) 802281806SrpauloAC_SUBST(LEGACY_EXTRA_CXXFLAGS) 803281806SrpauloAC_SUBST(LEGACY_EXTRA_LDFLAGS) 804281806Srpaulo 805281806Srpaulo############################################################################### 806281806Srpaulo# 807281806Srpaulo# Now setup the CFLAGS and LDFLAGS for the JDK build. 808281806Srpaulo# Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build. 809281806Srpaulo# 810281806Srpaulocase $COMPILER_NAME in 811281806Srpaulo gcc ) 812281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -W -Wall -Wno-unused -Wno-parentheses \ 813281806Srpaulo -pipe \ 814281806Srpaulo -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE" 815281806Srpaulo case $OPENJDK_TARGET_CPU_ARCH in 816281806Srpaulo arm ) 817281806Srpaulo # on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing 818281806Srpaulo CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing" 819281806Srpaulo ;; 820281806Srpaulo ppc ) 821281806Srpaulo # on ppc we don't prevent gcc to omit frame pointer nor strict-aliasing 822281806Srpaulo ;; 823281806Srpaulo * ) 824281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS_JDK -fno-omit-frame-pointer" 825281806Srpaulo CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing" 826281806Srpaulo ;; 827281806Srpaulo esac 828281806Srpaulo ;; 829281806Srpaulo ossc ) 830281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS" 831281806Srpaulo case $OPENJDK_TARGET_CPU_ARCH in 832281806Srpaulo x86 ) 833281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB" 834281806Srpaulo CFLAGS_JDK="$CFLAGS_JDK -erroff=E_BAD_PRAGMA_PACK_VALUE" 835281806Srpaulo ;; 836281806Srpaulo esac 837281806Srpaulo 838281806Srpaulo CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal" 839281806Srpaulo CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib" 840281806Srpaulo 841281806Srpaulo LDFLAGS_JDK="$LDFLAGS_JDK -z defs -xildoff -ztext" 842281806Srpaulo LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK -norunpath -xnolib" 843281806Srpaulo ;; 844281806Srpaulo cl ) 845281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \ 846281806Srpaulo -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \ 847281806Srpaulo -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \ 848281806Srpaulo -DWIN32 -DIAL" 849281806Srpaulo case $OPENJDK_TARGET_CPU in 850281806Srpaulo x86 ) 851281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_X86_ -Dx86" 852281806Srpaulo ;; 853281806Srpaulo x86_64 ) 854281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_AMD64_ -Damd64" 855281806Srpaulo ;; 856281806Srpaulo esac 857281806Srpaulo ;; 858281806Srpauloesac 859281806Srpaulo 860281806Srpaulo############################################################################### 861281806Srpaulo 862281806SrpauloCCXXFLAGS_JDK="$CCXXFLAGS_JDK $ADD_LP64" 863281806Srpaulo 864281806Srpaulo# The package path is used only on macosx? 865281806SrpauloPACKAGE_PATH=/opt/local 866281806SrpauloAC_SUBST(PACKAGE_PATH) 867281806Srpaulo 868281806Srpauloif test "x$OPENJDK_TARGET_CPU_ENDIAN" = xlittle; then 869281806Srpaulo # The macro _LITTLE_ENDIAN needs to be defined the same to avoid the 870281806Srpaulo # Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN 871281806Srpaulo # (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h). 872281806Srpaulo # Note: -Dmacro is the same as #define macro 1 873281806Srpaulo # -Dmacro= is the same as #define macro 874281806Srpaulo if test "x$OPENJDK_TARGET_OS" = xsolaris; then 875281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN=" 876281806Srpaulo else 877281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN" 878281806Srpaulo fi 879281806Srpauloelse 880281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN" 881281806Srpaulofi 882281806Srpauloif test "x$OPENJDK_TARGET_OS" = xlinux; then 883281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DLINUX" 884281806Srpaulofi 885281806Srpauloif test "x$OPENJDK_TARGET_OS" = xwindows; then 886281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DWINDOWS" 887281806Srpaulofi 888281806Srpauloif test "x$OPENJDK_TARGET_OS" = xsolaris; then 889281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DSOLARIS" 890281806Srpaulofi 891281806Srpauloif test "x$OPENJDK_TARGET_OS" = xmacosx; then 892281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMACOSX -D_ALLBSD_SOURCE" 893281806Srpaulo # Setting these parameters makes it an error to link to macosx APIs that are 894281806Srpaulo # newer than the given OS version and makes the linked binaries compatible even 895281806Srpaulo # if built on a newer version of the OS. 896281806Srpaulo # The expected format is X.Y.Z 897281806Srpaulo MACOSX_VERSION_MIN=10.7.0 898281806Srpaulo AC_SUBST(MACOSX_VERSION_MIN) 899281806Srpaulo # The macro takes the version with no dots, ex: 1070 900281806Srpaulo # Let the flags variables get resolved in make for easier override on make 901281806Srpaulo # command line. 902281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)" 903281806Srpaulo LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)" 904281806Srpaulofi 905281806Srpauloif test "x$OPENJDK_TARGET_OS" = xbsd; then 906281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DBSD -D_ALLBSD_SOURCE" 907281806Srpaulofi 908281806Srpauloif test "x$DEBUG_LEVEL" = xrelease; then 909281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DNDEBUG" 910281806Srpaulo if test "x$OPENJDK_TARGET_OS" = xsolaris; then 911281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DTRIMMED" 912281806Srpaulo fi 913281806Srpauloelse 914281806Srpaulo CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DDEBUG" 915281806Srpaulofi 916281806Srpaulo 917281806SrpauloCCXXFLAGS_JDK="$CCXXFLAGS_JDK -DARCH='\"$OPENJDK_TARGET_CPU_LEGACY\"' -D$OPENJDK_TARGET_CPU_LEGACY" 918281806SrpauloCCXXFLAGS_JDK="$CCXXFLAGS_JDK -DRELEASE='\"$RELEASE\"'" 919281806Srpaulo 920281806SrpauloCCXXFLAGS_JDK="$CCXXFLAGS_JDK \ 921281806Srpaulo -I${JDK_OUTPUTDIR}/include \ 922281806Srpaulo -I${JDK_OUTPUTDIR}/include/$OPENJDK_TARGET_OS \ 923281806Srpaulo -I${JDK_TOPDIR}/src/share/javavm/export \ 924281806Srpaulo -I${JDK_TOPDIR}/src/$OPENJDK_TARGET_OS_API_DIR/javavm/export \ 925281806Srpaulo -I${JDK_TOPDIR}/src/share/native/common \ 926281806Srpaulo -I${JDK_TOPDIR}/src/$OPENJDK_TARGET_OS_API_DIR/native/common" 927281806Srpaulo 928281806Srpaulo# The shared libraries are compiled using the picflag. 929281806SrpauloCFLAGS_JDKLIB="$CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA" 930281806SrpauloCXXFLAGS_JDKLIB="$CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA " 931281806Srpaulo 932281806Srpaulo# Executable flags 933281806SrpauloCFLAGS_JDKEXE="$CCXXFLAGS_JDK $CFLAGS_JDK" 934281806SrpauloCXXFLAGS_JDKEXE="$CCXXFLAGS_JDK $CXXFLAGS_JDK" 935281806Srpaulo 936281806Srpaulo# Now this is odd. The JDK native libraries have to link against libjvm.so 937281806Srpaulo# On 32-bit machines there is normally two distinct libjvm.so:s, client and server. 938281806Srpaulo# Which should we link to? Are we lucky enough that the binary api to the libjvm.so library 939281806Srpaulo# is identical for client and server? Yes. Which is picked at runtime (client or server)? 940281806Srpaulo# Neither, since the chosen libjvm.so has already been loaded by the launcher, all the following 941281806Srpaulo# libraries will link to whatever is in memory. Yuck. 942281806Srpaulo# 943281806Srpaulo# Thus we offer the compiler to find libjvm.so first in server then in client. It works. Ugh. 944281806Srpauloif test "x$COMPILER_NAME" = xcl; then 945281806Srpaulo LDFLAGS_JDK="$LDFLAGS_JDK -nologo -opt:ref -incremental:no" 946281806Srpaulo if test "x$OPENJDK_TARGET_CPU" = xx86; then 947281806Srpaulo LDFLAGS_JDK="$LDFLAGS_JDK -safeseh" 948281806Srpaulo fi 949281806Srpaulo # TODO: make -debug optional "--disable-full-debug-symbols" 950281806Srpaulo LDFLAGS_JDK="$LDFLAGS_JDK -debug" 951281806Srpaulo LDFLAGS_JDKLIB="${LDFLAGS_JDK} -dll -libpath:${JDK_OUTPUTDIR}/lib" 952281806Srpaulo LDFLAGS_JDKLIB_SUFFIX="" 953281806Srpaulo if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then 954281806Srpaulo LDFLAGS_STACK_SIZE=1048576 955281806Srpaulo else 956281806Srpaulo LDFLAGS_STACK_SIZE=327680 957281806Srpaulo fi 958281806Srpaulo LDFLAGS_JDKEXE="${LDFLAGS_JDK} /STACK:$LDFLAGS_STACK_SIZE" 959281806Srpauloelse 960281806Srpaulo if test "x$COMPILER_NAME" = xgcc; then 961281806Srpaulo # If this is a --hash-style=gnu system, use --hash-style=both, why? 962281806Srpaulo HAS_GNU_HASH=`$CC -dumpspecs 2>/dev/null | $GREP 'hash-style=gnu'` 963281806Srpaulo if test -n "$HAS_GNU_HASH"; then 964281806Srpaulo LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker --hash-style=both " 965281806Srpaulo fi 966281806Srpaulo if test "x$OPENJDK_TARGET_OS" = xlinux; then 967281806Srpaulo # And since we now know that the linker is gnu, then add -z defs, to forbid 968281806Srpaulo # undefined symbols in object files. 969281806Srpaulo LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -z -Xlinker defs" 970281806Srpaulo if test "x$DEBUG_LEVEL" = "xrelease"; then 971281806Srpaulo # When building release libraries, tell the linker optimize them. 972281806Srpaulo # Should this be supplied to the OSS linker as well? 973281806Srpaulo LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -O1" 974281806Srpaulo fi 975281806Srpaulo fi 976289549Srpaulo fi 977289549Srpaulo LDFLAGS_JDKLIB="${LDFLAGS_JDK} $SHARED_LIBRARY_FLAGS \ 978289549Srpaulo -L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}" 979289549Srpaulo 980289549Srpaulo # On some platforms (mac) the linker warns about non existing -L dirs. 981289549Srpaulo # Add server first if available. Linking aginst client does not always produce the same results. 982289549Srpaulo # Only add client dir if client is being built. Add minimal (note not minimal1) if only building minimal1. 983289549Srpaulo # Default to server for other variants. 984289549Srpaulo if test "x$JVM_VARIANT_SERVER" = xtrue; then 985289549Srpaulo LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}/server" 986289549Srpaulo elif test "x$JVM_VARIANT_CLIENT" = xtrue; then 987289549Srpaulo LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}/client" 988289549Srpaulo elif test "x$JVM_VARIANT_MINIMAL1" = xtrue; then 989289549Srpaulo LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}/minimal" 990289549Srpaulo else 991289549Srpaulo LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}/server" 992289549Srpaulo fi 993289549Srpaulo 994289549Srpaulo LDFLAGS_JDKLIB_SUFFIX="-ljava -ljvm" 995289549Srpaulo if test "x$COMPILER_NAME" = xossc; then 996289549Srpaulo LDFLAGS_JDKLIB_SUFFIX="$LDFLAGS_JDKLIB_SUFFIX -lc" 997289549Srpaulo fi 998289549Srpaulo 999289549Srpaulo LDFLAGS_JDKEXE="${LDFLAGS_JDK}" 1000289549Srpaulo if test "x$OPENJDK_TARGET_OS" = xlinux; then 1001289549Srpaulo LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -Xlinker --allow-shlib-undefined" 1002289549Srpaulo fi 1003289549Srpaulofi 1004289549Srpaulo 1005289549Srpaulo# Adjust flags according to debug level. 1006289549Srpaulocase $DEBUG_LEVEL in 1007289549Srpaulo fastdebug ) 1008289549Srpaulo CFLAGS="$CFLAGS $D_FLAG" 1009289549Srpaulo JAVAC_FLAGS="$JAVAC_FLAGS -g" 1010289549Srpaulo ;; 1011289549Srpaulo slowdebug ) 1012289549Srpaulo CFLAGS="$CFLAGS $D_FLAG" 1013289549Srpaulo C_O_FLAG_HI="$C_O_FLAG_NONE" 1014289549Srpaulo C_O_FLAG_NORM="$C_O_FLAG_NONE" 1015289549Srpaulo CXX_O_FLAG_HI="$CXX_O_FLAG_NONE" 1016289549Srpaulo CXX_O_FLAG_NORM="$CXX_O_FLAG_NONE" 1017289549Srpaulo JAVAC_FLAGS="$JAVAC_FLAGS -g" 1018281806Srpaulo ;; 1019281806Srpauloesac 1020281806Srpaulo 1021281806Srpaulo 1022281806SrpauloAC_SUBST(CFLAGS_JDKLIB) 1023281806SrpauloAC_SUBST(CFLAGS_JDKEXE) 1024281806Srpaulo 1025281806SrpauloAC_SUBST(CXXFLAGS_JDKLIB) 1026281806SrpauloAC_SUBST(CXXFLAGS_JDKEXE) 1027289549Srpaulo 1028281806SrpauloAC_SUBST(LDFLAGS_JDKLIB) 1029289549SrpauloAC_SUBST(LDFLAGS_JDKEXE) 1030289549SrpauloAC_SUBST(LDFLAGS_JDKLIB_SUFFIX) 1031281806SrpauloAC_SUBST(LDFLAGS_JDKEXE_SUFFIX) 1032289549SrpauloAC_SUBST(LDFLAGS_CXX_JDK) 1033281806Srpaulo]) 1034281806Srpaulo 1035281806Srpaulo 1036281806Srpaulo# TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE], 1037281806Srpaulo# [RUN-IF-FALSE]) 1038281806Srpaulo# ------------------------------------------------------------ 1039281806Srpaulo# Check that the c and c++ compilers support an argument 1040281806SrpauloAC_DEFUN([TOOLCHAIN_COMPILER_CHECK_ARGUMENTS], 1041281806Srpaulo[ 1042281806Srpaulo AC_MSG_CHECKING([if compiler supports "$1"]) 1043281806Srpaulo supports=yes 1044281806Srpaulo 1045281806Srpaulo saved_cflags="$CFLAGS" 1046281806Srpaulo CFLAGS="$CFLAGS $1" 1047281806Srpaulo AC_LANG_PUSH([C]) 1048281806Srpaulo AC_COMPILE_IFELSE([ 1049281806Srpaulo AC_LANG_SOURCE([[int i;]]) 1050281806Srpaulo ], [], [supports=no]) 1051281806Srpaulo AC_LANG_POP([C]) 1052281806Srpaulo CFLAGS="$saved_cflags" 1053281806Srpaulo 1054281806Srpaulo saved_cxxflags="$CXXFLAGS" 1055281806Srpaulo CXXFLAGS="$CXXFLAG $1" 1056281806Srpaulo AC_LANG_PUSH([C++]) 1057281806Srpaulo AC_COMPILE_IFELSE([ 1058281806Srpaulo AC_LANG_SOURCE([[int i;]]) 1059281806Srpaulo ], [], [supports=no]) 1060281806Srpaulo AC_LANG_POP([C++]) 1061281806Srpaulo CXXFLAGS="$saved_cxxflags" 1062281806Srpaulo 1063281806Srpaulo AC_MSG_RESULT([$supports]) 1064281806Srpaulo if test "x$supports" = "xyes" ; then 1065281806Srpaulo m4_ifval([$2], [$2], [:]) 1066281806Srpaulo else 1067281806Srpaulo m4_ifval([$3], [$3], [:]) 1068281806Srpaulo fi 1069281806Srpaulo]) 1070281806Srpaulo 1071281806SrpauloAC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_MISC], 1072281806Srpaulo[ 1073281806Srpaulo # Some Zero and Shark settings. 1074281806Srpaulo # ZERO_ARCHFLAG tells the compiler which mode to build for 1075281806Srpaulo case "${OPENJDK_TARGET_CPU}" in 1076281806Srpaulo s390) 1077281806Srpaulo ZERO_ARCHFLAG="-m31" 1078281806Srpaulo ;; 1079281806Srpaulo *) 1080281806Srpaulo ZERO_ARCHFLAG="-m${OPENJDK_TARGET_CPU_BITS}" 1081281806Srpaulo esac 1082281806Srpaulo TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([$ZERO_ARCHFLAG], [], [ZERO_ARCHFLAG=""]) 1083281806Srpaulo AC_SUBST(ZERO_ARCHFLAG) 1084281806Srpaulo 1085281806Srpaulo # Check that the compiler supports -mX flags 1086281806Srpaulo # Set COMPILER_SUPPORTS_TARGET_BITS_FLAG to 'true' if it does 1087281806Srpaulo TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([-m${OPENJDK_TARGET_CPU_BITS}], 1088281806Srpaulo [COMPILER_SUPPORTS_TARGET_BITS_FLAG=true], 1089281806Srpaulo [COMPILER_SUPPORTS_TARGET_BITS_FLAG=false]) 1090281806Srpaulo AC_SUBST(COMPILER_SUPPORTS_TARGET_BITS_FLAG) 1091281806Srpaulo]) 1092281806Srpaulo