update exclude list on results of main.3228 test runs

Ensure the jmethod_ids array has sufficient initial capacity. This array is not resized since JDK 23.

make/RunTests.gmk

@@ -534,21 +534,22 @@ define SetupRunGtestTestBody
 	  $$(eval $1_PASSED := $$(shell $$(AWK) '/\[  PASSED  \] .* tests?./ \
 	      { print $$$$4 }' $$($1_RESULT_FILE))) \
 	  $$(if $$($1_PASSED), , $$(eval $1_PASSED := 0)) \
-	  $$(eval $1_GTEST_DISABLED := $$(shell $$(AWK) '/YOU HAVE .* DISABLED TEST/ \
-	      { print $$$$3 }' $$($1_RESULT_FILE))) \
-	  $$(if $$($1_GTEST_DISABLED), , $$(eval $1_GTEST_DISABLED := 0)) \
-	  $$(eval $1_GTEST_SKIPPED := $$(shell $$(AWK) '/\[  SKIPPED \] .* tests?.*/ \
-	      { print $$$$4 }' $$($1_RESULT_FILE))) \
-	  $$(if $$($1_GTEST_SKIPPED), , $$(eval $1_GTEST_SKIPPED := 0)) \
-	  $$(eval $1_SKIPPED := $$(shell \
-	      $$(EXPR) $$($1_GTEST_DISABLED) + $$($1_GTEST_SKIPPED))) \
+	  $$(eval $1_SKIPPED := $$(shell $$(AWK) \
+	      '/YOU HAVE [0-9]+ DISABLED TEST/ { \
+	          if (match($$$$0, /[0-9]+/, arr)) { \
+	            print arr[0]; \
+	            found=1; \
+	          } \
+	       } \
+	       END { if (!found) print 0; }' \
+	      $$($1_RESULT_FILE))) \
 	  $$(eval $1_FAILED := $$(shell $$(AWK) '/\[  FAILED  \] .* tests?, \
 	      listed below/ { print $$$$4 }' $$($1_RESULT_FILE))) \
 	  $$(if $$($1_FAILED), , $$(eval $1_FAILED := 0)) \
 	  $$(eval $1_ERROR := $$(shell \
-	      $$(EXPR) $$($1_RUN) - $$($1_PASSED) - $$($1_FAILED) - $$($1_GTEST_SKIPPED))) \
+	      $$(EXPR) $$($1_RUN) - $$($1_PASSED) - $$($1_FAILED))) \
 	  $$(eval $1_TOTAL := $$(shell \
-	      $$(EXPR) $$($1_RUN) + $$($1_GTEST_DISABLED))) \
+	      $$(EXPR) $$($1_RUN) + $$($1_SKIPPED))) \
 	, \
 	  $$(eval $1_PASSED := 0) \
 	  $$(eval $1_FAILED := 0) \

make/autoconf/basic_tools.m4

@@ -468,15 +468,7 @@ AC_DEFUN_ONCE([BASIC_SETUP_PANDOC],
     AC_MSG_CHECKING([if the pandoc smart extension needs to be disabled for markdown])
     if $PANDOC --list-extensions | $GREP -q '+smart'; then
       AC_MSG_RESULT([yes])
-      PANDOC_MARKDOWN_FLAG="$PANDOC_MARKDOWN_FLAG-smart"
-    else
-      AC_MSG_RESULT([no])
-    fi
-
-    AC_MSG_CHECKING([if the pandoc tex_math_dollars extension needs to be disabled for markdown])
-    if $PANDOC --list-extensions | $GREP -q '+tex_math_dollars'; then
-      AC_MSG_RESULT([yes])
-      PANDOC_MARKDOWN_FLAG="$PANDOC_MARKDOWN_FLAG-tex_math_dollars"
+      PANDOC_MARKDOWN_FLAG="markdown-smart"
     else
       AC_MSG_RESULT([no])
     fi

make/autoconf/flags-cflags.m4

@@ -721,7 +721,7 @@ AC_DEFUN([FLAGS_SETUP_CFLAGS_CPU_DEP],
       $1_CFLAGS_CPU="-fsigned-char -Wno-psabi $ARM_ARCH_TYPE_FLAGS $ARM_FLOAT_TYPE_FLAGS -DJDK_ARCH_ABI_PROP_NAME='\"\$(JDK_ARCH_ABI_PROP_NAME)\"'"
       $1_CFLAGS_CPU_JVM="-DARM"
     elif test "x$FLAGS_CPU_ARCH" = xppc; then
-      $1_CFLAGS_CPU_JVM="-mno-multiple -mno-string"
+      $1_CFLAGS_CPU_JVM="-minsert-sched-nops=regroup_exact -mno-multiple -mno-string"
       if test "x$FLAGS_CPU" = xppc64; then
         # -mminimal-toc fixes `relocation truncated to fit' error for gcc 4.1.
         # Use ppc64 instructions, but schedule for power5

make/autoconf/lib-vulkan.m4

@@ -108,6 +108,13 @@ AC_DEFUN_ONCE([LIB_SETUP_VULKAN],
     fi
   fi
 
+  # Add platform-specific flags
+  if test "x$VULKAN_ENABLED" = xtrue; then
+    if test "x$NEEDS_LIB_WAYLAND" = xtrue; then
+      VULKAN_FLAGS="$VULKAN_FLAGS -DVK_USE_PLATFORM_WAYLAND_KHR"
+    fi
+  fi
+
   AC_SUBST(VULKAN_ENABLED)
   AC_SUBST(VULKAN_FLAGS)
   AC_SUBST(VULKAN_SHADER_COMPILER)

make/hotspot/lib/JvmFeatures.gmk

@@ -93,7 +93,7 @@ ifneq ($(call check-jvm-feature, jvmti), true)
       jvmtiEnvThreadState.cpp jvmtiTagMap.cpp jvmtiEventController.cpp \
       evmCompat.cpp jvmtiEnter.xsl jvmtiExport.cpp \
       jvmtiClassFileReconstituter.cpp jvmtiTagMapTable.cpp jvmtiAgent.cpp \
-      jvmtiAgentList.cpp jfrJvmtiAgent.cpp
+      jvmtiAgentList.cpp jfrJvmtiAgent.cpp jvmtiEnhancedRedefineClasses.cpp
 endif
 
 ifneq ($(call check-jvm-feature, jvmci), true)

make/modules/jdk.jlink/Java.gmk

@@ -1,32 +0,0 @@
-#
-# Copyright (c) 2025, 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.
-#
-
-################################################################################
-
-# Instruct SetupJavaCompilation for the jdk.jlink module to include
-# upgrade_files_<module-name>.conf files
-COPY += .conf
-
-################################################################################

src/demo/share/jfc/CodePointIM/com/sun/inputmethods/internal/codepointim/CodePointInputMethodDescriptor.java

@@ -63,7 +63,7 @@ public class CodePointInputMethodDescriptor implements InputMethodDescriptor {
      * Creates a new instance of the Code Point input method.
      *
      * @return a new instance of the Code Point input method
-     * @throws Exception any exception that may occur while creating the
+     * @exception Exception any exception that may occur while creating the
      * input method instance
      */
     public InputMethod createInputMethod() throws Exception {

src/hotspot/cpu/x86/assembler_x86.cpp

@@ -12918,6 +12918,380 @@ void Assembler::edecl(Register dst, Register src, bool no_flags) {
   (void) evex_prefix_and_encode_ndd(0, dst->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F_3C, &attributes, no_flags);
   emit_int8(0x48 | src->encoding());
 }
+
+// 64bit doesn't use the x87
+
+void Assembler::fabs() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xE1);
+}
+
+void Assembler::fadd(int i) {
+  emit_farith(0xD8, 0xC0, i);
+}
+
+void Assembler::fadd_d(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDC);
+  emit_operand32(rax, src, 0);
+}
+
+void Assembler::fadd_s(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xD8);
+  emit_operand32(rax, src, 0);
+}
+
+void Assembler::fadda(int i) {
+  emit_farith(0xDC, 0xC0, i);
+}
+
+void Assembler::faddp(int i) {
+  emit_farith(0xDE, 0xC0, i);
+}
+
+void Assembler::fchs() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xE0);
+}
+
+void Assembler::fcom(int i) {
+  emit_farith(0xD8, 0xD0, i);
+}
+
+void Assembler::fcomp(int i) {
+  emit_farith(0xD8, 0xD8, i);
+}
+
+void Assembler::fcomp_d(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDC);
+  emit_operand32(rbx, src, 0);
+}
+
+void Assembler::fcomp_s(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xD8);
+  emit_operand32(rbx, src, 0);
+}
+
+void Assembler::fcompp() {
+  emit_int16((unsigned char)0xDE, (unsigned char)0xD9);
+}
+
+void Assembler::fcos() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xFF);
+}
+
+void Assembler::fdecstp() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xF6);
+}
+
+void Assembler::fdiv(int i) {
+  emit_farith(0xD8, 0xF0, i);
+}
+
+void Assembler::fdiv_d(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDC);
+  emit_operand32(rsi, src, 0);
+}
+
+void Assembler::fdiv_s(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xD8);
+  emit_operand32(rsi, src, 0);
+}
+
+void Assembler::fdiva(int i) {
+  emit_farith(0xDC, 0xF8, i);
+}
+
+// Note: The Intel manual (Pentium Processor User's Manual, Vol.3, 1994)
+//       is erroneous for some of the floating-point instructions below.
+
+void Assembler::fdivp(int i) {
+  emit_farith(0xDE, 0xF8, i);                    // ST(0) <- ST(0) / ST(1) and pop (Intel manual wrong)
+}
+
+void Assembler::fdivr(int i) {
+  emit_farith(0xD8, 0xF8, i);
+}
+
+void Assembler::fdivr_d(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDC);
+  emit_operand32(rdi, src, 0);
+}
+
+void Assembler::fdivr_s(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xD8);
+  emit_operand32(rdi, src, 0);
+}
+
+void Assembler::fdivra(int i) {
+  emit_farith(0xDC, 0xF0, i);
+}
+
+void Assembler::fdivrp(int i) {
+  emit_farith(0xDE, 0xF0, i);                    // ST(0) <- ST(1) / ST(0) and pop (Intel manual wrong)
+}
+
+void Assembler::ffree(int i) {
+  emit_farith(0xDD, 0xC0, i);
+}
+
+void Assembler::fild_d(Address adr) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDF);
+  emit_operand32(rbp, adr, 0);
+}
+
+void Assembler::fild_s(Address adr) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDB);
+  emit_operand32(rax, adr, 0);
+}
+
+void Assembler::fincstp() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xF7);
+}
+
+void Assembler::finit() {
+  emit_int24((unsigned char)0x9B, (unsigned char)0xDB, (unsigned char)0xE3);
+}
+
+void Assembler::fist_s(Address adr) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDB);
+  emit_operand32(rdx, adr, 0);
+}
+
+void Assembler::fistp_d(Address adr) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDF);
+  emit_operand32(rdi, adr, 0);
+}
+
+void Assembler::fistp_s(Address adr) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDB);
+  emit_operand32(rbx, adr, 0);
+}
+
+void Assembler::fld1() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xE8);
+}
+
+void Assembler::fld_s(Address adr) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xD9);
+  emit_operand32(rax, adr, 0);
+}
+
+
+void Assembler::fld_s(int index) {
+  emit_farith(0xD9, 0xC0, index);
+}
+
+void Assembler::fldcw(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xD9);
+  emit_operand32(rbp, src, 0);
+}
+
+void Assembler::fldenv(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xD9);
+  emit_operand32(rsp, src, 0);
+}
+
+void Assembler::fldlg2() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xEC);
+}
+
+void Assembler::fldln2() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xED);
+}
+
+void Assembler::fldz() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xEE);
+}
+
+void Assembler::flog() {
+  fldln2();
+  fxch();
+  fyl2x();
+}
+
+void Assembler::flog10() {
+  fldlg2();
+  fxch();
+  fyl2x();
+}
+
+void Assembler::fmul(int i) {
+  emit_farith(0xD8, 0xC8, i);
+}
+
+void Assembler::fmul_d(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDC);
+  emit_operand32(rcx, src, 0);
+}
+
+void Assembler::fmul_s(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xD8);
+  emit_operand32(rcx, src, 0);
+}
+
+void Assembler::fmula(int i) {
+  emit_farith(0xDC, 0xC8, i);
+}
+
+void Assembler::fmulp(int i) {
+  emit_farith(0xDE, 0xC8, i);
+}
+
+void Assembler::fnsave(Address dst) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDD);
+  emit_operand32(rsi, dst, 0);
+}
+
+void Assembler::fnstcw(Address src) {
+  InstructionMark im(this);
+  emit_int16((unsigned char)0x9B, (unsigned char)0xD9);
+  emit_operand32(rdi, src, 0);
+}
+
+void Assembler::fprem1() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xF5);
+}
+
+void Assembler::frstor(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDD);
+  emit_operand32(rsp, src, 0);
+}
+
+void Assembler::fsin() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xFE);
+}
+
+void Assembler::fsqrt() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xFA);
+}
+
+void Assembler::fst_d(Address adr) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDD);
+  emit_operand32(rdx, adr, 0);
+}
+
+void Assembler::fst_s(Address adr) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xD9);
+  emit_operand32(rdx, adr, 0);
+}
+
+void Assembler::fstp_s(Address adr) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xD9);
+  emit_operand32(rbx, adr, 0);
+}
+
+void Assembler::fsub(int i) {
+  emit_farith(0xD8, 0xE0, i);
+}
+
+void Assembler::fsub_d(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDC);
+  emit_operand32(rsp, src, 0);
+}
+
+void Assembler::fsub_s(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xD8);
+  emit_operand32(rsp, src, 0);
+}
+
+void Assembler::fsuba(int i) {
+  emit_farith(0xDC, 0xE8, i);
+}
+
+void Assembler::fsubp(int i) {
+  emit_farith(0xDE, 0xE8, i);                    // ST(0) <- ST(0) - ST(1) and pop (Intel manual wrong)
+}
+
+void Assembler::fsubr(int i) {
+  emit_farith(0xD8, 0xE8, i);
+}
+
+void Assembler::fsubr_d(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDC);
+  emit_operand32(rbp, src, 0);
+}
+
+void Assembler::fsubr_s(Address src) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xD8);
+  emit_operand32(rbp, src, 0);
+}
+
+void Assembler::fsubra(int i) {
+  emit_farith(0xDC, 0xE0, i);
+}
+
+void Assembler::fsubrp(int i) {
+  emit_farith(0xDE, 0xE0, i);                    // ST(0) <- ST(1) - ST(0) and pop (Intel manual wrong)
+}
+
+void Assembler::ftan() {
+  emit_int32((unsigned char)0xD9, (unsigned char)0xF2, (unsigned char)0xDD, (unsigned char)0xD8);
+}
+
+void Assembler::ftst() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xE4);
+}
+
+void Assembler::fucomi(int i) {
+  // make sure the instruction is supported (introduced for P6, together with cmov)
+  guarantee(VM_Version::supports_cmov(), "illegal instruction");
+  emit_farith(0xDB, 0xE8, i);
+}
+
+void Assembler::fucomip(int i) {
+  // make sure the instruction is supported (introduced for P6, together with cmov)
+  guarantee(VM_Version::supports_cmov(), "illegal instruction");
+  emit_farith(0xDF, 0xE8, i);
+}
+
+void Assembler::fwait() {
+  emit_int8((unsigned char)0x9B);
+}
+
+void Assembler::fxch(int i) {
+  emit_farith(0xD9, 0xC8, i);
+}
+
+void Assembler::fyl2x() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xF1);
+}
+
+void Assembler::frndint() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xFC);
+}
+
+void Assembler::f2xm1() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xF0);
+}
+
+void Assembler::fldl2e() {
+  emit_int16((unsigned char)0xD9, (unsigned char)0xEA);
+}
 #endif // !_LP64
 
 // SSE SIMD prefix byte values corresponding to VexSimdPrefix encoding.

src/hotspot/cpu/x86/assembler_x86.hpp

@@ -1397,6 +1397,135 @@ private:
  public:
 #ifndef _LP64
   void emms();
+
+  void fabs();
+
+  void fadd(int i);
+
+  void fadd_d(Address src);
+  void fadd_s(Address src);
+
+  // "Alternate" versions of x87 instructions place result down in FPU
+  // stack instead of on TOS
+
+  void fadda(int i); // "alternate" fadd
+  void faddp(int i = 1);
+
+  void fchs();
+
+  void fcom(int i);
+
+  void fcomp(int i = 1);
+  void fcomp_d(Address src);
+  void fcomp_s(Address src);
+
+  void fcompp();
+
+  void fcos();
+
+  void fdecstp();
+
+  void fdiv(int i);
+  void fdiv_d(Address src);
+  void fdivr_s(Address src);
+  void fdiva(int i);  // "alternate" fdiv
+  void fdivp(int i = 1);
+
+  void fdivr(int i);
+  void fdivr_d(Address src);
+  void fdiv_s(Address src);
+
+  void fdivra(int i); // "alternate" reversed fdiv
+
+  void fdivrp(int i = 1);
+
+  void ffree(int i = 0);
+
+  void fild_d(Address adr);
+  void fild_s(Address adr);
+
+  void fincstp();
+
+  void finit();
+
+  void fist_s (Address adr);
+  void fistp_d(Address adr);
+  void fistp_s(Address adr);
+
+  void fld1();
+
+  void fld_s(Address adr);
+  void fld_s(int index);
+
+  void fldcw(Address src);
+
+  void fldenv(Address src);
+
+  void fldlg2();
+
+  void fldln2();
+
+  void fldz();
+
+  void flog();
+  void flog10();
+
+  void fmul(int i);
+
+  void fmul_d(Address src);
+  void fmul_s(Address src);
+
+  void fmula(int i);  // "alternate" fmul
+
+  void fmulp(int i = 1);
+
+  void fnsave(Address dst);
+
+  void fnstcw(Address src);
+  void fprem1();
+
+  void frstor(Address src);
+
+  void fsin();
+
+  void fsqrt();
+
+  void fst_d(Address adr);
+  void fst_s(Address adr);
+
+  void fstp_s(Address adr);
+
+  void fsub(int i);
+  void fsub_d(Address src);
+  void fsub_s(Address src);
+
+  void fsuba(int i);  // "alternate" fsub
+
+  void fsubp(int i = 1);
+
+  void fsubr(int i);
+  void fsubr_d(Address src);
+  void fsubr_s(Address src);
+
+  void fsubra(int i); // "alternate" reversed fsub
+
+  void fsubrp(int i = 1);
+
+  void ftan();
+
+  void ftst();
+
+  void fucomi(int i = 1);
+  void fucomip(int i = 1);
+
+  void fwait();
+
+  void fxch(int i = 1);
+
+  void fyl2x();
+  void frndint();
+  void f2xm1();
+  void fldl2e();
 #endif // !_LP64
 
   // operands that only take the original 32bit registers

src/hotspot/cpu/x86/c1_MacroAssembler_x86.cpp

