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

src/share/vm/c1/c1_GraphBuilder.hpp@a61af66fc99e (annotated)

src/share/vm/c1/c1_GraphBuilder.hpp

Sat, 01 Dec 2007 00:00:00 +0000

author

duke

date

Sat, 01 Dec 2007 00:00:00 +0000

changeset 435

a61af66fc99e

child 894

3a86a8dcf27c

permissions

-rw-r--r--

Initial load

duke@435	1	/*
duke@435	2	* Copyright 1999-2006 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	class MemoryBuffer;
duke@435	26
duke@435	27	class GraphBuilder VALUE_OBJ_CLASS_SPEC {
duke@435	28	private:
duke@435	29	// Per-scope data. These are pushed and popped as we descend into
duke@435	30	// inlined methods. Currently in order to generate good code in the
duke@435	31	// inliner we have to attempt to inline methods directly into the
duke@435	32	// basic block we are parsing; this adds complexity.
duke@435	33	class ScopeData: public CompilationResourceObj {
duke@435	34	private:
duke@435	35	ScopeData* _parent;
duke@435	36	// bci-to-block mapping
duke@435	37	BlockList* _bci2block;
duke@435	38	// Scope
duke@435	39	IRScope* _scope;
duke@435	40	// Whether this scope or any parent scope has exception handlers
duke@435	41	bool _has_handler;
duke@435	42	// The bytecodes
duke@435	43	ciBytecodeStream* _stream;
duke@435	44
duke@435	45	// Work list
duke@435	46	BlockList* _work_list;
duke@435	47
duke@435	48	// Maximum inline size for this scope
duke@435	49	intx _max_inline_size;
duke@435	50	// Expression stack depth at point where inline occurred
duke@435	51	int _caller_stack_size;
duke@435	52
duke@435	53	// The continuation point for the inline. Currently only used in
duke@435	54	// multi-block inlines, but eventually would like to use this for
duke@435	55	// all inlines for uniformity and simplicity; in this case would
duke@435	56	// get the continuation point from the BlockList instead of
duke@435	57	// fabricating it anew because Invokes would be considered to be
duke@435	58	// BlockEnds.
duke@435	59	BlockBegin* _continuation;
duke@435	60
duke@435	61	// Without return value of inlined method on stack
duke@435	62	ValueStack* _continuation_state;
duke@435	63
duke@435	64	// Was this ScopeData created only for the parsing and inlining of
duke@435	65	// a jsr?
duke@435	66	bool _parsing_jsr;
duke@435	67	// We track the destination bci of the jsr only to determine
duke@435	68	// bailout conditions, since we only handle a subset of all of the
duke@435	69	// possible jsr-ret control structures. Recursive invocations of a
duke@435	70	// jsr are disallowed by the verifier.
duke@435	71	int _jsr_entry_bci;
duke@435	72	// We need to track the local variable in which the return address
duke@435	73	// was stored to ensure we can handle inlining the jsr, because we
duke@435	74	// don't handle arbitrary jsr/ret constructs.
duke@435	75	int _jsr_ret_addr_local;
duke@435	76	// If we are parsing a jsr, the continuation point for rets
duke@435	77	BlockBegin* _jsr_continuation;
duke@435	78	// Cloned XHandlers for jsr-related ScopeDatas
duke@435	79	XHandlers* _jsr_xhandlers;
duke@435	80
duke@435	81	// Number of returns seen in this scope
duke@435	82	int _num_returns;
duke@435	83
duke@435	84	// In order to generate profitable code for inlining, we currently
duke@435	85	// have to perform an optimization for single-block inlined
duke@435	86	// methods where we continue parsing into the same block. This
duke@435	87	// allows us to perform CSE across inlined scopes and to avoid
duke@435	88	// storing parameters to the stack. Having a global register
duke@435	89	// allocator and being able to perform global CSE would allow this
duke@435	90	// code to be removed and thereby simplify the inliner.
duke@435	91	BlockBegin* _cleanup_block; // The block to which the return was added
duke@435	92	Instruction* _cleanup_return_prev; // Instruction before return instruction
duke@435	93	ValueStack* _cleanup_state; // State of that block (not yet pinned)
duke@435	94
duke@435	95	public:
duke@435	96	ScopeData(ScopeData* parent);
duke@435	97
duke@435	98	ScopeData* parent() const { return _parent; }
duke@435	99
duke@435	100	BlockList* bci2block() const { return _bci2block; }
duke@435	101	void set_bci2block(BlockList* bci2block) { _bci2block = bci2block; }
duke@435	102
duke@435	103	// NOTE: this has a different effect when parsing jsrs
duke@435	104	BlockBegin* block_at(int bci);
duke@435	105
duke@435	106	IRScope* scope() const { return _scope; }
duke@435	107	// Has side-effect of setting has_handler flag
duke@435	108	void set_scope(IRScope* scope);
duke@435	109
duke@435	110	// Whether this or any parent scope has exception handlers
duke@435	111	bool has_handler() const { return _has_handler; }
duke@435	112	void set_has_handler() { _has_handler = true; }
duke@435	113
duke@435	114	// Exception handlers list to be used for this scope
duke@435	115	XHandlers* xhandlers() const;
duke@435	116
duke@435	117	// How to get a block to be parsed
duke@435	118	void add_to_work_list(BlockBegin* block);
duke@435	119	// How to remove the next block to be parsed; returns NULL if none left
duke@435	120	BlockBegin* remove_from_work_list();
duke@435	121	// Indicates parse is over
duke@435	122	bool is_work_list_empty() const;
duke@435	123
duke@435	124	ciBytecodeStream* stream() { return _stream; }
duke@435	125	void set_stream(ciBytecodeStream* stream) { _stream = stream; }
duke@435	126
duke@435	127	intx max_inline_size() const { return _max_inline_size; }
duke@435	128	int caller_stack_size() const;
duke@435	129
duke@435	130	BlockBegin* continuation() const { return _continuation; }
duke@435	131	void set_continuation(BlockBegin* cont) { _continuation = cont; }
duke@435	132
duke@435	133	ValueStack* continuation_state() const { return _continuation_state; }
duke@435	134	void set_continuation_state(ValueStack* s) { _continuation_state = s; }
duke@435	135
duke@435	136	// Indicates whether this ScopeData was pushed only for the
duke@435	137	// parsing and inlining of a jsr
duke@435	138	bool parsing_jsr() const { return _parsing_jsr; }
duke@435	139	void set_parsing_jsr() { _parsing_jsr = true; }
duke@435	140	int jsr_entry_bci() const { return _jsr_entry_bci; }
duke@435	141	void set_jsr_entry_bci(int bci) { _jsr_entry_bci = bci; }
duke@435	142	void set_jsr_return_address_local(int local_no){ _jsr_ret_addr_local = local_no; }
duke@435	143	int jsr_return_address_local() const { return _jsr_ret_addr_local; }
duke@435	144	// Must be called after scope is set up for jsr ScopeData
duke@435	145	void setup_jsr_xhandlers();
duke@435	146
duke@435	147	// The jsr continuation is only used when parsing_jsr is true, and
duke@435	148	// is different from the "normal" continuation since we can end up
duke@435	149	// doing a return (rather than a ret) from within a subroutine
duke@435	150	BlockBegin* jsr_continuation() const { return _jsr_continuation; }
duke@435	151	void set_jsr_continuation(BlockBegin* cont) { _jsr_continuation = cont; }
duke@435	152
duke@435	153	int num_returns();
duke@435	154	void incr_num_returns();
duke@435	155
duke@435	156	void set_inline_cleanup_info(BlockBegin* block,
duke@435	157	Instruction* return_prev,
duke@435	158	ValueStack* return_state);
duke@435	159	BlockBegin* inline_cleanup_block() const { return _cleanup_block; }
duke@435	160	Instruction* inline_cleanup_return_prev() const{ return _cleanup_return_prev; }
duke@435	161	ValueStack* inline_cleanup_state() const { return _cleanup_state; }
duke@435	162	};
duke@435	163
duke@435	164	// for all GraphBuilders
duke@435	165	static bool _is_initialized; // true if trap tables were initialized, false otherwise
duke@435	166	static bool _can_trap[Bytecodes::number_of_java_codes];
duke@435	167	static bool _is_async[Bytecodes::number_of_java_codes];
duke@435	168
duke@435	169	// for each instance of GraphBuilder
duke@435	170	ScopeData* _scope_data; // Per-scope data; used for inlining
duke@435	171	Compilation* _compilation; // the current compilation
duke@435	172	ValueMap* _vmap; // the map of values encountered (for CSE)
duke@435	173	MemoryBuffer* _memory;
duke@435	174	const char* _inline_bailout_msg; // non-null if most recent inline attempt failed
duke@435	175	int _instruction_count; // for bailing out in pathological jsr/ret cases
duke@435	176	BlockBegin* _start; // the start block
duke@435	177	BlockBegin* _osr_entry; // the osr entry block block
duke@435	178	ValueStack* _initial_state; // The state for the start block
duke@435	179
duke@435	180	// for each call to connect_to_end; can also be set by inliner
duke@435	181	BlockBegin* _block; // the current block
duke@435	182	ValueStack* _state; // the current execution state
duke@435	183	ValueStack* _exception_state; // state that will be used by handle_exception
duke@435	184	Instruction* _last; // the last instruction added
duke@435	185	bool _skip_block; // skip processing of the rest of this block
duke@435	186
duke@435	187	// accessors
duke@435	188	ScopeData* scope_data() const { return _scope_data; }
duke@435	189	Compilation* compilation() const { return _compilation; }
duke@435	190	BlockList* bci2block() const { return scope_data()->bci2block(); }
duke@435	191	ValueMap* vmap() const { assert(UseLocalValueNumbering, "should not access otherwise"); return _vmap; }
duke@435	192	bool has_handler() const { return scope_data()->has_handler(); }
duke@435	193
duke@435	194	BlockBegin* block() const { return _block; }
duke@435	195	ValueStack* state() const { return _state; }
duke@435	196	void set_state(ValueStack* state) { _state = state; }
duke@435	197	IRScope* scope() const { return scope_data()->scope(); }
duke@435	198	ValueStack* exception_state() const { return _exception_state; }
duke@435	199	void set_exception_state(ValueStack* s) { _exception_state = s; }
duke@435	200	ciMethod* method() const { return scope()->method(); }
duke@435	201	ciBytecodeStream* stream() const { return scope_data()->stream(); }
duke@435	202	Instruction* last() const { return _last; }
duke@435	203	Bytecodes::Code code() const { return stream()->cur_bc(); }
duke@435	204	int bci() const { return stream()->cur_bci(); }
duke@435	205	int next_bci() const { return stream()->next_bci(); }
duke@435	206
duke@435	207	// unified bailout support
duke@435	208	void bailout(const char* msg) const { compilation()->bailout(msg); }
duke@435	209	bool bailed_out() const { return compilation()->bailed_out(); }
duke@435	210
duke@435	211	// stack manipulation helpers
duke@435	212	void ipush(Value t) const { state()->ipush(t); }
duke@435	213	void lpush(Value t) const { state()->lpush(t); }
duke@435	214	void fpush(Value t) const { state()->fpush(t); }
duke@435	215	void dpush(Value t) const { state()->dpush(t); }
duke@435	216	void apush(Value t) const { state()->apush(t); }
duke@435	217	void push(ValueType* type, Value t) const { state()-> push(type, t); }
duke@435	218
duke@435	219	Value ipop() { return state()->ipop(); }
duke@435	220	Value lpop() { return state()->lpop(); }
duke@435	221	Value fpop() { return state()->fpop(); }
duke@435	222	Value dpop() { return state()->dpop(); }
duke@435	223	Value apop() { return state()->apop(); }
duke@435	224	Value pop(ValueType* type) { return state()-> pop(type); }
duke@435	225
duke@435	226	// instruction helpers
duke@435	227	void load_constant();
duke@435	228	void load_local(ValueType* type, int index);
duke@435	229	void store_local(ValueType* type, int index);
duke@435	230	void store_local(ValueStack* state, Value value, ValueType* type, int index);
duke@435	231	void load_indexed (BasicType type);
duke@435	232	void store_indexed(BasicType type);
duke@435	233	void stack_op(Bytecodes::Code code);
duke@435	234	void arithmetic_op(ValueType* type, Bytecodes::Code code, ValueStack* lock_stack = NULL);
duke@435	235	void negate_op(ValueType* type);
duke@435	236	void shift_op(ValueType* type, Bytecodes::Code code);
duke@435	237	void logic_op(ValueType* type, Bytecodes::Code code);
duke@435	238	void compare_op(ValueType* type, Bytecodes::Code code);
duke@435	239	void convert(Bytecodes::Code op, BasicType from, BasicType to);
duke@435	240	void increment();
duke@435	241	void _goto(int from_bci, int to_bci);
duke@435	242	void if_node(Value x, If::Condition cond, Value y, ValueStack* stack_before);
duke@435	243	void if_zero(ValueType* type, If::Condition cond);
duke@435	244	void if_null(ValueType* type, If::Condition cond);
duke@435	245	void if_same(ValueType* type, If::Condition cond);
duke@435	246	void jsr(int dest);
duke@435	247	void ret(int local_index);
duke@435	248	void table_switch();
duke@435	249	void lookup_switch();
duke@435	250	void method_return(Value x);
duke@435	251	void call_register_finalizer();
duke@435	252	void access_field(Bytecodes::Code code);
duke@435	253	void invoke(Bytecodes::Code code);
duke@435	254	void new_instance(int klass_index);
duke@435	255	void new_type_array();
duke@435	256	void new_object_array();
duke@435	257	void check_cast(int klass_index);
duke@435	258	void instance_of(int klass_index);
duke@435	259	void monitorenter(Value x, int bci);
duke@435	260	void monitorexit(Value x, int bci);
duke@435	261	void new_multi_array(int dimensions);
duke@435	262	void throw_op(int bci);
duke@435	263	Value round_fp(Value fp_value);
duke@435	264
duke@435	265	// stack/code manipulation helpers
duke@435	266	Instruction* append_with_bci(Instruction* instr, int bci);
duke@435	267	Instruction* append(Instruction* instr);
duke@435	268	Instruction* append_split(StateSplit* instr);
duke@435	269
duke@435	270	// other helpers
duke@435	271	static bool is_initialized() { return _is_initialized; }
duke@435	272	static bool is_async(Bytecodes::Code code) {
duke@435	273	assert(0 <= code && code < Bytecodes::number_of_java_codes, "illegal bytecode");
duke@435	274	return _is_async[code];
duke@435	275	}
duke@435	276	BlockBegin* block_at(int bci) { return scope_data()->block_at(bci); }
duke@435	277	XHandlers* handle_exception(int bci);
duke@435	278	void connect_to_end(BlockBegin* beg);
duke@435	279	void null_check(Value value);
duke@435	280	void eliminate_redundant_phis(BlockBegin* start);
duke@435	281	BlockEnd* iterate_bytecodes_for_block(int bci);
duke@435	282	void iterate_all_blocks(bool start_in_current_block_for_inlining = false);
duke@435	283	Dependencies* dependency_recorder() const; // = compilation()->dependencies()
duke@435	284	bool direct_compare(ciKlass* k);
duke@435	285
duke@435	286	void kill_field(ciField* field);
duke@435	287	void kill_array(Value value);
duke@435	288	void kill_all();
duke@435	289
duke@435	290	ValueStack* lock_stack();
duke@435	291
duke@435	292	//
duke@435	293	// Inlining support
duke@435	294	//
duke@435	295
duke@435	296	// accessors
duke@435	297	bool parsing_jsr() const { return scope_data()->parsing_jsr(); }
duke@435	298	BlockBegin* continuation() const { return scope_data()->continuation(); }
duke@435	299	ValueStack* continuation_state() const { return scope_data()->continuation_state(); }
duke@435	300	BlockBegin* jsr_continuation() const { return scope_data()->jsr_continuation(); }
duke@435	301	int caller_stack_size() const { return scope_data()->caller_stack_size(); }
duke@435	302	void set_continuation(BlockBegin* continuation) { scope_data()->set_continuation(continuation); }
duke@435	303	void set_inline_cleanup_info(BlockBegin* block,
duke@435	304	Instruction* return_prev,
duke@435	305	ValueStack* return_state) { scope_data()->set_inline_cleanup_info(block,
duke@435	306	return_prev,
duke@435	307	return_state); }
duke@435	308	BlockBegin* inline_cleanup_block() const { return scope_data()->inline_cleanup_block(); }
duke@435	309	Instruction* inline_cleanup_return_prev() const { return scope_data()->inline_cleanup_return_prev(); }
duke@435	310	ValueStack* inline_cleanup_state() const { return scope_data()->inline_cleanup_state(); }
duke@435	311	void incr_num_returns() { scope_data()->incr_num_returns(); }
duke@435	312	int num_returns() const { return scope_data()->num_returns(); }
duke@435	313	intx max_inline_size() const { return scope_data()->max_inline_size(); }
duke@435	314	int inline_level() const { return scope()->level(); }
duke@435	315	int recursive_inline_level(ciMethod* callee) const;
duke@435	316
duke@435	317	// inlining of synchronized methods
duke@435	318	void inline_sync_entry(Value lock, BlockBegin* sync_handler);
duke@435	319	void fill_sync_handler(Value lock, BlockBegin* sync_handler, bool default_handler = false);
duke@435	320
duke@435	321	// inliners
duke@435	322	bool try_inline(ciMethod* callee, bool holder_known);
duke@435	323	bool try_inline_intrinsics(ciMethod* callee);
duke@435	324	bool try_inline_full (ciMethod* callee, bool holder_known);
duke@435	325	bool try_inline_jsr(int jsr_dest_bci);
duke@435	326
duke@435	327	// helpers
duke@435	328	void inline_bailout(const char* msg);
duke@435	329	BlockBegin* header_block(BlockBegin* entry, BlockBegin::Flag f, ValueStack* state);
duke@435	330	BlockBegin* setup_start_block(int osr_bci, BlockBegin* std_entry, BlockBegin* osr_entry, ValueStack* init_state);
duke@435	331	void setup_osr_entry_block();
duke@435	332	void clear_inline_bailout();
duke@435	333	ValueStack* state_at_entry();
duke@435	334	void push_root_scope(IRScope* scope, BlockList* bci2block, BlockBegin* start);
duke@435	335	void push_scope(ciMethod* callee, BlockBegin* continuation);
duke@435	336	void push_scope_for_jsr(BlockBegin* jsr_continuation, int jsr_dest_bci);
duke@435	337	void pop_scope();
duke@435	338	void pop_scope_for_jsr();
duke@435	339
duke@435	340	bool append_unsafe_get_obj(ciMethod* callee, BasicType t, bool is_volatile);
duke@435	341	bool append_unsafe_put_obj(ciMethod* callee, BasicType t, bool is_volatile);
duke@435	342	bool append_unsafe_get_raw(ciMethod* callee, BasicType t);
duke@435	343	bool append_unsafe_put_raw(ciMethod* callee, BasicType t);
duke@435	344	bool append_unsafe_prefetch(ciMethod* callee, bool is_store, bool is_static);
duke@435	345	void append_unsafe_CAS(ciMethod* callee);
duke@435	346
duke@435	347	NOT_PRODUCT(void print_inline_result(ciMethod* callee, bool res);)
duke@435	348
duke@435	349	// methodDataOop profiling helpers
duke@435	350	void profile_call(Value recv, ciKlass* predicted_holder);
duke@435	351	void profile_invocation(ciMethod* method);
duke@435	352	void profile_bci(int bci);
duke@435	353
duke@435	354	// Helpers for generation of profile information
duke@435	355	bool profile_branches() {
duke@435	356	return _compilation->env()->comp_level() == CompLevel_fast_compile &&
duke@435	357	Tier1UpdateMethodData && Tier1ProfileBranches;
duke@435	358	}
duke@435	359	bool profile_calls() {
duke@435	360	return _compilation->env()->comp_level() == CompLevel_fast_compile &&
duke@435	361	Tier1UpdateMethodData && Tier1ProfileCalls;
duke@435	362	}
duke@435	363	bool profile_inlined_calls() {
duke@435	364	return profile_calls() && Tier1ProfileInlinedCalls;
duke@435	365	}
duke@435	366	bool profile_checkcasts() {
duke@435	367	return _compilation->env()->comp_level() == CompLevel_fast_compile &&
duke@435	368	Tier1UpdateMethodData && Tier1ProfileCheckcasts;
duke@435	369	}
duke@435	370
duke@435	371	public:
duke@435	372	NOT_PRODUCT(void print_stats();)
duke@435	373
duke@435	374	// initialization
duke@435	375	static void initialize();
duke@435	376
duke@435	377	// public
duke@435	378	static bool can_trap(ciMethod* method, Bytecodes::Code code) {
duke@435	379	assert(0 <= code && code < Bytecodes::number_of_java_codes, "illegal bytecode");
duke@435	380	if (_can_trap[code]) return true;
duke@435	381	// special handling for finalizer registration
duke@435	382	return code == Bytecodes::_return && method->intrinsic_id() == vmIntrinsics::_Object_init;
duke@435	383	}
duke@435	384
duke@435	385	// creation
duke@435	386	GraphBuilder(Compilation* compilation, IRScope* scope);
duke@435	387	static void sort_top_into_worklist(BlockList* worklist, BlockBegin* top);
duke@435	388
duke@435	389	BlockBegin* start() const { return _start; }
duke@435	390	};