Merge to tag jdk-28+12

doc/building.html

@@ -146,6 +146,7 @@ <h1 class="title">Building the JDK</h1>
 <li><a href="#virus-checking" id="toc-virus-checking">Virus
 Checking</a></li>
 <li><a href="#ccache" id="toc-ccache">Ccache</a></li>
+<li><a href="#sccache" id="toc-sccache">Sccache</a></li>
 <li><a href="#precompiled-headers"
 id="toc-precompiled-headers">Precompiled Headers</a></li>
 <li><a href="#icecc-icecream" id="toc-icecc-icecream">Icecc /
@@ -365,11 +366,13 @@ <h3 id="building-on-aarch64">Building on aarch64</h3>
 also possible to use <a href="#cross-compiling">cross-compiling</a>.</p>
 <h4 id="branch-protection">Branch Protection</h4>
 <p>In order to use Branch Protection features in the VM,
-<code>--enable-branch-protection</code> must be used. This option
-requires C++ compiler support (GCC 9.1.0+ or Clang 10+). The resulting
-build can be run on both machines with and without support for branch
-protection in hardware. Branch Protection is only supported for Linux
-targets.</p>
+<code>--enable-branch-protection</code> must be used. This option requires C++
+compiler support for <code>-mbranch-protection=standard</code> in GCC 9.1.0+ or
+Clang 10+ on Linux/AArch64 or for <code>/guard:signret</code> in Visual Studio
+2019+ on Windows/ARM64. The resulting build can be run on both machines with and
+without support for branch protection in hardware. Branch Protection is fully
+supported for the Linux/AArch64 target and only partially supported for the
+Windows/ARM64 targets.</p>
 <h3 id="building-on-32-bit-arm">Building on 32-bit ARM</h3>
 <p>This is not recommended. Instead, see the section on <a
 href="#cross-compiling">Cross-compiling</a>.</p>
@@ -1814,6 +1817,14 @@ <h3 id="ccache">Ccache</h3>
 often rebuild the same sources. Your mileage may vary however, so we
 recommend evaluating it for yourself. To enable it, make sure it's on
 the path and configure with <code>--enable-ccache</code>.</p>
