truffle: src/share/vm/oops/oopsHierarchy.hpp annotate

annotate src/share/vm/oops/oopsHierarchy.hpp @ 14649:f6301b007a16

6498581: ThreadInterruptTest3 produces wrong output on Windows Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set. Reviewed-by: acorn, kvn Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com

author	minqi
date	Wed, 26 Feb 2014 15:20:41 -0800
parents	190899198332
children

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 6831 diff changeset	2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 845 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 845 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 845 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	25 #ifndef SHARE_VM_OOPS_OOPSHIERARCHY_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #define SHARE_VM_OOPS_OOPSHIERARCHY_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "runtime/globals.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29 #include "utilities/globalDefinitions.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	30
0 a61af66fc99e Initial load duke parents: diff changeset	31 // OBJECT hierarchy
a61af66fc99e Initial load duke parents: diff changeset	32 // This hierarchy is a representation hierarchy, i.e. if A is a superclass
a61af66fc99e Initial load duke parents: diff changeset	33 // of B, A's representation is a prefix of B's representation.
a61af66fc99e Initial load duke parents: diff changeset	34
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	35 typedef juint narrowOop; // Offset instead of address for an oop within a java object
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 6831 diff changeset	36
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 6831 diff changeset	37 // If compressed klass pointers then use narrowKlass.
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 6831 diff changeset	38 typedef juint narrowKlass;
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 6831 diff changeset	39
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 579 diff changeset	40 typedef void* OopOrNarrowOopStar;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	41 typedef class markOopDesc* markOop;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	42
0 a61af66fc99e Initial load duke parents: diff changeset	43 #ifndef CHECK_UNHANDLED_OOPS
a61af66fc99e Initial load duke parents: diff changeset	44
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	45 typedef class oopDesc* oop;
0 a61af66fc99e Initial load duke parents: diff changeset	46 typedef class instanceOopDesc* instanceOop;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	47 typedef class arrayOopDesc* arrayOop;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	48 typedef class objArrayOopDesc* objArrayOop;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	49 typedef class typeArrayOopDesc* typeArrayOop;
0 a61af66fc99e Initial load duke parents: diff changeset	50
a61af66fc99e Initial load duke parents: diff changeset	51 #else
a61af66fc99e Initial load duke parents: diff changeset	52
a61af66fc99e Initial load duke parents: diff changeset	53 // When CHECK_UNHANDLED_OOPS is defined, an "oop" is a class with a
a61af66fc99e Initial load duke parents: diff changeset	54 // carefully chosen set of constructors and conversion operators to go
a61af66fc99e Initial load duke parents: diff changeset	55 // to and from the underlying oopDesc pointer type.
a61af66fc99e Initial load duke parents: diff changeset	56 //
a61af66fc99e Initial load duke parents: diff changeset	57 // Because oop and its subclasses <type>Oop are class types, arbitrary
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	58 // conversions are not accepted by the compiler. Applying a cast to
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	59 // an oop will cause the best matched conversion operator to be
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	60 // invoked returning the underlying oopDesc* type if appropriate.
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	61 // No copy constructors, explicit user conversions or operators of
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	62 // numerical type should be defined within the oop class. Most C++
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	63 // compilers will issue a compile time error concerning the overloading
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	64 // ambiguity between operators of numerical and pointer types. If
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	65 // a conversion to or from an oop to a numerical type is needed,
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	66 // use the inline template methods, cast_*_oop, defined below.
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	67 //
0 a61af66fc99e Initial load duke parents: diff changeset	68 // Converting NULL to oop to Handle implicit is no longer accepted by the
a61af66fc99e Initial load duke parents: diff changeset	69 // compiler because there are too many steps in the conversion. Use Handle()
a61af66fc99e Initial load duke parents: diff changeset	70 // instead, which generates less code anyway.
a61af66fc99e Initial load duke parents: diff changeset	71
a61af66fc99e Initial load duke parents: diff changeset	72 class Thread;
a61af66fc99e Initial load duke parents: diff changeset	73 class PromotedObject;
a61af66fc99e Initial load duke parents: diff changeset	74
a61af66fc99e Initial load duke parents: diff changeset	75
a61af66fc99e Initial load duke parents: diff changeset	76 class oop {
a61af66fc99e Initial load duke parents: diff changeset	77 oopDesc* _o;
a61af66fc99e Initial load duke parents: diff changeset	78
a61af66fc99e Initial load duke parents: diff changeset	79 void register_oop();
a61af66fc99e Initial load duke parents: diff changeset	80 void unregister_oop();
a61af66fc99e Initial load duke parents: diff changeset	81
a61af66fc99e Initial load duke parents: diff changeset	82 // friend class markOop;
a61af66fc99e Initial load duke parents: diff changeset	83 public:
a61af66fc99e Initial load duke parents: diff changeset	84 void set_obj(const void* p) {
a61af66fc99e Initial load duke parents: diff changeset	85 raw_set_obj(p);
a61af66fc99e Initial load duke parents: diff changeset	86 if (CheckUnhandledOops) register_oop();
a61af66fc99e Initial load duke parents: diff changeset	87 }
a61af66fc99e Initial load duke parents: diff changeset	88 void raw_set_obj(const void* p) { _o = (oopDesc*)p; }
a61af66fc99e Initial load duke parents: diff changeset	89
a61af66fc99e Initial load duke parents: diff changeset	90 oop() { set_obj(NULL); }
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	91 oop(const oop& o) { set_obj(o.obj()); }
0 a61af66fc99e Initial load duke parents: diff changeset	92 oop(const volatile oop& o) { set_obj(o.obj()); }
a61af66fc99e Initial load duke parents: diff changeset	93 oop(const void* p) { set_obj(p); }
a61af66fc99e Initial load duke parents: diff changeset	94 ~oop() {
a61af66fc99e Initial load duke parents: diff changeset	95 if (CheckUnhandledOops) unregister_oop();
a61af66fc99e Initial load duke parents: diff changeset	96 }
a61af66fc99e Initial load duke parents: diff changeset	97
a61af66fc99e Initial load duke parents: diff changeset	98 oopDesc* obj() const volatile { return _o; }
a61af66fc99e Initial load duke parents: diff changeset	99
a61af66fc99e Initial load duke parents: diff changeset	100 // General access
a61af66fc99e Initial load duke parents: diff changeset	101 oopDesc* operator->() const { return obj(); }
a61af66fc99e Initial load duke parents: diff changeset	102 bool operator==(const oop o) const { return obj() == o.obj(); }
a61af66fc99e Initial load duke parents: diff changeset	103 bool operator==(void *p) const { return obj() == p; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	104 bool operator!=(const volatile oop o) const { return obj() != o.obj(); }
0 a61af66fc99e Initial load duke parents: diff changeset	105 bool operator!=(void *p) const { return obj() != p; }
a61af66fc99e Initial load duke parents: diff changeset	106
a61af66fc99e Initial load duke parents: diff changeset	107 bool operator<(oop o) const { return obj() < o.obj(); }
a61af66fc99e Initial load duke parents: diff changeset	108 bool operator>(oop o) const { return obj() > o.obj(); }
a61af66fc99e Initial load duke parents: diff changeset	109 bool operator<=(oop o) const { return obj() <= o.obj(); }
a61af66fc99e Initial load duke parents: diff changeset	110 bool operator>=(oop o) const { return obj() >= o.obj(); }
a61af66fc99e Initial load duke parents: diff changeset	111 bool operator!() const { return !obj(); }
a61af66fc99e Initial load duke parents: diff changeset	112
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	113 // Assignment
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	114 oop& operator=(const oop& o) { _o = o.obj(); return *this; }
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	115 #ifndef SOLARIS
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	116 volatile oop& operator=(const oop& o) volatile { _o = o.obj(); return *this; }
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	117 #endif
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	118 volatile oop& operator=(const volatile oop& o) volatile { _o = o.obj(); return *this; }
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	119
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	120 // Explict user conversions
0 a61af66fc99e Initial load duke parents: diff changeset	121 operator void* () const { return (void *)obj(); }
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	122 #ifndef SOLARIS
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	123 operator void* () const volatile { return (void *)obj(); }
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	124 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	125 operator HeapWord* () const { return (HeapWord*)obj(); }
a61af66fc99e Initial load duke parents: diff changeset	126 operator oopDesc* () const { return obj(); }
a61af66fc99e Initial load duke parents: diff changeset	127 operator intptr_t* () const { return (intptr_t*)obj(); }
a61af66fc99e Initial load duke parents: diff changeset	128 operator PromotedObject* () const { return (PromotedObject*)obj(); }
a61af66fc99e Initial load duke parents: diff changeset	129 operator markOop () const { return markOop(obj()); }
a61af66fc99e Initial load duke parents: diff changeset	130
a61af66fc99e Initial load duke parents: diff changeset	131 operator address () const { return (address)obj(); }
a61af66fc99e Initial load duke parents: diff changeset	132
a61af66fc99e Initial load duke parents: diff changeset	133 // from javaCalls.cpp
a61af66fc99e Initial load duke parents: diff changeset	134 operator jobject () const { return (jobject)obj(); }
a61af66fc99e Initial load duke parents: diff changeset	135 // from javaClasses.cpp
a61af66fc99e Initial load duke parents: diff changeset	136 operator JavaThread* () const { return (JavaThread*)obj(); }
513 2328d1d3f8cf 6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2 xlu parents: 196 diff changeset	137
2328d1d3f8cf 6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2 xlu parents: 196 diff changeset	138 #ifndef _LP64
0 a61af66fc99e Initial load duke parents: diff changeset	139 // from jvm.cpp
a61af66fc99e Initial load duke parents: diff changeset	140 operator jlong* () const { return (jlong*)obj(); }
513 2328d1d3f8cf 6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2 xlu parents: 196 diff changeset	141 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	142
a61af66fc99e Initial load duke parents: diff changeset	143 // from parNewGeneration and other things that want to get to the end of
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6735 diff changeset	144 // an oop for stuff (like ObjArrayKlass.cpp)
0 a61af66fc99e Initial load duke parents: diff changeset	145 operator oop* () const { return (oop *)obj(); }
a61af66fc99e Initial load duke parents: diff changeset	146 };
a61af66fc99e Initial load duke parents: diff changeset	147
a61af66fc99e Initial load duke parents: diff changeset	148 #define DEF_OOP(type) \
a61af66fc99e Initial load duke parents: diff changeset	149 class type##OopDesc; \
a61af66fc99e Initial load duke parents: diff changeset	150 class type##Oop : public oop { \
a61af66fc99e Initial load duke parents: diff changeset	151 public: \
a61af66fc99e Initial load duke parents: diff changeset	152 type##Oop() : oop() {} \
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	153 type##Oop(const oop& o) : oop(o) {} \
0 a61af66fc99e Initial load duke parents: diff changeset	154 type##Oop(const volatile oop& o) : oop(o) {} \
a61af66fc99e Initial load duke parents: diff changeset	155 type##Oop(const void* p) : oop(p) {} \
a61af66fc99e Initial load duke parents: diff changeset	156 operator type##OopDesc* () const { return (type##OopDesc*)obj(); } \
a61af66fc99e Initial load duke parents: diff changeset	157 type##OopDesc* operator->() const { \
a61af66fc99e Initial load duke parents: diff changeset	158 return (type##OopDesc*)obj(); \
a61af66fc99e Initial load duke parents: diff changeset	159 } \
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	160 type##Oop& operator=(const type##Oop& o) { \
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	161 oop::operator=(o); \
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	162 return *this; \
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	163 } \
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	164 NOT_SOLARIS( \
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	165 volatile type##Oop& operator=(const type##Oop& o) volatile { \
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	166 (void)const_cast<oop&>(oop::operator=(o)); \
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	167 return *this; \
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	168 }) \
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	169 volatile type##Oop& operator=(const volatile type##Oop& o) volatile {\
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	170 (void)const_cast<oop&>(oop::operator=(o)); \
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	171 return *this; \
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	172 } \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	173 };
0 a61af66fc99e Initial load duke parents: diff changeset	174
a61af66fc99e Initial load duke parents: diff changeset	175 DEF_OOP(instance);
a61af66fc99e Initial load duke parents: diff changeset	176 DEF_OOP(array);
a61af66fc99e Initial load duke parents: diff changeset	177 DEF_OOP(objArray);
a61af66fc99e Initial load duke parents: diff changeset	178 DEF_OOP(typeArray);
a61af66fc99e Initial load duke parents: diff changeset	179
a61af66fc99e Initial load duke parents: diff changeset	180 #endif // CHECK_UNHANDLED_OOPS
a61af66fc99e Initial load duke parents: diff changeset	181
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	182 // For CHECK_UNHANDLED_OOPS, it is ambiguous C++ behavior to have the oop
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	183 // structure contain explicit user defined conversions of both numerical
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	184 // and pointer type. Define inline methods to provide the numerical conversions.
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	185 template <class T> inline oop cast_to_oop(T value) {
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	186 return (oop)(CHECK_UNHANDLED_OOPS_ONLY((void *))(value));
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	187 }
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	188 template <class T> inline T cast_from_oop(oop o) {
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	189 return (T)(CHECK_UNHANDLED_OOPS_ONLY((void*))o);
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	190 }
190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12056 diff changeset	191
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	192 // The metadata hierarchy is separate from the oop hierarchy
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	193
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	194 // class MetaspaceObj
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	195 class ConstMethod;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	196 class ConstantPoolCache;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	197 class MethodData;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	198 // class Metadata
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	199 class Method;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	200 class ConstantPool;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	201 // class CHeapObj
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	202 class CompiledICHolder;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	203
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	204
0 a61af66fc99e Initial load duke parents: diff changeset	205 // The klass hierarchy is separate from the oop hierarchy.
a61af66fc99e Initial load duke parents: diff changeset	206
a61af66fc99e Initial load duke parents: diff changeset	207 class Klass;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2376 diff changeset	208 class InstanceKlass;
6735 aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6725 diff changeset	209 class InstanceMirrorKlass;
aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6725 diff changeset	210 class InstanceClassLoaderKlass;
aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6725 diff changeset	211 class InstanceRefKlass;
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6735 diff changeset	212 class ArrayKlass;
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6735 diff changeset	213 class ObjArrayKlass;
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6735 diff changeset	214 class TypeArrayKlass;
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	215
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	216 #endif // SHARE_VM_OOPS_OOPSHIERARCHY_HPP

Mercurial > hg > truffle

annotate src/share/vm/oops/oopsHierarchy.hpp @ 14649:f6301b007a16