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