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

comparison src/share/vm/opto/type.hpp @ 17810:62c54fcc0a35

Merge

author	kvn
date	Tue, 25 Mar 2014 17:07:36 -0700
parents	752ba2e5f6d0 9ab9f254cfe2
children	52b4284cb496

comparison

equal deleted inserted replaced

-:a433eb716ce1
+:62c54fcc0a35
 static const Type* make_from_constant(ciConstant constant,
 bool require_constant = false,
 bool is_autobox_cache = false);
 // Speculative type. See TypeInstPtr
+virtual const TypeOopPtr* speculative() const { return NULL; }
 virtual ciKlass* speculative_type() const { return NULL; }
 const Type* maybe_remove_speculative(bool include_speculative) const;
 virtual const Type* remove_speculative() const { return this; }
+virtual bool would_improve_type(ciKlass* exact_kls, int inline_depth) const {
+return exact_kls != NULL;
+}
 private:
 // support arrays
 static const BasicType _basic_type[];
 static const Type*        _zero_type[T_CONFLICT+1];
 TypeInt( jint lo, jint hi, int w );
 protected:
 virtual const Type *filter_helper(const Type *kills, bool include_speculative) const;
 public:
+typedef jint NativeType;
 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
 const jint _lo, _hi;          // Lower bound, upper bound
 static const TypeInt *SHORT;
 static const TypeInt *POS;
 static const TypeInt *POS1;
 static const TypeInt *INT;
 static const TypeInt *SYMINT; // symmetric range [-max_jint..max_jint]
+static const TypeInt *TYPE_DOMAIN; // alias for TypeInt::INT
+static const TypeInt *as_self(const Type *t) { return t->is_int(); }
 #ifndef PRODUCT
 virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
 #endif
 };
 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:
+typedef jlong NativeType;
 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:
 // Check for positive 32-bit value.
 int is_positive_int() const { return _lo >= 0 && _hi <= (jlong)max_jint; }
 virtual bool        is_finite() const;  // Has a finite value
 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;
 static const TypeLong *ONE;
 static const TypeLong *POS;
 static const TypeLong *LONG;
 static const TypeLong *INT;    // 32-bit subrange [min_jint..max_jint]
 static const TypeLong *UINT;   // 32-bit unsigned [0..max_juint]
+static const TypeLong *TYPE_DOMAIN; // alias for TypeLong::LONG
+// static convenience methods.
+static const TypeLong *as_self(const Type *t) { return t->is_long(); }
 #ifndef PRODUCT
 virtual void dump2( Dict &d, uint, outputStream *st  ) const;// Specialized per-Type dumping
 #endif
 };
 //------------------------------TypeOopPtr-------------------------------------
 // Some kind of oop (Java pointer), either klass or instance or array.
 class TypeOopPtr : public TypePtr {
 protected:
-TypeOopPtr(TYPES t, PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id, const TypeOopPtr* speculative);
+TypeOopPtr(TYPES t, PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id, const TypeOopPtr* speculative, int inline_depth);
 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
 enum {
 InstanceTop = -1,   // undefined instance
 InstanceBot = 0     // any possible instance
 };
 protected:
+enum {
+InlineDepthBottom = INT_MAX,
+InlineDepthTop = -InlineDepthBottom
+};
 // Oop is NULL, unless this is a constant oop.
 ciObject*     _const_oop;   // Constant oop
 // 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.)
 // Extra type information profiling gave us. We propagate it the
 // same way the rest of the type info is propagated. If we want to
 // use it, then we have to emit a guard: this part of the type is
 // not something we know but something we speculate about the type.
 const TypeOopPtr*   _speculative;
+// For speculative types, we record at what inlining depth the
+// profiling point that provided the data is. We want to favor
+// profile data coming from outer scopes which are likely better for
+// the current compilation.
+int _inline_depth;
 static const TypeOopPtr* make_from_klass_common(ciKlass* klass, bool klass_change, bool try_for_exact);
 int dual_instance_id() const;
 int meet_instance_id(int uid) 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
+// utility methods to work on the inline depth of the type
+int dual_inline_depth() const;
+int meet_inline_depth(int depth) const;
+#ifndef PRODUCT
+void dump_inline_depth(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;
 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, const TypeOopPtr* speculative);
+static const TypeOopPtr* make(PTR ptr, int offset, int instance_id, const TypeOopPtr* speculative = NULL, int inline_depth = InlineDepthBottom);
 ciObject* const_oop()    const { return _const_oop; }
 virtual ciKlass* klass() const { return _klass;     }
 bool klass_is_exact()    const { return _klass_is_exact; }
 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; }
