src/share/vm/opto/callnode.hpp

*** 176,185 ****
--- 176,192 ----
  // plus GC roots, for all active calls at some call site in this compilation
  // unit.  (If there is no inlining, then the list has exactly one link.)
  // This provides a way to map the optimized program back into the interpreter,
  // or to let the GC mark the stack.
  class JVMState : public ResourceObj {
+ public:
+   typedef enum {
+     RE_Undefined = -1, // not defined -- will be translated into false later
+     RE_False     =  0, // false       -- do not reexecute
+     RE_True      =  1  // true        -- reexecute the bytecode
+   } REBit; //ReExecution Bit
+ 
  private:
    JVMState*         _caller;    // List pointer for forming scope chains
    uint              _depth;     // One mroe than caller depth, or one.
    uint              _locoff;    // Offset to locals in input edge mapping
    uint              _stkoff;    // Offset to stack in input edge mapping
*** 186,195 ****
--- 193,203 ----
    uint              _monoff;    // Offset to monitors in input edge mapping
    uint              _scloff;    // Offset to fields of scalar objs in input edge mapping
    uint              _endoff;    // Offset to end of input edge mapping
    uint              _sp;        // Jave Expression Stack Pointer for this state
    int               _bci;       // Byte Code Index of this JVM point
+   REBit             _reexecute; // Whether this bytecode need to be re-executed
    ciMethod*         _method;    // Method Pointer
    SafePointNode*    _map;       // Map node associated with this scope
  public:
    friend class Compile;
  
*** 222,231 ****
--- 230,240 ----
    bool        is_mon(uint i) const { return i >= _monoff && i < _scloff; }
    bool        is_scl(uint i) const { return i >= _scloff && i < _endoff; }
  
    uint                      sp()     const { return _sp; }
    int                      bci()    const { return _bci; }
+   REBit       should_reexecute() const { return _reexecute; }
    bool              has_method() const { return _method != NULL; }
    ciMethod*             method() const { assert(has_method(), ""); return _method; }
    JVMState*             caller() const { return _caller; }
    SafePointNode*           map()    const { return _map; }
    uint                   depth()  const { return _depth; }
*** 266,275 ****
--- 275,285 ----
      _locoff = _stkoff = _monoff = _scloff = _endoff = off;
    }
    void              set_map(SafePointNode *map) { _map = map; }
    void              set_sp(uint sp) { _sp = sp; }
    void              set_bci(int bci) { _bci = bci; }
+   void              set_reexecute(REBit reexec) {_reexecute = reexec;}
  
    // Miscellaneous utility functions
    JVMState* clone_deep(Compile* C) const;    // recursively clones caller chain
    JVMState* clone_shallow(Compile* C) const; // retains uncloned caller