@@ -324,11 +324,11 @@ void C1_MacroAssembler::remove_frame(int frame_size_in_bytes) {
 
 
 void C1_MacroAssembler::verified_entry(bool breakAtEntry) {
-  if (breakAtEntry) {
+  if (breakAtEntry || VerifyFPU) {
     // Verified Entry first instruction should be 5 bytes long for correct
     // patching by patch_verified_entry().
     //
-    // Breakpoint has one byte first instruction.
+    // Breakpoint and VerifyFPU have one byte first instruction.
     // Also first instruction will be one byte "push(rbp)" if stack banging
     // code is not generated (see build_frame() above).
     // For all these cases generate long instruction first.
@@ -336,6 +336,7 @@ void C1_MacroAssembler::verified_entry(bool breakAtEntry) {
   }
   if (breakAtEntry) int3();
   // build frame
+  IA32_ONLY( verify_FPU(0, "method_entry"); )
 }
 
 void C1_MacroAssembler::load_parameter(int offset_in_words, Register reg) {

src/hotspot/cpu/x86/continuationFreezeThaw_x86.inline.hpp

@@ -261,12 +261,15 @@ template<typename FKind> frame ThawBase::new_stack_frame(const frame& hf, frame&
 }
 
 inline intptr_t* ThawBase::align(const frame& hf, intptr_t* frame_sp, frame& caller, bool bottom) {
+#ifdef _LP64
   if (((intptr_t)frame_sp & 0xf) != 0) {
     assert(caller.is_interpreted_frame() || (bottom && hf.compiled_frame_stack_argsize() % 2 != 0), "");
     frame_sp--;
     caller.set_sp(caller.sp() - 1);
   }
   assert(is_aligned(frame_sp, frame::frame_alignment), "");
+#endif
+
   return frame_sp;
 }
 

src/hotspot/cpu/x86/continuationHelper_x86.inline.hpp

@@ -55,11 +55,18 @@ static inline void patch_return_pc_with_preempt_stub(frame& f) {
 }
 
 inline int ContinuationHelper::frame_align_words(int size) {
+#ifdef _LP64
   return size & 1;
+#else
+  return 0;
+#endif
 }
 
 inline intptr_t* ContinuationHelper::frame_align_pointer(intptr_t* sp) {
-  return align_down(sp, frame::frame_alignment);
+#ifdef _LP64
+  sp = align_down(sp, frame::frame_alignment);
+#endif
+  return sp;
 }
 
 template<typename FKind>

src/hotspot/cpu/x86/macroAssembler_x86.cpp

@@ -143,6 +143,26 @@ void MacroAssembler::extend_sign(Register hi, Register lo) {
   }
 }
 
+void MacroAssembler::jC2(Register tmp, Label& L) {
+  // set parity bit if FPU flag C2 is set (via rax)
+  save_rax(tmp);
+  fwait(); fnstsw_ax();
+  sahf();
+  restore_rax(tmp);
+  // branch
+  jcc(Assembler::parity, L);
+}
+
+void MacroAssembler::jnC2(Register tmp, Label& L) {
+  // set parity bit if FPU flag C2 is set (via rax)
+  save_rax(tmp);
+  fwait(); fnstsw_ax();
+  sahf();
+  restore_rax(tmp);
+  // branch
+  jcc(Assembler::noParity, L);
+}
+
 // 32bit can do a case table jump in one instruction but we no longer allow the base
 // to be installed in the Address class
 void MacroAssembler::jump(ArrayAddress entry, Register rscratch) {
@@ -2034,6 +2054,115 @@ void MacroAssembler::fat_nop() {
   }
 }
 
+#ifndef _LP64
+void MacroAssembler::fcmp(Register tmp) {
+  fcmp(tmp, 1, true, true);
+}
+
+void MacroAssembler::fcmp(Register tmp, int index, bool pop_left, bool pop_right) {
+  assert(!pop_right || pop_left, "usage error");
+  if (VM_Version::supports_cmov()) {
+    assert(tmp == noreg, "unneeded temp");
+    if (pop_left) {
+      fucomip(index);
+    } else {
+      fucomi(index);
+    }
+    if (pop_right) {
+      fpop();
+    }
+  } else {
+    assert(tmp != noreg, "need temp");
+    if (pop_left) {
+      if (pop_right) {
+        fcompp();
+      } else {
+        fcomp(index);
+      }
+    } else {
+      fcom(index);
+    }
+    // convert FPU condition into eflags condition via rax,
+    save_rax(tmp);
+    fwait(); fnstsw_ax();
+    sahf();
+    restore_rax(tmp);
+  }
+  // condition codes set as follows:
+  //
+  // CF (corresponds to C0) if x < y
+  // PF (corresponds to C2) if unordered
+  // ZF (corresponds to C3) if x = y
+}
+
+void MacroAssembler::fcmp2int(Register dst, bool unordered_is_less) {
+  fcmp2int(dst, unordered_is_less, 1, true, true);
+}
+
+void MacroAssembler::fcmp2int(Register dst, bool unordered_is_less, int index, bool pop_left, bool pop_right) {
+  fcmp(VM_Version::supports_cmov() ? noreg : dst, index, pop_left, pop_right);
+  Label L;
+  if (unordered_is_less) {
+    movl(dst, -1);
+    jcc(Assembler::parity, L);
+    jcc(Assembler::below , L);
+    movl(dst, 0);
+    jcc(Assembler::equal , L);
+    increment(dst);
+  } else { // unordered is greater
+    movl(dst, 1);
+    jcc(Assembler::parity, L);
+    jcc(Assembler::above , L);
+    movl(dst, 0);
+    jcc(Assembler::equal , L);
+    decrementl(dst);
+  }
+  bind(L);
+}
+
+void MacroAssembler::fld_d(AddressLiteral src) {
+  fld_d(as_Address(src));
+}
+
+void MacroAssembler::fld_s(AddressLiteral src) {
+  fld_s(as_Address(src));
+}
+
+void MacroAssembler::fldcw(AddressLiteral src) {
+  fldcw(as_Address(src));
+}
+
+void MacroAssembler::fpop() {
+  ffree();
+  fincstp();
+}
+
+void MacroAssembler::fremr(Register tmp) {
+  save_rax(tmp);
+  { Label L;
+    bind(L);
+    fprem();
+    fwait(); fnstsw_ax();
+    sahf();
+    jcc(Assembler::parity, L);
+  }
+  restore_rax(tmp);
+  // Result is in ST0.
+  // Note: fxch & fpop to get rid of ST1
+  // (otherwise FPU stack could overflow eventually)
+  fxch(1);
+  fpop();
+}
+
+void MacroAssembler::empty_FPU_stack() {
+  if (VM_Version::supports_mmx()) {
+    emms();
+  } else {
+    for (int i = 8; i-- > 0; ) ffree(i);
+  }
+}
+#endif // !LP64
+
 void MacroAssembler::mulpd(XMMRegister dst, AddressLiteral src, Register rscratch) {
   assert(rscratch != noreg || always_reachable(src), "missing");
   if (reachable(src)) {
@@ -2860,39 +2989,91 @@ void MacroAssembler::push_IU_state() {
 void MacroAssembler::push_cont_fastpath() {
   if (!Continuations::enabled()) return;
 
-  Label L_done;
-  cmpptr(rsp, Address(r15_thread, JavaThread::cont_fastpath_offset()));
-  jccb(Assembler::belowEqual, L_done);
-  movptr(Address(r15_thread, JavaThread::cont_fastpath_offset()), rsp);
-  bind(L_done);
+#ifndef _LP64
+  Register rthread = rax;
+  Register rrealsp = rbx;
+  push(rthread);
+  push(rrealsp);
+
+  get_thread(rthread);
+
+  // The code below wants the original RSP.
+  // Move it back after the pushes above.
+  movptr(rrealsp, rsp);
+  addptr(rrealsp, 2*wordSize);
+#else
+  Register rthread = r15_thread;
+  Register rrealsp = rsp;
+#endif
+
+  Label done;
+  cmpptr(rrealsp, Address(rthread, JavaThread::cont_fastpath_offset()));
+  jccb(Assembler::belowEqual, done);
+  movptr(Address(rthread, JavaThread::cont_fastpath_offset()), rrealsp);
+  bind(done);
+
+#ifndef _LP64
+  pop(rrealsp);
+  pop(rthread);
+#endif
 }
 
 void MacroAssembler::pop_cont_fastpath() {
   if (!Continuations::enabled()) return;
 
-  Label L_done;
-  cmpptr(rsp, Address(r15_thread, JavaThread::cont_fastpath_offset()));
-  jccb(Assembler::below, L_done);
-  movptr(Address(r15_thread, JavaThread::cont_fastpath_offset()), 0);
-  bind(L_done);
+#ifndef _LP64
+  Register rthread = rax;
+  Register rrealsp = rbx;
+  push(rthread);
+  push(rrealsp);
+
+  get_thread(rthread);
+
+  // The code below wants the original RSP.
+  // Move it back after the pushes above.
+  movptr(rrealsp, rsp);
+  addptr(rrealsp, 2*wordSize);
+#else
+  Register rthread = r15_thread;
+  Register rrealsp = rsp;
+#endif
+
+  Label done;
+  cmpptr(rrealsp, Address(rthread, JavaThread::cont_fastpath_offset()));
+  jccb(Assembler::below, done);
+  movptr(Address(rthread, JavaThread::cont_fastpath_offset()), 0);
+  bind(done);
+
+#ifndef _LP64
+  pop(rrealsp);
+  pop(rthread);
+#endif
 }
 
 void MacroAssembler::inc_held_monitor_count() {
+#ifdef _LP64
   incrementq(Address(r15_thread, JavaThread::held_monitor_count_offset()));
+#endif
 }
 
 void MacroAssembler::dec_held_monitor_count() {
+#ifdef _LP64
   decrementq(Address(r15_thread, JavaThread::held_monitor_count_offset()));
+#endif
 }
 
 #ifdef ASSERT
 void MacroAssembler::stop_if_in_cont(Register cont, const char* name) {
+#ifdef _LP64
   Label no_cont;
   movptr(cont, Address(r15_thread, JavaThread::cont_entry_offset()));
   testl(cont, cont);
   jcc(Assembler::zero, no_cont);
   stop(name);
   bind(no_cont);
+#else
+  Unimplemented();
+#endif
 }
 #endif
 
@@ -2909,11 +3090,21 @@ void MacroAssembler::reset_last_Java_frame(bool clear_fp) { // determine java_th
   vzeroupper();
 }
 
+void MacroAssembler::restore_rax(Register tmp) {
+  if (tmp == noreg) pop(rax);
+  else if (tmp != rax) mov(rax, tmp);
+}
+
 void MacroAssembler::round_to(Register reg, int modulus) {
   addptr(reg, modulus - 1);
   andptr(reg, -modulus);
 }
 
+void MacroAssembler::save_rax(Register tmp) {
+  if (tmp == noreg) push(rax);
+  else if (tmp != rax) mov(tmp, rax);
+}
+
 void MacroAssembler::safepoint_poll(Label& slow_path, bool at_return, bool in_nmethod) {
   if (at_return) {
     // Note that when in_nmethod is set, the stack pointer is incremented before the poll. Therefore,
@@ -5597,6 +5788,85 @@ void MacroAssembler::print_CPU_state() {
   pop_CPU_state();
 }
 
+
+#ifndef _LP64
+static bool _verify_FPU(int stack_depth, char* s, CPU_State* state) {
+  static int counter = 0;
+  FPU_State* fs = &state->_fpu_state;
+  counter++;
+  // For leaf calls, only verify that the top few elements remain empty.
+  // We only need 1 empty at the top for C2 code.
+  if( stack_depth < 0 ) {
+    if( fs->tag_for_st(7) != 3 ) {
+      printf("FPR7 not empty\n");
+      state->print();
+      assert(false, "error");
+      return false;
+    }
+    return true;                // All other stack states do not matter
+  }
+
+  assert((fs->_control_word._value & 0xffff) == StubRoutines::x86::fpu_cntrl_wrd_std(),
+         "bad FPU control word");
+
+  // compute stack depth
+  int i = 0;
+  while (i < FPU_State::number_of_registers && fs->tag_for_st(i)  < 3) i++;
+  int d = i;
+  while (i < FPU_State::number_of_registers && fs->tag_for_st(i) == 3) i++;
+  // verify findings
+  if (i != FPU_State::number_of_registers) {
+    // stack not contiguous
+    printf("%s: stack not contiguous at ST%d\n", s, i);
+    state->print();
+    assert(false, "error");
+    return false;
+  }
+  // check if computed stack depth corresponds to expected stack depth
+  if (stack_depth < 0) {
+    // expected stack depth is -stack_depth or less
+    if (d > -stack_depth) {
+      // too many elements on the stack
+      printf("%s: <= %d stack elements expected but found %d\n", s, -stack_depth, d);
+      state->print();
+      assert(false, "error");
+      return false;
+    }
+  } else {
+    // expected stack depth is stack_depth
+    if (d != stack_depth) {
+      // wrong stack depth
+      printf("%s: %d stack elements expected but found %d\n", s, stack_depth, d);
+      state->print();
+      assert(false, "error");
+      return false;
+    }
+  }
+  // everything is cool
+  return true;
+}
+
+void MacroAssembler::verify_FPU(int stack_depth, const char* s) {
+  if (!VerifyFPU) return;
+  push_CPU_state();
+  push(rsp);                // pass CPU state
+  ExternalAddress msg((address) s);
+  // pass message string s
+  pushptr(msg.addr(), noreg);
+  push(stack_depth);        // pass stack depth
+  call(RuntimeAddress(CAST_FROM_FN_PTR(address, _verify_FPU)));
+  addptr(rsp, 3 * wordSize);   // discard arguments
+  // check for error
+  { Label L;
+    testl(rax, rax);
+    jcc(Assembler::notZero, L);
+    int3();                  // break if error condition
+    bind(L);
+  }
+  pop_CPU_state();
+}
+#endif // _LP64
+
 void MacroAssembler::restore_cpu_control_state_after_jni(Register rscratch) {
   // Either restore the MXCSR register after returning from the JNI Call
   // or verify that it wasn't changed (with -Xcheck:jni flag).
@@ -5609,6 +5879,14 @@ void MacroAssembler::restore_cpu_control_state_after_jni(Register rscratch) {
   }
   // Clear upper bits of YMM registers to avoid SSE <-> AVX transition penalty.
   vzeroupper();
+
+#ifndef _LP64
+  // Either restore the x87 floating pointer control word after returning
+  // from the JNI call or verify that it wasn't changed.
+  if (CheckJNICalls) {
+    call(RuntimeAddress(StubRoutines::x86::verify_fpu_cntrl_wrd_entry()));
+  }
+#endif // _LP64
 }
 
 // ((OopHandle)result).resolve();

src/hotspot/cpu/x86/macroAssembler_x86.hpp

@@ -71,6 +71,11 @@ class MacroAssembler: public Assembler {
 
   void call_VM_helper(Register oop_result, address entry_point, int number_of_arguments, bool check_exceptions = true);
 
+  // helpers for FPU flag access
+  // tmp is a temporary register, if none is available use noreg
+  void save_rax   (Register tmp);
+  void restore_rax(Register tmp);
+
  public:
   MacroAssembler(CodeBuffer* code) : Assembler(code) {}
 
@@ -455,6 +460,39 @@ class MacroAssembler: public Assembler {
   // Division by power of 2, rounding towards 0
   void division_with_shift(Register reg, int shift_value);
 
+#ifndef _LP64
+  // Compares the top-most stack entries on the FPU stack and sets the eflags as follows:
+  //
+  // CF (corresponds to C0) if x < y
+  // PF (corresponds to C2) if unordered
+  // ZF (corresponds to C3) if x = y
+  //
+  // The arguments are in reversed order on the stack (i.e., top of stack is first argument).
+  // tmp is a temporary register, if none is available use noreg (only matters for non-P6 code)
+  void fcmp(Register tmp);
+  // Variant of the above which allows y to be further down the stack
+  // and which only pops x and y if specified. If pop_right is
+  // specified then pop_left must also be specified.
+  void fcmp(Register tmp, int index, bool pop_left, bool pop_right);
+
+  // Floating-point comparison for Java
+  // Compares the top-most stack entries on the FPU stack and stores the result in dst.
+  // The arguments are in reversed order on the stack (i.e., top of stack is first argument).
+  // (semantics as described in JVM spec.)
+  void fcmp2int(Register dst, bool unordered_is_less);
+  // Variant of the above which allows y to be further down the stack
+  // and which only pops x and y if specified. If pop_right is
+  // specified then pop_left must also be specified.
+  void fcmp2int(Register dst, bool unordered_is_less, int index, bool pop_left, bool pop_right);
+
+  // Floating-point remainder for Java (ST0 = ST0 fremr ST1, ST1 is empty afterwards)
+  // tmp is a temporary register, if none is available use noreg
+  void fremr(Register tmp);
+
+  // only if +VerifyFPU
+  void verify_FPU(int stack_depth, const char* s = "illegal FPU state");
+#endif // !LP64
+
   // dst = c = a * b + c
   void fmad(XMMRegister dst, XMMRegister a, XMMRegister b, XMMRegister c);
   void fmaf(XMMRegister dst, XMMRegister a, XMMRegister b, XMMRegister c);
@@ -469,6 +507,18 @@ class MacroAssembler: public Assembler {
   void cmpss2int(XMMRegister opr1, XMMRegister opr2, Register dst, bool unordered_is_less);
   void cmpsd2int(XMMRegister opr1, XMMRegister opr2, Register dst, bool unordered_is_less);
 
+  // branch to L if FPU flag C2 is set/not set
+  // tmp is a temporary register, if none is available use noreg
+  void jC2 (Register tmp, Label& L);
+  void jnC2(Register tmp, Label& L);
+
+#ifndef _LP64
+  // Pop ST (ffree & fincstp combined)
+  void fpop();
+
+  void empty_FPU_stack();
+#endif // !_LP64
+
   void push_IU_state();
   void pop_IU_state();
 
@@ -1029,6 +1079,27 @@ public:
   void comisd(XMMRegister dst, Address        src) { Assembler::comisd(dst, src); }
   void comisd(XMMRegister dst, AddressLiteral src, Register rscratch = noreg);
 
+#ifndef _LP64
+  void fadd_s(Address        src) { Assembler::fadd_s(src); }
+  void fadd_s(AddressLiteral src) { Assembler::fadd_s(as_Address(src)); }
+
+  void fldcw(Address        src) { Assembler::fldcw(src); }
+  void fldcw(AddressLiteral src);
+
+  void fld_s(int index)          { Assembler::fld_s(index); }
+  void fld_s(Address        src) { Assembler::fld_s(src); }
+  void fld_s(AddressLiteral src);
+
+  void fld_d(Address        src) { Assembler::fld_d(src); }
+  void fld_d(AddressLiteral src);
+
+  void fld_x(Address        src) { Assembler::fld_x(src); }
+  void fld_x(AddressLiteral src) { Assembler::fld_x(as_Address(src)); }
+
+  void fmul_s(Address        src) { Assembler::fmul_s(src); }
+  void fmul_s(AddressLiteral src) { Assembler::fmul_s(as_Address(src)); }
+#endif // !_LP64
+
   void cmp32_mxcsr_std(Address mxcsr_save, Register tmp, Register rscratch = noreg);
   void ldmxcsr(Address src) { Assembler::ldmxcsr(src); }
   void ldmxcsr(AddressLiteral src, Register rscratch = noreg);

src/hotspot/cpu/x86/methodHandles_x86.cpp

@@ -82,8 +82,8 @@ void MethodHandles::verify_klass(MacroAssembler* _masm,
   __ verify_oop(obj);
   __ testptr(obj, obj);
   __ jcc(Assembler::zero, L_bad);
-#define PUSH { __ push(temp); __ push(rscratch1);               }
-#define POP  {                __ pop(rscratch1);  __ pop(temp); }
+#define PUSH { __ push(temp); LP64_ONLY(  __ push(rscratch1); )               }
+#define POP  {                LP64_ONLY(  __ pop(rscratch1);  ) __ pop(temp); }
   PUSH;
   __ load_klass(temp, obj, rscratch1);
   __ cmpptr(temp, ExternalAddress((address) klass_addr), rscratch1);
@@ -139,9 +139,15 @@ void MethodHandles::jump_from_method_handle(MacroAssembler* _masm, Register meth
     // JVMTI events, such as single-stepping, are implemented partly by avoiding running
     // compiled code in threads for which the event is enabled.  Check here for
     // interp_only_mode if these events CAN be enabled.
+#ifdef _LP64
+    Register rthread = r15_thread;
+#else
+    Register rthread = temp;
+    __ get_thread(rthread);
+#endif
     // interp_only is an int, on little endian it is sufficient to test the byte only
     // Is a cmpl faster?
-    __ cmpb(Address(r15_thread, JavaThread::interp_only_mode_offset()), 0);
+    __ cmpb(Address(rthread, JavaThread::interp_only_mode_offset()), 0);
     __ jccb(Assembler::zero, run_compiled_code);
     __ jmp(Address(method, Method::interpreter_entry_offset()));
     __ BIND(run_compiled_code);
@@ -318,6 +324,7 @@ void MethodHandles::generate_method_handle_dispatch(MacroAssembler* _masm,
   assert(is_signature_polymorphic(iid), "expected invoke iid");
   Register rbx_method = rbx;   // eventual target of this invocation
   // temps used in this code are not used in *either* compiled or interpreted calling sequences
+#ifdef _LP64
   Register temp1 = rscratch1;
   Register temp2 = rscratch2;
   Register temp3 = rax;
@@ -326,7 +333,19 @@ void MethodHandles::generate_method_handle_dispatch(MacroAssembler* _masm,
     assert_different_registers(temp1,        j_rarg0, j_rarg1, j_rarg2, j_rarg3, j_rarg4, j_rarg5);
     assert_different_registers(temp2,        j_rarg0, j_rarg1, j_rarg2, j_rarg3, j_rarg4, j_rarg5);
     assert_different_registers(temp3,        j_rarg0, j_rarg1, j_rarg2, j_rarg3, j_rarg4, j_rarg5);
-  } else {
+  }
+#else
+  Register temp1 = (for_compiler_entry ? rsi : rdx);
+  Register temp2 = rdi;
+  Register temp3 = rax;
+  if (for_compiler_entry) {
+    assert(receiver_reg == (iid == vmIntrinsics::_linkToStatic || iid == vmIntrinsics::_linkToNative ? noreg : rcx), "only valid assignment");
+    assert_different_registers(temp1,        rcx, rdx);
+    assert_different_registers(temp2,        rcx, rdx);
+    assert_different_registers(temp3,        rcx, rdx);
+  }
+#endif
+  else {
     assert_different_registers(temp1, temp2, temp3, saved_last_sp_register());  // don't trash lastSP
   }
   assert_different_registers(temp1, temp2, temp3, receiver_reg);

src/hotspot/cpu/x86/methodHandles_x86.hpp

@@ -60,5 +60,5 @@ public:
 
   static Register saved_last_sp_register() {
     // Should be in sharedRuntime, not here.
-    return r13;
+    return LP64_ONLY(r13) NOT_LP64(rsi);
   }

src/hotspot/cpu/x86/sharedRuntime_x86.cpp

@@ -73,14 +73,21 @@ void SharedRuntime::inline_check_hashcode_from_object_header(MacroAssembler* mas
   }
 
   // get hash
+#ifdef _LP64
   // Read the header and build a mask to get its hash field.
   // Depend on hash_mask being at most 32 bits and avoid the use of hash_mask_in_place
   // because it could be larger than 32 bits in a 64-bit vm. See markWord.hpp.
   __ shrptr(result, markWord::hash_shift);
   __ andptr(result, markWord::hash_mask);
+#else
+  __ andptr(result, markWord::hash_mask_in_place);
+#endif //_LP64
 
   // test if hashCode exists
-  __ jccb(Assembler::zero, slowCase);
+  __ jcc(Assembler::zero, slowCase);
+#ifndef _LP64
+  __ shrptr(result, markWord::hash_shift);
+#endif
   __ ret(0);
   __ bind(slowCase);
 }

src/hotspot/cpu/x86/stubDeclarations_x86.hpp

@@ -34,43 +34,58 @@
   do_stub(initial, verify_mxcsr)                                        \
   do_arch_entry(x86, initial, verify_mxcsr, verify_mxcsr_entry,         \
                 verify_mxcsr_entry)                                     \
-  do_stub(initial, get_previous_sp)                                     \
-  do_arch_entry(x86, initial, get_previous_sp,                          \
-                get_previous_sp_entry,                                  \
-                get_previous_sp_entry)                                  \
-  do_stub(initial, f2i_fixup)                                           \
-  do_arch_entry(x86, initial, f2i_fixup, f2i_fixup, f2i_fixup)          \
-  do_stub(initial, f2l_fixup)                                           \
-  do_arch_entry(x86, initial, f2l_fixup, f2l_fixup, f2l_fixup)          \
-  do_stub(initial, d2i_fixup)                                           \
-  do_arch_entry(x86, initial, d2i_fixup, d2i_fixup, d2i_fixup)          \
-  do_stub(initial, d2l_fixup)                                           \
-  do_arch_entry(x86, initial, d2l_fixup, d2l_fixup, d2l_fixup)          \
-  do_stub(initial, float_sign_mask)                                     \
-  do_arch_entry(x86, initial, float_sign_mask, float_sign_mask,         \
-                float_sign_mask)                                        \
-  do_stub(initial, float_sign_flip)                                     \
-  do_arch_entry(x86, initial, float_sign_flip, float_sign_flip,         \
-                float_sign_flip)                                        \
-  do_stub(initial, double_sign_mask)                                    \
-  do_arch_entry(x86, initial, double_sign_mask, double_sign_mask,       \
-                double_sign_mask)                                       \
-  do_stub(initial, double_sign_flip)                                    \
-  do_arch_entry(x86, initial, double_sign_flip, double_sign_flip,       \
-                double_sign_flip)                                       \
+  LP64_ONLY(                                                            \
+    do_stub(initial, get_previous_sp)                                   \
+    do_arch_entry(x86, initial, get_previous_sp,                        \
+                  get_previous_sp_entry,                                \
+                  get_previous_sp_entry)                                \
+    do_stub(initial, f2i_fixup)                                         \
+    do_arch_entry(x86, initial, f2i_fixup, f2i_fixup, f2i_fixup)        \
+    do_stub(initial, f2l_fixup)                                         \
+    do_arch_entry(x86, initial, f2l_fixup, f2l_fixup, f2l_fixup)        \
+    do_stub(initial, d2i_fixup)                                         \
+    do_arch_entry(x86, initial, d2i_fixup, d2i_fixup, d2i_fixup)        \
+    do_stub(initial, d2l_fixup)                                         \
+    do_arch_entry(x86, initial, d2l_fixup, d2l_fixup, d2l_fixup)        \
+    do_stub(initial, float_sign_mask)                                   \
+    do_arch_entry(x86, initial, float_sign_mask, float_sign_mask,       \
+                  float_sign_mask)                                      \
+    do_stub(initial, float_sign_flip)                                   \
+    do_arch_entry(x86, initial, float_sign_flip, float_sign_flip,       \
+                  float_sign_flip)                                      \
+    do_stub(initial, double_sign_mask)                                  \
+    do_arch_entry(x86, initial, double_sign_mask, double_sign_mask,     \
+                  double_sign_mask)                                     \
+    do_stub(initial, double_sign_flip)                                  \
+    do_arch_entry(x86, initial, double_sign_flip, double_sign_flip,     \
+                  double_sign_flip)                                     \
+  )                                                                     \
+  NOT_LP64(                                                             \
+    do_stub(initial, verify_fpu_cntrl_word)                             \
+    do_arch_entry(x86, initial, verify_fpu_cntrl_word,                  \
+                  verify_fpu_cntrl_wrd_entry,                           \
+                  verify_fpu_cntrl_wrd_entry)                           \
+    do_stub(initial, d2i_wrapper)                                       \
+    do_arch_entry(x86, initial, d2i_wrapper, d2i_wrapper,               \
+                  d2i_wrapper)                                          \
+    do_stub(initial, d2l_wrapper)                                       \
+    do_arch_entry(x86, initial, d2l_wrapper, d2l_wrapper,               \
+                  d2l_wrapper)                                          \
+  )                                                                     \
+
 
 #define STUBGEN_CONTINUATION_BLOBS_ARCH_DO(do_stub,                     \
                                            do_arch_blob,                \
                                            do_arch_entry,               \
                                            do_arch_entry_init)          \
-  do_arch_blob(continuation, 3000)                                      \
+  do_arch_blob(continuation, 1000 LP64_ONLY(+2000))                     \
 
 
 #define STUBGEN_COMPILER_BLOBS_ARCH_DO(do_stub,                         \
                                        do_arch_blob,                    \
                                        do_arch_entry,                   \
                                        do_arch_entry_init)              \
-  do_arch_blob(compiler, 109000 WINDOWS_ONLY(+2000))                    \
+  do_arch_blob(compiler, 20000 LP64_ONLY(+89000) WINDOWS_ONLY(+2000))   \
   do_stub(compiler, vector_float_sign_mask)                             \
   do_arch_entry(x86, compiler, vector_float_sign_mask,                  \
                 vector_float_sign_mask, vector_float_sign_mask)         \
@@ -158,88 +173,90 @@
   do_arch_entry(x86, compiler, pshuffle_byte_flip_mask,                 \
                 pshuffle_byte_flip_mask_addr,                           \
                 pshuffle_byte_flip_mask_addr)                           \
-  /* x86_64 exposes these 3 stubs via a generic entry array */          \
-  /* other arches use arch-specific entries */                          \
-  /* this really needs rationalising */                                 \
-  do_stub(compiler, string_indexof_linear_ll)                           \
-  do_stub(compiler, string_indexof_linear_uu)                           \
-  do_stub(compiler, string_indexof_linear_ul)                           \
-  do_stub(compiler, pshuffle_byte_flip_mask_sha512)                     \
-  do_arch_entry(x86, compiler, pshuffle_byte_flip_mask_sha512,          \
-                pshuffle_byte_flip_mask_addr_sha512,                    \
-                pshuffle_byte_flip_mask_addr_sha512)                    \
-  do_stub(compiler, compress_perm_table32)                              \
-  do_arch_entry(x86, compiler, compress_perm_table32,                   \
-                compress_perm_table32, compress_perm_table32)           \
-  do_stub(compiler, compress_perm_table64)                              \
-  do_arch_entry(x86, compiler, compress_perm_table64,                   \
-                compress_perm_table64, compress_perm_table64)           \
-  do_stub(compiler, expand_perm_table32)                                \
-  do_arch_entry(x86, compiler, expand_perm_table32,                     \
-                expand_perm_table32, expand_perm_table32)               \
-  do_stub(compiler, expand_perm_table64)                                \
-  do_arch_entry(x86, compiler, expand_perm_table64,                     \
-                expand_perm_table64, expand_perm_table64)               \
-  do_stub(compiler, avx2_shuffle_base64)                                \
-  do_arch_entry(x86, compiler, avx2_shuffle_base64,                     \
-                avx2_shuffle_base64, base64_avx2_shuffle_addr)          \
-  do_stub(compiler, avx2_input_mask_base64)                             \
-  do_arch_entry(x86, compiler, avx2_input_mask_base64,                  \
-                avx2_input_mask_base64,                                 \
-                base64_avx2_input_mask_addr)                            \
-  do_stub(compiler, avx2_lut_base64)                                    \
-  do_arch_entry(x86, compiler, avx2_lut_base64,                         \
-                avx2_lut_base64, base64_avx2_lut_addr)                  \
-  do_stub(compiler, avx2_decode_tables_base64)                          \
-  do_arch_entry(x86, compiler, avx2_decode_tables_base64,               \
-                avx2_decode_tables_base64,                              \
-                base64_AVX2_decode_tables_addr)                         \
-  do_stub(compiler, avx2_decode_lut_tables_base64)                      \
-  do_arch_entry(x86, compiler, avx2_decode_lut_tables_base64,           \
-                avx2_decode_lut_tables_base64,                          \
-                base64_AVX2_decode_LUT_tables_addr)                     \
-  do_stub(compiler, shuffle_base64)                                     \
-  do_arch_entry(x86, compiler, shuffle_base64, shuffle_base64,          \
-                base64_shuffle_addr)                                    \
-  do_stub(compiler, lookup_lo_base64)                                   \
-  do_arch_entry(x86, compiler, lookup_lo_base64, lookup_lo_base64,      \
-                base64_vbmi_lookup_lo_addr)                             \
-  do_stub(compiler, lookup_hi_base64)                                   \
-  do_arch_entry(x86, compiler, lookup_hi_base64, lookup_hi_base64,      \
-                base64_vbmi_lookup_hi_addr)                             \
-  do_stub(compiler, lookup_lo_base64url)                                \
-  do_arch_entry(x86, compiler, lookup_lo_base64url,                     \
-                lookup_lo_base64url,                                    \
-                base64_vbmi_lookup_lo_url_addr)                         \
-  do_stub(compiler, lookup_hi_base64url)                                \
-  do_arch_entry(x86, compiler, lookup_hi_base64url,                     \
-                lookup_hi_base64url,                                    \
-                base64_vbmi_lookup_hi_url_addr)                         \
-  do_stub(compiler, pack_vec_base64)                                    \
-  do_arch_entry(x86, compiler, pack_vec_base64, pack_vec_base64,        \
-                base64_vbmi_pack_vec_addr)                              \
-  do_stub(compiler, join_0_1_base64)                                    \
-  do_arch_entry(x86, compiler, join_0_1_base64, join_0_1_base64,        \
-                base64_vbmi_join_0_1_addr)                              \
-  do_stub(compiler, join_1_2_base64)                                    \
-  do_arch_entry(x86, compiler, join_1_2_base64, join_1_2_base64,        \
-                base64_vbmi_join_1_2_addr)                              \
-  do_stub(compiler, join_2_3_base64)                                    \
-  do_arch_entry(x86, compiler, join_2_3_base64, join_2_3_base64,        \
-                base64_vbmi_join_2_3_addr)                              \
-  do_stub(compiler, encoding_table_base64)                              \
-  do_arch_entry(x86, compiler, encoding_table_base64,                   \
-                encoding_table_base64, base64_encoding_table_addr)      \
-  do_stub(compiler, decoding_table_base64)                              \
-  do_arch_entry(x86, compiler, decoding_table_base64,                   \
-                decoding_table_base64, base64_decoding_table_addr)      \
+  LP64_ONLY(                                                            \
+    /* x86_64 exposes these 3 stubs via a generic entry array */        \
+    /* oher arches use arch-specific entries */                         \
+    /* this really needs rationalising */                               \
+    do_stub(compiler, string_indexof_linear_ll)                         \
+    do_stub(compiler, string_indexof_linear_uu)                         \
+    do_stub(compiler, string_indexof_linear_ul)                         \
+    do_stub(compiler, pshuffle_byte_flip_mask_sha512)                   \
+    do_arch_entry(x86, compiler, pshuffle_byte_flip_mask_sha512,        \
+                  pshuffle_byte_flip_mask_addr_sha512,                  \
+                  pshuffle_byte_flip_mask_addr_sha512)                  \
+    do_stub(compiler, compress_perm_table32)                            \
+    do_arch_entry(x86, compiler, compress_perm_table32,                 \
+                  compress_perm_table32, compress_perm_table32)         \
+    do_stub(compiler, compress_perm_table64)                            \
+    do_arch_entry(x86, compiler, compress_perm_table64,                 \
+                  compress_perm_table64, compress_perm_table64)         \
+    do_stub(compiler, expand_perm_table32)                              \
+    do_arch_entry(x86, compiler, expand_perm_table32,                   \
+                  expand_perm_table32, expand_perm_table32)             \
+    do_stub(compiler, expand_perm_table64)                              \
+    do_arch_entry(x86, compiler, expand_perm_table64,                   \
+                  expand_perm_table64, expand_perm_table64)             \
+    do_stub(compiler, avx2_shuffle_base64)                              \
+    do_arch_entry(x86, compiler, avx2_shuffle_base64,                   \
+                  avx2_shuffle_base64, base64_avx2_shuffle_addr)        \
+    do_stub(compiler, avx2_input_mask_base64)                           \
+    do_arch_entry(x86, compiler, avx2_input_mask_base64,                \
+                  avx2_input_mask_base64,                               \
+                  base64_avx2_input_mask_addr)                          \
+    do_stub(compiler, avx2_lut_base64)                                  \
+    do_arch_entry(x86, compiler, avx2_lut_base64,                       \
+                  avx2_lut_base64, base64_avx2_lut_addr)                \
+    do_stub(compiler, avx2_decode_tables_base64)                        \
+    do_arch_entry(x86, compiler, avx2_decode_tables_base64,             \
+                  avx2_decode_tables_base64,                            \
+                  base64_AVX2_decode_tables_addr)                       \
+    do_stub(compiler, avx2_decode_lut_tables_base64)                    \
+    do_arch_entry(x86, compiler, avx2_decode_lut_tables_base64,         \
+                  avx2_decode_lut_tables_base64,                        \
+                  base64_AVX2_decode_LUT_tables_addr)                   \
+    do_stub(compiler, shuffle_base64)                                   \
+    do_arch_entry(x86, compiler, shuffle_base64, shuffle_base64,        \
+                  base64_shuffle_addr)                                  \
+    do_stub(compiler, lookup_lo_base64)                                 \
+    do_arch_entry(x86, compiler, lookup_lo_base64, lookup_lo_base64,    \
+                  base64_vbmi_lookup_lo_addr)                           \
+    do_stub(compiler, lookup_hi_base64)                                 \
+    do_arch_entry(x86, compiler, lookup_hi_base64, lookup_hi_base64,    \
+                  base64_vbmi_lookup_hi_addr)                           \
+    do_stub(compiler, lookup_lo_base64url)                              \
+    do_arch_entry(x86, compiler, lookup_lo_base64url,                   \
+                  lookup_lo_base64url,                                  \
+                  base64_vbmi_lookup_lo_url_addr)                       \
+    do_stub(compiler, lookup_hi_base64url)                              \
+    do_arch_entry(x86, compiler, lookup_hi_base64url,                   \
+                  lookup_hi_base64url,                                  \
+                  base64_vbmi_lookup_hi_url_addr)                       \
+    do_stub(compiler, pack_vec_base64)                                  \
+    do_arch_entry(x86, compiler, pack_vec_base64, pack_vec_base64,      \
+                  base64_vbmi_pack_vec_addr)                            \
+    do_stub(compiler, join_0_1_base64)                                  \
+    do_arch_entry(x86, compiler, join_0_1_base64, join_0_1_base64,      \
+                  base64_vbmi_join_0_1_addr)                            \
+    do_stub(compiler, join_1_2_base64)                                  \
+    do_arch_entry(x86, compiler, join_1_2_base64, join_1_2_base64,      \
+                  base64_vbmi_join_1_2_addr)                            \
+    do_stub(compiler, join_2_3_base64)                                  \
+    do_arch_entry(x86, compiler, join_2_3_base64, join_2_3_base64,      \
+                  base64_vbmi_join_2_3_addr)                            \
+    do_stub(compiler, encoding_table_base64)                            \
+    do_arch_entry(x86, compiler, encoding_table_base64,                 \
+                  encoding_table_base64, base64_encoding_table_addr)    \
+    do_stub(compiler, decoding_table_base64)                            \
+    do_arch_entry(x86, compiler, decoding_table_base64,                 \
+                  decoding_table_base64, base64_decoding_table_addr)    \
+  )                                                                     \
 
 
 #define STUBGEN_FINAL_BLOBS_ARCH_DO(do_stub,                            \
                                     do_arch_blob,                       \
                                     do_arch_entry,                      \
                                     do_arch_entry_init)                 \
-  do_arch_blob(final, 31000                                             \
-               WINDOWS_ONLY(+22000) ZGC_ONLY(+20000))                   \
+  do_arch_blob(final, 11000 LP64_ONLY(+20000)                           \
+               WINDOWS_ONLY(+22000) ZGC_ONLY(+20000))                    \
 
 #endif // CPU_X86_STUBDECLARATIONS_HPP

src/hotspot/cpu/x86/stubRoutines_x86.cpp

@@ -46,8 +46,10 @@ STUBGEN_ARCH_ENTRIES_DO(DEFINE_ARCH_ENTRY, DEFINE_ARCH_ENTRY_INIT)
 #undef DEFINE_ARCH_ENTRY
 
 address StubRoutines::x86::_k256_adr = nullptr;
+#ifdef _LP64
 address StubRoutines::x86::_k256_W_adr = nullptr;
 address StubRoutines::x86::_k512_W_addr = nullptr;
+#endif
 
 const uint64_t StubRoutines::x86::_crc_by128_masks[] =
 {
@@ -144,6 +146,7 @@ const juint StubRoutines::x86::_crc_table[] =
     0x2d02ef8dUL
 };
 
+#ifdef _LP64
 const juint StubRoutines::x86::_crc_table_avx512[] =
 {
     0xe95c1271UL, 0x00000000UL, 0xce3371cbUL, 0x00000000UL,
@@ -190,6 +193,7 @@ const juint StubRoutines::x86::_shuf_table_crc32_avx512[] =
     0x83828100UL, 0x87868584UL, 0x8b8a8988UL, 0x8f8e8d8cUL,
     0x03020100UL, 0x07060504UL, 0x0b0a0908UL, 0x000e0d0cUL
 };
+#endif // _LP64
 
 const jint StubRoutines::x86::_arrays_hashcode_powers_of_31[] =
 {
@@ -352,6 +356,7 @@ ATTRIBUTE_ALIGNED(64) const juint StubRoutines::x86::_k256[] =
     0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
 };
 
+#ifdef _LP64
 // used in MacroAssembler::sha256_AVX2
 // dynamically built from _k256
 ATTRIBUTE_ALIGNED(64) juint StubRoutines::x86::_k256_W[2*sizeof(StubRoutines::x86::_k256)];
@@ -400,3 +405,4 @@ ATTRIBUTE_ALIGNED(64) const julong StubRoutines::x86::_k512_W[] =
     0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL,
     0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL,
 };
+#endif

src/hotspot/cpu/x86/stubRoutines_x86.hpp

@@ -75,16 +75,39 @@ public:
 #undef DEFINE_ARCH_ENTRY_GETTER_INIT
 #undef DEFINE_ARCH_GETTER_ENTRY
 
+
+#ifndef _LP64
+
+  static jint    _fpu_cntrl_wrd_std;
+  static jint    _fpu_cntrl_wrd_24;
+  static jint    _fpu_cntrl_wrd_trunc;
+
+  static jint    _fpu_subnormal_bias1[3];
+  static jint    _fpu_subnormal_bias2[3];
+
+  static address addr_fpu_cntrl_wrd_std()     { return (address)&_fpu_cntrl_wrd_std;   }
+  static address addr_fpu_cntrl_wrd_24()      { return (address)&_fpu_cntrl_wrd_24;    }
+  static address addr_fpu_cntrl_wrd_trunc()   { return (address)&_fpu_cntrl_wrd_trunc; }
+  static address addr_fpu_subnormal_bias1()   { return (address)&_fpu_subnormal_bias1; }
+  static address addr_fpu_subnormal_bias2()   { return (address)&_fpu_subnormal_bias2; }
+
+  static jint    fpu_cntrl_wrd_std()          { return _fpu_cntrl_wrd_std; }
+#endif // !LP64
+
  private:
   static jint    _mxcsr_std;
+#ifdef _LP64
   static jint    _mxcsr_rz;
+#endif // _LP64
   // masks and table for CRC32
   static const uint64_t _crc_by128_masks[];
   static const juint    _crc_table[];
+#ifdef _LP64
   static const juint    _crc_by128_masks_avx512[];
   static const juint    _crc_table_avx512[];
   static const juint    _crc32c_table_avx512[];
   static const juint    _shuf_table_crc32_avx512[];
+#endif // _LP64
   // table for CRC32C
   static juint* _crc32c_table;
   // table for arrays_hashcode
@@ -92,22 +115,30 @@ public:
   //k256 table for sha256
   static const juint _k256[];
   static address _k256_adr;
+#ifdef _LP64
   static juint _k256_W[];
   static address _k256_W_adr;
   static const julong _k512_W[];
   static address _k512_W_addr;
+#endif
 
  public:
   static address addr_mxcsr_std()        { return (address)&_mxcsr_std; }
+#ifdef _LP64
   static address addr_mxcsr_rz()        { return (address)&_mxcsr_rz; }
+#endif // _LP64
   static address crc_by128_masks_addr()  { return (address)_crc_by128_masks; }
+#ifdef _LP64
   static address crc_by128_masks_avx512_addr()  { return (address)_crc_by128_masks_avx512; }
   static address shuf_table_crc32_avx512_addr()  { return (address)_shuf_table_crc32_avx512; }
   static address crc_table_avx512_addr()  { return (address)_crc_table_avx512; }
   static address crc32c_table_avx512_addr()  { return (address)_crc32c_table_avx512; }
+#endif // _LP64
   static address k256_addr()      { return _k256_adr; }
+#ifdef _LP64
   static address k256_W_addr()    { return _k256_W_adr; }
   static address k512_W_addr()    { return _k512_W_addr; }
+#endif
 
   static address arrays_hashcode_powers_of_31() { return (address)_arrays_hashcode_powers_of_31; }
   static void generate_CRC32C_table(bool is_pclmulqdq_supported);

src/hotspot/cpu/x86/vm_version_x86.cpp

@@ -3062,10 +3062,6 @@ uint64_t VM_Version::CpuidInfo::feature_flags() const {
     result |= CPU_TSCINV_BIT;
   if (std_cpuid1_ecx.bits.aes != 0)
     result |= CPU_AES;
-  if (ext_cpuid1_ecx.bits.lzcnt != 0)
-    result |= CPU_LZCNT;
-  if (ext_cpuid1_ecx.bits.prefetchw != 0)
-    result |= CPU_3DNOW_PREFETCH;
   if (sef_cpuid7_ebx.bits.erms != 0)
     result |= CPU_ERMS;
   if (sef_cpuid7_edx.bits.fast_short_rep_mov != 0)
@@ -3084,36 +3080,48 @@ uint64_t VM_Version::CpuidInfo::feature_flags() const {
     result |= CPU_FMA;
   if (sef_cpuid7_ebx.bits.clflushopt != 0)
     result |= CPU_FLUSHOPT;
-  if (sef_cpuid7_ebx.bits.clwb != 0)
-    result |= CPU_CLWB;
   if (ext_cpuid1_edx.bits.rdtscp != 0)
     result |= CPU_RDTSCP;
   if (sef_cpuid7_ecx.bits.rdpid != 0)
     result |= CPU_RDPID;
 
-  // AMD|Hygon additional features.
+  // AMD|Hygon features.
   if (is_amd_family()) {
-    // PREFETCHW was checked above, check TDNOW here.
-    if ((ext_cpuid1_edx.bits.tdnow != 0))
+    if ((ext_cpuid1_edx.bits.tdnow != 0) ||
+        (ext_cpuid1_ecx.bits.prefetchw != 0))
       result |= CPU_3DNOW_PREFETCH;
+    if (ext_cpuid1_ecx.bits.lzcnt != 0)
+      result |= CPU_LZCNT;
     if (ext_cpuid1_ecx.bits.sse4a != 0)
       result |= CPU_SSE4A;
   }
 
-  // Intel additional features.
+  // Intel features.
   if (is_intel()) {
+    if (ext_cpuid1_ecx.bits.lzcnt != 0) {
+      result |= CPU_LZCNT;
+    }
+    if (ext_cpuid1_ecx.bits.prefetchw != 0) {
+      result |= CPU_3DNOW_PREFETCH;
+    }
+    if (sef_cpuid7_ebx.bits.clwb != 0) {
+      result |= CPU_CLWB;
+    }
     if (sef_cpuid7_edx.bits.serialize != 0)
       result |= CPU_SERIALIZE;
+
     if (_cpuid_info.sef_cpuid7_edx.bits.avx512_fp16 != 0)
       result |= CPU_AVX512_FP16;
   }
 
-  // ZX additional features.
+  // ZX features.
   if (is_zx()) {
-    // We do not know if these are supported by ZX, so we cannot trust
-    // common CPUID bit for them.
-    assert((result & CPU_CLWB) == 0, "Check if it is supported?");
-    result &= ~CPU_CLWB;
+    if (ext_cpuid1_ecx.bits.lzcnt != 0) {
+      result |= CPU_LZCNT;
+    }
+    if (ext_cpuid1_ecx.bits.prefetchw != 0) {
+      result |= CPU_3DNOW_PREFETCH;
+    }
   }
 
   // Protection key features.

src/hotspot/cpu/x86/x86_64.ad

@@ -7396,7 +7396,7 @@ instruct addL_mem_imm(memory dst, immL32 src, rFlagsReg cr)
   ins_pipe(ialu_mem_imm);
 %}
 
-instruct incL_rReg(rRegL dst, immL1 src, rFlagsReg cr)
+instruct incL_rReg(rRegI dst, immL1 src, rFlagsReg cr)
 %{
   predicate(!UseAPX && UseIncDec);
   match(Set dst (AddL dst src));
@@ -7409,7 +7409,7 @@ instruct incL_rReg(rRegL dst, immL1 src, rFlagsReg cr)
   ins_pipe(ialu_reg);
 %}
 
-instruct incL_rReg_ndd(rRegL dst, rRegI src, immL1 val, rFlagsReg cr)
+instruct incL_rReg_ndd(rRegI dst, rRegI src, immL1 val, rFlagsReg cr)
 %{
   predicate(UseAPX && UseIncDec);
   match(Set dst (AddL src val));
@@ -7422,7 +7422,7 @@ instruct incL_rReg_ndd(rRegL dst, rRegI src, immL1 val, rFlagsReg cr)
   ins_pipe(ialu_reg);
 %}
 
-instruct incL_rReg_mem_ndd(rRegL dst, memory src, immL1 val, rFlagsReg cr)
+instruct incL_rReg_mem_ndd(rRegI dst, memory src, immL1 val, rFlagsReg cr)
 %{
   predicate(UseAPX && UseIncDec);
   match(Set dst (AddL (LoadL src) val));
@@ -11345,7 +11345,7 @@ instruct xorL_rReg_mem_rReg_ndd(rRegL dst, memory src1, rRegL src2, rFlagsReg cr
   ins_cost(150);
   format %{ "exorq    $dst, $src1, $src2\t# long ndd" %}
   ins_encode %{
-    __ exorq($dst$$Register, $src1$$Address, $src2$$Register, false);
+    __ exorq($dst$$Register, $src1$$Address, $src1$$Register, false);
   %}
   ins_pipe(ialu_reg_mem);
 %}

src/hotspot/share/cds/lambdaFormInvokers.cpp

@@ -211,6 +211,7 @@ void LambdaFormInvokers::regenerate_class(char* class_name, ClassFileStream& st,
                                                    class_name_sym,
                                                    cld,
                                                    cl_info,
+                                                   false, // pick_newest
                                                    CHECK);
 
   assert(result->java_mirror() != nullptr, "must be");

src/hotspot/share/ci/ciBaseObject.cpp

@@ -31,7 +31,7 @@
 //
 // Set the unique identity number of a ciBaseObject.
 void ciBaseObject::set_ident(uint id) {
-  assert(_ident == 0, "must only initialize once");
+  assert(AllowEnhancedClassRedefinition || _ident == 0, "must only initialize once");
   _ident = id;
 }
 

src/hotspot/share/ci/ciEnv.cpp

@@ -255,7 +255,7 @@ ciEnv::ciEnv(Arena* arena) : _ciEnv_arena(mtCompiler, Arena::Tag::tag_cienv) {
   _break_at_compile = false;
   _compiler_data = nullptr;
 #ifndef PRODUCT
-  assert(firstEnv, "must be first");
+  assert(AllowEnhancedClassRedefinition || firstEnv, "must be first");
   firstEnv = false;
 #endif /* !PRODUCT */
 

src/hotspot/share/ci/ciKlass.hpp

@@ -139,6 +139,7 @@ public:
 
   juint prototype_header_offset();
   uintptr_t prototype_header();
+  Klass* new_version() { return get_Klass()->new_version(); }
 };
 
 #endif // SHARE_CI_CIKLASS_HPP

src/hotspot/share/ci/ciObjectFactory.cpp

@@ -73,7 +73,10 @@ GrowableArray<ciMetadata*>* ciObjectFactory::_shared_ci_metadata = nullptr;
 ciSymbol*                 ciObjectFactory::_shared_ci_symbols[vmSymbols::number_of_symbols()];
 int                       ciObjectFactory::_shared_ident_limit = 0;
 volatile bool             ciObjectFactory::_initialized = false;
+volatile bool             ciObjectFactory::_reinitialize_vm_klasses = false;
 
+// TODO: review...
+Arena* ciObjectFactory::_initial_arena = nullptr;
 
 // ------------------------------------------------------------------
 // ciObjectFactory::ciObjectFactory
@@ -109,6 +112,9 @@ void ciObjectFactory::initialize() {
   // compiler thread that initializes the initial ciObjectFactory which
   // creates the shared ciObjects that all later ciObjectFactories use.
   Arena* arena = new (mtCompiler) Arena(mtCompiler, Arena::Tag::tag_cienv);
+  if (AllowEnhancedClassRedefinition) {
+    ciObjectFactory::_initial_arena = arena;
+  }
   ciEnv initial(arena);
   ciEnv* env = ciEnv::current();
   env->_factory->init_shared_objects();
@@ -117,6 +123,16 @@ void ciObjectFactory::initialize() {
 
 }
 
+// (DCEVM) vm classes could be modified
+void ciObjectFactory::reinitialize_vm_classes_dcevm() {
+  // TODO: compiler crashes after 'delete _initial_arena;'
+  // delete ciObjectFactory::_initial_arena;
+  _initialized = false;
+  ciObjectFactory::initialize();
+  _reinitialize_vm_klasses = false;
+  _initialized = true;
+}
+
 void ciObjectFactory::init_shared_objects() {
 
   _next_ident = 1;  // start numbering CI objects at 1
@@ -719,3 +735,28 @@ void ciObjectFactory::print() {
              _unloaded_instances.length(),
              _unloaded_klasses.length());
 }
+
+
+int ciObjectFactory::compare_cimetadata(ciMetadata** a, ciMetadata** b) {
+  Metadata* am = (*a)->constant_encoding();
+  Metadata* bm = (*b)->constant_encoding();
+  return ((am > bm) ? 1 : ((am == bm) ? 0 : -1));
+}
+
+// FIXME: review... Resoring the ciObject arrays after class redefinition
+void ciObjectFactory::resort_shared_ci_metadata() {
+  if (_shared_ci_metadata == nullptr) return;
+  _shared_ci_metadata->sort(ciObjectFactory::compare_cimetadata);
+
+#ifdef ASSERT
+  if (CIObjectFactoryVerify) {
+    Metadata* last = nullptr;
+    for (int j = 0; j< _shared_ci_metadata->length(); j++) {
+      Metadata* o = _shared_ci_metadata->at(j)->constant_encoding();
+      assert(last < o, "out of order");
+      last = o;
+    }
+  }
+#endif // ASSERT
+}
+

src/hotspot/share/ci/ciObjectFactory.hpp

@@ -41,9 +41,11 @@ class ciObjectFactory : public ArenaObj {
 
 private:
   static volatile bool _initialized;
+  static volatile bool _reinitialize_vm_klasses;
   static GrowableArray<ciMetadata*>* _shared_ci_metadata;
   static ciSymbol*                 _shared_ci_symbols[];
   static int                       _shared_ident_limit;
+  static Arena*                    _initial_arena;
 
   Arena*                           _arena;
   GrowableArray<ciMetadata*>       _ci_metadata;
@@ -88,8 +90,13 @@ private:
 
   ciInstance* get_unloaded_instance(ciInstanceKlass* klass);
 
+  static int compare_cimetadata(ciMetadata** a, ciMetadata** b);
 public:
   static bool is_initialized() { return _initialized; }
+  // (DCEVM)
+  static bool is_reinitialize_vm_klasses() { return _reinitialize_vm_klasses; }
+  static void set_reinitialize_vm_klasses() { _reinitialize_vm_klasses = true; }
+  static void reinitialize_vm_classes_dcevm();
 
   static void initialize();
   void init_shared_objects();
@@ -144,6 +151,8 @@ public:
 
   void print_contents();
   void print();
+
+  static void resort_shared_ci_metadata();
 };
 
 #endif // SHARE_CI_CIOBJECTFACTORY_HPP

src/hotspot/share/classfile/classFileParser.cpp

@@ -826,6 +826,9 @@ void ClassFileParser::parse_interfaces(const ClassFileStream* const stream,
                                                          false, CHECK);
       }
 
+      // (DCEVM) pick newest
+      interf = (Klass *) maybe_newest(interf);
+
       if (!interf->is_interface()) {
         THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(),
                   err_msg("class %s can not implement %s, because it is not an interface (%s)",
@@ -3795,7 +3798,8 @@ const InstanceKlass* ClassFileParser::parse_super_class(ConstantPool* const cp,
     // However, make sure it is not an array type.
     bool is_array = false;
     if (cp->tag_at(super_class_index).is_klass()) {
-      super_klass = InstanceKlass::cast(cp->resolved_klass_at(super_class_index));
+      // (DCEVM) pick newest
+      super_klass = InstanceKlass::cast(maybe_newest(cp->resolved_klass_at(super_class_index)));
       if (need_verify)
         is_array = super_klass->is_array_klass();
     } else if (need_verify) {
@@ -3935,7 +3939,10 @@ void ClassFileParser::set_precomputed_flags(InstanceKlass* ik) {
   if (!_has_empty_finalizer) {
     if (_has_finalizer ||
         (super != nullptr && super->has_finalizer())) {
-      ik->set_has_finalizer();
+        // FIXME - (DCEVM) this is condition from previous DCEVM version, however after reload a new finalize() method is not active
+        if (ik->old_version() == nullptr || ik->old_version()->has_finalizer()) {
+          ik->set_has_finalizer();
+        }
     }
   }
 
@@ -5262,6 +5269,7 @@ ClassFileParser::ClassFileParser(ClassFileStream* stream,
                                  ClassLoaderData* loader_data,
                                  const ClassLoadInfo* cl_info,
                                  Publicity pub_level,
+                                 const bool pick_newest,
                                  TRAPS) :
   _stream(stream),
   _class_name(nullptr),
@@ -5320,7 +5328,8 @@ ClassFileParser::ClassFileParser(ClassFileStream* stream,
   _has_contended_fields(false),
   _has_finalizer(false),
   _has_empty_finalizer(false),
-  _max_bootstrap_specifier_index(-1) {
+  _max_bootstrap_specifier_index(-1),
+  _pick_newest(pick_newest) {
 
   _class_name = name != nullptr ? name : vmSymbols::unknown_class_name();
   _class_name->increment_refcount();
@@ -5707,16 +5716,18 @@ void ClassFileParser::post_process_parsed_stream(const ClassFileStream* const st
         CHECK);
     }
     Handle loader(THREAD, _loader_data->class_loader());
+    Klass* super_klass;
     if (loader.is_null() && super_class_name == vmSymbols::java_lang_Object()) {
-      _super_klass = vmClasses::Object_klass();
+      super_klass = vmClasses::Object_klass();
     } else {
-      _super_klass = (const InstanceKlass*)
+      super_klass = (InstanceKlass*)
                        SystemDictionary::resolve_super_or_fail(_class_name,
                                                                super_class_name,
                                                                loader,
                                                                true,
                                                                CHECK);
     }
+    _super_klass = (InstanceKlass*) maybe_newest(super_klass);
   }
 
   if (_super_klass != nullptr) {

src/hotspot/share/classfile/classFileParser.hpp

@@ -197,6 +197,9 @@ class ClassFileParser {
   bool _has_empty_finalizer;
   int _max_bootstrap_specifier_index;  // detects BSS values
 
+  // (DCEVM) Enhanced class redefinition
+  const bool _pick_newest;
+
   void parse_stream(const ClassFileStream* const stream, TRAPS);
 
   void mangle_hidden_class_name(InstanceKlass* const ik);
@@ -484,6 +487,8 @@ class ClassFileParser {
                                TRAPS);
 
   void update_class_name(Symbol* new_name);
+  // (DCEVM) Enhanced class redefinition
+  inline const Klass* maybe_newest(const Klass* klass) const { return klass != NULL && _pick_newest ? klass->newest_version() : klass; }
 
  public:
   ClassFileParser(ClassFileStream* stream,
@@ -491,6 +496,7 @@ class ClassFileParser {
                   ClassLoaderData* loader_data,
                   const ClassLoadInfo* cl_info,
                   Publicity pub_level,
+                  const bool pick_newest,
                   TRAPS);
 
   ~ClassFileParser();
@@ -521,6 +527,7 @@ class ClassFileParser {
   ClassLoaderData* loader_data() const { return _loader_data; }
   const Symbol* class_name() const { return _class_name; }
   const InstanceKlass* super_klass() const { return _super_klass; }
+  Array<InstanceKlass*>* local_interfaces() const { return _local_interfaces; }
 
   ReferenceType super_reference_type() const;
   bool is_instance_ref_klass() const;

src/hotspot/share/classfile/classLoader.cpp

@@ -1098,6 +1098,7 @@ InstanceKlass* ClassLoader::load_class(Symbol* name, PackageEntry* pkg_entry, bo
                                                            name,
                                                            loader_data,
                                                            cl_info,
+                                                           false, // pick_newest
                                                            CHECK_NULL);
   result->set_classpath_index(classpath_index);
   return result;

src/hotspot/share/classfile/classLoaderData.cpp

@@ -651,6 +651,15 @@ Dictionary* ClassLoaderData::create_dictionary() {
   return new Dictionary(this, size);
 }
 
+void ClassLoaderData::exchange_holders(ClassLoaderData* cld) {
+  oop holder_oop = _holder.peek();
+  _holder.replace(cld->_holder.peek());
+  cld->_holder.replace(holder_oop);
+  WeakHandle exchange = _holder;
+  _holder = cld->_holder;
+  cld->_holder = exchange;
+}
+
 // Tell the GC to keep this klass alive. Needed while iterating ClassLoaderDataGraph,
 // and any runtime code that uses klasses.
 oop ClassLoaderData::holder() const {

src/hotspot/share/classfile/classLoaderData.hpp

@@ -208,6 +208,8 @@ private:
   // Resolving the holder keeps this CLD alive for the current GC cycle.
   oop holder() const;
   void keep_alive() const { (void)holder(); }
+  // (DCEVM)
+  void exchange_holders(ClassLoaderData* cld);
 
   void classes_do(void f(Klass* const));
 

src/hotspot/share/classfile/classLoaderDataGraph.cpp

@@ -352,6 +352,38 @@ void ClassLoaderDataGraph::verify_dictionary() {
   }
 }
 
+// (DCEVM) - iterate over dict classes
+void ClassLoaderDataGraph::dictionary_classes_do(KlassClosure* klass_closure) {
+  ClassLoaderDataGraphIterator iter;
+  while (ClassLoaderData* cld = iter.get_next()) {
+    if (cld->dictionary() != nullptr) {
+      cld->dictionary()->classes_do(klass_closure);
+    }
+  }
+}
+
+// (DCEVM) rollback redefined classes
+void ClassLoaderDataGraph::rollback_redefinition() {
+  ClassLoaderDataGraphIterator iter;
+  while (ClassLoaderData* cld = iter.get_next()) {
+    if (cld->dictionary() != nullptr) {
+      cld->dictionary()->rollback_redefinition();
+    }
+  }
+}
+
+// (DCEVM) - iterate over all classes in all dictionaries
+bool ClassLoaderDataGraph::dictionary_classes_do_update_klass(Thread* current, Symbol* name, InstanceKlass* k, InstanceKlass* old_klass) {
+  bool ok = false;
+  ClassLoaderDataGraphIterator iter;
+  while (ClassLoaderData* cld = iter.get_next()) {
+    if (cld->dictionary() != nullptr) {
+      ok = cld->dictionary()->update_klass(current, name, k, old_klass) || ok;
+    }
+  }
+  return ok;
+}
+
 void ClassLoaderDataGraph::print_dictionary(outputStream* st) {
   ClassLoaderDataGraphIterator iter;
   while (ClassLoaderData *cld = iter.get_next()) {

src/hotspot/share/classfile/classLoaderDataGraph.hpp

@@ -83,6 +83,7 @@ class ClassLoaderDataGraph : public AllStatic {
   // for redefinition.  These classes are removed during the next class unloading.
   // Walking the ClassLoaderDataGraph also includes hidden classes.
   static void classes_do(KlassClosure* klass_closure);
+
   static void classes_do(void f(Klass* const));
   static void methods_do(void f(Method*));
   static void modules_do_keepalive(void f(ModuleEntry*));
@@ -100,6 +101,11 @@ class ClassLoaderDataGraph : public AllStatic {
   // Called from VMOperation
   static void walk_metadata_and_clean_metaspaces();
 
+  // (DCEVM) Enhanced class redefinition
+  static void dictionary_classes_do(KlassClosure* klass_closure);
+  static void rollback_redefinition();
+  static bool dictionary_classes_do_update_klass(Thread* current, Symbol* name, InstanceKlass* k, InstanceKlass* old_klass);
+
   static void verify_dictionary();
   static void print_dictionary(outputStream* st);
   static void print_table_statistics(outputStream* st);

src/hotspot/share/classfile/dictionary.cpp

@@ -91,6 +91,31 @@ void Dictionary::classes_do(void f(InstanceKlass*)) {
   _table->do_scan(Thread::current(), doit);
 }
 
+void Dictionary::classes_do_safepoint(void f(InstanceKlass*)) {
+    auto doit = [&] (InstanceKlass** value) {
+        InstanceKlass* k = (*value);
+        if (loader_data() == k->class_loader_data()) {
+            f(k);
+        }
+        return true;
+    };
+
+    _table->do_safepoint_scan(doit);
+}
+
+// (DCEVM) iterate over dict entry
+void Dictionary::classes_do(KlassClosure* closure) {
+  auto doit = [&] (InstanceKlass** value) {
+    InstanceKlass* k = (*value);
+    if (loader_data() == k->class_loader_data()) {
+      closure->do_klass(k);
+    }
+    return true;
+  };
+
+  _table->do_scan(Thread::current(), doit);
+}
+
 // All classes, and their class loaders, including initiating class loaders
 void Dictionary::all_entries_do(KlassClosure* closure) {
   auto all_doit = [&] (InstanceKlass** value) {
@@ -179,7 +204,57 @@ InstanceKlass* Dictionary::find_class(Thread* current, Symbol* class_name) {
   bool needs_rehashing = false;
   _table->get(current, lookup, get, &needs_rehashing);
   assert (!needs_rehashing, "should never need rehashing");
-  return result;
+  return old_if_redefining(result);
+}
+
+class UpdateKlassDcevm : public StackObj {
+  InstanceKlass* _new_klass;
+  InstanceKlass* _old_klass;
+  bool _replaced;
+public:
+  UpdateKlassDcevm(InstanceKlass* new_klass, InstanceKlass* old_klass) :
+    _new_klass(new_klass),
+    _old_klass(old_klass),
+    _replaced(false) {
+  }
+
+  void operator()(InstanceKlass** old_table_value) {
+    assert(*old_table_value == _old_klass, "should be old class");
+    *old_table_value = _new_klass;
+    _replaced = true;
+  }
+
+  bool get_replaced() {
+    return _replaced;
+  }
+};
+
+// (DCEVM) replace old_class by new class in dictionary
+bool Dictionary::update_klass(Thread* current, Symbol* class_name, InstanceKlass* k, InstanceKlass* old_klass) {
+  UpdateKlassDcevm found(k, old_klass);
+
+  DictionaryLookup lookup(class_name);
+  InstanceKlass* result = nullptr;
+  bool needs_rehashing = false;
+  bool ret = _table->insert_get(current, lookup, old_klass, found);
+  return ret || found.get_replaced();
+}
+
+class RollBackDcevm : public StackObj {
+public:
+  bool operator()(InstanceKlass** table_value) {
+    InstanceKlass* k = *table_value;
+    if (k->is_redefining()) {
+      *table_value = (InstanceKlass*) k->old_version();
+    }
+    return true;
+  }
+};
+
+// (DCEVM) rollback redefinition
+void Dictionary::rollback_redefinition() {
+  RollBackDcevm rollback;
+  _table->do_scan(Thread::current(), rollback);
 }
 
 void Dictionary::print_size(outputStream* st) const {

src/hotspot/share/classfile/dictionary.hpp

@@ -63,6 +63,10 @@ public:
   InstanceKlass* find_class(Thread* current, Symbol* name);
 
   void classes_do(void f(InstanceKlass*));
+  // (DCEVM)
+  void classes_do_safepoint(void f(InstanceKlass*));
+  void classes_do(KlassClosure* closure);
+
   void all_entries_do(KlassClosure* closure);
   void classes_do(MetaspaceClosure* it);
 
@@ -71,6 +75,16 @@ public:
   void print_on(outputStream* st) const;
   void print_size(outputStream* st) const;
   void verify();
+
+  // (DCEVM) Enhanced class redefinition
+  bool update_klass(Thread* current, Symbol* class_name, InstanceKlass* k, InstanceKlass* old_klass);
+
+  void rollback_redefinition();
+private:
+  // (DCEVM) return old class if redefining in AllowEnhancedClassRedefinition, otherwise return "k"
+  static InstanceKlass* old_if_redefining(InstanceKlass* k) {
+    return (k != nullptr && k->is_redefining()) ? ((InstanceKlass* )k->old_version()) : k;
+  }
 };
 
 #endif // SHARE_CLASSFILE_DICTIONARY_HPP

src/hotspot/share/classfile/javaClasses.cpp

@@ -93,6 +93,7 @@
 #if INCLUDE_JVMCI
 #include "jvmci/jvmciJavaClasses.hpp"
 #endif
+#include "prims/jvmtiEnhancedRedefineClasses.hpp"
 
 #define DECLARE_INJECTED_FIELD(klass, name, signature, may_be_java)           \
   { VM_CLASS_ID(klass), VM_SYMBOL_ENUM_NAME(name##_name), VM_SYMBOL_ENUM_NAME(signature), may_be_java },
@@ -732,7 +733,8 @@ char* java_lang_String::as_utf8_string(oop java_string, typeArrayOop value, int
 }
 
 bool java_lang_String::equals(oop java_string, const jchar* chars, int len) {
-  assert(java_string->klass() == vmClasses::String_klass(),
+  assert(java_string->klass() == vmClasses::String_klass()
+         || (Universe::is_inside_redefinition() && java_string->klass()->newest_version() == vmClasses::String_klass()),
          "must be java_string");
   typeArrayOop value = java_lang_String::value_no_keepalive(java_string);
   int length = java_lang_String::length(java_string, value);
@@ -1496,7 +1498,8 @@ BasicType java_lang_Class::as_BasicType(oop java_class, Klass** reference_klass)
 
 oop java_lang_Class::primitive_mirror(BasicType t) {
   oop mirror = Universe::java_mirror(t);
-  assert(mirror != nullptr && mirror->is_a(vmClasses::Class_klass()), "must be a Class");
+  assert(mirror != nullptr && (mirror->is_a(vmClasses::Class_klass())
+         || (Universe::is_inside_redefinition() && vmClasses::Class_klass()->old_version() != NULL && mirror->is_a(vmClasses::Class_klass()->old_version()))), "must be a Class");
   assert(is_primitive(mirror), "must be primitive");
   return mirror;
 }
@@ -2847,6 +2850,8 @@ void java_lang_Throwable::fill_in_stack_trace(Handle throwable, const methodHand
         skip_throwableInit_check = true;
       }
     }
+    // (DCEVM): Line numbers from newest version must be used for EMCP-swapped methods
+    method = method->newest_version();
     if (method->is_hidden() || method->is_continuation_enter_intrinsic()) {
       if (skip_hidden) {
         if (total_count == 0) {
@@ -4188,6 +4193,62 @@ void java_lang_invoke_DirectMethodHandle::serialize_offsets(SerializeClosure* f)
 }
 #endif
 
+// Support for java_lang_invoke_DirectMethodHandle$StaticAccessor
+
+int java_lang_invoke_DirectMethodHandle_StaticAccessor::_static_offset_offset;
+
+long java_lang_invoke_DirectMethodHandle_StaticAccessor::static_offset(oop dmh) {
+  assert(_static_offset_offset != 0, "");
+  return dmh->long_field(_static_offset_offset);
+}
+
+void java_lang_invoke_DirectMethodHandle_StaticAccessor::set_static_offset(oop dmh, long static_offset) {
+  assert(_static_offset_offset != 0, "");
+  dmh->long_field_put(_static_offset_offset, static_offset);
+}
+
+#define DIRECTMETHODHANDLE_STATIC_ACCESSOR_FIELDS_DO(macro) \
+  macro(_static_offset_offset, k, vmSymbols::static_offset_name(), long_signature, false)
+
+void java_lang_invoke_DirectMethodHandle_StaticAccessor::compute_offsets() {
+  InstanceKlass* k = vmClasses::DirectMethodHandle_StaticAccessor_klass();
+  DIRECTMETHODHANDLE_STATIC_ACCESSOR_FIELDS_DO(FIELD_COMPUTE_OFFSET);
+}
+
+#if INCLUDE_CDS
+void java_lang_invoke_DirectMethodHandle_StaticAccessor::serialize_offsets(SerializeClosure* f) {
+  DIRECTMETHODHANDLE_STATIC_ACCESSOR_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
+}
+#endif
+
+// Support for java_lang_invoke_DirectMethodHandle$Accessor
+
+int java_lang_invoke_DirectMethodHandle_Accessor::_field_offset_offset;
+
+int java_lang_invoke_DirectMethodHandle_Accessor::field_offset(oop dmh) {
+  assert(_field_offset_offset != 0, "");
+  return dmh->int_field(_field_offset_offset);
+}
+
+void java_lang_invoke_DirectMethodHandle_Accessor::set_field_offset(oop dmh, int field_offset) {
+  assert(_field_offset_offset != 0, "");
+  dmh->int_field_put(_field_offset_offset, field_offset);
+}
+
+#define DIRECTMETHODHANDLE_ACCESSOR_FIELDS_DO(macro) \
+  macro(_field_offset_offset, k, vmSymbols::field_offset_name(), int_signature, false)
+
+void java_lang_invoke_DirectMethodHandle_Accessor::compute_offsets() {
+  InstanceKlass* k = vmClasses::DirectMethodHandle_Accessor_klass();
+  DIRECTMETHODHANDLE_ACCESSOR_FIELDS_DO(FIELD_COMPUTE_OFFSET);
+}
+
+#if INCLUDE_CDS
+void java_lang_invoke_DirectMethodHandle_Accessor::serialize_offsets(SerializeClosure* f) {
+  DIRECTMETHODHANDLE_ACCESSOR_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
+}
+#endif
+
 // Support for java_lang_invoke_MethodHandle
 
 int java_lang_invoke_MethodHandle::_type_offset;
@@ -5390,6 +5451,8 @@ void java_lang_InternalError::serialize_offsets(SerializeClosure* f) {
   f(java_lang_invoke_MethodType) \
   f(java_lang_invoke_CallSite) \
   f(java_lang_invoke_ConstantCallSite) \
+  f(java_lang_invoke_DirectMethodHandle_StaticAccessor) \
+  f(java_lang_invoke_DirectMethodHandle_Accessor) \
   f(java_lang_reflect_AccessibleObject) \
   f(java_lang_reflect_Method) \
   f(java_lang_reflect_Constructor) \

src/hotspot/share/classfile/javaClasses.hpp

@@ -267,7 +267,9 @@ class java_lang_Class : AllStatic {
   static void set_init_lock(oop java_class, oop init_lock);
   static void set_protection_domain(oop java_class, oop protection_domain);
   static void set_class_loader(oop java_class, oop class_loader);
+ public: // DCEVM
   static void set_component_mirror(oop java_class, oop comp_mirror);
+ private:
   static void initialize_mirror_fields(Klass* k, Handle mirror, Handle protection_domain,
                                        Handle classData, TRAPS);
   static void set_mirror_module_field(JavaThread* current, Klass* K, Handle mirror, Handle module);
@@ -1118,6 +1120,55 @@ class java_lang_invoke_DirectMethodHandle: AllStatic {
   static int member_offset()           { CHECK_INIT(_member_offset); }
 };
 
+// Interface to java.lang.invoke.DirectMethodHandle$StaticAccessor objects
+
+class java_lang_invoke_DirectMethodHandle_StaticAccessor: AllStatic {
+  friend class JavaClasses;
+
+ private:
+  static int _static_offset_offset;               // offset to static field
+
+  static void compute_offsets();
+
+ public:
+  // Accessors
+  static long      static_offset(oop dmh);
+  static void  set_static_offset(oop dmh, long value);
+
+  // Testers
+  static bool is_subclass(Klass* klass) {
+    return klass->is_subclass_of(vmClasses::DirectMethodHandle_StaticAccessor_klass());
+  }
+  static bool is_instance(oop obj);
+
+  static void serialize_offsets(SerializeClosure* f) NOT_CDS_RETURN;
+};
+
+// Interface to java.lang.invoke.DirectMethodHandle$Accessor objects
+
+class java_lang_invoke_DirectMethodHandle_Accessor: AllStatic {
+  friend class JavaClasses;
+
+ private:
+  static int _field_offset_offset;               // offset to field
+
+  static void compute_offsets();
+
+ public:
+  // Accessors
+  static int      field_offset(oop dmh);
+  static void set_field_offset(oop dmh, int value);
+
+  // Testers
+  static bool is_subclass(Klass* klass) {
+    return klass->is_subclass_of(vmClasses::DirectMethodHandle_Accessor_klass());
+  }
+  static bool is_instance(oop obj);
+
+  static void serialize_offsets(SerializeClosure* f) NOT_CDS_RETURN;
+};
+
+
 // Interface to java.lang.invoke.LambdaForm objects
 // (These are a private interface for managing adapter code generation.)
 

src/hotspot/share/classfile/javaClasses.inline.hpp

@@ -34,6 +34,7 @@
 #include "oops/oop.inline.hpp"
 #include "oops/oopsHierarchy.hpp"
 #include "oops/typeArrayOop.inline.hpp"
+#include "prims/jvmtiEnhancedRedefineClasses.hpp"
 
 void java_lang_String::set_coder(oop string, jbyte coder) {
   string->byte_field_put(_coder_offset, coder);
@@ -123,7 +124,8 @@ int java_lang_String::length(oop java_string) {
 }
 
 bool java_lang_String::is_instance(oop obj) {
-  return obj != nullptr && obj->klass() == vmClasses::String_klass();
+  return obj != nullptr && (obj->klass() == vmClasses::String_klass()
+         || (Universe::is_inside_redefinition() && obj->klass()->newest_version() == vmClasses::String_klass()));
 }
 
 // Accessors
@@ -264,11 +266,13 @@ inline bool java_lang_invoke_ConstantCallSite::is_instance(oop obj) {
 }
 
 inline bool java_lang_invoke_MemberName::is_instance(oop obj) {
-  return obj != nullptr && obj->klass() == vmClasses::MemberName_klass();
+  return obj != nullptr && (obj->klass() == vmClasses::MemberName_klass()
+                         || (Universe::is_inside_redefinition() && obj->klass()->newest_version() == vmClasses::MemberName_klass()));
 }
 
 inline bool java_lang_invoke_ResolvedMethodName::is_instance(oop obj) {
-  return obj != nullptr && obj->klass() == vmClasses::ResolvedMethodName_klass();
+  return obj != nullptr && (obj->klass() == vmClasses::ResolvedMethodName_klass()
+                         || (Universe::is_inside_redefinition() && obj->klass()->newest_version() == vmClasses::ResolvedMethodName_klass()));
 }
 
 inline bool java_lang_invoke_MethodType::is_instance(oop obj) {
@@ -280,7 +284,8 @@ inline bool java_lang_invoke_MethodHandle::is_instance(oop obj) {
 }
 
 inline bool java_lang_Class::is_instance(oop obj) {
-  return obj != nullptr && obj->klass() == vmClasses::Class_klass();
+  return obj != nullptr && (obj->klass() == vmClasses::Class_klass()
+                         || (Universe::is_inside_redefinition() && obj->klass()->newest_version() == vmClasses::Class_klass()));
 }
 
 inline Klass* java_lang_Class::as_Klass(oop java_class) {
@@ -317,6 +322,16 @@ inline size_t java_lang_Class::oop_size(oop java_class) {
 }
 
 inline bool java_lang_invoke_DirectMethodHandle::is_instance(oop obj) {
+  return obj != nullptr && (is_subclass(obj->klass())
+         || (Universe::is_inside_redefinition() && is_subclass(obj->klass()->newest_version())));
+}
+
+inline bool java_lang_invoke_DirectMethodHandle_StaticAccessor::is_instance(oop obj) {
+  return obj != nullptr && (is_subclass(obj->klass())
+         || (Universe::is_inside_redefinition() && is_subclass(obj->klass()->newest_version())));
+}
+
+inline bool java_lang_invoke_DirectMethodHandle_Accessor::is_instance(oop obj) {
   return obj != nullptr && is_subclass(obj->klass());
 }
 

src/hotspot/share/classfile/klassFactory.cpp

@@ -85,6 +85,7 @@ InstanceKlass* KlassFactory::check_shared_class_file_load_hook(
                              loader_data,
                              &cl_info,
                              ClassFileParser::BROADCAST, // publicity level
+                             false,
                              CHECK_NULL);
       const ClassInstanceInfo* cl_inst_info = cl_info.class_hidden_info_ptr();
       InstanceKlass* new_ik = parser.create_instance_klass(true, // changed_by_loadhook
@@ -171,6 +172,7 @@ InstanceKlass* KlassFactory::create_from_stream(ClassFileStream* stream,
                                                 Symbol* name,
                                                 ClassLoaderData* loader_data,
                                                 const ClassLoadInfo& cl_info,
+                                                const bool pick_newest,
                                                 TRAPS) {
   assert(stream != nullptr, "invariant");
   assert(loader_data != nullptr, "invariant");
@@ -200,6 +202,7 @@ InstanceKlass* KlassFactory::create_from_stream(ClassFileStream* stream,
                          loader_data,
                          &cl_info,
                          ClassFileParser::BROADCAST, // publicity level
+                         pick_newest,
                          CHECK_NULL);
 
   const ClassInstanceInfo* cl_inst_info = cl_info.class_hidden_info_ptr();

src/hotspot/share/classfile/klassFactory.hpp

@@ -64,6 +64,7 @@ class KlassFactory : AllStatic {
                                            Symbol* name,
                                            ClassLoaderData* loader_data,
                                            const ClassLoadInfo& cl_info,
+                                           const bool pick_newest,
                                            TRAPS);
   static InstanceKlass* check_shared_class_file_load_hook(
                                           InstanceKlass* ik,

src/hotspot/share/classfile/loaderConstraints.cpp

@@ -218,6 +218,21 @@ void LoaderConstraintTable::add_loader_constraint(Symbol* name, InstanceKlass* k
   }
 }
 
+// (DCEVM) update constraint entries to new classes, called from dcevm redefinition code only
+void LoaderConstraintTable::update_after_redefinition() {
+  auto update_old = [&] (SymbolHandle& key, ConstraintSet& set) {
+    int len = set.num_constraints();
+    for (int i = 0; i < len; i++) {
+      LoaderConstraint* probe = set.constraint_at(i);
+      if (probe->klass() != nullptr) {
+        // We swap the class with the newest version with an assumption that the hash will be the same
+        probe->set_klass((InstanceKlass*) probe->klass()->newest_version());
+      }
+    }
+  };
+  _loader_constraint_table->iterate_all(update_old);
+}
+
 class PurgeUnloadedConstraints : public StackObj {
  public:
   bool do_entry(SymbolHandle& name, ConstraintSet& set) {
@@ -526,6 +541,7 @@ void LoaderConstraintTable::verify() {
           guarantee(k == probe->klass(), "klass should be in dictionary");
           // If we don't find the class in the dictionary, it is
           // in the process of loading and may or may not be in the placeholder table.
+          guarantee(k == probe->klass() || (AllowEnhancedClassRedefinition && k->newest_version() == probe->klass()->newest_version()), "klass should be in dictionary");
         }
       }
       for (int n = 0; n< probe->num_loaders(); n++) {

src/hotspot/share/classfile/loaderConstraints.hpp

@@ -44,6 +44,9 @@ private:
                                        LoaderConstraint* pp2, InstanceKlass* klass);
 public:
   static void initialize();
+  // (DCEVM) update all klasses with newest version
+  static void update_after_redefinition();
+
   // Check class loader constraints
   static bool add_entry(Symbol* name, InstanceKlass* klass1, ClassLoaderData* loader1,
                         InstanceKlass* klass2, ClassLoaderData* loader2);

src/hotspot/share/classfile/systemDictionary.cpp

@@ -300,7 +300,7 @@ static void verify_dictionary_entry(Symbol* class_name, InstanceKlass* k) {
   Dictionary* dictionary = loader_data->dictionary();
   assert(class_name == k->name(), "Must be the same");
   InstanceKlass* kk = dictionary->find_class(JavaThread::current(), class_name);
-  assert(kk == k, "should be present in dictionary");
+  assert((kk == k && !k->is_redefining()) || (k->is_redefining() && kk == k->old_version()), "should be present in dictionary");
 }
 #endif
 
@@ -337,6 +337,7 @@ Klass* SystemDictionary::resolve_or_fail(Symbol* class_name, Handle class_loader
   if (HAS_PENDING_EXCEPTION || klass == nullptr) {
     handle_resolution_exception(class_name, throw_error, CHECK_NULL);
   }
+  assert(klass == nullptr || klass->new_version() == nullptr || klass->newest_version()->is_redefining(), "must be");
   return klass;
 }
 
@@ -785,11 +786,14 @@ InstanceKlass* SystemDictionary::resolve_hidden_class_from_stream(
                                                      Symbol* class_name,
                                                      Handle class_loader,
                                                      const ClassLoadInfo& cl_info,
+                                                     InstanceKlass* old_klass,
                                                      TRAPS) {
 
   EventClassLoad class_load_start_event;
   ClassLoaderData* loader_data;
 
+  bool is_redefining = (old_klass != nullptr);
+
   // - for hidden classes that are not strong: create a new CLD that has a class holder and
   //                                           whose loader is the Lookup class's loader.
   // - for hidden class: add the class to the Lookup class's loader's CLD.
@@ -804,8 +808,13 @@ InstanceKlass* SystemDictionary::resolve_hidden_class_from_stream(
                                                       class_name,
                                                       loader_data,
                                                       cl_info,
+                                                      is_redefining, // pick_newest
                                                       CHECK_NULL);
   assert(k != nullptr, "no klass created");
+  if (is_redefining && k != nullptr) {
+    k->set_redefining(true);
+    k->set_old_version(old_klass);
+  }
 
   // Hidden classes that are not strong must update ClassLoaderData holder
   // so that they can be unloaded when the mirror is no longer referenced.
@@ -841,10 +850,12 @@ InstanceKlass* SystemDictionary::resolve_class_from_stream(
                                                      Symbol* class_name,
                                                      Handle class_loader,
                                                      const ClassLoadInfo& cl_info,
+                                                     InstanceKlass* old_klass,
                                                      TRAPS) {
 
   HandleMark hm(THREAD);
 
+  bool is_redefining = (old_klass != nullptr);
   ClassLoaderData* loader_data = register_loader(class_loader);
 
   // Classloaders that support parallelism, e.g. bootstrap classloader,
@@ -859,6 +870,7 @@ InstanceKlass* SystemDictionary::resolve_class_from_stream(
  InstanceKlass* k = nullptr;
 
 #if INCLUDE_CDS
+  // FIXME: (DCEVM) what to do during redefinition?
   if (!CDSConfig::is_dumping_static_archive()) {
     k = SystemDictionaryShared::lookup_from_stream(class_name,
                                                    class_loader,
@@ -869,7 +881,12 @@ InstanceKlass* SystemDictionary::resolve_class_from_stream(
 #endif
 
   if (k == nullptr) {
-    k = KlassFactory::create_from_stream(st, class_name, loader_data, cl_info, CHECK_NULL);
+    k = KlassFactory::create_from_stream(st, class_name, loader_data, cl_info, is_redefining, CHECK_NULL);
+  }
+
+  if (is_redefining && k != nullptr) {
+    k->set_redefining(true);
+    k->set_old_version(old_klass);
   }
 
   assert(k != nullptr, "no klass created");
@@ -880,10 +897,10 @@ InstanceKlass* SystemDictionary::resolve_class_from_stream(
   // If a class loader supports parallel classloading, handle parallel define requests.
   // find_or_define_instance_class may return a different InstanceKlass,
   // in which case the old k would be deallocated
-  if (is_parallelCapable(class_loader)) {
+  if (is_parallelCapable(class_loader) && !is_redefining) {
     k = find_or_define_instance_class(h_name, class_loader, k, CHECK_NULL);
   } else {
-    define_instance_class(k, class_loader, THREAD);
+    define_instance_class(k, old_klass, class_loader, THREAD);
 
     // If defining the class throws an exception register 'k' for cleanup.
     if (HAS_PENDING_EXCEPTION) {
@@ -903,11 +920,12 @@ InstanceKlass* SystemDictionary::resolve_from_stream(ClassFileStream* st,
                                                      Symbol* class_name,
                                                      Handle class_loader,
                                                      const ClassLoadInfo& cl_info,
+                                                     InstanceKlass* old_klass,
                                                      TRAPS) {
   if (cl_info.is_hidden()) {
-    return resolve_hidden_class_from_stream(st, class_name, class_loader, cl_info, CHECK_NULL);
+    return resolve_hidden_class_from_stream(st, class_name, class_loader, cl_info, old_klass, CHECK_NULL);
   } else {
-    return resolve_class_from_stream(st, class_name, class_loader, cl_info, CHECK_NULL);
+    return resolve_class_from_stream(st, class_name, class_loader, cl_info, old_klass, CHECK_NULL);
   }
 }
 
@@ -1335,10 +1353,11 @@ static void post_class_define_event(InstanceKlass* k, const ClassLoaderData* def
   }
 }
 
-void SystemDictionary::define_instance_class(InstanceKlass* k, Handle class_loader, TRAPS) {
+void SystemDictionary::define_instance_class(InstanceKlass* k, InstanceKlass* old_klass, Handle class_loader, TRAPS) {
 
   ClassLoaderData* loader_data = k->class_loader_data();
   assert(loader_data->class_loader() == class_loader(), "they must be the same");
+  bool is_redefining = (old_klass != NULL);
 
   // Bootstrap and other parallel classloaders don't acquire a lock,
   // they use placeholder token.
@@ -1360,7 +1379,17 @@ void SystemDictionary::define_instance_class(InstanceKlass* k, Handle class_load
   // classloader lock held
   // Parallel classloaders will call find_or_define_instance_class
   // which will require a token to perform the define class
-  check_constraints(k, loader_data, true, CHECK);
+
+  if (is_redefining) {
+    // Update all dictionaries containing old_class to new_class
+    // outcome must be same as result of standard redefinition, that does not create a new Klass
+    ClassLoaderDataGraph_lock->lock();
+    Symbol*  name_h = k->name();
+    bool ok = ClassLoaderDataGraph::dictionary_classes_do_update_klass(THREAD, name_h, k, old_klass);
+    ClassLoaderDataGraph_lock->unlock();
+    assert (ok, "must have found old class and updated!");
+  }
+  check_constraints(k, loader_data, !is_redefining, CHECK);
 
   // Register class just loaded with class loader (placed in ArrayList)
   // Note we do this before updating the dictionary, as this can
@@ -1383,7 +1412,7 @@ void SystemDictionary::define_instance_class(InstanceKlass* k, Handle class_load
   update_dictionary(THREAD, k, loader_data);
 
   // notify jvmti
-  if (JvmtiExport::should_post_class_load()) {
+  if (!is_redefining && JvmtiExport::should_post_class_load()) {
     JvmtiExport::post_class_load(THREAD, k);
   }
   post_class_define_event(k, loader_data);
@@ -1455,7 +1484,7 @@ InstanceKlass* SystemDictionary::find_or_define_helper(Symbol* class_name, Handl
     }
   }
 
-  define_instance_class(k, class_loader, THREAD);
+  define_instance_class(k, NULL, class_loader, THREAD);
 
   // definer must notify any waiting threads
   {
@@ -1493,6 +1522,14 @@ InstanceKlass* SystemDictionary::find_or_define_instance_class(Symbol* class_nam
 }
 
 
+// (DCEVM) - remove from klass hierarchy
+void SystemDictionary::remove_from_hierarchy(InstanceKlass* k) {
+    assert(k != NULL, "just checking");
+
+  // remove receiver from sibling list
+  k->remove_from_sibling_list();
+}
+
 // ----------------------------------------------------------------------------
 // GC support
 
@@ -1600,7 +1637,7 @@ void SystemDictionary::check_constraints(InstanceKlass* k,
       // else - ok, class loaded by a different thread in parallel.
       // We should only have found it if it was done loading and ok to use.
 
-      if ((defining == true) || (k != check)) {
+      if ((defining == true) || (k != check && (!AllowEnhancedClassRedefinition || k->old_version() != check))) {
         throwException = true;
         ss.print("loader %s", loader_data->loader_name_and_id());
         ss.print(" attempted duplicate %s definition for %s. (%s)",
@@ -2303,7 +2340,7 @@ Handle SystemDictionary::link_method_handle_constant(Klass* caller,
 
   // call java.lang.invoke.MethodHandleNatives::linkMethodHandleConstant(Class caller, int refKind, Class callee, String name, Object type) -> MethodHandle
   JavaCallArguments args;
-  args.push_oop(Handle(THREAD, caller->java_mirror()));  // the referring class
+  args.push_oop(Handle(THREAD, caller->newest_version()->java_mirror()));  // the referring class
   args.push_int(ref_kind);
   args.push_oop(Handle(THREAD, callee->java_mirror()));  // the target class
   args.push_oop(name_str);

src/hotspot/share/classfile/systemDictionary.hpp

@@ -125,6 +125,7 @@ class SystemDictionary : AllStatic {
                                                          Symbol* class_name,
                                                          Handle class_loader,
                                                          const ClassLoadInfo& cl_info,
+                                                         InstanceKlass* old_klass,
                                                          TRAPS);
 
   // Resolve a class from stream (called by jni_DefineClass and JVM_DefineClass)
@@ -133,6 +134,7 @@ class SystemDictionary : AllStatic {
                                                   Symbol* class_name,
                                                   Handle class_loader,
                                                   const ClassLoadInfo& cl_info,
+                                                  InstanceKlass* old_klass,
                                                   TRAPS);
 
   static oop get_system_class_loader_impl(TRAPS);
@@ -144,6 +146,7 @@ class SystemDictionary : AllStatic {
                                             Symbol* class_name,
                                             Handle class_loader,
                                             const ClassLoadInfo& cl_info,
+                                            InstanceKlass* old_klass,
                                             TRAPS);
 
   // Lookup an already loaded class. If not found null is returned.
@@ -203,6 +206,9 @@ class SystemDictionary : AllStatic {
   // Initialization
   static void initialize(TRAPS);
 
+  // (DCEVM) Enhanced class redefinition
+  static void remove_from_hierarchy(InstanceKlass* k);
+
 public:
   // Returns java system loader
   static oop java_system_loader();
@@ -297,7 +303,7 @@ private:
   static Klass* resolve_array_class_or_null(Symbol* class_name,
                                             Handle class_loader,
                                             TRAPS);
-  static void define_instance_class(InstanceKlass* k, Handle class_loader, TRAPS);
+  static void define_instance_class(InstanceKlass* k, InstanceKlass* old_klass, Handle class_loader, TRAPS);
   static InstanceKlass* find_or_define_helper(Symbol* class_name,
                                               Handle class_loader,
                                               InstanceKlass* k, TRAPS);

src/hotspot/share/classfile/verifier.hpp

@@ -373,6 +373,7 @@ class ClassVerifier : public StackObj {
 
   VerificationType object_type() const;
 
+  InstanceKlass*      _klass_to_verify;
   InstanceKlass*      _klass;  // the class being verified
   methodHandle        _method; // current method being verified
   VerificationType    _this_type; // the verification type of the current class

src/hotspot/share/classfile/vmClassMacros.hpp

@@ -110,6 +110,8 @@
                                                                                                                 \
   /* support for dynamic typing */                                                                              \
   do_klass(DirectMethodHandle_klass,                    java_lang_invoke_DirectMethodHandle                   ) \
+  do_klass(DirectMethodHandle_StaticAccessor_klass,     java_lang_invoke_DirectMethodHandle_StaticAccessor    ) \
+  do_klass(DirectMethodHandle_Accessor_klass,           java_lang_invoke_DirectMethodHandle_Accessor          ) \
   do_klass(MethodHandle_klass,                          java_lang_invoke_MethodHandle                         ) \
   do_klass(VarHandle_klass,                             java_lang_invoke_VarHandle                            ) \
   do_klass(MemberName_klass,                            java_lang_invoke_MemberName                           ) \

src/hotspot/share/classfile/vmClasses.cpp

@@ -259,3 +259,20 @@ BasicType vmClasses::box_klass_type(Klass* k) {
   }
   return T_OBJECT;
 }
+
+bool vmClasses::update_vm_klass(InstanceKlass* old_klass, InstanceKlass* new_klass) {
+  for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
+    if (_box_klasses[i] == old_klass) {
+      _box_klasses[i] = new_klass;
+      break;
+    }
+  }
+
+  for (int id = static_cast<int>(vmClassID::FIRST); id < static_cast<int>(vmClassID::LIMIT); id++) {
+    if (_klasses[id] == old_klass) {
+      _klasses[id] = new_klass;
+      return true;
+    }
+  }
+  return false;
+}

src/hotspot/share/classfile/vmClasses.hpp

@@ -108,6 +108,10 @@ public:
   static bool Cloneable_klass_loaded()      { return is_loaded(VM_CLASS_AT(Cloneable_klass));          }
   static bool Parameter_klass_loaded()      { return is_loaded(VM_CLASS_AT(reflect_Parameter_klass));  }
   static bool ClassLoader_klass_loaded()    { return is_loaded(VM_CLASS_AT(ClassLoader_klass));        }
+
+  // (DCEVM) vmClasses could be modified
+  static bool update_vm_klass(InstanceKlass* new_klass, InstanceKlass* old_klass);
+
 };
 
 #endif // SHARE_CLASSFILE_VMCLASSES_HPP

src/hotspot/share/classfile/vmSymbols.hpp

@@ -313,6 +313,8 @@ class SerializeClosure;
   template(java_lang_invoke_CallSite,                 "java/lang/invoke/CallSite")                \
   template(java_lang_invoke_ConstantCallSite,         "java/lang/invoke/ConstantCallSite")        \
   template(java_lang_invoke_DirectMethodHandle,       "java/lang/invoke/DirectMethodHandle")      \
+  template(java_lang_invoke_DirectMethodHandle_StaticAccessor, "java/lang/invoke/DirectMethodHandle$StaticAccessor") \
+  template(java_lang_invoke_DirectMethodHandle_Accessor, "java/lang/invoke/DirectMethodHandle$Accessor") \
   template(java_lang_invoke_MutableCallSite,          "java/lang/invoke/MutableCallSite")         \
   template(java_lang_invoke_VolatileCallSite,         "java/lang/invoke/VolatileCallSite")        \
   template(java_lang_invoke_MethodHandle,             "java/lang/invoke/MethodHandle")            \
@@ -386,6 +388,8 @@ class SerializeClosure;
   template(interrupt_method_name,                     "interrupt")                                \
   template(exit_method_name,                          "exit")                                     \
   template(remove_method_name,                        "remove")                                   \
+  template(registerNatives_method_name,               "registerNatives")                          \
+  template(initIDs_method_name,                       "initIDs")                                  \
   template(parent_name,                               "parent")                                   \
   template(maxPriority_name,                          "maxPriority")                              \
   template(shutdown_name,                             "shutdown")                                 \
@@ -512,6 +516,9 @@ class SerializeClosure;
   template(maxThawingSize_name,                       "maxThawingSize")                           \
   template(lockStackSize_name,                        "lockStackSize")                            \
   template(objectWaiter_name,                         "objectWaiter")                             \
+  template(static_offset_name,                        "staticOffset")                             \
+  template(static_base_name,                          "staticBase")                               \
+  template(field_offset_name,                         "fieldOffset")                              \
                                                                                                   \
   /* name symbols needed by intrinsics */                                                         \
   VM_INTRINSICS_DO(VM_INTRINSIC_IGNORE, VM_SYMBOL_IGNORE, template, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE) \

src/hotspot/share/compiler/compileBroker.cpp

@@ -143,6 +143,8 @@ CompileLog** CompileBroker::_compiler2_logs = nullptr;
 volatile jint CompileBroker::_compilation_id     = 0;
 volatile jint CompileBroker::_osr_compilation_id = 0;
 volatile jint CompileBroker::_native_compilation_id = 0;
+volatile bool CompileBroker::_compilation_stopped = false;
+volatile jint CompileBroker::_active_compilations = 0;
 
 // Performance counters
 PerfCounter* CompileBroker::_perf_total_compilation = nullptr;
@@ -1948,7 +1950,32 @@ void CompileBroker::compiler_thread_loop() {
       if (method()->number_of_breakpoints() == 0) {
         // Compile the method.
         if ((UseCompiler || AlwaysCompileLoopMethods) && CompileBroker::should_compile_new_jobs()) {
-          invoke_compiler_on_method(task);
+
+          // TODO: review usage of CompileThread_lock (DCEVM)
+          if (AllowEnhancedClassRedefinition) {
+            {
+              // go to native, since dcevm doit() is in a safepoint (_compilation_stopped == true)
+              ThreadToNativeFromVM ttn(thread);
+              MonitorLocker locker(DcevmCompilation_lock, Mutex::_no_safepoint_check_flag);
+              // stop all compilations if requested from redefinition
+              while (_compilation_stopped) {
+                locker.wait(20);
+              }
+              Atomic::add(&_active_compilations, 1);
+            }
+
+            if (ciObjectFactory::is_reinitialize_vm_klasses()) {
+              MutexLocker only_one(DcevmCompilationInit_lock, Mutex::_no_safepoint_check_flag);
+              if (ciObjectFactory::is_reinitialize_vm_klasses()) {
+                ciObjectFactory::reinitialize_vm_classes_dcevm();
+              }
+            }
+            invoke_compiler_on_method(task);
+            Atomic::sub(&_active_compilations, 1);
+          } else {
+            invoke_compiler_on_method(task);
+          }
+
           thread->start_idle_timer();
         } else {
           // After compilation is disabled, remove remaining methods from queue
@@ -2304,8 +2331,16 @@ void CompileBroker::invoke_compiler_on_method(CompileTask* task) {
       if (WhiteBoxAPI && WhiteBox::compilation_locked) {
         whitebox_lock_compilation();
       }
-      comp->compile_method(&ci_env, target, osr_bci, true, directive);
-
+      if (AllowEnhancedClassRedefinition) {
+        // Skip redefined methods
+        if (task->method()->is_old() || task->method()->method_holder()->new_version() != NULL) {
+          ci_env.record_method_not_compilable("redefined method", true);
+        } else {
+          comp->compile_method(&ci_env, target, osr_bci, true, directive);
+        }
+      } else {
+        comp->compile_method(&ci_env, target, osr_bci, true, directive);
+      }
       /* Repeat compilation without installing code for profiling purposes */
       int repeat_compilation_count = directive->RepeatCompilationOption;
       while (repeat_compilation_count > 0) {
@@ -2314,6 +2349,7 @@ void CompileBroker::invoke_compiler_on_method(CompileTask* task) {
         comp->compile_method(&ci_env, target, osr_bci, false, directive);
         repeat_compilation_count--;
       }
+
     }
 
 
@@ -2891,3 +2927,30 @@ void CompileBroker::print_heapinfo(outputStream* out, const char* function, size
   }
   out->print_cr("\n__ CodeHeapStateAnalytics total duration %10.3f seconds _________\n", ts_total.seconds());
 }
+
+void CompileBroker::stopCompilationBeforeEnhancedRedefinition() {
+  // There are hard to fix C1/C2 race conditions with dcevm. The easiest solution
+  // is to stop compilation.
+  if (AllowEnhancedClassRedefinition) {
+    DcevmCompilation_lock->lock_without_safepoint_check();
+    _compilation_stopped = true;
+    while (_active_compilations > 0) {
+      DcevmCompilation_lock->wait_without_safepoint_check(10);
+      if (_active_compilations > 0) {
+        DcevmCompilation_lock->unlock();   // must unlock to run following VM op
+        VM_ForceSafepoint forceSafePoint;  // force safepoint to avoid deadlock
+        VMThread::execute(&forceSafePoint);
+        DcevmCompilation_lock->lock_without_safepoint_check();
+      }
+    }
+    DcevmCompilation_lock->unlock();
+  }
+}
+
+void CompileBroker::releaseCompilationAfterEnhancedRedefinition() {
+  if (AllowEnhancedClassRedefinition) {
+    MonitorLocker locker(DcevmCompilation_lock, Mutex::_no_safepoint_check_flag);
+    _compilation_stopped = false;
+    locker.notify_all();
+  }
+}

src/hotspot/share/compiler/compileBroker.hpp

@@ -200,6 +200,9 @@ class CompileBroker: AllStatic {
   static volatile jint _osr_compilation_id;
   static volatile jint _native_compilation_id;
 
+  static volatile bool _compilation_stopped;
+  static volatile jint _active_compilations;
+
   static CompileQueue* _c2_compile_queue;
   static CompileQueue* _c1_compile_queue;
 
@@ -449,6 +452,9 @@ public:
   // CodeHeap State Analytics.
   static void print_info(outputStream *out);
   static void print_heapinfo(outputStream *out, const char* function, size_t granularity);
+
+  static void stopCompilationBeforeEnhancedRedefinition();
+  static void releaseCompilationAfterEnhancedRedefinition();
 };
 
 #endif // SHARE_COMPILER_COMPILEBROKER_HPP

src/hotspot/share/gc/g1/g1CollectedHeap.cpp

@@ -1933,6 +1933,24 @@ public:
   }
 };
 
+class G1IterateObjectClosureTask : public WorkerTask {
+ private:
+  ObjectClosure* _cl;
+  G1CollectedHeap* _g1h;
+  G1HeapRegionClaimer _hrclaimer;
+ public:
+  G1IterateObjectClosureTask(ObjectClosure* cl, G1CollectedHeap* g1h) : WorkerTask("IterateObject Closure"),
+    _cl(cl), _g1h(g1h),  _hrclaimer(g1h->workers()->active_workers()) { }
+
+  virtual void work(uint worker_id) {
+    Thread *thread = Thread::current();
+    HandleMark hm(thread);   // make sure any handles created are deleted
+    ResourceMark rm(thread);
+    IterateObjectClosureRegionClosure blk(_cl);
+    _g1h->heap_region_par_iterate_from_worker_offset(&blk, &_hrclaimer, worker_id);
+  }
+};
+
 void G1CollectedHeap::object_iterate(ObjectClosure* cl) {
   IterateObjectClosureRegionClosure blk(cl);
   heap_region_iterate(&blk);

src/hotspot/share/gc/g1/g1CollectedHeap.hpp

@@ -160,6 +160,7 @@ class G1CollectedHeap : public CollectedHeap {
   // Closures used in implementation.
   friend class G1EvacuateRegionsTask;
   friend class G1PLABAllocator;
+  friend class G1FullGCPrepareTask;
 
   // Other related classes.
   friend class G1HeapPrinterMark;

src/hotspot/share/gc/g1/g1FullCollector.cpp

@@ -355,14 +355,18 @@ void G1FullCollector::phase2_prepare_compaction() {
   // Try to avoid OOM immediately after Full GC in case there are no free regions
   // left after determining the result locations (i.e. this phase). Prepare to
   // maximally compact the tail regions of the compaction queues serially.
-  if (scope()->do_maximal_compaction() || !has_free_compaction_targets) {
-    phase2c_prepare_serial_compaction();
+  if (!Universe::is_redefining_gc_run()) {
+    if (scope()->do_maximal_compaction() || !has_free_compaction_targets) {
+      phase2c_prepare_serial_compaction();
 
-    if (scope()->do_maximal_compaction() &&
-        has_humongous() &&
-        serial_compaction_point()->has_regions()) {
-      phase2d_prepare_humongous_compaction();
+      if (scope()->do_maximal_compaction() &&
+          has_humongous() &&
+          serial_compaction_point()->has_regions()) {
+        phase2d_prepare_humongous_compaction();
+      }
     }
+  } else {
+    phase2c_prepare_serial_compaction_dcevm();
   }
 }
 
@@ -473,6 +477,27 @@ void G1FullCollector::phase2d_prepare_humongous_compaction() {
   }
 }
 
+void G1FullCollector::phase2c_prepare_serial_compaction_dcevm() {
+  GCTraceTime(Debug, gc, phases) debug("Phase 2: Prepare Serial Compaction", scope()->timer());
+
+  for (uint i = 0; i < workers(); i++) {
+    G1FullGCCompactionPoint* cp = compaction_point(i);
+
+    // collect remaining, not forwarded rescued oops using serial compact point
+    while (cp->last_rescued_oop() < cp->rescued_oops()->length()) {
+      G1HeapRegion* hr = G1CollectedHeap::heap()->new_region(G1HeapRegion::GrainBytes / HeapWordSize, G1HeapRegionType::Eden, true, G1NUMA::AnyNodeIndex);
+      if (hr == nullptr) {
+        vm_exit_out_of_memory(0, OOM_MMAP_ERROR, "G1 - not enough of free regions after redefinition.");
+      }
+      set_compaction_top(hr, hr->bottom());
+      cp->add(hr);
+      cp->forward_rescued();
+      cp->update();
+    }
+  }
+}
+
+
 void G1FullCollector::phase3_adjust_pointers() {
   // Adjust the pointers to reflect the new locations
   GCTraceTime(Info, gc, phases) info("Phase 3: Adjust pointers", scope()->timer());
@@ -488,8 +513,12 @@ void G1FullCollector::phase4_do_compaction() {
   run_task(&task);
 
   // Serial compact to avoid OOM when very few free regions.
-  if (serial_compaction_point()->has_regions()) {
-    task.serial_compaction();
+  if (!Universe::is_redefining_gc_run()) {
+    if (serial_compaction_point()->has_regions()) {
+      task.serial_compaction();
+    }
+  } else {
+    task.serial_compaction_dcevm();
   }
 
   if (!_humongous_compaction_regions.is_empty()) {

src/hotspot/share/gc/g1/g1FullCollector.hpp

@@ -160,6 +160,7 @@ private:
   bool phase2b_forward_oops();
   void phase2c_prepare_serial_compaction();
   void phase2d_prepare_humongous_compaction();
+  void phase2c_prepare_serial_compaction_dcevm();
 
   void phase3_adjust_pointers();
   void phase4_do_compaction();

src/hotspot/share/gc/g1/g1FullGCCompactTask.cpp

@@ -30,6 +30,7 @@
 #include "gc/g1/g1HeapRegion.inline.hpp"
 #include "gc/shared/fullGCForwarding.inline.hpp"
 #include "gc/shared/gcTraceTime.inline.hpp"
+#include "gc/shared/dcevmSharedGC.hpp"
 #include "logging/log.hpp"
 #include "oops/oop.inline.hpp"
 #include "utilities/ticks.hpp"
@@ -88,10 +89,28 @@ void G1FullGCCompactTask::compact_region(G1HeapRegion* hr) {
 void G1FullGCCompactTask::work(uint worker_id) {
   Ticks start = Ticks::now();
   GrowableArray<G1HeapRegion*>* compaction_queue = collector()->compaction_point(worker_id)->regions();
-  for (GrowableArrayIterator<G1HeapRegion*> it = compaction_queue->begin();
-       it != compaction_queue->end();
-       ++it) {
-    compact_region(*it);
+
+  if (!Universe::is_redefining_gc_run()) {
+    GrowableArray<G1HeapRegion*>* compaction_queue = collector()->compaction_point(worker_id)->regions();
+    for (GrowableArrayIterator<G1HeapRegion*> it = compaction_queue->begin();
+         it != compaction_queue->end();
+         ++it) {
+      compact_region(*it);
+    }
+  } else {
+    GrowableArrayIterator<HeapWord*> rescue_oops_it = collector()->compaction_point(worker_id)->rescued_oops()->begin();
+    GrowableArray<HeapWord*>* rescued_oops_values = collector()->compaction_point(worker_id)->rescued_oops_values();
+
+    for (GrowableArrayIterator<G1HeapRegion*> it = compaction_queue->begin();
+         it != compaction_queue->end();
+         ++it) {
+      compact_region_dcevm(*it, rescued_oops_values, &rescue_oops_it);
+    }
+    assert(rescue_oops_it.at_end(), "Must be at end");
+    G1FullGCCompactionPoint* cp = collector()->compaction_point(worker_id);
+    if (cp->last_rescued_oop() > 0) {
+      DcevmSharedGC::copy_rescued_objects_back(rescued_oops_values, 0, cp->last_rescued_oop(), false);
+    }
   }
 }
 
@@ -150,3 +169,77 @@ void G1FullGCCompactTask::free_non_overlapping_regions(uint src_start_idx, uint
     _g1h->free_humongous_region(hr, nullptr);
   }
 }
+
+void G1FullGCCompactTask::compact_region_dcevm(G1HeapRegion* hr, GrowableArray<HeapWord*>* rescued_oops_values,
+    GrowableArrayIterator<HeapWord*>* rescue_oops_it) {
+  assert(!hr->is_humongous(), "Should be no humongous regions in compaction queue");
+  ResourceMark rm; //
+
+  if (!collector()->is_free(hr->hrm_index())) {
+    // The compaction closure not only copies the object to the new
+    // location, but also clears the bitmap for it. This is needed
+    // for bitmap verification and to be able to use the bitmap
+    // for evacuation failures in the next young collection. Testing
+    // showed that it was better overall to clear bit by bit, compared
+    // to clearing the whole region at the end. This difference was
+    // clearly seen for regions with few marks.
+    G1CompactRegionClosureDcevm compact(collector()->mark_bitmap(), rescued_oops_values, rescue_oops_it);
+    hr->apply_to_marked_objects(collector()->mark_bitmap(), &compact);
+  }
+
+  hr->reset_compacted_after_full_gc(_collector->compaction_top(hr));
+}
+
+
+void G1FullGCCompactTask::serial_compaction_dcevm() {
+  GCTraceTime(Debug, gc, phases) tm("Phase 4: Serial Compaction", collector()->scope()->timer());
+
+  // Clear allocated resources at compact points now, since all rescued oops are copied to destination.
+  for (uint i = 0; i < collector()->workers(); i++) {
+    G1FullGCCompactionPoint* cp = collector()->compaction_point(i);
+    DcevmSharedGC::clear_rescued_objects_heap(cp->rescued_oops_values());
+  }
+
+}
+
+void G1FullGCCompactTask::G1CompactRegionClosureDcevm::clear_in_bitmap(oop obj) {
+  assert(_bitmap->is_marked(obj), "Should only compact marked objects");
+  _bitmap->clear(obj);
+}
+
+size_t G1FullGCCompactTask::G1CompactRegionClosureDcevm::apply(oop obj) {
+  size_t size = obj->size();
+  if (obj->is_forwarded()) {
+    HeapWord* destination = cast_from_oop<HeapWord*>(FullGCForwarding::forwardee(obj));
+    // copy object and reinit its mark
+    HeapWord *obj_addr = cast_from_oop<HeapWord *>(obj);
+
+    if (!_rescue_oops_it->at_end() && **_rescue_oops_it == obj_addr) {
+      ++(*_rescue_oops_it);
+      HeapWord *rescued_obj = NEW_C_HEAP_ARRAY(HeapWord, size, mtInternal);
+      Copy::aligned_disjoint_words(obj_addr, rescued_obj, size);
+      _rescued_oops_values->append(rescued_obj);
+      debug_only(Copy::fill_to_words(obj_addr, size, 0));
+      return size;
+    }
+
+    if (obj->klass()->new_version() != nullptr) {
+      Klass *new_version = obj->klass()->new_version();
+      if (new_version->update_information() == nullptr) {
+        Copy::aligned_conjoint_words(obj_addr, destination, size);
+        cast_to_oop(destination)->set_klass(new_version);
+      } else {
+        DcevmSharedGC::update_fields(obj, cast_to_oop(destination));
+      }
+      cast_to_oop(destination)->init_mark();
+      assert(cast_to_oop(destination)->klass() != nullptr, "should have a class");
+      return size;
+    }
+
+    Copy::aligned_conjoint_words(obj_addr, destination, size);
+    cast_to_oop(destination)->init_mark();
+    assert(cast_to_oop(destination)->klass() != nullptr, "should have a class");
+  }
+  clear_in_bitmap(obj);
+  return size;
+}

src/hotspot/share/gc/g1/g1FullGCCompactTask.hpp

@@ -45,6 +45,8 @@ class G1FullGCCompactTask : public G1FullGCTask {
   void free_non_overlapping_regions(uint src_start_idx, uint dest_start_idx, uint num_regions);
 
   static void copy_object_to_new_location(oop obj);
+  void compact_region_dcevm(G1HeapRegion* hr, GrowableArray<HeapWord*>* rescued_oops_values,
+    GrowableArrayIterator<HeapWord*>* rescue_oops_it);
 
 public:
   G1FullGCCompactTask(G1FullCollector* collector) :
@@ -56,6 +58,7 @@ public:
   void work(uint worker_id);
   void serial_compaction();
   void humongous_compaction();
+  void serial_compaction_dcevm();
 
   class G1CompactRegionClosure : public StackObj {
     G1CMBitMap* _bitmap;
@@ -64,6 +67,22 @@ public:
     G1CompactRegionClosure(G1CMBitMap* bitmap) : _bitmap(bitmap) { }
     size_t apply(oop object);
   };
+
+  class G1CompactRegionClosureDcevm : public StackObj {
+    G1CMBitMap* _bitmap;
+    GrowableArray<HeapWord*>* _rescued_oops_values;
+    GrowableArrayIterator<HeapWord*>* _rescue_oops_it;
+    void clear_in_bitmap(oop object);
+  public:
+    G1CompactRegionClosureDcevm(G1CMBitMap* bitmap,
+                           GrowableArray<HeapWord*>* rescued_oops_values,
+                           GrowableArrayIterator<HeapWord*>* rescue_oops_it) :
+      _bitmap(bitmap),
+      _rescued_oops_values(rescued_oops_values),
+      _rescue_oops_it(rescue_oops_it)
+      { }
+    size_t apply(oop object);
+  };
 };
 
 #endif // SHARE_GC_G1_G1FULLGCCOMPACTTASK_HPP

src/hotspot/share/gc/g1/g1FullGCCompactionPoint.cpp

@@ -34,13 +34,18 @@ G1FullGCCompactionPoint::G1FullGCCompactionPoint(G1FullCollector* collector, Pre
     _collector(collector),
     _current_region(nullptr),
     _compaction_top(nullptr),
-    _preserved_stack(preserved_stack) {
+    _preserved_stack(preserved_stack),
+    _last_rescued_oop(0) {
   _compaction_regions = new (mtGC) GrowableArray<G1HeapRegion*>(32, mtGC);
   _compaction_region_iterator = _compaction_regions->begin();
+  _rescued_oops = new (mtGC) GrowableArray<HeapWord*>(128, mtGC);
+  _rescued_oops_values = new (mtGC) GrowableArray<HeapWord*>(128, mtGC);
 }
 
 G1FullGCCompactionPoint::~G1FullGCCompactionPoint() {
   delete _compaction_regions;
+  delete _rescued_oops;
+  delete _rescued_oops_values;
 }
 
 void G1FullGCCompactionPoint::update() {
@@ -80,6 +85,14 @@ GrowableArray<G1HeapRegion*>* G1FullGCCompactionPoint::regions() {
   return _compaction_regions;
 }
 
+GrowableArray<HeapWord*>* G1FullGCCompactionPoint::rescued_oops() {
+  return _rescued_oops;
+}
+
+GrowableArray<HeapWord*>* G1FullGCCompactionPoint::rescued_oops_values() {
+  return _rescued_oops_values;
+}
+
 bool G1FullGCCompactionPoint::object_will_fit(size_t size) {
   size_t space_left = pointer_delta(_current_region->end(), _compaction_top);
   return size <= space_left;
@@ -216,3 +229,62 @@ uint G1FullGCCompactionPoint::find_contiguous_before(G1HeapRegion* hr, uint num_
   // Return the index of the first region in the range of contiguous regions.
   return range_end - contiguous_region_count;
 }
+
+HeapWord* G1FullGCCompactionPoint::forward_compact_top(size_t size) {
+  assert(_current_region != NULL, "Must have been initialized");
+  // Ensure the object fit in the current region.
+  while (!object_will_fit(size)) {
+    if (!_compaction_region_iterator.has_next()) {
+      return NULL;
+    }
+    switch_region();
+  }
+  return _compaction_top;
+}
+
+void G1FullGCCompactionPoint::forward_dcevm(oop object, size_t size, bool force_forward) {
+  assert(_current_region != NULL, "Must have been initialized");
+
+  // Ensure the object fit in the current region.
+  while (!object_will_fit(size)) {
+    switch_region();
+  }
+
+  // Store a forwarding pointer if the object should be moved.
+  if (cast_from_oop<HeapWord*>(object) != _compaction_top || force_forward) {
+    if (!object->is_forwarded()) {
+      preserved_stack()->push_if_necessary(object, object->mark());
+    }
+    FullGCForwarding::forward_to(object, cast_to_oop(_compaction_top));
+    assert(FullGCForwarding::is_forwarded(object), "must be forwarded");
+  } else {
+    assert(!FullGCForwarding::is_forwarded(object), "must not be forwarded");
+  }
+
+  // Update compaction values.
+  _compaction_top += size;
+  _current_region->update_bot_for_block(_compaction_top - size, _compaction_top);
+}
+
+void G1FullGCCompactionPoint::forward_rescued() {
+  int i;
+
+  i = _last_rescued_oop;
+
+  for (;i<rescued_oops()->length(); i++) {
+    HeapWord* q = rescued_oops()->at(i);
+
+    size_t size = cast_to_oop(q)->size();
+
+    // (DCEVM) There is a new version of the class of q => different size
+    if (cast_to_oop(q)->klass()->new_version() != nullptr) {
+      // assert(size != new_size, "instances without changed size have to be updated prior to GC run");
+      size = cast_to_oop(q)->size_given_klass(cast_to_oop(q)->klass()->new_version());
+    }
+    if (forward_compact_top(size) == nullptr) {
+      break;
+    }
+    forward_dcevm(cast_to_oop(q), size, true);
+  }
+  _last_rescued_oop = i;
+}

src/hotspot/share/gc/g1/g1FullGCCompactionPoint.hpp

@@ -41,6 +41,9 @@ class G1FullGCCompactionPoint : public CHeapObj<mtGC> {
   PreservedMarks* _preserved_stack;
   GrowableArray<G1HeapRegion*>* _compaction_regions;
   GrowableArrayIterator<G1HeapRegion*> _compaction_region_iterator;
+  GrowableArray<HeapWord*>* _rescued_oops;
+  GrowableArray<HeapWord*>* _rescued_oops_values;
+  int _last_rescued_oop;
 
   bool object_will_fit(size_t size);
   void initialize_values();
@@ -60,6 +63,8 @@ public:
   void forward_humongous(G1HeapRegion* hr);
   void add(G1HeapRegion* hr);
   void add_humongous(G1HeapRegion* hr);
+  HeapWord* forward_compact_top(size_t size);
+  void forward_dcevm(oop object, size_t size, bool force_forward);
 
   void remove_at_or_above(uint bottom);
   G1HeapRegion* current_region();
@@ -75,6 +80,12 @@ public:
     assert(_preserved_stack == nullptr, "only initialize once");
     _preserved_stack = preserved_stack;
   }
+
+  GrowableArray<HeapWord*>* rescued_oops();
+  GrowableArray<HeapWord*>* rescued_oops_values();
+
+  void forward_rescued();
+  int last_rescued_oop() { return _last_rescued_oop; }
 };
 
 #endif // SHARE_GC_G1_G1FULLGCCOMPACTIONPOINT_HPP

src/hotspot/share/gc/g1/g1FullGCPrepareTask.cpp

@@ -45,6 +45,7 @@ G1DetermineCompactionQueueClosure::G1DetermineCompactionQueueClosure(G1FullColle
 bool G1FullGCPrepareTask::G1CalculatePointersClosure::do_heap_region(G1HeapRegion* hr) {
   uint region_idx = hr->hrm_index();
   assert(_collector->is_compaction_target(region_idx), "must be");
+  hr->set_processing_order(_region_processing_order++);
 
   assert(!hr->is_humongous(), "must be");
 
@@ -82,6 +83,9 @@ void G1FullGCPrepareTask::work(uint worker_id) {
          ++it) {
       closure.do_heap_region(*it);
     }
+    if (Universe::is_redefining_gc_run()) {
+      compaction_point->forward_rescued();
+    }
     compaction_point->update();
     // Determine if there are any unused compaction targets. This is only the case if
     // there are
@@ -100,7 +104,8 @@ G1FullGCPrepareTask::G1CalculatePointersClosure::G1CalculatePointersClosure(G1Fu
   _g1h(G1CollectedHeap::heap()),
   _collector(collector),
   _bitmap(collector->mark_bitmap()),
-  _cp(cp) { }
+  _cp(cp),
+  _region_processing_order(0) { }
 
 
 G1FullGCPrepareTask::G1PrepareCompactLiveClosure::G1PrepareCompactLiveClosure(G1FullGCCompactionPoint* cp) :
@@ -114,7 +119,61 @@ size_t G1FullGCPrepareTask::G1PrepareCompactLiveClosure::apply(oop object) {
 
 void G1FullGCPrepareTask::G1CalculatePointersClosure::prepare_for_compaction(G1HeapRegion* hr) {
   if (!_collector->is_free(hr->hrm_index())) {
-    G1PrepareCompactLiveClosure prepare_compact(_cp);
-    hr->apply_to_marked_objects(_bitmap, &prepare_compact);
+    if (!Universe::is_redefining_gc_run()) {
+      G1PrepareCompactLiveClosure prepare_compact(_cp);
+      hr->apply_to_marked_objects(_bitmap, &prepare_compact);
+    } else {
+      G1PrepareCompactLiveClosureDcevm prepare_compact(_cp, hr->processing_order());
+      hr->apply_to_marked_objects(_bitmap, &prepare_compact);
+    }
   }
 }
+
+G1FullGCPrepareTask::G1PrepareCompactLiveClosureDcevm::G1PrepareCompactLiveClosureDcevm(G1FullGCCompactionPoint* cp,
+                                                                                        uint region_processing_order) :
+    _cp(cp),
+    _region_processing_order(region_processing_order) { }
+
+size_t G1FullGCPrepareTask::G1PrepareCompactLiveClosureDcevm::apply(oop object) {
+  size_t size = object->size();
+  size_t forward_size = size;
+
+  // (DCEVM) There is a new version of the class of q => different size
+  if (object->klass()->new_version() != nullptr) {
+    forward_size = object->size_given_klass(object->klass()->new_version());
+  }
+
+  HeapWord* compact_top = _cp->forward_compact_top(forward_size);
+
+  if (compact_top == nullptr || must_rescue(object, cast_to_oop(compact_top))) {
+    _cp->rescued_oops()->append(cast_from_oop<HeapWord*>(object));
+  } else {
+    _cp->forward_dcevm(object, forward_size, (size != forward_size));
+  }
+
+  return size;
+}
+
+bool G1FullGCPrepareTask::G1PrepareCompactLiveClosureDcevm::must_rescue(oop old_obj, oop new_obj) {
+  // Only redefined objects can have the need to be rescued.
+  if (old_obj->klass()->new_version() == nullptr) {
+    return false;
+  }
+
+  if (_region_processing_order > _cp->current_region()->processing_order()) {
+    return false;
+  }
+
+  if (_region_processing_order < _cp->current_region()->processing_order()) {
+    return true;
+  }
+
+  // old obj and new obj are within same region
+  size_t new_size = old_obj->size_given_klass(oop(old_obj)->klass()->new_version());
+  size_t original_size = old_obj->size();
+
+  // what if old_obj > new_obj ?
+  bool overlap = (cast_from_oop<HeapWord*>(old_obj) + original_size < cast_from_oop<HeapWord*>(new_obj) + new_size);
+
+  return overlap;
+}

src/hotspot/share/gc/g1/g1FullGCPrepareTask.hpp

@@ -79,6 +79,7 @@ private:
     G1FullCollector* _collector;
     G1CMBitMap* _bitmap;
     G1FullGCCompactionPoint* _cp;
+    uint _region_processing_order;
 
     void prepare_for_compaction(G1HeapRegion* hr);
 
@@ -96,6 +97,16 @@ private:
     G1PrepareCompactLiveClosure(G1FullGCCompactionPoint* cp);
     size_t apply(oop object);
   };
+
+  class G1PrepareCompactLiveClosureDcevm : public StackObj {
+    G1FullGCCompactionPoint* _cp;
+    uint _region_processing_order;
+
+    bool must_rescue(oop old_obj, oop new_obj);
+  public:
+    G1PrepareCompactLiveClosureDcevm(G1FullGCCompactionPoint* cp, uint region_processing_order);
+    size_t apply(oop object);
+  };
 };
 
 // Closure to re-prepare objects in the serial compaction point queue regions for

src/hotspot/share/gc/g1/g1FullGCPrepareTask.inline.hpp

@@ -46,6 +46,9 @@ inline bool G1DetermineCompactionQueueClosure::should_compact(G1HeapRegion* hr)
   if (hr->is_humongous() || hr->has_pinned_objects()) {
     return false;
   }
+  if (Universe::is_redefining_gc_run()) {
+    return true;
+  }
   size_t live_words = _collector->live_words(hr->hrm_index());
   size_t live_words_threshold = _collector->scope()->region_compaction_threshold();
   // High live ratio region will not be compacted.

src/hotspot/share/gc/g1/g1HeapRegion.hpp

@@ -199,6 +199,8 @@ private:
   // The remembered set for this region.
   G1HeapRegionRemSet* _rem_set;
 
+  uint _processing_order;
+
   // Cached index of this region in the heap region sequence.
   const uint _hrm_index;
 
@@ -432,6 +434,14 @@ public:
     return _rem_set;
   }
 
+  uint processing_order() {
+    return _processing_order;
+  }
+
+  void set_processing_order(uint processing_order) {
+    _processing_order = processing_order;
+  }
+
   inline bool in_collection_set() const;
 
   void prepare_remset_for_scan();

src/hotspot/share/gc/serial/serialFullGC.cpp

@@ -70,6 +70,7 @@
 #include "utilities/copy.hpp"
 #include "utilities/events.hpp"
 #include "utilities/stack.inline.hpp"
+#include "gc/shared/dcevmSharedGC.hpp"
 #if INCLUDE_JVMCI
 #include "jvmci/jvmci.hpp"
 #endif
@@ -104,7 +105,11 @@ public:
   DeadSpacer(ContiguousSpace* space) : _allowed_deadspace_words(0), _space(space) {
     size_t ratio = (_space == SerialHeap::heap()->old_gen()->space())
                    ? MarkSweepDeadRatio : 0;
-    _active = ratio > 0;
+    if (!Universe::is_redefining_gc_run()) {
+      _active = ratio > 0;
+    } else {
+      _active = false; // dead spacer is not active in DCEVM
+    }
 
     if (_active) {
       // We allow some amount of garbage towards the bottom of the space, so
@@ -173,6 +178,11 @@ class Compacter {
   // Used for BOT update
   TenuredGeneration* _old_gen;
 
+  // (DCEVM)
+  GrowableArray<HeapWord*>* _rescued_oops;
+  GrowableArray<HeapWord*>* _rescued_oops_values;
+  GrowableArrayIterator<HeapWord*> _rescue_oops_it;
+
   HeapWord* get_compaction_top(uint index) const {
     return _spaces[index]._compaction_top;
   }
@@ -238,6 +248,12 @@ class Compacter {
     }
   }
 
+  static void forward_obj_dcevm(oop obj, HeapWord* new_addr) {
+    // always forward in dcevm
+    prefetch_write_scan(obj);
+    FullGCForwarding::forward_to(obj, cast_to_oop(new_addr));
+  }
+
   static HeapWord* find_next_live_addr(HeapWord* start, HeapWord* end) {
     for (HeapWord* i_addr = start; i_addr < end; /* empty */) {
       prefetch_read_scan(i_addr);
@@ -267,6 +283,45 @@ class Compacter {
     return obj_size;
   }
 
+  size_t relocate_dcevm(HeapWord* addr) {
+    // Prefetch source and destination
+    prefetch_read_scan(addr);
+
+    oop obj = cast_to_oop(addr);
+    size_t obj_size = obj->size();
+
+    if (!_rescue_oops_it.at_end() && *_rescue_oops_it == addr) {
+      ++_rescue_oops_it;
+      HeapWord *rescued_obj = NEW_C_HEAP_ARRAY(HeapWord, obj_size, mtInternal);
+      Copy::aligned_disjoint_words(addr, rescued_obj, obj_size);
+      _rescued_oops_values->append(rescued_obj);
+      debug_only(Copy::fill_to_words(addr, obj_size, 0));
+      return obj_size;
+    }
+
+    oop new_obj = FullGCForwarding::forwardee(obj);
+    HeapWord* new_addr = cast_from_oop<HeapWord*>(new_obj);
+    // assert(addr != new_addr, "inv");
+    prefetch_write_copy(new_addr);
+
+    if (obj->klass()->new_version() != nullptr) {
+      Klass *new_version = obj->klass()->new_version();
+      if (new_version->update_information() == nullptr) {
+        Copy::aligned_conjoint_words(addr, new_addr, obj_size);
+        cast_to_oop(new_addr)->set_klass(new_version);
+      } else {
+        DcevmSharedGC::update_fields(obj, cast_to_oop(new_addr));
+      }
+      cast_to_oop(new_addr)->init_mark();
+      assert(cast_to_oop(new_addr)->klass() != nullptr, "should have a class");
+      return obj_size;
+    }
+
+    Copy::aligned_conjoint_words(addr, new_addr, obj_size);
+    new_obj->init_mark();
+
+    return obj_size;
+  }
 public:
   explicit Compacter(SerialHeap* heap) {
     // In this order so that heap is compacted towards old-gen.
@@ -283,9 +338,25 @@ public:
     }
     _index = 0;
     _old_gen = heap->old_gen();
+    _rescued_oops = nullptr;
+    _rescued_oops_values = nullptr;
+  }
+
+  ~Compacter() {
+    if (_rescued_oops != nullptr) {
+      delete _rescued_oops;
+      delete _rescued_oops_values;
+    }
   }
 
   void phase2_calculate_new_addr() {
+    bool redefinition_run = Universe::is_redefining_gc_run();
+
+    if (redefinition_run) {
+      _rescued_oops = new (mtGC) GrowableArray<HeapWord*>(128, mtGC);
+      _rescued_oops_values = new (mtGC) GrowableArray<HeapWord*>(128, mtGC);
+    }
+
     for (uint i = 0; i < _num_spaces; ++i) {
       ContiguousSpace* space = get_space(i);
       HeapWord* cur_addr = space->bottom();
@@ -299,9 +370,24 @@ public:
         oop obj = cast_to_oop(cur_addr);
         size_t obj_size = obj->size();
         if (obj->is_gc_marked()) {
-          HeapWord* new_addr = alloc(obj_size);
-          forward_obj(obj, new_addr);
-          cur_addr += obj_size;
+          if (redefinition_run) {
+            size_t forward_size = obj_size;
+            if (obj->klass()->new_version() != nullptr) {
+              forward_size = obj->size_given_klass(obj->klass()->new_version());
+            }
+            if (must_rescue(obj, cast_to_oop(get_compaction_top(_index)))) {
+              _rescued_oops->append(cast_from_oop<HeapWord *>(obj));
+              cur_addr += obj_size;
+              continue;
+            }
+            HeapWord *new_addr = alloc(forward_size);
+            forward_obj_dcevm(obj, new_addr);
+            cur_addr += obj_size;
+          } else {
+            HeapWord *new_addr = alloc(obj_size);
+            forward_obj(obj, new_addr);
+            cur_addr += obj_size;
+          }
         } else {
           // Skipping the current known-unmarked obj
           HeapWord* next_live_addr = find_next_live_addr(cur_addr + obj_size, top);
@@ -323,6 +409,10 @@ public:
         record_first_dead(i, top);
       }
     }
+
+    if (redefinition_run) {
+      forward_rescued();
+    }
   }
 
   void phase3_adjust_pointers() {
@@ -346,6 +436,12 @@ public:
   }
 
   void phase4_compact() {
+    bool redefinition_run = Universe::is_redefining_gc_run();
+
+    if (redefinition_run) {
+      _rescue_oops_it = _rescued_oops->begin();
+    }
+
     for (uint i = 0; i < _num_spaces; ++i) {
       ContiguousSpace* space = get_space(i);
       HeapWord* cur_addr = space->bottom();
@@ -362,7 +458,11 @@ public:
           cur_addr = *(HeapWord**) cur_addr;
           continue;
         }
-        cur_addr += relocate(cur_addr);
+        if (redefinition_run) {
+          cur_addr += relocate_dcevm(cur_addr);
+        } else {
+          cur_addr += relocate(cur_addr);
+        }
       }
 
       // Reset top and unused memory
@@ -372,6 +472,60 @@ public:
         space->mangle_unused_area(MemRegion(new_top, top));
       }
     }
+
+    if (redefinition_run) {
+      DcevmSharedGC::copy_rescued_objects_back(_rescued_oops_values, false);
+      DcevmSharedGC::clear_rescued_objects_heap(_rescued_oops_values);
+    }
+  }
+
+  bool must_rescue(oop old_obj, oop new_obj) {
+    // Only redefined objects can have the need to be rescued.
+    if (oop(old_obj)->klass()->new_version() == nullptr) return false;
+
+    size_t new_size = old_obj->size_given_klass(oop(old_obj)->klass()->new_version());
+    size_t original_size = old_obj->size();
+
+    uint old_index = -1u;
+    uint new_index = -1u;
+
+    for (uint i=0; i<_num_spaces; i++) {
+      if (old_index == -1u && _spaces[i]._space->is_in_reserved(old_obj)) {
+        old_index = i;
+      }
+      if (new_index == -1u && _spaces[i]._space->is_in_reserved(new_obj)) {
+        new_index = i;
+      }
+    }
+
+    if (old_index == new_index) {
+      // Rescue if object may overlap with a higher memory address.
+      bool overlap = (cast_from_oop<HeapWord*>(old_obj) + original_size < cast_from_oop<HeapWord*>(new_obj) + new_size);
+      return overlap;
+    } else {
+      if (old_index == 0) {
+        // Must always rescue when moving from the old into the new generation.
+        return false;
+      } else {
+        // Must never rescue when moving from the new into the old generation.
+        return true;
+      }
+    }
+  }
+
+  void forward_rescued() {
+    for (int i=0; i<_rescued_oops->length(); i++) {
+      oop obj = cast_to_oop(_rescued_oops->at(i));
+      size_t obj_size = obj->size();
+      size_t forward_size = obj_size;
+
+      if (obj->klass()->new_version() != nullptr) {
+        forward_size = obj->size_given_klass(obj->klass()->new_version());
+      }
+
+      HeapWord *new_addr = alloc(forward_size);
+      forward_obj_dcevm(obj, new_addr);
+    }
   }
 };
 

src/hotspot/share/gc/shared/dcevmSharedGC.cpp

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 1997, 2018, 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.
+ *
+ * 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 "gc/shared/dcevmSharedGC.hpp"
+#include "oops/compressedOops.inline.hpp"
+#include "oops/instanceKlass.inline.hpp"
+#include "gc/shared/fullGCForwarding.inline.hpp"
+#include "utilities/copy.hpp"
+
+void DcevmSharedGC::copy_rescued_objects_back(GrowableArray<HeapWord*>* rescued_oops, bool must_be_new) {
+  if (rescued_oops != nullptr) {
+    copy_rescued_objects_back(rescued_oops, 0, rescued_oops->length(), must_be_new);
+  }
+}
+
+// (DCEVM) Copy the rescued objects to their destination address after compaction.
+void DcevmSharedGC::copy_rescued_objects_back(GrowableArray<HeapWord*>* rescued_oops, int from, int to, bool must_be_new) {
+
+  if (rescued_oops != nullptr) {
+    ResourceMark rm;
+    for (int i=from; i < to; i++) {
+      HeapWord* rescued_ptr = rescued_oops->at(i);
+      oop rescued_obj = cast_to_oop(rescued_ptr);
+
+      size_t size = rescued_obj->size();
+      oop new_obj = FullGCForwarding::forwardee(rescued_obj);
+
+      assert(!must_be_new || rescued_obj->klass()->new_version() != nullptr, "Just checking");
+      Klass* new_klass = rescued_obj->klass()->new_version();
+      if (new_klass!= nullptr) {
+        if (new_klass->update_information() != nullptr) {
+          DcevmSharedGC::update_fields(rescued_obj, new_obj);
+        } else {
+          rescued_obj->set_klass(new_klass);
+          Copy::aligned_disjoint_words(cast_from_oop<HeapWord*>(rescued_obj), cast_from_oop<HeapWord*>(new_obj), size);
+        }
+      } else {
+        Copy::aligned_disjoint_words(cast_from_oop<HeapWord*>(rescued_obj), cast_from_oop<HeapWord*>(new_obj), size);
+      }
+
+      new_obj->init_mark();
+      assert(oopDesc::is_oop(new_obj), "must be a valid oop");
+    }
+  }
+
+}
+
+void DcevmSharedGC::clear_rescued_objects_resource(GrowableArray<HeapWord*>* rescued_oops) {
+  if (rescued_oops != nullptr) {
+    for (int i=0; i < rescued_oops->length(); i++) {
+      HeapWord* rescued_ptr = rescued_oops->at(i);
+      size_t size = cast_to_oop(rescued_ptr)->size();
+      FREE_RESOURCE_ARRAY(HeapWord, rescued_ptr, size);
+    }
+    rescued_oops->clear();
+  }
+}
+
+void DcevmSharedGC::clear_rescued_objects_heap(GrowableArray<HeapWord*>* rescued_oops) {
+  if (rescued_oops != nullptr) {
+    for (int i=0; i < rescued_oops->length(); i++) {
+      HeapWord* rescued_ptr = rescued_oops->at(i);
+      FREE_C_HEAP_ARRAY(HeapWord, rescued_ptr);
+    }
+    rescued_oops->clear();
+  }
+}
+
+// (DCEVM) Update instances of a class whose fields changed.
+void DcevmSharedGC::update_fields(oop q, oop new_location) {
+
+  assert(q->klass()->new_version() != nullptr, "class of old object must have new version");
+
+  Klass* old_klass_oop = q->klass();
+  Klass* new_klass_oop = q->klass()->new_version();
+
+  InstanceKlass *old_klass = InstanceKlass::cast(old_klass_oop);
+  InstanceKlass *new_klass = InstanceKlass::cast(new_klass_oop);
+
+  size_t size = q->size_given_klass(old_klass);
+  size_t new_size = q->size_given_klass(new_klass);
+
+  HeapWord* tmp = nullptr;
+  oop tmp_obj = q;
+
+  // Save object somewhere, there is an overlap in fields
+  if (new_klass_oop->is_copying_backwards()) {
+    if ((cast_from_oop<HeapWord*>(q) >= cast_from_oop<HeapWord*>(new_location) && cast_from_oop<HeapWord*>(q) < cast_from_oop<HeapWord*>(new_location) + new_size) ||
+        (cast_from_oop<HeapWord*>(new_location) >= cast_from_oop<HeapWord*>(q) && cast_from_oop<HeapWord*>(new_location) < cast_from_oop<HeapWord*>(q) + size)) {
+       tmp = NEW_RESOURCE_ARRAY(HeapWord, size);
+       q = cast_to_oop(tmp);
+       Copy::aligned_disjoint_words(cast_from_oop<HeapWord*>(tmp_obj), cast_from_oop<HeapWord*>(q), size);
+    }
+  }
+
+  q->set_klass(new_klass_oop);
+  int *cur = new_klass_oop->update_information();
+  assert(cur != nullptr, "just checking");
+  DcevmSharedGC::update_fields(new_location, q, cur);
+
+  if (tmp != nullptr) {
+    FREE_RESOURCE_ARRAY(HeapWord, tmp, size);
+  }
+}
+
+void DcevmSharedGC::update_fields(oop new_location, oop tmp_obj, int *cur) {
+  assert(cur != nullptr, "just checking");
+  char* to = (char*)cast_from_oop<HeapWord*>(new_location);
+  while (*cur != 0) {
+    int size = *cur;
+    if (size > 0) {
+      cur++;
+      int offset = *cur;
+      HeapWord* from = (HeapWord*)(((char *)cast_from_oop<HeapWord*>(tmp_obj)) + offset);
+      if (size == HeapWordSize) {
+        *((HeapWord*)to) = *from;
+      } else if (size == HeapWordSize * 2) {
+        *((HeapWord*)to) = *from;
+        *(((HeapWord*)to) + 1) = *(from + 1);
+      } else {
+        Copy::conjoint_jbytes(from, to, size);
+      }
+      to += size;
+      cur++;
+    } else {
+      assert(size < 0, "");
+      int skip = -*cur;
+      Copy::fill_to_bytes(to, skip, 0);
+      to += skip;
+      cur++;
+    }
+  }
+}

src/hotspot/share/gc/shared/dcevmSharedGC.hpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 1997, 2018, 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.
+ *
+ * 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.
+ *
+ */
+
+#ifndef SHARE_GC_DCEVM_SHARED_GC_HPP
+#define SHARE_GC_DCEVM_SHARED_GC_HPP
+
+#include "gc/shared/collectedHeap.hpp"
+#include "gc/shared/taskqueue.hpp"
+#include "memory/iterator.hpp"
+#include "oops/markWord.hpp"
+#include "oops/oop.hpp"
+#include "runtime/timer.hpp"
+#include "utilities/growableArray.hpp"
+#include "utilities/stack.hpp"
+
+// Shared GC code used from different GC (Serial, CMS, G1) on enhanced redefinition
+class DcevmSharedGC : AllStatic {
+ public:
+  static void copy_rescued_objects_back(GrowableArray<HeapWord*>* rescued_oops, bool must_be_new);
+  static void copy_rescued_objects_back(GrowableArray<HeapWord*>* rescued_oops, int from, int to, bool must_be_new);
+  static void clear_rescued_objects_resource(GrowableArray<HeapWord*>* rescued_oops);
+  static void clear_rescued_objects_heap(GrowableArray<HeapWord*>* rescued_oops);
+  static void update_fields(oop q, oop new_location);
+  static void update_fields(oop new_location, oop tmp_obj, int *cur);
+};
+
+#endif

src/hotspot/share/gc/shared/gcConfig.cpp

@@ -95,7 +95,10 @@ void GCConfig::fail_if_non_included_gc_is_selected() {
 }
 
 void GCConfig::select_gc_ergonomically() {
-  if (os::is_server_class_machine()) {
+  if (AllowEnhancedClassRedefinition && !UseSerialGC) {
+    // (DCEVM) use G1 as default GC in Enhanced class redefinition
+    FLAG_SET_ERGO(UseG1GC, true);
+  } else if (os::is_server_class_machine()) {
 #if INCLUDE_G1GC
     FLAG_SET_ERGO_IF_DEFAULT(UseG1GC, true);
 #elif INCLUDE_PARALLELGC

src/hotspot/share/gc/z/zPageAllocator.cpp

@@ -1003,44 +1003,37 @@ bool ZPartition::prime(ZWorkers* workers, size_t size) {
     return true;
   }
 
-  ZArray<ZVirtualMemory> vmems;
-
   // Claim virtual memory
-  const size_t claimed_size = claim_virtual(size, &vmems);
-
-  // The partition must have size available in virtual memory when priming.
-  assert(claimed_size == size, "must succeed %zx == %zx", claimed_size, size);
+  const ZVirtualMemory vmem = claim_virtual(size);
 
   // Increase capacity
-  increase_capacity(claimed_size);
+  increase_capacity(size);
 
-  for (ZVirtualMemory vmem : vmems) {
-    // Claim the backing physical memory
-    claim_physical(vmem);
+  // Claim the backing physical memory
+  claim_physical(vmem);
 
-    // Commit the claimed physical memory
-    const size_t committed = commit_physical(vmem);
+  // Commit the claimed physical memory
+  const size_t committed = commit_physical(vmem);
 
-    if (committed != vmem.size()) {
-      // This is a failure state. We do not cleanup the maybe partially committed memory.
-      return false;
-    }
-
-    map_virtual(vmem);
-
-    check_numa_mismatch(vmem, _numa_id);
-
-    if (AlwaysPreTouch) {
-      // Pre-touch memory
-      ZPreTouchTask task(vmem.start(), vmem.end());
-      workers->run_all(&task);
-    }
-
-    // We don't have to take a lock here as no other threads will access the cache
-    // until we're finished
-    _cache.insert(vmem);
+  if (committed != vmem.size()) {
+    // This is a failure state. We do not cleanup the maybe partially committed memory.
+    return false;
   }
 
+  map_virtual(vmem);
+
+  check_numa_mismatch(vmem, _numa_id);
+
+  if (AlwaysPreTouch) {
+    // Pre-touch memory
+    ZPreTouchTask task(vmem.start(), vmem.end());
+    workers->run_all(&task);
+  }
+
+  // We don't have to take a lock here as no other threads will access the cache
+  // until we're finished
+  _cache.insert(vmem);
+
   return true;
 }
 

src/hotspot/share/interpreter/bytecodes.cpp

@@ -369,7 +369,7 @@ Bytecodes::Code Bytecodes::code_at(Method* method, int bci) {
 Bytecodes::Code Bytecodes::non_breakpoint_code_at(const Method* method, address bcp) {
   assert(method != nullptr, "must have the method for breakpoint conversion");
   assert(method->contains(bcp), "must be valid bcp in method");
-  return method->orig_bytecode_at(method->bci_from(bcp));
+  return method->orig_bytecode_at(method->bci_from(bcp), false);
 }
 
 int Bytecodes::special_length_at(Bytecodes::Code code, address bcp, address end) {

src/hotspot/share/interpreter/interpreterRuntime.cpp

@@ -777,7 +777,7 @@ JRT_END
 // Invokes
 
 JRT_ENTRY(Bytecodes::Code, InterpreterRuntime::get_original_bytecode_at(JavaThread* current, Method* method, address bcp))
-  return method->orig_bytecode_at(method->bci_from(bcp));
+  return method->orig_bytecode_at(method->bci_from(bcp), false);
 JRT_END
 
 JRT_ENTRY(void, InterpreterRuntime::set_original_bytecode_at(JavaThread* current, Method* method, address bcp, Bytecodes::Code new_code))

src/hotspot/share/interpreter/linkResolver.cpp

@@ -158,14 +158,14 @@ void CallInfo::set_common(Klass* resolved_klass,
 }
 
 // utility query for unreflecting a method
-CallInfo::CallInfo(Method* resolved_method, Klass* resolved_klass, TRAPS) {
+CallInfo::CallInfo(Method* resolved_method, Klass* resolved_klass, Thread* thread) {
   Klass* resolved_method_holder = resolved_method->method_holder();
   if (resolved_klass == nullptr) { // 2nd argument defaults to holder of 1st
     resolved_klass = resolved_method_holder;
   }
   _resolved_klass  = resolved_klass;
-  _resolved_method = methodHandle(THREAD, resolved_method);
-  _selected_method = methodHandle(THREAD, resolved_method);
+  _resolved_method = methodHandle(thread, resolved_method);
+  _selected_method = methodHandle(thread, resolved_method);
   // classify:
   CallKind kind = CallInfo::unknown_kind;
   int index = resolved_method->vtable_index();
@@ -206,8 +206,9 @@ CallInfo::CallInfo(Method* resolved_method, Klass* resolved_klass, TRAPS) {
   _call_index = index;
   _resolved_appendix = Handle();
   // Find or create a ResolvedMethod instance for this Method*
-  set_resolved_method_name(CHECK);
-
+  if (thread->is_Java_thread()) { // exclude DCEVM VM thread
+    set_resolved_method_name(JavaThread::cast(thread));
+  }
   DEBUG_ONLY(verify());
 }
 
@@ -217,6 +218,10 @@ void CallInfo::set_resolved_method_name(TRAPS) {
   _resolved_method_name = Handle(THREAD, rmethod_name);
 }
 
+void CallInfo::set_resolved_method_name_dcevm(oop rmethod_name, Thread* thread) {
+  _resolved_method_name = Handle(thread, rmethod_name);
+}
+
 #ifdef ASSERT
 void CallInfo::verify() {
   switch (call_kind()) {  // the meaning and allowed value of index depends on kind
@@ -314,9 +319,14 @@ void LinkResolver::check_klass_accessibility(Klass* ref_klass, Klass* sel_klass,
   if (!base_klass->is_instance_klass()) {
     return;  // no relevant check to do
   }
-
+  Klass* refKlassNewest = ref_klass;
+  Klass* baseKlassNewest = base_klass;
+  if (AllowEnhancedClassRedefinition) {
+    refKlassNewest = ref_klass->newest_version();
+    baseKlassNewest = base_klass->newest_version();
+  }
   Reflection::VerifyClassAccessResults vca_result =
-    Reflection::verify_class_access(ref_klass, InstanceKlass::cast(base_klass), true);
+    Reflection::verify_class_access(refKlassNewest, InstanceKlass::cast(baseKlassNewest), true);
   if (vca_result != Reflection::ACCESS_OK) {
     ResourceMark rm(THREAD);
     char* msg = Reflection::verify_class_access_msg(ref_klass,
@@ -578,7 +588,8 @@ void LinkResolver::check_method_accessability(Klass* ref_klass,
   // We'll check for the method name first, as that's most likely
   // to be false (so we'll short-circuit out of these tests).
   if (sel_method->name() == vmSymbols::clone_name() &&
-      sel_klass == vmClasses::Object_klass() &&
+      ( (!AllowEnhancedClassRedefinition && sel_klass == vmClasses::Object_klass()) ||
+        (AllowEnhancedClassRedefinition && sel_klass->newest_version() == vmClasses::Object_klass()->newest_version()) ) &&
       resolved_klass->is_array_klass()) {
     // We need to change "protected" to "public".
     assert(flags.is_protected(), "clone not protected?");
@@ -1040,7 +1051,7 @@ void LinkResolver::resolve_field(fieldDescriptor& fd,
     //     or by the <init> method (in case of an instance field).
     if (is_put && fd.access_flags().is_final()) {
 
-      if (sel_klass != current_klass) {
+      if (sel_klass != current_klass && (!AllowEnhancedClassRedefinition || sel_klass != current_klass->active_version())) {
         ResourceMark rm(THREAD);
         stringStream ss;
         ss.print("Update to %s final field %s.%s attempted from a different class (%s) than the field's declaring class",
@@ -1059,14 +1070,16 @@ void LinkResolver::resolve_field(fieldDescriptor& fd,
                                                      !fd.is_static() &&
                                                      !m->is_object_initializer());
 
-        if (is_initialized_static_final_update || is_initialized_instance_final_update) {
-          ResourceMark rm(THREAD);
-          stringStream ss;
-          ss.print("Update to %s final field %s.%s attempted from a different method (%s) than the initializer method %s ",
-                   is_static ? "static" : "non-static", resolved_klass->external_name(), fd.name()->as_C_string(),
-                   m->name()->as_C_string(),
-                   is_static ? "<clinit>" : "<init>");
-          THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), ss.as_string());
+        if (!AllowEnhancedClassRedefinition || !m->name()->equals("$$ha$clinit")) {
+          if (is_initialized_static_final_update || is_initialized_instance_final_update) {
+            ResourceMark rm(THREAD);
+            stringStream ss;
+            ss.print("Update to %s final field %s.%s attempted from a different method (%s) than the initializer method %s ",
+                    is_static ? "static" : "non-static", resolved_klass->external_name(), fd.name()->as_C_string(),
+                    m->name()->as_C_string(),
+                    is_static ? "<clinit>" : "<init>");
+            THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), ss.as_string());
+          }
         }
       }
     }

src/hotspot/share/interpreter/linkResolver.hpp

@@ -89,7 +89,7 @@ class CallInfo : public StackObj {
   // utility to extract an effective CallInfo from a method and an optional receiver limit
   // does not queue the method for compilation.  This also creates a ResolvedMethodName
   // object for the resolved_method.
-  CallInfo(Method* resolved_method, Klass* resolved_klass, TRAPS);
+  CallInfo(Method* resolved_method, Klass* resolved_klass, Thread* thread);
 
   Klass*  resolved_klass() const                 { return _resolved_klass; }
   Method* resolved_method() const;
@@ -98,6 +98,7 @@ class CallInfo : public StackObj {
   Handle       resolved_method_name() const      { return _resolved_method_name; }
   // Materialize a java.lang.invoke.ResolvedMethodName for this resolved_method
   void     set_resolved_method_name(TRAPS);
+  void     set_resolved_method_name_dcevm(oop rmethod_name, Thread* thread);
 
   CallKind     call_kind() const                 { return _call_kind; }
   int          vtable_index() const {

src/hotspot/share/jfr/instrumentation/jfrEventClassTransformer.cpp

@@ -1698,6 +1698,7 @@ static InstanceKlass* create_new_instance_klass(InstanceKlass* ik, ClassFileStre
                              cld,
                              &cl_info,
                              ClassFileParser::INTERNAL, // internal visibility
+                             false,
                              THREAD);
   if (HAS_PENDING_EXCEPTION) {
     log_pending_exception(PENDING_EXCEPTION);

src/hotspot/share/jfr/metadata/metadata.xml

@@ -453,10 +453,10 @@
     <Field type="ulong" contentType="bytes" name="regionEndWaste" label="Region End Wasted" description="Total memory wasted at the end of regions due to refill" />
     <Field type="uint" name="regionsRefilled" label="Region Refills" description="Number of regions refilled" />
     <Field type="ulong" name="numPlabsFilled" label="PLAB Fills" description="Number of PLABs filled" />
-    <Field type="ulong" contentType="bytes" name="directAllocated" label="Allocated (Direct)" description="Total memory allocated using direct allocation outside of PLABs" />
-    <Field type="ulong" name="numDirectAllocated" label="Direct Allocations" description="Number of direct allocations" />
-    <Field type="ulong" contentType="bytes" name="failureUsed" label="Used (Failure)" description="Total memory occupied by objects in regions where evacuation failed" />
-    <Field type="ulong" contentType="bytes" name="failureWaste" label="Wasted (Failure)" description="Total memory left unused in regions where evacuation failed" />
+    <Field type="ulong" contentType="bytes" name="directAllocated" label="Allocated (direct)" description="Total memory allocated using direct allocation outside of PLABs" />
+    <Field type="ulong" name="numDirectAllocated" label="Direct allocations" description="Number of direct allocations" />
+    <Field type="ulong" contentType="bytes" name="failureUsed" label="Used (failure)" description="Total memory occupied by objects in regions where evacuation failed" />
+    <Field type="ulong" contentType="bytes" name="failureWaste" label="Wasted (failure)" description="Total memory left unused in regions where evacuation failed" />
   </Type>
 
   <Event name="G1EvacuationYoungStatistics" category="Java Virtual Machine, GC, Detailed" label="G1 Evacuation Statistics for Young" startTime="false"
@@ -523,7 +523,7 @@
   <Event name="PromotionFailed" category="Java Virtual Machine, GC, Detailed" label="Promotion Failed" startTime="false" description="Promotion of an object failed">
     <Field type="uint" name="gcId" label="GC Identifier" relation="GcId" />
     <Field type="CopyFailed" struct="true" name="promotionFailed" label="Promotion Failed Data" />
-    <Field type="Thread" name="thread" label="Running Thread" />
+    <Field type="Thread" name="thread" label="Running thread" />
   </Event>
 
   <Event name="EvacuationFailed" category="Java Virtual Machine, GC, Detailed" label="Evacuation Failed" startTime="false" description="Evacuation of an object failed">
@@ -1007,7 +1007,7 @@
     <Field type="ulong" contentType="bytes" name="nmethodsSize" label="Compilation Resulting Size" />
     <Field type="ulong" contentType="bytes" name="nmethodCodeSize" label="Compilation Resulting Code Size" />
     <Field type="long" contentType="millis" name="peakTimeSpent" label="Peak Time" />
-    <Field type="long" contentType="millis" name="totalTimeSpent" label="Total Time" />
+    <Field type="long" contentType="millis" name="totalTimeSpent" label="Total time" />
   </Event>
 
   <Event name="CompilerConfiguration" category="Java Virtual Machine, Compiler" label="Compiler Configuration" thread="false" period="endChunk" startTime="false">
@@ -1030,10 +1030,10 @@
   <Event name="CodeCacheConfiguration" category="Java Virtual Machine, Code Cache" label="Code Cache Configuration" thread="false" period="endChunk" startTime="false">
     <Field type="ulong" contentType="bytes" name="initialSize" label="Initial Size" />
     <Field type="ulong" contentType="bytes" name="reservedSize" label="Reserved Size" />
-    <Field type="ulong" contentType="bytes" name="nonNMethodSize" label="Non-Nmethod Size" />
+    <Field type="ulong" contentType="bytes" name="nonNMethodSize" label="Non-nmethod Size" />
     <Field type="ulong" contentType="bytes" name="profiledSize" label="Profiled Size" />
-    <Field type="ulong" contentType="bytes" name="nonProfiledSize" label="Non-Profiled Size" />
-    <Field type="ulong" contentType="bytes" name="expansionSize" label="Expansion Size" />
+    <Field type="ulong" contentType="bytes" name="nonProfiledSize" label="Non-profiled Size" />
+    <Field type="ulong" contentType="bytes" name="expansionSize" label="Expansion size" />
     <Field type="ulong" contentType="bytes" name="minBlockLength" label="Minimum Block Length" />
     <Field type="ulong" contentType="address" name="startAddress" label="Start Address" />
     <Field type="ulong" contentType="address" name="reservedTopAddress" label="Reserved Top" />
@@ -1159,10 +1159,10 @@
     <Field type="ulong" contentType="bytes" name="size" label="Size" />
     <Field type="ulong" contentType="bytes" name="harvested" label="Harvested" />
     <Field type="ulong" contentType="bytes" name="committed" label="Committed" />
-    <Field type="uint" name="harvestedRanges" label="Harvested Ranges" description="Number of harvested memory ranges" />
-    <Field type="boolean" name="multiPartition" label="Multi-Partition" />
-    <Field type="boolean" name="successful" label="Successful" />
-    <Field type="boolean" name="nonBlocking" label="Non-Blocking" />
+    <Field type="uint" name="numHarvested" label="Number of harvested vmems" />
+    <Field type="boolean" name="multiPartition" label="Multi-partition allocation" />
+    <Field type="boolean" name="successful" label="Successful allocation" />
+    <Field type="boolean" name="nonBlocking" label="Non-blocking" />
   </Event>
 
   <Event name="ZRelocationSet" category="Java Virtual Machine, GC, Detailed" label="ZGC Relocation Set" thread="true">

src/hotspot/share/jfr/recorder/jfrRecorder.cpp

@@ -69,6 +69,7 @@ static bool enable() {
   }
   _enabled = FlightRecorder;
   assert(_enabled, "invariant");
+  AllowEnhancedClassRedefinition = false;
   return _enabled;
 }
 

src/hotspot/share/jvmci/jvmciCompilerToVM.cpp

@@ -2253,21 +2253,14 @@ static jobject read_field_value(Handle obj, long displacement, jchar type_char,
   if (!aligned) {
     JVMCI_THROW_MSG_NULL(IllegalArgumentException, "read is unaligned");
   }
-  if (obj->is_array()) {
-    // Disallow reading after the last element of an array
-    size_t array_length = arrayOop(obj())->length();
-    int lh = obj->klass()->layout_helper();
-    size_t size_in_bytes = array_length << Klass::layout_helper_log2_element_size(lh);
-    size_in_bytes += Klass::layout_helper_header_size(lh);
-    if ((size_t) displacement + basic_type_elemsize > size_in_bytes) {
-      JVMCI_THROW_MSG_NULL(IllegalArgumentException, "reading after last array element");
-    }
-  }
   if (basic_type == T_OBJECT) {
     if (obj->is_objArray()) {
       if (displacement < arrayOopDesc::base_offset_in_bytes(T_OBJECT)) {
         JVMCI_THROW_MSG_NULL(IllegalArgumentException, "reading from array header");
       }
+      if (displacement + heapOopSize > arrayOopDesc::base_offset_in_bytes(T_OBJECT) + arrayOop(obj())->length() * heapOopSize) {
+        JVMCI_THROW_MSG_NULL(IllegalArgumentException, "reading after last array element");
+      }
       if (((displacement - arrayOopDesc::base_offset_in_bytes(T_OBJECT)) % heapOopSize) != 0) {
         JVMCI_THROW_MSG_NULL(IllegalArgumentException, "misaligned object read from array");
       }

src/hotspot/share/memory/universe.cpp

@@ -180,6 +180,8 @@ int             Universe::_base_vtable_size = 0;
 bool            Universe::_bootstrapping = false;
 bool            Universe::_module_initialized = false;
 bool            Universe::_fully_initialized = false;
+bool            Universe::_is_redefining_gc_run = false;
+bool            Universe::_is_inside_redefinition = false;
 
 OopStorage*     Universe::_vm_weak = nullptr;
 OopStorage*     Universe::_vm_global = nullptr;
@@ -1074,6 +1076,35 @@ void Universe::initialize_known_methods(JavaThread* current) {
                           vmSymbols::doStackWalk_signature(), false);
 }
 
+void Universe::reinitialize_known_method_dcevm(JavaThread* current) {
+  // Set up static method for registering finalizers
+  _finalizer_register_cache.init(current,
+                          vmClasses::Finalizer_klass(),
+                          "register",
+                          vmSymbols::object_void_signature(), true);
+
+  _throw_illegal_access_error_cache.init(current,
+                          vmClasses::internal_Unsafe_klass(),
+                          "throwIllegalAccessError",
+                          vmSymbols::void_method_signature(), true);
+
+  _throw_no_such_method_error_cache.init(current,
+                          vmClasses::internal_Unsafe_klass(),
+                          "throwNoSuchMethodError",
+                          vmSymbols::void_method_signature(), true);
+
+  // Set up method for registering loaded classes in class loader vector
+  _loader_addClass_cache.init(current,
+                              vmClasses::ClassLoader_klass(),
+                              "addClass",
+                              vmSymbols::class_void_signature(), false);
+  // Set up method for stack walking
+  _do_stack_walk_cache.init(current,
+                            vmClasses::AbstractStackWalker_klass(),
+                            "doStackWalk",
+                            vmSymbols::doStackWalk_signature(), false);
+}
+
 void universe2_init() {
   EXCEPTION_MARK;
   Universe::genesis(CATCH);
@@ -1376,3 +1407,9 @@ bool Universe::is_in_heap(const void* p) {
 }
 
 #endif // ASSERT
+
+void Universe::update_vmClasses_dcevm() {
+  _the_array_interfaces_array->at_put(0, vmClasses::Cloneable_klass()->newest_version());
+  _the_array_interfaces_array->at_put(1, vmClasses::Serializable_klass()->newest_version());
+}
+

src/hotspot/share/memory/universe.hpp

@@ -160,6 +160,8 @@ class Universe: AllStatic {
 
   static uintptr_t _verify_oop_mask;
   static uintptr_t _verify_oop_bits;
+  static bool _is_redefining_gc_run;
+  static bool _is_inside_redefinition;
 
   // Table of primitive type mirrors, excluding T_OBJECT and T_ARRAY
   // but including T_VOID, hence the index including T_VOID
@@ -175,6 +177,12 @@ class Universe: AllStatic {
   static void calculate_verify_data(HeapWord* low_boundary, HeapWord* high_boundary) PRODUCT_RETURN;
   static void set_verify_data(uintptr_t mask, uintptr_t bits) PRODUCT_RETURN;
 
+  // (DCEVM) Advanced class redefinition.
+  static bool is_redefining_gc_run()               { return _is_redefining_gc_run; }
+  static void set_redefining_gc_run(bool b)        { _is_redefining_gc_run = b;    }
+  static bool is_inside_redefinition()               { return _is_inside_redefinition; }
+  static void set_inside_redefinition(bool b)        { _is_inside_redefinition = b;    }
+
   // Known classes in the VM
   static TypeArrayKlass* boolArrayKlass()        { return typeArrayKlass(T_BOOLEAN); }
   static TypeArrayKlass* byteArrayKlass()        { return typeArrayKlass(T_BYTE); }
@@ -189,6 +197,9 @@ class Universe: AllStatic {
 
   static Klass* fillerArrayKlass()               { return _fillerArrayKlass; }
 
+  // (DCEVM)
+  static void update_vmClasses_dcevm();
+
   static TypeArrayKlass* typeArrayKlass(BasicType t) {
     assert((uint)t >= T_BOOLEAN, "range check for type: %s", type2name(t));
     assert((uint)t < T_LONG+1,   "range check for type: %s", type2name(t));
@@ -249,6 +260,8 @@ class Universe: AllStatic {
   // Function to initialize these
   static void initialize_known_methods(JavaThread* current);
 
+  static void reinitialize_known_method_dcevm(JavaThread* current);
+
   static void create_preallocated_out_of_memory_errors(TRAPS);
 
   // Reference pending list manipulation.  Access is protected by

src/hotspot/share/oops/compressedKlass.inline.hpp

@@ -95,7 +95,7 @@ inline void CompressedKlassPointers::check_valid_narrow_klass_id(narrowKlass nk)
 
 inline address CompressedKlassPointers::encoding_range_end() {
   const int max_bits = narrow_klass_pointer_bits() + _shift;
-  return (address)((uintptr_t)_base + nth_bit(max_bits));
+  return _base + nth_bit(max_bits);
 }
 
 #endif // SHARE_OOPS_COMPRESSEDKLASS_INLINE_HPP

src/hotspot/share/oops/cpCache.cpp

@@ -322,7 +322,7 @@ ResolvedMethodEntry* ConstantPoolCache::set_method_handle(int method_index, cons
   if (has_appendix) {
     const int appendix_index = method_entry->resolved_references_index();
     assert(appendix_index >= 0 && appendix_index < resolved_references->length(), "oob");
-    assert(resolved_references->obj_at(appendix_index) == nullptr, "init just once");
+    assert(AllowEnhancedClassRedefinition || resolved_references->obj_at(appendix_index) == nullptr, "init just once");
     resolved_references->obj_at_put(appendix_index, appendix());
   }
 
@@ -872,3 +872,25 @@ void ConstantPoolCache::print_resolved_indy_entries(outputStream* st) const {
     }
   }
 }
+
+void ConstantPoolCache::clear_entries() {
+  if (_resolved_indy_entries != nullptr) {
+    for (int i = 0; i < _resolved_indy_entries->length(); i++) {
+      ResolvedIndyEntry *indy_entry = resolved_indy_entry_at(i);
+      indy_entry->clear_entry();
+    }
+  }
+  if (_resolved_field_entries != nullptr) {
+    for (int i = 0; i < _resolved_field_entries->length(); i++) {
+      ResolvedFieldEntry* field_entry = resolved_field_entry_at(i);
+      field_entry->clear_entry();
+    }
+  }
+  if (_resolved_method_entries != nullptr) {
+    for (int i = 0; i < _resolved_method_entries->length(); i++) {
+      ResolvedMethodEntry *method_entry = resolved_method_entry_at(i);
+      method_entry->clear_entry();
+    }
+  }
+}
+

src/hotspot/share/oops/cpCache.hpp

@@ -251,6 +251,9 @@ class ConstantPoolCache: public MetaspaceObj {
 
   // Verify
   void verify_on(outputStream* st);
+
+  // DCEVM
+  void clear_entries();
 };
 
 #endif // SHARE_OOPS_CPCACHE_HPP

src/hotspot/share/oops/fieldInfo.hpp

@@ -199,6 +199,9 @@ class FieldInfo {
 
   inline Symbol* signature(ConstantPool* cp) const;
 
+  // (DCEVM) - signature() duplicate for internal fields to resolve gcc compilation "nonnull" issue
+  inline Symbol* signature_injected_dcevm() const;
+
   inline Symbol* lookup_symbol(int symbol_index) const;
 
   void print(outputStream* os, ConstantPool* cp);

src/hotspot/share/oops/fieldInfo.inline.hpp

@@ -49,6 +49,12 @@ inline Symbol* FieldInfo::signature(ConstantPool* cp) const {
   return cp->symbol_at(index);
 }
 
+inline Symbol* FieldInfo::signature_injected_dcevm() const {
+  assert(_field_flags.is_injected(), "injected only");
+  int index = _signature_index;
+  return lookup_symbol(index);
+}
+
 inline Symbol* FieldInfo::lookup_symbol(int symbol_index) const {
   assert(_field_flags.is_injected(), "only injected fields");
   return Symbol::vm_symbol_at(static_cast<vmSymbolID>(symbol_index));

src/hotspot/share/oops/fieldStreams.hpp

@@ -120,7 +120,7 @@ class FieldStreamBase : public StackObj {
 
   // Convenient methods
 
-  const FieldInfo& to_FieldInfo() const {
+  FieldInfo to_FieldInfo() {
     return _fi_buf;
   }
 
@@ -131,7 +131,7 @@ class FieldStreamBase : public StackObj {
   // bridge to a heavier API:
   fieldDescriptor& field_descriptor() const {
     fieldDescriptor& field = const_cast<fieldDescriptor&>(_fd_buf);
-    field.reinitialize(field_holder(), to_FieldInfo());
+    field.reinitialize(field_holder(), _index);
     return field;
   }
 };

src/hotspot/share/oops/instanceKlass.cpp

@@ -97,6 +97,7 @@
 #include "utilities/events.hpp"
 #include "utilities/macros.hpp"
 #include "utilities/nativeStackPrinter.hpp"
+#include "utilities/pair.hpp"
 #include "utilities/stringUtils.hpp"
 #ifdef COMPILER1
 #include "c1/c1_Compiler.hpp"
@@ -431,11 +432,21 @@ bool InstanceKlass::has_nestmate_access_to(InstanceKlass* k, TRAPS) {
     return false;
   }
 
+  // (DCEVM) cur_host can be old, decide accessibility based on active version
+  if (AllowEnhancedClassRedefinition) {
+    cur_host = InstanceKlass::cast(cur_host->active_version());
+  }
+
   Klass* k_nest_host = k->nest_host(CHECK_false);
   if (k_nest_host == nullptr) {
     return false;
   }
 
+  // (DCEVM) k_nest_host can be old, decide accessibility based on active version
+  if (AllowEnhancedClassRedefinition) {
+    k_nest_host = InstanceKlass::cast(k_nest_host->active_version());
+  }
+
   bool access = (cur_host == k_nest_host);
 
   ResourceMark rm(THREAD);
@@ -988,7 +999,10 @@ bool InstanceKlass::link_class_impl(TRAPS) {
         if (is_shared()) {
           assert(!verified_at_dump_time(), "must be");
         }
-        {
+        // (DCEVM): If class A is being redefined and class B->A (B is extended from A) and B is host class of anonymous class C
+        // then second redefinition fails with cannot cast klass exception. So we currently turn off bytecode verification
+        // on redefinition.
+        if (!AllowEnhancedClassRedefinition || !newest_version()->is_redefining()) {
           bool verify_ok = verify_code(THREAD);
           if (!verify_ok) {
             return false;
@@ -1050,7 +1064,7 @@ bool InstanceKlass::link_class_impl(TRAPS) {
       } else {
         set_init_state(linked);
       }
-      if (JvmtiExport::should_post_class_prepare()) {
+      if (JvmtiExport::should_post_class_prepare() && (!AllowEnhancedClassRedefinition || old_version() == nullptr /* JVMTI deadlock otherwise */)) {
         JvmtiExport::post_class_prepare(THREAD, this);
       }
     }
@@ -1196,7 +1210,8 @@ void InstanceKlass::initialize_impl(TRAPS) {
     // If we were to use wait() instead of waitInterruptibly() then
     // we might end up throwing IE from link/symbol resolution sites
     // that aren't expected to throw.  This would wreak havoc.  See 6320309.
-    while (is_being_initialized() && !is_reentrant_initialization(jt)) {
+    while ((is_being_initialized() && !is_reentrant_initialization(jt))
+           || (AllowEnhancedClassRedefinition && old_version() != nullptr && InstanceKlass::cast(old_version())->is_being_initialized())) {
       if (debug_logging_enabled) {
         ResourceMark rm(jt);
         log_debug(class, init)("Thread \"%s\" waiting for initialization of %s by thread \"%s\"",
@@ -1483,6 +1498,15 @@ void InstanceKlass::init_implementor() {
   }
 }
 
+// (DCEVM) - init_implementor() for dcevm
+void InstanceKlass::init_implementor_from_redefine() {
+  assert(is_interface(), "not interface");
+  InstanceKlass* volatile* addr = adr_implementor();
+  assert(addr != nullptr, "null addr");
+  if (addr != nullptr) {
+    *addr = nullptr;
+  }
+}
 
 void InstanceKlass::process_interfaces() {
   // link this class into the implementors list of every interface it implements
@@ -1539,6 +1563,20 @@ bool InstanceKlass::implements_interface(Klass* k) const {
   return false;
 }
 
+
+// (DCEVM)
+bool InstanceKlass::implements_interface_any_version(Klass* k) const {
+  k = k->newest_version();
+  if (this->newest_version() == k) return true;
+  assert(k->is_interface(), "should be an interface class");
+  for (int i = 0; i < transitive_interfaces()->length(); i++) {
+    if (transitive_interfaces()->at(i)->newest_version() == k) {
+      return true;
+    }
+  }
+  return false;
+}
+
 bool InstanceKlass::is_same_or_direct_interface(Klass *k) const {
   // Verify direct super interface
   if (this == k) return true;
@@ -1784,7 +1822,7 @@ bool InstanceKlass::find_local_field(Symbol* name, Symbol* sig, fieldDescriptor*
     Symbol* f_name = fs.name();
     Symbol* f_sig  = fs.signature();
     if (f_name == name && f_sig == sig) {
-      fd->reinitialize(const_cast<InstanceKlass*>(this), fs.to_FieldInfo());
+      fd->reinitialize(const_cast<InstanceKlass*>(this), fs.index());
       return true;
     }
   }
@@ -1853,7 +1891,7 @@ Klass* InstanceKlass::find_field(Symbol* name, Symbol* sig, bool is_static, fiel
 bool InstanceKlass::find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const {
   for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
     if (fs.offset() == offset) {
-      fd->reinitialize(const_cast<InstanceKlass*>(this), fs.to_FieldInfo());
+      fd->reinitialize(const_cast<InstanceKlass*>(this), fs.index());
       if (fd->is_static() == is_static) return true;
     }
   }
@@ -1889,6 +1927,21 @@ void InstanceKlass::methods_do(void f(Method* method)) {
   }
 }
 
+//  (DCEVM) Update information contains mapping of fields from old class to the new class.
+//  Info is stored on HEAP, you need to call clear_update_information to free the space.
+void InstanceKlass::store_update_information(GrowableArray<int> &values) {
+  int *arr = NEW_C_HEAP_ARRAY(int, values.length(), mtClass);
+  for (int i = 0; i < values.length(); i++) {
+    arr[i] = values.at(i);
+  }
+  set_update_information(arr);
+}
+
+void InstanceKlass::clear_update_information() {
+  FREE_C_HEAP_ARRAY(int, update_information());
+  set_update_information(nullptr);
+}
+
 
 void InstanceKlass::do_local_static_fields(FieldClosure* cl) {
   for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
@@ -1914,16 +1967,78 @@ void InstanceKlass::do_nonstatic_fields(FieldClosure* cl) {
   if (super != nullptr) {
     super->do_nonstatic_fields(cl);
   }
-  for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
-    fieldDescriptor& fd = fs.field_descriptor();
+  fieldDescriptor fd;
+  int length = java_fields_count();
+  for (int i = 0; i < length; i += 1) {
+    fd.reinitialize(this, i);
     if (!fd.is_static()) {
       cl->do_field(&fd);
     }
   }
 }
 
-static int compare_fields_by_offset(FieldInfo* a, FieldInfo* b) {
-  return a->offset() - b->offset();
+// first in Pair is offset, second is index.
+static int compare_fields_by_offset(Pair<int,int>* a, Pair<int,int>* b) {
+  return a->first - b->first;
+}
+
+template<typename F, typename S, typename T, typename ALLOC_BASE = ResourceObj>
+class Triple : public ALLOC_BASE {
+public:
+  F first;
+  S second;
+  T third;
+
+  Triple() {}
+  Triple(F f, S s, T t) : first(f), second(s), third(t) {}
+};
+
+void InstanceKlass::do_nonstatic_fields_dcevm_collect_fields(void* fields, int depth) {
+  InstanceKlass* super = superklass();
+  if (super != nullptr) {
+    super->do_nonstatic_fields_dcevm_collect_fields(fields, depth + 1);
+  }
+  GrowableArray<Triple<int,int, int> >* all_fields = (GrowableArray<Triple<int,int,int> >*) fields;
+  // In DebugInfo nonstatic fields are sorted by offset.
+  for (AllFieldStream fs(this); !fs.done(); fs.next()) {
+    if (!fs.access_flags().is_static()) {
+      Triple<int,int, int> f(fs.offset(), fs.index(), depth);
+      all_fields->push(f);
+    }
+  }
+}
+
+static int compare_fields_by_offset_dcevm(Triple<int,int,int>* a, Triple<int,int,int>* b) {
+  return a->first - b->first;
+}
+
+void InstanceKlass::do_nonstatic_fields_dcevm(FieldClosure* cl) {
+  GrowableArray<InstanceKlass*> class_hiearchy;
+  class_hiearchy.push(this);
+  InstanceKlass* super = superklass();
+  while (super != nullptr) {
+    class_hiearchy.push(super);
+    super = super->superklass();
+  }
+
+  GrowableArray<Triple<int,int, int>> fields_sorted;
+  do_nonstatic_fields_dcevm_collect_fields(&fields_sorted, 0);
+
+  int length = fields_sorted.length();
+  if (length > 0) {
+    // _sort_Fn is defined in growableArray.hpp.
+    fields_sorted.sort(compare_fields_by_offset_dcevm);
+
+    fieldDescriptor fd;
+
+    for (int i = 0; i < length; i++) {
+      InstanceKlass* ik = class_hiearchy.at(fields_sorted.at(i).third);
+      fd.reinitialize(ik, fields_sorted.at(i).second);
+      assert(!fd.is_static(), "only nonstatic fields");
+      assert(fd.offset() == fields_sorted.at(i).first, "offset matches");
+      cl->do_field(&fd);
+    }
+  }
 }
 
 void InstanceKlass::print_nonstatic_fields(FieldClosure* cl) {
@@ -1932,20 +2047,25 @@ void InstanceKlass::print_nonstatic_fields(FieldClosure* cl) {
     super->print_nonstatic_fields(cl);
   }
   ResourceMark rm;
+  fieldDescriptor fd;
   // In DebugInfo nonstatic fields are sorted by offset.
-  GrowableArray<FieldInfo> fields_sorted;
+  GrowableArray<Pair<int,int> > fields_sorted;
+  int i = 0;
   for (AllFieldStream fs(this); !fs.done(); fs.next()) {
     if (!fs.access_flags().is_static()) {
-      fields_sorted.push(fs.to_FieldInfo());
+      fd = fs.field_descriptor();
+      Pair<int,int> f(fs.offset(), fs.index());
+      fields_sorted.push(f);
+      i++;
     }
   }
-  int length = fields_sorted.length();
-  if (length > 0) {
+  if (i > 0) {
+    int length = i;
+    assert(length == fields_sorted.length(), "duh");
     fields_sorted.sort(compare_fields_by_offset);
-    fieldDescriptor fd;
     for (int i = 0; i < length; i++) {
-      fd.reinitialize(this, fields_sorted.at(i));
-      assert(!fd.is_static() && fd.offset() == checked_cast<int>(fields_sorted.at(i).offset()), "only nonstatic fields");
+      fd.reinitialize(this, fields_sorted.at(i).second);
+      assert(!fd.is_static() && fd.offset() == fields_sorted.at(i).first, "only nonstatic fields");
       cl->do_field(&fd);
     }
   }
@@ -2508,6 +2628,20 @@ void InstanceKlass::clean_dependency_context() {
   dependencies().clean_unloading_dependents();
 }
 
+// DCEVM - update jmethod ids
+bool InstanceKlass::update_jmethod_id(Method* method, jmethodID newMethodID) {
+  size_t idnum = (size_t)method->method_idnum();
+  jmethodID* jmeths = methods_jmethod_ids_acquire();
+  size_t length;                                // length assigned as debugging crumb
+  jmethodID id = nullptr;
+  if (jmeths != nullptr &&                         // If there is a cache
+      (length = (size_t)jmeths[0]) > idnum) {   // and if it is long enough,
+    jmeths[idnum+1] = newMethodID;              // Set method id (may be nullptr)
+    return true;
+  }
+  return false;
+}
+
 #ifndef PRODUCT
 void InstanceKlass::print_dependent_nmethods(bool verbose) {
   dependencies().print_dependent_nmethods(verbose);
@@ -4097,7 +4231,7 @@ void InstanceKlass::verify_on(outputStream* st) {
     }
 
     guarantee(sib->is_klass(), "should be klass");
-    guarantee(sib->super() == super, "siblings should have same superklass");
+    guarantee(sib->super() == super || (AllowEnhancedClassRedefinition && sib->super()->newest_version() == super->newest_version()), "siblings should have same superklass");
   }
 
   // Verify local interfaces

src/hotspot/share/oops/instanceKlass.hpp

@@ -136,6 +136,7 @@ class InstanceKlass: public Klass {
   friend class JVMCIVMStructs;
   friend class ClassFileParser;
   friend class CompileReplay;
+  friend class VM_EnhancedRedefineClasses;
 
  public:
   static const KlassKind Kind = InstanceKlassKind;
@@ -548,6 +549,11 @@ public:
 
   // reference type
   ReferenceType reference_type() const     { return (ReferenceType)_reference_type; }
+  // (DCEVM)
+  void set_reference_type(ReferenceType t) {
+    assert(t == (u1)t, "overflow");
+    _reference_type = (u1)t;
+  }
 
   // this class cp index
   u2 this_class_index() const             { return _this_class_index; }
@@ -767,6 +773,13 @@ public:
   inline u2 next_method_idnum();
   void set_initial_method_idnum(u2 value)             { _idnum_allocated_count = value; }
 
+  // DCEVM
+  void adjust_method_idnum(u2 value) {
+    if (value > _idnum_allocated_count) {
+      _idnum_allocated_count= value;
+    }
+  }
+
   // generics support
   Symbol* generic_signature() const;
   u2 generic_signature_index() const;
@@ -787,6 +800,7 @@ public:
   void ensure_space_for_methodids(int start_offset = 0);
   jmethodID jmethod_id_or_null(Method* method);
   void update_methods_jmethod_cache();
+  bool update_jmethod_id(Method* method, jmethodID newMethodID);
 
   // annotations support
   Annotations* annotations() const          { return _annotations; }
@@ -863,6 +877,7 @@ public:
 
   // subclass/subinterface checks
   bool implements_interface(Klass* k) const;
+  bool implements_interface_any_version(Klass* k) const;
   bool is_same_or_direct_interface(Klass* k) const;
 
 #ifdef ASSERT
@@ -876,11 +891,13 @@ public:
   int  nof_implementors() const;
   void add_implementor(InstanceKlass* ik);  // ik is a new class that implements this interface
   void init_implementor();           // initialize
+  void init_implementor_from_redefine();           // initialize
 
  private:
   // link this class into the implementors list of every interface it implements
   void process_interfaces();
-
+  // (DCEVM)
+  void do_nonstatic_fields_dcevm_collect_fields(void* fields, int depth);
  public:
   // virtual operations from Klass
   GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots,
@@ -894,9 +911,15 @@ public:
   // Iterators
   void do_local_static_fields(FieldClosure* cl);
   void do_nonstatic_fields(FieldClosure* cl); // including inherited fields
+  // (DCEVM)
+  void do_nonstatic_fields_dcevm(FieldClosure* cl);
   void do_local_static_fields(void f(fieldDescriptor*, Handle, TRAPS), Handle, TRAPS);
   void print_nonstatic_fields(FieldClosure* cl); // including inherited and injected fields
 
+  // Advanced class redefinition: FIXME: why here?
+  void store_update_information(GrowableArray<int> &values);
+  void clear_update_information();
+
   void methods_do(void f(Method* method));
 
   static InstanceKlass* cast(Klass* k) {

src/hotspot/share/oops/klass.cpp

@@ -301,7 +301,15 @@ Klass::Klass() : _kind(UnknownKlassKind) {
 // which doesn't zero out the memory before calling the constructor.
 Klass::Klass(KlassKind kind) : _kind(kind),
                                _prototype_header(make_prototype(this)),
-                               _shared_class_path_index(-1) {
+                               _old_version(nullptr),
+                               _new_version(nullptr),
+                               _redefinition_flags(Klass::NoRedefinition),
+                               _is_redefining(false),
+                               _update_information(nullptr),
+                               _is_copying_backwards(false),
+                               _is_rolled_back(false),
+                               _shared_class_path_index(-1)
+                               {
   CDS_ONLY(_shared_class_flags = 0;)
   CDS_JAVA_HEAP_ONLY(_archived_mirror_index = -1;)
   _primary_supers[0] = this;
@@ -511,8 +519,8 @@ void Klass::initialize_supers(Klass* k, Array<InstanceKlass*>* transitive_interf
     set_super(nullptr);
     _primary_supers[0] = this;
     assert(super_depth() == 0, "Object must already be initialized properly");
-  } else if (k != super() || k == vmClasses::Object_klass()) {
-    assert(super() == nullptr || super() == vmClasses::Object_klass(),
+  } else if (k != super() || k == vmClasses::Object_klass() || (k->is_redefining() && k == vmClasses::Object_klass()->newest_version())) {
+    assert(super() == NULL || super() == vmClasses::Object_klass() || (k->is_redefining() && super() == vmClasses::Object_klass()->newest_version()),
            "initialize this only once to a non-trivial value");
     set_super(k);
     Klass* sup = k;
@@ -718,6 +726,27 @@ void Klass::clean_subklass() {
   }
 }
 
+void Klass::remove_from_sibling_list() {
+  debug_only(verify();)
+
+  // remove ourselves to superklass' subklass list
+  InstanceKlass* super = superklass();
+  if (super == nullptr) return;        // special case: class Object
+  if (super->subklass() == this) {
+    // this klass is the first subklass
+    super->set_subklass(next_sibling());
+  } else {
+    Klass* sib = super->subklass();
+    assert(sib != nullptr, "cannot find this class in sibling list!");
+    while (sib->next_sibling() != this) {
+      sib = sib->next_sibling();
+      assert(sib != nullptr, "cannot find this class in sibling list!");
+    }
+    sib->set_next_sibling(next_sibling());
+  }
+  debug_only(verify();)
+}
+
 void Klass::clean_weak_klass_links(bool unloading_occurred, bool clean_alive_klasses) {
   if (!ClassUnloading || !unloading_occurred) {
     return;
@@ -1342,3 +1371,25 @@ void Klass::on_secondary_supers_verification_failure(Klass* super, Klass* sub, b
   fatal("%s: %s implements %s: linear_search: %d; table_lookup: %d",
         msg, sub->external_name(), super->external_name(), linear_result, table_result);
 }
+
+void Klass::update_supers_dcevm() {
+  if (_super != NULL) {
+    _super = _super->newest_version();
+  }
+  int sup_depth = super_depth();
+  for (int idx = 0; idx < sup_depth; idx++) {
+    Klass* primary = _primary_supers[idx];
+    if (primary == NULL) {
+      break;
+    }
+    _primary_supers[idx] = primary->newest_version();
+  }
+  if (secondary_super_cache() != NULL) {
+    set_secondary_super_cache(secondary_super_cache()->newest_version());
+  }
+
+  int cnt = secondary_supers()->length();
+  for (int i = 0; i < cnt; i++) {
+    secondary_supers()->at_put(i, secondary_supers()->at(i)->newest_version());
+  }
+}

src/hotspot/share/oops/klass.hpp

@@ -17,7 +17,7 @@
  * 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
+ e or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */
@@ -165,6 +165,19 @@ class Klass : public Metadata {
   uintx    _secondary_supers_bitmap;
   uint8_t  _hash_slot;
 
+  // Advanced class redefinition
+
+  // Old version (used in advanced class redefinition)
+  Klass*      _old_version;
+  // New version (used in advanced class redefinition)
+  Klass*      _new_version;
+
+  int         _redefinition_flags;     // Level of class redefinition
+  bool        _is_redefining;
+  int*        _update_information;
+  bool        _is_copying_backwards;   // Does the class need to copy fields backwards? => possibly overwrite itself?
+  bool        _is_rolled_back;         // true if class was rolled back in redefinition
+
 private:
   // This is an index into AOTClassLocationConfig::class_locations(), to
   // indicate the AOTClassLocation where this class is loaded from during
@@ -302,6 +315,7 @@ protected:
 
   InstanceKlass* superklass() const;
   void append_to_sibling_list();           // add newly created receiver to superklass' subklass list
+  void remove_from_sibling_list();         // enhanced class redefinition
 
   void set_next_link(Klass* k) { _next_link = k; }
   Klass* next_link() const { return _next_link; }   // The next klass defined by the class loader.
@@ -402,6 +416,33 @@ protected:
   virtual ModuleEntry* module() const = 0;
   virtual PackageEntry* package() const = 0;
 
+  // Advanced class redefinition
+  Klass* old_version() const             { return _old_version; }
+  void set_old_version(Klass* klass)     { assert(_old_version == nullptr || klass == nullptr, "Old version can only be set once!"); _old_version = klass; }
+  Klass* new_version() const             { return _new_version; }
+  void set_new_version(Klass* klass)     { assert(_new_version == nullptr || klass == nullptr, "New version can only be set once!"); _new_version = klass; }
+  bool is_redefining() const             { return _is_redefining; }
+  void set_redefining(bool b)            { _is_redefining = b; }
+  int redefinition_flags() const         { return _redefinition_flags; }
+  bool check_redefinition_flag(int flags) const { return (_redefinition_flags & flags) != 0; }
+  void clear_redefinition_flag(int flag) { _redefinition_flags &= ~flag; }
+  void set_redefinition_flag(int flag)   { _redefinition_flags |= flag; }
+  void set_redefinition_flags(int flags) { _redefinition_flags = flags; }
+
+  const Klass* newest_version() const    { return _new_version == nullptr ? this : _new_version->newest_version(); }
+        Klass* newest_version()          { return _new_version == nullptr ? this : _new_version->newest_version(); }
+
+  const Klass* active_version() const   { return _new_version == nullptr || _new_version->is_redefining() ? this : _new_version->active_version(); }
+        Klass* active_version()         { return _new_version == nullptr || _new_version->is_redefining() ? this : _new_version->active_version(); }
+
+  // update information
+  int *update_information() const        { return _update_information; }
+  void set_update_information(int *info) { _update_information = info; }
+  bool is_copying_backwards() const      { return _is_copying_backwards; }
+  void set_copying_backwards(bool b)     { _is_copying_backwards = b; }
+  bool is_rolled_back() { return _is_rolled_back; }
+  void set_rolled_back(bool b) { _is_rolled_back = b;}
+
  protected:                                // internal accessors
   void     set_subklass(Klass* s);
   void     set_next_sibling(Klass* s);
@@ -432,6 +473,16 @@ protected:
 
   static constexpr uintx SECONDARY_SUPERS_BITMAP_EMPTY    = 0;
   static constexpr uintx SECONDARY_SUPERS_BITMAP_FULL     = ~(uintx)0;
+   enum RedefinitionFlags {
+     NoRedefinition,                             // This class is not redefined at all!
+     ModifyClass = 1,                            // There are changes to the class meta data.
+     ModifyClassSize = ModifyClass << 1,         // The size of the class meta data changes.
+     ModifyInstances = ModifyClassSize << 1,     // There are change to the instance format.
+     ModifyInstanceSize = ModifyInstances << 1,  // The size of instances changes.
+     RemoveSuperType = ModifyInstanceSize << 1,  // A super type of this class is removed.
+     MarkedAsAffected = RemoveSuperType << 1,    // This class has been marked as an affected class.
+     PrimaryRedefine = MarkedAsAffected << 1     // This class is from primary redefinition set
+   };
 
   // Compiler support
   static ByteSize super_offset()                 { return byte_offset_of(Klass, _super); }
@@ -788,6 +839,8 @@ public:
   // Returns true if this Klass needs to be addressable via narrow Klass ID.
   inline bool needs_narrow_id() const;
 
+  // (DCEVM)
+  void update_supers_dcevm();
 };
 
 #endif // SHARE_OOPS_KLASS_HPP

src/hotspot/share/oops/method.cpp

@@ -101,7 +101,8 @@ Method* Method::allocate(ClassLoaderData* loader_data,
   return new (loader_data, size, MetaspaceObj::MethodType, THREAD) Method(cm, access_flags, name);
 }
 
-Method::Method(ConstMethod* xconst, AccessFlags access_flags, Symbol* name) {
+Method::Method(ConstMethod* xconst, AccessFlags access_flags, Symbol* name) :  _new_version(nullptr),
+                                                                               _old_version(nullptr) {
   NoSafepointVerifier no_safepoint;
   set_constMethod(xconst);
   set_access_flags(access_flags);
@@ -1838,14 +1839,14 @@ bool CompressedLineNumberReadStream::read_pair() {
 
 #if INCLUDE_JVMTI
 
-Bytecodes::Code Method::orig_bytecode_at(int bci) const {
+Bytecodes::Code Method::orig_bytecode_at(int bci, bool no_fatal) const {
   BreakpointInfo* bp = method_holder()->breakpoints();
   for (; bp != nullptr; bp = bp->next()) {
     if (bp->match(this, bci)) {
       return bp->orig_bytecode();
     }
   }
-  {
+  if (!no_fatal) {
     ResourceMark rm;
     fatal("no original bytecode found in %s at bci %d", name_and_sig_as_C_string(), bci);
   }
@@ -1950,7 +1951,7 @@ BreakpointInfo::BreakpointInfo(Method* m, int bci) {
   _signature_index = m->signature_index();
   _orig_bytecode = (Bytecodes::Code) *m->bcp_from(_bci);
   if (_orig_bytecode == Bytecodes::_breakpoint)
-    _orig_bytecode = m->orig_bytecode_at(_bci);
+    _orig_bytecode = m->orig_bytecode_at(_bci, false);
   _next = nullptr;
 }
 
@@ -1959,7 +1960,7 @@ void BreakpointInfo::set(Method* method) {
   {
     Bytecodes::Code code = (Bytecodes::Code) *method->bcp_from(_bci);
     if (code == Bytecodes::_breakpoint)
-      code = method->orig_bytecode_at(_bci);
+      code = method->orig_bytecode_at(_bci, false);
     assert(orig_bytecode() == code, "original bytecode must be the same");
   }
 #endif
@@ -2135,7 +2136,10 @@ jmethodID Method::make_jmethod_id(ClassLoaderData* cld, Method* m) {
   // Have to add jmethod_ids() to class loader data thread-safely.
   // Also have to add the method to the list safely, which the lock
   // protects as well.
-  assert(JmethodIdCreation_lock->owned_by_self(), "sanity check");
+  assert(AllowEnhancedClassRedefinition || JmethodIdCreation_lock->owned_by_self(), "sanity check");
+  if (AllowEnhancedClassRedefinition && m != m->newest_version()) {
+    m = m->newest_version();
+  }
 
   ResourceMark rm;
   log_debug(jmethod)("Creating jmethodID for Method %s", m->external_name());

src/hotspot/share/oops/method.hpp

@@ -78,6 +78,9 @@ class Method : public Metadata {
   int               _vtable_index;               // vtable index of this method (see VtableIndexFlag)
   AccessFlags       _access_flags;               // Access flags
   MethodFlags       _flags;
+  // (DCEVM) Newer version of method available?
+  Method*           _new_version;
+  Method*           _old_version;
 
   u2                _intrinsic_id;               // vmSymbols::intrinsic_id (0 == _none)
 
@@ -143,6 +146,23 @@ class Method : public Metadata {
   u2 name_index() const                          { return constMethod()->name_index();         }
   void set_name_index(int index)                 { constMethod()->set_name_index(index);       }
 
+  Method* new_version() const                    { return _new_version; }
+  void set_new_version(Method* m)                { _new_version = m; }
+  Method* newest_version()                       { return (_new_version == nullptr) ? this : _new_version->newest_version(); }
+
+  Method* old_version() const                    { return _old_version; }
+  void set_old_version(Method* m) {
+    /*if (m == nullptr) {
+      _old_version = nullptr;
+      return;
+    }*/
+
+    assert(_old_version == nullptr, "may only be set once");
+    assert(this->code_size() == m->code_size(), "must have same code length");
+    _old_version = m;
+  }
+  const Method* oldest_version() const           { return (_old_version == nullptr) ? this : _old_version->oldest_version(); }
+
   // signature
   Symbol* signature() const                      { return constants()->symbol_at(signature_index()); }
   u2 signature_index() const                     { return constMethod()->signature_index();         }
@@ -198,7 +218,7 @@ class Method : public Metadata {
 
   // JVMTI breakpoints
 #if !INCLUDE_JVMTI
-  Bytecodes::Code orig_bytecode_at(int bci) const {
+  Bytecodes::Code orig_bytecode_at(int bci, bool no_fatal) const {
     ShouldNotReachHere();
     return Bytecodes::_shouldnotreachhere;
   }
@@ -207,7 +227,7 @@ class Method : public Metadata {
   };
   u2   number_of_breakpoints() const {return 0;}
 #else // !INCLUDE_JVMTI
-  Bytecodes::Code orig_bytecode_at(int bci) const;
+  Bytecodes::Code orig_bytecode_at(int bci, bool no_fatal) const;
   void set_orig_bytecode_at(int bci, Bytecodes::Code code);
   void set_breakpoint(int bci);
   void clear_breakpoint(int bci);
@@ -850,7 +870,7 @@ public:
   void release_C_heap_structures();
 
   Method* get_new_method() const {
-    InstanceKlass* holder = method_holder();
+    InstanceKlass* holder = InstanceKlass::cast(method_holder()->newest_version());
     Method* new_method = holder->method_with_idnum(orig_method_idnum());
 
     assert(new_method != nullptr, "method_with_idnum() should not be null");

src/hotspot/share/oops/resolvedFieldEntry.cpp

@@ -54,3 +54,8 @@ void ResolvedFieldEntry::mark_and_relocate() {
   ArchiveBuilder::current()->mark_and_relocate_to_buffered_addr(&_field_holder);
 }
 #endif
+
+void ResolvedFieldEntry::clear_entry() {
+  _get_code = 0;
+  _put_code = 0;
+}

src/hotspot/share/oops/resolvedFieldEntry.hpp

@@ -157,6 +157,9 @@ public:
   void mark_and_relocate();
 #endif
 
+  // DCEVM
+  void clear_entry();
+
   // Offsets
   static ByteSize field_holder_offset() { return byte_offset_of(ResolvedFieldEntry, _field_holder); }
   static ByteSize field_offset_offset() { return byte_offset_of(ResolvedFieldEntry, _field_offset); }

src/hotspot/share/oops/resolvedIndyEntry.cpp

@@ -66,3 +66,8 @@ void ResolvedIndyEntry::print_on(outputStream* st) const {
   st->print_cr(" - Has Appendix: %d", has_appendix());
   st->print_cr(" - Resolution Failed %d", resolution_failed());
 }
+
+void ResolvedIndyEntry::clear_entry() {
+  _flags |= (1 << is_not_resolved_shift);
+}
+

src/hotspot/share/oops/resolvedIndyEntry.hpp

@@ -71,6 +71,7 @@ public:
   // Note: Only two flags exists at the moment but more could be added
   enum {
       has_appendix_shift        = 1,
+      is_not_resolved_shift     = 2
   };
 
   // Getters
@@ -79,7 +80,7 @@ public:
   u2 constant_pool_index()       const { return _cpool_index;                   }
   u2 num_parameters()            const { return _number_of_parameters;          }
   u1 return_type()               const { return _return_type;                   }
-  bool is_resolved()             const { return method() != nullptr;            }
+  bool is_resolved()             const { return method() != nullptr && !(_flags & (1 << is_not_resolved_shift)); }
   bool has_appendix()            const { return (_flags & (1 << has_appendix_shift)) != 0; }
   bool resolution_failed()       const { return (_flags & 1) != 0; }
   bool is_vfinal()               const { return false; }
@@ -107,7 +108,7 @@ public:
   void fill_in(Method* m, u2 num_params, u1 return_type, bool has_appendix) {
     set_num_parameters(num_params);
     _return_type = return_type;
-    set_flags(has_appendix);
+    set_flags(has_appendix); // DCEVM: this also clears "is_not_resolved_shift" bit
     // Set the method last since it is read lock free.
     // Resolution is indicated by whether or not the method is set.
     Atomic::release_store(&_method, m);
@@ -134,6 +135,9 @@ public:
   void mark_and_relocate();
 #endif
 
+  // DCEVM
+  void clear_entry();
+
   // Offsets
   static ByteSize method_offset()                    { return byte_offset_of(ResolvedIndyEntry, _method);                    }
   static ByteSize resolved_references_index_offset() { return byte_offset_of(ResolvedIndyEntry, _resolved_references_index); }

src/hotspot/share/oops/resolvedMethodEntry.cpp

@@ -108,3 +108,10 @@ void ResolvedMethodEntry::print_on(outputStream* st) const {
   st->print_cr(" - Bytecode 1: %s", Bytecodes::name((Bytecodes::Code)bytecode1()));
   st->print_cr(" - Bytecode 2: %s", Bytecodes::name((Bytecodes::Code)bytecode2()));
 }
+
+void ResolvedMethodEntry::clear_entry() {
+  // Always clear for invokehandle/invokedynamic to re-resolve them
+  set_bytecode1(0);
+  set_bytecode2(0);
+}
+

src/hotspot/share/oops/resolvedMethodEntry.hpp

@@ -254,6 +254,9 @@ class ResolvedMethodEntry {
   void mark_and_relocate(ConstantPool* src_cp);
 #endif
 
+  // DCEVM
+  void clear_entry();
+
   // Offsets
   static ByteSize klass_offset()                     { return byte_offset_of(ResolvedMethodEntry, _entry_specific._interface_klass); }
   static ByteSize method_offset()                    { return byte_offset_of(ResolvedMethodEntry, _method);       }

src/hotspot/share/opto/arraycopynode.hpp

@@ -74,7 +74,7 @@ public:
   }
 
   static void initialize_arraycopy_Type() {
-    assert(_arraycopy_type_Type == nullptr, "should be");
+    assert(AllowEnhancedClassRedefinition || _arraycopy_type_Type == nullptr, "should be");
     const Type** fields = TypeTuple::fields(ParmLimit - TypeFunc::Parms);
     fields[Src]       = TypeInstPtr::BOTTOM;
     fields[SrcPos]    = TypeInt::INT;

src/hotspot/share/opto/c2compiler.cpp

@@ -36,6 +36,7 @@
 #include "runtime/globals_extension.hpp"
 #include "utilities/macros.hpp"
 
+bool C2Compiler::_reinitialize_vm_klasses = false;
 
 // register information defined by ADLC
 extern const char register_save_policy[];