graal-compiler: src/share/vm/opto/type.hpp comparison

comparison src/share/vm/opto/type.hpp @ 14457:45467c53f178

Merge

author	kvn
date	Tue, 28 Jan 2014 12:28:17 -0800
parents	15120a36272d 5ec7dace41a6
children	cd5d10655495 62c54fcc0a35

comparison

equal deleted inserted replaced

-:abec000618bf
+:45467c53f178
 #ifdef ASSERT
 // One type is interface, the other is oop
 virtual bool interface_vs_oop_helper(const Type *t) const;
 #endif
+const Type *meet_helper(const Type *t, bool include_speculative) const;
 protected:
 // Each class of type is also identified by its base.
 const TYPES _base;            // Enum of Types type
 Type( TYPES t ) : _dual(NULL),  _base(t) {} // Simple types
 // ~Type();                   // Use fast deallocation
 const Type *hashcons();       // Hash-cons the type
+virtual const Type *filter_helper(const Type *kills, bool include_speculative) const;
+const Type *join_helper(const Type *t, bool include_speculative) const {
+return dual()->meet_helper(t->dual(), include_speculative)->dual();
+}
 public:
 inline void* operator new( size_t x ) throw() {
 Compile* compile = Compile::current();
 // Create a new hash-consd type
 static const Type *make(enum TYPES);
 // Test for equivalence of types
 static int cmp( const Type *const t1, const Type *const t2 );
 // Test for higher or equal in lattice
-int higher_equal( const Type *t ) const { return !cmp(meet(t),t); }
+// Variant that drops the speculative part of the types
+int higher_equal(const Type *t) const {
+return !cmp(meet(t),t->remove_speculative());
+}
+// Variant that keeps the speculative part of the types
+int higher_equal_speculative(const Type *t) const {
+return !cmp(meet_speculative(t),t);
+}
 // MEET operation; lower in lattice.
-const Type *meet( const Type *t ) const;
+// Variant that drops the speculative part of the types
+const Type *meet(const Type *t) const {
+return meet_helper(t, false);
+}
+// Variant that keeps the speculative part of the types
+const Type *meet_speculative(const Type *t) const {
+return meet_helper(t, true);
+}
 // WIDEN: 'widens' for Ints and other range types
 virtual const Type *widen( const Type *old, const Type* limit ) const { return this; }
 // NARROW: complement for widen, used by pessimistic phases
 virtual const Type *narrow( const Type *old ) const { return this; }
 virtual const Type *xmeet( const Type *t ) const;
 virtual const Type *xdual() const;    // Compute dual right now.
 // JOIN operation; higher in lattice.  Done by finding the dual of the
 // meet of the dual of the 2 inputs.
-const Type *join( const Type *t ) const {
+// Variant that drops the speculative part of the types
-return dual()->meet(t->dual())->dual(); }
+const Type *join(const Type *t) const {
+return join_helper(t, false);
+}
+// Variant that keeps the speculative part of the types
+const Type *join_speculative(const Type *t) const {
+return join_helper(t, true);
+}
 // Modified version of JOIN adapted to the needs Node::Value.
 // Normalizes all empty values to TOP.  Does not kill _widen bits.
 // Currently, it also works around limitations involving interface types.
-virtual const Type *filter( const Type *kills ) const;
+// Variant that drops the speculative part of the types
+const Type *filter(const Type *kills) const {
+return filter_helper(kills, false);
+}
+// Variant that keeps the speculative part of the types
+const Type *filter_speculative(const Type *kills) const {
+return filter_helper(kills, true);
+}
 #ifdef ASSERT
 // One type is interface, the other is oop
 virtual bool interface_vs_oop(const Type *t) const;
 #endif
 bool require_constant = false,
 bool is_autobox_cache = false);
 // Speculative type. See TypeInstPtr
 virtual ciKlass* speculative_type() const { return NULL; }
