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

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

src/share/vm/c1/c1_GraphBuilder.hpp

Wed, 31 Aug 2011 16:46:11 -0700

author

never

date

Wed, 31 Aug 2011 16:46:11 -0700

changeset 3099

c124e2e7463e

parent 2314

f95d63e2154a

child 3100

a32de5085326

permissions

-rw-r--r--

7083786: dead various dead chunks of code
Reviewed-by: iveresov, kvn

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