src/share/vm/opto/type.hpp

*** 232,241 ****
--- 232,244 ----
    // Returns true if this pointer points at memory which contains a
    // compressed oop references.
    bool is_ptr_to_narrowoop() const;
    bool is_ptr_to_narrowklass() const;
  
+   bool is_ptr_to_boxing_obj() const;
+ 
+ 
    // Convenience access
    float getf() const;
    double getd() const;
  
    const TypeInt    *is_int() const;
*** 792,801 ****
--- 795,805 ----
    ciKlass*      _klass;       // Klass object
    // Does the type exclude subclasses of the klass?  (Inexact == polymorphic.)
    bool          _klass_is_exact;
    bool          _is_ptr_to_narrowoop;
    bool          _is_ptr_to_narrowklass;
+   bool          _is_ptr_to_boxed_value;
  
    // If not InstanceTop or InstanceBot, indicates that this is
    // a particular instance of this type which is distinct.
    // This is the the node index of the allocation node creating this instance.
    int           _instance_id;
*** 824,834 ****
    }
    // Creates a singleton type given an object.
    // If the object cannot be rendered as a constant,
    // may return a non-singleton type.
    // If require_constant, produce a NULL if a singleton is not possible.
!   static const TypeOopPtr* make_from_constant(ciObject* o, bool require_constant = false);
  
    // Make a generic (unclassed) pointer to an oop.
    static const TypeOopPtr* make(PTR ptr, int offset, int instance_id);
  
    ciObject* const_oop()    const { return _const_oop; }
--- 828,840 ----
    }
    // Creates a singleton type given an object.
    // If the object cannot be rendered as a constant,
    // may return a non-singleton type.
    // If require_constant, produce a NULL if a singleton is not possible.
!   static const TypeOopPtr* make_from_constant(ciObject* o,
!                                               bool require_constant = false,
!                                               bool not_null_elements = false);
  
    // Make a generic (unclassed) pointer to an oop.
    static const TypeOopPtr* make(PTR ptr, int offset, int instance_id);
  
    ciObject* const_oop()    const { return _const_oop; }
*** 837,847 ****
  
    // Returns true if this pointer points at memory which contains a
    // compressed oop references.
    bool is_ptr_to_narrowoop_nv() const { return _is_ptr_to_narrowoop; }
    bool is_ptr_to_narrowklass_nv() const { return _is_ptr_to_narrowklass; }
! 
    bool is_known_instance()       const { return _instance_id > 0; }
    int  instance_id()             const { return _instance_id; }
    bool is_known_instance_field() const { return is_known_instance() && _offset >= 0; }
  
    virtual intptr_t get_con() const;
--- 843,853 ----
  
    // Returns true if this pointer points at memory which contains a
    // compressed oop references.
    bool is_ptr_to_narrowoop_nv() const { return _is_ptr_to_narrowoop; }
    bool is_ptr_to_narrowklass_nv() const { return _is_ptr_to_narrowklass; }
!   bool is_ptr_to_boxed_value()   const { return _is_ptr_to_boxed_value; }
    bool is_known_instance()       const { return _instance_id > 0; }
    int  instance_id()             const { return _instance_id; }
    bool is_known_instance_field() const { return is_known_instance() && _offset >= 0; }
  
    virtual intptr_t get_con() const;
*** 941,951 ****
  };
  
  //------------------------------TypeAryPtr-------------------------------------
  // Class of Java array pointers
  class TypeAryPtr : public TypeOopPtr {
!   TypeAryPtr( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id ) : TypeOopPtr(AryPtr,ptr,k,xk,o,offset, instance_id), _ary(ary) {
  #ifdef ASSERT
      if (k != NULL) {
        // Verify that specified klass and TypeAryPtr::klass() follow the same rules.
        ciKlass* ck = compute_klass(true);
        if (k != ck) {
--- 947,962 ----
  };
  
  //------------------------------TypeAryPtr-------------------------------------
  // Class of Java array pointers
  class TypeAryPtr : public TypeOopPtr {
!   TypeAryPtr( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk,
!               int offset, int instance_id, bool is_autobox_cache )
!   : TypeOopPtr(AryPtr,ptr,k,xk,o,offset, instance_id),
!     _ary(ary),
!     _is_autobox_cache(is_autobox_cache)
!  {
  #ifdef ASSERT
      if (k != NULL) {
        // Verify that specified klass and TypeAryPtr::klass() follow the same rules.
        ciKlass* ck = compute_klass(true);
        if (k != ck) {
*** 962,984 ****
  #endif
    }
    virtual bool eq( const Type *t ) const;
    virtual int hash() const;     // Type specific hashing
    const TypeAry *_ary;          // Array we point into
  
    ciKlass* compute_klass(DEBUG_ONLY(bool verify = false)) const;
  
  public:
    // Accessors
    ciKlass* klass() const;
    const TypeAry* ary() const  { return _ary; }
    const Type*    elem() const { return _ary->_elem; }
    const TypeInt* size() const { return _ary->_size; }
  
    static const TypeAryPtr *make( PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot);
    // Constant pointer to array
!   static const TypeAryPtr *make( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot);
  
    // Return a 'ptr' version of this type
    virtual const Type *cast_to_ptr_type(PTR ptr) const;
  
    virtual const Type *cast_to_exactness(bool klass_is_exact) const;
--- 973,998 ----
  #endif
    }
    virtual bool eq( const Type *t ) const;
    virtual int hash() const;     // Type specific hashing
    const TypeAry *_ary;          // Array we point into
+   const bool     _is_autobox_cache;
  
    ciKlass* compute_klass(DEBUG_ONLY(bool verify = false)) const;
  
  public:
    // Accessors
    ciKlass* klass() const;
    const TypeAry* ary() const  { return _ary; }
    const Type*    elem() const { return _ary->_elem; }
    const TypeInt* size() const { return _ary->_size; }
  
+   bool is_autobox_cache() const { return _is_autobox_cache; }
+ 
    static const TypeAryPtr *make( PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot);
    // Constant pointer to array
!   static const TypeAryPtr *make( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot, bool is_autobox_cache = false);
  
    // Return a 'ptr' version of this type
    virtual const Type *cast_to_ptr_type(PTR ptr) const;
  
    virtual const Type *cast_to_exactness(bool klass_is_exact) const;
*** 1502,1511 ****
--- 1516,1532 ----
        (_base == DoubleCon) || (_base == DoubleBot) )
      return true;
    return false;
  }
  
+ inline bool Type::is_ptr_to_boxing_obj() const {
+   const TypeInstPtr* tp = isa_instptr();
+   return (tp != NULL) && (tp->offset() == 0) &&
+          tp->klass()->is_instance_klass()  &&
+          tp->klass()->as_instance_klass()->is_box_klass();
+ }
+ 
  
  // ===============================================================
  // Things that need to be 64-bits in the 64-bit build but
  // 32-bits in the 32-bit build.  Done this way to get full
  // optimization AND strong typing.