jdk-sandbox: comparison src/hotspot/share/gc/z/c2/zBarrierSetC2.cpp

equal deleted inserted replaced

-:9a88ffdc2f43
+:4b42f828e0c3
 #include "gc/z/zBarrierSet.hpp"
 #include "gc/z/c2/zBarrierSetC2.hpp"
 #include "gc/z/zThreadLocalData.hpp"
 #include "gc/z/zBarrierSetRuntime.hpp"
-ZBarrierSetC2State::ZBarrierSetC2State(Arena* comp_arena)
+ZBarrierSetC2State::ZBarrierSetC2State(Arena* comp_arena) :
-: _load_barrier_nodes(new (comp_arena) GrowableArray<LoadBarrierNode*>(comp_arena, 8,  0, NULL)) {}
+_load_barrier_nodes(new (comp_arena) GrowableArray<LoadBarrierNode*>(comp_arena, 8,  0, NULL)) {}
 int ZBarrierSetC2State::load_barrier_count() const {
 return _load_barrier_nodes->length();
 }
 }
 }
 void ZBarrierSetC2::find_dominating_barriers(PhaseIterGVN& igvn) {
 // Look for dominating barriers on the same address only once all
-// other loop opts are over: loop opts may cause a safepoint to be
+// other loop opts are over. Loop opts may cause a safepoint to be
 // inserted between a barrier and its dominating barrier.
 Compile* C = Compile::current();
 ZBarrierSetC2* bs = (ZBarrierSetC2*)BarrierSet::barrier_set()->barrier_set_c2();
 ZBarrierSetC2State* s = bs->state();
 if (s->load_barrier_count() >= 2) {
 traverse(preceding_barrier_node, result_region, result_phi, -1);
 #endif
 assert(is_gc_barrier_node(result_phi), "sanity");
 assert(step_over_gc_barrier(result_phi) == in_val, "sanity");
-return;
 }
 bool ZBarrierSetC2::expand_barriers(Compile* C, PhaseIterGVN& igvn) const {
 ZBarrierSetC2State* s = state();
 if (s->load_barrier_count() > 0) {
 skipped++;
 continue;
 }
 expand_loadbarrier_node(&macro, n);
 assert(s->load_barrier_count() < load_barrier_count, "must have deleted a node from load barrier list");
-if (C->failing())  return true;
+if (C->failing()) {
+return true;
+}
 }
 while (s->load_barrier_count() > 0) {
 int load_barrier_count = s->load_barrier_count();
 LoadBarrierNode* n = s->load_barrier_node(load_barrier_count - 1);
 assert(!(igvn.type(n) == Type::TOP || (n->in(0) != NULL && n->in(0)->is_top())), "should have been processed already");
 assert(!n->can_be_eliminated(), "should have been processed already");
 expand_loadbarrier_node(&macro, n);
 assert(s->load_barrier_count() < load_barrier_count, "must have deleted a node from load barrier list");
-if (C->failing())  return true;
+if (C->failing()) {
+return true;
+}
 }
 igvn.set_delay_transform(false);
 igvn.optimize();
-if (C->failing())  return true;
+if (C->failing()) {
-}
+return true;
+}
+}
 return false;
 }
 // == Loop optimization ==
 static bool replace_with_dominating_barrier(PhaseIdealLoop* phase, LoadBarrierNode* lb, bool last_round) {
 PhaseIterGVN &igvn = phase->igvn();
 Compile* C = Compile::current();
 LoadBarrierNode* lb2 = lb->has_dominating_barrier(phase, false, last_round);
-if (lb2 != NULL) {
+if (lb2 == NULL) {
-if (lb->in(LoadBarrierNode::Oop) != lb2->in(LoadBarrierNode::Oop)) {
+return false;
-assert(lb->in(LoadBarrierNode::Address) == lb2->in(LoadBarrierNode::Address), "");
+}
-igvn.replace_input_of(lb, LoadBarrierNode::Similar, lb2->proj_out(LoadBarrierNode::Oop));
-C->set_major_progress();
+if (lb->in(LoadBarrierNode::Oop) != lb2->in(LoadBarrierNode::Oop)) {
-} else  {
+assert(lb->in(LoadBarrierNode::Address) == lb2->in(LoadBarrierNode::Address), "Invalid address");
-// That transformation may cause the Similar edge on dominated load barriers to be invalid
+igvn.replace_input_of(lb, LoadBarrierNode::Similar, lb2->proj_out(LoadBarrierNode::Oop));
-lb->fix_similar_in_uses(&igvn);
+C->set_major_progress();
+return false;
-Node* val = lb->proj_out(LoadBarrierNode::Oop);
+}
-assert(lb2->has_true_uses(), "");
-assert(lb2->in(LoadBarrierNode::Oop) == lb->in(LoadBarrierNode::Oop), "");
+// That transformation may cause the Similar edge on dominated load barriers to be invalid
+lb->fix_similar_in_uses(&igvn);
-phase->lazy_update(lb, lb->in(LoadBarrierNode::Control));
-phase->lazy_replace(lb->proj_out(LoadBarrierNode::Control), lb->in(LoadBarrierNode::Control));
+Node* val = lb->proj_out(LoadBarrierNode::Oop);
-igvn.replace_node(val, lb2->proj_out(LoadBarrierNode::Oop));
+assert(lb2->has_true_uses(), "Invalid uses");
+assert(lb2->in(LoadBarrierNode::Oop) == lb->in(LoadBarrierNode::Oop), "Invalid oop");
-return true;
+phase->lazy_update(lb, lb->in(LoadBarrierNode::Control));
-}
+phase->lazy_replace(lb->proj_out(LoadBarrierNode::Control), lb->in(LoadBarrierNode::Control));
-}
+igvn.replace_node(val, lb2->proj_out(LoadBarrierNode::Oop));
-return false;
+return true;
 }
 static Node* find_dominating_memory(PhaseIdealLoop* phase, Node* mem, Node* dom, int i) {
 assert(dom->is_Region() || i == -1, "");
 Node* m = mem;
 while(phase->is_dominator(dom, phase->has_ctrl(m) ? phase->get_ctrl(m) : m->in(0))) {
 if (m->is_Mem()) {
 assert(m->as_Mem()->adr_type() == TypeRawPtr::BOTTOM, "");
 m = m->in(MemNode::Memory);
 m->dump();
 #endif
 ShouldNotReachHere();
 }
 }
 return m;
 }
 static LoadBarrierNode* clone_load_barrier(PhaseIdealLoop* phase, LoadBarrierNode* lb, Node* ctl, Node* mem, Node* oop_in) {
 PhaseIterGVN &igvn = phase->igvn();
 }
 return false;
 }
