hotspot/src/share/vm/opto/type.hpp

rev 5143 : imported patch webrev.01

*** 370,379 ****
--- 370,383 ----
    relocInfo::relocType reloc() const { return _type_info[_base].reloc; }
  
    // Mapping from CI type system to compiler type:
    static const Type* get_typeflow_type(ciType* type);
  
+   static const Type* make_from_constant(ciConstant constant,
+                                         bool require_constant = false,
+                                         bool is_autobox_cache = false);
+ 
  private:
    // support arrays
    static const BasicType _basic_type[];
    static const Type*        _zero_type[T_CONFLICT+1];
    static const Type* _const_basic_type[T_CONFLICT+1];
*** 586,610 ****
  };
  
  //------------------------------TypeAry----------------------------------------
  // Class of Array Types
  class TypeAry : public Type {
!   TypeAry( const Type *elem, const TypeInt *size) : Type(Array),
!     _elem(elem), _size(size) {}
  public:
    virtual bool eq( const Type *t ) const;
    virtual int  hash() const;             // Type specific hashing
    virtual bool singleton(void) const;    // TRUE if type is a singleton
    virtual bool empty(void) const;        // TRUE if type is vacuous
  
  private:
    const Type *_elem;            // Element type of array
    const TypeInt *_size;         // Elements in array
    friend class TypeAryPtr;
  
  public:
!   static const TypeAry *make(  const Type *elem, const TypeInt *size);
  
    virtual const Type *xmeet( const Type *t ) const;
    virtual const Type *xdual() const;    // Compute dual right now.
    bool ary_must_be_exact() const;  // true if arrays of such are never generic
  #ifdef ASSERT
--- 590,615 ----
  };
  
  //------------------------------TypeAry----------------------------------------
  // Class of Array Types
  class TypeAry : public Type {
!   TypeAry(const Type* elem, const TypeInt* size, bool stable) : Type(Array),
!       _elem(elem), _size(size), _stable(stable) {}
  public:
    virtual bool eq( const Type *t ) const;
    virtual int  hash() const;             // Type specific hashing
    virtual bool singleton(void) const;    // TRUE if type is a singleton
    virtual bool empty(void) const;        // TRUE if type is vacuous
  
  private:
    const Type *_elem;            // Element type of array
    const TypeInt *_size;         // Elements in array
+   const bool _stable;           // Are elements @Stable?
    friend class TypeAryPtr;
  
  public:
!   static const TypeAry* make(const Type* elem, const TypeInt* size, bool stable = false);
  
    virtual const Type *xmeet( const Type *t ) const;
    virtual const Type *xdual() const;    // Compute dual right now.
    bool ary_must_be_exact() const;  // true if arrays of such are never generic
  #ifdef ASSERT
*** 986,995 ****
--- 991,1001 ----
    // 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_stable() const { return _ary->_stable; }
  
    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
*** 1009,1018 ****
--- 1015,1027 ----
    virtual const TypePtr *add_offset( intptr_t offset ) const;
  
    virtual const Type *xmeet( const Type *t ) const;
    virtual const Type *xdual() const;    // Compute dual right now.
  
+   const TypeAryPtr* cast_to_stable(bool stable, int stable_dimension = 1) const;
+   int stable_dimension() const;
+ 
    // Convenience common pre-built types.
    static const TypeAryPtr *RANGE;
    static const TypeAryPtr *OOPS;
    static const TypeAryPtr *NARROWOOPS;
    static const TypeAryPtr *BYTES;