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