src/hotspot/share/opto/escape.cpp

@@ -1557,15 +1557,10 @@
    PointsToNode* n_ptn = ptnode_adr(n_idx);
    if (n_ptn != nullptr) {
      return; // No need to redefine PointsTo node during first iteration.
    }
    int opcode = n->Opcode();
-   bool gc_handled = BarrierSet::barrier_set()->barrier_set_c2()->escape_add_to_con_graph(this, igvn, delayed_worklist, n, opcode);
-   if (gc_handled) {
-     return; // Ignore node if already handled by GC.
-   }
- 
    if (n->is_Call()) {
      // Arguments to allocation and locking don't escape.
      if (n->is_AbstractLock()) {
        // Put Lock and Unlock nodes on IGVN worklist to process them during
        // first IGVN optimization when escape information is still available.

@@ -1779,14 +1774,10 @@
    }
    assert(n->is_Store() || n->is_LoadStore() ||
           ((n_ptn != nullptr) && (n_ptn->ideal_node() != nullptr)),
           "node should be registered already");
    int opcode = n->Opcode();
-   bool gc_handled = BarrierSet::barrier_set()->barrier_set_c2()->escape_add_final_edges(this, _igvn, n, opcode);
-   if (gc_handled) {
-     return; // Ignore node if already handled by GC.
-   }
    switch (opcode) {
      case Op_AddP: {
        Node* base = get_addp_base(n);
        PointsToNode* ptn_base = ptnode_adr(base->_idx);
        assert(ptn_base != nullptr, "field's base should be registered");

@@ -2223,11 +2214,10 @@
            //
            bool arg_is_arraycopy_dest = src_has_oops && is_arraycopy &&
                                         arg_has_oops && (i > TypeFunc::Parms);
  #ifdef ASSERT
            if (!(is_arraycopy ||
-                 BarrierSet::barrier_set()->barrier_set_c2()->is_gc_barrier_node(call) ||
                  (call->as_CallLeaf()->_name != nullptr &&
                   (strcmp(call->as_CallLeaf()->_name, "updateBytesCRC32") == 0 ||
                    strcmp(call->as_CallLeaf()->_name, "updateBytesCRC32C") == 0 ||
                    strcmp(call->as_CallLeaf()->_name, "updateBytesAdler32") == 0 ||
                    strcmp(call->as_CallLeaf()->_name, "aescrypt_encryptBlock") == 0 ||

@@ -3539,12 +3529,11 @@
  }
  
  bool ConnectionGraph::has_oop_node_outs(Node* n) {
    return n->has_out_with(Op_StoreP, Op_LoadP, Op_StoreN, Op_LoadN) ||
           n->has_out_with(Op_GetAndSetP, Op_GetAndSetN, Op_CompareAndExchangeP, Op_CompareAndExchangeN) ||
-          n->has_out_with(Op_CompareAndSwapP, Op_CompareAndSwapN, Op_WeakCompareAndSwapP, Op_WeakCompareAndSwapN) ||
-          BarrierSet::barrier_set()->barrier_set_c2()->escape_has_out_with_unsafe_object(n);
+          n->has_out_with(Op_CompareAndSwapP, Op_CompareAndSwapN, Op_WeakCompareAndSwapP, Op_WeakCompareAndSwapN);
  }
  
  // Returns unique pointed java object or null.
  JavaObjectNode* ConnectionGraph::unique_java_object(Node *n) const {
    // If the node was created after the escape computation we can't answer.

@@ -4220,13 +4209,11 @@
            assert(result != nullptr, "new projection should have been allocated");
            break;
          }
        } else if (proj_in->is_MemBar()) {
          // Check if there is an array copy for a clone
-         // Step over GC barrier when ReduceInitialCardMarks is disabled
-         BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
-         Node* control_proj_ac = bs->step_over_gc_barrier(proj_in->in(0));
+         Node* control_proj_ac = proj_in->in(0);
  
          if (control_proj_ac->is_Proj() && control_proj_ac->in(0)->is_ArrayCopy()) {
            // Stop if it is a clone
            ArrayCopyNode* ac = control_proj_ac->in(0)->as_ArrayCopy();
            if (ac->may_modify(toop, igvn)) {

@@ -4709,12 +4696,11 @@
                op == Op_StrComp || op == Op_CountPositives ||
                op == Op_StrCompressedCopy || op == Op_StrInflatedCopy ||
                op == Op_StrEquals || op == Op_VectorizedHashCode ||
                op == Op_StrIndexOf || op == Op_StrIndexOfChar ||
                op == Op_SubTypeCheck ||
-               op == Op_ReinterpretS2HF ||
-               BarrierSet::barrier_set()->barrier_set_c2()->is_gc_barrier_node(use))) {
+               op == Op_ReinterpretS2HF)) {
            n->dump();
            use->dump();
            assert(false, "EA: missing allocation reference path");
          }
  #endif

@@ -4882,12 +4868,11 @@
          uint op = use->Opcode();
          if ((use->in(MemNode::Memory) == n) &&
              (op == Op_StrCompressedCopy || op == Op_StrInflatedCopy)) {
            // They overwrite memory edge corresponding to destination array,
            memnode_worklist.append_if_missing(use);
-         } else if (!(BarrierSet::barrier_set()->barrier_set_c2()->is_gc_barrier_node(use) ||
-               op == Op_AryEq || op == Op_StrComp || op == Op_CountPositives ||
+         } else if (!(op == Op_AryEq || op == Op_StrComp || op == Op_CountPositives ||
                op == Op_StrCompressedCopy || op == Op_StrInflatedCopy || op == Op_VectorizedHashCode ||
                op == Op_StrEquals || op == Op_StrIndexOf || op == Op_StrIndexOfChar)) {
            n->dump();
            use->dump();
            assert(false, "EA: missing memory path");