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

src/share/vm/opto/parse2.cpp@f3de1255b035 (annotated)

src/share/vm/opto/parse2.cpp

Wed, 07 May 2008 08:06:46 -0700

author

rasbold

date

Wed, 07 May 2008 08:06:46 -0700

changeset 580

f3de1255b035

parent 564

c0939256690b

child 631

d1605aabd0a1

child 656

1e026f8da827

permissions

-rw-r--r--

6603011: RFE: Optimize long division
Summary: Transform long division by constant into multiply
Reviewed-by: never, kvn

duke@435	1	/*
duke@435	2	* Copyright 1998-2007 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	#include "incls/_precompiled.incl"
duke@435	26	#include "incls/_parse2.cpp.incl"
duke@435	27
duke@435	28	extern int explicit_null_checks_inserted,
duke@435	29	explicit_null_checks_elided;
duke@435	30
duke@435	31	//---------------------------------array_load----------------------------------
duke@435	32	void Parse::array_load(BasicType elem_type) {
duke@435	33	const Type* elem = Type::TOP;
duke@435	34	Node* adr = array_addressing(elem_type, 0, &elem);
duke@435	35	if (stopped()) return; // guarenteed null or range check
duke@435	36	_sp -= 2; // Pop array and index
duke@435	37	const TypeAryPtr* adr_type = TypeAryPtr::get_array_body_type(elem_type);
duke@435	38	Node* ld = make_load(control(), adr, elem, elem_type, adr_type);
duke@435	39	push(ld);
duke@435	40	}
duke@435	41
duke@435	42
duke@435	43	//--------------------------------array_store----------------------------------
duke@435	44	void Parse::array_store(BasicType elem_type) {
duke@435	45	Node* adr = array_addressing(elem_type, 1);
duke@435	46	if (stopped()) return; // guarenteed null or range check
duke@435	47	Node* val = pop();
duke@435	48	_sp -= 2; // Pop array and index
duke@435	49	const TypeAryPtr* adr_type = TypeAryPtr::get_array_body_type(elem_type);
duke@435	50	store_to_memory(control(), adr, val, elem_type, adr_type);
duke@435	51	}
duke@435	52
duke@435	53
duke@435	54	//------------------------------array_addressing-------------------------------
duke@435	55	// Pull array and index from the stack. Compute pointer-to-element.
duke@435	56	Node* Parse::array_addressing(BasicType type, int vals, const Type* *result2) {
duke@435	57	Node *idx = peek(0+vals); // Get from stack without popping
duke@435	58	Node *ary = peek(1+vals); // in case of exception
duke@435	59
duke@435	60	// Null check the array base, with correct stack contents
duke@435	61	ary = do_null_check(ary, T_ARRAY);
duke@435	62	// Compile-time detect of null-exception?
duke@435	63	if (stopped()) return top();
duke@435	64
duke@435	65	const TypeAryPtr* arytype = _gvn.type(ary)->is_aryptr();
duke@435	66	const TypeInt* sizetype = arytype->size();
duke@435	67	const Type* elemtype = arytype->elem();
duke@435	68
duke@435	69	if (UseUniqueSubclasses && result2 != NULL) {
coleenp@548	70	const Type* el = elemtype;
coleenp@548	71	if (elemtype->isa_narrowoop()) {
coleenp@548	72	el = elemtype->is_narrowoop()->make_oopptr();
coleenp@548	73	}
coleenp@548	74	const TypeInstPtr* toop = el->isa_instptr();
duke@435	75	if (toop) {
duke@435	76	if (toop->klass()->as_instance_klass()->unique_concrete_subklass()) {
duke@435	77	// If we load from "AbstractClass[]" we must see "ConcreteSubClass".
duke@435	78	const Type* subklass = Type::get_const_type(toop->klass());
coleenp@548	79	elemtype = subklass->join(el);
duke@435	80	}
duke@435	81	}
duke@435	82	}
duke@435	83
duke@435	84	// Check for big class initializers with all constant offsets
duke@435	85	// feeding into a known-size array.
duke@435	86	const TypeInt* idxtype = _gvn.type(idx)->is_int();
duke@435	87	// See if the highest idx value is less than the lowest array bound,
duke@435	88	// and if the idx value cannot be negative:
duke@435	89	bool need_range_check = true;
duke@435	90	if (idxtype->_hi < sizetype->_lo && idxtype->_lo >= 0) {
duke@435	91	need_range_check = false;
duke@435	92	if (C->log() != NULL) C->log()->elem("observe that='!need_range_check'");
duke@435	93	}
duke@435	94
duke@435	95	if (!arytype->klass()->is_loaded()) {
duke@435	96	// Only fails for some -Xcomp runs
duke@435	97	// The class is unloaded. We have to run this bytecode in the interpreter.
duke@435	98	uncommon_trap(Deoptimization::Reason_unloaded,
duke@435	99	Deoptimization::Action_reinterpret,
duke@435	100	arytype->klass(), "!loaded array");
duke@435	101	return top();
duke@435	102	}
duke@435	103
duke@435	104	// Do the range check
duke@435	105	if (GenerateRangeChecks && need_range_check) {
duke@435	106	// Range is constant in array-oop, so we can use the original state of mem
duke@435	107	Node* len = load_array_length(ary);
rasbold@564	108	Node* tst;
rasbold@564	109	if (sizetype->_hi <= 0) {
rasbold@564	110	// If the greatest array bound is negative, we can conclude that we're
rasbold@564	111	// compiling unreachable code, but the unsigned compare trick used below
rasbold@564	112	// only works with non-negative lengths. Instead, hack "tst" to be zero so
rasbold@564	113	// the uncommon_trap path will always be taken.
rasbold@564	114	tst = _gvn.intcon(0);
rasbold@564	115	} else {
rasbold@564	116	// Test length vs index (standard trick using unsigned compare)
rasbold@564	117	Node* chk = _gvn.transform( new (C, 3) CmpUNode(idx, len) );
rasbold@564	118	BoolTest::mask btest = BoolTest::lt;
rasbold@564	119	tst = _gvn.transform( new (C, 2) BoolNode(chk, btest) );
rasbold@564	120	}
duke@435	121	// Branch to failure if out of bounds
duke@435	122	{ BuildCutout unless(this, tst, PROB_MAX);
duke@435	123	if (C->allow_range_check_smearing()) {
duke@435	124	// Do not use builtin_throw, since range checks are sometimes
duke@435	125	// made more stringent by an optimistic transformation.
duke@435	126	// This creates "tentative" range checks at this point,
duke@435	127	// which are not guaranteed to throw exceptions.
duke@435	128	// See IfNode::Ideal, is_range_check, adjust_check.
duke@435	129	uncommon_trap(Deoptimization::Reason_range_check,
duke@435	130	Deoptimization::Action_make_not_entrant,
duke@435	131	NULL, "range_check");
duke@435	132	} else {
duke@435	133	// If we have already recompiled with the range-check-widening
duke@435	134	// heroic optimization turned off, then we must really be throwing
duke@435	135	// range check exceptions.
duke@435	136	builtin_throw(Deoptimization::Reason_range_check, idx);
duke@435	137	}
duke@435	138	}
duke@435	139	}
duke@435	140	// Check for always knowing you are throwing a range-check exception
duke@435	141	if (stopped()) return top();
duke@435	142
duke@435	143	Node* ptr = array_element_address( ary, idx, type, sizetype);
duke@435	144
duke@435	145	if (result2 != NULL) *result2 = elemtype;
duke@435	146	return ptr;
duke@435	147	}
duke@435	148
duke@435	149
duke@435	150	// returns IfNode
duke@435	151	IfNode* Parse::jump_if_fork_int(Node* a, Node* b, BoolTest::mask mask) {
duke@435	152	Node *cmp = _gvn.transform( new (C, 3) CmpINode( a, b)); // two cases: shiftcount > 32 and shiftcount <= 32
duke@435	153	Node *tst = _gvn.transform( new (C, 2) BoolNode( cmp, mask));
duke@435	154	IfNode *iff = create_and_map_if( control(), tst, ((mask == BoolTest::eq) ? PROB_STATIC_INFREQUENT : PROB_FAIR), COUNT_UNKNOWN );
duke@435	155	return iff;
duke@435	156	}
duke@435	157
duke@435	158	// return Region node
duke@435	159	Node* Parse::jump_if_join(Node* iffalse, Node* iftrue) {
duke@435	160	Node *region = new (C, 3) RegionNode(3); // 2 results
duke@435	161	record_for_igvn(region);
duke@435	162	region->init_req(1, iffalse);
duke@435	163	region->init_req(2, iftrue );
duke@435	164	_gvn.set_type(region, Type::CONTROL);
duke@435	165	region = _gvn.transform(region);
duke@435	166	set_control (region);
duke@435	167	return region;
duke@435	168	}
duke@435	169
duke@435	170
duke@435	171	//------------------------------helper for tableswitch-------------------------
duke@435	172	void Parse::jump_if_true_fork(IfNode *iff, int dest_bci_if_true, int prof_table_index) {
duke@435	173	// True branch, use existing map info
duke@435	174	{ PreserveJVMState pjvms(this);
duke@435	175	Node *iftrue = _gvn.transform( new (C, 1) IfTrueNode (iff) );
duke@435	176	set_control( iftrue );
duke@435	177	profile_switch_case(prof_table_index);
duke@435	178	merge_new_path(dest_bci_if_true);
duke@435	179	}
duke@435	180
duke@435	181	// False branch
duke@435	182	Node *iffalse = _gvn.transform( new (C, 1) IfFalseNode(iff) );
duke@435	183	set_control( iffalse );
duke@435	184	}
duke@435	185
duke@435	186	void Parse::jump_if_false_fork(IfNode *iff, int dest_bci_if_true, int prof_table_index) {
duke@435	187	// True branch, use existing map info
duke@435	188	{ PreserveJVMState pjvms(this);
duke@435	189	Node *iffalse = _gvn.transform( new (C, 1) IfFalseNode (iff) );
duke@435	190	set_control( iffalse );
duke@435	191	profile_switch_case(prof_table_index);
duke@435	192	merge_new_path(dest_bci_if_true);
duke@435	193	}
duke@435	194
duke@435	195	// False branch
duke@435	196	Node *iftrue = _gvn.transform( new (C, 1) IfTrueNode(iff) );
duke@435	197	set_control( iftrue );
duke@435	198	}
duke@435	199
duke@435	200	void Parse::jump_if_always_fork(int dest_bci, int prof_table_index) {
duke@435	201	// False branch, use existing map and control()
duke@435	202	profile_switch_case(prof_table_index);
duke@435	203	merge_new_path(dest_bci);
duke@435	204	}
duke@435	205
duke@435	206
duke@435	207	extern "C" {
duke@435	208	static int jint_cmp(const void *i, const void *j) {
duke@435	209	int a = *(jint *)i;
duke@435	210	int b = *(jint *)j;
duke@435	211	return a > b ? 1 : a < b ? -1 : 0;
duke@435	212	}
duke@435	213	}
duke@435	214
duke@435	215
duke@435	216	// Default value for methodData switch indexing. Must be a negative value to avoid
duke@435	217	// conflict with any legal switch index.
duke@435	218	#define NullTableIndex -1
duke@435	219
duke@435	220	class SwitchRange : public StackObj {
duke@435	221	// a range of integers coupled with a bci destination
duke@435	222	jint _lo; // inclusive lower limit
duke@435	223	jint _hi; // inclusive upper limit
duke@435	224	int _dest;
duke@435	225	int _table_index; // index into method data table
duke@435	226
duke@435	227	public:
duke@435	228	jint lo() const { return _lo; }
duke@435	229	jint hi() const { return _hi; }
duke@435	230	int dest() const { return _dest; }
duke@435	231	int table_index() const { return _table_index; }
duke@435	232	bool is_singleton() const { return _lo == _hi; }
duke@435	233
duke@435	234	void setRange(jint lo, jint hi, int dest, int table_index) {
duke@435	235	assert(lo <= hi, "must be a non-empty range");
duke@435	236	_lo = lo, _hi = hi; _dest = dest; _table_index = table_index;
duke@435	237	}
duke@435	238	bool adjoinRange(jint lo, jint hi, int dest, int table_index) {
duke@435	239	assert(lo <= hi, "must be a non-empty range");
duke@435	240	if (lo == _hi+1 && dest == _dest && table_index == _table_index) {
duke@435	241	_hi = hi;
duke@435	242	return true;
duke@435	243	}
duke@435	244	return false;
duke@435	245	}
duke@435	246
duke@435	247	void set (jint value, int dest, int table_index) {
duke@435	248	setRange(value, value, dest, table_index);
duke@435	249	}
duke@435	250	bool adjoin(jint value, int dest, int table_index) {
duke@435	251	return adjoinRange(value, value, dest, table_index);
duke@435	252	}
duke@435	253
duke@435	254	void print(ciEnv* env) {
duke@435	255	if (is_singleton())
duke@435	256	tty->print(" {%d}=>%d", lo(), dest());
duke@435	257	else if (lo() == min_jint)
duke@435	258	tty->print(" {..%d}=>%d", hi(), dest());
duke@435	259	else if (hi() == max_jint)
duke@435	260	tty->print(" {%d..}=>%d", lo(), dest());
duke@435	261	else
duke@435	262	tty->print(" {%d..%d}=>%d", lo(), hi(), dest());
duke@435	263	}
duke@435	264	};
duke@435	265
duke@435	266
duke@435	267	//-------------------------------do_tableswitch--------------------------------
duke@435	268	void Parse::do_tableswitch() {
duke@435	269	Node* lookup = pop();
duke@435	270
duke@435	271	// Get information about tableswitch
duke@435	272	int default_dest = iter().get_dest_table(0);
duke@435	273	int lo_index = iter().get_int_table(1);
duke@435	274	int hi_index = iter().get_int_table(2);
duke@435	275	int len = hi_index - lo_index + 1;
duke@435	276
duke@435	277	if (len < 1) {
duke@435	278	// If this is a backward branch, add safepoint
duke@435	279	maybe_add_safepoint(default_dest);
duke@435	280	merge(default_dest);
duke@435	281	return;
duke@435	282	}
duke@435	283
duke@435	284	// generate decision tree, using trichotomy when possible
duke@435	285	int rnum = len+2;
duke@435	286	bool makes_backward_branch = false;
duke@435	287	SwitchRange* ranges = NEW_RESOURCE_ARRAY(SwitchRange, rnum);
duke@435	288	int rp = -1;
duke@435	289	if (lo_index != min_jint) {
duke@435	290	ranges[++rp].setRange(min_jint, lo_index-1, default_dest, NullTableIndex);
duke@435	291	}
duke@435	292	for (int j = 0; j < len; j++) {
duke@435	293	jint match_int = lo_index+j;
duke@435	294	int dest = iter().get_dest_table(j+3);
duke@435	295	makes_backward_branch |= (dest <= bci());
duke@435	296	int table_index = method_data_update() ? j : NullTableIndex;
duke@435	297	if (rp < 0 || !ranges[rp].adjoin(match_int, dest, table_index)) {
duke@435	298	ranges[++rp].set(match_int, dest, table_index);
duke@435	299	}
duke@435	300	}
duke@435	301	jint highest = lo_index+(len-1);
duke@435	302	assert(ranges[rp].hi() == highest, "");
duke@435	303	if (highest != max_jint
duke@435	304	&& !ranges[rp].adjoinRange(highest+1, max_jint, default_dest, NullTableIndex)) {
duke@435	305	ranges[++rp].setRange(highest+1, max_jint, default_dest, NullTableIndex);
duke@435	306	}
duke@435	307	assert(rp < len+2, "not too many ranges");
duke@435	308
duke@435	309	// Safepoint in case if backward branch observed
duke@435	310	if( makes_backward_branch && UseLoopSafepoints )
duke@435	311	add_safepoint();
duke@435	312
duke@435	313	jump_switch_ranges(lookup, &ranges[0], &ranges[rp]);
duke@435	314	}
duke@435	315
duke@435	316
duke@435	317	//------------------------------do_lookupswitch--------------------------------
duke@435	318	void Parse::do_lookupswitch() {
duke@435	319	Node *lookup = pop(); // lookup value
duke@435	320	// Get information about lookupswitch
duke@435	321	int default_dest = iter().get_dest_table(0);
duke@435	322	int len = iter().get_int_table(1);
duke@435	323
duke@435	324	if (len < 1) { // If this is a backward branch, add safepoint
duke@435	325	maybe_add_safepoint(default_dest);
duke@435	326	merge(default_dest);
duke@435	327	return;
duke@435	328	}
duke@435	329
duke@435	330	// generate decision tree, using trichotomy when possible
duke@435	331	jint* table = NEW_RESOURCE_ARRAY(jint, len*2);
duke@435	332	{
duke@435	333	for( int j = 0; j < len; j++ ) {
duke@435	334	table[j+j+0] = iter().get_int_table(2+j+j);
duke@435	335	table[j+j+1] = iter().get_dest_table(2+j+j+1);
duke@435	336	}
duke@435	337	qsort( table, len, 2*sizeof(table[0]), jint_cmp );
duke@435	338	}
duke@435	339
duke@435	340	int rnum = len*2+1;
duke@435	341	bool makes_backward_branch = false;
duke@435	342	SwitchRange* ranges = NEW_RESOURCE_ARRAY(SwitchRange, rnum);
duke@435	343	int rp = -1;
duke@435	344	for( int j = 0; j < len; j++ ) {
duke@435	345	jint match_int = table[j+j+0];
duke@435	346	int dest = table[j+j+1];
duke@435	347	int next_lo = rp < 0 ? min_jint : ranges[rp].hi()+1;
duke@435	348	int table_index = method_data_update() ? j : NullTableIndex;
duke@435	349	makes_backward_branch |= (dest <= bci());
duke@435	350	if( match_int != next_lo ) {
duke@435	351	ranges[++rp].setRange(next_lo, match_int-1, default_dest, NullTableIndex);
duke@435	352	}
duke@435	353	if( rp < 0 || !ranges[rp].adjoin(match_int, dest, table_index) ) {
duke@435	354	ranges[++rp].set(match_int, dest, table_index);
duke@435	355	}
duke@435	356	}
duke@435	357	jint highest = table[2*(len-1)];
duke@435	358	assert(ranges[rp].hi() == highest, "");
duke@435	359	if( highest != max_jint
duke@435	360	&& !ranges[rp].adjoinRange(highest+1, max_jint, default_dest, NullTableIndex) ) {
duke@435	361	ranges[++rp].setRange(highest+1, max_jint, default_dest, NullTableIndex);
duke@435	362	}
duke@435	363	assert(rp < rnum, "not too many ranges");
duke@435	364
duke@435	365	// Safepoint in case backward branch observed
duke@435	366	if( makes_backward_branch && UseLoopSafepoints )
duke@435	367	add_safepoint();
duke@435	368
duke@435	369	jump_switch_ranges(lookup, &ranges[0], &ranges[rp]);
duke@435	370	}
duke@435	371
duke@435	372	//----------------------------create_jump_tables-------------------------------
duke@435	373	bool Parse::create_jump_tables(Node* key_val, SwitchRange* lo, SwitchRange* hi) {
duke@435	374	// Are jumptables enabled
duke@435	375	if (!UseJumpTables) return false;
duke@435	376
duke@435	377	// Are jumptables supported
duke@435	378	if (!Matcher::has_match_rule(Op_Jump)) return false;
duke@435	379
duke@435	380	// Don't make jump table if profiling
duke@435	381	if (method_data_update()) return false;
duke@435	382
duke@435	383	// Decide if a guard is needed to lop off big ranges at either (or
duke@435	384	// both) end(s) of the input set. We'll call this the default target
duke@435	385	// even though we can't be sure that it is the true "default".
duke@435	386
duke@435	387	bool needs_guard = false;
duke@435	388	int default_dest;
duke@435	389	int64 total_outlier_size = 0;
duke@435	390	int64 hi_size = ((int64)hi->hi()) - ((int64)hi->lo()) + 1;
duke@435	391	int64 lo_size = ((int64)lo->hi()) - ((int64)lo->lo()) + 1;
duke@435	392
duke@435	393	if (lo->dest() == hi->dest()) {
duke@435	394	total_outlier_size = hi_size + lo_size;
duke@435	395	default_dest = lo->dest();
duke@435	396	} else if (lo_size > hi_size) {
duke@435	397	total_outlier_size = lo_size;
duke@435	398	default_dest = lo->dest();
duke@435	399	} else {
duke@435	400	total_outlier_size = hi_size;
duke@435	401	default_dest = hi->dest();
duke@435	402	}
duke@435	403
duke@435	404	// If a guard test will eliminate very sparse end ranges, then
duke@435	405	// it is worth the cost of an extra jump.
duke@435	406	if (total_outlier_size > (MaxJumpTableSparseness * 4)) {
duke@435	407	needs_guard = true;
duke@435	408	if (default_dest == lo->dest()) lo++;
duke@435	409	if (default_dest == hi->dest()) hi--;
duke@435	410	}
duke@435	411
duke@435	412	// Find the total number of cases and ranges
duke@435	413	int64 num_cases = ((int64)hi->hi()) - ((int64)lo->lo()) + 1;
duke@435	414	int num_range = hi - lo + 1;
duke@435	415
duke@435	416	// Don't create table if: too large, too small, or too sparse.
duke@435	417	if (num_cases < MinJumpTableSize || num_cases > MaxJumpTableSize)
duke@435	418	return false;
duke@435	419	if (num_cases > (MaxJumpTableSparseness * num_range))
duke@435	420	return false;
duke@435	421
duke@435	422	// Normalize table lookups to zero
duke@435	423	int lowval = lo->lo();
duke@435	424	key_val = _gvn.transform( new (C, 3) SubINode(key_val, _gvn.intcon(lowval)) );
duke@435	425
duke@435	426	// Generate a guard to protect against input keyvals that aren't
duke@435	427	// in the switch domain.
duke@435	428	if (needs_guard) {
duke@435	429	Node* size = _gvn.intcon(num_cases);
duke@435	430	Node* cmp = _gvn.transform( new (C, 3) CmpUNode(key_val, size) );
duke@435	431	Node* tst = _gvn.transform( new (C, 2) BoolNode(cmp, BoolTest::ge) );
duke@435	432	IfNode* iff = create_and_map_if( control(), tst, PROB_FAIR, COUNT_UNKNOWN);
duke@435	433	jump_if_true_fork(iff, default_dest, NullTableIndex);
duke@435	434	}
duke@435	435
duke@435	436	// Create an ideal node JumpTable that has projections
duke@435	437	// of all possible ranges for a switch statement
duke@435	438	// The key_val input must be converted to a pointer offset and scaled.
duke@435	439	// Compare Parse::array_addressing above.
duke@435	440	#ifdef _LP64
duke@435	441	// Clean the 32-bit int into a real 64-bit offset.
duke@435	442	// Otherwise, the jint value 0 might turn into an offset of 0x0800000000.
duke@435	443	const TypeLong* lkeytype = TypeLong::make(CONST64(0), num_cases-1, Type::WidenMin);
duke@435	444	key_val = _gvn.transform( new (C, 2) ConvI2LNode(key_val, lkeytype) );
duke@435	445	#endif
duke@435	446	// Shift the value by wordsize so we have an index into the table, rather
duke@435	447	// than a switch value
duke@435	448	Node *shiftWord = _gvn.MakeConX(wordSize);
duke@435	449	key_val = _gvn.transform( new (C, 3) MulXNode( key_val, shiftWord));
duke@435	450
duke@435	451	// Create the JumpNode
duke@435	452	Node* jtn = _gvn.transform( new (C, 2) JumpNode(control(), key_val, num_cases) );
duke@435	453
duke@435	454	// These are the switch destinations hanging off the jumpnode
duke@435	455	int i = 0;
duke@435	456	for (SwitchRange* r = lo; r <= hi; r++) {
duke@435	457	for (int j = r->lo(); j <= r->hi(); j++, i++) {
duke@435	458	Node* input = _gvn.transform(new (C, 1) JumpProjNode(jtn, i, r->dest(), j - lowval));
duke@435	459	{
duke@435	460	PreserveJVMState pjvms(this);
duke@435	461	set_control(input);
duke@435	462	jump_if_always_fork(r->dest(), r->table_index());
duke@435	463	}
duke@435	464	}
duke@435	465	}
duke@435	466	assert(i == num_cases, "miscount of cases");
duke@435	467	stop_and_kill_map(); // no more uses for this JVMS
duke@435	468	return true;
duke@435	469	}
duke@435	470
duke@435	471	//----------------------------jump_switch_ranges-------------------------------
duke@435	472	void Parse::jump_switch_ranges(Node* key_val, SwitchRange *lo, SwitchRange *hi, int switch_depth) {
duke@435	473	Block* switch_block = block();
duke@435	474
duke@435	475	if (switch_depth == 0) {
duke@435	476	// Do special processing for the top-level call.
duke@435	477	assert(lo->lo() == min_jint, "initial range must exhaust Type::INT");
duke@435	478	assert(hi->hi() == max_jint, "initial range must exhaust Type::INT");
duke@435	479
duke@435	480	// Decrement pred-numbers for the unique set of nodes.
duke@435	481	#ifdef ASSERT
duke@435	482	// Ensure that the block's successors are a (duplicate-free) set.
duke@435	483	int successors_counted = 0; // block occurrences in [hi..lo]
duke@435	484	int unique_successors = switch_block->num_successors();
duke@435	485	for (int i = 0; i < unique_successors; i++) {
duke@435	486	Block* target = switch_block->successor_at(i);
duke@435	487
duke@435	488	// Check that the set of successors is the same in both places.
duke@435	489	int successors_found = 0;
duke@435	490	for (SwitchRange* p = lo; p <= hi; p++) {
duke@435	491	if (p->dest() == target->start()) successors_found++;
duke@435	492	}
duke@435	493	assert(successors_found > 0, "successor must be known");
duke@435	494	successors_counted += successors_found;
duke@435	495	}
duke@435	496	assert(successors_counted == (hi-lo)+1, "no unexpected successors");
duke@435	497	#endif
duke@435	498
duke@435	499	// Maybe prune the inputs, based on the type of key_val.
duke@435	500	jint min_val = min_jint;
duke@435	501	jint max_val = max_jint;
duke@435	502	const TypeInt* ti = key_val->bottom_type()->isa_int();
duke@435	503	if (ti != NULL) {
duke@435	504	min_val = ti->_lo;
duke@435	505	max_val = ti->_hi;
duke@435	506	assert(min_val <= max_val, "invalid int type");
duke@435	507	}
duke@435	508	while (lo->hi() < min_val) lo++;
duke@435	509	if (lo->lo() < min_val) lo->setRange(min_val, lo->hi(), lo->dest(), lo->table_index());
duke@435	510	while (hi->lo() > max_val) hi--;
duke@435	511	if (hi->hi() > max_val) hi->setRange(hi->lo(), max_val, hi->dest(), hi->table_index());
duke@435	512	}
duke@435	513
duke@435	514	#ifndef PRODUCT
duke@435	515	if (switch_depth == 0) {
duke@435	516	_max_switch_depth = 0;
duke@435	517	_est_switch_depth = log2_intptr((hi-lo+1)-1)+1;
duke@435	518	}
duke@435	519	#endif
duke@435	520
duke@435	521	assert(lo <= hi, "must be a non-empty set of ranges");
duke@435	522	if (lo == hi) {
duke@435	523	jump_if_always_fork(lo->dest(), lo->table_index());
duke@435	524	} else {
duke@435	525	assert(lo->hi() == (lo+1)->lo()-1, "contiguous ranges");
duke@435	526	assert(hi->lo() == (hi-1)->hi()+1, "contiguous ranges");
duke@435	527
duke@435	528	if (create_jump_tables(key_val, lo, hi)) return;
duke@435	529
duke@435	530	int nr = hi - lo + 1;
duke@435	531
duke@435	532	SwitchRange* mid = lo + nr/2;
duke@435	533	// if there is an easy choice, pivot at a singleton:
duke@435	534	if (nr > 3 && !mid->is_singleton() && (mid-1)->is_singleton()) mid--;
duke@435	535
duke@435	536	assert(lo < mid && mid <= hi, "good pivot choice");
duke@435	537	assert(nr != 2 || mid == hi, "should pick higher of 2");
duke@435	538	assert(nr != 3 || mid == hi-1, "should pick middle of 3");
duke@435	539
duke@435	540	Node *test_val = _gvn.intcon(mid->lo());
duke@435	541
duke@435	542	if (mid->is_singleton()) {
duke@435	543	IfNode *iff_ne = jump_if_fork_int(key_val, test_val, BoolTest::ne);
duke@435	544	jump_if_false_fork(iff_ne, mid->dest(), mid->table_index());
duke@435	545
duke@435	546	// Special Case: If there are exactly three ranges, and the high
duke@435	547	// and low range each go to the same place, omit the "gt" test,
duke@435	548	// since it will not discriminate anything.
duke@435	549	bool eq_test_only = (hi == lo+2 && hi->dest() == lo->dest());
duke@435	550	if (eq_test_only) {
duke@435	551	assert(mid == hi-1, "");
duke@435	552	}
duke@435	553
duke@435	554	// if there is a higher range, test for it and process it:
duke@435	555	if (mid < hi && !eq_test_only) {
duke@435	556	// two comparisons of same values--should enable 1 test for 2 branches
duke@435	557	// Use BoolTest::le instead of BoolTest::gt
duke@435	558	IfNode *iff_le = jump_if_fork_int(key_val, test_val, BoolTest::le);
duke@435	559	Node *iftrue = _gvn.transform( new (C, 1) IfTrueNode(iff_le) );
duke@435	560	Node *iffalse = _gvn.transform( new (C, 1) IfFalseNode(iff_le) );
duke@435	561	{ PreserveJVMState pjvms(this);
duke@435	562	set_control(iffalse);
duke@435	563	jump_switch_ranges(key_val, mid+1, hi, switch_depth+1);
duke@435	564	}
duke@435	565	set_control(iftrue);
duke@435	566	}
duke@435	567
duke@435	568	} else {
duke@435	569	// mid is a range, not a singleton, so treat mid..hi as a unit
duke@435	570	IfNode *iff_ge = jump_if_fork_int(key_val, test_val, BoolTest::ge);
duke@435	571
duke@435	572	// if there is a higher range, test for it and process it:
duke@435	573	if (mid == hi) {
duke@435	574	jump_if_true_fork(iff_ge, mid->dest(), mid->table_index());
duke@435	575	} else {
duke@435	576	Node *iftrue = _gvn.transform( new (C, 1) IfTrueNode(iff_ge) );
duke@435	577	Node *iffalse = _gvn.transform( new (C, 1) IfFalseNode(iff_ge) );
duke@435	578	{ PreserveJVMState pjvms(this);
duke@435	579	set_control(iftrue);
duke@435	580	jump_switch_ranges(key_val, mid, hi, switch_depth+1);
duke@435	581	}
duke@435	582	set_control(iffalse);
duke@435	583	}
duke@435	584	}
duke@435	585
duke@435	586	// in any case, process the lower range
duke@435	587	jump_switch_ranges(key_val, lo, mid-1, switch_depth+1);
duke@435	588	}
duke@435	589
duke@435	590	// Decrease pred_count for each successor after all is done.
duke@435	591	if (switch_depth == 0) {
duke@435	592	int unique_successors = switch_block->num_successors();
duke@435	593	for (int i = 0; i < unique_successors; i++) {
duke@435	594	Block* target = switch_block->successor_at(i);
duke@435	595	// Throw away the pre-allocated path for each unique successor.
duke@435	596	target->next_path_num();
duke@435	597	}
duke@435	598	}
duke@435	599
duke@435	600	#ifndef PRODUCT
duke@435	601	_max_switch_depth = MAX2(switch_depth, _max_switch_depth);
duke@435	602	if (TraceOptoParse && Verbose && WizardMode && switch_depth == 0) {
duke@435	603	SwitchRange* r;
duke@435	604	int nsing = 0;
duke@435	605	for( r = lo; r <= hi; r++ ) {
duke@435	606	if( r->is_singleton() ) nsing++;
duke@435	607	}
duke@435	608	tty->print(">>> ");
duke@435	609	_method->print_short_name();
duke@435	610	tty->print_cr(" switch decision tree");
duke@435	611	tty->print_cr(" %d ranges (%d singletons), max_depth=%d, est_depth=%d",
duke@435	612	hi-lo+1, nsing, _max_switch_depth, _est_switch_depth);
duke@435	613	if (_max_switch_depth > _est_switch_depth) {
duke@435	614	tty->print_cr("******** BAD SWITCH DEPTH ********");
duke@435	615	}
duke@435	616	tty->print(" ");
duke@435	617	for( r = lo; r <= hi; r++ ) {
duke@435	618	r->print(env());
duke@435	619	}
duke@435	620	tty->print_cr("");
duke@435	621	}
duke@435	622	#endif
duke@435	623	}
duke@435	624
duke@435	625	void Parse::modf() {
duke@435	626	Node *f2 = pop();
duke@435	627	Node *f1 = pop();
duke@435	628	Node* c = make_runtime_call(RC_LEAF, OptoRuntime::modf_Type(),
duke@435	629	CAST_FROM_FN_PTR(address, SharedRuntime::frem),
duke@435	630	"frem", NULL, //no memory effects
duke@435	631	f1, f2);
duke@435	632	Node* res = _gvn.transform(new (C, 1) ProjNode(c, TypeFunc::Parms + 0));
duke@435	633
duke@435	634	push(res);
duke@435	635	}
duke@435	636
duke@435	637	void Parse::modd() {
duke@435	638	Node *d2 = pop_pair();
duke@435	639	Node *d1 = pop_pair();
duke@435	640	Node* c = make_runtime_call(RC_LEAF, OptoRuntime::Math_DD_D_Type(),
duke@435	641	CAST_FROM_FN_PTR(address, SharedRuntime::drem),
duke@435	642	"drem", NULL, //no memory effects
duke@435	643	d1, top(), d2, top());
duke@435	644	Node* res_d = _gvn.transform(new (C, 1) ProjNode(c, TypeFunc::Parms + 0));
duke@435	645
duke@435	646	#ifdef ASSERT
duke@435	647	Node* res_top = _gvn.transform(new (C, 1) ProjNode(c, TypeFunc::Parms + 1));
duke@435	648	assert(res_top == top(), "second value must be top");
duke@435	649	#endif
duke@435	650
duke@435	651	push_pair(res_d);
duke@435	652	}
duke@435	653
duke@435	654	void Parse::l2f() {
duke@435	655	Node* f2 = pop();
duke@435	656	Node* f1 = pop();
duke@435	657	Node* c = make_runtime_call(RC_LEAF, OptoRuntime::l2f_Type(),
duke@435	658	CAST_FROM_FN_PTR(address, SharedRuntime::l2f),
duke@435	659	"l2f", NULL, //no memory effects
duke@435	660	f1, f2);
duke@435	661	Node* res = _gvn.transform(new (C, 1) ProjNode(c, TypeFunc::Parms + 0));
duke@435	662
duke@435	663	push(res);
duke@435	664	}
duke@435	665
duke@435	666	void Parse::do_irem() {
duke@435	667	// Must keep both values on the expression-stack during null-check
duke@435	668	do_null_check(peek(), T_INT);
duke@435	669	// Compile-time detect of null-exception?
duke@435	670	if (stopped()) return;
duke@435	671
duke@435	672	Node* b = pop();
duke@435	673	Node* a = pop();
duke@435	674
duke@435	675	const Type *t = _gvn.type(b);
duke@435	676	if (t != Type::TOP) {
duke@435	677	const TypeInt *ti = t->is_int();
duke@435	678	if (ti->is_con()) {
duke@435	679	int divisor = ti->get_con();
duke@435	680	// check for positive power of 2
duke@435	681	if (divisor > 0 &&
duke@435	682	(divisor & ~(divisor-1)) == divisor) {
duke@435	683	// yes !
duke@435	684	Node *mask = _gvn.intcon((divisor - 1));
duke@435	685	// Sigh, must handle negative dividends
duke@435	686	Node *zero = _gvn.intcon(0);
duke@435	687	IfNode *ifff = jump_if_fork_int(a, zero, BoolTest::lt);
duke@435	688	Node *iff = _gvn.transform( new (C, 1) IfFalseNode(ifff) );
duke@435	689	Node *ift = _gvn.transform( new (C, 1) IfTrueNode (ifff) );
duke@435	690	Node *reg = jump_if_join(ift, iff);
duke@435	691	Node *phi = PhiNode::make(reg, NULL, TypeInt::INT);
duke@435	692	// Negative path; negate/and/negate
duke@435	693	Node *neg = _gvn.transform( new (C, 3) SubINode(zero, a) );
duke@435	694	Node *andn= _gvn.transform( new (C, 3) AndINode(neg, mask) );
duke@435	695	Node *negn= _gvn.transform( new (C, 3) SubINode(zero, andn) );
duke@435	696	phi->init_req(1, negn);
duke@435	697	// Fast positive case
duke@435	698	Node *andx = _gvn.transform( new (C, 3) AndINode(a, mask) );
duke@435	699	phi->init_req(2, andx);
duke@435	700	// Push the merge
duke@435	701	push( _gvn.transform(phi) );
duke@435	702	return;
duke@435	703	}
duke@435	704	}
duke@435	705	}
duke@435	706	// Default case
duke@435	707	push( _gvn.transform( new (C, 3) ModINode(control(),a,b) ) );
duke@435	708	}
duke@435	709
duke@435	710	// Handle jsr and jsr_w bytecode
duke@435	711	void Parse::do_jsr() {
duke@435	712	assert(bc() == Bytecodes::_jsr || bc() == Bytecodes::_jsr_w, "wrong bytecode");
duke@435	713
duke@435	714	// Store information about current state, tagged with new _jsr_bci
duke@435	715	int return_bci = iter().next_bci();
duke@435	716	int jsr_bci = (bc() == Bytecodes::_jsr) ? iter().get_dest() : iter().get_far_dest();
duke@435	717
duke@435	718	// Update method data
duke@435	719	profile_taken_branch(jsr_bci);
duke@435	720
duke@435	721	// The way we do things now, there is only one successor block
duke@435	722	// for the jsr, because the target code is cloned by ciTypeFlow.
duke@435	723	Block* target = successor_for_bci(jsr_bci);
duke@435	724
duke@435	725	// What got pushed?
duke@435	726	const Type* ret_addr = target->peek();
duke@435	727	assert(ret_addr->singleton(), "must be a constant (cloned jsr body)");
duke@435	728
duke@435	729	// Effect on jsr on stack
duke@435	730	push(_gvn.makecon(ret_addr));
duke@435	731
duke@435	732	// Flow to the jsr.
duke@435	733	merge(jsr_bci);
duke@435	734	}
duke@435	735
duke@435	736	// Handle ret bytecode
duke@435	737	void Parse::do_ret() {
duke@435	738	// Find to whom we return.
duke@435	739	#if 0 // %%%% MAKE THIS WORK
duke@435	740	Node* con = local();
duke@435	741	const TypePtr* tp = con->bottom_type()->isa_ptr();
duke@435	742	assert(tp && tp->singleton(), "");
duke@435	743	int return_bci = (int) tp->get_con();
duke@435	744	merge(return_bci);
duke@435	745	#else
duke@435	746	assert(block()->num_successors() == 1, "a ret can only go one place now");
duke@435	747	Block* target = block()->successor_at(0);
duke@435	748	assert(!target->is_ready(), "our arrival must be expected");
duke@435	749	profile_ret(target->flow()->start());
duke@435	750	int pnum = target->next_path_num();
duke@435	751	merge_common(target, pnum);
duke@435	752	#endif
duke@435	753	}
duke@435	754
duke@435	755	//--------------------------dynamic_branch_prediction--------------------------
duke@435	756	// Try to gather dynamic branch prediction behavior. Return a probability
duke@435	757	// of the branch being taken and set the "cnt" field. Returns a -1.0
duke@435	758	// if we need to use static prediction for some reason.
duke@435	759	float Parse::dynamic_branch_prediction(float &cnt) {
duke@435	760	ResourceMark rm;
duke@435	761
duke@435	762	cnt = COUNT_UNKNOWN;
duke@435	763
duke@435	764	// Use MethodData information if it is available
duke@435	765	// FIXME: free the ProfileData structure
duke@435	766	ciMethodData* methodData = method()->method_data();
duke@435	767	if (!methodData->is_mature()) return PROB_UNKNOWN;
duke@435	768	ciProfileData* data = methodData->bci_to_data(bci());
duke@435	769	if (!data->is_JumpData()) return PROB_UNKNOWN;
duke@435	770
duke@435	771	// get taken and not taken values
duke@435	772	int taken = data->as_JumpData()->taken();
duke@435	773	int not_taken = 0;
duke@435	774	if (data->is_BranchData()) {
duke@435	775	not_taken = data->as_BranchData()->not_taken();
duke@435	776	}
duke@435	777
duke@435	778	// scale the counts to be commensurate with invocation counts:
duke@435	779	taken = method()->scale_count(taken);
duke@435	780	not_taken = method()->scale_count(not_taken);
duke@435	781
duke@435	782	// Give up if too few counts to be meaningful
duke@435	783	if (taken + not_taken < 40) {
duke@435	784	if (C->log() != NULL) {
duke@435	785	C->log()->elem("branch target_bci='%d' taken='%d' not_taken='%d'", iter().get_dest(), taken, not_taken);
duke@435	786	}
duke@435	787	return PROB_UNKNOWN;
duke@435	788	}
duke@435	789
duke@435	790	// Compute frequency that we arrive here
duke@435	791	int sum = taken + not_taken;
duke@435	792	// Adjust, if this block is a cloned private block but the
duke@435	793	// Jump counts are shared. Taken the private counts for
duke@435	794	// just this path instead of the shared counts.
duke@435	795	if( block()->count() > 0 )
duke@435	796	sum = block()->count();
duke@435	797	cnt = (float)sum / (float)FreqCountInvocations;
duke@435	798
duke@435	799	// Pin probability to sane limits
duke@435	800	float prob;
duke@435	801	if( !taken )
duke@435	802	prob = (0+PROB_MIN) / 2;
duke@435	803	else if( !not_taken )
duke@435	804	prob = (1+PROB_MAX) / 2;
duke@435	805	else { // Compute probability of true path
duke@435	806	prob = (float)taken / (float)(taken + not_taken);
duke@435	807	if (prob > PROB_MAX) prob = PROB_MAX;
duke@435	808	if (prob < PROB_MIN) prob = PROB_MIN;
duke@435	809	}
duke@435	810
duke@435	811	assert((cnt > 0.0f) && (prob > 0.0f),
duke@435	812	"Bad frequency assignment in if");
duke@435	813
duke@435	814	if (C->log() != NULL) {
duke@435	815	const char* prob_str = NULL;
duke@435	816	if (prob >= PROB_MAX) prob_str = (prob == PROB_MAX) ? "max" : "always";
duke@435	817	if (prob <= PROB_MIN) prob_str = (prob == PROB_MIN) ? "min" : "never";
duke@435	818	char prob_str_buf[30];
duke@435	819	if (prob_str == NULL) {
duke@435	820	sprintf(prob_str_buf, "%g", prob);
duke@435	821	prob_str = prob_str_buf;
duke@435	822	}
duke@435	823	C->log()->elem("branch target_bci='%d' taken='%d' not_taken='%d' cnt='%g' prob='%s'",
duke@435	824	iter().get_dest(), taken, not_taken, cnt, prob_str);
duke@435	825	}
duke@435	826	return prob;
duke@435	827	}
duke@435	828
duke@435	829	//-----------------------------branch_prediction-------------------------------
duke@435	830	float Parse::branch_prediction(float& cnt,
duke@435	831	BoolTest::mask btest,
duke@435	832	int target_bci) {
duke@435	833	float prob = dynamic_branch_prediction(cnt);
duke@435	834	// If prob is unknown, switch to static prediction
duke@435	835	if (prob != PROB_UNKNOWN) return prob;
duke@435	836
duke@435	837	prob = PROB_FAIR; // Set default value
duke@435	838	if (btest == BoolTest::eq) // Exactly equal test?
duke@435	839	prob = PROB_STATIC_INFREQUENT; // Assume its relatively infrequent
duke@435	840	else if (btest == BoolTest::ne)
duke@435	841	prob = PROB_STATIC_FREQUENT; // Assume its relatively frequent
duke@435	842
duke@435	843	// If this is a conditional test guarding a backwards branch,
duke@435	844	// assume its a loop-back edge. Make it a likely taken branch.
duke@435	845	if (target_bci < bci()) {
duke@435	846	if (is_osr_parse()) { // Could be a hot OSR'd loop; force deopt
duke@435	847	// Since it's an OSR, we probably have profile data, but since
duke@435	848	// branch_prediction returned PROB_UNKNOWN, the counts are too small.
duke@435	849	// Let's make a special check here for completely zero counts.
duke@435	850	ciMethodData* methodData = method()->method_data();
duke@435	851	if (!methodData->is_empty()) {
duke@435	852	ciProfileData* data = methodData->bci_to_data(bci());
duke@435	853	// Only stop for truly zero counts, which mean an unknown part
duke@435	854	// of the OSR-ed method, and we want to deopt to gather more stats.
duke@435	855	// If you have ANY counts, then this loop is simply 'cold' relative
duke@435	856	// to the OSR loop.
duke@435	857	if (data->as_BranchData()->taken() +
duke@435	858	data->as_BranchData()->not_taken() == 0 ) {
duke@435	859	// This is the only way to return PROB_UNKNOWN:
duke@435	860	return PROB_UNKNOWN;
duke@435	861	}
duke@435	862	}
duke@435	863	}
duke@435	864	prob = PROB_STATIC_FREQUENT; // Likely to take backwards branch
duke@435	865	}
duke@435	866
duke@435	867	assert(prob != PROB_UNKNOWN, "must have some guess at this point");
duke@435	868	return prob;
duke@435	869	}
duke@435	870
duke@435	871	// The magic constants are chosen so as to match the output of
duke@435	872	// branch_prediction() when the profile reports a zero taken count.
duke@435	873	// It is important to distinguish zero counts unambiguously, because
duke@435	874	// some branches (e.g., _213_javac.Assembler.eliminate) validly produce
duke@435	875	// very small but nonzero probabilities, which if confused with zero
duke@435	876	// counts would keep the program recompiling indefinitely.
duke@435	877	bool Parse::seems_never_taken(float prob) {
duke@435	878	return prob < PROB_MIN;
duke@435	879	}
duke@435	880
duke@435	881	inline void Parse::repush_if_args() {
duke@435	882	#ifndef PRODUCT
duke@435	883	if (PrintOpto && WizardMode) {
duke@435	884	tty->print("defending against excessive implicit null exceptions on %s @%d in ",
duke@435	885	Bytecodes::name(iter().cur_bc()), iter().cur_bci());
duke@435	886	method()->print_name(); tty->cr();
duke@435	887	}
duke@435	888	#endif
duke@435	889	int bc_depth = - Bytecodes::depth(iter().cur_bc());
duke@435	890	assert(bc_depth == 1 || bc_depth == 2, "only two kinds of branches");
duke@435	891	DEBUG_ONLY(sync_jvms()); // argument(n) requires a synced jvms
duke@435	892	assert(argument(0) != NULL, "must exist");
duke@435	893	assert(bc_depth == 1 || argument(1) != NULL, "two must exist");
duke@435	894	_sp += bc_depth;
duke@435	895	}
duke@435	896
duke@435	897	//----------------------------------do_ifnull----------------------------------
duke@435	898	void Parse::do_ifnull(BoolTest::mask btest) {
duke@435	899	int target_bci = iter().get_dest();
duke@435	900
never@452	901	Block* branch_block = successor_for_bci(target_bci);
never@452	902	Block* next_block = successor_for_bci(iter().next_bci());
never@452	903
duke@435	904	float cnt;
duke@435	905	float prob = branch_prediction(cnt, btest, target_bci);
duke@435	906	if (prob == PROB_UNKNOWN) {
duke@435	907	// (An earlier version of do_ifnull omitted this trap for OSR methods.)
duke@435	908	#ifndef PRODUCT
duke@435	909	if (PrintOpto && Verbose)
duke@435	910	tty->print_cr("Never-taken backedge stops compilation at bci %d",bci());
duke@435	911	#endif
duke@435	912	repush_if_args(); // to gather stats on loop
duke@435	913	// We need to mark this branch as taken so that if we recompile we will
duke@435	914	// see that it is possible. In the tiered system the interpreter doesn't
duke@435	915	// do profiling and by the time we get to the lower tier from the interpreter
duke@435	916	// the path may be cold again. Make sure it doesn't look untaken
duke@435	917	profile_taken_branch(target_bci, !ProfileInterpreter);
duke@435	918	uncommon_trap(Deoptimization::Reason_unreached,
duke@435	919	Deoptimization::Action_reinterpret,
duke@435	920	NULL, "cold");
never@452	921	if (EliminateAutoBox) {
never@452	922	// Mark the successor blocks as parsed
never@452	923	branch_block->next_path_num();
never@452	924	next_block->next_path_num();
never@452	925	}
duke@435	926	return;
duke@435	927	}
duke@435	928
duke@435	929	// If this is a backwards branch in the bytecodes, add Safepoint
duke@435	930	maybe_add_safepoint(target_bci);
duke@435	931
duke@435	932	explicit_null_checks_inserted++;
duke@435	933	Node* a = null();
duke@435	934	Node* b = pop();
duke@435	935	Node* c = _gvn.transform( new (C, 3) CmpPNode(b, a) );
duke@435	936
duke@435	937	// Make a cast-away-nullness that is control dependent on the test
duke@435	938	const Type *t = _gvn.type(b);
duke@435	939	const Type *t_not_null = t->join(TypePtr::NOTNULL);
duke@435	940	Node *cast = new (C, 2) CastPPNode(b,t_not_null);
duke@435	941
duke@435	942	// Generate real control flow
duke@435	943	Node *tst = _gvn.transform( new (C, 2) BoolNode( c, btest ) );
duke@435	944
duke@435	945	// Sanity check the probability value
duke@435	946	assert(prob > 0.0f,"Bad probability in Parser");
duke@435	947	// Need xform to put node in hash table
duke@435	948	IfNode *iff = create_and_xform_if( control(), tst, prob, cnt );
duke@435	949	assert(iff->_prob > 0.0f,"Optimizer made bad probability in parser");
duke@435	950	// True branch
duke@435	951	{ PreserveJVMState pjvms(this);
duke@435	952	Node* iftrue = _gvn.transform( new (C, 1) IfTrueNode (iff) );
duke@435	953	set_control(iftrue);
duke@435	954
duke@435	955	if (stopped()) { // Path is dead?
duke@435	956	explicit_null_checks_elided++;
never@452	957	if (EliminateAutoBox) {
never@452	958	// Mark the successor block as parsed
never@452	959	branch_block->next_path_num();
never@452	960	}
duke@435	961	} else { // Path is live.
duke@435	962	// Update method data
duke@435	963	profile_taken_branch(target_bci);
duke@435	964	adjust_map_after_if(btest, c, prob, branch_block, next_block);
duke@435	965	if (!stopped())
duke@435	966	merge(target_bci);
duke@435	967	}
duke@435	968	}
duke@435	969
duke@435	970	// False branch
duke@435	971	Node* iffalse = _gvn.transform( new (C, 1) IfFalseNode(iff) );
duke@435	972	set_control(iffalse);
duke@435	973
duke@435	974	if (stopped()) { // Path is dead?
duke@435	975	explicit_null_checks_elided++;
never@452	976	if (EliminateAutoBox) {
never@452	977	// Mark the successor block as parsed
never@452	978	next_block->next_path_num();
never@452	979	}
duke@435	980	} else { // Path is live.
duke@435	981	// Update method data
duke@435	982	profile_not_taken_branch();
duke@435	983	adjust_map_after_if(BoolTest(btest).negate(), c, 1.0-prob,
duke@435	984	next_block, branch_block);
duke@435	985	}
duke@435	986	}
duke@435	987
duke@435	988	//------------------------------------do_if------------------------------------
duke@435	989	void Parse::do_if(BoolTest::mask btest, Node* c) {
duke@435	990	int target_bci = iter().get_dest();
duke@435	991
never@452	992	Block* branch_block = successor_for_bci(target_bci);
never@452	993	Block* next_block = successor_for_bci(iter().next_bci());
never@452	994
duke@435	995	float cnt;
duke@435	996	float prob = branch_prediction(cnt, btest, target_bci);
duke@435	997	float untaken_prob = 1.0 - prob;
duke@435	998
duke@435	999	if (prob == PROB_UNKNOWN) {
duke@435	1000	#ifndef PRODUCT
duke@435	1001	if (PrintOpto && Verbose)
duke@435	1002	tty->print_cr("Never-taken backedge stops compilation at bci %d",bci());
duke@435	1003	#endif
duke@435	1004	repush_if_args(); // to gather stats on loop
duke@435	1005	// We need to mark this branch as taken so that if we recompile we will
duke@435	1006	// see that it is possible. In the tiered system the interpreter doesn't
duke@435	1007	// do profiling and by the time we get to the lower tier from the interpreter
duke@435	1008	// the path may be cold again. Make sure it doesn't look untaken
duke@435	1009	profile_taken_branch(target_bci, !ProfileInterpreter);
duke@435	1010	uncommon_trap(Deoptimization::Reason_unreached,
duke@435	1011	Deoptimization::Action_reinterpret,
duke@435	1012	NULL, "cold");
never@452	1013	if (EliminateAutoBox) {
never@452	1014	// Mark the successor blocks as parsed
never@452	1015	branch_block->next_path_num();
never@452	1016	next_block->next_path_num();
never@452	1017	}
duke@435	1018	return;
duke@435	1019	}
duke@435	1020
duke@435	1021	// Sanity check the probability value
duke@435	1022	assert(0.0f < prob && prob < 1.0f,"Bad probability in Parser");
duke@435	1023
duke@435	1024	bool taken_if_true = true;
duke@435	1025	// Convert BoolTest to canonical form:
duke@435	1026	if (!BoolTest(btest).is_canonical()) {
duke@435	1027	btest = BoolTest(btest).negate();
duke@435	1028	taken_if_true = false;
duke@435	1029	// prob is NOT updated here; it remains the probability of the taken
duke@435	1030	// path (as opposed to the prob of the path guarded by an 'IfTrueNode').
duke@435	1031	}
duke@435	1032	assert(btest != BoolTest::eq, "!= is the only canonical exact test");
duke@435	1033
duke@435	1034	Node* tst0 = new (C, 2) BoolNode(c, btest);
duke@435	1035	Node* tst = _gvn.transform(tst0);
duke@435	1036	BoolTest::mask taken_btest = BoolTest::illegal;
duke@435	1037	BoolTest::mask untaken_btest = BoolTest::illegal;
kvn@472	1038
kvn@472	1039	if (tst->is_Bool()) {
kvn@472	1040	// Refresh c from the transformed bool node, since it may be
kvn@472	1041	// simpler than the original c. Also re-canonicalize btest.
kvn@472	1042	// This wins when (Bool ne (Conv2B p) 0) => (Bool ne (CmpP p NULL)).
kvn@472	1043	// That can arise from statements like: if (x instanceof C) ...
kvn@472	1044	if (tst != tst0) {
kvn@472	1045	// Canonicalize one more time since transform can change it.
kvn@472	1046	btest = tst->as_Bool()->_test._test;
kvn@472	1047	if (!BoolTest(btest).is_canonical()) {
kvn@472	1048	// Reverse edges one more time...
kvn@472	1049	tst = _gvn.transform( tst->as_Bool()->negate(&_gvn) );
kvn@472	1050	btest = tst->as_Bool()->_test._test;
kvn@472	1051	assert(BoolTest(btest).is_canonical(), "sanity");
kvn@472	1052	taken_if_true = !taken_if_true;
kvn@472	1053	}
kvn@472	1054	c = tst->in(1);
kvn@472	1055	}
kvn@472	1056	BoolTest::mask neg_btest = BoolTest(btest).negate();
kvn@472	1057	taken_btest = taken_if_true ? btest : neg_btest;
kvn@472	1058	untaken_btest = taken_if_true ? neg_btest : btest;
duke@435	1059	}
duke@435	1060
duke@435	1061	// Generate real control flow
duke@435	1062	float true_prob = (taken_if_true ? prob : untaken_prob);
duke@435	1063	IfNode* iff = create_and_map_if(control(), tst, true_prob, cnt);
duke@435	1064	assert(iff->_prob > 0.0f,"Optimizer made bad probability in parser");
duke@435	1065	Node* taken_branch = new (C, 1) IfTrueNode(iff);
duke@435	1066	Node* untaken_branch = new (C, 1) IfFalseNode(iff);
duke@435	1067	if (!taken_if_true) { // Finish conversion to canonical form
duke@435	1068	Node* tmp = taken_branch;
duke@435	1069	taken_branch = untaken_branch;
duke@435	1070	untaken_branch = tmp;
duke@435	1071	}
duke@435	1072
duke@435	1073	// Branch is taken:
duke@435	1074	{ PreserveJVMState pjvms(this);
duke@435	1075	taken_branch = _gvn.transform(taken_branch);
duke@435	1076	set_control(taken_branch);
duke@435	1077
never@452	1078	if (stopped()) {
never@452	1079	if (EliminateAutoBox) {
never@452	1080	// Mark the successor block as parsed
never@452	1081	branch_block->next_path_num();
never@452	1082	}
never@452	1083	} else {
duke@435	1084	// Update method data
duke@435	1085	profile_taken_branch(target_bci);
duke@435	1086	adjust_map_after_if(taken_btest, c, prob, branch_block, next_block);
duke@435	1087	if (!stopped())
duke@435	1088	merge(target_bci);
duke@435	1089	}
duke@435	1090	}
duke@435	1091
duke@435	1092	untaken_branch = _gvn.transform(untaken_branch);
duke@435	1093	set_control(untaken_branch);
duke@435	1094
duke@435	1095	// Branch not taken.
never@452	1096	if (stopped()) {
never@452	1097	if (EliminateAutoBox) {
never@452	1098	// Mark the successor block as parsed
never@452	1099	next_block->next_path_num();
never@452	1100	}
never@452	1101	} else {
duke@435	1102	// Update method data
duke@435	1103	profile_not_taken_branch();
duke@435	1104	adjust_map_after_if(untaken_btest, c, untaken_prob,
duke@435	1105	next_block, branch_block);
duke@435	1106	}
duke@435	1107	}
duke@435	1108
duke@435	1109	//----------------------------adjust_map_after_if------------------------------
duke@435	1110	// Adjust the JVM state to reflect the result of taking this path.
duke@435	1111	// Basically, it means inspecting the CmpNode controlling this
duke@435	1112	// branch, seeing how it constrains a tested value, and then
duke@435	1113	// deciding if it's worth our while to encode this constraint
duke@435	1114	// as graph nodes in the current abstract interpretation map.
duke@435	1115	void Parse::adjust_map_after_if(BoolTest::mask btest, Node* c, float prob,
duke@435	1116	Block* path, Block* other_path) {
duke@435	1117	if (stopped() || !c->is_Cmp() || btest == BoolTest::illegal)
duke@435	1118	return; // nothing to do
duke@435	1119
duke@435	1120	bool is_fallthrough = (path == successor_for_bci(iter().next_bci()));
duke@435	1121
duke@435	1122	int cop = c->Opcode();
duke@435	1123	if (seems_never_taken(prob) && cop == Op_CmpP && btest == BoolTest::eq) {
duke@435	1124	// (An earlier version of do_if omitted '&& btest == BoolTest::eq'.)
duke@435	1125	//
duke@435	1126	// If this might possibly turn into an implicit null check,
duke@435	1127	// and the null has never yet been seen, we need to generate
duke@435	1128	// an uncommon trap, so as to recompile instead of suffering
duke@435	1129	// with very slow branches. (We'll get the slow branches if
duke@435	1130	// the program ever changes phase and starts seeing nulls here.)
duke@435	1131	//
duke@435	1132	// The tests we worry about are of the form (p == null).
duke@435	1133	// We do not simply inspect for a null constant, since a node may
duke@435	1134	// optimize to 'null' later on.
duke@435	1135	repush_if_args();
duke@435	1136	// We need to mark this branch as taken so that if we recompile we will
duke@435	1137	// see that it is possible. In the tiered system the interpreter doesn't
duke@435	1138	// do profiling and by the time we get to the lower tier from the interpreter
duke@435	1139	// the path may be cold again. Make sure it doesn't look untaken
duke@435	1140	if (is_fallthrough) {
duke@435	1141	profile_not_taken_branch(!ProfileInterpreter);
duke@435	1142	} else {
duke@435	1143	profile_taken_branch(iter().get_dest(), !ProfileInterpreter);
duke@435	1144	}
duke@435	1145	uncommon_trap(Deoptimization::Reason_unreached,
duke@435	1146	Deoptimization::Action_reinterpret,
duke@435	1147	NULL,
duke@435	1148	(is_fallthrough ? "taken always" : "taken never"));
duke@435	1149	return;
duke@435	1150	}
duke@435	1151
duke@435	1152	Node* val = c->in(1);
duke@435	1153	Node* con = c->in(2);
duke@435	1154	const Type* tcon = _gvn.type(con);
duke@435	1155	const Type* tval = _gvn.type(val);
duke@435	1156	bool have_con = tcon->singleton();
duke@435	1157	if (tval->singleton()) {
duke@435	1158	if (!have_con) {
duke@435	1159	// Swap, so constant is in con.
duke@435	1160	con = val;
duke@435	1161	tcon = tval;
duke@435	1162	val = c->in(2);
duke@435	1163	tval = _gvn.type(val);
duke@435	1164	btest = BoolTest(btest).commute();
duke@435	1165	have_con = true;
duke@435	1166	} else {
duke@435	1167	// Do we have two constants? Then leave well enough alone.
duke@435	1168	have_con = false;
duke@435	1169	}
duke@435	1170	}
duke@435	1171	if (!have_con) // remaining adjustments need a con
duke@435	1172	return;
duke@435	1173
duke@435	1174
duke@435	1175	int val_in_map = map()->find_edge(val);
duke@435	1176	if (val_in_map < 0) return; // replace_in_map would be useless
duke@435	1177	{
duke@435	1178	JVMState* jvms = this->jvms();
duke@435	1179	if (!(jvms->is_loc(val_in_map) ||
duke@435	1180	jvms->is_stk(val_in_map)))
duke@435	1181	return; // again, it would be useless
duke@435	1182	}
duke@435	1183
duke@435	1184	// Check for a comparison to a constant, and "know" that the compared
duke@435	1185	// value is constrained on this path.
duke@435	1186	assert(tcon->singleton(), "");
duke@435	1187	ConstraintCastNode* ccast = NULL;
duke@435	1188	Node* cast = NULL;
duke@435	1189
duke@435	1190	switch (btest) {
duke@435	1191	case BoolTest::eq: // Constant test?
duke@435	1192	{
duke@435	1193	const Type* tboth = tcon->join(tval);
duke@435	1194	if (tboth == tval) break; // Nothing to gain.
duke@435	1195	if (tcon->isa_int()) {
duke@435	1196	ccast = new (C, 2) CastIINode(val, tboth);
duke@435	1197	} else if (tcon == TypePtr::NULL_PTR) {
duke@435	1198	// Cast to null, but keep the pointer identity temporarily live.
duke@435	1199	ccast = new (C, 2) CastPPNode(val, tboth);
duke@435	1200	} else {
duke@435	1201	const TypeF* tf = tcon->isa_float_constant();
duke@435	1202	const TypeD* td = tcon->isa_double_constant();
duke@435	1203	// Exclude tests vs float/double 0 as these could be
duke@435	1204	// either +0 or -0. Just because you are equal to +0
duke@435	1205	// doesn't mean you ARE +0!
duke@435	1206	if ((!tf || tf->_f != 0.0) &&
duke@435	1207	(!td || td->_d != 0.0))
duke@435	1208	cast = con; // Replace non-constant val by con.
duke@435	1209	}
duke@435	1210	}
duke@435	1211	break;
duke@435	1212
duke@435	1213	case BoolTest::ne:
duke@435	1214	if (tcon == TypePtr::NULL_PTR) {
duke@435	1215	cast = cast_not_null(val, false);
duke@435	1216	}
duke@435	1217	break;
duke@435	1218
duke@435	1219	default:
duke@435	1220	// (At this point we could record int range types with CastII.)
duke@435	1221	break;
duke@435	1222	}
duke@435	1223
duke@435	1224	if (ccast != NULL) {
duke@435	1225	const Type* tcc = ccast->as_Type()->type();
duke@435	1226	assert(tcc != tval && tcc->higher_equal(tval), "must improve");
duke@435	1227	// Delay transform() call to allow recovery of pre-cast value
duke@435	1228	// at the control merge.
duke@435	1229	ccast->set_req(0, control());
duke@435	1230	_gvn.set_type_bottom(ccast);
duke@435	1231	record_for_igvn(ccast);
duke@435	1232	cast = ccast;
duke@435	1233	}
duke@435	1234
duke@435	1235	if (cast != NULL) { // Here's the payoff.
duke@435	1236	replace_in_map(val, cast);
duke@435	1237	}
duke@435	1238	}
duke@435	1239
duke@435	1240
duke@435	1241	//------------------------------do_one_bytecode--------------------------------
duke@435	1242	// Parse this bytecode, and alter the Parsers JVM->Node mapping
duke@435	1243	void Parse::do_one_bytecode() {
duke@435	1244	Node *a, *b, *c, *d; // Handy temps
duke@435	1245	BoolTest::mask btest;
duke@435	1246	int i;
duke@435	1247
duke@435	1248	assert(!has_exceptions(), "bytecode entry state must be clear of throws");
duke@435	1249
duke@435	1250	if (C->check_node_count(NodeLimitFudgeFactor * 5,
duke@435	1251	"out of nodes parsing method")) {
duke@435	1252	return;
duke@435	1253	}
duke@435	1254
duke@435	1255	#ifdef ASSERT
duke@435	1256	// for setting breakpoints
duke@435	1257	if (TraceOptoParse) {
duke@435	1258	tty->print(" @");
duke@435	1259	dump_bci(bci());
duke@435	1260	}
duke@435	1261	#endif
duke@435	1262
duke@435	1263	switch (bc()) {
duke@435	1264	case Bytecodes::_nop:
duke@435	1265	// do nothing
duke@435	1266	break;
duke@435	1267	case Bytecodes::_lconst_0:
duke@435	1268	push_pair(longcon(0));
duke@435	1269	break;
duke@435	1270
duke@435	1271	case Bytecodes::_lconst_1:
duke@435	1272	push_pair(longcon(1));
duke@435	1273	break;
duke@435	1274
duke@435	1275	case Bytecodes::_fconst_0:
duke@435	1276	push(zerocon(T_FLOAT));
duke@435	1277	break;
duke@435	1278
duke@435	1279	case Bytecodes::_fconst_1:
duke@435	1280	push(makecon(TypeF::ONE));
duke@435	1281	break;
duke@435	1282
duke@435	1283	case Bytecodes::_fconst_2:
duke@435	1284	push(makecon(TypeF::make(2.0f)));
duke@435	1285	break;
duke@435	1286
duke@435	1287	case Bytecodes::_dconst_0:
duke@435	1288	push_pair(zerocon(T_DOUBLE));
duke@435	1289	break;
duke@435	1290
duke@435	1291	case Bytecodes::_dconst_1:
duke@435	1292	push_pair(makecon(TypeD::ONE));
duke@435	1293	break;
duke@435	1294
duke@435	1295	case Bytecodes::_iconst_m1:push(intcon(-1)); break;
duke@435	1296	case Bytecodes::_iconst_0: push(intcon( 0)); break;
duke@435	1297	case Bytecodes::_iconst_1: push(intcon( 1)); break;
duke@435	1298	case Bytecodes::_iconst_2: push(intcon( 2)); break;
duke@435	1299	case Bytecodes::_iconst_3: push(intcon( 3)); break;
duke@435	1300	case Bytecodes::_iconst_4: push(intcon( 4)); break;
duke@435	1301	case Bytecodes::_iconst_5: push(intcon( 5)); break;
duke@435	1302	case Bytecodes::_bipush: push(intcon( iter().get_byte())); break;
duke@435	1303	case Bytecodes::_sipush: push(intcon( iter().get_short())); break;
duke@435	1304	case Bytecodes::_aconst_null: push(null()); break;
duke@435	1305	case Bytecodes::_ldc:
duke@435	1306	case Bytecodes::_ldc_w:
duke@435	1307	case Bytecodes::_ldc2_w:
duke@435	1308	// If the constant is unresolved, run this BC once in the interpreter.
duke@435	1309	if (iter().is_unresolved_string()) {
duke@435	1310	uncommon_trap(Deoptimization::make_trap_request
duke@435	1311	(Deoptimization::Reason_unloaded,
duke@435	1312	Deoptimization::Action_reinterpret,
duke@435	1313	iter().get_constant_index()),
duke@435	1314	NULL, "unresolved_string");
duke@435	1315	break;
duke@435	1316	} else {
duke@435	1317	ciConstant constant = iter().get_constant();
duke@435	1318	if (constant.basic_type() == T_OBJECT) {
duke@435	1319	ciObject* c = constant.as_object();
duke@435	1320	if (c->is_klass()) {
duke@435	1321	// The constant returned for a klass is the ciKlass for the
duke@435	1322	// entry. We want the java_mirror so get it.
duke@435	1323	ciKlass* klass = c->as_klass();
duke@435	1324	if (klass->is_loaded()) {
duke@435	1325	constant = ciConstant(T_OBJECT, klass->java_mirror());
duke@435	1326	} else {
duke@435	1327	uncommon_trap(Deoptimization::make_trap_request
duke@435	1328	(Deoptimization::Reason_unloaded,
duke@435	1329	Deoptimization::Action_reinterpret,
duke@435	1330	iter().get_constant_index()),
duke@435	1331	NULL, "unresolved_klass");
duke@435	1332	break;
duke@435	1333	}
duke@435	1334	}
duke@435	1335	}
duke@435	1336	push_constant(constant);
duke@435	1337	}
duke@435	1338
duke@435	1339	break;
duke@435	1340
duke@435	1341	case Bytecodes::_aload_0:
duke@435	1342	push( local(0) );
duke@435	1343	break;
duke@435	1344	case Bytecodes::_aload_1:
duke@435	1345	push( local(1) );
duke@435	1346	break;
duke@435	1347	case Bytecodes::_aload_2:
duke@435	1348	push( local(2) );
duke@435	1349	break;
duke@435	1350	case Bytecodes::_aload_3:
duke@435	1351	push( local(3) );
duke@435	1352	break;
duke@435	1353	case Bytecodes::_aload:
duke@435	1354	push( local(iter().get_index()) );
duke@435	1355	break;
duke@435	1356
duke@435	1357	case Bytecodes::_fload_0:
duke@435	1358	case Bytecodes::_iload_0:
duke@435	1359	push( local(0) );
duke@435	1360	break;
duke@435	1361	case Bytecodes::_fload_1:
duke@435	1362	case Bytecodes::_iload_1:
duke@435	1363	push( local(1) );
duke@435	1364	break;
duke@435	1365	case Bytecodes::_fload_2:
duke@435	1366	case Bytecodes::_iload_2:
duke@435	1367	push( local(2) );
duke@435	1368	break;
duke@435	1369	case Bytecodes::_fload_3:
duke@435	1370	case Bytecodes::_iload_3:
duke@435	1371	push( local(3) );
duke@435	1372	break;
duke@435	1373	case Bytecodes::_fload:
duke@435	1374	case Bytecodes::_iload:
duke@435	1375	push( local(iter().get_index()) );
duke@435	1376	break;
duke@435	1377	case Bytecodes::_lload_0:
duke@435	1378	push_pair_local( 0 );
duke@435	1379	break;
duke@435	1380	case Bytecodes::_lload_1:
duke@435	1381	push_pair_local( 1 );
duke@435	1382	break;
duke@435	1383	case Bytecodes::_lload_2:
duke@435	1384	push_pair_local( 2 );
duke@435	1385	break;
duke@435	1386	case Bytecodes::_lload_3:
duke@435	1387	push_pair_local( 3 );
duke@435	1388	break;
duke@435	1389	case Bytecodes::_lload:
duke@435	1390	push_pair_local( iter().get_index() );
duke@435	1391	break;
duke@435	1392
duke@435	1393	case Bytecodes::_dload_0:
duke@435	1394	push_pair_local(0);
duke@435	1395	break;
duke@435	1396	case Bytecodes::_dload_1:
duke@435	1397	push_pair_local(1);
duke@435	1398	break;
duke@435	1399	case Bytecodes::_dload_2:
duke@435	1400	push_pair_local(2);
duke@435	1401	break;
duke@435	1402	case Bytecodes::_dload_3:
duke@435	1403	push_pair_local(3);
duke@435	1404	break;
duke@435	1405	case Bytecodes::_dload:
duke@435	1406	push_pair_local(iter().get_index());
duke@435	1407	break;
duke@435	1408	case Bytecodes::_fstore_0:
duke@435	1409	case Bytecodes::_istore_0:
duke@435	1410	case Bytecodes::_astore_0:
duke@435	1411	set_local( 0, pop() );
duke@435	1412	break;
duke@435	1413	case Bytecodes::_fstore_1:
duke@435	1414	case Bytecodes::_istore_1:
duke@435	1415	case Bytecodes::_astore_1:
duke@435	1416	set_local( 1, pop() );
duke@435	1417	break;
duke@435	1418	case Bytecodes::_fstore_2:
duke@435	1419	case Bytecodes::_istore_2:
duke@435	1420	case Bytecodes::_astore_2:
duke@435	1421	set_local( 2, pop() );
duke@435	1422	break;
duke@435	1423	case Bytecodes::_fstore_3:
duke@435	1424	case Bytecodes::_istore_3:
duke@435	1425	case Bytecodes::_astore_3:
duke@435	1426	set_local( 3, pop() );
duke@435	1427	break;
duke@435	1428	case Bytecodes::_fstore:
duke@435	1429	case Bytecodes::_istore:
duke@435	1430	case Bytecodes::_astore:
duke@435	1431	set_local( iter().get_index(), pop() );
duke@435	1432	break;
duke@435	1433	// long stores
duke@435	1434	case Bytecodes::_lstore_0:
duke@435	1435	set_pair_local( 0, pop_pair() );
duke@435	1436	break;
duke@435	1437	case Bytecodes::_lstore_1:
duke@435	1438	set_pair_local( 1, pop_pair() );
duke@435	1439	break;
duke@435	1440	case Bytecodes::_lstore_2:
duke@435	1441	set_pair_local( 2, pop_pair() );
duke@435	1442	break;
duke@435	1443	case Bytecodes::_lstore_3:
duke@435	1444	set_pair_local( 3, pop_pair() );
duke@435	1445	break;
duke@435	1446	case Bytecodes::_lstore:
duke@435	1447	set_pair_local( iter().get_index(), pop_pair() );
duke@435	1448	break;
duke@435	1449
duke@435	1450	// double stores
duke@435	1451	case Bytecodes::_dstore_0:
duke@435	1452	set_pair_local( 0, dstore_rounding(pop_pair()) );
duke@435	1453	break;
duke@435	1454	case Bytecodes::_dstore_1:
duke@435	1455	set_pair_local( 1, dstore_rounding(pop_pair()) );
duke@435	1456	break;
duke@435	1457	case Bytecodes::_dstore_2:
duke@435	1458	set_pair_local( 2, dstore_rounding(pop_pair()) );
duke@435	1459	break;
duke@435	1460	case Bytecodes::_dstore_3:
duke@435	1461	set_pair_local( 3, dstore_rounding(pop_pair()) );
duke@435	1462	break;
duke@435	1463	case Bytecodes::_dstore:
duke@435	1464	set_pair_local( iter().get_index(), dstore_rounding(pop_pair()) );
duke@435	1465	break;
duke@435	1466
duke@435	1467	case Bytecodes::_pop: _sp -= 1; break;
duke@435	1468	case Bytecodes::_pop2: _sp -= 2; break;
duke@435	1469	case Bytecodes::_swap:
duke@435	1470	a = pop();
duke@435	1471	b = pop();
duke@435	1472	push(a);
duke@435	1473	push(b);
duke@435	1474	break;
duke@435	1475	case Bytecodes::_dup:
duke@435	1476	a = pop();
duke@435	1477	push(a);
duke@435	1478	push(a);
duke@435	1479	break;
duke@435	1480	case Bytecodes::_dup_x1:
duke@435	1481	a = pop();
duke@435	1482	b = pop();
duke@435	1483	push( a );
duke@435	1484	push( b );
duke@435	1485	push( a );
duke@435	1486	break;
duke@435	1487	case Bytecodes::_dup_x2:
duke@435	1488	a = pop();
duke@435	1489	b = pop();
duke@435	1490	c = pop();
duke@435	1491	push( a );
duke@435	1492	push( c );
duke@435	1493	push( b );
duke@435	1494	push( a );
duke@435	1495	break;
duke@435	1496	case Bytecodes::_dup2:
duke@435	1497	a = pop();
duke@435	1498	b = pop();
duke@435	1499	push( b );
duke@435	1500	push( a );
duke@435	1501	push( b );
duke@435	1502	push( a );
duke@435	1503	break;
duke@435	1504
duke@435	1505	case Bytecodes::_dup2_x1:
duke@435	1506	// before: .. c, b, a
duke@435	1507	// after: .. b, a, c, b, a
duke@435	1508	// not tested
duke@435	1509	a = pop();
duke@435	1510	b = pop();
duke@435	1511	c = pop();
duke@435	1512	push( b );
duke@435	1513	push( a );
duke@435	1514	push( c );
duke@435	1515	push( b );
duke@435	1516	push( a );
duke@435	1517	break;
duke@435	1518	case Bytecodes::_dup2_x2:
duke@435	1519	// before: .. d, c, b, a
duke@435	1520	// after: .. b, a, d, c, b, a
duke@435	1521	// not tested
duke@435	1522	a = pop();
duke@435	1523	b = pop();
duke@435	1524	c = pop();
duke@435	1525	d = pop();
duke@435	1526	push( b );
duke@435	1527	push( a );
duke@435	1528	push( d );
duke@435	1529	push( c );
duke@435	1530	push( b );
duke@435	1531	push( a );
duke@435	1532	break;
duke@435	1533
duke@435	1534	case Bytecodes::_arraylength: {
duke@435	1535	// Must do null-check with value on expression stack
duke@435	1536	Node *ary = do_null_check(peek(), T_ARRAY);
duke@435	1537	// Compile-time detect of null-exception?
duke@435	1538	if (stopped()) return;
duke@435	1539	a = pop();
duke@435	1540	push(load_array_length(a));
duke@435	1541	break;
duke@435	1542	}
duke@435	1543
duke@435	1544	case Bytecodes::_baload: array_load(T_BYTE); break;
duke@435	1545	case Bytecodes::_caload: array_load(T_CHAR); break;
duke@435	1546	case Bytecodes::_iaload: array_load(T_INT); break;
duke@435	1547	case Bytecodes::_saload: array_load(T_SHORT); break;
duke@435	1548	case Bytecodes::_faload: array_load(T_FLOAT); break;
duke@435	1549	case Bytecodes::_aaload: array_load(T_OBJECT); break;
duke@435	1550	case Bytecodes::_laload: {
duke@435	1551	a = array_addressing(T_LONG, 0);
duke@435	1552	if (stopped()) return; // guarenteed null or range check
duke@435	1553	_sp -= 2; // Pop array and index
duke@435	1554	push_pair( make_load(control(), a, TypeLong::LONG, T_LONG, TypeAryPtr::LONGS));
duke@435	1555	break;
duke@435	1556	}
duke@435	1557	case Bytecodes::_daload: {
duke@435	1558	a = array_addressing(T_DOUBLE, 0);
duke@435	1559	if (stopped()) return; // guarenteed null or range check
duke@435	1560	_sp -= 2; // Pop array and index
duke@435	1561	push_pair( make_load(control(), a, Type::DOUBLE, T_DOUBLE, TypeAryPtr::DOUBLES));
duke@435	1562	break;
duke@435	1563	}
duke@435	1564	case Bytecodes::_bastore: array_store(T_BYTE); break;
duke@435	1565	case Bytecodes::_castore: array_store(T_CHAR); break;
duke@435	1566	case Bytecodes::_iastore: array_store(T_INT); break;
duke@435	1567	case Bytecodes::_sastore: array_store(T_SHORT); break;
duke@435	1568	case Bytecodes::_fastore: array_store(T_FLOAT); break;
duke@435	1569	case Bytecodes::_aastore: {
duke@435	1570	d = array_addressing(T_OBJECT, 1);
duke@435	1571	if (stopped()) return; // guarenteed null or range check
duke@435	1572	array_store_check();
duke@435	1573	c = pop(); // Oop to store
duke@435	1574	b = pop(); // index (already used)
duke@435	1575	a = pop(); // the array itself
duke@435	1576	const Type* elemtype = _gvn.type(a)->is_aryptr()->elem();
duke@435	1577	const TypeAryPtr* adr_type = TypeAryPtr::OOPS;
duke@435	1578	Node* store = store_oop_to_array(control(), a, d, adr_type, c, elemtype, T_OBJECT);
duke@435	1579	break;
duke@435	1580	}
duke@435	1581	case Bytecodes::_lastore: {
duke@435	1582	a = array_addressing(T_LONG, 2);
duke@435	1583	if (stopped()) return; // guarenteed null or range check
duke@435	1584	c = pop_pair();
duke@435	1585	_sp -= 2; // Pop array and index
duke@435	1586	store_to_memory(control(), a, c, T_LONG, TypeAryPtr::LONGS);
duke@435	1587	break;
duke@435	1588	}
duke@435	1589	case Bytecodes::_dastore: {
duke@435	1590	a = array_addressing(T_DOUBLE, 2);
duke@435	1591	if (stopped()) return; // guarenteed null or range check
duke@435	1592	c = pop_pair();
duke@435	1593	_sp -= 2; // Pop array and index
duke@435	1594	c = dstore_rounding(c);
duke@435	1595	store_to_memory(control(), a, c, T_DOUBLE, TypeAryPtr::DOUBLES);
duke@435	1596	break;
duke@435	1597	}
duke@435	1598	case Bytecodes::_getfield:
duke@435	1599	do_getfield();
duke@435	1600	break;
duke@435	1601
duke@435	1602	case Bytecodes::_getstatic:
duke@435	1603	do_getstatic();
duke@435	1604	break;
duke@435	1605
duke@435	1606	case Bytecodes::_putfield:
duke@435	1607	do_putfield();
duke@435	1608	break;
duke@435	1609
duke@435	1610	case Bytecodes::_putstatic:
duke@435	1611	do_putstatic();
duke@435	1612	break;
duke@435	1613
duke@435	1614	case Bytecodes::_irem:
duke@435	1615	do_irem();
duke@435	1616	break;
duke@435	1617	case Bytecodes::_idiv:
duke@435	1618	// Must keep both values on the expression-stack during null-check
duke@435	1619	do_null_check(peek(), T_INT);
duke@435	1620	// Compile-time detect of null-exception?
duke@435	1621	if (stopped()) return;
duke@435	1622	b = pop();
duke@435	1623	a = pop();
duke@435	1624	push( _gvn.transform( new (C, 3) DivINode(control(),a,b) ) );
duke@435	1625	break;
duke@435	1626	case Bytecodes::_imul:
duke@435	1627	b = pop(); a = pop();
duke@435	1628	push( _gvn.transform( new (C, 3) MulINode(a,b) ) );
duke@435	1629	break;
duke@435	1630	case Bytecodes::_iadd:
duke@435	1631	b = pop(); a = pop();
duke@435	1632	push( _gvn.transform( new (C, 3) AddINode(a,b) ) );
duke@435	1633	break;
duke@435	1634	case Bytecodes::_ineg:
duke@435	1635	a = pop();
duke@435	1636	push( _gvn.transform( new (C, 3) SubINode(_gvn.intcon(0),a)) );
duke@435	1637	break;
duke@435	1638	case Bytecodes::_isub:
duke@435	1639	b = pop(); a = pop();
duke@435	1640	push( _gvn.transform( new (C, 3) SubINode(a,b) ) );
duke@435	1641	break;
duke@435	1642	case Bytecodes::_iand:
duke@435	1643	b = pop(); a = pop();
duke@435	1644	push( _gvn.transform( new (C, 3) AndINode(a,b) ) );
duke@435	1645	break;
duke@435	1646	case Bytecodes::_ior:
duke@435	1647	b = pop(); a = pop();
duke@435	1648	push( _gvn.transform( new (C, 3) OrINode(a,b) ) );
duke@435	1649	break;
duke@435	1650	case Bytecodes::_ixor:
duke@435	1651	b = pop(); a = pop();
duke@435	1652	push( _gvn.transform( new (C, 3) XorINode(a,b) ) );
duke@435	1653	break;
duke@435	1654	case Bytecodes::_ishl:
duke@435	1655	b = pop(); a = pop();
duke@435	1656	push( _gvn.transform( new (C, 3) LShiftINode(a,b) ) );
duke@435	1657	break;
duke@435	1658	case Bytecodes::_ishr:
duke@435	1659	b = pop(); a = pop();
duke@435	1660	push( _gvn.transform( new (C, 3) RShiftINode(a,b) ) );
duke@435	1661	break;
duke@435	1662	case Bytecodes::_iushr:
duke@435	1663	b = pop(); a = pop();
duke@435	1664	push( _gvn.transform( new (C, 3) URShiftINode(a,b) ) );
duke@435	1665	break;
duke@435	1666
duke@435	1667	case Bytecodes::_fneg:
duke@435	1668	a = pop();
duke@435	1669	b = _gvn.transform(new (C, 2) NegFNode (a));
duke@435	1670	push(b);
duke@435	1671	break;
duke@435	1672
duke@435	1673	case Bytecodes::_fsub:
duke@435	1674	b = pop();
duke@435	1675	a = pop();
duke@435	1676	c = _gvn.transform( new (C, 3) SubFNode(a,b) );
duke@435	1677	d = precision_rounding(c);
duke@435	1678	push( d );
duke@435	1679	break;
duke@435	1680
duke@435	1681	case Bytecodes::_fadd:
duke@435	1682	b = pop();
duke@435	1683	a = pop();
duke@435	1684	c = _gvn.transform( new (C, 3) AddFNode(a,b) );
duke@435	1685	d = precision_rounding(c);
duke@435	1686	push( d );
duke@435	1687	break;
duke@435	1688
duke@435	1689	case Bytecodes::_fmul:
duke@435	1690	b = pop();
duke@435	1691	a = pop();
duke@435	1692	c = _gvn.transform( new (C, 3) MulFNode(a,b) );
duke@435	1693	d = precision_rounding(c);
duke@435	1694	push( d );
duke@435	1695	break;
duke@435	1696
duke@435	1697	case Bytecodes::_fdiv:
duke@435	1698	b = pop();
duke@435	1699	a = pop();
duke@435	1700	c = _gvn.transform( new (C, 3) DivFNode(0,a,b) );
duke@435	1701	d = precision_rounding(c);
duke@435	1702	push( d );
duke@435	1703	break;
duke@435	1704
duke@435	1705	case Bytecodes::_frem:
duke@435	1706	if (Matcher::has_match_rule(Op_ModF)) {
duke@435	1707	// Generate a ModF node.
duke@435	1708	b = pop();
duke@435	1709	a = pop();
duke@435	1710	c = _gvn.transform( new (C, 3) ModFNode(0,a,b) );
duke@435	1711	d = precision_rounding(c);
duke@435	1712	push( d );
duke@435	1713	}
duke@435	1714	else {
duke@435	1715	// Generate a call.
duke@435	1716	modf();
duke@435	1717	}
duke@435	1718	break;
duke@435	1719
duke@435	1720	case Bytecodes::_fcmpl:
duke@435	1721	b = pop();
duke@435	1722	a = pop();
duke@435	1723	c = _gvn.transform( new (C, 3) CmpF3Node( a, b));
duke@435	1724	push(c);
duke@435	1725	break;
duke@435	1726	case Bytecodes::_fcmpg:
duke@435	1727	b = pop();
duke@435	1728	a = pop();
duke@435	1729
duke@435	1730	// Same as fcmpl but need to flip the unordered case. Swap the inputs,
duke@435	1731	// which negates the result sign except for unordered. Flip the unordered
duke@435	1732	// as well by using CmpF3 which implements unordered-lesser instead of
duke@435	1733	// unordered-greater semantics. Finally, commute the result bits. Result
duke@435	1734	// is same as using a CmpF3Greater except we did it with CmpF3 alone.
duke@435	1735	c = _gvn.transform( new (C, 3) CmpF3Node( b, a));
duke@435	1736	c = _gvn.transform( new (C, 3) SubINode(_gvn.intcon(0),c) );
duke@435	1737	push(c);
duke@435	1738	break;
duke@435	1739
duke@435	1740	case Bytecodes::_f2i:
duke@435	1741	a = pop();
duke@435	1742	push(_gvn.transform(new (C, 2) ConvF2INode(a)));
duke@435	1743	break;
duke@435	1744
duke@435	1745	case Bytecodes::_d2i:
duke@435	1746	a = pop_pair();
duke@435	1747	b = _gvn.transform(new (C, 2) ConvD2INode(a));
duke@435	1748	push( b );
duke@435	1749	break;
duke@435	1750
duke@435	1751	case Bytecodes::_f2d:
duke@435	1752	a = pop();
duke@435	1753	b = _gvn.transform( new (C, 2) ConvF2DNode(a));
duke@435	1754	push_pair( b );
duke@435	1755	break;
duke@435	1756
duke@435	1757	case Bytecodes::_d2f:
duke@435	1758	a = pop_pair();
duke@435	1759	b = _gvn.transform( new (C, 2) ConvD2FNode(a));
duke@435	1760	// This breaks _227_mtrt (speed & correctness) and _222_mpegaudio (speed)
duke@435	1761	//b = _gvn.transform(new (C, 2) RoundFloatNode(0, b) );
duke@435	1762	push( b );
duke@435	1763	break;
duke@435	1764
duke@435	1765	case Bytecodes::_l2f:
duke@435	1766	if (Matcher::convL2FSupported()) {
duke@435	1767	a = pop_pair();
duke@435	1768	b = _gvn.transform( new (C, 2) ConvL2FNode(a));
duke@435	1769	// For i486.ad, FILD doesn't restrict precision to 24 or 53 bits.
duke@435	1770	// Rather than storing the result into an FP register then pushing
duke@435	1771	// out to memory to round, the machine instruction that implements
duke@435	1772	// ConvL2D is responsible for rounding.
duke@435	1773	// c = precision_rounding(b);
duke@435	1774	c = _gvn.transform(b);
duke@435	1775	push(c);
duke@435	1776	} else {
duke@435	1777	l2f();
duke@435	1778	}
duke@435	1779	break;
duke@435	1780
duke@435	1781	case Bytecodes::_l2d:
duke@435	1782	a = pop_pair();
duke@435	1783	b = _gvn.transform( new (C, 2) ConvL2DNode(a));
duke@435	1784	// For i486.ad, rounding is always necessary (see _l2f above).
duke@435	1785	// c = dprecision_rounding(b);
duke@435	1786	c = _gvn.transform(b);
duke@435	1787	push_pair(c);
duke@435	1788	break;
duke@435	1789
duke@435	1790	case Bytecodes::_f2l:
duke@435	1791	a = pop();
duke@435	1792	b = _gvn.transform( new (C, 2) ConvF2LNode(a));
duke@435	1793	push_pair(b);
duke@435	1794	break;
duke@435	1795
duke@435	1796	case Bytecodes::_d2l:
duke@435	1797	a = pop_pair();
duke@435	1798	b = _gvn.transform( new (C, 2) ConvD2LNode(a));
duke@435	1799	push_pair(b);
duke@435	1800	break;
duke@435	1801
duke@435	1802	case Bytecodes::_dsub:
duke@435	1803	b = pop_pair();
duke@435	1804	a = pop_pair();
duke@435	1805	c = _gvn.transform( new (C, 3) SubDNode(a,b) );
duke@435	1806	d = dprecision_rounding(c);
duke@435	1807	push_pair( d );
duke@435	1808	break;
duke@435	1809
duke@435	1810	case Bytecodes::_dadd:
duke@435	1811	b = pop_pair();
duke@435	1812	a = pop_pair();
duke@435	1813	c = _gvn.transform( new (C, 3) AddDNode(a,b) );
duke@435	1814	d = dprecision_rounding(c);
duke@435	1815	push_pair( d );
duke@435	1816	break;
duke@435	1817
duke@435	1818	case Bytecodes::_dmul:
duke@435	1819	b = pop_pair();
duke@435	1820	a = pop_pair();
duke@435	1821	c = _gvn.transform( new (C, 3) MulDNode(a,b) );
duke@435	1822	d = dprecision_rounding(c);
duke@435	1823	push_pair( d );
duke@435	1824	break;
duke@435	1825
duke@435	1826	case Bytecodes::_ddiv:
duke@435	1827	b = pop_pair();
duke@435	1828	a = pop_pair();
duke@435	1829	c = _gvn.transform( new (C, 3) DivDNode(0,a,b) );
duke@435	1830	d = dprecision_rounding(c);
duke@435	1831	push_pair( d );
duke@435	1832	break;
duke@435	1833
duke@435	1834	case Bytecodes::_dneg:
duke@435	1835	a = pop_pair();
duke@435	1836	b = _gvn.transform(new (C, 2) NegDNode (a));
duke@435	1837	push_pair(b);
duke@435	1838	break;
duke@435	1839
duke@435	1840	case Bytecodes::_drem:
duke@435	1841	if (Matcher::has_match_rule(Op_ModD)) {
duke@435	1842	// Generate a ModD node.
duke@435	1843	b = pop_pair();
duke@435	1844	a = pop_pair();
duke@435	1845	// a % b
duke@435	1846
duke@435	1847	c = _gvn.transform( new (C, 3) ModDNode(0,a,b) );
duke@435	1848	d = dprecision_rounding(c);
duke@435	1849	push_pair( d );
duke@435	1850	}
duke@435	1851	else {
duke@435	1852	// Generate a call.
duke@435	1853	modd();
duke@435	1854	}
duke@435	1855	break;
duke@435	1856
duke@435	1857	case Bytecodes::_dcmpl:
duke@435	1858	b = pop_pair();
duke@435	1859	a = pop_pair();
duke@435	1860	c = _gvn.transform( new (C, 3) CmpD3Node( a, b));
duke@435	1861	push(c);
duke@435	1862	break;
duke@435	1863
duke@435	1864	case Bytecodes::_dcmpg:
duke@435	1865	b = pop_pair();
duke@435	1866	a = pop_pair();
duke@435	1867	// Same as dcmpl but need to flip the unordered case.
duke@435	1868	// Commute the inputs, which negates the result sign except for unordered.
duke@435	1869	// Flip the unordered as well by using CmpD3 which implements
duke@435	1870	// unordered-lesser instead of unordered-greater semantics.
duke@435	1871	// Finally, negate the result bits. Result is same as using a
duke@435	1872	// CmpD3Greater except we did it with CmpD3 alone.
duke@435	1873	c = _gvn.transform( new (C, 3) CmpD3Node( b, a));
duke@435	1874	c = _gvn.transform( new (C, 3) SubINode(_gvn.intcon(0),c) );
duke@435	1875	push(c);
duke@435	1876	break;
duke@435	1877
duke@435	1878
duke@435	1879	// Note for longs -> lo word is on TOS, hi word is on TOS - 1
duke@435	1880	case Bytecodes::_land:
duke@435	1881	b = pop_pair();
duke@435	1882	a = pop_pair();
duke@435	1883	c = _gvn.transform( new (C, 3) AndLNode(a,b) );
duke@435	1884	push_pair(c);
duke@435	1885	break;
duke@435	1886	case Bytecodes::_lor:
duke@435	1887	b = pop_pair();
duke@435	1888	a = pop_pair();
duke@435	1889	c = _gvn.transform( new (C, 3) OrLNode(a,b) );
duke@435	1890	push_pair(c);
duke@435	1891	break;
duke@435	1892	case Bytecodes::_lxor:
duke@435	1893	b = pop_pair();
duke@435	1894	a = pop_pair();
duke@435	1895	c = _gvn.transform( new (C, 3) XorLNode(a,b) );
duke@435	1896	push_pair(c);
duke@435	1897	break;
duke@435	1898
duke@435	1899	case Bytecodes::_lshl:
duke@435	1900	b = pop(); // the shift count
duke@435	1901	a = pop_pair(); // value to be shifted
duke@435	1902	c = _gvn.transform( new (C, 3) LShiftLNode(a,b) );
duke@435	1903	push_pair(c);
duke@435	1904	break;
duke@435	1905	case Bytecodes::_lshr:
duke@435	1906	b = pop(); // the shift count
duke@435	1907	a = pop_pair(); // value to be shifted
duke@435	1908	c = _gvn.transform( new (C, 3) RShiftLNode(a,b) );
duke@435	1909	push_pair(c);
duke@435	1910	break;
duke@435	1911	case Bytecodes::_lushr:
duke@435	1912	b = pop(); // the shift count
duke@435	1913	a = pop_pair(); // value to be shifted
duke@435	1914	c = _gvn.transform( new (C, 3) URShiftLNode(a,b) );
duke@435	1915	push_pair(c);
duke@435	1916	break;
duke@435	1917	case Bytecodes::_lmul:
duke@435	1918	b = pop_pair();
duke@435	1919	a = pop_pair();
duke@435	1920	c = _gvn.transform( new (C, 3) MulLNode(a,b) );
duke@435	1921	push_pair(c);
duke@435	1922	break;
duke@435	1923
duke@435	1924	case Bytecodes::_lrem:
duke@435	1925	// Must keep both values on the expression-stack during null-check
duke@435	1926	assert(peek(0) == top(), "long word order");
duke@435	1927	do_null_check(peek(1), T_LONG);
duke@435	1928	// Compile-time detect of null-exception?
duke@435	1929	if (stopped()) return;
duke@435	1930	b = pop_pair();
duke@435	1931	a = pop_pair();
duke@435	1932	c = _gvn.transform( new (C, 3) ModLNode(control(),a,b) );
duke@435	1933	push_pair(c);
duke@435	1934	break;
duke@435	1935
duke@435	1936	case Bytecodes::_ldiv:
duke@435	1937	// Must keep both values on the expression-stack during null-check
duke@435	1938	assert(peek(0) == top(), "long word order");
duke@435	1939	do_null_check(peek(1), T_LONG);
duke@435	1940	// Compile-time detect of null-exception?
duke@435	1941	if (stopped()) return;
duke@435	1942	b = pop_pair();
duke@435	1943	a = pop_pair();
duke@435	1944	c = _gvn.transform( new (C, 3) DivLNode(control(),a,b) );
duke@435	1945	push_pair(c);
duke@435	1946	break;
duke@435	1947
duke@435	1948	case Bytecodes::_ladd:
duke@435	1949	b = pop_pair();
duke@435	1950	a = pop_pair();
duke@435	1951	c = _gvn.transform( new (C, 3) AddLNode(a,b) );
duke@435	1952	push_pair(c);
duke@435	1953	break;
duke@435	1954	case Bytecodes::_lsub:
duke@435	1955	b = pop_pair();
duke@435	1956	a = pop_pair();
duke@435	1957	c = _gvn.transform( new (C, 3) SubLNode(a,b) );
duke@435	1958	push_pair(c);
duke@435	1959	break;
duke@435	1960	case Bytecodes::_lcmp:
duke@435	1961	// Safepoints are now inserted _before_ branches. The long-compare
duke@435	1962	// bytecode painfully produces a 3-way value (-1,0,+1) which requires a
duke@435	1963	// slew of control flow. These are usually followed by a CmpI vs zero and
duke@435	1964	// a branch; this pattern then optimizes to the obvious long-compare and
duke@435	1965	// branch. However, if the branch is backwards there's a Safepoint
duke@435	1966	// inserted. The inserted Safepoint captures the JVM state at the
duke@435	1967	// pre-branch point, i.e. it captures the 3-way value. Thus if a
duke@435	1968	// long-compare is used to control a loop the debug info will force
duke@435	1969	// computation of the 3-way value, even though the generated code uses a
duke@435	1970	// long-compare and branch. We try to rectify the situation by inserting
duke@435	1971	// a SafePoint here and have it dominate and kill the safepoint added at a
duke@435	1972	// following backwards branch. At this point the JVM state merely holds 2
duke@435	1973	// longs but not the 3-way value.
duke@435	1974	if( UseLoopSafepoints ) {
duke@435	1975	switch( iter().next_bc() ) {
duke@435	1976	case Bytecodes::_ifgt:
duke@435	1977	case Bytecodes::_iflt:
duke@435	1978	case Bytecodes::_ifge:
duke@435	1979	case Bytecodes::_ifle:
duke@435	1980	case Bytecodes::_ifne:
duke@435	1981	case Bytecodes::_ifeq:
duke@435	1982	// If this is a backwards branch in the bytecodes, add Safepoint
duke@435	1983	maybe_add_safepoint(iter().next_get_dest());
duke@435	1984	}
duke@435	1985	}
duke@435	1986	b = pop_pair();
duke@435	1987	a = pop_pair();
duke@435	1988	c = _gvn.transform( new (C, 3) CmpL3Node( a, b ));
duke@435	1989	push(c);
duke@435	1990	break;
duke@435	1991
duke@435	1992	case Bytecodes::_lneg:
duke@435	1993	a = pop_pair();
duke@435	1994	b = _gvn.transform( new (C, 3) SubLNode(longcon(0),a));
duke@435	1995	push_pair(b);
duke@435	1996	break;
duke@435	1997	case Bytecodes::_l2i:
duke@435	1998	a = pop_pair();
duke@435	1999	push( _gvn.transform( new (C, 2) ConvL2INode(a)));
duke@435	2000	break;
duke@435	2001	case Bytecodes::_i2l:
duke@435	2002	a = pop();
duke@435	2003	b = _gvn.transform( new (C, 2) ConvI2LNode(a));
duke@435	2004	push_pair(b);
duke@435	2005	break;
duke@435	2006	case Bytecodes::_i2b:
duke@435	2007	// Sign extend
duke@435	2008	a = pop();
duke@435	2009	a = _gvn.transform( new (C, 3) LShiftINode(a,_gvn.intcon(24)) );
duke@435	2010	a = _gvn.transform( new (C, 3) RShiftINode(a,_gvn.intcon(24)) );
duke@435	2011	push( a );
duke@435	2012	break;
duke@435	2013	case Bytecodes::_i2s:
duke@435	2014	a = pop();
duke@435	2015	a = _gvn.transform( new (C, 3) LShiftINode(a,_gvn.intcon(16)) );
duke@435	2016	a = _gvn.transform( new (C, 3) RShiftINode(a,_gvn.intcon(16)) );
duke@435	2017	push( a );
duke@435	2018	break;
duke@435	2019	case Bytecodes::_i2c:
duke@435	2020	a = pop();
duke@435	2021	push( _gvn.transform( new (C, 3) AndINode(a,_gvn.intcon(0xFFFF)) ) );
duke@435	2022	break;
duke@435	2023
duke@435	2024	case Bytecodes::_i2f:
duke@435	2025	a = pop();
duke@435	2026	b = _gvn.transform( new (C, 2) ConvI2FNode(a) ) ;
duke@435	2027	c = precision_rounding(b);
duke@435	2028	push (b);
duke@435	2029	break;
duke@435	2030
duke@435	2031	case Bytecodes::_i2d:
duke@435	2032	a = pop();
duke@435	2033	b = _gvn.transform( new (C, 2) ConvI2DNode(a));
duke@435	2034	push_pair(b);
duke@435	2035	break;
duke@435	2036
duke@435	2037	case Bytecodes::_iinc: // Increment local
duke@435	2038	i = iter().get_index(); // Get local index
duke@435	2039	set_local( i, _gvn.transform( new (C, 3) AddINode( _gvn.intcon(iter().get_iinc_con()), local(i) ) ) );
duke@435	2040	break;
duke@435	2041
duke@435	2042	// Exit points of synchronized methods must have an unlock node
duke@435	2043	case Bytecodes::_return:
duke@435	2044	return_current(NULL);
duke@435	2045	break;
duke@435	2046
duke@435	2047	case Bytecodes::_ireturn:
duke@435	2048	case Bytecodes::_areturn:
duke@435	2049	case Bytecodes::_freturn:
duke@435	2050	return_current(pop());
duke@435	2051	break;
duke@435	2052	case Bytecodes::_lreturn:
duke@435	2053	return_current(pop_pair());
duke@435	2054	break;
duke@435	2055	case Bytecodes::_dreturn:
duke@435	2056	return_current(pop_pair());
duke@435	2057	break;
duke@435	2058
duke@435	2059	case Bytecodes::_athrow:
duke@435	2060	// null exception oop throws NULL pointer exception
duke@435	2061	do_null_check(peek(), T_OBJECT);
duke@435	2062	if (stopped()) return;
duke@435	2063	if (JvmtiExport::can_post_exceptions()) {
duke@435	2064	// "Full-speed throwing" is not necessary here,
duke@435	2065	// since we're notifying the VM on every throw.
duke@435	2066	uncommon_trap(Deoptimization::Reason_unhandled,
duke@435	2067	Deoptimization::Action_none);
duke@435	2068	return;
duke@435	2069	}
duke@435	2070	// Hook the thrown exception directly to subsequent handlers.
duke@435	2071	if (BailoutToInterpreterForThrows) {
duke@435	2072	// Keep method interpreted from now on.
duke@435	2073	uncommon_trap(Deoptimization::Reason_unhandled,
duke@435	2074	Deoptimization::Action_make_not_compilable);
duke@435	2075	return;
duke@435	2076	}
duke@435	2077	add_exception_state(make_exception_state(peek()));
duke@435	2078	break;
duke@435	2079
duke@435	2080	case Bytecodes::_goto: // fall through
duke@435	2081	case Bytecodes::_goto_w: {
duke@435	2082	int target_bci = (bc() == Bytecodes::_goto) ? iter().get_dest() : iter().get_far_dest();
duke@435	2083
duke@435	2084	// If this is a backwards branch in the bytecodes, add Safepoint
duke@435	2085	maybe_add_safepoint(target_bci);
duke@435	2086
duke@435	2087	// Update method data
duke@435	2088	profile_taken_branch(target_bci);
duke@435	2089
duke@435	2090	// Merge the current control into the target basic block
duke@435	2091	merge(target_bci);
duke@435	2092
duke@435	2093	// See if we can get some profile data and hand it off to the next block
duke@435	2094	Block *target_block = block()->successor_for_bci(target_bci);
duke@435	2095	if (target_block->pred_count() != 1) break;
duke@435	2096	ciMethodData* methodData = method()->method_data();
duke@435	2097	if (!methodData->is_mature()) break;
duke@435	2098	ciProfileData* data = methodData->bci_to_data(bci());
duke@435	2099	assert( data->is_JumpData(), "" );
duke@435	2100	int taken = ((ciJumpData*)data)->taken();
duke@435	2101	taken = method()->scale_count(taken);
duke@435	2102	target_block->set_count(taken);
duke@435	2103	break;
duke@435	2104	}
duke@435	2105
duke@435	2106	case Bytecodes::_ifnull:
duke@435	2107	do_ifnull(BoolTest::eq);
duke@435	2108	break;
duke@435	2109	case Bytecodes::_ifnonnull:
duke@435	2110	do_ifnull(BoolTest::ne);
duke@435	2111	break;
duke@435	2112
duke@435	2113	case Bytecodes::_if_acmpeq: btest = BoolTest::eq; goto handle_if_acmp;
duke@435	2114	case Bytecodes::_if_acmpne: btest = BoolTest::ne; goto handle_if_acmp;
duke@435	2115	handle_if_acmp:
duke@435	2116	// If this is a backwards branch in the bytecodes, add Safepoint
duke@435	2117	maybe_add_safepoint(iter().get_dest());
duke@435	2118	a = pop();
duke@435	2119	b = pop();
duke@435	2120	c = _gvn.transform( new (C, 3) CmpPNode(b, a) );
duke@435	2121	do_if(btest, c);
duke@435	2122	break;
duke@435	2123
duke@435	2124	case Bytecodes::_ifeq: btest = BoolTest::eq; goto handle_ifxx;
duke@435	2125	case Bytecodes::_ifne: btest = BoolTest::ne; goto handle_ifxx;
duke@435	2126	case Bytecodes::_iflt: btest = BoolTest::lt; goto handle_ifxx;
duke@435	2127	case Bytecodes::_ifle: btest = BoolTest::le; goto handle_ifxx;
duke@435	2128	case Bytecodes::_ifgt: btest = BoolTest::gt; goto handle_ifxx;
duke@435	2129	case Bytecodes::_ifge: btest = BoolTest::ge; goto handle_ifxx;
duke@435	2130	handle_ifxx:
duke@435	2131	// If this is a backwards branch in the bytecodes, add Safepoint
duke@435	2132	maybe_add_safepoint(iter().get_dest());
duke@435	2133	a = _gvn.intcon(0);
duke@435	2134	b = pop();
duke@435	2135	c = _gvn.transform( new (C, 3) CmpINode(b, a) );
duke@435	2136	do_if(btest, c);
duke@435	2137	break;
duke@435	2138
duke@435	2139	case Bytecodes::_if_icmpeq: btest = BoolTest::eq; goto handle_if_icmp;
duke@435	2140	case Bytecodes::_if_icmpne: btest = BoolTest::ne; goto handle_if_icmp;
duke@435	2141	case Bytecodes::_if_icmplt: btest = BoolTest::lt; goto handle_if_icmp;
duke@435	2142	case Bytecodes::_if_icmple: btest = BoolTest::le; goto handle_if_icmp;
duke@435	2143	case Bytecodes::_if_icmpgt: btest = BoolTest::gt; goto handle_if_icmp;
duke@435	2144	case Bytecodes::_if_icmpge: btest = BoolTest::ge; goto handle_if_icmp;
duke@435	2145	handle_if_icmp:
duke@435	2146	// If this is a backwards branch in the bytecodes, add Safepoint
duke@435	2147	maybe_add_safepoint(iter().get_dest());
duke@435	2148	a = pop();
duke@435	2149	b = pop();
duke@435	2150	c = _gvn.transform( new (C, 3) CmpINode( b, a ) );
duke@435	2151	do_if(btest, c);
duke@435	2152	break;
duke@435	2153
duke@435	2154	case Bytecodes::_tableswitch:
duke@435	2155	do_tableswitch();
duke@435	2156	break;
duke@435	2157
duke@435	2158	case Bytecodes::_lookupswitch:
duke@435	2159	do_lookupswitch();
duke@435	2160	break;
duke@435	2161
duke@435	2162	case Bytecodes::_invokestatic:
duke@435	2163	case Bytecodes::_invokespecial:
duke@435	2164	case Bytecodes::_invokevirtual:
duke@435	2165	case Bytecodes::_invokeinterface:
duke@435	2166	do_call();
duke@435	2167	break;
duke@435	2168	case Bytecodes::_checkcast:
duke@435	2169	do_checkcast();
duke@435	2170	break;
duke@435	2171	case Bytecodes::_instanceof:
duke@435	2172	do_instanceof();
duke@435	2173	break;
duke@435	2174	case Bytecodes::_anewarray:
duke@435	2175	do_anewarray();
duke@435	2176	break;
duke@435	2177	case Bytecodes::_newarray:
duke@435	2178	do_newarray((BasicType)iter().get_index());
duke@435	2179	break;
duke@435	2180	case Bytecodes::_multianewarray:
duke@435	2181	do_multianewarray();
duke@435	2182	break;
duke@435	2183	case Bytecodes::_new:
duke@435	2184	do_new();
duke@435	2185	break;
duke@435	2186
duke@435	2187	case Bytecodes::_jsr:
duke@435	2188	case Bytecodes::_jsr_w:
duke@435	2189	do_jsr();
duke@435	2190	break;
duke@435	2191
duke@435	2192	case Bytecodes::_ret:
duke@435	2193	do_ret();
duke@435	2194	break;
duke@435	2195
duke@435	2196
duke@435	2197	case Bytecodes::_monitorenter:
duke@435	2198	do_monitor_enter();
duke@435	2199	break;
duke@435	2200
duke@435	2201	case Bytecodes::_monitorexit:
duke@435	2202	do_monitor_exit();
duke@435	2203	break;
duke@435	2204
duke@435	2205	case Bytecodes::_breakpoint:
duke@435	2206	// Breakpoint set concurrently to compile
duke@435	2207	// %%% use an uncommon trap?
duke@435	2208	C->record_failure("breakpoint in method");
duke@435	2209	return;
duke@435	2210
duke@435	2211	default:
duke@435	2212	#ifndef PRODUCT
duke@435	2213	map()->dump(99);
duke@435	2214	#endif
duke@435	2215	tty->print("\nUnhandled bytecode %s\n", Bytecodes::name(bc()) );
duke@435	2216	ShouldNotReachHere();
duke@435	2217	}
duke@435	2218
duke@435	2219	#ifndef PRODUCT
duke@435	2220	IdealGraphPrinter *printer = IdealGraphPrinter::printer();
duke@435	2221	if(printer) {
duke@435	2222	char buffer[256];
duke@435	2223	sprintf(buffer, "Bytecode %d: %s", bci(), Bytecodes::name(bc()));
duke@435	2224	bool old = printer->traverse_outs();
duke@435	2225	printer->set_traverse_outs(true);
duke@435	2226	printer->print_method(C, buffer, 3);
duke@435	2227	printer->set_traverse_outs(old);
duke@435	2228	}
duke@435	2229	#endif
duke@435	2230	}