< prev index next >

src/share/vm/opto/connode.hpp

Print this page




 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


< prev index next >