1 #
2 # Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.
3 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 #
5 # This code is free software; you can redistribute it and/or modify it
6 # under the terms of the GNU General Public License version 2 only, as
7 # published by the Free Software Foundation. Oracle designates this
8 # particular file as subject to the "Classpath" exception as provided
9 # by Oracle in the LICENSE file that accompanied this code.
10 #
11 # This code is distributed in the hope that it will be useful, but WITHOUT
12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 # version 2 for more details (a copy is included in the LICENSE file that
15 # accompanied this code).
16 #
17 # You should have received a copy of the GNU General Public License version
18 # 2 along with this work; if not, write to the Free Software Foundation,
19 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 #
21 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 # or visit www.oracle.com if you need additional information or have any
23 # questions.
24 #
25
26 ################################################################################
27 # The order of these defines the priority by which we try to find them.
28 VALID_VS_VERSIONS="2017 2013 2015 2012 2010"
29
30 VS_DESCRIPTION_2010="Microsoft Visual Studio 2010"
31 VS_VERSION_INTERNAL_2010=100
32 VS_MSVCR_2010=msvcr100.dll
33 # We don't use msvcp on Visual Studio 2010
34 #VS_MSVCP_2010=msvcp100.dll
35 VS_ENVVAR_2010="VS100COMNTOOLS"
36 VS_VS_INSTALLDIR_2010="Microsoft Visual Studio 10.0"
37 VS_SDK_INSTALLDIR_2010="Microsoft SDKs/Windows/v7.1"
38 VS_VS_PLATFORM_NAME_2010="v100"
39 VS_SDK_PLATFORM_NAME_2010="Windows7.1SDK"
40 VS_SUPPORTED_2010=false
41
42 VS_DESCRIPTION_2012="Microsoft Visual Studio 2012"
43 VS_VERSION_INTERNAL_2012=110
44 VS_MSVCR_2012=msvcr110.dll
45 VS_MSVCP_2012=msvcp110.dll
46 VS_ENVVAR_2012="VS110COMNTOOLS"
47 VS_VS_INSTALLDIR_2012="Microsoft Visual Studio 11.0"
48 VS_SDK_INSTALLDIR_2012=
49 VS_VS_PLATFORM_NAME_2012="v110"
50 VS_SDK_PLATFORM_NAME_2012=
51 VS_SUPPORTED_2012=false
52
53 VS_DESCRIPTION_2013="Microsoft Visual Studio 2013"
54 VS_VERSION_INTERNAL_2013=120
55 VS_MSVCR_2013=msvcr120.dll
56 VS_MSVCP_2013=msvcp120.dll
57 VS_ENVVAR_2013="VS120COMNTOOLS"
58 VS_VS_INSTALLDIR_2013="Microsoft Visual Studio 12.0"
59 VS_SDK_INSTALLDIR_2013=
60 VS_VS_PLATFORM_NAME_2013="v120"
61 VS_SDK_PLATFORM_NAME_2013=
62 VS_SUPPORTED_2013=false
63
64 VS_DESCRIPTION_2015="Microsoft Visual Studio 2015"
65 VS_VERSION_INTERNAL_2015=140
66 VS_MSVCR_2015=vcruntime140.dll
67 VS_MSVCP_2015=msvcp140.dll
68 VS_ENVVAR_2015="VS140COMNTOOLS"
69 VS_VS_INSTALLDIR_2015="Microsoft Visual Studio 14.0"
70 VS_SDK_INSTALLDIR_2015=
71 VS_VS_PLATFORM_NAME_2015="v140"
72 VS_SDK_PLATFORM_NAME_2015=
73 # The vcvars of 2015 breaks if 2017 is also installed. Work around this by
74 # explicitly specifying Windows Kit 8.1 to be used.
75 VS_ENV_ARGS_2015="8.1"
76 VS_SUPPORTED_2015=false
77
78 VS_DESCRIPTION_2017="Microsoft Visual Studio 2017"
79 VS_VERSION_INTERNAL_2017=141
80 VS_MSVCR_2017=vcruntime140.dll
81 VS_MSVCP_2017=msvcp140.dll
82 VS_ENVVAR_2017="VS150COMNTOOLS"
83 VS_USE_UCRT_2017="true"
84 VS_VS_INSTALLDIR_2017="Microsoft Visual Studio/2017"
85 VS_EDITIONS_2017="BuildTools Community Professional Enterprise"
86 VS_SDK_INSTALLDIR_2017=
87 VS_VS_PLATFORM_NAME_2017="v141"
88 VS_SDK_PLATFORM_NAME_2017=
89 VS_SUPPORTED_2017=true
90 VS_TOOLSET_SUPPORTED_2017=true
91
92 ################################################################################
93
94 AC_DEFUN([TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT],
95 [
96 if test "x$VS_ENV_CMD" = x; then
97 VS_VERSION="$1"
98 VS_BASE="$2"
99 METHOD="$3"
100
101 BASIC_WINDOWS_REWRITE_AS_UNIX_PATH(VS_BASE)
102 # In VS 2017, the default installation is in a subdir named after the edition.
103 # Find the first one present and use that.
104 if test "x$VS_EDITIONS" != x; then
105 for edition in $VS_EDITIONS; do
106 if test -d "$VS_BASE/$edition"; then
107 VS_BASE="$VS_BASE/$edition"
108 break
109 fi
110 done
111 fi
112
113 if test -d "$VS_BASE"; then
114 AC_MSG_NOTICE([Found Visual Studio installation at $VS_BASE using $METHOD])
115 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
116 VCVARSFILES="vc/bin/vcvars32.bat vc/auxiliary/build/vcvars32.bat"
117 else
118 VCVARSFILES="vc/bin/amd64/vcvars64.bat vc/bin/x86_amd64/vcvarsx86_amd64.bat \
119 VC/Auxiliary/Build/vcvarsx86_amd64.bat VC/Auxiliary/Build/vcvars64.bat"
120 fi
121
122 for VCVARSFILE in $VCVARSFILES; do
123 if test -f "$VS_BASE/$VCVARSFILE"; then
124 VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
125 break
126 fi
127 done
128
129 if test "x$VS_ENV_CMD" = x; then
130 AC_MSG_NOTICE([Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring])
131 else
132 # PLATFORM_TOOLSET is used during the compilation of the freetype sources
133 # (see 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100',
134 # 'v110' or 'v120' for VS 2010, 2012 or VS2013
135 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
136 fi
137 fi
138 fi
139 ])
140
141 ################################################################################
142
143 AC_DEFUN([TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT],
144 [
145 if test "x$VS_ENV_CMD" = x; then
146 VS_VERSION="$1"
147 WIN_SDK_BASE="$2"
148 METHOD="$3"
149 BASIC_WINDOWS_REWRITE_AS_UNIX_PATH(WIN_SDK_BASE)
150 if test -d "$WIN_SDK_BASE"; then
151 # There have been cases of partial or broken SDK installations. A missing
152 # lib dir is not going to work.
153 if test ! -d "$WIN_SDK_BASE/lib"; then
154 AC_MSG_NOTICE([Found Windows SDK installation at $WIN_SDK_BASE using $METHOD])
155 AC_MSG_NOTICE([Warning: Installation is broken, lib dir is missing. Ignoring])
156 elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
157 AC_MSG_NOTICE([Found Windows SDK installation at $WIN_SDK_BASE using $METHOD])
158 VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
159 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
160 VS_ENV_ARGS="/x86"
161 else
162 VS_ENV_ARGS="/x64"
163 fi
164 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
165 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
166 # TODO: improve detection for other versions of SDK
167 eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
168 else
169 AC_MSG_NOTICE([Found Windows SDK installation at $WIN_SDK_BASE using $METHOD])
170 AC_MSG_NOTICE([Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring])
171 fi
172 fi
173 fi
174 ])
175
176 ################################################################################
177 # Finds the bat or cmd file in Visual Studio or the SDK that sets up a proper
178 # build environment and assigns it to VS_ENV_CMD
179 AC_DEFUN([TOOLCHAIN_FIND_VISUAL_STUDIO_BAT_FILE],
180 [
181 # VS2017 provides the option to install previous minor versions of the MSVC
182 # toolsets. It is not possible to directly download earlier minor versions of
183 # VS2017 and in order to build with a previous minor compiler toolset version,
184 # it is now possible to compile with earlier minor versions by passing
185 # -vcvars_ver=<toolset_version> argument to vcvarsall.bat.
186 AC_ARG_WITH(msvc-toolset-version, [AS_HELP_STRING([--with-msvc-toolset-version],
187 [specific MSVC toolset version to use, passed as -vcvars_ver argument to
188 pass to vcvarsall.bat (Windows only)])])
189
190 VS_VERSION="$1"
191 eval VS_COMNTOOLS_VAR="\${VS_ENVVAR_${VS_VERSION}}"
192 eval VS_COMNTOOLS="\$${VS_COMNTOOLS_VAR}"
193 eval VS_INSTALL_DIR="\${VS_VS_INSTALLDIR_${VS_VERSION}}"
194 eval VS_EDITIONS="\${VS_EDITIONS_${VS_VERSION}}"
195 eval SDK_INSTALL_DIR="\${VS_SDK_INSTALLDIR_${VS_VERSION}}"
196 eval VS_ENV_ARGS="\${VS_ENV_ARGS_${VS_VERSION}}"
197 eval VS_TOOLSET_SUPPORTED="\${VS_TOOLSET_SUPPORTED_${VS_VERSION}}"
198
199 # When using --with-tools-dir, assume it points to the correct and default
200 # version of Visual Studio or that --with-toolchain-version was also set.
201 if test "x$with_tools_dir" != x; then
202 TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([${VS_VERSION}],
203 [$with_tools_dir/../..], [--with-tools-dir])
204 TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([${VS_VERSION}],
205 [$with_tools_dir/../../..], [--with-tools-dir])
206 if test "x$VS_ENV_CMD" = x; then
207 # Having specified an argument which is incorrect will produce an instant failure;
208 # we should not go on looking
209 AC_MSG_NOTICE([The path given by --with-tools-dir does not contain a valid])
210 AC_MSG_NOTICE([Visual Studio installation. Please point to the VC/bin or VC/bin/amd64])
211 AC_MSG_NOTICE([directory within the Visual Studio installation])
212 AC_MSG_ERROR([Cannot locate a valid Visual Studio installation])
213 fi
214 fi
215
216 VS_ENV_CMD=""
217
218 if test "x$VS_COMNTOOLS" != x; then
219 TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([${VS_VERSION}],
220 [$VS_COMNTOOLS/../..], [$VS_COMNTOOLS_VAR variable])
221 fi
222 if test "x$PROGRAMFILES" != x; then
223 TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([${VS_VERSION}],
224 [$PROGRAMFILES/$VS_INSTALL_DIR], [well-known name])
225 fi
226 # Work around the insanely named ProgramFiles(x86) env variable
227 PROGRAMFILES_X86="`env | $SED -n 's/^ProgramFiles(x86)=//p'`"
228 if test "x$PROGRAMFILES_X86" != x; then
229 TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([${VS_VERSION}],
230 [$PROGRAMFILES_X86/$VS_INSTALL_DIR], [well-known name])
231 fi
232 TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([${VS_VERSION}],
233 [C:/Program Files/$VS_INSTALL_DIR], [well-known name])
234 TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([${VS_VERSION}],
235 [C:/Program Files (x86)/$VS_INSTALL_DIR], [well-known name])
236 if test "x$SDK_INSTALL_DIR" != x; then
237 if test "x$ProgramW6432" != x; then
238 TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT([${VS_VERSION}],
239 [$ProgramW6432/$SDK_INSTALL_DIR], [well-known name])
240 fi
241 if test "x$PROGRAMW6432" != x; then
242 TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT([${VS_VERSION}],
243 [$PROGRAMW6432/$SDK_INSTALL_DIR], [well-known name])
244 fi
245 if test "x$PROGRAMFILES" != x; then
246 TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT([${VS_VERSION}],
247 [$PROGRAMFILES/$SDK_INSTALL_DIR], [well-known name])
248 fi
249 TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT([${VS_VERSION}],
250 [C:/Program Files/$SDK_INSTALL_DIR], [well-known name])
251 TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT([${VS_VERSION}],
252 [C:/Program Files (x86)/$SDK_INSTALL_DIR], [well-known name])
253 fi
254
255 if test "x$VS_TOOLSET_SUPPORTED" != x; then
256 if test "x$with_msvc_toolset_version" != x; then
257 VS_ENV_ARGS="$VS_ENV_ARGS -vcvars_ver=$with_msvc_toolset_version"
258 fi
259 fi
260 ])
261
262 ################################################################################
263
264 AC_DEFUN([TOOLCHAIN_FIND_VISUAL_STUDIO],
265 [
266 AC_ARG_WITH(toolchain-version, [AS_HELP_STRING([--with-toolchain-version],
267 [the version of the toolchain to look for, use '--help' to show possible values @<:@platform dependent@:>@])])
268
269 if test "x$with_toolchain_version" = xlist; then
270 # List all toolchains
271 AC_MSG_NOTICE([The following toolchain versions are valid on this platform:])
272 for version in $VALID_VS_VERSIONS; do
273 eval VS_DESCRIPTION=\${VS_DESCRIPTION_$version}
274 $PRINTF " %-10s %s\n" $version "$VS_DESCRIPTION"
275 done
276
277 exit 0
278 elif test "x$DEVKIT_VS_VERSION" != x; then
279 VS_VERSION=$DEVKIT_VS_VERSION
280 TOOLCHAIN_VERSION=$VS_VERSION
281 # If the devkit has a name, use that as description
282 VS_DESCRIPTION="$DEVKIT_NAME"
283 if test "x$VS_DESCRIPTION" = x; then
284 eval VS_DESCRIPTION="\${VS_DESCRIPTION_${VS_VERSION}}"
285 fi
286 eval VS_VERSION_INTERNAL="\${VS_VERSION_INTERNAL_${VS_VERSION}}"
287 eval MSVCR_NAME="\${VS_MSVCR_${VS_VERSION}}"
288 eval MSVCP_NAME="\${VS_MSVCP_${VS_VERSION}}"
289 eval USE_UCRT="\${VS_USE_UCRT_${VS_VERSION}}"
290 eval VS_SUPPORTED="\${VS_SUPPORTED_${VS_VERSION}}"
291 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
292
293 # The TOOLCHAIN_PATH from a devkit is in Unix format. In WSL we need a
294 # windows version of the complete VS_PATH as VS_PATH_WINDOWS
295 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then
296 # Convert the toolchain path
297 OLDIFS="$IFS"
298 IFS=":"
299 VS_PATH_WINDOWS=""
300 for i in $TOOLCHAIN_PATH; do
301 path=$i
302 BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH([path])
303 VS_PATH_WINDOWS="$VS_PATH_WINDOWS;$path"
304 done
305 IFS="$OLDIFS"
306 # Append the current path from Windows env
307 WINDOWS_PATH="`$CMD /c echo %PATH%`"
308 VS_PATH_WINDOWS="$VS_PATH_WINDOWS;$WINDOWS_PATH"
309 else
310 VS_PATH="$TOOLCHAIN_PATH:$PATH"
311 fi
312
313 # Convert DEVKIT_VS_INCLUDE into windows style VS_INCLUDE so that it
314 # can still be exported as INCLUDE for compiler invocations without
315 # SYSROOT_CFLAGS
316 OLDIFS="$IFS"
317 IFS=";"
318 for i in $DEVKIT_VS_INCLUDE; do
319 ipath=$i
320 BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH([ipath])
321 VS_INCLUDE="$VS_INCLUDE;$ipath"
322 done
323 # Convert DEVKIT_VS_LIB into VS_LIB so that it can still be exported
324 # as LIB for compiler invocations without SYSROOT_LDFLAGS
325 for i in $DEVKIT_VS_LIB; do
326 libpath=$i
327 BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH([libpath])
328 VS_LIB="$VS_LIB;$libpath"
329 done
330 IFS="$OLDIFS"
331
332 AC_MSG_NOTICE([Found devkit $VS_DESCRIPTION])
333
334 elif test "x$with_toolchain_version" != x; then
335 # User override; check that it is valid
336 if test "x${VALID_VS_VERSIONS/$with_toolchain_version/}" = "x${VALID_VS_VERSIONS}"; then
337 AC_MSG_NOTICE([Visual Studio version $with_toolchain_version is not valid.])
338 AC_MSG_NOTICE([Valid Visual Studio versions: $VALID_VS_VERSIONS.])
339 AC_MSG_ERROR([Cannot continue.])
340 fi
341 VS_VERSIONS_PROBE_LIST="$with_toolchain_version"
342 else
343 # No flag given, use default
344 VS_VERSIONS_PROBE_LIST="$VALID_VS_VERSIONS"
345 fi
346
347 for VS_VERSION in $VS_VERSIONS_PROBE_LIST; do
348 TOOLCHAIN_FIND_VISUAL_STUDIO_BAT_FILE([$VS_VERSION])
349 if test "x$VS_ENV_CMD" != x; then
350 TOOLCHAIN_VERSION=$VS_VERSION
351 eval VS_DESCRIPTION="\${VS_DESCRIPTION_${VS_VERSION}}"
352 eval VS_VERSION_INTERNAL="\${VS_VERSION_INTERNAL_${VS_VERSION}}"
353 eval MSVCR_NAME="\${VS_MSVCR_${VS_VERSION}}"
354 eval MSVCP_NAME="\${VS_MSVCP_${VS_VERSION}}"
355 eval USE_UCRT="\${VS_USE_UCRT_${VS_VERSION}}"
356 eval VS_SUPPORTED="\${VS_SUPPORTED_${VS_VERSION}}"
357 # The rest of the variables are already evaled while probing
358 AC_MSG_NOTICE([Found $VS_DESCRIPTION])
359 break
360 fi
361 done
362
363 TOOLCHAIN_DESCRIPTION="$VS_DESCRIPTION"
364 if test "x$VS_SUPPORTED" = "xfalse"; then
365 UNSUPPORTED_TOOLCHAIN_VERSION=yes
366 fi
367 ])
368
369 ################################################################################
370 # Check if the VS env variables were setup prior to running configure.
371 # If not, then find vcvarsall.bat and run it automatically, and integrate
372 # the set env variables into the spec file.
373 AC_DEFUN([TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV],
374 [
375 # Store path to cygwin link.exe to help excluding it when searching for
376 # VS linker. This must be done before changing the PATH when looking for VS.
377 AC_PATH_PROG(CYGWIN_LINK, link.exe)
378 if test "x$CYGWIN_LINK" != x; then
379 AC_MSG_CHECKING([if the first found link.exe is actually the Cygwin link tool])
380 "$CYGWIN_LINK" --version > /dev/null
381 if test $? -eq 0 ; then
382 AC_MSG_RESULT([yes])
383 else
384 AC_MSG_RESULT([no])
385 # This might be the VS linker. Don't exclude it later on.
386 CYGWIN_LINK=""
387 fi
388 fi
389
390 # First-hand choice is to locate and run the vsvars bat file.
391 TOOLCHAIN_FIND_VISUAL_STUDIO
392
393 # If we have a devkit, skip all of the below.
394 if test "x$DEVKIT_VS_VERSION" = x; then
395 if test "x$VS_ENV_CMD" != x; then
396 # We have found a Visual Studio environment on disk, let's extract variables from the vsvars bat file.
397 BASIC_FIXUP_EXECUTABLE(VS_ENV_CMD)
398
399 # Lets extract the variables that are set by vcvarsall.bat/vsvars32.bat/vsvars64.bat
400 AC_MSG_NOTICE([Trying to extract Visual Studio environment variables])
401
402 # We need to create a couple of temporary files.
403 VS_ENV_TMP_DIR="$CONFIGURESUPPORT_OUTPUTDIR/vs-env"
404 $MKDIR -p $VS_ENV_TMP_DIR
405
406 # Cannot use the VS10 setup script directly (since it only updates the DOS subshell environment).
407 # Instead create a shell script which will set the relevant variables when run.
408 WINPATH_VS_ENV_CMD="$VS_ENV_CMD"
409 BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH([WINPATH_VS_ENV_CMD])
410
411 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then
412 WINPATH_BASH="bash"
413 else
414 WINPATH_BASH="$BASH"
415 BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH([WINPATH_BASH])
416 fi
417
418 # Generate a DOS batch file which runs $VS_ENV_CMD, and then creates a shell
419 # script (executable by bash) that will setup the important variables.
420 EXTRACT_VC_ENV_BAT_FILE="$VS_ENV_TMP_DIR/extract-vs-env.bat"
421 $ECHO "@echo off" > $EXTRACT_VC_ENV_BAT_FILE
422 # This will end up something like:
423 # call C:/progra~2/micros~2.0/vc/bin/amd64/vcvars64.bat
424 $ECHO "call \"$WINPATH_VS_ENV_CMD\" $VS_ENV_ARGS" >> $EXTRACT_VC_ENV_BAT_FILE
425 # In some cases, the VS_ENV_CMD will change directory, change back so
426 # the set-vs-env.sh ends up in the right place.
427 $ECHO 'cd %~dp0' >> $EXTRACT_VC_ENV_BAT_FILE
428 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then
429 # These will end up something like:
430 # echo VS_PATH=\"$PATH\" > set-vs-env.sh
431 # The trailing space for everyone except PATH is no typo, but is needed due
432 # to trailing \ in the Windows paths. These will be stripped later.
433 # Trying pure CMD extract. This results in windows paths that need to
434 # be converted post extraction, but a simpler script.
435 $ECHO 'echo VS_PATH="%PATH%" > set-vs-env.sh' \
436 >> $EXTRACT_VC_ENV_BAT_FILE
437 $ECHO 'echo VS_INCLUDE="%INCLUDE% " >> set-vs-env.sh' \
438 >> $EXTRACT_VC_ENV_BAT_FILE
439 $ECHO 'echo VS_LIB="%LIB% " >> set-vs-env.sh' \
440 >> $EXTRACT_VC_ENV_BAT_FILE
441 $ECHO 'echo VCINSTALLDIR="%VCINSTALLDIR% " >> set-vs-env.sh' \
442 >> $EXTRACT_VC_ENV_BAT_FILE
443 $ECHO 'echo VCToolsRedistDir="%VCToolsRedistDir% " >> set-vs-env.sh' \
444 >> $EXTRACT_VC_ENV_BAT_FILE
445 $ECHO 'echo WindowsSdkDir="%WindowsSdkDir% " >> set-vs-env.sh' \
446 >> $EXTRACT_VC_ENV_BAT_FILE
447 $ECHO 'echo WINDOWSSDKDIR="%WINDOWSSDKDIR% " >> set-vs-env.sh' \
448 >> $EXTRACT_VC_ENV_BAT_FILE
449 else
450 # These will end up something like:
451 # C:/CygWin/bin/bash -c 'echo VS_PATH=\"$PATH\" > localdevenv.sh
452 # The trailing space for everyone except PATH is no typo, but is needed due
453 # to trailing \ in the Windows paths. These will be stripped later.
454 $ECHO "$WINPATH_BASH -c 'echo VS_PATH="'\"$PATH\" > set-vs-env.sh' \
455 >> $EXTRACT_VC_ENV_BAT_FILE
456 $ECHO "$WINPATH_BASH -c 'echo VS_INCLUDE="'\"$INCLUDE\;$include \" >> set-vs-env.sh' \
457 >> $EXTRACT_VC_ENV_BAT_FILE
458 $ECHO "$WINPATH_BASH -c 'echo VS_LIB="'\"$LIB\;$lib \" >> set-vs-env.sh' \
459 >> $EXTRACT_VC_ENV_BAT_FILE
460 $ECHO "$WINPATH_BASH -c 'echo VCINSTALLDIR="'\"$VCINSTALLDIR \" >> set-vs-env.sh' \
461 >> $EXTRACT_VC_ENV_BAT_FILE
462 $ECHO "$WINPATH_BASH -c 'echo VCToolsRedistDir="'\"$VCToolsRedistDir \" >> set-vs-env.sh' \
463 >> $EXTRACT_VC_ENV_BAT_FILE
464 $ECHO "$WINPATH_BASH -c 'echo WindowsSdkDir="'\"$WindowsSdkDir \" >> set-vs-env.sh' \
465 >> $EXTRACT_VC_ENV_BAT_FILE
466 $ECHO "$WINPATH_BASH -c 'echo WINDOWSSDKDIR="'\"$WINDOWSSDKDIR \" >> set-vs-env.sh' \
467 >> $EXTRACT_VC_ENV_BAT_FILE
468 fi
469
470 # Now execute the newly created bat file.
471 # The | cat is to stop SetEnv.Cmd to mess with system colors on msys.
472 # Change directory so we don't need to mess with Windows paths in redirects.
473 cd $VS_ENV_TMP_DIR
474 $CMD /c extract-vs-env.bat | $CAT
475 cd $CONFIGURE_START_DIR
476
477 if test ! -s $VS_ENV_TMP_DIR/set-vs-env.sh; then
478 AC_MSG_NOTICE([Could not succesfully extract the environment variables needed for the VS setup.])
479 AC_MSG_NOTICE([Try setting --with-tools-dir to the VC/bin directory within the VS installation])
480 AC_MSG_NOTICE([or run "bash.exe -l" from a VS command prompt and then run configure from there.])
481 AC_MSG_ERROR([Cannot continue])
482 fi
483
484 # Remove windows line endings
485 $SED -i -e 's|\r||g' $VS_ENV_TMP_DIR/set-vs-env.sh
486
487 # Now set all paths and other env variables. This will allow the rest of
488 # the configure script to find and run the compiler in the proper way.
489 AC_MSG_NOTICE([Setting extracted environment variables])
490 . $VS_ENV_TMP_DIR/set-vs-env.sh
491 # Now we have VS_PATH, VS_INCLUDE, VS_LIB. For further checking, we
492 # also define VCINSTALLDIR, WindowsSdkDir and WINDOWSSDKDIR.
493
494 # In WSL, the extracted VS_PATH is Windows style. This needs to be
495 # rewritten as Unix style and the Windows style version is saved
496 # in VS_PATH_WINDOWS.
497 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then
498 OLDIFS="$IFS"
499 IFS=";"
500 # Convert VS_PATH to unix style
501 VS_PATH_WINDOWS="$VS_PATH"
502 VS_PATH=""
503 for i in $VS_PATH_WINDOWS; do
504 path=$i
505 # Only process non-empty elements
506 if test "x$path" != x; then
507 IFS="$OLDIFS"
508 # Check that directory exists before calling fixup_path
509 testpath=$path
510 BASIC_WINDOWS_REWRITE_AS_UNIX_PATH([testpath])
511 if test -d "$testpath"; then
512 BASIC_FIXUP_PATH([path])
513 BASIC_APPEND_TO_PATH(VS_PATH, $path)
514 fi
515 IFS=";"
516 fi
517 done
518 IFS="$OLDIFS"
519 fi
520
521 else
522 # We did not find a vsvars bat file, let's hope we are run from a VS command prompt.
523 AC_MSG_NOTICE([Cannot locate a valid Visual Studio installation, checking current environment])
524 fi
525 fi
526
527 # At this point, we should have correct variables in the environment, or we can't continue.
528 AC_MSG_CHECKING([for Visual Studio variables])
529
530 if test "x$VCINSTALLDIR" != x || test "x$WindowsSDKDir" != x \
531 || test "x$WINDOWSSDKDIR" != x || test "x$DEVKIT_NAME" != x; then
532 if test "x$VS_INCLUDE" = x || test "x$VS_LIB" = x; then
533 AC_MSG_RESULT([present but broken])
534 AC_MSG_ERROR([Your VC command prompt seems broken, INCLUDE and/or LIB is missing.])
535 else
536 AC_MSG_RESULT([ok])
537 # Remove any trailing "\" ";" and " " from the variables.
538 VS_INCLUDE=`$ECHO "$VS_INCLUDE" | $SED -e 's/\\\\*;* *$//'`
539 VS_LIB=`$ECHO "$VS_LIB" | $SED 's/\\\\*;* *$//'`
540 VCINSTALLDIR=`$ECHO "$VCINSTALLDIR" | $SED 's/\\\\* *$//'`
541 VCToolsRedistDir=`$ECHO "$VCToolsRedistDir" | $SED 's/\\\\* *$//'`
542 WindowsSdkDir=`$ECHO "$WindowsSdkDir" | $SED 's/\\\\* *$//'`
543 WINDOWSSDKDIR=`$ECHO "$WINDOWSSDKDIR" | $SED 's/\\\\* *$//'`
544 if test -z "$WINDOWSSDKDIR"; then
545 WINDOWSSDKDIR="$WindowsSdkDir"
546 fi
547 # Remove any paths containing # (typically F#) as that messes up make. This
548 # is needed if visual studio was installed with F# support.
549 VS_PATH=`$ECHO "$VS_PATH" | $SED 's/[[^:#]]*#[^:]*://g'`
550
551 AC_SUBST(VS_PATH)
552 AC_SUBST(VS_INCLUDE)
553 AC_SUBST(VS_LIB)
554
555 # Convert VS_INCLUDE into SYSROOT_CFLAGS
556 OLDIFS="$IFS"
557 IFS=";"
558 for i in $VS_INCLUDE; do
559 ipath=$i
560 # Only process non-empty elements
561 if test "x$ipath" != x; then
562 IFS="$OLDIFS"
563 # Check that directory exists before calling fixup_path
564 testpath=$ipath
565 BASIC_WINDOWS_REWRITE_AS_UNIX_PATH([testpath])
566 if test -d "$testpath"; then
567 BASIC_FIXUP_PATH([ipath])
568 SYSROOT_CFLAGS="$SYSROOT_CFLAGS -I$ipath"
569 fi
570 IFS=";"
571 fi
572 done
573 # Convert VS_LIB into SYSROOT_LDFLAGS
574 for i in $VS_LIB; do
575 libpath=$i
576 # Only process non-empty elements
577 if test "x$libpath" != x; then
578 IFS="$OLDIFS"
579 # Check that directory exists before calling fixup_path
580 testpath=$libpath
581 BASIC_WINDOWS_REWRITE_AS_UNIX_PATH([testpath])
582 if test -d "$testpath"; then
583 BASIC_FIXUP_PATH([libpath])
584 SYSROOT_LDFLAGS="$SYSROOT_LDFLAGS -libpath:$libpath"
585 fi
586 IFS=";"
587 fi
588 done
589 IFS="$OLDIFS"
590
591 AC_SUBST(VS_PATH_WINDOWS)
592 fi
593 else
594 AC_MSG_RESULT([not found])
595
596 if test "x$VS_ENV_CMD" = x; then
597 AC_MSG_NOTICE([Cannot locate a valid Visual Studio or Windows SDK installation on disk,])
598 AC_MSG_NOTICE([nor is this script run from a Visual Studio command prompt.])
599 else
600 AC_MSG_NOTICE([Running the extraction script failed.])
601 fi
602 AC_MSG_NOTICE([Try setting --with-tools-dir to the VC/bin directory within the VS installation])
603 AC_MSG_NOTICE([or run "bash.exe -l" from a VS command prompt and then run configure from there.])
604 AC_MSG_ERROR([Cannot continue])
605 fi
606 ])
607
608 AC_DEFUN([TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL],
609 [
610 DLL_NAME="$1"
611 POSSIBLE_MSVC_DLL="$2"
612 METHOD="$3"
613 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
614 AC_MSG_NOTICE([Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD])
615
616 # Need to check if the found msvcr is correct architecture
617 AC_MSG_CHECKING([found $DLL_NAME architecture])
618 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
619 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
620 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
621 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
622 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
623 CORRECT_MSVCR_ARCH="PE32 executable"
624 else
625 CORRECT_MSVCR_ARCH="PE32+ executable"
626 fi
627 else
628 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
629 CORRECT_MSVCR_ARCH=386
630 else
631 CORRECT_MSVCR_ARCH=x86-64
632 fi
633 fi
634 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
635 AC_MSG_RESULT([ok])
636 MSVC_DLL="$POSSIBLE_MSVC_DLL"
637 AC_MSG_CHECKING([for $DLL_NAME])
638 AC_MSG_RESULT([$MSVC_DLL])
639 else
640 AC_MSG_RESULT([incorrect, ignoring])
641 AC_MSG_NOTICE([The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE])
642 fi
643 fi
644 ])
645
646 AC_DEFUN([TOOLCHAIN_SETUP_MSVC_DLL],
647 [
648 DLL_NAME="$1"
649 MSVC_DLL=
650
651 if test "x$MSVC_DLL" = x; then
652 if test "x$VCINSTALLDIR" != x; then
653 CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR"
654 BASIC_FIXUP_PATH(CYGWIN_VC_INSTALL_DIR)
655 if test "$VS_VERSION" -lt 2017; then
656 # Probe: Using well-known location from Visual Studio 12.0 and older
657 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
658 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x64/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
659 else
660 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x86/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
661 fi
662 else
663 CYGWIN_VC_TOOLS_REDIST_DIR="$VCToolsRedistDir"
664 BASIC_FIXUP_PATH(CYGWIN_VC_TOOLS_REDIST_DIR)
665 # Probe: Using well-known location from VS 2017
666 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
667 POSSIBLE_MSVC_DLL="`ls $CYGWIN_VC_TOOLS_REDIST_DIR/x64/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME`"
668 else
669 POSSIBLE_MSVC_DLL="`ls $CYGWIN_VC_TOOLS_REDIST_DIR/x86/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME`"
670 fi
671 fi
672 # In case any of the above finds more than one file, loop over them.
673 for possible_msvc_dll in $POSSIBLE_MSVC_DLL; do
674 $ECHO "POSSIBLE_MSVC_DLL $possible_msvc_dll"
675 TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL([$DLL_NAME], [$possible_msvc_dll],
676 [well-known location in VCINSTALLDIR])
677 done
678 fi
679 fi
680
681 if test "x$MSVC_DLL" = x; then
682 # Probe: Check in the Boot JDK directory.
683 POSSIBLE_MSVC_DLL="$BOOT_JDK/bin/$DLL_NAME"
684 TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL([$DLL_NAME], [$POSSIBLE_MSVC_DLL],
685 [well-known location in Boot JDK])
686 fi
687
688 if test "x$MSVC_DLL" = x; then
689 # Probe: Look in the Windows system32 directory
690 CYGWIN_SYSTEMROOT="$SYSTEMROOT"
691 BASIC_WINDOWS_REWRITE_AS_UNIX_PATH(CYGWIN_SYSTEMROOT)
692 POSSIBLE_MSVC_DLL="$CYGWIN_SYSTEMROOT/system32/$DLL_NAME"
693 TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL([$DLL_NAME], [$POSSIBLE_MSVC_DLL],
694 [well-known location in SYSTEMROOT])
695 fi
696
697 if test "x$MSVC_DLL" = x; then
698 # Probe: If Visual Studio Express is installed, there is usually one with the debugger
699 if test "x$VS100COMNTOOLS" != x; then
700 CYGWIN_VS_TOOLS_DIR="$VS100COMNTOOLS/.."
701 BASIC_WINDOWS_REWRITE_AS_UNIX_PATH(CYGWIN_VS_TOOLS_DIR)
702 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
703 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
704 | $GREP -i /x64/ | $HEAD --lines 1`
705 else
706 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
707 | $GREP -i /x86/ | $HEAD --lines 1`
708 fi
709 TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL([$DLL_NAME], [$POSSIBLE_MSVC_DLL],
710 [search of VS100COMNTOOLS])
711 fi
712 fi
713
714 if test "x$MSVC_DLL" = x; then
715 # Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now.
716 # (This was the original behaviour; kept since it might turn something up)
717 if test "x$CYGWIN_VC_INSTALL_DIR" != x; then
718 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
719 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
720 | $GREP x64 | $HEAD --lines 1`
721 else
722 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
723 | $GREP x86 | $GREP -v ia64 | $GREP -v x64 | $HEAD --lines 1`
724 if test "x$POSSIBLE_MSVC_DLL" = x; then
725 # We're grasping at straws now...
726 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
727 | $HEAD --lines 1`
728 fi
729 fi
730
731 TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL([$DLL_NAME], [$POSSIBLE_MSVC_DLL],
732 [search of VCINSTALLDIR])
733 fi
734 fi
735
736 if test "x$MSVC_DLL" = x; then
737 AC_MSG_CHECKING([for $DLL_NAME])
738 AC_MSG_RESULT([no])
739 AC_MSG_ERROR([Could not find $DLL_NAME. Please specify using --with-msvcr-dll.])
740 fi
741 ])
742
743 AC_DEFUN([TOOLCHAIN_SETUP_VS_RUNTIME_DLLS],
744 [
745 AC_ARG_WITH(msvcr-dll, [AS_HELP_STRING([--with-msvcr-dll],
746 [path to microsoft C runtime dll (msvcr*.dll) (Windows only) @<:@probed@:>@])])
747
748 if test "x$with_msvcr_dll" != x; then
749 # If given explicitly by user, do not probe. If not present, fail directly.
750 TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL($MSVCR_NAME, [$with_msvcr_dll], [--with-msvcr-dll])
751 if test "x$MSVC_DLL" = x; then
752 AC_MSG_ERROR([Could not find a proper $MSVCR_NAME as specified by --with-msvcr-dll])
753 fi
754 MSVCR_DLL="$MSVC_DLL"
755 elif test "x$DEVKIT_MSVCR_DLL" != x; then
756 TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL($MSVCR_NAME, [$DEVKIT_MSVCR_DLL], [devkit])
757 if test "x$MSVC_DLL" = x; then
758 AC_MSG_ERROR([Could not find a proper $MSVCR_NAME as specified by devkit])
759 fi
760 MSVCR_DLL="$MSVC_DLL"
761 else
762 TOOLCHAIN_SETUP_MSVC_DLL([${MSVCR_NAME}])
763 MSVCR_DLL="$MSVC_DLL"
764 fi
765 AC_SUBST(MSVCR_DLL)
766
767 AC_ARG_WITH(msvcp-dll, [AS_HELP_STRING([--with-msvcp-dll],
768 [path to microsoft C++ runtime dll (msvcp*.dll) (Windows only) @<:@probed@:>@])])
769
770 if test "x$MSVCP_NAME" != "x"; then
771 if test "x$with_msvcp_dll" != x; then
772 # If given explicitly by user, do not probe. If not present, fail directly.
773 TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL($MSVCP_NAME, [$with_msvcp_dll], [--with-msvcp-dll])
774 if test "x$MSVC_DLL" = x; then
775 AC_MSG_ERROR([Could not find a proper $MSVCP_NAME as specified by --with-msvcp-dll])
776 fi
777 MSVCP_DLL="$MSVC_DLL"
778 elif test "x$DEVKIT_MSVCP_DLL" != x; then
779 TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL($MSVCP_NAME, [$DEVKIT_MSVCP_DLL], [devkit])
780 if test "x$MSVC_DLL" = x; then
781 AC_MSG_ERROR([Could not find a proper $MSVCP_NAME as specified by devkit])
782 fi
783 MSVCP_DLL="$MSVC_DLL"
784 else
785 TOOLCHAIN_SETUP_MSVC_DLL([${MSVCP_NAME}])
786 MSVCP_DLL="$MSVC_DLL"
787 fi
788 AC_SUBST(MSVCP_DLL)
789 fi
790
791 AC_ARG_WITH(ucrt-dll-dir, [AS_HELP_STRING([--with-ucrt-dll-dir],
792 [path to Microsoft Windows Kit UCRT DLL dir (Windows only) @<:@probed@:>@])])
793
794 if test "x$USE_UCRT" = "xtrue"; then
795 AC_MSG_CHECKING([for UCRT DLL dir])
796 if test "x$with_ucrt_dll_dir" != x; then
797 if test -z "$(ls -d $with_ucrt_dll_dir/*.dll 2> /dev/null)"; then
798 AC_MSG_RESULT([no])
799 AC_MSG_ERROR([Could not find any dlls in $with_ucrt_dll_dir])
800 else
801 AC_MSG_RESULT([$with_ucrt_dll_dir])
802 UCRT_DLL_DIR="$with_ucrt_dll_dir"
803 BASIC_FIXUP_PATH([UCRT_DLL_DIR])
804 fi
805 elif test "x$DEVKIT_UCRT_DLL_DIR" != "x"; then
806 UCRT_DLL_DIR="$DEVKIT_UCRT_DLL_DIR"
807 AC_MSG_RESULT($UCRT_DLL_DIR)
808 else
809 CYGWIN_WINDOWSSDKDIR="${WINDOWSSDKDIR}"
810 BASIC_FIXUP_PATH([CYGWIN_WINDOWSSDKDIR])
811 dll_subdir=$OPENJDK_TARGET_CPU
812 if test "x$dll_subdir" = "xx86_64"; then
813 dll_subdir="x64"
814 fi
815 UCRT_DLL_DIR="$CYGWIN_WINDOWSSDKDIR/Redist/ucrt/DLLs/$dll_subdir"
816 if test -z "$(ls -d "$UCRT_DLL_DIR/"*.dll 2> /dev/null)"; then
817 # Try with version subdir
818 UCRT_DLL_DIR="`ls -d $CYGWIN_WINDOWSSDKDIR/Redist/*/ucrt/DLLs/$dll_subdir \
819 2> /dev/null | $SORT -d | $HEAD -n1`"
820 if test -z "$UCRT_DLL_DIR" \
821 || test -z "$(ls -d "$UCRT_DLL_DIR/"*.dll 2> /dev/null)"; then
822 AC_MSG_RESULT([no])
823 AC_MSG_ERROR([Could not find any dlls in $UCRT_DLL_DIR])
824 else
825 AC_MSG_RESULT($UCRT_DLL_DIR)
826 fi
827 else
828 AC_MSG_RESULT($UCRT_DLL_DIR)
829 fi
830 fi
831 else
832 UCRT_DLL_DIR=
833 fi
834 AC_SUBST(UCRT_DLL_DIR)
835 ])