-const TypeOopPtr* speculative() const { return _speculative; }
+virtual const TypeOopPtr* speculative() const { return _speculative; }
 virtual intptr_t get_con() const;
 virtual const Type *cast_to_ptr_type(PTR ptr) const;
 // Return the speculative type if any
 ciKlass* speculative_type() const {
 if (_speculative != NULL) {
 const TypeOopPtr* speculative = _speculative->join(this)->is_oopptr();
 if (speculative->klass_is_exact()) {
 return speculative->klass();
 }
 }
 return NULL;
 }
+int inline_depth() const {
+return _inline_depth;
+}
+virtual const TypeOopPtr* with_inline_depth(int depth) const;
+virtual bool would_improve_type(ciKlass* exact_kls, int inline_depth) const;
 };
 //------------------------------TypeInstPtr------------------------------------
 // Class of Java object pointers, pointing either to non-array Java instances
 // or to a Klass* (including array klasses).
 class TypeInstPtr : public TypeOopPtr {
-TypeInstPtr(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id, const TypeOopPtr* speculative);
+TypeInstPtr(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id, const TypeOopPtr* speculative, int inline_depth);
 virtual bool eq( const Type *t ) const;
 virtual int  hash() const;             // Type specific hashing
 ciSymbol*  _name;        // class name
 static const TypeInstPtr *make(PTR ptr, ciKlass* klass, int offset) {
 return make(ptr, klass, false, NULL, offset, InstanceBot);
 }
 // Make a pointer to an oop.
-static const TypeInstPtr *make(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id = InstanceBot, const TypeOopPtr* speculative = NULL);
+static const TypeInstPtr *make(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id = InstanceBot, const TypeOopPtr* speculative = NULL, int inline_depth = InlineDepthBottom);
 /** Create constant type for a constant boxed value */
 const Type* get_const_boxed_value() const;
 // If this is a java.lang.Class constant, return the type for it or NULL.
 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 Type* remove_speculative() const;
+virtual const TypeOopPtr* with_inline_depth(int depth) 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.
 //------------------------------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, const TypeOopPtr* speculative)
+int offset, int instance_id, bool is_autobox_cache, const TypeOopPtr* speculative, int inline_depth)
-: TypeOopPtr(AryPtr,ptr,k,xk,o,offset, instance_id, speculative),
+: TypeOopPtr(AryPtr,ptr,k,xk,o,offset, instance_id, speculative, inline_depth),
 _ary(ary),
 _is_autobox_cache(is_autobox_cache)
 {
 #ifdef ASSERT
 if (k != NULL) {
 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, const TypeOopPtr* speculative = NULL);
+static const TypeAryPtr *make( PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot, const TypeOopPtr* speculative = NULL, int inline_depth = InlineDepthBottom);
 // 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, const TypeOopPtr* speculative = NULL, bool is_autobox_cache = false);
+static const TypeAryPtr *make( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot, const TypeOopPtr* speculative = NULL, int inline_depth = InlineDepthBottom, 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;
 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 Type* remove_speculative() const;
+virtual const TypeOopPtr* with_inline_depth(int depth) 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.
 // conversions
 #define ConvI2X(x)   ConvI2L(x)
 #define ConvL2X(x)   (x)
 #define ConvX2I(x)   ConvL2I(x)
 #define ConvX2L(x)   (x)
+#define ConvX2UL(x)  (x)
 #else
 // For type queries and asserts
 #define is_intptr_t  is_int
 // conversions
 #define ConvI2X(x)   (x)
 #define ConvL2X(x)   ConvL2I(x)
 #define ConvX2I(x)   (x)
 #define ConvX2L(x)   ConvI2L(x)
+#define ConvX2UL(x)  ConvI2UL(x)
 #endif
 #endif // SHARE_VM_OPTO_TYPE_HPP

Mercurial > hg > graal-compiler

comparison src/share/vm/opto/type.hpp @ 17810:62c54fcc0a35