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