162 #ifdef ASSERT |
162 #ifdef ASSERT |
163 // One type is interface, the other is oop |
163 // One type is interface, the other is oop |
164 virtual bool interface_vs_oop_helper(const Type *t) const; |
164 virtual bool interface_vs_oop_helper(const Type *t) const; |
165 #endif |
165 #endif |
166 |
166 |
|
167 const Type *meet_helper(const Type *t, bool include_speculative) const; |
|
168 |
167 protected: |
169 protected: |
168 // Each class of type is also identified by its base. |
170 // Each class of type is also identified by its base. |
169 const TYPES _base; // Enum of Types type |
171 const TYPES _base; // Enum of Types type |
170 |
172 |
171 Type( TYPES t ) : _dual(NULL), _base(t) {} // Simple types |
173 Type( TYPES t ) : _dual(NULL), _base(t) {} // Simple types |
172 // ~Type(); // Use fast deallocation |
174 // ~Type(); // Use fast deallocation |
173 const Type *hashcons(); // Hash-cons the type |
175 const Type *hashcons(); // Hash-cons the type |
|
176 virtual const Type *filter_helper(const Type *kills, bool include_speculative) const; |
|
177 const Type *join_helper(const Type *t, bool include_speculative) const { |
|
178 return dual()->meet_helper(t->dual(), include_speculative)->dual(); |
|
179 } |
174 |
180 |
175 public: |
181 public: |
176 |
182 |
177 inline void* operator new( size_t x ) throw() { |
183 inline void* operator new( size_t x ) throw() { |
178 Compile* compile = Compile::current(); |
184 Compile* compile = Compile::current(); |
200 // Create a new hash-consd type |
206 // Create a new hash-consd type |
201 static const Type *make(enum TYPES); |
207 static const Type *make(enum TYPES); |
202 // Test for equivalence of types |
208 // Test for equivalence of types |
203 static int cmp( const Type *const t1, const Type *const t2 ); |
209 static int cmp( const Type *const t1, const Type *const t2 ); |
204 // Test for higher or equal in lattice |
210 // Test for higher or equal in lattice |
205 int higher_equal( const Type *t ) const { return !cmp(meet(t),t); } |
211 // Variant that drops the speculative part of the types |
|
212 int higher_equal(const Type *t) const { |
|
213 return !cmp(meet(t),t->remove_speculative()); |
|
214 } |
|
215 // Variant that keeps the speculative part of the types |
|
216 int higher_equal_speculative(const Type *t) const { |
|
217 return !cmp(meet_speculative(t),t); |
|
218 } |
206 |
219 |
207 // MEET operation; lower in lattice. |
220 // MEET operation; lower in lattice. |
208 const Type *meet( const Type *t ) const; |
221 // Variant that drops the speculative part of the types |
|
222 const Type *meet(const Type *t) const { |
|
223 return meet_helper(t, false); |
|
224 } |
|
225 // Variant that keeps the speculative part of the types |
|
226 const Type *meet_speculative(const Type *t) const { |
|
227 return meet_helper(t, true); |
|
228 } |
209 // WIDEN: 'widens' for Ints and other range types |
229 // WIDEN: 'widens' for Ints and other range types |
210 virtual const Type *widen( const Type *old, const Type* limit ) const { return this; } |
230 virtual const Type *widen( const Type *old, const Type* limit ) const { return this; } |
211 // NARROW: complement for widen, used by pessimistic phases |
231 // NARROW: complement for widen, used by pessimistic phases |
212 virtual const Type *narrow( const Type *old ) const { return this; } |
232 virtual const Type *narrow( const Type *old ) const { return this; } |
213 |
233 |
219 virtual const Type *xmeet( const Type *t ) const; |
239 virtual const Type *xmeet( const Type *t ) const; |
220 virtual const Type *xdual() const; // Compute dual right now. |
240 virtual const Type *xdual() const; // Compute dual right now. |
221 |
241 |
222 // JOIN operation; higher in lattice. Done by finding the dual of the |
242 // JOIN operation; higher in lattice. Done by finding the dual of the |
223 // meet of the dual of the 2 inputs. |
243 // meet of the dual of the 2 inputs. |
224 const Type *join( const Type *t ) const { |
244 // Variant that drops the speculative part of the types |
225 return dual()->meet(t->dual())->dual(); } |
245 const Type *join(const Type *t) const { |
|
246 return join_helper(t, false); |
|
247 } |
|
248 // Variant that keeps the speculative part of the types |
|
249 const Type *join_speculative(const Type *t) const { |
|
250 return join_helper(t, true); |
|
251 } |
226 |
252 |
227 // Modified version of JOIN adapted to the needs Node::Value. |
253 // Modified version of JOIN adapted to the needs Node::Value. |
228 // Normalizes all empty values to TOP. Does not kill _widen bits. |
254 // Normalizes all empty values to TOP. Does not kill _widen bits. |
229 // Currently, it also works around limitations involving interface types. |
255 // Currently, it also works around limitations involving interface types. |
230 virtual const Type *filter( const Type *kills ) const; |
256 // Variant that drops the speculative part of the types |
|
257 const Type *filter(const Type *kills) const { |
|
258 return filter_helper(kills, false); |
|
259 } |
|
260 // Variant that keeps the speculative part of the types |
|
261 const Type *filter_speculative(const Type *kills) const { |
|
262 return filter_helper(kills, true); |
|
263 } |
231 |
264 |
232 #ifdef ASSERT |
265 #ifdef ASSERT |
233 // One type is interface, the other is oop |
266 // One type is interface, the other is oop |
234 virtual bool interface_vs_oop(const Type *t) const; |
267 virtual bool interface_vs_oop(const Type *t) const; |
235 #endif |
268 #endif |
381 bool require_constant = false, |
414 bool require_constant = false, |
382 bool is_autobox_cache = false); |
415 bool is_autobox_cache = false); |
383 |
416 |
384 // Speculative type. See TypeInstPtr |
417 // Speculative type. See TypeInstPtr |
385 virtual ciKlass* speculative_type() const { return NULL; } |
418 virtual ciKlass* speculative_type() const { return NULL; } |
|
419 const Type* maybe_remove_speculative(bool include_speculative) const; |
|
420 virtual const Type* remove_speculative() const { return this; } |
386 |
421 |
387 private: |
422 private: |
388 // support arrays |
423 // support arrays |
389 static const BasicType _basic_type[]; |
424 static const BasicType _basic_type[]; |
390 static const Type* _zero_type[T_CONFLICT+1]; |
425 static const Type* _zero_type[T_CONFLICT+1]; |
448 //------------------------------TypeInt---------------------------------------- |
483 //------------------------------TypeInt---------------------------------------- |
449 // Class of integer ranges, the set of integers between a lower bound and an |
484 // Class of integer ranges, the set of integers between a lower bound and an |
450 // upper bound, inclusive. |
485 // upper bound, inclusive. |
451 class TypeInt : public Type { |
486 class TypeInt : public Type { |
452 TypeInt( jint lo, jint hi, int w ); |
487 TypeInt( jint lo, jint hi, int w ); |
|
488 protected: |
|
489 virtual const Type *filter_helper(const Type *kills, bool include_speculative) const; |
|
490 |
453 public: |
491 public: |
454 virtual bool eq( const Type *t ) const; |
492 virtual bool eq( const Type *t ) const; |
455 virtual int hash() const; // Type specific hashing |
493 virtual int hash() const; // Type specific hashing |
456 virtual bool singleton(void) const; // TRUE if type is a singleton |
494 virtual bool singleton(void) const; // TRUE if type is a singleton |
457 virtual bool empty(void) const; // TRUE if type is vacuous |
495 virtual bool empty(void) const; // TRUE if type is vacuous |
458 public: |
|
459 const jint _lo, _hi; // Lower bound, upper bound |
496 const jint _lo, _hi; // Lower bound, upper bound |
460 const short _widen; // Limit on times we widen this sucker |
497 const short _widen; // Limit on times we widen this sucker |
461 |
498 |
462 static const TypeInt *make(jint lo); |
499 static const TypeInt *make(jint lo); |
463 // must always specify w |
500 // must always specify w |
473 virtual const Type *xmeet( const Type *t ) const; |
510 virtual const Type *xmeet( const Type *t ) const; |
474 virtual const Type *xdual() const; // Compute dual right now. |
511 virtual const Type *xdual() const; // Compute dual right now. |
475 virtual const Type *widen( const Type *t, const Type* limit_type ) const; |
512 virtual const Type *widen( const Type *t, const Type* limit_type ) const; |
476 virtual const Type *narrow( const Type *t ) const; |
513 virtual const Type *narrow( const Type *t ) const; |
477 // Do not kill _widen bits. |
514 // Do not kill _widen bits. |
478 virtual const Type *filter( const Type *kills ) const; |
|
479 // Convenience common pre-built types. |
515 // Convenience common pre-built types. |
480 static const TypeInt *MINUS_1; |
516 static const TypeInt *MINUS_1; |
481 static const TypeInt *ZERO; |
517 static const TypeInt *ZERO; |
482 static const TypeInt *ONE; |
518 static const TypeInt *ONE; |
483 static const TypeInt *BOOL; |
519 static const TypeInt *BOOL; |
504 //------------------------------TypeLong--------------------------------------- |
540 //------------------------------TypeLong--------------------------------------- |
505 // Class of long integer ranges, the set of integers between a lower bound and |
541 // Class of long integer ranges, the set of integers between a lower bound and |
506 // an upper bound, inclusive. |
542 // an upper bound, inclusive. |
507 class TypeLong : public Type { |
543 class TypeLong : public Type { |
508 TypeLong( jlong lo, jlong hi, int w ); |
544 TypeLong( jlong lo, jlong hi, int w ); |
|
545 protected: |
|
546 // Do not kill _widen bits. |
|
547 virtual const Type *filter_helper(const Type *kills, bool include_speculative) const; |
509 public: |
548 public: |
510 virtual bool eq( const Type *t ) const; |
549 virtual bool eq( const Type *t ) const; |
511 virtual int hash() const; // Type specific hashing |
550 virtual int hash() const; // Type specific hashing |
512 virtual bool singleton(void) const; // TRUE if type is a singleton |
551 virtual bool singleton(void) const; // TRUE if type is a singleton |
513 virtual bool empty(void) const; // TRUE if type is vacuous |
552 virtual bool empty(void) const; // TRUE if type is vacuous |
528 |
567 |
529 virtual const Type *xmeet( const Type *t ) const; |
568 virtual const Type *xmeet( const Type *t ) const; |
530 virtual const Type *xdual() const; // Compute dual right now. |
569 virtual const Type *xdual() const; // Compute dual right now. |
531 virtual const Type *widen( const Type *t, const Type* limit_type ) const; |
570 virtual const Type *widen( const Type *t, const Type* limit_type ) const; |
532 virtual const Type *narrow( const Type *t ) const; |
571 virtual const Type *narrow( const Type *t ) const; |
533 // Do not kill _widen bits. |
|
534 virtual const Type *filter( const Type *kills ) const; |
|
535 // Convenience common pre-built types. |
572 // Convenience common pre-built types. |
536 static const TypeLong *MINUS_1; |
573 static const TypeLong *MINUS_1; |
537 static const TypeLong *ZERO; |
574 static const TypeLong *ZERO; |
538 static const TypeLong *ONE; |
575 static const TypeLong *ONE; |
539 static const TypeLong *POS; |
576 static const TypeLong *POS; |
620 static const TypeAry* make(const Type* elem, const TypeInt* size, bool stable = false); |
657 static const TypeAry* make(const Type* elem, const TypeInt* size, bool stable = false); |
621 |
658 |
622 virtual const Type *xmeet( const Type *t ) const; |
659 virtual const Type *xmeet( const Type *t ) const; |
623 virtual const Type *xdual() const; // Compute dual right now. |
660 virtual const Type *xdual() const; // Compute dual right now. |
624 bool ary_must_be_exact() const; // true if arrays of such are never generic |
661 bool ary_must_be_exact() const; // true if arrays of such are never generic |
|
662 virtual const Type* remove_speculative() const; |
625 #ifdef ASSERT |
663 #ifdef ASSERT |
626 // One type is interface, the other is oop |
664 // One type is interface, the other is oop |
627 virtual bool interface_vs_oop(const Type *t) const; |
665 virtual bool interface_vs_oop(const Type *t) const; |
628 #endif |
666 #endif |
629 #ifndef PRODUCT |
667 #ifndef PRODUCT |
830 int dual_instance_id() const; |
868 int dual_instance_id() const; |
831 int meet_instance_id(int uid) const; |
869 int meet_instance_id(int uid) const; |
832 |
870 |
833 // utility methods to work on the speculative part of the type |
871 // utility methods to work on the speculative part of the type |
834 const TypeOopPtr* dual_speculative() const; |
872 const TypeOopPtr* dual_speculative() const; |
835 const TypeOopPtr* meet_speculative(const TypeOopPtr* other) const; |
873 const TypeOopPtr* xmeet_speculative(const TypeOopPtr* other) const; |
836 bool eq_speculative(const TypeOopPtr* other) const; |
874 bool eq_speculative(const TypeOopPtr* other) const; |
837 int hash_speculative() const; |
875 int hash_speculative() const; |
838 const TypeOopPtr* add_offset_speculative(intptr_t offset) const; |
876 const TypeOopPtr* add_offset_speculative(intptr_t offset) const; |
839 #ifndef PRODUCT |
877 #ifndef PRODUCT |
840 void dump_speculative(outputStream *st) const; |
878 void dump_speculative(outputStream *st) const; |
841 #endif |
879 #endif |
|
880 |
|
881 // Do not allow interface-vs.-noninterface joins to collapse to top. |
|
882 virtual const Type *filter_helper(const Type *kills, bool include_speculative) const; |
842 |
883 |
843 public: |
884 public: |
844 // Creates a type given a klass. Correctly handles multi-dimensional arrays |
885 // Creates a type given a klass. Correctly handles multi-dimensional arrays |
845 // Respects UseUniqueSubclasses. |
886 // Respects UseUniqueSubclasses. |
846 // If the klass is final, the resulting type will be exact. |
887 // If the klass is final, the resulting type will be exact. |
893 // corresponding pointer to klass, for a given instance |
934 // corresponding pointer to klass, for a given instance |
894 const TypeKlassPtr* as_klass_type() const; |
935 const TypeKlassPtr* as_klass_type() const; |
895 |
936 |
896 virtual const TypePtr *add_offset( intptr_t offset ) const; |
937 virtual const TypePtr *add_offset( intptr_t offset ) const; |
897 // Return same type without a speculative part |
938 // Return same type without a speculative part |
898 virtual const TypeOopPtr* remove_speculative() const; |
939 virtual const Type* remove_speculative() const; |
899 |
940 |
900 virtual const Type *xmeet(const Type *t) const; |
941 virtual const Type *xmeet(const Type *t) const; |
901 virtual const Type *xdual() const; // Compute dual right now. |
942 virtual const Type *xdual() const; // Compute dual right now. |
902 // the core of the computation of the meet for TypeOopPtr and for its subclasses |
943 // the core of the computation of the meet for TypeOopPtr and for its subclasses |
903 virtual const Type *xmeet_helper(const Type *t) const; |
944 virtual const Type *xmeet_helper(const Type *t) const; |
904 |
|
905 // Do not allow interface-vs.-noninterface joins to collapse to top. |
|
906 virtual const Type *filter( const Type *kills ) const; |
|
907 |
945 |
908 // Convenience common pre-built type. |
946 // Convenience common pre-built type. |
909 static const TypeOopPtr *BOTTOM; |
947 static const TypeOopPtr *BOTTOM; |
910 #ifndef PRODUCT |
948 #ifndef PRODUCT |
911 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; |
949 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; |
979 |
1017 |
980 virtual const TypeOopPtr *cast_to_instance_id(int instance_id) const; |
1018 virtual const TypeOopPtr *cast_to_instance_id(int instance_id) const; |
981 |
1019 |
982 virtual const TypePtr *add_offset( intptr_t offset ) const; |
1020 virtual const TypePtr *add_offset( intptr_t offset ) const; |
983 // Return same type without a speculative part |
1021 // Return same type without a speculative part |
984 virtual const TypeOopPtr* remove_speculative() const; |
1022 virtual const Type* remove_speculative() const; |
985 |
1023 |
986 // the core of the computation of the meet of 2 types |
1024 // the core of the computation of the meet of 2 types |
987 virtual const Type *xmeet_helper(const Type *t) const; |
1025 virtual const Type *xmeet_helper(const Type *t) const; |
988 virtual const TypeInstPtr *xmeet_unloaded( const TypeInstPtr *t ) const; |
1026 virtual const TypeInstPtr *xmeet_unloaded( const TypeInstPtr *t ) const; |
989 virtual const Type *xdual() const; // Compute dual right now. |
1027 virtual const Type *xdual() const; // Compute dual right now. |
1057 virtual const TypeInt* narrow_size_type(const TypeInt* size) const; |
1095 virtual const TypeInt* narrow_size_type(const TypeInt* size) const; |
1058 |
1096 |
1059 virtual bool empty(void) const; // TRUE if type is vacuous |
1097 virtual bool empty(void) const; // TRUE if type is vacuous |
1060 virtual const TypePtr *add_offset( intptr_t offset ) const; |
1098 virtual const TypePtr *add_offset( intptr_t offset ) const; |
1061 // Return same type without a speculative part |
1099 // Return same type without a speculative part |
1062 virtual const TypeOopPtr* remove_speculative() const; |
1100 virtual const Type* remove_speculative() const; |
1063 |
1101 |
1064 // the core of the computation of the meet of 2 types |
1102 // the core of the computation of the meet of 2 types |
1065 virtual const Type *xmeet_helper(const Type *t) const; |
1103 virtual const Type *xmeet_helper(const Type *t) const; |
1066 virtual const Type *xdual() const; // Compute dual right now. |
1104 virtual const Type *xdual() const; // Compute dual right now. |
1067 |
1105 |
1098 //------------------------------TypeMetadataPtr------------------------------------- |
1136 //------------------------------TypeMetadataPtr------------------------------------- |
1099 // Some kind of metadata, either Method*, MethodData* or CPCacheOop |
1137 // Some kind of metadata, either Method*, MethodData* or CPCacheOop |
1100 class TypeMetadataPtr : public TypePtr { |
1138 class TypeMetadataPtr : public TypePtr { |
1101 protected: |
1139 protected: |
1102 TypeMetadataPtr(PTR ptr, ciMetadata* metadata, int offset); |
1140 TypeMetadataPtr(PTR ptr, ciMetadata* metadata, int offset); |
|
1141 // Do not allow interface-vs.-noninterface joins to collapse to top. |
|
1142 virtual const Type *filter_helper(const Type *kills, bool include_speculative) const; |
1103 public: |
1143 public: |
1104 virtual bool eq( const Type *t ) const; |
1144 virtual bool eq( const Type *t ) const; |
1105 virtual int hash() const; // Type specific hashing |
1145 virtual int hash() const; // Type specific hashing |
1106 virtual bool singleton(void) const; // TRUE if type is a singleton |
1146 virtual bool singleton(void) const; // TRUE if type is a singleton |
1107 |
1147 |
1122 |
1162 |
1123 virtual const Type *xmeet( const Type *t ) const; |
1163 virtual const Type *xmeet( const Type *t ) const; |
1124 virtual const Type *xdual() const; // Compute dual right now. |
1164 virtual const Type *xdual() const; // Compute dual right now. |
1125 |
1165 |
1126 virtual intptr_t get_con() const; |
1166 virtual intptr_t get_con() const; |
1127 |
|
1128 // Do not allow interface-vs.-noninterface joins to collapse to top. |
|
1129 virtual const Type *filter( const Type *kills ) const; |
|
1130 |
1167 |
1131 // Convenience common pre-built types. |
1168 // Convenience common pre-built types. |
1132 static const TypeMetadataPtr *BOTTOM; |
1169 static const TypeMetadataPtr *BOTTOM; |
1133 |
1170 |
1134 #ifndef PRODUCT |
1171 #ifndef PRODUCT |
1139 //------------------------------TypeKlassPtr----------------------------------- |
1176 //------------------------------TypeKlassPtr----------------------------------- |
1140 // Class of Java Klass pointers |
1177 // Class of Java Klass pointers |
1141 class TypeKlassPtr : public TypePtr { |
1178 class TypeKlassPtr : public TypePtr { |
1142 TypeKlassPtr( PTR ptr, ciKlass* klass, int offset ); |
1179 TypeKlassPtr( PTR ptr, ciKlass* klass, int offset ); |
1143 |
1180 |
|
1181 protected: |
|
1182 virtual const Type *filter_helper(const Type *kills, bool include_speculative) const; |
1144 public: |
1183 public: |
1145 virtual bool eq( const Type *t ) const; |
1184 virtual bool eq( const Type *t ) const; |
1146 virtual int hash() const; // Type specific hashing |
1185 virtual int hash() const; // Type specific hashing |
1147 virtual bool singleton(void) const; // TRUE if type is a singleton |
1186 virtual bool singleton(void) const; // TRUE if type is a singleton |
1148 private: |
1187 private: |
1200 virtual const Type *xmeet( const Type *t ) const; |
1239 virtual const Type *xmeet( const Type *t ) const; |
1201 virtual const Type *xdual() const; // Compute dual right now. |
1240 virtual const Type *xdual() const; // Compute dual right now. |
1202 |
1241 |
1203 virtual intptr_t get_con() const; |
1242 virtual intptr_t get_con() const; |
1204 |
1243 |
1205 // Do not allow interface-vs.-noninterface joins to collapse to top. |
|
1206 virtual const Type *filter( const Type *kills ) const; |
|
1207 |
|
1208 // Convenience common pre-built types. |
1244 // Convenience common pre-built types. |
1209 static const TypeKlassPtr* OBJECT; // Not-null object klass or below |
1245 static const TypeKlassPtr* OBJECT; // Not-null object klass or below |
1210 static const TypeKlassPtr* OBJECT_OR_NULL; // Maybe-null version of same |
1246 static const TypeKlassPtr* OBJECT_OR_NULL; // Maybe-null version of same |
1211 #ifndef PRODUCT |
1247 #ifndef PRODUCT |
1212 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping |
1248 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; // Specialized per-Type dumping |
1226 |
1262 |
1227 virtual const TypeNarrowPtr *isa_same_narrowptr(const Type *t) const = 0; |
1263 virtual const TypeNarrowPtr *isa_same_narrowptr(const Type *t) const = 0; |
1228 virtual const TypeNarrowPtr *is_same_narrowptr(const Type *t) const = 0; |
1264 virtual const TypeNarrowPtr *is_same_narrowptr(const Type *t) const = 0; |
1229 virtual const TypeNarrowPtr *make_same_narrowptr(const TypePtr *t) const = 0; |
1265 virtual const TypeNarrowPtr *make_same_narrowptr(const TypePtr *t) const = 0; |
1230 virtual const TypeNarrowPtr *make_hash_same_narrowptr(const TypePtr *t) const = 0; |
1266 virtual const TypeNarrowPtr *make_hash_same_narrowptr(const TypePtr *t) const = 0; |
|
1267 // Do not allow interface-vs.-noninterface joins to collapse to top. |
|
1268 virtual const Type *filter_helper(const Type *kills, bool include_speculative) const; |
1231 public: |
1269 public: |
1232 virtual bool eq( const Type *t ) const; |
1270 virtual bool eq( const Type *t ) const; |
1233 virtual int hash() const; // Type specific hashing |
1271 virtual int hash() const; // Type specific hashing |
1234 virtual bool singleton(void) const; // TRUE if type is a singleton |
1272 virtual bool singleton(void) const; // TRUE if type is a singleton |
1235 |
1273 |
1236 virtual const Type *xmeet( const Type *t ) const; |
1274 virtual const Type *xmeet( const Type *t ) const; |
1237 virtual const Type *xdual() const; // Compute dual right now. |
1275 virtual const Type *xdual() const; // Compute dual right now. |
1238 |
1276 |
1239 virtual intptr_t get_con() const; |
1277 virtual intptr_t get_con() const; |
1240 |
|
1241 // Do not allow interface-vs.-noninterface joins to collapse to top. |
|
1242 virtual const Type *filter( const Type *kills ) const; |
|
1243 |
1278 |
1244 virtual bool empty(void) const; // TRUE if type is vacuous |
1279 virtual bool empty(void) const; // TRUE if type is vacuous |
1245 |
1280 |
1246 // returns the equivalent ptr type for this compressed pointer |
1281 // returns the equivalent ptr type for this compressed pointer |
1247 const TypePtr *get_ptrtype() const { |
1282 const TypePtr *get_ptrtype() const { |
1288 return make(TypeOopPtr::make_from_constant(con, require_constant)); |
1323 return make(TypeOopPtr::make_from_constant(con, require_constant)); |
1289 } |
1324 } |
1290 |
1325 |
1291 static const TypeNarrowOop *BOTTOM; |
1326 static const TypeNarrowOop *BOTTOM; |
1292 static const TypeNarrowOop *NULL_PTR; |
1327 static const TypeNarrowOop *NULL_PTR; |
|
1328 |
|
1329 virtual const Type* remove_speculative() const { |
|
1330 return make(_ptrtype->remove_speculative()->is_ptr()); |
|
1331 } |
1293 |
1332 |
1294 #ifndef PRODUCT |
1333 #ifndef PRODUCT |
1295 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; |
1334 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; |
1296 #endif |
1335 #endif |
1297 }; |
1336 }; |