1 /* 2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_VM_OOPS_OOPSHIERARCHY_HPP 26 #define SHARE_VM_OOPS_OOPSHIERARCHY_HPP 27 28 #include "runtime/globals.hpp" 29 #include "utilities/globalDefinitions.hpp" 30 31 // OBJECT hierarchy 32 // This hierarchy is a representation hierarchy, i.e. if A is a superclass 33 // of B, A's representation is a prefix of B's representation. 34 35 typedef juint narrowOop; // Offset instead of address for an oop within a java object 36 37 // If compressed klass pointers then use narrowKlass. 38 typedef juint narrowKlass; 39 40 typedef void* OopOrNarrowOopStar; 41 typedef class markOopDesc* markOop; 42 43 #ifndef CHECK_UNHANDLED_OOPS 44 45 typedef class oopDesc* oop; 46 typedef class instanceOopDesc* instanceOop; 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() 70 // instead, which generates less code anyway. 71 72 class Thread; 73 class PromotedObject; 74 75 76 class oop { 77 oopDesc* _o; 78 79 void register_oop(); 80 void unregister_oop(); 81 82 // friend class markOop; 83 public: 84 void set_obj(const void* p) { 85 raw_set_obj(p); 86 if (CheckUnhandledOops) register_oop(); 87 } 88 void raw_set_obj(const void* p) { _o = (oopDesc*)p; } 89 90 oop() { set_obj(NULL); } 91 oop(const oop& o) { set_obj(o.obj()); } 92 oop(const volatile oop& o) { set_obj(o.obj()); } 93 oop(const void* p) { set_obj(p); } 94 ~oop() { 95 if (CheckUnhandledOops) unregister_oop(); 96 } 97 98 oopDesc* obj() const volatile { return _o; } 99 100 // General access 101 oopDesc* operator->() const { return obj(); } 102 bool operator==(const oop o) const { return obj() == o.obj(); } 103 bool operator==(void *p) const { return obj() == p; } 104 bool operator!=(const volatile oop o) const { return obj() != o.obj(); } 105 bool operator!=(void *p) const { return obj() != p; } 106 107 bool operator<(oop o) const { return obj() < o.obj(); } 108 bool operator>(oop o) const { return obj() > o.obj(); } 109 bool operator<=(oop o) const { return obj() <= o.obj(); } 110 bool operator>=(oop o) const { return obj() >= o.obj(); } 111 bool operator!() const { return !obj(); } 112 113 // Assignment 114 oop& operator=(const oop& o) { _o = o.obj(); return *this; } 115 #ifndef SOLARIS 116 volatile oop& operator=(const oop& o) volatile { _o = o.obj(); return *this; } 117 #endif 118 volatile oop& operator=(const volatile oop& o) volatile { _o = o.obj(); return *this; } 119 120 // Explict user conversions 121 operator void* () const { return (void *)obj(); } 122 #ifndef SOLARIS 123 operator void* () const volatile { return (void *)obj(); } 124 #endif 125 operator HeapWord* () const { return (HeapWord*)obj(); } 126 operator oopDesc* () const { return obj(); } 127 operator intptr_t* () const { return (intptr_t*)obj(); } 128 operator PromotedObject* () const { return (PromotedObject*)obj(); } 129 operator markOop () const { return markOop(obj()); } 130 131 operator address () const { return (address)obj(); } 132 133 // from javaCalls.cpp 134 operator jobject () const { return (jobject)obj(); } 135 // from javaClasses.cpp 136 operator JavaThread* () const { return (JavaThread*)obj(); } 137 138 #ifndef _LP64 139 // from jvm.cpp 140 operator jlong* () const { return (jlong*)obj(); } 141 #endif 142 143 // from parNewGeneration and other things that want to get to the end of 144 // an oop for stuff (like ObjArrayKlass.cpp) 145 operator oop* () const { return (oop *)obj(); } 146 }; 147 148 #define DEF_OOP(type) \ 149 class type##OopDesc; \ 150 class type##Oop : public oop { \ 151 public: \ 152 type##Oop() : oop() {} \ 153 type##Oop(const oop& o) : oop(o) {} \ 154 type##Oop(const volatile oop& o) : oop(o) {} \ 155 type##Oop(const void* p) : oop(p) {} \ 156 operator type##OopDesc* () const { return (type##OopDesc*)obj(); } \ 157 type##OopDesc* operator->() const { \ 158 return (type##OopDesc*)obj(); \ 159 } \ 160 type##Oop& operator=(const type##Oop& o) { \ 161 oop::operator=(o); \ 162 return *this; \ 163 } \ 164 NOT_SOLARIS( \ 165 volatile type##Oop& operator=(const type##Oop& o) volatile { \ 166 (void)const_cast<oop&>(oop::operator=(o)); \ 167 return *this; \ 168 }) \ 169 volatile type##Oop& operator=(const volatile type##Oop& o) volatile {\ 170 (void)const_cast<oop&>(oop::operator=(o)); \ 171 return *this; \ 172 } \ 173 }; 174 175 DEF_OOP(instance); 176 DEF_OOP(array); 177 DEF_OOP(objArray); 178 DEF_OOP(typeArray); 179 180 #endif // CHECK_UNHANDLED_OOPS 181 182 // For CHECK_UNHANDLED_OOPS, it is ambiguous C++ behavior to have the oop 183 // structure contain explicit user defined conversions of both numerical 184 // and pointer type. Define inline methods to provide the numerical conversions. 185 template <class T> inline oop cast_to_oop(T value) { 186 return (oop)(CHECK_UNHANDLED_OOPS_ONLY((void *))(value)); 187 } 188 template <class T> inline T cast_from_oop(oop o) { 189 return (T)(CHECK_UNHANDLED_OOPS_ONLY((void*))o); 190 } 191 192 // The metadata hierarchy is separate from the oop hierarchy 193 194 // class MetaspaceObj 195 class ConstMethod; 196 class ConstantPoolCache; 197 class MethodData; 198 // class Metadata 199 class Method; 200 class ConstantPool; 201 // class CHeapObj 202 class CompiledICHolder; 203 204 205 // The klass hierarchy is separate from the oop hierarchy. 206 207 class Klass; 208 class InstanceKlass; 209 class InstanceMirrorKlass; 210 class InstanceClassLoaderKlass; 211 class InstanceRefKlass; 212 class ArrayKlass; 213 class ObjArrayKlass; 214 class TypeArrayKlass; 215 216 #endif // SHARE_VM_OOPS_OOPSHIERARCHY_HPP