1 /*
   2  * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "memory/allocation.inline.hpp"
  27 #include "oops/constantPool.hpp"
  28 #include "oops/oop.inline.hpp"
  29 #include "oops/valueKlass.hpp"
  30 #include "runtime/atomic.hpp"
  31 #include "runtime/handles.inline.hpp"
  32 #include "runtime/thread.inline.hpp"
  33 
  34 #ifdef ASSERT
  35 oop* HandleArea::allocate_handle(oop obj) {
  36   assert(_handle_mark_nesting > 1, "memory leak: allocating handle outside HandleMark");
  37   assert(_no_handle_mark_nesting == 0, "allocating handle inside NoHandleMark");
  38   assert(oopDesc::is_oop(obj), "not an oop: " INTPTR_FORMAT, p2i(obj));
  39   return real_allocate_handle(obj);
  40 }
  41 #endif
  42 
  43 // Copy constructors and destructors for metadata handles
  44 // These do too much to inline.
  45 #define DEF_METADATA_HANDLE_FN_NOINLINE(name, type) \
  46 name##Handle::name##Handle(const name##Handle &h) {                    \
  47   _value = h._value;                                                   \
  48   if (_value != NULL) {                                                \
  49     assert(_value->is_valid(), "obj is valid");                        \
  50     if (h._thread != NULL) {                                           \
  51       assert(h._thread == Thread::current(), "thread must be current");\
  52       _thread = h._thread;                                             \
  53     } else {                                                           \
  54       _thread = Thread::current();                                     \
  55     }                                                                  \
  56     assert (_thread->is_in_stack((address)this), "not on stack?");     \
  57     _thread->metadata_handles()->push((Metadata*)_value);              \
  58   } else {                                                             \
  59     _thread = NULL;                                                    \
  60   }                                                                    \
  61 }                                                                      \
  62 name##Handle& name##Handle::operator=(const name##Handle &s) {         \
  63   remove();                                                            \
  64   _value = s._value;                                                   \
  65   if (_value != NULL) {                                                \
  66     assert(_value->is_valid(), "obj is valid");                        \
  67     if (s._thread != NULL) {                                           \
  68       assert(s._thread == Thread::current(), "thread must be current");\
  69       _thread = s._thread;                                             \
  70     } else {                                                           \
  71       _thread = Thread::current();                                     \
  72     }                                                                  \
  73     assert (_thread->is_in_stack((address)this), "not on stack?");     \
  74     _thread->metadata_handles()->push((Metadata*)_value);              \
  75   } else {                                                             \
  76     _thread = NULL;                                                    \
  77   }                                                                    \
  78   return *this;                                                        \
  79 }                                                                      \
  80 inline void name##Handle::remove() {                                   \
  81   if (_value != NULL) {                                                \
  82     int i = _thread->metadata_handles()->find_from_end((Metadata*)_value); \
  83     assert(i!=-1, "not in metadata_handles list");                     \
  84     _thread->metadata_handles()->remove_at(i);                         \
  85   }                                                                    \
  86 }                                                                      \
  87 name##Handle::~name##Handle () { remove(); }                           \
  88 
  89 DEF_METADATA_HANDLE_FN_NOINLINE(method, Method)
  90 DEF_METADATA_HANDLE_FN_NOINLINE(constantPool, ConstantPool)
  91 
  92 
  93 static uintx chunk_oops_do(OopClosure* f, Chunk* chunk, char* chunk_top) {
  94   oop* bottom = (oop*) chunk->bottom();
  95   oop* top    = (oop*) chunk_top;
  96   uintx handles_visited = top - bottom;
  97   assert(top >= bottom && top <= (oop*) chunk->top(), "just checking");
  98   // during GC phase 3, a handle may be a forward pointer that
  99   // is not yet valid, so loosen the assertion
 100   while (bottom < top) {
 101     if (Universe::heap()->is_in_reserved_or_null(*bottom)) {
 102       f->do_oop(bottom);
 103     }
 104     bottom++;
 105   }
 106   return handles_visited;
 107 }
 108 
 109 void HandleArea::oops_do(OopClosure* f) {
 110   uintx handles_visited = 0;
 111   // First handle the current chunk. It is filled to the high water mark.
 112   handles_visited += chunk_oops_do(f, _chunk, _hwm);
 113   // Then handle all previous chunks. They are completely filled.
 114   Chunk* k = _first;
 115   while(k != _chunk) {
 116     handles_visited += chunk_oops_do(f, k, k->top());
 117     k = k->next();
 118   }
 119 
 120   if (_prev != NULL) _prev->oops_do(f);
 121 }
 122 
 123 void HandleMark::initialize(Thread* thread) {
 124   _thread = thread;
 125   // Save area
 126   _area  = thread->handle_area();
 127   // Save current top
 128   _chunk = _area->_chunk;
 129   _hwm   = _area->_hwm;
 130   _max   = _area->_max;
 131   _size_in_bytes = _area->_size_in_bytes;
 132   debug_only(_area->_handle_mark_nesting++);
 133   assert(_area->_handle_mark_nesting > 0, "must stack allocate HandleMarks");
 134 
 135   // Link this in the thread
 136   set_previous_handle_mark(thread->last_handle_mark());
 137   thread->set_last_handle_mark(this);
 138 }
 139 
 140 HandleMark::~HandleMark() {
 141   assert(_area == _thread->handle_area(), "sanity check");
 142   assert(_area->_handle_mark_nesting > 0, "must stack allocate HandleMarks" );
 143 
 144   pop_and_restore();
 145 #ifdef ASSERT
 146   // clear out first chunk (to detect allocation bugs)
 147   if (ZapVMHandleArea) {
 148     memset(_hwm, badHandleValue, _max - _hwm);
 149   }
 150 #endif
 151 
 152   // Unlink this from the thread
 153   _thread->set_last_handle_mark(previous_handle_mark());
 154 }
 155 
 156 void HandleMark::chop_later_chunks() {
 157   // reset arena size before delete chunks. Otherwise, the total
 158   // arena size could exceed total chunk size
 159   _area->set_size_in_bytes(size_in_bytes());
 160   _chunk->next_chop();
 161 }
 162 
 163 void* HandleMark::operator new(size_t size) throw() {
 164   return AllocateHeap(size, mtThread);
 165 }
 166 
 167 void* HandleMark::operator new [] (size_t size) throw() {
 168   return AllocateHeap(size, mtThread);
 169 }
 170 
 171 void HandleMark::operator delete(void* p) {
 172   FreeHeap(p);
 173 }
 174 
 175 void HandleMark::operator delete[](void* p) {
 176   FreeHeap(p);
 177 }
 178 
 179 #ifdef ASSERT
 180 
 181 NoHandleMark::NoHandleMark() {
 182   HandleArea* area = Thread::current()->handle_area();
 183   area->_no_handle_mark_nesting++;
 184   assert(area->_no_handle_mark_nesting > 0, "must stack allocate NoHandleMark" );
 185 }
 186 
 187 
 188 NoHandleMark::~NoHandleMark() {
 189   HandleArea* area = Thread::current()->handle_area();
 190   assert(area->_no_handle_mark_nesting > 0, "must stack allocate NoHandleMark" );
 191   area->_no_handle_mark_nesting--;
 192 }
 193 
 194 
 195 ResetNoHandleMark::ResetNoHandleMark() {
 196   HandleArea* area = Thread::current()->handle_area();
 197   _no_handle_mark_nesting = area->_no_handle_mark_nesting;
 198   area->_no_handle_mark_nesting = 0;
 199 }
 200 
 201 
 202 ResetNoHandleMark::~ResetNoHandleMark() {
 203   HandleArea* area = Thread::current()->handle_area();
 204   area->_no_handle_mark_nesting = _no_handle_mark_nesting;
 205 }
 206 
 207 #endif // ASSERT