jdk8-mips64-public/hotspot: comparison src/share/vm/opto/type.hpp

-:65d07d9ee446
+:8e47bac5643a
 class Type;
 class   TypeD;
 class   TypeF;
 class   TypeInt;
 class   TypeLong;
-class   TypeNarrowOop;
+class   TypeNarrowPtr;
+class     TypeNarrowOop;
+class     TypeNarrowKlass;
 class   TypeAry;
 class   TypeTuple;
 class   TypeVect;
 class     TypeVectS;
 class     TypeVectD;
 Top,                        // Top of the lattice
 Int,                        // Integer range (lo-hi)
 Long,                       // Long integer range (lo-hi)
 Half,                       // Placeholder half of doubleword
 NarrowOop,                  // Compressed oop pointer
+NarrowKlass,                // Compressed klass pointer
 Tuple,                      // Method signature or object layout
 Array,                      // Array types
 VectorS,                    //  32bit Vector types
 VectorD,                    //  64bit Vector types
 #endif
 // 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;
 // Convenience access
 float getf() const;
 double getd() const;
 const TypePtr    *isa_ptr() const;             // Returns NULL if not ptr type
 const TypeRawPtr *isa_rawptr() const;          // NOT Java oop
 const TypeRawPtr *is_rawptr() const;           // Asserts is rawptr
 const TypeNarrowOop  *is_narrowoop() const;    // Java-style GC'd pointer
 const TypeNarrowOop  *isa_narrowoop() const;   // Returns NULL if not oop ptr type
+const TypeNarrowKlass *is_narrowklass() const; // compressed klass pointer
+const TypeNarrowKlass *isa_narrowklass() const;// Returns NULL if not oop ptr type
 const TypeOopPtr   *isa_oopptr() const;        // Returns NULL if not oop ptr type
 const TypeOopPtr   *is_oopptr() const;         // Java-style GC'd pointer
 const TypeInstPtr  *isa_instptr() const;       // Returns NULL if not InstPtr
 const TypeInstPtr  *is_instptr() const;        // Instance
 const TypeAryPtr   *isa_aryptr() const;        // Returns NULL if not AryPtr
 const TypeOopPtr* make_oopptr() const;
 // Returns this compressed pointer or the equivalent compressed version
 // of this pointer type.
 const TypeNarrowOop* make_narrowoop() const;
+// Returns this compressed klass pointer or the equivalent
+// compressed version of this pointer type.
+const TypeNarrowKlass* make_narrowklass() const;
 // Special test for register pressure heuristic
 bool is_floatingpoint() const;        // True if Float or Double base type
 // Do you have memory, directly or through a tuple?
 // Class of machine Pointer Types: raw data, instances or arrays.
 // If the _base enum is AnyPtr, then this refers to all of the above.
 // Otherwise the _base will indicate which subset of pointers is affected,
 // and the class will be inherited from.
 class TypePtr : public Type {
-friend class TypeNarrowOop;
+friend class TypeNarrowPtr;
 public:
 enum PTR { TopPTR, AnyNull, Constant, Null, NotNull, BotPTR, lastPTR };
 protected:
 TypePtr( TYPES t, PTR ptr, int offset ) : Type(t), _ptr(ptr), _offset(offset) {}
 virtual bool eq( const Type *t ) const;
 // If _klass is NULL, then so is _sig.  This is an unloaded klass.
 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;
 // 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;
 bool klass_is_exact()    const { return _klass_is_exact; }
 // 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; }
 #ifndef PRODUCT
 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping
 #endif
 };
+class TypeNarrowPtr : public Type {
+protected:
+const TypePtr* _ptrtype; // Could be TypePtr::NULL_PTR
+TypeNarrowPtr(TYPES t, const TypePtr* ptrtype): _ptrtype(ptrtype),
+Type(t) {
+assert(ptrtype->offset() == 0 ||
+ptrtype->offset() == OffsetBot ||
+ptrtype->offset() == OffsetTop, "no real offsets");
+}
+virtual const TypeNarrowPtr *isa_same_narrowptr(const Type *t) const = 0;
+virtual const TypeNarrowPtr *is_same_narrowptr(const Type *t) const = 0;
+virtual const TypeNarrowPtr *make_same_narrowptr(const TypePtr *t) const = 0;
+virtual const TypeNarrowPtr *make_hash_same_narrowptr(const TypePtr *t) const = 0;
+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 const Type *xmeet( const Type *t ) const;
+virtual const Type *xdual() const;    // Compute dual right now.
+virtual intptr_t get_con() const;
+// Do not allow interface-vs.-noninterface joins to collapse to top.
+virtual const Type *filter( const Type *kills ) const;
+virtual bool empty(void) const;        // TRUE if type is vacuous
+// returns the equivalent ptr type for this compressed pointer
+const TypePtr *get_ptrtype() const {
+return _ptrtype;
+}
+#ifndef PRODUCT
+virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
+#endif
+};
 //------------------------------TypeNarrowOop----------------------------------
 // A compressed reference to some kind of Oop.  This type wraps around
 // a preexisting TypeOopPtr and forwards most of it's operations to
 // the underlying type.  It's only real purpose is to track the
 // oopness of the compressed oop value when we expose the conversion
 // between the normal and the compressed form.
