src/share/vm/opto/compile.hpp

*** 398,407 ****
--- 398,408 ----
    const char*           _failure_reason;        // for record_failure/failing pattern
    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
    ConnectionGraph*      _congraph;
  #ifndef PRODUCT
    IdealGraphPrinter*    _printer;
  #endif
  
*** 751,761 ****
    Node*         expensive_node(int idx)   const { return _expensive_nodes->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");
      _macro_nodes->append(n);
    }
    void remove_macro_node(Node * n) {
      // this function may be called twice for a node so check
      // that the node is in the array before attempting to remove it
--- 752,762 ----
    Node*         expensive_node(int idx)   const { return _expensive_nodes->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");
      _macro_nodes->append(n);
    }
    void remove_macro_node(Node * n) {
      // this function may be called twice for a node so check
      // that the node is in the array before attempting to remove it
*** 771,784 ****
      if (_expensive_nodes->contains(n)) {
        _expensive_nodes->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);
    }
    // remove the opaque nodes that protect the predicates so that the unused checks and
    // uncommon traps will be eliminated from the graph.
    void cleanup_loop_predicates(PhaseIterGVN &igvn);
    bool is_predicate_opaq(Node * n) {
      return _predicate_opaqs->contains(n);
--- 772,798 ----
      if (_expensive_nodes->contains(n)) {
        _expensive_nodes->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);
    }
+ 
+   // Range check dependent CastII nodes that can be removed after loop optimizations
+   void add_range_check_cast(Node* n);
+   void remove_range_check_cast(Node* n) {
+     if (_range_check_casts->contains(n)) {
+       _range_check_casts->remove(n);
+     }
+   }
+   Node* range_check_cast_node(int idx) const { return _range_check_casts->at(idx);  }
+   int   range_check_cast_count()       const { return _range_check_casts->length(); }
+   // Remove all range check dependent CastIINodes.
+   void  remove_range_check_casts(PhaseIterGVN &igvn);
+ 
    // remove the opaque nodes that protect the predicates so that the unused checks and
    // uncommon traps will be eliminated from the graph.
    void cleanup_loop_predicates(PhaseIterGVN &igvn);
    bool is_predicate_opaq(Node * n) {
      return _predicate_opaqs->contains(n);
*** 1290,1300 ****
  
    // Static parse-time type checking logic for gen_subtype_check:
    enum { SSC_always_false, SSC_always_true, SSC_easy_test, SSC_full_test };
    int static_subtype_check(ciKlass* superk, ciKlass* subk);
  
!   static Node* conv_I2X_index(PhaseGVN *phase, Node* offset, const TypeInt* sizetype);
  
    // Auxiliary method for randomized fuzzing/stressing
    static bool randomized_select(int count);
  
    // supporting clone_map
--- 1304,1319 ----
  
    // Static parse-time type checking logic for gen_subtype_check:
    enum { SSC_always_false, SSC_always_true, SSC_easy_test, SSC_full_test };
    int static_subtype_check(ciKlass* superk, ciKlass* subk);
  
!   static Node* conv_I2X_index(PhaseGVN* phase, Node* offset, const TypeInt* sizetype,
!                               // Optional control dependency (for example, on range check)
!                               Node* ctrl = NULL);
! 
!   // 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);
  
    // supporting clone_map