• file
• revisions
• annotate
• diff
• comparison
• raw

src/share/vm/runtime/vframeArray.hpp@9f4457a14b58 (annotated)

src/share/vm/runtime/vframeArray.hpp

Wed, 09 Apr 2008 15:10:22 -0700

author

rasbold

date

Wed, 09 Apr 2008 15:10:22 -0700

changeset 544

9f4457a14b58

parent 435

a61af66fc99e

child 1335

9987d9d5eb0e

permissions

-rw-r--r--

Merge

duke@435	1	/*
duke@435	2	* Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
duke@435	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435	4	*
duke@435	5	* This code is free software; you can redistribute it and/or modify it
duke@435	6	* under the terms of the GNU General Public License version 2 only, as
duke@435	7	* published by the Free Software Foundation.
duke@435	8	*
duke@435	9	* This code is distributed in the hope that it will be useful, but WITHOUT
duke@435	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435	12	* version 2 for more details (a copy is included in the LICENSE file that
duke@435	13	* accompanied this code).
duke@435	14	*
duke@435	15	* You should have received a copy of the GNU General Public License version
duke@435	16	* 2 along with this work; if not, write to the Free Software Foundation,
duke@435	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435	18	*
duke@435	19	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@435	20	* CA 95054 USA or visit www.sun.com if you need additional information or
duke@435	21	* have any questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
duke@435	25	// A vframeArray is an array used for momentarily storing off stack Java method activations
duke@435	26	// during deoptimization. Essentially it is an array of vframes where each vframe
duke@435	27	// data is stored off stack. This structure will never exist across a safepoint so
duke@435	28	// there is no need to gc any oops that are stored in the structure.
duke@435	29
duke@435	30
duke@435	31	class LocalsClosure;
duke@435	32	class ExpressionStackClosure;
duke@435	33	class MonitorStackClosure;
duke@435	34	class MonitorArrayElement;
duke@435	35	class StackValueCollection;
duke@435	36
duke@435	37	// A vframeArrayElement is an element of a vframeArray. Each element
duke@435	38	// represent an interpreter frame which will eventually be created.
duke@435	39
duke@435	40	class vframeArrayElement : public _ValueObj {
duke@435	41	private:
duke@435	42
duke@435	43	frame _frame; // the interpreter frame we will unpack into
duke@435	44	int _bci; // raw bci for this vframe
duke@435	45	methodOop _method; // the method for this vframe
duke@435	46	MonitorChunk* _monitors; // active monitors for this vframe
duke@435	47	StackValueCollection* _locals;
duke@435	48	StackValueCollection* _expressions;
duke@435	49
duke@435	50	public:
duke@435	51
duke@435	52	frame* iframe(void) { return &_frame; }
duke@435	53
duke@435	54	int bci(void) const;
duke@435	55
duke@435	56	int raw_bci(void) const { return _bci; }
duke@435	57
duke@435	58	methodOop method(void) const { return _method; }
duke@435	59
duke@435	60	MonitorChunk* monitors(void) const { return _monitors; }
duke@435	61
duke@435	62	void free_monitors(JavaThread* jt);
duke@435	63
duke@435	64	StackValueCollection* locals(void) const { return _locals; }
duke@435	65
duke@435	66	StackValueCollection* expressions(void) const { return _expressions; }
duke@435	67
duke@435	68	void fill_in(compiledVFrame* vf);
duke@435	69
duke@435	70	// Formerly part of deoptimizedVFrame
duke@435	71
duke@435	72
duke@435	73	// Returns the on stack word size for this frame
duke@435	74	// callee_parameters is the number of callee locals residing inside this frame
duke@435	75	int on_stack_size(int callee_parameters,
duke@435	76	int callee_locals,
duke@435	77	bool is_top_frame,
duke@435	78	int popframe_extra_stack_expression_els) const;
duke@435	79
duke@435	80	// Unpacks the element to skeletal interpreter frame
duke@435	81	void unpack_on_stack(int callee_parameters,
duke@435	82	int callee_locals,
duke@435	83	frame* caller,
duke@435	84	bool is_top_frame,
duke@435	85	int exec_mode);
duke@435	86
duke@435	87	#ifndef PRODUCT
duke@435	88	void print(outputStream* st);
duke@435	89	#endif /* PRODUCT */
duke@435	90	};
duke@435	91
duke@435	92	// this can be a ResourceObj if we don't save the last one...
duke@435	93	// but it does make debugging easier even if we can't look
duke@435	94	// at the data in each vframeElement
duke@435	95
duke@435	96	class vframeArray: public CHeapObj {
duke@435	97	private:
duke@435	98
duke@435	99
duke@435	100	// Here is what a vframeArray looks like in memory
duke@435	101
duke@435	102	/*
duke@435	103	fixed part
duke@435	104	description of the original frame
duke@435	105	_frames - number of vframes in this array
duke@435	106	adapter info
duke@435	107	callee register save area
duke@435	108	variable part
duke@435	109	vframeArrayElement [ 0 ]
duke@435	110	...
duke@435	111	vframeArrayElement [_frames - 1]
duke@435	112
duke@435	113	*/
duke@435	114
duke@435	115	JavaThread* _owner_thread;
duke@435	116	vframeArray* _next;
duke@435	117	frame _original; // the original frame of the deoptee
duke@435	118	frame _caller; // caller of root frame in vframeArray
duke@435	119	frame _sender;
duke@435	120
duke@435	121	Deoptimization::UnrollBlock* _unroll_block;
duke@435	122	int _frame_size;
duke@435	123
duke@435	124	int _frames; // number of javavframes in the array (does not count any adapter)
duke@435	125
duke@435	126	intptr_t _callee_registers[RegisterMap::reg_count];
duke@435	127	unsigned char _valid[RegisterMap::reg_count];
duke@435	128
duke@435	129	vframeArrayElement _elements[1]; // First variable section.
duke@435	130
duke@435	131	void fill_in_element(int index, compiledVFrame* vf);
duke@435	132
duke@435	133	bool is_location_valid(int i) const { return _valid[i] != 0; }
duke@435	134	void set_location_valid(int i, bool valid) { _valid[i] = valid; }
duke@435	135
duke@435	136	public:
duke@435	137
duke@435	138
duke@435	139	// Tells whether index is within bounds.
duke@435	140	bool is_within_bounds(int index) const { return 0 <= index && index < frames(); }
duke@435	141
duke@435	142	// Accessores for instance variable
duke@435	143	int frames() const { return _frames; }
duke@435	144
duke@435	145	static vframeArray* allocate(JavaThread* thread, int frame_size, GrowableArray<compiledVFrame*>* chunk,
duke@435	146	RegisterMap* reg_map, frame sender, frame caller, frame self);
duke@435	147
duke@435	148
duke@435	149	vframeArrayElement* element(int index) { assert(is_within_bounds(index), "Bad index"); return &_elements[index]; }
duke@435	150
duke@435	151	// Allocates a new vframe in the array and fills the array with vframe information in chunk
duke@435	152	void fill_in(JavaThread* thread, int frame_size, GrowableArray<compiledVFrame*>* chunk, const RegisterMap *reg_map);
duke@435	153
duke@435	154	// Returns the owner of this vframeArray
duke@435	155	JavaThread* owner_thread() const { return _owner_thread; }
duke@435	156
duke@435	157	// Accessors for next
duke@435	158	vframeArray* next() const { return _next; }
duke@435	159	void set_next(vframeArray* value) { _next = value; }
duke@435	160
duke@435	161	// Accessors for sp
duke@435	162	intptr_t* sp() const { return _original.sp(); }
duke@435	163
duke@435	164	intptr_t* unextended_sp() const { return _original.unextended_sp(); }
duke@435	165
duke@435	166	address original_pc() const { return _original.pc(); }
duke@435	167
duke@435	168	frame original() const { return _original; }
duke@435	169
duke@435	170	frame caller() const { return _caller; }
duke@435	171
duke@435	172	frame sender() const { return _sender; }
duke@435	173
duke@435	174	// Accessors for unroll block
duke@435	175	Deoptimization::UnrollBlock* unroll_block() const { return _unroll_block; }
duke@435	176	void set_unroll_block(Deoptimization::UnrollBlock* block) { _unroll_block = block; }
duke@435	177
duke@435	178	// Returns the size of the frame that got deoptimized
duke@435	179	int frame_size() const { return _frame_size; }
duke@435	180
duke@435	181	// Unpack the array on the stack passed in stack interval
duke@435	182	void unpack_to_stack(frame &unpack_frame, int exec_mode);
duke@435	183
duke@435	184	// Deallocates monitor chunks allocated during deoptimization.
duke@435	185	// This should be called when the array is not used anymore.
duke@435	186	void deallocate_monitor_chunks();
duke@435	187
duke@435	188
duke@435	189
duke@435	190	// Accessor for register map
duke@435	191	address register_location(int i) const;
duke@435	192
duke@435	193	void print_on_2(outputStream* st) PRODUCT_RETURN;
duke@435	194	void print_value_on(outputStream* st) const PRODUCT_RETURN;
duke@435	195
duke@435	196	#ifndef PRODUCT
duke@435	197	// Comparing
duke@435	198	bool structural_compare(JavaThread* thread, GrowableArray<compiledVFrame*>* chunk);
duke@435	199	#endif
duke@435	200
duke@435	201	};