src/hotspot/share/oops/instanceClassLoaderKlass.inline.hpp
changeset 50752 9d62da00bf15
parent 49982 9042ffe5b7fe
child 51516 7c3891b9f1e0
equal deleted inserted replaced
50751:d9132bdf6c30 50752:9d62da00bf15
    24 
    24 
    25 #ifndef SHARE_VM_OOPS_INSTANCECLASSLOADERKLASS_INLINE_HPP
    25 #ifndef SHARE_VM_OOPS_INSTANCECLASSLOADERKLASS_INLINE_HPP
    26 #define SHARE_VM_OOPS_INSTANCECLASSLOADERKLASS_INLINE_HPP
    26 #define SHARE_VM_OOPS_INSTANCECLASSLOADERKLASS_INLINE_HPP
    27 
    27 
    28 #include "classfile/javaClasses.hpp"
    28 #include "classfile/javaClasses.hpp"
    29 #include "memory/iterator.inline.hpp"
    29 #include "memory/iterator.hpp"
    30 #include "oops/instanceClassLoaderKlass.hpp"
    30 #include "oops/instanceClassLoaderKlass.hpp"
    31 #include "oops/instanceKlass.inline.hpp"
    31 #include "oops/instanceKlass.inline.hpp"
    32 #include "oops/oop.inline.hpp"
    32 #include "oops/oop.inline.hpp"
    33 #include "utilities/debug.hpp"
    33 #include "utilities/debug.hpp"
    34 #include "utilities/globalDefinitions.hpp"
    34 #include "utilities/globalDefinitions.hpp"
    35 #include "utilities/macros.hpp"
    35 #include "utilities/macros.hpp"
    36 
    36 
    37 template <bool nv, class OopClosureType>
    37 template <typename T, class OopClosureType>
    38 inline void InstanceClassLoaderKlass::oop_oop_iterate(oop obj, OopClosureType* closure) {
    38 inline void InstanceClassLoaderKlass::oop_oop_iterate(oop obj, OopClosureType* closure) {
    39   InstanceKlass::oop_oop_iterate<nv>(obj, closure);
    39   InstanceKlass::oop_oop_iterate<T>(obj, closure);
    40 
    40 
    41   if (Devirtualizer<nv>::do_metadata(closure)) {
    41   if (Devirtualizer::do_metadata(closure)) {
    42     ClassLoaderData* cld = java_lang_ClassLoader::loader_data(obj);
    42     ClassLoaderData* cld = java_lang_ClassLoader::loader_data(obj);
    43     // cld can be null if we have a non-registered class loader.
    43     // cld can be null if we have a non-registered class loader.
    44     if (cld != NULL) {
    44     if (cld != NULL) {
    45       Devirtualizer<nv>::do_cld(closure, cld);
    45       Devirtualizer::do_cld(closure, cld);
    46     }
    46     }
    47   }
    47   }
    48 }
    48 }
    49 
    49 
    50 #if INCLUDE_OOP_OOP_ITERATE_BACKWARDS
    50 template <typename T, class OopClosureType>
    51 template <bool nv, class OopClosureType>
       
    52 inline void InstanceClassLoaderKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) {
    51 inline void InstanceClassLoaderKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) {
    53   InstanceKlass::oop_oop_iterate_reverse<nv>(obj, closure);
    52   InstanceKlass::oop_oop_iterate_reverse<T>(obj, closure);
    54 
    53 
    55   assert(!Devirtualizer<nv>::do_metadata(closure),
    54   assert(!Devirtualizer::do_metadata(closure),
    56       "Code to handle metadata is not implemented");
    55       "Code to handle metadata is not implemented");
    57 }
    56 }
    58 #endif // INCLUDE_OOP_OOP_ITERATE_BACKWARDS
       
    59 
    57 
       
    58 template <typename T, class OopClosureType>
       
    59 inline void InstanceClassLoaderKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) {
       
    60   InstanceKlass::oop_oop_iterate_bounded<T>(obj, closure, mr);
    60 
    61 
    61 template <bool nv, class OopClosureType>
    62   if (Devirtualizer::do_metadata(closure)) {
    62 inline void InstanceClassLoaderKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) {
       
    63   InstanceKlass::oop_oop_iterate_bounded<nv>(obj, closure, mr);
       
    64 
       
    65   if (Devirtualizer<nv>::do_metadata(closure)) {
       
    66     if (mr.contains(obj)) {
    63     if (mr.contains(obj)) {
    67       ClassLoaderData* cld = java_lang_ClassLoader::loader_data(obj);
    64       ClassLoaderData* cld = java_lang_ClassLoader::loader_data(obj);
    68       // cld can be null if we have a non-registered class loader.
    65       // cld can be null if we have a non-registered class loader.
    69       if (cld != NULL) {
    66       if (cld != NULL) {
    70         Devirtualizer<nv>::do_cld(closure, cld);
    67         Devirtualizer::do_cld(closure, cld);
    71       }
    68       }
    72     }
    69     }
    73   }
    70   }
    74 }
    71 }
    75 
    72 
    76 #define ALL_INSTANCE_CLASS_LOADER_KLASS_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix)  \
       
    77   OOP_OOP_ITERATE_DEFN(          InstanceClassLoaderKlass, OopClosureType, nv_suffix)    \
       
    78   OOP_OOP_ITERATE_DEFN_BOUNDED(  InstanceClassLoaderKlass, OopClosureType, nv_suffix)    \
       
    79   OOP_OOP_ITERATE_DEFN_BACKWARDS(InstanceClassLoaderKlass, OopClosureType, nv_suffix)
       
    80 
       
    81 #endif // SHARE_VM_OOPS_INSTANCECLASSLOADERKLASS_INLINE_HPP
    73 #endif // SHARE_VM_OOPS_INSTANCECLASSLOADERKLASS_INLINE_HPP