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
|