src/share/vm/opto/superword.hpp

*** 237,259 ****
    GrowableArray<Node*> _stk;   // Stack of nodes
  
   public:
    SuperWord(PhaseIdealLoop* phase);
  
!   void transform_loop(IdealLoopTree* lpt);
  
    // Accessors for SWPointer
    PhaseIdealLoop* phase()          { return _phase; }
    IdealLoopTree* lpt()             { return _lpt; }
    PhiNode* iv()                    { return _iv; }
  
   private:
    IdealLoopTree* _lpt;             // Current loop tree node
    LoopNode*      _lp;              // Current LoopNode
    Node*          _bb;              // Current basic block
    PhiNode*       _iv;              // Induction var
    bool           _race_possible;   // In cases where SDMU is true
    bool           _do_vector_loop;  // whether to do vectorization/simd style
    bool           _vector_loop_debug; // provide more printing in debug mode
    int            _num_work_vecs;   // Number of non memory vector operations
    int            _num_reductions;  // Number of reduction expressions applied
    int            _ii_first;        // generation with direct deps from mem phi
--- 237,263 ----
    GrowableArray<Node*> _stk;   // Stack of nodes
  
   public:
    SuperWord(PhaseIdealLoop* phase);
  
!   void transform_loop(IdealLoopTree* lpt, bool do_optimization);
! 
!   void unrolling_analysis(CountedLoopNode *cl, int &local_loop_unroll_factor);
  
    // Accessors for SWPointer
    PhaseIdealLoop* phase()          { return _phase; }
    IdealLoopTree* lpt()             { return _lpt; }
    PhiNode* iv()                    { return _iv; }
+   bool early_return()              { return _early_return; }
  
   private:
    IdealLoopTree* _lpt;             // Current loop tree node
    LoopNode*      _lp;              // Current LoopNode
    Node*          _bb;              // Current basic block
    PhiNode*       _iv;              // Induction var
    bool           _race_possible;   // In cases where SDMU is true
+   bool           _early_return;    // True if we do not initialize
    bool           _do_vector_loop;  // whether to do vectorization/simd style
    bool           _vector_loop_debug; // provide more printing in debug mode
    int            _num_work_vecs;   // Number of non memory vector operations
    int            _num_reductions;  // Number of reduction expressions applied
    int            _ii_first;        // generation with direct deps from mem phi
*** 468,477 ****
--- 472,484 ----
    Node* _adr;                // address pointer
    jint  _scale;              // multiplier for iv (in bytes), 0 if no loop iv
    jint  _offset;             // constant offset (in bytes)
    Node* _invar;              // invariant offset (in bytes), NULL if none
    bool  _negate_invar;       // if true then use: (0 - _invar)
+   Node_Stack* _nstack;       // stack used to record a swpointer trace of variants
+   bool        _analyze_only; // Used in loop unrolling only for swpointer trace
+   uint        _stack_idx;    // Used in loop unrolling only for swpointer trace
  
    PhaseIdealLoop* phase() { return _slp->phase(); }
    IdealLoopTree*  lpt()   { return _slp->lpt(); }
    PhiNode*        iv()    { return _slp->iv();  } // Induction var
  
*** 494,504 ****
      Equal         = 4,
      NotEqual      = (Less | Greater),
      NotComparable = (Less | Greater | Equal)
    };
  
!   SWPointer(MemNode* mem, SuperWord* slp);
    // Following is used to create a temporary object during
    // the pattern match of an address expression.
    SWPointer(SWPointer* p);
  
    bool valid()  { return _adr != NULL; }
--- 501,511 ----
      Equal         = 4,
      NotEqual      = (Less | Greater),
      NotComparable = (Less | Greater | Equal)
    };
  
!   SWPointer(MemNode* mem, SuperWord* slp, Node_Stack *nstack, bool analyze_only);
    // Following is used to create a temporary object during
    // the pattern match of an address expression.
    SWPointer(SWPointer* p);
  
    bool valid()  { return _adr != NULL; }
*** 510,519 ****
--- 517,527 ----
    int   scale_in_bytes()   { return _scale; }
    Node* invar()            { return _invar; }
    bool  negate_invar()     { return _negate_invar; }
    int   offset_in_bytes()  { return _offset; }
    int   memory_size()      { return _mem->memory_size(); }
+   Node_Stack* node_stack() { return _nstack; }
  
    // Comparable?
    int cmp(SWPointer& q) {
      if (valid() && q.valid() &&
          (_adr == q._adr || _base == _adr && q._base == q._adr) &&