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`
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.
164 # searching again.
165
166 # Remove the path to the fake ccache cc from the PATH
167 RETRY_COMPILER_SAVED_PATH="$PATH"
168 COMPILER_DIRNAME=`$DIRNAME [$]$1`
169 PATH="`$ECHO $PATH | $SED -e "s,$COMPILER_DIRNAME,,g" -e "s,::,:,g" -e "s,^:,,g"`"
170
171 # Try again looking for our compiler
172 AC_CHECK_TOOLS(PROPER_COMPILER_$1, $3)
173 BASIC_FIXUP_EXECUTABLE(PROPER_COMPILER_$1)
174 PATH="$RETRY_COMPILER_SAVED_PATH"
175
176 AC_MSG_CHECKING([for resolved symbolic links for $1])
177 BASIC_REMOVE_SYMBOLIC_LINKS(PROPER_COMPILER_$1)
178 AC_MSG_RESULT([$PROPER_COMPILER_$1])
179 $1="$PROPER_COMPILER_$1"
180 else
181 AC_MSG_RESULT([no, keeping $1])
182 $1="$TEST_COMPILER"
183 fi
184 TOOLCHAIN_CHECK_COMPILER_VERSION([$1], [$COMPILER_NAME])
185 ])
186
187
188 AC_DEFUN([TOOLCHAIN_SETUP_PATHS],
189 [
190 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
191 TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV
192 TOOLCHAIN_SETUP_MSVCR_DLL
193 BASIC_DEPRECATED_ARG_WITH([dxsdk])
194 BASIC_DEPRECATED_ARG_WITH([dxsdk-lib])
195 BASIC_DEPRECATED_ARG_WITH([dxsdk-include])
196 fi
197
198 AC_SUBST(MSVCR_DLL)
199
200 # If --build AND --host is set, then the configure script will find any
201 # cross compilation tools in the PATH. Cross compilation tools
202 # follows the cross compilation standard where they are prefixed with ${host}.
203 # For example the binary i686-sun-solaris2.10-gcc
204 # will cross compile for i686-sun-solaris2.10
368
369 ### Locate C++ compiler (CXX)
370
371 if test "x$CXX" != x; then
372 COMPILER_CHECK_LIST="$CXX"
373 elif test "x$OPENJDK_TARGET_OS" = "xwindows"; then
374 COMPILER_CHECK_LIST="cl"
375 elif test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
376 COMPILER_CHECK_LIST="CC g++"
377 elif test "x$OPENJDK_TARGET_OS" = "xaix"; then
378 # Do not probe for CC on AIX .
379 COMPILER_CHECK_LIST="xlC_r"
380 else
381 COMPILER_CHECK_LIST="g++ CC"
382 fi
383
384 TOOLCHAIN_FIND_COMPILER([CXX],[C++],[$COMPILER_CHECK_LIST])
385 # Now that we have resolved CXX ourself, let autoconf have its go at it
386 AC_PROG_CXX([$CXX])
387
388 ### Locate other tools
389
390 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
391 AC_PROG_OBJC
392 BASIC_FIXUP_EXECUTABLE(OBJC)
393 else
394 OBJC=
395 fi
396
397 # Restore the flags to the user specified values.
398 # This is necessary since AC_PROG_CC defaults CFLAGS to "-g -O2"
399 CFLAGS="$ORG_CFLAGS"
400 CXXFLAGS="$ORG_CXXFLAGS"
401 OBJCFLAGS="$ORG_OBJCFLAGS"
402
403 LD="$CC"
404 LDEXE="$CC"
405 LDCXX="$CXX"
406 LDEXECXX="$CXX"
407 AC_SUBST(LD)
490 # are evaluated by make.
491 RC_FLAGS="$RC_FLAGS \
492 -d \"JDK_BUILD_ID=\$(FULL_VERSION)\" \
493 -d \"JDK_COMPANY=\$(COMPANY_NAME)\" \
494 -d \"JDK_COMPONENT=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) binary\" \
495 -d \"JDK_VER=\$(JDK_MINOR_VERSION).\$(JDK_MICRO_VERSION).\$(COOKED_JDK_UPDATE_VERSION).\$(COOKED_BUILD_NUMBER)\" \
496 -d \"JDK_COPYRIGHT=Copyright \xA9 $COPYRIGHT_YEAR\" \
497 -d \"JDK_NAME=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) \$(JDK_MINOR_VERSION) \$(JDK_UPDATE_META_TAG)\" \
498 -d \"JDK_FVER=\$(JDK_MINOR_VERSION),\$(JDK_MICRO_VERSION),\$(COOKED_JDK_UPDATE_VERSION),\$(COOKED_BUILD_NUMBER)\""
499
500 # lib.exe is used to create static libraries.
501 AC_CHECK_PROG([WINAR], [lib],[lib],,,)
502 BASIC_FIXUP_EXECUTABLE(WINAR)
503 AR="$WINAR"
504 ARFLAGS="-nologo -NODEFAULTLIB:MSVCRT"
505
506 AC_CHECK_PROG([DUMPBIN], [dumpbin], [dumpbin],,,)
507 BASIC_FIXUP_EXECUTABLE(DUMPBIN)
508
509 COMPILER_TYPE=CL
510 CCXXFLAGS="$CCXXFLAGS -nologo"
511 ])
512 AC_SUBST(RC_FLAGS)
513 AC_SUBST(COMPILER_TYPE)
514
515 AC_PROG_CPP
516 BASIC_FIXUP_EXECUTABLE(CPP)
517
518 AC_PROG_CXXCPP
519 BASIC_FIXUP_EXECUTABLE(CXXCPP)
520
521 if test "x$COMPILE_TYPE" != "xcross"; then
522 # If we are not cross compiling, use the same compilers for
523 # building the build platform executables. The cross-compilation
524 # case needed to be done earlier, but this can only be done after
525 # the native tools have been localized.
526 BUILD_CC="$CC"
527 BUILD_CXX="$CXX"
528 BUILD_LD="$LD"
529 fi
530
937 AC_ARG_WITH(extra-ldflags, [AS_HELP_STRING([--with-extra-ldflags],
938 [extra flags to be used when linking jdk])])
939
940 CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags"
941 CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags"
942 LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags"
943
944 # Hotspot needs these set in their legacy form
945 LEGACY_EXTRA_CFLAGS=$with_extra_cflags
946 LEGACY_EXTRA_CXXFLAGS=$with_extra_cxxflags
947 LEGACY_EXTRA_LDFLAGS=$with_extra_ldflags
948
949 AC_SUBST(LEGACY_EXTRA_CFLAGS)
950 AC_SUBST(LEGACY_EXTRA_CXXFLAGS)
951 AC_SUBST(LEGACY_EXTRA_LDFLAGS)
952
953 ###############################################################################
954 #
955 # Now setup the CFLAGS and LDFLAGS for the JDK build.
956 # Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build.
957 #
958 case $COMPILER_NAME in
959 gcc )
960 CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -W -Wall -Wno-unused -Wno-parentheses \
961 -pipe \
962 -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
963 case $OPENJDK_TARGET_CPU_ARCH in
964 arm )
965 # on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing
966 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
967 ;;
968 ppc )
969 # on ppc we don't prevent gcc to omit frame pointer nor strict-aliasing
970 ;;
971 * )
972 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -fno-omit-frame-pointer"
973 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
974 ;;
975 esac
976 ;;
977 ossc )
978 CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
979 case $OPENJDK_TARGET_CPU_ARCH in
980 x86 )
981 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
982 CFLAGS_JDK="$CFLAGS_JDK -erroff=E_BAD_PRAGMA_PACK_VALUE"
983 ;;
984 esac
985
986 CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
987 CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
988
989 LDFLAGS_JDK="$LDFLAGS_JDK -z defs -xildoff -ztext"
990 LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK -norunpath -xnolib"
991 ;;
992 xlc )
993 CFLAGS_JDK="$CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
994 CXXFLAGS_JDK="$CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
995
996 LDFLAGS_JDK="$LDFLAGS_JDK"
997 LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK"
998 ;;
999 cl )
1000 CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \
1001 -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \
1002 -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
1003 -DWIN32 -DIAL"
1004 case $OPENJDK_TARGET_CPU in
1005 x86 )
1006 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_X86_ -Dx86"
1007 ;;
1008 x86_64 )
1009 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_AMD64_ -Damd64"
1010 ;;
1011 esac
1012 ;;
1013 esac
1014
1015 ###############################################################################
1016
1017 # Adjust flags according to debug level.
1018 case $DEBUG_LEVEL in
1019 fastdebug )
1020 CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS"
1021 CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS"
1022 C_O_FLAG_HI="$C_O_FLAG_NORM"
1023 C_O_FLAG_NORM="$C_O_FLAG_NORM"
1024 CXX_O_FLAG_HI="$CXX_O_FLAG_NORM"
1025 CXX_O_FLAG_NORM="$CXX_O_FLAG_NORM"
1026 JAVAC_FLAGS="$JAVAC_FLAGS -g"
1027 ;;
1028 slowdebug )
1029 CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS"
1030 CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS"
1031 C_O_FLAG_HI="$C_O_FLAG_NONE"
1032 C_O_FLAG_NORM="$C_O_FLAG_NONE"
1033 CXX_O_FLAG_HI="$CXX_O_FLAG_NONE"
1034 CXX_O_FLAG_NORM="$CXX_O_FLAG_NONE"
1035 JAVAC_FLAGS="$JAVAC_FLAGS -g"
1036 ;;
1037 esac
1038
1039 CCXXFLAGS_JDK="$CCXXFLAGS_JDK $ADD_LP64"
1040
1041 # The package path is used only on macosx?
1042 PACKAGE_PATH=/opt/local
1043 AC_SUBST(PACKAGE_PATH)
1044
1045 if test "x$OPENJDK_TARGET_CPU_ENDIAN" = xlittle; then
1046 # The macro _LITTLE_ENDIAN needs to be defined the same to avoid the
1047 # Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN
1048 # (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h).
1049 # Note: -Dmacro is the same as #define macro 1
1050 # -Dmacro= is the same as #define macro
1051 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
1052 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
1053 else
1054 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
1055 fi
1056 else
1057 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN"
1058 fi
1059 if test "x$OPENJDK_TARGET_OS" = xlinux; then
1060 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DLINUX"
1061 fi
1062 if test "x$OPENJDK_TARGET_OS" = xwindows; then
1063 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DWINDOWS"
1064 fi
1065 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
1066 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DSOLARIS"
1067 fi
1068 if test "x$OPENJDK_TARGET_OS" = xaix; then
1069 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DAIX -DPPC64"
1070 fi
1071 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
1072 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMACOSX -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
1073 # Setting these parameters makes it an error to link to macosx APIs that are
1074 # newer than the given OS version and makes the linked binaries compatible even
1075 # if built on a newer version of the OS.
1076 # The expected format is X.Y.Z
1077 MACOSX_VERSION_MIN=10.7.0
1078 AC_SUBST(MACOSX_VERSION_MIN)
1079 # The macro takes the version with no dots, ex: 1070
1080 # Let the flags variables get resolved in make for easier override on make
1081 # command line.
1082 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
1083 LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
1084 fi
1085 if test "x$OPENJDK_TARGET_OS" = xbsd; then
1086 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DBSD -D_ALLBSD_SOURCE"
1087 fi
1088 if test "x$DEBUG_LEVEL" = xrelease; then
1089 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DNDEBUG"
1090 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
1091 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DTRIMMED"
1092 fi
1093 else
1094 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DDEBUG"
1095 fi
1096
1097 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DARCH='\"$OPENJDK_TARGET_CPU_LEGACY\"' -D$OPENJDK_TARGET_CPU_LEGACY"
1098 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DRELEASE='\"\$(RELEASE)\"'"
1099
1100 CCXXFLAGS_JDK="$CCXXFLAGS_JDK \
1101 -I${JDK_OUTPUTDIR}/include \
1102 -I${JDK_OUTPUTDIR}/include/$OPENJDK_TARGET_OS \
1103 -I${JDK_TOPDIR}/src/share/javavm/export \
1104 -I${JDK_TOPDIR}/src/$OPENJDK_TARGET_OS_EXPORT_DIR/javavm/export \
1105 -I${JDK_TOPDIR}/src/share/native/common \
1106 -I${JDK_TOPDIR}/src/$OPENJDK_TARGET_OS_API_DIR/native/common"
1107
1108 # The shared libraries are compiled using the picflag.
1109 CFLAGS_JDKLIB="$CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
1110 CXXFLAGS_JDKLIB="$CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA "
1111
1112 # Executable flags
1113 CFLAGS_JDKEXE="$CCXXFLAGS_JDK $CFLAGS_JDK"
1114 CXXFLAGS_JDKEXE="$CCXXFLAGS_JDK $CXXFLAGS_JDK"
1115
1116 # Now this is odd. The JDK native libraries have to link against libjvm.so
1117 # On 32-bit machines there is normally two distinct libjvm.so:s, client and server.
1118 # Which should we link to? Are we lucky enough that the binary api to the libjvm.so library
1119 # is identical for client and server? Yes. Which is picked at runtime (client or server)?
1120 # Neither, since the chosen libjvm.so has already been loaded by the launcher, all the following
1121 # libraries will link to whatever is in memory. Yuck.
1122 #
1123 # Thus we offer the compiler to find libjvm.so first in server then in client. It works. Ugh.
1124 if test "x$COMPILER_NAME" = xcl; then
1125 LDFLAGS_JDK="$LDFLAGS_JDK -nologo -opt:ref -incremental:no"
1126 if test "x$OPENJDK_TARGET_CPU" = xx86; then
1127 LDFLAGS_JDK="$LDFLAGS_JDK -safeseh"
1128 fi
1129 # TODO: make -debug optional "--disable-full-debug-symbols"
1130 LDFLAGS_JDK="$LDFLAGS_JDK -debug"
1131 LDFLAGS_JDKLIB="${LDFLAGS_JDK} -dll -libpath:${JDK_OUTPUTDIR}/lib"
1132 LDFLAGS_JDKLIB_SUFFIX=""
1133 if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
1134 LDFLAGS_STACK_SIZE=1048576
1179 LDFLAGS_JDKEXE="${LDFLAGS_JDK}"
1180 if test "x$OPENJDK_TARGET_OS" = xlinux; then
1181 LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -Xlinker --allow-shlib-undefined"
1182 fi
1183 fi
1184
1185 AC_SUBST(CFLAGS_JDKLIB)
1186 AC_SUBST(CFLAGS_JDKEXE)
1187
1188 AC_SUBST(CXXFLAGS_JDKLIB)
1189 AC_SUBST(CXXFLAGS_JDKEXE)
1190
1191 AC_SUBST(LDFLAGS_JDKLIB)
1192 AC_SUBST(LDFLAGS_JDKEXE)
1193 AC_SUBST(LDFLAGS_JDKLIB_SUFFIX)
1194 AC_SUBST(LDFLAGS_JDKEXE_SUFFIX)
1195 AC_SUBST(LDFLAGS_CXX_JDK)
1196 ])
1197
1198
1199 # TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
1200 # [RUN-IF-FALSE])
1201 # ------------------------------------------------------------
1202 # Check that the c and c++ compilers support an argument
1203 AC_DEFUN([TOOLCHAIN_COMPILER_CHECK_ARGUMENTS],
1204 [
1205 AC_MSG_CHECKING([if compiler supports "$1"])
1206 supports=yes
1207
1208 saved_cflags="$CFLAGS"
1209 CFLAGS="$CFLAGS $1"
1210 AC_LANG_PUSH([C])
1211 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [],
1212 [supports=no])
1213 AC_LANG_POP([C])
1214 CFLAGS="$saved_cflags"
1215
1216 saved_cxxflags="$CXXFLAGS"
1217 CXXFLAGS="$CXXFLAG $1"
1218 AC_LANG_PUSH([C++])
1219 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [],
1220 [supports=no])
1221 AC_LANG_POP([C++])
1222 CXXFLAGS="$saved_cxxflags"
1223
1224 AC_MSG_RESULT([$supports])
1225 if test "x$supports" = "xyes" ; then
1226 m4_ifval([$2], [$2], [:])
1227 else
1228 m4_ifval([$3], [$3], [:])
1229 fi
1230 ])
1231
1232 AC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_MISC],
1233 [
1234 # Some Zero and Shark settings.
1235 # ZERO_ARCHFLAG tells the compiler which mode to build for
1236 case "${OPENJDK_TARGET_CPU}" in
1237 s390)
1238 ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}31"
1239 ;;
1240 *)
1241 ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
1242 esac
1243 TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([$ZERO_ARCHFLAG], [], [ZERO_ARCHFLAG=""])
1244 AC_SUBST(ZERO_ARCHFLAG)
1245
1246 # Check that the compiler supports -mX (or -qX on AIX) flags
1247 # Set COMPILER_SUPPORTS_TARGET_BITS_FLAG to 'true' if it does
1248 TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}],
1249 [COMPILER_SUPPORTS_TARGET_BITS_FLAG=true],
1250 [COMPILER_SUPPORTS_TARGET_BITS_FLAG=false])
1251 AC_SUBST(COMPILER_SUPPORTS_TARGET_BITS_FLAG)
1293 # use JT_HOME enviroment var.
1294 BASIC_FIXUP_PATH([JT_HOME])
1295
1296 # jtreg win32 script works for everybody
1297 JTREGEXE="$JT_HOME/bin/jtreg"
1298
1299 if test ! -f "$JTREGEXE"; then
1300 AC_MSG_ERROR([JTReg executable does not exist: $JTREGEXE])
1301 fi
1302
1303 AC_MSG_RESULT($JTREGEXE)
1304 else
1305 # try to find jtreg on path
1306 BASIC_REQUIRE_PROG(JTREGEXE, jtreg)
1307 JT_HOME="`$DIRNAME $JTREGEXE`"
1308 fi
1309 fi
1310
1311 AC_SUBST(JT_HOME)
1312 AC_SUBST(JTREGEXE)
1313 ])
|
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 # Prepare the system so that TOOLCHAIN_CHECK_COMPILER_VERSION can be called.
27 # Must have CC_VERSION_NUMBER and CXX_VERSION_NUMBER.
28 AC_DEFUN([TOOLCHAIN_PREPARE_FOR_VERSION_COMPARISONS],
29 [
30 if test "x$CC_VERSION" != "x$CXX_VERSION"; then
31 AC_MSG_WARN([C and C++ compiler has different version numbers, $CC_VERSION vs $CXX_VERSION.])
32 AC_MSG_WARN([This typically indicates a broken setup, and is not supported])
33 fi
34
35 # We only check CC_VERSION since we assume CXX_VERSION is equal.
36 if [ [[ "$CC_VERSION" =~ (.*\.){3} ]] ]; then
37 AC_MSG_WARN([C compiler version number has more than three parts (X.Y.Z): $CC_VERSION. Comparisons might be wrong.])
38 fi
39
40 if [ [[ "$CC_VERSION" =~ [0-9]{6} ]] ]; then
41 AC_MSG_WARN([C compiler version number has a part larger than 99999: $CC_VERSION. Comparisons might be wrong.])
42 fi
43
44 COMPARABLE_ACTUAL_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", [$]1, [$]2, [$]3) }' <<< "$CC_VERSION"`
45 ])
46
47 # Check if the configured compiler (C and C++) is of a specific version or
48 # newer. TOOLCHAIN_PREPARE_FOR_VERSION_COMPARISONS must have been called before.
49 #
50 # Arguments:
51 # $1: The version string to check against the found version
52 # $2: block to run if the compiler is at least this version (>=)
53 # $3: block to run if the compiler is older than this version (<)
54 AC_DEFUN([TOOLCHAIN_CHECK_COMPILER_VERSION],
55 [
56 REFERENCE_VERSION=$1
57
58 if [ [[ "$REFERENCE_VERSION" =~ (.*\.){3} ]] ]; then
59 AC_MSG_ERROR([Internal error: Cannot compare to $REFERENCE_VERSION, only three parts (X.Y.Z) is supported])
60 fi
61
62 if [ [[ "$REFERENCE_VERSION" =~ [0-9]{6} ]] ]; then
63 AC_MSG_ERROR([Internal error: Cannot compare to $REFERENCE_VERSION, only parts < 99999 is supported])
64 fi
65
66 # Version comparison method inspired by http://stackoverflow.com/a/24067243
67 COMPARABLE_REFERENCE_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", [$]1, [$]2, [$]3) }' <<< "$REFERENCE_VERSION"`
68
69 if test $COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
70 m4_ifval([$2], [$2], [:])
71 else
72 m4_ifval([$3], [$3], [:])
73 fi
74 ])
75
76 # $1 = compiler to test (CC or CXX)
77 # $2 = human readable name of compiler (C or C++)
78 AC_DEFUN([TOOLCHAIN_EXTRACT_COMPILER_VERSION],
79 [
80 COMPILER=[$]$1
81 COMPILER_NAME=$2
82
83 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
84 # Make sure we use the Sun Studio compiler and not gcc on Solaris, which won't work
85 COMPILER_VERSION_TEST=`$COMPILER -V 2>&1 | $HEAD -n 1`
86 $ECHO $COMPILER_VERSION_TEST | $GREP "^.*: Sun $COMPILER_NAME" > /dev/null
87 if test $? -ne 0; then
88 GCC_VERSION_TEST=`$COMPILER --version 2>&1 | $HEAD -n 1`
89
90 AC_MSG_NOTICE([The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required Sun Studio compiler.])
91 AC_MSG_NOTICE([The result from running with -V was: "$COMPILER_VERSION_TEST" and with --version: "$GCC_VERSION_TEST"])
92 AC_MSG_ERROR([Sun Studio compiler is required. Try setting --with-tools-dir.])
93 else
94 COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.*@<:@ ,\t@:>@$COMPILER_NAME@<:@ ,\t@:>@\(@<:@1-9@:>@\.@<:@0-9@:>@@<:@0-9@:>@*\).*/\1/p"`
95 COMPILER_VENDOR="Sun Studio"
96 fi
97 elif test "x$OPENJDK_TARGET_OS" = xaix; then
98 COMPILER_VERSION_TEST=`$COMPILER -qversion 2>&1 | $TAIL -n 1`
114 if test "x$COMPILER_CPU_TEST" != "x80x86"; then
115 AC_MSG_ERROR([Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for "$COMPILER_CPU_TEST"; expected "80x86".])
116 fi
117 elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then
118 if test "x$COMPILER_CPU_TEST" != "xx64"; then
119 AC_MSG_ERROR([Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for "$COMPILER_CPU_TEST"; expected "x64".])
120 fi
121 fi
122 else
123 COMPILER_VERSION_TEST=`$COMPILER --version 2>&1 | $HEAD -n 1`
124 # Check that this is likely to be GCC.
125 $COMPILER --version 2>&1 | $GREP "Free Software Foundation" > /dev/null
126 if test $? -ne 0; then
127 AC_MSG_NOTICE([The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required GCC compiler.])
128 AC_MSG_NOTICE([The result from running with --version was: "$COMPILER_VERSION_TEST"])
129 AC_MSG_ERROR([GCC compiler is required. Try setting --with-tools-dir.])
130 fi
131
132 # First line typically looks something like:
133 # gcc (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2
134 COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | \
135 $SED -e 's/^.* \(@<:@1-9@:>@\.@<:@0-9.@:>@*\)@<:@^0-9.@:>@.*$/\1/'`
136 COMPILER_VENDOR=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^\(.*\) @<:@1-9@:>@@<:@0-9.@:>@*/\1/p"`
137 fi
138 # This sets CC_VERSION or CXX_VERSION. (This comment is a grep marker)
139 $1_VERSION="$COMPILER_VERSION"
140 # This sets CC_VENDOR or CXX_VENDOR. (This comment is a grep marker)
141 $1_VENDOR="$COMPILER_VENDOR"
142
143 AC_MSG_NOTICE([Using $COMPILER_VENDOR $COMPILER_NAME compiler version $COMPILER_VERSION (located at $COMPILER)])
144 ])
145
146
147 AC_DEFUN_ONCE([TOOLCHAIN_SETUP_SYSROOT_AND_OUT_OPTIONS],
148 [
149 ###############################################################################
150 #
151 # Configure the development tool paths and potential sysroot.
152 #
153 AC_LANG(C++)
154
155 # The option used to specify the target .o,.a or .so file.
215 # searching again.
216
217 # Remove the path to the fake ccache cc from the PATH
218 RETRY_COMPILER_SAVED_PATH="$PATH"
219 COMPILER_DIRNAME=`$DIRNAME [$]$1`
220 PATH="`$ECHO $PATH | $SED -e "s,$COMPILER_DIRNAME,,g" -e "s,::,:,g" -e "s,^:,,g"`"
221
222 # Try again looking for our compiler
223 AC_CHECK_TOOLS(PROPER_COMPILER_$1, $3)
224 BASIC_FIXUP_EXECUTABLE(PROPER_COMPILER_$1)
225 PATH="$RETRY_COMPILER_SAVED_PATH"
226
227 AC_MSG_CHECKING([for resolved symbolic links for $1])
228 BASIC_REMOVE_SYMBOLIC_LINKS(PROPER_COMPILER_$1)
229 AC_MSG_RESULT([$PROPER_COMPILER_$1])
230 $1="$PROPER_COMPILER_$1"
231 else
232 AC_MSG_RESULT([no, keeping $1])
233 $1="$TEST_COMPILER"
234 fi
235 TOOLCHAIN_EXTRACT_COMPILER_VERSION([$1], [$COMPILER_NAME])
236 ])
237
238
239 AC_DEFUN([TOOLCHAIN_SETUP_PATHS],
240 [
241 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
242 TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV
243 TOOLCHAIN_SETUP_MSVCR_DLL
244 BASIC_DEPRECATED_ARG_WITH([dxsdk])
245 BASIC_DEPRECATED_ARG_WITH([dxsdk-lib])
246 BASIC_DEPRECATED_ARG_WITH([dxsdk-include])
247 fi
248
249 AC_SUBST(MSVCR_DLL)
250
251 # If --build AND --host is set, then the configure script will find any
252 # cross compilation tools in the PATH. Cross compilation tools
253 # follows the cross compilation standard where they are prefixed with ${host}.
254 # For example the binary i686-sun-solaris2.10-gcc
255 # will cross compile for i686-sun-solaris2.10
419
420 ### Locate C++ compiler (CXX)
421
422 if test "x$CXX" != x; then
423 COMPILER_CHECK_LIST="$CXX"
424 elif test "x$OPENJDK_TARGET_OS" = "xwindows"; then
425 COMPILER_CHECK_LIST="cl"
426 elif test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
427 COMPILER_CHECK_LIST="CC g++"
428 elif test "x$OPENJDK_TARGET_OS" = "xaix"; then
429 # Do not probe for CC on AIX .
430 COMPILER_CHECK_LIST="xlC_r"
431 else
432 COMPILER_CHECK_LIST="g++ CC"
433 fi
434
435 TOOLCHAIN_FIND_COMPILER([CXX],[C++],[$COMPILER_CHECK_LIST])
436 # Now that we have resolved CXX ourself, let autoconf have its go at it
437 AC_PROG_CXX([$CXX])
438
439 # This is the compiler version number on the form X.Y[.Z]
440 AC_SUBST(CC_VERSION)
441 AC_SUBST(CXX_VERSION)
442
443 TOOLCHAIN_PREPARE_FOR_VERSION_COMPARISONS
444
445 ### Locate other tools
446
447 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
448 AC_PROG_OBJC
449 BASIC_FIXUP_EXECUTABLE(OBJC)
450 else
451 OBJC=
452 fi
453
454 # Restore the flags to the user specified values.
455 # This is necessary since AC_PROG_CC defaults CFLAGS to "-g -O2"
456 CFLAGS="$ORG_CFLAGS"
457 CXXFLAGS="$ORG_CXXFLAGS"
458 OBJCFLAGS="$ORG_OBJCFLAGS"
459
460 LD="$CC"
461 LDEXE="$CC"
462 LDCXX="$CXX"
463 LDEXECXX="$CXX"
464 AC_SUBST(LD)
547 # are evaluated by make.
548 RC_FLAGS="$RC_FLAGS \
549 -d \"JDK_BUILD_ID=\$(FULL_VERSION)\" \
550 -d \"JDK_COMPANY=\$(COMPANY_NAME)\" \
551 -d \"JDK_COMPONENT=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) binary\" \
552 -d \"JDK_VER=\$(JDK_MINOR_VERSION).\$(JDK_MICRO_VERSION).\$(COOKED_JDK_UPDATE_VERSION).\$(COOKED_BUILD_NUMBER)\" \
553 -d \"JDK_COPYRIGHT=Copyright \xA9 $COPYRIGHT_YEAR\" \
554 -d \"JDK_NAME=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) \$(JDK_MINOR_VERSION) \$(JDK_UPDATE_META_TAG)\" \
555 -d \"JDK_FVER=\$(JDK_MINOR_VERSION),\$(JDK_MICRO_VERSION),\$(COOKED_JDK_UPDATE_VERSION),\$(COOKED_BUILD_NUMBER)\""
556
557 # lib.exe is used to create static libraries.
558 AC_CHECK_PROG([WINAR], [lib],[lib],,,)
559 BASIC_FIXUP_EXECUTABLE(WINAR)
560 AR="$WINAR"
561 ARFLAGS="-nologo -NODEFAULTLIB:MSVCRT"
562
563 AC_CHECK_PROG([DUMPBIN], [dumpbin], [dumpbin],,,)
564 BASIC_FIXUP_EXECUTABLE(DUMPBIN)
565
566 COMPILER_TYPE=CL
567 # silence copyright notice and other headers.
568 COMMON_CCXXFLAGS="$COMMON_CCXXFLAGS -nologo"
569 ])
570 AC_SUBST(RC_FLAGS)
571 AC_SUBST(COMPILER_TYPE)
572
573 AC_PROG_CPP
574 BASIC_FIXUP_EXECUTABLE(CPP)
575
576 AC_PROG_CXXCPP
577 BASIC_FIXUP_EXECUTABLE(CXXCPP)
578
579 if test "x$COMPILE_TYPE" != "xcross"; then
580 # If we are not cross compiling, use the same compilers for
581 # building the build platform executables. The cross-compilation
582 # case needed to be done earlier, but this can only be done after
583 # the native tools have been localized.
584 BUILD_CC="$CC"
585 BUILD_CXX="$CXX"
586 BUILD_LD="$LD"
587 fi
588
995 AC_ARG_WITH(extra-ldflags, [AS_HELP_STRING([--with-extra-ldflags],
996 [extra flags to be used when linking jdk])])
997
998 CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags"
999 CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags"
1000 LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags"
1001
1002 # Hotspot needs these set in their legacy form
1003 LEGACY_EXTRA_CFLAGS=$with_extra_cflags
1004 LEGACY_EXTRA_CXXFLAGS=$with_extra_cxxflags
1005 LEGACY_EXTRA_LDFLAGS=$with_extra_ldflags
1006
1007 AC_SUBST(LEGACY_EXTRA_CFLAGS)
1008 AC_SUBST(LEGACY_EXTRA_CXXFLAGS)
1009 AC_SUBST(LEGACY_EXTRA_LDFLAGS)
1010
1011 ###############################################################################
1012 #
1013 # Now setup the CFLAGS and LDFLAGS for the JDK build.
1014 # Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build.
1015 # CFLAGS_JDK - C Compiler flags
1016 # CXXFLAGS_JDK - C++ Compiler flags
1017 # COMMON_CCXXFLAGS_JDK - common to C and C++
1018 #
1019 case $COMPILER_NAME in
1020 gcc )
1021 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -W -Wall -Wno-unused -Wno-parentheses \
1022 -pipe \
1023 -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
1024 CXXSTD_CXXFLAG="-std=gnu++98"
1025 TOOLCHAIN_CXX_COMPILER_CHECK_ARGUMENTS([$CXXSTD_CXXFLAG $CFLAGS_WARNINGS_ARE_ERRORS],
1026 [], [CXXSTD_CXXFLAG=""])
1027 CXXFLAGS_JDK="${CXXFLAGS_JDK} ${CXXSTD_CXXFLAG}"
1028 AC_SUBST([CXXSTD_CXXFLAG])
1029 case $OPENJDK_TARGET_CPU_ARCH in
1030 arm )
1031 # on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing
1032 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
1033 ;;
1034 ppc )
1035 # on ppc we don't prevent gcc to omit frame pointer nor strict-aliasing
1036 ;;
1037 * )
1038 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
1039 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
1040 ;;
1041 esac
1042 TOOLCHAIN_CHECK_COMPILER_VERSION(6, TOOLCHAIN_SETUP_GCC6_COMPILER_FLAGS)
1043 ;;
1044 ossc )
1045 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
1046 case $OPENJDK_TARGET_CPU_ARCH in
1047 x86 )
1048 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
1049 CFLAGS_JDK="$CFLAGS_JDK -erroff=E_BAD_PRAGMA_PACK_VALUE"
1050 ;;
1051 esac
1052
1053 CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
1054 CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
1055
1056 LDFLAGS_JDK="$LDFLAGS_JDK -z defs -xildoff -ztext"
1057 LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK -norunpath -xnolib"
1058 ;;
1059 xlc )
1060 CFLAGS_JDK="$CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
1061 CXXFLAGS_JDK="$CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
1062
1063 LDFLAGS_JDK="$LDFLAGS_JDK"
1064 LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK"
1065 ;;
1066 cl )
1067 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \
1068 -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \
1069 -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
1070 -DWIN32 -DIAL"
1071 case $OPENJDK_TARGET_CPU in
1072 x86 )
1073 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_X86_ -Dx86"
1074 ;;
1075 x86_64 )
1076 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_AMD64_ -Damd64"
1077 ;;
1078 esac
1079 ;;
1080 esac
1081
1082 ###############################################################################
1083
1084 # Adjust flags according to debug level.
1085 case $DEBUG_LEVEL in
1086 fastdebug )
1087 CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS"
1088 CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS"
1089 C_O_FLAG_HI="$C_O_FLAG_NORM"
1090 C_O_FLAG_NORM="$C_O_FLAG_NORM"
1091 CXX_O_FLAG_HI="$CXX_O_FLAG_NORM"
1092 CXX_O_FLAG_NORM="$CXX_O_FLAG_NORM"
1093 JAVAC_FLAGS="$JAVAC_FLAGS -g"
1094 ;;
1095 slowdebug )
1096 CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS"
1097 CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS"
1098 C_O_FLAG_HI="$C_O_FLAG_NONE"
1099 C_O_FLAG_NORM="$C_O_FLAG_NONE"
1100 CXX_O_FLAG_HI="$CXX_O_FLAG_NONE"
1101 CXX_O_FLAG_NORM="$CXX_O_FLAG_NONE"
1102 JAVAC_FLAGS="$JAVAC_FLAGS -g"
1103 ;;
1104 esac
1105
1106 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK $ADD_LP64"
1107
1108 # The package path is used only on macosx?
1109 PACKAGE_PATH=/opt/local
1110 AC_SUBST(PACKAGE_PATH)
1111
1112 if test "x$OPENJDK_TARGET_CPU_ENDIAN" = xlittle; then
1113 # The macro _LITTLE_ENDIAN needs to be defined the same to avoid the
1114 # Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN
1115 # (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h).
1116 # Note: -Dmacro is the same as #define macro 1
1117 # -Dmacro= is the same as #define macro
1118 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
1119 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
1120 else
1121 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
1122 fi
1123 else
1124 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN"
1125 fi
1126 if test "x$OPENJDK_TARGET_OS" = xlinux; then
1127 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DLINUX"
1128 fi
1129 if test "x$OPENJDK_TARGET_OS" = xwindows; then
1130 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DWINDOWS"
1131 fi
1132 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
1133 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DSOLARIS"
1134 fi
1135 if test "x$OPENJDK_TARGET_OS" = xaix; then
1136 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DAIX -DPPC64"
1137 fi
1138 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
1139 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DMACOSX -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
1140 # Setting these parameters makes it an error to link to macosx APIs that are
1141 # newer than the given OS version and makes the linked binaries compatible even
1142 # if built on a newer version of the OS.
1143 # The expected format is X.Y.Z
1144 MACOSX_VERSION_MIN=10.7.0
1145 AC_SUBST(MACOSX_VERSION_MIN)
1146 # The macro takes the version with no dots, ex: 1070
1147 # Let the flags variables get resolved in make for easier override on make
1148 # command line.
1149 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
1150 LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
1151 fi
1152 if test "x$OPENJDK_TARGET_OS" = xbsd; then
1153 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DBSD -D_ALLBSD_SOURCE"
1154 fi
1155 if test "x$DEBUG_LEVEL" = xrelease; then
1156 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DNDEBUG"
1157 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
1158 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DTRIMMED"
1159 fi
1160 else
1161 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DDEBUG"
1162 fi
1163
1164 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DARCH='\"$OPENJDK_TARGET_CPU_LEGACY\"' -D$OPENJDK_TARGET_CPU_LEGACY"
1165 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DRELEASE='\"\$(RELEASE)\"'"
1166
1167 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK \
1168 -I${JDK_OUTPUTDIR}/include \
1169 -I${JDK_OUTPUTDIR}/include/$OPENJDK_TARGET_OS \
1170 -I${JDK_TOPDIR}/src/share/javavm/export \
1171 -I${JDK_TOPDIR}/src/$OPENJDK_TARGET_OS_EXPORT_DIR/javavm/export \
1172 -I${JDK_TOPDIR}/src/share/native/common \
1173 -I${JDK_TOPDIR}/src/$OPENJDK_TARGET_OS_API_DIR/native/common"
1174
1175 # The shared libraries are compiled using the picflag.
1176 CFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
1177 CXXFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA "
1178
1179 # Executable flags
1180 CFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK"
1181 CXXFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK"
1182
1183 # Now this is odd. The JDK native libraries have to link against libjvm.so
1184 # On 32-bit machines there is normally two distinct libjvm.so:s, client and server.
1185 # Which should we link to? Are we lucky enough that the binary api to the libjvm.so library
1186 # is identical for client and server? Yes. Which is picked at runtime (client or server)?
1187 # Neither, since the chosen libjvm.so has already been loaded by the launcher, all the following
1188 # libraries will link to whatever is in memory. Yuck.
1189 #
1190 # Thus we offer the compiler to find libjvm.so first in server then in client. It works. Ugh.
1191 if test "x$COMPILER_NAME" = xcl; then
1192 LDFLAGS_JDK="$LDFLAGS_JDK -nologo -opt:ref -incremental:no"
1193 if test "x$OPENJDK_TARGET_CPU" = xx86; then
1194 LDFLAGS_JDK="$LDFLAGS_JDK -safeseh"
1195 fi
1196 # TODO: make -debug optional "--disable-full-debug-symbols"
1197 LDFLAGS_JDK="$LDFLAGS_JDK -debug"
1198 LDFLAGS_JDKLIB="${LDFLAGS_JDK} -dll -libpath:${JDK_OUTPUTDIR}/lib"
1199 LDFLAGS_JDKLIB_SUFFIX=""
1200 if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
1201 LDFLAGS_STACK_SIZE=1048576
1246 LDFLAGS_JDKEXE="${LDFLAGS_JDK}"
1247 if test "x$OPENJDK_TARGET_OS" = xlinux; then
1248 LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -Xlinker --allow-shlib-undefined"
1249 fi
1250 fi
1251
1252 AC_SUBST(CFLAGS_JDKLIB)
1253 AC_SUBST(CFLAGS_JDKEXE)
1254
1255 AC_SUBST(CXXFLAGS_JDKLIB)
1256 AC_SUBST(CXXFLAGS_JDKEXE)
1257
1258 AC_SUBST(LDFLAGS_JDKLIB)
1259 AC_SUBST(LDFLAGS_JDKEXE)
1260 AC_SUBST(LDFLAGS_JDKLIB_SUFFIX)
1261 AC_SUBST(LDFLAGS_JDKEXE_SUFFIX)
1262 AC_SUBST(LDFLAGS_CXX_JDK)
1263 ])
1264
1265
1266 # TOOLCHAIN_C_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
1267 # [RUN-IF-FALSE])
1268 # ------------------------------------------------------------
1269 # Check that the C compiler supports an argument
1270 AC_DEFUN([TOOLCHAIN_C_COMPILER_CHECK_ARGUMENTS],
1271 [
1272 AC_MSG_CHECKING([if the C compiler supports "$1"])
1273 supports=yes
1274
1275 saved_cflags="$CFLAGS"
1276 CFLAGS="$CFLAGS $1"
1277 AC_LANG_PUSH([C])
1278 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [],
1279 [supports=no])
1280 AC_LANG_POP([C])
1281 CFLAGS="$saved_cflags"
1282
1283 AC_MSG_RESULT([$supports])
1284 if test "x$supports" = "xyes" ; then
1285 m4_ifval([$2], [$2], [:])
1286 else
1287 m4_ifval([$3], [$3], [:])
1288 fi
1289 ])
1290
1291 # TOOLCHAIN_CXX_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
1292 # [RUN-IF-FALSE])
1293 # ------------------------------------------------------------
1294 # Check that the C++ compiler supports an argument
1295 AC_DEFUN([TOOLCHAIN_CXX_COMPILER_CHECK_ARGUMENTS],
1296 [
1297 AC_MSG_CHECKING([if the C++ compiler supports "$1"])
1298 supports=yes
1299
1300 saved_cxxflags="$CXXFLAGS"
1301 CXXFLAGS="$CXXFLAG $1"
1302 AC_LANG_PUSH([C++])
1303 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [],
1304 [supports=no])
1305 AC_LANG_POP([C++])
1306 CXXFLAGS="$saved_cxxflags"
1307
1308 AC_MSG_RESULT([$supports])
1309 if test "x$supports" = "xyes" ; then
1310 m4_ifval([$2], [$2], [:])
1311 else
1312 m4_ifval([$3], [$3], [:])
1313 fi
1314 ])
1315
1316 # TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
1317 # [RUN-IF-FALSE])
1318 # ------------------------------------------------------------
1319 # Check that the C and C++ compilers support an argument
1320 AC_DEFUN([TOOLCHAIN_COMPILER_CHECK_ARGUMENTS],
1321 [
1322 TOOLCHAIN_C_COMPILER_CHECK_ARGUMENTS([$1],
1323 [C_COMP_SUPPORTS="yes"],
1324 [C_COMP_SUPPORTS="no"])
1325 TOOLCHAIN_CXX_COMPILER_CHECK_ARGUMENTS([$1],
1326 [CXX_COMP_SUPPORTS="yes"],
1327 [CXX_COMP_SUPPORTS="no"])
1328
1329 AC_MSG_CHECKING([if both compilers support "$1"])
1330 supports=no
1331 if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
1332
1333 AC_MSG_RESULT([$supports])
1334 if test "x$supports" = "xyes" ; then
1335 m4_ifval([$2], [$2], [:])
1336 else
1337 m4_ifval([$3], [$3], [:])
1338 fi
1339 ])
1340
1341 AC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_MISC],
1342 [
1343 # Some Zero and Shark settings.
1344 # ZERO_ARCHFLAG tells the compiler which mode to build for
1345 case "${OPENJDK_TARGET_CPU}" in
1346 s390)
1347 ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}31"
1348 ;;
1349 *)
1350 ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
1351 esac
1352 TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([$ZERO_ARCHFLAG], [], [ZERO_ARCHFLAG=""])
1353 AC_SUBST(ZERO_ARCHFLAG)
1354
1355 # Check that the compiler supports -mX (or -qX on AIX) flags
1356 # Set COMPILER_SUPPORTS_TARGET_BITS_FLAG to 'true' if it does
1357 TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}],
1358 [COMPILER_SUPPORTS_TARGET_BITS_FLAG=true],
1359 [COMPILER_SUPPORTS_TARGET_BITS_FLAG=false])
1360 AC_SUBST(COMPILER_SUPPORTS_TARGET_BITS_FLAG)
1402 # use JT_HOME enviroment var.
1403 BASIC_FIXUP_PATH([JT_HOME])
1404
1405 # jtreg win32 script works for everybody
1406 JTREGEXE="$JT_HOME/bin/jtreg"
1407
1408 if test ! -f "$JTREGEXE"; then
1409 AC_MSG_ERROR([JTReg executable does not exist: $JTREGEXE])
1410 fi
1411
1412 AC_MSG_RESULT($JTREGEXE)
1413 else
1414 # try to find jtreg on path
1415 BASIC_REQUIRE_PROG(JTREGEXE, jtreg)
1416 JT_HOME="`$DIRNAME $JTREGEXE`"
1417 fi
1418 fi
1419
1420 AC_SUBST(JT_HOME)
1421 AC_SUBST(JTREGEXE)
1422 ])
1423
1424 AC_DEFUN_ONCE([TOOLCHAIN_SETUP_GCC6_COMPILER_FLAGS],
1425 [
1426 # These flags are required for GCC 6 builds as undefined behaviour in OpenJDK code
1427 # runs afoul of the more aggressive versions of these optimisations.
1428 # Notably, value range propagation now assumes that the this pointer of C++
1429 # member functions is non-null.
1430 NO_DELETE_NULL_POINTER_CHECKS_CFLAG="-fno-delete-null-pointer-checks"
1431 TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror],
1432 [], [NO_DELETE_NULL_POINTER_CHECKS_CFLAG=""])
1433 AC_SUBST([NO_DELETE_NULL_POINTER_CHECKS_CFLAG])
1434 NO_LIFETIME_DSE_CFLAG="-fno-lifetime-dse"
1435 TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([$NO_LIFETIME_DSE_CFLAG -Werror],
1436 [], [NO_LIFETIME_DSE_CFLAG=""])
1437 CFLAGS_JDK="${CFLAGS_JDK} ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} ${NO_LIFETIME_DSE_CFLAG}"
1438 AC_SUBST([NO_LIFETIME_DSE_CFLAG])
1439 ])
|