never@2658: /*
coleenp@4037:  * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
never@2658:  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
never@2658:  *
never@2658:  * This code is free software; you can redistribute it and/or modify it
never@2658:  * under the terms of the GNU General Public License version 2 only, as
never@2658:  * published by the Free Software Foundation.
never@2658:  *
never@2658:  * This code is distributed in the hope that it will be useful, but WITHOUT
never@2658:  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
never@2658:  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
never@2658:  * version 2 for more details (a copy is included in the LICENSE file that
never@2658:  * accompanied this code).
never@2658:  *
never@2658:  * You should have received a copy of the GNU General Public License version
never@2658:  * 2 along with this work; if not, write to the Free Software Foundation,
never@2658:  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
never@2658:  *
never@2658:  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
never@2658:  * or visit www.oracle.com if you need additional information or have any
never@2658:  * questions.
never@2658:  *
never@2658:  */
never@2658: 
never@2658: #include "precompiled.hpp"
never@2658: #include "classfile/javaClasses.hpp"
never@2658: #include "classfile/systemDictionary.hpp"
never@2658: #include "gc_implementation/shared/markSweep.inline.hpp"
never@2658: #include "gc_interface/collectedHeap.inline.hpp"
never@2658: #include "memory/genOopClosures.inline.hpp"
never@2658: #include "memory/oopFactory.hpp"
never@2658: #include "oops/instanceKlass.hpp"
never@2658: #include "oops/instanceMirrorKlass.hpp"
never@2658: #include "oops/instanceOop.hpp"
never@2658: #include "oops/oop.inline.hpp"
never@2658: #include "oops/symbol.hpp"
never@2658: #include "runtime/handles.inline.hpp"
never@2658: #ifndef SERIALGC
coleenp@4037: #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp"
never@2658: #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
never@2658: #include "gc_implementation/g1/g1OopClosures.inline.hpp"
never@2658: #include "gc_implementation/g1/g1RemSet.inline.hpp"
never@2658: #include "gc_implementation/g1/heapRegionSeq.inline.hpp"
never@2658: #include "gc_implementation/parNew/parOopClosures.inline.hpp"
never@2658: #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
never@2658: #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
never@2658: #include "oops/oop.pcgc.inline.hpp"
never@2658: #endif
never@2658: 
coleenp@4047: int InstanceMirrorKlass::_offset_of_static_fields = 0;
never@2658: 
never@2658: #ifdef ASSERT
never@2658: template <class T> void assert_is_in(T *p) {
never@2658:   T heap_oop = oopDesc::load_heap_oop(p);
never@2658:   if (!oopDesc::is_null(heap_oop)) {
never@2658:     oop o = oopDesc::decode_heap_oop_not_null(heap_oop);
never@2658:     assert(Universe::heap()->is_in(o), "should be in heap");
never@2658:   }
never@2658: }
never@2658: template <class T> void assert_is_in_closed_subset(T *p) {
never@2658:   T heap_oop = oopDesc::load_heap_oop(p);
never@2658:   if (!oopDesc::is_null(heap_oop)) {
never@2658:     oop o = oopDesc::decode_heap_oop_not_null(heap_oop);
never@2658:     assert(Universe::heap()->is_in_closed_subset(o), "should be in closed");
never@2658:   }
never@2658: }
never@2658: template <class T> void assert_is_in_reserved(T *p) {
never@2658:   T heap_oop = oopDesc::load_heap_oop(p);
never@2658:   if (!oopDesc::is_null(heap_oop)) {
never@2658:     oop o = oopDesc::decode_heap_oop_not_null(heap_oop);
never@2658:     assert(Universe::heap()->is_in_reserved(o), "should be in reserved");
never@2658:   }
never@2658: }
never@2658: template <class T> void assert_nothing(T *p) {}
never@2658: 
never@2658: #else
never@2658: template <class T> void assert_is_in(T *p) {}
never@2658: template <class T> void assert_is_in_closed_subset(T *p) {}
never@2658: template <class T> void assert_is_in_reserved(T *p) {}
never@2658: template <class T> void assert_nothing(T *p) {}
never@2658: #endif // ASSERT
never@2658: 
never@2658: #define InstanceMirrorKlass_SPECIALIZED_OOP_ITERATE( \
never@2658:   T, start_p, count, do_oop,                         \
never@2658:   assert_fn)                                         \
never@2658: {                                                    \
never@2658:   T* p         = (T*)(start_p);                      \
never@2658:   T* const end = p + (count);                        \
never@2658:   while (p < end) {                                  \
never@2658:     (assert_fn)(p);                                  \
never@2658:     do_oop;                                          \
never@2658:     ++p;                                             \
never@2658:   }                                                  \
never@2658: }
never@2658: 
never@2658: #define InstanceMirrorKlass_SPECIALIZED_BOUNDED_OOP_ITERATE( \
never@2658:   T, start_p, count, low, high,                              \
never@2658:   do_oop, assert_fn)                                         \
never@2658: {                                                            \
never@2658:   T* const l = (T*)(low);                                    \
never@2658:   T* const h = (T*)(high);                                   \
never@2658:   assert(mask_bits((intptr_t)l, sizeof(T)-1) == 0 &&         \
never@2658:          mask_bits((intptr_t)h, sizeof(T)-1) == 0,           \
never@2658:          "bounded region must be properly aligned");         \
never@2658:   T* p       = (T*)(start_p);                                \
never@2658:   T* end     = p + (count);                                  \
never@2658:   if (p < l) p = l;                                          \
never@2658:   if (end > h) end = h;                                      \
never@2658:   while (p < end) {                                          \
never@2658:     (assert_fn)(p);                                          \
never@2658:     do_oop;                                                  \
never@2658:     ++p;                                                     \
never@2658:   }                                                          \
never@2658: }
never@2658: 
never@2658: 
never@2658: #define InstanceMirrorKlass_OOP_ITERATE(start_p, count,    \
never@2658:                                   do_oop, assert_fn)       \
never@2658: {                                                          \
never@2658:   if (UseCompressedOops) {                                 \
never@2658:     InstanceMirrorKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \
never@2658:       start_p, count,                                      \
never@2658:       do_oop, assert_fn)                                   \
never@2658:   } else {                                                 \
never@2658:     InstanceMirrorKlass_SPECIALIZED_OOP_ITERATE(oop,       \
never@2658:       start_p, count,                                      \
never@2658:       do_oop, assert_fn)                                   \
never@2658:   }                                                        \
never@2658: }
never@2658: 
never@2658: // The following macros call specialized macros, passing either oop or
never@2658: // narrowOop as the specialization type.  These test the UseCompressedOops
never@2658: // flag.
never@2658: #define InstanceMirrorKlass_BOUNDED_OOP_ITERATE(start_p, count, low, high, \
never@2658:                                           do_oop, assert_fn)               \
never@2658: {                                                                          \
never@2658:   if (UseCompressedOops) {                                                 \
never@2658:     InstanceMirrorKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop,         \
never@2658:       start_p, count,                                                      \
never@2658:       low, high,                                                           \
never@2658:       do_oop, assert_fn)                                                   \
never@2658:   } else {                                                                 \
never@2658:     InstanceMirrorKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop,               \
never@2658:       start_p, count,                                                      \
never@2658:       low, high,                                                           \
never@2658:       do_oop, assert_fn)                                                   \
never@2658:   }                                                                        \
never@2658: }
never@2658: 
never@2658: 
coleenp@4047: void InstanceMirrorKlass::oop_follow_contents(oop obj) {
coleenp@4037:   InstanceKlass::oop_follow_contents(obj);
coleenp@4037: 
coleenp@4037:   // Follow the klass field in the mirror.
coleenp@4037:   Klass* klass = java_lang_Class::as_Klass(obj);
coleenp@4037:   if (klass != NULL) {
coleenp@4037:     MarkSweep::follow_klass(klass);
coleenp@4037:   } else {
coleenp@4037:     // If klass is NULL then this a mirror for a primitive type.
coleenp@4037:     // We don't have to follow them, since they are handled as strong
coleenp@4037:     // roots in Universe::oops_do.
coleenp@4037:     assert(java_lang_Class::is_primitive(obj), "Sanity check");
coleenp@4037:   }
coleenp@4037: 
never@2658:   InstanceMirrorKlass_OOP_ITERATE(                                                    \
never@2658:     start_of_static_fields(obj), java_lang_Class::static_oop_field_count(obj),        \
never@2658:     MarkSweep::mark_and_push(p),                                                      \
never@2658:     assert_is_in_closed_subset)
never@2658: }
never@2658: 
never@2658: #ifndef SERIALGC
coleenp@4047: void InstanceMirrorKlass::oop_follow_contents(ParCompactionManager* cm,
never@2658:                                               oop obj) {
coleenp@4037:   InstanceKlass::oop_follow_contents(cm, obj);
coleenp@4037: 
coleenp@4037:   // Follow the klass field in the mirror.
coleenp@4037:   Klass* klass = java_lang_Class::as_Klass(obj);
coleenp@4037:   if (klass != NULL) {
coleenp@4037:     PSParallelCompact::follow_klass(cm, klass);
coleenp@4037:   } else {
coleenp@4037:     // If klass is NULL then this a mirror for a primitive type.
coleenp@4037:     // We don't have to follow them, since they are handled as strong
coleenp@4037:     // roots in Universe::oops_do.
coleenp@4037:     assert(java_lang_Class::is_primitive(obj), "Sanity check");
coleenp@4037:   }
coleenp@4037: 
never@2658:   InstanceMirrorKlass_OOP_ITERATE(                                                    \
never@2658:     start_of_static_fields(obj), java_lang_Class::static_oop_field_count(obj),        \
never@2658:     PSParallelCompact::mark_and_push(cm, p),                                          \
never@2658:     assert_is_in)
never@2658: }
never@2658: #endif // SERIALGC
never@2658: 
coleenp@4047: int InstanceMirrorKlass::oop_adjust_pointers(oop obj) {
never@2658:   int size = oop_size(obj);
coleenp@4037:   InstanceKlass::oop_adjust_pointers(obj);
coleenp@4037: 
coleenp@4037:   // Follow the klass field in the mirror.
coleenp@4037:   Klass* klass = java_lang_Class::as_Klass(obj);
coleenp@4037:   if (klass != NULL) {
coleenp@4037:     MarkSweep::adjust_klass(klass);
coleenp@4037:   } else {
coleenp@4037:     // If klass is NULL then this a mirror for a primitive type.
coleenp@4037:     // We don't have to follow them, since they are handled as strong
coleenp@4037:     // roots in Universe::oops_do.
coleenp@4037:     assert(java_lang_Class::is_primitive(obj), "Sanity check");
coleenp@4037:   }
coleenp@4037: 
never@2658:   InstanceMirrorKlass_OOP_ITERATE(                                                    \
never@2658:     start_of_static_fields(obj), java_lang_Class::static_oop_field_count(obj),        \
never@2658:     MarkSweep::adjust_pointer(p),                                                     \
never@2658:     assert_nothing)
never@2658:   return size;
never@2658: }
never@2658: 
never@2658: #define InstanceMirrorKlass_SPECIALIZED_OOP_ITERATE_DEFN(T, nv_suffix)                \
never@2658:   InstanceMirrorKlass_OOP_ITERATE(                                                    \
never@2658:     start_of_static_fields(obj), java_lang_Class::static_oop_field_count(obj),        \
never@2658:       (closure)->do_oop##nv_suffix(p),                                                \
never@2658:     assert_is_in_closed_subset)                                                       \
never@2658:   return oop_size(obj);                                                               \
never@2658: 
never@2658: #define InstanceMirrorKlass_BOUNDED_SPECIALIZED_OOP_ITERATE(T, nv_suffix, mr)         \
never@2658:   InstanceMirrorKlass_BOUNDED_OOP_ITERATE(                                            \
never@2658:     start_of_static_fields(obj), java_lang_Class::static_oop_field_count(obj),        \
never@2658:     mr.start(), mr.end(),                                                             \
never@2658:       (closure)->do_oop##nv_suffix(p),                                                \
never@2658:     assert_is_in_closed_subset)                                                       \
never@2658:   return oop_size(obj);                                                               \
never@2658: 
never@2658: 
coleenp@4037: #define if_do_metadata_checked(closure, nv_suffix)                    \
coleenp@4037:   /* Make sure the non-virtual and the virtual versions match. */     \
coleenp@4037:   assert(closure->do_metadata##nv_suffix() == closure->do_metadata(), \
coleenp@4037:       "Inconsistency in do_metadata");                                \
coleenp@4037:   if (closure->do_metadata##nv_suffix())
coleenp@4037: 
coleenp@4047: // Macro to define InstanceMirrorKlass::oop_oop_iterate for virtual/nonvirtual for
never@2658: // all closures.  Macros calling macros above for each oop size.
never@2658: 
never@2658: #define InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix)           \
never@2658:                                                                                       \
coleenp@4047: int InstanceMirrorKlass::                                                             \
never@2658: oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) {                        \
never@2658:   /* Get size before changing pointers */                                             \
never@2658:   SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);      \
never@2658:                                                                                       \
coleenp@4037:   InstanceKlass::oop_oop_iterate##nv_suffix(obj, closure);                            \
coleenp@4037:                                                                                       \
coleenp@4037:   if_do_metadata_checked(closure, nv_suffix) {                                        \
coleenp@4037:     Klass* klass = java_lang_Class::as_Klass(obj);                                    \
coleenp@4037:     /* We'll get NULL for primitive mirrors. */                                       \
coleenp@4037:     if (klass != NULL) {                                                              \
coleenp@4037:       closure->do_klass##nv_suffix(klass);                                            \
coleenp@4037:     }                                                                                 \
coleenp@4037:   }                                                                                   \
never@2658:                                                                                       \
never@2658:   if (UseCompressedOops) {                                                            \
never@2658:     InstanceMirrorKlass_SPECIALIZED_OOP_ITERATE_DEFN(narrowOop, nv_suffix);           \
never@2658:   } else {                                                                            \
never@2658:     InstanceMirrorKlass_SPECIALIZED_OOP_ITERATE_DEFN(oop, nv_suffix);                 \
never@2658:   }                                                                                   \
never@2658: }
never@2658: 
never@2658: #ifndef SERIALGC
never@2658: #define InstanceMirrorKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
never@2658:                                                                                       \
coleenp@4047: int InstanceMirrorKlass::                                                             \
never@2658: oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) {              \
never@2658:   /* Get size before changing pointers */                                             \
never@2658:   SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);      \
never@2658:                                                                                       \
coleenp@4037:   InstanceKlass::oop_oop_iterate_backwards##nv_suffix(obj, closure);                  \
never@2658:                                                                                       \
never@2658:   if (UseCompressedOops) {                                                            \
never@2658:     InstanceMirrorKlass_SPECIALIZED_OOP_ITERATE_DEFN(narrowOop, nv_suffix);           \
never@2658:   } else {                                                                            \
never@2658:     InstanceMirrorKlass_SPECIALIZED_OOP_ITERATE_DEFN(oop, nv_suffix);                 \
never@2658:   }                                                                                   \
never@2658: }
never@2658: #endif // !SERIALGC
never@2658: 
never@2658: 
never@2658: #define InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix)         \
never@2658:                                                                                       \
coleenp@4047: int InstanceMirrorKlass::                                                             \
never@2658: oop_oop_iterate##nv_suffix##_m(oop obj,                                               \
never@2658:                                OopClosureType* closure,                               \
never@2658:                                MemRegion mr) {                                        \
never@2658:   SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);      \
never@2658:                                                                                       \
coleenp@4037:   InstanceKlass::oop_oop_iterate##nv_suffix##_m(obj, closure, mr);                    \
coleenp@4037:                                                                                       \
coleenp@4037:   if_do_metadata_checked(closure, nv_suffix) {                                        \
coleenp@4037:     if (mr.contains(obj)) {                                                           \
coleenp@4037:       Klass* klass = java_lang_Class::as_Klass(obj);                                  \
coleenp@4037:       /* We'll get NULL for primitive mirrors. */                                     \
coleenp@4037:       if (klass != NULL) {                                                            \
coleenp@4037:         closure->do_klass##nv_suffix(klass);                                          \
coleenp@4037:       }                                                                               \
coleenp@4037:     }                                                                                 \
coleenp@4037:   }                                                                                   \
coleenp@4037:                                                                                       \
never@2658:   if (UseCompressedOops) {                                                            \
never@2658:     InstanceMirrorKlass_BOUNDED_SPECIALIZED_OOP_ITERATE(narrowOop, nv_suffix, mr);    \
never@2658:   } else {                                                                            \
never@2658:     InstanceMirrorKlass_BOUNDED_SPECIALIZED_OOP_ITERATE(oop, nv_suffix, mr);          \
never@2658:   }                                                                                   \
never@2658: }
never@2658: 
never@2658: ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN)
never@2658: ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN)
never@2658: #ifndef SERIALGC
never@2658: ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceMirrorKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
never@2658: ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceMirrorKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
never@2658: #endif // SERIALGC
never@2658: ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN_m)
never@2658: ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN_m)
never@2658: 
never@2658: #ifndef SERIALGC
coleenp@4047: void InstanceMirrorKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
coleenp@4037:   // Note that we don't have to follow the mirror -> klass pointer, since all
coleenp@4037:   // klasses that are dirty will be scavenged when we iterate over the
coleenp@4037:   // ClassLoaderData objects.
coleenp@4037: 
coleenp@4037:   InstanceKlass::oop_push_contents(pm, obj);
never@2658:   InstanceMirrorKlass_OOP_ITERATE(                                            \
never@2658:     start_of_static_fields(obj), java_lang_Class::static_oop_field_count(obj),\
never@2658:     if (PSScavenge::should_scavenge(p)) {                                     \
never@2658:       pm->claim_or_forward_depth(p);                                          \
never@2658:     },                                                                        \
never@2658:     assert_nothing )
never@2658: }
never@2658: 
coleenp@4047: int InstanceMirrorKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
coleenp@4037:   int size = oop_size(obj);
coleenp@4037:   InstanceKlass::oop_update_pointers(cm, obj);
coleenp@4037: 
coleenp@4037:   // Follow the klass field in the mirror.
coleenp@4037:   Klass* klass = java_lang_Class::as_Klass(obj);
coleenp@4037:   if (klass != NULL) {
coleenp@4037:     PSParallelCompact::adjust_klass(cm, klass);
coleenp@4037:   } else {
coleenp@4037:     // If klass is NULL then this a mirror for a primitive type.
coleenp@4037:     // We don't have to follow them, since they are handled as strong
coleenp@4037:     // roots in Universe::oops_do.
coleenp@4037:     assert(java_lang_Class::is_primitive(obj), "Sanity check");
coleenp@4037:   }
coleenp@4037: 
never@2658:   InstanceMirrorKlass_OOP_ITERATE(                                            \
never@2658:     start_of_static_fields(obj), java_lang_Class::static_oop_field_count(obj),\
never@2658:     PSParallelCompact::adjust_pointer(p),                                     \
never@2658:     assert_nothing)
coleenp@4037:   return size;
never@2658: }
never@2658: #endif // SERIALGC
never@2658: 
coleenp@4047: int InstanceMirrorKlass::instance_size(KlassHandle k) {
never@2658:   if (k() != NULL && k->oop_is_instance()) {
coleenp@4037:     return align_object_size(size_helper() + InstanceKlass::cast(k())->static_field_size());
never@2658:   }
never@2658:   return size_helper();
never@2658: }
never@2658: 
coleenp@4047: instanceOop InstanceMirrorKlass::allocate_instance(KlassHandle k, TRAPS) {
never@2658:   // Query before forming handle.
never@2658:   int size = instance_size(k);
coleenp@4037:   KlassHandle h_k(THREAD, this);
never@3205:   instanceOop i = (instanceOop) CollectedHeap::Class_obj_allocate(h_k, size, k, CHECK_NULL);
never@2658:   return i;
never@2658: }
never@2658: 
coleenp@4047: int InstanceMirrorKlass::oop_size(oop obj) const {
never@2658:   return java_lang_Class::oop_size(obj);
never@2658: }
never@2658: 
coleenp@4047: int InstanceMirrorKlass::compute_static_oop_field_count(oop obj) {
coleenp@4037:   Klass* k = java_lang_Class::as_Klass(obj);
coleenp@4037:   if (k != NULL && k->oop_is_instance()) {
coleenp@4037:     return InstanceKlass::cast(k)->static_oop_field_count();
never@2658:   }
never@2658:   return 0;
never@2658: }