< prev index next >

common/autoconf/generated-configure.sh

Print this page




 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"


< prev index next >