8257679: Improved unix compatibility layer in Windows build (winenv)

Reviewed-by: erikj, jvernee, burban
2020-12-07 15:55:53 +00:00 · 2020-12-07 15:55:53 +00:00 · d29c78da19
commit d29c78da19
parent 74be819088
48 changed files with 1718 additions and 2302 deletions
--- 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
--- 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)

--- 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))

--- 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

--- 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), \
--- 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

 ################################################################################
--- 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'

--- 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'
--- 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
--- 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
 ])
--- 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)

--- 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
--- 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

--- 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
--- 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])
--- 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@"
--- 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
--- 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"
--- 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}"
--- 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],
--- 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"
--- 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)
--- 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
--- 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)
 ])

 ################################################################################
--- 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@
--- 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)`
--- a/make/autoconf/toolchain_microsoft.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)
--- 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)
-])
--- 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
 ])
-
--- a/make/autoconf/util_windows.m4
+++ b/make/autoconf/util_windows.m4
@ -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])
-])
-
--- 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) \
--- 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

--- 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) ; ) \
--- 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
--- 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

 ################################################################################
--- 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-";
--- 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)) \
 )
--- 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)

--- 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)))
--- 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' \
--- 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 {
--- 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
--- 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 \
--- 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
--- a/make/scripts/windowsShortName.bat
+++ b/make/scripts/windowsShortName.bat
@ -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
--- a/make/scripts/fixpath.sh
+++ 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 "@<temp file>" 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
--- a/make/src/native/fixpath.c
+++ b/make/src/native/fixpath.c
@ -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 <Windows.h>
-#include <stdbool.h>
-#include <io.h>
-#include <stdio.h>
-#include <string.h>
-#include <malloc.h>
-
-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<len;) {
-    if (is_prefix_here(i, in, len, "/cygdrive/")) {
-      out[j++] = in[i+10];
-      out[j++] = ':';
-      i+=11;
-    } else {
-      out[j] = in[i];
-      i++;
-      j++;
-    }
-  }
-  out[j] = '\0';
-  return out;
-}
-
-void append(char **b, size_t *bl, size_t *u, char *add, size_t addlen)
-{
-  while ((addlen+*u+1) > *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<len;) {
-    if (is_prefix_here(i, in, len, "/mnt/")) {
-      out[j++] = in[i+5];
-      out[j++] = ':';
-      i+=6;
-    } else {
-      out[j] = in[i];
-      i++;
-      j++;
-    }
-  }
-  out[j] = '\0';
-  return out;
-}
-
-char*(*replace_cygdrive)(char const *in) = NULL;
-bool debug_fixpath = false;
-
-char *files_to_delete[1024];
-int num_files_to_delete = 0;
-
-char *fix_at_file(char const *in)
-{
-  char *tmpdir;
-  char name[2048];
-  char *atname;
-  char *buffer;
-  size_t buflen=65536;
-  size_t used=0;
-  size_t len;
-  int rc;
-  FILE *atout;
-  FILE *atin;
-  char block[2048];
-  size_t blocklen;
-  char *fixed;
-
-  atin = fopen(in+1, "r");
-  if (atin == NULL) {
-    fprintf(stderr, "Could not read at file %s\n", in+1);
-    exit(-1);
-  }
-
-  tmpdir = getenv("TEMP");
-  if (tmpdir == NULL) {
-#if _WIN64
-    tmpdir = "c:/cygwin64/tmp";
-#else
-    tmpdir = "c:/cygwin/tmp";
-#endif
-  }
-  _snprintf(name, sizeof(name), "%s\\atfile_XXXXXX", tmpdir);
-
-  rc = _mktemp_s(name, strlen(name)+1);
-  if (rc) {
-    fprintf(stderr, "Could not create temporary file name for at file!\n");
-    exit(-1);
-  }
-
-  atout = fopen(name, "w");
-  if (atout == NULL) {
-    fprintf(stderr, "Could not open temporary file for writing! %s\n", name);
-    exit(-1);
-  }
-
-  buffer = (char*) malloc(buflen);
-  while ((blocklen = fread(block, 1, sizeof(block), atin)) > 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<path@path@...> [--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<num_files_to_delete; ++i) {
-          fprintf(stderr, "fixpath Not deleting temporary file %s\n",
-                  files_to_delete[i]);
-        }
-      } else {
-        for (i=0; i<num_files_to_delete; ++i) {
-          remove(files_to_delete[i]);
-        }
-      }
-
-      if (exitCode != 0) {
-        if (debug_fixpath) {
-          fprintf(stderr, "fixpath exit code %d\n",
-                  exitCode);
-        }
-      }
-    } else {
-      if (debug_fixpath) {
-        fprintf(stderr, "fixpath Not waiting for child process");
-      }
-    }
-
-    exit(exitCode);
-}
--- a/src/hotspot/share/adlc/main.cpp
+++ b/src/hotspot/share/adlc/main.cpp
@ -37,7 +37,7 @@ const char* get_basename(const char* filename) {
  const char *basename = filename;
  const char *cp;
  for (cp = basename; *cp; cp++) {
-    if (*cp == '/') {
+    if (*cp == '/' || *cp == '\\') {
      basename = cp+1;
    }
  }