1.1 --- a/src/share/vm/opto/type.hpp Fri Aug 31 16:39:35 2012 -0700
1.2 +++ b/src/share/vm/opto/type.hpp Sat Sep 01 13:25:18 2012 -0400
1.3 @@ -62,6 +62,7 @@
1.4 class TypeInstPtr;
1.5 class TypeAryPtr;
1.6 class TypeKlassPtr;
1.7 +class TypeMetadataPtr;
1.8
1.9 //------------------------------Type-------------------------------------------
1.10 // Basic Type object, represents a set of primitive Values.
1.11 @@ -93,8 +94,10 @@
1.12 OopPtr, // Any and all Java heap entities
1.13 InstPtr, // Instance pointers (non-array objects)
1.14 AryPtr, // Array pointers
1.15 + // (Ptr order matters: See is_ptr, isa_ptr, is_oopptr, isa_oopptr.)
1.16 +
1.17 + MetadataPtr, // Generic metadata
1.18 KlassPtr, // Klass pointers
1.19 - // (Ptr order matters: See is_ptr, isa_ptr, is_oopptr, isa_oopptr.)
1.20
1.21 Function, // Function signature
1.22 Abio, // Abstract I/O
1.23 @@ -123,8 +126,18 @@
1.24 };
1.25
1.26 private:
1.27 + typedef struct {
1.28 + const TYPES dual_type;
1.29 + const BasicType basic_type;
1.30 + const char* msg;
1.31 + const bool isa_oop;
1.32 + const int ideal_reg;
1.33 + const relocInfo::relocType reloc;
1.34 + } TypeInfo;
1.35 +
1.36 // Dictionary of types shared among compilations.
1.37 static Dict* _shared_type_dict;
1.38 + static TypeInfo _type_info[];
1.39
1.40 static int uhash( const Type *const t );
1.41 // Structural equality check. Assumes that cmp() has already compared
1.42 @@ -241,12 +254,16 @@
1.43 const TypeNarrowOop *isa_narrowoop() const; // Returns NULL if not oop ptr type
1.44 const TypeOopPtr *isa_oopptr() const; // Returns NULL if not oop ptr type
1.45 const TypeOopPtr *is_oopptr() const; // Java-style GC'd pointer
1.46 - const TypeKlassPtr *isa_klassptr() const; // Returns NULL if not KlassPtr
1.47 - const TypeKlassPtr *is_klassptr() const; // assert if not KlassPtr
1.48 const TypeInstPtr *isa_instptr() const; // Returns NULL if not InstPtr
1.49 const TypeInstPtr *is_instptr() const; // Instance
1.50 const TypeAryPtr *isa_aryptr() const; // Returns NULL if not AryPtr
1.51 const TypeAryPtr *is_aryptr() const; // Array oop
1.52 +
1.53 + const TypeMetadataPtr *isa_metadataptr() const; // Returns NULL if not oop ptr type
1.54 + const TypeMetadataPtr *is_metadataptr() const; // Java-style GC'd pointer
1.55 + const TypeKlassPtr *isa_klassptr() const; // Returns NULL if not KlassPtr
1.56 + const TypeKlassPtr *is_klassptr() const; // assert if not KlassPtr
1.57 +
1.58 virtual bool is_finite() const; // Has a finite value
1.59 virtual bool is_nan() const; // Is not a number (NaN)
1.60
1.61 @@ -267,9 +284,6 @@
1.62 // Do you have memory, directly or through a tuple?
1.63 bool has_memory( ) const;
1.64
1.65 - // Are you a pointer type or not?
1.66 - bool isa_oop_ptr() const;
1.67 -
1.68 // TRUE if type is a singleton
1.69 virtual bool singleton(void) const;
1.70
1.71 @@ -284,7 +298,6 @@
1.72 static const Type *mreg2type[];
1.73
1.74 // Printing, statistics
1.75 - static const char * const msg[lastype]; // Printable strings
1.76 #ifndef PRODUCT
1.77 void dump_on(outputStream *st) const;
1.78 void dump() const {
1.79 @@ -292,7 +305,6 @@
1.80 }
1.81 virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
1.82 static void dump_stats();
1.83 - static void verify_lastype(); // Check that arrays match type enum
1.84 #endif
1.85 void typerr(const Type *t) const; // Mixing types error
1.86
1.87 @@ -336,7 +348,11 @@
1.88 static const Type *TOP;
1.89
1.90 // Mapping from compiler type to VM BasicType
1.91 - BasicType basic_type() const { return _basic_type[_base]; }
1.92 + BasicType basic_type() const { return _type_info[_base].basic_type; }
1.93 + int ideal_reg() const { return _type_info[_base].ideal_reg; }
1.94 + const char* msg() const { return _type_info[_base].msg; }
1.95 + bool isa_oop_ptr() const { return _type_info[_base].isa_oop; }
1.96 + relocInfo::relocType reloc() const { return _type_info[_base].reloc; }
1.97
1.98 // Mapping from CI type system to compiler type:
1.99 static const Type* get_typeflow_type(ciType* type);
1.100 @@ -842,7 +858,7 @@
1.101
1.102 //------------------------------TypeInstPtr------------------------------------
1.103 // Class of Java object pointers, pointing either to non-array Java instances
1.104 -// or to a klassOop (including array klasses).
1.105 +// or to a Klass* (including array klasses).
1.106 class TypeInstPtr : public TypeOopPtr {
1.107 TypeInstPtr( PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id );
1.108 virtual bool eq( const Type *t ) const;
1.109 @@ -859,7 +875,6 @@
1.110 static const TypeInstPtr *make(ciObject* o) {
1.111 return make(TypePtr::Constant, o->klass(), true, o, 0);
1.112 }
1.113 -
1.114 // Make a pointer to a constant oop with offset.
1.115 static const TypeInstPtr *make(ciObject* o, int offset) {
1.116 return make(TypePtr::Constant, o->klass(), true, o, offset);
1.117 @@ -992,18 +1007,92 @@
1.118 #endif
1.119 };
1.120
1.121 +//------------------------------TypeMetadataPtr-------------------------------------
1.122 +// Some kind of metadata, either Method*, MethodData* or CPCacheOop
1.123 +class TypeMetadataPtr : public TypePtr {
1.124 +protected:
1.125 + TypeMetadataPtr(PTR ptr, ciMetadata* metadata, int offset);
1.126 +public:
1.127 + virtual bool eq( const Type *t ) const;
1.128 + virtual int hash() const; // Type specific hashing
1.129 + virtual bool singleton(void) const; // TRUE if type is a singleton
1.130 +
1.131 +private:
1.132 + ciMetadata* _metadata;
1.133 +
1.134 +public:
1.135 + static const TypeMetadataPtr* make(PTR ptr, ciMetadata* m, int offset);
1.136 +
1.137 + static const TypeMetadataPtr* make(ciMethod* m);
1.138 + static const TypeMetadataPtr* make(ciMethodData* m);
1.139 +
1.140 + ciMetadata* metadata() const { return _metadata; }
1.141 +
1.142 + virtual const Type *cast_to_ptr_type(PTR ptr) const;
1.143 +
1.144 + virtual const TypePtr *add_offset( intptr_t offset ) const;
1.145 +
1.146 + virtual const Type *xmeet( const Type *t ) const;
1.147 + virtual const Type *xdual() const; // Compute dual right now.
1.148 +
1.149 + virtual intptr_t get_con() const;
1.150 +
1.151 + // Do not allow interface-vs.-noninterface joins to collapse to top.
1.152 + virtual const Type *filter( const Type *kills ) const;
1.153 +
1.154 + // Convenience common pre-built types.
1.155 + static const TypeMetadataPtr *BOTTOM;
1.156 +
1.157 +#ifndef PRODUCT
1.158 + virtual void dump2( Dict &d, uint depth, outputStream *st ) const;
1.159 +#endif
1.160 +};
1.161 +
1.162 //------------------------------TypeKlassPtr-----------------------------------
1.163 // Class of Java Klass pointers
1.164 -class TypeKlassPtr : public TypeOopPtr {
1.165 +class TypeKlassPtr : public TypePtr {
1.166 TypeKlassPtr( PTR ptr, ciKlass* klass, int offset );
1.167
1.168 + public:
1.169 virtual bool eq( const Type *t ) const;
1.170 virtual int hash() const; // Type specific hashing
1.171 + virtual bool singleton(void) const; // TRUE if type is a singleton
1.172 + private:
1.173 +
1.174 + static const TypeKlassPtr* make_from_klass_common(ciKlass* klass, bool klass_change, bool try_for_exact);
1.175 +
1.176 + ciKlass* _klass;
1.177 +
1.178 + // Does the type exclude subclasses of the klass? (Inexact == polymorphic.)
1.179 + bool _klass_is_exact;
1.180
1.181 public:
1.182 - ciSymbol* name() const { return _klass->name(); }
1.183 + ciSymbol* name() const { return klass()->name(); }
1.184
1.185 - bool is_loaded() const { return _klass->is_loaded(); }
1.186 + ciKlass* klass() const { return _klass; }
1.187 + bool klass_is_exact() const { return _klass_is_exact; }
1.188 +
1.189 + bool is_loaded() const { return klass()->is_loaded(); }
1.190 +
1.191 + // Creates a type given a klass. Correctly handles multi-dimensional arrays
1.192 + // Respects UseUniqueSubclasses.
1.193 + // If the klass is final, the resulting type will be exact.
1.194 + static const TypeKlassPtr* make_from_klass(ciKlass* klass) {
1.195 + return make_from_klass_common(klass, true, false);
1.196 + }
1.197 + // Same as before, but will produce an exact type, even if
1.198 + // the klass is not final, as long as it has exactly one implementation.
1.199 + static const TypeKlassPtr* make_from_klass_unique(ciKlass* klass) {
1.200 + return make_from_klass_common(klass, true, true);
1.201 + }
1.202 + // Same as before, but does not respects UseUniqueSubclasses.
1.203 + // Use this only for creating array element types.
1.204 + static const TypeKlassPtr* make_from_klass_raw(ciKlass* klass) {
1.205 + return make_from_klass_common(klass, false, false);
1.206 + }
1.207 +
1.208 + // Make a generic (unclassed) pointer to metadata.
1.209 + static const TypeKlassPtr* make(PTR ptr, int offset);
1.210
1.211 // ptr to klass 'k'
1.212 static const TypeKlassPtr *make( ciKlass* k ) { return make( TypePtr::Constant, k, 0); }
1.213 @@ -1023,6 +1112,8 @@
1.214 virtual const Type *xmeet( const Type *t ) const;
1.215 virtual const Type *xdual() const; // Compute dual right now.
1.216
1.217 + virtual intptr_t get_con() const;
1.218 +
1.219 // Convenience common pre-built types.
1.220 static const TypeKlassPtr* OBJECT; // Not-null object klass or below
1.221 static const TypeKlassPtr* OBJECT_OR_NULL; // Maybe-null version of same
1.222 @@ -1117,7 +1208,6 @@
1.223
1.224 #ifndef PRODUCT
1.225 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping
1.226 - void print_flattened() const; // Print a 'flattened' signature
1.227 #endif
1.228 // Convenience common pre-built types.
1.229 };
1.230 @@ -1209,13 +1299,13 @@
1.231
1.232 inline const TypeOopPtr *Type::is_oopptr() const {
1.233 // OopPtr is the first and KlassPtr the last, with no non-oops between.
1.234 - assert(_base >= OopPtr && _base <= KlassPtr, "Not a Java pointer" ) ;
1.235 + assert(_base >= OopPtr && _base <= AryPtr, "Not a Java pointer" ) ;
1.236 return (TypeOopPtr*)this;
1.237 }
1.238
1.239 inline const TypeOopPtr *Type::isa_oopptr() const {
1.240 // OopPtr is the first and KlassPtr the last, with no non-oops between.
1.241 - return (_base >= OopPtr && _base <= KlassPtr) ? (TypeOopPtr*)this : NULL;
1.242 + return (_base >= OopPtr && _base <= AryPtr) ? (TypeOopPtr*)this : NULL;
1.243 }
1.244
1.245 inline const TypeRawPtr *Type::isa_rawptr() const {
1.246 @@ -1256,6 +1346,16 @@
1.247 return (_base == NarrowOop) ? (TypeNarrowOop*)this : NULL;
1.248 }
1.249
1.250 +inline const TypeMetadataPtr *Type::is_metadataptr() const {
1.251 + // MetadataPtr is the first and CPCachePtr the last
1.252 + assert(_base == MetadataPtr, "Not a metadata pointer" ) ;
1.253 + return (TypeMetadataPtr*)this;
1.254 +}
1.255 +
1.256 +inline const TypeMetadataPtr *Type::isa_metadataptr() const {
1.257 + return (_base == MetadataPtr) ? (TypeMetadataPtr*)this : NULL;
1.258 +}
1.259 +
1.260 inline const TypeKlassPtr *Type::isa_klassptr() const {
1.261 return (_base == KlassPtr) ? (TypeKlassPtr*)this : NULL;
1.262 }