+const Type* maybe_remove_speculative(bool include_speculative) const;
+virtual const Type* remove_speculative() const { return this; }
 private:
 // support arrays
 static const BasicType _basic_type[];
 static const Type*        _zero_type[T_CONFLICT+1];
 //------------------------------TypeInt----------------------------------------
 // Class of integer ranges, the set of integers between a lower bound and an
 // upper bound, inclusive.
 class TypeInt : public Type {
 TypeInt( jint lo, jint hi, int w );
+protected:
+virtual const Type *filter_helper(const Type *kills, bool include_speculative) const;
 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
-public:
 const jint _lo, _hi;          // Lower bound, upper bound
 const short _widen;           // Limit on times we widen this sucker
 static const TypeInt *make(jint lo);
 // must always specify w
 virtual const Type *xmeet( const Type *t ) const;
 virtual const Type *xdual() const;    // Compute dual right now.
 virtual const Type *widen( const Type *t, const Type* limit_type ) const;
 virtual const Type *narrow( const Type *t ) const;
 // Do not kill _widen bits.
-virtual const Type *filter( const Type *kills ) const;
 // Convenience common pre-built types.
 static const TypeInt *MINUS_1;
 static const TypeInt *ZERO;
 static const TypeInt *ONE;
 static const TypeInt *BOOL;
 //------------------------------TypeLong---------------------------------------
 // Class of long integer ranges, the set of integers between a lower bound and
 // an upper bound, inclusive.
 class TypeLong : public Type {
 TypeLong( jlong lo, jlong hi, int w );
+protected:
+// Do not kill _widen bits.
+virtual const Type *filter_helper(const Type *kills, bool include_speculative) const;
 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
 virtual const Type *xmeet( const Type *t ) const;
 virtual const Type *xdual() const;    // Compute dual right now.
 virtual const Type *widen( const Type *t, const Type* limit_type ) const;
 virtual const Type *narrow( const Type *t ) const;
-// Do not kill _widen bits.
-virtual const Type *filter( const Type *kills ) const;
 // Convenience common pre-built types.
 static const TypeLong *MINUS_1;
 static const TypeLong *ZERO;
 static const TypeLong *ONE;
 static const TypeLong *POS;
 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
+virtual const Type* remove_speculative() const;
 #ifdef ASSERT
 // One type is interface, the other is oop
 virtual bool interface_vs_oop(const Type *t) const;
 #endif
 #ifndef PRODUCT
 int dual_instance_id() const;
 int meet_instance_id(int uid) const;
 // utility methods to work on the speculative part of the type
 const TypeOopPtr* dual_speculative() const;
-const TypeOopPtr* meet_speculative(const TypeOopPtr* other) const;
+const TypeOopPtr* xmeet_speculative(const TypeOopPtr* other) const;
 bool eq_speculative(const TypeOopPtr* other) const;
 int hash_speculative() const;
 const TypeOopPtr* add_offset_speculative(intptr_t offset) const;
 #ifndef PRODUCT
 void dump_speculative(outputStream *st) const;
 #endif
+// Do not allow interface-vs.-noninterface joins to collapse to top.
+virtual const Type *filter_helper(const Type *kills, bool include_speculative) const;
 public:
 // Creates a type given a klass. Correctly handles multi-dimensional arrays
 // Respects UseUniqueSubclasses.
 // If the klass is final, the resulting type will be exact.
 // corresponding pointer to klass, for a given instance
 const TypeKlassPtr* as_klass_type() const;
 virtual const TypePtr *add_offset( intptr_t offset ) const;
 // Return same type without a speculative part
-virtual const TypeOopPtr* remove_speculative() const;
+virtual const Type* remove_speculative() const;
 virtual const Type *xmeet(const Type *t) const;
 virtual const Type *xdual() const;    // Compute dual right now.
 // the core of the computation of the meet for TypeOopPtr and for its subclasses
 virtual const Type *xmeet_helper(const Type *t) const;
-// Do not allow interface-vs.-noninterface joins to collapse to top.
-virtual const Type *filter( const Type *kills ) const;
 // Convenience common pre-built type.
 static const TypeOopPtr *BOTTOM;
 #ifndef PRODUCT
 virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
 virtual const TypeOopPtr *cast_to_instance_id(int instance_id) const;
 virtual const TypePtr *add_offset( intptr_t offset ) const;
 // Return same type without a speculative part
-virtual const TypeOopPtr* remove_speculative() const;
+virtual const Type* remove_speculative() const;
 // the core of the computation of the meet of 2 types
 virtual const Type *xmeet_helper(const Type *t) const;
 virtual const TypeInstPtr *xmeet_unloaded( const TypeInstPtr *t ) const;
 virtual const Type *xdual() const;    // Compute dual right now.
 virtual const TypeInt* narrow_size_type(const TypeInt* size) const;
 virtual bool empty(void) const;        // TRUE if type is vacuous
 virtual const TypePtr *add_offset( intptr_t offset ) const;
 // Return same type without a speculative part
-virtual const TypeOopPtr* remove_speculative() const;
+virtual const Type* remove_speculative() const;
 // the core of the computation of the meet of 2 types
 virtual const Type *xmeet_helper(const Type *t) const;
 virtual const Type *xdual() const;    // Compute dual right now.
 //------------------------------TypeMetadataPtr-------------------------------------
 // Some kind of metadata, either Method*, MethodData* or CPCacheOop
 class TypeMetadataPtr : public TypePtr {
 protected:
 TypeMetadataPtr(PTR ptr, ciMetadata* metadata, int offset);
+// Do not allow interface-vs.-noninterface joins to collapse to top.
+virtual const Type *filter_helper(const Type *kills, bool include_speculative) const;
 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;
 // Convenience common pre-built types.
 static const TypeMetadataPtr *BOTTOM;
 #ifndef PRODUCT
 //------------------------------TypeKlassPtr-----------------------------------
 // Class of Java Klass pointers
 class TypeKlassPtr : public TypePtr {
 TypeKlassPtr( PTR ptr, ciKlass* klass, int offset );
+protected:
+virtual const Type *filter_helper(const Type *kills, bool include_speculative) const;
 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
 private:
 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;
 // Convenience common pre-built types.
 static const TypeKlassPtr* OBJECT; // Not-null object klass or below
 static const TypeKlassPtr* OBJECT_OR_NULL; // Maybe-null version of same
 #ifndef PRODUCT
 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping
 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;
+// Do not allow interface-vs.-noninterface joins to collapse to top.
+virtual const Type *filter_helper(const Type *kills, bool include_speculative) const;
 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 make(TypeOopPtr::make_from_constant(con, require_constant));
 }
 static const TypeNarrowOop *BOTTOM;
 static const TypeNarrowOop *NULL_PTR;
+virtual const Type* remove_speculative() const {
+return make(_ptrtype->remove_speculative()->is_ptr());
+}
 #ifndef PRODUCT
 virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
 #endif
 };

Mercurial > hg > graal-compiler

comparison src/share/vm/opto/type.hpp @ 14457:45467c53f178