Automatic merge of jdk:master into master

duke · duke · commit 6b2ef4204149 · 2020-07-03T09:51:49.000Z
diff --git a/src/hotspot/share/c1/c1_Compilation.cpp b/src/hotspot/share/c1/c1_Compilation.cpp
@@ -463,7 +463,7 @@ void Compilation::compile_method() {
   // Note: make sure we mark the method as not compilable!
   CHECK_BAILOUT();
 
-  if (InstallMethods) {
+  if (should_install_code()) {
     // install code
     PhaseTraceTime timeit(_t_codeinstall);
     install_code(frame_size);
@@ -539,7 +539,7 @@ void Compilation::generate_exception_handler_table() {
 }
 
 Compilation::Compilation(AbstractCompiler* compiler, ciEnv* env, ciMethod* method,
-                         int osr_bci, BufferBlob* buffer_blob, DirectiveSet* directive)
+                         int osr_bci, BufferBlob* buffer_blob, bool install_code, DirectiveSet* directive)
 : _next_id(0)
 , _next_block_id(0)
 , _compiler(compiler)
@@ -558,6 +558,7 @@ Compilation::Compilation(AbstractCompiler* compiler, ciEnv* env, ciMethod* metho
 , _would_profile(false)
 , _has_method_handle_invokes(false)
 , _has_reserved_stack_access(method->has_reserved_stack_access())
+, _install_code(install_code)
 , _bailout_msg(NULL)
 , _exception_info_list(NULL)
 , _allocator(NULL)
diff --git a/src/hotspot/share/c1/c1_Compilation.hpp b/src/hotspot/share/c1/c1_Compilation.hpp
@@ -81,6 +81,7 @@ class Compilation: public StackObj {
   bool               _would_profile;
   bool               _has_method_handle_invokes;  // True if this method has MethodHandle invokes.
   bool               _has_reserved_stack_access;
+  bool               _install_code;
   const char*        _bailout_msg;
   ExceptionInfoList* _exception_info_list;
   ExceptionHandlerTable _exception_handler_table;
@@ -120,7 +121,7 @@ class Compilation: public StackObj {
  public:
   // creation
   Compilation(AbstractCompiler* compiler, ciEnv* env, ciMethod* method,
-              int osr_bci, BufferBlob* buffer_blob, DirectiveSet* directive);
+              int osr_bci, BufferBlob* buffer_blob, bool install_code, DirectiveSet* directive);
   ~Compilation();
 
 
@@ -148,6 +149,7 @@ class Compilation: public StackObj {
   CodeOffsets* offsets()                         { return &_offsets; }
   Arena* arena()                                 { return _arena; }
   bool has_access_indexed()                      { return _has_access_indexed; }
+  bool should_install_code()                     { return _install_code && InstallMethods; }
 
   // Instruction ids
   int get_next_id()                              { return _next_id++; }
diff --git a/src/hotspot/share/c1/c1_Compiler.cpp b/src/hotspot/share/c1/c1_Compiler.cpp
@@ -235,7 +235,7 @@ bool Compiler::is_intrinsic_supported(const methodHandle& method) {
   return true;
 }
 
-void Compiler::compile_method(ciEnv* env, ciMethod* method, int entry_bci, DirectiveSet* directive) {
+void Compiler::compile_method(ciEnv* env, ciMethod* method, int entry_bci, bool install_code, DirectiveSet* directive) {
   BufferBlob* buffer_blob = CompilerThread::current()->get_buffer_blob();
   assert(buffer_blob != NULL, "Must exist");
   // invoke compilation
@@ -244,7 +244,7 @@ void Compiler::compile_method(ciEnv* env, ciMethod* method, int entry_bci, Direc
     // of Compilation to occur before we release the any
     // competing compiler thread
     ResourceMark rm;
-    Compilation c(this, env, method, entry_bci, buffer_blob, directive);
+    Compilation c(this, env, method, entry_bci, buffer_blob, install_code, directive);
   }
 }
 
diff --git a/src/hotspot/share/c1/c1_Compiler.hpp b/src/hotspot/share/c1/c1_Compiler.hpp
@@ -51,7 +51,7 @@ class Compiler: public AbstractCompiler {
   virtual void initialize();
 
   // Compilation entry point for methods
-  virtual void compile_method(ciEnv* env, ciMethod* target, int entry_bci, DirectiveSet* directive);
+  virtual void compile_method(ciEnv* env, ciMethod* target, int entry_bci, bool install_code, DirectiveSet* directive);
 
   // Print compilation timers and statistics
   virtual void print_timers();
diff --git a/src/hotspot/share/compiler/abstractCompiler.hpp b/src/hotspot/share/compiler/abstractCompiler.hpp
@@ -166,7 +166,7 @@ class AbstractCompiler : public CHeapObj<mtCompiler> {
   void set_state     (int state);
   void set_shut_down ()           { set_state(shut_down); }
   // Compilation entry point for methods
-  virtual void compile_method(ciEnv* env, ciMethod* target, int entry_bci, DirectiveSet* directive) {
+  virtual void compile_method(ciEnv* env, ciMethod* target, int entry_bci, bool install_code, DirectiveSet* directive) {
     ShouldNotReachHere();
   }
 
diff --git a/src/hotspot/share/compiler/compileBroker.cpp b/src/hotspot/share/compiler/compileBroker.cpp
@@ -2223,7 +2223,15 @@ void CompileBroker::invoke_compiler_on_method(CompileTask* task) {
           locker.wait();
         }
       }
-      comp->compile_method(&ci_env, target, osr_bci, directive);
+      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) {
+        task->print_ul("NO CODE INSTALLED");
+        comp->compile_method(&ci_env, target, osr_bci, false , directive);
+        repeat_compilation_count--;
+      }
     }
 
     if (!ci_env.failing() && task->code() == NULL) {
diff --git a/src/hotspot/share/compiler/compilerDirectives.hpp b/src/hotspot/share/compiler/compilerDirectives.hpp
@@ -48,7 +48,8 @@
     cflags(DumpInline,              bool, false, DumpInline) \
     cflags(CompilerDirectivesIgnoreCompileCommands, bool, CompilerDirectivesIgnoreCompileCommands, X) \
     cflags(DisableIntrinsic,        ccstrlist, DisableIntrinsic, DisableIntrinsic) \
-    cflags(ControlIntrinsic,        ccstrlist, ControlIntrinsic, ControlIntrinsic)
+    cflags(ControlIntrinsic,        ccstrlist, ControlIntrinsic, ControlIntrinsic) \
+    cflags(RepeatCompilation,       intx, RepeatCompilation, RepeatCompilation)
 
 #ifdef COMPILER1
   #define compilerdirectives_c1_flags(cflags)
@@ -64,11 +65,11 @@
 NOT_PRODUCT(cflags(TraceOptoPipelining, bool, TraceOptoPipelining, TraceOptoPipelining)) \
 NOT_PRODUCT(cflags(TraceOptoOutput,     bool, TraceOptoOutput, TraceOptoOutput)) \
 NOT_PRODUCT(cflags(PrintIdeal,          bool, PrintIdeal, PrintIdeal)) \
-NOT_PRODUCT(cflags(IGVPrintLevel,       intx, PrintIdealGraphLevel, IGVPrintLevel)) \
     cflags(TraceSpilling,           bool, TraceSpilling, TraceSpilling) \
     cflags(Vectorize,               bool, false, Vectorize) \
-    cflags(VectorizeDebug,          uintx, 0, VectorizeDebug) \
     cflags(CloneMapDebug,           bool, false, CloneMapDebug) \
+NOT_PRODUCT(cflags(IGVPrintLevel,       intx, PrintIdealGraphLevel, IGVPrintLevel)) \
+    cflags(VectorizeDebug,          uintx, 0, VectorizeDebug) \
     cflags(MaxNodeLimit,            intx, MaxNodeLimit, MaxNodeLimit)
 #else
   #define compilerdirectives_c2_flags(cflags)
diff --git a/src/hotspot/share/jvmci/jvmciCompiler.cpp b/src/hotspot/share/jvmci/jvmciCompiler.cpp
@@ -135,7 +135,7 @@ bool JVMCICompiler::force_comp_at_level_simple(const methodHandle& method) {
 }
 
 // Compilation entry point for methods
-void JVMCICompiler::compile_method(ciEnv* env, ciMethod* target, int entry_bci, DirectiveSet* directive) {
+void JVMCICompiler::compile_method(ciEnv* env, ciMethod* target, int entry_bci, bool install_code, DirectiveSet* directive) {
   ShouldNotReachHere();
 }
 
diff --git a/src/hotspot/share/jvmci/jvmciCompiler.hpp b/src/hotspot/share/jvmci/jvmciCompiler.hpp
@@ -94,7 +94,7 @@ class JVMCICompiler : public AbstractCompiler {
   }
 
   // Compilation entry point for methods
-  virtual void compile_method(ciEnv* env, ciMethod* target, int entry_bci, DirectiveSet* directive);
+  virtual void compile_method(ciEnv* env, ciMethod* target, int entry_bci, bool install_code, DirectiveSet* directive);
 
   // Print compilation timers and statistics
   virtual void print_timers();
diff --git a/src/hotspot/share/opto/c2compiler.cpp b/src/hotspot/share/opto/c2compiler.cpp
@@ -99,7 +99,7 @@ void C2Compiler::initialize() {
   }
 }
 
-void C2Compiler::compile_method(ciEnv* env, ciMethod* target, int entry_bci, DirectiveSet* directive) {
+void C2Compiler::compile_method(ciEnv* env, ciMethod* target, int entry_bci, bool install_code, DirectiveSet* directive) {
   assert(is_initialized(), "Compiler thread must be initialized");
 
   bool subsume_loads = SubsumeLoads;
@@ -109,7 +109,7 @@ void C2Compiler::compile_method(ciEnv* env, ciMethod* target, int entry_bci, Dir
 
   while (!env->failing()) {
     // Attempt to compile while subsuming loads into machine instructions.
-    Compile C(env, target, entry_bci, subsume_loads, do_escape_analysis, eliminate_boxing, directive);
+    Compile C(env, target, entry_bci, subsume_loads, do_escape_analysis, eliminate_boxing, install_code, directive);
 
     // Check result and retry if appropriate.
     if (C.failure_reason() != NULL) {
@@ -151,7 +151,6 @@ void C2Compiler::compile_method(ciEnv* env, ciMethod* target, int entry_bci, Dir
         continue;  // retry
       }
     }
-
     // print inlining for last compilation only
     C.dump_print_inlining();
 
diff --git a/src/hotspot/share/opto/c2compiler.hpp b/src/hotspot/share/opto/c2compiler.hpp
@@ -43,6 +43,7 @@ class C2Compiler : public AbstractCompiler {
   void compile_method(ciEnv* env,
                       ciMethod* target,
                       int entry_bci,
+                      bool install_code,
                       DirectiveSet* directive);
 
   // sentinel value used to trigger backtracking in compile_method().
diff --git a/src/hotspot/share/opto/compile.cpp b/src/hotspot/share/opto/compile.cpp
@@ -499,12 +499,13 @@ debug_only( int Compile::_debug_idx = 100000; )
 
 
 Compile::Compile( ciEnv* ci_env, ciMethod* target, int osr_bci,
-                  bool subsume_loads, bool do_escape_analysis, bool eliminate_boxing, DirectiveSet* directive)
+                  bool subsume_loads, bool do_escape_analysis, bool eliminate_boxing, bool install_code, DirectiveSet* directive)
                 : Phase(Compiler),
                   _compile_id(ci_env->compile_id()),
                   _save_argument_registers(false),
                   _subsume_loads(subsume_loads),
                   _do_escape_analysis(do_escape_analysis),
+                  _install_code(install_code),
                   _eliminate_boxing(eliminate_boxing),
                   _method(target),
                   _entry_bci(osr_bci),
@@ -791,6 +792,7 @@ Compile::Compile( ciEnv* ci_env,
     _save_argument_registers(save_arg_registers),
     _subsume_loads(true),
     _do_escape_analysis(false),
+    _install_code(true),
     _eliminate_boxing(false),
     _method(NULL),
     _entry_bci(InvocationEntryBci),
diff --git a/src/hotspot/share/opto/compile.hpp b/src/hotspot/share/opto/compile.hpp
@@ -246,6 +246,7 @@ class Compile : public Phase {
   const bool            _save_argument_registers; // save/restore arg regs for trampolines
   const bool            _subsume_loads;         // Load can be matched as part of a larger op.
   const bool            _do_escape_analysis;    // Do escape analysis.
+  const bool            _install_code;          // Install the code that was compiled
   const bool            _eliminate_boxing;      // Do boxing elimination.
   ciMethod*             _method;                // The method being compiled.
   int                   _entry_bci;             // entry bci for osr methods.
@@ -507,7 +508,7 @@ class Compile : public Phase {
   /** Do aggressive boxing elimination. */
   bool              aggressive_unboxing() const { return _eliminate_boxing && AggressiveUnboxing; }
   bool              save_argument_registers() const { return _save_argument_registers; }
-
+  bool              should_install_code() const { return _install_code; }
 
   // Other fixed compilation parameters.
   ciMethod*         method() const              { return _method; }
@@ -1008,7 +1009,7 @@ class Compile : public Phase {
   // continuation.
   Compile(ciEnv* ci_env, ciMethod* target,
           int entry_bci, bool subsume_loads, bool do_escape_analysis,
-          bool eliminate_boxing, DirectiveSet* directive);
+          bool eliminate_boxing, bool install_code, DirectiveSet* directive);
 
   // Second major entry point.  From the TypeFunc signature, generate code
   // to pass arguments from the Java calling convention to the C calling
diff --git a/src/hotspot/share/opto/output.cpp b/src/hotspot/share/opto/output.cpp
@@ -3260,7 +3260,9 @@ uint PhaseOutput::scratch_emit_size(const Node* n) {
 }
 
 void PhaseOutput::install() {
-  if (C->stub_function() != NULL) {
+  if (!C->should_install_code()) {
+    return;
+  } else if (C->stub_function() != NULL) {
     install_stub(C->stub_name(),
                  C->save_argument_registers());
   } else {
diff --git a/src/hotspot/share/runtime/globals.hpp b/src/hotspot/share/runtime/globals.hpp
@@ -538,6 +538,10 @@ const size_t minimumSymbolTableSize = 1024;
   product(bool, PrintCompilation, false,                                    \
           "Print compilations")                                             \
                                                                             \
+  diagnostic(intx, RepeatCompilation, 0,                                    \
+          "Repeat compilation without installing code (number of times)")   \
+          range(0, max_jint)                                                 \
+                                                                            \
   product(bool, PrintExtendedThreadInfo, false,                             \
           "Print more information in thread dump")                          \
                                                                             \

Original file line number	Diff line number	Diff line change
`@@ -235,7 +235,7 @@ bool Compiler::is_intrinsic_supported(const methodHandle& method) {`
`235`	`235`	`return true;`
`236`	`236`	`}`
`237`	`237`
`238`		`-void Compiler::compile_method(ciEnv* env, ciMethod* method, int entry_bci, DirectiveSet* directive) {`
	`238`	`+void Compiler::compile_method(ciEnv* env, ciMethod* method, int entry_bci, bool install_code, DirectiveSet* directive) {`
`239`	`239`	`BufferBlob* buffer_blob = CompilerThread::current()->get_buffer_blob();`
`240`	`240`	`assert(buffer_blob != NULL, "Must exist");`
`241`	`241`	`// invoke compilation`
`@@ -244,7 +244,7 @@ void Compiler::compile_method(ciEnv* env, ciMethod* method, int entry_bci, Direc`
`244`	`244`	`// of Compilation to occur before we release the any`
`245`	`245`	`// competing compiler thread`
`246`	`246`	`ResourceMark rm;`
`247`		`- Compilation c(this, env, method, entry_bci, buffer_blob, directive);`
	`247`	`+ Compilation c(this, env, method, entry_bci, buffer_blob, install_code, directive);`
`248`	`248`	`}`
`249`	`249`	`}`
`250`	`250`
Original file line number	Diff line number	Diff line change
`@@ -166,7 +166,7 @@ class AbstractCompiler : public CHeapObj<mtCompiler> {`
`166`	`166`	`void set_state (int state);`
`167`	`167`	`void set_shut_down () { set_state(shut_down); }`
`168`	`168`	`// Compilation entry point for methods`
`169`		`- virtual void compile_method(ciEnv* env, ciMethod* target, int entry_bci, DirectiveSet* directive) {`
	`169`	`+ virtual void compile_method(ciEnv* env, ciMethod* target, int entry_bci, bool install_code, DirectiveSet* directive) {`
`170`	`170`	`ShouldNotReachHere();`
`171`	`171`	`}`
`172`	`172`
Original file line number	Diff line number	Diff line change
`@@ -2223,7 +2223,15 @@ void CompileBroker::invoke_compiler_on_method(CompileTask* task) {`
`2223`	`2223`	`locker.wait();`
`2224`	`2224`	`}`
`2225`	`2225`	`}`
`2226`		`- comp->compile_method(&ci_env, target, osr_bci, directive);`
	`2226`	`+ comp->compile_method(&ci_env, target, osr_bci, true, directive);`
	`2227`	`+`
	`2228`	`+ /* Repeat compilation without installing code for profiling purposes */`
	`2229`	`+ int repeat_compilation_count = directive->RepeatCompilationOption;`
	`2230`	`+ while (repeat_compilation_count > 0) {`
	`2231`	`+ task->print_ul("NO CODE INSTALLED");`
	`2232`	`+ comp->compile_method(&ci_env, target, osr_bci, false , directive);`
	`2233`	`+ repeat_compilation_count--;`
	`2234`	`+ }`
`2227`	`2235`	`}`
`2228`	`2236`
`2229`	`2237`	`if (!ci_env.failing() && task->code() == NULL) {`
Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ bool JVMCICompiler::force_comp_at_level_simple(const methodHandle& method) {`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`// Compilation entry point for methods`
`138`		`-void JVMCICompiler::compile_method(ciEnv* env, ciMethod* target, int entry_bci, DirectiveSet* directive) {`
	`138`	`+void JVMCICompiler::compile_method(ciEnv* env, ciMethod* target, int entry_bci, bool install_code, DirectiveSet* directive) {`
`139`	`139`	`ShouldNotReachHere();`
`140`	`140`	`}`
`141`	`141`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ class JVMCICompiler : public AbstractCompiler {`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`// Compilation entry point for methods`
`97`		`- virtual void compile_method(ciEnv* env, ciMethod* target, int entry_bci, DirectiveSet* directive);`
	`97`	`+ virtual void compile_method(ciEnv* env, ciMethod* target, int entry_bci, bool install_code, DirectiveSet* directive);`
`98`	`98`
`99`	`99`	`// Print compilation timers and statistics`
`100`	`100`	`virtual void print_timers();`
Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ void C2Compiler::initialize() {`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`102`		`-void C2Compiler::compile_method(ciEnv* env, ciMethod* target, int entry_bci, DirectiveSet* directive) {`
	`102`	`+void C2Compiler::compile_method(ciEnv* env, ciMethod* target, int entry_bci, bool install_code, DirectiveSet* directive) {`
`103`	`103`	`assert(is_initialized(), "Compiler thread must be initialized");`
`104`	`104`
`105`	`105`	`bool subsume_loads = SubsumeLoads;`
`@@ -109,7 +109,7 @@ void C2Compiler::compile_method(ciEnv* env, ciMethod* target, int entry_bci, Dir`
`109`	`109`
`110`	`110`	`while (!env->failing()) {`
`111`	`111`	`// Attempt to compile while subsuming loads into machine instructions.`
`112`		`- Compile C(env, target, entry_bci, subsume_loads, do_escape_analysis, eliminate_boxing, directive);`
	`112`	`+ Compile C(env, target, entry_bci, subsume_loads, do_escape_analysis, eliminate_boxing, install_code, directive);`
`113`	`113`
`114`	`114`	`// Check result and retry if appropriate.`
`115`	`115`	`if (C.failure_reason() != NULL) {`
`@@ -151,7 +151,6 @@ void C2Compiler::compile_method(ciEnv* env, ciMethod* target, int entry_bci, Dir`
`151`	`151`	`continue; // retry`
`152`	`152`	`}`
`153`	`153`	`}`
`154`		`-`
`155`	`154`	`// print inlining for last compilation only`
`156`	`155`	`C.dump_print_inlining();`
`157`	`156`
Original file line number	Diff line number	Diff line change
`@@ -538,6 +538,10 @@ const size_t minimumSymbolTableSize = 1024;`
`538`	`538`	`product(bool, PrintCompilation, false, \`
`539`	`539`	`"Print compilations") \`
`540`	`540`	`\`
	`541`	`+ diagnostic(intx, RepeatCompilation, 0, \`
	`542`	`+ "Repeat compilation without installing code (number of times)") \`
	`543`	`+ range(0, max_jint) \`
	`544`	`+ \`
`541`	`545`	`product(bool, PrintExtendedThreadInfo, false, \`
`542`	`546`	`"Print more information in thread dump") \`
`543`	`547`	`\`