Sat, 01 Dec 2007 00:00:00 +0000
Initial load
duke@435 | 1 | /* |
duke@435 | 2 | * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved. |
duke@435 | 3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
duke@435 | 4 | * |
duke@435 | 5 | * This code is free software; you can redistribute it and/or modify it |
duke@435 | 6 | * under the terms of the GNU General Public License version 2 only, as |
duke@435 | 7 | * published by the Free Software Foundation. |
duke@435 | 8 | * |
duke@435 | 9 | * This code is distributed in the hope that it will be useful, but WITHOUT |
duke@435 | 10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
duke@435 | 11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
duke@435 | 12 | * version 2 for more details (a copy is included in the LICENSE file that |
duke@435 | 13 | * accompanied this code). |
duke@435 | 14 | * |
duke@435 | 15 | * You should have received a copy of the GNU General Public License version |
duke@435 | 16 | * 2 along with this work; if not, write to the Free Software Foundation, |
duke@435 | 17 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
duke@435 | 18 | * |
duke@435 | 19 | * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
duke@435 | 20 | * CA 95054 USA or visit www.sun.com if you need additional information or |
duke@435 | 21 | * have any questions. |
duke@435 | 22 | * |
duke@435 | 23 | */ |
duke@435 | 24 | |
duke@435 | 25 | // OBJECT hierarchy |
duke@435 | 26 | // This hierarchy is a representation hierarchy, i.e. if A is a superclass |
duke@435 | 27 | // of B, A's representation is a prefix of B's representation. |
duke@435 | 28 | |
duke@435 | 29 | #ifndef CHECK_UNHANDLED_OOPS |
duke@435 | 30 | |
duke@435 | 31 | typedef class oopDesc* oop; |
duke@435 | 32 | typedef class instanceOopDesc* instanceOop; |
duke@435 | 33 | typedef class methodOopDesc* methodOop; |
duke@435 | 34 | typedef class constMethodOopDesc* constMethodOop; |
duke@435 | 35 | typedef class methodDataOopDesc* methodDataOop; |
duke@435 | 36 | typedef class arrayOopDesc* arrayOop; |
duke@435 | 37 | typedef class constantPoolOopDesc* constantPoolOop; |
duke@435 | 38 | typedef class constantPoolCacheOopDesc* constantPoolCacheOop; |
duke@435 | 39 | typedef class objArrayOopDesc* objArrayOop; |
duke@435 | 40 | typedef class typeArrayOopDesc* typeArrayOop; |
duke@435 | 41 | typedef class symbolOopDesc* symbolOop; |
duke@435 | 42 | typedef class klassOopDesc* klassOop; |
duke@435 | 43 | typedef class markOopDesc* markOop; |
duke@435 | 44 | typedef class compiledICHolderOopDesc* compiledICHolderOop; |
duke@435 | 45 | |
duke@435 | 46 | #else |
duke@435 | 47 | |
duke@435 | 48 | |
duke@435 | 49 | // When CHECK_UNHANDLED_OOPS is defined, an "oop" is a class with a |
duke@435 | 50 | // carefully chosen set of constructors and conversion operators to go |
duke@435 | 51 | // to and from the underlying oopDesc pointer type. |
duke@435 | 52 | // |
duke@435 | 53 | // Because oop and its subclasses <type>Oop are class types, arbitrary |
duke@435 | 54 | // conversions are not accepted by the compiler, and you may get a message |
duke@435 | 55 | // about overloading ambiguity (between long and int is common when converting |
duke@435 | 56 | // from a constant in 64 bit mode), or unable to convert from type to 'oop'. |
duke@435 | 57 | // Applying a cast to one of these conversion operators first will get to the |
duke@435 | 58 | // underlying oopDesc* type if appropriate. |
duke@435 | 59 | // Converting NULL to oop to Handle implicit is no longer accepted by the |
duke@435 | 60 | // compiler because there are too many steps in the conversion. Use Handle() |
duke@435 | 61 | // instead, which generates less code anyway. |
duke@435 | 62 | |
duke@435 | 63 | class Thread; |
duke@435 | 64 | typedef class markOopDesc* markOop; |
duke@435 | 65 | class PromotedObject; |
duke@435 | 66 | |
duke@435 | 67 | |
duke@435 | 68 | class oop { |
duke@435 | 69 | oopDesc* _o; |
duke@435 | 70 | |
duke@435 | 71 | void register_oop(); |
duke@435 | 72 | void unregister_oop(); |
duke@435 | 73 | |
duke@435 | 74 | // friend class markOop; |
duke@435 | 75 | public: |
duke@435 | 76 | void set_obj(const void* p) { |
duke@435 | 77 | raw_set_obj(p); |
duke@435 | 78 | if (CheckUnhandledOops) register_oop(); |
duke@435 | 79 | } |
duke@435 | 80 | void raw_set_obj(const void* p) { _o = (oopDesc*)p; } |
duke@435 | 81 | |
duke@435 | 82 | oop() { set_obj(NULL); } |
duke@435 | 83 | oop(const volatile oop& o) { set_obj(o.obj()); } |
duke@435 | 84 | oop(const void* p) { set_obj(p); } |
duke@435 | 85 | oop(intptr_t i) { set_obj((void *)i); } |
duke@435 | 86 | #ifdef _LP64 |
duke@435 | 87 | oop(int i) { set_obj((void *)i); } |
duke@435 | 88 | #endif |
duke@435 | 89 | ~oop() { |
duke@435 | 90 | if (CheckUnhandledOops) unregister_oop(); |
duke@435 | 91 | } |
duke@435 | 92 | |
duke@435 | 93 | oopDesc* obj() const volatile { return _o; } |
duke@435 | 94 | |
duke@435 | 95 | // General access |
duke@435 | 96 | oopDesc* operator->() const { return obj(); } |
duke@435 | 97 | bool operator==(const oop o) const { return obj() == o.obj(); } |
duke@435 | 98 | bool operator==(void *p) const { return obj() == p; } |
duke@435 | 99 | bool operator!=(const oop o) const { return obj() != o.obj(); } |
duke@435 | 100 | bool operator!=(void *p) const { return obj() != p; } |
duke@435 | 101 | bool operator==(intptr_t p) const { return obj() == (oopDesc*)p; } |
duke@435 | 102 | bool operator!=(intptr_t p) const { return obj() != (oopDesc*)p; } |
duke@435 | 103 | |
duke@435 | 104 | bool operator<(oop o) const { return obj() < o.obj(); } |
duke@435 | 105 | bool operator>(oop o) const { return obj() > o.obj(); } |
duke@435 | 106 | bool operator<=(oop o) const { return obj() <= o.obj(); } |
duke@435 | 107 | bool operator>=(oop o) const { return obj() >= o.obj(); } |
duke@435 | 108 | bool operator!() const { return !obj(); } |
duke@435 | 109 | |
duke@435 | 110 | // Cast |
duke@435 | 111 | operator void* () const { return (void *)obj(); } |
duke@435 | 112 | operator HeapWord* () const { return (HeapWord*)obj(); } |
duke@435 | 113 | operator oopDesc* () const { return obj(); } |
duke@435 | 114 | operator intptr_t* () const { return (intptr_t*)obj(); } |
duke@435 | 115 | operator PromotedObject* () const { return (PromotedObject*)obj(); } |
duke@435 | 116 | operator markOop () const { return markOop(obj()); } |
duke@435 | 117 | |
duke@435 | 118 | operator address () const { return (address)obj(); } |
duke@435 | 119 | operator intptr_t () const { return (intptr_t)obj(); } |
duke@435 | 120 | |
duke@435 | 121 | // from javaCalls.cpp |
duke@435 | 122 | operator jobject () const { return (jobject)obj(); } |
duke@435 | 123 | // from javaClasses.cpp |
duke@435 | 124 | operator JavaThread* () const { return (JavaThread*)obj(); } |
duke@435 | 125 | // from jvm.cpp |
duke@435 | 126 | operator jlong* () const { return (jlong*)obj(); } |
duke@435 | 127 | |
duke@435 | 128 | // from parNewGeneration and other things that want to get to the end of |
duke@435 | 129 | // an oop for stuff (like constMethodKlass.cpp, objArrayKlass.cpp) |
duke@435 | 130 | operator oop* () const { return (oop *)obj(); } |
duke@435 | 131 | }; |
duke@435 | 132 | |
duke@435 | 133 | #define DEF_OOP(type) \ |
duke@435 | 134 | class type##OopDesc; \ |
duke@435 | 135 | class type##Oop : public oop { \ |
duke@435 | 136 | public: \ |
duke@435 | 137 | type##Oop() : oop() {} \ |
duke@435 | 138 | type##Oop(const volatile oop& o) : oop(o) {} \ |
duke@435 | 139 | type##Oop(const void* p) : oop(p) {} \ |
duke@435 | 140 | operator type##OopDesc* () const { return (type##OopDesc*)obj(); } \ |
duke@435 | 141 | type##OopDesc* operator->() const { \ |
duke@435 | 142 | return (type##OopDesc*)obj(); \ |
duke@435 | 143 | } \ |
duke@435 | 144 | }; \ |
duke@435 | 145 | |
duke@435 | 146 | DEF_OOP(instance); |
duke@435 | 147 | DEF_OOP(method); |
duke@435 | 148 | DEF_OOP(methodData); |
duke@435 | 149 | DEF_OOP(array); |
duke@435 | 150 | DEF_OOP(constMethod); |
duke@435 | 151 | DEF_OOP(constantPool); |
duke@435 | 152 | DEF_OOP(constantPoolCache); |
duke@435 | 153 | DEF_OOP(objArray); |
duke@435 | 154 | DEF_OOP(typeArray); |
duke@435 | 155 | DEF_OOP(symbol); |
duke@435 | 156 | DEF_OOP(klass); |
duke@435 | 157 | DEF_OOP(compiledICHolder); |
duke@435 | 158 | |
duke@435 | 159 | #endif // CHECK_UNHANDLED_OOPS |
duke@435 | 160 | |
duke@435 | 161 | // The klass hierarchy is separate from the oop hierarchy. |
duke@435 | 162 | |
duke@435 | 163 | class Klass; |
duke@435 | 164 | class instanceKlass; |
duke@435 | 165 | class instanceRefKlass; |
duke@435 | 166 | class methodKlass; |
duke@435 | 167 | class constMethodKlass; |
duke@435 | 168 | class methodDataKlass; |
duke@435 | 169 | class klassKlass; |
duke@435 | 170 | class instanceKlassKlass; |
duke@435 | 171 | class arrayKlassKlass; |
duke@435 | 172 | class objArrayKlassKlass; |
duke@435 | 173 | class typeArrayKlassKlass; |
duke@435 | 174 | class arrayKlass; |
duke@435 | 175 | class constantPoolKlass; |
duke@435 | 176 | class constantPoolCacheKlass; |
duke@435 | 177 | class objArrayKlass; |
duke@435 | 178 | class typeArrayKlass; |
duke@435 | 179 | class symbolKlass; |
duke@435 | 180 | class compiledICHolderKlass; |