< prev index next >

src/share/vm/opto/compile.hpp

Print this page

        

@@ -67,10 +67,11 @@
 class PhaseRegAlloc;
 class PhaseCCP;
 class PhaseCCP_DCE;
 class RootNode;
 class relocInfo;
+class ShenandoahLoadReferenceBarrierNode;
 class Scope;
 class StartNode;
 class SafePointNode;
 class JVMState;
 class Type;

@@ -336,16 +337,18 @@
   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,13 +667,15 @@
   }
 
   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,10 +695,19 @@
   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,10 +736,12 @@
   // 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; }

@@ -1221,8 +1237,10 @@
   // Convert integer value to a narrowed long type dependent on ctrl (for example, a range check)
   static Node* constrained_convI2L(PhaseGVN* phase, Node* value, const TypeInt* itype, Node* ctrl);
 
   // Auxiliary method for randomized fuzzing/stressing
   static bool randomized_select(int count);
+
+  void shenandoah_eliminate_g1_wb_pre(Node* call, PhaseIterGVN* igvn);
 };
 
 #endif // SHARE_VM_OPTO_COMPILE_HPP
< prev index next >