src/hotspot/share/opto/loopnode.hpp

*** 74,11 ***
           HasAtomicPostLoop     = 1<<11,
           StripMined            = 1<<12,
           SubwordLoop           = 1<<13,
           ProfileTripFailed     = 1<<14,
           LoopNestInnerLoop     = 1<<15,
!          LoopNestLongOuterLoop = 1<<16 };
    char _unswitch_count;
    enum { _unswitch_max=3 };
  
    // Expected trip count from profile data
    float _profile_trip_cnt;
--- 74,12 ---
           HasAtomicPostLoop     = 1<<11,
           StripMined            = 1<<12,
           SubwordLoop           = 1<<13,
           ProfileTripFailed     = 1<<14,
           LoopNestInnerLoop     = 1<<15,
!          LoopNestLongOuterLoop = 1<<16,
+          FlatArrays            = 1<<17};
    char _unswitch_count;
    enum { _unswitch_max=3 };
  
    // Expected trip count from profile data
    float _profile_trip_cnt;

*** 97,10 ***
--- 98,11 ---
    bool is_strip_mined() const { return _loop_flags & StripMined; }
    bool is_profile_trip_failed() const { return _loop_flags & ProfileTripFailed; }
    bool is_subword_loop() const { return _loop_flags & SubwordLoop; }
    bool is_loop_nest_inner_loop() const { return _loop_flags & LoopNestInnerLoop; }
    bool is_loop_nest_outer_loop() const { return _loop_flags & LoopNestLongOuterLoop; }
+   bool is_flat_arrays() const { return _loop_flags & FlatArrays; }
  
    void mark_partial_peel_failed() { _loop_flags |= PartialPeelFailed; }
    void mark_was_slp() { _loop_flags |= WasSlpAnalyzed; }
    void mark_passed_slp() { _loop_flags |= PassedSlpAnalysis; }
    void mark_do_unroll_only() { _loop_flags |= DoUnrollOnly; }

*** 110,10 ***
--- 112,11 ---
    void clear_strip_mined() { _loop_flags &= ~StripMined; }
    void mark_profile_trip_failed() { _loop_flags |= ProfileTripFailed; }
    void mark_subword_loop() { _loop_flags |= SubwordLoop; }
    void mark_loop_nest_inner_loop() { _loop_flags |= LoopNestInnerLoop; }
    void mark_loop_nest_outer_loop() { _loop_flags |= LoopNestLongOuterLoop; }
+   void mark_flat_arrays() { _loop_flags |= FlatArrays; }
  
    int unswitch_max() { return _unswitch_max; }
    int unswitch_count() { return _unswitch_count; }
  
    void set_unswitch_count(int val) {

*** 1407,21 ***
  
    // Create a slow version of the loop by cloning the loop
    // and inserting an if to select fast-slow versions.
    // Return the inserted if.
    IfNode* create_slow_version_of_loop(IdealLoopTree *loop,
!                                         Node_List &old_new,
!                                         IfNode* unswitch_iff,
!                                         CloneLoopMode mode);
  
    // Clone loop with an invariant test (that does not exit) and
    // insert a clone of the test that selects which version to
    // execute.
    void do_unswitching (IdealLoopTree *loop, Node_List &old_new);
  
    // Find candidate "if" for unswitching
!   IfNode* find_unswitching_candidate(const IdealLoopTree *loop) const;
  
    // Range Check Elimination uses this function!
    // Constrain the main loop iterations so the affine function:
    //    low_limit <= scale_con * I + offset  <  upper_limit
    // always holds true.  That is, either increase the number of iterations in
--- 1410,21 ---
  
    // Create a slow version of the loop by cloning the loop
    // and inserting an if to select fast-slow versions.
    // Return the inserted if.
    IfNode* create_slow_version_of_loop(IdealLoopTree *loop,
!                                       Node_List &old_new,
!                                       Node_List &unswitch_iffs,
!                                       CloneLoopMode mode);
  
    // Clone loop with an invariant test (that does not exit) and
    // insert a clone of the test that selects which version to
    // execute.
    void do_unswitching (IdealLoopTree *loop, Node_List &old_new);
  
    // Find candidate "if" for unswitching
!   IfNode* find_unswitching_candidate(const IdealLoopTree *loop, Node_List& unswitch_iffs) const;
  
    // Range Check Elimination uses this function!
    // Constrain the main loop iterations so the affine function:
    //    low_limit <= scale_con * I + offset  <  upper_limit
    // always holds true.  That is, either increase the number of iterations in

*** 1537,11 ***
--- 1540,13 ---
    bool split_up( Node *n, Node *blk1, Node *blk2 );
  
    Node* place_outside_loop(Node* useblock, IdealLoopTree* loop) const;
    Node* try_move_store_before_loop(Node* n, Node *n_ctrl);
    void try_move_store_after_loop(Node* n);
+   void move_flat_array_check_out_of_loop(Node* n);
    bool identical_backtoback_ifs(Node *n);
+   bool flat_array_element_type_check(Node *n);
    bool can_split_if(Node *n_ctrl);
    bool cannot_split_division(const Node* n, const Node* region) const;
    static bool is_divisor_counted_loop_phi(const Node* divisor, const Node* loop);
    bool loop_phi_backedge_type_contains_zero(const Node* phi_divisor, const Type* zero) const;