900 TOPDIR
901 PATH_SEP
902 ZERO_ARCHDEF
903 DEFINE_CROSS_COMPILE_ARCH
904 LP64
905 OPENJDK_TARGET_OS_EXPORT_DIR
906 OPENJDK_TARGET_OS_API_DIR
907 OPENJDK_TARGET_CPU_JLI_CFLAGS
908 OPENJDK_TARGET_CPU_OSARCH
909 OPENJDK_TARGET_CPU_ISADIR
910 OPENJDK_TARGET_CPU_LIBDIR
911 OPENJDK_TARGET_CPU_LEGACY_LIB
912 OPENJDK_TARGET_CPU_LEGACY
913 REQUIRED_OS_VERSION
914 REQUIRED_OS_NAME
915 COMPILE_TYPE
916 OPENJDK_TARGET_CPU_ENDIAN
917 OPENJDK_TARGET_CPU_BITS
918 OPENJDK_TARGET_CPU_ARCH
919 OPENJDK_TARGET_CPU
920 OPENJDK_TARGET_OS_API
921 OPENJDK_TARGET_OS
922 OPENJDK_BUILD_CPU_ENDIAN
923 OPENJDK_BUILD_CPU_BITS
924 OPENJDK_BUILD_CPU_ARCH
925 OPENJDK_BUILD_CPU
926 OPENJDK_BUILD_OS_API
927 OPENJDK_BUILD_OS
928 OPENJDK_BUILD_AUTOCONF_NAME
929 OPENJDK_TARGET_AUTOCONF_NAME
930 target_os
931 target_vendor
932 target_cpu
933 target
934 host_os
935 host_vendor
936 host_cpu
937 host
938 build_os
939 build_vendor
940 build_cpu
941 build
942 SETFILE
943 DF
944 READLINK
945 CYGPATH
946 SED
947 FGREP
948 EGREP
949 GREP
950 AWK
951 XARGS
952 WHICH
953 WC
954 UNIQ
955 UNAME
956 TR
957 TOUCH
958 TEE
959 TAR
960 TAIL
961 SORT
962 SH
963 RM
964 PRINTF
965 NAWK
966 MV
967 MKTEMP
968 MKDIR
969 LS
970 LN
971 HEAD
972 FIND
973 FILE
974 EXPR
975 ECHO
976 DIRNAME
977 DIFF
978 DATE
979 CUT
980 CPIO
981 CP
982 COMM
983 CMP
984 CHMOD
985 CAT
986 BASH
987 BASENAME
988 DATE_WHEN_CONFIGURED
989 CONFIGURE_COMMAND_LINE
990 target_alias
991 host_alias
992 build_alias
993 LIBS
994 ECHO_T
995 ECHO_N
996 ECHO_C
997 DEFS
998 mandir
999 localedir
1000 libdir
1099 with_dxsdk_include
1100 with_num_cores
1101 with_memory_size
1102 with_jobs
1103 with_sjavac_server_java
1104 enable_sjavac
1105 enable_precompiled_headers
1106 enable_ccache
1107 with_ccache_dir
1108 '
1109 ac_precious_vars='build_alias
1110 host_alias
1111 target_alias
1112 BASENAME
1113 BASH
1114 CAT
1115 CHMOD
1116 CMP
1117 COMM
1118 CP
1119 CPIO
1120 CUT
1121 DATE
1122 DIFF
1123 DIRNAME
1124 ECHO
1125 EXPR
1126 FILE
1127 FIND
1128 HEAD
1129 LN
1130 LS
1131 MKDIR
1132 MKTEMP
1133 MV
1134 NAWK
1135 PRINTF
1136 RM
1137 SH
1138 SORT
1139 TAIL
1140 TAR
1141 TEE
1142 TOUCH
1143 TR
1144 UNAME
1145 UNIQ
1146 WC
1147 WHICH
1148 XARGS
1149 AWK
1150 GREP
1151 EGREP
1152 FGREP
1153 SED
1154 CYGPATH
1155 READLINK
1156 DF
1157 SETFILE
1158 UNZIP
1159 ZIP
1160 LDD
1161 OTOOL
1162 READELF
1163 HG
1164 STAT
1165 TIME
1166 DSYMUTIL
1167 XATTR
1168 CODESIGN
1169 PKG_CONFIG
1170 JAVA
1171 JAVAC
1172 JAVAH
1173 JAR
1174 NATIVE2ASCII
1175 JARSIGNER
1176 CC
1177 CFLAGS
1967 compatibility and is ignored
1968 --with-num-cores number of cores in the build system, e.g.
1969 --with-num-cores=8 [probed]
1970 --with-memory-size memory (in MB) available in the build system, e.g.
1971 --with-memory-size=1024 [probed]
1972 --with-jobs number of parallel jobs to let make run [calculated
1973 based on cores and memory]
1974 --with-sjavac-server-java
1975 use this java binary for running the sjavac
1976 background server [Boot JDK java]
1977 --with-ccache-dir where to store ccache files [~/.ccache]
1978
1979 Some influential environment variables:
1980 BASENAME Override default value for BASENAME
1981 BASH Override default value for BASH
1982 CAT Override default value for CAT
1983 CHMOD Override default value for CHMOD
1984 CMP Override default value for CMP
1985 COMM Override default value for COMM
1986 CP Override default value for CP
1987 CPIO Override default value for CPIO
1988 CUT Override default value for CUT
1989 DATE Override default value for DATE
1990 DIFF Override default value for DIFF
1991 DIRNAME Override default value for DIRNAME
1992 ECHO Override default value for ECHO
1993 EXPR Override default value for EXPR
1994 FILE Override default value for FILE
1995 FIND Override default value for FIND
1996 HEAD Override default value for HEAD
1997 LN Override default value for LN
1998 LS Override default value for LS
1999 MKDIR Override default value for MKDIR
2000 MKTEMP Override default value for MKTEMP
2001 MV Override default value for MV
2002 NAWK Override default value for NAWK
2003 PRINTF Override default value for PRINTF
2004 RM Override default value for RM
2005 SH Override default value for SH
2006 SORT Override default value for SORT
2007 TAIL Override default value for TAIL
2008 TAR Override default value for TAR
2009 TEE Override default value for TEE
2010 TOUCH Override default value for TOUCH
2011 TR Override default value for TR
2012 UNAME Override default value for UNAME
2013 UNIQ Override default value for UNIQ
2014 WC Override default value for WC
2015 WHICH Override default value for WHICH
2016 XARGS Override default value for XARGS
2017 AWK Override default value for AWK
2018 GREP Override default value for GREP
2019 EGREP Override default value for EGREP
2020 FGREP Override default value for FGREP
2021 SED Override default value for SED
2022 CYGPATH Override default value for CYGPATH
2023 READLINK Override default value for READLINK
2024 DF Override default value for DF
2025 SETFILE Override default value for SETFILE
2026 UNZIP Override default value for UNZIP
2027 ZIP Override default value for ZIP
2028 LDD Override default value for LDD
2029 OTOOL Override default value for OTOOL
2030 READELF Override default value for READELF
2031 HG Override default value for HG
2032 STAT Override default value for STAT
2033 TIME Override default value for TIME
2034 DSYMUTIL Override default value for DSYMUTIL
2035 XATTR Override default value for XATTR
2036 CODESIGN Override default value for CODESIGN
2037 PKG_CONFIG path to pkg-config utility
2038 JAVA Override default value for JAVA
2039 JAVAC Override default value for JAVAC
2040 JAVAH Override default value for JAVAH
2041 JAR Override default value for JAR
2042 NATIVE2ASCII
2043 Override default value for NATIVE2ASCII
2044 JARSIGNER Override default value for JARSIGNER
2045 CC C compiler command
4294
4295 # Check if the VS env variables were setup prior to running configure.
4296 # If not, then find vcvarsall.bat and run it automatically, and integrate
4297 # the set env variables into the spec file.
4298
4299
4300
4301
4302
4303
4304
4305
4306
4307
4308 # This line needs to be here, verbatim, after all includes and the dummy hook
4309 # definitions. It is replaced with custom functionality when building
4310 # custom sources.
4311 #CUSTOM_AUTOCONF_INCLUDE
4312
4313 # Do not change or remove the following line, it is needed for consistency checks:
4314 DATE_WHEN_GENERATED=1405336663
4315
4316 ###############################################################################
4317 #
4318 # Initialization / Boot-strapping
4319 #
4320 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4321 # thus it jumps back and forth, each time gaining something needed later on.
4322 #
4323 ###############################################################################
4324
4325 # If we are requested to print additional help, do that and then exit.
4326 # This must be the very first call.
4327
4328 if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4329 $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4330 $PRINTF "Which are valid to use depends on the build platform.\n"
4331 for toolchain in $VALID_TOOLCHAINS_all; do
4332 # Use indirect variable referencing
4333 toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4334 TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
5699 fi
5700 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5701 $as_echo "$tool_specified" >&6; }
5702 fi
5703 fi
5704 fi
5705
5706
5707
5708 if test "x$CP" = x; then
5709 as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
5710 fi
5711
5712
5713
5714
5715
5716 # Publish this variable in the help.
5717
5718
5719 if test "x$CPIO" = x; then
5720 # The variable is not set by user, try to locate tool using the code snippet
5721 for ac_prog in cpio
5722 do
5723 # Extract the first word of "$ac_prog", so it can be a program name with args.
5724 set dummy $ac_prog; ac_word=$2
5725 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5726 $as_echo_n "checking for $ac_word... " >&6; }
5727 if ${ac_cv_path_CPIO+:} false; then :
5728 $as_echo_n "(cached) " >&6
5729 else
5730 case $CPIO in
5731 [\\/]* | ?:[\\/]*)
5732 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
5733 ;;
5734 *)
5735 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5736 for as_dir in $PATH
5737 do
5738 IFS=$as_save_IFS
5739 test -z "$as_dir" && as_dir=.
5740 for ac_exec_ext in '' $ac_executable_extensions; do
5741 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5742 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
5743 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5744 break 2
5745 fi
5746 done
5747 done
5748 IFS=$as_save_IFS
5749
5750 ;;
5751 esac
5752 fi
5753 CPIO=$ac_cv_path_CPIO
5754 if test -n "$CPIO"; then
5755 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
5756 $as_echo "$CPIO" >&6; }
5757 else
5758 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5759 $as_echo "no" >&6; }
5760 fi
5761
5762
5763 test -n "$CPIO" && break
5764 done
5765
5766 else
5767 # The variable is set, but is it from the command line or the environment?
5768
5769 # Try to remove the string !CPIO! from our list.
5770 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
5771 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5772 # If it failed, the variable was not from the command line. Ignore it,
5773 # but warn the user (except for BASH, which is always set by the calling BASH).
5774 if test "xCPIO" != xBASH; then
5775 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
5776 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
5777 fi
5778 # Try to locate tool using the code snippet
5779 for ac_prog in cpio
5780 do
5781 # Extract the first word of "$ac_prog", so it can be a program name with args.
5782 set dummy $ac_prog; ac_word=$2
5783 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5784 $as_echo_n "checking for $ac_word... " >&6; }
5785 if ${ac_cv_path_CPIO+:} false; then :
5786 $as_echo_n "(cached) " >&6
5787 else
5788 case $CPIO in
5789 [\\/]* | ?:[\\/]*)
5790 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
5791 ;;
5792 *)
5793 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5794 for as_dir in $PATH
5795 do
5796 IFS=$as_save_IFS
5797 test -z "$as_dir" && as_dir=.
5798 for ac_exec_ext in '' $ac_executable_extensions; do
5799 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5800 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
5801 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5802 break 2
5803 fi
5804 done
5805 done
5806 IFS=$as_save_IFS
5807
5808 ;;
5809 esac
5810 fi
5811 CPIO=$ac_cv_path_CPIO
5812 if test -n "$CPIO"; then
5813 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
5814 $as_echo "$CPIO" >&6; }
5815 else
5816 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5817 $as_echo "no" >&6; }
5818 fi
5819
5820
5821 test -n "$CPIO" && break
5822 done
5823
5824 else
5825 # If it succeeded, then it was overridden by the user. We will use it
5826 # for the tool.
5827
5828 # First remove it from the list of overridden variables, so we can test
5829 # for unknown variables in the end.
5830 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5831
5832 # Check if the provided tool contains a complete path.
5833 tool_specified="$CPIO"
5834 tool_basename="${tool_specified##*/}"
5835 if test "x$tool_basename" = "x$tool_specified"; then
5836 # A command without a complete path is provided, search $PATH.
5837 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
5838 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
5839 # Extract the first word of "$tool_basename", so it can be a program name with args.
5840 set dummy $tool_basename; ac_word=$2
5841 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5842 $as_echo_n "checking for $ac_word... " >&6; }
5843 if ${ac_cv_path_CPIO+:} false; then :
5844 $as_echo_n "(cached) " >&6
5845 else
5846 case $CPIO in
5847 [\\/]* | ?:[\\/]*)
5848 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
5849 ;;
5850 *)
5851 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5852 for as_dir in $PATH
5853 do
5854 IFS=$as_save_IFS
5855 test -z "$as_dir" && as_dir=.
5856 for ac_exec_ext in '' $ac_executable_extensions; do
5857 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5858 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
5859 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5860 break 2
5861 fi
5862 done
5863 done
5864 IFS=$as_save_IFS
5865
5866 ;;
5867 esac
5868 fi
5869 CPIO=$ac_cv_path_CPIO
5870 if test -n "$CPIO"; then
5871 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
5872 $as_echo "$CPIO" >&6; }
5873 else
5874 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5875 $as_echo "no" >&6; }
5876 fi
5877
5878
5879 if test "x$CPIO" = x; then
5880 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5881 fi
5882 else
5883 # Otherwise we believe it is a complete path. Use it as it is.
5884 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
5885 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
5886 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
5887 $as_echo_n "checking for CPIO... " >&6; }
5888 if test ! -x "$tool_specified"; then
5889 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5890 $as_echo "not found" >&6; }
5891 as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
5892 fi
5893 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5894 $as_echo "$tool_specified" >&6; }
5895 fi
5896 fi
5897 fi
5898
5899
5900
5901 if test "x$CPIO" = x; then
5902 as_fn_error $? "Could not find required tool for CPIO" "$LINENO" 5
5903 fi
5904
5905
5906
5907
5908
5909 # Publish this variable in the help.
5910
5911
5912 if test "x$CUT" = x; then
5913 # The variable is not set by user, try to locate tool using the code snippet
5914 for ac_prog in cut
5915 do
5916 # Extract the first word of "$ac_prog", so it can be a program name with args.
5917 set dummy $ac_prog; ac_word=$2
5918 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5919 $as_echo_n "checking for $ac_word... " >&6; }
5920 if ${ac_cv_path_CUT+:} false; then :
5921 $as_echo_n "(cached) " >&6
5922 else
5923 case $CUT in
5924 [\\/]* | ?:[\\/]*)
5925 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5926 ;;
5927 *)
5928 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5929 for as_dir in $PATH
5930 do
5931 IFS=$as_save_IFS
13361 else
13362 # Otherwise we believe it is a complete path. Use it as it is.
13363 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
13364 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
13365 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
13366 $as_echo_n "checking for SETFILE... " >&6; }
13367 if test ! -x "$tool_specified"; then
13368 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13369 $as_echo "not found" >&6; }
13370 as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
13371 fi
13372 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13373 $as_echo "$tool_specified" >&6; }
13374 fi
13375 fi
13376 fi
13377
13378
13379
13380
13381 # Now we can determine OpenJDK build and target platforms. This is required to
13382 # have early on.
13383 # Make sure we can run config.sub.
13384 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
13385 as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
13386
13387 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
13388 $as_echo_n "checking build system type... " >&6; }
13389 if ${ac_cv_build+:} false; then :
13390 $as_echo_n "(cached) " >&6
13391 else
13392 ac_build_alias=$build_alias
13393 test "x$ac_build_alias" = x &&
13394 ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
13395 test "x$ac_build_alias" = x &&
13396 as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
13397 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
13398 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
13399
13400 fi
13619 *)
13620 as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
13621 ;;
13622 esac
13623
13624 # ..and setup our own variables. (Do this explicitely to facilitate searching)
13625 OPENJDK_BUILD_OS="$VAR_OS"
13626 OPENJDK_BUILD_OS_API="$VAR_OS_API"
13627 OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
13628 OPENJDK_BUILD_CPU="$VAR_CPU"
13629 OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
13630 OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
13631 OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13632
13633
13634
13635
13636
13637
13638
13639 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
13640 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
13641 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
13642 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
13643
13644 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13645
13646 case "$host_os" in
13647 *linux*)
13648 VAR_OS=linux
13649 VAR_OS_API=posix
13650 VAR_OS_ENV=linux
13651 ;;
13652 *solaris*)
13653 VAR_OS=solaris
13654 VAR_OS_API=posix
13655 VAR_OS_ENV=solaris
13656 ;;
13657 *darwin*)
13658 VAR_OS=macosx
13750 *)
13751 as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
13752 ;;
13753 esac
13754
13755 # ... and setup our own variables. (Do this explicitely to facilitate searching)
13756 OPENJDK_TARGET_OS="$VAR_OS"
13757 OPENJDK_TARGET_OS_API="$VAR_OS_API"
13758 OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
13759 OPENJDK_TARGET_CPU="$VAR_CPU"
13760 OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
13761 OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
13762 OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13763
13764
13765
13766
13767
13768
13769
13770 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
13771 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
13772 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
13773 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
13774
13775
13776
13777 # Check whether --with-target-bits was given.
13778 if test "${with_target_bits+set}" = set; then :
13779 withval=$with_target_bits;
13780 fi
13781
13782
13783 # We have three types of compiles:
13784 # native == normal compilation, target system == build system
13785 # cross == traditional cross compilation, target system != build system; special toolchain needed
13786 # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
13787 #
13788 if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
13789 # We're doing a proper cross-compilation
15586 if test "x$new_path" = x; then
15587 # Oops. Which didn't find the executable.
15588 # The splitting of arguments from the executable at a space might have been incorrect,
15589 # since paths with space are more likely in Windows. Give it another try with the whole
15590 # argument.
15591 path="$complete"
15592 arguments="EOL"
15593 new_path="$path"
15594
15595 windows_path="$new_path"
15596 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15597 unix_path=`$CYGPATH -u "$windows_path"`
15598 new_path="$unix_path"
15599 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15600 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15601 new_path="$unix_path"
15602 fi
15603
15604
15605 new_path=`$WHICH "$new_path" 2> /dev/null`
15606
15607 if test "x$new_path" = x; then
15608 # It's still not found. Now this is an unrecoverable error.
15609 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15610 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15611 has_space=`$ECHO "$complete" | $GREP " "`
15612 if test "x$has_space" != x; then
15613 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15614 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15615 fi
15616 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15617 fi
15618 fi
15619
15620 # Now new_path has a complete unix path to the binary
15621 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15622 # Keep paths in /bin as-is, but remove trailing .exe if any
15623 new_path="${new_path/%.exe/}"
15624 # Do not save /bin paths to all_fixpath_prefixes!
15625 else
15942 if test "x$new_path" = x; then
15943 # Oops. Which didn't find the executable.
15944 # The splitting of arguments from the executable at a space might have been incorrect,
15945 # since paths with space are more likely in Windows. Give it another try with the whole
15946 # argument.
15947 path="$complete"
15948 arguments="EOL"
15949 new_path="$path"
15950
15951 windows_path="$new_path"
15952 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15953 unix_path=`$CYGPATH -u "$windows_path"`
15954 new_path="$unix_path"
15955 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15956 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15957 new_path="$unix_path"
15958 fi
15959
15960
15961 new_path=`$WHICH "$new_path" 2> /dev/null`
15962
15963 if test "x$new_path" = x; then
15964 # It's still not found. Now this is an unrecoverable error.
15965 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15966 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15967 has_space=`$ECHO "$complete" | $GREP " "`
15968 if test "x$has_space" != x; then
15969 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15970 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15971 fi
15972 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15973 fi
15974 fi
15975
15976 # Now new_path has a complete unix path to the binary
15977 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15978 # Keep paths in /bin as-is, but remove trailing .exe if any
15979 new_path="${new_path/%.exe/}"
15980 # Do not save /bin paths to all_fixpath_prefixes!
15981 else
16295 if test "x$new_path" = x; then
16296 # Oops. Which didn't find the executable.
16297 # The splitting of arguments from the executable at a space might have been incorrect,
16298 # since paths with space are more likely in Windows. Give it another try with the whole
16299 # argument.
16300 path="$complete"
16301 arguments="EOL"
16302 new_path="$path"
16303
16304 windows_path="$new_path"
16305 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16306 unix_path=`$CYGPATH -u "$windows_path"`
16307 new_path="$unix_path"
16308 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16309 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16310 new_path="$unix_path"
16311 fi
16312
16313
16314 new_path=`$WHICH "$new_path" 2> /dev/null`
16315
16316 if test "x$new_path" = x; then
16317 # It's still not found. Now this is an unrecoverable error.
16318 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16319 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16320 has_space=`$ECHO "$complete" | $GREP " "`
16321 if test "x$has_space" != x; then
16322 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16323 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16324 fi
16325 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16326 fi
16327 fi
16328
16329 # Now new_path has a complete unix path to the binary
16330 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16331 # Keep paths in /bin as-is, but remove trailing .exe if any
16332 new_path="${new_path/%.exe/}"
16333 # Do not save /bin paths to all_fixpath_prefixes!
16334 else
16653 if test "x$new_path" = x; then
16654 # Oops. Which didn't find the executable.
16655 # The splitting of arguments from the executable at a space might have been incorrect,
16656 # since paths with space are more likely in Windows. Give it another try with the whole
16657 # argument.
16658 path="$complete"
16659 arguments="EOL"
16660 new_path="$path"
16661
16662 windows_path="$new_path"
16663 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16664 unix_path=`$CYGPATH -u "$windows_path"`
16665 new_path="$unix_path"
16666 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16667 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16668 new_path="$unix_path"
16669 fi
16670
16671
16672 new_path=`$WHICH "$new_path" 2> /dev/null`
16673
16674 if test "x$new_path" = x; then
16675 # It's still not found. Now this is an unrecoverable error.
16676 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16677 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16678 has_space=`$ECHO "$complete" | $GREP " "`
16679 if test "x$has_space" != x; then
16680 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16681 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16682 fi
16683 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16684 fi
16685 fi
16686
16687 # Now new_path has a complete unix path to the binary
16688 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16689 # Keep paths in /bin as-is, but remove trailing .exe if any
16690 new_path="${new_path/%.exe/}"
16691 # Do not save /bin paths to all_fixpath_prefixes!
16692 else
17005 if test "x$new_path" = x; then
17006 # Oops. Which didn't find the executable.
17007 # The splitting of arguments from the executable at a space might have been incorrect,
17008 # since paths with space are more likely in Windows. Give it another try with the whole
17009 # argument.
17010 path="$complete"
17011 arguments="EOL"
17012 new_path="$path"
17013
17014 windows_path="$new_path"
17015 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17016 unix_path=`$CYGPATH -u "$windows_path"`
17017 new_path="$unix_path"
17018 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17019 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17020 new_path="$unix_path"
17021 fi
17022
17023
17024 new_path=`$WHICH "$new_path" 2> /dev/null`
17025
17026 if test "x$new_path" = x; then
17027 # It's still not found. Now this is an unrecoverable error.
17028 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17029 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17030 has_space=`$ECHO "$complete" | $GREP " "`
17031 if test "x$has_space" != x; then
17032 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17033 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17034 fi
17035 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17036 fi
17037 fi
17038
17039 # Now new_path has a complete unix path to the binary
17040 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17041 # Keep paths in /bin as-is, but remove trailing .exe if any
17042 new_path="${new_path/%.exe/}"
17043 # Do not save /bin paths to all_fixpath_prefixes!
17044 else
27431 if test "x$new_path" = x; then
27432 # Oops. Which didn't find the executable.
27433 # The splitting of arguments from the executable at a space might have been incorrect,
27434 # since paths with space are more likely in Windows. Give it another try with the whole
27435 # argument.
27436 path="$complete"
27437 arguments="EOL"
27438 new_path="$path"
27439
27440 windows_path="$new_path"
27441 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27442 unix_path=`$CYGPATH -u "$windows_path"`
27443 new_path="$unix_path"
27444 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27445 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27446 new_path="$unix_path"
27447 fi
27448
27449
27450 new_path=`$WHICH "$new_path" 2> /dev/null`
27451
27452 if test "x$new_path" = x; then
27453 # It's still not found. Now this is an unrecoverable error.
27454 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
27455 $as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
27456 has_space=`$ECHO "$complete" | $GREP " "`
27457 if test "x$has_space" != x; then
27458 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
27459 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
27460 fi
27461 as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
27462 fi
27463 fi
27464
27465 # Now new_path has a complete unix path to the binary
27466 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
27467 # Keep paths in /bin as-is, but remove trailing .exe if any
27468 new_path="${new_path/%.exe/}"
27469 # Do not save /bin paths to all_fixpath_prefixes!
27470 else
28074 if test "x$new_path" = x; then
28075 # Oops. Which didn't find the executable.
28076 # The splitting of arguments from the executable at a space might have been incorrect,
28077 # since paths with space are more likely in Windows. Give it another try with the whole
28078 # argument.
28079 path="$complete"
28080 arguments="EOL"
28081 new_path="$path"
28082
28083 windows_path="$new_path"
28084 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28085 unix_path=`$CYGPATH -u "$windows_path"`
28086 new_path="$unix_path"
28087 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28088 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
28089 new_path="$unix_path"
28090 fi
28091
28092
28093 new_path=`$WHICH "$new_path" 2> /dev/null`
28094
28095 if test "x$new_path" = x; then
28096 # It's still not found. Now this is an unrecoverable error.
28097 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
28098 $as_echo "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
28099 has_space=`$ECHO "$complete" | $GREP " "`
28100 if test "x$has_space" != x; then
28101 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
28102 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
28103 fi
28104 as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
28105 fi
28106 fi
28107
28108 # Now new_path has a complete unix path to the binary
28109 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
28110 # Keep paths in /bin as-is, but remove trailing .exe if any
28111 new_path="${new_path/%.exe/}"
28112 # Do not save /bin paths to all_fixpath_prefixes!
28113 else
28514 if test "x$new_path" = x; then
28515 # Oops. Which didn't find the executable.
28516 # The splitting of arguments from the executable at a space might have been incorrect,
28517 # since paths with space are more likely in Windows. Give it another try with the whole
28518 # argument.
28519 path="$complete"
28520 arguments="EOL"
28521 new_path="$path"
28522
28523 windows_path="$new_path"
28524 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28525 unix_path=`$CYGPATH -u "$windows_path"`
28526 new_path="$unix_path"
28527 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28528 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
28529 new_path="$unix_path"
28530 fi
28531
28532
28533 new_path=`$WHICH "$new_path" 2> /dev/null`
28534
28535 if test "x$new_path" = x; then
28536 # It's still not found. Now this is an unrecoverable error.
28537 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&5
28538 $as_echo "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&6;}
28539 has_space=`$ECHO "$complete" | $GREP " "`
28540 if test "x$has_space" != x; then
28541 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
28542 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
28543 fi
28544 as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CC" "$LINENO" 5
28545 fi
28546 fi
28547
28548 # Now new_path has a complete unix path to the binary
28549 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
28550 # Keep paths in /bin as-is, but remove trailing .exe if any
28551 new_path="${new_path/%.exe/}"
28552 # Do not save /bin paths to all_fixpath_prefixes!
28553 else
29780 if test "x$new_path" = x; then
29781 # Oops. Which didn't find the executable.
29782 # The splitting of arguments from the executable at a space might have been incorrect,
29783 # since paths with space are more likely in Windows. Give it another try with the whole
29784 # argument.
29785 path="$complete"
29786 arguments="EOL"
29787 new_path="$path"
29788
29789 windows_path="$new_path"
29790 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
29791 unix_path=`$CYGPATH -u "$windows_path"`
29792 new_path="$unix_path"
29793 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29794 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
29795 new_path="$unix_path"
29796 fi
29797
29798
29799 new_path=`$WHICH "$new_path" 2> /dev/null`
29800
29801 if test "x$new_path" = x; then
29802 # It's still not found. Now this is an unrecoverable error.
29803 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
29804 $as_echo "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
29805 has_space=`$ECHO "$complete" | $GREP " "`
29806 if test "x$has_space" != x; then
29807 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
29808 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
29809 fi
29810 as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
29811 fi
29812 fi
29813
29814 # Now new_path has a complete unix path to the binary
29815 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
29816 # Keep paths in /bin as-is, but remove trailing .exe if any
29817 new_path="${new_path/%.exe/}"
29818 # Do not save /bin paths to all_fixpath_prefixes!
29819 else
30220 if test "x$new_path" = x; then
30221 # Oops. Which didn't find the executable.
30222 # The splitting of arguments from the executable at a space might have been incorrect,
30223 # since paths with space are more likely in Windows. Give it another try with the whole
30224 # argument.
30225 path="$complete"
30226 arguments="EOL"
30227 new_path="$path"
30228
30229 windows_path="$new_path"
30230 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
30231 unix_path=`$CYGPATH -u "$windows_path"`
30232 new_path="$unix_path"
30233 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
30234 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
30235 new_path="$unix_path"
30236 fi
30237
30238
30239 new_path=`$WHICH "$new_path" 2> /dev/null`
30240
30241 if test "x$new_path" = x; then
30242 # It's still not found. Now this is an unrecoverable error.
30243 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&5
30244 $as_echo "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&6;}
30245 has_space=`$ECHO "$complete" | $GREP " "`
30246 if test "x$has_space" != x; then
30247 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
30248 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
30249 fi
30250 as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CXX" "$LINENO" 5
30251 fi
30252 fi
30253
30254 # Now new_path has a complete unix path to the binary
30255 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
30256 # Keep paths in /bin as-is, but remove trailing .exe if any
30257 new_path="${new_path/%.exe/}"
30258 # Do not save /bin paths to all_fixpath_prefixes!
30259 else
31065 if test "x$new_path" = x; then
31066 # Oops. Which didn't find the executable.
31067 # The splitting of arguments from the executable at a space might have been incorrect,
31068 # since paths with space are more likely in Windows. Give it another try with the whole
31069 # argument.
31070 path="$complete"
31071 arguments="EOL"
31072 new_path="$path"
31073
31074 windows_path="$new_path"
31075 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31076 unix_path=`$CYGPATH -u "$windows_path"`
31077 new_path="$unix_path"
31078 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31079 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31080 new_path="$unix_path"
31081 fi
31082
31083
31084 new_path=`$WHICH "$new_path" 2> /dev/null`
31085
31086 if test "x$new_path" = x; then
31087 # It's still not found. Now this is an unrecoverable error.
31088 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
31089 $as_echo "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
31090 has_space=`$ECHO "$complete" | $GREP " "`
31091 if test "x$has_space" != x; then
31092 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
31093 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
31094 fi
31095 as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
31096 fi
31097 fi
31098
31099 # Now new_path has a complete unix path to the binary
31100 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
31101 # Keep paths in /bin as-is, but remove trailing .exe if any
31102 new_path="${new_path/%.exe/}"
31103 # Do not save /bin paths to all_fixpath_prefixes!
31104 else
31463 if test "x$new_path" = x; then
31464 # Oops. Which didn't find the executable.
31465 # The splitting of arguments from the executable at a space might have been incorrect,
31466 # since paths with space are more likely in Windows. Give it another try with the whole
31467 # argument.
31468 path="$complete"
31469 arguments="EOL"
31470 new_path="$path"
31471
31472 windows_path="$new_path"
31473 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31474 unix_path=`$CYGPATH -u "$windows_path"`
31475 new_path="$unix_path"
31476 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31477 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31478 new_path="$unix_path"
31479 fi
31480
31481
31482 new_path=`$WHICH "$new_path" 2> /dev/null`
31483
31484 if test "x$new_path" = x; then
31485 # It's still not found. Now this is an unrecoverable error.
31486 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
31487 $as_echo "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
31488 has_space=`$ECHO "$complete" | $GREP " "`
31489 if test "x$has_space" != x; then
31490 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
31491 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
31492 fi
31493 as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
31494 fi
31495 fi
31496
31497 # Now new_path has a complete unix path to the binary
31498 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
31499 # Keep paths in /bin as-is, but remove trailing .exe if any
31500 new_path="${new_path/%.exe/}"
31501 # Do not save /bin paths to all_fixpath_prefixes!
31502 else
31790 if test "x$new_path" = x; then
31791 # Oops. Which didn't find the executable.
31792 # The splitting of arguments from the executable at a space might have been incorrect,
31793 # since paths with space are more likely in Windows. Give it another try with the whole
31794 # argument.
31795 path="$complete"
31796 arguments="EOL"
31797 new_path="$path"
31798
31799 windows_path="$new_path"
31800 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31801 unix_path=`$CYGPATH -u "$windows_path"`
31802 new_path="$unix_path"
31803 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31804 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31805 new_path="$unix_path"
31806 fi
31807
31808
31809 new_path=`$WHICH "$new_path" 2> /dev/null`
31810
31811 if test "x$new_path" = x; then
31812 # It's still not found. Now this is an unrecoverable error.
31813 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
31814 $as_echo "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
31815 has_space=`$ECHO "$complete" | $GREP " "`
31816 if test "x$has_space" != x; then
31817 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
31818 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
31819 fi
31820 as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
31821 fi
31822 fi
31823
31824 # Now new_path has a complete unix path to the binary
31825 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
31826 # Keep paths in /bin as-is, but remove trailing .exe if any
31827 new_path="${new_path/%.exe/}"
31828 # Do not save /bin paths to all_fixpath_prefixes!
31829 else
32268 if test "x$new_path" = x; then
32269 # Oops. Which didn't find the executable.
32270 # The splitting of arguments from the executable at a space might have been incorrect,
32271 # since paths with space are more likely in Windows. Give it another try with the whole
32272 # argument.
32273 path="$complete"
32274 arguments="EOL"
32275 new_path="$path"
32276
32277 windows_path="$new_path"
32278 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32279 unix_path=`$CYGPATH -u "$windows_path"`
32280 new_path="$unix_path"
32281 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32282 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32283 new_path="$unix_path"
32284 fi
32285
32286
32287 new_path=`$WHICH "$new_path" 2> /dev/null`
32288
32289 if test "x$new_path" = x; then
32290 # It's still not found. Now this is an unrecoverable error.
32291 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
32292 $as_echo "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
32293 has_space=`$ECHO "$complete" | $GREP " "`
32294 if test "x$has_space" != x; then
32295 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
32296 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
32297 fi
32298 as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
32299 fi
32300 fi
32301
32302 # Now new_path has a complete unix path to the binary
32303 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
32304 # Keep paths in /bin as-is, but remove trailing .exe if any
32305 new_path="${new_path/%.exe/}"
32306 # Do not save /bin paths to all_fixpath_prefixes!
32307 else
32879 if test "x$new_path" = x; then
32880 # Oops. Which didn't find the executable.
32881 # The splitting of arguments from the executable at a space might have been incorrect,
32882 # since paths with space are more likely in Windows. Give it another try with the whole
32883 # argument.
32884 path="$complete"
32885 arguments="EOL"
32886 new_path="$path"
32887
32888 windows_path="$new_path"
32889 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32890 unix_path=`$CYGPATH -u "$windows_path"`
32891 new_path="$unix_path"
32892 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32893 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32894 new_path="$unix_path"
32895 fi
32896
32897
32898 new_path=`$WHICH "$new_path" 2> /dev/null`
32899
32900 if test "x$new_path" = x; then
32901 # It's still not found. Now this is an unrecoverable error.
32902 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
32903 $as_echo "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
32904 has_space=`$ECHO "$complete" | $GREP " "`
32905 if test "x$has_space" != x; then
32906 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
32907 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
32908 fi
32909 as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
32910 fi
32911 fi
32912
32913 # Now new_path has a complete unix path to the binary
32914 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
32915 # Keep paths in /bin as-is, but remove trailing .exe if any
32916 new_path="${new_path/%.exe/}"
32917 # Do not save /bin paths to all_fixpath_prefixes!
32918 else
33398 if test "x$new_path" = x; then
33399 # Oops. Which didn't find the executable.
33400 # The splitting of arguments from the executable at a space might have been incorrect,
33401 # since paths with space are more likely in Windows. Give it another try with the whole
33402 # argument.
33403 path="$complete"
33404 arguments="EOL"
33405 new_path="$path"
33406
33407 windows_path="$new_path"
33408 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
33409 unix_path=`$CYGPATH -u "$windows_path"`
33410 new_path="$unix_path"
33411 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33412 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
33413 new_path="$unix_path"
33414 fi
33415
33416
33417 new_path=`$WHICH "$new_path" 2> /dev/null`
33418
33419 if test "x$new_path" = x; then
33420 # It's still not found. Now this is an unrecoverable error.
33421 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$complete\", is not found." >&5
33422 $as_echo "$as_me: The path of OBJC, which resolves as \"$complete\", is not found." >&6;}
33423 has_space=`$ECHO "$complete" | $GREP " "`
33424 if test "x$has_space" != x; then
33425 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
33426 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
33427 fi
33428 as_fn_error $? "Cannot locate the the path of OBJC" "$LINENO" 5
33429 fi
33430 fi
33431
33432 # Now new_path has a complete unix path to the binary
33433 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
33434 # Keep paths in /bin as-is, but remove trailing .exe if any
33435 new_path="${new_path/%.exe/}"
33436 # Do not save /bin paths to all_fixpath_prefixes!
33437 else
33849 if test "x$new_path" = x; then
33850 # Oops. Which didn't find the executable.
33851 # The splitting of arguments from the executable at a space might have been incorrect,
33852 # since paths with space are more likely in Windows. Give it another try with the whole
33853 # argument.
33854 path="$complete"
33855 arguments="EOL"
33856 new_path="$path"
33857
33858 windows_path="$new_path"
33859 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
33860 unix_path=`$CYGPATH -u "$windows_path"`
33861 new_path="$unix_path"
33862 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33863 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
33864 new_path="$unix_path"
33865 fi
33866
33867
33868 new_path=`$WHICH "$new_path" 2> /dev/null`
33869
33870 if test "x$new_path" = x; then
33871 # It's still not found. Now this is an unrecoverable error.
33872 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
33873 $as_echo "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
33874 has_space=`$ECHO "$complete" | $GREP " "`
33875 if test "x$has_space" != x; then
33876 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
33877 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
33878 fi
33879 as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
33880 fi
33881 fi
33882
33883 # Now new_path has a complete unix path to the binary
33884 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
33885 # Keep paths in /bin as-is, but remove trailing .exe if any
33886 new_path="${new_path/%.exe/}"
33887 # Do not save /bin paths to all_fixpath_prefixes!
33888 else
34173 if test "x$new_path" = x; then
34174 # Oops. Which didn't find the executable.
34175 # The splitting of arguments from the executable at a space might have been incorrect,
34176 # since paths with space are more likely in Windows. Give it another try with the whole
34177 # argument.
34178 path="$complete"
34179 arguments="EOL"
34180 new_path="$path"
34181
34182 windows_path="$new_path"
34183 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34184 unix_path=`$CYGPATH -u "$windows_path"`
34185 new_path="$unix_path"
34186 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34187 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34188 new_path="$unix_path"
34189 fi
34190
34191
34192 new_path=`$WHICH "$new_path" 2> /dev/null`
34193
34194 if test "x$new_path" = x; then
34195 # It's still not found. Now this is an unrecoverable error.
34196 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
34197 $as_echo "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
34198 has_space=`$ECHO "$complete" | $GREP " "`
34199 if test "x$has_space" != x; then
34200 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
34201 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
34202 fi
34203 as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
34204 fi
34205 fi
34206
34207 # Now new_path has a complete unix path to the binary
34208 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
34209 # Keep paths in /bin as-is, but remove trailing .exe if any
34210 new_path="${new_path/%.exe/}"
34211 # Do not save /bin paths to all_fixpath_prefixes!
34212 else
34493 if test "x$new_path" = x; then
34494 # Oops. Which didn't find the executable.
34495 # The splitting of arguments from the executable at a space might have been incorrect,
34496 # since paths with space are more likely in Windows. Give it another try with the whole
34497 # argument.
34498 path="$complete"
34499 arguments="EOL"
34500 new_path="$path"
34501
34502 windows_path="$new_path"
34503 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34504 unix_path=`$CYGPATH -u "$windows_path"`
34505 new_path="$unix_path"
34506 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34507 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34508 new_path="$unix_path"
34509 fi
34510
34511
34512 new_path=`$WHICH "$new_path" 2> /dev/null`
34513
34514 if test "x$new_path" = x; then
34515 # It's still not found. Now this is an unrecoverable error.
34516 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
34517 $as_echo "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
34518 has_space=`$ECHO "$complete" | $GREP " "`
34519 if test "x$has_space" != x; then
34520 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
34521 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
34522 fi
34523 as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
34524 fi
34525 fi
34526
34527 # Now new_path has a complete unix path to the binary
34528 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
34529 # Keep paths in /bin as-is, but remove trailing .exe if any
34530 new_path="${new_path/%.exe/}"
34531 # Do not save /bin paths to all_fixpath_prefixes!
34532 else
34795 if test "x$new_path" = x; then
34796 # Oops. Which didn't find the executable.
34797 # The splitting of arguments from the executable at a space might have been incorrect,
34798 # since paths with space are more likely in Windows. Give it another try with the whole
34799 # argument.
34800 path="$complete"
34801 arguments="EOL"
34802 new_path="$path"
34803
34804 windows_path="$new_path"
34805 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34806 unix_path=`$CYGPATH -u "$windows_path"`
34807 new_path="$unix_path"
34808 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34809 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34810 new_path="$unix_path"
34811 fi
34812
34813
34814 new_path=`$WHICH "$new_path" 2> /dev/null`
34815
34816 if test "x$new_path" = x; then
34817 # It's still not found. Now this is an unrecoverable error.
34818 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
34819 $as_echo "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
34820 has_space=`$ECHO "$complete" | $GREP " "`
34821 if test "x$has_space" != x; then
34822 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
34823 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
34824 fi
34825 as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
34826 fi
34827 fi
34828
34829 # Now new_path has a complete unix path to the binary
34830 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
34831 # Keep paths in /bin as-is, but remove trailing .exe if any
34832 new_path="${new_path/%.exe/}"
34833 # Do not save /bin paths to all_fixpath_prefixes!
34834 else
35249 if test "x$new_path" = x; then
35250 # Oops. Which didn't find the executable.
35251 # The splitting of arguments from the executable at a space might have been incorrect,
35252 # since paths with space are more likely in Windows. Give it another try with the whole
35253 # argument.
35254 path="$complete"
35255 arguments="EOL"
35256 new_path="$path"
35257
35258 windows_path="$new_path"
35259 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35260 unix_path=`$CYGPATH -u "$windows_path"`
35261 new_path="$unix_path"
35262 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35263 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
35264 new_path="$unix_path"
35265 fi
35266
35267
35268 new_path=`$WHICH "$new_path" 2> /dev/null`
35269
35270 if test "x$new_path" = x; then
35271 # It's still not found. Now this is an unrecoverable error.
35272 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
35273 $as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
35274 has_space=`$ECHO "$complete" | $GREP " "`
35275 if test "x$has_space" != x; then
35276 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
35277 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
35278 fi
35279 as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
35280 fi
35281 fi
35282
35283 # Now new_path has a complete unix path to the binary
35284 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
35285 # Keep paths in /bin as-is, but remove trailing .exe if any
35286 new_path="${new_path/%.exe/}"
35287 # Do not save /bin paths to all_fixpath_prefixes!
35288 else
35700 if test "x$new_path" = x; then
35701 # Oops. Which didn't find the executable.
35702 # The splitting of arguments from the executable at a space might have been incorrect,
35703 # since paths with space are more likely in Windows. Give it another try with the whole
35704 # argument.
35705 path="$complete"
35706 arguments="EOL"
35707 new_path="$path"
35708
35709 windows_path="$new_path"
35710 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35711 unix_path=`$CYGPATH -u "$windows_path"`
35712 new_path="$unix_path"
35713 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35714 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
35715 new_path="$unix_path"
35716 fi
35717
35718
35719 new_path=`$WHICH "$new_path" 2> /dev/null`
35720
35721 if test "x$new_path" = x; then
35722 # It's still not found. Now this is an unrecoverable error.
35723 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
35724 $as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
35725 has_space=`$ECHO "$complete" | $GREP " "`
35726 if test "x$has_space" != x; then
35727 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
35728 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
35729 fi
35730 as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
35731 fi
35732 fi
35733
35734 # Now new_path has a complete unix path to the binary
35735 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
35736 # Keep paths in /bin as-is, but remove trailing .exe if any
35737 new_path="${new_path/%.exe/}"
35738 # Do not save /bin paths to all_fixpath_prefixes!
35739 else
36151 if test "x$new_path" = x; then
36152 # Oops. Which didn't find the executable.
36153 # The splitting of arguments from the executable at a space might have been incorrect,
36154 # since paths with space are more likely in Windows. Give it another try with the whole
36155 # argument.
36156 path="$complete"
36157 arguments="EOL"
36158 new_path="$path"
36159
36160 windows_path="$new_path"
36161 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36162 unix_path=`$CYGPATH -u "$windows_path"`
36163 new_path="$unix_path"
36164 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36165 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36166 new_path="$unix_path"
36167 fi
36168
36169
36170 new_path=`$WHICH "$new_path" 2> /dev/null`
36171
36172 if test "x$new_path" = x; then
36173 # It's still not found. Now this is an unrecoverable error.
36174 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
36175 $as_echo "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
36176 has_space=`$ECHO "$complete" | $GREP " "`
36177 if test "x$has_space" != x; then
36178 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
36179 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
36180 fi
36181 as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
36182 fi
36183 fi
36184
36185 # Now new_path has a complete unix path to the binary
36186 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
36187 # Keep paths in /bin as-is, but remove trailing .exe if any
36188 new_path="${new_path/%.exe/}"
36189 # Do not save /bin paths to all_fixpath_prefixes!
36190 else
36603 if test "x$new_path" = x; then
36604 # Oops. Which didn't find the executable.
36605 # The splitting of arguments from the executable at a space might have been incorrect,
36606 # since paths with space are more likely in Windows. Give it another try with the whole
36607 # argument.
36608 path="$complete"
36609 arguments="EOL"
36610 new_path="$path"
36611
36612 windows_path="$new_path"
36613 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36614 unix_path=`$CYGPATH -u "$windows_path"`
36615 new_path="$unix_path"
36616 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36617 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36618 new_path="$unix_path"
36619 fi
36620
36621
36622 new_path=`$WHICH "$new_path" 2> /dev/null`
36623
36624 if test "x$new_path" = x; then
36625 # It's still not found. Now this is an unrecoverable error.
36626 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$complete\", is not found." >&5
36627 $as_echo "$as_me: The path of MCS, which resolves as \"$complete\", is not found." >&6;}
36628 has_space=`$ECHO "$complete" | $GREP " "`
36629 if test "x$has_space" != x; then
36630 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
36631 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
36632 fi
36633 as_fn_error $? "Cannot locate the the path of MCS" "$LINENO" 5
36634 fi
36635 fi
36636
36637 # Now new_path has a complete unix path to the binary
36638 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
36639 # Keep paths in /bin as-is, but remove trailing .exe if any
36640 new_path="${new_path/%.exe/}"
36641 # Do not save /bin paths to all_fixpath_prefixes!
36642 else
37166 if test "x$new_path" = x; then
37167 # Oops. Which didn't find the executable.
37168 # The splitting of arguments from the executable at a space might have been incorrect,
37169 # since paths with space are more likely in Windows. Give it another try with the whole
37170 # argument.
37171 path="$complete"
37172 arguments="EOL"
37173 new_path="$path"
37174
37175 windows_path="$new_path"
37176 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37177 unix_path=`$CYGPATH -u "$windows_path"`
37178 new_path="$unix_path"
37179 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37180 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
37181 new_path="$unix_path"
37182 fi
37183
37184
37185 new_path=`$WHICH "$new_path" 2> /dev/null`
37186
37187 if test "x$new_path" = x; then
37188 # It's still not found. Now this is an unrecoverable error.
37189 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
37190 $as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
37191 has_space=`$ECHO "$complete" | $GREP " "`
37192 if test "x$has_space" != x; then
37193 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
37194 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
37195 fi
37196 as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
37197 fi
37198 fi
37199
37200 # Now new_path has a complete unix path to the binary
37201 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
37202 # Keep paths in /bin as-is, but remove trailing .exe if any
37203 new_path="${new_path/%.exe/}"
37204 # Do not save /bin paths to all_fixpath_prefixes!
37205 else
37727 if test "x$new_path" = x; then
37728 # Oops. Which didn't find the executable.
37729 # The splitting of arguments from the executable at a space might have been incorrect,
37730 # since paths with space are more likely in Windows. Give it another try with the whole
37731 # argument.
37732 path="$complete"
37733 arguments="EOL"
37734 new_path="$path"
37735
37736 windows_path="$new_path"
37737 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37738 unix_path=`$CYGPATH -u "$windows_path"`
37739 new_path="$unix_path"
37740 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37741 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
37742 new_path="$unix_path"
37743 fi
37744
37745
37746 new_path=`$WHICH "$new_path" 2> /dev/null`
37747
37748 if test "x$new_path" = x; then
37749 # It's still not found. Now this is an unrecoverable error.
37750 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
37751 $as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
37752 has_space=`$ECHO "$complete" | $GREP " "`
37753 if test "x$has_space" != x; then
37754 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
37755 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
37756 fi
37757 as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
37758 fi
37759 fi
37760
37761 # Now new_path has a complete unix path to the binary
37762 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
37763 # Keep paths in /bin as-is, but remove trailing .exe if any
37764 new_path="${new_path/%.exe/}"
37765 # Do not save /bin paths to all_fixpath_prefixes!
37766 else
38297 if test "x$new_path" = x; then
38298 # Oops. Which didn't find the executable.
38299 # The splitting of arguments from the executable at a space might have been incorrect,
38300 # since paths with space are more likely in Windows. Give it another try with the whole
38301 # argument.
38302 path="$complete"
38303 arguments="EOL"
38304 new_path="$path"
38305
38306 windows_path="$new_path"
38307 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38308 unix_path=`$CYGPATH -u "$windows_path"`
38309 new_path="$unix_path"
38310 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38311 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38312 new_path="$unix_path"
38313 fi
38314
38315
38316 new_path=`$WHICH "$new_path" 2> /dev/null`
38317
38318 if test "x$new_path" = x; then
38319 # It's still not found. Now this is an unrecoverable error.
38320 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
38321 $as_echo "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
38322 has_space=`$ECHO "$complete" | $GREP " "`
38323 if test "x$has_space" != x; then
38324 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
38325 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
38326 fi
38327 as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
38328 fi
38329 fi
38330
38331 # Now new_path has a complete unix path to the binary
38332 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
38333 # Keep paths in /bin as-is, but remove trailing .exe if any
38334 new_path="${new_path/%.exe/}"
38335 # Do not save /bin paths to all_fixpath_prefixes!
38336 else
38864 if test "x$new_path" = x; then
38865 # Oops. Which didn't find the executable.
38866 # The splitting of arguments from the executable at a space might have been incorrect,
38867 # since paths with space are more likely in Windows. Give it another try with the whole
38868 # argument.
38869 path="$complete"
38870 arguments="EOL"
38871 new_path="$path"
38872
38873 windows_path="$new_path"
38874 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38875 unix_path=`$CYGPATH -u "$windows_path"`
38876 new_path="$unix_path"
38877 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38878 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38879 new_path="$unix_path"
38880 fi
38881
38882
38883 new_path=`$WHICH "$new_path" 2> /dev/null`
38884
38885 if test "x$new_path" = x; then
38886 # It's still not found. Now this is an unrecoverable error.
38887 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
38888 $as_echo "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
38889 has_space=`$ECHO "$complete" | $GREP " "`
38890 if test "x$has_space" != x; then
38891 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
38892 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
38893 fi
38894 as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
38895 fi
38896 fi
38897
38898 # Now new_path has a complete unix path to the binary
38899 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
38900 # Keep paths in /bin as-is, but remove trailing .exe if any
38901 new_path="${new_path/%.exe/}"
38902 # Do not save /bin paths to all_fixpath_prefixes!
38903 else
39340 if test "x$new_path" = x; then
39341 # Oops. Which didn't find the executable.
39342 # The splitting of arguments from the executable at a space might have been incorrect,
39343 # since paths with space are more likely in Windows. Give it another try with the whole
39344 # argument.
39345 path="$complete"
39346 arguments="EOL"
39347 new_path="$path"
39348
39349 windows_path="$new_path"
39350 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39351 unix_path=`$CYGPATH -u "$windows_path"`
39352 new_path="$unix_path"
39353 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39354 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39355 new_path="$unix_path"
39356 fi
39357
39358
39359 new_path=`$WHICH "$new_path" 2> /dev/null`
39360
39361 if test "x$new_path" = x; then
39362 # It's still not found. Now this is an unrecoverable error.
39363 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
39364 $as_echo "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
39365 has_space=`$ECHO "$complete" | $GREP " "`
39366 if test "x$has_space" != x; then
39367 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
39368 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
39369 fi
39370 as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
39371 fi
39372 fi
39373
39374 # Now new_path has a complete unix path to the binary
39375 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
39376 # Keep paths in /bin as-is, but remove trailing .exe if any
39377 new_path="${new_path/%.exe/}"
39378 # Do not save /bin paths to all_fixpath_prefixes!
39379 else
39791 if test "x$new_path" = x; then
39792 # Oops. Which didn't find the executable.
39793 # The splitting of arguments from the executable at a space might have been incorrect,
39794 # since paths with space are more likely in Windows. Give it another try with the whole
39795 # argument.
39796 path="$complete"
39797 arguments="EOL"
39798 new_path="$path"
39799
39800 windows_path="$new_path"
39801 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39802 unix_path=`$CYGPATH -u "$windows_path"`
39803 new_path="$unix_path"
39804 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39805 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39806 new_path="$unix_path"
39807 fi
39808
39809
39810 new_path=`$WHICH "$new_path" 2> /dev/null`
39811
39812 if test "x$new_path" = x; then
39813 # It's still not found. Now this is an unrecoverable error.
39814 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
39815 $as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
39816 has_space=`$ECHO "$complete" | $GREP " "`
39817 if test "x$has_space" != x; then
39818 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
39819 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
39820 fi
39821 as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
39822 fi
39823 fi
39824
39825 # Now new_path has a complete unix path to the binary
39826 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
39827 # Keep paths in /bin as-is, but remove trailing .exe if any
39828 new_path="${new_path/%.exe/}"
39829 # Do not save /bin paths to all_fixpath_prefixes!
39830 else
40242 if test "x$new_path" = x; then
40243 # Oops. Which didn't find the executable.
40244 # The splitting of arguments from the executable at a space might have been incorrect,
40245 # since paths with space are more likely in Windows. Give it another try with the whole
40246 # argument.
40247 path="$complete"
40248 arguments="EOL"
40249 new_path="$path"
40250
40251 windows_path="$new_path"
40252 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40253 unix_path=`$CYGPATH -u "$windows_path"`
40254 new_path="$unix_path"
40255 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40256 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40257 new_path="$unix_path"
40258 fi
40259
40260
40261 new_path=`$WHICH "$new_path" 2> /dev/null`
40262
40263 if test "x$new_path" = x; then
40264 # It's still not found. Now this is an unrecoverable error.
40265 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&5
40266 $as_echo "$as_me: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&6;}
40267 has_space=`$ECHO "$complete" | $GREP " "`
40268 if test "x$has_space" != x; then
40269 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
40270 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
40271 fi
40272 as_fn_error $? "Cannot locate the the path of BUILD_LD" "$LINENO" 5
40273 fi
40274 fi
40275
40276 # Now new_path has a complete unix path to the binary
40277 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
40278 # Keep paths in /bin as-is, but remove trailing .exe if any
40279 new_path="${new_path/%.exe/}"
40280 # Do not save /bin paths to all_fixpath_prefixes!
40281 else
42570 ac_ext=cpp
42571 ac_cpp='$CXXCPP $CPPFLAGS'
42572 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
42573 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
42574 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
42575
42576 CXXFLAGS="$saved_cxxflags"
42577
42578 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
42579 $as_echo "$supports" >&6; }
42580 if test "x$supports" = "xyes" ; then
42581 COMPILER_SUPPORTS_TARGET_BITS_FLAG=true
42582 else
42583 COMPILER_SUPPORTS_TARGET_BITS_FLAG=false
42584 fi
42585
42586
42587
42588 case "${TOOLCHAIN_TYPE}" in
42589 microsoft)
42590 CFLAGS_WARNINGS_ARE_ERRORS="/WX"
42591 ;;
42592 solstudio)
42593 CFLAGS_WARNINGS_ARE_ERRORS="-errtags -errwarn=%all"
42594 ;;
42595 gcc)
42596 CFLAGS_WARNINGS_ARE_ERRORS="-Werror"
42597 ;;
42598 clang)
42599 CFLAGS_WARNINGS_ARE_ERRORS="-Werror"
42600 ;;
42601 esac
42602
42603
42604
42605 # Setup debug symbols (need objcopy from the toolchain for that)
42606
42607 #
42608 # ENABLE_DEBUG_SYMBOLS
42609 # This must be done after the toolchain is setup, since we're looking at objcopy.
42610 #
48652
48653 # Check whether --with-msvcr-dll was given.
48654 if test "${with_msvcr_dll+set}" = set; then :
48655 withval=$with_msvcr_dll;
48656 fi
48657
48658
48659 if test "x$with_msvcr_dll" != x; then
48660 # If given explicitely by user, do not probe. If not present, fail directly.
48661
48662 POSSIBLE_MSVCR_DLL="$with_msvcr_dll"
48663 METHOD="--with-msvcr-dll"
48664 if test -e "$POSSIBLE_MSVCR_DLL"; then
48665 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
48666 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
48667
48668 # Need to check if the found msvcr is correct architecture
48669 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
48670 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
48671 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
48672 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48673 CORRECT_MSVCR_ARCH=386
48674 else
48675 CORRECT_MSVCR_ARCH=x86-64
48676 fi
48677 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP $CORRECT_MSVCR_ARCH 2>&1 > /dev/null; then
48678 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48679 $as_echo "ok" >&6; }
48680 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
48681 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
48682 $as_echo_n "checking for msvcr100.dll... " >&6; }
48683 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
48684 $as_echo "$MSVCR_DLL" >&6; }
48685 else
48686 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48687 $as_echo "incorrect, ignoring" >&6; }
48688 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
48689 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
48690 fi
48691 fi
48692
48693 if test "x$MSVCR_DLL" = x; then
48694 as_fn_error $? "Could not find a proper msvcr100.dll as specified by --with-msvcr-dll" "$LINENO" 5
48695 fi
48696 fi
48697
48708 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48709 CYGWIN_VC_INSTALL_DIR="$unix_path"
48710 fi
48711
48712 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
48713 POSSIBLE_MSVCR_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x64/Microsoft.VC100.CRT/msvcr100.dll"
48714 else
48715 POSSIBLE_MSVCR_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x86/Microsoft.VC100.CRT/msvcr100.dll"
48716 fi
48717
48718 POSSIBLE_MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
48719 METHOD="well-known location in VCINSTALLDIR"
48720 if test -e "$POSSIBLE_MSVCR_DLL"; then
48721 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
48722 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
48723
48724 # Need to check if the found msvcr is correct architecture
48725 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
48726 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
48727 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
48728 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48729 CORRECT_MSVCR_ARCH=386
48730 else
48731 CORRECT_MSVCR_ARCH=x86-64
48732 fi
48733 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP $CORRECT_MSVCR_ARCH 2>&1 > /dev/null; then
48734 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48735 $as_echo "ok" >&6; }
48736 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
48737 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
48738 $as_echo_n "checking for msvcr100.dll... " >&6; }
48739 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
48740 $as_echo "$MSVCR_DLL" >&6; }
48741 else
48742 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48743 $as_echo "incorrect, ignoring" >&6; }
48744 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
48745 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
48746 fi
48747 fi
48748
48749 fi
48750 fi
48751
48752 if test "x$MSVCR_DLL" = x; then
48753 # Probe: Check in the Boot JDK directory.
48754 POSSIBLE_MSVCR_DLL="$BOOT_JDK/bin/msvcr100.dll"
48755
48756 POSSIBLE_MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
48757 METHOD="well-known location in Boot JDK"
48758 if test -e "$POSSIBLE_MSVCR_DLL"; then
48759 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
48760 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
48761
48762 # Need to check if the found msvcr is correct architecture
48763 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
48764 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
48765 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
48766 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48767 CORRECT_MSVCR_ARCH=386
48768 else
48769 CORRECT_MSVCR_ARCH=x86-64
48770 fi
48771 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP $CORRECT_MSVCR_ARCH 2>&1 > /dev/null; then
48772 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48773 $as_echo "ok" >&6; }
48774 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
48775 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
48776 $as_echo_n "checking for msvcr100.dll... " >&6; }
48777 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
48778 $as_echo "$MSVCR_DLL" >&6; }
48779 else
48780 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48781 $as_echo "incorrect, ignoring" >&6; }
48782 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
48783 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
48784 fi
48785 fi
48786
48787 fi
48788
48789 if test "x$MSVCR_DLL" = x; then
48790 # Probe: Look in the Windows system32 directory
48791 CYGWIN_SYSTEMROOT="$SYSTEMROOT"
48794 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48795 unix_path=`$CYGPATH -u "$windows_path"`
48796 CYGWIN_SYSTEMROOT="$unix_path"
48797 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48798 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48799 CYGWIN_SYSTEMROOT="$unix_path"
48800 fi
48801
48802 POSSIBLE_MSVCR_DLL="$CYGWIN_SYSTEMROOT/system32/msvcr100.dll"
48803
48804 POSSIBLE_MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
48805 METHOD="well-known location in SYSTEMROOT"
48806 if test -e "$POSSIBLE_MSVCR_DLL"; then
48807 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
48808 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
48809
48810 # Need to check if the found msvcr is correct architecture
48811 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
48812 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
48813 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
48814 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48815 CORRECT_MSVCR_ARCH=386
48816 else
48817 CORRECT_MSVCR_ARCH=x86-64
48818 fi
48819 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP $CORRECT_MSVCR_ARCH 2>&1 > /dev/null; then
48820 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48821 $as_echo "ok" >&6; }
48822 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
48823 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
48824 $as_echo_n "checking for msvcr100.dll... " >&6; }
48825 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
48826 $as_echo "$MSVCR_DLL" >&6; }
48827 else
48828 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48829 $as_echo "incorrect, ignoring" >&6; }
48830 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
48831 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
48832 fi
48833 fi
48834
48835 fi
48836
48837 if test "x$MSVCR_DLL" = x; then
48838 # Probe: If Visual Studio Express is installed, there is usually one with the debugger
48839 if test "x$VS100COMNTOOLS" != x; then
48847 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48848 CYGWIN_VS_TOOLS_DIR="$unix_path"
48849 fi
48850
48851 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
48852 POSSIBLE_MSVCR_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name msvcr100.dll | $GREP -i /x64/ | $HEAD --lines 1`
48853 else
48854 POSSIBLE_MSVCR_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name msvcr100.dll | $GREP -i /x86/ | $HEAD --lines 1`
48855 fi
48856
48857 POSSIBLE_MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
48858 METHOD="search of VS100COMNTOOLS"
48859 if test -e "$POSSIBLE_MSVCR_DLL"; then
48860 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
48861 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
48862
48863 # Need to check if the found msvcr is correct architecture
48864 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
48865 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
48866 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
48867 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48868 CORRECT_MSVCR_ARCH=386
48869 else
48870 CORRECT_MSVCR_ARCH=x86-64
48871 fi
48872 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP $CORRECT_MSVCR_ARCH 2>&1 > /dev/null; then
48873 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48874 $as_echo "ok" >&6; }
48875 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
48876 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
48877 $as_echo_n "checking for msvcr100.dll... " >&6; }
48878 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
48879 $as_echo "$MSVCR_DLL" >&6; }
48880 else
48881 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48882 $as_echo "incorrect, ignoring" >&6; }
48883 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
48884 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
48885 fi
48886 fi
48887
48888 fi
48889 fi
48890
48891 if test "x$MSVCR_DLL" = x; then
48892 # Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now.
48896 POSSIBLE_MSVCR_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name msvcr100.dll | $GREP x64 | $HEAD --lines 1`
48897 else
48898 POSSIBLE_MSVCR_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name msvcr100.dll | $GREP x86 | $GREP -v ia64 | $GREP -v x64 | $HEAD --lines 1`
48899 if test "x$POSSIBLE_MSVCR_DLL" = x; then
48900 # We're grasping at straws now...
48901 POSSIBLE_MSVCR_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name msvcr100.dll | $HEAD --lines 1`
48902 fi
48903 fi
48904
48905
48906 POSSIBLE_MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
48907 METHOD="search of VCINSTALLDIR"
48908 if test -e "$POSSIBLE_MSVCR_DLL"; then
48909 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
48910 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
48911
48912 # Need to check if the found msvcr is correct architecture
48913 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
48914 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
48915 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
48916 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48917 CORRECT_MSVCR_ARCH=386
48918 else
48919 CORRECT_MSVCR_ARCH=x86-64
48920 fi
48921 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP $CORRECT_MSVCR_ARCH 2>&1 > /dev/null; then
48922 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48923 $as_echo "ok" >&6; }
48924 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
48925 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
48926 $as_echo_n "checking for msvcr100.dll... " >&6; }
48927 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
48928 $as_echo "$MSVCR_DLL" >&6; }
48929 else
48930 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48931 $as_echo "incorrect, ignoring" >&6; }
48932 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
48933 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
48934 fi
48935 fi
48936
48937 fi
48938 fi
48939
48940 if test "x$MSVCR_DLL" = x; then
48941 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
49844 CCACHE="CCACHE_COMPRESS=1 $SET_CCACHE_DIR CCACHE_SLOPPINESS=$CCACHE_SLOPPINESS $CCACHE"
49845 CCACHE_FLAGS=-fpch-preprocess
49846
49847 if test "x$SET_CCACHE_DIR" != x; then
49848 mkdir -p $CCACHE_DIR > /dev/null 2>&1
49849 chmod a+rwxs $CCACHE_DIR > /dev/null 2>&1
49850 fi
49851 fi
49852
49853 fi
49854
49855
49856 ###############################################################################
49857 #
49858 # And now the finish...
49859 #
49860 ###############################################################################
49861
49862 # Check for some common pitfalls
49863
49864 if test x"$OPENJDK_BUILD_OS" = xwindows; then
49865 file_to_test="$SRC_ROOT/LICENSE"
49866 if test `$STAT -c '%a' "$file_to_test"` -lt 400; then
49867 as_fn_error $? "Bad file permissions on src files. This is usually caused by cloning the repositories with a non cygwin hg in a directory not created in cygwin." "$LINENO" 5
49868 fi
49869 fi
49870
49871
49872 # Did user specify any unknown variables?
49873
49874 if test "x$CONFIGURE_OVERRIDDEN_VARIABLES" != x; then
49875 # Replace the separating ! with spaces before presenting for end user.
49876 unknown_variables=${CONFIGURE_OVERRIDDEN_VARIABLES//!/ }
49877 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: The following variables might be unknown to configure: $unknown_variables" >&5
49878 $as_echo "$as_me: WARNING: The following variables might be unknown to configure: $unknown_variables" >&2;}
49879 fi
49880
49881
49882 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if build directory is on local disk" >&5
49883 $as_echo_n "checking if build directory is on local disk... " >&6; }
49884
|
900 TOPDIR
901 PATH_SEP
902 ZERO_ARCHDEF
903 DEFINE_CROSS_COMPILE_ARCH
904 LP64
905 OPENJDK_TARGET_OS_EXPORT_DIR
906 OPENJDK_TARGET_OS_API_DIR
907 OPENJDK_TARGET_CPU_JLI_CFLAGS
908 OPENJDK_TARGET_CPU_OSARCH
909 OPENJDK_TARGET_CPU_ISADIR
910 OPENJDK_TARGET_CPU_LIBDIR
911 OPENJDK_TARGET_CPU_LEGACY_LIB
912 OPENJDK_TARGET_CPU_LEGACY
913 REQUIRED_OS_VERSION
914 REQUIRED_OS_NAME
915 COMPILE_TYPE
916 OPENJDK_TARGET_CPU_ENDIAN
917 OPENJDK_TARGET_CPU_BITS
918 OPENJDK_TARGET_CPU_ARCH
919 OPENJDK_TARGET_CPU
920 OPENJDK_TARGET_OS_ENV
921 OPENJDK_TARGET_OS_API
922 OPENJDK_TARGET_OS
923 OPENJDK_BUILD_CPU_ENDIAN
924 OPENJDK_BUILD_CPU_BITS
925 OPENJDK_BUILD_CPU_ARCH
926 OPENJDK_BUILD_CPU
927 OPENJDK_BUILD_OS_ENV
928 OPENJDK_BUILD_OS_API
929 OPENJDK_BUILD_OS
930 OPENJDK_BUILD_AUTOCONF_NAME
931 OPENJDK_TARGET_AUTOCONF_NAME
932 target_os
933 target_vendor
934 target_cpu
935 target
936 host_os
937 host_vendor
938 host_cpu
939 host
940 build_os
941 build_vendor
942 build_cpu
943 build
944 CPIO
945 SETFILE
946 DF
947 READLINK
948 CYGPATH
949 SED
950 FGREP
951 EGREP
952 GREP
953 AWK
954 XARGS
955 WHICH
956 WC
957 UNIQ
958 UNAME
959 TR
960 TOUCH
961 TEE
962 TAR
963 TAIL
964 SORT
965 SH
966 RM
967 PRINTF
968 NAWK
969 MV
970 MKTEMP
971 MKDIR
972 LS
973 LN
974 HEAD
975 FIND
976 FILE
977 EXPR
978 ECHO
979 DIRNAME
980 DIFF
981 DATE
982 CUT
983 CP
984 COMM
985 CMP
986 CHMOD
987 CAT
988 BASH
989 BASENAME
990 DATE_WHEN_CONFIGURED
991 CONFIGURE_COMMAND_LINE
992 target_alias
993 host_alias
994 build_alias
995 LIBS
996 ECHO_T
997 ECHO_N
998 ECHO_C
999 DEFS
1000 mandir
1001 localedir
1002 libdir
1101 with_dxsdk_include
1102 with_num_cores
1103 with_memory_size
1104 with_jobs
1105 with_sjavac_server_java
1106 enable_sjavac
1107 enable_precompiled_headers
1108 enable_ccache
1109 with_ccache_dir
1110 '
1111 ac_precious_vars='build_alias
1112 host_alias
1113 target_alias
1114 BASENAME
1115 BASH
1116 CAT
1117 CHMOD
1118 CMP
1119 COMM
1120 CP
1121 CUT
1122 DATE
1123 DIFF
1124 DIRNAME
1125 ECHO
1126 EXPR
1127 FILE
1128 FIND
1129 HEAD
1130 LN
1131 LS
1132 MKDIR
1133 MKTEMP
1134 MV
1135 NAWK
1136 PRINTF
1137 RM
1138 SH
1139 SORT
1140 TAIL
1141 TAR
1142 TEE
1143 TOUCH
1144 TR
1145 UNAME
1146 UNIQ
1147 WC
1148 WHICH
1149 XARGS
1150 AWK
1151 GREP
1152 EGREP
1153 FGREP
1154 SED
1155 CYGPATH
1156 READLINK
1157 DF
1158 SETFILE
1159 CPIO
1160 UNZIP
1161 ZIP
1162 LDD
1163 OTOOL
1164 READELF
1165 HG
1166 STAT
1167 TIME
1168 DSYMUTIL
1169 XATTR
1170 CODESIGN
1171 PKG_CONFIG
1172 JAVA
1173 JAVAC
1174 JAVAH
1175 JAR
1176 NATIVE2ASCII
1177 JARSIGNER
1178 CC
1179 CFLAGS
1969 compatibility and is ignored
1970 --with-num-cores number of cores in the build system, e.g.
1971 --with-num-cores=8 [probed]
1972 --with-memory-size memory (in MB) available in the build system, e.g.
1973 --with-memory-size=1024 [probed]
1974 --with-jobs number of parallel jobs to let make run [calculated
1975 based on cores and memory]
1976 --with-sjavac-server-java
1977 use this java binary for running the sjavac
1978 background server [Boot JDK java]
1979 --with-ccache-dir where to store ccache files [~/.ccache]
1980
1981 Some influential environment variables:
1982 BASENAME Override default value for BASENAME
1983 BASH Override default value for BASH
1984 CAT Override default value for CAT
1985 CHMOD Override default value for CHMOD
1986 CMP Override default value for CMP
1987 COMM Override default value for COMM
1988 CP Override default value for CP
1989 CUT Override default value for CUT
1990 DATE Override default value for DATE
1991 DIFF Override default value for DIFF
1992 DIRNAME Override default value for DIRNAME
1993 ECHO Override default value for ECHO
1994 EXPR Override default value for EXPR
1995 FILE Override default value for FILE
1996 FIND Override default value for FIND
1997 HEAD Override default value for HEAD
1998 LN Override default value for LN
1999 LS Override default value for LS
2000 MKDIR Override default value for MKDIR
2001 MKTEMP Override default value for MKTEMP
2002 MV Override default value for MV
2003 NAWK Override default value for NAWK
2004 PRINTF Override default value for PRINTF
2005 RM Override default value for RM
2006 SH Override default value for SH
2007 SORT Override default value for SORT
2008 TAIL Override default value for TAIL
2009 TAR Override default value for TAR
2010 TEE Override default value for TEE
2011 TOUCH Override default value for TOUCH
2012 TR Override default value for TR
2013 UNAME Override default value for UNAME
2014 UNIQ Override default value for UNIQ
2015 WC Override default value for WC
2016 WHICH Override default value for WHICH
2017 XARGS Override default value for XARGS
2018 AWK Override default value for AWK
2019 GREP Override default value for GREP
2020 EGREP Override default value for EGREP
2021 FGREP Override default value for FGREP
2022 SED Override default value for SED
2023 CYGPATH Override default value for CYGPATH
2024 READLINK Override default value for READLINK
2025 DF Override default value for DF
2026 SETFILE Override default value for SETFILE
2027 CPIO Override default value for CPIO
2028 UNZIP Override default value for UNZIP
2029 ZIP Override default value for ZIP
2030 LDD Override default value for LDD
2031 OTOOL Override default value for OTOOL
2032 READELF Override default value for READELF
2033 HG Override default value for HG
2034 STAT Override default value for STAT
2035 TIME Override default value for TIME
2036 DSYMUTIL Override default value for DSYMUTIL
2037 XATTR Override default value for XATTR
2038 CODESIGN Override default value for CODESIGN
2039 PKG_CONFIG path to pkg-config utility
2040 JAVA Override default value for JAVA
2041 JAVAC Override default value for JAVAC
2042 JAVAH Override default value for JAVAH
2043 JAR Override default value for JAR
2044 NATIVE2ASCII
2045 Override default value for NATIVE2ASCII
2046 JARSIGNER Override default value for JARSIGNER
2047 CC C compiler command
4296
4297 # Check if the VS env variables were setup prior to running configure.
4298 # If not, then find vcvarsall.bat and run it automatically, and integrate
4299 # the set env variables into the spec file.
4300
4301
4302
4303
4304
4305
4306
4307
4308
4309
4310 # This line needs to be here, verbatim, after all includes and the dummy hook
4311 # definitions. It is replaced with custom functionality when building
4312 # custom sources.
4313 #CUSTOM_AUTOCONF_INCLUDE
4314
4315 # Do not change or remove the following line, it is needed for consistency checks:
4316 DATE_WHEN_GENERATED=1407326260
4317
4318 ###############################################################################
4319 #
4320 # Initialization / Boot-strapping
4321 #
4322 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4323 # thus it jumps back and forth, each time gaining something needed later on.
4324 #
4325 ###############################################################################
4326
4327 # If we are requested to print additional help, do that and then exit.
4328 # This must be the very first call.
4329
4330 if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4331 $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4332 $PRINTF "Which are valid to use depends on the build platform.\n"
4333 for toolchain in $VALID_TOOLCHAINS_all; do
4334 # Use indirect variable referencing
4335 toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4336 TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
5701 fi
5702 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5703 $as_echo "$tool_specified" >&6; }
5704 fi
5705 fi
5706 fi
5707
5708
5709
5710 if test "x$CP" = x; then
5711 as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
5712 fi
5713
5714
5715
5716
5717
5718 # Publish this variable in the help.
5719
5720
5721 if test "x$CUT" = x; then
5722 # The variable is not set by user, try to locate tool using the code snippet
5723 for ac_prog in cut
5724 do
5725 # Extract the first word of "$ac_prog", so it can be a program name with args.
5726 set dummy $ac_prog; ac_word=$2
5727 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5728 $as_echo_n "checking for $ac_word... " >&6; }
5729 if ${ac_cv_path_CUT+:} false; then :
5730 $as_echo_n "(cached) " >&6
5731 else
5732 case $CUT in
5733 [\\/]* | ?:[\\/]*)
5734 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5735 ;;
5736 *)
5737 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5738 for as_dir in $PATH
5739 do
5740 IFS=$as_save_IFS
13170 else
13171 # Otherwise we believe it is a complete path. Use it as it is.
13172 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
13173 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
13174 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
13175 $as_echo_n "checking for SETFILE... " >&6; }
13176 if test ! -x "$tool_specified"; then
13177 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13178 $as_echo "not found" >&6; }
13179 as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
13180 fi
13181 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13182 $as_echo "$tool_specified" >&6; }
13183 fi
13184 fi
13185 fi
13186
13187
13188
13189
13190 # Publish this variable in the help.
13191
13192
13193 if test "x$CPIO" = x; then
13194 # The variable is not set by user, try to locate tool using the code snippet
13195 for ac_prog in cpio bsdcpio
13196 do
13197 # Extract the first word of "$ac_prog", so it can be a program name with args.
13198 set dummy $ac_prog; ac_word=$2
13199 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13200 $as_echo_n "checking for $ac_word... " >&6; }
13201 if ${ac_cv_path_CPIO+:} false; then :
13202 $as_echo_n "(cached) " >&6
13203 else
13204 case $CPIO in
13205 [\\/]* | ?:[\\/]*)
13206 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13207 ;;
13208 *)
13209 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13210 for as_dir in $PATH
13211 do
13212 IFS=$as_save_IFS
13213 test -z "$as_dir" && as_dir=.
13214 for ac_exec_ext in '' $ac_executable_extensions; do
13215 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13216 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13217 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13218 break 2
13219 fi
13220 done
13221 done
13222 IFS=$as_save_IFS
13223
13224 ;;
13225 esac
13226 fi
13227 CPIO=$ac_cv_path_CPIO
13228 if test -n "$CPIO"; then
13229 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13230 $as_echo "$CPIO" >&6; }
13231 else
13232 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13233 $as_echo "no" >&6; }
13234 fi
13235
13236
13237 test -n "$CPIO" && break
13238 done
13239
13240 else
13241 # The variable is set, but is it from the command line or the environment?
13242
13243 # Try to remove the string !CPIO! from our list.
13244 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
13245 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13246 # If it failed, the variable was not from the command line. Ignore it,
13247 # but warn the user (except for BASH, which is always set by the calling BASH).
13248 if test "xCPIO" != xBASH; then
13249 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
13250 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
13251 fi
13252 # Try to locate tool using the code snippet
13253 for ac_prog in cpio bsdcpio
13254 do
13255 # Extract the first word of "$ac_prog", so it can be a program name with args.
13256 set dummy $ac_prog; ac_word=$2
13257 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13258 $as_echo_n "checking for $ac_word... " >&6; }
13259 if ${ac_cv_path_CPIO+:} false; then :
13260 $as_echo_n "(cached) " >&6
13261 else
13262 case $CPIO in
13263 [\\/]* | ?:[\\/]*)
13264 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13265 ;;
13266 *)
13267 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13268 for as_dir in $PATH
13269 do
13270 IFS=$as_save_IFS
13271 test -z "$as_dir" && as_dir=.
13272 for ac_exec_ext in '' $ac_executable_extensions; do
13273 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13274 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13275 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13276 break 2
13277 fi
13278 done
13279 done
13280 IFS=$as_save_IFS
13281
13282 ;;
13283 esac
13284 fi
13285 CPIO=$ac_cv_path_CPIO
13286 if test -n "$CPIO"; then
13287 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13288 $as_echo "$CPIO" >&6; }
13289 else
13290 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13291 $as_echo "no" >&6; }
13292 fi
13293
13294
13295 test -n "$CPIO" && break
13296 done
13297
13298 else
13299 # If it succeeded, then it was overridden by the user. We will use it
13300 # for the tool.
13301
13302 # First remove it from the list of overridden variables, so we can test
13303 # for unknown variables in the end.
13304 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13305
13306 # Check if the provided tool contains a complete path.
13307 tool_specified="$CPIO"
13308 tool_basename="${tool_specified##*/}"
13309 if test "x$tool_basename" = "x$tool_specified"; then
13310 # A command without a complete path is provided, search $PATH.
13311 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
13312 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
13313 # Extract the first word of "$tool_basename", so it can be a program name with args.
13314 set dummy $tool_basename; ac_word=$2
13315 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13316 $as_echo_n "checking for $ac_word... " >&6; }
13317 if ${ac_cv_path_CPIO+:} false; then :
13318 $as_echo_n "(cached) " >&6
13319 else
13320 case $CPIO in
13321 [\\/]* | ?:[\\/]*)
13322 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13323 ;;
13324 *)
13325 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13326 for as_dir in $PATH
13327 do
13328 IFS=$as_save_IFS
13329 test -z "$as_dir" && as_dir=.
13330 for ac_exec_ext in '' $ac_executable_extensions; do
13331 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13332 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13333 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13334 break 2
13335 fi
13336 done
13337 done
13338 IFS=$as_save_IFS
13339
13340 ;;
13341 esac
13342 fi
13343 CPIO=$ac_cv_path_CPIO
13344 if test -n "$CPIO"; then
13345 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13346 $as_echo "$CPIO" >&6; }
13347 else
13348 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13349 $as_echo "no" >&6; }
13350 fi
13351
13352
13353 if test "x$CPIO" = x; then
13354 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13355 fi
13356 else
13357 # Otherwise we believe it is a complete path. Use it as it is.
13358 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
13359 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
13360 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
13361 $as_echo_n "checking for CPIO... " >&6; }
13362 if test ! -x "$tool_specified"; then
13363 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13364 $as_echo "not found" >&6; }
13365 as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
13366 fi
13367 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13368 $as_echo "$tool_specified" >&6; }
13369 fi
13370 fi
13371 fi
13372
13373
13374
13375
13376 # Now we can determine OpenJDK build and target platforms. This is required to
13377 # have early on.
13378 # Make sure we can run config.sub.
13379 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
13380 as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
13381
13382 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
13383 $as_echo_n "checking build system type... " >&6; }
13384 if ${ac_cv_build+:} false; then :
13385 $as_echo_n "(cached) " >&6
13386 else
13387 ac_build_alias=$build_alias
13388 test "x$ac_build_alias" = x &&
13389 ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
13390 test "x$ac_build_alias" = x &&
13391 as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
13392 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
13393 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
13394
13395 fi
13614 *)
13615 as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
13616 ;;
13617 esac
13618
13619 # ..and setup our own variables. (Do this explicitely to facilitate searching)
13620 OPENJDK_BUILD_OS="$VAR_OS"
13621 OPENJDK_BUILD_OS_API="$VAR_OS_API"
13622 OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
13623 OPENJDK_BUILD_CPU="$VAR_CPU"
13624 OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
13625 OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
13626 OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13627
13628
13629
13630
13631
13632
13633
13634
13635 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
13636 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
13637 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
13638 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
13639
13640 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13641
13642 case "$host_os" in
13643 *linux*)
13644 VAR_OS=linux
13645 VAR_OS_API=posix
13646 VAR_OS_ENV=linux
13647 ;;
13648 *solaris*)
13649 VAR_OS=solaris
13650 VAR_OS_API=posix
13651 VAR_OS_ENV=solaris
13652 ;;
13653 *darwin*)
13654 VAR_OS=macosx
13746 *)
13747 as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
13748 ;;
13749 esac
13750
13751 # ... and setup our own variables. (Do this explicitely to facilitate searching)
13752 OPENJDK_TARGET_OS="$VAR_OS"
13753 OPENJDK_TARGET_OS_API="$VAR_OS_API"
13754 OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
13755 OPENJDK_TARGET_CPU="$VAR_CPU"
13756 OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
13757 OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
13758 OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13759
13760
13761
13762
13763
13764
13765
13766
13767 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
13768 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
13769 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
13770 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
13771
13772
13773
13774 # Check whether --with-target-bits was given.
13775 if test "${with_target_bits+set}" = set; then :
13776 withval=$with_target_bits;
13777 fi
13778
13779
13780 # We have three types of compiles:
13781 # native == normal compilation, target system == build system
13782 # cross == traditional cross compilation, target system != build system; special toolchain needed
13783 # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
13784 #
13785 if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
13786 # We're doing a proper cross-compilation
15583 if test "x$new_path" = x; then
15584 # Oops. Which didn't find the executable.
15585 # The splitting of arguments from the executable at a space might have been incorrect,
15586 # since paths with space are more likely in Windows. Give it another try with the whole
15587 # argument.
15588 path="$complete"
15589 arguments="EOL"
15590 new_path="$path"
15591
15592 windows_path="$new_path"
15593 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15594 unix_path=`$CYGPATH -u "$windows_path"`
15595 new_path="$unix_path"
15596 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15597 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15598 new_path="$unix_path"
15599 fi
15600
15601
15602 new_path=`$WHICH "$new_path" 2> /dev/null`
15603 # bat and cmd files are not always considered executable in MSYS causing which
15604 # to not find them
15605 if test "x$new_path" = x \
15606 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15607 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15608 new_path="$path"
15609
15610 windows_path="$new_path"
15611 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15612 unix_path=`$CYGPATH -u "$windows_path"`
15613 new_path="$unix_path"
15614 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15615 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15616 new_path="$unix_path"
15617 fi
15618
15619 fi
15620
15621 if test "x$new_path" = x; then
15622 # It's still not found. Now this is an unrecoverable error.
15623 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15624 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15625 has_space=`$ECHO "$complete" | $GREP " "`
15626 if test "x$has_space" != x; then
15627 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15628 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15629 fi
15630 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15631 fi
15632 fi
15633
15634 # Now new_path has a complete unix path to the binary
15635 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15636 # Keep paths in /bin as-is, but remove trailing .exe if any
15637 new_path="${new_path/%.exe/}"
15638 # Do not save /bin paths to all_fixpath_prefixes!
15639 else
15956 if test "x$new_path" = x; then
15957 # Oops. Which didn't find the executable.
15958 # The splitting of arguments from the executable at a space might have been incorrect,
15959 # since paths with space are more likely in Windows. Give it another try with the whole
15960 # argument.
15961 path="$complete"
15962 arguments="EOL"
15963 new_path="$path"
15964
15965 windows_path="$new_path"
15966 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15967 unix_path=`$CYGPATH -u "$windows_path"`
15968 new_path="$unix_path"
15969 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15970 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15971 new_path="$unix_path"
15972 fi
15973
15974
15975 new_path=`$WHICH "$new_path" 2> /dev/null`
15976 # bat and cmd files are not always considered executable in MSYS causing which
15977 # to not find them
15978 if test "x$new_path" = x \
15979 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15980 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15981 new_path="$path"
15982
15983 windows_path="$new_path"
15984 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15985 unix_path=`$CYGPATH -u "$windows_path"`
15986 new_path="$unix_path"
15987 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15988 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15989 new_path="$unix_path"
15990 fi
15991
15992 fi
15993
15994 if test "x$new_path" = x; then
15995 # It's still not found. Now this is an unrecoverable error.
15996 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15997 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15998 has_space=`$ECHO "$complete" | $GREP " "`
15999 if test "x$has_space" != x; then
16000 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16001 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16002 fi
16003 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16004 fi
16005 fi
16006
16007 # Now new_path has a complete unix path to the binary
16008 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16009 # Keep paths in /bin as-is, but remove trailing .exe if any
16010 new_path="${new_path/%.exe/}"
16011 # Do not save /bin paths to all_fixpath_prefixes!
16012 else
16326 if test "x$new_path" = x; then
16327 # Oops. Which didn't find the executable.
16328 # The splitting of arguments from the executable at a space might have been incorrect,
16329 # since paths with space are more likely in Windows. Give it another try with the whole
16330 # argument.
16331 path="$complete"
16332 arguments="EOL"
16333 new_path="$path"
16334
16335 windows_path="$new_path"
16336 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16337 unix_path=`$CYGPATH -u "$windows_path"`
16338 new_path="$unix_path"
16339 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16340 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16341 new_path="$unix_path"
16342 fi
16343
16344
16345 new_path=`$WHICH "$new_path" 2> /dev/null`
16346 # bat and cmd files are not always considered executable in MSYS causing which
16347 # to not find them
16348 if test "x$new_path" = x \
16349 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16350 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16351 new_path="$path"
16352
16353 windows_path="$new_path"
16354 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16355 unix_path=`$CYGPATH -u "$windows_path"`
16356 new_path="$unix_path"
16357 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16358 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16359 new_path="$unix_path"
16360 fi
16361
16362 fi
16363
16364 if test "x$new_path" = x; then
16365 # It's still not found. Now this is an unrecoverable error.
16366 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16367 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16368 has_space=`$ECHO "$complete" | $GREP " "`
16369 if test "x$has_space" != x; then
16370 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16371 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16372 fi
16373 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16374 fi
16375 fi
16376
16377 # Now new_path has a complete unix path to the binary
16378 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16379 # Keep paths in /bin as-is, but remove trailing .exe if any
16380 new_path="${new_path/%.exe/}"
16381 # Do not save /bin paths to all_fixpath_prefixes!
16382 else
16701 if test "x$new_path" = x; then
16702 # Oops. Which didn't find the executable.
16703 # The splitting of arguments from the executable at a space might have been incorrect,
16704 # since paths with space are more likely in Windows. Give it another try with the whole
16705 # argument.
16706 path="$complete"
16707 arguments="EOL"
16708 new_path="$path"
16709
16710 windows_path="$new_path"
16711 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16712 unix_path=`$CYGPATH -u "$windows_path"`
16713 new_path="$unix_path"
16714 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16715 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16716 new_path="$unix_path"
16717 fi
16718
16719
16720 new_path=`$WHICH "$new_path" 2> /dev/null`
16721 # bat and cmd files are not always considered executable in MSYS causing which
16722 # to not find them
16723 if test "x$new_path" = x \
16724 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16725 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16726 new_path="$path"
16727
16728 windows_path="$new_path"
16729 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16730 unix_path=`$CYGPATH -u "$windows_path"`
16731 new_path="$unix_path"
16732 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16733 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16734 new_path="$unix_path"
16735 fi
16736
16737 fi
16738
16739 if test "x$new_path" = x; then
16740 # It's still not found. Now this is an unrecoverable error.
16741 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16742 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16743 has_space=`$ECHO "$complete" | $GREP " "`
16744 if test "x$has_space" != x; then
16745 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16746 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16747 fi
16748 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16749 fi
16750 fi
16751
16752 # Now new_path has a complete unix path to the binary
16753 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16754 # Keep paths in /bin as-is, but remove trailing .exe if any
16755 new_path="${new_path/%.exe/}"
16756 # Do not save /bin paths to all_fixpath_prefixes!
16757 else
17070 if test "x$new_path" = x; then
17071 # Oops. Which didn't find the executable.
17072 # The splitting of arguments from the executable at a space might have been incorrect,
17073 # since paths with space are more likely in Windows. Give it another try with the whole
17074 # argument.
17075 path="$complete"
17076 arguments="EOL"
17077 new_path="$path"
17078
17079 windows_path="$new_path"
17080 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17081 unix_path=`$CYGPATH -u "$windows_path"`
17082 new_path="$unix_path"
17083 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17084 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17085 new_path="$unix_path"
17086 fi
17087
17088
17089 new_path=`$WHICH "$new_path" 2> /dev/null`
17090 # bat and cmd files are not always considered executable in MSYS causing which
17091 # to not find them
17092 if test "x$new_path" = x \
17093 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17094 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17095 new_path="$path"
17096
17097 windows_path="$new_path"
17098 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17099 unix_path=`$CYGPATH -u "$windows_path"`
17100 new_path="$unix_path"
17101 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17102 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17103 new_path="$unix_path"
17104 fi
17105
17106 fi
17107
17108 if test "x$new_path" = x; then
17109 # It's still not found. Now this is an unrecoverable error.
17110 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17111 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17112 has_space=`$ECHO "$complete" | $GREP " "`
17113 if test "x$has_space" != x; then
17114 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17115 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17116 fi
17117 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17118 fi
17119 fi
17120
17121 # Now new_path has a complete unix path to the binary
17122 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17123 # Keep paths in /bin as-is, but remove trailing .exe if any
17124 new_path="${new_path/%.exe/}"
17125 # Do not save /bin paths to all_fixpath_prefixes!
17126 else
27513 if test "x$new_path" = x; then
27514 # Oops. Which didn't find the executable.
27515 # The splitting of arguments from the executable at a space might have been incorrect,
27516 # since paths with space are more likely in Windows. Give it another try with the whole
27517 # argument.
27518 path="$complete"
27519 arguments="EOL"
27520 new_path="$path"
27521
27522 windows_path="$new_path"
27523 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27524 unix_path=`$CYGPATH -u "$windows_path"`
27525 new_path="$unix_path"
27526 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27527 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27528 new_path="$unix_path"
27529 fi
27530
27531
27532 new_path=`$WHICH "$new_path" 2> /dev/null`
27533 # bat and cmd files are not always considered executable in MSYS causing which
27534 # to not find them
27535 if test "x$new_path" = x \
27536 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
27537 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
27538 new_path="$path"
27539
27540 windows_path="$new_path"
27541 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27542 unix_path=`$CYGPATH -u "$windows_path"`
27543 new_path="$unix_path"
27544 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27545 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27546 new_path="$unix_path"
27547 fi
27548
27549 fi
27550
27551 if test "x$new_path" = x; then
27552 # It's still not found. Now this is an unrecoverable error.
27553 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
27554 $as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
27555 has_space=`$ECHO "$complete" | $GREP " "`
27556 if test "x$has_space" != x; then
27557 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
27558 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
27559 fi
27560 as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
27561 fi
27562 fi
27563
27564 # Now new_path has a complete unix path to the binary
27565 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
27566 # Keep paths in /bin as-is, but remove trailing .exe if any
27567 new_path="${new_path/%.exe/}"
27568 # Do not save /bin paths to all_fixpath_prefixes!
27569 else
28173 if test "x$new_path" = x; then
28174 # Oops. Which didn't find the executable.
28175 # The splitting of arguments from the executable at a space might have been incorrect,
28176 # since paths with space are more likely in Windows. Give it another try with the whole
28177 # argument.
28178 path="$complete"
28179 arguments="EOL"
28180 new_path="$path"
28181
28182 windows_path="$new_path"
28183 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28184 unix_path=`$CYGPATH -u "$windows_path"`
28185 new_path="$unix_path"
28186 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28187 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
28188 new_path="$unix_path"
28189 fi
28190
28191
28192 new_path=`$WHICH "$new_path" 2> /dev/null`
28193 # bat and cmd files are not always considered executable in MSYS causing which
28194 # to not find them
28195 if test "x$new_path" = x \
28196 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
28197 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
28198 new_path="$path"
28199
28200 windows_path="$new_path"
28201 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28202 unix_path=`$CYGPATH -u "$windows_path"`
28203 new_path="$unix_path"
28204 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28205 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
28206 new_path="$unix_path"
28207 fi
28208
28209 fi
28210
28211 if test "x$new_path" = x; then
28212 # It's still not found. Now this is an unrecoverable error.
28213 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
28214 $as_echo "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
28215 has_space=`$ECHO "$complete" | $GREP " "`
28216 if test "x$has_space" != x; then
28217 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
28218 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
28219 fi
28220 as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
28221 fi
28222 fi
28223
28224 # Now new_path has a complete unix path to the binary
28225 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
28226 # Keep paths in /bin as-is, but remove trailing .exe if any
28227 new_path="${new_path/%.exe/}"
28228 # Do not save /bin paths to all_fixpath_prefixes!
28229 else
28630 if test "x$new_path" = x; then
28631 # Oops. Which didn't find the executable.
28632 # The splitting of arguments from the executable at a space might have been incorrect,
28633 # since paths with space are more likely in Windows. Give it another try with the whole
28634 # argument.
28635 path="$complete"
28636 arguments="EOL"
28637 new_path="$path"
28638
28639 windows_path="$new_path"
28640 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28641 unix_path=`$CYGPATH -u "$windows_path"`
28642 new_path="$unix_path"
28643 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28644 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
28645 new_path="$unix_path"
28646 fi
28647
28648
28649 new_path=`$WHICH "$new_path" 2> /dev/null`
28650 # bat and cmd files are not always considered executable in MSYS causing which
28651 # to not find them
28652 if test "x$new_path" = x \
28653 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
28654 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
28655 new_path="$path"
28656
28657 windows_path="$new_path"
28658 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28659 unix_path=`$CYGPATH -u "$windows_path"`
28660 new_path="$unix_path"
28661 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28662 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
28663 new_path="$unix_path"
28664 fi
28665
28666 fi
28667
28668 if test "x$new_path" = x; then
28669 # It's still not found. Now this is an unrecoverable error.
28670 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&5
28671 $as_echo "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&6;}
28672 has_space=`$ECHO "$complete" | $GREP " "`
28673 if test "x$has_space" != x; then
28674 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
28675 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
28676 fi
28677 as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CC" "$LINENO" 5
28678 fi
28679 fi
28680
28681 # Now new_path has a complete unix path to the binary
28682 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
28683 # Keep paths in /bin as-is, but remove trailing .exe if any
28684 new_path="${new_path/%.exe/}"
28685 # Do not save /bin paths to all_fixpath_prefixes!
28686 else
29913 if test "x$new_path" = x; then
29914 # Oops. Which didn't find the executable.
29915 # The splitting of arguments from the executable at a space might have been incorrect,
29916 # since paths with space are more likely in Windows. Give it another try with the whole
29917 # argument.
29918 path="$complete"
29919 arguments="EOL"
29920 new_path="$path"
29921
29922 windows_path="$new_path"
29923 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
29924 unix_path=`$CYGPATH -u "$windows_path"`
29925 new_path="$unix_path"
29926 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29927 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
29928 new_path="$unix_path"
29929 fi
29930
29931
29932 new_path=`$WHICH "$new_path" 2> /dev/null`
29933 # bat and cmd files are not always considered executable in MSYS causing which
29934 # to not find them
29935 if test "x$new_path" = x \
29936 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
29937 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
29938 new_path="$path"
29939
29940 windows_path="$new_path"
29941 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
29942 unix_path=`$CYGPATH -u "$windows_path"`
29943 new_path="$unix_path"
29944 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29945 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
29946 new_path="$unix_path"
29947 fi
29948
29949 fi
29950
29951 if test "x$new_path" = x; then
29952 # It's still not found. Now this is an unrecoverable error.
29953 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
29954 $as_echo "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
29955 has_space=`$ECHO "$complete" | $GREP " "`
29956 if test "x$has_space" != x; then
29957 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
29958 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
29959 fi
29960 as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
29961 fi
29962 fi
29963
29964 # Now new_path has a complete unix path to the binary
29965 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
29966 # Keep paths in /bin as-is, but remove trailing .exe if any
29967 new_path="${new_path/%.exe/}"
29968 # Do not save /bin paths to all_fixpath_prefixes!
29969 else
30370 if test "x$new_path" = x; then
30371 # Oops. Which didn't find the executable.
30372 # The splitting of arguments from the executable at a space might have been incorrect,
30373 # since paths with space are more likely in Windows. Give it another try with the whole
30374 # argument.
30375 path="$complete"
30376 arguments="EOL"
30377 new_path="$path"
30378
30379 windows_path="$new_path"
30380 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
30381 unix_path=`$CYGPATH -u "$windows_path"`
30382 new_path="$unix_path"
30383 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
30384 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
30385 new_path="$unix_path"
30386 fi
30387
30388
30389 new_path=`$WHICH "$new_path" 2> /dev/null`
30390 # bat and cmd files are not always considered executable in MSYS causing which
30391 # to not find them
30392 if test "x$new_path" = x \
30393 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
30394 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
30395 new_path="$path"
30396
30397 windows_path="$new_path"
30398 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
30399 unix_path=`$CYGPATH -u "$windows_path"`
30400 new_path="$unix_path"
30401 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
30402 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
30403 new_path="$unix_path"
30404 fi
30405
30406 fi
30407
30408 if test "x$new_path" = x; then
30409 # It's still not found. Now this is an unrecoverable error.
30410 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&5
30411 $as_echo "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&6;}
30412 has_space=`$ECHO "$complete" | $GREP " "`
30413 if test "x$has_space" != x; then
30414 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
30415 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
30416 fi
30417 as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CXX" "$LINENO" 5
30418 fi
30419 fi
30420
30421 # Now new_path has a complete unix path to the binary
30422 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
30423 # Keep paths in /bin as-is, but remove trailing .exe if any
30424 new_path="${new_path/%.exe/}"
30425 # Do not save /bin paths to all_fixpath_prefixes!
30426 else
31232 if test "x$new_path" = x; then
31233 # Oops. Which didn't find the executable.
31234 # The splitting of arguments from the executable at a space might have been incorrect,
31235 # since paths with space are more likely in Windows. Give it another try with the whole
31236 # argument.
31237 path="$complete"
31238 arguments="EOL"
31239 new_path="$path"
31240
31241 windows_path="$new_path"
31242 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31243 unix_path=`$CYGPATH -u "$windows_path"`
31244 new_path="$unix_path"
31245 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31246 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31247 new_path="$unix_path"
31248 fi
31249
31250
31251 new_path=`$WHICH "$new_path" 2> /dev/null`
31252 # bat and cmd files are not always considered executable in MSYS causing which
31253 # to not find them
31254 if test "x$new_path" = x \
31255 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
31256 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
31257 new_path="$path"
31258
31259 windows_path="$new_path"
31260 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31261 unix_path=`$CYGPATH -u "$windows_path"`
31262 new_path="$unix_path"
31263 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31264 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31265 new_path="$unix_path"
31266 fi
31267
31268 fi
31269
31270 if test "x$new_path" = x; then
31271 # It's still not found. Now this is an unrecoverable error.
31272 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
31273 $as_echo "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
31274 has_space=`$ECHO "$complete" | $GREP " "`
31275 if test "x$has_space" != x; then
31276 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
31277 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
31278 fi
31279 as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
31280 fi
31281 fi
31282
31283 # Now new_path has a complete unix path to the binary
31284 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
31285 # Keep paths in /bin as-is, but remove trailing .exe if any
31286 new_path="${new_path/%.exe/}"
31287 # Do not save /bin paths to all_fixpath_prefixes!
31288 else
31647 if test "x$new_path" = x; then
31648 # Oops. Which didn't find the executable.
31649 # The splitting of arguments from the executable at a space might have been incorrect,
31650 # since paths with space are more likely in Windows. Give it another try with the whole
31651 # argument.
31652 path="$complete"
31653 arguments="EOL"
31654 new_path="$path"
31655
31656 windows_path="$new_path"
31657 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31658 unix_path=`$CYGPATH -u "$windows_path"`
31659 new_path="$unix_path"
31660 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31661 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31662 new_path="$unix_path"
31663 fi
31664
31665
31666 new_path=`$WHICH "$new_path" 2> /dev/null`
31667 # bat and cmd files are not always considered executable in MSYS causing which
31668 # to not find them
31669 if test "x$new_path" = x \
31670 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
31671 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
31672 new_path="$path"
31673
31674 windows_path="$new_path"
31675 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31676 unix_path=`$CYGPATH -u "$windows_path"`
31677 new_path="$unix_path"
31678 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31679 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31680 new_path="$unix_path"
31681 fi
31682
31683 fi
31684
31685 if test "x$new_path" = x; then
31686 # It's still not found. Now this is an unrecoverable error.
31687 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
31688 $as_echo "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
31689 has_space=`$ECHO "$complete" | $GREP " "`
31690 if test "x$has_space" != x; then
31691 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
31692 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
31693 fi
31694 as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
31695 fi
31696 fi
31697
31698 # Now new_path has a complete unix path to the binary
31699 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
31700 # Keep paths in /bin as-is, but remove trailing .exe if any
31701 new_path="${new_path/%.exe/}"
31702 # Do not save /bin paths to all_fixpath_prefixes!
31703 else
31991 if test "x$new_path" = x; then
31992 # Oops. Which didn't find the executable.
31993 # The splitting of arguments from the executable at a space might have been incorrect,
31994 # since paths with space are more likely in Windows. Give it another try with the whole
31995 # argument.
31996 path="$complete"
31997 arguments="EOL"
31998 new_path="$path"
31999
32000 windows_path="$new_path"
32001 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32002 unix_path=`$CYGPATH -u "$windows_path"`
32003 new_path="$unix_path"
32004 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32005 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32006 new_path="$unix_path"
32007 fi
32008
32009
32010 new_path=`$WHICH "$new_path" 2> /dev/null`
32011 # bat and cmd files are not always considered executable in MSYS causing which
32012 # to not find them
32013 if test "x$new_path" = x \
32014 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
32015 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
32016 new_path="$path"
32017
32018 windows_path="$new_path"
32019 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32020 unix_path=`$CYGPATH -u "$windows_path"`
32021 new_path="$unix_path"
32022 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32023 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32024 new_path="$unix_path"
32025 fi
32026
32027 fi
32028
32029 if test "x$new_path" = x; then
32030 # It's still not found. Now this is an unrecoverable error.
32031 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
32032 $as_echo "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
32033 has_space=`$ECHO "$complete" | $GREP " "`
32034 if test "x$has_space" != x; then
32035 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
32036 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
32037 fi
32038 as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
32039 fi
32040 fi
32041
32042 # Now new_path has a complete unix path to the binary
32043 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
32044 # Keep paths in /bin as-is, but remove trailing .exe if any
32045 new_path="${new_path/%.exe/}"
32046 # Do not save /bin paths to all_fixpath_prefixes!
32047 else
32486 if test "x$new_path" = x; then
32487 # Oops. Which didn't find the executable.
32488 # The splitting of arguments from the executable at a space might have been incorrect,
32489 # since paths with space are more likely in Windows. Give it another try with the whole
32490 # argument.
32491 path="$complete"
32492 arguments="EOL"
32493 new_path="$path"
32494
32495 windows_path="$new_path"
32496 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32497 unix_path=`$CYGPATH -u "$windows_path"`
32498 new_path="$unix_path"
32499 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32500 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32501 new_path="$unix_path"
32502 fi
32503
32504
32505 new_path=`$WHICH "$new_path" 2> /dev/null`
32506 # bat and cmd files are not always considered executable in MSYS causing which
32507 # to not find them
32508 if test "x$new_path" = x \
32509 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
32510 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
32511 new_path="$path"
32512
32513 windows_path="$new_path"
32514 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32515 unix_path=`$CYGPATH -u "$windows_path"`
32516 new_path="$unix_path"
32517 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32518 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32519 new_path="$unix_path"
32520 fi
32521
32522 fi
32523
32524 if test "x$new_path" = x; then
32525 # It's still not found. Now this is an unrecoverable error.
32526 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
32527 $as_echo "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
32528 has_space=`$ECHO "$complete" | $GREP " "`
32529 if test "x$has_space" != x; then
32530 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
32531 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
32532 fi
32533 as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
32534 fi
32535 fi
32536
32537 # Now new_path has a complete unix path to the binary
32538 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
32539 # Keep paths in /bin as-is, but remove trailing .exe if any
32540 new_path="${new_path/%.exe/}"
32541 # Do not save /bin paths to all_fixpath_prefixes!
32542 else
33114 if test "x$new_path" = x; then
33115 # Oops. Which didn't find the executable.
33116 # The splitting of arguments from the executable at a space might have been incorrect,
33117 # since paths with space are more likely in Windows. Give it another try with the whole
33118 # argument.
33119 path="$complete"
33120 arguments="EOL"
33121 new_path="$path"
33122
33123 windows_path="$new_path"
33124 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
33125 unix_path=`$CYGPATH -u "$windows_path"`
33126 new_path="$unix_path"
33127 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33128 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
33129 new_path="$unix_path"
33130 fi
33131
33132
33133 new_path=`$WHICH "$new_path" 2> /dev/null`
33134 # bat and cmd files are not always considered executable in MSYS causing which
33135 # to not find them
33136 if test "x$new_path" = x \
33137 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
33138 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
33139 new_path="$path"
33140
33141 windows_path="$new_path"
33142 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
33143 unix_path=`$CYGPATH -u "$windows_path"`
33144 new_path="$unix_path"
33145 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33146 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
33147 new_path="$unix_path"
33148 fi
33149
33150 fi
33151
33152 if test "x$new_path" = x; then
33153 # It's still not found. Now this is an unrecoverable error.
33154 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
33155 $as_echo "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
33156 has_space=`$ECHO "$complete" | $GREP " "`
33157 if test "x$has_space" != x; then
33158 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
33159 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
33160 fi
33161 as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
33162 fi
33163 fi
33164
33165 # Now new_path has a complete unix path to the binary
33166 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
33167 # Keep paths in /bin as-is, but remove trailing .exe if any
33168 new_path="${new_path/%.exe/}"
33169 # Do not save /bin paths to all_fixpath_prefixes!
33170 else
33650 if test "x$new_path" = x; then
33651 # Oops. Which didn't find the executable.
33652 # The splitting of arguments from the executable at a space might have been incorrect,
33653 # since paths with space are more likely in Windows. Give it another try with the whole
33654 # argument.
33655 path="$complete"
33656 arguments="EOL"
33657 new_path="$path"
33658
33659 windows_path="$new_path"
33660 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
33661 unix_path=`$CYGPATH -u "$windows_path"`
33662 new_path="$unix_path"
33663 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33664 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
33665 new_path="$unix_path"
33666 fi
33667
33668
33669 new_path=`$WHICH "$new_path" 2> /dev/null`
33670 # bat and cmd files are not always considered executable in MSYS causing which
33671 # to not find them
33672 if test "x$new_path" = x \
33673 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
33674 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
33675 new_path="$path"
33676
33677 windows_path="$new_path"
33678 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
33679 unix_path=`$CYGPATH -u "$windows_path"`
33680 new_path="$unix_path"
33681 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33682 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
33683 new_path="$unix_path"
33684 fi
33685
33686 fi
33687
33688 if test "x$new_path" = x; then
33689 # It's still not found. Now this is an unrecoverable error.
33690 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$complete\", is not found." >&5
33691 $as_echo "$as_me: The path of OBJC, which resolves as \"$complete\", is not found." >&6;}
33692 has_space=`$ECHO "$complete" | $GREP " "`
33693 if test "x$has_space" != x; then
33694 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
33695 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
33696 fi
33697 as_fn_error $? "Cannot locate the the path of OBJC" "$LINENO" 5
33698 fi
33699 fi
33700
33701 # Now new_path has a complete unix path to the binary
33702 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
33703 # Keep paths in /bin as-is, but remove trailing .exe if any
33704 new_path="${new_path/%.exe/}"
33705 # Do not save /bin paths to all_fixpath_prefixes!
33706 else
34118 if test "x$new_path" = x; then
34119 # Oops. Which didn't find the executable.
34120 # The splitting of arguments from the executable at a space might have been incorrect,
34121 # since paths with space are more likely in Windows. Give it another try with the whole
34122 # argument.
34123 path="$complete"
34124 arguments="EOL"
34125 new_path="$path"
34126
34127 windows_path="$new_path"
34128 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34129 unix_path=`$CYGPATH -u "$windows_path"`
34130 new_path="$unix_path"
34131 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34132 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34133 new_path="$unix_path"
34134 fi
34135
34136
34137 new_path=`$WHICH "$new_path" 2> /dev/null`
34138 # bat and cmd files are not always considered executable in MSYS causing which
34139 # to not find them
34140 if test "x$new_path" = x \
34141 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
34142 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
34143 new_path="$path"
34144
34145 windows_path="$new_path"
34146 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34147 unix_path=`$CYGPATH -u "$windows_path"`
34148 new_path="$unix_path"
34149 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34150 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34151 new_path="$unix_path"
34152 fi
34153
34154 fi
34155
34156 if test "x$new_path" = x; then
34157 # It's still not found. Now this is an unrecoverable error.
34158 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
34159 $as_echo "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
34160 has_space=`$ECHO "$complete" | $GREP " "`
34161 if test "x$has_space" != x; then
34162 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
34163 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
34164 fi
34165 as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
34166 fi
34167 fi
34168
34169 # Now new_path has a complete unix path to the binary
34170 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
34171 # Keep paths in /bin as-is, but remove trailing .exe if any
34172 new_path="${new_path/%.exe/}"
34173 # Do not save /bin paths to all_fixpath_prefixes!
34174 else
34459 if test "x$new_path" = x; then
34460 # Oops. Which didn't find the executable.
34461 # The splitting of arguments from the executable at a space might have been incorrect,
34462 # since paths with space are more likely in Windows. Give it another try with the whole
34463 # argument.
34464 path="$complete"
34465 arguments="EOL"
34466 new_path="$path"
34467
34468 windows_path="$new_path"
34469 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34470 unix_path=`$CYGPATH -u "$windows_path"`
34471 new_path="$unix_path"
34472 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34473 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34474 new_path="$unix_path"
34475 fi
34476
34477
34478 new_path=`$WHICH "$new_path" 2> /dev/null`
34479 # bat and cmd files are not always considered executable in MSYS causing which
34480 # to not find them
34481 if test "x$new_path" = x \
34482 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
34483 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
34484 new_path="$path"
34485
34486 windows_path="$new_path"
34487 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34488 unix_path=`$CYGPATH -u "$windows_path"`
34489 new_path="$unix_path"
34490 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34491 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34492 new_path="$unix_path"
34493 fi
34494
34495 fi
34496
34497 if test "x$new_path" = x; then
34498 # It's still not found. Now this is an unrecoverable error.
34499 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
34500 $as_echo "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
34501 has_space=`$ECHO "$complete" | $GREP " "`
34502 if test "x$has_space" != x; then
34503 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
34504 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
34505 fi
34506 as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
34507 fi
34508 fi
34509
34510 # Now new_path has a complete unix path to the binary
34511 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
34512 # Keep paths in /bin as-is, but remove trailing .exe if any
34513 new_path="${new_path/%.exe/}"
34514 # Do not save /bin paths to all_fixpath_prefixes!
34515 else
34796 if test "x$new_path" = x; then
34797 # Oops. Which didn't find the executable.
34798 # The splitting of arguments from the executable at a space might have been incorrect,
34799 # since paths with space are more likely in Windows. Give it another try with the whole
34800 # argument.
34801 path="$complete"
34802 arguments="EOL"
34803 new_path="$path"
34804
34805 windows_path="$new_path"
34806 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34807 unix_path=`$CYGPATH -u "$windows_path"`
34808 new_path="$unix_path"
34809 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34810 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34811 new_path="$unix_path"
34812 fi
34813
34814
34815 new_path=`$WHICH "$new_path" 2> /dev/null`
34816 # bat and cmd files are not always considered executable in MSYS causing which
34817 # to not find them
34818 if test "x$new_path" = x \
34819 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
34820 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
34821 new_path="$path"
34822
34823 windows_path="$new_path"
34824 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34825 unix_path=`$CYGPATH -u "$windows_path"`
34826 new_path="$unix_path"
34827 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34828 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34829 new_path="$unix_path"
34830 fi
34831
34832 fi
34833
34834 if test "x$new_path" = x; then
34835 # It's still not found. Now this is an unrecoverable error.
34836 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
34837 $as_echo "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
34838 has_space=`$ECHO "$complete" | $GREP " "`
34839 if test "x$has_space" != x; then
34840 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
34841 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
34842 fi
34843 as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
34844 fi
34845 fi
34846
34847 # Now new_path has a complete unix path to the binary
34848 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
34849 # Keep paths in /bin as-is, but remove trailing .exe if any
34850 new_path="${new_path/%.exe/}"
34851 # Do not save /bin paths to all_fixpath_prefixes!
34852 else
35115 if test "x$new_path" = x; then
35116 # Oops. Which didn't find the executable.
35117 # The splitting of arguments from the executable at a space might have been incorrect,
35118 # since paths with space are more likely in Windows. Give it another try with the whole
35119 # argument.
35120 path="$complete"
35121 arguments="EOL"
35122 new_path="$path"
35123
35124 windows_path="$new_path"
35125 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35126 unix_path=`$CYGPATH -u "$windows_path"`
35127 new_path="$unix_path"
35128 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35129 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
35130 new_path="$unix_path"
35131 fi
35132
35133
35134 new_path=`$WHICH "$new_path" 2> /dev/null`
35135 # bat and cmd files are not always considered executable in MSYS causing which
35136 # to not find them
35137 if test "x$new_path" = x \
35138 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
35139 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
35140 new_path="$path"
35141
35142 windows_path="$new_path"
35143 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35144 unix_path=`$CYGPATH -u "$windows_path"`
35145 new_path="$unix_path"
35146 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35147 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
35148 new_path="$unix_path"
35149 fi
35150
35151 fi
35152
35153 if test "x$new_path" = x; then
35154 # It's still not found. Now this is an unrecoverable error.
35155 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
35156 $as_echo "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
35157 has_space=`$ECHO "$complete" | $GREP " "`
35158 if test "x$has_space" != x; then
35159 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
35160 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
35161 fi
35162 as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
35163 fi
35164 fi
35165
35166 # Now new_path has a complete unix path to the binary
35167 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
35168 # Keep paths in /bin as-is, but remove trailing .exe if any
35169 new_path="${new_path/%.exe/}"
35170 # Do not save /bin paths to all_fixpath_prefixes!
35171 else
35586 if test "x$new_path" = x; then
35587 # Oops. Which didn't find the executable.
35588 # The splitting of arguments from the executable at a space might have been incorrect,
35589 # since paths with space are more likely in Windows. Give it another try with the whole
35590 # argument.
35591 path="$complete"
35592 arguments="EOL"
35593 new_path="$path"
35594
35595 windows_path="$new_path"
35596 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35597 unix_path=`$CYGPATH -u "$windows_path"`
35598 new_path="$unix_path"
35599 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35600 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
35601 new_path="$unix_path"
35602 fi
35603
35604
35605 new_path=`$WHICH "$new_path" 2> /dev/null`
35606 # bat and cmd files are not always considered executable in MSYS causing which
35607 # to not find them
35608 if test "x$new_path" = x \
35609 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
35610 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
35611 new_path="$path"
35612
35613 windows_path="$new_path"
35614 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35615 unix_path=`$CYGPATH -u "$windows_path"`
35616 new_path="$unix_path"
35617 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35618 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
35619 new_path="$unix_path"
35620 fi
35621
35622 fi
35623
35624 if test "x$new_path" = x; then
35625 # It's still not found. Now this is an unrecoverable error.
35626 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
35627 $as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
35628 has_space=`$ECHO "$complete" | $GREP " "`
35629 if test "x$has_space" != x; then
35630 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
35631 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
35632 fi
35633 as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
35634 fi
35635 fi
35636
35637 # Now new_path has a complete unix path to the binary
35638 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
35639 # Keep paths in /bin as-is, but remove trailing .exe if any
35640 new_path="${new_path/%.exe/}"
35641 # Do not save /bin paths to all_fixpath_prefixes!
35642 else
36054 if test "x$new_path" = x; then
36055 # Oops. Which didn't find the executable.
36056 # The splitting of arguments from the executable at a space might have been incorrect,
36057 # since paths with space are more likely in Windows. Give it another try with the whole
36058 # argument.
36059 path="$complete"
36060 arguments="EOL"
36061 new_path="$path"
36062
36063 windows_path="$new_path"
36064 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36065 unix_path=`$CYGPATH -u "$windows_path"`
36066 new_path="$unix_path"
36067 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36068 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36069 new_path="$unix_path"
36070 fi
36071
36072
36073 new_path=`$WHICH "$new_path" 2> /dev/null`
36074 # bat and cmd files are not always considered executable in MSYS causing which
36075 # to not find them
36076 if test "x$new_path" = x \
36077 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
36078 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
36079 new_path="$path"
36080
36081 windows_path="$new_path"
36082 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36083 unix_path=`$CYGPATH -u "$windows_path"`
36084 new_path="$unix_path"
36085 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36086 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36087 new_path="$unix_path"
36088 fi
36089
36090 fi
36091
36092 if test "x$new_path" = x; then
36093 # It's still not found. Now this is an unrecoverable error.
36094 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
36095 $as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
36096 has_space=`$ECHO "$complete" | $GREP " "`
36097 if test "x$has_space" != x; then
36098 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
36099 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
36100 fi
36101 as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
36102 fi
36103 fi
36104
36105 # Now new_path has a complete unix path to the binary
36106 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
36107 # Keep paths in /bin as-is, but remove trailing .exe if any
36108 new_path="${new_path/%.exe/}"
36109 # Do not save /bin paths to all_fixpath_prefixes!
36110 else
36522 if test "x$new_path" = x; then
36523 # Oops. Which didn't find the executable.
36524 # The splitting of arguments from the executable at a space might have been incorrect,
36525 # since paths with space are more likely in Windows. Give it another try with the whole
36526 # argument.
36527 path="$complete"
36528 arguments="EOL"
36529 new_path="$path"
36530
36531 windows_path="$new_path"
36532 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36533 unix_path=`$CYGPATH -u "$windows_path"`
36534 new_path="$unix_path"
36535 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36536 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36537 new_path="$unix_path"
36538 fi
36539
36540
36541 new_path=`$WHICH "$new_path" 2> /dev/null`
36542 # bat and cmd files are not always considered executable in MSYS causing which
36543 # to not find them
36544 if test "x$new_path" = x \
36545 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
36546 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
36547 new_path="$path"
36548
36549 windows_path="$new_path"
36550 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36551 unix_path=`$CYGPATH -u "$windows_path"`
36552 new_path="$unix_path"
36553 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36554 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36555 new_path="$unix_path"
36556 fi
36557
36558 fi
36559
36560 if test "x$new_path" = x; then
36561 # It's still not found. Now this is an unrecoverable error.
36562 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
36563 $as_echo "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
36564 has_space=`$ECHO "$complete" | $GREP " "`
36565 if test "x$has_space" != x; then
36566 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
36567 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
36568 fi
36569 as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
36570 fi
36571 fi
36572
36573 # Now new_path has a complete unix path to the binary
36574 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
36575 # Keep paths in /bin as-is, but remove trailing .exe if any
36576 new_path="${new_path/%.exe/}"
36577 # Do not save /bin paths to all_fixpath_prefixes!
36578 else
36991 if test "x$new_path" = x; then
36992 # Oops. Which didn't find the executable.
36993 # The splitting of arguments from the executable at a space might have been incorrect,
36994 # since paths with space are more likely in Windows. Give it another try with the whole
36995 # argument.
36996 path="$complete"
36997 arguments="EOL"
36998 new_path="$path"
36999
37000 windows_path="$new_path"
37001 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37002 unix_path=`$CYGPATH -u "$windows_path"`
37003 new_path="$unix_path"
37004 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37005 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
37006 new_path="$unix_path"
37007 fi
37008
37009
37010 new_path=`$WHICH "$new_path" 2> /dev/null`
37011 # bat and cmd files are not always considered executable in MSYS causing which
37012 # to not find them
37013 if test "x$new_path" = x \
37014 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
37015 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
37016 new_path="$path"
37017
37018 windows_path="$new_path"
37019 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37020 unix_path=`$CYGPATH -u "$windows_path"`
37021 new_path="$unix_path"
37022 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37023 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
37024 new_path="$unix_path"
37025 fi
37026
37027 fi
37028
37029 if test "x$new_path" = x; then
37030 # It's still not found. Now this is an unrecoverable error.
37031 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$complete\", is not found." >&5
37032 $as_echo "$as_me: The path of MCS, which resolves as \"$complete\", is not found." >&6;}
37033 has_space=`$ECHO "$complete" | $GREP " "`
37034 if test "x$has_space" != x; then
37035 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
37036 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
37037 fi
37038 as_fn_error $? "Cannot locate the the path of MCS" "$LINENO" 5
37039 fi
37040 fi
37041
37042 # Now new_path has a complete unix path to the binary
37043 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
37044 # Keep paths in /bin as-is, but remove trailing .exe if any
37045 new_path="${new_path/%.exe/}"
37046 # Do not save /bin paths to all_fixpath_prefixes!
37047 else
37571 if test "x$new_path" = x; then
37572 # Oops. Which didn't find the executable.
37573 # The splitting of arguments from the executable at a space might have been incorrect,
37574 # since paths with space are more likely in Windows. Give it another try with the whole
37575 # argument.
37576 path="$complete"
37577 arguments="EOL"
37578 new_path="$path"
37579
37580 windows_path="$new_path"
37581 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37582 unix_path=`$CYGPATH -u "$windows_path"`
37583 new_path="$unix_path"
37584 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37585 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
37586 new_path="$unix_path"
37587 fi
37588
37589
37590 new_path=`$WHICH "$new_path" 2> /dev/null`
37591 # bat and cmd files are not always considered executable in MSYS causing which
37592 # to not find them
37593 if test "x$new_path" = x \
37594 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
37595 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
37596 new_path="$path"
37597
37598 windows_path="$new_path"
37599 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37600 unix_path=`$CYGPATH -u "$windows_path"`
37601 new_path="$unix_path"
37602 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37603 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
37604 new_path="$unix_path"
37605 fi
37606
37607 fi
37608
37609 if test "x$new_path" = x; then
37610 # It's still not found. Now this is an unrecoverable error.
37611 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
37612 $as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
37613 has_space=`$ECHO "$complete" | $GREP " "`
37614 if test "x$has_space" != x; then
37615 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
37616 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
37617 fi
37618 as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
37619 fi
37620 fi
37621
37622 # Now new_path has a complete unix path to the binary
37623 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
37624 # Keep paths in /bin as-is, but remove trailing .exe if any
37625 new_path="${new_path/%.exe/}"
37626 # Do not save /bin paths to all_fixpath_prefixes!
37627 else
38149 if test "x$new_path" = x; then
38150 # Oops. Which didn't find the executable.
38151 # The splitting of arguments from the executable at a space might have been incorrect,
38152 # since paths with space are more likely in Windows. Give it another try with the whole
38153 # argument.
38154 path="$complete"
38155 arguments="EOL"
38156 new_path="$path"
38157
38158 windows_path="$new_path"
38159 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38160 unix_path=`$CYGPATH -u "$windows_path"`
38161 new_path="$unix_path"
38162 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38163 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38164 new_path="$unix_path"
38165 fi
38166
38167
38168 new_path=`$WHICH "$new_path" 2> /dev/null`
38169 # bat and cmd files are not always considered executable in MSYS causing which
38170 # to not find them
38171 if test "x$new_path" = x \
38172 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
38173 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
38174 new_path="$path"
38175
38176 windows_path="$new_path"
38177 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38178 unix_path=`$CYGPATH -u "$windows_path"`
38179 new_path="$unix_path"
38180 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38181 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38182 new_path="$unix_path"
38183 fi
38184
38185 fi
38186
38187 if test "x$new_path" = x; then
38188 # It's still not found. Now this is an unrecoverable error.
38189 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
38190 $as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
38191 has_space=`$ECHO "$complete" | $GREP " "`
38192 if test "x$has_space" != x; then
38193 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
38194 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
38195 fi
38196 as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
38197 fi
38198 fi
38199
38200 # Now new_path has a complete unix path to the binary
38201 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
38202 # Keep paths in /bin as-is, but remove trailing .exe if any
38203 new_path="${new_path/%.exe/}"
38204 # Do not save /bin paths to all_fixpath_prefixes!
38205 else
38736 if test "x$new_path" = x; then
38737 # Oops. Which didn't find the executable.
38738 # The splitting of arguments from the executable at a space might have been incorrect,
38739 # since paths with space are more likely in Windows. Give it another try with the whole
38740 # argument.
38741 path="$complete"
38742 arguments="EOL"
38743 new_path="$path"
38744
38745 windows_path="$new_path"
38746 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38747 unix_path=`$CYGPATH -u "$windows_path"`
38748 new_path="$unix_path"
38749 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38750 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38751 new_path="$unix_path"
38752 fi
38753
38754
38755 new_path=`$WHICH "$new_path" 2> /dev/null`
38756 # bat and cmd files are not always considered executable in MSYS causing which
38757 # to not find them
38758 if test "x$new_path" = x \
38759 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
38760 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
38761 new_path="$path"
38762
38763 windows_path="$new_path"
38764 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38765 unix_path=`$CYGPATH -u "$windows_path"`
38766 new_path="$unix_path"
38767 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38768 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38769 new_path="$unix_path"
38770 fi
38771
38772 fi
38773
38774 if test "x$new_path" = x; then
38775 # It's still not found. Now this is an unrecoverable error.
38776 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
38777 $as_echo "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
38778 has_space=`$ECHO "$complete" | $GREP " "`
38779 if test "x$has_space" != x; then
38780 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
38781 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
38782 fi
38783 as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
38784 fi
38785 fi
38786
38787 # Now new_path has a complete unix path to the binary
38788 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
38789 # Keep paths in /bin as-is, but remove trailing .exe if any
38790 new_path="${new_path/%.exe/}"
38791 # Do not save /bin paths to all_fixpath_prefixes!
38792 else
39320 if test "x$new_path" = x; then
39321 # Oops. Which didn't find the executable.
39322 # The splitting of arguments from the executable at a space might have been incorrect,
39323 # since paths with space are more likely in Windows. Give it another try with the whole
39324 # argument.
39325 path="$complete"
39326 arguments="EOL"
39327 new_path="$path"
39328
39329 windows_path="$new_path"
39330 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39331 unix_path=`$CYGPATH -u "$windows_path"`
39332 new_path="$unix_path"
39333 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39334 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39335 new_path="$unix_path"
39336 fi
39337
39338
39339 new_path=`$WHICH "$new_path" 2> /dev/null`
39340 # bat and cmd files are not always considered executable in MSYS causing which
39341 # to not find them
39342 if test "x$new_path" = x \
39343 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
39344 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
39345 new_path="$path"
39346
39347 windows_path="$new_path"
39348 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39349 unix_path=`$CYGPATH -u "$windows_path"`
39350 new_path="$unix_path"
39351 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39352 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39353 new_path="$unix_path"
39354 fi
39355
39356 fi
39357
39358 if test "x$new_path" = x; then
39359 # It's still not found. Now this is an unrecoverable error.
39360 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
39361 $as_echo "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
39362 has_space=`$ECHO "$complete" | $GREP " "`
39363 if test "x$has_space" != x; then
39364 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
39365 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
39366 fi
39367 as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
39368 fi
39369 fi
39370
39371 # Now new_path has a complete unix path to the binary
39372 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
39373 # Keep paths in /bin as-is, but remove trailing .exe if any
39374 new_path="${new_path/%.exe/}"
39375 # Do not save /bin paths to all_fixpath_prefixes!
39376 else
39813 if test "x$new_path" = x; then
39814 # Oops. Which didn't find the executable.
39815 # The splitting of arguments from the executable at a space might have been incorrect,
39816 # since paths with space are more likely in Windows. Give it another try with the whole
39817 # argument.
39818 path="$complete"
39819 arguments="EOL"
39820 new_path="$path"
39821
39822 windows_path="$new_path"
39823 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39824 unix_path=`$CYGPATH -u "$windows_path"`
39825 new_path="$unix_path"
39826 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39827 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39828 new_path="$unix_path"
39829 fi
39830
39831
39832 new_path=`$WHICH "$new_path" 2> /dev/null`
39833 # bat and cmd files are not always considered executable in MSYS causing which
39834 # to not find them
39835 if test "x$new_path" = x \
39836 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
39837 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
39838 new_path="$path"
39839
39840 windows_path="$new_path"
39841 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39842 unix_path=`$CYGPATH -u "$windows_path"`
39843 new_path="$unix_path"
39844 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39845 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39846 new_path="$unix_path"
39847 fi
39848
39849 fi
39850
39851 if test "x$new_path" = x; then
39852 # It's still not found. Now this is an unrecoverable error.
39853 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
39854 $as_echo "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
39855 has_space=`$ECHO "$complete" | $GREP " "`
39856 if test "x$has_space" != x; then
39857 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
39858 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
39859 fi
39860 as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
39861 fi
39862 fi
39863
39864 # Now new_path has a complete unix path to the binary
39865 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
39866 # Keep paths in /bin as-is, but remove trailing .exe if any
39867 new_path="${new_path/%.exe/}"
39868 # Do not save /bin paths to all_fixpath_prefixes!
39869 else
40281 if test "x$new_path" = x; then
40282 # Oops. Which didn't find the executable.
40283 # The splitting of arguments from the executable at a space might have been incorrect,
40284 # since paths with space are more likely in Windows. Give it another try with the whole
40285 # argument.
40286 path="$complete"
40287 arguments="EOL"
40288 new_path="$path"
40289
40290 windows_path="$new_path"
40291 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40292 unix_path=`$CYGPATH -u "$windows_path"`
40293 new_path="$unix_path"
40294 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40295 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40296 new_path="$unix_path"
40297 fi
40298
40299
40300 new_path=`$WHICH "$new_path" 2> /dev/null`
40301 # bat and cmd files are not always considered executable in MSYS causing which
40302 # to not find them
40303 if test "x$new_path" = x \
40304 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
40305 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
40306 new_path="$path"
40307
40308 windows_path="$new_path"
40309 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40310 unix_path=`$CYGPATH -u "$windows_path"`
40311 new_path="$unix_path"
40312 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40313 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40314 new_path="$unix_path"
40315 fi
40316
40317 fi
40318
40319 if test "x$new_path" = x; then
40320 # It's still not found. Now this is an unrecoverable error.
40321 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
40322 $as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
40323 has_space=`$ECHO "$complete" | $GREP " "`
40324 if test "x$has_space" != x; then
40325 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
40326 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
40327 fi
40328 as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
40329 fi
40330 fi
40331
40332 # Now new_path has a complete unix path to the binary
40333 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
40334 # Keep paths in /bin as-is, but remove trailing .exe if any
40335 new_path="${new_path/%.exe/}"
40336 # Do not save /bin paths to all_fixpath_prefixes!
40337 else
40749 if test "x$new_path" = x; then
40750 # Oops. Which didn't find the executable.
40751 # The splitting of arguments from the executable at a space might have been incorrect,
40752 # since paths with space are more likely in Windows. Give it another try with the whole
40753 # argument.
40754 path="$complete"
40755 arguments="EOL"
40756 new_path="$path"
40757
40758 windows_path="$new_path"
40759 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40760 unix_path=`$CYGPATH -u "$windows_path"`
40761 new_path="$unix_path"
40762 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40763 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40764 new_path="$unix_path"
40765 fi
40766
40767
40768 new_path=`$WHICH "$new_path" 2> /dev/null`
40769 # bat and cmd files are not always considered executable in MSYS causing which
40770 # to not find them
40771 if test "x$new_path" = x \
40772 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
40773 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
40774 new_path="$path"
40775
40776 windows_path="$new_path"
40777 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40778 unix_path=`$CYGPATH -u "$windows_path"`
40779 new_path="$unix_path"
40780 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40781 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40782 new_path="$unix_path"
40783 fi
40784
40785 fi
40786
40787 if test "x$new_path" = x; then
40788 # It's still not found. Now this is an unrecoverable error.
40789 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&5
40790 $as_echo "$as_me: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&6;}
40791 has_space=`$ECHO "$complete" | $GREP " "`
40792 if test "x$has_space" != x; then
40793 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
40794 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
40795 fi
40796 as_fn_error $? "Cannot locate the the path of BUILD_LD" "$LINENO" 5
40797 fi
40798 fi
40799
40800 # Now new_path has a complete unix path to the binary
40801 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
40802 # Keep paths in /bin as-is, but remove trailing .exe if any
40803 new_path="${new_path/%.exe/}"
40804 # Do not save /bin paths to all_fixpath_prefixes!
40805 else
43094 ac_ext=cpp
43095 ac_cpp='$CXXCPP $CPPFLAGS'
43096 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
43097 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
43098 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
43099
43100 CXXFLAGS="$saved_cxxflags"
43101
43102 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
43103 $as_echo "$supports" >&6; }
43104 if test "x$supports" = "xyes" ; then
43105 COMPILER_SUPPORTS_TARGET_BITS_FLAG=true
43106 else
43107 COMPILER_SUPPORTS_TARGET_BITS_FLAG=false
43108 fi
43109
43110
43111
43112 case "${TOOLCHAIN_TYPE}" in
43113 microsoft)
43114 CFLAGS_WARNINGS_ARE_ERRORS="-WX"
43115 ;;
43116 solstudio)
43117 CFLAGS_WARNINGS_ARE_ERRORS="-errtags -errwarn=%all"
43118 ;;
43119 gcc)
43120 CFLAGS_WARNINGS_ARE_ERRORS="-Werror"
43121 ;;
43122 clang)
43123 CFLAGS_WARNINGS_ARE_ERRORS="-Werror"
43124 ;;
43125 esac
43126
43127
43128
43129 # Setup debug symbols (need objcopy from the toolchain for that)
43130
43131 #
43132 # ENABLE_DEBUG_SYMBOLS
43133 # This must be done after the toolchain is setup, since we're looking at objcopy.
43134 #
49176
49177 # Check whether --with-msvcr-dll was given.
49178 if test "${with_msvcr_dll+set}" = set; then :
49179 withval=$with_msvcr_dll;
49180 fi
49181
49182
49183 if test "x$with_msvcr_dll" != x; then
49184 # If given explicitely by user, do not probe. If not present, fail directly.
49185
49186 POSSIBLE_MSVCR_DLL="$with_msvcr_dll"
49187 METHOD="--with-msvcr-dll"
49188 if test -e "$POSSIBLE_MSVCR_DLL"; then
49189 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
49190 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
49191
49192 # Need to check if the found msvcr is correct architecture
49193 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
49194 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
49195 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
49196 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49197 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49198 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49199 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49200 CORRECT_MSVCR_ARCH="PE32 executable"
49201 else
49202 CORRECT_MSVCR_ARCH="PE32+ executable"
49203 fi
49204 else
49205 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49206 CORRECT_MSVCR_ARCH=386
49207 else
49208 CORRECT_MSVCR_ARCH=x86-64
49209 fi
49210 fi
49211 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49212 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49213 $as_echo "ok" >&6; }
49214 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49215 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
49216 $as_echo_n "checking for msvcr100.dll... " >&6; }
49217 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
49218 $as_echo "$MSVCR_DLL" >&6; }
49219 else
49220 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49221 $as_echo "incorrect, ignoring" >&6; }
49222 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
49223 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
49224 fi
49225 fi
49226
49227 if test "x$MSVCR_DLL" = x; then
49228 as_fn_error $? "Could not find a proper msvcr100.dll as specified by --with-msvcr-dll" "$LINENO" 5
49229 fi
49230 fi
49231
49242 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49243 CYGWIN_VC_INSTALL_DIR="$unix_path"
49244 fi
49245
49246 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
49247 POSSIBLE_MSVCR_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x64/Microsoft.VC100.CRT/msvcr100.dll"
49248 else
49249 POSSIBLE_MSVCR_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x86/Microsoft.VC100.CRT/msvcr100.dll"
49250 fi
49251
49252 POSSIBLE_MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49253 METHOD="well-known location in VCINSTALLDIR"
49254 if test -e "$POSSIBLE_MSVCR_DLL"; then
49255 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
49256 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
49257
49258 # Need to check if the found msvcr is correct architecture
49259 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
49260 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
49261 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
49262 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49263 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49264 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49265 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49266 CORRECT_MSVCR_ARCH="PE32 executable"
49267 else
49268 CORRECT_MSVCR_ARCH="PE32+ executable"
49269 fi
49270 else
49271 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49272 CORRECT_MSVCR_ARCH=386
49273 else
49274 CORRECT_MSVCR_ARCH=x86-64
49275 fi
49276 fi
49277 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49278 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49279 $as_echo "ok" >&6; }
49280 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49281 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
49282 $as_echo_n "checking for msvcr100.dll... " >&6; }
49283 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
49284 $as_echo "$MSVCR_DLL" >&6; }
49285 else
49286 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49287 $as_echo "incorrect, ignoring" >&6; }
49288 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
49289 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
49290 fi
49291 fi
49292
49293 fi
49294 fi
49295
49296 if test "x$MSVCR_DLL" = x; then
49297 # Probe: Check in the Boot JDK directory.
49298 POSSIBLE_MSVCR_DLL="$BOOT_JDK/bin/msvcr100.dll"
49299
49300 POSSIBLE_MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49301 METHOD="well-known location in Boot JDK"
49302 if test -e "$POSSIBLE_MSVCR_DLL"; then
49303 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
49304 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
49305
49306 # Need to check if the found msvcr is correct architecture
49307 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
49308 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
49309 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
49310 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49311 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49312 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49313 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49314 CORRECT_MSVCR_ARCH="PE32 executable"
49315 else
49316 CORRECT_MSVCR_ARCH="PE32+ executable"
49317 fi
49318 else
49319 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49320 CORRECT_MSVCR_ARCH=386
49321 else
49322 CORRECT_MSVCR_ARCH=x86-64
49323 fi
49324 fi
49325 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49326 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49327 $as_echo "ok" >&6; }
49328 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49329 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
49330 $as_echo_n "checking for msvcr100.dll... " >&6; }
49331 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
49332 $as_echo "$MSVCR_DLL" >&6; }
49333 else
49334 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49335 $as_echo "incorrect, ignoring" >&6; }
49336 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
49337 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
49338 fi
49339 fi
49340
49341 fi
49342
49343 if test "x$MSVCR_DLL" = x; then
49344 # Probe: Look in the Windows system32 directory
49345 CYGWIN_SYSTEMROOT="$SYSTEMROOT"
49348 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49349 unix_path=`$CYGPATH -u "$windows_path"`
49350 CYGWIN_SYSTEMROOT="$unix_path"
49351 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49352 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49353 CYGWIN_SYSTEMROOT="$unix_path"
49354 fi
49355
49356 POSSIBLE_MSVCR_DLL="$CYGWIN_SYSTEMROOT/system32/msvcr100.dll"
49357
49358 POSSIBLE_MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49359 METHOD="well-known location in SYSTEMROOT"
49360 if test -e "$POSSIBLE_MSVCR_DLL"; then
49361 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
49362 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
49363
49364 # Need to check if the found msvcr is correct architecture
49365 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
49366 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
49367 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
49368 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49369 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49370 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49371 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49372 CORRECT_MSVCR_ARCH="PE32 executable"
49373 else
49374 CORRECT_MSVCR_ARCH="PE32+ executable"
49375 fi
49376 else
49377 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49378 CORRECT_MSVCR_ARCH=386
49379 else
49380 CORRECT_MSVCR_ARCH=x86-64
49381 fi
49382 fi
49383 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49384 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49385 $as_echo "ok" >&6; }
49386 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49387 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
49388 $as_echo_n "checking for msvcr100.dll... " >&6; }
49389 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
49390 $as_echo "$MSVCR_DLL" >&6; }
49391 else
49392 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49393 $as_echo "incorrect, ignoring" >&6; }
49394 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
49395 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
49396 fi
49397 fi
49398
49399 fi
49400
49401 if test "x$MSVCR_DLL" = x; then
49402 # Probe: If Visual Studio Express is installed, there is usually one with the debugger
49403 if test "x$VS100COMNTOOLS" != x; then
49411 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49412 CYGWIN_VS_TOOLS_DIR="$unix_path"
49413 fi
49414
49415 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
49416 POSSIBLE_MSVCR_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name msvcr100.dll | $GREP -i /x64/ | $HEAD --lines 1`
49417 else
49418 POSSIBLE_MSVCR_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name msvcr100.dll | $GREP -i /x86/ | $HEAD --lines 1`
49419 fi
49420
49421 POSSIBLE_MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49422 METHOD="search of VS100COMNTOOLS"
49423 if test -e "$POSSIBLE_MSVCR_DLL"; then
49424 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
49425 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
49426
49427 # Need to check if the found msvcr is correct architecture
49428 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
49429 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
49430 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
49431 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49432 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49433 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49434 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49435 CORRECT_MSVCR_ARCH="PE32 executable"
49436 else
49437 CORRECT_MSVCR_ARCH="PE32+ executable"
49438 fi
49439 else
49440 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49441 CORRECT_MSVCR_ARCH=386
49442 else
49443 CORRECT_MSVCR_ARCH=x86-64
49444 fi
49445 fi
49446 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49447 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49448 $as_echo "ok" >&6; }
49449 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49450 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
49451 $as_echo_n "checking for msvcr100.dll... " >&6; }
49452 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
49453 $as_echo "$MSVCR_DLL" >&6; }
49454 else
49455 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49456 $as_echo "incorrect, ignoring" >&6; }
49457 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
49458 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
49459 fi
49460 fi
49461
49462 fi
49463 fi
49464
49465 if test "x$MSVCR_DLL" = x; then
49466 # Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now.
49470 POSSIBLE_MSVCR_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name msvcr100.dll | $GREP x64 | $HEAD --lines 1`
49471 else
49472 POSSIBLE_MSVCR_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name msvcr100.dll | $GREP x86 | $GREP -v ia64 | $GREP -v x64 | $HEAD --lines 1`
49473 if test "x$POSSIBLE_MSVCR_DLL" = x; then
49474 # We're grasping at straws now...
49475 POSSIBLE_MSVCR_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name msvcr100.dll | $HEAD --lines 1`
49476 fi
49477 fi
49478
49479
49480 POSSIBLE_MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49481 METHOD="search of VCINSTALLDIR"
49482 if test -e "$POSSIBLE_MSVCR_DLL"; then
49483 { $as_echo "$as_me:${as_lineno-$LINENO}: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&5
49484 $as_echo "$as_me: Found msvcr100.dll at $POSSIBLE_MSVCR_DLL using $METHOD" >&6;}
49485
49486 # Need to check if the found msvcr is correct architecture
49487 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found msvcr100.dll architecture" >&5
49488 $as_echo_n "checking found msvcr100.dll architecture... " >&6; }
49489 MSVCR_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVCR_DLL"`
49490 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49491 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49492 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49493 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49494 CORRECT_MSVCR_ARCH="PE32 executable"
49495 else
49496 CORRECT_MSVCR_ARCH="PE32+ executable"
49497 fi
49498 else
49499 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49500 CORRECT_MSVCR_ARCH=386
49501 else
49502 CORRECT_MSVCR_ARCH=x86-64
49503 fi
49504 fi
49505 if $ECHO "$MSVCR_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49506 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49507 $as_echo "ok" >&6; }
49508 MSVCR_DLL="$POSSIBLE_MSVCR_DLL"
49509 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
49510 $as_echo_n "checking for msvcr100.dll... " >&6; }
49511 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR_DLL" >&5
49512 $as_echo "$MSVCR_DLL" >&6; }
49513 else
49514 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49515 $as_echo "incorrect, ignoring" >&6; }
49516 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&5
49517 $as_echo "$as_me: The file type of the located msvcr100.dll is $MSVCR_DLL_FILETYPE" >&6;}
49518 fi
49519 fi
49520
49521 fi
49522 fi
49523
49524 if test "x$MSVCR_DLL" = x; then
49525 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5
50428 CCACHE="CCACHE_COMPRESS=1 $SET_CCACHE_DIR CCACHE_SLOPPINESS=$CCACHE_SLOPPINESS $CCACHE"
50429 CCACHE_FLAGS=-fpch-preprocess
50430
50431 if test "x$SET_CCACHE_DIR" != x; then
50432 mkdir -p $CCACHE_DIR > /dev/null 2>&1
50433 chmod a+rwxs $CCACHE_DIR > /dev/null 2>&1
50434 fi
50435 fi
50436
50437 fi
50438
50439
50440 ###############################################################################
50441 #
50442 # And now the finish...
50443 #
50444 ###############################################################################
50445
50446 # Check for some common pitfalls
50447
50448 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
50449 file_to_test="$SRC_ROOT/LICENSE"
50450 if test `$STAT -c '%a' "$file_to_test"` -lt 400; then
50451 as_fn_error $? "Bad file permissions on src files. This is usually caused by cloning the repositories with a non cygwin hg in a directory not created in cygwin." "$LINENO" 5
50452 fi
50453 fi
50454
50455
50456 # Did user specify any unknown variables?
50457
50458 if test "x$CONFIGURE_OVERRIDDEN_VARIABLES" != x; then
50459 # Replace the separating ! with spaces before presenting for end user.
50460 unknown_variables=${CONFIGURE_OVERRIDDEN_VARIABLES//!/ }
50461 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: The following variables might be unknown to configure: $unknown_variables" >&5
50462 $as_echo "$as_me: WARNING: The following variables might be unknown to configure: $unknown_variables" >&2;}
50463 fi
50464
50465
50466 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if build directory is on local disk" >&5
50467 $as_echo_n "checking if build directory is on local disk... " >&6; }
50468
|