-class TypeNarrowOop : public Type {
+class TypeNarrowOop : public TypeNarrowPtr {
 protected:
-const TypePtr* _ptrtype; // Could be TypePtr::NULL_PTR
+TypeNarrowOop( const TypePtr* ptrtype): TypeNarrowPtr(NarrowOop, ptrtype) {
+}
-TypeNarrowOop( const TypePtr* ptrtype): Type(NarrowOop),
-_ptrtype(ptrtype) {
+virtual const TypeNarrowPtr *isa_same_narrowptr(const Type *t) const {
-assert(ptrtype->offset() == 0 ||
+return t->isa_narrowoop();
-ptrtype->offset() == OffsetBot ||
+}
-ptrtype->offset() == OffsetTop, "no real offsets");
-}
+virtual const TypeNarrowPtr *is_same_narrowptr(const Type *t) const {
-public:
+return t->is_narrowoop();
-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 const TypeNarrowPtr *make_same_narrowptr(const TypePtr *t) const {
+return new TypeNarrowOop(t);
-virtual const Type *xmeet( const Type *t ) const;
+}
-virtual const Type *xdual() const;    // Compute dual right now.
+virtual const TypeNarrowPtr *make_hash_same_narrowptr(const TypePtr *t) const {
-virtual intptr_t get_con() const;
+return (const TypeNarrowPtr*)((new TypeNarrowOop(t))->hashcons());
+}
-// Do not allow interface-vs.-noninterface joins to collapse to top.
-virtual const Type *filter( const Type *kills ) const;
+public:
-virtual bool empty(void) const;        // TRUE if type is vacuous
 static const TypeNarrowOop *make( const TypePtr* type);
 static const TypeNarrowOop* make_from_constant(ciObject* con, bool require_constant = false) {
 return make(TypeOopPtr::make_from_constant(con, require_constant));
 }
-// returns the equivalent ptr type for this compressed pointer
-const TypePtr *get_ptrtype() const {
-return _ptrtype;
-}
 static const TypeNarrowOop *BOTTOM;
 static const TypeNarrowOop *NULL_PTR;
+#ifndef PRODUCT
+virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
+#endif
+};
+//------------------------------TypeNarrowKlass----------------------------------
+// A compressed reference to klass pointer.  This type wraps around a
+// preexisting TypeKlassPtr and forwards most of it's operations to
+// the underlying type.
+class TypeNarrowKlass : public TypeNarrowPtr {
+protected:
+TypeNarrowKlass( const TypePtr* ptrtype): TypeNarrowPtr(NarrowKlass, ptrtype) {
+}
+virtual const TypeNarrowPtr *isa_same_narrowptr(const Type *t) const {
+return t->isa_narrowklass();
+}
+virtual const TypeNarrowPtr *is_same_narrowptr(const Type *t) const {
+return t->is_narrowklass();
+}
+virtual const TypeNarrowPtr *make_same_narrowptr(const TypePtr *t) const {
+return new TypeNarrowKlass(t);
+}
+virtual const TypeNarrowPtr *make_hash_same_narrowptr(const TypePtr *t) const {
+return (const TypeNarrowPtr*)((new TypeNarrowKlass(t))->hashcons());
+}
+public:
+static const TypeNarrowKlass *make( const TypePtr* type);
+// static const TypeNarrowKlass *BOTTOM;
+static const TypeNarrowKlass *NULL_PTR;
 #ifndef PRODUCT
 virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
 #endif
 };
 #else
 return false;
 #endif
 }
+inline bool Type::is_ptr_to_narrowklass() const {
+#ifdef _LP64
+return (isa_oopptr() != NULL && is_oopptr()->is_ptr_to_narrowklass_nv());
+#else
+return false;
+#endif
+}
 inline float Type::getf() const {
 assert( _base == FloatCon, "Not a FloatCon" );
 return ((TypeF*)this)->_f;
 }
 inline const TypeNarrowOop *Type::isa_narrowoop() const {
 // OopPtr is the first and KlassPtr the last, with no non-oops between.
 return (_base == NarrowOop) ? (TypeNarrowOop*)this : NULL;
 }
+inline const TypeNarrowKlass *Type::is_narrowklass() const {
+assert(_base == NarrowKlass, "Not a narrow oop" ) ;
+return (TypeNarrowKlass*)this;
+}
+inline const TypeNarrowKlass *Type::isa_narrowklass() const {
+return (_base == NarrowKlass) ? (TypeNarrowKlass*)this : NULL;
+}
 inline const TypeMetadataPtr *Type::is_metadataptr() const {
 // MetadataPtr is the first and CPCachePtr the last
 assert(_base == MetadataPtr, "Not a metadata pointer" ) ;
 return (TypeMetadataPtr*)this;
 }
 return (TypeKlassPtr*)this;
 }
 inline const TypePtr* Type::make_ptr() const {
 return (_base == NarrowOop) ? is_narrowoop()->get_ptrtype() :
-(isa_ptr() ? is_ptr() : NULL);
+((_base == NarrowKlass) ? is_narrowklass()->get_ptrtype() :
+(isa_ptr() ? is_ptr() : NULL));
 }
 inline const TypeOopPtr* Type::make_oopptr() const {
 return (_base == NarrowOop) ? is_narrowoop()->get_ptrtype()->is_oopptr() : is_oopptr();
 }
 inline const TypeNarrowOop* Type::make_narrowoop() const {
 return (_base == NarrowOop) ? is_narrowoop() :
 (isa_ptr() ? TypeNarrowOop::make(is_ptr()) : NULL);
+}
+inline const TypeNarrowKlass* Type::make_narrowklass() const {
+return (_base == NarrowKlass) ? is_narrowklass() :
+(isa_ptr() ? TypeNarrowKlass::make(is_ptr()) : NULL);
 }
 inline bool Type::is_floatingpoint() const {
 if( (_base == FloatCon)  || (_base == FloatBot) ||
 (_base == DoubleCon) || (_base == DoubleBot) )

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/opto/type.hpp

src/share/vm/opto/type.hpp