jdk-sandbox: comparison src/hotspot/share/opto/compile.cpp

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 #include "runtime/stubRoutines.hpp"
 #include "runtime/timer.hpp"
 #include "utilities/align.hpp"
 #include "utilities/copy.hpp"
 #include "utilities/macros.hpp"
-#if INCLUDE_ZGC
-#include "gc/z/c2/zBarrierSetC2.hpp"
-#endif
 // -------------------- Compile::mach_constant_base_node -----------------------
 // Constant table base node singleton.
 MachConstantBaseNode* Compile::mach_constant_base_node() {
 assert(compile == Compile::current(), "sanity");
 compile->set_type_dict(NULL);
 compile->set_clone_map(new Dict(cmpkey, hashkey, _compile->comp_arena()));
 compile->clone_map().set_clone_idx(0);
-compile->set_type_hwm(NULL);
 compile->set_type_last_size(0);
 compile->set_last_tf(NULL, NULL);
 compile->set_indexSet_arena(NULL);
 compile->set_indexSet_free_block_list(NULL);
 compile->init_type_arena();
 _has_reserved_stack_access(target->has_reserved_stack_access()),
 #ifndef PRODUCT
 _trace_opto_output(directive->TraceOptoOutputOption),
 #endif
 _has_method_handle_invokes(false),
+_clinit_barrier_on_entry(false),
 _comp_arena(mtCompiler),
 _barrier_set_state(BarrierSet::barrier_set()->barrier_set_c2()->create_barrier_state(comp_arena())),
 _env(ci_env),
 _directive(directive),
 _log(ci_env->log()),
 _has_reserved_stack_access(false),
 #ifndef PRODUCT
 _trace_opto_output(directive->TraceOptoOutputOption),
 #endif
 _has_method_handle_invokes(false),
+_clinit_barrier_on_entry(false),
 _comp_arena(mtCompiler),
+_barrier_set_state(BarrierSet::barrier_set()->barrier_set_c2()->create_barrier_state(comp_arena())),
 _env(ci_env),
 _directive(directive),
 _log(ci_env->log()),
 _failure_reason(NULL),
 _congraph(NULL),
 // code if UseRTMDeopt is on.
 set_rtm_state(ProfileRTM);
 }
 }
 #endif
+if (VM_Version::supports_fast_class_init_checks() && has_method() && !is_osr_compilation() && method()->needs_clinit_barrier()) {
+set_clinit_barrier_on_entry(true);
+}
 if (debug_info()->recording_non_safepoints()) {
 set_node_note_array(new(comp_arena()) GrowableArray<Node_Notes*>
 (comp_arena(), 8, 0, NULL));
 set_default_node_notes(Node_Notes::make(this));
 }
 BREAKPOINT;
 }
 #endif
+BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
 #ifdef ASSERT
-BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
 bs->verify_gc_barriers(this, BarrierSetC2::BeforeOptimize);
 #endif
 ResourceMark rm;
 {
 TracePhase tp("iterGVN2", &timers[_t_iterGVN2]);
 igvn = ccp;
 igvn.optimize();
 }
 print_method(PHASE_ITER_GVN2, 2);
 if (failing())  return;
 // Loop transforms on the ideal graph.  Range Check Elimination,
 // peeling, unrolling, etc.
 if (!optimize_loops(igvn, LoopOptsDefault)) {
 return;
 }
-#if INCLUDE_ZGC
-if (UseZGC) {
-ZBarrierSetC2::find_dominating_barriers(igvn);
-}
-#endif
 if (failing())  return;
 // Ensure that major progress is now clear
 C->clear_major_progress();
 C->remove_range_check_casts(igvn);
 igvn.optimize();
 }
 #ifdef ASSERT
-BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
+bs->verify_gc_barriers(this, BarrierSetC2::BeforeMacroExpand);
-bs->verify_gc_barriers(this, BarrierSetC2::BeforeExpand);
 #endif
 {
 TracePhase tp("macroExpand", &timers[_t_macroExpand]);
 PhaseMacroExpand  mex(igvn);
-print_method(PHASE_BEFORE_MACRO_EXPANSION, 2);
 if (mex.expand_macro_nodes()) {
 assert(failing(), "must bail out w/ explicit message");
 return;
 }
+print_method(PHASE_MACRO_EXPANSION, 2);
 }
 {
 TracePhase tp("barrierExpand", &timers[_t_barrierExpand]);
-print_method(PHASE_BEFORE_BARRIER_EXPAND, 2);
-BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
 if (bs->expand_barriers(this, igvn)) {
 assert(failing(), "must bail out w/ explicit message");
 return;
 }
+print_method(PHASE_BARRIER_EXPANSION, 2);
 }
 if (opaque4_count() > 0) {
 C->remove_opaque4_nodes(igvn);
 igvn.optimize();
 }
 if (n->is_MemBar()) {
 MemBarNode* mb = n->as_MemBar();
 if (mb->trailing_store() || mb->trailing_load_store()) {
 assert(mb->leading_membar()->trailing_membar() == mb, "bad membar pair");
-Node* mem = mb->in(MemBarNode::Precedent);
+Node* mem = BarrierSet::barrier_set()->barrier_set_c2()->step_over_gc_barrier(mb->in(MemBarNode::Precedent));
 assert((mb->trailing_store() && mem->is_Store() && mem->as_Store()->is_release()) ||
 (mb->trailing_load_store() && mem->is_LoadStore()), "missing mem op");
 } else if (mb->leading()) {
 assert(mb->trailing_membar()->leading_membar() == mb, "bad membar pair");
 }
 // Code generation on some platforms doesn't need accurate
 // ConvI2L types. Widening the type can help remove redundant
 // address computations.
 n->as_Type()->set_type(TypeLong::INT);
 ResourceMark rm;
-Node_List wq;
+Unique_Node_List wq;
 wq.push(n);
 for (uint next = 0; next < wq.size(); next++) {
 Node *m = wq.at(next);
 for(;;) {
 }
 // Push their uses so we get a chance to remove node made
 // redundant
 for (DUIterator_Fast imax, i = k->fast_outs(imax); i < imax; i++) {
 Node* u = k->fast_out(i);
-assert(!wq.contains(u), "shouldn't process one node several times");
 if (u->Opcode() == Op_LShiftL ||
 u->Opcode() == Op_AddL ||
 u->Opcode() == Op_SubL ||
 u->Opcode() == Op_AddP) {
 wq.push(u);
 }
 }
 }
 }
-bool Compile::is_compiling_clinit_for(ciKlass* k) {
+bool Compile::needs_clinit_barrier(ciMethod* method, ciMethod* accessing_method) {
-ciMethod* root = method(); // the root method of compilation
+return method->is_static() && needs_clinit_barrier(method->holder(), accessing_method);
-return root->is_static_initializer() && root->holder() == k; // access in the context of clinit
+}
+bool Compile::needs_clinit_barrier(ciField* field, ciMethod* accessing_method) {
+return field->is_static() && needs_clinit_barrier(field->holder(), accessing_method);
+}
+bool Compile::needs_clinit_barrier(ciInstanceKlass* holder, ciMethod* accessing_method) {
+if (holder->is_initialized()) {
+return false;
+}
+if (holder->is_being_initialized()) {
+if (accessing_method->holder() == holder) {
+// Access inside a class. The barrier can be elided when access happens in <clinit>,
+// <init>, or a static method. In all those cases, there was an initialization
+// barrier on the holder klass passed.
+if (accessing_method->is_static_initializer() ||
+accessing_method->is_object_initializer() ||
+accessing_method->is_static()) {
+return false;
+}
+} else if (accessing_method->holder()->is_subclass_of(holder)) {
+// Access from a subclass. The barrier can be elided only when access happens in <clinit>.
+// In case of <init> or a static method, the barrier is on the subclass is not enough:
+// child class can become fully initialized while its parent class is still being initialized.
+if (accessing_method->is_static_initializer()) {
+return false;
+}
+}
+ciMethod* root = method(); // the root method of compilation
+if (root != accessing_method) {
+return needs_clinit_barrier(holder, root); // check access in the context of compilation root
+}
+}
+return true;
 }
 #ifndef PRODUCT
 //------------------------------verify_graph_edges---------------------------
 // Walk the Graph and verify that there is a one-to-one correspondence

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54960	e46fe26d7f77
child 58679	9c3209ff7550