662 XMKMF
663 FIXPATH
664 CXXFLAGS_DEBUG_SYMBOLS
665 CFLAGS_DEBUG_SYMBOLS
666 ZIP_DEBUGINFO_FILES
667 ENABLE_DEBUG_SYMBOLS
668 USING_BROKEN_SUSE_LD
669 COMPILER_SUPPORTS_TARGET_BITS_FLAG
670 ZERO_ARCHFLAG
671 LDFLAGS_CXX_JDK
672 LDFLAGS_JDKEXE_SUFFIX
673 LDFLAGS_JDKLIB_SUFFIX
674 LDFLAGS_JDKEXE
675 LDFLAGS_JDKLIB
676 CXXFLAGS_JDKEXE
677 CXXFLAGS_JDKLIB
678 CFLAGS_JDKEXE
679 CFLAGS_JDKLIB
680 MACOSX_VERSION_MIN
681 PACKAGE_PATH
682 LEGACY_EXTRA_LDFLAGS
683 LEGACY_EXTRA_CXXFLAGS
684 LEGACY_EXTRA_CFLAGS
685 CXX_FLAG_DEPS
686 C_FLAG_DEPS
687 CXX_O_FLAG_NONE
688 CXX_O_FLAG_NORM
689 CXX_O_FLAG_HI
690 CXX_O_FLAG_HIGHEST
691 C_O_FLAG_NONE
692 C_O_FLAG_NORM
693 C_O_FLAG_HI
694 C_O_FLAG_HIGHEST
695 POST_MCS_CMD
696 POST_STRIP_CMD
697 SET_EXECUTABLE_ORIGIN
698 SET_SHARED_LIBRARY_ORIGIN
699 CXX_FLAG_REORDER
700 C_FLAG_REORDER
701 SET_SHARED_LIBRARY_MAPFILE
726 COMPILER_TYPE
727 RC_FLAGS
728 DUMPBIN
729 WINAR
730 HOTSPOT_RC
731 HOTSPOT_MT
732 RC
733 MT
734 WINLD
735 HOTSPOT_LD
736 HOTSPOT_CXX
737 ARFLAGS
738 AR
739 LDEXECXX
740 LDCXX
741 LDEXE
742 LD
743 ac_ct_OBJC
744 OBJCFLAGS
745 OBJC
746 ac_ct_CXX
747 CXXFLAGS
748 CXX
749 ac_ct_PROPER_COMPILER_CXX
750 PROPER_COMPILER_CXX
751 POTENTIAL_CXX
752 TOOLS_DIR_CXX
753 COMPILER_TARGET_BITS_FLAG
754 OBJEXT
755 EXEEXT
756 ac_ct_CC
757 CPPFLAGS
758 LDFLAGS
759 CFLAGS
760 CC
761 ac_ct_PROPER_COMPILER_CC
762 PROPER_COMPILER_CC
763 POTENTIAL_CC
764 TOOLS_DIR_CC
765 SDKPATH
3655 # questions.
3656 #
3657
3658
3659
3660
3661
3662
3663
3664
3665
3666
3667
3668
3669
3670
3671
3672
3673
3674 #
3675 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3676 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3677 #
3678 # This code is free software; you can redistribute it and/or modify it
3679 # under the terms of the GNU General Public License version 2 only, as
3680 # published by the Free Software Foundation. Oracle designates this
3681 # particular file as subject to the "Classpath" exception as provided
3682 # by Oracle in the LICENSE file that accompanied this code.
3683 #
3684 # This code is distributed in the hope that it will be useful, but WITHOUT
3685 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3686 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3687 # version 2 for more details (a copy is included in the LICENSE file that
3688 # accompanied this code).
3689 #
3690 # You should have received a copy of the GNU General Public License version
3691 # 2 along with this work; if not, write to the Free Software Foundation,
3692 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3693 #
3694 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3695 # or visit www.oracle.com if you need additional information or have any
3778 # under the terms of the GNU General Public License version 2 only, as
3779 # published by the Free Software Foundation. Oracle designates this
3780 # particular file as subject to the "Classpath" exception as provided
3781 # by Oracle in the LICENSE file that accompanied this code.
3782 #
3783 # This code is distributed in the hope that it will be useful, but WITHOUT
3784 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3785 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3786 # version 2 for more details (a copy is included in the LICENSE file that
3787 # accompanied this code).
3788 #
3789 # You should have received a copy of the GNU General Public License version
3790 # 2 along with this work; if not, write to the Free Software Foundation,
3791 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3792 #
3793 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3794 # or visit www.oracle.com if you need additional information or have any
3795 # questions.
3796 #
3797
3798 # $1 = compiler to test (CC or CXX)
3799 # $2 = human readable name of compiler (C or C++)
3800
3801
3802
3803
3804
3805 # $1 = compiler to test (CC or CXX)
3806 # $2 = human readable name of compiler (C or C++)
3807 # $3 = list of compiler names to search for
3808
3809
3810
3811
3812
3813
3814
3815
3816
3817
3818
3819
3820
3821 # TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3822 # [RUN-IF-FALSE])
3823 # ------------------------------------------------------------
3824 # Check that the c and c++ compilers support an argument
3825
3826
3827
3828
3829 # Setup the JTREG paths
3830
3831
3832 #
3833 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3834 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3835 #
3836 # This code is free software; you can redistribute it and/or modify it
3837 # under the terms of the GNU General Public License version 2 only, as
3838 # published by the Free Software Foundation. Oracle designates this
3839 # particular file as subject to the "Classpath" exception as provided
3840 # by Oracle in the LICENSE file that accompanied this code.
3841 #
3842 # This code is distributed in the hope that it will be useful, but WITHOUT
3843 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3844 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3845 # version 2 for more details (a copy is included in the LICENSE file that
3846 # accompanied this code).
3847 #
3848 # You should have received a copy of the GNU General Public License version
3849 # 2 along with this work; if not, write to the Free Software Foundation,
3850 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3851 #
3863 # Check if the VS env variables were setup prior to running configure.
3864 # If not, then find vcvarsall.bat and run it automatically, and integrate
3865 # the set env variables into the spec file.
3866
3867
3868
3869
3870
3871
3872
3873
3874
3875
3876
3877 # This line needs to be here, verbatim, after all includes and the dummy hook
3878 # definitions. It is replaced with custom functionality when building
3879 # custom sources.
3880 #CUSTOM_AUTOCONF_INCLUDE
3881
3882 # Do not change or remove the following line, it is needed for consistency checks:
3883 DATE_WHEN_GENERATED=1449096260
3884
3885 ###############################################################################
3886 #
3887 # Initialization / Boot-strapping
3888 #
3889 # The bootstrapping process needs to solve the "chicken or the egg" problem,
3890 # thus it jumps back and forth, each time gaining something needed later on.
3891 #
3892 ###############################################################################
3893
3894 # Basic initialization that must happen first of all
3895
3896 # Save the original command line. This is passed to us by the wrapper configure script.
3897
3898 DATE_WHEN_CONFIGURED=`LANG=C date`
3899
3900 { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
3901 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
3902 { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
3903 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
20351 fi
20352 elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then
20353 if test "x$COMPILER_CPU_TEST" != "xx64"; then
20354 as_fn_error $? "Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for \"$COMPILER_CPU_TEST\"; expected \"x64\"." "$LINENO" 5
20355 fi
20356 fi
20357 else
20358 COMPILER_VERSION_TEST=`$COMPILER --version 2>&1 | $HEAD -n 1`
20359 # Check that this is likely to be GCC.
20360 $COMPILER --version 2>&1 | $GREP "Free Software Foundation" > /dev/null
20361 if test $? -ne 0; then
20362 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required GCC compiler." >&5
20363 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required GCC compiler." >&6;}
20364 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_TEST\"" >&5
20365 $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_TEST\"" >&6;}
20366 as_fn_error $? "GCC compiler is required. Try setting --with-tools-dir." "$LINENO" 5
20367 fi
20368
20369 # First line typically looks something like:
20370 # gcc (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2
20371 COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.* \([1-9][0-9.]*\)/\1/p"`
20372 COMPILER_VENDOR=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^\(.*\) [1-9][0-9.]*/\1/p"`
20373 fi
20374 # This sets CC_VERSION or CXX_VERSION. (This comment is a grep marker)
20375 CC_VERSION="$COMPILER_VERSION"
20376 # This sets CC_VENDOR or CXX_VENDOR. (This comment is a grep marker)
20377 CC_VENDOR="$COMPILER_VENDOR"
20378
20379 { $as_echo "$as_me:${as_lineno-$LINENO}: Using $COMPILER_VENDOR $COMPILER_NAME compiler version $COMPILER_VERSION (located at $COMPILER)" >&5
20380 $as_echo "$as_me: Using $COMPILER_VENDOR $COMPILER_NAME compiler version $COMPILER_VERSION (located at $COMPILER)" >&6;}
20381
20382
20383 # Now that we have resolved CC ourself, let autoconf have its go at it
20384 ac_ext=c
20385 ac_cpp='$CPP $CPPFLAGS'
20386 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
20387 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
20388 ac_compiler_gnu=$ac_cv_c_compiler_gnu
20389 if test -n "$ac_tool_prefix"; then
20390 for ac_prog in $CC
20391 do
21952 fi
21953 elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then
21954 if test "x$COMPILER_CPU_TEST" != "xx64"; then
21955 as_fn_error $? "Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for \"$COMPILER_CPU_TEST\"; expected \"x64\"." "$LINENO" 5
21956 fi
21957 fi
21958 else
21959 COMPILER_VERSION_TEST=`$COMPILER --version 2>&1 | $HEAD -n 1`
21960 # Check that this is likely to be GCC.
21961 $COMPILER --version 2>&1 | $GREP "Free Software Foundation" > /dev/null
21962 if test $? -ne 0; then
21963 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required GCC compiler." >&5
21964 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required GCC compiler." >&6;}
21965 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_TEST\"" >&5
21966 $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_TEST\"" >&6;}
21967 as_fn_error $? "GCC compiler is required. Try setting --with-tools-dir." "$LINENO" 5
21968 fi
21969
21970 # First line typically looks something like:
21971 # gcc (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2
21972 COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.* \([1-9][0-9.]*\)/\1/p"`
21973 COMPILER_VENDOR=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^\(.*\) [1-9][0-9.]*/\1/p"`
21974 fi
21975 # This sets CC_VERSION or CXX_VERSION. (This comment is a grep marker)
21976 CXX_VERSION="$COMPILER_VERSION"
21977 # This sets CC_VENDOR or CXX_VENDOR. (This comment is a grep marker)
21978 CXX_VENDOR="$COMPILER_VENDOR"
21979
21980 { $as_echo "$as_me:${as_lineno-$LINENO}: Using $COMPILER_VENDOR $COMPILER_NAME compiler version $COMPILER_VERSION (located at $COMPILER)" >&5
21981 $as_echo "$as_me: Using $COMPILER_VENDOR $COMPILER_NAME compiler version $COMPILER_VERSION (located at $COMPILER)" >&6;}
21982
21983
21984 # Now that we have resolved CXX ourself, let autoconf have its go at it
21985 ac_ext=cpp
21986 ac_cpp='$CXXCPP $CPPFLAGS'
21987 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
21988 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
21989 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
21990 if test -z "$CXX"; then
21991 if test -n "$CCC"; then
21992 CXX=$CCC
22223 elif test $ac_cv_prog_cxx_g = yes; then
22224 if test "$GXX" = yes; then
22225 CXXFLAGS="-g -O2"
22226 else
22227 CXXFLAGS="-g"
22228 fi
22229 else
22230 if test "$GXX" = yes; then
22231 CXXFLAGS="-O2"
22232 else
22233 CXXFLAGS=
22234 fi
22235 fi
22236 ac_ext=cpp
22237 ac_cpp='$CXXCPP $CPPFLAGS'
22238 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
22239 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
22240 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
22241
22242
22243 ### Locate other tools
22244
22245 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
22246 ac_ext=m
22247 ac_cpp='$OBJCPP $CPPFLAGS'
22248 ac_compile='$OBJC -c $OBJCFLAGS $CPPFLAGS conftest.$ac_ext >&5'
22249 ac_link='$OBJC -o conftest$ac_exeext $OBJCFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
22250 ac_compiler_gnu=$ac_cv_objc_compiler_gnu
22251 if test -n "$ac_tool_prefix"; then
22252 for ac_prog in gcc objcc objc cc CC
22253 do
22254 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
22255 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
22256 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22257 $as_echo_n "checking for $ac_word... " >&6; }
22258 if ${ac_cv_prog_OBJC+:} false; then :
22259 $as_echo_n "(cached) " >&6
22260 else
22261 if test -n "$OBJC"; then
22262 ac_cv_prog_OBJC="$OBJC" # Let the user override the test.
24814 fi
24815 as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
24816 fi
24817 fi
24818
24819 # Now join together the path and the arguments once again
24820 if test "x$arguments" != xEOL; then
24821 new_complete="$new_path ${arguments% *}"
24822 else
24823 new_complete="$new_path"
24824 fi
24825
24826 if test "x$complete" != "x$new_complete"; then
24827 DUMPBIN="$new_complete"
24828 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting DUMPBIN to \"$new_complete\"" >&5
24829 $as_echo "$as_me: Rewriting DUMPBIN to \"$new_complete\"" >&6;}
24830 fi
24831
24832
24833 COMPILER_TYPE=CL
24834 CCXXFLAGS="$CCXXFLAGS -nologo"
24835
24836 fi
24837
24838
24839
24840 ac_ext=c
24841 ac_cpp='$CPP $CPPFLAGS'
24842 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
24843 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
24844 ac_compiler_gnu=$ac_cv_c_compiler_gnu
24845 { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
24846 $as_echo_n "checking how to run the C preprocessor... " >&6; }
24847 # On Suns, sometimes $CPP names a directory.
24848 if test -n "$CPP" && test -d "$CPP"; then
24849 CPP=
24850 fi
24851 if test -z "$CPP"; then
24852 if ${ac_cv_prog_CPP+:} false; then :
24853 $as_echo_n "(cached) " >&6
24854 else
29647 fi
29648
29649
29650 CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags"
29651 CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags"
29652 LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags"
29653
29654 # Hotspot needs these set in their legacy form
29655 LEGACY_EXTRA_CFLAGS=$with_extra_cflags
29656 LEGACY_EXTRA_CXXFLAGS=$with_extra_cxxflags
29657 LEGACY_EXTRA_LDFLAGS=$with_extra_ldflags
29658
29659
29660
29661
29662
29663 ###############################################################################
29664 #
29665 # Now setup the CFLAGS and LDFLAGS for the JDK build.
29666 # Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build.
29667 #
29668 case $COMPILER_NAME in
29669 gcc )
29670 CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -W -Wall -Wno-unused -Wno-parentheses \
29671 -pipe \
29672 -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
29673 case $OPENJDK_TARGET_CPU_ARCH in
29674 arm )
29675 # on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing
29676 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
29677 ;;
29678 ppc )
29679 # on ppc we don't prevent gcc to omit frame pointer nor strict-aliasing
29680 ;;
29681 * )
29682 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -fno-omit-frame-pointer"
29683 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
29684 ;;
29685 esac
29686 ;;
29687 ossc )
29688 CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
29689 case $OPENJDK_TARGET_CPU_ARCH in
29690 x86 )
29691 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
29692 CFLAGS_JDK="$CFLAGS_JDK -erroff=E_BAD_PRAGMA_PACK_VALUE"
29693 ;;
29694 esac
29695
29696 CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
29697 CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
29698
29699 LDFLAGS_JDK="$LDFLAGS_JDK -z defs -xildoff -ztext"
29700 LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK -norunpath -xnolib"
29701 ;;
29702 xlc )
29703 CFLAGS_JDK="$CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
29704 CXXFLAGS_JDK="$CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
29705
29706 LDFLAGS_JDK="$LDFLAGS_JDK"
29707 LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK"
29708 ;;
29709 cl )
29710 CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \
29711 -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \
29712 -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
29713 -DWIN32 -DIAL"
29714 case $OPENJDK_TARGET_CPU in
29715 x86 )
29716 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_X86_ -Dx86"
29717 ;;
29718 x86_64 )
29719 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_AMD64_ -Damd64"
29720 ;;
29721 esac
29722 ;;
29723 esac
29724
29725 ###############################################################################
29726
29727 # Adjust flags according to debug level.
29728 case $DEBUG_LEVEL in
29729 fastdebug )
29730 CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS"
29731 CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS"
29732 C_O_FLAG_HI="$C_O_FLAG_NORM"
29733 C_O_FLAG_NORM="$C_O_FLAG_NORM"
29734 CXX_O_FLAG_HI="$CXX_O_FLAG_NORM"
29735 CXX_O_FLAG_NORM="$CXX_O_FLAG_NORM"
29736 JAVAC_FLAGS="$JAVAC_FLAGS -g"
29737 ;;
29738 slowdebug )
29739 CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS"
29740 CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS"
29741 C_O_FLAG_HI="$C_O_FLAG_NONE"
29742 C_O_FLAG_NORM="$C_O_FLAG_NONE"
29743 CXX_O_FLAG_HI="$CXX_O_FLAG_NONE"
29744 CXX_O_FLAG_NORM="$CXX_O_FLAG_NONE"
29745 JAVAC_FLAGS="$JAVAC_FLAGS -g"
29746 ;;
29747 esac
29748
29749 CCXXFLAGS_JDK="$CCXXFLAGS_JDK $ADD_LP64"
29750
29751 # The package path is used only on macosx?
29752 PACKAGE_PATH=/opt/local
29753
29754
29755 if test "x$OPENJDK_TARGET_CPU_ENDIAN" = xlittle; then
29756 # The macro _LITTLE_ENDIAN needs to be defined the same to avoid the
29757 # Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN
29758 # (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h).
29759 # Note: -Dmacro is the same as #define macro 1
29760 # -Dmacro= is the same as #define macro
29761 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
29762 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
29763 else
29764 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
29765 fi
29766 else
29767 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN"
29768 fi
29769 if test "x$OPENJDK_TARGET_OS" = xlinux; then
29770 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DLINUX"
29771 fi
29772 if test "x$OPENJDK_TARGET_OS" = xwindows; then
29773 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DWINDOWS"
29774 fi
29775 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
29776 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DSOLARIS"
29777 fi
29778 if test "x$OPENJDK_TARGET_OS" = xaix; then
29779 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DAIX -DPPC64"
29780 fi
29781 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
29782 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMACOSX -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
29783 # Setting these parameters makes it an error to link to macosx APIs that are
29784 # newer than the given OS version and makes the linked binaries compatible even
29785 # if built on a newer version of the OS.
29786 # The expected format is X.Y.Z
29787 MACOSX_VERSION_MIN=10.7.0
29788
29789 # The macro takes the version with no dots, ex: 1070
29790 # Let the flags variables get resolved in make for easier override on make
29791 # command line.
29792 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
29793 LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
29794 fi
29795 if test "x$OPENJDK_TARGET_OS" = xbsd; then
29796 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DBSD -D_ALLBSD_SOURCE"
29797 fi
29798 if test "x$DEBUG_LEVEL" = xrelease; then
29799 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DNDEBUG"
29800 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
29801 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DTRIMMED"
29802 fi
29803 else
29804 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DDEBUG"
29805 fi
29806
29807 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DARCH='\"$OPENJDK_TARGET_CPU_LEGACY\"' -D$OPENJDK_TARGET_CPU_LEGACY"
29808 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DRELEASE='\"\$(RELEASE)\"'"
29809
29810 CCXXFLAGS_JDK="$CCXXFLAGS_JDK \
29811 -I${JDK_OUTPUTDIR}/include \
29812 -I${JDK_OUTPUTDIR}/include/$OPENJDK_TARGET_OS \
29813 -I${JDK_TOPDIR}/src/share/javavm/export \
29814 -I${JDK_TOPDIR}/src/$OPENJDK_TARGET_OS_EXPORT_DIR/javavm/export \
29815 -I${JDK_TOPDIR}/src/share/native/common \
29816 -I${JDK_TOPDIR}/src/$OPENJDK_TARGET_OS_API_DIR/native/common"
29817
29818 # The shared libraries are compiled using the picflag.
29819 CFLAGS_JDKLIB="$CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
29820 CXXFLAGS_JDKLIB="$CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA "
29821
29822 # Executable flags
29823 CFLAGS_JDKEXE="$CCXXFLAGS_JDK $CFLAGS_JDK"
29824 CXXFLAGS_JDKEXE="$CCXXFLAGS_JDK $CXXFLAGS_JDK"
29825
29826 # Now this is odd. The JDK native libraries have to link against libjvm.so
29827 # On 32-bit machines there is normally two distinct libjvm.so:s, client and server.
29828 # Which should we link to? Are we lucky enough that the binary api to the libjvm.so library
29829 # is identical for client and server? Yes. Which is picked at runtime (client or server)?
29830 # Neither, since the chosen libjvm.so has already been loaded by the launcher, all the following
29831 # libraries will link to whatever is in memory. Yuck.
29832 #
29833 # Thus we offer the compiler to find libjvm.so first in server then in client. It works. Ugh.
29834 if test "x$COMPILER_NAME" = xcl; then
29835 LDFLAGS_JDK="$LDFLAGS_JDK -nologo -opt:ref -incremental:no"
29836 if test "x$OPENJDK_TARGET_CPU" = xx86; then
29837 LDFLAGS_JDK="$LDFLAGS_JDK -safeseh"
29838 fi
29839 # TODO: make -debug optional "--disable-full-debug-symbols"
29840 LDFLAGS_JDK="$LDFLAGS_JDK -debug"
29841 LDFLAGS_JDKLIB="${LDFLAGS_JDK} -dll -libpath:${JDK_OUTPUTDIR}/lib"
29842 LDFLAGS_JDKLIB_SUFFIX=""
29843 if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
29844 LDFLAGS_STACK_SIZE=1048576
29888
29889 LDFLAGS_JDKEXE="${LDFLAGS_JDK}"
29890 if test "x$OPENJDK_TARGET_OS" = xlinux; then
29891 LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -Xlinker --allow-shlib-undefined"
29892 fi
29893 fi
29894
29895
29896
29897
29898
29899
29900
29901
29902
29903
29904
29905
29906
29907
29908
29909 # Some Zero and Shark settings.
29910 # ZERO_ARCHFLAG tells the compiler which mode to build for
29911 case "${OPENJDK_TARGET_CPU}" in
29912 s390)
29913 ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}31"
29914 ;;
29915 *)
29916 ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
29917 esac
29918
29919 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if compiler supports \"$ZERO_ARCHFLAG\"" >&5
29920 $as_echo_n "checking if compiler supports \"$ZERO_ARCHFLAG\"... " >&6; }
29921 supports=yes
29922
29923 saved_cflags="$CFLAGS"
29924 CFLAGS="$CFLAGS $ZERO_ARCHFLAG"
29925 ac_ext=c
29926 ac_cpp='$CPP $CPPFLAGS'
29927 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
29928 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
29929 ac_compiler_gnu=$ac_cv_c_compiler_gnu
29930
29931 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
29932 /* end confdefs.h. */
29933 int i;
29934 _ACEOF
29935 if ac_fn_c_try_compile "$LINENO"; then :
29936
29937 else
29938 supports=no
29939 fi
29940 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
29958 /* end confdefs.h. */
29959 int i;
29960 _ACEOF
29961 if ac_fn_cxx_try_compile "$LINENO"; then :
29962
29963 else
29964 supports=no
29965 fi
29966 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
29967 ac_ext=cpp
29968 ac_cpp='$CXXCPP $CPPFLAGS'
29969 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
29970 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
29971 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
29972
29973 CXXFLAGS="$saved_cxxflags"
29974
29975 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
29976 $as_echo "$supports" >&6; }
29977 if test "x$supports" = "xyes" ; then
29978 :
29979 else
29980 ZERO_ARCHFLAG=""
29981 fi
29982
29983
29984
29985 # Check that the compiler supports -mX (or -qX on AIX) flags
29986 # Set COMPILER_SUPPORTS_TARGET_BITS_FLAG to 'true' if it does
29987
29988 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
29989 $as_echo_n "checking if compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
29990 supports=yes
29991
29992 saved_cflags="$CFLAGS"
29993 CFLAGS="$CFLAGS ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
29994 ac_ext=c
29995 ac_cpp='$CPP $CPPFLAGS'
29996 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
29997 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
29998 ac_compiler_gnu=$ac_cv_c_compiler_gnu
29999
30000 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
30001 /* end confdefs.h. */
30002 int i;
30003 _ACEOF
30004 if ac_fn_c_try_compile "$LINENO"; then :
30005
30006 else
30007 supports=no
30008 fi
30009 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
30023 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
30024 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
30025
30026 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
30027 /* end confdefs.h. */
30028 int i;
30029 _ACEOF
30030 if ac_fn_cxx_try_compile "$LINENO"; then :
30031
30032 else
30033 supports=no
30034 fi
30035 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
30036 ac_ext=cpp
30037 ac_cpp='$CXXCPP $CPPFLAGS'
30038 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
30039 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
30040 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
30041
30042 CXXFLAGS="$saved_cxxflags"
30043
30044 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
30045 $as_echo "$supports" >&6; }
30046 if test "x$supports" = "xyes" ; then
30047 COMPILER_SUPPORTS_TARGET_BITS_FLAG=true
30048 else
30049 COMPILER_SUPPORTS_TARGET_BITS_FLAG=false
30050 fi
30051
30052
30053
30054
30055 # Check for broken SuSE 'ld' for which 'Only anonymous version tag is allowed in executable.'
30056 USING_BROKEN_SUSE_LD=no
30057 if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$GCC" = xyes; then
30058 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for broken SuSE 'ld' which only understands anonymous version tags in executables" >&5
30059 $as_echo_n "checking for broken SuSE 'ld' which only understands anonymous version tags in executables... " >&6; }
30060 echo "SUNWprivate_1.1 { local: *; };" > version-script.map
30061 echo "int main() { }" > main.c
30062 if $CXX -Xlinker -version-script=version-script.map main.c 2>&5 >&5; then
|
662 XMKMF
663 FIXPATH
664 CXXFLAGS_DEBUG_SYMBOLS
665 CFLAGS_DEBUG_SYMBOLS
666 ZIP_DEBUGINFO_FILES
667 ENABLE_DEBUG_SYMBOLS
668 USING_BROKEN_SUSE_LD
669 COMPILER_SUPPORTS_TARGET_BITS_FLAG
670 ZERO_ARCHFLAG
671 LDFLAGS_CXX_JDK
672 LDFLAGS_JDKEXE_SUFFIX
673 LDFLAGS_JDKLIB_SUFFIX
674 LDFLAGS_JDKEXE
675 LDFLAGS_JDKLIB
676 CXXFLAGS_JDKEXE
677 CXXFLAGS_JDKLIB
678 CFLAGS_JDKEXE
679 CFLAGS_JDKLIB
680 MACOSX_VERSION_MIN
681 PACKAGE_PATH
682 NO_LIFETIME_DSE_CFLAG
683 NO_DELETE_NULL_POINTER_CHECKS_CFLAG
684 CXXSTD_CXXFLAG
685 LEGACY_EXTRA_LDFLAGS
686 LEGACY_EXTRA_CXXFLAGS
687 LEGACY_EXTRA_CFLAGS
688 CXX_FLAG_DEPS
689 C_FLAG_DEPS
690 CXX_O_FLAG_NONE
691 CXX_O_FLAG_NORM
692 CXX_O_FLAG_HI
693 CXX_O_FLAG_HIGHEST
694 C_O_FLAG_NONE
695 C_O_FLAG_NORM
696 C_O_FLAG_HI
697 C_O_FLAG_HIGHEST
698 POST_MCS_CMD
699 POST_STRIP_CMD
700 SET_EXECUTABLE_ORIGIN
701 SET_SHARED_LIBRARY_ORIGIN
702 CXX_FLAG_REORDER
703 C_FLAG_REORDER
704 SET_SHARED_LIBRARY_MAPFILE
729 COMPILER_TYPE
730 RC_FLAGS
731 DUMPBIN
732 WINAR
733 HOTSPOT_RC
734 HOTSPOT_MT
735 RC
736 MT
737 WINLD
738 HOTSPOT_LD
739 HOTSPOT_CXX
740 ARFLAGS
741 AR
742 LDEXECXX
743 LDCXX
744 LDEXE
745 LD
746 ac_ct_OBJC
747 OBJCFLAGS
748 OBJC
749 CXX_VERSION
750 CC_VERSION
751 ac_ct_CXX
752 CXXFLAGS
753 CXX
754 ac_ct_PROPER_COMPILER_CXX
755 PROPER_COMPILER_CXX
756 POTENTIAL_CXX
757 TOOLS_DIR_CXX
758 COMPILER_TARGET_BITS_FLAG
759 OBJEXT
760 EXEEXT
761 ac_ct_CC
762 CPPFLAGS
763 LDFLAGS
764 CFLAGS
765 CC
766 ac_ct_PROPER_COMPILER_CC
767 PROPER_COMPILER_CC
768 POTENTIAL_CC
769 TOOLS_DIR_CC
770 SDKPATH
3660 # questions.
3661 #
3662
3663
3664
3665
3666
3667
3668
3669
3670
3671
3672
3673
3674
3675
3676
3677
3678
3679 #
3680 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3681 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3682 #
3683 # This code is free software; you can redistribute it and/or modify it
3684 # under the terms of the GNU General Public License version 2 only, as
3685 # published by the Free Software Foundation. Oracle designates this
3686 # particular file as subject to the "Classpath" exception as provided
3687 # by Oracle in the LICENSE file that accompanied this code.
3688 #
3689 # This code is distributed in the hope that it will be useful, but WITHOUT
3690 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3691 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3692 # version 2 for more details (a copy is included in the LICENSE file that
3693 # accompanied this code).
3694 #
3695 # You should have received a copy of the GNU General Public License version
3696 # 2 along with this work; if not, write to the Free Software Foundation,
3697 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3698 #
3699 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3700 # or visit www.oracle.com if you need additional information or have any
3783 # under the terms of the GNU General Public License version 2 only, as
3784 # published by the Free Software Foundation. Oracle designates this
3785 # particular file as subject to the "Classpath" exception as provided
3786 # by Oracle in the LICENSE file that accompanied this code.
3787 #
3788 # This code is distributed in the hope that it will be useful, but WITHOUT
3789 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3790 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3791 # version 2 for more details (a copy is included in the LICENSE file that
3792 # accompanied this code).
3793 #
3794 # You should have received a copy of the GNU General Public License version
3795 # 2 along with this work; if not, write to the Free Software Foundation,
3796 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3797 #
3798 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3799 # or visit www.oracle.com if you need additional information or have any
3800 # questions.
3801 #
3802
3803 # Prepare the system so that TOOLCHAIN_CHECK_COMPILER_VERSION can be called.
3804 # Must have CC_VERSION_NUMBER and CXX_VERSION_NUMBER.
3805
3806
3807 # Check if the configured compiler (C and C++) is of a specific version or
3808 # newer. TOOLCHAIN_PREPARE_FOR_VERSION_COMPARISONS must have been called before.
3809 #
3810 # Arguments:
3811 # $1: The version string to check against the found version
3812 # $2: block to run if the compiler is at least this version (>=)
3813 # $3: block to run if the compiler is older than this version (<)
3814
3815
3816 # $1 = compiler to test (CC or CXX)
3817 # $2 = human readable name of compiler (C or C++)
3818
3819
3820
3821
3822
3823 # $1 = compiler to test (CC or CXX)
3824 # $2 = human readable name of compiler (C or C++)
3825 # $3 = list of compiler names to search for
3826
3827
3828
3829
3830
3831
3832
3833
3834
3835
3836
3837
3838
3839 # TOOLCHAIN_C_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3840 # [RUN-IF-FALSE])
3841 # ------------------------------------------------------------
3842 # Check that the C compiler supports an argument
3843
3844
3845 # TOOLCHAIN_CXX_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3846 # [RUN-IF-FALSE])
3847 # ------------------------------------------------------------
3848 # Check that the C++ compiler supports an argument
3849
3850
3851 # TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3852 # [RUN-IF-FALSE])
3853 # ------------------------------------------------------------
3854 # Check that the C and C++ compilers support an argument
3855
3856
3857
3858
3859 # Setup the JTREG paths
3860
3861
3862
3863
3864 #
3865 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3866 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3867 #
3868 # This code is free software; you can redistribute it and/or modify it
3869 # under the terms of the GNU General Public License version 2 only, as
3870 # published by the Free Software Foundation. Oracle designates this
3871 # particular file as subject to the "Classpath" exception as provided
3872 # by Oracle in the LICENSE file that accompanied this code.
3873 #
3874 # This code is distributed in the hope that it will be useful, but WITHOUT
3875 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3876 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3877 # version 2 for more details (a copy is included in the LICENSE file that
3878 # accompanied this code).
3879 #
3880 # You should have received a copy of the GNU General Public License version
3881 # 2 along with this work; if not, write to the Free Software Foundation,
3882 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3883 #
3895 # Check if the VS env variables were setup prior to running configure.
3896 # If not, then find vcvarsall.bat and run it automatically, and integrate
3897 # the set env variables into the spec file.
3898
3899
3900
3901
3902
3903
3904
3905
3906
3907
3908
3909 # This line needs to be here, verbatim, after all includes and the dummy hook
3910 # definitions. It is replaced with custom functionality when building
3911 # custom sources.
3912 #CUSTOM_AUTOCONF_INCLUDE
3913
3914 # Do not change or remove the following line, it is needed for consistency checks:
3915 DATE_WHEN_GENERATED=1467921862
3916
3917 ###############################################################################
3918 #
3919 # Initialization / Boot-strapping
3920 #
3921 # The bootstrapping process needs to solve the "chicken or the egg" problem,
3922 # thus it jumps back and forth, each time gaining something needed later on.
3923 #
3924 ###############################################################################
3925
3926 # Basic initialization that must happen first of all
3927
3928 # Save the original command line. This is passed to us by the wrapper configure script.
3929
3930 DATE_WHEN_CONFIGURED=`LANG=C date`
3931
3932 { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
3933 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
3934 { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
3935 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
20383 fi
20384 elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then
20385 if test "x$COMPILER_CPU_TEST" != "xx64"; then
20386 as_fn_error $? "Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for \"$COMPILER_CPU_TEST\"; expected \"x64\"." "$LINENO" 5
20387 fi
20388 fi
20389 else
20390 COMPILER_VERSION_TEST=`$COMPILER --version 2>&1 | $HEAD -n 1`
20391 # Check that this is likely to be GCC.
20392 $COMPILER --version 2>&1 | $GREP "Free Software Foundation" > /dev/null
20393 if test $? -ne 0; then
20394 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required GCC compiler." >&5
20395 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required GCC compiler." >&6;}
20396 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_TEST\"" >&5
20397 $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_TEST\"" >&6;}
20398 as_fn_error $? "GCC compiler is required. Try setting --with-tools-dir." "$LINENO" 5
20399 fi
20400
20401 # First line typically looks something like:
20402 # gcc (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2
20403 COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | \
20404 $SED -e 's/^.* \([1-9]\.[0-9.]*\)[^0-9.].*$/\1/'`
20405 COMPILER_VENDOR=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^\(.*\) [1-9][0-9.]*/\1/p"`
20406 fi
20407 # This sets CC_VERSION or CXX_VERSION. (This comment is a grep marker)
20408 CC_VERSION="$COMPILER_VERSION"
20409 # This sets CC_VENDOR or CXX_VENDOR. (This comment is a grep marker)
20410 CC_VENDOR="$COMPILER_VENDOR"
20411
20412 { $as_echo "$as_me:${as_lineno-$LINENO}: Using $COMPILER_VENDOR $COMPILER_NAME compiler version $COMPILER_VERSION (located at $COMPILER)" >&5
20413 $as_echo "$as_me: Using $COMPILER_VENDOR $COMPILER_NAME compiler version $COMPILER_VERSION (located at $COMPILER)" >&6;}
20414
20415
20416 # Now that we have resolved CC ourself, let autoconf have its go at it
20417 ac_ext=c
20418 ac_cpp='$CPP $CPPFLAGS'
20419 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
20420 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
20421 ac_compiler_gnu=$ac_cv_c_compiler_gnu
20422 if test -n "$ac_tool_prefix"; then
20423 for ac_prog in $CC
20424 do
21985 fi
21986 elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then
21987 if test "x$COMPILER_CPU_TEST" != "xx64"; then
21988 as_fn_error $? "Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for \"$COMPILER_CPU_TEST\"; expected \"x64\"." "$LINENO" 5
21989 fi
21990 fi
21991 else
21992 COMPILER_VERSION_TEST=`$COMPILER --version 2>&1 | $HEAD -n 1`
21993 # Check that this is likely to be GCC.
21994 $COMPILER --version 2>&1 | $GREP "Free Software Foundation" > /dev/null
21995 if test $? -ne 0; then
21996 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required GCC compiler." >&5
21997 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required GCC compiler." >&6;}
21998 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_TEST\"" >&5
21999 $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_TEST\"" >&6;}
22000 as_fn_error $? "GCC compiler is required. Try setting --with-tools-dir." "$LINENO" 5
22001 fi
22002
22003 # First line typically looks something like:
22004 # gcc (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2
22005 COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | \
22006 $SED -e 's/^.* \([1-9]\.[0-9.]*\)[^0-9.].*$/\1/'`
22007 COMPILER_VENDOR=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^\(.*\) [1-9][0-9.]*/\1/p"`
22008 fi
22009 # This sets CC_VERSION or CXX_VERSION. (This comment is a grep marker)
22010 CXX_VERSION="$COMPILER_VERSION"
22011 # This sets CC_VENDOR or CXX_VENDOR. (This comment is a grep marker)
22012 CXX_VENDOR="$COMPILER_VENDOR"
22013
22014 { $as_echo "$as_me:${as_lineno-$LINENO}: Using $COMPILER_VENDOR $COMPILER_NAME compiler version $COMPILER_VERSION (located at $COMPILER)" >&5
22015 $as_echo "$as_me: Using $COMPILER_VENDOR $COMPILER_NAME compiler version $COMPILER_VERSION (located at $COMPILER)" >&6;}
22016
22017
22018 # Now that we have resolved CXX ourself, let autoconf have its go at it
22019 ac_ext=cpp
22020 ac_cpp='$CXXCPP $CPPFLAGS'
22021 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
22022 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
22023 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
22024 if test -z "$CXX"; then
22025 if test -n "$CCC"; then
22026 CXX=$CCC
22257 elif test $ac_cv_prog_cxx_g = yes; then
22258 if test "$GXX" = yes; then
22259 CXXFLAGS="-g -O2"
22260 else
22261 CXXFLAGS="-g"
22262 fi
22263 else
22264 if test "$GXX" = yes; then
22265 CXXFLAGS="-O2"
22266 else
22267 CXXFLAGS=
22268 fi
22269 fi
22270 ac_ext=cpp
22271 ac_cpp='$CXXCPP $CPPFLAGS'
22272 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
22273 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
22274 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
22275
22276
22277 # This is the compiler version number on the form X.Y[.Z]
22278
22279
22280
22281
22282 if test "x$CC_VERSION" != "x$CXX_VERSION"; then
22283 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C and C++ compiler has different version numbers, $CC_VERSION vs $CXX_VERSION." >&5
22284 $as_echo "$as_me: WARNING: C and C++ compiler has different version numbers, $CC_VERSION vs $CXX_VERSION." >&2;}
22285 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This typically indicates a broken setup, and is not supported" >&5
22286 $as_echo "$as_me: WARNING: This typically indicates a broken setup, and is not supported" >&2;}
22287 fi
22288
22289 # We only check CC_VERSION since we assume CXX_VERSION is equal.
22290 if [[ "$CC_VERSION" =~ (.*\.){3} ]] ; then
22291 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has more than three parts (X.Y.Z): $CC_VERSION. Comparisons might be wrong." >&5
22292 $as_echo "$as_me: WARNING: C compiler version number has more than three parts (X.Y.Z): $CC_VERSION. Comparisons might be wrong." >&2;}
22293 fi
22294
22295 if [[ "$CC_VERSION" =~ [0-9]{6} ]] ; then
22296 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION. Comparisons might be wrong." >&5
22297 $as_echo "$as_me: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION. Comparisons might be wrong." >&2;}
22298 fi
22299
22300 COMPARABLE_ACTUAL_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", $1, $2, $3) }' <<< "$CC_VERSION"`
22301
22302
22303 ### Locate other tools
22304
22305 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
22306 ac_ext=m
22307 ac_cpp='$OBJCPP $CPPFLAGS'
22308 ac_compile='$OBJC -c $OBJCFLAGS $CPPFLAGS conftest.$ac_ext >&5'
22309 ac_link='$OBJC -o conftest$ac_exeext $OBJCFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
22310 ac_compiler_gnu=$ac_cv_objc_compiler_gnu
22311 if test -n "$ac_tool_prefix"; then
22312 for ac_prog in gcc objcc objc cc CC
22313 do
22314 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
22315 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
22316 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22317 $as_echo_n "checking for $ac_word... " >&6; }
22318 if ${ac_cv_prog_OBJC+:} false; then :
22319 $as_echo_n "(cached) " >&6
22320 else
22321 if test -n "$OBJC"; then
22322 ac_cv_prog_OBJC="$OBJC" # Let the user override the test.
24874 fi
24875 as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
24876 fi
24877 fi
24878
24879 # Now join together the path and the arguments once again
24880 if test "x$arguments" != xEOL; then
24881 new_complete="$new_path ${arguments% *}"
24882 else
24883 new_complete="$new_path"
24884 fi
24885
24886 if test "x$complete" != "x$new_complete"; then
24887 DUMPBIN="$new_complete"
24888 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting DUMPBIN to \"$new_complete\"" >&5
24889 $as_echo "$as_me: Rewriting DUMPBIN to \"$new_complete\"" >&6;}
24890 fi
24891
24892
24893 COMPILER_TYPE=CL
24894 # silence copyright notice and other headers.
24895 COMMON_CCXXFLAGS="$COMMON_CCXXFLAGS -nologo"
24896
24897 fi
24898
24899
24900
24901 ac_ext=c
24902 ac_cpp='$CPP $CPPFLAGS'
24903 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
24904 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
24905 ac_compiler_gnu=$ac_cv_c_compiler_gnu
24906 { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
24907 $as_echo_n "checking how to run the C preprocessor... " >&6; }
24908 # On Suns, sometimes $CPP names a directory.
24909 if test -n "$CPP" && test -d "$CPP"; then
24910 CPP=
24911 fi
24912 if test -z "$CPP"; then
24913 if ${ac_cv_prog_CPP+:} false; then :
24914 $as_echo_n "(cached) " >&6
24915 else
29708 fi
29709
29710
29711 CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags"
29712 CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags"
29713 LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags"
29714
29715 # Hotspot needs these set in their legacy form
29716 LEGACY_EXTRA_CFLAGS=$with_extra_cflags
29717 LEGACY_EXTRA_CXXFLAGS=$with_extra_cxxflags
29718 LEGACY_EXTRA_LDFLAGS=$with_extra_ldflags
29719
29720
29721
29722
29723
29724 ###############################################################################
29725 #
29726 # Now setup the CFLAGS and LDFLAGS for the JDK build.
29727 # Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build.
29728 # CFLAGS_JDK - C Compiler flags
29729 # CXXFLAGS_JDK - C++ Compiler flags
29730 # COMMON_CCXXFLAGS_JDK - common to C and C++
29731 #
29732 case $COMPILER_NAME in
29733 gcc )
29734 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -W -Wall -Wno-unused -Wno-parentheses \
29735 -pipe \
29736 -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
29737 CXXSTD_CXXFLAG="-std=gnu++98"
29738
29739 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$CXXSTD_CXXFLAG $CFLAGS_WARNINGS_ARE_ERRORS\"" >&5
29740 $as_echo_n "checking if the C++ compiler supports \"$CXXSTD_CXXFLAG $CFLAGS_WARNINGS_ARE_ERRORS\"... " >&6; }
29741 supports=yes
29742
29743 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
29744 $as_echo "$supports" >&6; }
29745 if test "x$supports" = "xyes" ; then
29746 :
29747 else
29748 CXXSTD_CXXFLAG=""
29749 fi
29750
29751 CXXFLAGS_JDK="${CXXFLAGS_JDK} ${CXXSTD_CXXFLAG}"
29752
29753 case $OPENJDK_TARGET_CPU_ARCH in
29754 arm )
29755 # on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing
29756 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
29757 ;;
29758 ppc )
29759 # on ppc we don't prevent gcc to omit frame pointer nor strict-aliasing
29760 ;;
29761 * )
29762 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
29763 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
29764 ;;
29765 esac
29766
29767 REFERENCE_VERSION=6
29768
29769 if [[ "$REFERENCE_VERSION" =~ (.*\.){3} ]] ; then
29770 as_fn_error $? "Internal error: Cannot compare to $REFERENCE_VERSION, only three parts (X.Y.Z) is supported" "$LINENO" 5
29771 fi
29772
29773 if [[ "$REFERENCE_VERSION" =~ [0-9]{6} ]] ; then
29774 as_fn_error $? "Internal error: Cannot compare to $REFERENCE_VERSION, only parts < 99999 is supported" "$LINENO" 5
29775 fi
29776
29777 # Version comparison method inspired by http://stackoverflow.com/a/24067243
29778 COMPARABLE_REFERENCE_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", $1, $2, $3) }' <<< "$REFERENCE_VERSION"`
29779
29780 if test $COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
29781
29782 # These flags are required for GCC 6 builds as undefined behaviour in OpenJDK code
29783 # runs afoul of the more aggressive versions of these optimisations.
29784 # Notably, value range propagation now assumes that the this pointer of C++
29785 # member functions is non-null.
29786 NO_DELETE_NULL_POINTER_CHECKS_CFLAG="-fno-delete-null-pointer-checks"
29787
29788
29789 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"" >&5
29790 $as_echo_n "checking if the C compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"... " >&6; }
29791 supports=yes
29792
29793 saved_cflags="$CFLAGS"
29794 CFLAGS="$CFLAGS $NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror"
29795 ac_ext=c
29796 ac_cpp='$CPP $CPPFLAGS'
29797 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
29798 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
29799 ac_compiler_gnu=$ac_cv_c_compiler_gnu
29800
29801
29802 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
29803 /* end confdefs.h. */
29804 int i;
29805 _ACEOF
29806 if ac_fn_c_try_compile "$LINENO"; then :
29807
29808 else
29809 supports=no
29810 fi
29811 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
29812 ac_ext=cpp
29813 ac_cpp='$CXXCPP $CPPFLAGS'
29814 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
29815 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
29816 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
29817
29818 CFLAGS="$saved_cflags"
29819
29820 saved_cxxflags="$CXXFLAGS"
29821 CXXFLAGS="$CXXFLAG $NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror"
29822 ac_ext=cpp
29823 ac_cpp='$CXXCPP $CPPFLAGS'
29824 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
29825 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
29826 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
29827
29828 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
29829 /* end confdefs.h. */
29830 int i;
29831 _ACEOF
29832 if ac_fn_cxx_try_compile "$LINENO"; then :
29833
29834 else
29835 supports=no
29836 fi
29837 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
29838 ac_ext=cpp
29839 ac_cpp='$CXXCPP $CPPFLAGS'
29840 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
29841 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
29842 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
29843
29844 CXXFLAGS="$saved_cxxflags"
29845
29846 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
29847 $as_echo "$supports" >&6; }
29848 if test "x$supports" = "xyes" ; then
29849 C_COMP_SUPPORTS="yes"
29850 else
29851 C_COMP_SUPPORTS="no"
29852 fi
29853
29854
29855 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"" >&5
29856 $as_echo_n "checking if the C++ compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"... " >&6; }
29857 supports=yes
29858
29859 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
29860 $as_echo "$supports" >&6; }
29861 if test "x$supports" = "xyes" ; then
29862 CXX_COMP_SUPPORTS="yes"
29863 else
29864 CXX_COMP_SUPPORTS="no"
29865 fi
29866
29867
29868 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"" >&5
29869 $as_echo_n "checking if both compilers support \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"... " >&6; }
29870 supports=no
29871 if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
29872
29873 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
29874 $as_echo "$supports" >&6; }
29875 if test "x$supports" = "xyes" ; then
29876 :
29877 else
29878 NO_DELETE_NULL_POINTER_CHECKS_CFLAG=""
29879 fi
29880
29881
29882 NO_LIFETIME_DSE_CFLAG="-fno-lifetime-dse"
29883
29884
29885 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"" >&5
29886 $as_echo_n "checking if the C compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"... " >&6; }
29887 supports=yes
29888
29889 saved_cflags="$CFLAGS"
29890 CFLAGS="$CFLAGS $NO_LIFETIME_DSE_CFLAG -Werror"
29891 ac_ext=c
29892 ac_cpp='$CPP $CPPFLAGS'
29893 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
29894 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
29895 ac_compiler_gnu=$ac_cv_c_compiler_gnu
29896
29897 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
29898 /* end confdefs.h. */
29899 int i;
29900 _ACEOF
29901 if ac_fn_c_try_compile "$LINENO"; then :
29902
29903 else
29904 supports=no
29905 fi
29906 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
29907 ac_ext=cpp
29908 ac_cpp='$CXXCPP $CPPFLAGS'
29909 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
29910 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
29911 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
29912
29913 CFLAGS="$saved_cflags"
29914
29915 saved_cxxflags="$CXXFLAGS"
29916 CXXFLAGS="$CXXFLAG $NO_LIFETIME_DSE_CFLAG -Werror"
29917 ac_ext=cpp
29918 ac_cpp='$CXXCPP $CPPFLAGS'
29919 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
29920 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
29921 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
29922
29923 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
29924 /* end confdefs.h. */
29925 int i;
29926 _ACEOF
29927 if ac_fn_cxx_try_compile "$LINENO"; then :
29928
29929 else
29930 supports=no
29931 fi
29932 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
29933 ac_ext=cpp
29934 ac_cpp='$CXXCPP $CPPFLAGS'
29935 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
29936 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
29937 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
29938
29939 CXXFLAGS="$saved_cxxflags"
29940
29941 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
29942 $as_echo "$supports" >&6; }
29943 if test "x$supports" = "xyes" ; then
29944 C_COMP_SUPPORTS="yes"
29945 else
29946 C_COMP_SUPPORTS="no"
29947 fi
29948
29949
29950 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"" >&5
29951 $as_echo_n "checking if the C++ compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"... " >&6; }
29952 supports=yes
29953
29954 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
29955 $as_echo "$supports" >&6; }
29956 if test "x$supports" = "xyes" ; then
29957 CXX_COMP_SUPPORTS="yes"
29958 else
29959 CXX_COMP_SUPPORTS="no"
29960 fi
29961
29962
29963 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$NO_LIFETIME_DSE_CFLAG -Werror\"" >&5
29964 $as_echo_n "checking if both compilers support \"$NO_LIFETIME_DSE_CFLAG -Werror\"... " >&6; }
29965 supports=no
29966 if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
29967
29968 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
29969 $as_echo "$supports" >&6; }
29970 if test "x$supports" = "xyes" ; then
29971 :
29972 else
29973 NO_LIFETIME_DSE_CFLAG=""
29974 fi
29975
29976 CFLAGS_JDK="${CFLAGS_JDK} ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} ${NO_LIFETIME_DSE_CFLAG}"
29977
29978
29979
29980 else
29981 :
29982 fi
29983
29984 ;;
29985 ossc )
29986 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
29987 case $OPENJDK_TARGET_CPU_ARCH in
29988 x86 )
29989 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
29990 CFLAGS_JDK="$CFLAGS_JDK -erroff=E_BAD_PRAGMA_PACK_VALUE"
29991 ;;
29992 esac
29993
29994 CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
29995 CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
29996
29997 LDFLAGS_JDK="$LDFLAGS_JDK -z defs -xildoff -ztext"
29998 LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK -norunpath -xnolib"
29999 ;;
30000 xlc )
30001 CFLAGS_JDK="$CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
30002 CXXFLAGS_JDK="$CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
30003
30004 LDFLAGS_JDK="$LDFLAGS_JDK"
30005 LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK"
30006 ;;
30007 cl )
30008 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \
30009 -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \
30010 -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
30011 -DWIN32 -DIAL"
30012 case $OPENJDK_TARGET_CPU in
30013 x86 )
30014 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_X86_ -Dx86"
30015 ;;
30016 x86_64 )
30017 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_AMD64_ -Damd64"
30018 ;;
30019 esac
30020 ;;
30021 esac
30022
30023 ###############################################################################
30024
30025 # Adjust flags according to debug level.
30026 case $DEBUG_LEVEL in
30027 fastdebug )
30028 CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS"
30029 CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS"
30030 C_O_FLAG_HI="$C_O_FLAG_NORM"
30031 C_O_FLAG_NORM="$C_O_FLAG_NORM"
30032 CXX_O_FLAG_HI="$CXX_O_FLAG_NORM"
30033 CXX_O_FLAG_NORM="$CXX_O_FLAG_NORM"
30034 JAVAC_FLAGS="$JAVAC_FLAGS -g"
30035 ;;
30036 slowdebug )
30037 CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS"
30038 CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS"
30039 C_O_FLAG_HI="$C_O_FLAG_NONE"
30040 C_O_FLAG_NORM="$C_O_FLAG_NONE"
30041 CXX_O_FLAG_HI="$CXX_O_FLAG_NONE"
30042 CXX_O_FLAG_NORM="$CXX_O_FLAG_NONE"
30043 JAVAC_FLAGS="$JAVAC_FLAGS -g"
30044 ;;
30045 esac
30046
30047 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK $ADD_LP64"
30048
30049 # The package path is used only on macosx?
30050 PACKAGE_PATH=/opt/local
30051
30052
30053 if test "x$OPENJDK_TARGET_CPU_ENDIAN" = xlittle; then
30054 # The macro _LITTLE_ENDIAN needs to be defined the same to avoid the
30055 # Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN
30056 # (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h).
30057 # Note: -Dmacro is the same as #define macro 1
30058 # -Dmacro= is the same as #define macro
30059 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
30060 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
30061 else
30062 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
30063 fi
30064 else
30065 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN"
30066 fi
30067 if test "x$OPENJDK_TARGET_OS" = xlinux; then
30068 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DLINUX"
30069 fi
30070 if test "x$OPENJDK_TARGET_OS" = xwindows; then
30071 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DWINDOWS"
30072 fi
30073 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
30074 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DSOLARIS"
30075 fi
30076 if test "x$OPENJDK_TARGET_OS" = xaix; then
30077 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DAIX -DPPC64"
30078 fi
30079 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
30080 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DMACOSX -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
30081 # Setting these parameters makes it an error to link to macosx APIs that are
30082 # newer than the given OS version and makes the linked binaries compatible even
30083 # if built on a newer version of the OS.
30084 # The expected format is X.Y.Z
30085 MACOSX_VERSION_MIN=10.7.0
30086
30087 # The macro takes the version with no dots, ex: 1070
30088 # Let the flags variables get resolved in make for easier override on make
30089 # command line.
30090 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
30091 LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
30092 fi
30093 if test "x$OPENJDK_TARGET_OS" = xbsd; then
30094 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DBSD -D_ALLBSD_SOURCE"
30095 fi
30096 if test "x$DEBUG_LEVEL" = xrelease; then
30097 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DNDEBUG"
30098 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
30099 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DTRIMMED"
30100 fi
30101 else
30102 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DDEBUG"
30103 fi
30104
30105 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DARCH='\"$OPENJDK_TARGET_CPU_LEGACY\"' -D$OPENJDK_TARGET_CPU_LEGACY"
30106 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DRELEASE='\"\$(RELEASE)\"'"
30107
30108 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK \
30109 -I${JDK_OUTPUTDIR}/include \
30110 -I${JDK_OUTPUTDIR}/include/$OPENJDK_TARGET_OS \
30111 -I${JDK_TOPDIR}/src/share/javavm/export \
30112 -I${JDK_TOPDIR}/src/$OPENJDK_TARGET_OS_EXPORT_DIR/javavm/export \
30113 -I${JDK_TOPDIR}/src/share/native/common \
30114 -I${JDK_TOPDIR}/src/$OPENJDK_TARGET_OS_API_DIR/native/common"
30115
30116 # The shared libraries are compiled using the picflag.
30117 CFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
30118 CXXFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA "
30119
30120 # Executable flags
30121 CFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK"
30122 CXXFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK"
30123
30124 # Now this is odd. The JDK native libraries have to link against libjvm.so
30125 # On 32-bit machines there is normally two distinct libjvm.so:s, client and server.
30126 # Which should we link to? Are we lucky enough that the binary api to the libjvm.so library
30127 # is identical for client and server? Yes. Which is picked at runtime (client or server)?
30128 # Neither, since the chosen libjvm.so has already been loaded by the launcher, all the following
30129 # libraries will link to whatever is in memory. Yuck.
30130 #
30131 # Thus we offer the compiler to find libjvm.so first in server then in client. It works. Ugh.
30132 if test "x$COMPILER_NAME" = xcl; then
30133 LDFLAGS_JDK="$LDFLAGS_JDK -nologo -opt:ref -incremental:no"
30134 if test "x$OPENJDK_TARGET_CPU" = xx86; then
30135 LDFLAGS_JDK="$LDFLAGS_JDK -safeseh"
30136 fi
30137 # TODO: make -debug optional "--disable-full-debug-symbols"
30138 LDFLAGS_JDK="$LDFLAGS_JDK -debug"
30139 LDFLAGS_JDKLIB="${LDFLAGS_JDK} -dll -libpath:${JDK_OUTPUTDIR}/lib"
30140 LDFLAGS_JDKLIB_SUFFIX=""
30141 if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
30142 LDFLAGS_STACK_SIZE=1048576
30186
30187 LDFLAGS_JDKEXE="${LDFLAGS_JDK}"
30188 if test "x$OPENJDK_TARGET_OS" = xlinux; then
30189 LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -Xlinker --allow-shlib-undefined"
30190 fi
30191 fi
30192
30193
30194
30195
30196
30197
30198
30199
30200
30201
30202
30203
30204
30205
30206 # Some Zero and Shark settings.
30207 # ZERO_ARCHFLAG tells the compiler which mode to build for
30208 case "${OPENJDK_TARGET_CPU}" in
30209 s390)
30210 ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}31"
30211 ;;
30212 *)
30213 ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
30214 esac
30215
30216
30217 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$ZERO_ARCHFLAG\"" >&5
30218 $as_echo_n "checking if the C compiler supports \"$ZERO_ARCHFLAG\"... " >&6; }
30219 supports=yes
30220
30221 saved_cflags="$CFLAGS"
30222 CFLAGS="$CFLAGS $ZERO_ARCHFLAG"
30223 ac_ext=c
30224 ac_cpp='$CPP $CPPFLAGS'
30225 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
30226 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
30227 ac_compiler_gnu=$ac_cv_c_compiler_gnu
30228
30229 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
30230 /* end confdefs.h. */
30231 int i;
30232 _ACEOF
30233 if ac_fn_c_try_compile "$LINENO"; then :
30234
30235 else
30236 supports=no
30237 fi
30238 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
30256 /* end confdefs.h. */
30257 int i;
30258 _ACEOF
30259 if ac_fn_cxx_try_compile "$LINENO"; then :
30260
30261 else
30262 supports=no
30263 fi
30264 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
30265 ac_ext=cpp
30266 ac_cpp='$CXXCPP $CPPFLAGS'
30267 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
30268 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
30269 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
30270
30271 CXXFLAGS="$saved_cxxflags"
30272
30273 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
30274 $as_echo "$supports" >&6; }
30275 if test "x$supports" = "xyes" ; then
30276 C_COMP_SUPPORTS="yes"
30277 else
30278 C_COMP_SUPPORTS="no"
30279 fi
30280
30281
30282 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$ZERO_ARCHFLAG\"" >&5
30283 $as_echo_n "checking if the C++ compiler supports \"$ZERO_ARCHFLAG\"... " >&6; }
30284 supports=yes
30285
30286 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
30287 $as_echo "$supports" >&6; }
30288 if test "x$supports" = "xyes" ; then
30289 CXX_COMP_SUPPORTS="yes"
30290 else
30291 CXX_COMP_SUPPORTS="no"
30292 fi
30293
30294
30295 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$ZERO_ARCHFLAG\"" >&5
30296 $as_echo_n "checking if both compilers support \"$ZERO_ARCHFLAG\"... " >&6; }
30297 supports=no
30298 if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
30299
30300 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
30301 $as_echo "$supports" >&6; }
30302 if test "x$supports" = "xyes" ; then
30303 :
30304 else
30305 ZERO_ARCHFLAG=""
30306 fi
30307
30308
30309
30310 # Check that the compiler supports -mX (or -qX on AIX) flags
30311 # Set COMPILER_SUPPORTS_TARGET_BITS_FLAG to 'true' if it does
30312
30313
30314 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
30315 $as_echo_n "checking if the C compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
30316 supports=yes
30317
30318 saved_cflags="$CFLAGS"
30319 CFLAGS="$CFLAGS ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
30320 ac_ext=c
30321 ac_cpp='$CPP $CPPFLAGS'
30322 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
30323 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
30324 ac_compiler_gnu=$ac_cv_c_compiler_gnu
30325
30326 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
30327 /* end confdefs.h. */
30328 int i;
30329 _ACEOF
30330 if ac_fn_c_try_compile "$LINENO"; then :
30331
30332 else
30333 supports=no
30334 fi
30335 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
30349 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
30350 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
30351
30352 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
30353 /* end confdefs.h. */
30354 int i;
30355 _ACEOF
30356 if ac_fn_cxx_try_compile "$LINENO"; then :
30357
30358 else
30359 supports=no
30360 fi
30361 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
30362 ac_ext=cpp
30363 ac_cpp='$CXXCPP $CPPFLAGS'
30364 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
30365 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
30366 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
30367
30368 CXXFLAGS="$saved_cxxflags"
30369
30370 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
30371 $as_echo "$supports" >&6; }
30372 if test "x$supports" = "xyes" ; then
30373 C_COMP_SUPPORTS="yes"
30374 else
30375 C_COMP_SUPPORTS="no"
30376 fi
30377
30378
30379 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
30380 $as_echo_n "checking if the C++ compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
30381 supports=yes
30382
30383 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
30384 $as_echo "$supports" >&6; }
30385 if test "x$supports" = "xyes" ; then
30386 CXX_COMP_SUPPORTS="yes"
30387 else
30388 CXX_COMP_SUPPORTS="no"
30389 fi
30390
30391
30392 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
30393 $as_echo_n "checking if both compilers support \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
30394 supports=no
30395 if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
30396
30397 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
30398 $as_echo "$supports" >&6; }
30399 if test "x$supports" = "xyes" ; then
30400 COMPILER_SUPPORTS_TARGET_BITS_FLAG=true
30401 else
30402 COMPILER_SUPPORTS_TARGET_BITS_FLAG=false
30403 fi
30404
30405
30406
30407
30408 # Check for broken SuSE 'ld' for which 'Only anonymous version tag is allowed in executable.'
30409 USING_BROKEN_SUSE_LD=no
30410 if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$GCC" = xyes; then
30411 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for broken SuSE 'ld' which only understands anonymous version tags in executables" >&5
30412 $as_echo_n "checking for broken SuSE 'ld' which only understands anonymous version tags in executables... " >&6; }
30413 echo "SUNWprivate_1.1 { local: *; };" > version-script.map
30414 echo "int main() { }" > main.c
30415 if $CXX -Xlinker -version-script=version-script.map main.c 2>&5 >&5; then
|