+<h3 id="sccache">Sccache</h3>
+<p>The JDK build supports building with sccache when using gcc, clang, or
+Microsoft toolchains.  To enable it, make sure the sccache binary is on the path
+(or specify the path to the binary using the <code>SCCACHE</code> argument to
+the configure script) and configure with <code>--enable-sccache</code>.  To
+optionally specify where sccache stores its cache files, use
+<code>--with-sccache-dir</code>.  Precompiled headers are disabled when sccache
+is enabled.</p>
 <h3 id="precompiled-headers">Precompiled Headers</h3>
 <p>By default, the Hotspot build uses pre-compiled headers (PCH) on the
 toolchains were it is properly supported (clang, gcc, and Visual

doc/building.md

@@ -171,9 +171,11 @@ possible to use [cross-compiling](#cross-compiling).
 
 In order to use Branch Protection features in the VM,
 `--enable-branch-protection` must be used. This option requires C++ compiler
-support (GCC 9.1.0+ or Clang 10+). The resulting build can be run on both
-machines with and without support for branch protection in hardware. Branch
-Protection is only supported for Linux targets.
+support for `-mbranch-protection=standard` in GCC 9.1.0+ or Clang 10+ on
+Linux/AArch64 or for `/guard:signret` in Visual Studio 2019+ on Windows/ARM64.
+The resulting build can be run on both machines with and without support for
+branch protection in hardware. Branch Protection is fully supported for the
+Linux/AArch64 target and only partially supported for the Windows/ARM64 target.
 
 ### Building on 32-bit ARM
 
@@ -1555,6 +1557,15 @@ the same sources. Your mileage may vary however, so we recommend evaluating it
 for yourself. To enable it, make sure it's on the path and configure with
 `--enable-ccache`.
 
+### Sccache
+
+The JDK build supports building with sccache when using gcc, clang, or Microsoft
+toolchains.  To enable it, make sure the sccache binary is on the path (or
+specify the path to the binary using the `SCCACHE` argument to the configure
+script) and configure with `--enable-sccache`.  To optionally specify where
+sccache stores its cache files, use `--with-sccache-dir`.  Precompiled headers
+are disabled when sccache is enabled.
+
 ### Precompiled Headers
 
 By default, the Hotspot build uses pre-compiled headers (PCH) on the toolchains

make/Main.gmk

@@ -1420,6 +1420,9 @@ clean: $(CLEAN_DIR_TARGETS)
 clean-docs:
 	$(call CleanDocs)
 
+clean-microbenchmark:
+	$(call CleanMicrobenchmark)
+
 clean-compile-commands:
 	$(call CleanMakeSupportDir,compile-commands)
 
@@ -1468,7 +1471,8 @@ dist-clean: clean
 	)
 	$(ECHO) Cleaned everything, you will have to re-run configure.
 
-ALL_TARGETS += clean clean-docs clean-compile-commands dist-clean $(CLEAN_DIR_TARGETS) \
+ALL_TARGETS += clean clean-docs clean-microbenchmark clean-compile-commands \
+    dist-clean $(CLEAN_DIR_TARGETS) \
     $(CLEAN_SUPPORT_DIR_TARGETS) $(CLEAN_TEST_TARGETS) $(CLEAN_PHASE_TARGETS) \
     $(CLEAN_MODULE_TARGETS) $(CLEAN_MODULE_PHASE_TARGETS)
 

make/MainSupport.gmk

@@ -65,6 +65,14 @@ define CleanDocs
 	@$(ECHO) " done"
 endef
 
+define CleanMicrobenchmark
+	@$(PRINTF) "Cleaning microbenchmark build artifacts ..."
+	@$(ECHO) "" $(LOG_DEBUG)
+	$(RM) -r $(SUPPORT_OUTPUTDIR)/test/micro
+	$(RM) -r $(TEST_IMAGE_DIR)/micro
+	@$(ECHO) " done"
+endef
+
 # Cleans the dir given as $1
 define CleanDir
 	@$(PRINTF) "Cleaning %s build artifacts ..." "$(strip $1)"

make/RunTests.gmk

@@ -1054,9 +1054,11 @@ define SetupRunJtregTestBody
   $1_JTREG_BASIC_OPTIONS += -timeoutFactor:$$(JTREG_TIMEOUT_FACTOR)
 
   clean-outputdirs-$1:
-	$$(call LogWarn, Clean up dirs for $1)
-	$$(RM) -r $$($1_TEST_SUPPORT_DIR)
-	$$(RM) -r $$($1_TEST_RESULTS_DIR)
+        ifeq ($(JTREG_STATUS),)
+	  $$(call LogWarn, Clean up dirs for $1)
+	  $$(RM) -r $$($1_TEST_SUPPORT_DIR)
+	  $$(RM) -r $$($1_TEST_RESULTS_DIR)
+        endif
 
   $1_COMMAND_LINE := \
       $$(JTREG_JAVA) $$($1_JTREG_LAUNCHER_OPTIONS) \

make/autoconf/build-performance.m4

@@ -252,6 +252,109 @@ AC_DEFUN([BPERF_SETUP_CCACHE_USAGE],
   fi
 ])
 
