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

src/share/vm/c1/c1_ValueStack.hpp@59766fd005ff (annotated)

src/share/vm/c1/c1_ValueStack.hpp

Wed, 13 Apr 2011 17:56:43 -0700

author

johnc

date

Wed, 13 Apr 2011 17:56:43 -0700

changeset 2786

59766fd005ff

parent 2314

f95d63e2154a

child 3969

1d7922586cf6

permissions

-rw-r--r--

7035117: G1: nsk/stress/jni/jnistress002 fails with assertion failure
Summary: Allow long type for offset in G1 code in compiler implementations of Unsafe.getObject
Reviewed-by: never, iveresov

duke@435	1	/*
stefank@2314	2	* Copyright (c) 1999, 2010, Oracle and/or its affiliates. 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	*
trims@1907	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907	20	* or visit www.oracle.com if you need additional information or have any
trims@1907	21	* questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
stefank@2314	25	#ifndef SHARE_VM_C1_C1_VALUESTACK_HPP
stefank@2314	26	#define SHARE_VM_C1_C1_VALUESTACK_HPP
stefank@2314	27
stefank@2314	28	#include "c1/c1_Instruction.hpp"
stefank@2314	29
duke@435	30	class ValueStack: public CompilationResourceObj {
roland@2174	31	public:
roland@2174	32	enum Kind {
roland@2174	33	Parsing, // During abstract interpretation in GraphBuilder
roland@2174	34	CallerState, // Caller state when inlining
roland@2174	35	StateBefore, // Before before execution of instruction
roland@2174	36	StateAfter, // After execution of instruction
roland@2174	37	ExceptionState, // Exception handling of instruction
roland@2174	38	EmptyExceptionState, // Exception handling of instructions not covered by an xhandler
roland@2174	39	BlockBeginState // State of BlockBegin instruction with phi functions of this block
roland@2174	40	};
roland@2174	41
duke@435	42	private:
duke@435	43	IRScope* _scope; // the enclosing scope
roland@2174	44	ValueStack* _caller_state;
roland@2174	45	int _bci;
roland@2174	46	Kind _kind;
roland@2174	47
duke@435	48	Values _locals; // the locals
duke@435	49	Values _stack; // the expression stack
duke@435	50	Values _locks; // the monitor stack (holding the locked values)
duke@435	51
duke@435	52	Value check(ValueTag tag, Value t) {
duke@435	53	assert(tag == t->type()->tag() || tag == objectTag && t->type()->tag() == addressTag, "types must correspond");
duke@435	54	return t;
duke@435	55	}
duke@435	56
duke@435	57	Value check(ValueTag tag, Value t, Value h) {
roland@2174	58	assert(h == NULL, "hi-word of doubleword value must be NULL");
duke@435	59	return check(tag, t);
duke@435	60	}
duke@435	61
duke@435	62	// helper routine
iveresov@1939	63	static void apply(Values list, ValueVisitor* f);
duke@435	64
roland@2174	65	// for simplified copying
roland@2174	66	ValueStack(ValueStack* copy_from, Kind kind, int bci);
roland@2174	67
duke@435	68	public:
duke@435	69	// creation
roland@2174	70	ValueStack(IRScope* scope, ValueStack* caller_state);
duke@435	71
roland@2174	72	ValueStack* copy() { return new ValueStack(this, _kind, _bci); }
roland@2174	73	ValueStack* copy(Kind new_kind, int new_bci) { return new ValueStack(this, new_kind, new_bci); }
roland@2174	74	ValueStack* copy_for_parsing() { return new ValueStack(this, Parsing, -99); }
roland@2174	75
never@2177	76	void set_caller_state(ValueStack* s) {
never@2177	77	assert(kind() == EmptyExceptionState ||
never@2177	78	(Compilation::current()->env()->jvmti_can_access_local_variables() && kind() == ExceptionState),
never@2177	79	"only EmptyExceptionStates can be modified");
never@2177	80	_caller_state = s;
never@2177	81	}
roland@2174	82
duke@435	83	bool is_same(ValueStack* s); // returns true if this & s's types match (w/o checking locals)
duke@435	84
duke@435	85	// accessors
duke@435	86	IRScope* scope() const { return _scope; }
roland@2174	87	ValueStack* caller_state() const { return _caller_state; }
roland@2174	88	int bci() const { return _bci; }
roland@2174	89	Kind kind() const { return _kind; }
roland@2174	90
duke@435	91	int locals_size() const { return _locals.length(); }
duke@435	92	int stack_size() const { return _stack.length(); }
duke@435	93	int locks_size() const { return _locks.length(); }
duke@435	94	bool stack_is_empty() const { return _stack.is_empty(); }
duke@435	95	bool no_active_locks() const { return _locks.is_empty(); }
roland@2174	96	int total_locks_size() const;
duke@435	97
duke@435	98	// locals access
duke@435	99	void clear_locals(); // sets all locals to NULL;
duke@435	100
duke@435	101	void invalidate_local(int i) {
roland@2174	102	assert(_locals.at(i)->type()->is_single_word() ||
roland@2174	103	_locals.at(i + 1) == NULL, "hi-word of doubleword value must be NULL");
duke@435	104	_locals.at_put(i, NULL);
duke@435	105	}
duke@435	106
roland@2174	107	Value local_at(int i) const {
duke@435	108	Value x = _locals.at(i);
roland@2174	109	assert(x == NULL || x->type()->is_single_word() ||
roland@2174	110	_locals.at(i + 1) == NULL, "hi-word of doubleword value must be NULL");
duke@435	111	return x;
duke@435	112	}
duke@435	113
duke@435	114	void store_local(int i, Value x) {
roland@2174	115	// When overwriting local i, check if i - 1 was the start of a
roland@2174	116	// double word local and kill it.
duke@435	117	if (i > 0) {
duke@435	118	Value prev = _locals.at(i - 1);
duke@435	119	if (prev != NULL && prev->type()->is_double_word()) {
duke@435	120	_locals.at_put(i - 1, NULL);
duke@435	121	}
duke@435	122	}
roland@2174	123
roland@2174	124	_locals.at_put(i, x);
roland@2174	125	if (x->type()->is_double_word()) {
roland@2174	126	// hi-word of doubleword value is always NULL
roland@2174	127	_locals.at_put(i + 1, NULL);
roland@2174	128	}
duke@435	129	}
duke@435	130
duke@435	131	// stack access
duke@435	132	Value stack_at(int i) const {
duke@435	133	Value x = _stack.at(i);
duke@435	134	assert(x->type()->is_single_word() ||
roland@2174	135	_stack.at(i + 1) == NULL, "hi-word of doubleword value must be NULL");
duke@435	136	return x;
duke@435	137	}
duke@435	138
duke@435	139	Value stack_at_inc(int& i) const {
duke@435	140	Value x = stack_at(i);
duke@435	141	i += x->type()->size();
duke@435	142	return x;
duke@435	143	}
duke@435	144
duke@435	145	// pinning support
duke@435	146	void pin_stack_for_linear_scan();
duke@435	147
duke@435	148	// iteration
iveresov@1939	149	void values_do(ValueVisitor* f);
duke@435	150
duke@435	151	// untyped manipulation (for dup_x1, etc.)
duke@435	152	void truncate_stack(int size) { _stack.trunc_to(size); }
duke@435	153	void raw_push(Value t) { _stack.push(t); }
duke@435	154	Value raw_pop() { return _stack.pop(); }
duke@435	155
duke@435	156	// typed manipulation
duke@435	157	void ipush(Value t) { _stack.push(check(intTag , t)); }
duke@435	158	void fpush(Value t) { _stack.push(check(floatTag , t)); }
duke@435	159	void apush(Value t) { _stack.push(check(objectTag , t)); }
duke@435	160	void rpush(Value t) { _stack.push(check(addressTag, t)); }
duke@435	161	void lpush(Value t) { _stack.push(check(longTag , t)); _stack.push(NULL); }
duke@435	162	void dpush(Value t) { _stack.push(check(doubleTag , t)); _stack.push(NULL); }
duke@435	163
duke@435	164	void push(ValueType* type, Value t) {
duke@435	165	switch (type->tag()) {
duke@435	166	case intTag : ipush(t); return;
duke@435	167	case longTag : lpush(t); return;
duke@435	168	case floatTag : fpush(t); return;
duke@435	169	case doubleTag : dpush(t); return;
duke@435	170	case objectTag : apush(t); return;
duke@435	171	case addressTag: rpush(t); return;
duke@435	172	}
duke@435	173	ShouldNotReachHere();
duke@435	174	}
duke@435	175
duke@435	176	Value ipop() { return check(intTag , _stack.pop()); }
duke@435	177	Value fpop() { return check(floatTag , _stack.pop()); }
duke@435	178	Value apop() { return check(objectTag , _stack.pop()); }
duke@435	179	Value rpop() { return check(addressTag, _stack.pop()); }
duke@435	180	Value lpop() { Value h = _stack.pop(); return check(longTag , _stack.pop(), h); }
duke@435	181	Value dpop() { Value h = _stack.pop(); return check(doubleTag, _stack.pop(), h); }
duke@435	182
duke@435	183	Value pop(ValueType* type) {
duke@435	184	switch (type->tag()) {
duke@435	185	case intTag : return ipop();
duke@435	186	case longTag : return lpop();
duke@435	187	case floatTag : return fpop();
duke@435	188	case doubleTag : return dpop();
duke@435	189	case objectTag : return apop();
duke@435	190	case addressTag: return rpop();
duke@435	191	}
duke@435	192	ShouldNotReachHere();
duke@435	193	return NULL;
duke@435	194	}
duke@435	195
duke@435	196	Values* pop_arguments(int argument_size);
duke@435	197
duke@435	198	// locks access
roland@2174	199	int lock (Value obj);
duke@435	200	int unlock();
duke@435	201	Value lock_at(int i) const { return _locks.at(i); }
duke@435	202
duke@435	203	// SSA form IR support
duke@435	204	void setup_phi_for_stack(BlockBegin* b, int index);
duke@435	205	void setup_phi_for_local(BlockBegin* b, int index);
duke@435	206
duke@435	207	// debugging
duke@435	208	void print() PRODUCT_RETURN;
duke@435	209	void verify() PRODUCT_RETURN;
duke@435	210	};
duke@435	211
duke@435	212
duke@435	213
duke@435	214	// Macro definitions for simple iteration of stack and local values of a ValueStack
duke@435	215	// The macros can be used like a for-loop. All variables (state, index and value)
duke@435	216	// must be defined before the loop.
duke@435	217	// When states are nested because of inlining, the stack of the innermost state
duke@435	218	// cumulates also the stack of the nested states. In contrast, the locals of all
duke@435	219	// states must be iterated each.
duke@435	220	// Use the following code pattern to iterate all stack values and all nested local values:
duke@435	221	//
duke@435	222	// ValueStack* state = ... // state that is iterated
duke@435	223	// int index; // current loop index (overwritten in loop)
duke@435	224	// Value value; // value at current loop index (overwritten in loop)
duke@435	225	//
duke@435	226	// for_each_stack_value(state, index, value {
duke@435	227	// do something with value and index
duke@435	228	// }
duke@435	229	//
duke@435	230	// for_each_state(state) {
duke@435	231	// for_each_local_value(state, index, value) {
duke@435	232	// do something with value and index
duke@435	233	// }
duke@435	234	// }
duke@435	235	// as an invariant, state is NULL now
duke@435	236
duke@435	237
duke@435	238	// construct a unique variable name with the line number where the macro is used
duke@435	239	#define temp_var3(x) temp__ ## x
duke@435	240	#define temp_var2(x) temp_var3(x)
duke@435	241	#define temp_var temp_var2(__LINE__)
duke@435	242
duke@435	243	#define for_each_state(state) \
duke@435	244	for (; state != NULL; state = state->caller_state())
duke@435	245
duke@435	246	#define for_each_local_value(state, index, value) \
duke@435	247	int temp_var = state->locals_size(); \
duke@435	248	for (index = 0; \
duke@435	249	index < temp_var && (value = state->local_at(index), true); \
duke@435	250	index += (value == NULL || value->type()->is_illegal() ? 1 : value->type()->size())) \
duke@435	251	if (value != NULL)
duke@435	252
duke@435	253
duke@435	254	#define for_each_stack_value(state, index, value) \
duke@435	255	int temp_var = state->stack_size(); \
duke@435	256	for (index = 0; \
duke@435	257	index < temp_var && (value = state->stack_at(index), true); \
duke@435	258	index += value->type()->size())
duke@435	259
duke@435	260
duke@435	261	#define for_each_lock_value(state, index, value) \
duke@435	262	int temp_var = state->locks_size(); \
duke@435	263	for (index = 0; \
duke@435	264	index < temp_var && (value = state->lock_at(index), true); \
duke@435	265	index++) \
duke@435	266	if (value != NULL)
duke@435	267
duke@435	268
duke@435	269	// Macro definition for simple iteration of all state values of a ValueStack
duke@435	270	// Because the code cannot be executed in a single loop, the code must be passed
duke@435	271	// as a macro parameter.
duke@435	272	// Use the following code pattern to iterate all stack values and all nested local values:
duke@435	273	//
duke@435	274	// ValueStack* state = ... // state that is iterated
duke@435	275	// for_each_state_value(state, value,
duke@435	276	// do something with value (note that this is a macro parameter)
duke@435	277	// );
duke@435	278
duke@435	279	#define for_each_state_value(v_state, v_value, v_code) \
duke@435	280	{ \
duke@435	281	int cur_index; \
duke@435	282	ValueStack* cur_state = v_state; \
roland@2174	283	Value v_value; \
roland@2174	284	for_each_state(cur_state) { \
roland@2174	285	{ \
roland@2174	286	for_each_local_value(cur_state, cur_index, v_value) { \
roland@2174	287	v_code; \
roland@2174	288	} \
duke@435	289	} \
roland@2174	290	{ \
roland@2174	291	for_each_stack_value(cur_state, cur_index, v_value) { \
roland@2174	292	v_code; \
roland@2174	293	} \
roland@2174	294	} \
duke@435	295	} \
duke@435	296	}
duke@435	297
duke@435	298
duke@435	299	// Macro definition for simple iteration of all phif functions of a block, i.e all
duke@435	300	// phi functions of the ValueStack where the block matches.
duke@435	301	// Use the following code pattern to iterate all phi functions of a block:
duke@435	302	//
duke@435	303	// BlockBegin* block = ... // block that is iterated
duke@435	304	// for_each_phi_function(block, phi,
duke@435	305	// do something with the phi function phi (note that this is a macro parameter)
duke@435	306	// );
duke@435	307
duke@435	308	#define for_each_phi_fun(v_block, v_phi, v_code) \
duke@435	309	{ \
duke@435	310	int cur_index; \
duke@435	311	ValueStack* cur_state = v_block->state(); \
duke@435	312	Value value; \
duke@435	313	{ \
duke@435	314	for_each_stack_value(cur_state, cur_index, value) { \
duke@435	315	Phi* v_phi = value->as_Phi(); \
duke@435	316	if (v_phi != NULL && v_phi->block() == v_block) { \
duke@435	317	v_code; \
duke@435	318	} \
duke@435	319	} \
duke@435	320	} \
duke@435	321	{ \
duke@435	322	for_each_local_value(cur_state, cur_index, value) { \
duke@435	323	Phi* v_phi = value->as_Phi(); \
duke@435	324	if (v_phi != NULL && v_phi->block() == v_block) { \
duke@435	325	v_code; \
duke@435	326	} \
duke@435	327	} \
duke@435	328	} \
duke@435	329	}
stefank@2314	330
stefank@2314	331	#endif // SHARE_VM_C1_C1_VALUESTACK_HPP