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" = xwindows; then
48 # First line typically looks something like:
49 # Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.30319.01 for 80x86
50 COMPILER_VERSION_TEST=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
51 COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.*Version \(@<:@1-9@:>@@<:@0-9.@:>@*\) .*/\1/p"`
52 COMPILER_VENDOR="Microsoft CL.EXE"
53 COMPILER_CPU_TEST=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.* for \(.*\)$/\1/p"`
54 if test "x$OPENJDK_TARGET_CPU" = "xx86"; then
55 if test "x$COMPILER_CPU_TEST" != "x80x86"; then
56 AC_MSG_ERROR([Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for "$COMPILER_CPU_TEST"; expected "80x86".])
57 fi
58 elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then
59 if test "x$COMPILER_CPU_TEST" != "xx64"; then
60 AC_MSG_ERROR([Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for "$COMPILER_CPU_TEST"; expected "x64".])
61 fi
62 fi
63 else
64 COMPILER_VERSION_TEST=`$COMPILER --version 2>&1 | $HEAD -n 1`
65 # Check that this is likely to be GCC.
66 $COMPILER --version 2>&1 | $GREP "Free Software Foundation" > /dev/null
120 if test -n "$TOOLS_DIR"; then
121 PATH_save="$PATH"
122 PATH="$TOOLS_DIR"
123 AC_PATH_PROGS(TOOLS_DIR_$1, $3)
124 $1=$TOOLS_DIR_$1
125 PATH="$PATH_save"
126 fi
127
128 # AC_PATH_PROGS can't be run multiple times with the same variable,
129 # so create a new name for this run.
130 if test "x[$]$1" = x; then
131 AC_PATH_PROGS(POTENTIAL_$1, $3)
132 $1=$POTENTIAL_$1
133 fi
134
135 if test "x[$]$1" = x; then
136 HELP_MSG_MISSING_DEPENDENCY([devkit])
137 AC_MSG_ERROR([Could not find a $COMPILER_NAME compiler. $HELP_MSG])
138 fi
139 BASIC_FIXUP_EXECUTABLE($1)
140 AC_MSG_CHECKING([resolved symbolic links for $1])
141 TEST_COMPILER="[$]$1"
142 BASIC_REMOVE_SYMBOLIC_LINKS(TEST_COMPILER)
143 AC_MSG_RESULT([$TEST_COMPILER])
144 AC_MSG_CHECKING([if $1 is disguised ccache])
145
146 COMPILER_BASENAME=`$BASENAME "$TEST_COMPILER"`
147 if test "x$COMPILER_BASENAME" = "xccache"; then
148 AC_MSG_RESULT([yes, trying to find proper $COMPILER_NAME compiler])
149 # We /usr/lib/ccache in the path, so cc is a symlink to /usr/bin/ccache.
150 # We want to control ccache invocation ourselves, so ignore this cc and try
151 # searching again.
152
153 # Remove the path to the fake ccache cc from the PATH
154 RETRY_COMPILER_SAVED_PATH="$PATH"
155 COMPILER_DIRNAME=`$DIRNAME [$]$1`
156 PATH="`$ECHO $PATH | $SED -e "s,$COMPILER_DIRNAME,,g" -e "s,::,:,g" -e "s,^:,,g"`"
157
158 # Try again looking for our compiler
159 AC_CHECK_TOOLS(PROPER_COMPILER_$1, $3)
160 BASIC_FIXUP_EXECUTABLE(PROPER_COMPILER_$1)
161 PATH="$RETRY_COMPILER_SAVED_PATH"
162
163 AC_MSG_CHECKING([for resolved symbolic links for $1])
233
234 # autoconf magic only relies on PATH, so update it if tools dir is specified
235 OLD_PATH="$PATH"
236 if test "x$TOOLS_DIR" != x; then
237 PATH=$TOOLS_DIR:$PATH
238 fi
239
240
241 ### Locate C compiler (CC)
242
243 # On windows, only cl.exe is supported.
244 # On Solaris, cc is preferred to gcc.
245 # Elsewhere, gcc is preferred to cc.
246
247 if test "x$CC" != x; then
248 COMPILER_CHECK_LIST="$CC"
249 elif test "x$OPENJDK_TARGET_OS" = "xwindows"; then
250 COMPILER_CHECK_LIST="cl"
251 elif test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
252 COMPILER_CHECK_LIST="cc gcc"
253 else
254 COMPILER_CHECK_LIST="gcc cc"
255 fi
256
257 TOOLCHAIN_FIND_COMPILER([CC],[C],[$COMPILER_CHECK_LIST])
258 # Now that we have resolved CC ourself, let autoconf have its go at it
259 AC_PROG_CC([$CC])
260
261 ### Locate C++ compiler (CXX)
262
263 if test "x$CXX" != x; then
264 COMPILER_CHECK_LIST="$CXX"
265 elif test "x$OPENJDK_TARGET_OS" = "xwindows"; then
266 COMPILER_CHECK_LIST="cl"
267 elif test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
268 COMPILER_CHECK_LIST="CC g++"
269 else
270 COMPILER_CHECK_LIST="g++ CC"
271 fi
272
273 TOOLCHAIN_FIND_COMPILER([CXX],[C++],[$COMPILER_CHECK_LIST])
274 # Now that we have resolved CXX ourself, let autoconf have its go at it
275 AC_PROG_CXX([$CXX])
276
277 ### Locate other tools
278
279 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
280 AC_PROG_OBJC
281 BASIC_FIXUP_EXECUTABLE(OBJC)
282 else
283 OBJC=
284 fi
285
286 # Restore the flags to the user specified values.
287 # This is necessary since AC_PROG_CC defaults CFLAGS to "-g -O2"
288 CFLAGS="$ORG_CFLAGS"
290 OBJCFLAGS="$ORG_OBJCFLAGS"
291
292 LD="$CC"
293 LDEXE="$CC"
294 LDCXX="$CXX"
295 LDEXECXX="$CXX"
296 AC_SUBST(LD)
297 # LDEXE is the linker to use, when creating executables.
298 AC_SUBST(LDEXE)
299 # Linking C++ libraries.
300 AC_SUBST(LDCXX)
301 # Linking C++ executables.
302 AC_SUBST(LDEXECXX)
303
304 if test "x$OPENJDK_TARGET_OS" != xwindows; then
305 AC_CHECK_TOOL(AR, ar)
306 BASIC_FIXUP_EXECUTABLE(AR)
307 fi
308 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
309 ARFLAGS="-r"
310 else
311 ARFLAGS=""
312 fi
313 AC_SUBST(ARFLAGS)
314
315 # For hotspot, we need these in Windows mixed path; other platforms keep them the same
316 HOTSPOT_CXX="$CXX"
317 HOTSPOT_LD="$LD"
318 AC_SUBST(HOTSPOT_CXX)
319 AC_SUBST(HOTSPOT_LD)
320
321 COMPILER_NAME=gcc
322 COMPILER_TYPE=CC
323 AS_IF([test "x$OPENJDK_TARGET_OS" = xwindows], [
324 # For now, assume that we are always compiling using cl.exe.
325 CC_OUT_OPTION=-Fo
326 EXE_OUT_OPTION=-out:
327 LD_OUT_OPTION=-out:
328 AR_OUT_OPTION=-out:
329 # On Windows, reject /usr/bin/link (as determined in CYGWIN_LINK), which is a cygwin
533 LIBRARY_PREFIX=lib
534 SHARED_LIBRARY='lib[$]1.so'
535 STATIC_LIBRARY='lib[$]1.a'
536 SHARED_LIBRARY_FLAGS="-G"
537 SHARED_LIBRARY_SUFFIX='.so'
538 STATIC_LIBRARY_SUFFIX='.a'
539 OBJ_SUFFIX='.o'
540 EXE_SUFFIX=''
541 SET_SHARED_LIBRARY_NAME=''
542 SET_SHARED_LIBRARY_MAPFILE='-M[$]1'
543 C_FLAG_REORDER='-xF'
544 CXX_FLAG_REORDER='-xF'
545 SET_SHARED_LIBRARY_ORIGIN='-R\$$$$ORIGIN[$]1'
546 SET_EXECUTABLE_ORIGIN="$SET_SHARED_LIBRARY_ORIGIN"
547 CFLAGS_JDK="${CFLAGS_JDK} -D__solaris__"
548 CXXFLAGS_JDK="${CXXFLAGS_JDK} -D__solaris__"
549 CFLAGS_JDKLIB_EXTRA='-xstrconst'
550 POST_STRIP_CMD="$STRIP -x"
551 POST_MCS_CMD="$MCS -d -a \"JDK $FULL_VERSION\""
552 fi
553 if test "x$OPENJDK_TARGET_OS" = xwindows; then
554 # If it is not gcc, then assume it is the MS Visual Studio compiler
555 COMPILER_NAME=cl
556 PICFLAG=""
557 LIBRARY_PREFIX=
558 SHARED_LIBRARY='[$]1.dll'
559 STATIC_LIBRARY='[$]1.lib'
560 SHARED_LIBRARY_FLAGS="-LD"
561 SHARED_LIBRARY_SUFFIX='.dll'
562 STATIC_LIBRARY_SUFFIX='.lib'
563 OBJ_SUFFIX='.obj'
564 EXE_SUFFIX='.exe'
565 SET_SHARED_LIBRARY_NAME=''
566 SET_SHARED_LIBRARY_MAPFILE=''
567 SET_SHARED_LIBRARY_ORIGIN=''
568 SET_EXECUTABLE_ORIGIN=''
569 fi
570 fi
571
572 AC_SUBST(COMPILER_NAME)
708 C_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST -xchip=pentium"
709 CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HIGHEST -xchip=pentium"
710 fi
711 ;;
712 sparc)
713 CFLAGS_JDKLIB_EXTRA="${CFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
714 CXXFLAGS_JDKLIB_EXTRA="${CXXFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
715 C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra"
716 C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0"
717 C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0"
718 C_O_FLAG_NONE=""
719 CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra"
720 CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
721 CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
722 CXX_O_FLAG_NONE=""
723 ;;
724 esac
725
726 CFLAGS_DEBUG_SYMBOLS="-g -xs"
727 CXXFLAGS_DEBUG_SYMBOLS="-g0 -xs"
728 esac
729 ;;
730 CL )
731 C_O_FLAG_HIGHEST="-O2"
732 C_O_FLAG_HI="-O1"
733 C_O_FLAG_NORM="-O1"
734 C_O_FLAG_NONE="-Od"
735 CXX_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST"
736 CXX_O_FLAG_HI="$C_O_FLAG_HI"
737 CXX_O_FLAG_NORM="$C_O_FLAG_NORM"
738 CXX_O_FLAG_NONE="$C_O_FLAG_NONE"
739 ;;
740 esac
741
742 if test -z "$C_O_FLAG_HIGHEST"; then
743 C_O_FLAG_HIGHEST="$C_O_FLAG_HI"
744 fi
745
746 if test -z "$CXX_O_FLAG_HIGHEST"; then
747 CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HI"
818 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -fno-omit-frame-pointer"
819 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
820 ;;
821 esac
822 ;;
823 ossc )
824 CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
825 case $OPENJDK_TARGET_CPU_ARCH in
826 x86 )
827 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
828 CFLAGS_JDK="$CFLAGS_JDK -erroff=E_BAD_PRAGMA_PACK_VALUE"
829 ;;
830 esac
831
832 CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
833 CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
834
835 LDFLAGS_JDK="$LDFLAGS_JDK -z defs -xildoff -ztext"
836 LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK -norunpath -xnolib"
837 ;;
838 cl )
839 CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \
840 -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \
841 -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
842 -DWIN32 -DIAL"
843 case $OPENJDK_TARGET_CPU in
844 x86 )
845 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_X86_ -Dx86"
846 ;;
847 x86_64 )
848 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_AMD64_ -Damd64"
849 ;;
850 esac
851 ;;
852 esac
853
854 ###############################################################################
855
856 # Adjust flags according to debug level.
857 case $DEBUG_LEVEL in
887 # (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h).
888 # Note: -Dmacro is the same as #define macro 1
889 # -Dmacro= is the same as #define macro
890 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
891 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
892 else
893 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
894 fi
895 else
896 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN"
897 fi
898 if test "x$OPENJDK_TARGET_OS" = xlinux; then
899 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DLINUX"
900 fi
901 if test "x$OPENJDK_TARGET_OS" = xwindows; then
902 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DWINDOWS"
903 fi
904 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
905 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DSOLARIS"
906 fi
907 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
908 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMACOSX -D_ALLBSD_SOURCE"
909 # Setting these parameters makes it an error to link to macosx APIs that are
910 # newer than the given OS version and makes the linked binaries compatible even
911 # if built on a newer version of the OS.
912 # The expected format is X.Y.Z
913 MACOSX_VERSION_MIN=10.7.0
914 AC_SUBST(MACOSX_VERSION_MIN)
915 # The macro takes the version with no dots, ex: 1070
916 # Let the flags variables get resolved in make for easier override on make
917 # command line.
918 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
919 LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
920 fi
921 if test "x$OPENJDK_TARGET_OS" = xbsd; then
922 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DBSD -D_ALLBSD_SOURCE"
923 fi
924 if test "x$DEBUG_LEVEL" = xrelease; then
925 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DNDEBUG"
926 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
1056 AC_COMPILE_IFELSE([
1057 AC_LANG_SOURCE([[int i;]])
1058 ], [], [supports=no])
1059 AC_LANG_POP([C++])
1060 CXXFLAGS="$saved_cxxflags"
1061
1062 AC_MSG_RESULT([$supports])
1063 if test "x$supports" = "xyes" ; then
1064 m4_ifval([$2], [$2], [:])
1065 else
1066 m4_ifval([$3], [$3], [:])
1067 fi
1068 ])
1069
1070 AC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_MISC],
1071 [
1072 # Some Zero and Shark settings.
1073 # ZERO_ARCHFLAG tells the compiler which mode to build for
1074 case "${OPENJDK_TARGET_CPU}" in
1075 s390)
1076 ZERO_ARCHFLAG="-m31"
1077 ;;
1078 *)
1079 ZERO_ARCHFLAG="-m${OPENJDK_TARGET_CPU_BITS}"
1080 esac
1081 TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([$ZERO_ARCHFLAG], [], [ZERO_ARCHFLAG=""])
1082 AC_SUBST(ZERO_ARCHFLAG)
1083
1084 # Check that the compiler supports -mX flags
1085 # Set COMPILER_SUPPORTS_TARGET_BITS_FLAG to 'true' if it does
1086 TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([-m${OPENJDK_TARGET_CPU_BITS}],
1087 [COMPILER_SUPPORTS_TARGET_BITS_FLAG=true],
1088 [COMPILER_SUPPORTS_TARGET_BITS_FLAG=false])
1089 AC_SUBST(COMPILER_SUPPORTS_TARGET_BITS_FLAG)
1090
1091
1092 # Check for broken SuSE 'ld' for which 'Only anonymous version tag is allowed in executable.'
1093 USING_BROKEN_SUSE_LD=no
1094 if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$GCC" = xyes; then
1095 AC_MSG_CHECKING([for broken SuSE 'ld' which only understands anonymous version tags in executables])
1096 echo "SUNWprivate_1.1 { local: *; };" > version-script.map
1097 echo "int main() { }" > main.c
1098 if $CXX -Xlinker -version-script=version-script.map main.c 2>&AS_MESSAGE_LOG_FD >&AS_MESSAGE_LOG_FD; then
1099 AC_MSG_RESULT(no)
1100 USING_BROKEN_SUSE_LD=no
1101 else
1102 AC_MSG_RESULT(yes)
1103 USING_BROKEN_SUSE_LD=yes
1104 fi
1105 rm -rf version-script.map main.c
1106 fi
|
27 # $2 = human readable name of compiler (C or C++)
28 AC_DEFUN([TOOLCHAIN_CHECK_COMPILER_VERSION],
29 [
30 COMPILER=[$]$1
31 COMPILER_NAME=$2
32
33 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
34 # Make sure we use the Sun Studio compiler and not gcc on Solaris, which won't work
35 COMPILER_VERSION_TEST=`$COMPILER -V 2>&1 | $HEAD -n 1`
36 $ECHO $COMPILER_VERSION_TEST | $GREP "^.*: Sun $COMPILER_NAME" > /dev/null
37 if test $? -ne 0; then
38 GCC_VERSION_TEST=`$COMPILER --version 2>&1 | $HEAD -n 1`
39
40 AC_MSG_NOTICE([The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required Sun Studio compiler.])
41 AC_MSG_NOTICE([The result from running with -V was: "$COMPILER_VERSION_TEST" and with --version: "$GCC_VERSION_TEST"])
42 AC_MSG_ERROR([Sun Studio compiler is required. Try setting --with-tools-dir.])
43 else
44 COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.*@<:@ ,\t@:>@$COMPILER_NAME@<:@ ,\t@:>@\(@<:@1-9@:>@\.@<:@0-9@:>@@<:@0-9@:>@*\).*/\1/p"`
45 COMPILER_VENDOR="Sun Studio"
46 fi
47 elif test "x$OPENJDK_TARGET_OS" = xaix; then
48 COMPILER_VERSION_TEST=`$COMPILER -qversion 2>&1 | $TAIL -n 1`
49 $ECHO $COMPILER_VERSION_TEST | $GREP "^Version: " > /dev/null
50 if test $? -ne 0; then
51 AC_MSG_ERROR([Failed to detect the compiler version of $COMPILER ....])
52 else
53 COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n 's/Version: \([0-9][0-9]\.[0-9][0-9]*\).*/\1/p'`
54 COMPILER_VENDOR='IBM'
55 fi
56 elif test "x$OPENJDK_TARGET_OS" = xwindows; then
57 # First line typically looks something like:
58 # Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.30319.01 for 80x86
59 COMPILER_VERSION_TEST=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
60 COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.*Version \(@<:@1-9@:>@@<:@0-9.@:>@*\) .*/\1/p"`
61 COMPILER_VENDOR="Microsoft CL.EXE"
62 COMPILER_CPU_TEST=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.* for \(.*\)$/\1/p"`
63 if test "x$OPENJDK_TARGET_CPU" = "xx86"; then
64 if test "x$COMPILER_CPU_TEST" != "x80x86"; then
65 AC_MSG_ERROR([Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for "$COMPILER_CPU_TEST"; expected "80x86".])
66 fi
67 elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then
68 if test "x$COMPILER_CPU_TEST" != "xx64"; then
69 AC_MSG_ERROR([Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for "$COMPILER_CPU_TEST"; expected "x64".])
70 fi
71 fi
72 else
73 COMPILER_VERSION_TEST=`$COMPILER --version 2>&1 | $HEAD -n 1`
74 # Check that this is likely to be GCC.
75 $COMPILER --version 2>&1 | $GREP "Free Software Foundation" > /dev/null
129 if test -n "$TOOLS_DIR"; then
130 PATH_save="$PATH"
131 PATH="$TOOLS_DIR"
132 AC_PATH_PROGS(TOOLS_DIR_$1, $3)
133 $1=$TOOLS_DIR_$1
134 PATH="$PATH_save"
135 fi
136
137 # AC_PATH_PROGS can't be run multiple times with the same variable,
138 # so create a new name for this run.
139 if test "x[$]$1" = x; then
140 AC_PATH_PROGS(POTENTIAL_$1, $3)
141 $1=$POTENTIAL_$1
142 fi
143
144 if test "x[$]$1" = x; then
145 HELP_MSG_MISSING_DEPENDENCY([devkit])
146 AC_MSG_ERROR([Could not find a $COMPILER_NAME compiler. $HELP_MSG])
147 fi
148 BASIC_FIXUP_EXECUTABLE($1)
149 TEST_COMPILER="[$]$1"
150 # Don't remove symbolic links on AIX because 'xlc_r' and 'xlC_r' may all be links
151 # to 'xlc' but it is crucial that we invoke the compiler with the right name!
152 if test "x$OPENJDK_BUILD_OS" != xaix; then
153 AC_MSG_CHECKING([resolved symbolic links for $1])
154 BASIC_REMOVE_SYMBOLIC_LINKS(TEST_COMPILER)
155 AC_MSG_RESULT([$TEST_COMPILER])
156 fi
157 AC_MSG_CHECKING([if $1 is disguised ccache])
158
159 COMPILER_BASENAME=`$BASENAME "$TEST_COMPILER"`
160 if test "x$COMPILER_BASENAME" = "xccache"; then
161 AC_MSG_RESULT([yes, trying to find proper $COMPILER_NAME compiler])
162 # We /usr/lib/ccache in the path, so cc is a symlink to /usr/bin/ccache.
163 # We want to control ccache invocation ourselves, so ignore this cc and try
164 # searching again.
165
166 # Remove the path to the fake ccache cc from the PATH
167 RETRY_COMPILER_SAVED_PATH="$PATH"
168 COMPILER_DIRNAME=`$DIRNAME [$]$1`
169 PATH="`$ECHO $PATH | $SED -e "s,$COMPILER_DIRNAME,,g" -e "s,::,:,g" -e "s,^:,,g"`"
170
171 # Try again looking for our compiler
172 AC_CHECK_TOOLS(PROPER_COMPILER_$1, $3)
173 BASIC_FIXUP_EXECUTABLE(PROPER_COMPILER_$1)
174 PATH="$RETRY_COMPILER_SAVED_PATH"
175
176 AC_MSG_CHECKING([for resolved symbolic links for $1])
246
247 # autoconf magic only relies on PATH, so update it if tools dir is specified
248 OLD_PATH="$PATH"
249 if test "x$TOOLS_DIR" != x; then
250 PATH=$TOOLS_DIR:$PATH
251 fi
252
253
254 ### Locate C compiler (CC)
255
256 # On windows, only cl.exe is supported.
257 # On Solaris, cc is preferred to gcc.
258 # Elsewhere, gcc is preferred to cc.
259
260 if test "x$CC" != x; then
261 COMPILER_CHECK_LIST="$CC"
262 elif test "x$OPENJDK_TARGET_OS" = "xwindows"; then
263 COMPILER_CHECK_LIST="cl"
264 elif test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
265 COMPILER_CHECK_LIST="cc gcc"
266 elif test "x$OPENJDK_TARGET_OS" = "xaix"; then
267 # Do not probe for cc on AIX.
268 COMPILER_CHECK_LIST="xlc_r"
269 else
270 COMPILER_CHECK_LIST="gcc cc"
271 fi
272
273 TOOLCHAIN_FIND_COMPILER([CC],[C],[$COMPILER_CHECK_LIST])
274 # Now that we have resolved CC ourself, let autoconf have its go at it
275 AC_PROG_CC([$CC])
276
277 # Option used to tell the compiler whether to create 32- or 64-bit executables
278 # Notice that CC contains the full compiler path at this point.
279 case $CC in
280 *xlc_r) COMPILER_TARGET_BITS_FLAG="-q";;
281 *) COMPILER_TARGET_BITS_FLAG="-m";;
282 esac
283 AC_SUBST(COMPILER_TARGET_BITS_FLAG)
284
285 ### Locate C++ compiler (CXX)
286
287 if test "x$CXX" != x; then
288 COMPILER_CHECK_LIST="$CXX"
289 elif test "x$OPENJDK_TARGET_OS" = "xwindows"; then
290 COMPILER_CHECK_LIST="cl"
291 elif test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
292 COMPILER_CHECK_LIST="CC g++"
293 elif test "x$OPENJDK_TARGET_OS" = "xaix"; then
294 # Do not probe for CC on AIX .
295 COMPILER_CHECK_LIST="xlC_r"
296 else
297 COMPILER_CHECK_LIST="g++ CC"
298 fi
299
300 TOOLCHAIN_FIND_COMPILER([CXX],[C++],[$COMPILER_CHECK_LIST])
301 # Now that we have resolved CXX ourself, let autoconf have its go at it
302 AC_PROG_CXX([$CXX])
303
304 ### Locate other tools
305
306 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
307 AC_PROG_OBJC
308 BASIC_FIXUP_EXECUTABLE(OBJC)
309 else
310 OBJC=
311 fi
312
313 # Restore the flags to the user specified values.
314 # This is necessary since AC_PROG_CC defaults CFLAGS to "-g -O2"
315 CFLAGS="$ORG_CFLAGS"
317 OBJCFLAGS="$ORG_OBJCFLAGS"
318
319 LD="$CC"
320 LDEXE="$CC"
321 LDCXX="$CXX"
322 LDEXECXX="$CXX"
323 AC_SUBST(LD)
324 # LDEXE is the linker to use, when creating executables.
325 AC_SUBST(LDEXE)
326 # Linking C++ libraries.
327 AC_SUBST(LDCXX)
328 # Linking C++ executables.
329 AC_SUBST(LDEXECXX)
330
331 if test "x$OPENJDK_TARGET_OS" != xwindows; then
332 AC_CHECK_TOOL(AR, ar)
333 BASIC_FIXUP_EXECUTABLE(AR)
334 fi
335 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
336 ARFLAGS="-r"
337 elif test "x$OPENJDK_TARGET_OS" = xaix; then
338 ARFLAGS="-X64"
339 else
340 ARFLAGS=""
341 fi
342 AC_SUBST(ARFLAGS)
343
344 # For hotspot, we need these in Windows mixed path; other platforms keep them the same
345 HOTSPOT_CXX="$CXX"
346 HOTSPOT_LD="$LD"
347 AC_SUBST(HOTSPOT_CXX)
348 AC_SUBST(HOTSPOT_LD)
349
350 COMPILER_NAME=gcc
351 COMPILER_TYPE=CC
352 AS_IF([test "x$OPENJDK_TARGET_OS" = xwindows], [
353 # For now, assume that we are always compiling using cl.exe.
354 CC_OUT_OPTION=-Fo
355 EXE_OUT_OPTION=-out:
356 LD_OUT_OPTION=-out:
357 AR_OUT_OPTION=-out:
358 # On Windows, reject /usr/bin/link (as determined in CYGWIN_LINK), which is a cygwin
562 LIBRARY_PREFIX=lib
563 SHARED_LIBRARY='lib[$]1.so'
564 STATIC_LIBRARY='lib[$]1.a'
565 SHARED_LIBRARY_FLAGS="-G"
566 SHARED_LIBRARY_SUFFIX='.so'
567 STATIC_LIBRARY_SUFFIX='.a'
568 OBJ_SUFFIX='.o'
569 EXE_SUFFIX=''
570 SET_SHARED_LIBRARY_NAME=''
571 SET_SHARED_LIBRARY_MAPFILE='-M[$]1'
572 C_FLAG_REORDER='-xF'
573 CXX_FLAG_REORDER='-xF'
574 SET_SHARED_LIBRARY_ORIGIN='-R\$$$$ORIGIN[$]1'
575 SET_EXECUTABLE_ORIGIN="$SET_SHARED_LIBRARY_ORIGIN"
576 CFLAGS_JDK="${CFLAGS_JDK} -D__solaris__"
577 CXXFLAGS_JDK="${CXXFLAGS_JDK} -D__solaris__"
578 CFLAGS_JDKLIB_EXTRA='-xstrconst'
579 POST_STRIP_CMD="$STRIP -x"
580 POST_MCS_CMD="$MCS -d -a \"JDK $FULL_VERSION\""
581 fi
582 if test "x$OPENJDK_TARGET_OS" = xaix; then
583 COMPILER_NAME=xlc
584 PICFLAG="-qpic=large"
585 LIBRARY_PREFIX=lib
586 SHARED_LIBRARY='lib[$]1.so'
587 STATIC_LIBRARY='lib[$]1.a'
588 SHARED_LIBRARY_FLAGS="-qmkshrobj"
589 SHARED_LIBRARY_SUFFIX='.so'
590 STATIC_LIBRARY_SUFFIX='.a'
591 OBJ_SUFFIX='.o'
592 EXE_SUFFIX=''
593 SET_SHARED_LIBRARY_NAME=''
594 SET_SHARED_LIBRARY_MAPFILE=''
595 C_FLAG_REORDER=''
596 CXX_FLAG_REORDER=''
597 SET_SHARED_LIBRARY_ORIGIN=''
598 SET_EXECUTABLE_ORIGIN=""
599 CFLAGS_JDK=""
600 CXXFLAGS_JDK=""
601 CFLAGS_JDKLIB_EXTRA=''
602 POST_STRIP_CMD="$STRIP -X32_64"
603 POST_MCS_CMD=""
604 fi
605 if test "x$OPENJDK_TARGET_OS" = xwindows; then
606 # If it is not gcc, then assume it is the MS Visual Studio compiler
607 COMPILER_NAME=cl
608 PICFLAG=""
609 LIBRARY_PREFIX=
610 SHARED_LIBRARY='[$]1.dll'
611 STATIC_LIBRARY='[$]1.lib'
612 SHARED_LIBRARY_FLAGS="-LD"
613 SHARED_LIBRARY_SUFFIX='.dll'
614 STATIC_LIBRARY_SUFFIX='.lib'
615 OBJ_SUFFIX='.obj'
616 EXE_SUFFIX='.exe'
617 SET_SHARED_LIBRARY_NAME=''
618 SET_SHARED_LIBRARY_MAPFILE=''
619 SET_SHARED_LIBRARY_ORIGIN=''
620 SET_EXECUTABLE_ORIGIN=''
621 fi
622 fi
623
624 AC_SUBST(COMPILER_NAME)
760 C_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST -xchip=pentium"
761 CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HIGHEST -xchip=pentium"
762 fi
763 ;;
764 sparc)
765 CFLAGS_JDKLIB_EXTRA="${CFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
766 CXXFLAGS_JDKLIB_EXTRA="${CXXFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
767 C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra"
768 C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0"
769 C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0"
770 C_O_FLAG_NONE=""
771 CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra"
772 CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
773 CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
774 CXX_O_FLAG_NONE=""
775 ;;
776 esac
777
778 CFLAGS_DEBUG_SYMBOLS="-g -xs"
779 CXXFLAGS_DEBUG_SYMBOLS="-g0 -xs"
780 ;;
781 xlc )
782 C_FLAG_DEPS="-qmakedep=gcc -MF"
783 CXX_FLAG_DEPS="-qmakedep=gcc -MF"
784 C_O_FLAG_HIGHEST="-O3"
785 C_O_FLAG_HI="-O3 -qstrict"
786 C_O_FLAG_NORM="-O2"
787 C_O_FLAG_NONE=""
788 CXX_O_FLAG_HIGHEST="-O3"
789 CXX_O_FLAG_HI="-O3 -qstrict"
790 CXX_O_FLAG_NORM="-O2"
791 CXX_O_FLAG_NONE=""
792 CFLAGS_DEBUG_SYMBOLS="-g"
793 CXXFLAGS_DEBUG_SYMBOLS="-g"
794 LDFLAGS_JDK="${LDFLAGS_JDK} -q64 -brtl -bnolibpath -liconv -bexpall"
795 CFLAGS_JDK="${CFLAGS_JDK} -qchars=signed -q64 -qfullpath -qsaveopt"
796 CXXFLAGS_JDK="${CXXFLAGS_JDK} -qchars=signed -q64 -qfullpath -qsaveopt"
797 ;;
798 esac
799 ;;
800 CL )
801 C_O_FLAG_HIGHEST="-O2"
802 C_O_FLAG_HI="-O1"
803 C_O_FLAG_NORM="-O1"
804 C_O_FLAG_NONE="-Od"
805 CXX_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST"
806 CXX_O_FLAG_HI="$C_O_FLAG_HI"
807 CXX_O_FLAG_NORM="$C_O_FLAG_NORM"
808 CXX_O_FLAG_NONE="$C_O_FLAG_NONE"
809 ;;
810 esac
811
812 if test -z "$C_O_FLAG_HIGHEST"; then
813 C_O_FLAG_HIGHEST="$C_O_FLAG_HI"
814 fi
815
816 if test -z "$CXX_O_FLAG_HIGHEST"; then
817 CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HI"
888 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -fno-omit-frame-pointer"
889 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
890 ;;
891 esac
892 ;;
893 ossc )
894 CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
895 case $OPENJDK_TARGET_CPU_ARCH in
896 x86 )
897 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
898 CFLAGS_JDK="$CFLAGS_JDK -erroff=E_BAD_PRAGMA_PACK_VALUE"
899 ;;
900 esac
901
902 CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
903 CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
904
905 LDFLAGS_JDK="$LDFLAGS_JDK -z defs -xildoff -ztext"
906 LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK -norunpath -xnolib"
907 ;;
908 xlc )
909 CFLAGS_JDK="$CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
910 CXXFLAGS_JDK="$CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
911
912 LDFLAGS_JDK="$LDFLAGS_JDK"
913 LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK"
914 ;;
915 cl )
916 CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \
917 -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \
918 -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
919 -DWIN32 -DIAL"
920 case $OPENJDK_TARGET_CPU in
921 x86 )
922 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_X86_ -Dx86"
923 ;;
924 x86_64 )
925 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_AMD64_ -Damd64"
926 ;;
927 esac
928 ;;
929 esac
930
931 ###############################################################################
932
933 # Adjust flags according to debug level.
934 case $DEBUG_LEVEL in
964 # (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h).
965 # Note: -Dmacro is the same as #define macro 1
966 # -Dmacro= is the same as #define macro
967 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
968 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
969 else
970 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
971 fi
972 else
973 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN"
974 fi
975 if test "x$OPENJDK_TARGET_OS" = xlinux; then
976 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DLINUX"
977 fi
978 if test "x$OPENJDK_TARGET_OS" = xwindows; then
979 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DWINDOWS"
980 fi
981 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
982 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DSOLARIS"
983 fi
984 if test "x$OPENJDK_TARGET_OS" = xaix; then
985 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DAIX -DPPC64"
986 fi
987 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
988 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMACOSX -D_ALLBSD_SOURCE"
989 # Setting these parameters makes it an error to link to macosx APIs that are
990 # newer than the given OS version and makes the linked binaries compatible even
991 # if built on a newer version of the OS.
992 # The expected format is X.Y.Z
993 MACOSX_VERSION_MIN=10.7.0
994 AC_SUBST(MACOSX_VERSION_MIN)
995 # The macro takes the version with no dots, ex: 1070
996 # Let the flags variables get resolved in make for easier override on make
997 # command line.
998 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
999 LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
1000 fi
1001 if test "x$OPENJDK_TARGET_OS" = xbsd; then
1002 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DBSD -D_ALLBSD_SOURCE"
1003 fi
1004 if test "x$DEBUG_LEVEL" = xrelease; then
1005 CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DNDEBUG"
1006 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
1136 AC_COMPILE_IFELSE([
1137 AC_LANG_SOURCE([[int i;]])
1138 ], [], [supports=no])
1139 AC_LANG_POP([C++])
1140 CXXFLAGS="$saved_cxxflags"
1141
1142 AC_MSG_RESULT([$supports])
1143 if test "x$supports" = "xyes" ; then
1144 m4_ifval([$2], [$2], [:])
1145 else
1146 m4_ifval([$3], [$3], [:])
1147 fi
1148 ])
1149
1150 AC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_MISC],
1151 [
1152 # Some Zero and Shark settings.
1153 # ZERO_ARCHFLAG tells the compiler which mode to build for
1154 case "${OPENJDK_TARGET_CPU}" in
1155 s390)
1156 ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}31"
1157 ;;
1158 *)
1159 ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
1160 esac
1161 TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([$ZERO_ARCHFLAG], [], [ZERO_ARCHFLAG=""])
1162 AC_SUBST(ZERO_ARCHFLAG)
1163
1164 # Check that the compiler supports -mX (or -qX on AIX) flags
1165 # Set COMPILER_SUPPORTS_TARGET_BITS_FLAG to 'true' if it does
1166 TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}],
1167 [COMPILER_SUPPORTS_TARGET_BITS_FLAG=true],
1168 [COMPILER_SUPPORTS_TARGET_BITS_FLAG=false])
1169 AC_SUBST(COMPILER_SUPPORTS_TARGET_BITS_FLAG)
1170
1171
1172 # Check for broken SuSE 'ld' for which 'Only anonymous version tag is allowed in executable.'
1173 USING_BROKEN_SUSE_LD=no
1174 if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$GCC" = xyes; then
1175 AC_MSG_CHECKING([for broken SuSE 'ld' which only understands anonymous version tags in executables])
1176 echo "SUNWprivate_1.1 { local: *; };" > version-script.map
1177 echo "int main() { }" > main.c
1178 if $CXX -Xlinker -version-script=version-script.map main.c 2>&AS_MESSAGE_LOG_FD >&AS_MESSAGE_LOG_FD; then
1179 AC_MSG_RESULT(no)
1180 USING_BROKEN_SUSE_LD=no
1181 else
1182 AC_MSG_RESULT(yes)
1183 USING_BROKEN_SUSE_LD=yes
1184 fi
1185 rm -rf version-script.map main.c
1186 fi
|