30
31 #include <type_traits>
32
33 // OBJECT hierarchy
34 // This hierarchy is a representation hierarchy, i.e. if A is a superclass
35 // of B, A's representation is a prefix of B's representation.
36
37 // Global offset instead of address for an oop within a java object.
38 enum class narrowOop : uint32_t { null = 0 };
39
40 typedef void* OopOrNarrowOopStar;
41
42 #ifndef CHECK_UNHANDLED_OOPS
43
44 typedef class oopDesc* oop;
45 typedef class instanceOopDesc* instanceOop;
46 typedef class stackChunkOopDesc* stackChunkOop;
47 typedef class arrayOopDesc* arrayOop;
48 typedef class objArrayOopDesc* objArrayOop;
49 typedef class typeArrayOopDesc* typeArrayOop;
50
51 #else
52
53 // When CHECK_UNHANDLED_OOPS is defined, an "oop" is a class with a
54 // carefully chosen set of constructors and conversion operators to go
55 // to and from the underlying oopDesc pointer type.
56 //
57 // Because oop and its subclasses <type>Oop are class types, arbitrary
58 // conversions are not accepted by the compiler. Applying a cast to
59 // an oop will cause the best matched conversion operator to be
60 // invoked returning the underlying oopDesc* type if appropriate.
61 // No copy constructors, explicit user conversions or operators of
62 // numerical type should be defined within the oop class. Most C++
63 // compilers will issue a compile time error concerning the overloading
64 // ambiguity between operators of numerical and pointer types. If
65 // a conversion to or from an oop to a numerical type is needed,
66 // use the inline template methods, cast_*_oop, defined below.
67 //
68 // Converting null to oop to Handle implicit is no longer accepted by the
69 // compiler because there are too many steps in the conversion. Use Handle()
138 type##Oop& operator=(const type##Oop& o) { \
139 oop::operator=(o); \
140 return *this; \
141 } \
142 }; \
143 \
144 template<> \
145 struct PrimitiveConversions::Translate<type##Oop> : public std::true_type { \
146 typedef type##Oop Value; \
147 typedef type##OopDesc* Decayed; \
148 \
149 static Decayed decay(Value x) { return (type##OopDesc*)x.obj(); } \
150 static Value recover(Decayed x) { return type##Oop(x); } \
151 };
152
153 DEF_OOP(instance);
154 DEF_OOP(stackChunk);
155 DEF_OOP(array);
156 DEF_OOP(objArray);
157 DEF_OOP(typeArray);
158
159 #endif // CHECK_UNHANDLED_OOPS
160
161 // Cast functions to convert to and from oops.
162 template <typename T> inline oop cast_to_oop(T value) {
163 return (oopDesc*)value;
164 }
165 template <typename T> inline T cast_from_oop(oop o) {
166 return (T)(CHECK_UNHANDLED_OOPS_ONLY((oopDesc*))o);
167 }
168
169 inline intptr_t p2i(narrowOop o) {
170 return static_cast<intptr_t>(o);
171 }
172
173 // The metadata hierarchy is separate from the oop hierarchy
174
175 // class MetaspaceObj
176 class ConstMethod;
177 class ConstantPoolCache;
178 class MethodData;
179 // class Metadata
180 class Method;
181 class ConstantPool;
182
183 // The klass hierarchy is separate from the oop hierarchy.
184
185 class Klass;
186 class InstanceKlass;
187 class InstanceMirrorKlass;
188 class InstanceClassLoaderKlass;
189 class InstanceRefKlass;
190 class InstanceStackChunkKlass;
191 class ArrayKlass;
192 class ObjArrayKlass;
193 class TypeArrayKlass;
194
195 #endif // SHARE_OOPS_OOPSHIERARCHY_HPP
|
30
31 #include <type_traits>
32
33 // OBJECT hierarchy
34 // This hierarchy is a representation hierarchy, i.e. if A is a superclass
35 // of B, A's representation is a prefix of B's representation.
36
37 // Global offset instead of address for an oop within a java object.
38 enum class narrowOop : uint32_t { null = 0 };
39
40 typedef void* OopOrNarrowOopStar;
41
42 #ifndef CHECK_UNHANDLED_OOPS
43
44 typedef class oopDesc* oop;
45 typedef class instanceOopDesc* instanceOop;
46 typedef class stackChunkOopDesc* stackChunkOop;
47 typedef class arrayOopDesc* arrayOop;
48 typedef class objArrayOopDesc* objArrayOop;
49 typedef class typeArrayOopDesc* typeArrayOop;
50 typedef class flatArrayOopDesc* flatArrayOop;
51 typedef class refArrayOopDesc* refArrayOop;
52
53 #else
54
55 // When CHECK_UNHANDLED_OOPS is defined, an "oop" is a class with a
56 // carefully chosen set of constructors and conversion operators to go
57 // to and from the underlying oopDesc pointer type.
58 //
59 // Because oop and its subclasses <type>Oop are class types, arbitrary
60 // conversions are not accepted by the compiler. Applying a cast to
61 // an oop will cause the best matched conversion operator to be
62 // invoked returning the underlying oopDesc* type if appropriate.
63 // No copy constructors, explicit user conversions or operators of
64 // numerical type should be defined within the oop class. Most C++
65 // compilers will issue a compile time error concerning the overloading
66 // ambiguity between operators of numerical and pointer types. If
67 // a conversion to or from an oop to a numerical type is needed,
68 // use the inline template methods, cast_*_oop, defined below.
69 //
70 // Converting null to oop to Handle implicit is no longer accepted by the
71 // compiler because there are too many steps in the conversion. Use Handle()
140 type##Oop& operator=(const type##Oop& o) { \
141 oop::operator=(o); \
142 return *this; \
143 } \
144 }; \
145 \
146 template<> \
147 struct PrimitiveConversions::Translate<type##Oop> : public std::true_type { \
148 typedef type##Oop Value; \
149 typedef type##OopDesc* Decayed; \
150 \
151 static Decayed decay(Value x) { return (type##OopDesc*)x.obj(); } \
152 static Value recover(Decayed x) { return type##Oop(x); } \
153 };
154
155 DEF_OOP(instance);
156 DEF_OOP(stackChunk);
157 DEF_OOP(array);
158 DEF_OOP(objArray);
159 DEF_OOP(typeArray);
160 DEF_OOP(flatArray);
161 DEF_OOP(refArray);
162
163 #endif // CHECK_UNHANDLED_OOPS
164
165 // Cast functions to convert to and from oops.
166 template <typename T> inline oop cast_to_oop(T value) {
167 return (oopDesc*)value;
168 }
169 template <typename T> inline T cast_from_oop(oop o) {
170 return (T)(CHECK_UNHANDLED_OOPS_ONLY((oopDesc*))o);
171 }
172
173 inline intptr_t p2i(narrowOop o) {
174 return static_cast<intptr_t>(o);
175 }
176
177 // The metadata hierarchy is separate from the oop hierarchy
178
179 // class MetaspaceObj
180 class ConstMethod;
181 class ConstantPoolCache;
182 class MethodData;
183 // class Metadata
184 class Method;
185 class ConstantPool;
186
187 // The klass hierarchy is separate from the oop hierarchy.
188
189 class Klass;
190 class InstanceKlass;
191 class InlineKlass;
192 class InstanceMirrorKlass;
193 class InstanceClassLoaderKlass;
194 class InstanceRefKlass;
195 class InstanceStackChunkKlass;
196 class ArrayKlass;
197 class ObjArrayKlass;
198 class TypeArrayKlass;
199 class FlatArrayKlass;
200
201 #endif // SHARE_OOPS_OOPSHIERARCHY_HPP
|