< prev index next >

src/share/vm/opto/compile.hpp

Print this page

        

*** 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; }
*** 1221,1228 **** --- 1237,1246 ---- // 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 >