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

src/share/vm/opto/connode.hpp@1dd146f17531 (annotated)

src/share/vm/opto/connode.hpp

Thu, 26 Jun 2008 13:34:00 -0700

author

kvn

date

Thu, 26 Jun 2008 13:34:00 -0700

changeset 658

1dd146f17531

parent 656

1e026f8da827

child 670

9c2ecc2ffb12

permissions

-rw-r--r--

6716441: error in meet with +DoEscapeAnalysis
Summary: Set instance_id to InstanceBot for InstPtr->meet(AryPtr) when types are not related.
Reviewed-by: jrose, never

duke@435	1	/*
duke@435	2	* Copyright 1997-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	class PhaseTransform;
duke@435	26	class MachNode;
duke@435	27
duke@435	28	//------------------------------ConNode----------------------------------------
duke@435	29	// Simple constants
duke@435	30	class ConNode : public TypeNode {
duke@435	31	public:
duke@435	32	ConNode( const Type *t ) : TypeNode(t,1) {
duke@435	33	init_req(0, (Node*)Compile::current()->root());
duke@435	34	init_flags(Flag_is_Con);
duke@435	35	}
duke@435	36	virtual int Opcode() const;
duke@435	37	virtual uint hash() const;
duke@435	38	virtual const RegMask &out_RegMask() const { return RegMask::Empty; }
duke@435	39	virtual const RegMask &in_RegMask(uint) const { return RegMask::Empty; }
duke@435	40
duke@435	41	// Polymorphic factory method:
duke@435	42	static ConNode* make( Compile* C, const Type *t );
duke@435	43	};
duke@435	44
duke@435	45	//------------------------------ConINode---------------------------------------
duke@435	46	// Simple integer constants
duke@435	47	class ConINode : public ConNode {
duke@435	48	public:
duke@435	49	ConINode( const TypeInt *t ) : ConNode(t) {}
duke@435	50	virtual int Opcode() const;
duke@435	51
duke@435	52	// Factory method:
duke@435	53	static ConINode* make( Compile* C, int con ) {
duke@435	54	return new (C, 1) ConINode( TypeInt::make(con) );
duke@435	55	}
duke@435	56
duke@435	57	};
duke@435	58
duke@435	59	//------------------------------ConPNode---------------------------------------
duke@435	60	// Simple pointer constants
duke@435	61	class ConPNode : public ConNode {
duke@435	62	public:
duke@435	63	ConPNode( const TypePtr *t ) : ConNode(t) {}
duke@435	64	virtual int Opcode() const;
duke@435	65
duke@435	66	// Factory methods:
duke@435	67	static ConPNode* make( Compile *C ,address con ) {
duke@435	68	if (con == NULL)
duke@435	69	return new (C, 1) ConPNode( TypePtr::NULL_PTR ) ;
duke@435	70	else
duke@435	71	return new (C, 1) ConPNode( TypeRawPtr::make(con) );
duke@435	72	}
duke@435	73	};
duke@435	74
duke@435	75
coleenp@548	76	//------------------------------ConNNode--------------------------------------
coleenp@548	77	// Simple narrow oop constants
coleenp@548	78	class ConNNode : public ConNode {
coleenp@548	79	public:
coleenp@548	80	ConNNode( const TypeNarrowOop *t ) : ConNode(t) {}
coleenp@548	81	virtual int Opcode() const;
coleenp@548	82	};
coleenp@548	83
coleenp@548	84
duke@435	85	//------------------------------ConLNode---------------------------------------
duke@435	86	// Simple long constants
duke@435	87	class ConLNode : public ConNode {
duke@435	88	public:
duke@435	89	ConLNode( const TypeLong *t ) : ConNode(t) {}
duke@435	90	virtual int Opcode() const;
duke@435	91
duke@435	92	// Factory method:
duke@435	93	static ConLNode* make( Compile *C ,jlong con ) {
duke@435	94	return new (C, 1) ConLNode( TypeLong::make(con) );
duke@435	95	}
duke@435	96
duke@435	97	};
duke@435	98
duke@435	99	//------------------------------ConFNode---------------------------------------
duke@435	100	// Simple float constants
duke@435	101	class ConFNode : public ConNode {
duke@435	102	public:
duke@435	103	ConFNode( const TypeF *t ) : ConNode(t) {}
duke@435	104	virtual int Opcode() const;
duke@435	105
duke@435	106	// Factory method:
duke@435	107	static ConFNode* make( Compile *C, float con ) {
duke@435	108	return new (C, 1) ConFNode( TypeF::make(con) );
duke@435	109	}
duke@435	110
duke@435	111	};
duke@435	112
duke@435	113	//------------------------------ConDNode---------------------------------------
duke@435	114	// Simple double constants
duke@435	115	class ConDNode : public ConNode {
duke@435	116	public:
duke@435	117	ConDNode( const TypeD *t ) : ConNode(t) {}
duke@435	118	virtual int Opcode() const;
duke@435	119
duke@435	120	// Factory method:
duke@435	121	static ConDNode* make( Compile *C, double con ) {
duke@435	122	return new (C, 1) ConDNode( TypeD::make(con) );
duke@435	123	}
duke@435	124
duke@435	125	};
duke@435	126
duke@435	127	//------------------------------BinaryNode-------------------------------------
duke@435	128	// Place holder for the 2 conditional inputs to a CMove. CMove needs 4
duke@435	129	// inputs: the Bool (for the lt/gt/eq/ne bits), the flags (result of some
duke@435	130	// compare), and the 2 values to select between. The Matcher requires a
duke@435	131	// binary tree so we break it down like this:
duke@435	132	// (CMove (Binary bol cmp) (Binary src1 src2))
duke@435	133	class BinaryNode : public Node {
duke@435	134	public:
duke@435	135	BinaryNode( Node *n1, Node *n2 ) : Node(0,n1,n2) { }
duke@435	136	virtual int Opcode() const;
duke@435	137	virtual uint ideal_reg() const { return 0; }
duke@435	138	};
duke@435	139
duke@435	140	//------------------------------CMoveNode--------------------------------------
duke@435	141	// Conditional move
duke@435	142	class CMoveNode : public TypeNode {
duke@435	143	public:
duke@435	144	enum { Control, // When is it safe to do this cmove?
duke@435	145	Condition, // Condition controlling the cmove
duke@435	146	IfFalse, // Value if condition is false
duke@435	147	IfTrue }; // Value if condition is true
duke@435	148	CMoveNode( Node *bol, Node *left, Node *right, const Type *t ) : TypeNode(t,4)
duke@435	149	{
duke@435	150	init_class_id(Class_CMove);
duke@435	151	// all inputs are nullified in Node::Node(int)
duke@435	152	// init_req(Control,NULL);
duke@435	153	init_req(Condition,bol);
duke@435	154	init_req(IfFalse,left);
duke@435	155	init_req(IfTrue,right);
duke@435	156	}
duke@435	157	virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435	158	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	159	virtual Node *Identity( PhaseTransform *phase );
duke@435	160	static CMoveNode *make( Compile *C, Node *c, Node *bol, Node *left, Node *right, const Type *t );
duke@435	161	// Helper function to spot cmove graph shapes
duke@435	162	static Node *is_cmove_id( PhaseTransform *phase, Node *cmp, Node *t, Node *f, BoolNode *b );
duke@435	163	};
duke@435	164
duke@435	165	//------------------------------CMoveDNode-------------------------------------
duke@435	166	class CMoveDNode : public CMoveNode {
duke@435	167	public:
duke@435	168	CMoveDNode( Node *bol, Node *left, Node *right, const Type* t) : CMoveNode(bol,left,right,t){}
duke@435	169	virtual int Opcode() const;
duke@435	170	virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435	171	};
duke@435	172
duke@435	173	//------------------------------CMoveFNode-------------------------------------
duke@435	174	class CMoveFNode : public CMoveNode {
duke@435	175	public:
duke@435	176	CMoveFNode( Node *bol, Node *left, Node *right, const Type* t ) : CMoveNode(bol,left,right,t) {}
duke@435	177	virtual int Opcode() const;
duke@435	178	virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435	179	};
duke@435	180
duke@435	181	//------------------------------CMoveINode-------------------------------------
duke@435	182	class CMoveINode : public CMoveNode {
duke@435	183	public:
duke@435	184	CMoveINode( Node *bol, Node *left, Node *right, const TypeInt *ti ) : CMoveNode(bol,left,right,ti){}
duke@435	185	virtual int Opcode() const;
duke@435	186	virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435	187	};
duke@435	188
duke@435	189	//------------------------------CMoveLNode-------------------------------------
duke@435	190	class CMoveLNode : public CMoveNode {
duke@435	191	public:
duke@435	192	CMoveLNode(Node *bol, Node *left, Node *right, const TypeLong *tl ) : CMoveNode(bol,left,right,tl){}
duke@435	193	virtual int Opcode() const;
duke@435	194	};
duke@435	195
duke@435	196	//------------------------------CMovePNode-------------------------------------
duke@435	197	class CMovePNode : public CMoveNode {
duke@435	198	public:
duke@435	199	CMovePNode( Node *c, Node *bol, Node *left, Node *right, const TypePtr* t ) : CMoveNode(bol,left,right,t) { init_req(Control,c); }
duke@435	200	virtual int Opcode() const;
duke@435	201	};
duke@435	202
kvn@599	203	//------------------------------CMoveNNode-------------------------------------
kvn@599	204	class CMoveNNode : public CMoveNode {
kvn@599	205	public:
kvn@599	206	CMoveNNode( Node *c, Node *bol, Node *left, Node *right, const Type* t ) : CMoveNode(bol,left,right,t) { init_req(Control,c); }
kvn@599	207	virtual int Opcode() const;
kvn@599	208	};
kvn@599	209
kvn@599	210	//------------------------------ConstraintCastNode-----------------------------
duke@435	211	// cast to a different range
duke@435	212	class ConstraintCastNode: public TypeNode {
duke@435	213	public:
duke@435	214	ConstraintCastNode (Node *n, const Type *t ): TypeNode(t,2) {
duke@435	215	init_class_id(Class_ConstraintCast);
duke@435	216	init_req(1, n);
duke@435	217	}
duke@435	218	virtual Node *Identity( PhaseTransform *phase );
duke@435	219	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	220	virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435	221	virtual int Opcode() const;
duke@435	222	virtual uint ideal_reg() const = 0;
duke@435	223	virtual Node *Ideal_DU_postCCP( PhaseCCP * );
duke@435	224	};
duke@435	225
duke@435	226	//------------------------------CastIINode-------------------------------------
duke@435	227	// cast integer to integer (different range)
duke@435	228	class CastIINode: public ConstraintCastNode {
duke@435	229	public:
duke@435	230	CastIINode (Node *n, const Type *t ): ConstraintCastNode(n,t) {}
duke@435	231	virtual int Opcode() const;
duke@435	232	virtual uint ideal_reg() const { return Op_RegI; }
duke@435	233	};
duke@435	234
duke@435	235	//------------------------------CastPPNode-------------------------------------
duke@435	236	// cast pointer to pointer (different type)
duke@435	237	class CastPPNode: public ConstraintCastNode {
duke@435	238	public:
kvn@561	239	CastPPNode (Node *n, const Type *t ): ConstraintCastNode(n, t) {}
duke@435	240	virtual int Opcode() const;
duke@435	241	virtual uint ideal_reg() const { return Op_RegP; }
duke@435	242	virtual Node *Ideal_DU_postCCP( PhaseCCP * );
duke@435	243	};
duke@435	244
duke@435	245	//------------------------------CheckCastPPNode--------------------------------
duke@435	246	// for _checkcast, cast pointer to pointer (different type), without JOIN,
duke@435	247	class CheckCastPPNode: public TypeNode {
duke@435	248	public:
duke@435	249	CheckCastPPNode( Node *c, Node *n, const Type *t ) : TypeNode(t,2) {
duke@435	250	init_class_id(Class_CheckCastPP);
duke@435	251	init_req(0, c);
duke@435	252	init_req(1, n);
duke@435	253	}
kvn@561	254
duke@435	255	virtual Node *Identity( PhaseTransform *phase );
duke@435	256	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	257	virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435	258	virtual int Opcode() const;
duke@435	259	virtual uint ideal_reg() const { return Op_RegP; }
duke@435	260	// No longer remove CheckCast after CCP as it gives me a place to hang
duke@435	261	// the proper address type - which is required to compute anti-deps.
duke@435	262	//virtual Node *Ideal_DU_postCCP( PhaseCCP * );
duke@435	263	};
duke@435	264
coleenp@548	265
coleenp@548	266	//------------------------------EncodeP--------------------------------
coleenp@548	267	// Encodes an oop pointers into its compressed form
coleenp@548	268	// Takes an extra argument which is the real heap base as a long which
coleenp@548	269	// may be useful for code generation in the backend.
coleenp@548	270	class EncodePNode : public TypeNode {
coleenp@548	271	public:
coleenp@548	272	EncodePNode(Node* value, const Type* type):
coleenp@548	273	TypeNode(type, 2) {
kvn@603	274	init_class_id(Class_EncodeP);
coleenp@548	275	init_req(0, NULL);
coleenp@548	276	init_req(1, value);
coleenp@548	277	}
coleenp@548	278	virtual int Opcode() const;
coleenp@548	279	virtual Node *Identity( PhaseTransform *phase );
kvn@559	280	virtual const Type *Value( PhaseTransform *phase ) const;
coleenp@548	281	virtual uint ideal_reg() const { return Op_RegN; }
coleenp@548	282
kvn@598	283	virtual Node *Ideal_DU_postCCP( PhaseCCP *ccp );
coleenp@548	284	};
coleenp@548	285
coleenp@548	286	//------------------------------DecodeN--------------------------------
coleenp@548	287	// Converts a narrow oop into a real oop ptr.
coleenp@548	288	// Takes an extra argument which is the real heap base as a long which
coleenp@548	289	// may be useful for code generation in the backend.
coleenp@548	290	class DecodeNNode : public TypeNode {
coleenp@548	291	public:
coleenp@548	292	DecodeNNode(Node* value, const Type* type):
coleenp@548	293	TypeNode(type, 2) {
kvn@603	294	init_class_id(Class_DecodeN);
coleenp@548	295	init_req(0, NULL);
coleenp@548	296	init_req(1, value);
coleenp@548	297	}
coleenp@548	298	virtual int Opcode() const;
coleenp@548	299	virtual Node *Identity( PhaseTransform *phase );
kvn@559	300	virtual const Type *Value( PhaseTransform *phase ) const;
coleenp@548	301	virtual uint ideal_reg() const { return Op_RegP; }
coleenp@548	302	};
coleenp@548	303
duke@435	304	//------------------------------Conv2BNode-------------------------------------
duke@435	305	// Convert int/pointer to a Boolean. Map zero to zero, all else to 1.
duke@435	306	class Conv2BNode : public Node {
duke@435	307	public:
duke@435	308	Conv2BNode( Node *i ) : Node(0,i) {}
duke@435	309	virtual int Opcode() const;
duke@435	310	virtual const Type *bottom_type() const { return TypeInt::BOOL; }
duke@435	311	virtual Node *Identity( PhaseTransform *phase );
duke@435	312	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	313	virtual uint ideal_reg() const { return Op_RegI; }
duke@435	314	};
duke@435	315
duke@435	316	// The conversions operations are all Alpha sorted. Please keep it that way!
duke@435	317	//------------------------------ConvD2FNode------------------------------------
duke@435	318	// Convert double to float
duke@435	319	class ConvD2FNode : public Node {
duke@435	320	public:
duke@435	321	ConvD2FNode( Node *in1 ) : Node(0,in1) {}
duke@435	322	virtual int Opcode() const;
duke@435	323	virtual const Type *bottom_type() const { return Type::FLOAT; }
duke@435	324	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	325	virtual Node *Identity( PhaseTransform *phase );
duke@435	326	virtual uint ideal_reg() const { return Op_RegF; }
duke@435	327	};
duke@435	328
duke@435	329	//------------------------------ConvD2INode------------------------------------
duke@435	330	// Convert Double to Integer
duke@435	331	class ConvD2INode : public Node {
duke@435	332	public:
duke@435	333	ConvD2INode( Node *in1 ) : Node(0,in1) {}
duke@435	334	virtual int Opcode() const;
duke@435	335	virtual const Type *bottom_type() const { return TypeInt::INT; }
duke@435	336	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	337	virtual Node *Identity( PhaseTransform *phase );
duke@435	338	virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435	339	virtual uint ideal_reg() const { return Op_RegI; }
duke@435	340	};
duke@435	341
duke@435	342	//------------------------------ConvD2LNode------------------------------------
duke@435	343	// Convert Double to Long
duke@435	344	class ConvD2LNode : public Node {
duke@435	345	public:
duke@435	346	ConvD2LNode( Node *dbl ) : Node(0,dbl) {}
duke@435	347	virtual int Opcode() const;
duke@435	348	virtual const Type *bottom_type() const { return TypeLong::LONG; }
duke@435	349	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	350	virtual Node *Identity( PhaseTransform *phase );
duke@435	351	virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435	352	virtual uint ideal_reg() const { return Op_RegL; }
duke@435	353	};
duke@435	354
duke@435	355	//------------------------------ConvF2DNode------------------------------------
duke@435	356	// Convert Float to a Double.
duke@435	357	class ConvF2DNode : public Node {
duke@435	358	public:
duke@435	359	ConvF2DNode( Node *in1 ) : Node(0,in1) {}
duke@435	360	virtual int Opcode() const;
duke@435	361	virtual const Type *bottom_type() const { return Type::DOUBLE; }
duke@435	362	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	363	virtual uint ideal_reg() const { return Op_RegD; }
duke@435	364	};
duke@435	365
duke@435	366	//------------------------------ConvF2INode------------------------------------
duke@435	367	// Convert float to integer
duke@435	368	class ConvF2INode : public Node {
duke@435	369	public:
duke@435	370	ConvF2INode( Node *in1 ) : Node(0,in1) {}
duke@435	371	virtual int Opcode() const;
duke@435	372	virtual const Type *bottom_type() const { return TypeInt::INT; }
duke@435	373	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	374	virtual Node *Identity( PhaseTransform *phase );
duke@435	375	virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435	376	virtual uint ideal_reg() const { return Op_RegI; }
duke@435	377	};
duke@435	378
duke@435	379	//------------------------------ConvF2LNode------------------------------------
duke@435	380	// Convert float to long
duke@435	381	class ConvF2LNode : public Node {
duke@435	382	public:
duke@435	383	ConvF2LNode( Node *in1 ) : Node(0,in1) {}
duke@435	384	virtual int Opcode() const;
duke@435	385	virtual const Type *bottom_type() const { return TypeLong::LONG; }
duke@435	386	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	387	virtual Node *Identity( PhaseTransform *phase );
duke@435	388	virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435	389	virtual uint ideal_reg() const { return Op_RegL; }
duke@435	390	};
duke@435	391
duke@435	392	//------------------------------ConvI2DNode------------------------------------
duke@435	393	// Convert Integer to Double
duke@435	394	class ConvI2DNode : public Node {
duke@435	395	public:
duke@435	396	ConvI2DNode( Node *in1 ) : Node(0,in1) {}
duke@435	397	virtual int Opcode() const;
duke@435	398	virtual const Type *bottom_type() const { return Type::DOUBLE; }
duke@435	399	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	400	virtual uint ideal_reg() const { return Op_RegD; }
duke@435	401	};
duke@435	402
duke@435	403	//------------------------------ConvI2FNode------------------------------------
duke@435	404	// Convert Integer to Float
duke@435	405	class ConvI2FNode : public Node {
duke@435	406	public:
duke@435	407	ConvI2FNode( Node *in1 ) : Node(0,in1) {}
duke@435	408	virtual int Opcode() const;
duke@435	409	virtual const Type *bottom_type() const { return Type::FLOAT; }
duke@435	410	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	411	virtual Node *Identity( PhaseTransform *phase );
duke@435	412	virtual uint ideal_reg() const { return Op_RegF; }
duke@435	413	};
duke@435	414
duke@435	415	//------------------------------ConvI2LNode------------------------------------
duke@435	416	// Convert integer to long
duke@435	417	class ConvI2LNode : public TypeNode {
duke@435	418	public:
duke@435	419	ConvI2LNode(Node *in1, const TypeLong* t = TypeLong::INT)
duke@435	420	: TypeNode(t, 2)
duke@435	421	{ init_req(1, in1); }
duke@435	422	virtual int Opcode() const;
duke@435	423	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	424	virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435	425	virtual uint ideal_reg() const { return Op_RegL; }
duke@435	426	};
duke@435	427
duke@435	428	//------------------------------ConvL2DNode------------------------------------
duke@435	429	// Convert Long to Double
duke@435	430	class ConvL2DNode : public Node {
duke@435	431	public:
duke@435	432	ConvL2DNode( Node *in1 ) : Node(0,in1) {}
duke@435	433	virtual int Opcode() const;
duke@435	434	virtual const Type *bottom_type() const { return Type::DOUBLE; }
duke@435	435	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	436	virtual uint ideal_reg() const { return Op_RegD; }
duke@435	437	};
duke@435	438
duke@435	439	//------------------------------ConvL2FNode------------------------------------
duke@435	440	// Convert Long to Float
duke@435	441	class ConvL2FNode : public Node {
duke@435	442	public:
duke@435	443	ConvL2FNode( Node *in1 ) : Node(0,in1) {}
duke@435	444	virtual int Opcode() const;
duke@435	445	virtual const Type *bottom_type() const { return Type::FLOAT; }
duke@435	446	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	447	virtual uint ideal_reg() const { return Op_RegF; }
duke@435	448	};
duke@435	449
duke@435	450	//------------------------------ConvL2INode------------------------------------
duke@435	451	// Convert long to integer
duke@435	452	class ConvL2INode : public Node {
duke@435	453	public:
duke@435	454	ConvL2INode( Node *in1 ) : Node(0,in1) {}
duke@435	455	virtual int Opcode() const;
duke@435	456	virtual const Type *bottom_type() const { return TypeInt::INT; }
duke@435	457	virtual Node *Identity( PhaseTransform *phase );
duke@435	458	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	459	virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435	460	virtual uint ideal_reg() const { return Op_RegI; }
duke@435	461	};
duke@435	462
duke@435	463	//------------------------------CastX2PNode-------------------------------------
duke@435	464	// convert a machine-pointer-sized integer to a raw pointer
duke@435	465	class CastX2PNode : public Node {
duke@435	466	public:
duke@435	467	CastX2PNode( Node *n ) : Node(NULL, n) {}
duke@435	468	virtual int Opcode() const;
duke@435	469	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	470	virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435	471	virtual Node *Identity( PhaseTransform *phase );
duke@435	472	virtual uint ideal_reg() const { return Op_RegP; }
duke@435	473	virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM; }
duke@435	474	};
duke@435	475
duke@435	476	//------------------------------CastP2XNode-------------------------------------
duke@435	477	// Used in both 32-bit and 64-bit land.
duke@435	478	// Used for card-marks and unsafe pointer math.
duke@435	479	class CastP2XNode : public Node {
duke@435	480	public:
duke@435	481	CastP2XNode( Node *ctrl, Node *n ) : Node(ctrl, n) {}
duke@435	482	virtual int Opcode() const;
duke@435	483	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	484	virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
duke@435	485	virtual Node *Identity( PhaseTransform *phase );
duke@435	486	virtual uint ideal_reg() const { return Op_RegX; }
duke@435	487	virtual const Type *bottom_type() const { return TypeX_X; }
duke@435	488	// Return false to keep node from moving away from an associated card mark.
duke@435	489	virtual bool depends_only_on_test() const { return false; }
duke@435	490	};
duke@435	491
duke@435	492	//------------------------------MemMoveNode------------------------------------
duke@435	493	// Memory to memory move. Inserted very late, after allocation.
duke@435	494	class MemMoveNode : public Node {
duke@435	495	public:
duke@435	496	MemMoveNode( Node *dst, Node *src ) : Node(0,dst,src) {}
duke@435	497	virtual int Opcode() const;
duke@435	498	};
duke@435	499
duke@435	500	//------------------------------ThreadLocalNode--------------------------------
duke@435	501	// Ideal Node which returns the base of ThreadLocalStorage.
duke@435	502	class ThreadLocalNode : public Node {
duke@435	503	public:
duke@435	504	ThreadLocalNode( ) : Node((Node*)Compile::current()->root()) {}
duke@435	505	virtual int Opcode() const;
duke@435	506	virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM;}
duke@435	507	virtual uint ideal_reg() const { return Op_RegP; }
duke@435	508	};
duke@435	509
duke@435	510	//------------------------------LoadReturnPCNode-------------------------------
duke@435	511	class LoadReturnPCNode: public Node {
duke@435	512	public:
duke@435	513	LoadReturnPCNode(Node *c) : Node(c) { }
duke@435	514	virtual int Opcode() const;
duke@435	515	virtual uint ideal_reg() const { return Op_RegP; }
duke@435	516	};
duke@435	517
duke@435	518
duke@435	519	//-----------------------------RoundFloatNode----------------------------------
duke@435	520	class RoundFloatNode: public Node {
duke@435	521	public:
duke@435	522	RoundFloatNode(Node* c, Node *in1): Node(c, in1) {}
duke@435	523	virtual int Opcode() const;
duke@435	524	virtual const Type *bottom_type() const { return Type::FLOAT; }
duke@435	525	virtual uint ideal_reg() const { return Op_RegF; }
duke@435	526	virtual Node *Identity( PhaseTransform *phase );
duke@435	527	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	528	};
duke@435	529
duke@435	530
duke@435	531	//-----------------------------RoundDoubleNode---------------------------------
duke@435	532	class RoundDoubleNode: public Node {
duke@435	533	public:
duke@435	534	RoundDoubleNode(Node* c, Node *in1): Node(c, in1) {}
duke@435	535	virtual int Opcode() const;
duke@435	536	virtual const Type *bottom_type() const { return Type::DOUBLE; }
duke@435	537	virtual uint ideal_reg() const { return Op_RegD; }
duke@435	538	virtual Node *Identity( PhaseTransform *phase );
duke@435	539	virtual const Type *Value( PhaseTransform *phase ) const;
duke@435	540	};
duke@435	541
duke@435	542	//------------------------------Opaque1Node------------------------------------
duke@435	543	// A node to prevent unwanted optimizations. Allows constant folding.
duke@435	544	// Stops value-numbering, Ideal calls or Identity functions.
duke@435	545	class Opaque1Node : public Node {
duke@435	546	virtual uint hash() const ; // { return NO_HASH; }
duke@435	547	virtual uint cmp( const Node &n ) const;
duke@435	548	public:
kvn@651	549	Opaque1Node( Compile* C, Node *n ) : Node(0,n) {
kvn@651	550	// Put it on the Macro nodes list to removed during macro nodes expansion.
kvn@651	551	init_flags(Flag_is_macro);
kvn@651	552	C->add_macro_node(this);
kvn@651	553	}
duke@435	554	// Special version for the pre-loop to hold the original loop limit
duke@435	555	// which is consumed by range check elimination.
kvn@651	556	Opaque1Node( Compile* C, Node *n, Node* orig_limit ) : Node(0,n,orig_limit) {
kvn@651	557	// Put it on the Macro nodes list to removed during macro nodes expansion.
kvn@651	558	init_flags(Flag_is_macro);
kvn@651	559	C->add_macro_node(this);
kvn@651	560	}
duke@435	561	Node* original_loop_limit() { return req()==3 ? in(2) : NULL; }
duke@435	562	virtual int Opcode() const;
duke@435	563	virtual const Type *bottom_type() const { return TypeInt::INT; }
duke@435	564	virtual Node *Identity( PhaseTransform *phase );
duke@435	565	};
duke@435	566
duke@435	567	//------------------------------Opaque2Node------------------------------------
duke@435	568	// A node to prevent unwanted optimizations. Allows constant folding. Stops
duke@435	569	// value-numbering, most Ideal calls or Identity functions. This Node is
duke@435	570	// specifically designed to prevent the pre-increment value of a loop trip
duke@435	571	// counter from being live out of the bottom of the loop (hence causing the
duke@435	572	// pre- and post-increment values both being live and thus requiring an extra
duke@435	573	// temp register and an extra move). If we "accidentally" optimize through
duke@435	574	// this kind of a Node, we'll get slightly pessimal, but correct, code. Thus
duke@435	575	// it's OK to be slightly sloppy on optimizations here.
duke@435	576	class Opaque2Node : public Node {
duke@435	577	virtual uint hash() const ; // { return NO_HASH; }
duke@435	578	virtual uint cmp( const Node &n ) const;
duke@435	579	public:
kvn@651	580	Opaque2Node( Compile* C, Node *n ) : Node(0,n) {
kvn@651	581	// Put it on the Macro nodes list to removed during macro nodes expansion.
kvn@651	582	init_flags(Flag_is_macro);
kvn@651	583	C->add_macro_node(this);
kvn@651	584	}
duke@435	585	virtual int Opcode() const;
duke@435	586	virtual const Type *bottom_type() const { return TypeInt::INT; }
duke@435	587	};
duke@435	588
duke@435	589	//----------------------PartialSubtypeCheckNode--------------------------------
duke@435	590	// The 2nd slow-half of a subtype check. Scan the subklass's 2ndary superklass
duke@435	591	// array for an instance of the superklass. Set a hidden internal cache on a
duke@435	592	// hit (cache is checked with exposed code in gen_subtype_check()). Return
duke@435	593	// not zero for a miss or zero for a hit.
duke@435	594	class PartialSubtypeCheckNode : public Node {
duke@435	595	public:
duke@435	596	PartialSubtypeCheckNode(Node* c, Node* sub, Node* super) : Node(c,sub,super) {}
duke@435	597	virtual int Opcode() const;
duke@435	598	virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM; }
duke@435	599	virtual uint ideal_reg() const { return Op_RegP; }
duke@435	600	};
duke@435	601
duke@435	602	//
duke@435	603	class MoveI2FNode : public Node {
duke@435	604	public:
duke@435	605	MoveI2FNode( Node *value ) : Node(0,value) {}
duke@435	606	virtual int Opcode() const;
duke@435	607	virtual const Type *bottom_type() const { return Type::FLOAT; }
duke@435	608	virtual uint ideal_reg() const { return Op_RegF; }
duke@435	609	virtual const Type* Value( PhaseTransform *phase ) const;
duke@435	610	};
duke@435	611
duke@435	612	class MoveL2DNode : public Node {
duke@435	613	public:
duke@435	614	MoveL2DNode( Node *value ) : Node(0,value) {}
duke@435	615	virtual int Opcode() const;
duke@435	616	virtual const Type *bottom_type() const { return Type::DOUBLE; }
duke@435	617	virtual uint ideal_reg() const { return Op_RegD; }
duke@435	618	virtual const Type* Value( PhaseTransform *phase ) const;
duke@435	619	};
duke@435	620
duke@435	621	class MoveF2INode : public Node {
duke@435	622	public:
duke@435	623	MoveF2INode( Node *value ) : Node(0,value) {}
duke@435	624	virtual int Opcode() const;
duke@435	625	virtual const Type *bottom_type() const { return TypeInt::INT; }
duke@435	626	virtual uint ideal_reg() const { return Op_RegI; }
duke@435	627	virtual const Type* Value( PhaseTransform *phase ) const;
duke@435	628	};
duke@435	629
duke@435	630	class MoveD2LNode : public Node {
duke@435	631	public:
duke@435	632	MoveD2LNode( Node *value ) : Node(0,value) {}
duke@435	633	virtual int Opcode() const;
duke@435	634	virtual const Type *bottom_type() const { return TypeLong::LONG; }
duke@435	635	virtual uint ideal_reg() const { return Op_RegL; }
duke@435	636	virtual const Type* Value( PhaseTransform *phase ) const;
duke@435	637	};