413 static const Type* make_from_constant(ciConstant constant, |
413 static const Type* make_from_constant(ciConstant constant, |
414 bool require_constant = false, |
414 bool require_constant = false, |
415 bool is_autobox_cache = false); |
415 bool is_autobox_cache = false); |
416 |
416 |
417 // Speculative type. See TypeInstPtr |
417 // Speculative type. See TypeInstPtr |
|
418 virtual const TypeOopPtr* speculative() const { return NULL; } |
418 virtual ciKlass* speculative_type() const { return NULL; } |
419 virtual ciKlass* speculative_type() const { return NULL; } |
419 const Type* maybe_remove_speculative(bool include_speculative) const; |
420 const Type* maybe_remove_speculative(bool include_speculative) const; |
420 virtual const Type* remove_speculative() const { return this; } |
421 virtual const Type* remove_speculative() const { return this; } |
|
422 |
|
423 virtual bool would_improve_type(ciKlass* exact_kls, int inline_depth) const { |
|
424 return exact_kls != NULL; |
|
425 } |
421 |
426 |
422 private: |
427 private: |
423 // support arrays |
428 // support arrays |
424 static const BasicType _basic_type[]; |
429 static const BasicType _basic_type[]; |
425 static const Type* _zero_type[T_CONFLICT+1]; |
430 static const Type* _zero_type[T_CONFLICT+1]; |
487 TypeInt( jint lo, jint hi, int w ); |
492 TypeInt( jint lo, jint hi, int w ); |
488 protected: |
493 protected: |
489 virtual const Type *filter_helper(const Type *kills, bool include_speculative) const; |
494 virtual const Type *filter_helper(const Type *kills, bool include_speculative) const; |
490 |
495 |
491 public: |
496 public: |
|
497 typedef jint NativeType; |
492 virtual bool eq( const Type *t ) const; |
498 virtual bool eq( const Type *t ) const; |
493 virtual int hash() const; // Type specific hashing |
499 virtual int hash() const; // Type specific hashing |
494 virtual bool singleton(void) const; // TRUE if type is a singleton |
500 virtual bool singleton(void) const; // TRUE if type is a singleton |
495 virtual bool empty(void) const; // TRUE if type is vacuous |
501 virtual bool empty(void) const; // TRUE if type is vacuous |
496 const jint _lo, _hi; // Lower bound, upper bound |
502 const jint _lo, _hi; // Lower bound, upper bound |
529 static const TypeInt *SHORT; |
535 static const TypeInt *SHORT; |
530 static const TypeInt *POS; |
536 static const TypeInt *POS; |
531 static const TypeInt *POS1; |
537 static const TypeInt *POS1; |
532 static const TypeInt *INT; |
538 static const TypeInt *INT; |
533 static const TypeInt *SYMINT; // symmetric range [-max_jint..max_jint] |
539 static const TypeInt *SYMINT; // symmetric range [-max_jint..max_jint] |
|
540 static const TypeInt *TYPE_DOMAIN; // alias for TypeInt::INT |
|
541 |
|
542 static const TypeInt *as_self(const Type *t) { return t->is_int(); } |
534 #ifndef PRODUCT |
543 #ifndef PRODUCT |
535 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; |
544 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; |
536 #endif |
545 #endif |
537 }; |
546 }; |
538 |
547 |
544 TypeLong( jlong lo, jlong hi, int w ); |
553 TypeLong( jlong lo, jlong hi, int w ); |
545 protected: |
554 protected: |
546 // Do not kill _widen bits. |
555 // Do not kill _widen bits. |
547 virtual const Type *filter_helper(const Type *kills, bool include_speculative) const; |
556 virtual const Type *filter_helper(const Type *kills, bool include_speculative) const; |
548 public: |
557 public: |
|
558 typedef jlong NativeType; |
549 virtual bool eq( const Type *t ) const; |
559 virtual bool eq( const Type *t ) const; |
550 virtual int hash() const; // Type specific hashing |
560 virtual int hash() const; // Type specific hashing |
551 virtual bool singleton(void) const; // TRUE if type is a singleton |
561 virtual bool singleton(void) const; // TRUE if type is a singleton |
552 virtual bool empty(void) const; // TRUE if type is vacuous |
562 virtual bool empty(void) const; // TRUE if type is vacuous |
553 public: |
563 public: |
565 |
575 |
566 // Check for positive 32-bit value. |
576 // Check for positive 32-bit value. |
567 int is_positive_int() const { return _lo >= 0 && _hi <= (jlong)max_jint; } |
577 int is_positive_int() const { return _lo >= 0 && _hi <= (jlong)max_jint; } |
568 |
578 |
569 virtual bool is_finite() const; // Has a finite value |
579 virtual bool is_finite() const; // Has a finite value |
|
580 |
570 |
581 |
571 virtual const Type *xmeet( const Type *t ) const; |
582 virtual const Type *xmeet( const Type *t ) const; |
572 virtual const Type *xdual() const; // Compute dual right now. |
583 virtual const Type *xdual() const; // Compute dual right now. |
573 virtual const Type *widen( const Type *t, const Type* limit_type ) const; |
584 virtual const Type *widen( const Type *t, const Type* limit_type ) const; |
574 virtual const Type *narrow( const Type *t ) const; |
585 virtual const Type *narrow( const Type *t ) const; |
578 static const TypeLong *ONE; |
589 static const TypeLong *ONE; |
579 static const TypeLong *POS; |
590 static const TypeLong *POS; |
580 static const TypeLong *LONG; |
591 static const TypeLong *LONG; |
581 static const TypeLong *INT; // 32-bit subrange [min_jint..max_jint] |
592 static const TypeLong *INT; // 32-bit subrange [min_jint..max_jint] |
582 static const TypeLong *UINT; // 32-bit unsigned [0..max_juint] |
593 static const TypeLong *UINT; // 32-bit unsigned [0..max_juint] |
|
594 static const TypeLong *TYPE_DOMAIN; // alias for TypeLong::LONG |
|
595 |
|
596 // static convenience methods. |
|
597 static const TypeLong *as_self(const Type *t) { return t->is_long(); } |
|
598 |
583 #ifndef PRODUCT |
599 #ifndef PRODUCT |
584 virtual void dump2( Dict &d, uint, outputStream *st ) const;// Specialized per-Type dumping |
600 virtual void dump2( Dict &d, uint, outputStream *st ) const;// Specialized per-Type dumping |
585 #endif |
601 #endif |
586 }; |
602 }; |
587 |
603 |
832 |
848 |
833 //------------------------------TypeOopPtr------------------------------------- |
849 //------------------------------TypeOopPtr------------------------------------- |
834 // Some kind of oop (Java pointer), either klass or instance or array. |
850 // Some kind of oop (Java pointer), either klass or instance or array. |
835 class TypeOopPtr : public TypePtr { |
851 class TypeOopPtr : public TypePtr { |
836 protected: |
852 protected: |
837 TypeOopPtr(TYPES t, PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id, const TypeOopPtr* speculative); |
853 TypeOopPtr(TYPES t, PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id, const TypeOopPtr* speculative, int inline_depth); |
838 public: |
854 public: |
839 virtual bool eq( const Type *t ) const; |
855 virtual bool eq( const Type *t ) const; |
840 virtual int hash() const; // Type specific hashing |
856 virtual int hash() const; // Type specific hashing |
841 virtual bool singleton(void) const; // TRUE if type is a singleton |
857 virtual bool singleton(void) const; // TRUE if type is a singleton |
842 enum { |
858 enum { |
843 InstanceTop = -1, // undefined instance |
859 InstanceTop = -1, // undefined instance |
844 InstanceBot = 0 // any possible instance |
860 InstanceBot = 0 // any possible instance |
845 }; |
861 }; |
846 protected: |
862 protected: |
847 |
863 |
|
864 enum { |
|
865 InlineDepthBottom = INT_MAX, |
|
866 InlineDepthTop = -InlineDepthBottom |
|
867 }; |
848 // Oop is NULL, unless this is a constant oop. |
868 // Oop is NULL, unless this is a constant oop. |
849 ciObject* _const_oop; // Constant oop |
869 ciObject* _const_oop; // Constant oop |
850 // If _klass is NULL, then so is _sig. This is an unloaded klass. |
870 // If _klass is NULL, then so is _sig. This is an unloaded klass. |
851 ciKlass* _klass; // Klass object |
871 ciKlass* _klass; // Klass object |
852 // Does the type exclude subclasses of the klass? (Inexact == polymorphic.) |
872 // Does the type exclude subclasses of the klass? (Inexact == polymorphic.) |
863 // Extra type information profiling gave us. We propagate it the |
883 // Extra type information profiling gave us. We propagate it the |
864 // same way the rest of the type info is propagated. If we want to |
884 // same way the rest of the type info is propagated. If we want to |
865 // use it, then we have to emit a guard: this part of the type is |
885 // use it, then we have to emit a guard: this part of the type is |
866 // not something we know but something we speculate about the type. |
886 // not something we know but something we speculate about the type. |
867 const TypeOopPtr* _speculative; |
887 const TypeOopPtr* _speculative; |
|
888 // For speculative types, we record at what inlining depth the |
|
889 // profiling point that provided the data is. We want to favor |
|
890 // profile data coming from outer scopes which are likely better for |
|
891 // the current compilation. |
|
892 int _inline_depth; |
868 |
893 |
869 static const TypeOopPtr* make_from_klass_common(ciKlass* klass, bool klass_change, bool try_for_exact); |
894 static const TypeOopPtr* make_from_klass_common(ciKlass* klass, bool klass_change, bool try_for_exact); |
870 |
895 |
871 int dual_instance_id() const; |
896 int dual_instance_id() const; |
872 int meet_instance_id(int uid) const; |
897 int meet_instance_id(int uid) const; |
877 bool eq_speculative(const TypeOopPtr* other) const; |
902 bool eq_speculative(const TypeOopPtr* other) const; |
878 int hash_speculative() const; |
903 int hash_speculative() const; |
879 const TypeOopPtr* add_offset_speculative(intptr_t offset) const; |
904 const TypeOopPtr* add_offset_speculative(intptr_t offset) const; |
880 #ifndef PRODUCT |
905 #ifndef PRODUCT |
881 void dump_speculative(outputStream *st) const; |
906 void dump_speculative(outputStream *st) const; |
|
907 #endif |
|
908 // utility methods to work on the inline depth of the type |
|
909 int dual_inline_depth() const; |
|
910 int meet_inline_depth(int depth) const; |
|
911 #ifndef PRODUCT |
|
912 void dump_inline_depth(outputStream *st) const; |
882 #endif |
913 #endif |
883 |
914 |
884 // Do not allow interface-vs.-noninterface joins to collapse to top. |
915 // Do not allow interface-vs.-noninterface joins to collapse to top. |
885 virtual const Type *filter_helper(const Type *kills, bool include_speculative) const; |
916 virtual const Type *filter_helper(const Type *kills, bool include_speculative) const; |
886 |
917 |
908 static const TypeOopPtr* make_from_constant(ciObject* o, |
939 static const TypeOopPtr* make_from_constant(ciObject* o, |
909 bool require_constant = false, |
940 bool require_constant = false, |
910 bool not_null_elements = false); |
941 bool not_null_elements = false); |
911 |
942 |
912 // Make a generic (unclassed) pointer to an oop. |
943 // Make a generic (unclassed) pointer to an oop. |
913 static const TypeOopPtr* make(PTR ptr, int offset, int instance_id, const TypeOopPtr* speculative); |
944 static const TypeOopPtr* make(PTR ptr, int offset, int instance_id, const TypeOopPtr* speculative = NULL, int inline_depth = InlineDepthBottom); |
914 |
945 |
915 ciObject* const_oop() const { return _const_oop; } |
946 ciObject* const_oop() const { return _const_oop; } |
916 virtual ciKlass* klass() const { return _klass; } |
947 virtual ciKlass* klass() const { return _klass; } |
917 bool klass_is_exact() const { return _klass_is_exact; } |
948 bool klass_is_exact() const { return _klass_is_exact; } |
918 |
949 |
922 bool is_ptr_to_narrowklass_nv() const { return _is_ptr_to_narrowklass; } |
953 bool is_ptr_to_narrowklass_nv() const { return _is_ptr_to_narrowklass; } |
923 bool is_ptr_to_boxed_value() const { return _is_ptr_to_boxed_value; } |
954 bool is_ptr_to_boxed_value() const { return _is_ptr_to_boxed_value; } |
924 bool is_known_instance() const { return _instance_id > 0; } |
955 bool is_known_instance() const { return _instance_id > 0; } |
925 int instance_id() const { return _instance_id; } |
956 int instance_id() const { return _instance_id; } |
926 bool is_known_instance_field() const { return is_known_instance() && _offset >= 0; } |
957 bool is_known_instance_field() const { return is_known_instance() && _offset >= 0; } |
927 const TypeOopPtr* speculative() const { return _speculative; } |
958 virtual const TypeOopPtr* speculative() const { return _speculative; } |
928 |
959 |
929 virtual intptr_t get_con() const; |
960 virtual intptr_t get_con() const; |
930 |
961 |
931 virtual const Type *cast_to_ptr_type(PTR ptr) const; |
962 virtual const Type *cast_to_ptr_type(PTR ptr) const; |
932 |
963 |
955 // Return the speculative type if any |
986 // Return the speculative type if any |
956 ciKlass* speculative_type() const { |
987 ciKlass* speculative_type() const { |
957 if (_speculative != NULL) { |
988 if (_speculative != NULL) { |
958 const TypeOopPtr* speculative = _speculative->join(this)->is_oopptr(); |
989 const TypeOopPtr* speculative = _speculative->join(this)->is_oopptr(); |
959 if (speculative->klass_is_exact()) { |
990 if (speculative->klass_is_exact()) { |
960 return speculative->klass(); |
991 return speculative->klass(); |
961 } |
992 } |
962 } |
993 } |
963 return NULL; |
994 return NULL; |
964 } |
995 } |
|
996 int inline_depth() const { |
|
997 return _inline_depth; |
|
998 } |
|
999 virtual const TypeOopPtr* with_inline_depth(int depth) const; |
|
1000 virtual bool would_improve_type(ciKlass* exact_kls, int inline_depth) const; |
965 }; |
1001 }; |
966 |
1002 |
967 //------------------------------TypeInstPtr------------------------------------ |
1003 //------------------------------TypeInstPtr------------------------------------ |
968 // Class of Java object pointers, pointing either to non-array Java instances |
1004 // Class of Java object pointers, pointing either to non-array Java instances |
969 // or to a Klass* (including array klasses). |
1005 // or to a Klass* (including array klasses). |
970 class TypeInstPtr : public TypeOopPtr { |
1006 class TypeInstPtr : public TypeOopPtr { |
971 TypeInstPtr(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id, const TypeOopPtr* speculative); |
1007 TypeInstPtr(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id, const TypeOopPtr* speculative, int inline_depth); |
972 virtual bool eq( const Type *t ) const; |
1008 virtual bool eq( const Type *t ) const; |
973 virtual int hash() const; // Type specific hashing |
1009 virtual int hash() const; // Type specific hashing |
974 |
1010 |
975 ciSymbol* _name; // class name |
1011 ciSymbol* _name; // class name |
976 |
1012 |
1002 static const TypeInstPtr *make(PTR ptr, ciKlass* klass, int offset) { |
1038 static const TypeInstPtr *make(PTR ptr, ciKlass* klass, int offset) { |
1003 return make(ptr, klass, false, NULL, offset, InstanceBot); |
1039 return make(ptr, klass, false, NULL, offset, InstanceBot); |
1004 } |
1040 } |
1005 |
1041 |
1006 // Make a pointer to an oop. |
1042 // Make a pointer to an oop. |
1007 static const TypeInstPtr *make(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id = InstanceBot, const TypeOopPtr* speculative = NULL); |
1043 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); |
1008 |
1044 |
1009 /** Create constant type for a constant boxed value */ |
1045 /** Create constant type for a constant boxed value */ |
1010 const Type* get_const_boxed_value() const; |
1046 const Type* get_const_boxed_value() const; |
1011 |
1047 |
1012 // If this is a java.lang.Class constant, return the type for it or NULL. |
1048 // If this is a java.lang.Class constant, return the type for it or NULL. |
1021 virtual const TypeOopPtr *cast_to_instance_id(int instance_id) const; |
1057 virtual const TypeOopPtr *cast_to_instance_id(int instance_id) const; |
1022 |
1058 |
1023 virtual const TypePtr *add_offset( intptr_t offset ) const; |
1059 virtual const TypePtr *add_offset( intptr_t offset ) const; |
1024 // Return same type without a speculative part |
1060 // Return same type without a speculative part |
1025 virtual const Type* remove_speculative() const; |
1061 virtual const Type* remove_speculative() const; |
|
1062 virtual const TypeOopPtr* with_inline_depth(int depth) const; |
1026 |
1063 |
1027 // the core of the computation of the meet of 2 types |
1064 // the core of the computation of the meet of 2 types |
1028 virtual const Type *xmeet_helper(const Type *t) const; |
1065 virtual const Type *xmeet_helper(const Type *t) const; |
1029 virtual const TypeInstPtr *xmeet_unloaded( const TypeInstPtr *t ) const; |
1066 virtual const TypeInstPtr *xmeet_unloaded( const TypeInstPtr *t ) const; |
1030 virtual const Type *xdual() const; // Compute dual right now. |
1067 virtual const Type *xdual() const; // Compute dual right now. |
1042 |
1079 |
1043 //------------------------------TypeAryPtr------------------------------------- |
1080 //------------------------------TypeAryPtr------------------------------------- |
1044 // Class of Java array pointers |
1081 // Class of Java array pointers |
1045 class TypeAryPtr : public TypeOopPtr { |
1082 class TypeAryPtr : public TypeOopPtr { |
1046 TypeAryPtr( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, |
1083 TypeAryPtr( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, |
1047 int offset, int instance_id, bool is_autobox_cache, const TypeOopPtr* speculative) |
1084 int offset, int instance_id, bool is_autobox_cache, const TypeOopPtr* speculative, int inline_depth) |
1048 : TypeOopPtr(AryPtr,ptr,k,xk,o,offset, instance_id, speculative), |
1085 : TypeOopPtr(AryPtr,ptr,k,xk,o,offset, instance_id, speculative, inline_depth), |
1049 _ary(ary), |
1086 _ary(ary), |
1050 _is_autobox_cache(is_autobox_cache) |
1087 _is_autobox_cache(is_autobox_cache) |
1051 { |
1088 { |
1052 #ifdef ASSERT |
1089 #ifdef ASSERT |
1053 if (k != NULL) { |
1090 if (k != NULL) { |
1081 const TypeInt* size() const { return _ary->_size; } |
1118 const TypeInt* size() const { return _ary->_size; } |
1082 bool is_stable() const { return _ary->_stable; } |
1119 bool is_stable() const { return _ary->_stable; } |
1083 |
1120 |
1084 bool is_autobox_cache() const { return _is_autobox_cache; } |
1121 bool is_autobox_cache() const { return _is_autobox_cache; } |
1085 |
1122 |
1086 static const TypeAryPtr *make( PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot, const TypeOopPtr* speculative = NULL); |
1123 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); |
1087 // Constant pointer to array |
1124 // Constant pointer to array |
1088 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); |
1125 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); |
1089 |
1126 |
1090 // Return a 'ptr' version of this type |
1127 // Return a 'ptr' version of this type |
1091 virtual const Type *cast_to_ptr_type(PTR ptr) const; |
1128 virtual const Type *cast_to_ptr_type(PTR ptr) const; |
1092 |
1129 |
1093 virtual const Type *cast_to_exactness(bool klass_is_exact) const; |
1130 virtual const Type *cast_to_exactness(bool klass_is_exact) const; |
1099 |
1136 |
1100 virtual bool empty(void) const; // TRUE if type is vacuous |
1137 virtual bool empty(void) const; // TRUE if type is vacuous |
1101 virtual const TypePtr *add_offset( intptr_t offset ) const; |
1138 virtual const TypePtr *add_offset( intptr_t offset ) const; |
1102 // Return same type without a speculative part |
1139 // Return same type without a speculative part |
1103 virtual const Type* remove_speculative() const; |
1140 virtual const Type* remove_speculative() const; |
|
1141 virtual const TypeOopPtr* with_inline_depth(int depth) const; |
1104 |
1142 |
1105 // the core of the computation of the meet of 2 types |
1143 // the core of the computation of the meet of 2 types |
1106 virtual const Type *xmeet_helper(const Type *t) const; |
1144 virtual const Type *xmeet_helper(const Type *t) const; |
1107 virtual const Type *xdual() const; // Compute dual right now. |
1145 virtual const Type *xdual() const; // Compute dual right now. |
1108 |
1146 |
1676 // conversions |
1714 // conversions |
1677 #define ConvI2X(x) ConvI2L(x) |
1715 #define ConvI2X(x) ConvI2L(x) |
1678 #define ConvL2X(x) (x) |
1716 #define ConvL2X(x) (x) |
1679 #define ConvX2I(x) ConvL2I(x) |
1717 #define ConvX2I(x) ConvL2I(x) |
1680 #define ConvX2L(x) (x) |
1718 #define ConvX2L(x) (x) |
|
1719 #define ConvX2UL(x) (x) |
1681 |
1720 |
1682 #else |
1721 #else |
1683 |
1722 |
1684 // For type queries and asserts |
1723 // For type queries and asserts |
1685 #define is_intptr_t is_int |
1724 #define is_intptr_t is_int |
1720 // conversions |
1759 // conversions |
1721 #define ConvI2X(x) (x) |
1760 #define ConvI2X(x) (x) |
1722 #define ConvL2X(x) ConvL2I(x) |
1761 #define ConvL2X(x) ConvL2I(x) |
1723 #define ConvX2I(x) (x) |
1762 #define ConvX2I(x) (x) |
1724 #define ConvX2L(x) ConvI2L(x) |
1763 #define ConvX2L(x) ConvI2L(x) |
|
1764 #define ConvX2UL(x) ConvI2UL(x) |
1725 |
1765 |
1726 #endif |
1766 #endif |
1727 |
1767 |
1728 #endif // SHARE_VM_OPTO_TYPE_HPP |
1768 #endif // SHARE_VM_OPTO_TYPE_HPP |