+AC_DEFUN([BPERF_SETUP_SCCACHE],
+[
+  # Check if sccache is available
+  SCCACHE_AVAILABLE=true
+
+  UTIL_LOOKUP_TOOLCHAIN_PROGS(SCCACHE, sccache)
+
+  AC_MSG_CHECKING([if sccache is available])
+  if test "x$TOOLCHAIN_TYPE" != "xgcc" && test "x$TOOLCHAIN_TYPE" != "xclang" && \
+      test "x$TOOLCHAIN_TYPE" != "xmicrosoft"; then
+    AC_MSG_RESULT([no, not supported for toolchain type $TOOLCHAIN_TYPE])
+    SCCACHE_AVAILABLE=false
+  elif test "x$SCCACHE" = "x"; then
+    AC_MSG_RESULT([no, sccache binary missing or not executable])
+    SCCACHE_AVAILABLE=false
+  else
+    AC_MSG_RESULT([yes])
+  fi
+
+  SCCACHE_STATUS=""
+  UTIL_ARG_ENABLE(NAME: sccache, DEFAULT: false, AVAILABLE: $SCCACHE_AVAILABLE,
+      DESC: [enable using sccache to speed up recompilations],
+      CHECKING_MSG: [if sccache is enabled],
+      IF_ENABLED: [
+        if test "x$CCACHE" != x; then
+          AC_MSG_ERROR([Cannot enable both ccache and sccache])
+        fi
+        # Versions of sccache before 0.10.0 can restore stale or incorrect
+        # dependency files for cached C/C++ compilations, breaking our build.
+        SCCACHE_VERSION=[`$SCCACHE --version | head -n1 | $CUT -d " " -f 2 | $TR -d '\r'`]
+        if test "x$SCCACHE_VERSION" = x; then
+          AC_MSG_ERROR([Could not determine sccache version])
+        fi
+        HAS_BAD_SCCACHE=[`$ECHO $SCCACHE_VERSION | \
+            $GREP -e '^0\.[0-9]\.' -e '^0\.[0-9]$'`]
+        if test "x$HAS_BAD_SCCACHE" != "x"; then
+          AC_MSG_ERROR([[sccache 0.10.0 or later is required, found $SCCACHE_VERSION]])
+        fi
+        SCCACHE_STATUS="Active ($SCCACHE_VERSION)"
+      ],
+      IF_DISABLED: [
+        SCCACHE=""
+      ])
+  AC_SUBST(SCCACHE)
+
+  AC_ARG_WITH([sccache-dir],
+      [AS_HELP_STRING([--with-sccache-dir],
+      [where to store sccache files @<:@~/.cache/sccache@:>@])])
+
+  if test "x$with_sccache_dir" != x; then
+    SCCACHE_DIR="$with_sccache_dir"
+    SCCACHE_DIR_FOR_SCCACHE="$SCCACHE_DIR"
+
+    # Ideally, we'd use `UTIL_FIXUP_PATH()`, but it expects the supplied path to
+    # already exist, which might not be true for the sccache directory during
+    # the configure step.  As a workaround, we manually invoke fixpath.sh.
+    if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
+      SCCACHE_DIR_FOR_SCCACHE=`$FIXPATH_BASE -m print "$SCCACHE_DIR_FOR_SCCACHE"`
+    fi
+
+    SET_SCCACHE_DIR="SCCACHE_DIR=$SCCACHE_DIR_FOR_SCCACHE"
+    if test "x$SCCACHE" = x; then
+      AC_MSG_WARN([--with-sccache-dir has no meaning when sccache is not enabled])
+    fi
+  fi
+
+  if test "x$SCCACHE" != x; then
+    BPERF_SETUP_SCCACHE_USAGE
+  fi
+])
+
+AC_DEFUN([BPERF_SETUP_SCCACHE_USAGE],
+[
+  if test "x$SCCACHE" != x; then
+    if test "x$USE_PRECOMPILED_HEADER" = "xtrue"; then
+      if test "x$PRECOMPILED_HEADERS_EXPLICITLY_SET" = "xtrue"; then
+        AC_MSG_ERROR([Cannot use sccache with precompiled headers. Use --disable-precompiled-headers.])
+      else
+        AC_MSG_NOTICE([Disabling precompiled headers because sccache is enabled])
+        USE_PRECOMPILED_HEADER=false
+      fi
+    fi
+
+    # On Windows, the sccache binary must be launched through fixpath and the
+    # compiler argument passed to sccache must be the actual compiler
+    # (gcc/clang/cl) and not another fixpath invocation, otherwise sccache will
+    # try to execute fixpath as the compiler.
+    [ if [[ "$OPENJDK_BUILD_OS" = "windows" && "$SCCACHE" =~ ^"$FIXPATH " ]]; then ]
+      [ if [[ "$CC" =~ ^"$FIXPATH " ]]; then ]
+        CC="${CC#"$FIXPATH "}"
+      [ fi ]
+      [ if [[ "$CXX" =~ ^"$FIXPATH " ]]; then ]
+        CXX="${CXX#"$FIXPATH "}"
+      [ fi ]
+    [ fi ]
+
+    if test "x$SET_SCCACHE_DIR" != x; then
+      SCCACHE="$SET_SCCACHE_DIR $SCCACHE"
+      mkdir -p "$SCCACHE_DIR" > /dev/null 2>&1
+    fi
+  fi
+])
+
 ################################################################################
 #
 # Runs icecc-create-env once and prints the error if it fails
