diff --git a/.github/workflows/submit.yml b/.github/workflows/submit.yml index a2cc911e5f8..f0b27f39bc3 100644 --- a/.github/workflows/submit.yml +++ b/.github/workflows/submit.yml @@ -938,15 +938,18 @@ jobs: run: > $env:Path = "$HOME\cygwin\cygwin64\bin;$HOME\cygwin\cygwin64\bin;$env:Path" ; $env:Path = $env:Path -split ";" -match "C:\\Windows|PowerShell|cygwin" -join ";" ; + $env:BOOT_JDK = cygpath "$HOME/bootjdk/$env:BOOT_JDK_VERSION" ; + $env:JT_HOME = cygpath "$HOME/jtreg" ; + $env:GTEST = cygpath "$env:GITHUB_WORKSPACE/gtest" ; & bash configure --with-conf-name=windows-x64 --with-msvc-toolset-version=14.27 ${{ matrix.flags }} --with-version-opt="$env:GITHUB_ACTOR-$env:GITHUB_SHA" --with-version-build=0 - --with-boot-jdk="$HOME/bootjdk/$env:BOOT_JDK_VERSION" - --with-jtreg="$HOME/jtreg" - --with-gtest="$env:GITHUB_WORKSPACE/gtest" + --with-boot-jdk="$env:BOOT_JDK" + --with-jtreg="$env:JT_HOME" + --with-gtest="$env:GTEST" --with-default-make-target="product-bundles test-bundles" --enable-jtreg-failure-handler working-directory: jdk diff --git a/make/GenerateLinkOptData.gmk b/make/GenerateLinkOptData.gmk index dd92bddc560..0de28d643fc 100644 --- a/make/GenerateLinkOptData.gmk +++ b/make/GenerateLinkOptData.gmk @@ -61,7 +61,7 @@ endif # Save the stderr output of the command and print it along with stdout in case # something goes wrong. -$(CLASSLIST_FILE): $(INTERIM_IMAGE_DIR)/bin/java$(EXE_SUFFIX) $(CLASSLIST_JAR) +$(CLASSLIST_FILE): $(INTERIM_IMAGE_DIR)/bin/java$(EXECUTABLE_SUFFIX) $(CLASSLIST_JAR) $(call MakeDir, $(LINK_OPT_DIR)) $(call LogInfo, Generating $(patsubst $(OUTPUTDIR)/%, %, $@)) $(call LogInfo, Generating $(patsubst $(OUTPUTDIR)/%, %, $(JLI_TRACE_FILE))) @@ -94,7 +94,7 @@ $(CLASSLIST_FILE): $(INTERIM_IMAGE_DIR)/bin/java$(EXE_SUFFIX) $(CLASSLIST_JAR) # dependencies, make will correctly rebuild both jli trace and classlist # incrementally using the single recipe above. $(CLASSLIST_FILE): $(JLI_TRACE_FILE) -$(JLI_TRACE_FILE): $(INTERIM_IMAGE_DIR)/bin/java$(EXE_SUFFIX) $(CLASSLIST_JAR) +$(JLI_TRACE_FILE): $(INTERIM_IMAGE_DIR)/bin/java$(EXECUTABLE_SUFFIX) $(CLASSLIST_JAR) TARGETS += $(CLASSLIST_FILE) $(JLI_TRACE_FILE) diff --git a/make/InterimImage.gmk b/make/InterimImage.gmk index 22d3db365aa..bb4b1fc6fd3 100644 --- a/make/InterimImage.gmk +++ b/make/InterimImage.gmk @@ -1,5 +1,5 @@ # -# Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2016, 2020, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # This code is free software; you can redistribute it and/or modify it @@ -32,7 +32,7 @@ include Modules.gmk ################################################################################ # Use this file inside the image as target for make rule -JIMAGE_TARGET_FILE := bin/java$(EXE_SUFFIX) +JIMAGE_TARGET_FILE := bin/java$(EXECUTABLE_SUFFIX) INTERIM_MODULES_LIST := $(call CommaList, $(INTERIM_IMAGE_MODULES)) diff --git a/make/RunTests.gmk b/make/RunTests.gmk index 97fd016b361..8b9fea85d32 100644 --- a/make/RunTests.gmk +++ b/make/RunTests.gmk @@ -60,19 +60,14 @@ define SetTestOpt endif endef -# Setup _NT_SYMBOL_PATH on Windows +# Setup _NT_SYMBOL_PATH on Windows, which points to our pdb files. ifeq ($(call isTargetOs, windows), true) ifndef _NT_SYMBOL_PATH - # Can't use PathList here as it adds quotes around the value. - _NT_SYMBOL_PATH := \ - $(subst $(SPACE),;,$(strip \ - $(foreach p, $(sort $(dir $(wildcard \ - $(addprefix $(SYMBOLS_IMAGE_DIR)/bin/, *.pdb */*.pdb)))), \ - $(call FixPath, $p) \ - ) \ - )) - export _NT_SYMBOL_PATH - $(call LogDebug, Rewriting _NT_SYMBOL_PATH to $(_NT_SYMBOL_PATH)) + SYMBOL_PATH := $(call PathList, $(sort $(patsubst %/, %, $(dir $(wildcard \ + $(addprefix $(SYMBOLS_IMAGE_DIR)/bin/, *.pdb */*.pdb)))))) + export _NT_SYMBOL_PATH := $(subst \\,\, $(call FixPath, \ + $(subst $(DQUOTE),, $(SYMBOL_PATH)))) + $(call LogDebug, Setting _NT_SYMBOL_PATH to $(_NT_SYMBOL_PATH)) endif endif diff --git a/make/RunTestsPrebuilt.gmk b/make/RunTestsPrebuilt.gmk index 3468ca4daf1..1cbd8f2273a 100644 --- a/make/RunTestsPrebuilt.gmk +++ b/make/RunTestsPrebuilt.gmk @@ -189,15 +189,9 @@ ifeq ($(OPENJDK_TARGET_CPU), x86_64) endif ifeq ($(OPENJDK_TARGET_OS), windows) - ifeq ($(wildcard $(TEST_IMAGE_DIR)/bin/fixpath.exe), ) - $(info Error: fixpath is missing from test image '$(TEST_IMAGE_DIR)') - $(error Cannot continue.) - endif - FIXPATH := $(TEST_IMAGE_DIR)/bin/fixpath.exe -c - PATH_SEP:=; + FIXPATH := $(BASH) $(TOPDIR)/make/scripts/fixpath.sh exec else FIXPATH := - PATH_SEP:=: endif # Check number of cores and memory in MB @@ -280,7 +274,6 @@ $(call CreateNewSpec, $(NEW_SPEC), \ BASH := $(BASH), \ JIB_JAR := $(JIB_JAR), \ FIXPATH := $(FIXPATH), \ - PATH_SEP := $(PATH_SEP), \ OPENJDK_TARGET_OS := $(OPENJDK_TARGET_OS), \ OPENJDK_TARGET_OS_TYPE := $(OPENJDK_TARGET_OS_TYPE), \ OPENJDK_TARGET_OS_ENV := $(OPENJDK_TARGET_OS_ENV), \ diff --git a/make/RunTestsPrebuiltSpec.gmk b/make/RunTestsPrebuiltSpec.gmk index a12a5383c6b..f423fea7198 100644 --- a/make/RunTestsPrebuiltSpec.gmk +++ b/make/RunTestsPrebuiltSpec.gmk @@ -116,16 +116,13 @@ JAVAC_CMD := $(BOOT_JDK)/bin/javac JAR_CMD := $(BOOT_JDK)/bin/jar JLINK_CMD := $(JDK_OUTPUTDIR)/bin/jlink JMOD_CMD := $(JDK_OUTPUTDIR)/bin/jmod -JARSIGNER_CMD := $(BOOT_JDK)/bin/jarsigner JAVA := $(FIXPATH) $(JAVA_CMD) $(JAVA_FLAGS_BIG) $(JAVA_FLAGS) JAVA_SMALL := $(FIXPATH) $(JAVA_CMD) $(JAVA_FLAGS_SMALL) $(JAVA_FLAGS) -JAVA_DETACH := $(FIXPATH) $(FIXPATH_DETACH_FLAG) $(JAVA_CMD) $(JAVA_FLAGS_BIG) $(JAVA_FLAGS) JAVAC := $(FIXPATH) $(JAVAC_CMD) JAR := $(FIXPATH) $(JAR_CMD) JLINK := $(FIXPATH) $(JLINK_CMD) JMOD := $(FIXPATH) $(JMOD_CMD) -JARSIGNER := $(FIXPATH) $(JARSIGNER_CMD) BUILD_JAVA := $(JDK_IMAGE_DIR)/bin/JAVA ################################################################################ @@ -166,7 +163,6 @@ TAIL := tail TEE := tee TR := tr TOUCH := touch -UNIQ := uniq WC := wc XARGS := xargs ZIPEXE := zip @@ -177,7 +173,7 @@ HG := hg ULIMIT := ulimit ifeq ($(OPENJDK_BUILD_OS), windows) - CYGPATH := cygpath + PATHTOOL := cygpath endif ################################################################################ diff --git a/make/TestImage.gmk b/make/TestImage.gmk index 8511c5dc87f..36ba5ba4007 100644 --- a/make/TestImage.gmk +++ b/make/TestImage.gmk @@ -30,29 +30,15 @@ include MakeBase.gmk ############################################################################ -ifeq ($(call isTargetOs, windows), true) - FIXPATH_COPY := $(TEST_IMAGE_DIR)/bin/fixpath.exe - - $(FIXPATH_COPY): $(firstword $(FIXPATH)) - $(call install-file) - - FIXPATH_WORKSPACE_ROOT := $(call FixPath, $(WORKSPACE_ROOT)) - FIXPATH_OUTPUTDIR := $(call FixPath, $(OUTPUTDIR)) -else - FIXPATH_WORKSPACE_ROOT := $(WORKSPACE_ROOT) - FIXPATH_OUTPUTDIR := $(OUTPUTDIR) -endif - - BUILD_INFO_PROPERTIES := $(TEST_IMAGE_DIR)/build-info.properties $(BUILD_INFO_PROPERTIES): $(call MakeTargetDir) $(ECHO) "# Build info properties for JDK tests" > $@ - $(ECHO) "build.workspace.root=$(FIXPATH_WORKSPACE_ROOT)" >> $@ - $(ECHO) "build.output.root=$(FIXPATH_OUTPUTDIR)" >> $@ + $(ECHO) "build.workspace.root=$(call FixPath, $(WORKSPACE_ROOT))" >> $@ + $(ECHO) "build.output.root=$(call FixPath, $(OUTPUTDIR))" >> $@ -prepare-test-image: $(FIXPATH_COPY) $(BUILD_INFO_PROPERTIES) +prepare-test-image: $(BUILD_INFO_PROPERTIES) $(call MakeDir, $(TEST_IMAGE_DIR)) $(ECHO) > $(TEST_IMAGE_DIR)/Readme.txt 'JDK test image' diff --git a/make/autoconf/basic.m4 b/make/autoconf/basic.m4 index fb06fa5426a..60b4097cba9 100644 --- a/make/autoconf/basic.m4 +++ b/make/autoconf/basic.m4 @@ -70,27 +70,18 @@ AC_DEFUN_ONCE([BASIC_SETUP_PATHS], fi if test "x$OPENJDK_TARGET_OS" = "xwindows"; then - PATH_SEP=";" - EXE_SUFFIX=".exe" - BASIC_CHECK_PATHS_WINDOWS - else - PATH_SEP=":" - EXE_SUFFIX="" + BASIC_SETUP_PATHS_WINDOWS fi - AC_SUBST(PATH_SEP) - AC_SUBST(EXE_SUFFIX) # We get the top-level directory from the supporting wrappers. + BASIC_WINDOWS_VERIFY_DIR($TOPDIR, source) + UTIL_FIXUP_PATH(TOPDIR) AC_MSG_CHECKING([for top-level directory]) AC_MSG_RESULT([$TOPDIR]) AC_SUBST(TOPDIR) - AC_SUBST(CONFIGURE_START_DIR) - - # We can only call UTIL_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS. - UTIL_FIXUP_PATH(TOPDIR) - UTIL_FIXUP_PATH(CONFIGURE_START_DIR) if test "x$CUSTOM_ROOT" != x; then + BASIC_WINDOWS_VERIFY_DIR($CUSTOM_ROOT, custom root) UTIL_FIXUP_PATH(CUSTOM_ROOT) WORKSPACE_ROOT="${CUSTOM_ROOT}" else @@ -98,6 +89,9 @@ AC_DEFUN_ONCE([BASIC_SETUP_PATHS], fi AC_SUBST(WORKSPACE_ROOT) + UTIL_FIXUP_PATH(CONFIGURE_START_DIR) + AC_SUBST(CONFIGURE_START_DIR) + # Locate the directory of this script. AUTOCONF_DIR=$TOPDIR/make/autoconf @@ -234,9 +228,12 @@ AC_DEFUN_ONCE([BASIC_SETUP_DEVKIT], # if no Xcode installed, xcodebuild exits with 1 # if Xcode is installed, even if xcode-select is misconfigured, then it exits with 0 if test "x$DEVKIT_ROOT" != x || /usr/bin/xcodebuild -version >/dev/null 2>&1; then - # We need to use xcodebuild in the toolchain dir provided by the user, this will - # fall back on the stub binary in /usr/bin/xcodebuild - AC_PATH_PROG([XCODEBUILD], [xcodebuild], [/usr/bin/xcodebuild], [$TOOLCHAIN_PATH]) + # We need to use xcodebuild in the toolchain dir provided by the user + UTIL_LOOKUP_PROGS(XCODEBUILD, xcodebuild, $TOOLCHAIN_PATH) + if test x$XCODEBUILD = x; then + # fall back on the stub binary in /usr/bin/xcodebuild + XCODEBUILD=/usr/bin/xcodebuild + fi else # this should result in SYSROOT being empty, unless --with-sysroot is provided # when only the command line tools are installed there are no SDKs, so headers @@ -306,6 +303,7 @@ AC_DEFUN_ONCE([BASIC_SETUP_DEVKIT], AC_MSG_RESULT([$SYSROOT]) AC_MSG_CHECKING([for toolchain path]) AC_MSG_RESULT([$TOOLCHAIN_PATH]) + AC_SUBST(TOOLCHAIN_PATH) AC_MSG_CHECKING([for extra path]) AC_MSG_RESULT([$EXTRA_PATH]) ]) @@ -380,6 +378,7 @@ AC_DEFUN_ONCE([BASIC_SETUP_OUTPUT_DIR], AC_MSG_CHECKING([what configuration name to use]) AC_MSG_RESULT([$CONF_NAME]) + BASIC_WINDOWS_VERIFY_DIR($OUTPUTDIR, output) UTIL_FIXUP_PATH(OUTPUTDIR) CONFIGURESUPPORT_OUTPUTDIR="$OUTPUTDIR/configure-support" @@ -416,26 +415,16 @@ AC_DEFUN([BASIC_CHECK_DIR_ON_LOCAL_DISK], # df -l lists only local disks; if the given directory is not found then # a non-zero exit code is given if test "x$DF" = x; then - if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then - # msys does not have df; use Windows "net use" instead. - IS_NETWORK_DISK=`net use | grep \`pwd -W | cut -d ":" -f 1 | tr a-z A-Z\`:` - if test "x$IS_NETWORK_DISK" = x; then - $2 - else - $3 - fi - else - # No df here, say it's local - $2 - fi + # No df here, say it's local + $2 else # JDK-8189619 # df on AIX does not understand -l. On modern AIXes it understands "-T local" which # is the same. On older AIXes we just continue to live with a "not local build" warning. if test "x$OPENJDK_TARGET_OS" = xaix; then DF_LOCAL_ONLY_OPTION='-T local' - elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then - # In WSL, we can only build on a drvfs file system (that is, a mounted real Windows drive) + elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl1"; then + # In WSL1, we can only build on a drvfs file system (that is, a mounted real Windows drive) DF_LOCAL_ONLY_OPTION='-t drvfs' else DF_LOCAL_ONLY_OPTION='-l' diff --git a/make/autoconf/basic_tools.m4 b/make/autoconf/basic_tools.m4 index dd1cd3935c4..820d2f4924d 100644 --- a/make/autoconf/basic_tools.m4 +++ b/make/autoconf/basic_tools.m4 @@ -28,38 +28,37 @@ # but is used by much of the early bootstrap code. AC_DEFUN_ONCE([BASIC_SETUP_FUNDAMENTAL_TOOLS], [ - # Start with tools that do not need have cross compilation support - # and can be expected to be found in the default PATH. These tools are - # used by configure. + # Bootstrapping: These tools are needed by UTIL_LOOKUP_PROGS + AC_PATH_PROGS(BASENAME, basename) + UTIL_CHECK_NONEMPTY(BASENAME) + AC_PATH_PROGS(DIRNAME, dirname) + UTIL_CHECK_NONEMPTY(DIRNAME) + AC_PATH_PROGS(FILE, file) + UTIL_CHECK_NONEMPTY(FILE) + AC_PATH_PROGS(LDD, ldd) - # First are all the simple required tools. - UTIL_REQUIRE_PROGS(BASENAME, basename) + # First are all the fundamental required tools. UTIL_REQUIRE_PROGS(BASH, bash) UTIL_REQUIRE_PROGS(CAT, cat) UTIL_REQUIRE_PROGS(CHMOD, chmod) - UTIL_REQUIRE_PROGS(CMP, cmp) - UTIL_REQUIRE_PROGS(COMM, comm) UTIL_REQUIRE_PROGS(CP, cp) UTIL_REQUIRE_PROGS(CUT, cut) UTIL_REQUIRE_PROGS(DATE, date) - UTIL_REQUIRE_PROGS(DIFF, [gdiff diff]) - UTIL_REQUIRE_PROGS(DIRNAME, dirname) + UTIL_REQUIRE_PROGS(DIFF, gdiff diff) UTIL_REQUIRE_PROGS(ECHO, echo) UTIL_REQUIRE_PROGS(EXPR, expr) - UTIL_REQUIRE_PROGS(FILE, file) UTIL_REQUIRE_PROGS(FIND, find) - UTIL_REQUIRE_PROGS(HEAD, head) UTIL_REQUIRE_PROGS(GUNZIP, gunzip) UTIL_REQUIRE_PROGS(GZIP, pigz gzip) + UTIL_REQUIRE_PROGS(HEAD, head) UTIL_REQUIRE_PROGS(LN, ln) UTIL_REQUIRE_PROGS(LS, ls) # gmkdir is known to be safe for concurrent invocations with -p flag. - UTIL_REQUIRE_PROGS(MKDIR, [gmkdir mkdir]) + UTIL_REQUIRE_PROGS(MKDIR, gmkdir mkdir) UTIL_REQUIRE_PROGS(MKTEMP, mktemp) UTIL_REQUIRE_PROGS(MV, mv) - UTIL_REQUIRE_PROGS(AWK, [gawk nawk awk]) + UTIL_REQUIRE_PROGS(AWK, gawk nawk awk) UTIL_REQUIRE_PROGS(PRINTF, printf) - UTIL_REQUIRE_PROGS(READLINK, [greadlink readlink]) UTIL_REQUIRE_PROGS(RM, rm) UTIL_REQUIRE_PROGS(RMDIR, rmdir) UTIL_REQUIRE_PROGS(SH, sh) @@ -70,7 +69,6 @@ AC_DEFUN_ONCE([BASIC_SETUP_FUNDAMENTAL_TOOLS], UTIL_REQUIRE_PROGS(TOUCH, touch) UTIL_REQUIRE_PROGS(TR, tr) UTIL_REQUIRE_PROGS(UNAME, uname) - UTIL_REQUIRE_PROGS(UNIQ, uniq) UTIL_REQUIRE_PROGS(WC, wc) UTIL_REQUIRE_PROGS(XARGS, xargs) @@ -80,22 +78,22 @@ AC_DEFUN_ONCE([BASIC_SETUP_FUNDAMENTAL_TOOLS], UTIL_REQUIRE_SPECIAL(FGREP, [AC_PROG_FGREP]) UTIL_REQUIRE_SPECIAL(SED, [AC_PROG_SED]) + # Optional tools, we can do without them + UTIL_LOOKUP_PROGS(DF, df) + UTIL_LOOKUP_PROGS(NICE, nice) + UTIL_LOOKUP_PROGS(READLINK, greadlink readlink) + + # These are only needed on some platforms + UTIL_LOOKUP_PROGS(PATHTOOL, cygpath wslpath) + UTIL_LOOKUP_PROGS(LSB_RELEASE, lsb_release) + UTIL_LOOKUP_PROGS(CMD, cmd.exe, $PATH:/cygdrive/c/windows/system32:/mnt/c/windows/system32:/c/windows/system32) + + # For compare.sh only + UTIL_LOOKUP_PROGS(CMP, cmp) + UTIL_LOOKUP_PROGS(UNIQ, uniq) + # Always force rm. RM="$RM -f" - - # pwd behaves differently on various platforms and some don't support the -L flag. - # Always use the bash builtin pwd to get uniform behavior. - THEPWDCMD=pwd - - # These are not required on all platforms - UTIL_PATH_PROGS(CYGPATH, cygpath) - UTIL_PATH_PROGS(WSLPATH, wslpath) - UTIL_PATH_PROGS(DF, df) - UTIL_PATH_PROGS(CPIO, [cpio bsdcpio]) - UTIL_PATH_PROGS(NICE, nice) - - UTIL_PATH_PROGS(LSB_RELEASE, lsb_release) - UTIL_PATH_PROGS(CMD, cmd.exe, $PATH /cygdrive/c/Windows/System32 /mnt/c/Windows/System32) ]) ############################################################################### @@ -130,10 +128,14 @@ AC_DEFUN([BASIC_CHECK_MAKE_VERSION], if test "x$OPENJDK_BUILD_OS" = "xwindows"; then if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then MAKE_EXPECTED_ENV='cygwin' - elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then + elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys2"; then MAKE_EXPECTED_ENV='msys' - elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then - MAKE_EXPECTED_ENV='x86_64-.*-linux-gnu' + elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl1" || test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl2"; then + if test "x$OPENJDK_BUILD_CPU" = "xaarch64"; then + MAKE_EXPECTED_ENV='aarch64-.*-linux-gnu' + else + MAKE_EXPECTED_ENV='x86_64-.*-linux-gnu' + fi else AC_MSG_ERROR([Unknown Windows environment]) fi @@ -185,14 +187,14 @@ AC_DEFUN([BASIC_CHECK_MAKE_OUTPUT_SYNC], # Goes looking for a usable version of GNU make. AC_DEFUN([BASIC_CHECK_GNU_MAKE], [ - UTIL_SETUP_TOOL([MAKE], + UTIL_SETUP_TOOL(MAKE, [ # Try our hardest to locate a correct version of GNU make - AC_PATH_PROGS(CHECK_GMAKE, gmake) + UTIL_LOOKUP_PROGS(CHECK_GMAKE, gmake) BASIC_CHECK_MAKE_VERSION("$CHECK_GMAKE", [gmake in PATH]) if test "x$FOUND_MAKE" = x; then - AC_PATH_PROGS(CHECK_MAKE, make) + UTIL_LOOKUP_PROGS(CHECK_MAKE, make) BASIC_CHECK_MAKE_VERSION("$CHECK_MAKE", [make in PATH]) fi @@ -201,10 +203,10 @@ AC_DEFUN([BASIC_CHECK_GNU_MAKE], # We have a toolchain path, check that as well before giving up. OLD_PATH=$PATH PATH=$TOOLCHAIN_PATH:$PATH - AC_PATH_PROGS(CHECK_TOOLSDIR_GMAKE, gmake) + UTIL_LOOKUP_PROGS(CHECK_TOOLSDIR_GMAKE, gmake) BASIC_CHECK_MAKE_VERSION("$CHECK_TOOLSDIR_GMAKE", [gmake in tools-dir]) if test "x$FOUND_MAKE" = x; then - AC_PATH_PROGS(CHECK_TOOLSDIR_MAKE, make) + UTIL_LOOKUP_PROGS(CHECK_TOOLSDIR_MAKE, make) BASIC_CHECK_MAKE_VERSION("$CHECK_TOOLSDIR_MAKE", [make in tools-dir]) fi PATH=$OLD_PATH @@ -334,24 +336,17 @@ AC_DEFUN_ONCE([BASIC_SETUP_COMPLEX_TOOLS], # Non-required basic tools - UTIL_PATH_PROGS(LDD, ldd) - if test "x$LDD" = "x"; then - # List shared lib dependencies is used for - # debug output and checking for forbidden dependencies. - # We can build without it. - LDD="true" - fi - UTIL_PATH_PROGS(READELF, [greadelf readelf]) - UTIL_PATH_PROGS(DOT, dot) - UTIL_PATH_PROGS(HG, hg) - UTIL_PATH_PROGS(GIT, git) - UTIL_PATH_PROGS(STAT, stat) - UTIL_PATH_PROGS(TIME, time) - UTIL_PATH_PROGS(FLOCK, flock) + UTIL_LOOKUP_PROGS(READELF, greadelf readelf) + UTIL_LOOKUP_PROGS(DOT, dot) + UTIL_LOOKUP_PROGS(HG, hg) + UTIL_LOOKUP_PROGS(GIT, git) + UTIL_LOOKUP_PROGS(STAT, stat) + UTIL_LOOKUP_PROGS(TIME, time) + UTIL_LOOKUP_PROGS(FLOCK, flock) # Dtrace is usually found in /usr/sbin, but that directory may not # be in the user path. - UTIL_PATH_PROGS(DTRACE, dtrace, $PATH:/usr/sbin) - UTIL_PATH_PROGS(PATCH, [gpatch patch]) + UTIL_LOOKUP_PROGS(DTRACE, dtrace, $PATH:/usr/sbin) + UTIL_LOOKUP_PROGS(PATCH, gpatch patch) # Check if it's GNU time IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'` if test "x$IS_GNU_TIME" != x; then @@ -365,7 +360,7 @@ AC_DEFUN_ONCE([BASIC_SETUP_COMPLEX_TOOLS], UTIL_REQUIRE_PROGS(DSYMUTIL, dsymutil) UTIL_REQUIRE_PROGS(MIG, mig) UTIL_REQUIRE_PROGS(XATTR, xattr) - UTIL_PATH_PROGS(CODESIGN, codesign) + UTIL_LOOKUP_PROGS(CODESIGN, codesign) if test "x$CODESIGN" != "x"; then # Check for user provided code signing identity. @@ -406,7 +401,7 @@ AC_DEFUN_ONCE([BASIC_SETUP_COMPLEX_TOOLS], UTIL_REQUIRE_PROGS(SETFILE, SetFile) fi if ! test "x$OPENJDK_TARGET_OS" = "xwindows"; then - UTIL_REQUIRE_BUILTIN_PROGS(ULIMIT, ulimit) + UTIL_REQUIRE_PROGS(ULIMIT, ulimit) fi ]) @@ -452,7 +447,7 @@ AC_DEFUN_ONCE([BASIC_CHECK_BASH_OPTIONS], # AC_DEFUN_ONCE([BASIC_SETUP_PANDOC], [ - UTIL_PATH_PROGS(PANDOC, pandoc) + UTIL_LOOKUP_PROGS(PANDOC, pandoc) PANDOC_MARKDOWN_FLAG="markdown" if test -n "$PANDOC"; then diff --git a/make/autoconf/basic_windows.m4 b/make/autoconf/basic_windows.m4 index cadc53b6754..8681442fe61 100644 --- a/make/autoconf/basic_windows.m4 +++ b/make/autoconf/basic_windows.m4 @@ -24,97 +24,160 @@ # # Setup basic configuration paths, and platform-specific stuff related to PATHs. -AC_DEFUN([BASIC_CHECK_PATHS_WINDOWS], +AC_DEFUN([BASIC_SETUP_PATHS_WINDOWS], [ - SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m` - if test $SRC_ROOT_LENGTH -gt 100; then - AC_MSG_ERROR([Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported]) + if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then + # Clarify if it is wsl1 or wsl2, and use that as OS_ENV from this point forward + $PATHTOOL -w / > /dev/null 2>&1 + if test $? -ne 0; then + # Without Windows access to our root, it's definitely WSL1 + OPENJDK_BUILD_OS_ENV=windows.wsl1 + else + # This test is not guaranteed, but there is no documented way of + # distinguishing between WSL1 and WSL2. Assume only WSL2 has WSL_INTEROP + # in /run/WSL + if test -d "/run/WSL" ; then + OPENJDK_BUILD_OS_ENV=windows.wsl2 + else + OPENJDK_BUILD_OS_ENV=windows.wsl1 + fi + fi + # This is a bit silly since we really don't have a target env as such, + # but do it to keep consistency. + OPENJDK_TARGET_OS_ENV=$OPENJDK_BUILD_OS_ENV fi + if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys2"; then + # Must be done prior to calling any commands to avoid mangling of command line + export MSYS2_ARG_CONV_EXCL="*" + fi + + AC_MSG_CHECKING([Windows environment type]) + WINENV_VENDOR=${OPENJDK_BUILD_OS_ENV#windows.} + AC_MSG_RESULT([$WINENV_VENDOR]) + + if test "x$WINENV_VENDOR" = x; then + AC_MSG_ERROR([Unknown Windows environment. Neither cygwin, msys2, wsl1 nor wsl2 was detected.]) + fi + + if test "x$PATHTOOL" = x; then + AC_MSG_ERROR([Incorrect $WINENV_VENDOR installation. Neither cygpath nor wslpath was found]) + fi + + if test "x$CMD" = x; then + AC_MSG_ERROR([Incorrect Windows/$WINENV_VENDOR setup. Could not locate cmd.exe]) + fi + + AC_MSG_CHECKING([$WINENV_VENDOR drive prefix]) + WINENV_PREFIX=`$PATHTOOL -u c:/ | $SED -e 's!/c/!!'` + AC_MSG_RESULT(['$WINENV_PREFIX']) + AC_SUBST(WINENV_PREFIX) + + AC_MSG_CHECKING([$WINENV_VENDOR root directory as Windows path]) + if test "x$OPENJDK_BUILD_OS_ENV" != "xwindows.wsl1"; then + WINENV_ROOT=`$PATHTOOL -w / 2> /dev/null` + # msys2 has a trailing backslash; strip it + WINENV_ROOT=${WINENV_ROOT%\\} + else + WINENV_ROOT='[[unavailable]]' + fi + AC_MSG_RESULT(['$WINENV_ROOT']) + AC_SUBST(WINENV_ROOT) + + AC_MSG_CHECKING([$WINENV_VENDOR temp directory]) + WINENV_TEMP_DIR=$($PATHTOOL -u $($CMD /q /c echo %TEMP% 2> /dev/null) | $TR -d '\r\n') + AC_MSG_RESULT([$WINENV_TEMP_DIR]) + + if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl2"; then + # Don't trust the current directory for WSL2, but change to an OK temp dir + cd "$WINENV_TEMP_DIR" + # Bring along confdefs.h or autoconf gets all confused + cp "$CONFIGURE_START_DIR/confdefs.h" "$WINENV_TEMP_DIR" + fi + + AC_MSG_CHECKING([$WINENV_VENDOR release]) + WINENV_UNAME_RELEASE=`$UNAME -r` + AC_MSG_RESULT([$WINENV_UNAME_RELEASE]) + + AC_MSG_CHECKING([$WINENV_VENDOR version]) + WINENV_UNAME_VERSION=`$UNAME -v` + AC_MSG_RESULT([$WINENV_UNAME_VERSION]) + + WINENV_VERSION="$WINENV_UNAME_RELEASE, $WINENV_UNAME_VERSION" + AC_MSG_CHECKING([Windows version]) + + # We must change directory to one guaranteed to work, otherwise WSL1 + # can complain (since it does not have a WINENV_ROOT so it can't access + # unix-style paths from Windows. # Additional [] needed to keep m4 from mangling shell constructs. - [ WINDOWS_VERSION=`$CMD /c ver.exe | $EGREP -o '([0-9]+\.)+[0-9]+'` ] + [ WINDOWS_VERSION=`cd $WINENV_TEMP_DIR && $CMD /c ver | $EGREP -o '([0-9]+\.)+[0-9]+'` ] AC_MSG_RESULT([$WINDOWS_VERSION]) + # Additional handling per specific env if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then - AC_MSG_CHECKING([cygwin release]) - CYGWIN_RELEASE=`$UNAME -r` - AC_MSG_RESULT([$CYGWIN_RELEASE]) - - AC_MSG_CHECKING([cygwin version]) - CYGWIN_VERSION=`$UNAME -v` - AC_MSG_RESULT([$CYGWIN_VERSION]) - # Additional [] needed to keep m4 from mangling shell constructs. - [ CYGWIN_VERSION_OLD=`$ECHO $CYGWIN_RELEASE | $GREP -e '^1\.[0-6]'` ] + [ CYGWIN_VERSION_OLD=`$ECHO $WINENV_UNAME_RELEASE | $GREP -e '^1\.[0-6]'` ] if test "x$CYGWIN_VERSION_OLD" != x; then AC_MSG_NOTICE([Your cygwin is too old. You are running $CYGWIN_RELEASE, but at least cygwin 1.7 is required. Please upgrade.]) AC_MSG_ERROR([Cannot continue]) fi - - WINDOWS_ENV_VENDOR='cygwin' - WINDOWS_ENV_VERSION="$CYGWIN_RELEASE, $CYGWIN_VERSION" - - if test "x$CYGPATH" = x; then - AC_MSG_ERROR([Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path]) + if test "x$LDD" = x; then + AC_MSG_ERROR([ldd is missing, which is needed on cygwin]) fi - AC_MSG_CHECKING([cygwin root directory as unix-style path]) - # The cmd output ends with Windows line endings (CR/LF) - cygwin_winpath_root=`cd / ; cmd /c cd | $TR -d '\r\n'` - # Force cygpath to report the proper root by including a trailing space, and then stripping it off again. - CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "` - AC_MSG_RESULT([$CYGWIN_ROOT_PATH]) - WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH" - test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/` - if test "x$test_cygdrive_prefix" = x; then - AC_MSG_ERROR([Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c.]) + WINENV_MARKER_DLL=cygwin1.dll + elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys2"; then + if test "x$LDD" = x; then + AC_MSG_ERROR([ldd is missing, which is needed on msys2]) fi - elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then - AC_MSG_CHECKING([msys release]) - MSYS_RELEASE=`$UNAME -r` - AC_MSG_RESULT([$MSYS_RELEASE]) - - AC_MSG_CHECKING([msys version]) - MSYS_VERSION=`$UNAME -v` - AC_MSG_RESULT([$MSYS_VERSION]) - - WINDOWS_ENV_VENDOR='msys' - WINDOWS_ENV_VERSION="$MSYS_RELEASE, $MSYS_VERSION" - - AC_MSG_CHECKING([msys root directory as unix-style path]) - # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away - MSYS_ROOT_PATH=`cd / ; cmd /c cd | $GREP ".*"` - UTIL_REWRITE_AS_UNIX_PATH(MSYS_ROOT_PATH) - AC_MSG_RESULT([$MSYS_ROOT_PATH]) - WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH" - elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then - - AC_MSG_CHECKING([WSL kernel version]) - WSL_KERNEL_VERSION=`$UNAME -v` - AC_MSG_RESULT([$WSL_KERNEL_VERSION]) - - AC_MSG_CHECKING([WSL kernel release]) - WSL_KERNEL_RELEASE=`$UNAME -r` - AC_MSG_RESULT([$WSL_KERNEL_RELEASE]) - - AC_MSG_CHECKING([WSL distribution]) + WINENV_MARKER_DLL=msys-2.0.dll + elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl1" || test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl2"; then + AC_MSG_CHECKING([wsl distribution]) WSL_DISTRIBUTION=`$LSB_RELEASE -d | sed 's/Description:\t//'` AC_MSG_RESULT([$WSL_DISTRIBUTION]) - WINDOWS_ENV_VENDOR='wsl' - WINDOWS_ENV_VERSION="$WSL_KERNEL_RELEASE, $WSL_KERNEL_VERSION ($WSL_DISTRIBUTION)" - else - AC_MSG_ERROR([Unknown Windows environment. Neither cygwin, msys, nor wsl was detected.]) + WINENV_VERSION="$WINENV_VERSION ($WSL_DISTRIBUTION)" + + # Tell WSL to automatically translate the PATH variable + export WSLENV=PATH/l fi - # Test if windows or unix (cygwin/msys) find is first in path. + # Chicken and egg: FIXPATH is needed for UTIL_FIXUP_PATH to work. So for the + # first run we use the auto-detect abilities of fixpath.sh. + FIXPATH_DIR="$TOPDIR/make/scripts" + FIXPATH="$BASH $FIXPATH_DIR/fixpath.sh exec" + FIXPATH_BASE="$BASH $FIXPATH_DIR/fixpath.sh" + FIXPATH_SAVED_PATH="$PATH" + UTIL_FIXUP_PATH(FIXPATH_DIR) + + # Now we can use FIXPATH_DIR to rewrite path to fixpath.sh properly. + if test "x$WINENV_PREFIX" = x; then + # On msys the prefix is empty, but we need to pass something to have the + # fixpath.sh options parser happy. + WINENV_PREFIX_ARG="NONE" + else + WINENV_PREFIX_ARG="$WINENV_PREFIX" + fi + FIXPATH_ARGS="-e $PATHTOOL -p $WINENV_PREFIX_ARG -r ${WINENV_ROOT/\\/\\\\} -t $WINENV_TEMP_DIR -c $CMD -q" + FIXPATH_BASE="$BASH $FIXPATH_DIR/fixpath.sh $FIXPATH_ARGS" + FIXPATH="$FIXPATH_BASE exec" + + AC_SUBST(FIXPATH_BASE) + AC_SUBST(FIXPATH) + + SRC_ROOT_LENGTH=`$ECHO "$TOPDIR" | $WC -m` + if test $SRC_ROOT_LENGTH -gt 100; then + AC_MSG_ERROR([Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported]) + fi + + # Test if windows or unix "find" is first in path. AC_MSG_CHECKING([what kind of 'find' is first on the PATH]) FIND_BINARY_OUTPUT=`find --version 2>&1` if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then AC_MSG_RESULT([unix style]) elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then AC_MSG_RESULT([Windows]) - AC_MSG_NOTICE([Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools.]) + AC_MSG_NOTICE([Your path contains Windows tools (C:\Windows\system32) before your unix tools.]) AC_MSG_NOTICE([This will not work. Please correct and make sure /usr/bin (or similar) is first in path.]) AC_MSG_ERROR([Cannot continue]) else @@ -123,73 +186,39 @@ AC_DEFUN([BASIC_CHECK_PATHS_WINDOWS], fi ]) -AC_DEFUN_ONCE([BASIC_COMPILE_FIXPATH], +# Verify that the directory is usable on Windows +AC_DEFUN([BASIC_WINDOWS_VERIFY_DIR], [ - # When using cygwin or msys, we need a wrapper binary that renames - # /cygdrive/c/ arguments into c:/ arguments and peeks into - # @files and rewrites these too! This wrapper binary is - # called fixpath. - FIXPATH= - if test "x$OPENJDK_BUILD_OS" = xwindows; then - AC_MSG_CHECKING([if fixpath can be created]) - FIXPATH_SRC="$TOPDIR/make/src/native/fixpath.c" - FIXPATH_BIN="$CONFIGURESUPPORT_OUTPUTDIR/bin/fixpath.exe" - FIXPATH_DIR="$CONFIGURESUPPORT_OUTPUTDIR/fixpath" - if test "x$OPENJDK_BUILD_OS_ENV" = xwindows.cygwin; then - # Important to keep the .exe suffix on Cygwin for Hotspot makefiles - FIXPATH="$FIXPATH_BIN -c" - elif test "x$OPENJDK_BUILD_OS_ENV" = xwindows.msys; then - # Take all collected prefixes and turn them into a -m/c/foo@/c/bar@... command line - # @ was chosen as separator to minimize risk of other tools messing around with it - all_unique_prefixes=`echo "${all_fixpath_prefixes@<:@@@:>@}" \ - | tr ' ' '\n' | $GREP '^/./' | $SORT | $UNIQ` - fixpath_argument_list=`echo $all_unique_prefixes | tr ' ' '@'` - FIXPATH="$FIXPATH_BIN -m$fixpath_argument_list" - elif test "x$OPENJDK_BUILD_OS_ENV" = xwindows.wsl; then - FIXPATH="$FIXPATH_BIN -w" + if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl1"; then + OUTPUTDIR_WIN=`$FIXPATH_BASE print $1` + if test "x$OUTPUTDIR_WIN" = x; then + AC_MSG_NOTICE([For wsl1, the $2 dir must be located on a Windows drive. Please see doc/building.md for details.]) + AC_MSG_ERROR([Cannot continue]) fi - FIXPATH_SRC_W="$FIXPATH_SRC" - FIXPATH_BIN_W="$FIXPATH_BIN" - $RM -rf $FIXPATH_BIN $FIXPATH_DIR - $MKDIR -p $FIXPATH_DIR $CONFIGURESUPPORT_OUTPUTDIR/bin - UTIL_REWRITE_AS_WINDOWS_MIXED_PATH([FIXPATH_SRC_W]) - UTIL_REWRITE_AS_WINDOWS_MIXED_PATH([FIXPATH_BIN_W]) - cd $FIXPATH_DIR - $CC $FIXPATH_SRC_W -Fe$FIXPATH_BIN_W > $FIXPATH_DIR/fixpath1.log 2>&1 - cd $CONFIGURE_START_DIR - - if test ! -x $FIXPATH_BIN; then - AC_MSG_RESULT([no]) - cat $FIXPATH_DIR/fixpath1.log - AC_MSG_ERROR([Could not create $FIXPATH_BIN]) - fi - AC_MSG_RESULT([yes]) - - if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then - OLD_WSLENV="$WSLENV" - WSLENV=`$ECHO $WSLENV | $SED 's/PATH\/l://'` - UTIL_APPEND_TO_PATH(WSLENV, "FIXPATH_PATH") - export WSLENV - export FIXPATH_PATH=$VS_PATH_WINDOWS - AC_MSG_NOTICE([FIXPATH_PATH is $FIXPATH_PATH]) - AC_MSG_NOTICE([Rewriting WSLENV from $OLD_WSLENV to $WSLENV]) - fi - - AC_MSG_CHECKING([if fixpath.exe works]) - cd $FIXPATH_DIR - $FIXPATH $CC $FIXPATH_SRC -Fe$FIXPATH_DIR/fixpath2.exe \ - > $FIXPATH_DIR/fixpath2.log 2>&1 - cd $CONFIGURE_START_DIR - if test ! -x $FIXPATH_DIR/fixpath2.exe; then - AC_MSG_RESULT([no]) - cat $FIXPATH_DIR/fixpath2.log - AC_MSG_ERROR([fixpath did not work!]) - fi - AC_MSG_RESULT([yes]) - - FIXPATH_DETACH_FLAG="--detach" fi - - AC_SUBST(FIXPATH) - AC_SUBST(FIXPATH_DETACH_FLAG) +]) + +# Create fixpath wrapper +AC_DEFUN([BASIC_WINDOWS_FINALIZE_FIXPATH], +[ + if test "x$OPENJDK_BUILD_OS" = xwindows; then + FIXPATH_CMDLINE=". $TOPDIR/make/scripts/fixpath.sh -e $PATHTOOL \ + -p $WINENV_PREFIX_ARG -r ${WINENV_ROOT/\\/\\\\} -t $WINENV_TEMP_DIR \ + -c $CMD -q" + $ECHO > $OUTPUTDIR/fixpath '#!/bin/bash' + $ECHO >> $OUTPUTDIR/fixpath export PATH='"[$]PATH:'$PATH'"' + $ECHO >> $OUTPUTDIR/fixpath $FIXPATH_CMDLINE '"[$]@"' + $CHMOD +x $OUTPUTDIR/fixpath + FIXPATH_BASE="$OUTPUTDIR/fixpath" + FIXPATH="$FIXPATH_BASE exec" + fi +]) + +# Platform-specific finalization +AC_DEFUN([BASIC_WINDOWS_FINALIZE], +[ + if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl2"; then + # Change back from temp dir + cd $CONFIGURE_START_DIR + fi ]) diff --git a/make/autoconf/boot-jdk.m4 b/make/autoconf/boot-jdk.m4 index c78b4432f2a..a7a9f1aba28 100644 --- a/make/autoconf/boot-jdk.m4 +++ b/make/autoconf/boot-jdk.m4 @@ -63,19 +63,23 @@ AC_DEFUN([BOOTJDK_DO_CHECK], # If previous step claimed to have found a JDK, check it to see if it seems to be valid. if test "x$BOOT_JDK_FOUND" = xmaybe; then # Do we have a bin/java? - if test ! -x "$BOOT_JDK/bin/java$EXE_SUFFIX"; then + if test ! -x "$BOOT_JDK/bin/java" && test ! -x "$BOOT_JDK/bin/java.exe"; then AC_MSG_NOTICE([Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring]) BOOT_JDK_FOUND=no else # Do we have a bin/javac? - if test ! -x "$BOOT_JDK/bin/javac$EXE_SUFFIX"; then + if test ! -x "$BOOT_JDK/bin/javac" && test ! -x "$BOOT_JDK/bin/javac.exe"; then AC_MSG_NOTICE([Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring]) AC_MSG_NOTICE([(This might be an JRE instead of an JDK)]) BOOT_JDK_FOUND=no else # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version? + java_to_test="$BOOT_JDK/bin/java" + UTIL_FIXUP_EXECUTABLE(java_to_test) + BOOT_JDK_VERSION_OUTPUT=`$java_to_test $USER_BOOT_JDK_OPTIONS -version 2>&1` # Additional [] needed to keep m4 from mangling shell constructs. - [ BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java$EXE_SUFFIX" $USER_BOOT_JDK_OPTIONS -version 2>&1 | $AWK '/version "[0-9a-zA-Z\._\-]+"/ {print $ 0; exit;}'` ] + [ BOOT_JDK_VERSION=`echo $BOOT_JDK_VERSION_OUTPUT | $AWK '/version "[0-9a-zA-Z\._\-]+"/ {print $ 0; exit;}'` ] + if [ [[ "$BOOT_JDK_VERSION" =~ "Picked up" ]] ]; then AC_MSG_NOTICE([You have _JAVA_OPTIONS or JAVA_TOOL_OPTIONS set. This can mess up the build. Please use --with-boot-jdk-jvmargs instead.]) AC_MSG_NOTICE([Java reports: "$BOOT_JDK_VERSION".]) @@ -91,7 +95,12 @@ AC_DEFUN([BOOTJDK_DO_CHECK], # Extra M4 quote needed to protect [] in grep expression. [FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION \ | $EGREP "\"(${DEFAULT_ACCEPTABLE_BOOT_VERSIONS// /|})([\.+-].*)?\""`] - if test "x$FOUND_CORRECT_VERSION" = x; then + + if test "x$BOOT_JDK_VERSION" = x; then + AC_MSG_NOTICE([Potential Boot JDK found at $BOOT_JDK is not a working JDK; ignoring]) + AC_MSG_NOTICE([Output from java -version was: $BOOT_JDK_VERSION_OUTPUT]) + BOOT_JDK_FOUND=no + elif test "x$FOUND_CORRECT_VERSION" = x; then AC_MSG_NOTICE([Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring]) AC_MSG_NOTICE([(Your Boot JDK version must be one of: $DEFAULT_ACCEPTABLE_BOOT_VERSIONS)]) BOOT_JDK_FOUND=no @@ -102,7 +111,9 @@ AC_DEFUN([BOOTJDK_DO_CHECK], AC_MSG_CHECKING([for Boot JDK]) AC_MSG_RESULT([$BOOT_JDK]) AC_MSG_CHECKING([Boot JDK version]) - BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java$EXE_SUFFIX" $USER_BOOT_JDK_OPTIONS -version 2>&1 | $TR '\n\r' ' '` + BOOT_JDK_VERSION=`$java_to_test $USER_BOOT_JDK_OPTIONS -version 2>&1 | $TR -d '\r'` + # This is not a no-op; it will portably convert newline to space + BOOT_JDK_VERSION=`$ECHO $BOOT_JDK_VERSION` AC_MSG_RESULT([$BOOT_JDK_VERSION]) fi # end check jdk version fi # end check javac @@ -151,8 +162,8 @@ AC_DEFUN([BOOTJDK_CHECK_JAVA_HOME], [ if test "x$JAVA_HOME" != x; then JAVA_HOME_PROCESSED="$JAVA_HOME" - UTIL_FIXUP_PATH(JAVA_HOME_PROCESSED) - if test ! -d "$JAVA_HOME_PROCESSED"; then + UTIL_FIXUP_PATH(JAVA_HOME_PROCESSED, NOFAIL) + if test "x$JAVA_HOME_PROCESSED" = x || test ! -d "$JAVA_HOME_PROCESSED"; then AC_MSG_NOTICE([Your JAVA_HOME points to a non-existing directory!]) else # Aha, the user has set a JAVA_HOME @@ -167,8 +178,8 @@ AC_DEFUN([BOOTJDK_CHECK_JAVA_HOME], # Test: Is there a java or javac in the PATH, which is a symlink to the JDK? AC_DEFUN([BOOTJDK_CHECK_JAVA_IN_PATH_IS_SYMLINK], [ - AC_PATH_PROG(JAVAC_CHECK, javac) - AC_PATH_PROG(JAVA_CHECK, java) + UTIL_LOOKUP_PROGS(JAVAC_CHECK, javac, , NOFIXPATH) + UTIL_LOOKUP_PROGS(JAVA_CHECK, java, , NOFIXPATH) BINARY="$JAVAC_CHECK" if test "x$JAVAC_CHECK" = x; then BINARY="$JAVA_CHECK" @@ -207,9 +218,9 @@ AC_DEFUN([BOOTJDK_CHECK_MACOSX_JAVA_LOCATOR], # First check at user selected default BOOTJDK_DO_CHECK([BOOTJDK_CHECK_LIBEXEC_JAVA_HOME()]) # If that did not work out (e.g. too old), try explicit versions instead - BOOTJDK_DO_CHECK([BOOTJDK_CHECK_LIBEXEC_JAVA_HOME([-v 1.9])]) - BOOTJDK_DO_CHECK([BOOTJDK_CHECK_LIBEXEC_JAVA_HOME([-v 1.8])]) - BOOTJDK_DO_CHECK([BOOTJDK_CHECK_LIBEXEC_JAVA_HOME([-v 1.7])]) + for ver in $DEFAULT_ACCEPTABLE_BOOT_VERSIONS ; do + BOOTJDK_DO_CHECK([BOOTJDK_CHECK_LIBEXEC_JAVA_HOME([-v $ver])]) + done fi ]) @@ -242,8 +253,10 @@ AC_DEFUN([BOOTJDK_FIND_BEST_JDK_IN_WINDOWS_VIRTUAL_DIRECTORY], [ if test "x[$]$1" != x; then VIRTUAL_DIR="[$]$1/Java" - UTIL_REWRITE_AS_UNIX_PATH(VIRTUAL_DIR) - BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY($VIRTUAL_DIR) + UTIL_FIXUP_PATH(VIRTUAL_DIR, NOFAIL) + if test "x$VIRTUAL_DIR" != x; then + BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY($VIRTUAL_DIR) + fi fi ]) @@ -270,16 +283,17 @@ AC_DEFUN([BOOTJDK_CHECK_WELL_KNOWN_LOCATIONS], AC_DEFUN([BOOTJDK_CHECK_TOOL_IN_BOOTJDK], [ # Use user overridden value if available, otherwise locate tool in the Boot JDK. - UTIL_SETUP_TOOL($1, + UTIL_REQUIRE_SPECIAL($1, [ - AC_MSG_CHECKING([for $2 in Boot JDK]) + AC_MSG_CHECKING([for $2 [[Boot JDK]]]) $1=$BOOT_JDK/bin/$2 - if test ! -x [$]$1; then + if test ! -x [$]$1 && test ! -x [$]$1.exe; then AC_MSG_RESULT(not found) AC_MSG_NOTICE([Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk]) AC_MSG_ERROR([Could not find $2 in the Boot JDK]) fi - AC_MSG_RESULT(ok) + AC_MSG_RESULT(\[$]BOOT_JDK/bin/$2) + UTIL_FIXUP_EXECUTABLE($1) AC_SUBST($1) ]) ]) @@ -313,12 +327,12 @@ AC_DEFUN_ONCE([BOOTJDK_SETUP_BOOT_JDK], AC_MSG_ERROR([The path given by --with-boot-jdk does not contain a valid Boot JDK]) fi - # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home? - BOOTJDK_DO_CHECK([BOOTJDK_CHECK_MACOSX_JAVA_LOCATOR]) - # Test: Is $JAVA_HOME set? BOOTJDK_DO_CHECK([BOOTJDK_CHECK_JAVA_HOME]) + # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home? + BOOTJDK_DO_CHECK([BOOTJDK_CHECK_MACOSX_JAVA_LOCATOR]) + # Test: Is there a java or javac in the PATH, which is a symlink to the JDK? BOOTJDK_DO_CHECK([BOOTJDK_CHECK_JAVA_IN_PATH_IS_SYMLINK]) @@ -336,11 +350,10 @@ AC_DEFUN_ONCE([BOOTJDK_SETUP_BOOT_JDK], AC_SUBST(BOOT_JDK) # Setup tools from the Boot JDK. - BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JAVA, java$EXE_SUFFIX) - BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JAVAC, javac$EXE_SUFFIX) - BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JAVADOC, javadoc$EXE_SUFFIX) - BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JAR, jar$EXE_SUFFIX) - BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JARSIGNER, jarsigner$EXE_SUFFIX) + BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JAVA, java) + BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JAVAC, javac) + BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JAVADOC, javadoc) + BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JAR, jar) # Finally, set some other options... @@ -353,7 +366,7 @@ AC_DEFUN_ONCE([BOOTJDK_SETUP_BOOT_JDK], AC_SUBST(BOOT_JDK_SOURCETARGET) # Check if the boot jdk is 32 or 64 bit - if "$JAVA" -version 2>&1 | $GREP -q "64-Bit"; then + if $JAVA -version 2>&1 | $GREP -q "64-Bit"; then BOOT_JDK_BITS="64" else BOOT_JDK_BITS="32" @@ -368,7 +381,7 @@ AC_DEFUN_ONCE([BOOTJDK_SETUP_BOOT_JDK], if test "x$boot_jdk_cds_args" != x; then # Try creating a CDS archive - "$JAVA" $boot_jdk_cds_args -Xshare:dump > /dev/null 2>&1 + $JAVA $boot_jdk_cds_args -Xshare:dump > /dev/null 2>&1 if test $? -eq 0; then BOOTJDK_USE_LOCAL_CDS=true AC_MSG_RESULT([yes, created]) @@ -574,8 +587,12 @@ AC_DEFUN([BOOTJDK_SETUP_BUILD_JDK], fi fi + # Since these tools do not yet exist, we cannot use UTIL_FIXUP_EXECUTABLE to + # detect the need of fixpath JMOD="$BUILD_JDK/bin/jmod" + UTIL_ADD_FIXPATH(JMOD) JLINK="$BUILD_JDK/bin/jlink" + UTIL_ADD_FIXPATH(JLINK) AC_SUBST(JMOD) AC_SUBST(JLINK) diff --git a/make/autoconf/bootcycle-spec.gmk.in b/make/autoconf/bootcycle-spec.gmk.in index 590a9170c6c..d46621fd891 100644 --- a/make/autoconf/bootcycle-spec.gmk.in +++ b/make/autoconf/bootcycle-spec.gmk.in @@ -28,14 +28,6 @@ # First include the real base spec.gmk file include @SPEC@ -# Check that the user did not try to specify a different java to use for compiling. -# On windows we need to account for fixpath being first word. -ifeq ($(firstword $(JAVA)),$(FIXPATH)) - JAVA_EXEC_POS=2 -else - JAVA_EXEC_POS=1 -endif - # Override specific values to do a boot cycle build # Use a different Boot JDK @@ -47,10 +39,9 @@ OUTPUTDIR:=$(OLD_OUTPUTDIR)/bootcycle-build # No spaces in patsubst to avoid leading space in variable JAVAC_SERVER_DIR:=$(patsubst $(OLD_OUTPUTDIR)%,$(OUTPUTDIR)%,$(JAVAC_SERVER_DIR)) -JAVA_CMD:=$(BOOT_JDK)/bin/java -JAVAC_CMD:=$(BOOT_JDK)/bin/javac -JAR_CMD:=$(BOOT_JDK)/bin/jar -JARSIGNER_CMD:=$(BOOT_JDK)/bin/jarsigner +JAVA_CMD := $(FIXPATH) $(BOOT_JDK)/bin/java +JAVAC_CMD := $(FIXPATH) $(BOOT_JDK)/bin/javac +JAR_CMD := $(FIXPATH) $(BOOT_JDK)/bin/jar # The bootcycle JVM arguments may differ from the original boot jdk. JAVA_FLAGS_BIG := @BOOTCYCLE_JVM_ARGS_BIG@ # Any CDS settings generated for the bootjdk are invalid in the bootcycle build. @@ -58,5 +49,3 @@ JAVA_FLAGS_BIG := @BOOTCYCLE_JVM_ARGS_BIG@ # settings for CDS. JAVA_FLAGS := $(filter-out -XX:SharedArchiveFile% -Xshare%, $(JAVA_FLAGS)) -# Pandoc cannot be used without the jjs plugin, which was removed with Nashorn. -ENABLE_PANDOC := false diff --git a/make/autoconf/build-aux/config.guess b/make/autoconf/build-aux/config.guess index 14f21a25e8f..916a464142b 100644 --- a/make/autoconf/build-aux/config.guess +++ b/make/autoconf/build-aux/config.guess @@ -56,11 +56,11 @@ if test $? = 0; then fi # Test and fix wsl -echo $OUT | grep x86_64-unknown-linux-gnu > /dev/null 2> /dev/null +echo $OUT | grep unknown-linux-gnu > /dev/null 2> /dev/null if test $? = 0; then uname -r | grep -i microsoft > /dev/null 2> /dev/null if test $? = 0; then - OUT="x86_64-pc-wsl" + OUT=`echo $OUT | sed -e 's/unknown-linux-gnu/pc-wsl/'` fi fi diff --git a/make/autoconf/build-aux/config.sub b/make/autoconf/build-aux/config.sub index d0dd001abdf..8f5a5cf5244 100644 --- a/make/autoconf/build-aux/config.sub +++ b/make/autoconf/build-aux/config.sub @@ -1,6 +1,6 @@ #!/bin/sh # -# Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2014, 2020, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # This code is free software; you can redistribute it and/or modify it @@ -35,7 +35,13 @@ if echo $* | grep linux-musl >/dev/null ; then fi # Allow wsl -if echo $* | grep x86_64-pc-wsl >/dev/null ; then +if echo $* | grep pc-wsl >/dev/null ; then + echo $* + exit +fi + +# Allow msys2 +if echo $* | grep pc-msys >/dev/null ; then echo $* exit fi @@ -49,7 +55,7 @@ if ! echo $* | grep '^aarch64-' >/dev/null ; then fi while test $# -gt 0 ; do - case $1 in + case $1 in -- ) # Stop option processing shift; break ;; aarch64-* ) diff --git a/make/autoconf/build-performance.m4 b/make/autoconf/build-performance.m4 index 065b3027d6f..52d143e5ab9 100644 --- a/make/autoconf/build-performance.m4 +++ b/make/autoconf/build-performance.m4 @@ -175,7 +175,7 @@ AC_DEFUN([BPERF_SETUP_CCACHE], if test "x$TOOLCHAIN_PATH" != x; then PATH=$TOOLCHAIN_PATH:$PATH fi - UTIL_PATH_PROGS(CCACHE, ccache) + UTIL_LOOKUP_PROGS(CCACHE, ccache) PATH="$OLD_PATH" AC_MSG_CHECKING([if ccache is available]) diff --git a/make/autoconf/compare.sh.in b/make/autoconf/compare.sh.in index e5f5ba679a1..1c48f800c8a 100644 --- a/make/autoconf/compare.sh.in +++ b/make/autoconf/compare.sh.in @@ -43,7 +43,7 @@ export CMP="@CMP@" export CP="@CP@" export CUT="@CUT@" export DIFF="@DIFF@" -export DUMPBIN="@FIXPATH@ @DUMPBIN@" +export DUMPBIN="@DUMPBIN@" export EXPR="@EXPR@" export FILE="@FILE@" export FIND="@FIND@" @@ -86,12 +86,10 @@ else fi if [ "$OPENJDK_TARGET_OS" = "windows" ]; then - if [ "$OPENJDK_BUILD_OS_ENV" = "windows.wsl" ]; then - export FIXPATH_PATH="@VS_PATH_WINDOWS@" - export WSLENV="$WSLENV:FIXPATH_PATH:DEBUG_FIXPATH" - else - export PATH="@VS_PATH@" + if [[ $OPENJDK_BUILD_OS_ENV =~ ^windows.wsl ]]; then + export WSLENV=PATH/l fi + export PATH="$PATH:@TOOLCHAIN_PATH@" fi export HOTSPOT_BUILD_TIME="@HOTSPOT_BUILD_TIME@" diff --git a/make/autoconf/configure.ac b/make/autoconf/configure.ac index 695dd57f208..a2fe84a1fb2 100644 --- a/make/autoconf/configure.ac +++ b/make/autoconf/configure.ac @@ -106,6 +106,8 @@ BASIC_SETUP_DEVKIT # To properly create a configuration name, we need to have the OpenJDK target # and options (variants and debug level) parsed. BASIC_SETUP_OUTPUT_DIR +# After we have the output dir we can finalize the fixpath wrapper +BASIC_WINDOWS_FINALIZE_FIXPATH # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY. HELP_SETUP_DEPENDENCY_HELP @@ -220,9 +222,6 @@ JDKOPT_SETUP_ADDRESS_SANITIZER # ############################################################################### -# After we have toolchain, we can compile fixpath. It's needed by the lib checks. -BASIC_COMPILE_FIXPATH - LIB_DETERMINE_DEPENDENCIES LIB_SETUP_LIBRARIES @@ -294,6 +293,7 @@ BASIC_CHECK_LEFTOVER_OVERRIDDEN CONFIG_STATUS="$CONFIGURESUPPORT_OUTPUTDIR/config.status" # Create the actual output files. Now the main work of configure is done. +BASIC_WINDOWS_FINALIZE AC_OUTPUT # After AC_OUTPUT, we need to do final work diff --git a/make/autoconf/flags-cflags.m4 b/make/autoconf/flags-cflags.m4 index 385828e3bb2..2cddaad65c6 100644 --- a/make/autoconf/flags-cflags.m4 +++ b/make/autoconf/flags-cflags.m4 @@ -130,6 +130,7 @@ AC_DEFUN([FLAGS_SETUP_WARNINGS], case "${TOOLCHAIN_TYPE}" in microsoft) DISABLE_WARNING_PREFIX="-wd" + BUILD_CC_DISABLE_WARNING_PREFIX="-wd" CFLAGS_WARNINGS_ARE_ERRORS="-WX" WARNINGS_ENABLE_ALL="-W3" @@ -142,6 +143,7 @@ AC_DEFUN([FLAGS_SETUP_WARNINGS], gcc) DISABLE_WARNING_PREFIX="-Wno-" + BUILD_CC_DISABLE_WARNING_PREFIX="-Wno-" CFLAGS_WARNINGS_ARE_ERRORS="-Werror" # Additional warnings that are not activated by -Wall and -Wextra @@ -153,7 +155,6 @@ AC_DEFUN([FLAGS_SETUP_WARNINGS], WARNINGS_ENABLE_ALL_CXXFLAGS="$WARNINGS_ENABLE_ALL_CFLAGS $WARNINGS_ENABLE_ADDITIONAL_CXX" DISABLED_WARNINGS="unused-parameter unused" - BUILD_CC_DISABLE_WARNING_PREFIX="-Wno-" ;; clang) @@ -784,8 +785,7 @@ AC_DEFUN([FLAGS_SETUP_CFLAGS_CPU_DEP], test "x$ENABLE_REPRODUCIBLE_BUILD" = xtrue; then # There is a known issue with the pathmap if the mapping is made to the # empty string. Add a minimal string "s" as prefix to work around this. - workspace_root_win="${WORKSPACE_ROOT%/}" - UTIL_REWRITE_AS_WINDOWS_MIXED_PATH([workspace_root_win]) + workspace_root_win=`$FIXPATH_BASE print "${WORKSPACE_ROOT%/}"` # PATHMAP_FLAGS is also added to LDFLAGS in flags-ldflags.m4. PATHMAP_FLAGS="-pathmap:${workspace_root_win//\//\\\\}=s \ -pathmap:${workspace_root_win}=s" diff --git a/make/autoconf/flags-ldflags.m4 b/make/autoconf/flags-ldflags.m4 index ed6726b1e2a..1f57577a2e8 100644 --- a/make/autoconf/flags-ldflags.m4 +++ b/make/autoconf/flags-ldflags.m4 @@ -195,7 +195,7 @@ AC_DEFUN([FLAGS_SETUP_LDFLAGS_CPU_DEP], # JVM_VARIANT_PATH depends on if this is build or target... if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then - $1_LDFLAGS_JDK_LIBPATH="-libpath:${OUTPUTDIR}/support/modules_libs/java.base" + $1_LDFLAGS_JDK_LIBPATH="-libpath:\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base" else $1_LDFLAGS_JDK_LIBPATH="-L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base \ -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base/${$1_JVM_VARIANT_PATH}" diff --git a/make/autoconf/flags.m4 b/make/autoconf/flags.m4 index 0301e64dc17..ddd61188306 100644 --- a/make/autoconf/flags.m4 +++ b/make/autoconf/flags.m4 @@ -226,6 +226,14 @@ AC_DEFUN([FLAGS_SETUP_SYSROOT_FLAGS], fi fi + # For the microsoft toolchain, we need to get the SYSROOT flags from the + # Visual Studio environment. Currently we cannot handle this as a separate + # build toolchain. + if test "x$1" = x && test "x$OPENJDK_BUILD_OS" = "xwindows" \ + && test "x$TOOLCHAIN_TYPE" = "xmicrosoft"; then + TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV + fi + AC_SUBST($1SYSROOT_CFLAGS) AC_SUBST($1SYSROOT_LDFLAGS) ]) @@ -234,6 +242,7 @@ AC_DEFUN_ONCE([FLAGS_PRE_TOOLCHAIN], [ # We should always include user supplied flags FLAGS_SETUP_USER_SUPPLIED_FLAGS + # The sysroot flags are needed for configure to be able to run the compilers FLAGS_SETUP_SYSROOT_FLAGS @@ -258,10 +267,6 @@ AC_DEFUN_ONCE([FLAGS_PRE_TOOLCHAIN], GLOBAL_LDFLAGS="$MACHINE_FLAG $SYSROOT_LDFLAGS $USER_LDFLAGS" # FIXME: Don't really know how to do with this, but this was the old behavior GLOBAL_CPPFLAGS="$SYSROOT_CFLAGS" - AC_SUBST(GLOBAL_CFLAGS) - AC_SUBST(GLOBAL_CXXFLAGS) - AC_SUBST(GLOBAL_LDFLAGS) - AC_SUBST(GLOBAL_CPPFLAGS) # FIXME: For compatilibity, export this as EXTRA_CFLAGS for now. EXTRA_CFLAGS="$MACHINE_FLAG $USER_CFLAGS" @@ -280,6 +285,14 @@ AC_DEFUN_ONCE([FLAGS_PRE_TOOLCHAIN], CXXFLAGS="$GLOBAL_CXXFLAGS" LDFLAGS="$GLOBAL_LDFLAGS" CPPFLAGS="$GLOBAL_CPPFLAGS" + + if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then + # When autoconf sends both compiler and linker flags to cl.exe at the same + # time, linker flags must be last at the command line. Achieve this by + # moving them to LIBS. + LIBS="$LIBS -link $LDFLAGS" + LDFLAGS="" + fi ]) AC_DEFUN([FLAGS_SETUP_TOOLCHAIN_CONTROL], @@ -370,9 +383,6 @@ AC_DEFUN_ONCE([FLAGS_POST_TOOLCHAIN], BUILD_SYSROOT_LDFLAGS="$SYSROOT_LDFLAGS" fi fi - AC_SUBST(BUILD_SYSROOT_CFLAGS) - AC_SUBST(BUILD_SYSROOT_LDFLAGS) - ]) AC_DEFUN([FLAGS_SETUP_FLAGS], diff --git a/make/autoconf/help.m4 b/make/autoconf/help.m4 index d2966579ab1..7de6398bbd6 100644 --- a/make/autoconf/help.m4 +++ b/make/autoconf/help.m4 @@ -25,7 +25,7 @@ AC_DEFUN_ONCE([HELP_SETUP_DEPENDENCY_HELP], [ - AC_CHECK_PROGS(PKGHANDLER, zypper apt-get yum brew port pkgutil pkgadd) + UTIL_LOOKUP_PROGS(PKGHANDLER, zypper apt-get yum brew port pkgutil pkgadd pacman) ]) AC_DEFUN([HELP_MSG_MISSING_DEPENDENCY], @@ -38,8 +38,6 @@ AC_DEFUN([HELP_MSG_MISSING_DEPENDENCY], HELP_MSG="OpenJDK distributions are available at http://jdk.java.net/." elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then cygwin_help $MISSING_DEPENDENCY - elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then - msys_help $MISSING_DEPENDENCY else PKGHANDLER_COMMAND= @@ -58,6 +56,8 @@ AC_DEFUN([HELP_MSG_MISSING_DEPENDENCY], pkgadd_help $MISSING_DEPENDENCY ;; zypper) zypper_help $MISSING_DEPENDENCY ;; + pacman) + pacman_help $MISSING_DEPENDENCY ;; esac if test "x$PKGHANDLER_COMMAND" != x; then @@ -83,10 +83,6 @@ cygwin_help() { esac } -msys_help() { - PKGHANDLER_COMMAND="" -} - apt_help() { case $1 in reduced) @@ -165,6 +161,17 @@ brew_help() { esac } +pacman_help() { + case $1 in + unzip) + PKGHANDLER_COMMAND="sudo pacman -S unzip" ;; + zip) + PKGHANDLER_COMMAND="sudo pacman -S zip" ;; + make) + PKGHANDLER_COMMAND="sudo pacman -S make" ;; + esac +} + port_help() { PKGHANDLER_COMMAND="" } @@ -257,16 +264,13 @@ AC_DEFUN_ONCE([HELP_PRINT_SUMMARY_AND_WARNINGS], printf "\n" printf "Tools summary:\n" if test "x$OPENJDK_BUILD_OS" = "xwindows"; then - printf "* Environment: $WINDOWS_ENV_VENDOR version $WINDOWS_ENV_VERSION. Windows version $WINDOWS_VERSION" - if test "x$WINDOWS_ENV_ROOT_PATH" != "x"; then - printf ". Root at $WINDOWS_ENV_ROOT_PATH" - fi - printf "\n" + printf "* Environment: %s version %s; windows version %s; prefix \"%s\"; root \"%s\"\n" \ + "$WINENV_VENDOR" "$WINENV_VERSION" "$WINDOWS_VERSION" "$WINENV_PREFIX" "$WINENV_ROOT" fi printf "* Boot JDK: $BOOT_JDK_VERSION (at $BOOT_JDK)\n" printf "* Toolchain: $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION)\n" - printf "* C Compiler: Version $CC_VERSION_NUMBER (at $CC)\n" - printf "* C++ Compiler: Version $CXX_VERSION_NUMBER (at $CXX)\n" + printf "* C Compiler: Version $CC_VERSION_NUMBER (at ${CC#"$FIXPATH "})\n" + printf "* C++ Compiler: Version $CXX_VERSION_NUMBER (at ${CXX#"$FIXPATH "})\n" printf "\n" printf "Build performance summary:\n" diff --git a/make/autoconf/jdk-options.m4 b/make/autoconf/jdk-options.m4 index a112a78d624..c87522ffa2e 100644 --- a/make/autoconf/jdk-options.m4 +++ b/make/autoconf/jdk-options.m4 @@ -388,9 +388,9 @@ AC_DEFUN_ONCE([JDKOPT_SETUP_CODE_COVERAGE], UTIL_FIXUP_PATH(JCOV_HOME) if test "x$with_jcov_input_jdk" != "x" ; then JCOV_INPUT_JDK="$with_jcov_input_jdk" - if test ! -f "$JCOV_INPUT_JDK/bin/java$EXE_SUFFIX"; then + if test ! -f "$JCOV_INPUT_JDK/bin/java" && test ! -f "$JCOV_INPUT_JDK/bin/java.exe"; then AC_MSG_RESULT([fail]) - AC_MSG_ERROR([Invalid JDK bundle: "$JCOV_INPUT_JDK/bin/java$EXE_SUFFIX" does not exist]) + AC_MSG_ERROR([Invalid JDK bundle: "$JCOV_INPUT_JDK/bin/java" does not exist]) fi UTIL_FIXUP_PATH(JCOV_INPUT_JDK) fi @@ -664,10 +664,27 @@ AC_DEFUN_ONCE([JDKOPT_SETUP_REPRODUCIBLE_BUILD], fi fi - UTIL_ARG_ENABLE(NAME: reproducible-build, DEFAULT: $with_source_date_present, + REPRODUCIBLE_BUILD_DEFAULT=$with_source_date_present + + if test "x$OPENJDK_BUILD_OS" = xwindows && \ + test "x$ALLOW_ABSOLUTE_PATHS_IN_OUTPUT" = xfalse; then + # To support banning absolute paths on Windows, we must use the -pathmap + # method, which requires reproducible builds. + REPRODUCIBLE_BUILD_DEFAULT=true + fi + + UTIL_ARG_ENABLE(NAME: reproducible-build, DEFAULT: $REPRODUCIBLE_BUILD_DEFAULT, RESULT: ENABLE_REPRODUCIBLE_BUILD, DESC: [enable reproducible builds (not yet fully functional)], - DEFAULT_DESC: [enabled if --with-source-date is given]) + DEFAULT_DESC: [enabled if --with-source-date is given or on Windows without absolute paths]) + + if test "x$OPENJDK_BUILD_OS" = xwindows && \ + test "x$ALLOW_ABSOLUTE_PATHS_IN_OUTPUT" = xfalse && \ + test "x$ENABLE_REPRODUCIBLE_BUILD" = xfalse; then + AC_MSG_NOTICE([On Windows it is not possible to combine --disable-reproducible-builds]) + AC_MSG_NOTICE([with --disable-absolute-paths-in-output.]) + AC_MSG_ERROR([Cannot continue]) + fi AC_SUBST(SOURCE_DATE) AC_SUBST(ENABLE_REPRODUCIBLE_BUILD) diff --git a/make/autoconf/platform.m4 b/make/autoconf/platform.m4 index 2f39d2b0ca7..1890491773b 100644 --- a/make/autoconf/platform.m4 +++ b/make/autoconf/platform.m4 @@ -206,9 +206,9 @@ AC_DEFUN([PLATFORM_EXTRACT_VARS_FROM_OS], VAR_OS=windows VAR_OS_ENV=windows.wsl ;; - *mingw*) + *msys*) VAR_OS=windows - VAR_OS_ENV=windows.msys + VAR_OS_ENV=windows.msys2 ;; *aix*) VAR_OS=aix diff --git a/make/autoconf/source-dirs.m4 b/make/autoconf/source-dirs.m4 index 8ac7c542cab..ea7d583fba2 100644 --- a/make/autoconf/source-dirs.m4 +++ b/make/autoconf/source-dirs.m4 @@ -1,5 +1,5 @@ # -# Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2011, 2020, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # This code is free software; you can redistribute it and/or modify it @@ -28,9 +28,6 @@ AC_DEFUN_ONCE([SRCDIRS_SETUP_DIRS], OUTPUTDIR="$OUTPUTDIR" AC_SUBST(OUTPUTDIR) JDK_OUTPUTDIR="$OUTPUTDIR/jdk" - - # Where are the sources. - AC_SUBST(TOPDIR) ]) ################################################################################ diff --git a/make/autoconf/spec.gmk.in b/make/autoconf/spec.gmk.in index a1a57446435..9e0d03e6f6c 100644 --- a/make/autoconf/spec.gmk.in +++ b/make/autoconf/spec.gmk.in @@ -131,20 +131,24 @@ ENABLE_REPRODUCIBLE_BUILD := @ENABLE_REPRODUCIBLE_BUILD@ LIBM:=@LIBM@ LIBDL:=@LIBDL@ -# colon or semicolon -PATH_SEP:=@PATH_SEP@ +WINENV_ROOT := @WINENV_ROOT@ +WINENV_PREFIX := @WINENV_PREFIX@ + +ifneq ($(findstring windows.wsl, @OPENJDK_BUILD_OS_ENV@), ) + # Tell WSL to convert PATH between linux and windows + export WSLENV := PATH/l +else ifeq (@OPENJDK_BUILD_OS_ENV@, windows.msys2) + # Prohibit msys2 from attemping any path wrangling + export MSYS2_ARG_CONV_EXCL := "*" +endif # Save the original path before replacing it with the Visual Studio tools -ORIGINAL_PATH:=@ORIGINAL_PATH@ -ifeq ($(OPENJDK_TARGET_OS), windows) - # On Windows, the Visual Studio toolchain needs the PATH to be adjusted - # to include Visual Studio tools (this needs to be in cygwin/msys style). - ifeq ($(OPENJDK_TARGET_OS_ENV), windows.wsl) - export FIXPATH_PATH:=@VS_PATH_WINDOWS@ - export WSLENV:=$(WSLENV):FIXPATH_PATH:DEBUG_FIXPATH - else - export PATH:=@VS_PATH@ - endif +ORIGINAL_PATH := @ORIGINAL_PATH@ + +ifeq (@TOOLCHAIN_TYPE@, microsoft) + # The Visual Studio toolchain needs the PATH to be adjusted to include + # Visual Studio tools. + export PATH := @TOOLCHAIN_PATH@:$(PATH) endif SYSROOT_CFLAGS := @SYSROOT_CFLAGS@ @@ -488,7 +492,7 @@ ADLC_LANGSTD_CXXFLAGS=@ADLC_LANGSTD_CXXFLAGS@ ADLC_LDFLAGS=@ADLC_LDFLAGS@ # Tools that potentially need to be cross compilation aware. -CC:=@FIXPATH@ @CCACHE@ @ICECC@ @CC@ +CC := @CCACHE@ @ICECC@ @CC@ # CFLAGS used to compile the jdk native libraries (C-code) CFLAGS_JDKLIB:=@CFLAGS_JDKLIB@ @@ -510,12 +514,12 @@ EXTRA_CXXFLAGS = @EXTRA_CXXFLAGS@ EXTRA_LDFLAGS = @EXTRA_LDFLAGS@ EXTRA_ASFLAGS = @EXTRA_ASFLAGS@ -CXX:=@FIXPATH@ @CCACHE@ @ICECC@ @CXX@ +CXX := @CCACHE@ @ICECC@ @CXX@ -CPP:=@FIXPATH@ @CPP@ +CPP := @CPP@ # The linker can be gcc or ld on unix systems, or link.exe on windows systems. -LD:=@FIXPATH@ @LD@ +LD := @LD@ # Linker used by the jaotc tool for AOT compilation. LD_JAOTC:=@LD_JAOTC@ @@ -535,7 +539,7 @@ JDKEXE_LIBS:=@JDKEXE_LIBS@ LDFLAGS_CXX_JDK:=@LDFLAGS_CXX_JDK@ # Sometimes a different linker is needed for c++ libs -LDCXX:=@FIXPATH@ @LDCXX@ +LDCXX := @LDCXX@ # The flags for linking libstdc++ linker. LIBCXX:=@LIBCXX@ @@ -544,22 +548,22 @@ LDFLAGS_TESTEXE:=@LDFLAGS_TESTEXE@ # BUILD_CC/BUILD_LD is a compiler/linker that generates code that is runnable on the # build platform. -BUILD_CC:=@FIXPATH@ @BUILD_ICECC@ @BUILD_CC@ -BUILD_CXX:=@FIXPATH@ @BUILD_ICECC@ @BUILD_CXX@ -BUILD_LD:=@FIXPATH@ @BUILD_LD@ -BUILD_LDCXX:=@FIXPATH@ @BUILD_LDCXX@ -BUILD_AS:=@FIXPATH@ @BUILD_AS@ -BUILD_AR:=@FIXPATH@ @BUILD_AR@ -BUILD_NM:=@FIXPATH@ @BUILD_NM@ +BUILD_CC := @BUILD_ICECC@ @BUILD_CC@ +BUILD_CXX := @BUILD_ICECC@ @BUILD_CXX@ +BUILD_LD := @BUILD_LD@ +BUILD_LDCXX := @BUILD_LDCXX@ +BUILD_AS := @BUILD_AS@ +BUILD_AR := @BUILD_AR@ +BUILD_NM := @BUILD_NM@ BUILD_OBJCOPY:=@BUILD_OBJCOPY@ BUILD_STRIP:=@BUILD_STRIP@ BUILD_SYSROOT_CFLAGS:=@BUILD_SYSROOT_CFLAGS@ BUILD_SYSROOT_LDFLAGS:=@BUILD_SYSROOT_LDFLAGS@ -AS:=@FIXPATH@ @AS@ +AS := @AS@ # AR is used to create a static library (is ar in unix, lib.exe in windows) -AR:=@FIXPATH@ @AR@ +AR := @AR@ ARFLAGS:=@ARFLAGS@ NM:=@NM@ @@ -608,7 +612,7 @@ STATIC_LIBRARY=@STATIC_LIBRARY@ LIBRARY_PREFIX:=@LIBRARY_PREFIX@ SHARED_LIBRARY_SUFFIX:=@SHARED_LIBRARY_SUFFIX@ STATIC_LIBRARY_SUFFIX:=@STATIC_LIBRARY_SUFFIX@ -EXE_SUFFIX:=@EXE_SUFFIX@ +EXECUTABLE_SUFFIX:=@EXECUTABLE_SUFFIX@ OBJ_SUFFIX:=@OBJ_SUFFIX@ STATIC_BUILD:=@STATIC_BUILD@ @@ -629,18 +633,15 @@ JAVADOC_CMD:=@JAVADOC@ JAR_CMD:=@JAR@ JLINK_CMD := @JLINK@ JMOD_CMD := @JMOD@ -JARSIGNER_CMD:=@JARSIGNER@ # These variables are meant to be used. They are defined with = instead of := to make # it possible to override only the *_CMD variables. -JAVA=@FIXPATH@ $(JAVA_CMD) $(JAVA_FLAGS_BIG) $(JAVA_FLAGS) -JAVA_SMALL=@FIXPATH@ $(JAVA_CMD) $(JAVA_FLAGS_SMALL) $(JAVA_FLAGS) -JAVA_DETACH =@FIXPATH@ @FIXPATH_DETACH_FLAG@ $(JAVA_CMD) $(JAVA_FLAGS_BIG) $(JAVA_FLAGS) -JAVAC=@FIXPATH@ $(JAVAC_CMD) -JAVADOC=@FIXPATH@ $(JAVADOC_CMD) -JAR=@FIXPATH@ $(JAR_CMD) -JLINK = @FIXPATH@ $(JLINK_CMD) -JMOD = @FIXPATH@ $(JMOD_CMD) $(JAVA_TOOL_FLAGS_SMALL) -JARSIGNER=@FIXPATH@ $(JARSIGNER_CMD) +JAVA = $(JAVA_CMD) $(JAVA_FLAGS_BIG) $(JAVA_FLAGS) +JAVA_SMALL = $(JAVA_CMD) $(JAVA_FLAGS_SMALL) $(JAVA_FLAGS) +JAVAC = $(JAVAC_CMD) +JAVADOC = $(JAVADOC_CMD) +JAR = $(JAR_CMD) +JLINK = $(JLINK_CMD) +JMOD = $(JMOD_CMD) $(JAVA_TOOL_FLAGS_SMALL) BUILD_JAVA_FLAGS := @BOOTCYCLE_JVM_ARGS_BIG@ BUILD_JAVA=@FIXPATH@ $(BUILD_JDK)/bin/java $(BUILD_JAVA_FLAGS) @@ -685,9 +686,7 @@ CCACHE:=@CCACHE@ CD:=cd CHMOD:=@CHMOD@ CODESIGN:=@CODESIGN@ -COMM:=@COMM@ CP:=@CP@ -CPIO:=@CPIO@ CUT:=@CUT@ DATE:=@DATE@ DIFF:=@DIFF@ @@ -708,7 +707,7 @@ MIG:=@MIG@ MKDIR:=@MKDIR@ MV:=@MV@ NICE:=@NICE@ -PANDOC:=@FIXPATH@ @PANDOC@ +PANDOC:=@PANDOC@ PATCH:=@PATCH@ PRINTF:=@PRINTF@ READLINK:=@READLINK@ @@ -724,15 +723,14 @@ TIME:=@TIME@ IS_GNU_TIME:=@IS_GNU_TIME@ TR:=@TR@ TOUCH:=@TOUCH@ -UNIQ:=@UNIQ@ WC:=@WC@ XARGS:=@XARGS@ ZIPEXE:=@ZIPEXE@ UNZIP:=@UNZIP@ -MT:=@FIXPATH@ @MT@ -RC:=@FIXPATH@ @RC@ -DUMPBIN:=@FIXPATH@ @DUMPBIN@ -CYGPATH:=@CYGPATH@ +MT:=@MT@ +RC:=@RC@ +DUMPBIN:=@DUMPBIN@ +PATHTOOL:=@PATHTOOL@ WSLPATH:=@WSLPATH@ LDD:=@LDD@ OTOOL:=@OTOOL@ @@ -749,7 +747,8 @@ JT_HOME:=@JT_HOME@ JIB_HOME:=@JIB_HOME@ XCODEBUILD=@XCODEBUILD@ DTRACE := @DTRACE@ -FIXPATH:=@FIXPATH@ +FIXPATH := @FIXPATH@ +FIXPATH_BASE := @FIXPATH_BASE@ ULIMIT:=@ULIMIT@ TAR_TYPE:=@TAR_TYPE@ diff --git a/make/autoconf/toolchain.m4 b/make/autoconf/toolchain.m4 index 6687cb6cd37..09a79636593 100644 --- a/make/autoconf/toolchain.m4 +++ b/make/autoconf/toolchain.m4 @@ -32,7 +32,7 @@ # compilers and related tools that are used. ######################################################################## -m4_include([toolchain_windows.m4]) +m4_include([toolchain_microsoft.m4]) # All valid toolchains, regardless of platform (used by help.m4) VALID_TOOLCHAINS_all="gcc clang xlc microsoft" @@ -179,6 +179,7 @@ AC_DEFUN([TOOLCHAIN_SETUP_FILENAME_PATTERNS], SHARED_LIBRARY='[$]1.dll' STATIC_LIBRARY='[$]1.lib' OBJ_SUFFIX='.obj' + EXECUTABLE_SUFFIX='.exe' else LIBRARY_PREFIX=lib SHARED_LIBRARY_SUFFIX='.so' @@ -186,6 +187,7 @@ AC_DEFUN([TOOLCHAIN_SETUP_FILENAME_PATTERNS], SHARED_LIBRARY='lib[$]1.so' STATIC_LIBRARY='lib[$]1.a' OBJ_SUFFIX='.o' + EXECUTABLE_SUFFIX='' if test "x$OPENJDK_TARGET_OS" = xmacosx; then # For full static builds, we're overloading the SHARED_LIBRARY # variables in order to limit the amount of changes required. @@ -209,6 +211,7 @@ AC_DEFUN([TOOLCHAIN_SETUP_FILENAME_PATTERNS], AC_SUBST(SHARED_LIBRARY) AC_SUBST(STATIC_LIBRARY) AC_SUBST(OBJ_SUFFIX) + AC_SUBST(EXECUTABLE_SUFFIX) ]) # Determine which toolchain type to use, and make sure it is valid for this @@ -292,12 +295,12 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETERMINE_TOOLCHAIN_TYPE], TOOLCHAIN_CC_BINARY_clang="clang" TOOLCHAIN_CC_BINARY_gcc="gcc" - TOOLCHAIN_CC_BINARY_microsoft="cl$EXE_SUFFIX" + TOOLCHAIN_CC_BINARY_microsoft="cl" TOOLCHAIN_CC_BINARY_xlc="xlclang" TOOLCHAIN_CXX_BINARY_clang="clang++" TOOLCHAIN_CXX_BINARY_gcc="g++" - TOOLCHAIN_CXX_BINARY_microsoft="cl$EXE_SUFFIX" + TOOLCHAIN_CXX_BINARY_microsoft="cl" TOOLCHAIN_CXX_BINARY_xlc="xlclang++" # Use indirect variable referencing @@ -325,9 +328,6 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETERMINE_TOOLCHAIN_TYPE], # special setup, e.g. additional paths etc. AC_DEFUN_ONCE([TOOLCHAIN_PRE_DETECTION], [ - # FIXME: Is this needed? - AC_LANG(C++) - # Store the CFLAGS etc passed to the configure script. ORG_CFLAGS="$CFLAGS" ORG_CXXFLAGS="$CXXFLAGS" @@ -335,52 +335,26 @@ AC_DEFUN_ONCE([TOOLCHAIN_PRE_DETECTION], # autoconf magic only relies on PATH, so update it if tools dir is specified OLD_PATH="$PATH" - # On Windows, we need to detect the visual studio installation first. - # This will change the PATH, but we need to keep that new PATH even - # after toolchain detection is done, since the compiler (on x86) uses - # it for DLL resolution in runtime. - if test "x$OPENJDK_BUILD_OS" = "xwindows" \ - && test "x$TOOLCHAIN_TYPE" = "xmicrosoft"; then - TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV - if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then - # Append VS_PATH. In WSL, VS_PATH will not contain the WSL env path needed - # for using basic Unix tools, so need to keep the original PATH. - UTIL_APPEND_TO_PATH(PATH, $VS_PATH) - UTIL_APPEND_TO_PATH(WSLENV, "PATH/l:LIB:INCLUDE") - export WSLENV - else - # Reset path to VS_PATH. It will include everything that was on PATH at the time we - # ran TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV. - PATH="$VS_PATH" - fi - # The microsoft toolchain also requires INCLUDE and LIB to be set. - export INCLUDE="$VS_INCLUDE" - export LIB="$VS_LIB" - else - if test "x$XCODE_VERSION_OUTPUT" != x; then - # For Xcode, we set the Xcode version as TOOLCHAIN_VERSION - TOOLCHAIN_VERSION=`$ECHO $XCODE_VERSION_OUTPUT | $CUT -f 2 -d ' '` - TOOLCHAIN_DESCRIPTION="$TOOLCHAIN_DESCRIPTION from Xcode $TOOLCHAIN_VERSION" - else - # Currently we do not define this for other toolchains. This might change as the need arise. - TOOLCHAIN_VERSION= - fi + if test "x$XCODE_VERSION_OUTPUT" != x; then + # For Xcode, we set the Xcode version as TOOLCHAIN_VERSION + TOOLCHAIN_VERSION=`$ECHO $XCODE_VERSION_OUTPUT | $CUT -f 2 -d ' '` + TOOLCHAIN_DESCRIPTION="$TOOLCHAIN_DESCRIPTION from Xcode $TOOLCHAIN_VERSION" fi AC_SUBST(TOOLCHAIN_VERSION) - # Finally add TOOLCHAIN_PATH at the beginning, to allow --with-tools-dir to + # Finally prepend TOOLCHAIN_PATH to the PATH, to allow --with-tools-dir to # override all other locations. if test "x$TOOLCHAIN_PATH" != x; then - PATH=$TOOLCHAIN_PATH:$PATH + export PATH=$TOOLCHAIN_PATH:$PATH fi ]) # Restore path, etc AC_DEFUN_ONCE([TOOLCHAIN_POST_DETECTION], [ - # Restore old path, except for the microsoft toolchain, which requires VS_PATH - # to remain in place. Otherwise the compiler will not work in some siutations - # in later configure checks. + # Restore old path, except for the microsoft toolchain, which requires the + # toolchain path to remain in place. Otherwise the compiler will not work in + # some siutations in later configure checks. if test "x$TOOLCHAIN_TYPE" != "xmicrosoft"; then PATH="$OLD_PATH" fi @@ -427,7 +401,7 @@ AC_DEFUN([TOOLCHAIN_EXTRACT_COMPILER_VERSION], # First line typically looks something like: # Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86 # but the compiler name may vary depending on locale. - COMPILER_VERSION_OUTPUT=`"$COMPILER" 2>&1 | $GREP -v 'ERROR.*UtilTranslatePathList' | $HEAD -n 1 | $TR -d '\r'` + COMPILER_VERSION_OUTPUT=`$COMPILER 2>&1 1>/dev/null | $HEAD -n 1 | $TR -d '\r'` # Check that this is likely to be Microsoft CL.EXE. $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft" > /dev/null if test $? -ne 0; then @@ -506,7 +480,7 @@ AC_DEFUN([TOOLCHAIN_FIND_COMPILER], if test "x`basename [$]$1`" = "x[$]$1"; then # A command without a complete path is provided, search $PATH. - AC_PATH_PROGS(POTENTIAL_$1, [$]$1) + UTIL_LOOKUP_PROGS(POTENTIAL_$1, [$]$1) if test "x$POTENTIAL_$1" != x; then $1=$POTENTIAL_$1 else @@ -528,34 +502,16 @@ AC_DEFUN([TOOLCHAIN_FIND_COMPILER], # If we are not cross compiling, then the default compiler name will be # used. - $1= - # If TOOLCHAIN_PATH is set, check for all compiler names in there first - # before checking the rest of the PATH. - # FIXME: Now that we prefix the TOOLS_DIR to the PATH in the PRE_DETECTION - # step, this should not be necessary. - if test -n "$TOOLCHAIN_PATH"; then - PATH_save="$PATH" - PATH="$TOOLCHAIN_PATH" - AC_PATH_TOOL(TOOLCHAIN_PATH_$1, $SEARCH_LIST) - $1=$TOOLCHAIN_PATH_$1 - PATH="$PATH_save" - fi - - # AC_PATH_TOOL can't be run multiple times with the same variable, - # so create a new name for this run. - if test "x[$]$1" = x; then - AC_PATH_TOOL(POTENTIAL_$1, $SEARCH_LIST) + UTIL_LOOKUP_TOOLCHAIN_PROGS(POTENTIAL_$1, $SEARCH_LIST) + if test "x$POTENTIAL_$1" != x; then $1=$POTENTIAL_$1 - fi - - if test "x[$]$1" = x; then + else HELP_MSG_MISSING_DEPENDENCY([devkit]) AC_MSG_ERROR([Could not find a $COMPILER_NAME compiler. $HELP_MSG]) fi fi # Now we have a compiler binary in $1. Make sure it's okay. - UTIL_FIXUP_EXECUTABLE($1) TEST_COMPILER="[$]$1" AC_MSG_CHECKING([resolved symbolic links for $1]) @@ -596,12 +552,7 @@ AC_DEFUN([TOOLCHAIN_EXTRACT_LD_VERSION], # There is no specific version flag, but all output starts with a version string. # First line typically looks something like: # Microsoft (R) Incremental Linker Version 12.00.31101.0 - # Reset PATH since it can contain a mix of WSL/linux paths and Windows paths from VS, - # which, in combination with WSLENV, will make the WSL layer complain - old_path="$PATH" - PATH= - LINKER_VERSION_STRING=`$LD 2>&1 | $HEAD -n 1 | $TR -d '\r'` - PATH="$old_path" + LINKER_VERSION_STRING=`$LINKER 2>&1 | $HEAD -n 1 | $TR -d '\r'` # Extract version number [ LINKER_VERSION_NUMBER=`$ECHO $LINKER_VERSION_STRING | \ $SED -e 's/.* \([0-9][0-9]*\(\.[0-9][0-9]*\)*\).*/\1/'` ] @@ -612,7 +563,7 @@ AC_DEFUN([TOOLCHAIN_EXTRACT_LD_VERSION], # This program is free software; [...] # If using gold it will look like: # GNU gold (GNU Binutils 2.30) 1.15 - LINKER_VERSION_STRING=`$LD -Wl,--version 2> /dev/null | $HEAD -n 1` + LINKER_VERSION_STRING=`$LINKER -Wl,--version 2> /dev/null | $HEAD -n 1` # Extract version number if [ [[ "$LINKER_VERSION_STRING" == *gold* ]] ]; then [ LINKER_VERSION_NUMBER=`$ECHO $LINKER_VERSION_STRING | \ @@ -629,7 +580,7 @@ AC_DEFUN([TOOLCHAIN_EXTRACT_LD_VERSION], # or # GNU ld (GNU Binutils for Ubuntu) 2.26.1 - LINKER_VERSION_STRING=`$LD -Wl,-v 2>&1 | $HEAD -n 1` + LINKER_VERSION_STRING=`$LINKER -Wl,-v 2>&1 | $HEAD -n 1` # Check if we're using the GNU ld $ECHO "$LINKER_VERSION_STRING" | $GREP "GNU" > /dev/null if test $? -eq 0; then @@ -649,6 +600,23 @@ AC_DEFUN([TOOLCHAIN_EXTRACT_LD_VERSION], AC_MSG_NOTICE([Using $TOOLCHAIN_TYPE $LINKER_NAME version $LINKER_VERSION_NUMBER @<:@$LINKER_VERSION_STRING@:>@]) ]) +# Make sure we did not pick up /usr/bin/link, which is the unix-style link +# executable. +# +# $1 = linker to test (LD or BUILD_LD) +AC_DEFUN(TOOLCHAIN_VERIFY_LINK_BINARY, +[ + LINKER=[$]$1 + + AC_MSG_CHECKING([if the found link.exe is actually the Visual Studio linker]) + $LINKER --version > /dev/null + if test $? -eq 0 ; then + AC_MSG_RESULT([no]) + AC_MSG_ERROR([$LINKER is the winenv link tool. Please check your PATH and rerun configure.]) + else + AC_MSG_RESULT([yes]) + fi +]) # Detect the core components of the toolchain, i.e. the compilers (CC and CXX), # preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the # archiver (AR). Verify that the compilers are correct according to the @@ -693,39 +661,18 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_CORE], # if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then # In the Microsoft toolchain we have a separate LD command "link". - # Make sure we reject /usr/bin/link (as determined in CYGWIN_LINK), which is - # a cygwin program for something completely different. - AC_CHECK_PROG([LD], [link$EXE_SUFFIX],[link$EXE_SUFFIX],,, [$CYGWIN_LINK]) - UTIL_FIXUP_EXECUTABLE(LD) - # Verify that we indeed succeeded with this trick. - AC_MSG_CHECKING([if the found link.exe is actually the Visual Studio linker]) - - # Reset PATH since it can contain a mix of WSL/linux paths and Windows paths from VS, - # which, in combination with WSLENV, will make the WSL layer complain - old_path="$PATH" - PATH= - - "$LD" --version > /dev/null - - if test $? -eq 0 ; then - AC_MSG_RESULT([no]) - AC_MSG_ERROR([This is the Cygwin link tool. Please check your PATH and rerun configure.]) - else - AC_MSG_RESULT([yes]) - fi - - PATH="$old_path" - + UTIL_LOOKUP_TOOLCHAIN_PROGS(LD, link) + TOOLCHAIN_VERIFY_LINK_BINARY(LD) LDCXX="$LD" - # jaotc being a windows program expects the linker to be supplied with exe suffix. - LD_JAOTC="$LD$EXE_SUFFIX" + # jaotc being a windows program expects the linker to be supplied with exe suffix.but without + # fixpath + LD_JAOTC="${LD##$FIXPATH }" else # All other toolchains use the compiler to link. LD="$CC" LDCXX="$CXX" # jaotc expects 'ld' as the linker rather than the compiler. - UTIL_CHECK_TOOLS([LD_JAOTC], ld) - UTIL_FIXUP_EXECUTABLE(LD_JAOTC) + UTIL_LOOKUP_TOOLCHAIN_PROGS(LD_JAOTC, ld) fi AC_SUBST(LD) AC_SUBST(LD_JAOTC) @@ -746,8 +693,12 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_CORE], # # Setup the assembler (AS) # - # FIXME: is this correct for microsoft? - AS="$CC -c" + if test "x$TOOLCHAIN_TYPE" != xmicrosoft; then + AS="$CC -c" + else + # On windows, the assember is "ml.exe" + UTIL_LOOKUP_TOOLCHAIN_PROGS(AS, ml) + fi AC_SUBST(AS) # @@ -755,13 +706,12 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_CORE], # if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then # The corresponding ar tool is lib.exe (used to create static libraries) - AC_CHECK_PROG([AR], [lib$EXE_SUFFIX],[lib$EXE_SUFFIX],,,) + UTIL_LOOKUP_TOOLCHAIN_PROGS(AR, lib) elif test "x$TOOLCHAIN_TYPE" = xgcc; then - UTIL_CHECK_TOOLS(AR, ar gcc-ar) + UTIL_LOOKUP_TOOLCHAIN_PROGS(AR, ar gcc-ar) else - UTIL_CHECK_TOOLS(AR, ar) + UTIL_LOOKUP_TOOLCHAIN_PROGS(AR, ar) fi - UTIL_FIXUP_EXECUTABLE(AR) ]) # Setup additional tools that is considered a part of the toolchain, but not the @@ -770,41 +720,26 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_CORE], AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_EXTRA], [ if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then - UTIL_PATH_PROGS(LIPO, lipo) - UTIL_FIXUP_EXECUTABLE(LIPO) + UTIL_LOOKUP_PROGS(LIPO, lipo) UTIL_REQUIRE_PROGS(OTOOL, otool) - UTIL_FIXUP_EXECUTABLE(OTOOL) UTIL_REQUIRE_PROGS(INSTALL_NAME_TOOL, install_name_tool) - UTIL_FIXUP_EXECUTABLE(INSTALL_NAME_TOOL) fi if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then - AC_CHECK_PROG([MT], [mt$EXE_SUFFIX], [mt$EXE_SUFFIX],,, [/usr/bin/mt]) - UTIL_FIXUP_EXECUTABLE(MT) + # Setup the manifest tool (MT) + UTIL_LOOKUP_TOOLCHAIN_PROGS(MT, mt) # Setup the resource compiler (RC) - AC_CHECK_PROG([RC], [rc$EXE_SUFFIX], [rc$EXE_SUFFIX],,, [/usr/bin/rc]) - UTIL_FIXUP_EXECUTABLE(RC) - AC_CHECK_PROG([DUMPBIN], [dumpbin$EXE_SUFFIX], [dumpbin$EXE_SUFFIX],,,) - UTIL_FIXUP_EXECUTABLE(DUMPBIN) - # We need to check for 'msbuild.exe' because at the place where we expect to - # find 'msbuild.exe' there's also a directory called 'msbuild' and configure - # won't find the 'msbuild.exe' executable in that case (and the - # 'ac_executable_extensions' is unusable due to performance reasons). - # Notice that we intentionally don't fix up the path to MSBUILD because we - # will call it in a DOS shell during freetype detection on Windows (see - # 'LIB_SETUP_FREETYPE' in "libraries.m4" - AC_CHECK_PROG([MSBUILD], [msbuild$EXE_SUFFIX], [msbuild$EXE_SUFFIX],,,) + UTIL_LOOKUP_TOOLCHAIN_PROGS(RC, rc) + UTIL_LOOKUP_TOOLCHAIN_PROGS(DUMPBIN, dumpbin) fi if test "x$OPENJDK_TARGET_OS" != xwindows; then - UTIL_CHECK_TOOLS(STRIP, strip) - UTIL_FIXUP_EXECUTABLE(STRIP) + UTIL_LOOKUP_TOOLCHAIN_PROGS(STRIP, strip) if test "x$TOOLCHAIN_TYPE" = xgcc; then - UTIL_CHECK_TOOLS(NM, nm gcc-nm) + UTIL_LOOKUP_TOOLCHAIN_PROGS(NM, nm gcc-nm) else - UTIL_CHECK_TOOLS(NM, nm) + UTIL_LOOKUP_TOOLCHAIN_PROGS(NM, nm) fi - UTIL_FIXUP_EXECUTABLE(NM) GNM="$NM" AC_SUBST(GNM) fi @@ -812,25 +747,14 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_EXTRA], # objcopy is used for moving debug symbols to separate files when # full debug symbols are enabled. if test "x$OPENJDK_TARGET_OS" = xlinux; then - UTIL_CHECK_TOOLS(OBJCOPY, [gobjcopy objcopy]) - # Only call fixup if objcopy was found. - if test -n "$OBJCOPY"; then - UTIL_FIXUP_EXECUTABLE(OBJCOPY) - fi + UTIL_LOOKUP_TOOLCHAIN_PROGS(OBJCOPY, gobjcopy objcopy) fi - UTIL_CHECK_TOOLS(OBJDUMP, [gobjdump objdump]) - if test "x$OBJDUMP" != x; then - # Only used for compare.sh; we can live without it. UTIL_FIXUP_EXECUTABLE - # bails if argument is missing. - UTIL_FIXUP_EXECUTABLE(OBJDUMP) - fi + UTIL_LOOKUP_TOOLCHAIN_PROGS(OBJDUMP, gobjdump objdump) case $TOOLCHAIN_TYPE in gcc|clang) - UTIL_CHECK_TOOLS(CXXFILT, [c++filt]) - UTIL_CHECK_NONEMPTY(CXXFILT) - UTIL_FIXUP_EXECUTABLE(CXXFILT) + UTIL_REQUIRE_TOOLCHAIN_PROGS(CXXFILT, c++filt) ;; esac ]) @@ -902,63 +826,57 @@ AC_DEFUN_ONCE([TOOLCHAIN_SETUP_BUILD_COMPILERS], BUILD_SYSROOT="$BUILD_DEVKIT_SYSROOT" if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then - BUILD_VS_INCLUDE="$BUILD_DEVKIT_VS_INCLUDE" - BUILD_VS_LIB="$BUILD_DEVKIT_VS_LIB" + # For historical reasons, paths are separated by ; in devkit.info + BUILD_VS_INCLUDE="${BUILD_DEVKIT_VS_INCLUDE//;/:}" + BUILD_VS_LIB="${BUILD_DEVKIT_VS_LIB//;/:}" - TOOLCHAIN_SETUP_VISUAL_STUDIO_SYSROOT_FLAGS([BUILD_]) + TOOLCHAIN_SETUP_VISUAL_STUDIO_SYSROOT_FLAGS(BUILD_, BUILD_) fi fi - fi - - # FIXME: we should list the discovered compilers as an exclude pattern! - # If we do that, we can do this detection before POST_DETECTION, and still - # find the build compilers in the tools dir, if needed. - if test "x$OPENJDK_BUILD_OS" = xmacosx; then - UTIL_REQUIRE_PROGS(BUILD_CC, [clang cl cc gcc]) - UTIL_REQUIRE_PROGS(BUILD_CXX, [clang++ cl CC g++]) else - UTIL_REQUIRE_PROGS(BUILD_CC, [cl cc gcc]) - UTIL_REQUIRE_PROGS(BUILD_CXX, [cl CC g++]) - fi - UTIL_FIXUP_EXECUTABLE(BUILD_CC) - UTIL_FIXUP_EXECUTABLE(BUILD_CXX) - UTIL_PATH_PROGS(BUILD_NM, nm gcc-nm) - UTIL_FIXUP_EXECUTABLE(BUILD_NM) - UTIL_PATH_PROGS(BUILD_AR, ar gcc-ar) - UTIL_FIXUP_EXECUTABLE(BUILD_AR) - UTIL_PATH_PROGS(BUILD_OBJCOPY, objcopy) - UTIL_FIXUP_EXECUTABLE(BUILD_OBJCOPY) - UTIL_PATH_PROGS(BUILD_STRIP, strip) - UTIL_FIXUP_EXECUTABLE(BUILD_STRIP) - # Assume the C compiler is the assembler - BUILD_AS="$BUILD_CC -c" - if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then - # In the Microsoft toolchain we have a separate LD command "link". - # Make sure we reject /usr/bin/link (as determined in CYGWIN_LINK), which is - # a cygwin program for something completely different. - AC_CHECK_PROG([BUILD_LD], [link$EXE_SUFFIX],[link$EXE_SUFFIX],,, [$CYGWIN_LINK]) - UTIL_FIXUP_EXECUTABLE(BUILD_LD) - # Verify that we indeed succeeded with this trick. - AC_MSG_CHECKING([if the found link.exe is actually the Visual Studio linker]) + if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then + # If we got no devkit, we need to go hunting for the proper env + TOOLCHAIN_FIND_VISUAL_STUDIO_BAT_FILE($OPENJDK_BUILD_CPU, [$TOOLCHAIN_VERSION]) + TOOLCHAIN_EXTRACT_VISUAL_STUDIO_ENV($OPENJDK_BUILD_CPU, BUILD_) - # Reset PATH since it can contain a mix of WSL/linux paths and Windows paths from VS, - # which, in combination with WSLENV, will make the WSL layer complain - old_path="$PATH" - PATH= + # We cannot currently export the VS_PATH to spec.gmk. This is probably + # strictly not correct, but seems to work anyway. - "$BUILD_LD" --version > /dev/null - - if test $? -eq 0 ; then - AC_MSG_RESULT([no]) - AC_MSG_ERROR([This is the Cygwin link tool. Please check your PATH and rerun configure.]) - else - AC_MSG_RESULT([yes]) + # Convert VS_INCLUDE and VS_LIB into sysroot flags + TOOLCHAIN_SETUP_VISUAL_STUDIO_SYSROOT_FLAGS(BUILD_) fi + fi - PATH="$old_path" + if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then + UTIL_REQUIRE_PROGS(BUILD_CC, cl, [$VS_PATH]) + UTIL_REQUIRE_PROGS(BUILD_CXX, cl, [$VS_PATH]) + # On windows, the assember is "ml.exe". We currently don't need this so + # do not require. + UTIL_LOOKUP_PROGS(BUILD_AS, ml, [$VS_PATH]) + + # On windows, the ar tool is lib.exe (used to create static libraries). + # We currently don't need this so do not require. + UTIL_LOOKUP_PROGS(BUILD_AR, lib, [$VS_PATH]) + + # In the Microsoft toolchain we have a separate LD command "link". + UTIL_REQUIRE_PROGS(BUILD_LD, link, [$VS_PATH]) + TOOLCHAIN_VERIFY_LINK_BINARY(BUILD_LD) BUILD_LDCXX="$BUILD_LD" else + if test "x$OPENJDK_BUILD_OS" = xmacosx; then + UTIL_REQUIRE_PROGS(BUILD_CC, clang cc gcc) + UTIL_REQUIRE_PROGS(BUILD_CXX, clang++ CC g++) + else + UTIL_REQUIRE_PROGS(BUILD_CC, cc gcc) + UTIL_REQUIRE_PROGS(BUILD_CXX, CC g++) + fi + UTIL_LOOKUP_PROGS(BUILD_NM, nm gcc-nm) + UTIL_LOOKUP_PROGS(BUILD_AR, ar gcc-ar lib) + UTIL_LOOKUP_PROGS(BUILD_OBJCOPY, objcopy) + UTIL_LOOKUP_PROGS(BUILD_STRIP, strip) + # Assume the C compiler is the assembler + BUILD_AS="$BUILD_CC -c" # Just like for the target compiler, use the compiler as linker BUILD_LD="$BUILD_CC" BUILD_LDCXX="$BUILD_CXX" @@ -1003,7 +921,7 @@ AC_DEFUN_ONCE([TOOLCHAIN_MISC_CHECKS], # Check for extra potential brokenness. if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then # On Windows, double-check that we got the right compiler. - CC_VERSION_OUTPUT=`$CC 2>&1 | $GREP -v 'ERROR.*UtilTranslatePathList' | $HEAD -n 1 | $TR -d '\r'` + CC_VERSION_OUTPUT=`$CC 2>&1 1>/dev/null | $HEAD -n 1 | $TR -d '\r'` COMPILER_CPU_TEST=`$ECHO $CC_VERSION_OUTPUT | $SED -n "s/^.* \(.*\)$/\1/p"` if test "x$OPENJDK_TARGET_CPU" = "xx86"; then if test "x$COMPILER_CPU_TEST" != "x80x86" -a "x$COMPILER_CPU_TEST" != "xx86"; then @@ -1099,7 +1017,7 @@ AC_DEFUN_ONCE([TOOLCHAIN_SETUP_JTREG], if test "x$JT_HOME" = x; then # JT_HOME is not set in environment, or was deemed invalid. # Try to find jtreg on path - UTIL_PATH_PROGS(JTREGEXE, jtreg) + UTIL_LOOKUP_PROGS(JTREGEXE, jtreg) if test "x$JTREGEXE" != x; then # That's good, now try to derive JT_HOME JT_HOME=`(cd $($DIRNAME $JTREGEXE)/.. && pwd)` diff --git a/make/autoconf/toolchain_windows.m4 b/make/autoconf/toolchain_microsoft.m4 similarity index 55% rename from make/autoconf/toolchain_windows.m4 rename to make/autoconf/toolchain_microsoft.m4 index 4644c0a9d7c..940f73a9d22 100644 --- a/make/autoconf/toolchain_windows.m4 +++ b/make/autoconf/toolchain_microsoft.m4 @@ -61,30 +61,32 @@ VS_TOOLSET_SUPPORTED_2019=true AC_DEFUN([TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT], [ if test "x$VS_ENV_CMD" = x; then - VS_VERSION="$1" - VS_BASE="$2" - METHOD="$3" + TARGET_CPU="$1" + VS_VERSION="$2" + VS_BASE="$3" + METHOD="$4" - UTIL_REWRITE_AS_UNIX_PATH(VS_BASE) - # In VS 2017 and VS 2019, the default installation is in a subdir named after the edition. - # Find the first one present and use that. - if test "x$VS_EDITIONS" != x; then - for edition in $VS_EDITIONS; do - if test -d "$VS_BASE/$edition"; then - VS_BASE="$VS_BASE/$edition" - break - fi - done - fi + UTIL_FIXUP_PATH(VS_BASE, NOFAIL) + + if test "x$VS_BASE" != x && test -d "$VS_BASE"; then + # In VS 2017 and VS 2019, the default installation is in a subdir named after the edition. + # Find the first one present and use that. + if test "x$VS_EDITIONS" != x; then + for edition in $VS_EDITIONS; do + if test -d "$VS_BASE/$edition"; then + VS_BASE="$VS_BASE/$edition" + break + fi + done + fi - if test -d "$VS_BASE"; then AC_MSG_NOTICE([Found Visual Studio installation at $VS_BASE using $METHOD]) - if test "x$OPENJDK_TARGET_CPU" = xx86; then + if test "x$TARGET_CPU" = xx86; then VCVARSFILES="vc/bin/vcvars32.bat vc/auxiliary/build/vcvars32.bat" - elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then + elif test "x$TARGET_CPU" = xx86_64; then VCVARSFILES="vc/bin/amd64/vcvars64.bat vc/bin/x86_amd64/vcvarsx86_amd64.bat \ - VC/Auxiliary/Build/vcvarsx86_amd64.bat VC/Auxiliary/Build/vcvars64.bat" - elif test "x$OPENJDK_TARGET_CPU" = xaarch64; then + vc/auxiliary/build/vcvarsx86_amd64.bat vc/auxiliary/build/vcvars64.bat" + elif test "x$TARGET_CPU" = xaarch64; then # for host x86-64, target aarch64 VCVARSFILES="vc/auxiliary/build/vcvarsamd64_arm64.bat \ vc/auxiliary/build/vcvarsx86_arm64.bat" @@ -114,24 +116,27 @@ AC_DEFUN([TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT], AC_DEFUN([TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT], [ if test "x$VS_ENV_CMD" = x; then - VS_VERSION="$1" - WIN_SDK_BASE="$2" - METHOD="$3" - UTIL_REWRITE_AS_UNIX_PATH(WIN_SDK_BASE) - if test -d "$WIN_SDK_BASE"; then + TARGET_CPU="$1" + VS_VERSION="$2" + WIN_SDK_BASE="$3" + METHOD="$4" + + UTIL_FIXUP_PATH(WIN_SDK_BASE, NOFAIL) + + if test "x$WIN_SDK_BASE" != x && test -d "$WIN_SDK_BASE"; then # There have been cases of partial or broken SDK installations. A missing # lib dir is not going to work. if test ! -d "$WIN_SDK_BASE/lib"; then AC_MSG_NOTICE([Found Windows SDK installation at $WIN_SDK_BASE using $METHOD]) AC_MSG_NOTICE([Warning: Installation is broken, lib dir is missing. Ignoring]) - elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then + elif test -f "$WIN_SDK_BASE/bin/setenv.cmd"; then AC_MSG_NOTICE([Found Windows SDK installation at $WIN_SDK_BASE using $METHOD]) - VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd" - if test "x$OPENJDK_TARGET_CPU" = xx86; then + VS_ENV_CMD="$WIN_SDK_BASE/bin/setenv.cmd" + if test "x$TARGET_CPU" = xx86; then VS_ENV_ARGS="/x86" - elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then + elif test "x$TARGET_CPU" = xx86_64; then VS_ENV_ARGS="/x64" - elif test "x$OPENJDK_TARGET_CPU" = xaarch64; then + elif test "x$TARGET_CPU" = xaarch64; then VS_ENV_ARGS="/arm64" fi # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see @@ -160,7 +165,8 @@ AC_DEFUN([TOOLCHAIN_FIND_VISUAL_STUDIO_BAT_FILE], [specific MSVC toolset version to use, passed as -vcvars_ver argument to pass to vcvarsall.bat (Windows only)])]) - VS_VERSION="$1" + TARGET_CPU="$1" + VS_VERSION="$2" eval VS_COMNTOOLS_VAR="\${VS_ENVVAR_${VS_VERSION}}" eval VS_COMNTOOLS="\$${VS_COMNTOOLS_VAR}" eval VS_INSTALL_DIR="\${VS_VS_INSTALLDIR_${VS_VERSION}}" @@ -174,9 +180,9 @@ AC_DEFUN([TOOLCHAIN_FIND_VISUAL_STUDIO_BAT_FILE], # When using --with-tools-dir, assume it points to the correct and default # version of Visual Studio or that --with-toolchain-version was also set. if test "x$with_tools_dir" != x; then - TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([${VS_VERSION}], + TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([$TARGET_CPU], [$VS_VERSION], [$with_tools_dir/../..], [--with-tools-dir]) - TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([${VS_VERSION}], + TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([$TARGET_CPU], [$VS_VERSION], [$with_tools_dir/../../..], [--with-tools-dir]) if test "x$VS_ENV_CMD" = x; then # Having specified an argument which is incorrect will produce an instant failure; @@ -189,45 +195,46 @@ AC_DEFUN([TOOLCHAIN_FIND_VISUAL_STUDIO_BAT_FILE], fi if test "x$VS_COMNTOOLS" != x; then - TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([${VS_VERSION}], + TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([$TARGET_CPU], [$VS_VERSION], [$VS_COMNTOOLS/../..], [$VS_COMNTOOLS_VAR variable]) fi if test "x$PROGRAMFILES" != x; then - TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([${VS_VERSION}], + TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([$TARGET_CPU], [$VS_VERSION], [$PROGRAMFILES/$VS_INSTALL_DIR], [well-known name]) fi # Work around the insanely named ProgramFiles(x86) env variable PROGRAMFILES_X86="`env | $SED -n 's/^ProgramFiles(x86)=//p'`" if test "x$PROGRAMFILES_X86" != x; then - TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([${VS_VERSION}], + TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([$TARGET_CPU], [$VS_VERSION], [$PROGRAMFILES_X86/$VS_INSTALL_DIR], [well-known name]) fi - TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([${VS_VERSION}], - [C:/Program Files/$VS_INSTALL_DIR], [well-known name]) - TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([${VS_VERSION}], - [C:/Program Files (x86)/$VS_INSTALL_DIR], [well-known name]) + TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([$TARGET_CPU], [$VS_VERSION], + [c:/program files/$VS_INSTALL_DIR], [well-known name]) + TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT([$TARGET_CPU], [$VS_VERSION], + [c:/program files (x86)/$VS_INSTALL_DIR], [well-known name]) if test "x$SDK_INSTALL_DIR" != x; then if test "x$ProgramW6432" != x; then - TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT([${VS_VERSION}], + TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT([$TARGET_CPU], [$VS_VERSION], [$ProgramW6432/$SDK_INSTALL_DIR], [well-known name]) fi if test "x$PROGRAMW6432" != x; then - TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT([${VS_VERSION}], + TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT([$TARGET_CPU], [$VS_VERSION], [$PROGRAMW6432/$SDK_INSTALL_DIR], [well-known name]) fi if test "x$PROGRAMFILES" != x; then - TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT([${VS_VERSION}], + TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT([$TARGET_CPU], [$VS_VERSION], [$PROGRAMFILES/$SDK_INSTALL_DIR], [well-known name]) fi - TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT([${VS_VERSION}], - [C:/Program Files/$SDK_INSTALL_DIR], [well-known name]) - TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT([${VS_VERSION}], - [C:/Program Files (x86)/$SDK_INSTALL_DIR], [well-known name]) + TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT([$TARGET_CPU], [$VS_VERSION], + [c:/program files/$SDK_INSTALL_DIR], [well-known name]) + TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT([$TARGET_CPU], [$VS_VERSION], + [c:/program files (x86)/$SDK_INSTALL_DIR], [well-known name]) fi + VCVARS_VER=auto if test "x$VS_TOOLSET_SUPPORTED" != x; then if test "x$with_msvc_toolset_version" != x; then - VS_ENV_ARGS="$VS_ENV_ARGS -vcvars_ver=$with_msvc_toolset_version" + VCVARS_VER="$with_msvc_toolset_version" fi fi ]) @@ -264,44 +271,9 @@ AC_DEFUN([TOOLCHAIN_FIND_VISUAL_STUDIO], eval VS_SUPPORTED="\${VS_SUPPORTED_${VS_VERSION}}" eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}" - # The TOOLCHAIN_PATH from a devkit is in Unix format. In WSL we need a - # windows version of the complete VS_PATH as VS_PATH_WINDOWS - if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then - # Convert the toolchain path - OLDIFS="$IFS" - IFS=":" - VS_PATH_WINDOWS="" - for i in $TOOLCHAIN_PATH; do - path=$i - UTIL_REWRITE_AS_WINDOWS_MIXED_PATH([path]) - VS_PATH_WINDOWS="$VS_PATH_WINDOWS;$path" - done - IFS="$OLDIFS" - # Append the current path from Windows env - WINDOWS_PATH="`$CMD /c echo %PATH%`" - VS_PATH_WINDOWS="$VS_PATH_WINDOWS;$WINDOWS_PATH" - else - VS_PATH="$TOOLCHAIN_PATH:$PATH" - fi - - # Convert DEVKIT_VS_INCLUDE into windows style VS_INCLUDE so that it - # can still be exported as INCLUDE for compiler invocations without - # SYSROOT_CFLAGS - OLDIFS="$IFS" - IFS=";" - for i in $DEVKIT_VS_INCLUDE; do - ipath=$i - UTIL_REWRITE_AS_WINDOWS_MIXED_PATH([ipath]) - VS_INCLUDE="$VS_INCLUDE;$ipath" - done - # Convert DEVKIT_VS_LIB into VS_LIB so that it can still be exported - # as LIB for compiler invocations without SYSROOT_LDFLAGS - for i in $DEVKIT_VS_LIB; do - libpath=$i - UTIL_REWRITE_AS_WINDOWS_MIXED_PATH([libpath]) - VS_LIB="$VS_LIB;$libpath" - done - IFS="$OLDIFS" + # For historical reasons, paths are separated by ; in devkit.info + VS_INCLUDE=${DEVKIT_VS_INCLUDE//;/:} + VS_LIB=${DEVKIT_VS_LIB//;/:} AC_MSG_NOTICE([Found devkit $VS_DESCRIPTION]) @@ -319,7 +291,7 @@ AC_DEFUN([TOOLCHAIN_FIND_VISUAL_STUDIO], fi for VS_VERSION in $VS_VERSIONS_PROBE_LIST; do - TOOLCHAIN_FIND_VISUAL_STUDIO_BAT_FILE([$VS_VERSION]) + TOOLCHAIN_FIND_VISUAL_STUDIO_BAT_FILE($OPENJDK_TARGET_CPU, [$VS_VERSION]) if test "x$VS_ENV_CMD" != x; then TOOLCHAIN_VERSION=$VS_VERSION eval VS_DESCRIPTION="\${VS_DESCRIPTION_${VS_VERSION}}" @@ -341,206 +313,118 @@ AC_DEFUN([TOOLCHAIN_FIND_VISUAL_STUDIO], fi ]) +AC_DEFUN([TOOLCHAIN_EXTRACT_VISUAL_STUDIO_ENV], +[ + TARGET_CPU=$1 + + AC_MSG_NOTICE([Trying to extract Visual Studio environment variables for $TARGET_CPU]) + AC_MSG_NOTICE([using $VS_ENV_CMD $VS_ENV_ARGS]) + + VS_ENV_TMP_DIR="$CONFIGURESUPPORT_OUTPUTDIR/vs-env-$TARGET_CPU" + $MKDIR -p $VS_ENV_TMP_DIR + + # Cannot use the VS10 setup script directly (since it only updates the DOS subshell environment). + # Instead create a shell script which will set the relevant variables when run. + + OLDPATH="$PATH" + # Make sure we only capture additions to PATH needed by VS. + # Clear out path, but need system dir present for vsvars cmd file to be able to run + export PATH=$WINENV_PREFIX/c/windows/system32 + # The "| cat" is to stop SetEnv.Cmd to mess with system colors on some systems + # We can't pass -vcvars_ver=$VCVARS_VER here because cmd.exe eats all '=' + # in bat file arguments. :-( + $FIXPATH $CMD /c "$TOPDIR/make/scripts/extract-vs-env.cmd" "$VS_ENV_CMD" \ + "$VS_ENV_TMP_DIR/set-vs-env.sh" $VCVARS_VER $VS_ENV_ARGS \ + > $VS_ENV_TMP_DIR/extract-vs-env.log | $CAT 2>&1 + PATH="$OLDPATH" + + if test ! -s $VS_ENV_TMP_DIR/set-vs-env.sh; then + AC_MSG_NOTICE([Could not succesfully extract the environment variables needed for the VS setup.]) + AC_MSG_NOTICE([Try setting --with-tools-dir to the VC/bin directory within the VS installation.]) + AC_MSG_NOTICE([To analyze the problem, see extract-vs-env.log and extract-vs-env.bat in]) + AC_MSG_NOTICE([$VS_ENV_TMP_DIR.]) + AC_MSG_ERROR([Cannot continue]) + fi + + # Remove windows line endings + $SED -i -e 's|\r||g' $VS_ENV_TMP_DIR/set-vs-env.sh + + # Now set all paths and other env variables by executing the generated + # shell script. This will allow the rest of the configure script to find + # and run the compiler in the proper way. + AC_MSG_NOTICE([Setting extracted environment variables for $TARGET_CPU]) + . $VS_ENV_TMP_DIR/set-vs-env.sh + + # Extract only what VS_ENV_CMD added to the PATH + VS_PATH=${PATH_AFTER/"$PATH_BEFORE"} + VS_PATH=${VS_PATH//::/:} + + # Remove any paths containing # (typically F#) as that messes up make. This + # is needed if visual studio was installed with F# support. + [ VS_PATH=`$ECHO "$VS_PATH" | $SED 's/[^:#]*#[^:]*://g'` ] + + # Sometimes case is off + if test -z "$WINDOWSSDKDIR"; then + WINDOWSSDKDIR="$WindowsSdkDir" + fi + # Now we have VS_PATH, VS_INCLUDE, VS_LIB. For further checking, we + # also define VCINSTALLDIR and WINDOWSSDKDIR. All are in + # unix style. +]) + ################################################################################ # Check if the VS env variables were setup prior to running configure. # If not, then find vcvarsall.bat and run it automatically, and integrate # the set env variables into the spec file. AC_DEFUN([TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV], [ - # Store path to cygwin link.exe to help excluding it when searching for - # VS linker. This must be done before changing the PATH when looking for VS. - AC_PATH_PROG(CYGWIN_LINK, link.exe) - if test "x$CYGWIN_LINK" != x; then - AC_MSG_CHECKING([if the first found link.exe is actually the Cygwin link tool]) - "$CYGWIN_LINK" --version > /dev/null - if test $? -eq 0 ; then - AC_MSG_RESULT([yes]) - else - AC_MSG_RESULT([no]) - # This might be the VS linker. Don't exclude it later on. - CYGWIN_LINK="" - fi - fi - - # First-hand choice is to locate and run the vsvars bat file. + # Locate the vsvars bat file and save it as VS_ENV_CMD TOOLCHAIN_FIND_VISUAL_STUDIO - # If we have a devkit, skip all of the below. + # If we have a devkit, we don't need to run VS_ENV_CMD if test "x$DEVKIT_VS_VERSION" = x; then if test "x$VS_ENV_CMD" != x; then - # We have found a Visual Studio environment on disk, let's extract variables from the vsvars bat file. - UTIL_FIXUP_EXECUTABLE(VS_ENV_CMD) + # We have found a Visual Studio environment on disk, let's extract variables + # from the vsvars bat file into shell variables in the configure script. + TOOLCHAIN_EXTRACT_VISUAL_STUDIO_ENV($OPENJDK_TARGET_CPU) - # Lets extract the variables that are set by vcvarsall.bat/vsvars32.bat/vsvars64.bat - AC_MSG_NOTICE([Trying to extract Visual Studio environment variables]) - - # We need to create a couple of temporary files. - VS_ENV_TMP_DIR="$CONFIGURESUPPORT_OUTPUTDIR/vs-env" - $MKDIR -p $VS_ENV_TMP_DIR - - # Cannot use the VS10 setup script directly (since it only updates the DOS subshell environment). - # Instead create a shell script which will set the relevant variables when run. - WINPATH_VS_ENV_CMD="$VS_ENV_CMD" - UTIL_REWRITE_AS_WINDOWS_MIXED_PATH([WINPATH_VS_ENV_CMD]) - - if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then - WINPATH_BASH="bash" - else - WINPATH_BASH="$BASH" - UTIL_REWRITE_AS_WINDOWS_MIXED_PATH([WINPATH_BASH]) - fi - - # Generate a DOS batch file which runs $VS_ENV_CMD, and then creates a shell - # script (executable by bash) that will setup the important variables. - EXTRACT_VC_ENV_BAT_FILE="$VS_ENV_TMP_DIR/extract-vs-env.bat" - $ECHO "@echo off" > $EXTRACT_VC_ENV_BAT_FILE - # This will end up something like: - # call C:/progra~2/micros~2.0/vc/bin/amd64/vcvars64.bat - $ECHO "call \"$WINPATH_VS_ENV_CMD\" $VS_ENV_ARGS" >> $EXTRACT_VC_ENV_BAT_FILE - # In some cases, the VS_ENV_CMD will change directory, change back so - # the set-vs-env.sh ends up in the right place. - $ECHO 'cd %~dp0' >> $EXTRACT_VC_ENV_BAT_FILE - if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then - # These will end up something like: - # echo VS_PATH=\"$PATH\" > set-vs-env.sh - # The trailing space for everyone except PATH is no typo, but is needed due - # to trailing \ in the Windows paths. These will be stripped later. - # Trying pure CMD extract. This results in windows paths that need to - # be converted post extraction, but a simpler script. - $ECHO 'echo VS_PATH="%PATH%" > set-vs-env.sh' \ - >> $EXTRACT_VC_ENV_BAT_FILE - $ECHO 'echo VS_INCLUDE="%INCLUDE% " >> set-vs-env.sh' \ - >> $EXTRACT_VC_ENV_BAT_FILE - $ECHO 'echo VS_LIB="%LIB% " >> set-vs-env.sh' \ - >> $EXTRACT_VC_ENV_BAT_FILE - $ECHO 'echo VCINSTALLDIR="%VCINSTALLDIR% " >> set-vs-env.sh' \ - >> $EXTRACT_VC_ENV_BAT_FILE - $ECHO 'echo VCToolsRedistDir="%VCToolsRedistDir% " >> set-vs-env.sh' \ - >> $EXTRACT_VC_ENV_BAT_FILE - $ECHO 'echo WindowsSdkDir="%WindowsSdkDir% " >> set-vs-env.sh' \ - >> $EXTRACT_VC_ENV_BAT_FILE - $ECHO 'echo WINDOWSSDKDIR="%WINDOWSSDKDIR% " >> set-vs-env.sh' \ - >> $EXTRACT_VC_ENV_BAT_FILE - else - # These will end up something like: - # C:/CygWin/bin/bash -c 'echo VS_PATH=\"$PATH\" > localdevenv.sh - # The trailing space for everyone except PATH is no typo, but is needed due - # to trailing \ in the Windows paths. These will be stripped later. - $ECHO "$WINPATH_BASH -c 'echo VS_PATH="'\"$PATH\" > set-vs-env.sh' \ - >> $EXTRACT_VC_ENV_BAT_FILE - $ECHO "$WINPATH_BASH -c 'echo VS_INCLUDE="'\"$INCLUDE\;$include \" >> set-vs-env.sh' \ - >> $EXTRACT_VC_ENV_BAT_FILE - $ECHO "$WINPATH_BASH -c 'echo VS_LIB="'\"$LIB\;$lib \" >> set-vs-env.sh' \ - >> $EXTRACT_VC_ENV_BAT_FILE - $ECHO "$WINPATH_BASH -c 'echo VCINSTALLDIR="'\"$VCINSTALLDIR \" >> set-vs-env.sh' \ - >> $EXTRACT_VC_ENV_BAT_FILE - $ECHO "$WINPATH_BASH -c 'echo VCToolsRedistDir="'\"$VCToolsRedistDir \" >> set-vs-env.sh' \ - >> $EXTRACT_VC_ENV_BAT_FILE - $ECHO "$WINPATH_BASH -c 'echo WindowsSdkDir="'\"$WindowsSdkDir \" >> set-vs-env.sh' \ - >> $EXTRACT_VC_ENV_BAT_FILE - $ECHO "$WINPATH_BASH -c 'echo WINDOWSSDKDIR="'\"$WINDOWSSDKDIR \" >> set-vs-env.sh' \ - >> $EXTRACT_VC_ENV_BAT_FILE - fi - - # Now execute the newly created bat file. - # Change directory so we don't need to mess with Windows paths in redirects. - cd $VS_ENV_TMP_DIR - $CMD /c extract-vs-env.bat > extract-vs-env.log 2>&1 - cd $CONFIGURE_START_DIR - - if test ! -s $VS_ENV_TMP_DIR/set-vs-env.sh; then - AC_MSG_NOTICE([Could not succesfully extract the environment variables needed for the VS setup.]) - AC_MSG_NOTICE([Try setting --with-tools-dir to the VC/bin directory within the VS installation]) - AC_MSG_NOTICE([or run "bash.exe -l" from a VS command prompt and then run configure from there.]) - AC_MSG_ERROR([Cannot continue]) - fi - - # Remove windows line endings - $SED -i -e 's|\r||g' $VS_ENV_TMP_DIR/set-vs-env.sh - - # Now set all paths and other env variables. This will allow the rest of - # the configure script to find and run the compiler in the proper way. - AC_MSG_NOTICE([Setting extracted environment variables]) - . $VS_ENV_TMP_DIR/set-vs-env.sh # Now we have VS_PATH, VS_INCLUDE, VS_LIB. For further checking, we - # also define VCINSTALLDIR, WindowsSdkDir and WINDOWSSDKDIR. - - # In WSL, the extracted VS_PATH is Windows style. This needs to be - # rewritten as Unix style and the Windows style version is saved - # in VS_PATH_WINDOWS. - if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then - OLDIFS="$IFS" - IFS=";" - # Convert VS_PATH to unix style - VS_PATH_WINDOWS="$VS_PATH" - VS_PATH="" - for i in $VS_PATH_WINDOWS; do - path=$i - # Only process non-empty elements - if test "x$path" != x; then - IFS="$OLDIFS" - # Check that directory exists before calling fixup_path - testpath=$path - UTIL_REWRITE_AS_UNIX_PATH([testpath]) - if test -d "$testpath"; then - UTIL_FIXUP_PATH([path]) - UTIL_APPEND_TO_PATH(VS_PATH, $path) - fi - IFS=";" - fi - done - IFS="$OLDIFS" - fi - + # also define VCINSTALLDIR and WINDOWSSDKDIR. All are in + # unix style. else - # We did not find a vsvars bat file, let's hope we are run from a VS command prompt. - AC_MSG_NOTICE([Cannot locate a valid Visual Studio installation, checking current environment]) + # We did not find a vsvars bat file. + AC_MSG_ERROR([Cannot locate a valid Visual Studio installation]) fi fi - # At this point, we should have correct variables in the environment, or we can't continue. - AC_MSG_CHECKING([for Visual Studio variables]) + # At this point, we should have correct variables in the environment + AC_MSG_CHECKING([that Visual Studio variables have been correctly extracted]) - if test "x$VCINSTALLDIR" != x || test "x$WindowsSDKDir" != x \ - || test "x$WINDOWSSDKDIR" != x || test "x$DEVKIT_NAME" != x; then + if test "x$VCINSTALLDIR" != x || test "x$WINDOWSSDKDIR" != x \ + || test "x$DEVKIT_NAME" != x; then if test "x$VS_INCLUDE" = x || test "x$VS_LIB" = x; then - AC_MSG_RESULT([present but broken]) + AC_MSG_RESULT([no; Visual Studio present but broken]) AC_MSG_ERROR([Your VC command prompt seems broken, INCLUDE and/or LIB is missing.]) else AC_MSG_RESULT([ok]) - # Remove any trailing "\" ";" and " " from the variables. - VS_INCLUDE=`$ECHO "$VS_INCLUDE" | $SED -e 's/\\\\*;* *$//'` - VS_LIB=`$ECHO "$VS_LIB" | $SED 's/\\\\*;* *$//'` - VCINSTALLDIR=`$ECHO "$VCINSTALLDIR" | $SED 's/\\\\* *$//'` - VCToolsRedistDir=`$ECHO "$VCToolsRedistDir" | $SED 's/\\\\* *$//'` - WindowsSdkDir=`$ECHO "$WindowsSdkDir" | $SED 's/\\\\* *$//'` - WINDOWSSDKDIR=`$ECHO "$WINDOWSSDKDIR" | $SED 's/\\\\* *$//'` - if test -z "$WINDOWSSDKDIR"; then - WINDOWSSDKDIR="$WindowsSdkDir" - fi - # Remove any paths containing # (typically F#) as that messes up make. This - # is needed if visual studio was installed with F# support. - VS_PATH=`$ECHO "$VS_PATH" | $SED 's/[[^:#]]*#[^:]*://g'` - AC_SUBST(VS_PATH) - AC_SUBST(VS_INCLUDE) - AC_SUBST(VS_LIB) + # Turn VS_PATH into TOOLCHAIN_PATH + TOOLCHAIN_PATH="$TOOLCHAIN_PATH:$VS_PATH" + # Convert VS_INCLUDE and VS_LIB into sysroot flags TOOLCHAIN_SETUP_VISUAL_STUDIO_SYSROOT_FLAGS - - AC_SUBST(VS_PATH_WINDOWS) fi else AC_MSG_RESULT([not found]) if test "x$VS_ENV_CMD" = x; then - AC_MSG_NOTICE([Cannot locate a valid Visual Studio or Windows SDK installation on disk,]) - AC_MSG_NOTICE([nor is this script run from a Visual Studio command prompt.]) + AC_MSG_NOTICE([Cannot locate a valid Visual Studio or Windows SDK installation on disk]) else - AC_MSG_NOTICE([Running the extraction script failed.]) + AC_MSG_NOTICE([Running the extraction script failed]) fi - AC_MSG_NOTICE([Try setting --with-tools-dir to the VC/bin directory within the VS installation]) - AC_MSG_NOTICE([or run "bash.exe -l" from a VS command prompt and then run configure from there.]) + AC_MSG_NOTICE([Try setting --with-tools-dir to the VC/bin directory within the VS installation.]) + AC_MSG_NOTICE([To analyze the problem, see extract-vs-env.log and extract-vs-env.bat in]) + AC_MSG_NOTICE([$VS_ENV_TMP_DIR.]) AC_MSG_ERROR([Cannot continue]) fi ]) @@ -556,25 +440,15 @@ AC_DEFUN([TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL], # Need to check if the found msvcr is correct architecture AC_MSG_CHECKING([found $DLL_NAME architecture]) MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"` - if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then - # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit" - # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems. - if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then - CORRECT_MSVCR_ARCH="PE32 executable" - else - CORRECT_MSVCR_ARCH="PE32+ executable" - fi - else - if test "x$OPENJDK_TARGET_CPU" = xx86; then - CORRECT_MSVCR_ARCH=386 - elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then - CORRECT_MSVCR_ARCH=x86-64 - elif test "x$OPENJDK_TARGET_CPU" = xaarch64; then - # The cygwin 'file' command only returns "PE32+ executable (DLL) (console), for MS Windows", - # without specifying which architecture it is for specifically. This has been fixed upstream. - # https://github.com/file/file/commit/b849b1af098ddd530094bf779b58431395db2e10#diff-ff2eced09e6860de75057dd731d092aeR142 - CORRECT_MSVCR_ARCH="PE32+ executable" - fi + if test "x$OPENJDK_TARGET_CPU" = xx86; then + CORRECT_MSVCR_ARCH=386 + elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then + CORRECT_MSVCR_ARCH=x86-64 + elif test "x$OPENJDK_TARGET_CPU" = xaarch64; then + # The cygwin 'file' command only returns "PE32+ executable (DLL) (console), for MS Windows", + # without specifying which architecture it is for specifically. This has been fixed upstream. + # https://github.com/file/file/commit/b849b1af098ddd530094bf779b58431395db2e10#diff-ff2eced09e6860de75057dd731d092aeR142 + CORRECT_MSVCR_ARCH="PE32+ executable" fi if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then AC_MSG_RESULT([ok]) @@ -603,20 +477,15 @@ AC_DEFUN([TOOLCHAIN_SETUP_MSVC_DLL], if test "x$MSVC_DLL" = x; then if test "x$VCINSTALLDIR" != x; then - CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR" - UTIL_FIXUP_PATH(CYGWIN_VC_INSTALL_DIR) if test "$VS_VERSION" -lt 2017; then # Probe: Using well-known location from Visual Studio 12.0 and older - POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/$vs_target_cpu/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME" + POSSIBLE_MSVC_DLL="$VCINSTALLDIR/redist/$vs_target_cpu/microsoft.vc${VS_VERSION_INTERNAL}.crt/$DLL_NAME" else - CYGWIN_VC_TOOLS_REDIST_DIR="$VCToolsRedistDir" - UTIL_FIXUP_PATH(CYGWIN_VC_TOOLS_REDIST_DIR) # Probe: Using well-known location from VS 2017 and VS 2019 - POSSIBLE_MSVC_DLL="`ls $CYGWIN_VC_TOOLS_REDIST_DIR/$vs_target_cpu/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME`" + POSSIBLE_MSVC_DLL="`ls $VCToolsRedistDir/$vs_target_cpu/microsoft.vc${VS_VERSION_INTERNAL}.crt/$DLL_NAME 2> /dev/null`" fi # In case any of the above finds more than one file, loop over them. for possible_msvc_dll in $POSSIBLE_MSVC_DLL; do - $ECHO "POSSIBLE_MSVC_DLL $possible_msvc_dll" TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL([$DLL_NAME], [$possible_msvc_dll], [well-known location in VCINSTALLDIR]) done @@ -632,40 +501,44 @@ AC_DEFUN([TOOLCHAIN_SETUP_MSVC_DLL], if test "x$MSVC_DLL" = x; then # Probe: Look in the Windows system32 directory - CYGWIN_SYSTEMROOT="$SYSTEMROOT" - UTIL_REWRITE_AS_UNIX_PATH(CYGWIN_SYSTEMROOT) - POSSIBLE_MSVC_DLL="$CYGWIN_SYSTEMROOT/system32/$DLL_NAME" - TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL([$DLL_NAME], [$POSSIBLE_MSVC_DLL], - [well-known location in SYSTEMROOT]) + WIN_SYSTEMROOT="$SYSTEMROOT" + UTIL_FIXUP_PATH(WIN_SYSTEMROOT, NOFAIL) + if test "x$WIN_SYSTEMROOT" != x; then + POSSIBLE_MSVC_DLL="$WIN_SYSTEMROOT/system32/$DLL_NAME" + TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL([$DLL_NAME], [$POSSIBLE_MSVC_DLL], + [well-known location in SYSTEMROOT]) + fi fi if test "x$MSVC_DLL" = x; then # Probe: If Visual Studio Express is installed, there is usually one with the debugger if test "x$VS100COMNTOOLS" != x; then - CYGWIN_VS_TOOLS_DIR="$VS100COMNTOOLS/.." - UTIL_REWRITE_AS_UNIX_PATH(CYGWIN_VS_TOOLS_DIR) - POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \ + WIN_VS_TOOLS_DIR="$VS100COMNTOOLS/.." + UTIL_FIXUP_PATH(WIN_VS_TOOLS_DIR, NOFAIL) + if test "x$WIN_VS_TOOLS_DIR" != x; then + POSSIBLE_MSVC_DLL=`$FIND "$WIN_VS_TOOLS_DIR" -name $DLL_NAME \ | $GREP -i /$vs_target_cpu/ | $HEAD --lines 1` - TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL([$DLL_NAME], [$POSSIBLE_MSVC_DLL], - [search of VS100COMNTOOLS]) + TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL([$DLL_NAME], [$POSSIBLE_MSVC_DLL], + [search of VS100COMNTOOLS]) + fi fi fi if test "x$MSVC_DLL" = x; then # Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now. # (This was the original behaviour; kept since it might turn something up) - if test "x$CYGWIN_VC_INSTALL_DIR" != x; then + if test "x$VCINSTALLDIR" != x; then if test "x$OPENJDK_TARGET_CPU" = xx86; then - POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \ + POSSIBLE_MSVC_DLL=`$FIND "$VCINSTALLDIR" -name $DLL_NAME \ | $GREP x86 | $GREP -v ia64 | $GREP -v x64 | $GREP -v arm64 | $HEAD --lines 1` if test "x$POSSIBLE_MSVC_DLL" = x; then # We're grasping at straws now... - POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \ + POSSIBLE_MSVC_DLL=`$FIND "$VCINSTALLDIR" -name $DLL_NAME \ | $HEAD --lines 1` fi else - POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \ - | $GREP $vs_target_cpu | $HEAD --lines 1` + POSSIBLE_MSVC_DLL=`$FIND "$VCINSTALLDIR" -name $DLL_NAME \ + | $GREP x64 | $HEAD --lines 1` fi TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL([$DLL_NAME], [$POSSIBLE_MSVC_DLL], @@ -729,9 +602,9 @@ AC_DEFUN([TOOLCHAIN_SETUP_VS_RUNTIME_DLLS], fi AC_ARG_WITH(vcruntime-1-dll, [AS_HELP_STRING([--with-vcruntime-1-dll], - [path to microsoft C++ runtime dll (vcruntime*_1.dll) (Windows 64-bits only) @<:@probed@:>@])]) + [path to microsoft C++ runtime dll (vcruntime*_1.dll) (Windows x64 only) @<:@probed@:>@])]) - if test "x$VCRUNTIME_1_NAME" != "x" -a "x$OPENJDK_TARGET_CPU_BITS" = x64; then + if test "x$VCRUNTIME_1_NAME" != "x" && test "x$OPENJDK_TARGET_CPU" = xx86_64; then if test "x$with_vcruntime_1_dll" != x; then # If given explicitly by user, do not probe. If not present, fail directly. TOOLCHAIN_CHECK_POSSIBLE_MSVC_DLL($VCRUNTIME_1_NAME, [$with_vcruntime_1_dll], @@ -750,13 +623,13 @@ AC_DEFUN([TOOLCHAIN_SETUP_VS_RUNTIME_DLLS], TOOLCHAIN_SETUP_MSVC_DLL([${VCRUNTIME_1_NAME}]) VCRUNTIME_1_DLL="$MSVC_DLL" fi - AC_SUBST(VCRUNTIME_1_DLL) fi + AC_SUBST(VCRUNTIME_1_DLL) AC_ARG_WITH(ucrt-dll-dir, [AS_HELP_STRING([--with-ucrt-dll-dir], [path to Microsoft Windows Kit UCRT DLL dir (Windows only) @<:@probed@:>@])]) - if test "x$USE_UCRT" = "xtrue"; then + if test "x$USE_UCRT" = "xtrue" && test "x$OPENJDK_TARGET_CPU" != xaarch64; then AC_MSG_CHECKING([for UCRT DLL dir]) if test "x$with_ucrt_dll_dir" != x; then if test -z "$(ls -d "$with_ucrt_dll_dir/"*.dll 2> /dev/null)"; then @@ -771,19 +644,16 @@ AC_DEFUN([TOOLCHAIN_SETUP_VS_RUNTIME_DLLS], UCRT_DLL_DIR="$DEVKIT_UCRT_DLL_DIR" AC_MSG_RESULT($UCRT_DLL_DIR) else - CYGWIN_WINDOWSSDKDIR="${WINDOWSSDKDIR}" - UTIL_FIXUP_PATH([CYGWIN_WINDOWSSDKDIR]) - if test "x$OPENJDK_TARGET_CPU" = "xaarch64"; then + dll_subdir=$OPENJDK_TARGET_CPU + if test "x$dll_subdir" = "xaarch64"; then dll_subdir="arm64" - elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then + elif test "x$dll_subdir" = "xx86_64"; then dll_subdir="x64" - elif test "x$OPENJDK_TARGET_CPU" = "xx86"; then - dll_subdir="x86" fi - UCRT_DLL_DIR="$CYGWIN_WINDOWSSDKDIR/Redist/ucrt/DLLs/$dll_subdir" + UCRT_DLL_DIR="$WINDOWSSDKDIR/redist/ucrt/dlls/$dll_subdir" if test -z "$(ls -d "$UCRT_DLL_DIR/"*.dll 2> /dev/null)"; then # Try with version subdir - UCRT_DLL_DIR="`ls -d $CYGWIN_WINDOWSSDKDIR/Redist/*/ucrt/DLLs/$dll_subdir \ + UCRT_DLL_DIR="`ls -d $WINDOWSSDKDIR/redist/*/ucrt/dlls/$dll_subdir \ 2> /dev/null | $SORT -d | $HEAD -n1`" if test -z "$UCRT_DLL_DIR" \ || test -z "$(ls -d "$UCRT_DLL_DIR/"*.dll 2> /dev/null)"; then @@ -805,43 +675,23 @@ AC_DEFUN([TOOLCHAIN_SETUP_VS_RUNTIME_DLLS], # Setup the sysroot flags and add them to global CFLAGS and LDFLAGS so # that configure can use them while detecting compilers. # TOOLCHAIN_TYPE is available here. -# Param 1 - Optional prefix to all variables. (e.g BUILD_) +# Param 1 - Optional prefix to SYSROOT variables. (e.g BUILD_) +# Param 2 - Optional prefix to VS variables. (e.g BUILD_) AC_DEFUN([TOOLCHAIN_SETUP_VISUAL_STUDIO_SYSROOT_FLAGS], [ OLDIFS="$IFS" - IFS=";" - # Convert $1VS_INCLUDE into $1SYSROOT_CFLAGS - for i in [$]$1VS_INCLUDE; do - ipath=$i - # Only process non-empty elements - if test "x$ipath" != x; then - IFS="$OLDIFS" - # Check that directory exists before calling fixup_path - testpath=$ipath - UTIL_REWRITE_AS_UNIX_PATH([testpath]) - if test -d "$testpath"; then - UTIL_FIXUP_PATH([ipath]) - $1SYSROOT_CFLAGS="[$]$1SYSROOT_CFLAGS -I$ipath" - fi - IFS=";" - fi + IFS=":" + + # Convert VS_INCLUDE into SYSROOT_CFLAGS + for ipath in [$]$2VS_INCLUDE; do + $1SYSROOT_CFLAGS="[$]$1SYSROOT_CFLAGS -I$ipath" done - # Convert $1VS_LIB into $1SYSROOT_LDFLAGS - for i in [$]$1VS_LIB; do - libpath=$i - # Only process non-empty elements - if test "x$libpath" != x; then - IFS="$OLDIFS" - # Check that directory exists before calling fixup_path - testpath=$libpath - UTIL_REWRITE_AS_UNIX_PATH([testpath]) - if test -d "$testpath"; then - UTIL_FIXUP_PATH([libpath]) - $1SYSROOT_LDFLAGS="[$]$1SYSROOT_LDFLAGS -libpath:$libpath" - fi - IFS=";" - fi + + # Convert VS_LIB into SYSROOT_LDFLAGS + for libpath in [$]$2VS_LIB; do + $1SYSROOT_LDFLAGS="[$]$1SYSROOT_LDFLAGS -libpath:$libpath" done + IFS="$OLDIFS" AC_SUBST($1SYSROOT_CFLAGS) diff --git a/make/autoconf/util.m4 b/make/autoconf/util.m4 index 0addb9c3a16..9ececc55e5e 100644 --- a/make/autoconf/util.m4 +++ b/make/autoconf/util.m4 @@ -24,7 +24,6 @@ # m4_include([util_paths.m4]) -m4_include([util_windows.m4]) ############################################################################### # Create a function/macro that takes a series of named arguments. The call is @@ -462,151 +461,3 @@ UTIL_DEFUN_NAMED([UTIL_ARG_ENABLE], fi ]) -############################################################################### -# Test that variable $1 denoting a program is not empty. If empty, exit with an error. -# $1: variable to check -AC_DEFUN([UTIL_CHECK_NONEMPTY], -[ - if test "x[$]$1" = x; then - AC_MSG_ERROR([Could not find required tool for $1]) - fi -]) - -############################################################################### -# Setup a tool for the given variable. If correctly specified by the user, -# use that value, otherwise search for the tool using the supplied code snippet. -# $1: variable to set -# $2: code snippet to call to look for the tool -# $3: code snippet to call if variable was used to find tool -AC_DEFUN([UTIL_SETUP_TOOL], -[ - # Publish this variable in the help. - AC_ARG_VAR($1, [Override default value for $1]) - - if [[ -z "${$1+x}" ]]; then - # The variable is not set by user, try to locate tool using the code snippet - $2 - else - # The variable is set, but is it from the command line or the environment? - - # Try to remove the string !$1! from our list. - try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!$1!/} - if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then - # If it failed, the variable was not from the command line. Ignore it, - # but warn the user (except for BASH, which is always set by the calling BASH). - if test "x$1" != xBASH; then - AC_MSG_WARN([Ignoring value of $1 from the environment. Use command line variables instead.]) - fi - # Try to locate tool using the code snippet - $2 - else - # If it succeeded, then it was overridden by the user. We will use it - # for the tool. - - # First remove it from the list of overridden variables, so we can test - # for unknown variables in the end. - CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var" - - tool_override=[$]$1 - AC_MSG_NOTICE([User supplied override $1="$tool_override"]) - - # Check if we try to supply an empty value - if test "x$tool_override" = x; then - AC_MSG_CHECKING([for $1]) - AC_MSG_RESULT([disabled]) - else - # Split up override in command part and argument part - tool_and_args=($tool_override) - [ tool_command=${tool_and_args[0]} ] - [ unset 'tool_and_args[0]' ] - [ tool_args=${tool_and_args[@]} ] - - # Check if the provided tool contains a complete path. - tool_basename="${tool_command##*/}" - if test "x$tool_basename" = "x$tool_command"; then - # A command without a complete path is provided, search $PATH. - AC_MSG_NOTICE([Will search for user supplied tool "$tool_basename"]) - AC_PATH_PROG($1, $tool_basename) - if test "x[$]$1" = x; then - AC_MSG_ERROR([User supplied tool $1="$tool_basename" could not be found]) - fi - else - # Otherwise we believe it is a complete path. Use it as it is. - AC_MSG_NOTICE([Will use user supplied tool "$tool_command"]) - AC_MSG_CHECKING([for $tool_command]) - if test ! -x "$tool_command" && test ! -x "$tool_command.exe"; then - AC_MSG_RESULT([not found]) - AC_MSG_ERROR([User supplied tool $1="$tool_command" does not exist or is not executable]) - fi - $1="$tool_command" - AC_MSG_RESULT([found]) - fi - if test "x$tool_args" != x; then - # If we got arguments, re-append them to the command after the fixup. - $1="[$]$1 $tool_args" - fi - fi - fi - $3 - fi -]) - -############################################################################### -# Call UTIL_SETUP_TOOL with AC_PATH_PROGS to locate the tool -# $1: variable to set -# $2: executable name (or list of names) to look for -# $3: [path] -AC_DEFUN([UTIL_PATH_PROGS], -[ - UTIL_SETUP_TOOL($1, [AC_PATH_PROGS($1, $2, , $3)]) -]) - -############################################################################### -# Call UTIL_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool -# $1: variable to set -# $2: executable name (or list of names) to look for -AC_DEFUN([UTIL_CHECK_TOOLS], -[ - UTIL_SETUP_TOOL($1, [AC_CHECK_TOOLS($1, $2)]) -]) - -############################################################################### -# Like UTIL_PATH_PROGS but fails if no tool was found. -# $1: variable to set -# $2: executable name (or list of names) to look for -# $3: [path] -AC_DEFUN([UTIL_REQUIRE_PROGS], -[ - UTIL_PATH_PROGS($1, $2, , $3) - UTIL_CHECK_NONEMPTY($1) -]) - -############################################################################### -# Like UTIL_SETUP_TOOL but fails if no tool was found. -# $1: variable to set -# $2: autoconf macro to call to look for the special tool -AC_DEFUN([UTIL_REQUIRE_SPECIAL], -[ - UTIL_SETUP_TOOL($1, [$2]) - UTIL_CHECK_NONEMPTY($1) -]) - -############################################################################### -# Like UTIL_REQUIRE_PROGS but also allows for bash built-ins -# $1: variable to set -# $2: executable name (or list of names) to look for -# $3: [path] -AC_DEFUN([UTIL_REQUIRE_BUILTIN_PROGS], -[ - UTIL_SETUP_TOOL($1, [AC_PATH_PROGS($1, $2, , $3)]) - if test "x[$]$1" = x; then - AC_MSG_NOTICE([Required tool $2 not found in PATH, checking built-in]) - if type -p $2 > /dev/null 2>&1; then - AC_MSG_NOTICE([Found $2 as shell built-in. Using it]) - $1="$2" - else - AC_MSG_ERROR([Required tool $2 also not found as built-in.]) - fi - fi - UTIL_CHECK_NONEMPTY($1) -]) diff --git a/make/autoconf/util_paths.m4 b/make/autoconf/util_paths.m4 index 9a3d3e2bb04..497332f4509 100644 --- a/make/autoconf/util_paths.m4 +++ b/make/autoconf/util_paths.m4 @@ -23,6 +23,7 @@ # questions. # +############################################################################### # Appends a string to a path variable, only adding the : when needed. AC_DEFUN([UTIL_APPEND_TO_PATH], [ @@ -35,6 +36,7 @@ AC_DEFUN([UTIL_APPEND_TO_PATH], fi ]) +############################################################################### # Prepends a string to a path variable, only adding the : when needed. AC_DEFUN([UTIL_PREPEND_TO_PATH], [ @@ -47,34 +49,6 @@ AC_DEFUN([UTIL_PREPEND_TO_PATH], fi ]) -################################################################################ -# This will make a path absolute. Assumes it's already a unix path. Also -# resolves ~ to homedir. -AC_DEFUN([UTIL_ABSOLUTE_PATH], -[ - if test "x[$]$1" != x; then - new_path="[$]$1" - - # Use eval to expand a potential ~. This technique does not work if there - # are spaces in the path (which is valid at this point on Windows), so only - # try to apply it if there is an actual ~ first in the path. - if [ [[ "$new_path" = "~"* ]] ]; then - eval new_path="$new_path" - if test ! -f "$new_path" && test ! -d "$new_path"; then - AC_MSG_ERROR([The new_path of $1, which resolves as "$new_path", is not found.]) - fi - fi - - if test -d "$new_path"; then - $1="`cd "$new_path"; $THEPWDCMD -L`" - else - dir="`$DIRNAME "$new_path"`" - base="`$BASENAME "$new_path"`" - $1="`cd "$dir"; $THEPWDCMD -L`/$base" - fi - fi -]) - ############################################################################### # This will make sure the given variable points to a full and proper # path. This means: @@ -84,31 +58,100 @@ AC_DEFUN([UTIL_ABSOLUTE_PATH], # 2) The path will be absolute, and it will be in unix-style (on # cygwin). # $1: The name of the variable to fix +# $2: if NOFAIL, errors will be silently ignored AC_DEFUN([UTIL_FIXUP_PATH], [ # Only process if variable expands to non-empty - if test "x[$]$1" != x; then - if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then - UTIL_FIXUP_PATH_CYGWIN($1) - elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then - UTIL_FIXUP_PATH_MSYS($1) - elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then - UTIL_FIXUP_PATH_WSL($1) + path="[$]$1" + if test "x$path" != x; then + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + if test "x$2" = "xNOFAIL"; then + quiet_option="-q" + fi + imported_path=`$FIXPATH_BASE $quiet_option import "$path"` + $FIXPATH_BASE verify "$imported_path" + if test $? -ne 0; then + if test "x$2" != "xNOFAIL"; then + AC_MSG_ERROR([The path of $1, which resolves as "$path", could not be imported.]) + else + imported_path="" + fi + fi + if test "x$imported_path" != "x$path"; then + $1="$imported_path" + fi else - # We're on a unix platform. Hooray! :) - path="[$]$1" - has_space=`$ECHO "$path" | $GREP " "` - if test "x$has_space" != x; then - AC_MSG_NOTICE([The path of $1, which resolves as "$path", is invalid.]) - AC_MSG_ERROR([Spaces are not allowed in this path.]) + [ if [[ "$path" =~ " " ]]; then ] + if test "x$2" != "xNOFAIL"; then + AC_MSG_NOTICE([The path of $1, which resolves as "$path", is invalid.]) + AC_MSG_ERROR([Spaces are not allowed in this path.]) + else + path="" + fi + fi + + # Use eval to expand a potential ~. + eval new_path="$path" + if test ! -e "$new_path"; then + if test "x$2" != "xNOFAIL"; then + AC_MSG_ERROR([The path of $1, which resolves as "$new_path", is not found.]) + else + new_path="" + fi + fi + + # Make the path absolute + if test "x$new_path" != x; then + if test -d "$new_path"; then + path="`cd "$new_path"; pwd -L`" + else + dir="`$DIRNAME "$new_path"`" + base="`$BASENAME "$new_path"`" + path="`cd "$dir"; pwd -L`/$base" + fi + else + path="" fi - UTIL_ABSOLUTE_PATH(path) $1="$path" fi fi ]) +############################################################################### +# Check if the given file is a unix-style or windows-style executable, that is, +# if it expects paths in unix-style or windows-style. +# Returns "windows" or "unix" in $RESULT. +AC_DEFUN([UTIL_CHECK_WINENV_EXEC_TYPE], +[ + # For cygwin and msys2, if it's linked with the correct helper lib, it + # accept unix paths + if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin" || \ + test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys2"; then + linked_libs=`$LDD $1 2>&1` + if test $? -ne 0; then + # Non-binary files (e.g. shell scripts) are unix files + RESULT=unix + else + [ if [[ "$linked_libs" =~ $WINENV_MARKER_DLL ]]; then ] + RESULT=unix + else + RESULT=windows + fi + fi + elif test "x$OPENJDK_BUILD_OS" = "xwindows"; then + # On WSL, we can check if it is a PE file + file_type=`$FILE -b $1 2>&1` + [ if [[ $file_type =~ PE.*Windows ]]; then ] + RESULT=windows + else + RESULT=unix + fi + else + RESULT=unix + fi +]) + ############################################################################### # This will make sure the given variable points to a executable # with a full and proper path. This means: @@ -121,65 +164,331 @@ AC_DEFUN([UTIL_FIXUP_PATH], # If the input variable does not have a directory specification, then # it need to be in the PATH. # $1: The name of the variable to fix +# $2: Where to look for the command (replaces $PATH) +# $3: set to NOFIXPATH to skip prefixing FIXPATH, even if needed on platform AC_DEFUN([UTIL_FIXUP_EXECUTABLE], [ + input="[$]$1" + # Only process if variable expands to non-empty - - if test "x[$]$1" != x; then - if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then - UTIL_FIXUP_EXECUTABLE_CYGWIN($1) - elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then - UTIL_FIXUP_EXECUTABLE_MSYS($1) - elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then - UTIL_FIXUP_EXECUTABLE_WSL($1) + if test "x$input" != x; then + # First separate the path from the arguments. This will split at the first + # space. + [ if [[ "$OPENJDK_BUILD_OS" = "windows" && input =~ ^$FIXPATH ]]; then + line="${input#$FIXPATH }" + prefix="$FIXPATH " else - # We're on a unix platform. Hooray! :) - # First separate the path from the arguments. This will split at the first - # space. - complete="[$]$1" - path="${complete%% *}" - tmp="$complete EOL" - arguments="${tmp#* }" + line="$input" + prefix="" + fi ] + path="${line%% *}" + arguments="${line#"$path"}" - # Cannot rely on the command "which" here since it doesn't always work. - is_absolute_path=`$ECHO "$path" | $GREP ^/` - if test -z "$is_absolute_path"; then - # Path to executable is not absolute. Find it. - IFS_save="$IFS" - IFS=: - for p in $PATH; do - if test -f "$p/$path" && test -x "$p/$path"; then - new_path="$p/$path" - break - fi - done - IFS="$IFS_save" - else - # This is an absolute path, we can use it without further modifications. + [ if ! [[ "$path" =~ /|\\ ]]; then ] + # This is a command without path (e.g. "gcc" or "echo") + command_type=`type -t "$path"` + if test "x$command_type" = xbuiltin || test "x$command_type" = xkeyword; then + # Shell builtin or keyword; we're done here new_path="$path" - fi - - if test "x$new_path" = x; then - AC_MSG_NOTICE([The path of $1, which resolves as "$complete", is not found.]) - has_space=`$ECHO "$complete" | $GREP " "` - if test "x$has_space" != x; then - AC_MSG_NOTICE([This might be caused by spaces in the path, which is not allowed.]) + else + # Search in $PATH using bash built-in 'type -p'. + saved_path="$PATH" + if test "x$2" != x; then + PATH="$2" + fi + new_path=`type -p "$path"` + if test "x$new_path" = x && test "x$OPENJDK_BUILD_OS" = "xwindows"; then + # Try again with .exe + new_path="`type -p "$path.exe"`" + fi + PATH="$saved_path" + + if test "x$new_path" = x; then + AC_MSG_NOTICE([The command for $1, which resolves as "$input", is not found in the PATH.]) + AC_MSG_ERROR([Cannot locate $path]) fi - AC_MSG_ERROR([Cannot locate the the path of $1]) fi + else + # This is a path with slashes, don't look at $PATH + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + # fixpath.sh import will do all heavy lifting for us + new_path=`$FIXPATH_BASE import "$path"` + + if test ! -e $new_path; then + # It failed, but maybe spaces were part of the path and not separating + # the command and argument. Retry using that assumption. + new_path=`$FIXPATH_BASE import "$input"` + if test ! -e $new_path; then + AC_MSG_NOTICE([The command for $1, which resolves as "$input", can not be found.]) + AC_MSG_ERROR([Cannot locate $input]) + fi + # It worked, clear all "arguments" + arguments="" + fi + else # on unix + # Make absolute + $1="$path" + UTIL_FIXUP_PATH($1, NOFAIL) + new_path="[$]$1" + + if test ! -e $new_path; then + AC_MSG_NOTICE([The command for $1, which resolves as "$input", is not found]) + [ if [[ "$path" =~ " " ]]; then ] + AC_MSG_NOTICE([This might be caused by spaces in the path, which is not allowed.]) + fi + AC_MSG_ERROR([Cannot locate $path]) + fi + if test ! -x $new_path; then + AC_MSG_NOTICE([The command for $1, which resolves as "$input", is not executable.]) + AC_MSG_ERROR([Cannot execute command at $path]) + fi + fi # end on unix + fi # end with or without slashes + + # Now we have a usable command as new_path, with arguments in arguments + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + if test "x$prefix" = x; then + # Only mess around if prefix was not given + UTIL_CHECK_WINENV_EXEC_TYPE("$new_path") + if test "x$RESULT" = xwindows; then + prefix="$FIXPATH " + # make sure we have an .exe suffix (but not two) + new_path="${new_path%.exe}.exe" + else + # If we have gotten a .exe suffix, remove it + new_path="${new_path%.exe}" + fi + fi + fi + + if test "x$3" = xNOFIXPATH; then + prefix="" fi # Now join together the path and the arguments once again - if test "x$arguments" != xEOL; then - new_complete="$new_path ${arguments% *}" + new_complete="$prefix$new_path$arguments" + $1="$new_complete" + fi +]) + +############################################################################### +# Setup a tool for the given variable. If correctly specified by the user, +# use that value, otherwise search for the tool using the supplied code snippet. +# $1: variable to set +# $2: code snippet to call to look for the tool +# $3: code snippet to call if variable was used to find tool +AC_DEFUN([UTIL_SETUP_TOOL], +[ + # Publish this variable in the help. + AC_ARG_VAR($1, [Override default value for $1]) + + if [[ -z "${$1+x}" ]]; then + # The variable is not set by user, try to locate tool using the code snippet + $2 + else + # The variable is set, but is it from the command line or the environment? + + # Try to remove the string !$1! from our list. + try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!$1!/} + if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then + # If it failed, the variable was not from the command line. Ignore it, + # but warn the user (except for BASH, which is always set by the calling BASH). + if test "x$1" != xBASH; then + AC_MSG_WARN([Ignoring value of $1 from the environment. Use command line variables instead.]) + fi + # Try to locate tool using the code snippet + $2 else - new_complete="$new_path" + # If it succeeded, then it was overridden by the user. We will use it + # for the tool. + + # First remove it from the list of overridden variables, so we can test + # for unknown variables in the end. + CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var" + + tool_override=[$]$1 + + # Check if we try to supply an empty value + if test "x$tool_override" = x; then + AC_MSG_CHECKING([for $1]) + AC_MSG_RESULT([[[disabled by user]]]) + else + # Split up override in command part and argument part + tool_and_args=($tool_override) + [ tool_command=${tool_and_args[0]} ] + [ unset 'tool_and_args[0]' ] + [ tool_args=${tool_and_args[@]} ] + + # Check if the provided tool contains a complete path. + tool_basename="${tool_command##*/}" + if test "x$tool_basename" = "x$tool_command"; then + # A command without a complete path is provided, search $PATH. + AC_MSG_NOTICE([Will search for user supplied tool "$tool_basename"]) + AC_PATH_PROGS($1, $tool_basename ${tool_basename}.exe) + tool_command="[$]$1" + if test "x$tool_command" = x; then + AC_MSG_ERROR([User supplied tool $1="$tool_basename" could not be found in PATH]) + fi + else + # Otherwise we believe it is a complete path. Use it as it is. + if test ! -x "$tool_command" && test ! -x "${tool_command}.exe"; then + AC_MSG_ERROR([User supplied tool $1="$tool_command" does not exist or is not executable]) + fi + if test ! -x "$tool_command"; then + tool_command="${tool_command}.exe" + fi + $1="$tool_command" + fi + if test "x$tool_args" != x; then + # If we got arguments, re-append them to the command after the fixup. + $1="[$]$1 $tool_args" + fi + AC_MSG_CHECKING([for $1]) + AC_MSG_RESULT([[$]$1 [[user supplied]]]) + fi + fi + $3 + fi +]) + +############################################################################### +# Locate a tool using proper methods. +# $1: variable to set +# $2: executable name (or list of names) to look for +# $3: [path] +# $4: set to NOFIXPATH to skip prefixing FIXPATH, even if needed on platform +AC_DEFUN([UTIL_LOOKUP_PROGS], +[ + UTIL_SETUP_TOOL($1, [ + $1="" + + if test "x$3" != x; then + old_path="$PATH" + PATH="$3" fi - if test "x$complete" != "x$new_complete"; then - $1="$new_complete" - AC_MSG_NOTICE([Rewriting $1 to "$new_complete"]) + for name in $2; do + AC_MSG_CHECKING(for $name) + + command_type=`type -t "$name"` + if test "x$command_type" = xbuiltin || test "x$command_type" = xkeyword; then + # Shell builtin or keyword; we're done here + full_path="$name" + $1="$full_path" + AC_MSG_RESULT([[$full_path [builtin]]]) + break + else + # Search in $PATH + old_ifs="$IFS" + IFS=":" + for elem in $PATH; do + IFS="$old_ifs" + if test "x$elem" = x; then + continue + fi + full_path="$elem/$name" + if test ! -e "$full_path" && test "x$OPENJDK_BUILD_OS" = "xwindows"; then + # Try again with .exe + full_path="$elem/$name.exe" + fi + if test -e "$full_path"; then + $1="$full_path" + UTIL_FIXUP_EXECUTABLE($1, $3, $4) + result="[$]$1" + + # If we have FIXPATH enabled, strip all instances of it and prepend + # a single one, to avoid double fixpath prefixing. + if test "x$4" != xNOFIXPATH; then + [ if [[ $FIXPATH != "" && $result =~ ^"$FIXPATH " ]]; then ] + result="\$FIXPATH ${result#"$FIXPATH "}" + fi + fi + AC_MSG_RESULT([$result]) + break 2; + fi + done + IFS="$old_ifs" + fi + AC_MSG_RESULT([[[not found]]]) + done + + if test "x$3" != x; then + PATH="$old_path" fi + ]) +]) + +############################################################################### +# Call UTIL_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool. This will look +# first for cross-compilation tools. +# $1: variable to set +# $2: executable name (or list of names) to look for +# $3: [path] +AC_DEFUN([UTIL_LOOKUP_TOOLCHAIN_PROGS], +[ + if test "x$ac_tool_prefix" = x; then + UTIL_LOOKUP_PROGS($1, $2, $3) + else + prefixed_names=$(for name in $2; do echo ${ac_tool_prefix}${name} $name; done) + UTIL_LOOKUP_PROGS($1, $prefixed_names, $3) + fi +]) + +############################################################################### +# Test that variable $1 denoting a program is not empty. If empty, exit with an error. +# $1: variable to check +AC_DEFUN([UTIL_CHECK_NONEMPTY], +[ + if test "x[$]$1" = x; then + AC_MSG_ERROR([Could not find required tool for $1]) + fi +]) + +############################################################################### +# Like UTIL_LOOKUP_PROGS but fails if no tool was found. +# $1: variable to set +# $2: executable name (or list of names) to look for +# $3: [path] +AC_DEFUN([UTIL_REQUIRE_PROGS], +[ + UTIL_LOOKUP_PROGS($1, $2, $3) + UTIL_CHECK_NONEMPTY($1) +]) + +############################################################################### +# Like UTIL_LOOKUP_PROGS but fails if no tool was found. +# $1: variable to set +# $2: executable name (or list of names) to look for +# $3: [path] +AC_DEFUN([UTIL_REQUIRE_TOOLCHAIN_PROGS], +[ + UTIL_LOOKUP_TOOLCHAIN_PROGS($1, $2, $3) + UTIL_CHECK_NONEMPTY($1) +]) + + +############################################################################### +# Like UTIL_SETUP_TOOL but fails if no tool was found. +# $1: variable to set +# $2: autoconf macro to call to look for the special tool +AC_DEFUN([UTIL_REQUIRE_SPECIAL], +[ + UTIL_SETUP_TOOL($1, [$2]) + UTIL_CHECK_NONEMPTY($1) + # The special macro will return an absolute path, and is only used for + # unix tools. No further processing needed. +]) + +############################################################################### +# Add FIXPATH prefix to variable. Normally this is done by UTIL_LOOKUP_PROGS +# or UTIL_FIXUP_EXECUTABLE, but in some circumstances this has to be done +# explicitly, such as when the command in question does not exist yet. +# +# $1: variable to add fixpath to +AC_DEFUN([UTIL_ADD_FIXPATH], +[ + if test "x$FIXPATH" != x; then + $1="$FIXPATH [$]$1" fi ]) @@ -208,8 +517,8 @@ AC_DEFUN([UTIL_REMOVE_SYMBOLIC_LINKS], sym_link_file=`$BASENAME [$]$1` cd $sym_link_dir # Use -P flag to resolve symlinks in directories. - cd `$THEPWDCMD -P` - sym_link_dir=`$THEPWDCMD -P` + cd `pwd -P` + sym_link_dir=`pwd -P` # Resolve file symlinks while test $COUNTER -lt 20; do ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'` @@ -220,7 +529,7 @@ AC_DEFUN([UTIL_REMOVE_SYMBOLIC_LINKS], # Again resolve directory symlinks since the target of the just found # link could be in a different directory cd `$DIRNAME $ISLINK` - sym_link_dir=`$THEPWDCMD -P` + sym_link_dir=`pwd -P` sym_link_file=`$BASENAME $ISLINK` let COUNTER=COUNTER+1 done @@ -229,4 +538,3 @@ AC_DEFUN([UTIL_REMOVE_SYMBOLIC_LINKS], fi fi ]) - diff --git a/make/autoconf/util_windows.m4 b/make/autoconf/util_windows.m4 deleted file mode 100644 index 868c436bcb3..00000000000 --- a/make/autoconf/util_windows.m4 +++ /dev/null @@ -1,451 +0,0 @@ -# -# Copyright (c) 2011, 2020, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -AC_DEFUN([UTIL_REWRITE_AS_UNIX_PATH], -[ - windows_path="[$]$1" - if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then - unix_path=`$CYGPATH -u "$windows_path"` - $1="$unix_path" - elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then - unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` - $1="$unix_path" - elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then - # wslpath does not check the input, only call if an actual windows path was - # given. - if $ECHO "$windows_path" | $GREP -q ["^[a-zA-Z]:[\\\\/]"]; then - unix_path=`$WSLPATH -u "$windows_path"` - $1="$unix_path" - fi - fi -]) - -AC_DEFUN([UTIL_REWRITE_AS_WINDOWS_MIXED_PATH], -[ - unix_path="[$]$1" - if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then - windows_path=`$CYGPATH -m "$unix_path"` - $1="$windows_path" - elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then - windows_path=`cmd //c echo $unix_path` - $1="$windows_path" - elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.wsl"; then - windows_path=`$WSLPATH -m "$unix_path" 2>/dev/null` - if test $? -ne 0; then - dir=`dirname "$unix_path"` - base=`basename "$unix_path"` - windows_path=`$WSLPATH -m "$dir"`/"$base" - if test $? -ne 0; then - AC_MSG_ERROR([Cannot convert "$unix_path" to Windows path]) - fi - fi - $1="$windows_path" - fi -]) - -# Helper function which possibly converts a path using DOS-style short mode. -# If so, the updated path is stored in $new_path. -# $1: The path to check -AC_DEFUN([UTIL_MAKE_WINDOWS_SPACE_SAFE_CYGWIN], -[ - input_path="$1" - # Check if we need to convert this using DOS-style short mode. If the path - # contains just simple characters, use it. Otherwise (spaces, weird characters), - # take no chances and rewrite it. - # Note: m4 eats our [], so we need to use @<:@ and @:>@ instead. - has_forbidden_chars=`$ECHO "$input_path" | $GREP @<:@^-._/a-zA-Z0-9@:>@` - if test "x$has_forbidden_chars" != x; then - # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) - shortmode_path=`$CYGPATH -s -m -a "$input_path"` - path_after_shortmode=`$CYGPATH -u "$shortmode_path"` - if test "x$path_after_shortmode" != "x$input_to_shortpath"; then - # Going to short mode and back again did indeed matter. Since short mode is - # case insensitive, let's make it lowercase to improve readability. - shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` - # Now convert it back to Unix-style (cygpath) - input_path=`$CYGPATH -u "$shortmode_path"` - new_path="$input_path" - fi - fi - - test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/` - if test "x$test_cygdrive_prefix" = x; then - # As a simple fix, exclude /usr/bin since it's not a real path. - if test "x`$ECHO $1 | $GREP ^/usr/bin/`" = x; then - # The path is in a Cygwin special directory (e.g. /home). We need this converted to - # a path prefixed by /cygdrive for fixpath to work. - new_path="$CYGWIN_ROOT_PATH$input_path" - fi - fi -]) - -# Helper function which possibly converts a path using DOS-style short mode. -# If so, the updated path is stored in $new_path. -# $1: The path to check -AC_DEFUN([UTIL_MAKE_WINDOWS_SPACE_SAFE_MSYS], -[ - input_path="$1" - # Check if we need to convert this using DOS-style short mode. If the path - # contains just simple characters, use it. Otherwise (spaces, weird characters), - # take no chances and rewrite it. - # Note: m4 eats our [], so we need to use @<:@ and @:>@ instead. - has_forbidden_chars=`$ECHO "$input_path" | $GREP @<:@^-_/:a-zA-Z0-9@:>@` - if test "x$has_forbidden_chars" != x; then - # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) - new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` - fi -]) - -# Helper function which possibly converts a path using DOS-style short mode. -# If so, the updated path is stored in $new_path. -# $1: The path to check -AC_DEFUN([UTIL_MAKE_WINDOWS_SPACE_SAFE_WSL], -[ - input_path="$1" - # Check if we need to convert this using DOS-style short mode. If the path - # contains just simple characters, use it. Otherwise (spaces, weird characters), - # take no chances and rewrite it. - # Note: m4 eats our [], so we need to use @<:@ and @:>@ instead. - has_forbidden_chars=`$ECHO "$input_path" | $GREP [[^-_/:a-zA-Z0-9\\.]]` - if test "x$has_forbidden_chars" != x; then - # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) - TOPDIR_windows="$TOPDIR" - UTIL_REWRITE_AS_WINDOWS_MIXED_PATH([TOPDIR_windows]) - # First convert to Windows path to make input valid for cmd - UTIL_REWRITE_AS_WINDOWS_MIXED_PATH([input_path]) - # Reset PATH since it can contain a mix of WSL/linux paths and Windows paths from VS, - # which, in combination with WSLENV, will make the WSL layer complain - old_path="$PATH" - PATH= - new_path=`$CMD /c $TOPDIR_windows/make/scripts/windowsShortName.bat "$input_path" \ - | $SED -e 's|\r||g' \ - | $TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` - # Rewrite back to unix style - PATH="$old_path" - UTIL_REWRITE_AS_UNIX_PATH([new_path]) - fi -]) - -# FIXME: The UTIL_FIXUP_*_CYGWIN/MSYS is most likely too convoluted -# and could probably be heavily simplified. However, all changes in this -# area tend to need lot of testing in different scenarios, and in lack of -# proper unit testing, cleaning this up has not been deemed worth the effort -# at the moment. - -AC_DEFUN([UTIL_FIXUP_PATH_CYGWIN], -[ - # Input might be given as Windows format, start by converting to - # unix format. - path="[$]$1" - new_path=`$CYGPATH -u "$path"` - - UTIL_ABSOLUTE_PATH(new_path) - - # Cygwin tries to hide some aspects of the Windows file system, such that binaries are - # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered - # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then - # "foo.exe" is OK but "foo" is an error. - # - # This test is therefore slightly more accurate than "test -f" to check for file precense. - # It is also a way to make sure we got the proper file name for the real test later on. - test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` - if test "x$test_shortpath" = x; then - AC_MSG_NOTICE([The path of $1, which resolves as "$path", is invalid.]) - AC_MSG_ERROR([Cannot locate the the path of $1]) - fi - - # Call helper function which possibly converts this using DOS-style short mode. - # If so, the updated path is stored in $new_path. - UTIL_MAKE_WINDOWS_SPACE_SAFE_CYGWIN([$new_path]) - - if test "x$path" != "x$new_path"; then - $1="$new_path" - AC_MSG_NOTICE([Rewriting $1 to "$new_path"]) - fi -]) - -AC_DEFUN([UTIL_FIXUP_PATH_MSYS], -[ - path="[$]$1" - has_colon=`$ECHO $path | $GREP ^.:` - new_path="$path" - if test "x$has_colon" = x; then - # Not in mixed or Windows style, start by that. - new_path=`cmd //c echo $path` - fi - - UTIL_ABSOLUTE_PATH(new_path) - - UTIL_MAKE_WINDOWS_SPACE_SAFE_MSYS([$new_path]) - UTIL_REWRITE_AS_UNIX_PATH(new_path) - if test "x$path" != "x$new_path"; then - $1="$new_path" - AC_MSG_NOTICE([Rewriting $1 to "$new_path"]) - fi - - # Save the first 10 bytes of this path to the storage, so fixpath can work. - all_fixpath_prefixes=("${all_fixpath_prefixes@<:@@@:>@}" "${new_path:0:10}") -]) - -AC_DEFUN([UTIL_FIXUP_PATH_WSL], -[ - # Input might be given as Windows format, start by converting to - # unix format. - new_path="[$]$1" - UTIL_REWRITE_AS_UNIX_PATH([new_path]) - - UTIL_ABSOLUTE_PATH(new_path) - - # Call helper function which possibly converts this using DOS-style short mode. - # If so, the updated path is stored in $new_path. - UTIL_MAKE_WINDOWS_SPACE_SAFE_WSL([$new_path]) - - if test "x$path" != "x$new_path"; then - $1="$new_path" - AC_MSG_NOTICE([Rewriting $1 to "$new_path"]) - fi -]) - -AC_DEFUN([UTIL_FIXUP_EXECUTABLE_CYGWIN], -[ - # First separate the path from the arguments. This will split at the first - # space. - complete="[$]$1" - path="${complete%% *}" - tmp="$complete EOL" - arguments="${tmp#* }" - - # Input might be given as Windows format, start by converting to - # unix format. - new_path=`$CYGPATH -u "$path"` - - # Now try to locate executable using which - new_path=`type -p "$new_path" 2> /dev/null` - # bat and cmd files are not always considered executable in cygwin causing which - # to not find them - if test "x$new_path" = x \ - && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \ - && test "x`$LS \"$path\" 2>/dev/null`" != x; then - new_path=`$CYGPATH -u "$path"` - fi - if test "x$new_path" = x; then - # Oops. Which didn't find the executable. - # The splitting of arguments from the executable at a space might have been incorrect, - # since paths with space are more likely in Windows. Give it another try with the whole - # argument. - path="$complete" - arguments="EOL" - new_path=`$CYGPATH -u "$path"` - new_path=`type -p "$new_path" 2> /dev/null` - # bat and cmd files are not always considered executable in cygwin causing which - # to not find them - if test "x$new_path" = x \ - && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \ - && test "x`$LS \"$path\" 2>/dev/null`" != x; then - new_path=`$CYGPATH -u "$path"` - fi - if test "x$new_path" = x; then - # It's still not found. Now this is an unrecoverable error. - AC_MSG_NOTICE([The path of $1, which resolves as "$complete", is not found.]) - has_space=`$ECHO "$complete" | $GREP " "` - if test "x$has_space" != x; then - AC_MSG_NOTICE([You might be mixing spaces in the path and extra arguments, which is not allowed.]) - fi - AC_MSG_ERROR([Cannot locate the the path of $1]) - fi - fi - - # Cygwin tries to hide some aspects of the Windows file system, such that binaries are - # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered - # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then - # "foo.exe" is OK but "foo" is an error. - # - # This test is therefore slightly more accurate than "test -f" to check for file presence. - # It is also a way to make sure we got the proper file name for the real test later on. - test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` - if test "x$test_shortpath" = x; then - # Short path failed, file does not exist as specified. - # Try adding .exe or .cmd - if test -f "${new_path}.exe"; then - input_to_shortpath="${new_path}.exe" - elif test -f "${new_path}.cmd"; then - input_to_shortpath="${new_path}.cmd" - else - AC_MSG_NOTICE([The path of $1, which resolves as "$new_path", is invalid.]) - AC_MSG_NOTICE([Neither "$new_path" nor "$new_path.exe/cmd" can be found]) - AC_MSG_ERROR([Cannot locate the the path of $1]) - fi - else - input_to_shortpath="$new_path" - fi - - # Call helper function which possibly converts this using DOS-style short mode. - # If so, the updated path is stored in $new_path. - new_path="$input_to_shortpath" - UTIL_MAKE_WINDOWS_SPACE_SAFE_CYGWIN([$input_to_shortpath]) - # remove trailing .exe if any - new_path="${new_path/%.exe/}" -]) - -AC_DEFUN([UTIL_FIXUP_EXECUTABLE_MSYS], -[ - # First separate the path from the arguments. This will split at the first - # space. - complete="[$]$1" - path="${complete%% *}" - tmp="$complete EOL" - arguments="${tmp#* }" - - # Input might be given as Windows format, start by converting to - # unix format. - new_path="$path" - UTIL_REWRITE_AS_UNIX_PATH(new_path) - - # Now try to locate executable using which - new_path=`type -p "$new_path" 2> /dev/null` - - if test "x$new_path" = x; then - # Oops. Which didn't find the executable. - # The splitting of arguments from the executable at a space might have been incorrect, - # since paths with space are more likely in Windows. Give it another try with the whole - # argument. - path="$complete" - arguments="EOL" - new_path="$path" - UTIL_REWRITE_AS_UNIX_PATH(new_path) - - new_path=`type -p "$new_path" 2> /dev/null` - # bat and cmd files are not always considered executable in MSYS causing which - # to not find them - if test "x$new_path" = x \ - && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \ - && test "x`$LS \"$path\" 2>/dev/null`" != x; then - new_path="$path" - UTIL_REWRITE_AS_UNIX_PATH(new_path) - fi - - if test "x$new_path" = x; then - # It's still not found. Now this is an unrecoverable error. - AC_MSG_NOTICE([The path of $1, which resolves as "$complete", is not found.]) - has_space=`$ECHO "$complete" | $GREP " "` - if test "x$has_space" != x; then - AC_MSG_NOTICE([You might be mixing spaces in the path and extra arguments, which is not allowed.]) - fi - AC_MSG_ERROR([Cannot locate the the path of $1]) - fi - fi - - # Now new_path has a complete unix path to the binary - if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then - # Keep paths in /bin as-is, but remove trailing .exe if any - new_path="${new_path/%.exe/}" - # Do not save /bin paths to all_fixpath_prefixes! - else - # Not in mixed or Windows style, start by that. - new_path=`cmd //c echo $new_path` - UTIL_MAKE_WINDOWS_SPACE_SAFE_MSYS([$new_path]) - # Output is in $new_path - UTIL_REWRITE_AS_UNIX_PATH(new_path) - # remove trailing .exe if any - new_path="${new_path/%.exe/}" - - # Save the first 10 bytes of this path to the storage, so fixpath can work. - all_fixpath_prefixes=("${all_fixpath_prefixes@<:@@@:>@}" "${new_path:0:10}") - fi -]) - -AC_DEFUN([UTIL_FIXUP_EXECUTABLE_WSL], -[ - # First separate the path from the arguments. This will split at the first - # space. - complete="[$]$1" - path="${complete%% *}" - tmp="$complete EOL" - arguments="${tmp#* }" - - # Input might be given as Windows format, start by converting to - # unix format. - new_path="$path" - UTIL_REWRITE_AS_UNIX_PATH([new_path]) - - # Now try to locate executable using which - new_path_bak="$new_path" - new_path=`type -p "$new_path" 2> /dev/null` - # bat and cmd files are not considered executable in WSL - if test "x$new_path" = x \ - && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \ - && test "x`$LS \"$path\" 2>/dev/null`" != x; then - new_path="$new_path_back" - fi - if test "x$new_path" = x; then - # Oops. Which didn't find the executable. - # The splitting of arguments from the executable at a space might have been incorrect, - # since paths with space are more likely in Windows. Give it another try with the whole - # argument. - path="$complete" - arguments="EOL" - new_path="$path" - UTIL_REWRITE_AS_UNIX_PATH([new_path]) - new_path_bak="$new_path" - new_path=`type -p "$new_path" 2> /dev/null` - # bat and cmd files are not considered executable in WSL - if test "x$new_path" = x \ - && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \ - && test "x`$LS \"$path\" 2>/dev/null`" != x; then - new_path="$new_path_bak" - fi - if test "x$new_path" = x; then - # It's still not found. Now this is an unrecoverable error. - AC_MSG_NOTICE([The path of $1, which resolves as "$complete", is not found.]) - has_space=`$ECHO "$complete" | $GREP " "` - if test "x$has_space" != x; then - AC_MSG_NOTICE([You might be mixing spaces in the path and extra arguments, which is not allowed.]) - fi - AC_MSG_ERROR([Cannot locate the the path of $1]) - fi - fi - - # In WSL, suffixes must be present for Windows executables - if test ! -f "$new_path"; then - # Try adding .exe or .cmd - if test -f "${new_path}.exe"; then - input_to_shortpath="${new_path}.exe" - elif test -f "${new_path}.cmd"; then - input_to_shortpath="${new_path}.cmd" - else - AC_MSG_NOTICE([The path of $1, which resolves as "$new_path", is invalid.]) - AC_MSG_NOTICE([Neither "$new_path" nor "$new_path.exe/cmd" can be found]) - AC_MSG_ERROR([Cannot locate the the path of $1]) - fi - else - input_to_shortpath="$new_path" - fi - - # Call helper function which possibly converts this using DOS-style short mode. - # If so, the updated path is stored in $new_path. - new_path="$input_to_shortpath" - UTIL_MAKE_WINDOWS_SPACE_SAFE_WSL([$input_to_shortpath]) -]) - diff --git a/make/common/JavaCompilation.gmk b/make/common/JavaCompilation.gmk index 00affb4ea02..1d25dc6dbeb 100644 --- a/make/common/JavaCompilation.gmk +++ b/make/common/JavaCompilation.gmk @@ -227,25 +227,19 @@ define SetupJavaCompilationBody # The portfile contains the tcp/ip on which the server listens # and the cookie necessary to talk to the server. - $1_JAVAC_PORT_FILE := $$(JAVAC_SERVER_DIR)/server.port + $1_JAVAC_PORT_FILE := $$(call FixPath, $$(JAVAC_SERVER_DIR)/server.port) - # The servercmd specified how to launch the server. This must use - # JAVA_DETACH, which is the "big" java with an ability to detach from - # fixpath (on Windows) This will be executed by the client, if needed. - $1_JAVAC_SERVER_CMD := $$(JAVA_DETACH) $$($1_JAVA_FLAGS) $$($1_JAVAC) + # The servercmd specifies how to launch the server. This will be executed + # by the client, if needed. + $1_JAVAC_SERVER_CMD := $$(call FixPath, $$(JAVA) $$($1_JAVA_FLAGS) $$($1_JAVAC)) $1_CONFIG_VARDEPS := $$($1_JAVAC_PORT_FILE) $$($1_JAVAC_SERVER_CMD) $1_CONFIG_VARDEPS_FILE := $$(call DependOnVariable, $1_CONFIG_VARDEPS, \ $$($1_BIN)$$($1_MODULE_SUBDIR)/_the.$1.config_vardeps) - ifeq ($(call isBuildOs, windows), true) - $1_ECHO_COMMAND := $(FIXPATH) cmd /c echo - else - $1_ECHO_COMMAND := $(ECHO) - endif $$($1_JAVAC_SERVER_CONFIG): $$($1_CONFIG_VARDEPS_FILE) - $$($1_ECHO_COMMAND) portfile=$$($1_JAVAC_PORT_FILE) > $$@ - $$($1_ECHO_COMMAND) servercmd=$$($1_JAVAC_SERVER_CMD) >> $$@ + $(ECHO) portfile=$$($1_JAVAC_PORT_FILE) > $$@ + $(ECHO) servercmd=$$($1_JAVAC_SERVER_CMD) >> $$@ # Always use small java to launch client $1_JAVAC_CMD := $$(JAVA_SMALL) $$($1_JAVA_FLAGS) $$($1_JAVAC) \ diff --git a/make/common/MakeBase.gmk b/make/common/MakeBase.gmk index 7efd9009eb6..a9d806da0c0 100644 --- a/make/common/MakeBase.gmk +++ b/make/common/MakeBase.gmk @@ -64,6 +64,9 @@ define NEWLINE endef +# Make sure we have a value (could be overridden on command line by caller) +CREATING_BUILDJDK ?= false + # Certain features only work in newer version of GNU Make. The build will still # function in 3.81, but will be less performant. ifeq (4.0, $(firstword $(sort 4.0 $(MAKE_VERSION)))) @@ -436,38 +439,15 @@ endif # On Windows, converts a path from cygwin/unix style (e.g. /bin/foo) into # "mixed mode" (e.g. c:/cygwin/bin/foo). On other platforms, return the path # unchanged. +# This also converts a colon-separated list of paths to a semicolon-separated +# list. # This is normally not needed since we use the FIXPATH prefix for command lines, # but might be needed in certain circumstances. ifeq ($(call isTargetOs, windows), true) - FixPathArgs = \ - $(shell $(FIXPATH) cmd /c echo $1) - ifeq ($(call isBuildOsEnv, windows.wsl), true) - FixPath = \ - $(shell $(WSLPATH) -m $1) - else - FixPath = \ - $(shell $(CYGPATH) -m $1) - endif -else - FixPathArgs = \ - $1 FixPath = \ - $1 -endif - -################################################################################ -# FixPathList -# -# On Windows, converts a cygwin/unix style path list (colon-separated) into -# the native format (mixed mode, semicolon-separated). On other platforms, -# return the path list unchanged. -################################################################################ -ifeq ($(call isTargetOs, windows), true) - FixPathList = \ - $(subst @,$(SPACE),$(subst $(SPACE),;,$(foreach entry,$(subst :,$(SPACE),\ - $(subst $(SPACE),@,$(strip $1))),$(call FixPath, $(entry))))) + $(strip $(subst \,\\, $(shell $(FIXPATH_BASE) print $(patsubst $(FIXPATH), , $1)))) else - FixPathList = \ + FixPath = \ $1 endif diff --git a/make/common/NativeCompilation.gmk b/make/common/NativeCompilation.gmk index 6901d6d003f..db2a0ba1156 100644 --- a/make/common/NativeCompilation.gmk +++ b/make/common/NativeCompilation.gmk @@ -72,10 +72,10 @@ define WriteCompileCommandsFragment $(call LogInfo, Creating compile commands fragment for $(notdir $3)) $(call MakeDir, $(dir $1)) $(call WriteFile,{ \ - "directory": "$(strip $(call FixPathArgs, $2))"$(COMMA) \ - "file": "$(strip $(call FixPathArgs, $3))"$(COMMA) \ + "directory": "$(strip $(call FixPath, $2))"$(COMMA) \ + "file": "$(strip $(call FixPath, $3))"$(COMMA) \ "command": "$(strip $(subst $(DQUOTE),\$(DQUOTE),$(subst \,\\,\ - $(subst $(FIXPATH),,$(call FixPathArgs, $4)))))" \ + $(subst $(FIXPATH),,$(call FixPath, $4)))))" \ }$(COMMA), \ $1) endef @@ -175,12 +175,6 @@ $(strip \ ) endef -ifeq ($(call isBuildOsEnv, windows.cygwin), true) - UNIX_PATH_PREFIX := /cygdrive -else ifeq ($(call isBuildOsEnv, windows.msys), true) - UNIX_PATH_PREFIX := -endif - # This pattern is used to transform the output of the microsoft CL compiler # into a make syntax dependency file (.d) WINDOWS_SHOWINCLUDE_SED_PATTERN := \ @@ -188,7 +182,7 @@ WINDOWS_SHOWINCLUDE_SED_PATTERN := \ -e 's|Note: including file: *||' \ -e 's|\r||g' \ -e 's|\\|/|g' \ - -e 's|^\([a-zA-Z]\):|$(UNIX_PATH_PREFIX)/\1|g' \ + -e 's|^\([a-zA-Z]\):|$(WINENV_PREFIX)/\1|g' \ -e '\|$(TOPDIR)|I !d' \ -e 's|$$$$| \\|g' \ # @@ -542,7 +536,7 @@ define SetupNativeCompilationBody ifeq ($$($1_TYPE), EXECUTABLE) $1_PREFIX := ifeq ($$($1_SUFFIX), ) - $1_SUFFIX := $(EXE_SUFFIX) + $1_SUFFIX := $(EXECUTABLE_SUFFIX) endif else $1_PREFIX := $(LIBRARY_PREFIX) @@ -1163,6 +1157,9 @@ define SetupNativeCompilationBody test "$$$$?" = "1" ; \ $$($1_CREATE_DEBUGINFO_CMDS) $$($1_STRIP_CMD) + ifeq ($(call isBuildOsEnv, windows.wsl2), true) + $$(CHMOD) +x $$($1_TARGET) + endif else $$(call ExecuteWithLog, $$($1_OBJECT_DIR)/$$($1_SAFE_NAME)_link, \ $$(if $$($1_LINK_OBJS_RELATIVE), $$(CD) $$(OUTPUTDIR) ; ) \ diff --git a/make/common/Utils.gmk b/make/common/Utils.gmk index 8f6f40c2657..a7df32065ae 100644 --- a/make/common/Utils.gmk +++ b/make/common/Utils.gmk @@ -278,7 +278,7 @@ FindExecutableDirForModule = \ # param 1 : A space separated list of classpath entries # The surrounding strip is needed to keep additional whitespace out PathList = \ - "$(subst $(SPACE),$(PATH_SEP),$(strip $(subst $(DQUOTE),,$1)))" + "$(subst $(SPACE),:,$(strip $(subst $(DQUOTE),,$1)))" ################################################################################ # Check if a specified hotspot variant is being built, or at least one of a diff --git a/make/common/modules/GensrcCommonLangtools.gmk b/make/common/modules/GensrcCommonLangtools.gmk index 44e46aa5253..fc4be633351 100644 --- a/make/common/modules/GensrcCommonLangtools.gmk +++ b/make/common/modules/GensrcCommonLangtools.gmk @@ -85,14 +85,16 @@ define SetupCompileProperties $$(addprefix _SPACE_, $$(PROPJAVAS))))) # Now setup the rule for the generation of the resource bundles. - $(SUPPORT_OUTPUTDIR)/gensrc/$(MODULE)/_the_props: $$(PROPSOURCES) + PROPS_BASE := $(SUPPORT_OUTPUTDIR)/gensrc/$(MODULE)/_the_props + $$(PROPS_BASE): $$(PROPSOURCES) $$(call MakeDir, $$(@D) $$(PROPDIRS)) $(FIND) $$(@D) -name "*.java" -a ! -name "*Properties.java" $(FIND_DELETE) $(ECHO) Compiling $$(words $$(PROPSOURCES)) properties into resource bundles for $(MODULE) - $(TOOL_COMPILEPROPS_CMD) $$(PROPCMDLINE) + $$(call ExecuteWithLog, $$(PROPS_BASE)_exec, \ + $(TOOL_COMPILEPROPS_CMD) $$(PROPCMDLINE)) $(TOUCH) $$@ - $$(strip $1) += $(SUPPORT_OUTPUTDIR)/gensrc/$(MODULE)/_the_props + $$(strip $1) += $$(PROPS_BASE) endef ################################################################################ diff --git a/make/conf/jib-profiles.js b/make/conf/jib-profiles.js index 6d68964a0fd..2bd8ac926d5 100644 --- a/make/conf/jib-profiles.js +++ b/make/conf/jib-profiles.js @@ -240,7 +240,7 @@ var getJibProfilesCommon = function (input, data) { // List of the main profile names used for iteration common.main_profile_names = [ "linux-x64", "linux-x86", "macosx-x64", - "windows-x64", "windows-x86", + "windows-x64", "windows-x86", "windows-aarch64", "linux-aarch64", "linux-arm32", "linux-ppc64le", "linux-s390x" ]; @@ -461,6 +461,15 @@ var getJibProfilesProfiles = function (input, common, data) { configure_args: concat(common.configure_args_32bit), }, + "windows-aarch64": { + target_os: "windows", + target_cpu: "aarch64", + dependencies: ["devkit", "gtest", "build_devkit"], + configure_args: [ + "--openjdk-target=aarch64-unknown-cygwin", + ], + }, + "linux-aarch64": { target_os: "linux", target_cpu: "aarch64", @@ -673,6 +682,10 @@ var getJibProfilesProfiles = function (input, common, data) { platform: "windows-x86", jdk_suffix: "zip", }, + "windows-aarch64": { + platform: "windows-aarch64", + jdk_suffix: "zip", + }, "linux-aarch64": { platform: "linux-aarch64", }, @@ -1014,7 +1027,7 @@ var getJibProfilesDependencies = function (input, common) { var devkit_platform_revisions = { linux_x64: "gcc10.2.0-OL6.4+1.0", macosx_x64: "Xcode11.3.1-MacOSX10.15+1.1", - windows_x64: "VS2019-16.7.2+1.0", + windows_x64: "VS2019-16.7.2+1.1", linux_aarch64: "gcc10.2.0-OL7.6+1.0", linux_arm: "gcc8.2.0-Fedora27+1.0", linux_ppc64le: "gcc8.2.0-Fedora27+1.0", @@ -1024,9 +1037,11 @@ var getJibProfilesDependencies = function (input, common) { var devkit_platform = (input.target_cpu == "x86" ? input.target_os + "_x64" : input.target_platform); - + if (input.target_platform == "windows_aarch64") { + devkit_platform = "windows_x64"; + } var devkit_cross_prefix = ""; - if (!(input.target_os == "windows" && isWsl(input))) { + if (!(input.target_os == "windows")) { if (input.build_platform != input.target_platform && input.build_platform != devkit_platform) { devkit_cross_prefix = input.build_platform + "-to-"; diff --git a/make/hotspot/test/GtestImage.gmk b/make/hotspot/test/GtestImage.gmk index 74077e47987..322a90b3d10 100644 --- a/make/hotspot/test/GtestImage.gmk +++ b/make/hotspot/test/GtestImage.gmk @@ -32,7 +32,7 @@ $(foreach v, $(JVM_VARIANTS), \ $(eval $(call SetupCopyFiles, COPY_GTEST_$v, \ SRC := $(HOTSPOT_OUTPUTDIR)/variant-$v/libjvm/gtest, \ DEST := $(TEST_IMAGE_DIR)/hotspot/gtest/$v, \ - FILES := $(call SHARED_LIBRARY,jvm) gtestLauncher$(EXE_SUFFIX), \ + FILES := $(call SHARED_LIBRARY,jvm) gtestLauncher$(EXECUTABLE_SUFFIX), \ )) \ $(eval TARGETS += $$(COPY_GTEST_$v)) \ ) diff --git a/make/ide/idea/jdk/idea.gmk b/make/ide/idea/jdk/idea.gmk index 9d286c961d1..310b582591c 100644 --- a/make/ide/idea/jdk/idea.gmk +++ b/make/ide/idea/jdk/idea.gmk @@ -51,7 +51,7 @@ else #with SPEC $(ECHO) "MODULE_NAMES=\"$(strip $(foreach mod, $(SEL_MODULES), $(mod)))\"" >> $(OUT) $(ECHO) "SEL_MODULES=\"$(SEL_MODULES)\"" >> $(OUT) $(ECHO) "BOOT_JDK=\"$(BOOT_JDK)\"" >> $(OUT) - $(ECHO) "CYGPATH=\"$(CYGPATH)\"" >> $(OUT) + $(ECHO) "CYGPATH=\"$(PATHTOOL)\"" >> $(OUT) $(ECHO) "SPEC=\"$(SPEC)\"" >> $(OUT) $(ECHO) "JT_HOME=\"$(JT_HOME)\"" >> $(OUT) diff --git a/make/ide/visualstudio/hotspot/CreateVSProject.gmk b/make/ide/visualstudio/hotspot/CreateVSProject.gmk index b463beec435..f60f7c62489 100644 --- a/make/ide/visualstudio/hotspot/CreateVSProject.gmk +++ b/make/ide/visualstudio/hotspot/CreateVSProject.gmk @@ -44,18 +44,10 @@ ifeq ($(call isTargetOs, windows), true) # Reset targets so we don't build libjvm. TARGETS := - # Helper macro to convert a unix path to a Windows path, suitable for - # inclusion in a command line. - ifeq ($(call isBuildOsEnv, windows.cygwin), true) - FixPath = \ - $(strip $(subst \,\\,$(shell $(CYGPATH) -w $1))) - FixLinuxExecutable = \ - $(call FixPath, $1) - else ifeq ($(call isBuildOsEnv, windows.wsl), true) - FixPath = \ - $(strip $(subst \,\\,$(shell $(WSLPATH) -w $1))) - FixLinuxExecutable = \ - "%windir%\Sysnative\wsl.exe $1" + ifeq ($(call isBuildOsEnv, windows.cygwin windows.msys2), true) + FixLinuxExecutable = $(call FixPath, $1) + else ifeq ($(call isBuildOsEnv, windows.wsl1 windows.wsl2), true) + FixLinuxExecutable = "%windir%\Sysnative\wsl.exe $1" endif JVM_DEFINES_client := $(patsubst -D%,%, $(filter -D%, $(JVM_CFLAGS))) diff --git a/make/ide/vscode/hotspot/CreateVSCodeProject.gmk b/make/ide/vscode/hotspot/CreateVSCodeProject.gmk index 4405b31004e..8b82c38a751 100644 --- a/make/ide/vscode/hotspot/CreateVSCodeProject.gmk +++ b/make/ide/vscode/hotspot/CreateVSCodeProject.gmk @@ -86,7 +86,7 @@ define CreateFromTemplate -e 's!{{CONF_NAME}}!$(CONF_NAME)!g' \ -e 's!{{COMPILER}}!$(call FixPath,$(CXX)) $(SYSROOT_CFLAGS)!g' \ -e 's!{{MAKE}}!$(call FixPath,$(MAKE))!g' \ - -e 's!{{PATH}}!$(call FixPathList,$(PATH))!g' \ + -e 's!{{PATH}}!$(call FixPath,$(PATH))!g' \ -e 's!{{DEBUGENGINENAME}}!$(call DebugEngineName)!g' \ -e '/{{INDEXER_EXTENSIONS}}/d' \ -e '/{{INDEXER_SETTINGS}}/d' \ diff --git a/make/jdk/src/classes/build/tools/generatecharacter/GenerateCharacter.java b/make/jdk/src/classes/build/tools/generatecharacter/GenerateCharacter.java index 432cd654eb3..a21b662e2ac 100644 --- a/make/jdk/src/classes/build/tools/generatecharacter/GenerateCharacter.java +++ b/make/jdk/src/classes/build/tools/generatecharacter/GenerateCharacter.java @@ -1841,7 +1841,7 @@ OUTER: for (int i = 0; i < n; i += m) { } commentStart = (Csyntax ? "/*" : "//"); commentEnd = (Csyntax ? " */" : ""); - commandLineDescription = desc.toString(); + commandLineDescription = desc.toString().replace("\\", "\\\\"); } private static void searchBins(long[] map, int binsOccupied) throws Exception { diff --git a/make/modules/java.base/Copy.gmk b/make/modules/java.base/Copy.gmk index 040b7588ba1..dfa2a54f63a 100644 --- a/make/modules/java.base/Copy.gmk +++ b/make/modules/java.base/Copy.gmk @@ -44,8 +44,11 @@ ifeq ($(call isTargetOs, aix), true) endif ################################################################################ -# Copy the microsoft runtime libraries on windows -ifeq ($(call isTargetOs, windows), true) +# Copy the microsoft runtime libraries on windows, but only if we are not +# creating a buildjdk. If we are, the provided runtime librareis are made for +# the target platform, not the build platform (and we should not need to bundle +# anything with the minimalistic, locally-only buildjdk.) +ifeq ($(call isTargetOs, windows)+$(CREATING_BUILDJDK), true+false) # Chmod to avoid permission issues if bundles are unpacked on unix platforms. define copy-and-chmod diff --git a/make/modules/java.base/gensrc/GensrcCharacterData.gmk b/make/modules/java.base/gensrc/GensrcCharacterData.gmk index cdfc8a64c96..868397f0c9a 100644 --- a/make/modules/java.base/gensrc/GensrcCharacterData.gmk +++ b/make/modules/java.base/gensrc/GensrcCharacterData.gmk @@ -32,13 +32,18 @@ GENSRC_CHARACTERDATA := CHARACTERDATA = $(TOPDIR)/make/data/characterdata UNICODEDATA = $(TOPDIR)/make/data/unicodedata +ifneq ($(DEBUG_LEVEL), release) + ifeq ($(ALLOW_ABSOLUTE_PATHS_IN_OUTPUT), true) + DEBUG_OPTION := -d + endif +endif + define SetupCharacterData $(SUPPORT_OUTPUTDIR)/gensrc/java.base/java/lang/$1.java: \ $(CHARACTERDATA)/$1.java.template $$(call LogInfo, Generating $1.java) $$(call MakeDir, $$(@D)) - $(TOOL_GENERATECHARACTER) $2 \ - $(if $(call equals, $(ALLOW_ABSOLUTE_PATHS_IN_OUTPUT), true), -d) \ + $(TOOL_GENERATECHARACTER) $2 $(DEBUG_OPTION) \ -template $(CHARACTERDATA)/$1.java.template \ -spec $(UNICODEDATA)/UnicodeData.txt \ -specialcasing $(UNICODEDATA)/SpecialCasing.txt \ diff --git a/make/modules/java.base/gensrc/GensrcCharsetCoder.gmk b/make/modules/java.base/gensrc/GensrcCharsetCoder.gmk index 7622c1069a4..79fa54b19cc 100644 --- a/make/modules/java.base/gensrc/GensrcCharsetCoder.gmk +++ b/make/modules/java.base/gensrc/GensrcCharsetCoder.gmk @@ -36,7 +36,8 @@ GENSRC_CHARSETCODER_TEMPLATE := $(GENSRC_CHARSETCODER_SRC)/charset/Charset-X-Cod $(GENSRC_CHARSETCODER_DST)/CharsetDecoder.java: $(GENSRC_CHARSETCODER_TEMPLATE) $(call MakeTargetDir) $(RM) $@.tmp - $(TOOL_SPP) -i$< -o$@.tmp \ + $(call ExecuteWithLog, $(SUPPORT_OUTPUTDIR)/gensrc/java.base/_charset_decoder, \ + $(TOOL_SPP) -i$< -o$@.tmp \ -Kdecoder \ -DA='A' \ -Da='a' \ @@ -61,7 +62,7 @@ $(GENSRC_CHARSETCODER_DST)/CharsetDecoder.java: $(GENSRC_CHARSETCODER_TEMPLATE) -DItypesPerOtype='CharsPerByte' \ -DnotLegal='not legal for this charset' \ -Dotypes-per-itype='chars-per-byte' \ - -DoutSequence='Unicode character' + -DoutSequence='Unicode character') $(MV) $@.tmp $@ GENSRC_CHARSETCODER += $(GENSRC_CHARSETCODER_DST)/CharsetDecoder.java @@ -71,7 +72,8 @@ GENSRC_CHARSETCODER += $(GENSRC_CHARSETCODER_DST)/CharsetDecoder.java $(GENSRC_CHARSETCODER_DST)/CharsetEncoder.java: $(GENSRC_CHARSETCODER_TEMPLATE) $(call MakeTargetDir) $(RM) $@.tmp - $(TOOL_SPP) -i$< -o$@.tmp \ + $(call ExecuteWithLog, $(SUPPORT_OUTPUTDIR)/gensrc/java.base/_charset_encoder, \ + $(TOOL_SPP) -i$< -o$@.tmp \ -Kencoder \ -DA='An' \ -Da='an' \ @@ -96,7 +98,7 @@ $(GENSRC_CHARSETCODER_DST)/CharsetEncoder.java: $(GENSRC_CHARSETCODER_TEMPLATE) -DItypesPerOtype='BytesPerChar' \ -DnotLegal='not a legal sixteen-bit Unicode sequence' \ -Dotypes-per-itype='bytes-per-char' \ - -DoutSequence='byte sequence in the given charset' + -DoutSequence='byte sequence in the given charset') $(MV) $@.tmp $@ GENSRC_CHARSETCODER += $(GENSRC_CHARSETCODER_DST)/CharsetEncoder.java diff --git a/make/scripts/windowsShortName.bat b/make/scripts/extract-vs-env.cmd similarity index 59% rename from make/scripts/windowsShortName.bat rename to make/scripts/extract-vs-env.cmd index 7730593e6c2..096eb0dca57 100644 --- a/make/scripts/windowsShortName.bat +++ b/make/scripts/extract-vs-env.cmd @@ -1,6 +1,6 @@ @echo off REM -REM Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved. +REM Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. REM DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. REM REM This code is free software; you can redistribute it and/or modify it @@ -21,4 +21,27 @@ REM Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA REM or visit www.oracle.com if you need additional information or have any REM questions. REM -if '%1' NEQ '' echo %~s1 + +set vcvarscmd=%1 +set output=%2 +if not "%3" == "auto" set version=-vcvars_ver=%3 + +set PATH_BEFORE=%PATH% + +call %vcvarscmd% %version% %4 %5 %6 %7 %8 %9 +if exist %output% del %output% + +call :extract "%PATH_BEFORE%", PATH_BEFORE +call :extract "%PATH%", PATH_AFTER +call :extract "%INCLUDE%", VS_INCLUDE +call :extract "%LIB%", VS_LIB +call :extract "%VCINSTALLDIR%", VCINSTALLDIR +call :extract "%VCToolsRedistDir%", VCToolsRedistDir +call :extract "%WindowsSdkDir%", WindowsSdkDir +call :extract "%WINDOWSSDKDIR%", WINDOWSSDKDIR + +exit /b 0 + +:extract +echo %~2=$($BASH $TOPDIR/make/scripts/fixpath.sh -i import '%~1 ') >> %output% +exit /b 0 diff --git a/make/scripts/fixpath.sh b/make/scripts/fixpath.sh new file mode 100644 index 00000000000..dfee8c7c562 --- /dev/null +++ b/make/scripts/fixpath.sh @@ -0,0 +1,498 @@ +#!/bin/bash +# +# Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +# Setup the environment fixpath assumes. Read from command line options if +# available, or extract values automatically from the environment if missing. +# This is robust, but slower. +function setup() { + while getopts "e:p:r:t:c:qmi" opt; do + case "$opt" in + e) PATHTOOL="$OPTARG" ;; + p) DRIVEPREFIX="$OPTARG" ;; + r) ENVROOT="$OPTARG" ;; + t) WINTEMP="$OPTARG" ;; + c) CMD="$OPTARG" ;; + q) QUIET=true ;; + m) MIXEDMODE=true ;; + i) IGNOREFAILURES=true ;; + ?) + # optargs found argument error + exit 2 + ;; + esac + done + + shift $((OPTIND-1)) + ACTION="$1" + + # Locate variables ourself if not giving from caller + if [[ -z ${PATHTOOL+x} ]]; then + PATHTOOL="$(type -p cygpath)" + if [[ $PATHTOOL == "" ]]; then + PATHTOOL="$(type -p wslpath)" + if [[ $PATHTOOL == "" ]]; then + if [[ $QUIET != true ]]; then + echo fixpath: failure: Cannot locate cygpath or wslpath >&2 + fi + exit 2 + fi + fi + fi + + if [[ -z ${DRIVEPREFIX+x} ]]; then + winroot="$($PATHTOOL -u c:/)" + DRIVEPREFIX="${winroot%/c/}" + else + if [[ $DRIVEPREFIX == "NONE" ]]; then + DRIVEPREFIX="" + fi + fi + + if [[ -z ${ENVROOT+x} ]]; then + unixroot="$($PATHTOOL -w / 2> /dev/null)" + # Remove trailing backslash + ENVROOT="${unixroot%\\}" + elif [[ "$ENVROOT" == "[unavailable]" ]]; then + ENVROOT="" + fi + + if [[ -z ${CMD+x} ]]; then + CMD="$DRIVEPREFIX/c/windows/system32/cmd.exe" + fi + + if [[ -z ${WINTEMP+x} ]]; then + wintemp_win="$($CMD /q /c echo %TEMP% 2>/dev/null | tr -d \\n\\r)" + WINTEMP="$($PATHTOOL -u "$wintemp_win")" + fi + + # Make regexp tests case insensitive + shopt -s nocasematch + # Prohibit msys2 from meddling with paths + export MSYS2_ARG_CONV_EXCL="*" + # Make sure WSL gets a copy of the path + export WSLENV=PATH/l +} + +# Cleanup handling +TEMPDIRS="" +trap "cleanup" EXIT +function cleanup() { + if [[ "$TEMPDIRS" != "" ]]; then + rm -rf $TEMPDIRS + fi +} + +# Import a single path +# Result: imported path returned in $result +function import_path() { + path="$1" + # Strip trailing and leading space + path="${path#"${path%%[![:space:]]*}"}" + path="${path%"${path##*[![:space:]]}"}" + + if [[ $path =~ ^.:[/\\].*$ ]] || [[ "$path" =~ ^"$ENVROOT"\\.*$ ]] ; then + # We got a Windows path as input; use pathtool to convert to unix path + path="$($PATHTOOL -u "$path")" + # Path will now be absolute + else + # Make path absolute, and resolve embedded '..' in path + dirpart="$(dirname "$path")" + dirpart="$(cd "$dirpart" 2>&1 > /dev/null && pwd)" + if [[ $? -ne 0 ]]; then + if [[ $QUIET != true ]]; then + echo fixpath: failure: Directory containing path "'"$path"'" does not exist >&2 + fi + if [[ $IGNOREFAILURES != true ]]; then + exit 1 + else + path="" + fi + else + basepart="$(basename "$path")" + if [[ $dirpart == / ]]; then + # Avoid double leading / + dirpart="" + fi + if [[ $basepart == / ]]; then + # Avoid trailing / + basepart="" + fi + path="$dirpart/$basepart" + fi + fi + + if [[ "$path" != "" ]]; then + # Now turn it into a windows path + winpath="$($PATHTOOL -w "$path" 2>/dev/null)" + # If it fails, try again with an added .exe (needed on WSL) + if [[ $? -ne 0 ]]; then + winpath="$($PATHTOOL -w "$path.exe" 2>/dev/null)" + fi + if [[ $? -eq 0 ]]; then + if [[ ! "$winpath" =~ ^"$ENVROOT"\\.*$ ]] ; then + # If it is not in envroot, it's a generic windows path + if [[ ! $winpath =~ ^[-_.:\\a-zA-Z0-9]*$ ]] ; then + # Path has forbidden characters, rewrite as short name + # This monster of a command uses the %~s support from cmd.exe to + # reliably convert to short paths on all winenvs. + shortpath="$($CMD /q /c for %I in \( "$winpath" \) do echo %~sI 2>/dev/null | tr -d \\n\\r)" + path="$($PATHTOOL -u "$shortpath")" + # Path is now unix style, based on short name + fi + # Make it lower case + path="$(echo "$path" | tr [:upper:] [:lower:])" + fi + else + # On WSL1, PATHTOOL will fail for files in envroot. If the unix path + # exists, we assume that $path is a valid unix path. + + if [[ ! -e $path ]]; then + if [[ -e $path.exe ]]; then + path="$path.exe" + else + if [[ $QUIET != true ]]; then + echo fixpath: warning: Path "'"$path"'" does not exist >&2 + fi + # This is not a fatal error, maybe the path will be created later on + fi + fi + fi + fi + + if [[ "$path" =~ " " ]]; then + # Our conversion attempts failed. Perhaps the path did not exists, and thus + # we could not convert it to short name. + if [[ $QUIET != true ]]; then + echo fixpath: failure: Path "'"$path"'" contains space >&2 + fi + if [[ $IGNOREFAILURES != true ]]; then + exit 1 + else + path="" + fi + fi + + result="$path" +} + +# Import a single path, or a pathlist in Windows style (i.e. ; separated) +# Incoming paths can be in Windows or unix style. +# Returns in $result a converted path or path list +function import_command_line() { + imported="" + + old_ifs="$IFS" + IFS=";" + for arg in $1; do + if ! [[ $arg =~ ^" "+$ ]]; then + import_path "$arg" + + if [[ "$result" != "" && "$imported" = "" ]]; then + imported="$result" + else + imported="$imported:$result" + fi + fi + done + IFS="$old_ifs" + + result="$imported" +} + +# If argument seems to be colon separated path list, and all elements +# are possible to convert to paths, make a windows path list +# Return 0 if successful with converted path list in $result, or +# 1 if it was not a path list. +function convert_pathlist() { + converted_list="" + pathlist_args="$1" + + IFS=':' read -r -a arg_array <<< "$pathlist_args" + for arg in "${arg_array[@]}"; do + winpath="" + # Start looking for drive prefix + if [[ $arg =~ ^($DRIVEPREFIX/)([a-z])(/[^/]+.*$) ]] ; then + winpath="${BASH_REMATCH[2]}:${BASH_REMATCH[3]}" + # Change slash to backslash (or vice versa if mixed mode) + if [[ $MIXEDMODE != true ]]; then + winpath="${winpath//'/'/'\'}" + else + winpath="${winpath//'\'/'/'}" + fi + elif [[ $arg =~ ^(/[-_.*a-zA-Z0-9]+(/[-_.*a-zA-Z0-9]+)+.*$) ]] ; then + # This looks like a unix path, like /foo/bar + pathmatch="${BASH_REMATCH[1]}" + if [[ $ENVROOT == "" ]]; then + if [[ $QUIET != true ]]; then + echo fixpath: failure: Path "'"$pathmatch"'" cannot be converted to Windows path >&2 + fi + exit 1 + fi + winpath="$ENVROOT$pathmatch" + # Change slash to backslash (or vice versa if mixed mode) + if [[ $MIXEDMODE != true ]]; then + winpath="${winpath//'/'/'\'}" + else + winpath="${winpath//'\'/'/'}" + fi + else + # This does not look like a path, so assume this is not a proper pathlist. + # Flag this to caller. + result="" + return 1 + fi + + if [[ "$converted_list" = "" ]]; then + converted_list="$winpath" + else + converted_list="$converted_list;$winpath" + fi + done + + result="$converted_list" + return 0 +} + +# The central conversion function. Convert a single argument, so that any +# contained paths are converted to Windows style paths. Result is returned +# in $result. If it is a path list, convert it as one. +function convert_path() { + if [[ $1 =~ : ]]; then + convert_pathlist "$1" + if [[ $? -eq 0 ]]; then + return 0 + fi + # Not all elements was possible to convert to Windows paths, so we + # presume it is not a pathlist. Continue using normal conversion. + fi + + arg="$1" + winpath="" + # Start looking for drive prefix. Also allow /xxxx prefixes (typically options + # for Visual Studio tools), and embedded file:// URIs. + if [[ $arg =~ ^([^/]*|.*file://|/[a-zA-Z:]{1,3}:?)($DRIVEPREFIX/)([a-z])(/[^/]+.*$) ]] ; then + prefix="${BASH_REMATCH[1]}" + winpath="${BASH_REMATCH[3]}:${BASH_REMATCH[4]}" + # Change slash to backslash (or vice versa if mixed mode) + if [[ $MIXEDMODE != true ]]; then + winpath="${winpath//'/'/'\'}" + else + winpath="${winpath//'\'/'/'}" + fi + elif [[ $arg =~ ^([^/]*|(.*file://))(/([-_.a-zA-Z0-9]+)(/[-_.a-zA-Z0-9]+)+)(.*)?$ ]] ; then + # This looks like a unix path, like /foo/bar. Also embedded file:// URIs. + prefix="${BASH_REMATCH[1]}" + pathmatch="${BASH_REMATCH[3]}" + firstdir="${BASH_REMATCH[4]}" + suffix="${BASH_REMATCH[6]}" + + # We only believe this is a path if the first part is an existing directory + if [[ -d "/$firstdir" ]]; then + if [[ $ENVROOT == "" ]]; then + if [[ $QUIET != true ]]; then + echo fixpath: failure: Path "'"$pathmatch"'" cannot be converted to Windows path >&2 + fi + exit 1 + fi + winpath="$ENVROOT$pathmatch" + # Change slash to backslash (or vice versa if mixed mode) + if [[ $MIXEDMODE != true ]]; then + winpath="${winpath//'/'/'\'}" + else + winpath="${winpath//'\'/'/'}" + fi + winpath="$winpath$suffix" + fi + fi + + if [[ $winpath != "" ]]; then + result="$prefix$winpath" + else + # Return the arg unchanged + result="$arg" + fi +} + +# Treat $1 as name of a file containg paths. Convert those paths to Windows style, +# in a new temporary file, and return a string "@" pointing to that +# new file. +function convert_at_file() { + infile="$1" + if [[ -e $infile ]] ; then + tempdir=$(mktemp -dt fixpath.XXXXXX -p "$WINTEMP") + TEMPDIRS="$TEMPDIRS $tempdir" + + while read line; do + convert_path "$line" + echo "$result" >> $tempdir/atfile + done < $infile + convert_path "$tempdir/atfile" + result="@$result" + else + result="@$infile" + fi +} + +# Convert an entire command line, replacing all unix paths with Windows paths, +# and all unix-style path lists (colon separated) with Windows-style (semicolon +# separated). +function print_command_line() { + converted_args="" + for arg in "$@" ; do + if [[ $arg =~ ^@(.*$) ]] ; then + # This is an @-file with paths that need converting + convert_at_file "${BASH_REMATCH[1]}" + else + convert_path "$arg" + fi + converted_args="$converted_args$result " + done + result="${converted_args% }" +} + +# Check if the winenv will allow us to start a Windows program when we are +# standing in the current directory +function verify_current_dir() { + arg="$PWD" + if [[ $arg =~ ^($DRIVEPREFIX/)([a-z])(/[^/]+.*$) ]] ; then + return 0 + elif [[ $arg =~ ^(/[^/]+.*$) ]] ; then + if [[ $ENVROOT == "" || $ENVROOT =~ ^\\\\.* ]]; then + # This is a WSL1 or WSL2 environment + return 1 + fi + return 0 + fi + # This should not happen + return 1 +} + +# The core functionality of fixpath. Take the given command line, and convert +# it and execute it, so that all paths are converted to Windows style. +# The return code is the return code of the executed command. +function exec_command_line() { + # Check that Windows can handle our current directory (only an issue for WSL) + verify_current_dir + + if [[ $? -ne 0 ]]; then + # WSL1 will just forcefully put us in C:\Windows\System32 if we execute this from + # a unix directory. WSL2 will do the same, and print a warning. In both cases, + # we prefer to take control. + cd "$WINTEMP" + if [[ $QUIET != true ]]; then + echo fixpath: warning: Changing directory to $WINTEMP >&2 + fi + fi + + collected_args=() + command="" + for arg in "$@" ; do + if [[ $command == "" ]]; then + # We have not yet located the command to run + if [[ $arg =~ ^(.*)=(.*)$ ]]; then + # It's a leading env variable assignment (FOO=bar) + key="${BASH_REMATCH[1]}" + arg="${BASH_REMATCH[2]}" + convert_path "$arg" + # Set the variable to the converted result + export $key="$result" + # While this is only needed on WSL, it does not hurt to do everywhere + export WSLENV=$WSLENV:$key/w + else + # The actual command will be executed by bash, so don't convert it + command="$arg" + fi + else + # Now we are collecting arguments; they all need converting + if [[ $arg =~ ^@(.*$) ]] ; then + # This is an @-file with paths that need converting + convert_at_file "${BASH_REMATCH[1]}" + else + convert_path "$arg" + fi + collected_args=("${collected_args[@]}" "$result") + fi + done + + # Now execute it + if [[ -v DEBUG_FIXPATH ]]; then + echo fixpath: debug: input: "$@" >&2 + echo fixpath: debug: output: "$command" "${collected_args[@]}" >&2 + fi + + if [[ ! -e "$command" ]]; then + if [[ -e "$command.exe" ]]; then + command="$command.exe" + fi + fi + + if [[ $ENVROOT != "" || ! -x /bin/grep ]]; then + "$command" "${collected_args[@]}" + else + # For WSL1, automatically strip away warnings from WSLENV=PATH/l + "$command" "${collected_args[@]}" 2> >(/bin/grep -v "ERROR: UtilTranslatePathList" 1>&2) + fi +} + +# Check that the input represents a path that is reachable from Windows +function verify_command_line() { + arg="$1" + if [[ $arg =~ ^($DRIVEPREFIX/)([a-z])(/[^/]+.*$) ]] ; then + return 0 + elif [[ $arg =~ ^(/[^/]+/[^/]+.*$) ]] ; then + if [[ $ENVROOT != "" ]]; then + return 0 + fi + fi + return 1 +} + +#### MAIN FUNCTION + +setup "$@" +# Shift away the options processed in setup +shift $((OPTIND)) + +if [[ "$ACTION" == "import" ]] ; then + import_command_line "$@" + echo "$result" +elif [[ "$ACTION" == "print" ]] ; then + print_command_line "$@" + echo "$result" +elif [[ "$ACTION" == "exec" ]] ; then + exec_command_line "$@" + # Propagate exit code + exit $? +elif [[ "$ACTION" == "verify" ]] ; then + verify_command_line "$@" + exit $? +else + if [[ $QUIET != true ]]; then + echo Unknown operation: "$ACTION" >&2 + echo Supported operations: import print exec verify >&2 + fi + exit 2 +fi diff --git a/make/src/native/fixpath.c b/make/src/native/fixpath.c deleted file mode 100644 index 73927d4fcca..00000000000 --- a/make/src/native/fixpath.c +++ /dev/null @@ -1,594 +0,0 @@ -/* - * Copyright (c) 2011, 2020, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the "Classpath" exception as provided - * by Oracle in the LICENSE file that accompanied this code. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -#include -#include -#include -#include -#include -#include - -void report_error(char const * msg) -{ - LPTSTR lpMsgBuf; - DWORD dw = GetLastError(); - - FormatMessage( - FORMAT_MESSAGE_ALLOCATE_BUFFER | - FORMAT_MESSAGE_FROM_SYSTEM | - FORMAT_MESSAGE_IGNORE_INSERTS, - NULL, - dw, - MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - (LPTSTR) &lpMsgBuf, - 0, - NULL); - - fprintf(stderr, - "%s Failed with error %d: %s\n", - msg, dw, lpMsgBuf); - - LocalFree(lpMsgBuf); -} - -/* - * Test if pos points to /prefix/_/ where _ can - * be any character. - */ -int is_prefix_here(int pos, char const *in, int len, const char* prefix) -{ - // Length of c/ is 2 - int prefix_size = strlen(prefix); - if (pos+prefix_size+2 > len) return 0; - if (in[pos+prefix_size+1]=='/') { - return strncmp(in + pos, prefix, prefix_size) == 0; - } - return 0; -} - -/* - * Replace /cygdrive/_/ with _:/ - * Works in place since drive letter is always - * shorter than /cygdrive/ - */ -char *replace_cygdrive_cygwin(char const *in) -{ - size_t len = strlen(in); - char *out = (char*) malloc(len+1); - int i,j; - - if (len < 12) { - memmove(out, in, len + 1); - return out; - } - - for (i = 0, j = 0; i *bl) { - *bl *= 2; - *b = (char*) realloc(*b, *bl); - } - memcpy(*b+*u, add, addlen); - *u += addlen; -} - -/* - * Creates a new string from in where the first occurrence of sub is - * replaced by rep. - */ -char *replace_substring(char *in, char *sub, char *rep) -{ - int in_len = strlen(in); - int sub_len = strlen(sub); - int rep_len = strlen(rep); - char *out = (char *) malloc(in_len - sub_len + rep_len + 1); - char *p; - - if (!(p = strstr(in, sub))) { - // If sub isn't a substring of in, just return in. - return in; - } - - // Copy characters from beginning of in to start of sub. - strncpy(out, in, p - in); - out[p - in] = '\0'; - - sprintf(out + (p - in), "%s%s", rep, p + sub_len); - - return out; -} - -char* msys_path_list; // @-separated list of paths prefix to look for -char* msys_path_list_end; // Points to last \0 in msys_path_list. - -void setup_msys_path_list(char const * argument) -{ - char* p; - char* drive_letter_pos; - - msys_path_list = strdup(&argument[2]); - msys_path_list_end = &msys_path_list[strlen(msys_path_list)]; - - // Convert all at-sign (@) in path list to \0. - // @ was chosen as separator to minimize risk of other tools messing around with it - p = msys_path_list; - do { - if (p[1] == ':') { - // msys has mangled our path list, restore it from c:/... to /c/... - drive_letter_pos = p+1; - *drive_letter_pos = *p; - *p = '/'; - } - - // Look for an @ in the list - p = strchr(p, '@'); - if (p != NULL) { - *p = '\0'; - p++; - } - } while (p != NULL); -} - -char *replace_cygdrive_msys(char const *in) -{ - char* str; - char* prefix; - char* p; - - str = strdup(in); - - // For each prefix in the path list, search for it and replace /c/... with c:/... - for (prefix = msys_path_list; prefix < msys_path_list_end && prefix != NULL; prefix += strlen(prefix)+1) { - p=str; - while ((p = strstr(p, prefix))) { - char* drive_letter = p+1; - *p = *drive_letter; - *drive_letter = ':'; - p++; - } - } - - return str; -} - -/* - * Replace /mnt/_/ with _:/ - * Works in place since drive letter is always - * shorter than /mnt/ - */ -char *replace_cygdrive_wsl(char const *in) -{ - size_t len = strlen(in); - char *out = (char*) malloc(len+1); - int i,j; - - if (len < 7) { - memmove(out, in, len + 1); - return out; - } - - for (i = 0, j = 0; i 0) { - append(&buffer, &buflen, &used, block, blocklen); - } - buffer[used] = 0; - if (debug_fixpath) { - fprintf(stderr, "fixpath input from @-file %s: %s\n", &in[1], buffer); - } - fixed = replace_cygdrive(buffer); - if (debug_fixpath) { - fprintf(stderr, "fixpath converted to @-file %s is: %s\n", name, fixed); - } - fwrite(fixed, strlen(fixed), 1, atout); - fclose(atin); - fclose(atout); - free(fixed); - free(buffer); - files_to_delete[num_files_to_delete] = (char*) malloc(strlen(name)+1); - strcpy(files_to_delete[num_files_to_delete], name); - num_files_to_delete++; - atname = (char*) malloc(strlen(name)+2); - atname[0] = '@'; - strcpy(atname+1, name); - return atname; -} - -// given an argument, convert it to the windows command line safe quoted version -// using rules from: -// http://blogs.msdn.com/b/twistylittlepassagesallalike/archive/2011/04/23/everyone-quotes-arguments-the-wrong-way.aspx -// caller is responsible for freeing both input and output. -char * quote_arg(char const * in_arg) { - char *quoted = NULL; - char *current = quoted; - int pass; - - if (strlen(in_arg) == 0) { - // empty string? explicitly quote it. - return _strdup("\"\""); - } - - if (strpbrk(in_arg, " \t\n\v\r\\\"") == NULL) { - return _strdup(in_arg); - } - - // process the arg twice. Once to calculate the size and then to copy it. - for (pass=1; pass<=2; pass++) { - char const *arg = in_arg; - - // initial " - if (pass == 2) { - *current = '\"'; - } - current++; - - // process string to be quoted until NUL - do { - int escapes = 0; - - while (*arg == '\\') { - // count escapes. - escapes++; - arg++; - } - - if (*arg == '\0') { - // escape the escapes before final " - escapes *= 2; - } else if (*arg == '"') { - // escape the escapes and the " - escapes = escapes * 2 + 1; - } else { - // escapes aren't special, just echo them. - } - - // emit some escapes - while (escapes > 0) { - if (pass == 2) { - *current = '\\'; - } - current++; - escapes--; - } - - // and the current char - if (pass == 2) { - *current = *arg; - } - current++; - } while (*arg++ != '\0'); - - // allocate the buffer - if (pass == 1) { - size_t alloc = (size_t) (current - quoted + (ptrdiff_t) 2); - current = quoted = (char*) calloc(alloc, sizeof(char)); - } - } - - // final " and \0 - *(current - 1) = '"'; - *current = '\0'; - - return quoted; -} - -int main(int argc, char const ** argv) -{ - STARTUPINFO si; - PROCESS_INFORMATION pi; - unsigned short rc; - - char *line; - char *current; - int i, cmd; - DWORD exitCode = 0; - DWORD processFlags = 0; - BOOL processInheritHandles = TRUE; - BOOL waitForChild = TRUE; - char* fixpathPath; - - debug_fixpath = (getenv("DEBUG_FIXPATH") != NULL); - - if (argc<2 || argv[1][0] != '-' || (argv[1][1] != 'c' && argv[1][1] != 'm' && argv[1][1] != 'w')) { - fprintf(stderr, "Usage: fixpath -c|m|w [--detach] /cygdrive/c/WINDOWS/notepad.exe [/cygdrive/c/x/test.txt|@/cygdrive/c/x/atfile]\n"); - exit(0); - } - - if (debug_fixpath) { - char const * cmdline = GetCommandLine(); - fprintf(stderr, "fixpath input line >%s<\n", strstr(cmdline, argv[1])); - } - - if (argv[1][1] == 'c' && argv[1][2] == '\0') { - if (debug_fixpath) { - fprintf(stderr, "fixpath using cygwin mode\n"); - } - replace_cygdrive = replace_cygdrive_cygwin; - } else if (argv[1][1] == 'm') { - if (debug_fixpath) { - fprintf(stderr, "fixpath using msys mode, with path list: %s\n", &argv[1][2]); - } - setup_msys_path_list(argv[1]); - replace_cygdrive = replace_cygdrive_msys; - } else if (argv[1][1] == 'w') { - if (debug_fixpath) { - fprintf(stderr, "fixpath using wsl mode, with path list: %s\n", &argv[1][2]); - } - replace_cygdrive = replace_cygdrive_wsl; - } else { - fprintf(stderr, "fixpath Unknown mode: %s\n", argv[1]); - exit(-1); - } - - if (argv[2][0] == '-') { - if (strcmp(argv[2], "--detach") == 0) { - if (debug_fixpath) { - fprintf(stderr, "fixpath in detached mode\n"); - } - processFlags |= DETACHED_PROCESS; - processInheritHandles = FALSE; - waitForChild = FALSE; - } else { - fprintf(stderr, "fixpath Unknown argument: %s\n", argv[2]); - exit(-1); - } - i = 3; - } else { - i = 2; - } - - // handle assignments - while (i < argc) { - char const * assignment = strchr(argv[i], '='); - if (assignment != NULL && assignment != argv[i]) { - size_t var_len = (size_t) (assignment - argv[i] + (ptrdiff_t) 1); - char *var = (char *) calloc(var_len, sizeof(char)); - char *val = replace_cygdrive(assignment + 1); - memmove(var, argv[i], var_len); - var[var_len - 1] = '\0'; - strupr(var); - - if (debug_fixpath) { - fprintf(stderr, "fixpath setting var >%s< to >%s<\n", var, val); - } - - rc = SetEnvironmentVariable(var, val); - if (!rc) { - // Could not set var for some reason. Try to report why. - const int msg_len = 80 + var_len + strlen(val); - char * msg = (char *) alloca(msg_len); - _snprintf_s(msg, msg_len, _TRUNCATE, "Could not set environment variable [%s=%s]", var, val); - report_error(msg); - exit(1); - } - free(var); - free(val); - } else { - // no more assignments; - break; - } - i++; - } - - // remember index of the command - cmd = i; - - // handle command and it's args. - while (i < argc) { - char const *replaced = replace_cygdrive(argv[i]); - if (replaced[0] == '@') { - if (waitForChild == FALSE) { - fprintf(stderr, "fixpath Cannot use @-files in detached mode: %s\n", replaced); - exit(1); - } - // Found at-file! Fix it! - replaced = fix_at_file(replaced); - } - argv[i] = quote_arg(replaced); - i++; - } - - // determine the length of the line - line = NULL; - // args - for (i = cmd; i < argc; i++) { - line += (ptrdiff_t) strlen(argv[i]); - } - // spaces and null - line += (ptrdiff_t) (argc - cmd + 1); - // allocate - line = (char*) calloc(line - (char*) NULL, sizeof(char)); - - // copy in args. - current = line; - for (i = cmd; i < argc; i++) { - ptrdiff_t len = strlen(argv[i]); - if (i != cmd) { - *current++ = ' '; - } - memmove(current, argv[i], len); - current += len; - } - *current = '\0'; - - if (debug_fixpath) { - fprintf(stderr, "fixpath converted line >%s<\n", line); - } - - if (cmd == argc) { - if (debug_fixpath) { - fprintf(stderr, "fixpath no command provided!\n"); - } - exit(0); - } - - ZeroMemory(&si, sizeof(si)); - si.cb=sizeof(si); - ZeroMemory(&pi, sizeof(pi)); - - fflush(stderr); - fflush(stdout); - - fixpathPath = calloc(32767, sizeof(char)); - rc = GetEnvironmentVariable("FIXPATH_PATH", fixpathPath, 32767); - if (rc) { - if (debug_fixpath) { - fprintf(stderr, "Setting Path to FIXPATH_PATH: %s\n", fixpathPath); - } - rc = SetEnvironmentVariable("Path", fixpathPath); - if (!rc) { - // Could not set Path for some reason. Try to report why. - const int msg_len = 80 + strlen(fixpathPath); - char * msg = (char *)alloca(msg_len); - _snprintf_s(msg, msg_len, _TRUNCATE, "Could not set environment variable [Path=%s]", fixpathPath); - report_error(msg); - exit(1); - } - } - - rc = CreateProcess(NULL, - line, - 0, - 0, - processInheritHandles, - processFlags, - NULL, - NULL, - &si, - &pi); - if (!rc) { - // Could not start process for some reason. Try to report why: - report_error("Could not start process!"); - exit(126); - } - - if (waitForChild == TRUE) { - WaitForSingleObject(pi.hProcess, INFINITE); - GetExitCodeProcess(pi.hProcess, &exitCode); - - if (debug_fixpath) { - for (i=0; i