src/share/vm/opto/compile.hpp

*** 67,76 ****
--- 67,77 ----
  class PhaseRegAlloc;
  class PhaseCCP;
  class PhaseCCP_DCE;
  class RootNode;
  class relocInfo;
+ class ShenandoahLoadReferenceBarrierNode;
  class Scope;
  class StartNode;
  class SafePointNode;
  class JVMState;
  class Type;
*** 336,351 ****
--- 337,354 ----
    GrowableArray<CallGenerator*>* _intrinsics;   // List of intrinsics.
    GrowableArray<Node*>* _macro_nodes;           // List of nodes which need to be expanded before matching.
    GrowableArray<Node*>* _predicate_opaqs;       // List of Opaque1 nodes for the loop predicates.
    GrowableArray<Node*>* _expensive_nodes;       // List of nodes that are expensive to compute and that we'd better not let the GVN freely common
    GrowableArray<Node*>* _range_check_casts;     // List of CastII nodes with a range check dependency
+   GrowableArray<ShenandoahLoadReferenceBarrierNode*>* _shenandoah_barriers;
    ConnectionGraph*      _congraph;
  #ifndef PRODUCT
    IdealGraphPrinter*    _printer;
  #endif
  
  
+ 
    // Node management
    uint                  _unique;                // Counter for unique Node indices
    VectorSet             _dead_node_list;        // Set of dead nodes
    uint                  _dead_node_count;       // Number of dead nodes; VectorSet::Size() is O(N).
                                                  // So use this to keep count and make the call O(1).
*** 664,676 ****
--- 667,681 ----
    }
  
    int           macro_count()             const { return _macro_nodes->length(); }
    int           predicate_count()         const { return _predicate_opaqs->length();}
    int           expensive_count()         const { return _expensive_nodes->length(); }
+   int           shenandoah_barriers_count()         const { return _shenandoah_barriers->length(); }
    Node*         macro_node(int idx)       const { return _macro_nodes->at(idx); }
    Node*         predicate_opaque1_node(int idx) const { return _predicate_opaqs->at(idx);}
    Node*         expensive_node(int idx)   const { return _expensive_nodes->at(idx); }
+   ShenandoahLoadReferenceBarrierNode* shenandoah_barrier(int idx)   const { return _shenandoah_barriers->at(idx); }
    ConnectionGraph* congraph()                   { return _congraph;}
    void set_congraph(ConnectionGraph* congraph)  { _congraph = congraph;}
    void add_macro_node(Node * n) {
      //assert(n->is_macro(), "must be a macro node");
      assert(!_macro_nodes->contains(n), "duplicate entry in expand list");
*** 690,699 ****
--- 695,713 ----
    void remove_expensive_node(Node * n) {
      if (_expensive_nodes->contains(n)) {
        _expensive_nodes->remove(n);
      }
    }
+   void add_shenandoah_barrier(ShenandoahLoadReferenceBarrierNode * n) {
+     assert(!_shenandoah_barriers->contains(n), "duplicate entry in barrier list");
+     _shenandoah_barriers->append(n);
+   }
+   void remove_shenandoah_barrier(ShenandoahLoadReferenceBarrierNode * n) {
+     if (_shenandoah_barriers->contains(n)) {
+       _shenandoah_barriers->remove(n);
+     }
+   }
    void add_predicate_opaq(Node * n) {
      assert(!_predicate_opaqs->contains(n), "duplicate entry in predicate opaque1");
      assert(_macro_nodes->contains(n), "should have already been in macro list");
      _predicate_opaqs->append(n);
    }
*** 722,731 ****
--- 736,747 ----
    // Check whether n1 and n2 are similar
    static int cmp_expensive_nodes(Node* n1, Node* n2);
    // Sort expensive nodes to locate similar expensive nodes
    void sort_expensive_nodes();
  
+   GrowableArray<ShenandoahLoadReferenceBarrierNode*>* shenandoah_barriers() { return _shenandoah_barriers; }
+ 
    // Compilation environment.
    Arena*            comp_arena()                { return &_comp_arena; }
    ciEnv*            env() const                 { return _env; }
    CompileLog*       log() const                 { return _log; }
    bool              failing() const             { return _env->failing() || _failure_reason != NULL; }
*** 1225,1232 ****
--- 1241,1250 ----
    // Auxiliary method for randomized fuzzing/stressing
    static bool randomized_select(int count);
  #ifdef ASSERT
    bool _type_verify_symmetry;
  #endif
+ 
+   void shenandoah_eliminate_g1_wb_pre(Node* call, PhaseIterGVN* igvn);
  };
  
  #endif // SHARE_VM_OPTO_COMPILE_HPP