@@ -372,7 +475,13 @@ AC_DEFUN_ONCE([BPERF_SETUP_PRECOMPILED_HEADERS],
 
   UTIL_ARG_ENABLE(NAME: precompiled-headers, DEFAULT: auto,
       RESULT: USE_PRECOMPILED_HEADER, AVAILABLE: $PRECOMPILED_HEADERS_AVAILABLE,
-      DESC: [enable using precompiled headers when compiling C++])
+      DESC: [enable using precompiled headers when compiling C++],
+      IF_GIVEN: [
+        PRECOMPILED_HEADERS_EXPLICITLY_SET=true
+      ],
+      IF_NOT_GIVEN: [
+        PRECOMPILED_HEADERS_EXPLICITLY_SET=false
+      ])
   AC_SUBST(USE_PRECOMPILED_HEADER)
 ])
 

make/autoconf/configure.ac

@@ -293,6 +293,9 @@ BPERF_SETUP_PRECOMPILED_HEADERS
 # Setup use of ccache, if available
 BPERF_SETUP_CCACHE
 
+# Setup use of sccache, if available
+BPERF_SETUP_SCCACHE
+
 ################################################################################
 #
 # And now the finish...

make/autoconf/flags-cflags.m4

@@ -945,17 +945,27 @@ AC_DEFUN_ONCE([FLAGS_SETUP_BRANCH_PROTECTION],
 [
   # Is branch protection available?
   BRANCH_PROTECTION_AVAILABLE=false
-  BRANCH_PROTECTION_FLAG="-mbranch-protection=standard"
+  BRANCH_PROTECTION_CFLAG=""
+  BRANCH_PROTECTION_ASFLAG=""
 
   if test "x$OPENJDK_TARGET_CPU" = xaarch64; then
     if test "x$TOOLCHAIN_TYPE" = xgcc || test "x$TOOLCHAIN_TYPE" = xclang; then
-      FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [$BRANCH_PROTECTION_FLAG],
+      BRANCH_PROTECTION_CFLAG="-mbranch-protection=standard"
+      # The GCC/Clang assembler accepts the same flag as the compiler.
+      BRANCH_PROTECTION_ASFLAG="$BRANCH_PROTECTION_CFLAG"
+      FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [$BRANCH_PROTECTION_CFLAG],
+          IF_TRUE: [BRANCH_PROTECTION_AVAILABLE=true])
+    elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
+      BRANCH_PROTECTION_CFLAG="/guard:signret"
+      # MSVC's assembler does not support branch protection flags, so
+      # BRANCH_PROTECTION_ASFLAG is intentionally left empty.
+      FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [$BRANCH_PROTECTION_CFLAG],
           IF_TRUE: [BRANCH_PROTECTION_AVAILABLE=true])
     fi
   fi
 
   UTIL_ARG_ENABLE(NAME: branch-protection, DEFAULT: false,
       RESULT: BRANCH_PROTECTION_ENABLED, AVAILABLE: $BRANCH_PROTECTION_AVAILABLE,
       DESC: [enable branch protection when compiling C/C++],
-      IF_ENABLED: [BRANCH_PROTECTION_CFLAGS=$BRANCH_PROTECTION_FLAG])
+      IF_ENABLED: [BRANCH_PROTECTION_CFLAGS=$BRANCH_PROTECTION_CFLAG])
 ])

