#ifndef SHARE_VM_RUNTIME_VFRAMEARRAY_HPP

#define SHARE_VM_RUNTIME_VFRAMEARRAY_HPP

#include "oops/arrayOop.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/monitorChunk.hpp"

#include "utilities/growableArray.hpp"

class LocalsClosure;

class ExpressionStackClosure;

class MonitorStackClosure;

class MonitorArrayElement;

class StackValueCollection;

class vframeArrayElement : public _ValueObj {

friend class VMStructs;

private:

frame _frame; // the interpreter frame we will unpack into

int _bci; // raw bci for this vframe

bool _reexecute; // whether sould we reexecute this bytecode

methodOop _method; // the method for this vframe

MonitorChunk* _monitors; // active monitors for this vframe

StackValueCollection* _locals;

StackValueCollection* _expressions;

public:

frame* iframe(void) { return &_frame; }

int bci(void) const;

int raw_bci(void) const { return _bci; }

bool should_reexecute(void) const { return _reexecute; }

methodOop method(void) const { return _method; }

MonitorChunk* monitors(void) const { return _monitors; }

void free_monitors(JavaThread* jt);

StackValueCollection* locals(void) const { return _locals; }

StackValueCollection* expressions(void) const { return _expressions; }

void fill_in(compiledVFrame* vf);

// Formerly part of deoptimizedVFrame

// Returns the on stack word size for this frame

// callee_parameters is the number of callee locals residing inside this frame

int on_stack_size(int caller_actual_parameters,

int callee_parameters,

int callee_locals,

bool is_bottom_frame,

bool is_top_frame,

int popframe_extra_stack_expression_els) const;

// Unpacks the element to skeletal interpreter frame

void unpack_on_stack(int caller_actual_parameters,

int callee_parameters,

int callee_locals,

frame* caller,

bool is_top_frame,

bool is_bottom_frame,

int exec_mode);

#ifndef PRODUCT

void print(outputStream* st);

#endif /* PRODUCT */

};

class vframeArray: public CHeapObj<mtCompiler> {

friend class VMStructs;

private:

// Here is what a vframeArray looks like in memory

/*

JavaThread* _owner_thread;

vframeArray* _next;

frame _original; // the original frame of the deoptee

frame _caller; // caller of root frame in vframeArray

frame _sender;

Deoptimization::UnrollBlock* _unroll_block;

int _frame_size;

int _frames; // number of javavframes in the array (does not count any adapter)

intptr_t _callee_registers[RegisterMap::reg_count];

unsigned char _valid[RegisterMap::reg_count];

vframeArrayElement _elements[1]; // First variable section.

void fill_in_element(int index, compiledVFrame* vf);

bool is_location_valid(int i) const { return _valid[i] != 0; }

void set_location_valid(int i, bool valid) { _valid[i] = valid; }

public:

// Tells whether index is within bounds.

bool is_within_bounds(int index) const { return 0 <= index && index < frames(); }

// Accessores for instance variable

int frames() const { return _frames; }

static vframeArray* allocate(JavaThread* thread, int frame_size, GrowableArray<compiledVFrame*>* chunk,

RegisterMap* reg_map, frame sender, frame caller, frame self);

vframeArrayElement* element(int index) { assert(is_within_bounds(index), "Bad index"); return &_elements[index]; }

// Allocates a new vframe in the array and fills the array with vframe information in chunk

void fill_in(JavaThread* thread, int frame_size, GrowableArray<compiledVFrame*>* chunk, const RegisterMap *reg_map);

// Returns the owner of this vframeArray

JavaThread* owner_thread() const { return _owner_thread; }

// Accessors for next

vframeArray* next() const { return _next; }

void set_next(vframeArray* value) { _next = value; }

// Accessors for sp

intptr_t* sp() const { return _original.sp(); }

intptr_t* unextended_sp() const { return _original.unextended_sp(); }

address original_pc() const { return _original.pc(); }

frame original() const { return _original; }

frame caller() const { return _caller; }

frame sender() const { return _sender; }

// Accessors for unroll block

Deoptimization::UnrollBlock* unroll_block() const { return _unroll_block; }

void set_unroll_block(Deoptimization::UnrollBlock* block) { _unroll_block = block; }

// Returns the size of the frame that got deoptimized

int frame_size() const { return _frame_size; }

// Unpack the array on the stack passed in stack interval

void unpack_to_stack(frame &unpack_frame, int exec_mode, int caller_actual_parameters);

// Deallocates monitor chunks allocated during deoptimization.

// This should be called when the array is not used anymore.

void deallocate_monitor_chunks();

// Accessor for register map

address register_location(int i) const;

void print_on_2(outputStream* st) PRODUCT_RETURN;

void print_value_on(outputStream* st) const PRODUCT_RETURN;

#ifndef PRODUCT

// Comparing

bool structural_compare(JavaThread* thread, GrowableArray<compiledVFrame*>* chunk);

#endif

};

#endif // SHARE_VM_RUNTIME_VFRAMEARRAY_HPP