264 const bool has_range_check() { 265 #ifdef _LP64 266 return _range_check_dependency; 267 #else 268 assert(!_range_check_dependency, "Should not have range check dependency"); 269 return false; 270 #endif 271 } 272 #ifndef PRODUCT 273 virtual void dump_spec(outputStream *st) const; 274 #endif 275 }; 276 277 //------------------------------CastPPNode------------------------------------- 278 // cast pointer to pointer (different type) 279 class CastPPNode: public ConstraintCastNode { 280 public: 281 CastPPNode (Node *n, const Type *t ): ConstraintCastNode(n, t) {} 282 virtual int Opcode() const; 283 virtual uint ideal_reg() const { return Op_RegP; } 284 virtual Node *Ideal_DU_postCCP( PhaseCCP * ); 285 }; 286 287 //------------------------------CheckCastPPNode-------------------------------- 288 // for _checkcast, cast pointer to pointer (different type), without JOIN, 289 class CheckCastPPNode: public TypeNode { 290 public: 291 CheckCastPPNode( Node *c, Node *n, const Type *t ) : TypeNode(t,2) { 292 init_class_id(Class_CheckCastPP); 293 init_req(0, c); 294 init_req(1, n); 295 } 296 297 virtual Node *Identity( PhaseTransform *phase ); 298 virtual const Type *Value( PhaseTransform *phase ) const; 299 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 300 virtual int Opcode() const; 301 virtual uint ideal_reg() const { return Op_RegP; } 302 // No longer remove CheckCast after CCP as it gives me a place to hang 303 // the proper address type - which is required to compute anti-deps. 304 //virtual Node *Ideal_DU_postCCP( PhaseCCP * ); 305 }; 306 307 308 //------------------------------EncodeNarrowPtr-------------------------------- 309 class EncodeNarrowPtrNode : public TypeNode { 310 protected: 311 EncodeNarrowPtrNode(Node* value, const Type* type): 312 TypeNode(type, 2) { 313 init_class_id(Class_EncodeNarrowPtr); 314 init_req(0, NULL); 315 init_req(1, value); 316 } 317 public: 318 virtual uint ideal_reg() const { return Op_RegN; } 319 virtual Node *Ideal_DU_postCCP( PhaseCCP *ccp ); 320 }; 321 322 //------------------------------EncodeP-------------------------------- 323 // Encodes an oop pointers into its compressed form 324 // Takes an extra argument which is the real heap base as a long which 325 // may be useful for code generation in the backend. 326 class EncodePNode : public EncodeNarrowPtrNode { 327 public: 328 EncodePNode(Node* value, const Type* type): 329 EncodeNarrowPtrNode(value, type) { 330 init_class_id(Class_EncodeP); 331 } 332 virtual int Opcode() const; 333 virtual Node *Identity( PhaseTransform *phase ); 334 virtual const Type *Value( PhaseTransform *phase ) const; 335 }; 336 337 //------------------------------EncodePKlass-------------------------------- 338 // Encodes a klass pointer into its compressed form 339 // Takes an extra argument which is the real heap base as a long which | 264 const bool has_range_check() { 265 #ifdef _LP64 266 return _range_check_dependency; 267 #else 268 assert(!_range_check_dependency, "Should not have range check dependency"); 269 return false; 270 #endif 271 } 272 #ifndef PRODUCT 273 virtual void dump_spec(outputStream *st) const; 274 #endif 275 }; 276 277 //------------------------------CastPPNode------------------------------------- 278 // cast pointer to pointer (different type) 279 class CastPPNode: public ConstraintCastNode { 280 public: 281 CastPPNode (Node *n, const Type *t ): ConstraintCastNode(n, t) {} 282 virtual int Opcode() const; 283 virtual uint ideal_reg() const { return Op_RegP; } 284 }; 285 286 //------------------------------CheckCastPPNode-------------------------------- 287 // for _checkcast, cast pointer to pointer (different type), without JOIN, 288 class CheckCastPPNode: public TypeNode { 289 public: 290 CheckCastPPNode( Node *c, Node *n, const Type *t ) : TypeNode(t,2) { 291 init_class_id(Class_CheckCastPP); 292 init_req(0, c); 293 init_req(1, n); 294 } 295 296 virtual Node *Identity( PhaseTransform *phase ); 297 virtual const Type *Value( PhaseTransform *phase ) const; 298 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 299 virtual int Opcode() const; 300 virtual uint ideal_reg() const { return Op_RegP; } 301 }; 302 303 304 //------------------------------EncodeNarrowPtr-------------------------------- 305 class EncodeNarrowPtrNode : public TypeNode { 306 protected: 307 EncodeNarrowPtrNode(Node* value, const Type* type): 308 TypeNode(type, 2) { 309 init_class_id(Class_EncodeNarrowPtr); 310 init_req(0, NULL); 311 init_req(1, value); 312 } 313 public: 314 virtual uint ideal_reg() const { return Op_RegN; } 315 }; 316 317 //------------------------------EncodeP-------------------------------- 318 // Encodes an oop pointers into its compressed form 319 // Takes an extra argument which is the real heap base as a long which 320 // may be useful for code generation in the backend. 321 class EncodePNode : public EncodeNarrowPtrNode { 322 public: 323 EncodePNode(Node* value, const Type* type): 324 EncodeNarrowPtrNode(value, type) { 325 init_class_id(Class_EncodeP); 326 } 327 virtual int Opcode() const; 328 virtual Node *Identity( PhaseTransform *phase ); 329 virtual const Type *Value( PhaseTransform *phase ) const; 330 }; 331 332 //------------------------------EncodePKlass-------------------------------- 333 // Encodes a klass pointer into its compressed form 334 // Takes an extra argument which is the real heap base as a long which |