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

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

src/share/vm/c1/c1_ValueStack.hpp

Tue, 24 Feb 2015 15:04:52 -0500

author

dlong

date

Tue, 24 Feb 2015 15:04:52 -0500

changeset 7598

ddce0b7cee93

parent 4153

b9a9ed0f8eeb

child 6876

710a3c8b516e

child 9942

eddd586d1a4c

permissions

-rw-r--r--

8072383: resolve conflicts between open and closed ports
Summary: refactor close to remove references to closed ports
Reviewed-by: kvn, simonis, sgehwolf, dholmes

duke@435	1	/*
mikael@4153	2	* Copyright (c) 1999, 2012, 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
twisti@3969	145	void stack_at_put(int i, Value x) {
twisti@3969	146	_stack.at_put(i, x);
twisti@3969	147	}
twisti@3969	148
duke@435	149	// pinning support
duke@435	150	void pin_stack_for_linear_scan();
duke@435	151
duke@435	152	// iteration
iveresov@1939	153	void values_do(ValueVisitor* f);
duke@435	154
duke@435	155	// untyped manipulation (for dup_x1, etc.)
duke@435	156	void truncate_stack(int size) { _stack.trunc_to(size); }
duke@435	157	void raw_push(Value t) { _stack.push(t); }
duke@435	158	Value raw_pop() { return _stack.pop(); }
duke@435	159
duke@435	160	// typed manipulation
duke@435	161	void ipush(Value t) { _stack.push(check(intTag , t)); }
duke@435	162	void fpush(Value t) { _stack.push(check(floatTag , t)); }
duke@435	163	void apush(Value t) { _stack.push(check(objectTag , t)); }
duke@435	164	void rpush(Value t) { _stack.push(check(addressTag, t)); }
duke@435	165	void lpush(Value t) { _stack.push(check(longTag , t)); _stack.push(NULL); }
duke@435	166	void dpush(Value t) { _stack.push(check(doubleTag , t)); _stack.push(NULL); }
duke@435	167
duke@435	168	void push(ValueType* type, Value t) {
duke@435	169	switch (type->tag()) {
duke@435	170	case intTag : ipush(t); return;
duke@435	171	case longTag : lpush(t); return;
duke@435	172	case floatTag : fpush(t); return;
duke@435	173	case doubleTag : dpush(t); return;
duke@435	174	case objectTag : apush(t); return;
duke@435	175	case addressTag: rpush(t); return;
duke@435	176	}
duke@435	177	ShouldNotReachHere();
duke@435	178	}
duke@435	179
duke@435	180	Value ipop() { return check(intTag , _stack.pop()); }
duke@435	181	Value fpop() { return check(floatTag , _stack.pop()); }
duke@435	182	Value apop() { return check(objectTag , _stack.pop()); }
duke@435	183	Value rpop() { return check(addressTag, _stack.pop()); }
duke@435	184	Value lpop() { Value h = _stack.pop(); return check(longTag , _stack.pop(), h); }
duke@435	185	Value dpop() { Value h = _stack.pop(); return check(doubleTag, _stack.pop(), h); }
duke@435	186
duke@435	187	Value pop(ValueType* type) {
duke@435	188	switch (type->tag()) {
duke@435	189	case intTag : return ipop();
duke@435	190	case longTag : return lpop();
duke@435	191	case floatTag : return fpop();
duke@435	192	case doubleTag : return dpop();
duke@435	193	case objectTag : return apop();
duke@435	194	case addressTag: return rpop();
duke@435	195	}
duke@435	196	ShouldNotReachHere();
duke@435	197	return NULL;
duke@435	198	}
duke@435	199
duke@435	200	Values* pop_arguments(int argument_size);
duke@435	201
duke@435	202	// locks access
roland@2174	203	int lock (Value obj);
duke@435	204	int unlock();
duke@435	205	Value lock_at(int i) const { return _locks.at(i); }
duke@435	206
duke@435	207	// SSA form IR support
duke@435	208	void setup_phi_for_stack(BlockBegin* b, int index);
duke@435	209	void setup_phi_for_local(BlockBegin* b, int index);
duke@435	210
duke@435	211	// debugging
duke@435	212	void print() PRODUCT_RETURN;
duke@435	213	void verify() PRODUCT_RETURN;
duke@435	214	};
duke@435	215
duke@435	216
duke@435	217
duke@435	218	// Macro definitions for simple iteration of stack and local values of a ValueStack
duke@435	219	// The macros can be used like a for-loop. All variables (state, index and value)
duke@435	220	// must be defined before the loop.
duke@435	221	// When states are nested because of inlining, the stack of the innermost state
duke@435	222	// cumulates also the stack of the nested states. In contrast, the locals of all
duke@435	223	// states must be iterated each.
duke@435	224	// Use the following code pattern to iterate all stack values and all nested local values:
duke@435	225	//
duke@435	226	// ValueStack* state = ... // state that is iterated
duke@435	227	// int index; // current loop index (overwritten in loop)
duke@435	228	// Value value; // value at current loop index (overwritten in loop)
duke@435	229	//
duke@435	230	// for_each_stack_value(state, index, value {
duke@435	231	// do something with value and index
duke@435	232	// }
duke@435	233	//
duke@435	234	// for_each_state(state) {
duke@435	235	// for_each_local_value(state, index, value) {
duke@435	236	// do something with value and index
duke@435	237	// }
duke@435	238	// }
duke@435	239	// as an invariant, state is NULL now
duke@435	240
duke@435	241
duke@435	242	// construct a unique variable name with the line number where the macro is used
duke@435	243	#define temp_var3(x) temp__ ## x
duke@435	244	#define temp_var2(x) temp_var3(x)
duke@435	245	#define temp_var temp_var2(__LINE__)
duke@435	246
duke@435	247	#define for_each_state(state) \
duke@435	248	for (; state != NULL; state = state->caller_state())
duke@435	249
duke@435	250	#define for_each_local_value(state, index, value) \
duke@435	251	int temp_var = state->locals_size(); \
duke@435	252	for (index = 0; \
duke@435	253	index < temp_var && (value = state->local_at(index), true); \
duke@435	254	index += (value == NULL || value->type()->is_illegal() ? 1 : value->type()->size())) \
duke@435	255	if (value != NULL)
duke@435	256
duke@435	257
duke@435	258	#define for_each_stack_value(state, index, value) \
duke@435	259	int temp_var = state->stack_size(); \
duke@435	260	for (index = 0; \
duke@435	261	index < temp_var && (value = state->stack_at(index), true); \
duke@435	262	index += value->type()->size())
duke@435	263
duke@435	264
duke@435	265	#define for_each_lock_value(state, index, value) \
duke@435	266	int temp_var = state->locks_size(); \
duke@435	267	for (index = 0; \
duke@435	268	index < temp_var && (value = state->lock_at(index), true); \
duke@435	269	index++) \
duke@435	270	if (value != NULL)
duke@435	271
duke@435	272
duke@435	273	// Macro definition for simple iteration of all state values of a ValueStack
duke@435	274	// Because the code cannot be executed in a single loop, the code must be passed
duke@435	275	// as a macro parameter.
duke@435	276	// Use the following code pattern to iterate all stack values and all nested local values:
duke@435	277	//
duke@435	278	// ValueStack* state = ... // state that is iterated
duke@435	279	// for_each_state_value(state, value,
duke@435	280	// do something with value (note that this is a macro parameter)
duke@435	281	// );
duke@435	282
duke@435	283	#define for_each_state_value(v_state, v_value, v_code) \
duke@435	284	{ \
duke@435	285	int cur_index; \
duke@435	286	ValueStack* cur_state = v_state; \
roland@2174	287	Value v_value; \
roland@2174	288	for_each_state(cur_state) { \
roland@2174	289	{ \
roland@2174	290	for_each_local_value(cur_state, cur_index, v_value) { \
roland@2174	291	v_code; \
roland@2174	292	} \
duke@435	293	} \
roland@2174	294	{ \
roland@2174	295	for_each_stack_value(cur_state, cur_index, v_value) { \
roland@2174	296	v_code; \
roland@2174	297	} \
roland@2174	298	} \
duke@435	299	} \
duke@435	300	}
duke@435	301
duke@435	302
duke@435	303	// Macro definition for simple iteration of all phif functions of a block, i.e all
duke@435	304	// phi functions of the ValueStack where the block matches.
duke@435	305	// Use the following code pattern to iterate all phi functions of a block:
duke@435	306	//
duke@435	307	// BlockBegin* block = ... // block that is iterated
duke@435	308	// for_each_phi_function(block, phi,
duke@435	309	// do something with the phi function phi (note that this is a macro parameter)
duke@435	310	// );
duke@435	311
duke@435	312	#define for_each_phi_fun(v_block, v_phi, v_code) \
duke@435	313	{ \
duke@435	314	int cur_index; \
duke@435	315	ValueStack* cur_state = v_block->state(); \
duke@435	316	Value value; \
duke@435	317	{ \
duke@435	318	for_each_stack_value(cur_state, cur_index, value) { \
duke@435	319	Phi* v_phi = value->as_Phi(); \
duke@435	320	if (v_phi != NULL && v_phi->block() == v_block) { \
duke@435	321	v_code; \
duke@435	322	} \
duke@435	323	} \
duke@435	324	} \
duke@435	325	{ \
duke@435	326	for_each_local_value(cur_state, cur_index, value) { \
duke@435	327	Phi* v_phi = value->as_Phi(); \
duke@435	328	if (v_phi != NULL && v_phi->block() == v_block) { \
duke@435	329	v_code; \
duke@435	330	} \
duke@435	331	} \
duke@435	332	} \
duke@435	333	}
stefank@2314	334
stefank@2314	335	#endif // SHARE_VM_C1_C1_VALUESTACK_HPP