156 // join to ensure my lattice is symmetric up and down. Dual is computed |
156 // join to ensure my lattice is symmetric up and down. Dual is computed |
157 // lazily, on demand, and cached in _dual. |
157 // lazily, on demand, and cached in _dual. |
158 const Type *_dual; // Cached dual value |
158 const Type *_dual; // Cached dual value |
159 // Table for efficient dualing of base types |
159 // Table for efficient dualing of base types |
160 static const TYPES dual_type[lastype]; |
160 static const TYPES dual_type[lastype]; |
|
161 |
|
162 #ifdef ASSERT |
|
163 // One type is interface, the other is oop |
|
164 virtual bool interface_vs_oop_helper(const Type *t) const; |
|
165 #endif |
161 |
166 |
162 protected: |
167 protected: |
163 // Each class of type is also identified by its base. |
168 // Each class of type is also identified by its base. |
164 const TYPES _base; // Enum of Types type |
169 const TYPES _base; // Enum of Types type |
165 |
170 |
374 |
379 |
375 static const Type* make_from_constant(ciConstant constant, |
380 static const Type* make_from_constant(ciConstant constant, |
376 bool require_constant = false, |
381 bool require_constant = false, |
377 bool is_autobox_cache = false); |
382 bool is_autobox_cache = false); |
378 |
383 |
|
384 // Speculative type. See TypeInstPtr |
|
385 virtual ciKlass* speculative_type() const { return NULL; } |
|
386 |
379 private: |
387 private: |
380 // support arrays |
388 // support arrays |
381 static const BasicType _basic_type[]; |
389 static const BasicType _basic_type[]; |
382 static const Type* _zero_type[T_CONFLICT+1]; |
390 static const Type* _zero_type[T_CONFLICT+1]; |
383 static const Type* _const_basic_type[T_CONFLICT+1]; |
391 static const Type* _const_basic_type[T_CONFLICT+1]; |
782 |
790 |
783 //------------------------------TypeOopPtr------------------------------------- |
791 //------------------------------TypeOopPtr------------------------------------- |
784 // Some kind of oop (Java pointer), either klass or instance or array. |
792 // Some kind of oop (Java pointer), either klass or instance or array. |
785 class TypeOopPtr : public TypePtr { |
793 class TypeOopPtr : public TypePtr { |
786 protected: |
794 protected: |
787 TypeOopPtr( TYPES t, PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id ); |
795 TypeOopPtr(TYPES t, PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id, const TypeOopPtr* speculative); |
788 public: |
796 public: |
789 virtual bool eq( const Type *t ) const; |
797 virtual bool eq( const Type *t ) const; |
790 virtual int hash() const; // Type specific hashing |
798 virtual int hash() const; // Type specific hashing |
791 virtual bool singleton(void) const; // TRUE if type is a singleton |
799 virtual bool singleton(void) const; // TRUE if type is a singleton |
792 enum { |
800 enum { |
808 // If not InstanceTop or InstanceBot, indicates that this is |
816 // If not InstanceTop or InstanceBot, indicates that this is |
809 // a particular instance of this type which is distinct. |
817 // a particular instance of this type which is distinct. |
810 // This is the the node index of the allocation node creating this instance. |
818 // This is the the node index of the allocation node creating this instance. |
811 int _instance_id; |
819 int _instance_id; |
812 |
820 |
|
821 // Extra type information profiling gave us. We propagate it the |
|
822 // same way the rest of the type info is propagated. If we want to |
|
823 // use it, then we have to emit a guard: this part of the type is |
|
824 // not something we know but something we speculate about the type. |
|
825 const TypeOopPtr* _speculative; |
|
826 |
813 static const TypeOopPtr* make_from_klass_common(ciKlass* klass, bool klass_change, bool try_for_exact); |
827 static const TypeOopPtr* make_from_klass_common(ciKlass* klass, bool klass_change, bool try_for_exact); |
814 |
828 |
815 int dual_instance_id() const; |
829 int dual_instance_id() const; |
816 int meet_instance_id(int uid) const; |
830 int meet_instance_id(int uid) const; |
|
831 |
|
832 // utility methods to work on the speculative part of the type |
|
833 const TypeOopPtr* dual_speculative() const; |
|
834 const TypeOopPtr* meet_speculative(const TypeOopPtr* other) const; |
|
835 bool eq_speculative(const TypeOopPtr* other) const; |
|
836 int hash_speculative() const; |
|
837 const TypeOopPtr* add_offset_speculative(intptr_t offset) const; |
|
838 #ifndef PRODUCT |
|
839 void dump_speculative(outputStream *st) const; |
|
840 #endif |
817 |
841 |
818 public: |
842 public: |
819 // Creates a type given a klass. Correctly handles multi-dimensional arrays |
843 // Creates a type given a klass. Correctly handles multi-dimensional arrays |
820 // Respects UseUniqueSubclasses. |
844 // Respects UseUniqueSubclasses. |
821 // If the klass is final, the resulting type will be exact. |
845 // If the klass is final, the resulting type will be exact. |
839 static const TypeOopPtr* make_from_constant(ciObject* o, |
863 static const TypeOopPtr* make_from_constant(ciObject* o, |
840 bool require_constant = false, |
864 bool require_constant = false, |
841 bool not_null_elements = false); |
865 bool not_null_elements = false); |
842 |
866 |
843 // Make a generic (unclassed) pointer to an oop. |
867 // Make a generic (unclassed) pointer to an oop. |
844 static const TypeOopPtr* make(PTR ptr, int offset, int instance_id); |
868 static const TypeOopPtr* make(PTR ptr, int offset, int instance_id, const TypeOopPtr* speculative); |
845 |
869 |
846 ciObject* const_oop() const { return _const_oop; } |
870 ciObject* const_oop() const { return _const_oop; } |
847 virtual ciKlass* klass() const { return _klass; } |
871 virtual ciKlass* klass() const { return _klass; } |
848 bool klass_is_exact() const { return _klass_is_exact; } |
872 bool klass_is_exact() const { return _klass_is_exact; } |
849 |
873 |
853 bool is_ptr_to_narrowklass_nv() const { return _is_ptr_to_narrowklass; } |
877 bool is_ptr_to_narrowklass_nv() const { return _is_ptr_to_narrowklass; } |
854 bool is_ptr_to_boxed_value() const { return _is_ptr_to_boxed_value; } |
878 bool is_ptr_to_boxed_value() const { return _is_ptr_to_boxed_value; } |
855 bool is_known_instance() const { return _instance_id > 0; } |
879 bool is_known_instance() const { return _instance_id > 0; } |
856 int instance_id() const { return _instance_id; } |
880 int instance_id() const { return _instance_id; } |
857 bool is_known_instance_field() const { return is_known_instance() && _offset >= 0; } |
881 bool is_known_instance_field() const { return is_known_instance() && _offset >= 0; } |
|
882 const TypeOopPtr* speculative() const { return _speculative; } |
858 |
883 |
859 virtual intptr_t get_con() const; |
884 virtual intptr_t get_con() const; |
860 |
885 |
861 virtual const Type *cast_to_ptr_type(PTR ptr) const; |
886 virtual const Type *cast_to_ptr_type(PTR ptr) const; |
862 |
887 |
866 |
891 |
867 // corresponding pointer to klass, for a given instance |
892 // corresponding pointer to klass, for a given instance |
868 const TypeKlassPtr* as_klass_type() const; |
893 const TypeKlassPtr* as_klass_type() const; |
869 |
894 |
870 virtual const TypePtr *add_offset( intptr_t offset ) const; |
895 virtual const TypePtr *add_offset( intptr_t offset ) const; |
871 |
896 // Return same type without a speculative part |
872 virtual const Type *xmeet( const Type *t ) const; |
897 virtual const TypeOopPtr* remove_speculative() const; |
|
898 |
|
899 virtual const Type *xmeet(const Type *t) const; |
873 virtual const Type *xdual() const; // Compute dual right now. |
900 virtual const Type *xdual() const; // Compute dual right now. |
|
901 // the core of the computation of the meet for TypeOopPtr and for its subclasses |
|
902 virtual const Type *xmeet_helper(const Type *t) const; |
874 |
903 |
875 // Do not allow interface-vs.-noninterface joins to collapse to top. |
904 // Do not allow interface-vs.-noninterface joins to collapse to top. |
876 virtual const Type *filter( const Type *kills ) const; |
905 virtual const Type *filter( const Type *kills ) const; |
877 |
906 |
878 // Convenience common pre-built type. |
907 // Convenience common pre-built type. |
879 static const TypeOopPtr *BOTTOM; |
908 static const TypeOopPtr *BOTTOM; |
880 #ifndef PRODUCT |
909 #ifndef PRODUCT |
881 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; |
910 virtual void dump2( Dict &d, uint depth, outputStream *st ) const; |
882 #endif |
911 #endif |
|
912 |
|
913 // Return the speculative type if any |
|
914 ciKlass* speculative_type() const { |
|
915 if (_speculative != NULL) { |
|
916 const TypeOopPtr* speculative = _speculative->join(this)->is_oopptr(); |
|
917 if (speculative->klass_is_exact()) { |
|
918 return speculative->klass(); |
|
919 } |
|
920 } |
|
921 return NULL; |
|
922 } |
883 }; |
923 }; |
884 |
924 |
885 //------------------------------TypeInstPtr------------------------------------ |
925 //------------------------------TypeInstPtr------------------------------------ |
886 // Class of Java object pointers, pointing either to non-array Java instances |
926 // Class of Java object pointers, pointing either to non-array Java instances |
887 // or to a Klass* (including array klasses). |
927 // or to a Klass* (including array klasses). |
888 class TypeInstPtr : public TypeOopPtr { |
928 class TypeInstPtr : public TypeOopPtr { |
889 TypeInstPtr( PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id ); |
929 TypeInstPtr(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id, const TypeOopPtr* speculative); |
890 virtual bool eq( const Type *t ) const; |
930 virtual bool eq( const Type *t ) const; |
891 virtual int hash() const; // Type specific hashing |
931 virtual int hash() const; // Type specific hashing |
892 |
932 |
893 ciSymbol* _name; // class name |
933 ciSymbol* _name; // class name |
894 |
934 |
897 |
937 |
898 bool is_loaded() const { return _klass->is_loaded(); } |
938 bool is_loaded() const { return _klass->is_loaded(); } |
899 |
939 |
900 // Make a pointer to a constant oop. |
940 // Make a pointer to a constant oop. |
901 static const TypeInstPtr *make(ciObject* o) { |
941 static const TypeInstPtr *make(ciObject* o) { |
902 return make(TypePtr::Constant, o->klass(), true, o, 0); |
942 return make(TypePtr::Constant, o->klass(), true, o, 0, InstanceBot); |
903 } |
943 } |
904 // Make a pointer to a constant oop with offset. |
944 // Make a pointer to a constant oop with offset. |
905 static const TypeInstPtr *make(ciObject* o, int offset) { |
945 static const TypeInstPtr *make(ciObject* o, int offset) { |
906 return make(TypePtr::Constant, o->klass(), true, o, offset); |
946 return make(TypePtr::Constant, o->klass(), true, o, offset, InstanceBot); |
907 } |
947 } |
908 |
948 |
909 // Make a pointer to some value of type klass. |
949 // Make a pointer to some value of type klass. |
910 static const TypeInstPtr *make(PTR ptr, ciKlass* klass) { |
950 static const TypeInstPtr *make(PTR ptr, ciKlass* klass) { |
911 return make(ptr, klass, false, NULL, 0); |
951 return make(ptr, klass, false, NULL, 0, InstanceBot); |
912 } |
952 } |
913 |
953 |
914 // Make a pointer to some non-polymorphic value of exactly type klass. |
954 // Make a pointer to some non-polymorphic value of exactly type klass. |
915 static const TypeInstPtr *make_exact(PTR ptr, ciKlass* klass) { |
955 static const TypeInstPtr *make_exact(PTR ptr, ciKlass* klass) { |
916 return make(ptr, klass, true, NULL, 0); |
956 return make(ptr, klass, true, NULL, 0, InstanceBot); |
917 } |
957 } |
918 |
958 |
919 // Make a pointer to some value of type klass with offset. |
959 // Make a pointer to some value of type klass with offset. |
920 static const TypeInstPtr *make(PTR ptr, ciKlass* klass, int offset) { |
960 static const TypeInstPtr *make(PTR ptr, ciKlass* klass, int offset) { |
921 return make(ptr, klass, false, NULL, offset); |
961 return make(ptr, klass, false, NULL, offset, InstanceBot); |
922 } |
962 } |
923 |
963 |
924 // Make a pointer to an oop. |
964 // Make a pointer to an oop. |
925 static const TypeInstPtr *make(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id = InstanceBot ); |
965 static const TypeInstPtr *make(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id = InstanceBot, const TypeOopPtr* speculative = NULL); |
926 |
966 |
927 /** Create constant type for a constant boxed value */ |
967 /** Create constant type for a constant boxed value */ |
928 const Type* get_const_boxed_value() const; |
968 const Type* get_const_boxed_value() const; |
929 |
969 |
930 // If this is a java.lang.Class constant, return the type for it or NULL. |
970 // If this is a java.lang.Class constant, return the type for it or NULL. |
937 virtual const Type *cast_to_exactness(bool klass_is_exact) const; |
977 virtual const Type *cast_to_exactness(bool klass_is_exact) const; |
938 |
978 |
939 virtual const TypeOopPtr *cast_to_instance_id(int instance_id) const; |
979 virtual const TypeOopPtr *cast_to_instance_id(int instance_id) const; |
940 |
980 |
941 virtual const TypePtr *add_offset( intptr_t offset ) const; |
981 virtual const TypePtr *add_offset( intptr_t offset ) const; |
942 |
982 // Return same type without a speculative part |
943 virtual const Type *xmeet( const Type *t ) const; |
983 virtual const TypeOopPtr* remove_speculative() const; |
|
984 |
|
985 // the core of the computation of the meet of 2 types |
|
986 virtual const Type *xmeet_helper(const Type *t) const; |
944 virtual const TypeInstPtr *xmeet_unloaded( const TypeInstPtr *t ) const; |
987 virtual const TypeInstPtr *xmeet_unloaded( const TypeInstPtr *t ) const; |
945 virtual const Type *xdual() const; // Compute dual right now. |
988 virtual const Type *xdual() const; // Compute dual right now. |
946 |
989 |
947 // Convenience common pre-built types. |
990 // Convenience common pre-built types. |
948 static const TypeInstPtr *NOTNULL; |
991 static const TypeInstPtr *NOTNULL; |
957 |
1000 |
958 //------------------------------TypeAryPtr------------------------------------- |
1001 //------------------------------TypeAryPtr------------------------------------- |
959 // Class of Java array pointers |
1002 // Class of Java array pointers |
960 class TypeAryPtr : public TypeOopPtr { |
1003 class TypeAryPtr : public TypeOopPtr { |
961 TypeAryPtr( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, |
1004 TypeAryPtr( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, |
962 int offset, int instance_id, bool is_autobox_cache ) |
1005 int offset, int instance_id, bool is_autobox_cache, const TypeOopPtr* speculative) |
963 : TypeOopPtr(AryPtr,ptr,k,xk,o,offset, instance_id), |
1006 : TypeOopPtr(AryPtr,ptr,k,xk,o,offset, instance_id, speculative), |
964 _ary(ary), |
1007 _ary(ary), |
965 _is_autobox_cache(is_autobox_cache) |
1008 _is_autobox_cache(is_autobox_cache) |
966 { |
1009 { |
967 #ifdef ASSERT |
1010 #ifdef ASSERT |
968 if (k != NULL) { |
1011 if (k != NULL) { |
996 const TypeInt* size() const { return _ary->_size; } |
1039 const TypeInt* size() const { return _ary->_size; } |
997 bool is_stable() const { return _ary->_stable; } |
1040 bool is_stable() const { return _ary->_stable; } |
998 |
1041 |
999 bool is_autobox_cache() const { return _is_autobox_cache; } |
1042 bool is_autobox_cache() const { return _is_autobox_cache; } |
1000 |
1043 |
1001 static const TypeAryPtr *make( PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot); |
1044 static const TypeAryPtr *make( PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot, const TypeOopPtr* speculative = NULL); |
1002 // Constant pointer to array |
1045 // Constant pointer to array |
1003 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); |
1046 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); |
1004 |
1047 |
1005 // Return a 'ptr' version of this type |
1048 // Return a 'ptr' version of this type |
1006 virtual const Type *cast_to_ptr_type(PTR ptr) const; |
1049 virtual const Type *cast_to_ptr_type(PTR ptr) const; |
1007 |
1050 |
1008 virtual const Type *cast_to_exactness(bool klass_is_exact) const; |
1051 virtual const Type *cast_to_exactness(bool klass_is_exact) const; |
1012 virtual const TypeAryPtr* cast_to_size(const TypeInt* size) const; |
1055 virtual const TypeAryPtr* cast_to_size(const TypeInt* size) const; |
1013 virtual const TypeInt* narrow_size_type(const TypeInt* size) const; |
1056 virtual const TypeInt* narrow_size_type(const TypeInt* size) const; |
1014 |
1057 |
1015 virtual bool empty(void) const; // TRUE if type is vacuous |
1058 virtual bool empty(void) const; // TRUE if type is vacuous |
1016 virtual const TypePtr *add_offset( intptr_t offset ) const; |
1059 virtual const TypePtr *add_offset( intptr_t offset ) const; |
1017 |
1060 // Return same type without a speculative part |
1018 virtual const Type *xmeet( const Type *t ) const; |
1061 virtual const TypeOopPtr* remove_speculative() const; |
|
1062 |
|
1063 // the core of the computation of the meet of 2 types |
|
1064 virtual const Type *xmeet_helper(const Type *t) const; |
1019 virtual const Type *xdual() const; // Compute dual right now. |
1065 virtual const Type *xdual() const; // Compute dual right now. |
1020 |
1066 |
1021 const TypeAryPtr* cast_to_stable(bool stable, int stable_dimension = 1) const; |
1067 const TypeAryPtr* cast_to_stable(bool stable, int stable_dimension = 1) const; |
1022 int stable_dimension() const; |
1068 int stable_dimension() const; |
1023 |
1069 |