oopsHierarchy.hpp revision 1472:c18cbe5936b8 
1195360Simp/*
2195360Simp * Copyright (c) 1997, 2009, Oracle and/or its affiliates. All rights reserved.
3195360Simp * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4195360Simp *
5195360Simp * This code is free software; you can redistribute it and/or modify it
6195360Simp * under the terms of the GNU General Public License version 2 only, as
7195360Simp * published by the Free Software Foundation.
8195360Simp *
9195360Simp * This code is distributed in the hope that it will be useful, but WITHOUT
10195360Simp * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11195360Simp * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12195360Simp * version 2 for more details (a copy is included in the LICENSE file that
13195360Simp * accompanied this code).
14195360Simp *
15195360Simp * You should have received a copy of the GNU General Public License version
16195360Simp * 2 along with this work; if not, write to the Free Software Foundation,
17195360Simp * 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// OBJECT hierarchy
26// This hierarchy is a representation hierarchy, i.e. if A is a superclass
27// of B, A's representation is a prefix of B's representation.
28
29typedef juint narrowOop; // Offset instead of address for an oop within a java object
30typedef class klassOopDesc* wideKlassOop; // to keep SA happy and unhandled oop
31                                          // detector happy.
32typedef void* OopOrNarrowOopStar;
33
34#ifndef CHECK_UNHANDLED_OOPS
35
36typedef class oopDesc*                            oop;
37typedef class   instanceOopDesc*            instanceOop;
38typedef class   methodOopDesc*                    methodOop;
39typedef class   constMethodOopDesc*            constMethodOop;
40typedef class   methodDataOopDesc*            methodDataOop;
41typedef class   arrayOopDesc*                    arrayOop;
42typedef class     objArrayOopDesc*            objArrayOop;
43typedef class     typeArrayOopDesc*            typeArrayOop;
44typedef class   constantPoolOopDesc*            constantPoolOop;
45typedef class   constantPoolCacheOopDesc*   constantPoolCacheOop;
46typedef class   symbolOopDesc*                    symbolOop;
47typedef class   klassOopDesc*                    klassOop;
48typedef class   markOopDesc*                    markOop;
49typedef class   compiledICHolderOopDesc*    compiledICHolderOop;
50
51#else
52
53
54// When CHECK_UNHANDLED_OOPS is defined, an "oop" is a class with a
55// carefully chosen set of constructors and conversion operators to go
56// to and from the underlying oopDesc pointer type.
57//
58// Because oop and its subclasses <type>Oop are class types, arbitrary
59// conversions are not accepted by the compiler, and you may get a message
60// about overloading ambiguity (between long and int is common when converting
61// from a constant in 64 bit mode), or unable to convert from type to 'oop'.
62// Applying a cast to one of these conversion operators first will get to the
63// underlying oopDesc* type if appropriate.
64// Converting NULL to oop to Handle implicit is no longer accepted by the
65// compiler because there are too many steps in the conversion.  Use Handle()
66// instead, which generates less code anyway.
67
68class Thread;
69typedef class   markOopDesc*                markOop;
70class PromotedObject;
71
72
73class oop {
74  oopDesc* _o;
75
76  void register_oop();
77  void unregister_oop();
78
79  // friend class markOop;
80public:
81  void set_obj(const void* p)         {
82    raw_set_obj(p);
83    if (CheckUnhandledOops) register_oop();
84  }
85  void raw_set_obj(const void* p)     { _o = (oopDesc*)p; }
86
87  oop()                               { set_obj(NULL); }
88  oop(const volatile oop& o)          { set_obj(o.obj()); }
89  oop(const void* p)                  { set_obj(p); }
90  oop(intptr_t i)                     { set_obj((void *)i); }
91#ifdef _LP64
92  oop(int i)                          { set_obj((void *)i); }
93#endif
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 oop o) const  { return obj() != o.obj(); }
105  bool operator!=(void *p) const      { return obj() != p; }
106  bool operator==(intptr_t p) const   { return obj() == (oopDesc*)p; }
107  bool operator!=(intptr_t p) const   { return obj() != (oopDesc*)p; }
108
109  bool operator<(oop o) const         { return obj() < o.obj(); }
110  bool operator>(oop o) const         { return obj() > o.obj(); }
111  bool operator<=(oop o) const        { return obj() <= o.obj(); }
112  bool operator>=(oop o) const        { return obj() >= o.obj(); }
113  bool operator!() const              { return !obj(); }
114
115  // Cast
116  operator void* () const             { return (void *)obj(); }
117  operator HeapWord* () const         { return (HeapWord*)obj(); }
118  operator oopDesc* () const          { return obj(); }
119  operator intptr_t* () const         { return (intptr_t*)obj(); }
120  operator PromotedObject* () const   { return (PromotedObject*)obj(); }
121  operator markOop () const           { return markOop(obj()); }
122
123  operator address   () const         { return (address)obj(); }
124  operator intptr_t () const          { return (intptr_t)obj(); }
125
126  // from javaCalls.cpp
127  operator jobject () const           { return (jobject)obj(); }
128  // from javaClasses.cpp
129  operator JavaThread* () const       { return (JavaThread*)obj(); }
130
131#ifndef _LP64
132  // from jvm.cpp
133  operator jlong* () const            { return (jlong*)obj(); }
134#endif
135
136  // from parNewGeneration and other things that want to get to the end of
137  // an oop for stuff (like constMethodKlass.cpp, objArrayKlass.cpp)
138  operator oop* () const              { return (oop *)obj(); }
139};
140
141#define DEF_OOP(type)                                                      \
142   class type##OopDesc;                                                    \
143   class type##Oop : public oop {                                          \
144     public:                                                               \
145       type##Oop() : oop() {}                                              \
146       type##Oop(const volatile oop& o) : oop(o) {}                        \
147       type##Oop(const void* p) : oop(p) {}                                \
148       operator type##OopDesc* () const { return (type##OopDesc*)obj(); }  \
149       type##OopDesc* operator->() const {                                 \
150            return (type##OopDesc*)obj();                                  \
151       }                                                                   \
152   };                                                                      \
153
154DEF_OOP(instance);
155DEF_OOP(method);
156DEF_OOP(methodData);
157DEF_OOP(array);
158DEF_OOP(constMethod);
159DEF_OOP(constantPool);
160DEF_OOP(constantPoolCache);
161DEF_OOP(objArray);
162DEF_OOP(typeArray);
163DEF_OOP(symbol);
164DEF_OOP(klass);
165DEF_OOP(compiledICHolder);
166
167#endif // CHECK_UNHANDLED_OOPS
168
169// The klass hierarchy is separate from the oop hierarchy.
170
171class Klass;
172class   instanceKlass;
173class     instanceRefKlass;
174class   methodKlass;
175class   constMethodKlass;
176class   methodDataKlass;
177class   klassKlass;
178class     instanceKlassKlass;
179class     arrayKlassKlass;
180class       objArrayKlassKlass;
181class       typeArrayKlassKlass;
182class   arrayKlass;
183class     objArrayKlass;
184class     typeArrayKlass;
185class   constantPoolKlass;
186class   constantPoolCacheKlass;
187class   symbolKlass;
188class   compiledICHolderKlass;
189