Merge branch 'openjdk:master' into patch-13

make/RunTests.gmk

@@ -45,7 +45,7 @@ ifneq ($(TEST_VM_OPTS), )
 endif
 
 $(eval $(call ParseKeywordVariable, TEST_OPTS, \
-    SINGLE_KEYWORDS := JOBS TIMEOUT_FACTOR JCOV JCOV_DIFF_CHANGESET, \
+    SINGLE_KEYWORDS := JOBS TIMEOUT_FACTOR JCOV JCOV_DIFF_CHANGESET AOT_JDK, \
     STRING_KEYWORDS := VM_OPTIONS JAVA_OPTIONS, \
 ))
 
@@ -202,11 +202,12 @@ $(eval $(call SetTestOpt,JOBS,JTREG))
 $(eval $(call SetTestOpt,TIMEOUT_FACTOR,JTREG))
 $(eval $(call SetTestOpt,FAILURE_HANDLER_TIMEOUT,JTREG))
 $(eval $(call SetTestOpt,REPORT,JTREG))
+$(eval $(call SetTestOpt,AOT_JDK,JTREG))
 
 $(eval $(call ParseKeywordVariable, JTREG, \
     SINGLE_KEYWORDS := JOBS TIMEOUT_FACTOR FAILURE_HANDLER_TIMEOUT \
         TEST_MODE ASSERT VERBOSE RETAIN TEST_THREAD_FACTORY MAX_MEM RUN_PROBLEM_LISTS \
-        RETRY_COUNT REPEAT_COUNT MAX_OUTPUT REPORT $(CUSTOM_JTREG_SINGLE_KEYWORDS), \
+        RETRY_COUNT REPEAT_COUNT MAX_OUTPUT REPORT AOT_JDK $(CUSTOM_JTREG_SINGLE_KEYWORDS), \
     STRING_KEYWORDS := OPTIONS JAVA_OPTIONS VM_OPTIONS KEYWORDS \
         EXTRA_PROBLEM_LISTS LAUNCHER_OPTIONS \
         $(CUSTOM_JTREG_STRING_KEYWORDS), \
@@ -702,6 +703,58 @@ define SetJtregValue
   endif
 endef
 
+
+# Parameter 1 is the name of the rule.
+#
+# Remaining parameters are named arguments.
+#   VM_OPTIONS  List of JVM arguments to use when creating AOT cache
+#
+#  After calling this, the following variables are defined
+#   $1_AOT_TARGETS   List of all targets that the test rule will need to depend on
+#   $1_AOT_JDK_CACHE The AOT cache file to be used to run the test with
+#
+SetupAot = $(NamedParamsMacroTemplate)
+define SetupAotBody
+  $1_AOT_JDK_CONF  := $$($1_TEST_SUPPORT_DIR)/aot/jdk.aotconf
+  $1_AOT_JDK_CACHE := $$($1_TEST_SUPPORT_DIR)/aot/jdk.aotcache
+
+  $1_JAVA_TOOL_OPTS := $$(addprefix -J, $$($1_VM_OPTIONS))
+
+  $$($1_AOT_JDK_CACHE): $$(JDK_IMAGE_DIR)/release
+	$$(call MakeDir, $$($1_TEST_SUPPORT_DIR)/aot)
+
+	$(foreach jtool, javac javap jlink jar, \
+	    $(info AOT: Create cache configuration for $(jtool)) \
+	    $$(call ExecuteWithLog, $$($1_TEST_SUPPORT_DIR)/aot.$(jtool), ( \
+	        $$(FIXPATH) $(JDK_UNDER_TEST)/bin/$(jtool) $$($1_JAVA_TOOL_OPTS) \
+	                    -J-XX:AOTMode=record -J-XX:AOTConfiguration=$$($1_AOT_JDK_CONF).$(jtool) --help \
+	    ))
+	)
+
+	$$(info AOT: Copy $(JDK_UNDER_TEST)/lib/classlist to $$($1_AOT_JDK_CONF).jdk )
+	$$(call ExecuteWithLog, $$($1_TEST_SUPPORT_DIR)/aot, ( \
+		$$(FIXPATH) $(CP) $(JDK_UNDER_TEST)/lib/classlist $$($1_AOT_JDK_CONF).jdk \
+	))
+
+	$$(FIXPATH) $$(CAT) $$($1_AOT_JDK_CONF).* > $$($1_AOT_JDK_CONF).temp
+	$$(FIXPATH) $$(CAT) $$($1_AOT_JDK_CONF).temp | $(GREP) -v '#' | $(GREP) -v '@' | $(SORT) | \
+	        $(SED) -e 's/id:.*//g' | uniq \
+		> $$($1_AOT_JDK_CONF)
+	$$(FIXPATH) $$(CAT) $$($1_AOT_JDK_CONF).temp | $(GREP) '@cp' | $(SORT) \
+	        >> $$($1_AOT_JDK_CONF)
+
+	$$(info AOT: Generate AOT cache $$($1_AOT_JDK_CACHE) with flags: $$($1_VM_OPTIONS))
+	$$(call ExecuteWithLog, $$($1_TEST_SUPPORT_DIR)/aot, ( \
+		$$(FIXPATH) $(JDK_UNDER_TEST)/bin/java \
+	        $$($1_VM_OPTIONS) -Xlog:cds,cds+class=debug:file=$$($1_AOT_JDK_CACHE).log \
+		-XX:AOTMode=create -XX:AOTConfiguration=$$($1_AOT_JDK_CONF) -XX:AOTCache=$$($1_AOT_JDK_CACHE) \
+	))
+
+  $1_AOT_TARGETS += $$($1_AOT_JDK_CACHE)
+
+endef
+
+
 SetupRunJtregTest = $(NamedParamsMacroTemplate)
 define SetupRunJtregTestBody
   $1_TEST_RESULTS_DIR := $$(TEST_RESULTS_DIR)/$1
@@ -762,6 +815,7 @@ define SetupRunJtregTestBody
   JTREG_RETRY_COUNT ?= 0
   JTREG_REPEAT_COUNT ?= 0
   JTREG_REPORT ?= files
+  JTREG_AOT_JDK ?= false
 
   ifneq ($$(JTREG_RETRY_COUNT), 0)
     ifneq ($$(JTREG_REPEAT_COUNT), 0)
@@ -891,6 +945,17 @@ define SetupRunJtregTestBody
     endif
   endif
 
+  ifeq ($$(JTREG_AOT_JDK), true)
+    $$(info Add AOT target for $1)
+    $$(eval $$(call SetupAot, $1, VM_OPTIONS := $$(JTREG_ALL_OPTIONS) ))
+
+    $$(info AOT_TARGETS=$$($1_AOT_TARGETS))
+    $$(info AOT_JDK_CACHE=$$($1_AOT_JDK_CACHE))
+
+    $1_JTREG_BASIC_OPTIONS += -vmoption:-XX:AOTCache="$$($1_AOT_JDK_CACHE)"
+  endif
+
+
   $$(eval $$(call SetupRunJtregTestCustom, $1))
 
   # SetupRunJtregTestCustom might also adjust JTREG_AUTO_ variables
@@ -906,6 +971,7 @@ define SetupRunJtregTestBody
   JTREG_TIMEOUT_FACTOR ?= $$(JTREG_AUTO_TIMEOUT_FACTOR)
 
   clean-outputdirs-$1:
+	$$(call LogWarn, Clean up dirs for $1)
 	$$(RM) -r $$($1_TEST_SUPPORT_DIR)
 	$$(RM) -r $$($1_TEST_RESULTS_DIR)
 
@@ -953,7 +1019,7 @@ define SetupRunJtregTestBody
         done
   endif
 
-  run-test-$1: pre-run-test clean-outputdirs-$1
+  run-test-$1: clean-outputdirs-$1 pre-run-test $$($1_AOT_TARGETS)
 	$$(call LogWarn)
 	$$(call LogWarn, Running test '$$($1_TEST)')
 	$$(call MakeDir, $$($1_TEST_RESULTS_DIR) $$($1_TEST_SUPPORT_DIR) \

src/hotspot/cpu/aarch64/aarch64.ad

@@ -5755,10 +5755,6 @@ opclass memory(indirect, indIndexScaled, indIndexScaledI2L, indIndexI2L, indInde
                indirectN, indIndexScaledN, indIndexScaledI2LN, indIndexI2LN, indIndexN, indOffIN, indOffLN, indirectX2P, indOffX2P);
 
 
-opclass memory_noindex(indirect,
-                       indOffI1, indOffL1,indOffI2, indOffL2, indOffI4, indOffL4, indOffI8, indOffL8,
-                       indirectN, indOffIN, indOffLN, indirectX2P, indOffX2P);
-
 // iRegIorL2I is used for src inputs in rules for 32 bit int (I)
 // operations. it allows the src to be either an iRegI or a (ConvL2I
 // iRegL). in the latter case the l2i normally planted for a ConvL2I
@@ -6695,16 +6691,21 @@ instruct loadNKlass(iRegNNoSp dst, memory4 mem)
   ins_pipe(iload_reg_mem);
 %}
 
-instruct loadNKlassCompactHeaders(iRegNNoSp dst, memory_noindex mem)
+instruct loadNKlassCompactHeaders(iRegNNoSp dst, memory4 mem)
 %{
   match(Set dst (LoadNKlass mem));
   predicate(!needs_acquiring_load(n) && UseCompactObjectHeaders);
 
   ins_cost(4 * INSN_COST);
-  format %{ "load_narrow_klass_compact  $dst, $mem\t# compressed class ptr" %}
+  format %{
+    "ldrw  $dst, $mem\t# compressed class ptr, shifted\n\t"
+    "lsrw  $dst, $dst, markWord::klass_shift_at_offset"
+  %}
   ins_encode %{
-    assert($mem$$index$$Register == noreg, "must not have indexed address");
-    __ load_narrow_klass_compact_c2($dst$$Register, $mem$$base$$Register, $mem$$disp);
+    // inlined aarch64_enc_ldrw
+    loadStore(masm, &MacroAssembler::ldrw, $dst$$Register, $mem->opcode(),
+              as_Register($mem$$base), $mem$$index, $mem$$scale, $mem$$disp, 4);
+    __ lsrw($dst$$Register, $dst$$Register, markWord::klass_shift_at_offset);
   %}
   ins_pipe(iload_reg_mem);
 %}

src/hotspot/cpu/aarch64/c2_MacroAssembler_aarch64.cpp

@@ -2690,12 +2690,3 @@ bool C2_MacroAssembler::in_scratch_emit_size() {
   }
   return MacroAssembler::in_scratch_emit_size();
 }
-
-void C2_MacroAssembler::load_narrow_klass_compact_c2(Register dst, Register obj, int disp) {
-  // Note: Don't clobber obj anywhere in that method!
-
-  // The incoming address is pointing into obj-start + klass_offset_in_bytes. We need to extract
-  // obj-start, so that we can load from the object's mark-word instead.
-  ldr(dst, Address(obj, disp - oopDesc::klass_offset_in_bytes()));
-  lsr(dst, dst, markWord::klass_shift);
-}

src/hotspot/cpu/aarch64/c2_MacroAssembler_aarch64.hpp

@@ -186,6 +186,4 @@
   void vector_signum_sve(FloatRegister dst, FloatRegister src, FloatRegister zero,
                          FloatRegister one, FloatRegister vtmp, PRegister pgtmp, SIMD_RegVariant T);
 
-  void load_narrow_klass_compact_c2(Register dst, Register obj, int disp);
-
 #endif // CPU_AARCH64_C2_MACROASSEMBLER_AARCH64_HPP

src/hotspot/cpu/riscv/stubRoutines_riscv.cpp

@@ -34,16 +34,6 @@
 // Implementation of the platform-specific part of StubRoutines - for
 // a description of how to extend it, see the stubRoutines.hpp file.
 
-address StubRoutines::riscv::_get_previous_sp_entry = nullptr;
-
-address StubRoutines::riscv::_f2i_fixup = nullptr;
-address StubRoutines::riscv::_f2l_fixup = nullptr;
-address StubRoutines::riscv::_d2i_fixup = nullptr;
-address StubRoutines::riscv::_d2l_fixup = nullptr;
-address StubRoutines::riscv::_float_sign_mask = nullptr;
-address StubRoutines::riscv::_float_sign_flip = nullptr;
-address StubRoutines::riscv::_double_sign_mask = nullptr;
-address StubRoutines::riscv::_double_sign_flip = nullptr;
 address StubRoutines::riscv::_zero_blocks = nullptr;
 address StubRoutines::riscv::_compare_long_string_LL = nullptr;
 address StubRoutines::riscv::_compare_long_string_UU = nullptr;
@@ -52,7 +42,6 @@ address StubRoutines::riscv::_compare_long_string_UL = nullptr;
 address StubRoutines::riscv::_string_indexof_linear_ll = nullptr;
 address StubRoutines::riscv::_string_indexof_linear_uu = nullptr;
 address StubRoutines::riscv::_string_indexof_linear_ul = nullptr;
-address StubRoutines::riscv::_large_byte_array_inflate = nullptr;
 
 bool StubRoutines::riscv::_completed = false;
 

src/hotspot/cpu/riscv/stubRoutines_riscv.hpp

@@ -47,18 +47,6 @@ class riscv {
  friend class StubGenerator;
 
  private:
-  static address _get_previous_sp_entry;
-
-  static address _f2i_fixup;
-  static address _f2l_fixup;
-  static address _d2i_fixup;
-  static address _d2l_fixup;
-
-  static address _float_sign_mask;
-  static address _float_sign_flip;
-  static address _double_sign_mask;
-  static address _double_sign_flip;
-
   static address _zero_blocks;
 
   static address _compare_long_string_LL;
@@ -68,48 +56,11 @@ class riscv {
   static address _string_indexof_linear_ll;
   static address _string_indexof_linear_uu;
   static address _string_indexof_linear_ul;
-  static address _large_byte_array_inflate;
 
   static bool _completed;
 
  public:
 
-  static address get_previous_sp_entry() {
-    return _get_previous_sp_entry;
-  }
-
-  static address f2i_fixup() {
-    return _f2i_fixup;
-  }
-
-  static address f2l_fixup() {
-    return _f2l_fixup;
-  }
-
-  static address d2i_fixup() {
-    return _d2i_fixup;
-  }
-
-  static address d2l_fixup() {
-    return _d2l_fixup;
-  }
-
-  static address float_sign_mask() {
-    return _float_sign_mask;
-  }
-
-  static address float_sign_flip() {
-    return _float_sign_flip;
-  }
-
-  static address double_sign_mask() {
-    return _double_sign_mask;
-  }
-
-  static address double_sign_flip() {
-    return _double_sign_flip;
-  }
-
   static address zero_blocks() {
     return _zero_blocks;
   }
@@ -142,10 +93,6 @@ class riscv {
     return _string_indexof_linear_uu;
   }
 
-  static address large_byte_array_inflate() {
-    return _large_byte_array_inflate;
-  }
-
   static bool complete() {
     return _completed;
   }

src/hotspot/cpu/x86/c2_MacroAssembler_x86.cpp

@@ -7073,13 +7073,3 @@ void C2_MacroAssembler::vector_saturating_op(int ideal_opc, BasicType elem_bt, X
     vector_saturating_op(ideal_opc, elem_bt, dst, src1, src2, vlen_enc);
   }
 }
-
-#ifdef _LP64
-void C2_MacroAssembler::load_narrow_klass_compact_c2(Register dst, Address src) {
-  // The incoming address is pointing into obj-start + klass_offset_in_bytes. We need to extract
-  // obj-start, so that we can load from the object's mark-word instead. Usually the address
-  // comes as obj-start in obj and klass_offset_in_bytes in disp.
-  movq(dst, src.plus_disp(-oopDesc::klass_offset_in_bytes()));
-  shrq(dst, markWord::klass_shift);
-}
-#endif

src/hotspot/cpu/x86/c2_MacroAssembler_x86.hpp

@@ -583,8 +583,4 @@
 
   void select_from_two_vectors_evex(BasicType elem_bt, XMMRegister dst, XMMRegister src1, XMMRegister src2, int vlen_enc);
 
-#ifdef _LP64
-  void load_narrow_klass_compact_c2(Register dst, Address src);
-#endif
-
 #endif // CPU_X86_C2_MACROASSEMBLER_X86_HPP

src/hotspot/cpu/x86/x86_64.ad

@@ -4368,11 +4368,15 @@ instruct loadNKlassCompactHeaders(rRegN dst, memory mem, rFlagsReg cr)
   match(Set dst (LoadNKlass mem));
   effect(KILL cr);
   ins_cost(125); // XXX
-  format %{ "load_narrow_klass_compact    $dst, $mem\t# compressed klass ptr" %}
+  format %{
+    "movl    $dst, $mem\t# compressed klass ptr, shifted\n\t"
+    "shrl    $dst, markWord::klass_shift_at_offset"
+  %}
   ins_encode %{
-    __ load_narrow_klass_compact_c2($dst$$Register, $mem$$Address);
+    __ movl($dst$$Register, $mem$$Address);
+    __ shrl($dst$$Register, markWord::klass_shift_at_offset);
   %}
-  ins_pipe(pipe_slow); // XXX
+  ins_pipe(ialu_reg_mem); // XXX
 %}
 
 // Load Float