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

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

src/share/vm/c1/c1_GraphBuilder.hpp

Fri, 25 Apr 2014 09:22:16 +0200

author

roland

date

Fri, 25 Apr 2014 09:22:16 +0200

changeset 6668

45e59fae8f2b

parent 6198

55fb97c4c58d

child 6876

710a3c8b516e

permissions

-rw-r--r--

8041481: JVM crashes with collect_args_for_profiling
Summary: method handle call to c1 intrinsic tries to profile popped argument
Reviewed-by: kvn, twisti

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