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

src/share/vm/opto/parse.hpp@98cb887364d3 (annotated)

src/share/vm/opto/parse.hpp

Fri, 27 Feb 2009 13:27:09 -0800

author

twisti

date

Fri, 27 Feb 2009 13:27:09 -0800

changeset 1040

98cb887364d3

parent 870

b1d6a3e95810

child 1165

9c6be3edf0dc

permissions

-rw-r--r--

6810672: Comment typos
Summary: I have collected some typos I have found while looking at the code.
Reviewed-by: kvn, never

duke@435	1	/*
xdono@631	2	* Copyright 1997-2008 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 BytecodeParseHistogram;
duke@435	26	class InlineTree;
duke@435	27	class Parse;
duke@435	28	class SwitchRange;
duke@435	29
duke@435	30
duke@435	31	//------------------------------InlineTree-------------------------------------
duke@435	32	class InlineTree : public ResourceObj {
duke@435	33	Compile* C; // cache
duke@435	34	JVMState* _caller_jvms; // state of caller
duke@435	35	ciMethod* _method; // method being called by the caller_jvms
duke@435	36	InlineTree* _caller_tree;
duke@435	37	uint _count_inline_bcs; // Accumulated count of inlined bytecodes
duke@435	38	// Call-site count / interpreter invocation count, scaled recursively.
duke@435	39	// Always between 0.0 and 1.0. Represents the percentage of the method's
duke@435	40	// total execution time used at this call site.
duke@435	41	const float _site_invoke_ratio;
duke@435	42	float compute_callee_frequency( int caller_bci ) const;
duke@435	43
duke@435	44	GrowableArray<InlineTree*> _subtrees;
duke@435	45	friend class Compile;
duke@435	46
duke@435	47	protected:
duke@435	48	InlineTree(Compile* C,
duke@435	49	const InlineTree* caller_tree,
duke@435	50	ciMethod* callee_method,
duke@435	51	JVMState* caller_jvms,
duke@435	52	int caller_bci,
duke@435	53	float site_invoke_ratio);
duke@435	54	InlineTree *build_inline_tree_for_callee(ciMethod* callee_method,
duke@435	55	JVMState* caller_jvms,
duke@435	56	int caller_bci);
kvn@476	57	const char* try_to_inline(ciMethod* callee_method, ciMethod* caller_method, int caller_bci, ciCallProfile& profile, WarmCallInfo* wci_result);
kvn@476	58	const char* shouldInline(ciMethod* callee_method, ciMethod* caller_method, int caller_bci, ciCallProfile& profile, WarmCallInfo* wci_result) const;
kvn@476	59	const char* shouldNotInline(ciMethod* callee_method, ciMethod* caller_method, WarmCallInfo* wci_result) const;
duke@435	60	void print_inlining(ciMethod *callee_method, int caller_bci, const char *failure_msg) const PRODUCT_RETURN;
duke@435	61
duke@435	62	InlineTree *caller_tree() const { return _caller_tree; }
duke@435	63	InlineTree* callee_at(int bci, ciMethod* m) const;
duke@435	64	int inline_depth() const { return _caller_jvms ? _caller_jvms->depth() : 0; }
duke@435	65
duke@435	66	public:
duke@435	67	static InlineTree* build_inline_tree_root();
duke@435	68	static InlineTree* find_subtree_from_root(InlineTree* root, JVMState* jvms, ciMethod* callee, bool create_if_not_found = false);
duke@435	69
duke@435	70	// For temporary (stack-allocated, stateless) ilts:
duke@435	71	InlineTree(Compile* c, ciMethod* callee_method, JVMState* caller_jvms, float site_invoke_ratio);
duke@435	72
duke@435	73	// InlineTree enum
duke@435	74	enum InlineStyle {
duke@435	75	Inline_do_not_inline = 0, //
duke@435	76	Inline_cha_is_monomorphic = 1, //
duke@435	77	Inline_type_profile_monomorphic = 2 //
duke@435	78	};
duke@435	79
duke@435	80	// See if it is OK to inline.
twisti@1040	81	// The receiver is the inline tree for the caller.
duke@435	82	//
duke@435	83	// The result is a temperature indication. If it is hot or cold,
duke@435	84	// inlining is immediate or undesirable. Otherwise, the info block
duke@435	85	// returned is newly allocated and may be enqueued.
duke@435	86	//
duke@435	87	// If the method is inlinable, a new inline subtree is created on the fly,
duke@435	88	// and may be accessed by find_subtree_from_root.
duke@435	89	// The call_method is the dest_method for a special or static invocation.
duke@435	90	// The call_method is an optimized virtual method candidate otherwise.
duke@435	91	WarmCallInfo* ok_to_inline(ciMethod *call_method, JVMState* caller_jvms, ciCallProfile& profile, WarmCallInfo* wci);
duke@435	92
duke@435	93	// Information about inlined method
duke@435	94	JVMState* caller_jvms() const { return _caller_jvms; }
duke@435	95	ciMethod *method() const { return _method; }
duke@435	96	int caller_bci() const { return _caller_jvms ? _caller_jvms->bci() : InvocationEntryBci; }
duke@435	97	uint count_inline_bcs() const { return _count_inline_bcs; }
duke@435	98	float site_invoke_ratio() const { return _site_invoke_ratio; };
duke@435	99
duke@435	100	#ifndef PRODUCT
duke@435	101	private:
duke@435	102	uint _count_inlines; // Count of inlined methods
duke@435	103	public:
duke@435	104	// Debug information collected during parse
duke@435	105	uint count_inlines() const { return _count_inlines; };
duke@435	106	#endif
duke@435	107	GrowableArray<InlineTree*> subtrees() { return _subtrees; }
duke@435	108	};
duke@435	109
duke@435	110
duke@435	111	//-----------------------------------------------------------------------------
duke@435	112	//------------------------------Parse------------------------------------------
duke@435	113	// Parse bytecodes, build a Graph
duke@435	114	class Parse : public GraphKit {
duke@435	115	public:
duke@435	116	// Per-block information needed by the parser:
duke@435	117	class Block {
duke@435	118	private:
duke@435	119	ciTypeFlow::Block* _flow;
duke@435	120	int _pred_count; // how many predecessors in CFG?
duke@435	121	int _preds_parsed; // how many of these have been parsed?
duke@435	122	uint _count; // how many times executed? Currently only set by _goto's
duke@435	123	bool _is_parsed; // has this block been parsed yet?
duke@435	124	bool _is_handler; // is this block an exception handler?
duke@435	125	SafePointNode* _start_map; // all values flowing into this block
duke@435	126	MethodLivenessResult _live_locals; // lazily initialized liveness bitmap
duke@435	127
duke@435	128	int _num_successors; // Includes only normal control flow.
duke@435	129	int _all_successors; // Include exception paths also.
duke@435	130	Block** _successors;
duke@435	131
duke@435	132	// Use init_node/init_graph to initialize Blocks.
duke@435	133	// Block() : _live_locals((uintptr_t*)NULL,0) { ShouldNotReachHere(); }
duke@435	134	Block() : _live_locals(NULL,0) { ShouldNotReachHere(); }
duke@435	135
duke@435	136	public:
duke@435	137
duke@435	138	// Set up the block data structure itself.
duke@435	139	void init_node(Parse* outer, int po);
duke@435	140	// Set up the block's relations to other blocks.
duke@435	141	void init_graph(Parse* outer);
duke@435	142
duke@435	143	ciTypeFlow::Block* flow() const { return _flow; }
duke@435	144	int pred_count() const { return _pred_count; }
duke@435	145	int preds_parsed() const { return _preds_parsed; }
duke@435	146	bool is_parsed() const { return _is_parsed; }
duke@435	147	bool is_handler() const { return _is_handler; }
duke@435	148	void set_count( uint x ) { _count = x; }
duke@435	149	uint count() const { return _count; }
duke@435	150
duke@435	151	SafePointNode* start_map() const { assert(is_merged(),""); return _start_map; }
duke@435	152	void set_start_map(SafePointNode* m) { assert(!is_merged(), ""); _start_map = m; }
duke@435	153
duke@435	154	// True after any predecessor flows control into this block
duke@435	155	bool is_merged() const { return _start_map != NULL; }
duke@435	156
duke@435	157	// True when all non-exception predecessors have been parsed.
duke@435	158	bool is_ready() const { return preds_parsed() == pred_count(); }
duke@435	159
duke@435	160	int num_successors() const { return _num_successors; }
duke@435	161	int all_successors() const { return _all_successors; }
duke@435	162	Block* successor_at(int i) const {
duke@435	163	assert((uint)i < (uint)all_successors(), "");
duke@435	164	return _successors[i];
duke@435	165	}
duke@435	166	Block* successor_for_bci(int bci);
duke@435	167
duke@435	168	int start() const { return flow()->start(); }
duke@435	169	int limit() const { return flow()->limit(); }
never@802	170	int rpo() const { return flow()->rpo(); }
duke@435	171	int start_sp() const { return flow()->stack_size(); }
duke@435	172
never@802	173	bool is_loop_head() const { return flow()->is_loop_head(); }
never@802	174	bool is_SEL_head() const { return flow()->is_single_entry_loop_head(); }
never@802	175	bool is_SEL_backedge(Block* pred) const{ return is_SEL_head() && pred->rpo() >= rpo(); }
never@802	176	bool is_invariant_local(uint i) const {
never@802	177	const JVMState* jvms = start_map()->jvms();
kvn@870	178	if (!jvms->is_loc(i) || flow()->outer()->has_irreducible_entry()) return false;
never@802	179	return flow()->is_invariant_local(i - jvms->locoff());
never@802	180	}
never@802	181	bool can_elide_SEL_phi(uint i) const { assert(is_SEL_head(),""); return is_invariant_local(i); }
never@802	182
duke@435	183	const Type* peek(int off=0) const { return stack_type_at(start_sp() - (off+1)); }
duke@435	184
duke@435	185	const Type* stack_type_at(int i) const;
duke@435	186	const Type* local_type_at(int i) const;
duke@435	187	static const Type* get_type(ciType* t) { return Type::get_typeflow_type(t); }
duke@435	188
duke@435	189	bool has_trap_at(int bci) const { return flow()->has_trap() && flow()->trap_bci() == bci; }
duke@435	190
duke@435	191	// Call this just before parsing a block.
duke@435	192	void mark_parsed() {
duke@435	193	assert(!_is_parsed, "must parse each block exactly once");
duke@435	194	_is_parsed = true;
duke@435	195	}
duke@435	196
duke@435	197	// Return the phi/region input index for the "current" pred,
duke@435	198	// and bump the pred number. For historical reasons these index
duke@435	199	// numbers are handed out in descending order. The last index is
duke@435	200	// always PhiNode::Input (i.e., 1). The value returned is known
duke@435	201	// as a "path number" because it distinguishes by which path we are
duke@435	202	// entering the block.
duke@435	203	int next_path_num() {
duke@435	204	assert(preds_parsed() < pred_count(), "too many preds?");
duke@435	205	return pred_count() - _preds_parsed++;
duke@435	206	}
duke@435	207
duke@435	208	// Add a previously unaccounted predecessor to this block.
duke@435	209	// This operates by increasing the size of the block's region
duke@435	210	// and all its phi nodes (if any). The value returned is a
duke@435	211	// path number ("pnum").
duke@435	212	int add_new_path();
duke@435	213
duke@435	214	// Initialize me by recording the parser's map. My own map must be NULL.
duke@435	215	void record_state(Parse* outer);
duke@435	216	};
duke@435	217
duke@435	218	#ifndef PRODUCT
duke@435	219	// BytecodeParseHistogram collects number of bytecodes parsed, nodes constructed, and transformations.
duke@435	220	class BytecodeParseHistogram : public ResourceObj {
duke@435	221	private:
duke@435	222	enum BPHType {
duke@435	223	BPH_transforms,
duke@435	224	BPH_values
duke@435	225	};
duke@435	226	static bool _initialized;
duke@435	227	static uint _bytecodes_parsed [Bytecodes::number_of_codes];
duke@435	228	static uint _nodes_constructed[Bytecodes::number_of_codes];
duke@435	229	static uint _nodes_transformed[Bytecodes::number_of_codes];
duke@435	230	static uint _new_values [Bytecodes::number_of_codes];
duke@435	231
duke@435	232	Bytecodes::Code _initial_bytecode;
duke@435	233	int _initial_node_count;
duke@435	234	int _initial_transforms;
duke@435	235	int _initial_values;
duke@435	236
duke@435	237	Parse *_parser;
duke@435	238	Compile *_compiler;
duke@435	239
duke@435	240	// Initialization
duke@435	241	static void reset();
duke@435	242
duke@435	243	// Return info being collected, select with global flag 'BytecodeParseInfo'
duke@435	244	int current_count(BPHType info_selector);
duke@435	245
duke@435	246	public:
duke@435	247	BytecodeParseHistogram(Parse *p, Compile *c);
duke@435	248	static bool initialized();
duke@435	249
duke@435	250	// Record info when starting to parse one bytecode
duke@435	251	void set_initial_state( Bytecodes::Code bc );
duke@435	252	// Record results of parsing one bytecode
duke@435	253	void record_change();
duke@435	254
duke@435	255	// Profile printing
duke@435	256	static void print(float cutoff = 0.01F); // cutoff in percent
duke@435	257	};
duke@435	258
duke@435	259	public:
duke@435	260	// Record work done during parsing
duke@435	261	BytecodeParseHistogram* _parse_histogram;
duke@435	262	void set_parse_histogram(BytecodeParseHistogram *bph) { _parse_histogram = bph; }
duke@435	263	BytecodeParseHistogram* parse_histogram() { return _parse_histogram; }
duke@435	264	#endif
duke@435	265
duke@435	266	private:
duke@435	267	friend class Block;
duke@435	268
duke@435	269	// Variables which characterize this compilation as a whole:
duke@435	270
duke@435	271	JVMState* _caller; // JVMS which carries incoming args & state.
duke@435	272	float _expected_uses; // expected number of calls to this code
duke@435	273	float _prof_factor; // discount applied to my profile counts
duke@435	274	int _depth; // Inline tree depth, for debug printouts
duke@435	275	const TypeFunc*_tf; // My kind of function type
duke@435	276	int _entry_bci; // the osr bci or InvocationEntryBci
duke@435	277
duke@435	278	ciTypeFlow* _flow; // Results of previous flow pass.
duke@435	279	Block* _blocks; // Array of basic-block structs.
duke@435	280	int _block_count; // Number of elements in _blocks.
duke@435	281
duke@435	282	GraphKit _exits; // Record all normal returns and throws here.
duke@435	283	bool _wrote_final; // Did we write a final field?
duke@435	284	bool _count_invocations; // update and test invocation counter
duke@435	285	bool _method_data_update; // update method data oop
duke@435	286
duke@435	287	// Variables which track Java semantics during bytecode parsing:
duke@435	288
duke@435	289	Block* _block; // block currently getting parsed
duke@435	290	ciBytecodeStream _iter; // stream of this method's bytecodes
duke@435	291
duke@435	292	int _blocks_merged; // Progress meter: state merges from BB preds
duke@435	293	int _blocks_parsed; // Progress meter: BBs actually parsed
duke@435	294
duke@435	295	const FastLockNode* _synch_lock; // FastLockNode for synchronized method
duke@435	296
duke@435	297	#ifndef PRODUCT
duke@435	298	int _max_switch_depth; // Debugging SwitchRanges.
duke@435	299	int _est_switch_depth; // Debugging SwitchRanges.
duke@435	300	#endif
duke@435	301
duke@435	302	public:
duke@435	303	// Constructor
duke@435	304	Parse(JVMState* caller, ciMethod* parse_method, float expected_uses);
duke@435	305
duke@435	306	virtual Parse* is_Parse() const { return (Parse*)this; }
duke@435	307
duke@435	308	public:
duke@435	309	// Accessors.
duke@435	310	JVMState* caller() const { return _caller; }
duke@435	311	float expected_uses() const { return _expected_uses; }
duke@435	312	float prof_factor() const { return _prof_factor; }
duke@435	313	int depth() const { return _depth; }
duke@435	314	const TypeFunc* tf() const { return _tf; }
duke@435	315	// entry_bci() -- see osr_bci, etc.
duke@435	316
duke@435	317	ciTypeFlow* flow() const { return _flow; }
never@802	318	// blocks() -- see rpo_at, start_block, etc.
duke@435	319	int block_count() const { return _block_count; }
duke@435	320
duke@435	321	GraphKit& exits() { return _exits; }
duke@435	322	bool wrote_final() const { return _wrote_final; }
duke@435	323	void set_wrote_final(bool z) { _wrote_final = z; }
duke@435	324	bool count_invocations() const { return _count_invocations; }
duke@435	325	bool method_data_update() const { return _method_data_update; }
duke@435	326
duke@435	327	Block* block() const { return _block; }
duke@435	328	ciBytecodeStream& iter() { return _iter; }
duke@435	329	Bytecodes::Code bc() const { return _iter.cur_bc(); }
duke@435	330
duke@435	331	void set_block(Block* b) { _block = b; }
duke@435	332
duke@435	333	// Derived accessors:
duke@435	334	bool is_normal_parse() const { return _entry_bci == InvocationEntryBci; }
duke@435	335	bool is_osr_parse() const { return _entry_bci != InvocationEntryBci; }
duke@435	336	int osr_bci() const { assert(is_osr_parse(),""); return _entry_bci; }
duke@435	337
duke@435	338	void set_parse_bci(int bci);
duke@435	339
duke@435	340	// Must this parse be aborted?
duke@435	341	bool failing() { return C->failing(); }
duke@435	342
never@802	343	Block* rpo_at(int rpo) {
never@802	344	assert(0 <= rpo && rpo < _block_count, "oob");
never@802	345	return &_blocks[rpo];
duke@435	346	}
duke@435	347	Block* start_block() {
never@802	348	return rpo_at(flow()->start_block()->rpo());
duke@435	349	}
duke@435	350	// Can return NULL if the flow pass did not complete a block.
duke@435	351	Block* successor_for_bci(int bci) {
duke@435	352	return block()->successor_for_bci(bci);
duke@435	353	}
duke@435	354
duke@435	355	private:
duke@435	356	// Create a JVMS & map for the initial state of this method.
duke@435	357	SafePointNode* create_entry_map();
duke@435	358
duke@435	359	// OSR helpers
duke@435	360	Node *fetch_interpreter_state(int index, BasicType bt, Node *local_addrs, Node *local_addrs_base);
duke@435	361	Node* check_interpreter_type(Node* l, const Type* type, SafePointNode* &bad_type_exit);
duke@435	362	void load_interpreter_state(Node* osr_buf);
duke@435	363
duke@435	364	// Functions for managing basic blocks:
duke@435	365	void init_blocks();
duke@435	366	void load_state_from(Block* b);
duke@435	367	void store_state_to(Block* b) { b->record_state(this); }
duke@435	368
duke@435	369	// Parse all the basic blocks.
duke@435	370	void do_all_blocks();
duke@435	371
duke@435	372	// Parse the current basic block
duke@435	373	void do_one_block();
duke@435	374
duke@435	375	// Raise an error if we get a bad ciTypeFlow CFG.
duke@435	376	void handle_missing_successor(int bci);
duke@435	377
duke@435	378	// first actions (before BCI 0)
duke@435	379	void do_method_entry();
duke@435	380
duke@435	381	// implementation of monitorenter/monitorexit
duke@435	382	void do_monitor_enter();
duke@435	383	void do_monitor_exit();
duke@435	384
duke@435	385	// Eagerly create phie throughout the state, to cope with back edges.
duke@435	386	void ensure_phis_everywhere();
duke@435	387
duke@435	388	// Merge the current mapping into the basic block starting at bci
duke@435	389	void merge( int target_bci);
duke@435	390	// Same as plain merge, except that it allocates a new path number.
duke@435	391	void merge_new_path( int target_bci);
duke@435	392	// Merge the current mapping into an exception handler.
duke@435	393	void merge_exception(int target_bci);
duke@435	394	// Helper: Merge the current mapping into the given basic block
duke@435	395	void merge_common(Block* target, int pnum);
duke@435	396	// Helper functions for merging individual cells.
duke@435	397	PhiNode *ensure_phi( int idx, bool nocreate = false);
duke@435	398	PhiNode *ensure_memory_phi(int idx, bool nocreate = false);
duke@435	399	// Helper to merge the current memory state into the given basic block
duke@435	400	void merge_memory_edges(MergeMemNode* n, int pnum, bool nophi);
duke@435	401
duke@435	402	// Parse this bytecode, and alter the Parsers JVM->Node mapping
duke@435	403	void do_one_bytecode();
duke@435	404
duke@435	405	// helper function to generate array store check
duke@435	406	void array_store_check();
duke@435	407	// Helper function to generate array load
duke@435	408	void array_load(BasicType etype);
duke@435	409	// Helper function to generate array store
duke@435	410	void array_store(BasicType etype);
duke@435	411	// Helper function to compute array addressing
duke@435	412	Node* array_addressing(BasicType type, int vals, const Type* *result2=NULL);
duke@435	413
duke@435	414	// Pass current map to exits
duke@435	415	void return_current(Node* value);
duke@435	416
duke@435	417	// Register finalizers on return from Object.<init>
duke@435	418	void call_register_finalizer();
duke@435	419
duke@435	420	// Insert a compiler safepoint into the graph
duke@435	421	void add_safepoint();
duke@435	422
duke@435	423	// Insert a compiler safepoint into the graph, if there is a back-branch.
duke@435	424	void maybe_add_safepoint(int target_bci) {
duke@435	425	if (UseLoopSafepoints && target_bci <= bci()) {
duke@435	426	add_safepoint();
duke@435	427	}
duke@435	428	}
duke@435	429
duke@435	430	// Note: Intrinsic generation routines may be found in library_call.cpp.
duke@435	431
duke@435	432	// Helper function to setup Ideal Call nodes
duke@435	433	void do_call();
duke@435	434
duke@435	435	// Helper function to uncommon-trap or bailout for non-compilable call-sites
duke@435	436	bool can_not_compile_call_site(ciMethod *dest_method, ciInstanceKlass *klass);
duke@435	437
duke@435	438	// Helper function to identify inlining potential at call-site
duke@435	439	ciMethod* optimize_inlining(ciMethod* caller, int bci, ciInstanceKlass* klass,
duke@435	440	ciMethod *dest_method, const TypeOopPtr* receiver_type);
duke@435	441
duke@435	442	// Helper function to setup for type-profile based inlining
duke@435	443	bool prepare_type_profile_inline(ciInstanceKlass* prof_klass, ciMethod* prof_method);
duke@435	444
duke@435	445	// Helper functions for type checking bytecodes:
duke@435	446	void do_checkcast();
duke@435	447	void do_instanceof();
duke@435	448
duke@435	449	// Helper functions for shifting & arithmetic
duke@435	450	void modf();
duke@435	451	void modd();
duke@435	452	void l2f();
duke@435	453
duke@435	454	void do_irem();
duke@435	455
duke@435	456	// implementation of _get* and _put* bytecodes
duke@435	457	void do_getstatic() { do_field_access(true, false); }
duke@435	458	void do_getfield () { do_field_access(true, true); }
duke@435	459	void do_putstatic() { do_field_access(false, false); }
duke@435	460	void do_putfield () { do_field_access(false, true); }
duke@435	461
duke@435	462	// common code for making initial checks and forming addresses
duke@435	463	void do_field_access(bool is_get, bool is_field);
duke@435	464	bool static_field_ok_in_clinit(ciField *field, ciMethod *method);
duke@435	465
duke@435	466	// common code for actually performing the load or store
duke@435	467	void do_get_xxx(const TypePtr* obj_type, Node* obj, ciField* field, bool is_field);
duke@435	468	void do_put_xxx(const TypePtr* obj_type, Node* obj, ciField* field, bool is_field);
duke@435	469
duke@435	470	// loading from a constant field or the constant pool
duke@435	471	// returns false if push failed (non-perm field constants only, not ldcs)
duke@435	472	bool push_constant(ciConstant con);
duke@435	473
duke@435	474	// implementation of object creation bytecodes
duke@435	475	void do_new();
duke@435	476	void do_newarray(BasicType elemtype);
duke@435	477	void do_anewarray();
duke@435	478	void do_multianewarray();
duke@435	479	Node* expand_multianewarray(ciArrayKlass* array_klass, Node* *lengths, int ndimensions);
duke@435	480
duke@435	481	// implementation of jsr/ret
duke@435	482	void do_jsr();
duke@435	483	void do_ret();
duke@435	484
duke@435	485	float dynamic_branch_prediction(float &cnt);
duke@435	486	float branch_prediction(float &cnt, BoolTest::mask btest, int target_bci);
duke@435	487	bool seems_never_taken(float prob);
duke@435	488
rasbold@683	489	void do_ifnull(BoolTest::mask btest, Node* c);
duke@435	490	void do_if(BoolTest::mask btest, Node* c);
duke@435	491	void repush_if_args();
duke@435	492	void adjust_map_after_if(BoolTest::mask btest, Node* c, float prob,
duke@435	493	Block* path, Block* other_path);
duke@435	494	IfNode* jump_if_fork_int(Node* a, Node* b, BoolTest::mask mask);
duke@435	495	Node* jump_if_join(Node* iffalse, Node* iftrue);
duke@435	496	void jump_if_true_fork(IfNode *ifNode, int dest_bci_if_true, int prof_table_index);
duke@435	497	void jump_if_false_fork(IfNode *ifNode, int dest_bci_if_false, int prof_table_index);
duke@435	498	void jump_if_always_fork(int dest_bci_if_true, int prof_table_index);
duke@435	499
duke@435	500	friend class SwitchRange;
duke@435	501	void do_tableswitch();
duke@435	502	void do_lookupswitch();
duke@435	503	void jump_switch_ranges(Node* a, SwitchRange* lo, SwitchRange* hi, int depth = 0);
duke@435	504	bool create_jump_tables(Node* a, SwitchRange* lo, SwitchRange* hi);
duke@435	505
duke@435	506	// helper functions for methodData style profiling
duke@435	507	void test_counter_against_threshold(Node* cnt, int limit);
duke@435	508	void increment_and_test_invocation_counter(int limit);
duke@435	509	void test_for_osr_md_counter_at(ciMethodData* md, ciProfileData* data, ByteSize offset, int limit);
duke@435	510	Node* method_data_addressing(ciMethodData* md, ciProfileData* data, ByteSize offset, Node* idx = NULL, uint stride = 0);
duke@435	511	void increment_md_counter_at(ciMethodData* md, ciProfileData* data, ByteSize offset, Node* idx = NULL, uint stride = 0);
duke@435	512	void set_md_flag_at(ciMethodData* md, ciProfileData* data, int flag_constant);
duke@435	513
duke@435	514	void profile_method_entry();
duke@435	515	void profile_taken_branch(int target_bci, bool force_update = false);
duke@435	516	void profile_not_taken_branch(bool force_update = false);
duke@435	517	void profile_call(Node* receiver);
duke@435	518	void profile_generic_call();
duke@435	519	void profile_receiver_type(Node* receiver);
duke@435	520	void profile_ret(int target_bci);
duke@435	521	void profile_null_checkcast();
duke@435	522	void profile_switch_case(int table_index);
duke@435	523
duke@435	524	// helper function for call statistics
duke@435	525	void count_compiled_calls(bool at_method_entry, bool is_inline) PRODUCT_RETURN;
duke@435	526
duke@435	527	Node_Notes* make_node_notes(Node_Notes* caller_nn);
duke@435	528
duke@435	529	// Helper functions for handling normal and abnormal exits.
duke@435	530	void build_exits();
duke@435	531
duke@435	532	// Fix up all exceptional control flow exiting a single bytecode.
duke@435	533	void do_exceptions();
duke@435	534
duke@435	535	// Fix up all exiting control flow at the end of the parse.
duke@435	536	void do_exits();
duke@435	537
duke@435	538	// Add Catch/CatchProjs
duke@435	539	// The call is either a Java call or the VM's rethrow stub
duke@435	540	void catch_call_exceptions(ciExceptionHandlerStream&);
duke@435	541
duke@435	542	// Handle all exceptions thrown by the inlined method.
duke@435	543	// Also handles exceptions for individual bytecodes.
duke@435	544	void catch_inline_exceptions(SafePointNode* ex_map);
duke@435	545
duke@435	546	// Bytecode classifier, helps decide to use uncommon_trap vs. rethrow_C.
duke@435	547	bool can_rerun_bytecode();
duke@435	548
duke@435	549	// Merge the given map into correct exceptional exit state.
duke@435	550	// Assumes that there is no applicable local handler.
duke@435	551	void throw_to_exit(SafePointNode* ex_map);
duke@435	552
duke@435	553	public:
duke@435	554	#ifndef PRODUCT
duke@435	555	// Handle PrintOpto, etc.
duke@435	556	void show_parse_info();
duke@435	557	void dump_map_adr_mem() const;
duke@435	558	static void print_statistics(); // Print some performance counters
duke@435	559	void dump();
duke@435	560	void dump_bci(int bci);
duke@435	561	#endif
duke@435	562	};