make/autoconf/flags-other.m4

@@ -211,7 +211,7 @@ AC_DEFUN([FLAGS_SETUP_ASFLAGS_CPU_DEP],
   fi
 
   if test "x$BRANCH_PROTECTION_ENABLED" = "xtrue"; then
-    $2JVM_ASFLAGS="${$2JVM_ASFLAGS} $BRANCH_PROTECTION_FLAG"
+    $2JVM_ASFLAGS="${$2JVM_ASFLAGS} $BRANCH_PROTECTION_ASFLAG"
   fi
 
   AC_SUBST($2JVM_ASFLAGS)

make/autoconf/help.m4

@@ -335,6 +335,9 @@ AC_DEFUN_ONCE([HELP_PRINT_SUMMARY_AND_WARNINGS],
   if test "x$CCACHE_STATUS" != "x"; then
     $ECHO "* ccache status:  $CCACHE_STATUS"
   fi
+  if test "x$SCCACHE_STATUS" != "x"; then
+    $ECHO "* sccache status: $SCCACHE_STATUS"
+  fi
   $ECHO ""
 
   if test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = "xtrue"; then

make/autoconf/spec.gmk.template

@@ -545,7 +545,7 @@ ADLC_LANGSTD_CXXFLAGS := @ADLC_LANGSTD_CXXFLAGS@
 ADLC_LDFLAGS := @ADLC_LDFLAGS@
 
 # Tools that potentially need to be cross compilation aware.
-CC := @CCACHE@ @ICECC@ @CC@
+CC := @SCCACHE@ @CCACHE@ @ICECC@ @CC@
 
 # CFLAGS used to compile the jdk native libraries (C-code)
 CFLAGS_JDKLIB := @CFLAGS_JDKLIB@
@@ -571,7 +571,7 @@ EXTRA_CXXFLAGS := @EXTRA_CXXFLAGS@
 EXTRA_LDFLAGS := @EXTRA_LDFLAGS@
 EXTRA_ASFLAGS := @EXTRA_ASFLAGS@
 
-CXX := @CCACHE@ @ICECC@ @CXX@
+CXX := @SCCACHE@ @CCACHE@ @ICECC@ @CXX@
 
 CPP := @CPP@
 
@@ -740,6 +740,7 @@ RCFLAGS := @RCFLAGS@
 AWK := @AWK@
 BASENAME := @BASENAME@
 CAT := @CAT@
+SCCACHE := @SCCACHE@
 CCACHE := @CCACHE@
 # CD is going away, but remains to cater for legacy makefiles.
 CD := cd

src/hotspot/cpu/aarch64/assembler_aarch64.hpp

@@ -457,17 +457,18 @@ class Address {
 
   Address(address target, relocInfo::relocType rtype = relocInfo::external_word_type);
 
-  Address(Register base, RegisterOrConstant index, extend ext = lsl()) {
+  Address(Register base, RegisterOrConstant index, extend ext = lsl(0)) {
     if (index.is_register()) {
       _mode = base_plus_offset_reg;
       new (&_nonliteral) Nonliteral(base, index.as_register(), 0, ext);
     } else {
       guarantee(ext.option() == ext::uxtx, "should be");
       assert(index.is_constant(), "should be");
+      assert(ext.shift() == 0, "must be");
       _mode = base_plus_offset;
       new (&_nonliteral) Nonliteral(base,
                                     noreg,
-                                    index.as_constant() << ext.shift());
+                                    index.as_constant());
     }
   }