628 #endif"
629
630 ac_subst_vars='LTLIBOBJS
631 LIBOBJS
632 CCACHE
633 USE_PRECOMPILED_HEADER
634 SJAVAC_SERVER_DIR
635 ENABLE_SJAVAC
636 SJAVAC_SERVER_JAVA_FLAGS
637 SJAVAC_SERVER_JAVA
638 JAVA_TOOL_FLAGS_SMALL
639 JAVA_FLAGS_SMALL
640 JAVA_FLAGS_BIG
641 JAVA_FLAGS
642 JOBS
643 MEMORY_SIZE
644 NUM_CORES
645 ENABLE_INTREE_EC
646 SALIB_NAME
647 HOTSPOT_MAKE_ARGS
648 MSVCR_DLL
649 LIBCXX
650 LLVM_LIBS
651 LLVM_LDFLAGS
652 LLVM_CFLAGS
653 LLVM_CONFIG
654 LIBFFI_LIBS
655 LIBFFI_CFLAGS
656 STATIC_CXX_SETTING
657 LIBDL
658 LIBM
659 LIBZIP_CAN_USE_MMAP
660 USE_EXTERNAL_LIBZ
661 USE_EXTERNAL_LIBPNG
662 PNG_LIBS
663 PNG_CFLAGS
664 USE_EXTERNAL_LCMS
665 LCMS_LIBS
666 LCMS_CFLAGS
667 USE_EXTERNAL_LIBGIF
1059 enable_unlimited_crypto
1060 enable_rmiconnector_iiop
1061 with_milestone
1062 with_update_version
1063 with_user_release_suffix
1064 with_build_number
1065 with_copyright_year
1066 with_boot_jdk
1067 with_add_source_root
1068 with_override_source_root
1069 with_adds_and_overrides
1070 with_override_langtools
1071 with_override_corba
1072 with_override_jaxp
1073 with_override_jaxws
1074 with_override_hotspot
1075 with_override_nashorn
1076 with_override_jdk
1077 with_import_hotspot
1078 with_toolchain_type
1079 with_jtreg
1080 with_extra_cflags
1081 with_extra_cxxflags
1082 with_extra_ldflags
1083 enable_debug_symbols
1084 enable_zip_debug_info
1085 with_x
1086 with_cups
1087 with_cups_include
1088 with_freetype
1089 with_freetype_include
1090 with_freetype_lib
1091 with_freetype_src
1092 enable_freetype_bundling
1093 with_alsa
1094 with_alsa_include
1095 with_alsa_lib
1096 with_libjpeg
1097 with_giflib
1098 with_lcms
1099 with_libpng
1100 with_zlib
1101 with_stdc__lib
1102 with_msvcr_dll
1103 with_dxsdk
1104 with_dxsdk_lib
1105 with_dxsdk_include
1106 with_num_cores
1107 with_memory_size
1108 with_jobs
1109 with_boot_jdk_jvmargs
1110 with_sjavac_server_java
1111 enable_sjavac
1112 enable_precompiled_headers
1113 enable_ccache
1114 with_ccache_dir
1115 '
1116 ac_precious_vars='build_alias
1117 host_alias
1118 target_alias
1119 BASENAME
1120 BASH
1121 CAT
1122 CHMOD
1914 override source root for the same directory; if it
1915 exists, use that directory instead and ignore the
1916 directory in the original source root
1917 --with-adds-and-overrides
1918 use the subdirs 'adds' and 'overrides' in the
1919 specified directory as add-source-root and
1920 override-source-root
1921 --with-override-langtools
1922 use this langtools dir for the build
1923 --with-override-corba use this corba dir for the build
1924 --with-override-jaxp use this jaxp dir for the build
1925 --with-override-jaxws use this jaxws dir for the build
1926 --with-override-hotspot use this hotspot dir for the build
1927 --with-override-nashorn use this nashorn dir for the build
1928 --with-override-jdk use this jdk dir for the build
1929 --with-import-hotspot import hotspot binaries from this jdk image or
1930 hotspot build dist dir instead of building from
1931 source
1932 --with-toolchain-type the toolchain type (or family) to use, use '--help'
1933 to show possible values [platform dependent]
1934 --with-jtreg Regression Test Harness [probed]
1935 --with-extra-cflags extra flags to be used when compiling jdk c-files
1936 --with-extra-cxxflags extra flags to be used when compiling jdk c++-files
1937 --with-extra-ldflags extra flags to be used when linking jdk
1938 --with-x use the X Window System
1939 --with-cups specify prefix directory for the cups package
1940 (expecting the headers under PATH/include)
1941 --with-cups-include specify directory for the cups include files
1942 --with-freetype specify prefix directory for the freetype package
1943 (expecting the libraries under PATH/lib and the
1944 headers under PATH/include)
1945 --with-freetype-include specify directory for the freetype include files
1946 --with-freetype-lib specify directory for the freetype library
1947 --with-freetype-src specify directory with freetype sources to
1948 automatically build the library (experimental,
1949 Windows-only)
1950 --with-alsa specify prefix directory for the alsa package
1951 (expecting the libraries under PATH/lib and the
1952 headers under PATH/include)
1953 --with-alsa-include specify directory for the alsa include files
1954 --with-alsa-lib specify directory for the alsa library
1955 --with-libjpeg use libjpeg from build system or OpenJDK source
1956 (system, bundled) [bundled]
1957 --with-giflib use giflib from build system or OpenJDK source
1958 (system, bundled) [bundled]
1959 --with-lcms use lcms2 from build system or OpenJDK source
1960 (system, bundled) [bundled]
1961 --with-libpng use libpng from build system or OpenJDK source
1962 (system, bundled) [bundled]
1963 --with-zlib use zlib from build system or OpenJDK source
1964 (system, bundled) [bundled]
1965 --with-stdc++lib=<static>,<dynamic>,<default>
1966 force linking of the C++ runtime on Linux to either
1967 static or dynamic, default is static with dynamic as
1968 fallback
1969 --with-msvcr-dll copy this msvcr100.dll into the built JDK (Windows
1970 only) [probed]
1971 --with-dxsdk Deprecated. Option is kept for backwards
1972 compatibility and is ignored
1973 --with-dxsdk-lib Deprecated. Option is kept for backwards
1974 compatibility and is ignored
1975 --with-dxsdk-include Deprecated. Option is kept for backwards
1976 compatibility and is ignored
1977 --with-num-cores number of cores in the build system, e.g.
1978 --with-num-cores=8 [probed]
1979 --with-memory-size memory (in MB) available in the build system, e.g.
1980 --with-memory-size=1024 [probed]
1981 --with-jobs number of parallel jobs to let make run [calculated
1982 based on cores and memory]
1983 --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
1984 invocations of boot JDK, overriding the default
1985 values, e.g --with-boot-jdk-jvmargs="-Xmx8G
1986 -enableassertions"
1987 --with-sjavac-server-java
1988 use this java binary for running the sjavac
1989 background server [Boot JDK java]
1990 --with-ccache-dir where to store ccache files [~/.ccache]
4286 # under the terms of the GNU General Public License version 2 only, as
4287 # published by the Free Software Foundation. Oracle designates this
4288 # particular file as subject to the "Classpath" exception as provided
4289 # by Oracle in the LICENSE file that accompanied this code.
4290 #
4291 # This code is distributed in the hope that it will be useful, but WITHOUT
4292 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4293 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4294 # version 2 for more details (a copy is included in the LICENSE file that
4295 # accompanied this code).
4296 #
4297 # You should have received a copy of the GNU General Public License version
4298 # 2 along with this work; if not, write to the Free Software Foundation,
4299 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4300 #
4301 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4302 # or visit www.oracle.com if you need additional information or have any
4303 # questions.
4304 #
4305
4306
4307
4308
4309
4310
4311
4312 # Check if the VS env variables were setup prior to running configure.
4313 # If not, then find vcvarsall.bat and run it automatically, and integrate
4314 # the set env variables into the spec file.
4315
4316
4317
4318
4319
4320
4321
4322
4323
4324
4325
4326 # This line needs to be here, verbatim, after all includes and the dummy hook
4327 # definitions. It is replaced with custom functionality when building
4328 # custom sources.
4329 #CUSTOM_AUTOCONF_INCLUDE
4330
4331 # Do not change or remove the following line, it is needed for consistency checks:
4332 DATE_WHEN_GENERATED=1420811523
4333
4334 ###############################################################################
4335 #
4336 # Initialization / Boot-strapping
4337 #
4338 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4339 # thus it jumps back and forth, each time gaining something needed later on.
4340 #
4341 ###############################################################################
4342
4343 # If we are requested to print additional help, do that and then exit.
4344 # This must be the very first call.
4345
4346 if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4347 $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4348 $PRINTF "Which are valid to use depends on the build platform.\n"
4349 for toolchain in $VALID_TOOLCHAINS_all; do
4350 # Use indirect variable referencing
4351 toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4352 TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
26648 fi
26649
26650
26651 if test "x$CYGWIN_LINK" != x; then
26652 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the first found link.exe is actually the Cygwin link tool" >&5
26653 $as_echo_n "checking if the first found link.exe is actually the Cygwin link tool... " >&6; }
26654 "$CYGWIN_LINK" --version > /dev/null
26655 if test $? -eq 0 ; then
26656 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
26657 $as_echo "yes" >&6; }
26658 else
26659 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
26660 $as_echo "no" >&6; }
26661 # This might be the VS linker. Don't exclude it later on.
26662 CYGWIN_LINK=""
26663 fi
26664 fi
26665
26666 # First-hand choice is to locate and run the vsvars bat file.
26667
26668 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
26669 VCVARSFILE="vc/bin/vcvars32.bat"
26670 else
26671 VCVARSFILE="vc/bin/amd64/vcvars64.bat"
26672 fi
26673
26674 VS_ENV_CMD=""
26675 VS_ENV_ARGS=""
26676 if test "x$with_toolsdir" != x; then
26677
26678 if test "x$VS_ENV_CMD" = x; then
26679 VS100BASE="$with_toolsdir/../.."
26680 METHOD="--with-tools-dir"
26681
26682 windows_path="$VS100BASE"
26683 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26684 unix_path=`$CYGPATH -u "$windows_path"`
26685 VS100BASE="$unix_path"
26686 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26687 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26688 VS100BASE="$unix_path"
26689 fi
26690
26691 if test -d "$VS100BASE"; then
26692 if test -f "$VS100BASE/$VCVARSFILE"; then
26693 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS100BASE using $METHOD" >&5
26694 $as_echo "$as_me: Found Visual Studio installation at $VS100BASE using $METHOD" >&6;}
26695 VS_ENV_CMD="$VS100BASE/$VCVARSFILE"
26696 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
26697 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
26698 # TODO: improve detection for other versions of VS
26699 PLATFORM_TOOLSET="v100"
26700 else
26701 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS100BASE using $METHOD" >&5
26702 $as_echo "$as_me: Found Visual Studio installation at $VS100BASE using $METHOD" >&6;}
26703 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
26704 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
26705 fi
26706 fi
26707 fi
26708
26709 fi
26710
26711 if test "x$with_toolsdir" != x && test "x$VS_ENV_CMD" = x; then
26712 # Having specified an argument which is incorrect will produce an instant failure;
26713 # we should not go on looking
26714 { $as_echo "$as_me:${as_lineno-$LINENO}: The path given by --with-tools-dir does not contain a valid Visual Studio installation" >&5
26715 $as_echo "$as_me: The path given by --with-tools-dir does not contain a valid Visual Studio installation" >&6;}
26716 { $as_echo "$as_me:${as_lineno-$LINENO}: Please point to the VC/bin directory within the Visual Studio installation" >&5
26717 $as_echo "$as_me: Please point to the VC/bin directory within the Visual Studio installation" >&6;}
26718 as_fn_error $? "Cannot locate a valid Visual Studio installation" "$LINENO" 5
26719 fi
26720
26721 if test "x$VS100COMNTOOLS" != x; then
26722
26723 if test "x$VS_ENV_CMD" = x; then
26724 VS100BASE="$VS100COMNTOOLS/../.."
26725 METHOD="VS100COMNTOOLS variable"
26726
26727 windows_path="$VS100BASE"
26728 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26729 unix_path=`$CYGPATH -u "$windows_path"`
26730 VS100BASE="$unix_path"
26731 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26732 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26733 VS100BASE="$unix_path"
26734 fi
26735
26736 if test -d "$VS100BASE"; then
26737 if test -f "$VS100BASE/$VCVARSFILE"; then
26738 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS100BASE using $METHOD" >&5
26739 $as_echo "$as_me: Found Visual Studio installation at $VS100BASE using $METHOD" >&6;}
26740 VS_ENV_CMD="$VS100BASE/$VCVARSFILE"
26741 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
26742 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
26743 # TODO: improve detection for other versions of VS
26744 PLATFORM_TOOLSET="v100"
26745 else
26746 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS100BASE using $METHOD" >&5
26747 $as_echo "$as_me: Found Visual Studio installation at $VS100BASE using $METHOD" >&6;}
26748 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
26749 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
26750 fi
26751 fi
26752 fi
26753
26754 fi
26755 if test "x$PROGRAMFILES" != x; then
26756
26757 if test "x$VS_ENV_CMD" = x; then
26758 VS100BASE="$PROGRAMFILES/Microsoft Visual Studio 10.0"
26759 METHOD="well-known name"
26760
26761 windows_path="$VS100BASE"
26762 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26763 unix_path=`$CYGPATH -u "$windows_path"`
26764 VS100BASE="$unix_path"
26765 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26766 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26767 VS100BASE="$unix_path"
26768 fi
26769
26770 if test -d "$VS100BASE"; then
26771 if test -f "$VS100BASE/$VCVARSFILE"; then
26772 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS100BASE using $METHOD" >&5
26773 $as_echo "$as_me: Found Visual Studio installation at $VS100BASE using $METHOD" >&6;}
26774 VS_ENV_CMD="$VS100BASE/$VCVARSFILE"
26775 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
26776 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
26777 # TODO: improve detection for other versions of VS
26778 PLATFORM_TOOLSET="v100"
26779 else
26780 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS100BASE using $METHOD" >&5
26781 $as_echo "$as_me: Found Visual Studio installation at $VS100BASE using $METHOD" >&6;}
26782 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
26783 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
26784 fi
26785 fi
26786 fi
26787
26788 fi
26789
26790 if test "x$VS_ENV_CMD" = x; then
26791 VS100BASE="C:/Program Files/Microsoft Visual Studio 10.0"
26792 METHOD="well-known name"
26793
26794 windows_path="$VS100BASE"
26795 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26796 unix_path=`$CYGPATH -u "$windows_path"`
26797 VS100BASE="$unix_path"
26798 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26799 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26800 VS100BASE="$unix_path"
26801 fi
26802
26803 if test -d "$VS100BASE"; then
26804 if test -f "$VS100BASE/$VCVARSFILE"; then
26805 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS100BASE using $METHOD" >&5
26806 $as_echo "$as_me: Found Visual Studio installation at $VS100BASE using $METHOD" >&6;}
26807 VS_ENV_CMD="$VS100BASE/$VCVARSFILE"
26808 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
26809 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
26810 # TODO: improve detection for other versions of VS
26811 PLATFORM_TOOLSET="v100"
26812 else
26813 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS100BASE using $METHOD" >&5
26814 $as_echo "$as_me: Found Visual Studio installation at $VS100BASE using $METHOD" >&6;}
26815 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
26816 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
26817 fi
26818 fi
26819 fi
26820
26821
26822 if test "x$VS_ENV_CMD" = x; then
26823 VS100BASE="C:/Program Files (x86)/Microsoft Visual Studio 10.0"
26824 METHOD="well-known name"
26825
26826 windows_path="$VS100BASE"
26827 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26828 unix_path=`$CYGPATH -u "$windows_path"`
26829 VS100BASE="$unix_path"
26830 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26831 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26832 VS100BASE="$unix_path"
26833 fi
26834
26835 if test -d "$VS100BASE"; then
26836 if test -f "$VS100BASE/$VCVARSFILE"; then
26837 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS100BASE using $METHOD" >&5
26838 $as_echo "$as_me: Found Visual Studio installation at $VS100BASE using $METHOD" >&6;}
26839 VS_ENV_CMD="$VS100BASE/$VCVARSFILE"
26840 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
26841 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
26842 # TODO: improve detection for other versions of VS
26843 PLATFORM_TOOLSET="v100"
26844 else
26845 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS100BASE using $METHOD" >&5
26846 $as_echo "$as_me: Found Visual Studio installation at $VS100BASE using $METHOD" >&6;}
26847 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
26848 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
26849 fi
26850 fi
26851 fi
26852
26853
26854 if test "x$ProgramW6432" != x; then
26855
26856 if test "x$VS_ENV_CMD" = x; then
26857 WIN_SDK_BASE="$ProgramW6432/Microsoft SDKs/Windows/v7.1/Bin"
26858 METHOD="well-known name"
26859
26860 windows_path="$WIN_SDK_BASE"
26861 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26862 unix_path=`$CYGPATH -u "$windows_path"`
26863 WIN_SDK_BASE="$unix_path"
26864 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26865 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26866 WIN_SDK_BASE="$unix_path"
26867 fi
26868
26869 if test -d "$WIN_SDK_BASE"; then
26870 # There have been cases of partial or broken SDK installations. A missing
26871 # lib dir is not going to work.
26872 if test ! -d "$WIN_SDK_BASE/../lib"; then
26873 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
26874 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
26875 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
26876 $as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
26877 elif test -f "$WIN_SDK_BASE/SetEnv.Cmd"; then
26878 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
26879 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
26880 VS_ENV_CMD="$WIN_SDK_BASE/SetEnv.Cmd"
26881 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
26882 VS_ENV_ARGS="/x86"
26883 else
26884 VS_ENV_ARGS="/x64"
26885 fi
26886 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
26887 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
26888 # TODO: improve detection for other versions of SDK
26889 PLATFORM_TOOLSET="Windows7.1SDK"
26890 else
26891 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
26892 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
26893 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
26894 $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
26895 fi
26896 fi
26897 fi
26898
26899 fi
26900 if test "x$PROGRAMW6432" != x; then
26901
26902 if test "x$VS_ENV_CMD" = x; then
26903 WIN_SDK_BASE="$PROGRAMW6432/Microsoft SDKs/Windows/v7.1/Bin"
26904 METHOD="well-known name"
26905
26906 windows_path="$WIN_SDK_BASE"
26907 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26908 unix_path=`$CYGPATH -u "$windows_path"`
26909 WIN_SDK_BASE="$unix_path"
26910 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26911 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26912 WIN_SDK_BASE="$unix_path"
26913 fi
26914
26915 if test -d "$WIN_SDK_BASE"; then
26916 # There have been cases of partial or broken SDK installations. A missing
26917 # lib dir is not going to work.
26918 if test ! -d "$WIN_SDK_BASE/../lib"; then
26919 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
26920 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
26921 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
26922 $as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
26923 elif test -f "$WIN_SDK_BASE/SetEnv.Cmd"; then
26924 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
26925 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
26926 VS_ENV_CMD="$WIN_SDK_BASE/SetEnv.Cmd"
26927 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
26928 VS_ENV_ARGS="/x86"
26929 else
26930 VS_ENV_ARGS="/x64"
26931 fi
26932 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
26933 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
26934 # TODO: improve detection for other versions of SDK
26935 PLATFORM_TOOLSET="Windows7.1SDK"
26936 else
26937 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
26938 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
26939 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
26940 $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
26941 fi
26942 fi
26943 fi
26944
26945 fi
26946 if test "x$PROGRAMFILES" != x; then
26947
26948 if test "x$VS_ENV_CMD" = x; then
26949 WIN_SDK_BASE="$PROGRAMFILES/Microsoft SDKs/Windows/v7.1/Bin"
26950 METHOD="well-known name"
26951
26952 windows_path="$WIN_SDK_BASE"
26953 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26954 unix_path=`$CYGPATH -u "$windows_path"`
26955 WIN_SDK_BASE="$unix_path"
26956 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26957 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26958 WIN_SDK_BASE="$unix_path"
26959 fi
26960
26961 if test -d "$WIN_SDK_BASE"; then
26962 # There have been cases of partial or broken SDK installations. A missing
26963 # lib dir is not going to work.
26964 if test ! -d "$WIN_SDK_BASE/../lib"; then
26965 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
26966 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
26967 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
26968 $as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
26969 elif test -f "$WIN_SDK_BASE/SetEnv.Cmd"; then
26970 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
26971 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
26972 VS_ENV_CMD="$WIN_SDK_BASE/SetEnv.Cmd"
26973 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
26974 VS_ENV_ARGS="/x86"
26975 else
26976 VS_ENV_ARGS="/x64"
26977 fi
26978 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
26979 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
26980 # TODO: improve detection for other versions of SDK
26981 PLATFORM_TOOLSET="Windows7.1SDK"
26982 else
26983 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
26984 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
26985 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
26986 $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
26987 fi
26988 fi
26989 fi
26990
26991 fi
26992
26993 if test "x$VS_ENV_CMD" = x; then
26994 WIN_SDK_BASE="C:/Program Files/Microsoft SDKs/Windows/v7.1/Bin"
26995 METHOD="well-known name"
26996
26997 windows_path="$WIN_SDK_BASE"
26998 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26999 unix_path=`$CYGPATH -u "$windows_path"`
27000 WIN_SDK_BASE="$unix_path"
27001 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27002 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27003 WIN_SDK_BASE="$unix_path"
27004 fi
27005
27006 if test -d "$WIN_SDK_BASE"; then
27007 # There have been cases of partial or broken SDK installations. A missing
27008 # lib dir is not going to work.
27009 if test ! -d "$WIN_SDK_BASE/../lib"; then
27010 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27011 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27012 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
27013 $as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
27014 elif test -f "$WIN_SDK_BASE/SetEnv.Cmd"; then
27015 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27016 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27017 VS_ENV_CMD="$WIN_SDK_BASE/SetEnv.Cmd"
27018 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
27019 VS_ENV_ARGS="/x86"
27020 else
27021 VS_ENV_ARGS="/x64"
27022 fi
27023 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
27024 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
27025 # TODO: improve detection for other versions of SDK
27026 PLATFORM_TOOLSET="Windows7.1SDK"
27027 else
27028 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27029 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27030 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
27031 $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
27032 fi
27033 fi
27034 fi
27035
27036
27037 if test "x$VS_ENV_CMD" = x; then
27038 WIN_SDK_BASE="C:/Program Files (x86)/Microsoft SDKs/Windows/v7.1/Bin"
27039 METHOD="well-known name"
27040
27041 windows_path="$WIN_SDK_BASE"
27042 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27043 unix_path=`$CYGPATH -u "$windows_path"`
27044 WIN_SDK_BASE="$unix_path"
27045 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27046 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27047 WIN_SDK_BASE="$unix_path"
27048 fi
27049
27050 if test -d "$WIN_SDK_BASE"; then
27051 # There have been cases of partial or broken SDK installations. A missing
27052 # lib dir is not going to work.
27053 if test ! -d "$WIN_SDK_BASE/../lib"; then
27054 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27055 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27056 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
27057 $as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
27058 elif test -f "$WIN_SDK_BASE/SetEnv.Cmd"; then
27059 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27060 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27061 VS_ENV_CMD="$WIN_SDK_BASE/SetEnv.Cmd"
27062 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
27063 VS_ENV_ARGS="/x86"
27064 else
27065 VS_ENV_ARGS="/x64"
27066 fi
27067 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
27068 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
27069 # TODO: improve detection for other versions of SDK
27070 PLATFORM_TOOLSET="Windows7.1SDK"
27071 else
27072 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27073 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27074 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
27075 $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
27076 fi
27077 fi
27078 fi
27079
27080
27081 if test "x$VS_ENV_CMD" != x; then
27082 # We have found a Visual Studio environment on disk, let's extract variables from the vsvars bat file.
27083
27084 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27085
27086 # First separate the path from the arguments. This will split at the first
27087 # space.
27088 complete="$VS_ENV_CMD"
27089 path="${complete%% *}"
27090 tmp="$complete EOL"
27091 arguments="${tmp#* }"
27092
27093 # Input might be given as Windows format, start by converting to
27094 # unix format.
27095 new_path=`$CYGPATH -u "$path"`
27096
27097 # Now try to locate executable using which
27098 new_path=`$WHICH "$new_path" 2> /dev/null`
27099 # bat and cmd files are not always considered executable in cygwin causing which
40720 # FIXME: These should just be removed!
40721 LDEXE="$LD"
40722 LDEXECXX="$LDCXX"
40723
40724
40725
40726
40727
40728
40729 # The package path is used only on macosx?
40730 # FIXME: clean this up, and/or move it elsewhere.
40731 PACKAGE_PATH=/opt/local
40732
40733
40734 # Check for extra potential brokenness.
40735 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
40736 # On Windows, double-check that we got the right compiler.
40737 CC_VERSION_OUTPUT=`$CC 2>&1 | $HEAD -n 1 | $TR -d '\r'`
40738 COMPILER_CPU_TEST=`$ECHO $CC_VERSION_OUTPUT | $SED -n "s/^.* \(.*\)$/\1/p"`
40739 if test "x$OPENJDK_TARGET_CPU" = "xx86"; then
40740 if test "x$COMPILER_CPU_TEST" != "x80x86"; then
40741 as_fn_error $? "Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for \"$COMPILER_CPU_TEST\"; expected \"80x86\"." "$LINENO" 5
40742 fi
40743 elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then
40744 if test "x$COMPILER_CPU_TEST" != "xx64"; then
40745 as_fn_error $? "Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for \"$COMPILER_CPU_TEST\"; expected \"x64\"." "$LINENO" 5
40746 fi
40747 fi
40748 fi
40749
40750 if test "x$TOOLCHAIN_TYPE" = xgcc; then
40751 # If this is a --hash-style=gnu system, use --hash-style=both, why?
40752 HAS_GNU_HASH=`$CC -dumpspecs 2>/dev/null | $GREP 'hash-style=gnu'`
40753 # This is later checked when setting flags.
40754
40755 # "-Og" suppported for GCC 4.8 and later
40756 CFLAG_OPTIMIZE_DEBUG_FLAG="-Og"
40757
40758 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if compiler supports \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"" >&5
40759 $as_echo_n "checking if compiler supports \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"... " >&6; }
40760 supports=yes
40761
42369 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
42370 ;;
42371 * )
42372 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
42373 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
42374 ;;
42375 esac
42376 elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
42377 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
42378 if test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
42379 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
42380 CFLAGS_JDK="$CFLAGS_JDK -erroff=E_BAD_PRAGMA_PACK_VALUE"
42381 fi
42382
42383 CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
42384 CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
42385 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
42386 CFLAGS_JDK="$CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
42387 CXXFLAGS_JDK="$CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
42388 elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
42389 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \
42390 -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \
42391 -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
42392 -DWIN32 -DIAL"
42393 if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
42394 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_AMD64_ -Damd64"
42395 else
42396 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_X86_ -Dx86"
42397 fi
42398 fi
42399
42400 ###############################################################################
42401
42402 # Adjust flags according to debug level.
42403 case $DEBUG_LEVEL in
42404 fastdebug | slowdebug )
42405 CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS $CFLAGS_DEBUG_OPTIONS"
42406 CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS $CXXFLAGS_DEBUG_OPTIONS"
42407 JAVAC_FLAGS="$JAVAC_FLAGS -g"
42408 ;;
42409 release )
42410 ;;
42411 * )
42412 as_fn_error $? "Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL" "$LINENO" 5
42413 ;;
42414 esac
42415
42416 # Setup LP64
42417 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK $ADD_LP64"
49528 # TODO better (platform agnostic) test
49529 if test "x$OPENJDK_TARGET_OS" = xmacosx && test "x$LIBCXX" = x && test "x$TOOLCHAIN_TYPE" = xgcc; then
49530 LIBCXX="-lstdc++"
49531 fi
49532
49533
49534
49535
49536 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
49537
49538
49539 # Check whether --with-msvcr-dll was given.
49540 if test "${with_msvcr_dll+set}" = set; then :
49541 withval=$with_msvcr_dll;
49542 fi
49543
49544
49545 if test "x$with_msvcr_dll" != x; then
49546 # If given explicitely by user, do not probe. If not present, fail directly.
49547
49548 POSSIBLE_MSVCR_DLL="$with_msvcr_dll"
49549 METHOD="--with-msvcr-dll"
49550 if test -e "$POSSIBLE_MSVCR_DLL"; then
49551 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
49552 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
49553
49554 # Need to check if the found msvcr is correct architecture
49555 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
49556 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
49557 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
49558 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49559 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49560 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49561 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49562 CORRECT_MSVCR_ARCH="PE32 executable"
49563 else
49564 CORRECT_MSVCR_ARCH="PE32+ executable"
49565 fi
49566 else
49567 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49568 CORRECT_MSVCR_ARCH=386
49569 else
49570 CORRECT_MSVCR_ARCH=x86-64
49571 fi
49572 fi
49573 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49574 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49575 $as_echo "ok" >&6; }
49576 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49577 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
49578 $as_echo_n "checking for msvcr100.dll... " >&6; }
49579 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
49580 $as_echo "$MSVCR_DLL" >&6; }
49581 else
49582 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49583 $as_echo "incorrect, ignoring" >&6; }
49584 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
49585 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
49586 fi
49587 fi
49588
49589 if test "x$MSVCR_DLL" = x; then
49590 as_fn_error $? "Could not find a proper msvcr100.dll as specified by --with-msvcr-dll" "$LINENO" 5
49591 fi
49592 fi
49593
49594 if test "x$MSVCR_DLL" = x; then
49595 # Probe: Using well-known location from Visual Studio 10.0
49596 if test "x$VCINSTALLDIR" != x; then
49597 CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR"
49598
49599 windows_path="$CYGWIN_VC_INSTALL_DIR"
49600 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49601 unix_path=`$CYGPATH -u "$windows_path"`
49602 CYGWIN_VC_INSTALL_DIR="$unix_path"
49603 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49604 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49605 CYGWIN_VC_INSTALL_DIR="$unix_path"
49606 fi
49607
49608 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
49609 POSSIBLE_MSVCR_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x64/Microsoft.VC100.CRT/msvcr100.dll"
49610 else
49611 POSSIBLE_MSVCR_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x86/Microsoft.VC100.CRT/msvcr100.dll"
49612 fi
49613
49614 POSSIBLE_MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49615 METHOD="well-known location in VCINSTALLDIR"
49616 if test -e "$POSSIBLE_MSVCR_DLL"; then
49617 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
49618 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
49619
49620 # Need to check if the found msvcr is correct architecture
49621 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
49622 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
49623 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
49624 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49625 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49626 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49627 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49628 CORRECT_MSVCR_ARCH="PE32 executable"
49629 else
49630 CORRECT_MSVCR_ARCH="PE32+ executable"
49631 fi
49632 else
49633 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49634 CORRECT_MSVCR_ARCH=386
49635 else
49636 CORRECT_MSVCR_ARCH=x86-64
49637 fi
49638 fi
49639 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49640 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49641 $as_echo "ok" >&6; }
49642 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49643 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
49644 $as_echo_n "checking for msvcr100.dll... " >&6; }
49645 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
49646 $as_echo "$MSVCR_DLL" >&6; }
49647 else
49648 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49649 $as_echo "incorrect, ignoring" >&6; }
49650 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
49651 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
49652 fi
49653 fi
49654
49655 fi
49656 fi
49657
49658 if test "x$MSVCR_DLL" = x; then
49659 # Probe: Check in the Boot JDK directory.
49660 POSSIBLE_MSVCR_DLL="$BOOT_JDK/bin/msvcr100.dll"
49661
49662 POSSIBLE_MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49663 METHOD="well-known location in Boot JDK"
49664 if test -e "$POSSIBLE_MSVCR_DLL"; then
49665 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
49666 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
49667
49668 # Need to check if the found msvcr is correct architecture
49669 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
49670 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
49671 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
49672 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49673 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49674 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49675 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49676 CORRECT_MSVCR_ARCH="PE32 executable"
49677 else
49678 CORRECT_MSVCR_ARCH="PE32+ executable"
49679 fi
49680 else
49681 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49682 CORRECT_MSVCR_ARCH=386
49683 else
49684 CORRECT_MSVCR_ARCH=x86-64
49685 fi
49686 fi
49687 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49688 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49689 $as_echo "ok" >&6; }
49690 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49691 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
49692 $as_echo_n "checking for msvcr100.dll... " >&6; }
49693 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
49694 $as_echo "$MSVCR_DLL" >&6; }
49695 else
49696 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49697 $as_echo "incorrect, ignoring" >&6; }
49698 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
49699 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
49700 fi
49701 fi
49702
49703 fi
49704
49705 if test "x$MSVCR_DLL" = x; then
49706 # Probe: Look in the Windows system32 directory
49707 CYGWIN_SYSTEMROOT="$SYSTEMROOT"
49708
49709 windows_path="$CYGWIN_SYSTEMROOT"
49710 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49711 unix_path=`$CYGPATH -u "$windows_path"`
49712 CYGWIN_SYSTEMROOT="$unix_path"
49713 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49714 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49715 CYGWIN_SYSTEMROOT="$unix_path"
49716 fi
49717
49718 POSSIBLE_MSVCR_DLL="$CYGWIN_SYSTEMROOT/system32/msvcr100.dll"
49719
49720 POSSIBLE_MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49721 METHOD="well-known location in SYSTEMROOT"
49722 if test -e "$POSSIBLE_MSVCR_DLL"; then
49723 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
49724 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
49725
49726 # Need to check if the found msvcr is correct architecture
49727 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
49728 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
49729 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
49730 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49731 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49732 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49733 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49734 CORRECT_MSVCR_ARCH="PE32 executable"
49735 else
49736 CORRECT_MSVCR_ARCH="PE32+ executable"
49737 fi
49738 else
49739 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49740 CORRECT_MSVCR_ARCH=386
49741 else
49742 CORRECT_MSVCR_ARCH=x86-64
49743 fi
49744 fi
49745 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49746 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49747 $as_echo "ok" >&6; }
49748 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49749 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
49750 $as_echo_n "checking for msvcr100.dll... " >&6; }
49751 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
49752 $as_echo "$MSVCR_DLL" >&6; }
49753 else
49754 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49755 $as_echo "incorrect, ignoring" >&6; }
49756 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
49757 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
49758 fi
49759 fi
49760
49761 fi
49762
49763 if test "x$MSVCR_DLL" = x; then
49764 # Probe: If Visual Studio Express is installed, there is usually one with the debugger
49765 if test "x$VS100COMNTOOLS" != x; then
49766 CYGWIN_VS_TOOLS_DIR="$VS100COMNTOOLS/.."
49767
49768 windows_path="$CYGWIN_VS_TOOLS_DIR"
49769 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49770 unix_path=`$CYGPATH -u "$windows_path"`
49771 CYGWIN_VS_TOOLS_DIR="$unix_path"
49772 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49773 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49774 CYGWIN_VS_TOOLS_DIR="$unix_path"
49775 fi
49776
49777 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
49778 POSSIBLE_MSVCR_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name msvcr100.dll | $GREP -i /x64/ | $HEAD --lines 1`
49779 else
49780 POSSIBLE_MSVCR_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name msvcr100.dll | $GREP -i /x86/ | $HEAD --lines 1`
49781 fi
49782
49783 POSSIBLE_MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49784 METHOD="search of VS100COMNTOOLS"
49785 if test -e "$POSSIBLE_MSVCR_DLL"; then
49786 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
49787 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
49788
49789 # Need to check if the found msvcr is correct architecture
49790 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
49791 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
49792 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
49793 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49794 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49795 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49796 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49797 CORRECT_MSVCR_ARCH="PE32 executable"
49798 else
49799 CORRECT_MSVCR_ARCH="PE32+ executable"
49800 fi
49801 else
49802 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49803 CORRECT_MSVCR_ARCH=386
49804 else
49805 CORRECT_MSVCR_ARCH=x86-64
49806 fi
49807 fi
49808 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49809 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49810 $as_echo "ok" >&6; }
49811 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49812 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
49813 $as_echo_n "checking for msvcr100.dll... " >&6; }
49814 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
49815 $as_echo "$MSVCR_DLL" >&6; }
49816 else
49817 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49818 $as_echo "incorrect, ignoring" >&6; }
49819 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
49820 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
49821 fi
49822 fi
49823
49824 fi
49825 fi
49826
49827 if test "x$MSVCR_DLL" = x; then
49828 # Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now.
49829 # (This was the original behaviour; kept since it might turn up something)
49830 if test "x$CYGWIN_VC_INSTALL_DIR" != x; then
49831 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
49832 POSSIBLE_MSVCR_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name msvcr100.dll | $GREP x64 | $HEAD --lines 1`
49833 else
49834 POSSIBLE_MSVCR_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name msvcr100.dll | $GREP x86 | $GREP -v ia64 | $GREP -v x64 | $HEAD --lines 1`
49835 if test "x$POSSIBLE_MSVCR_DLL" = x; then
49836 # We're grasping at straws now...
49837 POSSIBLE_MSVCR_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name msvcr100.dll | $HEAD --lines 1`
49838 fi
49839 fi
49840
49841
49842 POSSIBLE_MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49843 METHOD="search of VCINSTALLDIR"
49844 if test -e "$POSSIBLE_MSVCR_DLL"; then
49845 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
49846 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
49847
49848 # Need to check if the found msvcr is correct architecture
49849 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
49850 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
49851 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
49852 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49853 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49854 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49855 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49856 CORRECT_MSVCR_ARCH="PE32 executable"
49857 else
49858 CORRECT_MSVCR_ARCH="PE32+ executable"
49859 fi
49860 else
49861 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49862 CORRECT_MSVCR_ARCH=386
49863 else
49864 CORRECT_MSVCR_ARCH=x86-64
49865 fi
49866 fi
49867 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49868 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49869 $as_echo "ok" >&6; }
49870 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49871 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
49872 $as_echo_n "checking for msvcr100.dll... " >&6; }
49873 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
49874 $as_echo "$MSVCR_DLL" >&6; }
49875 else
49876 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49877 $as_echo "incorrect, ignoring" >&6; }
49878 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
49879 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
49880 fi
49881 fi
49882
49883 fi
49884 fi
49885
49886 if test "x$MSVCR_DLL" = x; then
49887 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
49888 $as_echo_n "checking for msvcr100.dll... " >&6; }
49889 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
49890 $as_echo "no" >&6; }
49891 as_fn_error $? "Could not find msvcr100.dll. Please specify using --with-msvcr-dll." "$LINENO" 5
49892 fi
49893
49894
49895 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49896
49897 # Input might be given as Windows format, start by converting to
49898 # unix format.
49899 path="$MSVCR_DLL"
49900 new_path=`$CYGPATH -u "$path"`
49901
49902 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
49903 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
49904 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
49905 # "foo.exe" is OK but "foo" is an error.
49906 #
49907 # This test is therefore slightly more accurate than "test -f" to check for file precense.
49908 # It is also a way to make sure we got the proper file name for the real test later on.
49909 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
49910 if test "x$test_shortpath" = x; then
49911 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&5
49912 $as_echo "$as_me: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&6;}
49913 as_fn_error $? "Cannot locate the the path of MSVCR_DLL" "$LINENO" 5
49996
49997 else
49998 # We're on a unix platform. Hooray! :)
49999 path="$MSVCR_DLL"
50000 has_space=`$ECHO "$path" | $GREP " "`
50001 if test "x$has_space" != x; then
50002 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&5
50003 $as_echo "$as_me: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&6;}
50004 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
50005 fi
50006
50007 # Use eval to expand a potential ~
50008 eval path="$path"
50009 if test ! -f "$path" && test ! -d "$path"; then
50010 as_fn_error $? "The path of MSVCR_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
50011 fi
50012
50013 MSVCR_DLL="`cd "$path"; $THEPWDCMD -L`"
50014 fi
50015
50016
50017
50018
50019 # Check whether --with-dxsdk was given.
50020 if test "${with_dxsdk+set}" = set; then :
50021 withval=$with_dxsdk; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&5
50022 $as_echo "$as_me: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&2;}
50023 fi
50024
50025
50026
50027
50028 # Check whether --with-dxsdk-lib was given.
50029 if test "${with_dxsdk_lib+set}" = set; then :
50030 withval=$with_dxsdk_lib; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&5
50031 $as_echo "$as_me: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&2;}
50032 fi
50033
50034
50035
50036
50037 # Check whether --with-dxsdk-include was given.
50038 if test "${with_dxsdk_include+set}" = set; then :
50039 withval=$with_dxsdk_include; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&5
50040 $as_echo "$as_me: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&2;}
50041 fi
50042
50043
50044 fi
50045
50046
50047
50048 ###############################################################################
50049 #
50050 # We need to do some final tweaking, when everything else is done.
50051 #
50052 ###############################################################################
50053
50054
50055 HOTSPOT_MAKE_ARGS="$HOTSPOT_TARGET"
50056
50057
50058 # The name of the Service Agent jar.
50059 SALIB_NAME="${LIBRARY_PREFIX}saproc${SHARED_LIBRARY_SUFFIX}"
50060 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
50061 SALIB_NAME="${LIBRARY_PREFIX}sawindbg${SHARED_LIBRARY_SUFFIX}"
50062 fi
50063
50064
50065
50066 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if elliptic curve crypto implementation is present" >&5
50067 $as_echo_n "checking if elliptic curve crypto implementation is present... " >&6; }
52154 if test "x$CONFIGURE_COMMAND_LINE" != x; then
52155 printf "using configure arguments '$CONFIGURE_COMMAND_LINE'.\n"
52156 else
52157 printf "using default settings.\n"
52158 fi
52159
52160 printf "\n"
52161 printf "Configuration summary:\n"
52162 printf "* Debug level: $DEBUG_LEVEL\n"
52163 printf "* HS debug level: $HOTSPOT_DEBUG_LEVEL\n"
52164 printf "* JDK variant: $JDK_VARIANT\n"
52165 printf "* JVM variants: $with_jvm_variants\n"
52166 printf "* OpenJDK target: OS: $OPENJDK_TARGET_OS, CPU architecture: $OPENJDK_TARGET_CPU_ARCH, address length: $OPENJDK_TARGET_CPU_BITS\n"
52167
52168 printf "\n"
52169 printf "Tools summary:\n"
52170 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
52171 printf "* Environment: $WINDOWS_ENV_VENDOR version $WINDOWS_ENV_VERSION (root at $WINDOWS_ENV_ROOT_PATH)\n"
52172 fi
52173 printf "* Boot JDK: $BOOT_JDK_VERSION (at $BOOT_JDK)\n"
52174 printf "* Toolchain: $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION)\n"
52175 printf "* C Compiler: Version $CC_VERSION_NUMBER (at $CC)\n"
52176 printf "* C++ Compiler: Version $CXX_VERSION_NUMBER (at $CXX)\n"
52177
52178 printf "\n"
52179 printf "Build performance summary:\n"
52180 printf "* Cores to use: $JOBS\n"
52181 printf "* Memory limit: $MEMORY_SIZE MB\n"
52182 if test "x$CCACHE_STATUS" != "x"; then
52183 printf "* ccache status: $CCACHE_STATUS\n"
52184 fi
52185 printf "\n"
52186
52187 if test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = "xyes"; then
52188 printf "NOTE: You have requested to build more than one version of the JVM, which\n"
52189 printf "will result in longer build times.\n"
52190 printf "\n"
52191 fi
52192
52193 if test "x$FOUND_ALT_VARIABLES" != "x"; then
52194 printf "WARNING: You have old-style ALT_ environment variables set.\n"
|
628 #endif"
629
630 ac_subst_vars='LTLIBOBJS
631 LIBOBJS
632 CCACHE
633 USE_PRECOMPILED_HEADER
634 SJAVAC_SERVER_DIR
635 ENABLE_SJAVAC
636 SJAVAC_SERVER_JAVA_FLAGS
637 SJAVAC_SERVER_JAVA
638 JAVA_TOOL_FLAGS_SMALL
639 JAVA_FLAGS_SMALL
640 JAVA_FLAGS_BIG
641 JAVA_FLAGS
642 JOBS
643 MEMORY_SIZE
644 NUM_CORES
645 ENABLE_INTREE_EC
646 SALIB_NAME
647 HOTSPOT_MAKE_ARGS
648 MSVCP_DLL
649 MSVCR_DLL
650 LIBCXX
651 LLVM_LIBS
652 LLVM_LDFLAGS
653 LLVM_CFLAGS
654 LLVM_CONFIG
655 LIBFFI_LIBS
656 LIBFFI_CFLAGS
657 STATIC_CXX_SETTING
658 LIBDL
659 LIBM
660 LIBZIP_CAN_USE_MMAP
661 USE_EXTERNAL_LIBZ
662 USE_EXTERNAL_LIBPNG
663 PNG_LIBS
664 PNG_CFLAGS
665 USE_EXTERNAL_LCMS
666 LCMS_LIBS
667 LCMS_CFLAGS
668 USE_EXTERNAL_LIBGIF
1060 enable_unlimited_crypto
1061 enable_rmiconnector_iiop
1062 with_milestone
1063 with_update_version
1064 with_user_release_suffix
1065 with_build_number
1066 with_copyright_year
1067 with_boot_jdk
1068 with_add_source_root
1069 with_override_source_root
1070 with_adds_and_overrides
1071 with_override_langtools
1072 with_override_corba
1073 with_override_jaxp
1074 with_override_jaxws
1075 with_override_hotspot
1076 with_override_nashorn
1077 with_override_jdk
1078 with_import_hotspot
1079 with_toolchain_type
1080 with_toolchain_version
1081 with_jtreg
1082 with_extra_cflags
1083 with_extra_cxxflags
1084 with_extra_ldflags
1085 enable_debug_symbols
1086 enable_zip_debug_info
1087 with_x
1088 with_cups
1089 with_cups_include
1090 with_freetype
1091 with_freetype_include
1092 with_freetype_lib
1093 with_freetype_src
1094 enable_freetype_bundling
1095 with_alsa
1096 with_alsa_include
1097 with_alsa_lib
1098 with_libjpeg
1099 with_giflib
1100 with_lcms
1101 with_libpng
1102 with_zlib
1103 with_stdc__lib
1104 with_msvcr_dll
1105 with_msvcp_dll
1106 with_dxsdk
1107 with_dxsdk_lib
1108 with_dxsdk_include
1109 with_num_cores
1110 with_memory_size
1111 with_jobs
1112 with_boot_jdk_jvmargs
1113 with_sjavac_server_java
1114 enable_sjavac
1115 enable_precompiled_headers
1116 enable_ccache
1117 with_ccache_dir
1118 '
1119 ac_precious_vars='build_alias
1120 host_alias
1121 target_alias
1122 BASENAME
1123 BASH
1124 CAT
1125 CHMOD
1917 override source root for the same directory; if it
1918 exists, use that directory instead and ignore the
1919 directory in the original source root
1920 --with-adds-and-overrides
1921 use the subdirs 'adds' and 'overrides' in the
1922 specified directory as add-source-root and
1923 override-source-root
1924 --with-override-langtools
1925 use this langtools dir for the build
1926 --with-override-corba use this corba dir for the build
1927 --with-override-jaxp use this jaxp dir for the build
1928 --with-override-jaxws use this jaxws dir for the build
1929 --with-override-hotspot use this hotspot dir for the build
1930 --with-override-nashorn use this nashorn dir for the build
1931 --with-override-jdk use this jdk dir for the build
1932 --with-import-hotspot import hotspot binaries from this jdk image or
1933 hotspot build dist dir instead of building from
1934 source
1935 --with-toolchain-type the toolchain type (or family) to use, use '--help'
1936 to show possible values [platform dependent]
1937 --with-toolchain-version
1938 the version of the toolchain to look for, use
1939 '--help' to show possible values [platform
1940 dependent]
1941 --with-jtreg Regression Test Harness [probed]
1942 --with-extra-cflags extra flags to be used when compiling jdk c-files
1943 --with-extra-cxxflags extra flags to be used when compiling jdk c++-files
1944 --with-extra-ldflags extra flags to be used when linking jdk
1945 --with-x use the X Window System
1946 --with-cups specify prefix directory for the cups package
1947 (expecting the headers under PATH/include)
1948 --with-cups-include specify directory for the cups include files
1949 --with-freetype specify prefix directory for the freetype package
1950 (expecting the libraries under PATH/lib and the
1951 headers under PATH/include)
1952 --with-freetype-include specify directory for the freetype include files
1953 --with-freetype-lib specify directory for the freetype library
1954 --with-freetype-src specify directory with freetype sources to
1955 automatically build the library (experimental,
1956 Windows-only)
1957 --with-alsa specify prefix directory for the alsa package
1958 (expecting the libraries under PATH/lib and the
1959 headers under PATH/include)
1960 --with-alsa-include specify directory for the alsa include files
1961 --with-alsa-lib specify directory for the alsa library
1962 --with-libjpeg use libjpeg from build system or OpenJDK source
1963 (system, bundled) [bundled]
1964 --with-giflib use giflib from build system or OpenJDK source
1965 (system, bundled) [bundled]
1966 --with-lcms use lcms2 from build system or OpenJDK source
1967 (system, bundled) [bundled]
1968 --with-libpng use libpng from build system or OpenJDK source
1969 (system, bundled) [bundled]
1970 --with-zlib use zlib from build system or OpenJDK source
1971 (system, bundled) [bundled]
1972 --with-stdc++lib=<static>,<dynamic>,<default>
1973 force linking of the C++ runtime on Linux to either
1974 static or dynamic, default is static with dynamic as
1975 fallback
1976 --with-msvcr-dll path to microsoft C runtime dll (msvcr*.dll)
1977 (Windows only) [probed]
1978 --with-msvcp-dll path to microsoft C++ runtime dll (msvcp*.dll)
1979 (Windows only) [probed]
1980 --with-dxsdk Deprecated. Option is kept for backwards
1981 compatibility and is ignored
1982 --with-dxsdk-lib Deprecated. Option is kept for backwards
1983 compatibility and is ignored
1984 --with-dxsdk-include Deprecated. Option is kept for backwards
1985 compatibility and is ignored
1986 --with-num-cores number of cores in the build system, e.g.
1987 --with-num-cores=8 [probed]
1988 --with-memory-size memory (in MB) available in the build system, e.g.
1989 --with-memory-size=1024 [probed]
1990 --with-jobs number of parallel jobs to let make run [calculated
1991 based on cores and memory]
1992 --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
1993 invocations of boot JDK, overriding the default
1994 values, e.g --with-boot-jdk-jvmargs="-Xmx8G
1995 -enableassertions"
1996 --with-sjavac-server-java
1997 use this java binary for running the sjavac
1998 background server [Boot JDK java]
1999 --with-ccache-dir where to store ccache files [~/.ccache]
4295 # under the terms of the GNU General Public License version 2 only, as
4296 # published by the Free Software Foundation. Oracle designates this
4297 # particular file as subject to the "Classpath" exception as provided
4298 # by Oracle in the LICENSE file that accompanied this code.
4299 #
4300 # This code is distributed in the hope that it will be useful, but WITHOUT
4301 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4302 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4303 # version 2 for more details (a copy is included in the LICENSE file that
4304 # accompanied this code).
4305 #
4306 # You should have received a copy of the GNU General Public License version
4307 # 2 along with this work; if not, write to the Free Software Foundation,
4308 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4309 #
4310 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4311 # or visit www.oracle.com if you need additional information or have any
4312 # questions.
4313 #
4314
4315 ################################################################################
4316
4317 VALID_VS_VERSIONS="2010 2012 2013"
4318
4319 VS_DESCRIPTION_2010="Microsoft Visual Studio 2010"
4320 VS_VERSION_INTERNAL_2010=100
4321 VS_MSVCR_2010=msvcr100.dll
4322 # We don't use msvcp on Visual Studio 2010
4323 #VS_MSVCP_2010=msvcp100.dll
4324 VS_ENVVAR_2010="VS100COMNTOOLS"
4325 VS_VS_INSTALLDIR_2010="Microsoft Visual Studio 10.0"
4326 VS_SDK_INSTALLDIR_2010="Microsoft SDKs/Windows/v7.1"
4327 VS_VS_PLATFORM_NAME_2010="v100"
4328 VS_SDK_PLATFORM_NAME_2010="Windows7.1SDK"
4329
4330 VS_DESCRIPTION_2012="Microsoft Visual Studio 2012"
4331 VS_VERSION_INTERNAL_2012=110
4332 VS_MSVCR_2012=msvcr110.dll
4333 VS_MSVCP_2012=msvcp110.dll
4334 VS_ENVVAR_2012="VS110COMNTOOLS"
4335 VS_VS_INSTALLDIR_2012="Microsoft Visual Studio 11.0"
4336 VS_SDK_INSTALLDIR_2012=
4337 VS_VS_PLATFORM_NAME_2012="v110"
4338 VS_SDK_PLATFORM_NAME_2012=
4339
4340 VS_DESCRIPTION_2013="Microsoft Visual Studio 2013"
4341 VS_VERSION_INTERNAL_2013=120
4342 VS_MSVCR_2013=msvcr120.dll
4343 VS_MSVCP_2013=msvcp120.dll
4344 VS_ENVVAR_2013="VS120COMNTOOLS"
4345 VS_VS_INSTALLDIR_2013="Microsoft Visual Studio 12.0"
4346 VS_SDK_INSTALLDIR_2013=
4347 VS_VS_PLATFORM_NAME_2013="v120"
4348 VS_SDK_PLATFORM_NAME_2013=
4349
4350 ################################################################################
4351
4352
4353
4354 ################################################################################
4355
4356
4357
4358 ################################################################################
4359 # Finds the bat or cmd file in Visual Studio or the SDK that sets up a proper
4360 # build environment and assigns it to VS_ENV_CMD
4361
4362
4363 ################################################################################
4364
4365
4366
4367 ################################################################################
4368 # Check if the VS env variables were setup prior to running configure.
4369 # If not, then find vcvarsall.bat and run it automatically, and integrate
4370 # the set env variables into the spec file.
4371
4372
4373
4374
4375
4376
4377
4378
4379
4380
4381
4382
4383
4384 # This line needs to be here, verbatim, after all includes and the dummy hook
4385 # definitions. It is replaced with custom functionality when building
4386 # custom sources.
4387 #CUSTOM_AUTOCONF_INCLUDE
4388
4389 # Do not change or remove the following line, it is needed for consistency checks:
4390 DATE_WHEN_GENERATED=1421073193
4391
4392 ###############################################################################
4393 #
4394 # Initialization / Boot-strapping
4395 #
4396 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4397 # thus it jumps back and forth, each time gaining something needed later on.
4398 #
4399 ###############################################################################
4400
4401 # If we are requested to print additional help, do that and then exit.
4402 # This must be the very first call.
4403
4404 if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4405 $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4406 $PRINTF "Which are valid to use depends on the build platform.\n"
4407 for toolchain in $VALID_TOOLCHAINS_all; do
4408 # Use indirect variable referencing
4409 toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4410 TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
26706 fi
26707
26708
26709 if test "x$CYGWIN_LINK" != x; then
26710 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the first found link.exe is actually the Cygwin link tool" >&5
26711 $as_echo_n "checking if the first found link.exe is actually the Cygwin link tool... " >&6; }
26712 "$CYGWIN_LINK" --version > /dev/null
26713 if test $? -eq 0 ; then
26714 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
26715 $as_echo "yes" >&6; }
26716 else
26717 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
26718 $as_echo "no" >&6; }
26719 # This might be the VS linker. Don't exclude it later on.
26720 CYGWIN_LINK=""
26721 fi
26722 fi
26723
26724 # First-hand choice is to locate and run the vsvars bat file.
26725
26726
26727 # Check whether --with-toolchain-version was given.
26728 if test "${with_toolchain_version+set}" = set; then :
26729 withval=$with_toolchain_version;
26730 fi
26731
26732
26733 if test "x$with_toolchain_version" = xlist; then
26734 # List all toolchains
26735 { $as_echo "$as_me:${as_lineno-$LINENO}: The following toolchain versions are valid on this platform:" >&5
26736 $as_echo "$as_me: The following toolchain versions are valid on this platform:" >&6;}
26737 for version in $VALID_VS_VERSIONS; do
26738 eval VS_DESCRIPTION=\${VS_DESCRIPTION_$version}
26739 $PRINTF " %-10s %s\n" $version "$VS_DESCRIPTION"
26740 done
26741
26742 exit 0
26743 elif test "x$with_toolchain_version" != x; then
26744 # User override; check that it is valid
26745 if test "x${VALID_VS_VERSIONS/$with_toolchain_version/}" = "x${VALID_VS_VERSIONS}"; then
26746 { $as_echo "$as_me:${as_lineno-$LINENO}: Visual Studio version $with_toolchain_version is not valid." >&5
26747 $as_echo "$as_me: Visual Studio version $with_toolchain_version is not valid." >&6;}
26748 { $as_echo "$as_me:${as_lineno-$LINENO}: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&5
26749 $as_echo "$as_me: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&6;}
26750 as_fn_error $? "Cannot continue." "$LINENO" 5
26751 fi
26752 VS_VERSIONS_PROBE_LIST="$with_toolchain_version"
26753 else
26754 # No flag given, use default
26755 VS_VERSIONS_PROBE_LIST="$VALID_VS_VERSIONS"
26756 fi
26757
26758 for VS_VERSION in $VS_VERSIONS_PROBE_LIST; do
26759
26760 VS_VERSION="$VS_VERSION"
26761 eval VS_COMNTOOLS_VAR="\${VS_ENVVAR_${VS_VERSION}}"
26762 eval VS_COMNTOOLS="\$${VS_COMNTOOLS_VAR}"
26763 eval VS_INSTALL_DIR="\${VS_VS_INSTALLDIR_${VS_VERSION}}"
26764 eval SDK_INSTALL_DIR="\${VS_SDK_INSTALLDIR_${VS_VERSION}}"
26765
26766 # When using --with-tools-dir, assume it points to the correct and default
26767 # version of Visual Studio or that --with-toolchain-version was also set.
26768 if test "x$with_tools_dir" != x; then
26769
26770 if test "x$VS_ENV_CMD" = x; then
26771 VS_VERSION="${VS_VERSION}"
26772 VS_BASE="$with_tools_dir/../.."
26773 METHOD="--with-tools-dir"
26774
26775 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
26776 VCVARSFILE="vc/bin/vcvars32.bat"
26777 else
26778 VCVARSFILE="vc/bin/amd64/vcvars64.bat"
26779 fi
26780
26781
26782 windows_path="$VS_BASE"
26783 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26784 unix_path=`$CYGPATH -u "$windows_path"`
26785 VS_BASE="$unix_path"
26786 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26787 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26788 VS_BASE="$unix_path"
26789 fi
26790
26791 if test -d "$VS_BASE"; then
26792 if test -f "$VS_BASE/$VCVARSFILE"; then
26793 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
26794 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
26795 VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
26796 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
26797 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
26798 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
26799 else
26800 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
26801 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
26802 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
26803 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
26804 fi
26805 fi
26806 fi
26807
26808
26809 if test "x$VS_ENV_CMD" = x; then
26810 VS_VERSION="${VS_VERSION}"
26811 VS_BASE="$with_tools_dir/../../.."
26812 METHOD="--with-tools-dir"
26813
26814 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
26815 VCVARSFILE="vc/bin/vcvars32.bat"
26816 else
26817 VCVARSFILE="vc/bin/amd64/vcvars64.bat"
26818 fi
26819
26820
26821 windows_path="$VS_BASE"
26822 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26823 unix_path=`$CYGPATH -u "$windows_path"`
26824 VS_BASE="$unix_path"
26825 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26826 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26827 VS_BASE="$unix_path"
26828 fi
26829
26830 if test -d "$VS_BASE"; then
26831 if test -f "$VS_BASE/$VCVARSFILE"; then
26832 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
26833 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
26834 VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
26835 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
26836 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
26837 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
26838 else
26839 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
26840 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
26841 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
26842 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
26843 fi
26844 fi
26845 fi
26846
26847 if test "x$VS_ENV_CMD" = x; then
26848 # Having specified an argument which is incorrect will produce an instant failure;
26849 # we should not go on looking
26850 { $as_echo "$as_me:${as_lineno-$LINENO}: The path given by --with-tools-dir does not contain a valid" >&5
26851 $as_echo "$as_me: The path given by --with-tools-dir does not contain a valid" >&6;}
26852 { $as_echo "$as_me:${as_lineno-$LINENO}: Visual Studio installation. Please point to the VC/bin or VC/bin/amd64" >&5
26853 $as_echo "$as_me: Visual Studio installation. Please point to the VC/bin or VC/bin/amd64" >&6;}
26854 { $as_echo "$as_me:${as_lineno-$LINENO}: directory within the Visual Studio installation" >&5
26855 $as_echo "$as_me: directory within the Visual Studio installation" >&6;}
26856 as_fn_error $? "Cannot locate a valid Visual Studio installation" "$LINENO" 5
26857 fi
26858 fi
26859
26860 VS_ENV_CMD=""
26861 VS_ENV_ARGS=""
26862
26863 if test "x$VS_COMNTOOLS" != x; then
26864
26865 if test "x$VS_ENV_CMD" = x; then
26866 VS_VERSION="${VS_VERSION}"
26867 VS_BASE="$VS_COMNTOOLS/../.."
26868 METHOD="$VS_COMNTOOLS_VAR variable"
26869
26870 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
26871 VCVARSFILE="vc/bin/vcvars32.bat"
26872 else
26873 VCVARSFILE="vc/bin/amd64/vcvars64.bat"
26874 fi
26875
26876
26877 windows_path="$VS_BASE"
26878 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26879 unix_path=`$CYGPATH -u "$windows_path"`
26880 VS_BASE="$unix_path"
26881 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26882 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26883 VS_BASE="$unix_path"
26884 fi
26885
26886 if test -d "$VS_BASE"; then
26887 if test -f "$VS_BASE/$VCVARSFILE"; then
26888 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
26889 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
26890 VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
26891 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
26892 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
26893 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
26894 else
26895 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
26896 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
26897 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
26898 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
26899 fi
26900 fi
26901 fi
26902
26903 fi
26904 if test "x$PROGRAMFILES" != x; then
26905
26906 if test "x$VS_ENV_CMD" = x; then
26907 VS_VERSION="${VS_VERSION}"
26908 VS_BASE="$PROGRAMFILES/$VS_INSTALL_DIR"
26909 METHOD="well-known name"
26910
26911 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
26912 VCVARSFILE="vc/bin/vcvars32.bat"
26913 else
26914 VCVARSFILE="vc/bin/amd64/vcvars64.bat"
26915 fi
26916
26917
26918 windows_path="$VS_BASE"
26919 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26920 unix_path=`$CYGPATH -u "$windows_path"`
26921 VS_BASE="$unix_path"
26922 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26923 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26924 VS_BASE="$unix_path"
26925 fi
26926
26927 if test -d "$VS_BASE"; then
26928 if test -f "$VS_BASE/$VCVARSFILE"; then
26929 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
26930 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
26931 VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
26932 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
26933 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
26934 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
26935 else
26936 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
26937 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
26938 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
26939 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
26940 fi
26941 fi
26942 fi
26943
26944 fi
26945 # Work around the insanely named ProgramFiles(x86) env variable
26946 PROGRAMFILES_X86="`env | $SED -n 's/^ProgramFiles(x86)=//p'`"
26947 if test "x$PROGRAMFILES_X86" != x; then
26948
26949 if test "x$VS_ENV_CMD" = x; then
26950 VS_VERSION="${VS_VERSION}"
26951 VS_BASE="$PROGRAMFILES_X86/$VS_INSTALL_DIR"
26952 METHOD="well-known name"
26953
26954 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
26955 VCVARSFILE="vc/bin/vcvars32.bat"
26956 else
26957 VCVARSFILE="vc/bin/amd64/vcvars64.bat"
26958 fi
26959
26960
26961 windows_path="$VS_BASE"
26962 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26963 unix_path=`$CYGPATH -u "$windows_path"`
26964 VS_BASE="$unix_path"
26965 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26966 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26967 VS_BASE="$unix_path"
26968 fi
26969
26970 if test -d "$VS_BASE"; then
26971 if test -f "$VS_BASE/$VCVARSFILE"; then
26972 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
26973 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
26974 VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
26975 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
26976 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
26977 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
26978 else
26979 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
26980 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
26981 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
26982 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
26983 fi
26984 fi
26985 fi
26986
26987 fi
26988
26989 if test "x$VS_ENV_CMD" = x; then
26990 VS_VERSION="${VS_VERSION}"
26991 VS_BASE="C:/Program Files/$VS_INSTALL_DIR"
26992 METHOD="well-known name"
26993
26994 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
26995 VCVARSFILE="vc/bin/vcvars32.bat"
26996 else
26997 VCVARSFILE="vc/bin/amd64/vcvars64.bat"
26998 fi
26999
27000
27001 windows_path="$VS_BASE"
27002 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27003 unix_path=`$CYGPATH -u "$windows_path"`
27004 VS_BASE="$unix_path"
27005 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27006 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27007 VS_BASE="$unix_path"
27008 fi
27009
27010 if test -d "$VS_BASE"; then
27011 if test -f "$VS_BASE/$VCVARSFILE"; then
27012 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
27013 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
27014 VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
27015 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
27016 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
27017 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
27018 else
27019 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
27020 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
27021 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
27022 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
27023 fi
27024 fi
27025 fi
27026
27027
27028 if test "x$VS_ENV_CMD" = x; then
27029 VS_VERSION="${VS_VERSION}"
27030 VS_BASE="C:/Program Files (x86)/$VS_INSTALL_DIR"
27031 METHOD="well-known name"
27032
27033 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
27034 VCVARSFILE="vc/bin/vcvars32.bat"
27035 else
27036 VCVARSFILE="vc/bin/amd64/vcvars64.bat"
27037 fi
27038
27039
27040 windows_path="$VS_BASE"
27041 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27042 unix_path=`$CYGPATH -u "$windows_path"`
27043 VS_BASE="$unix_path"
27044 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27045 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27046 VS_BASE="$unix_path"
27047 fi
27048
27049 if test -d "$VS_BASE"; then
27050 if test -f "$VS_BASE/$VCVARSFILE"; then
27051 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
27052 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
27053 VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
27054 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
27055 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
27056 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
27057 else
27058 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
27059 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
27060 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
27061 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
27062 fi
27063 fi
27064 fi
27065
27066
27067 if test "x$SDK_INSTALL_DIR" != x; then
27068 if test "x$ProgramW6432" != x; then
27069
27070 if test "x$VS_ENV_CMD" = x; then
27071 VS_VERSION="${VS_VERSION}"
27072 WIN_SDK_BASE="$ProgramW6432/$SDK_INSTALL_DIR"
27073 METHOD="well-known name"
27074
27075 windows_path="$WIN_SDK_BASE"
27076 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27077 unix_path=`$CYGPATH -u "$windows_path"`
27078 WIN_SDK_BASE="$unix_path"
27079 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27080 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27081 WIN_SDK_BASE="$unix_path"
27082 fi
27083
27084 if test -d "$WIN_SDK_BASE"; then
27085 # There have been cases of partial or broken SDK installations. A missing
27086 # lib dir is not going to work.
27087 if test ! -d "$WIN_SDK_BASE/lib"; then
27088 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27089 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27090 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
27091 $as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
27092 elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
27093 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27094 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27095 VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
27096 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
27097 VS_ENV_ARGS="/x86"
27098 else
27099 VS_ENV_ARGS="/x64"
27100 fi
27101 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
27102 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
27103 # TODO: improve detection for other versions of SDK
27104 eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
27105 else
27106 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27107 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27108 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
27109 $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
27110 fi
27111 fi
27112 fi
27113
27114 fi
27115 if test "x$PROGRAMW6432" != x; then
27116
27117 if test "x$VS_ENV_CMD" = x; then
27118 VS_VERSION="${VS_VERSION}"
27119 WIN_SDK_BASE="$PROGRAMW6432/$SDK_INSTALL_DIR"
27120 METHOD="well-known name"
27121
27122 windows_path="$WIN_SDK_BASE"
27123 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27124 unix_path=`$CYGPATH -u "$windows_path"`
27125 WIN_SDK_BASE="$unix_path"
27126 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27127 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27128 WIN_SDK_BASE="$unix_path"
27129 fi
27130
27131 if test -d "$WIN_SDK_BASE"; then
27132 # There have been cases of partial or broken SDK installations. A missing
27133 # lib dir is not going to work.
27134 if test ! -d "$WIN_SDK_BASE/lib"; then
27135 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27136 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27137 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
27138 $as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
27139 elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
27140 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27141 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27142 VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
27143 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
27144 VS_ENV_ARGS="/x86"
27145 else
27146 VS_ENV_ARGS="/x64"
27147 fi
27148 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
27149 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
27150 # TODO: improve detection for other versions of SDK
27151 eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
27152 else
27153 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27154 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27155 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
27156 $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
27157 fi
27158 fi
27159 fi
27160
27161 fi
27162 if test "x$PROGRAMFILES" != x; then
27163
27164 if test "x$VS_ENV_CMD" = x; then
27165 VS_VERSION="${VS_VERSION}"
27166 WIN_SDK_BASE="$PROGRAMFILES/$SDK_INSTALL_DIR"
27167 METHOD="well-known name"
27168
27169 windows_path="$WIN_SDK_BASE"
27170 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27171 unix_path=`$CYGPATH -u "$windows_path"`
27172 WIN_SDK_BASE="$unix_path"
27173 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27174 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27175 WIN_SDK_BASE="$unix_path"
27176 fi
27177
27178 if test -d "$WIN_SDK_BASE"; then
27179 # There have been cases of partial or broken SDK installations. A missing
27180 # lib dir is not going to work.
27181 if test ! -d "$WIN_SDK_BASE/lib"; then
27182 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27183 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27184 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
27185 $as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
27186 elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
27187 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27188 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27189 VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
27190 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
27191 VS_ENV_ARGS="/x86"
27192 else
27193 VS_ENV_ARGS="/x64"
27194 fi
27195 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
27196 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
27197 # TODO: improve detection for other versions of SDK
27198 eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
27199 else
27200 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27201 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27202 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
27203 $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
27204 fi
27205 fi
27206 fi
27207
27208 fi
27209
27210 if test "x$VS_ENV_CMD" = x; then
27211 VS_VERSION="${VS_VERSION}"
27212 WIN_SDK_BASE="C:/Program Files/$SDK_INSTALL_DIR"
27213 METHOD="well-known name"
27214
27215 windows_path="$WIN_SDK_BASE"
27216 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27217 unix_path=`$CYGPATH -u "$windows_path"`
27218 WIN_SDK_BASE="$unix_path"
27219 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27220 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27221 WIN_SDK_BASE="$unix_path"
27222 fi
27223
27224 if test -d "$WIN_SDK_BASE"; then
27225 # There have been cases of partial or broken SDK installations. A missing
27226 # lib dir is not going to work.
27227 if test ! -d "$WIN_SDK_BASE/lib"; then
27228 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27229 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27230 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
27231 $as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
27232 elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
27233 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27234 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27235 VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
27236 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
27237 VS_ENV_ARGS="/x86"
27238 else
27239 VS_ENV_ARGS="/x64"
27240 fi
27241 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
27242 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
27243 # TODO: improve detection for other versions of SDK
27244 eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
27245 else
27246 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27247 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27248 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
27249 $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
27250 fi
27251 fi
27252 fi
27253
27254
27255 if test "x$VS_ENV_CMD" = x; then
27256 VS_VERSION="${VS_VERSION}"
27257 WIN_SDK_BASE="C:/Program Files (x86)/$SDK_INSTALL_DIR"
27258 METHOD="well-known name"
27259
27260 windows_path="$WIN_SDK_BASE"
27261 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27262 unix_path=`$CYGPATH -u "$windows_path"`
27263 WIN_SDK_BASE="$unix_path"
27264 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27265 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27266 WIN_SDK_BASE="$unix_path"
27267 fi
27268
27269 if test -d "$WIN_SDK_BASE"; then
27270 # There have been cases of partial or broken SDK installations. A missing
27271 # lib dir is not going to work.
27272 if test ! -d "$WIN_SDK_BASE/lib"; then
27273 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27274 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27275 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
27276 $as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
27277 elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
27278 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27279 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27280 VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
27281 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
27282 VS_ENV_ARGS="/x86"
27283 else
27284 VS_ENV_ARGS="/x64"
27285 fi
27286 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
27287 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
27288 # TODO: improve detection for other versions of SDK
27289 eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
27290 else
27291 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
27292 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
27293 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
27294 $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
27295 fi
27296 fi
27297 fi
27298
27299 fi
27300
27301 if test "x$VS_ENV_CMD" != x; then
27302 TOOLCHAIN_VERSION=$VS_VERSION
27303 eval VS_DESCRIPTION="\${VS_DESCRIPTION_${VS_VERSION}}"
27304 eval VS_VERSION_INTERNAL="\${VS_VERSION_INTERNAL_${VS_VERSION}}"
27305 eval MSVCR_NAME="\${VS_MSVCR_${VS_VERSION}}"
27306 eval MSVCP_NAME="\${VS_MSVCP_${VS_VERSION}}"
27307 # The rest of the variables are already evaled while probing
27308 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $VS_DESCRIPTION" >&5
27309 $as_echo "$as_me: Found $VS_DESCRIPTION" >&6;}
27310 break
27311 fi
27312 done
27313
27314
27315 if test "x$VS_ENV_CMD" != x; then
27316 # We have found a Visual Studio environment on disk, let's extract variables from the vsvars bat file.
27317
27318 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27319
27320 # First separate the path from the arguments. This will split at the first
27321 # space.
27322 complete="$VS_ENV_CMD"
27323 path="${complete%% *}"
27324 tmp="$complete EOL"
27325 arguments="${tmp#* }"
27326
27327 # Input might be given as Windows format, start by converting to
27328 # unix format.
27329 new_path=`$CYGPATH -u "$path"`
27330
27331 # Now try to locate executable using which
27332 new_path=`$WHICH "$new_path" 2> /dev/null`
27333 # bat and cmd files are not always considered executable in cygwin causing which
40954 # FIXME: These should just be removed!
40955 LDEXE="$LD"
40956 LDEXECXX="$LDCXX"
40957
40958
40959
40960
40961
40962
40963 # The package path is used only on macosx?
40964 # FIXME: clean this up, and/or move it elsewhere.
40965 PACKAGE_PATH=/opt/local
40966
40967
40968 # Check for extra potential brokenness.
40969 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
40970 # On Windows, double-check that we got the right compiler.
40971 CC_VERSION_OUTPUT=`$CC 2>&1 | $HEAD -n 1 | $TR -d '\r'`
40972 COMPILER_CPU_TEST=`$ECHO $CC_VERSION_OUTPUT | $SED -n "s/^.* \(.*\)$/\1/p"`
40973 if test "x$OPENJDK_TARGET_CPU" = "xx86"; then
40974 if test "x$COMPILER_CPU_TEST" != "x80x86" -a "x$COMPILER_CPU_TEST" != "xx86"; then
40975 as_fn_error $? "Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for \"$COMPILER_CPU_TEST\"; expected \"80x86\" or \"x86\"." "$LINENO" 5
40976 fi
40977 elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then
40978 if test "x$COMPILER_CPU_TEST" != "xx64"; then
40979 as_fn_error $? "Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for \"$COMPILER_CPU_TEST\"; expected \"x64\"." "$LINENO" 5
40980 fi
40981 fi
40982 fi
40983
40984 if test "x$TOOLCHAIN_TYPE" = xgcc; then
40985 # If this is a --hash-style=gnu system, use --hash-style=both, why?
40986 HAS_GNU_HASH=`$CC -dumpspecs 2>/dev/null | $GREP 'hash-style=gnu'`
40987 # This is later checked when setting flags.
40988
40989 # "-Og" suppported for GCC 4.8 and later
40990 CFLAG_OPTIMIZE_DEBUG_FLAG="-Og"
40991
40992 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if compiler supports \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"" >&5
40993 $as_echo_n "checking if compiler supports \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"... " >&6; }
40994 supports=yes
40995
42603 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
42604 ;;
42605 * )
42606 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
42607 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
42608 ;;
42609 esac
42610 elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
42611 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
42612 if test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
42613 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
42614 CFLAGS_JDK="$CFLAGS_JDK -erroff=E_BAD_PRAGMA_PACK_VALUE"
42615 fi
42616
42617 CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
42618 CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
42619 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
42620 CFLAGS_JDK="$CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
42621 CXXFLAGS_JDK="$CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
42622 elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
42623 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK \
42624 -Zi -MD -Zc:wchar_t- -W3 -wd4800 \
42625 -DWIN32_LEAN_AND_MEAN \
42626 -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
42627 -DWIN32 -DIAL"
42628 if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
42629 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_AMD64_ -Damd64"
42630 else
42631 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_X86_ -Dx86"
42632 fi
42633 # If building with Visual Studio 2010, we can still use _STATIC_CPPLIB to
42634 # avoid bundling msvcpNNN.dll. Doesn't work with newer versions of visual
42635 # studio.
42636 if test "x$TOOLCHAIN_VERSION" = "x2010"; then
42637 COMMON_CXXFLAGS_JDK="$COMMON_CXXFLAGS_JDK \
42638 -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB"
42639 fi
42640 fi
42641
42642 ###############################################################################
42643
42644 # Adjust flags according to debug level.
42645 case $DEBUG_LEVEL in
42646 fastdebug | slowdebug )
42647 CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS $CFLAGS_DEBUG_OPTIONS"
42648 CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS $CXXFLAGS_DEBUG_OPTIONS"
42649 JAVAC_FLAGS="$JAVAC_FLAGS -g"
42650 ;;
42651 release )
42652 ;;
42653 * )
42654 as_fn_error $? "Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL" "$LINENO" 5
42655 ;;
42656 esac
42657
42658 # Setup LP64
42659 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK $ADD_LP64"
49770 # TODO better (platform agnostic) test
49771 if test "x$OPENJDK_TARGET_OS" = xmacosx && test "x$LIBCXX" = x && test "x$TOOLCHAIN_TYPE" = xgcc; then
49772 LIBCXX="-lstdc++"
49773 fi
49774
49775
49776
49777
49778 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
49779
49780
49781 # Check whether --with-msvcr-dll was given.
49782 if test "${with_msvcr_dll+set}" = set; then :
49783 withval=$with_msvcr_dll;
49784 fi
49785
49786
49787 if test "x$with_msvcr_dll" != x; then
49788 # If given explicitely by user, do not probe. If not present, fail directly.
49789
49790 DLL_NAME="$DLL_NAME"
49791 POSSIBLE_MSVC_DLL="$with_msvcr_dll"
49792 METHOD="--with-msvcr-dll"
49793 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
49794 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
49795 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
49796
49797 # Need to check if the found msvcr is correct architecture
49798 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
49799 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
49800 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
49801 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49802 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49803 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49804 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49805 CORRECT_MSVCR_ARCH="PE32 executable"
49806 else
49807 CORRECT_MSVCR_ARCH="PE32+ executable"
49808 fi
49809 else
49810 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49811 CORRECT_MSVCR_ARCH=386
49812 else
49813 CORRECT_MSVCR_ARCH=x86-64
49814 fi
49815 fi
49816 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49817 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49818 $as_echo "ok" >&6; }
49819 MSVC_DLL="$POSSIBLE_MSVC_DLL"
49820 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
49821 $as_echo_n "checking for $DLL_NAME... " >&6; }
49822 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
49823 $as_echo "$MSVC_DLL" >&6; }
49824 else
49825 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49826 $as_echo "incorrect, ignoring" >&6; }
49827 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
49828 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
49829 fi
49830 fi
49831
49832 if test "x$MSVC_DLL" = x; then
49833 as_fn_error $? "Could not find a proper $MSVCR_NAME as specified by --with-msvcr-dll" "$LINENO" 5
49834 fi
49835 else
49836
49837 VAR_NAME="MSVCR_DLL"
49838 DLL_NAME="${MSVCR_NAME}"
49839 MSVC_DLL=
49840
49841 if test "x$MSVC_DLL" = x; then
49842 # Probe: Using well-known location from Visual Studio 10.0
49843 if test "x$VCINSTALLDIR" != x; then
49844 CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR"
49845
49846 windows_path="$CYGWIN_VC_INSTALL_DIR"
49847 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49848 unix_path=`$CYGPATH -u "$windows_path"`
49849 CYGWIN_VC_INSTALL_DIR="$unix_path"
49850 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49851 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49852 CYGWIN_VC_INSTALL_DIR="$unix_path"
49853 fi
49854
49855 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
49856 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x64/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
49857 else
49858 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x86/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
49859 fi
49860 $ECHO "POSSIBLE_MSVC_DLL $POSSIBLEMSVC_DLL"
49861
49862 DLL_NAME="$DLL_NAME"
49863 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
49864 METHOD="well-known location in VCINSTALLDIR"
49865 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
49866 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
49867 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
49868
49869 # Need to check if the found msvcr is correct architecture
49870 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
49871 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
49872 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
49873 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49874 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49875 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49876 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49877 CORRECT_MSVCR_ARCH="PE32 executable"
49878 else
49879 CORRECT_MSVCR_ARCH="PE32+ executable"
49880 fi
49881 else
49882 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49883 CORRECT_MSVCR_ARCH=386
49884 else
49885 CORRECT_MSVCR_ARCH=x86-64
49886 fi
49887 fi
49888 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49889 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49890 $as_echo "ok" >&6; }
49891 MSVC_DLL="$POSSIBLE_MSVC_DLL"
49892 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
49893 $as_echo_n "checking for $DLL_NAME... " >&6; }
49894 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
49895 $as_echo "$MSVC_DLL" >&6; }
49896 else
49897 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49898 $as_echo "incorrect, ignoring" >&6; }
49899 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
49900 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
49901 fi
49902 fi
49903
49904 fi
49905 fi
49906
49907 if test "x$MSVC_DLL" = x; then
49908 # Probe: Check in the Boot JDK directory.
49909 POSSIBLE_MSVC_DLL="$BOOT_JDK/bin/$DLL_NAME"
49910
49911 DLL_NAME="$DLL_NAME"
49912 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
49913 METHOD="well-known location in Boot JDK"
49914 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
49915 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
49916 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
49917
49918 # Need to check if the found msvcr is correct architecture
49919 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
49920 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
49921 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
49922 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49923 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49924 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49925 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49926 CORRECT_MSVCR_ARCH="PE32 executable"
49927 else
49928 CORRECT_MSVCR_ARCH="PE32+ executable"
49929 fi
49930 else
49931 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49932 CORRECT_MSVCR_ARCH=386
49933 else
49934 CORRECT_MSVCR_ARCH=x86-64
49935 fi
49936 fi
49937 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49938 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49939 $as_echo "ok" >&6; }
49940 MSVC_DLL="$POSSIBLE_MSVC_DLL"
49941 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
49942 $as_echo_n "checking for $DLL_NAME... " >&6; }
49943 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
49944 $as_echo "$MSVC_DLL" >&6; }
49945 else
49946 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49947 $as_echo "incorrect, ignoring" >&6; }
49948 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
49949 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
49950 fi
49951 fi
49952
49953 fi
49954
49955 if test "x$MSVC_DLL" = x; then
49956 # Probe: Look in the Windows system32 directory
49957 CYGWIN_SYSTEMROOT="$SYSTEMROOT"
49958
49959 windows_path="$CYGWIN_SYSTEMROOT"
49960 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49961 unix_path=`$CYGPATH -u "$windows_path"`
49962 CYGWIN_SYSTEMROOT="$unix_path"
49963 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49964 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49965 CYGWIN_SYSTEMROOT="$unix_path"
49966 fi
49967
49968 POSSIBLE_MSVC_DLL="$CYGWIN_SYSTEMROOT/system32/$DLL_NAME"
49969
49970 DLL_NAME="$DLL_NAME"
49971 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
49972 METHOD="well-known location in SYSTEMROOT"
49973 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
49974 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
49975 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
49976
49977 # Need to check if the found msvcr is correct architecture
49978 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
49979 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
49980 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
49981 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49982 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49983 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49984 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49985 CORRECT_MSVCR_ARCH="PE32 executable"
49986 else
49987 CORRECT_MSVCR_ARCH="PE32+ executable"
49988 fi
49989 else
49990 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49991 CORRECT_MSVCR_ARCH=386
49992 else
49993 CORRECT_MSVCR_ARCH=x86-64
49994 fi
49995 fi
49996 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49997 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49998 $as_echo "ok" >&6; }
49999 MSVC_DLL="$POSSIBLE_MSVC_DLL"
50000 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
50001 $as_echo_n "checking for $DLL_NAME... " >&6; }
50002 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
50003 $as_echo "$MSVC_DLL" >&6; }
50004 else
50005 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
50006 $as_echo "incorrect, ignoring" >&6; }
50007 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
50008 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
50009 fi
50010 fi
50011
50012 fi
50013
50014 if test "x$MSVC_DLL" = x; then
50015 # Probe: If Visual Studio Express is installed, there is usually one with the debugger
50016 if test "x$VS100COMNTOOLS" != x; then
50017 CYGWIN_VS_TOOLS_DIR="$VS100COMNTOOLS/.."
50018
50019 windows_path="$CYGWIN_VS_TOOLS_DIR"
50020 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
50021 unix_path=`$CYGPATH -u "$windows_path"`
50022 CYGWIN_VS_TOOLS_DIR="$unix_path"
50023 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50024 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
50025 CYGWIN_VS_TOOLS_DIR="$unix_path"
50026 fi
50027
50028 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
50029 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
50030 | $GREP -i /x64/ | $HEAD --lines 1`
50031 else
50032 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
50033 | $GREP -i /x86/ | $HEAD --lines 1`
50034 fi
50035
50036 DLL_NAME="$DLL_NAME"
50037 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
50038 METHOD="search of VS100COMNTOOLS"
50039 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
50040 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
50041 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
50042
50043 # Need to check if the found msvcr is correct architecture
50044 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
50045 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
50046 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
50047 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50048 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
50049 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
50050 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50051 CORRECT_MSVCR_ARCH="PE32 executable"
50052 else
50053 CORRECT_MSVCR_ARCH="PE32+ executable"
50054 fi
50055 else
50056 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50057 CORRECT_MSVCR_ARCH=386
50058 else
50059 CORRECT_MSVCR_ARCH=x86-64
50060 fi
50061 fi
50062 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
50063 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
50064 $as_echo "ok" >&6; }
50065 MSVC_DLL="$POSSIBLE_MSVC_DLL"
50066 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
50067 $as_echo_n "checking for $DLL_NAME... " >&6; }
50068 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
50069 $as_echo "$MSVC_DLL" >&6; }
50070 else
50071 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
50072 $as_echo "incorrect, ignoring" >&6; }
50073 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
50074 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
50075 fi
50076 fi
50077
50078 fi
50079 fi
50080
50081 if test "x$MSVC_DLL" = x; then
50082 # Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now.
50083 # (This was the original behaviour; kept since it might turn something up)
50084 if test "x$CYGWIN_VC_INSTALL_DIR" != x; then
50085 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
50086 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
50087 | $GREP x64 | $HEAD --lines 1`
50088 else
50089 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
50090 | $GREP x86 | $GREP -v ia64 | $GREP -v x64 | $HEAD --lines 1`
50091 if test "x$POSSIBLE_MSVC_DLL" = x; then
50092 # We're grasping at straws now...
50093 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
50094 | $HEAD --lines 1`
50095 fi
50096 fi
50097
50098
50099 DLL_NAME="$DLL_NAME"
50100 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
50101 METHOD="search of VCINSTALLDIR"
50102 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
50103 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
50104 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
50105
50106 # Need to check if the found msvcr is correct architecture
50107 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
50108 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
50109 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
50110 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50111 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
50112 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
50113 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50114 CORRECT_MSVCR_ARCH="PE32 executable"
50115 else
50116 CORRECT_MSVCR_ARCH="PE32+ executable"
50117 fi
50118 else
50119 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50120 CORRECT_MSVCR_ARCH=386
50121 else
50122 CORRECT_MSVCR_ARCH=x86-64
50123 fi
50124 fi
50125 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
50126 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
50127 $as_echo "ok" >&6; }
50128 MSVC_DLL="$POSSIBLE_MSVC_DLL"
50129 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
50130 $as_echo_n "checking for $DLL_NAME... " >&6; }
50131 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
50132 $as_echo "$MSVC_DLL" >&6; }
50133 else
50134 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
50135 $as_echo "incorrect, ignoring" >&6; }
50136 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
50137 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
50138 fi
50139 fi
50140
50141 fi
50142 fi
50143
50144 if test "x$MSVC_DLL" = x; then
50145 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
50146 $as_echo_n "checking for $DLL_NAME... " >&6; }
50147 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
50148 $as_echo "no" >&6; }
50149 as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5
50150 fi
50151
50152 MSVCR_DLL=$MSVC_DLL
50153
50154 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
50155
50156 # Input might be given as Windows format, start by converting to
50157 # unix format.
50158 path="$MSVCR_DLL"
50159 new_path=`$CYGPATH -u "$path"`
50160
50161 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
50162 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
50163 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
50164 # "foo.exe" is OK but "foo" is an error.
50165 #
50166 # This test is therefore slightly more accurate than "test -f" to check for file precense.
50167 # It is also a way to make sure we got the proper file name for the real test later on.
50168 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
50169 if test "x$test_shortpath" = x; then
50170 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&5
50171 $as_echo "$as_me: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&6;}
50172 as_fn_error $? "Cannot locate the the path of MSVCR_DLL" "$LINENO" 5
50255
50256 else
50257 # We're on a unix platform. Hooray! :)
50258 path="$MSVCR_DLL"
50259 has_space=`$ECHO "$path" | $GREP " "`
50260 if test "x$has_space" != x; then
50261 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&5
50262 $as_echo "$as_me: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&6;}
50263 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
50264 fi
50265
50266 # Use eval to expand a potential ~
50267 eval path="$path"
50268 if test ! -f "$path" && test ! -d "$path"; then
50269 as_fn_error $? "The path of MSVCR_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
50270 fi
50271
50272 MSVCR_DLL="`cd "$path"; $THEPWDCMD -L`"
50273 fi
50274
50275 MSVCR_DLL=$MSVCR_DLL
50276
50277
50278 fi
50279
50280
50281 # Check whether --with-msvcp-dll was given.
50282 if test "${with_msvcp_dll+set}" = set; then :
50283 withval=$with_msvcp_dll;
50284 fi
50285
50286
50287 if test "x$MSVCP_NAME" != "x"; then
50288 if test "x$with_msvcp_dll" != x; then
50289 # If given explicitely by user, do not probe. If not present, fail directly.
50290
50291 DLL_NAME="$DLL_NAME"
50292 POSSIBLE_MSVC_DLL="$with_msvcp_dll"
50293 METHOD="--with-msvcp-dll"
50294 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
50295 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
50296 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
50297
50298 # Need to check if the found msvcr is correct architecture
50299 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
50300 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
50301 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
50302 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50303 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
50304 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
50305 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50306 CORRECT_MSVCR_ARCH="PE32 executable"
50307 else
50308 CORRECT_MSVCR_ARCH="PE32+ executable"
50309 fi
50310 else
50311 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50312 CORRECT_MSVCR_ARCH=386
50313 else
50314 CORRECT_MSVCR_ARCH=x86-64
50315 fi
50316 fi
50317 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
50318 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
50319 $as_echo "ok" >&6; }
50320 MSVC_DLL="$POSSIBLE_MSVC_DLL"
50321 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
50322 $as_echo_n "checking for $DLL_NAME... " >&6; }
50323 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
50324 $as_echo "$MSVC_DLL" >&6; }
50325 else
50326 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
50327 $as_echo "incorrect, ignoring" >&6; }
50328 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
50329 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
50330 fi
50331 fi
50332
50333 if test "x$MSVC_DLL" = x; then
50334 as_fn_error $? "Could not find a proper $MSVCP_NAME as specified by --with-msvcp-dll" "$LINENO" 5
50335 fi
50336 else
50337
50338 VAR_NAME="MSVCP_DLL"
50339 DLL_NAME="${MSVCP_NAME}"
50340 MSVC_DLL=
50341
50342 if test "x$MSVC_DLL" = x; then
50343 # Probe: Using well-known location from Visual Studio 10.0
50344 if test "x$VCINSTALLDIR" != x; then
50345 CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR"
50346
50347 windows_path="$CYGWIN_VC_INSTALL_DIR"
50348 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
50349 unix_path=`$CYGPATH -u "$windows_path"`
50350 CYGWIN_VC_INSTALL_DIR="$unix_path"
50351 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50352 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
50353 CYGWIN_VC_INSTALL_DIR="$unix_path"
50354 fi
50355
50356 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
50357 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x64/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
50358 else
50359 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x86/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
50360 fi
50361 $ECHO "POSSIBLE_MSVC_DLL $POSSIBLEMSVC_DLL"
50362
50363 DLL_NAME="$DLL_NAME"
50364 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
50365 METHOD="well-known location in VCINSTALLDIR"
50366 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
50367 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
50368 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
50369
50370 # Need to check if the found msvcr is correct architecture
50371 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
50372 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
50373 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
50374 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50375 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
50376 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
50377 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50378 CORRECT_MSVCR_ARCH="PE32 executable"
50379 else
50380 CORRECT_MSVCR_ARCH="PE32+ executable"
50381 fi
50382 else
50383 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50384 CORRECT_MSVCR_ARCH=386
50385 else
50386 CORRECT_MSVCR_ARCH=x86-64
50387 fi
50388 fi
50389 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
50390 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
50391 $as_echo "ok" >&6; }
50392 MSVC_DLL="$POSSIBLE_MSVC_DLL"
50393 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
50394 $as_echo_n "checking for $DLL_NAME... " >&6; }
50395 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
50396 $as_echo "$MSVC_DLL" >&6; }
50397 else
50398 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
50399 $as_echo "incorrect, ignoring" >&6; }
50400 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
50401 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
50402 fi
50403 fi
50404
50405 fi
50406 fi
50407
50408 if test "x$MSVC_DLL" = x; then
50409 # Probe: Check in the Boot JDK directory.
50410 POSSIBLE_MSVC_DLL="$BOOT_JDK/bin/$DLL_NAME"
50411
50412 DLL_NAME="$DLL_NAME"
50413 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
50414 METHOD="well-known location in Boot JDK"
50415 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
50416 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
50417 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
50418
50419 # Need to check if the found msvcr is correct architecture
50420 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
50421 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
50422 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
50423 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50424 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
50425 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
50426 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50427 CORRECT_MSVCR_ARCH="PE32 executable"
50428 else
50429 CORRECT_MSVCR_ARCH="PE32+ executable"
50430 fi
50431 else
50432 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50433 CORRECT_MSVCR_ARCH=386
50434 else
50435 CORRECT_MSVCR_ARCH=x86-64
50436 fi
50437 fi
50438 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
50439 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
50440 $as_echo "ok" >&6; }
50441 MSVC_DLL="$POSSIBLE_MSVC_DLL"
50442 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
50443 $as_echo_n "checking for $DLL_NAME... " >&6; }
50444 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
50445 $as_echo "$MSVC_DLL" >&6; }
50446 else
50447 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
50448 $as_echo "incorrect, ignoring" >&6; }
50449 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
50450 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
50451 fi
50452 fi
50453
50454 fi
50455
50456 if test "x$MSVC_DLL" = x; then
50457 # Probe: Look in the Windows system32 directory
50458 CYGWIN_SYSTEMROOT="$SYSTEMROOT"
50459
50460 windows_path="$CYGWIN_SYSTEMROOT"
50461 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
50462 unix_path=`$CYGPATH -u "$windows_path"`
50463 CYGWIN_SYSTEMROOT="$unix_path"
50464 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50465 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
50466 CYGWIN_SYSTEMROOT="$unix_path"
50467 fi
50468
50469 POSSIBLE_MSVC_DLL="$CYGWIN_SYSTEMROOT/system32/$DLL_NAME"
50470
50471 DLL_NAME="$DLL_NAME"
50472 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
50473 METHOD="well-known location in SYSTEMROOT"
50474 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
50475 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
50476 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
50477
50478 # Need to check if the found msvcr is correct architecture
50479 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
50480 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
50481 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
50482 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50483 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
50484 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
50485 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50486 CORRECT_MSVCR_ARCH="PE32 executable"
50487 else
50488 CORRECT_MSVCR_ARCH="PE32+ executable"
50489 fi
50490 else
50491 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50492 CORRECT_MSVCR_ARCH=386
50493 else
50494 CORRECT_MSVCR_ARCH=x86-64
50495 fi
50496 fi
50497 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
50498 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
50499 $as_echo "ok" >&6; }
50500 MSVC_DLL="$POSSIBLE_MSVC_DLL"
50501 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
50502 $as_echo_n "checking for $DLL_NAME... " >&6; }
50503 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
50504 $as_echo "$MSVC_DLL" >&6; }
50505 else
50506 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
50507 $as_echo "incorrect, ignoring" >&6; }
50508 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
50509 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
50510 fi
50511 fi
50512
50513 fi
50514
50515 if test "x$MSVC_DLL" = x; then
50516 # Probe: If Visual Studio Express is installed, there is usually one with the debugger
50517 if test "x$VS100COMNTOOLS" != x; then
50518 CYGWIN_VS_TOOLS_DIR="$VS100COMNTOOLS/.."
50519
50520 windows_path="$CYGWIN_VS_TOOLS_DIR"
50521 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
50522 unix_path=`$CYGPATH -u "$windows_path"`
50523 CYGWIN_VS_TOOLS_DIR="$unix_path"
50524 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50525 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
50526 CYGWIN_VS_TOOLS_DIR="$unix_path"
50527 fi
50528
50529 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
50530 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
50531 | $GREP -i /x64/ | $HEAD --lines 1`
50532 else
50533 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
50534 | $GREP -i /x86/ | $HEAD --lines 1`
50535 fi
50536
50537 DLL_NAME="$DLL_NAME"
50538 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
50539 METHOD="search of VS100COMNTOOLS"
50540 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
50541 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
50542 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
50543
50544 # Need to check if the found msvcr is correct architecture
50545 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
50546 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
50547 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
50548 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50549 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
50550 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
50551 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50552 CORRECT_MSVCR_ARCH="PE32 executable"
50553 else
50554 CORRECT_MSVCR_ARCH="PE32+ executable"
50555 fi
50556 else
50557 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50558 CORRECT_MSVCR_ARCH=386
50559 else
50560 CORRECT_MSVCR_ARCH=x86-64
50561 fi
50562 fi
50563 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
50564 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
50565 $as_echo "ok" >&6; }
50566 MSVC_DLL="$POSSIBLE_MSVC_DLL"
50567 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
50568 $as_echo_n "checking for $DLL_NAME... " >&6; }
50569 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
50570 $as_echo "$MSVC_DLL" >&6; }
50571 else
50572 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
50573 $as_echo "incorrect, ignoring" >&6; }
50574 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
50575 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
50576 fi
50577 fi
50578
50579 fi
50580 fi
50581
50582 if test "x$MSVC_DLL" = x; then
50583 # Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now.
50584 # (This was the original behaviour; kept since it might turn something up)
50585 if test "x$CYGWIN_VC_INSTALL_DIR" != x; then
50586 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
50587 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
50588 | $GREP x64 | $HEAD --lines 1`
50589 else
50590 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
50591 | $GREP x86 | $GREP -v ia64 | $GREP -v x64 | $HEAD --lines 1`
50592 if test "x$POSSIBLE_MSVC_DLL" = x; then
50593 # We're grasping at straws now...
50594 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
50595 | $HEAD --lines 1`
50596 fi
50597 fi
50598
50599
50600 DLL_NAME="$DLL_NAME"
50601 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
50602 METHOD="search of VCINSTALLDIR"
50603 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
50604 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
50605 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
50606
50607 # Need to check if the found msvcr is correct architecture
50608 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
50609 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
50610 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
50611 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50612 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
50613 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
50614 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50615 CORRECT_MSVCR_ARCH="PE32 executable"
50616 else
50617 CORRECT_MSVCR_ARCH="PE32+ executable"
50618 fi
50619 else
50620 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50621 CORRECT_MSVCR_ARCH=386
50622 else
50623 CORRECT_MSVCR_ARCH=x86-64
50624 fi
50625 fi
50626 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
50627 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
50628 $as_echo "ok" >&6; }
50629 MSVC_DLL="$POSSIBLE_MSVC_DLL"
50630 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
50631 $as_echo_n "checking for $DLL_NAME... " >&6; }
50632 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
50633 $as_echo "$MSVC_DLL" >&6; }
50634 else
50635 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
50636 $as_echo "incorrect, ignoring" >&6; }
50637 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
50638 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
50639 fi
50640 fi
50641
50642 fi
50643 fi
50644
50645 if test "x$MSVC_DLL" = x; then
50646 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
50647 $as_echo_n "checking for $DLL_NAME... " >&6; }
50648 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
50649 $as_echo "no" >&6; }
50650 as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5
50651 fi
50652
50653 MSVCP_DLL=$MSVC_DLL
50654
50655 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
50656
50657 # Input might be given as Windows format, start by converting to
50658 # unix format.
50659 path="$MSVCP_DLL"
50660 new_path=`$CYGPATH -u "$path"`
50661
50662 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
50663 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
50664 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
50665 # "foo.exe" is OK but "foo" is an error.
50666 #
50667 # This test is therefore slightly more accurate than "test -f" to check for file precense.
50668 # It is also a way to make sure we got the proper file name for the real test later on.
50669 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
50670 if test "x$test_shortpath" = x; then
50671 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCP_DLL, which resolves as \"$path\", is invalid." >&5
50672 $as_echo "$as_me: The path of MSVCP_DLL, which resolves as \"$path\", is invalid." >&6;}
50673 as_fn_error $? "Cannot locate the the path of MSVCP_DLL" "$LINENO" 5
50674 fi
50675
50676 # Call helper function which possibly converts this using DOS-style short mode.
50677 # If so, the updated path is stored in $new_path.
50678
50679 input_path="$new_path"
50680 # Check if we need to convert this using DOS-style short mode. If the path
50681 # contains just simple characters, use it. Otherwise (spaces, weird characters),
50682 # take no chances and rewrite it.
50683 # Note: m4 eats our [], so we need to use [ and ] instead.
50684 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
50685 if test "x$has_forbidden_chars" != x; then
50686 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
50687 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
50688 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
50689 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
50690 # Going to short mode and back again did indeed matter. Since short mode is
50691 # case insensitive, let's make it lowercase to improve readability.
50692 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
50693 # Now convert it back to Unix-stile (cygpath)
50694 input_path=`$CYGPATH -u "$shortmode_path"`
50695 new_path="$input_path"
50696 fi
50697 fi
50698
50699 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
50700 if test "x$test_cygdrive_prefix" = x; then
50701 # As a simple fix, exclude /usr/bin since it's not a real path.
50702 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
50703 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
50704 # a path prefixed by /cygdrive for fixpath to work.
50705 new_path="$CYGWIN_ROOT_PATH$input_path"
50706 fi
50707 fi
50708
50709
50710 if test "x$path" != "x$new_path"; then
50711 MSVCP_DLL="$new_path"
50712 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVCP_DLL to \"$new_path\"" >&5
50713 $as_echo "$as_me: Rewriting MSVCP_DLL to \"$new_path\"" >&6;}
50714 fi
50715
50716 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50717
50718 path="$MSVCP_DLL"
50719 has_colon=`$ECHO $path | $GREP ^.:`
50720 new_path="$path"
50721 if test "x$has_colon" = x; then
50722 # Not in mixed or Windows style, start by that.
50723 new_path=`cmd //c echo $path`
50724 fi
50725
50726
50727 input_path="$new_path"
50728 # Check if we need to convert this using DOS-style short mode. If the path
50729 # contains just simple characters, use it. Otherwise (spaces, weird characters),
50730 # take no chances and rewrite it.
50731 # Note: m4 eats our [], so we need to use [ and ] instead.
50732 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
50733 if test "x$has_forbidden_chars" != x; then
50734 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
50735 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
50736 fi
50737
50738
50739 windows_path="$new_path"
50740 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
50741 unix_path=`$CYGPATH -u "$windows_path"`
50742 new_path="$unix_path"
50743 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50744 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
50745 new_path="$unix_path"
50746 fi
50747
50748 if test "x$path" != "x$new_path"; then
50749 MSVCP_DLL="$new_path"
50750 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVCP_DLL to \"$new_path\"" >&5
50751 $as_echo "$as_me: Rewriting MSVCP_DLL to \"$new_path\"" >&6;}
50752 fi
50753
50754 # Save the first 10 bytes of this path to the storage, so fixpath can work.
50755 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
50756
50757 else
50758 # We're on a unix platform. Hooray! :)
50759 path="$MSVCP_DLL"
50760 has_space=`$ECHO "$path" | $GREP " "`
50761 if test "x$has_space" != x; then
50762 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCP_DLL, which resolves as \"$path\", is invalid." >&5
50763 $as_echo "$as_me: The path of MSVCP_DLL, which resolves as \"$path\", is invalid." >&6;}
50764 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
50765 fi
50766
50767 # Use eval to expand a potential ~
50768 eval path="$path"
50769 if test ! -f "$path" && test ! -d "$path"; then
50770 as_fn_error $? "The path of MSVCP_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
50771 fi
50772
50773 MSVCP_DLL="`cd "$path"; $THEPWDCMD -L`"
50774 fi
50775
50776 MSVCP_DLL=$MSVCP_DLL
50777
50778
50779 fi
50780 fi
50781
50782
50783
50784 # Check whether --with-dxsdk was given.
50785 if test "${with_dxsdk+set}" = set; then :
50786 withval=$with_dxsdk; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&5
50787 $as_echo "$as_me: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&2;}
50788 fi
50789
50790
50791
50792
50793 # Check whether --with-dxsdk-lib was given.
50794 if test "${with_dxsdk_lib+set}" = set; then :
50795 withval=$with_dxsdk_lib; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&5
50796 $as_echo "$as_me: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&2;}
50797 fi
50798
50799
50800
50801
50802 # Check whether --with-dxsdk-include was given.
50803 if test "${with_dxsdk_include+set}" = set; then :
50804 withval=$with_dxsdk_include; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&5
50805 $as_echo "$as_me: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&2;}
50806 fi
50807
50808
50809 fi
50810
50811
50812 ###############################################################################
50813 #
50814 # We need to do some final tweaking, when everything else is done.
50815 #
50816 ###############################################################################
50817
50818
50819 HOTSPOT_MAKE_ARGS="$HOTSPOT_TARGET"
50820
50821
50822 # The name of the Service Agent jar.
50823 SALIB_NAME="${LIBRARY_PREFIX}saproc${SHARED_LIBRARY_SUFFIX}"
50824 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
50825 SALIB_NAME="${LIBRARY_PREFIX}sawindbg${SHARED_LIBRARY_SUFFIX}"
50826 fi
50827
50828
50829
50830 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if elliptic curve crypto implementation is present" >&5
50831 $as_echo_n "checking if elliptic curve crypto implementation is present... " >&6; }
52918 if test "x$CONFIGURE_COMMAND_LINE" != x; then
52919 printf "using configure arguments '$CONFIGURE_COMMAND_LINE'.\n"
52920 else
52921 printf "using default settings.\n"
52922 fi
52923
52924 printf "\n"
52925 printf "Configuration summary:\n"
52926 printf "* Debug level: $DEBUG_LEVEL\n"
52927 printf "* HS debug level: $HOTSPOT_DEBUG_LEVEL\n"
52928 printf "* JDK variant: $JDK_VARIANT\n"
52929 printf "* JVM variants: $with_jvm_variants\n"
52930 printf "* OpenJDK target: OS: $OPENJDK_TARGET_OS, CPU architecture: $OPENJDK_TARGET_CPU_ARCH, address length: $OPENJDK_TARGET_CPU_BITS\n"
52931
52932 printf "\n"
52933 printf "Tools summary:\n"
52934 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
52935 printf "* Environment: $WINDOWS_ENV_VENDOR version $WINDOWS_ENV_VERSION (root at $WINDOWS_ENV_ROOT_PATH)\n"
52936 fi
52937 printf "* Boot JDK: $BOOT_JDK_VERSION (at $BOOT_JDK)\n"
52938 if test "x$TOOLCHAIN_VERSION" != "x"; then
52939 print_version=" $TOOLCHAIN_VERSION"
52940 fi
52941 printf "* Toolchain: $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION$print_version)\n"
52942 printf "* C Compiler: Version $CC_VERSION_NUMBER (at $CC)\n"
52943 printf "* C++ Compiler: Version $CXX_VERSION_NUMBER (at $CXX)\n"
52944
52945 printf "\n"
52946 printf "Build performance summary:\n"
52947 printf "* Cores to use: $JOBS\n"
52948 printf "* Memory limit: $MEMORY_SIZE MB\n"
52949 if test "x$CCACHE_STATUS" != "x"; then
52950 printf "* ccache status: $CCACHE_STATUS\n"
52951 fi
52952 printf "\n"
52953
52954 if test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = "xyes"; then
52955 printf "NOTE: You have requested to build more than one version of the JVM, which\n"
52956 printf "will result in longer build times.\n"
52957 printf "\n"
52958 fi
52959
52960 if test "x$FOUND_ALT_VARIABLES" != "x"; then
52961 printf "WARNING: You have old-style ALT_ environment variables set.\n"
|