hotspot/src/share/vm/oops/oopsHierarchy.hpp
author coleenp
Sat, 01 Sep 2012 13:25:18 -0400
changeset 13728 882756847a04
parent 8725 8c1e3dd5fe1b
child 13738 d67be49a5beb
permissions -rw-r--r--
6964458: Reimplement class meta-data storage to use native memory Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
     2
 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. 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
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3262
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3262
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3262
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    25
#ifndef SHARE_VM_OOPS_OOPSHIERARCHY_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    26
#define SHARE_VM_OOPS_OOPSHIERARCHY_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    28
#include "runtime/globals.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    29
#include "utilities/globalDefinitions.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    30
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
// OBJECT hierarchy
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
// This hierarchy is a representation hierarchy, i.e. if A is a superclass
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
// of B, A's representation is a prefix of B's representation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    35
typedef juint narrowOop; // Offset instead of address for an oop within a java object
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 2105
diff changeset
    36
typedef void* OopOrNarrowOopStar;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
    37
typedef class   markOopDesc*                markOop;
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    38
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
#ifndef CHECK_UNHANDLED_OOPS
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    41
typedef class oopDesc*                            oop;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
typedef class   instanceOopDesc*            instanceOop;
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    43
typedef class   arrayOopDesc*                    arrayOop;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    44
typedef class     objArrayOopDesc*            objArrayOop;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    45
typedef class     typeArrayOopDesc*            typeArrayOop;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// When CHECK_UNHANDLED_OOPS is defined, an "oop" is a class with a
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// carefully chosen set of constructors and conversion operators to go
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
// to and from the underlying oopDesc pointer type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
// Because oop and its subclasses <type>Oop are class types, arbitrary
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
// conversions are not accepted by the compiler, and you may get a message
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
// about overloading ambiguity (between long and int is common when converting
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
// from a constant in 64 bit mode), or unable to convert from type to 'oop'.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
// Applying a cast to one of these conversion operators first will get to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
// underlying oopDesc* type if appropriate.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
// Converting NULL to oop to Handle implicit is no longer accepted by the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
// compiler because there are too many steps in the conversion.  Use Handle()
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
// instead, which generates less code anyway.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
class Thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
class PromotedObject;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
class oop {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  oopDesc* _o;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  void register_oop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  void unregister_oop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  // friend class markOop;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  void set_obj(const void* p)         {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
    raw_set_obj(p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
    if (CheckUnhandledOops) register_oop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  void raw_set_obj(const void* p)     { _o = (oopDesc*)p; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  oop()                               { set_obj(NULL); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  oop(const volatile oop& o)          { set_obj(o.obj()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  oop(const void* p)                  { set_obj(p); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  oop(intptr_t i)                     { set_obj((void *)i); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  oop(int i)                          { set_obj((void *)i); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  ~oop()                              {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
    if (CheckUnhandledOops) unregister_oop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  oopDesc* obj()  const volatile      { return _o; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  // General access
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  oopDesc*  operator->() const        { return obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  bool operator==(const oop o) const  { return obj() == o.obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  bool operator==(void *p) const      { return obj() == p; }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
    98
  bool operator!=(const volatile oop o) const  { return obj() != o.obj(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  bool operator!=(void *p) const      { return obj() != p; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  bool operator==(intptr_t p) const   { return obj() == (oopDesc*)p; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  bool operator!=(intptr_t p) const   { return obj() != (oopDesc*)p; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  bool operator<(oop o) const         { return obj() < o.obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  bool operator>(oop o) const         { return obj() > o.obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  bool operator<=(oop o) const        { return obj() <= o.obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  bool operator>=(oop o) const        { return obj() >= o.obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  bool operator!() const              { return !obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  // Cast
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  operator void* () const             { return (void *)obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  operator HeapWord* () const         { return (HeapWord*)obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  operator oopDesc* () const          { return obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  operator intptr_t* () const         { return (intptr_t*)obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  operator PromotedObject* () const   { return (PromotedObject*)obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  operator markOop () const           { return markOop(obj()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  operator address   () const         { return (address)obj(); }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   118
  operator intptr_t () const volatile { return (intptr_t)obj(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  // from javaCalls.cpp
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  operator jobject () const           { return (jobject)obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  // from javaClasses.cpp
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  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
   124
24b003a6fe46 6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents: 670
diff changeset
   125
#ifndef _LP64
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  // from jvm.cpp
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  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
   128
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  // from parNewGeneration and other things that want to get to the end of
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   131
  // an oop for stuff (like objArrayKlass.cpp)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  operator oop* () const              { return (oop *)obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
#define DEF_OOP(type)                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
   class type##OopDesc;                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
   class type##Oop : public oop {                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
     public:                                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
       type##Oop() : oop() {}                                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
       type##Oop(const volatile oop& o) : oop(o) {}                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
       type##Oop(const void* p) : oop(p) {}                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
       operator type##OopDesc* () const { return (type##OopDesc*)obj(); }  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
       type##OopDesc* operator->() const {                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
            return (type##OopDesc*)obj();                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
       }                                                                   \
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   146
   };
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
DEF_OOP(instance);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
DEF_OOP(array);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
DEF_OOP(objArray);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
DEF_OOP(typeArray);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
#endif // CHECK_UNHANDLED_OOPS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   155
// The metadata hierarchy is separate from the oop hierarchy
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   156
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   157
//      class MetaspaceObj
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   158
class   ConstMethod;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   159
class   ConstantPoolCache;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   160
class   MethodData;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   161
//      class Metadata
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   162
class   Method;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   163
class   ConstantPool;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   164
//      class CHeapObj
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   165
class   CompiledICHolder;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   166
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   167
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
// The klass hierarchy is separate from the oop hierarchy.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
class Klass;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   171
class   InstanceKlass;
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8076
diff changeset
   172
class     instanceMirrorKlass;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8725
diff changeset
   173
class     instanceClassLoaderKlass;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
class     instanceRefKlass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
class   arrayKlass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
class     objArrayKlass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
class     typeArrayKlass;
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   178
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   179
#endif // SHARE_VM_OOPS_OOPSHIERARCHY_HPP