Review feedback

Author: Andrew Haley

src/hotspot/cpu/aarch64/c1_FrameMap_aarch64.hpp

@@ -127,7 +127,6 @@
   static LIR_Opr fpu0_float_opr;
   static LIR_Opr fpu0_double_opr;
 
-  // static LIR_Opr r_profile_rng_opr;
   static LIR_Opr profile_rng_opr;
 
   static LIR_Opr as_long_opr(Register r) {

src/hotspot/cpu/aarch64/c1_LIRAssembler_aarch64.cpp

@@ -2548,10 +2548,6 @@ void LIR_Assembler::emit_load_klass(LIR_OpLoadKlass* op) {
   __ load_klass(result, obj);
 }
 
-#ifndef PRODUCT
-long tier3_overflows;
-#endif
-
 void LIR_Assembler::increment_profile_ctr(LIR_Opr step, LIR_Opr dest_opr, LIR_Opr freq_opr,
                                           LIR_Opr md_reg, LIR_Opr md_opr, LIR_Opr md_offset_opr,
                                           CodeStub* overflow_stub) {
@@ -2616,7 +2612,6 @@ void LIR_Assembler::increment_profile_ctr(LIR_Opr step, LIR_Opr dest_opr, LIR_Op
           break;
         }
         case T_LONG: {
-          inc *= ProfileCaptureRatio;
           __ increment(counter_address, inc, dest);
 
           break;
@@ -2662,14 +2657,6 @@ void LIR_Assembler::increment_profile_ctr(LIR_Opr step, LIR_Opr dest_opr, LIR_Op
               __ mov(rscratch1, step->as_constant_ptr()->as_jint_bits() << ratio_shift);
               __ subsw(zr, dest, rscratch1);
             }
-#ifndef PRODUCT
-            Label nope;
-            __ br(~ __ LO, nope);
-            __ lea(rscratch2, Address((address)&tier3_overflows));
-            __ mov(rscratch1, 1);
-            __ ldadd(Assembler::xword, rscratch1, rscratch1, rscratch2);
-            __ bind(nope);
-#endif
             __ br(__ LO, *overflow_stub->entry());
             break;
         }

src/hotspot/cpu/aarch64/c1_MacroAssembler_aarch64.cpp

@@ -36,6 +36,7 @@
 #include "runtime/sharedRuntime.hpp"
 #include "runtime/stubRoutines.hpp"
 
+// State for randomized profile counters.
 Register r_profile_rng;
 
 void C1_MacroAssembler::float_cmp(bool is_float, int unordered_result,

src/hotspot/cpu/x86/c1_LIRAssembler_x86.cpp

@@ -1293,7 +1293,7 @@ static void increment_mdo(MacroAssembler *C1_masm, Address dst, int32_t src, Reg
   if (ProfileCaptureRatio > 1) {
     assert(!dst.uses(temp), "fix register allocation");
     auto threshold = (UCONST64(1) << 32) >> ratio_shift;
-    __ cmpl(r_profile_rng, threshold);
+    __ cmpl(r_profile_rng, (uint32_t)threshold);
     __ jccb(Assembler::aboveEqual, nope);
   }
   __ addptr(dst, src << ratio_shift);
@@ -2903,9 +2903,9 @@ void LIR_Assembler::increment_profile_ctr(LIR_Opr step_opr, LIR_Opr dest_opr,
           guarantee(dest != step_opr->as_register(), "must be");
           // If step_opr is 0, make sure the stub check below always fails
           __ cmpl(step_opr->as_register(), 0);
-          __ movl(step_opr->as_register(),
+          __ movl(rscratch1,
                   InvocationCounter::count_increment * ProfileCaptureRatio);
-          __ cmovl(Assembler::equal, dest, step_opr->as_register());
+          __ cmovl(Assembler::equal, dest, rscratch1);
         }
 
         // If (dest & mask) < step, we just overflowed.

src/hotspot/share/c1/c1_LIRGenerator.cpp

@@ -3218,8 +3218,9 @@ void LIRGenerator::increment_event_counter_impl(CodeEmitInfo* info,
     counter_holder = new_register(T_METADATA);
     offset = in_bytes(backedge ? MethodData::backedge_counter_offset() :
                                  MethodData::invocation_counter_offset());
-    counters_base = LIR_OprFact::metadataConst
-                     (method->method_data()->constant_encoding());
+    ciMethodData* md = method->method_data_or_null();
+    assert(md != nullptr, "Sanity");
+    counters_base = LIR_OprFact::metadataConst(md->constant_encoding());
   } else {
     ShouldNotReachHere();
   }
@@ -3230,8 +3231,6 @@ void LIRGenerator::increment_event_counter_impl(CodeEmitInfo* info,
     LIR_Opr meth = LIR_OprFact::metadataConst(method->constant_encoding());
     // The bci for info can point to cmp for if's we want the if bci
     CodeStub* overflow = new CounterOverflowStub (info, bci, meth);
-    // Zero the low-order bits of the frequency, otherwise we'll miss
-    // overflows when using randomized profile counters.
     unsigned int freq = (unsigned int)frequency
                          << InvocationCounter::count_shift;
     __ increment_counter(step, result,

src/hotspot/share/compiler/compilationPolicy.cpp

@@ -411,9 +411,6 @@ void CompilationPolicy::print_training_data_on(outputStream* st,  const char* pr
 
 // Print an event.
 void CompilationPolicy::print_event_on(outputStream *st, EventType type, Method* m, Method* im, int bci, CompLevel level) {
-
-  if (level < CompLevel_full_optimization)  return;
-
   bool inlinee_event = m != im;
 
   st->print("%lf: [", os::elapsedTime());
@@ -454,7 +451,7 @@ void CompilationPolicy::print_event_on(outputStream *st, EventType type, Method*
   st->print("[%s", method_name);
   if (inlinee_event) {
     char *inlinee_name = im->name_and_sig_as_C_string();
-    st->print(" [inlinee %s]] ", inlinee_name);
+    st->print(" [%s]] ", inlinee_name);
   }
   else st->print("] ");
   st->print("@%d queues=%d,%d", bci, CompileBroker::queue_size(CompLevel_full_profile),
@@ -502,11 +499,8 @@ void CompilationPolicy::print_event_on(outputStream *st, EventType type, Method*
       print_training_data_on(st, "inlinee ", im, level);
     }
   }
-
-  if (im) {
-    im->method_data()->print_on(st);
-  }
   st->print_cr("]");
+
 }
 
 void CompilationPolicy::print_event(EventType type, Method* m, Method* im, int bci, CompLevel level) {
@@ -1383,7 +1377,7 @@ CompLevel CompilationPolicy::transition_from_limited_profile(const methodHandle&
 // Determine if a method should be compiled with a normal entry point at a different level.
 CompLevel CompilationPolicy::call_event(const methodHandle& method, CompLevel cur_level, JavaThread* THREAD) {
   CompLevel osr_level = MIN2((CompLevel) method->highest_osr_comp_level(), common<LoopPredicate>(method, cur_level, THREAD, true));
-  CompLevel next_level = common<CallPredicate>(method, cur_level, THREAD, is_old(method));
+  CompLevel next_level = common<CallPredicate>(method, cur_level, THREAD, !TrainingData::have_data() && is_old(method));
 
   // If OSR method level is greater than the regular method level, the levels should be
   // equalized by raising the regular method level in order to avoid OSRs during each

src/hotspot/share/utilities/debug.cpp

@@ -373,11 +373,11 @@ extern "C" NOINLINE void disnm(intptr_t p) {
   if (cb != nullptr) {
     nmethod* nm = cb->as_nmethod_or_null();
     if (nm != nullptr) {
-      nm->print_nmethod(true);
+      nm->print();
     } else {
       cb->print();
     }
-    // Disassembler::decode(cb);
+    Disassembler::decode(cb);
   }
 }
 

src/hotspot/share/utilities/vmError.cpp

@@ -1637,8 +1637,6 @@ void VMError::report_and_die(Thread* thread, const void* context, const char* fi
                              const char* detail_fmt, ...) {
   va_list detail_args;
   va_start(detail_args, detail_fmt);
-  fprintf(stderr, "Spinning\n"); fflush(stderr);
-  for(;;);
   report_and_die(thread, context, filename, lineno, message, detail_fmt, detail_args);
   va_end(detail_args);
 }

test/hotspot/jtreg/compiler/tiered/LevelTransitionTest.java

@@ -38,8 +38,20 @@
  *                   -XX:CompileCommand=compileonly,compiler.whitebox.SimpleTestCaseHelper::*
  *                   -XX:CompileCommand=compileonly,compiler.tiered.LevelTransitionTest$ExtendedTestCase$CompileMethodHolder::*
  *                   compiler.tiered.LevelTransitionTest
- *
+ */
+
+/**
+ * @test LevelTransitionTest
+ * @requires vm.compMode != "Xcomp"
  * @requires os.arch=="amd64" | os.arch=="x86_64" | os.arch=="arm" | os.arch=="aarch64"
+ * @summary Test the correctness of compilation level transitions for different methods
+ * @library /test/lib /
+ * @modules java.base/jdk.internal.misc
+ *          java.management
+ *
+ * @build jdk.test.whitebox.WhiteBox
+ *        compiler.tiered.LevelTransitionTest
+ * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
  * @run main/othervm/timeout=240 -Xmixed -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
  *                   -XX:+UnlockExperimentalVMOptions -XX:ProfileCaptureRatio=64
  *                   -XX:+WhiteBoxAPI -XX:+TieredCompilation
@@ -49,6 +61,7 @@
  *                   compiler.tiered.LevelTransitionTest
  */
 
+
 package compiler.tiered;
 
 import compiler.whitebox.CompilerWhiteBoxTest;