25 // A vframeArray is an array used for momentarily storing off stack Java method activations
  26 // during deoptimization. Essentially it is an array of vframes where each vframe
  27 // data is stored off stack. This structure will never exist across a safepoint so
  28 // there is no need to gc any oops that are stored in the structure.
  29 
  30 
  31 class LocalsClosure;
  32 class ExpressionStackClosure;
  33 class MonitorStackClosure;
  34 class MonitorArrayElement;
  35 class StackValueCollection;
  36 
  37 // A vframeArrayElement is an element of a vframeArray. Each element
  38 // represent an interpreter frame which will eventually be created.
  39 
  40 class vframeArrayElement : public _ValueObj {
  41   private:
  42 
  43     frame _frame;                                                // the interpreter frame we will unpack into
  44     int _bci;                                                    // raw bci for this vframe

  45     methodOop  _method;                                          // the method for this vframe
  46     MonitorChunk* _monitors;                                     // active monitors for this vframe
  47     StackValueCollection* _locals;
  48     StackValueCollection* _expressions;
  49 
  50   public:
  51 
  52   frame* iframe(void)                { return &_frame; }
  53 
  54   int bci(void) const;
  55 
  56   int raw_bci(void) const            { return _bci; }

  57 
  58   methodOop method(void) const       { return _method; }
  59 
  60   MonitorChunk* monitors(void) const { return _monitors; }
  61 
  62   void free_monitors(JavaThread* jt);
  63 
  64   StackValueCollection* locals(void) const             { return _locals; }
  65 
  66   StackValueCollection* expressions(void) const        { return _expressions; }
  67 
  68   void fill_in(compiledVFrame* vf);
  69 
  70   // Formerly part of deoptimizedVFrame
  71 
  72 
  73   // Returns the on stack word size for this frame
  74   // callee_parameters is the number of callee locals residing inside this frame
  75   int on_stack_size(int callee_parameters,
  76                     int callee_locals,

  25 // A vframeArray is an array used for momentarily storing off stack Java method activations
  26 // during deoptimization. Essentially it is an array of vframes where each vframe
  27 // data is stored off stack. This structure will never exist across a safepoint so
  28 // there is no need to gc any oops that are stored in the structure.
  29 
  30 
  31 class LocalsClosure;
  32 class ExpressionStackClosure;
  33 class MonitorStackClosure;
  34 class MonitorArrayElement;
  35 class StackValueCollection;
  36 
  37 // A vframeArrayElement is an element of a vframeArray. Each element
  38 // represent an interpreter frame which will eventually be created.
  39 
  40 class vframeArrayElement : public _ValueObj {
  41   private:
  42 
  43     frame _frame;                                                // the interpreter frame we will unpack into
  44     int  _bci;                                                   // raw bci for this vframe
  45     bool _restart;                                               // whether sould we restart  
  46     methodOop  _method;                                          // the method for this vframe
  47     MonitorChunk* _monitors;                                     // active monitors for this vframe
  48     StackValueCollection* _locals;
  49     StackValueCollection* _expressions;
  50 
  51   public:
  52 
  53   frame* iframe(void)                { return &_frame; }
  54 
  55   int bci(void) const;
  56 
  57   int raw_bci(void) const            { return _bci; }
  58   bool is_restart(void) const        { return _restart; }
  59 
  60   methodOop method(void) const       { return _method; }
  61 
  62   MonitorChunk* monitors(void) const { return _monitors; }
  63 
  64   void free_monitors(JavaThread* jt);
  65 
  66   StackValueCollection* locals(void) const             { return _locals; }
  67 
  68   StackValueCollection* expressions(void) const        { return _expressions; }
  69 
  70   void fill_in(compiledVFrame* vf);
  71 
  72   // Formerly part of deoptimizedVFrame
  73 
  74 
  75   // Returns the on stack word size for this frame
  76   // callee_parameters is the number of callee locals residing inside this frame
  77   int on_stack_size(int callee_parameters,
  78                     int callee_locals,