-static void optimize_load_barrier(PhaseIdealLoop* phase, LoadBarrierNode* lb, bool last_round) {
+void ZBarrierSetC2::loop_optimize_gc_barrier(PhaseIdealLoop* phase, Node* node, bool last_round) {
-Compile* C = Compile::current();
+if (!Compile::current()->directive()->ZOptimizeLoadBarriersOption) {
-if (!C->directive()->ZOptimizeLoadBarriersOption) {
 return;
 }
-if (lb->has_true_uses()) {
+if (!node->is_LoadBarrier()) {
-if (replace_with_dominating_barrier(phase, lb, last_round)) {
+return;
-return;
+}
-}
+if (!node->as_LoadBarrier()->has_true_uses()) {
-if (split_barrier_thru_phi(phase, lb)) {
+return;
-return;
+}
-}
+if (replace_with_dominating_barrier(phase, node->as_LoadBarrier(), last_round)) {
-if (move_out_of_loop(phase, lb)) {
+return;
-return;
+}
-}
+if (split_barrier_thru_phi(phase, node->as_LoadBarrier())) {
-if (common_barriers(phase, lb)) {
+return;
-return;
+}
-}
-}
+if (move_out_of_loop(phase, node->as_LoadBarrier())) {
-}
+return;
+}
-void ZBarrierSetC2::loop_optimize_gc_barrier(PhaseIdealLoop* phase, Node* node, bool last_round) {
-if (node->is_LoadBarrier()) {
+if (common_barriers(phase, node->as_LoadBarrier())) {
-optimize_load_barrier(phase, node->as_LoadBarrier(), last_round);
+return;
 }
 }
 Node* ZBarrierSetC2::step_over_gc_barrier(Node* c) const {
 Node* node = c;
 bool ZBarrierSetC2::array_copy_requires_gc_barriers(bool tightly_coupled_alloc, BasicType type, bool is_clone, ArrayCopyPhase phase) const {
 return type == T_OBJECT || type == T_ARRAY;
 }
 bool ZBarrierSetC2::final_graph_reshaping(Compile* compile, Node* n, uint opcode) const {
-bool handled;
+if (opcode != Op_LoadBarrierSlowReg &&
-switch (opcode) {
+opcode != Op_LoadBarrierWeakSlowReg) {
-case Op_LoadBarrierSlowReg:
+return false;
-case Op_LoadBarrierWeakSlowReg:
+}
 #ifdef ASSERT
 if (VerifyOptoOopOffsets) {
 MemNode* mem  = n->as_Mem();
 // Check to see if address types have grounded out somehow.
 const TypeInstPtr* tp = mem->in(MemNode::Address)->bottom_type()->isa_instptr();
 ciInstanceKlass* k = tp->klass()->as_instance_klass();
 bool oop_offset_is_sane = k->contains_field_offset(tp->offset());
 assert(!tp || oop_offset_is_sane, "");
 }
 #endif
-handled = true;
-break;
+return true;
-default:
-handled = false;
-}
-return handled;
 }
 bool ZBarrierSetC2::matcher_find_shared_visit(Matcher* matcher, Matcher::MStack& mstack, Node* n, uint opcode, bool& mem_op, int& mem_addr_idx) const {
 if (opcode == Op_CallLeaf &&
 (n->as_Call()->entry_point() == ZBarrierSetRuntime::load_barrier_on_oop_field_preloaded_addr() ||
 n->as_Call()->entry_point() == ZBarrierSetRuntime::load_barrier_on_weak_oop_field_preloaded_addr())) {
 mem_op = true;
 mem_addr_idx = TypeFunc::Parms + 1;
 return true;
 }
 return false;
 }
 // == Verification ==
 switch (opcode) {
 case Op_LoadBarrierSlowReg:
 case Op_LoadBarrierWeakSlowReg:
 conn_graph->add_objload_to_connection_graph(n, delayed_worklist);
 return true;
 case Op_Proj:
-if (n->as_Proj()->_con == LoadBarrierNode::Oop && n->in(0)->is_LoadBarrier()) {
+if (n->as_Proj()->_con != LoadBarrierNode::Oop || !n->in(0)->is_LoadBarrier()) {
-conn_graph->add_local_var_and_edge(n, PointsToNode::NoEscape, n->in(0)->in(LoadBarrierNode::Oop),
+return false;
-delayed_worklist);
+}
-return true;
+conn_graph->add_local_var_and_edge(n, PointsToNode::NoEscape, n->in(0)->in(LoadBarrierNode::Oop), delayed_worklist);
-}
+return true;
-default:
+}
-break;
-}
 return false;
 }
 bool ZBarrierSetC2::escape_add_final_edges(ConnectionGraph* conn_graph, PhaseGVN* gvn, Node* n, uint opcode) const {
 switch (opcode) {
 case Op_LoadBarrierSlowReg:
-case Op_LoadBarrierWeakSlowReg: {
+case Op_LoadBarrierWeakSlowReg:
-const Type *t = gvn->type(n);
+if (gvn->type(n)->make_ptr() == NULL) {
-if (t->make_ptr() != NULL) {
+return false;
-Node *adr = n->in(MemNode::Address);
+}
-conn_graph->add_local_var_and_edge(n, PointsToNode::NoEscape, adr, NULL);
+conn_graph->add_local_var_and_edge(n, PointsToNode::NoEscape, n->in(MemNode::Address), NULL);
 return true;
-}
-break;
+case Op_Proj:
-}
+if (n->as_Proj()->_con != LoadBarrierNode::Oop || !n->in(0)->is_LoadBarrier()) {
-case Op_Proj: {
+return false;
-if (n->as_Proj()->_con == LoadBarrierNode::Oop && n->in(0)->is_LoadBarrier()) {
+}
 conn_graph->add_local_var_and_edge(n, PointsToNode::NoEscape, n->in(0)->in(LoadBarrierNode::Oop), NULL);
 return true;
 }
-}
-default:
-break;
-}
 return false;
 }

changeset 53439	4b42f828e0c3
parent 53438	9a88ffdc2f43
child 53766	7e4a9e912759