< prev index next >

src/hotspot/share/opto/loopnode.hpp

Print this page
@@ -76,11 +76,12 @@
           IsMultiversioned    = 1<<14,
           StripMined          = 1<<15,
           SubwordLoop         = 1<<16,
           ProfileTripFailed   = 1<<17,
           TransformedLongInnerLoop = 1<<18,
-          TransformedLongOuterLoop = 1<<19};
+          TransformedLongOuterLoop = 1<<19,
+          FlattenedArrays     = 1<<20};
    char _unswitch_count;
    enum { _unswitch_max=3 };
    char _postloop_flags;
    enum { LoopNotRCEChecked = 0, LoopRCEChecked = 1, RCEPostLoop = 2 };
  

@@ -103,10 +104,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_transformed_long_inner_loop() const { return _loop_flags & TransformedLongInnerLoop; }
    bool is_transformed_long_outer_loop() const { return _loop_flags & TransformedLongOuterLoop; }
+   bool is_flattened_arrays() const { return _loop_flags & FlattenedArrays; }
  
    void mark_partial_peel_failed() { _loop_flags |= PartialPeelFailed; }
    void mark_has_reductions() { _loop_flags |= HasReductions; }
    void mark_was_slp() { _loop_flags |= WasSlpAnalyzed; }
    void mark_passed_slp() { _loop_flags |= PassedSlpAnalysis; }

@@ -119,10 +121,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_transformed_long_inner_loop() { _loop_flags |= TransformedLongInnerLoop; }
    void mark_transformed_long_outer_loop() { _loop_flags |= TransformedLongOuterLoop; }
+   void mark_flattened_arrays() { _loop_flags |= FlattenedArrays; }
  
    int unswitch_max() { return _unswitch_max; }
    int unswitch_count() { return _unswitch_count; }
  
    int has_been_range_checked() const { return _postloop_flags & LoopRCEChecked; }

@@ -1354,13 +1357,13 @@
  
    // 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);
+                                       Node_List &old_new,
+                                       Node_List &unswitch_iffs,
+                                       CloneLoopMode mode);
  
    // Clone a loop and return the clone head (clone_loop_head).
    // Added nodes include int(1), int(0) - disconnected, If, IfTrue, IfFalse,
    // This routine was created for usage in CountedLoopReserveKit.
    //

@@ -1374,11 +1377,11 @@
    // 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;
+   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

@@ -1495,11 +1498,13 @@
    bool split_up( Node *n, Node *blk1, Node *blk2 );
    void sink_use( Node *use, Node *post_loop );
    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 flatten_array_element_type_check(Node *n);
    bool can_split_if(Node *n_ctrl);
  
    // Determine if a method is too big for a/another round of split-if, based on
    // a magic (approximate) ratio derived from the equally magic constant 35000,
    // previously used for this purpose (but without relating to the node limit).
< prev index next >