hotspot/src/share/vm/runtime/handles.hpp
author duke
Sat, 01 Dec 2007 00:00:00 +0000
changeset 1 489c9b5090e2
child 2332 5c7b6f4ce0a1
permissions -rw-r--r--
Initial load
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
     2
 * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.
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
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
// In order to preserve oops during garbage collection, they should be
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
// allocated and passed around via Handles within the VM. A handle is
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
// simply an extra indirection allocated in a thread local handle area.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
// A handle is a ValueObj, so it can be passed around as a value, can
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
// be used as a parameter w/o using &-passing, and can be returned as a
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
// return value.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
// oop parameters and return types should be Handles whenever feasible.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// Handles are declared in a straight-forward manner, e.g.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
//   oop obj = ...;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
//   Handle h1(obj);              // allocate new handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
//   Handle h2(thread, obj);      // faster allocation when current thread is known
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
//   Handle h3;                   // declare handle only, no allocation occurs
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
//   ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
//   h3 = h1;                     // make h3 refer to same indirection as h1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
//   oop obj2 = h2();             // get handle value
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
//   h1->print();                 // invoking operation on oop
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
// Handles are specialized for different oop types to provide extra type
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
// information and avoid unnecessary casting. For each oop type xxxOop
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// there is a corresponding handle called xxxHandle, e.g.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
//   oop           Handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
//   methodOop     methodHandle
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
//   instanceOop   instanceHandle
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
// For klassOops, it is often useful to model the Klass hierarchy in order
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
// to get access to the klass_part without casting. For each xxxKlass there
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
// is a corresponding handle called xxxKlassHandle, e.g.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
//   klassOop      Klass           KlassHandle
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
//   klassOop      methodKlass     methodKlassHandle
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
//   klassOop      instanceKlass   instanceKlassHandle
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
// Base class for all handles. Provides overloading of frequently
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
// used operators for ease of use.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
class Handle VALUE_OBJ_CLASS_SPEC {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  oop* _handle;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  oop     obj() const                            { return _handle == NULL ? (oop)NULL : *_handle; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  oop     non_null_obj() const                   { assert(_handle != NULL, "resolving NULL handle"); return *_handle; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  // Constructors
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  Handle()                                       { _handle = NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  Handle(oop obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
#ifndef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  Handle(Thread* thread, oop obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  // Don't inline body with assert for current thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  Handle(Thread* thread, oop obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
#endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  // General access
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  oop     operator () () const                   { return obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  oop     operator -> () const                   { return non_null_obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  bool    operator == (oop o) const              { return obj() == o; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  bool    operator == (const Handle& h) const          { return obj() == h.obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  // Null checks
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  bool    is_null() const                        { return _handle == NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  bool    not_null() const                       { return _handle != NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  // Debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  void    print()                                { obj()->print(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  // Direct interface, use very sparingly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  // Used by JavaCalls to quickly convert handles and to create handles static data structures.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  // Constructor takes a dummy argument to prevent unintentional type conversion in C++.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  Handle(oop *handle, bool dummy)                { _handle = handle; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  // Raw handle access. Allows easy duplication of Handles. This can be very unsafe
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  // since duplicates is only valid as long as original handle is alive.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  oop* raw_value()                               { return _handle; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  static oop raw_resolve(oop *handle)            { return handle == NULL ? (oop)NULL : *handle; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
// Base class for Handles containing klassOops. Provides overloading of frequently
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
// used operators for ease of use and typed access to the Klass part.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
class KlassHandle: public Handle {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  klassOop    obj() const                        { return (klassOop)Handle::obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  klassOop    non_null_obj() const               { return (klassOop)Handle::non_null_obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  Klass*      as_klass() const                   { return non_null_obj()->klass_part(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  // Constructors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  KlassHandle ()                                 : Handle()            {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  KlassHandle (oop obj) : Handle(obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
    assert(SharedSkipVerify || is_null() || obj->is_klass(), "not a klassOop");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  KlassHandle (Klass* kl) : Handle(kl ? kl->as_klassOop() : (klassOop)NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
    assert(SharedSkipVerify || is_null() || obj()->is_klass(), "not a klassOop");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  // Faster versions passing Thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  KlassHandle (Thread* thread, oop obj) : Handle(thread, obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
    assert(SharedSkipVerify || is_null() || obj->is_klass(), "not a klassOop");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  KlassHandle (Thread *thread, Klass* kl)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
    : Handle(thread, kl ? kl->as_klassOop() : (klassOop)NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
    assert(is_null() || obj()->is_klass(), "not a klassOop");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  // General access
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  klassOop    operator () () const               { return obj(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  Klass*      operator -> () const               { return as_klass(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
// Specific Handles for different oop types
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
#define DEF_HANDLE(type, is_a)                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  class type##Handle;                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  class type##Handle: public Handle {            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
   protected:                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
    type##Oop    obj() const                     { return (type##Oop)Handle::obj(); } \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
    type##Oop    non_null_obj() const            { return (type##Oop)Handle::non_null_obj(); } \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
   public:                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
    /* Constructors */                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
    type##Handle ()                              : Handle()                 {} \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
    type##Handle (type##Oop obj) : Handle((oop)obj) {                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
      assert(SharedSkipVerify || is_null() || ((oop)obj)->is_a(),             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
             "illegal type");                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
    }                                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
    type##Handle (Thread* thread, type##Oop obj) : Handle(thread, (oop)obj) { \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
      assert(SharedSkipVerify || is_null() || ((oop)obj)->is_a(), "illegal type");  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
    }                                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
    /* Special constructor, use sparingly */ \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
    type##Handle (type##Oop *handle, bool dummy) : Handle((oop*)handle, dummy) {} \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
    /* Operators for ease of use */              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
    type##Oop    operator () () const            { return obj(); } \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
    type##Oop    operator -> () const            { return non_null_obj(); } \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
DEF_HANDLE(instance         , is_instance         )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
DEF_HANDLE(method           , is_method           )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
DEF_HANDLE(constMethod      , is_constMethod      )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
DEF_HANDLE(methodData       , is_methodData       )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
DEF_HANDLE(array            , is_array            )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
DEF_HANDLE(constantPool     , is_constantPool     )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
DEF_HANDLE(constantPoolCache, is_constantPoolCache)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
DEF_HANDLE(objArray         , is_objArray         )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
DEF_HANDLE(typeArray        , is_typeArray        )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
DEF_HANDLE(symbol           , is_symbol           )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
// Specific KlassHandles for different Klass types
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
#define DEF_KLASS_HANDLE(type, is_a)             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  class type##Handle : public KlassHandle {      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
   public:                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
    /* Constructors */                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
    type##Handle ()                              : KlassHandle()           {} \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
    type##Handle (klassOop obj) : KlassHandle(obj) {                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
      assert(SharedSkipVerify || is_null() || obj->klass_part()->is_a(),      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
             "illegal type");                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
    }                                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
    type##Handle (Thread* thread, klassOop obj) : KlassHandle(thread, obj) {  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
      assert(SharedSkipVerify || is_null() || obj->klass_part()->is_a(),      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
             "illegal type");                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
    }                                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
    /* Access to klass part */                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
    type*        operator -> () const            { return (type*)obj()->klass_part(); } \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
    static type##Handle cast(KlassHandle h)      { return type##Handle(h()); } \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
DEF_KLASS_HANDLE(instanceKlass         , oop_is_instance_slow )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
DEF_KLASS_HANDLE(methodKlass           , oop_is_method        )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
DEF_KLASS_HANDLE(constMethodKlass      , oop_is_constMethod   )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
DEF_KLASS_HANDLE(klassKlass            , oop_is_klass         )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
DEF_KLASS_HANDLE(arrayKlassKlass       , oop_is_arrayKlass    )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
DEF_KLASS_HANDLE(objArrayKlassKlass    , oop_is_objArrayKlass )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
DEF_KLASS_HANDLE(typeArrayKlassKlass   , oop_is_typeArrayKlass)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
DEF_KLASS_HANDLE(arrayKlass            , oop_is_array         )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
DEF_KLASS_HANDLE(typeArrayKlass        , oop_is_typeArray_slow)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
DEF_KLASS_HANDLE(objArrayKlass         , oop_is_objArray_slow )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
DEF_KLASS_HANDLE(symbolKlass           , oop_is_symbol        )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
DEF_KLASS_HANDLE(constantPoolKlass     , oop_is_constantPool  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
DEF_KLASS_HANDLE(constantPoolCacheKlass, oop_is_constantPool  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
// Thread local handle area
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
class HandleArea: public Arena {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  friend class HandleMark;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  friend class NoHandleMark;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  friend class ResetNoHandleMark;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  int _handle_mark_nesting;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  int _no_handle_mark_nesting;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  HandleArea* _prev;          // link to outer (older) area
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  HandleArea(HandleArea* prev) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
    debug_only(_handle_mark_nesting    = 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
    debug_only(_no_handle_mark_nesting = 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
    _prev = prev;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  // Handle allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  oop* real_allocate_handle(oop obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
    oop* handle = (oop*) (UseMallocOnly ? internal_malloc_4(oopSize) : Amalloc_4(oopSize));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
    oop* handle = (oop*) Amalloc_4(oopSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
    *handle = obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
    return handle;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  oop* allocate_handle(oop obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  oop* allocate_handle(oop obj) { return real_allocate_handle(obj); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  // Garbage collection support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  void oops_do(OopClosure* f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  // Number of handles in use
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  size_t used() const     { return Arena::used() / oopSize; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  debug_only(bool no_handle_mark_active() { return _no_handle_mark_nesting > 0; })
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
// Handles are allocated in a (growable) thread local handle area. Deallocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
// is managed using a HandleMark. It should normally not be necessary to use
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
// HandleMarks manually.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
// A HandleMark constructor will record the current handle area top, and the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
// desctructor will reset the top, destroying all handles allocated in between.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
// The following code will therefore NOT work:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
//   Handle h;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
//   {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
//     HandleMark hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
//     h = Handle(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
//   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
//   h()->print();       // WRONG, h destroyed by HandleMark destructor.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
// If h has to be preserved, it can be converted to an oop or a local JNI handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
// across the HandleMark boundary.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
// The base class of HandleMark should have been StackObj but we also heap allocate
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
// a HandleMark when a thread is created.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
class HandleMark {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  Thread *_thread;              // thread that owns this mark
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  HandleArea *_area;            // saved handle area
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  Chunk *_chunk;                // saved arena chunk
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  char *_hwm, *_max;            // saved arena info
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  NOT_PRODUCT(size_t _size_in_bytes;) // size of handle area
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  // Link to previous active HandleMark in thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  HandleMark* _previous_handle_mark;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  void initialize(Thread* thread);                // common code for constructors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  void set_previous_handle_mark(HandleMark* mark) { _previous_handle_mark = mark; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  HandleMark* previous_handle_mark() const        { return _previous_handle_mark; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  HandleMark();                            // see handles_inline.hpp
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  HandleMark(Thread* thread)                      { initialize(thread); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  ~HandleMark();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  // Functions used by HandleMarkCleaner
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  // called in the constructor of HandleMarkCleaner
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  void push();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  // called in the destructor of HandleMarkCleaner
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  void pop_and_restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
// A NoHandleMark stack object will verify that no handles are allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
// in its scope. Enabled in debug mode only.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
class NoHandleMark: public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  NoHandleMark();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  ~NoHandleMark();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  NoHandleMark()  {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  ~NoHandleMark() {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
class ResetNoHandleMark: public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  int _no_handle_mark_nesting;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  ResetNoHandleMark();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  ~ResetNoHandleMark();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  ResetNoHandleMark()  {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  ~ResetNoHandleMark() {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
};