Mercurial > jdk8-mips64-public > hotspot / annotate

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

src/share/vm/opto/connode.hpp

Sun, 13 Apr 2008 17:43:42 -0400

author
coleenp
date
Sun, 13 Apr 2008 17:43:42 -0400
changeset 548
ba764ed4b6f2
parent 435
a61af66fc99e
child 559
b130b98db9cf
permissions
-rw-r--r--

6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
Summary: Compressed oops in instances, arrays, and headers. Code contributors are coleenp, phh, never, swamyv
Reviewed-by: jmasa, kamg, acorn, tbell, kvn, rasbold

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

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial