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

src/share/vm/opto/multnode.cpp@1bd45abaa507 (annotated)

src/share/vm/opto/multnode.cpp

Wed, 16 Nov 2011 09:13:57 -0800

author

kvn

date

Wed, 16 Nov 2011 09:13:57 -0800

changeset 3311

1bd45abaa507

parent 2314

f95d63e2154a

child 4037

da91efe96a93

permissions

-rw-r--r--

6890673: Eliminate allocations immediately after EA
Summary: Try to eliminate allocations and related locks immediately after escape analysis.
Reviewed-by: never

duke@435	1	/*
stefank@2314	2	* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
duke@435	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435	4	*
duke@435	5	* This code is free software; you can redistribute it and/or modify it
duke@435	6	* under the terms of the GNU General Public License version 2 only, as
duke@435	7	* published by the Free Software Foundation.
duke@435	8	*
duke@435	9	* This code is distributed in the hope that it will be useful, but WITHOUT
duke@435	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435	12	* version 2 for more details (a copy is included in the LICENSE file that
duke@435	13	* accompanied this code).
duke@435	14	*
duke@435	15	* You should have received a copy of the GNU General Public License version
duke@435	16	* 2 along with this work; if not, write to the Free Software Foundation,
duke@435	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435	18	*
trims@1907	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907	20	* or visit www.oracle.com if you need additional information or have any
trims@1907	21	* questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
stefank@2314	25	#include "precompiled.hpp"
stefank@2314	26	#include "opto/matcher.hpp"
stefank@2314	27	#include "opto/multnode.hpp"
stefank@2314	28	#include "opto/opcodes.hpp"
stefank@2314	29	#include "opto/phaseX.hpp"
stefank@2314	30	#include "opto/regmask.hpp"
stefank@2314	31	#include "opto/type.hpp"
duke@435	32
duke@435	33	//=============================================================================
duke@435	34	//------------------------------MultiNode--------------------------------------
duke@435	35	const RegMask &MultiNode::out_RegMask() const {
duke@435	36	return RegMask::Empty;
duke@435	37	}
duke@435	38
duke@435	39	Node *MultiNode::match( const ProjNode *proj, const Matcher *m ) { return proj->clone(); }
duke@435	40
duke@435	41	//------------------------------proj_out---------------------------------------
duke@435	42	// Get a named projection
duke@435	43	ProjNode* MultiNode::proj_out(uint which_proj) const {
duke@435	44	assert(Opcode() != Op_If || which_proj == (uint)true || which_proj == (uint)false, "must be 1 or 0");
duke@435	45	assert(Opcode() != Op_If || outcnt() == 2, "bad if #1");
duke@435	46	for( DUIterator_Fast imax, i = fast_outs(imax); i < imax; i++ ) {
duke@435	47	Node *p = fast_out(i);
duke@435	48	if( !p->is_Proj() ) {
duke@435	49	assert(p == this && this->is_Start(), "else must be proj");
duke@435	50	continue;
duke@435	51	}
duke@435	52	ProjNode *proj = p->as_Proj();
duke@435	53	if( proj->_con == which_proj ) {
duke@435	54	assert(Opcode() != Op_If || proj->Opcode() == (which_proj?Op_IfTrue:Op_IfFalse), "bad if #2");
duke@435	55	return proj;
duke@435	56	}
duke@435	57	}
duke@435	58	return NULL;
duke@435	59	}
duke@435	60
duke@435	61	//=============================================================================
duke@435	62	//------------------------------ProjNode---------------------------------------
duke@435	63	uint ProjNode::hash() const {
duke@435	64	// only one input
duke@435	65	return (uintptr_t)in(TypeFunc::Control) + (_con << 1) + (_is_io_use ? 1 : 0);
duke@435	66	}
duke@435	67	uint ProjNode::cmp( const Node &n ) const { return _con == ((ProjNode&)n)._con && ((ProjNode&)n)._is_io_use == _is_io_use; }
duke@435	68	uint ProjNode::size_of() const { return sizeof(ProjNode); }
duke@435	69
duke@435	70	// Test if we propagate interesting control along this projection
duke@435	71	bool ProjNode::is_CFG() const {
duke@435	72	Node *def = in(0);
duke@435	73	return (_con == TypeFunc::Control && def->is_CFG());
duke@435	74	}
duke@435	75
duke@435	76	const Type *ProjNode::bottom_type() const {
duke@435	77	if (in(0) == NULL) return Type::TOP;
duke@435	78	const Type *tb = in(0)->bottom_type();
duke@435	79	if( tb == Type::TOP ) return Type::TOP;
duke@435	80	if( tb == Type::BOTTOM ) return Type::BOTTOM;
duke@435	81	const TypeTuple *t = tb->is_tuple();
duke@435	82	return t->field_at(_con);
duke@435	83	}
duke@435	84
duke@435	85	const TypePtr *ProjNode::adr_type() const {
duke@435	86	if (bottom_type() == Type::MEMORY) {
duke@435	87	// in(0) might be a narrow MemBar; otherwise we will report TypePtr::BOTTOM
duke@435	88	const TypePtr* adr_type = in(0)->adr_type();
duke@435	89	#ifdef ASSERT
duke@435	90	if (!is_error_reported() && !Node::in_dump())
duke@435	91	assert(adr_type != NULL, "source must have adr_type");
duke@435	92	#endif
duke@435	93	return adr_type;
duke@435	94	}
duke@435	95	assert(bottom_type()->base() != Type::Memory, "no other memories?");
duke@435	96	return NULL;
duke@435	97	}
duke@435	98
duke@435	99	bool ProjNode::pinned() const { return in(0)->pinned(); }
duke@435	100	#ifndef PRODUCT
duke@435	101	void ProjNode::dump_spec(outputStream *st) const { st->print("#%d",_con); if(_is_io_use) st->print(" (i_o_use)");}
duke@435	102	#endif
duke@435	103
duke@435	104	//----------------------------check_con----------------------------------------
duke@435	105	void ProjNode::check_con() const {
duke@435	106	Node* n = in(0);
duke@435	107	if (n == NULL) return; // should be assert, but NodeHash makes bogons
duke@435	108	if (n->is_Mach()) return; // mach. projs. are not type-safe
duke@435	109	if (n->is_Start()) return; // alas, starts can have mach. projs. also
duke@435	110	if (_con == SCMemProjNode::SCMEMPROJCON ) return;
duke@435	111	const Type* t = n->bottom_type();
duke@435	112	if (t == Type::TOP) return; // multi is dead
duke@435	113	assert(_con < t->is_tuple()->cnt(), "ProjNode::_con must be in range");
duke@435	114	}
duke@435	115
duke@435	116	//------------------------------Value------------------------------------------
duke@435	117	const Type *ProjNode::Value( PhaseTransform *phase ) const {
duke@435	118	if( !in(0) ) return Type::TOP;
duke@435	119	const Type *t = phase->type(in(0));
duke@435	120	if( t == Type::TOP ) return t;
duke@435	121	if( t == Type::BOTTOM ) return t;
duke@435	122	return t->is_tuple()->field_at(_con);
duke@435	123	}
duke@435	124
duke@435	125	//------------------------------out_RegMask------------------------------------
duke@435	126	// Pass the buck uphill
duke@435	127	const RegMask &ProjNode::out_RegMask() const {
duke@435	128	return RegMask::Empty;
duke@435	129	}
duke@435	130
duke@435	131	//------------------------------ideal_reg--------------------------------------
duke@435	132	uint ProjNode::ideal_reg() const {
duke@435	133	return Matcher::base2reg[bottom_type()->base()];
duke@435	134	}