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

comparison src/share/vm/opto/type.hpp @ 14422:2b8e28fdf503

Merge

author	kvn
date	Tue, 05 Nov 2013 17:38:04 -0800
parents	6c2f07d1495f
children	5ec7dace41a6 15120a36272d

comparison

equal deleted inserted replaced

-:3068270ba476
+:2b8e28fdf503
 /*
-* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 class   TypePtr;
 class     TypeRawPtr;
 class     TypeOopPtr;
 class       TypeInstPtr;
 class       TypeAryPtr;
-class       TypeKlassPtr;
+class     TypeKlassPtr;
 class     TypeMetadataPtr;
 //------------------------------Type-------------------------------------------
 // Basic Type object, represents a set of primitive Values.
 // Types are hash-cons'd into a private class dictionary, so only one of each
 // lazily, on demand, and cached in _dual.
 const Type *_dual;            // Cached dual value
 // Table for efficient dualing of base types
 static const TYPES dual_type[lastype];
+#ifdef ASSERT
+// One type is interface, the other is oop
+virtual bool interface_vs_oop_helper(const Type *t) const;
+#endif
 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
 public:
-inline void* operator new( size_t x ) {
+inline void* operator new( size_t x ) throw() {
 Compile* compile = Compile::current();
 compile->set_type_last_size(x);
 void *temp = compile->type_arena()->Amalloc_D(x);
 compile->set_type_hwm(temp);
 return temp;
 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);
+// Speculative type. See TypeInstPtr
+virtual ciKlass* speculative_type() const { return NULL; }
 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];
 static const TypeTuple *MEMBAR;
 static const TypeTuple *STORECONDITIONAL;
 static const TypeTuple *START_I2C;
 static const TypeTuple *INT_PAIR;
 static const TypeTuple *LONG_PAIR;
+static const TypeTuple *INT_CC_PAIR;
+static const TypeTuple *LONG_CC_PAIR;
 #ifndef PRODUCT
 virtual void dump2( Dict &d, uint, outputStream *st  ) const; // Specialized per-Type dumping
 #endif
 };
 //------------------------------TypeAry----------------------------------------
 // Class of Array Types
 class TypeAry : public Type {
-TypeAry( const Type *elem, const TypeInt *size) : Type(Array),
+TypeAry(const Type* elem, const TypeInt* size, bool stable) : Type(Array),
-_elem(elem), _size(size) {}
+_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);
+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
 //------------------------------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 );
+TypeOopPtr(TYPES t, PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id, const TypeOopPtr* speculative);
 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 {
 // 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;
+// 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;
 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;
+// utility methods to work on the speculative part of the type
+const TypeOopPtr* dual_speculative() const;
+const TypeOopPtr* meet_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
 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.
 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);
+static const TypeOopPtr* make(PTR ptr, int offset, int instance_id, const TypeOopPtr* speculative);
 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 intptr_t get_con() const;
 virtual const Type *cast_to_ptr_type(PTR ptr) const;
 // 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 Type *xmeet( const Type *t ) const;
+virtual const TypeOopPtr* 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;
 #endif
+// 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;
+}
 };
 //------------------------------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 );
+TypeInstPtr(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id, const TypeOopPtr* speculative);
 virtual bool eq( const Type *t ) const;
 virtual int  hash() const;             // Type specific hashing
 ciSymbol*  _name;        // class name
 bool  is_loaded() const { return _klass->is_loaded(); }
 // Make a pointer to a constant oop.
 static const TypeInstPtr *make(ciObject* o) {
-return make(TypePtr::Constant, o->klass(), true, o, 0);
+return make(TypePtr::Constant, o->klass(), true, o, 0, InstanceBot);
 }
 // Make a pointer to a constant oop with offset.
 static const TypeInstPtr *make(ciObject* o, int offset) {
-return make(TypePtr::Constant, o->klass(), true, o, offset);
+return make(TypePtr::Constant, o->klass(), true, o, offset, InstanceBot);
 }
 // Make a pointer to some value of type klass.
 static const TypeInstPtr *make(PTR ptr, ciKlass* klass) {
-return make(ptr, klass, false, NULL, 0);
+return make(ptr, klass, false, NULL, 0, InstanceBot);
 }
 // Make a pointer to some non-polymorphic value of exactly type klass.
 static const TypeInstPtr *make_exact(PTR ptr, ciKlass* klass) {
-return make(ptr, klass, true, NULL, 0);
+return make(ptr, klass, true, NULL, 0, InstanceBot);
 }
 // Make a pointer to some value of type klass with offset.
 static const TypeInstPtr *make(PTR ptr, ciKlass* klass, int offset) {
-return make(ptr, klass, false, NULL, 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 );
+static const TypeInstPtr *make(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id = InstanceBot, const TypeOopPtr* speculative = NULL);
 /** 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 Type *cast_to_exactness(bool klass_is_exact) 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 Type *xmeet( const Type *t ) const;
+virtual const TypeOopPtr* 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.
 // Convenience common pre-built types.
 static const TypeInstPtr *NOTNULL;
 //------------------------------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 )
+int offset, int instance_id, bool is_autobox_cache, const TypeOopPtr* speculative)
-: TypeOopPtr(AryPtr,ptr,k,xk,o,offset, instance_id),
+: TypeOopPtr(AryPtr,ptr,k,xk,o,offset, instance_id, speculative),
 _ary(ary),
 _is_autobox_cache(is_autobox_cache)
 {
 #ifdef ASSERT
 if (k != NULL) {
 // 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);
+static const TypeAryPtr *make( PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot, const TypeOopPtr* speculative = NULL);
 // 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);
+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);
 // 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 const TypeAryPtr* cast_to_size(const TypeInt* size) const;
 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 Type *xmeet( const Type *t ) const;
+virtual const TypeOopPtr* 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.
+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;
 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.
 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

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/opto/type.hpp @ 14422:2b8e28fdf503