hotspot/src/share/vm/runtime/handles.cpp
author stefank
Wed, 18 Feb 2015 09:22:37 +0100
changeset 29199 db7ae483ecb2
parent 27880 afb974a04396
child 29697 92501504191b
permissions -rw-r--r--
8073388: Get rid of the depenecy from handles.hpp to oop.inline.hpp Reviewed-by: mgerdin, coleenp
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 21198
diff changeset
     2
 * Copyright (c) 1997, 2014, 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: 1
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1
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: 1
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
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    26
#include "memory/allocation.inline.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
    27
#include "oops/constantPool.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    28
#include "oops/oop.inline.hpp"
25351
7c198a690050 8044775: Improve usage of umbrella header atomic.inline.hpp.
goetz
parents: 24424
diff changeset
    29
#include "runtime/atomic.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    30
#include "runtime/handles.inline.hpp"
14583
d70ee55535f4 8003935: Simplify the needed includes for using Thread::current()
stefank
parents: 14120
diff changeset
    31
#include "runtime/thread.inline.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 21198
diff changeset
    33
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 21198
diff changeset
    34
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
oop* HandleArea::allocate_handle(oop obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
  assert(_handle_mark_nesting > 1, "memory leak: allocating handle outside HandleMark");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
  assert(_no_handle_mark_nesting == 0, "allocating handle inside NoHandleMark");
21198
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM
twisti
parents: 19696
diff changeset
    39
  assert(obj->is_oop(), err_msg("not an oop: " INTPTR_FORMAT, (intptr_t*) obj));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
  return real_allocate_handle(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
Handle::Handle(Thread* thread, oop obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
  assert(thread == Thread::current(), "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
  if (obj == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
    _handle = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
    _handle = thread->handle_area()->allocate_handle(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
static uintx chunk_oops_do(OopClosure* f, Chunk* chunk, char* chunk_top) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  oop* bottom = (oop*) chunk->bottom();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  oop* top    = (oop*) chunk_top;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  uintx handles_visited = top - bottom;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  assert(top >= bottom && top <= (oop*) chunk->top(), "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  // during GC phase 3, a handle may be a forward pointer that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  // is not yet valid, so loosen the assertion
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  while (bottom < top) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
    62
    // This test can be moved up but for now check every oop.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
    63
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
    64
    assert((*bottom)->is_oop(), "handle should point to oop");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
    65
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
    f->do_oop(bottom++);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  return handles_visited;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
// Used for debugging handle allocation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
NOT_PRODUCT(jint _nof_handlemarks  = 0;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
void HandleArea::oops_do(OopClosure* f) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  uintx handles_visited = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  // First handle the current chunk. It is filled to the high water mark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  handles_visited += chunk_oops_do(f, _chunk, _hwm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  // Then handle all previous chunks. They are completely filled.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  Chunk* k = _first;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  while(k != _chunk) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
    handles_visited += chunk_oops_do(f, k, k->top());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
    k = k->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  // The thread local handle areas should not get very large
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  if (TraceHandleAllocation && handles_visited > TotalHandleAllocationLimit) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
    warning("%d: Visited in HandleMark : %d",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
      _nof_handlemarks, handles_visited);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
    warning("Visited in HandleMark : %d", handles_visited);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  if (_prev != NULL) _prev->oops_do(f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
void HandleMark::initialize(Thread* thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  _thread = thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  // Save area
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  _area  = thread->handle_area();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  // Save current top
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  _chunk = _area->_chunk;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  _hwm   = _area->_hwm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  _max   = _area->_max;
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 10565
diff changeset
   105
  _size_in_bytes = _area->_size_in_bytes;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  debug_only(_area->_handle_mark_nesting++);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  assert(_area->_handle_mark_nesting > 0, "must stack allocate HandleMarks");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  debug_only(Atomic::inc(&_nof_handlemarks);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  // Link this in the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  set_previous_handle_mark(thread->last_handle_mark());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  thread->set_last_handle_mark(this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
HandleMark::~HandleMark() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  HandleArea* area = _area;   // help compilers with poor alias analysis
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  assert(area == _thread->handle_area(), "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  assert(area->_handle_mark_nesting > 0, "must stack allocate HandleMarks" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  debug_only(area->_handle_mark_nesting--);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  // Debug code to trace the number of handles allocated per mark/
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  if (TraceHandleAllocation) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
    size_t handles = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
    Chunk *c = _chunk->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
    if (c == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
      handles = area->_hwm - _hwm; // no new chunk allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
      handles = _max - _hwm;      // add rest in first chunk
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
      while(c != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
        handles += c->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
        c = c->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
      handles -= area->_max - area->_hwm; // adjust for last trunk not full
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
    handles /= sizeof(void *); // Adjust for size of a handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
    if (handles > HandleAllocationLimit) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
      // Note: _nof_handlemarks is only set in debug mode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
      warning("%d: Allocated in HandleMark : %d", _nof_handlemarks, handles);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   142
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   143
    tty->print_cr("Handles %d", handles);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  // Delete later chunks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  if( _chunk->next() ) {
14120
7d298141c258 7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents: 14078
diff changeset
   149
    // reset arena size before delete chunks. Otherwise, the total
7d298141c258 7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents: 14078
diff changeset
   150
    // arena size could exceed total chunk size
7d298141c258 7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents: 14078
diff changeset
   151
    assert(area->size_in_bytes() > size_in_bytes(), "Sanity check");
7d298141c258 7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents: 14078
diff changeset
   152
    area->set_size_in_bytes(size_in_bytes());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
    _chunk->next_chop();
14120
7d298141c258 7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents: 14078
diff changeset
   154
  } else {
7d298141c258 7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents: 14078
diff changeset
   155
    assert(area->size_in_bytes() == size_in_bytes(), "Sanity check");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  // Roll back arena to saved top markers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  area->_chunk = _chunk;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  area->_hwm = _hwm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  area->_max = _max;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  // clear out first chunk (to detect allocation bugs)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  if (ZapVMHandleArea) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
    memset(_hwm, badHandleValue, _max - _hwm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  Atomic::dec(&_nof_handlemarks);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  // Unlink this from the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  _thread->set_last_handle_mark(previous_handle_mark());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
19696
bd5a0131bde1 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents: 17376
diff changeset
   173
void* HandleMark::operator new(size_t size) throw() {
17376
4ee999c3c007 8012902: remove use of global operator new - take 2
minqi
parents: 14583
diff changeset
   174
  return AllocateHeap(size, mtThread);
4ee999c3c007 8012902: remove use of global operator new - take 2
minqi
parents: 14583
diff changeset
   175
}
4ee999c3c007 8012902: remove use of global operator new - take 2
minqi
parents: 14583
diff changeset
   176
19696
bd5a0131bde1 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents: 17376
diff changeset
   177
void* HandleMark::operator new [] (size_t size) throw() {
17376
4ee999c3c007 8012902: remove use of global operator new - take 2
minqi
parents: 14583
diff changeset
   178
  return AllocateHeap(size, mtThread);
4ee999c3c007 8012902: remove use of global operator new - take 2
minqi
parents: 14583
diff changeset
   179
}
4ee999c3c007 8012902: remove use of global operator new - take 2
minqi
parents: 14583
diff changeset
   180
4ee999c3c007 8012902: remove use of global operator new - take 2
minqi
parents: 14583
diff changeset
   181
void HandleMark::operator delete(void* p) {
27880
afb974a04396 8060074: os::free() takes MemoryTrackingLevel but doesn't need it
coleenp
parents: 25468
diff changeset
   182
  FreeHeap(p);
17376
4ee999c3c007 8012902: remove use of global operator new - take 2
minqi
parents: 14583
diff changeset
   183
}
4ee999c3c007 8012902: remove use of global operator new - take 2
minqi
parents: 14583
diff changeset
   184
4ee999c3c007 8012902: remove use of global operator new - take 2
minqi
parents: 14583
diff changeset
   185
void HandleMark::operator delete[](void* p) {
27880
afb974a04396 8060074: os::free() takes MemoryTrackingLevel but doesn't need it
coleenp
parents: 25468
diff changeset
   186
  FreeHeap(p);
17376
4ee999c3c007 8012902: remove use of global operator new - take 2
minqi
parents: 14583
diff changeset
   187
}
4ee999c3c007 8012902: remove use of global operator new - take 2
minqi
parents: 14583
diff changeset
   188
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
NoHandleMark::NoHandleMark() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  HandleArea* area = Thread::current()->handle_area();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  area->_no_handle_mark_nesting++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  assert(area->_no_handle_mark_nesting > 0, "must stack allocate NoHandleMark" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
NoHandleMark::~NoHandleMark() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  HandleArea* area = Thread::current()->handle_area();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  assert(area->_no_handle_mark_nesting > 0, "must stack allocate NoHandleMark" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  area->_no_handle_mark_nesting--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
ResetNoHandleMark::ResetNoHandleMark() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  HandleArea* area = Thread::current()->handle_area();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  _no_handle_mark_nesting = area->_no_handle_mark_nesting;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  area->_no_handle_mark_nesting = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
ResetNoHandleMark::~ResetNoHandleMark() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  HandleArea* area = Thread::current()->handle_area();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  area->_no_handle_mark_nesting = _no_handle_mark_nesting;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
29199
db7ae483ecb2 8073388: Get rid of the depenecy from handles.hpp to oop.inline.hpp
stefank
parents: 27880
diff changeset
   217
bool instanceKlassHandle::is_instanceKlass(const Klass* k) {
db7ae483ecb2 8073388: Get rid of the depenecy from handles.hpp to oop.inline.hpp
stefank
parents: 27880
diff changeset
   218
  return k->oop_is_instance();
db7ae483ecb2 8073388: Get rid of the depenecy from handles.hpp to oop.inline.hpp
stefank
parents: 27880
diff changeset
   219
}
db7ae483ecb2 8073388: Get rid of the depenecy from handles.hpp to oop.inline.hpp
stefank
parents: 27880
diff changeset
   220
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
#endif