1 /* 2 * Copyright (c) 1997, 2014, 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 volatile oop& operator=(const oop& o) volatile { _o = o.obj(); return *this; } 116 volatile oop& operator=(const volatile oop& o) volatile { _o = o.obj(); return *this; } 117 118 // Explict user conversions 119 operator void* () const { return (void *)obj(); } 120 #ifndef SOLARIS 121 operator void* () const volatile { return (void *)obj(); } 122 #endif 123 operator HeapWord* () const { return (HeapWord*)obj(); } 124 operator oopDesc* () const volatile { return obj(); } 125 operator intptr_t* () const { return (intptr_t*)obj(); } 126 operator PromotedObject* () const { return (PromotedObject*)obj(); } 127 operator markOop () const volatile { return markOop(obj()); } 128 operator address () const { return (address)obj(); } 129 130 // from javaCalls.cpp 131 operator jobject () const { return (jobject)obj(); } 132 // from javaClasses.cpp 133 operator JavaThread* () const { return (JavaThread*)obj(); } 134 135 #ifndef _LP64 136 // from jvm.cpp 137 operator jlong* () const { return (jlong*)obj(); } 138 #endif 139 140 // from parNewGeneration and other things that want to get to the end of 141 // an oop for stuff (like ObjArrayKlass.cpp) 142 operator oop* () const { return (oop *)obj(); } 143 }; 144 145 #define DEF_OOP(type) \ 146 class type##OopDesc; \ 147 class type##Oop : public oop { \ 148 public: \ 149 type##Oop() : oop() {} \ 150 type##Oop(const oop& o) : oop(o) {} \ 151 type##Oop(const volatile oop& o) : oop(o) {} \ 152 type##Oop(const void* p) : oop(p) {} \ 153 operator type##OopDesc* () const { return (type##OopDesc*)obj(); } \ 154 type##OopDesc* operator->() const { \ 155 return (type##OopDesc*)obj(); \ 156 } \ 157 type##Oop& operator=(const type##Oop& o) { \ 158 oop::operator=(o); \ 159 return *this; \ 160 } \ 161 volatile type##Oop& operator=(const type##Oop& o) volatile { \ 162 (void)const_cast<oop&>(oop::operator=(o)); \ 163 return *this; \ 164 } \ 165 volatile type##Oop& operator=(const volatile type##Oop& o) volatile {\ 166 (void)const_cast<oop&>(oop::operator=(o)); \ 167 return *this; \ 168 } \ 169 }; 170 171 DEF_OOP(instance); 172 DEF_OOP(array); 173 DEF_OOP(objArray); 174 DEF_OOP(typeArray); 175 176 #endif // CHECK_UNHANDLED_OOPS 177 178 // For CHECK_UNHANDLED_OOPS, it is ambiguous C++ behavior to have the oop 179 // structure contain explicit user defined conversions of both numerical 180 // and pointer type. Define inline methods to provide the numerical conversions. 181 template <class T> inline oop cast_to_oop(T value) { 182 return (oop)(CHECK_UNHANDLED_OOPS_ONLY((void *))(value)); 183 } 184 template <class T> inline T cast_from_oop(oop o) { 185 return (T)(CHECK_UNHANDLED_OOPS_ONLY((void*))o); 186 } 187 188 // The metadata hierarchy is separate from the oop hierarchy 189 190 // class MetaspaceObj 191 class ConstMethod; 192 class ConstantPoolCache; 193 class MethodData; 194 // class Metadata 195 class Method; 196 class ConstantPool; 197 // class CHeapObj 198 class CompiledICHolder; 199 200 201 // The klass hierarchy is separate from the oop hierarchy. 202 203 class Klass; 204 class InstanceKlass; 205 class InstanceMirrorKlass; 206 class InstanceClassLoaderKlass; 207 class InstanceRefKlass; 208 class ArrayKlass; 209 class ObjArrayKlass; 210 class TypeArrayKlass; 211 212 #endif // SHARE_VM_OOPS_OOPSHIERARCHY_HPP