1 /*

     2  * Copyright (c) 2015, 2016, 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 #ifndef SHARE_VM_OOPS_INSTANCEKLASS_INLINE_HPP

    26 #define SHARE_VM_OOPS_INSTANCEKLASS_INLINE_HPP

    27 

    28 #include "memory/iterator.hpp"

    29 #include "oops/instanceKlass.hpp"

    30 #include "oops/klass.hpp"

    31 #include "oops/oop.inline.hpp"

    32 #include "runtime/orderAccess.inline.hpp"

    33 #include "utilities/debug.hpp"

    34 #include "utilities/globalDefinitions.hpp"

    35 #include "utilities/macros.hpp"

    36 

    37 inline Klass* InstanceKlass::array_klasses_acquire() const {

    38   return (Klass*) OrderAccess::load_ptr_acquire(&_array_klasses);

    39 }

    40 

    41 inline void InstanceKlass::release_set_array_klasses(Klass* k) {

    42   OrderAccess::release_store_ptr(&_array_klasses, k);

    43 }

    44 

    45 inline jmethodID* InstanceKlass::methods_jmethod_ids_acquire() const {

    46   return (jmethodID*)OrderAccess::load_ptr_acquire(&_methods_jmethod_ids);

    47 }

    48 

    49 inline void InstanceKlass::release_set_methods_jmethod_ids(jmethodID* jmeths) {

    50   OrderAccess::release_store_ptr(&_methods_jmethod_ids, jmeths);

    51 }

    52 

    53 // The iteration over the oops in objects is a hot path in the GC code.

    54 // By force inlining the following functions, we get similar GC performance

    55 // as the previous macro based implementation.

    56 

    57 template <bool nv, typename T, class OopClosureType>

    58 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_map(OopMapBlock* map, oop obj, OopClosureType* closure) {

    59   T* p         = (T*)obj->obj_field_addr<T>(map->offset());

    60   T* const end = p + map->count();

    61 

    62   for (; p < end; ++p) {

    63     Devirtualizer<nv>::do_oop(closure, p);

    64   }

    65 }

    66 

    67 #if INCLUDE_ALL_GCS

    68 template <bool nv, typename T, class OopClosureType>

    69 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_map_reverse(OopMapBlock* map, oop obj, OopClosureType* closure) {

    70   T* const start = (T*)obj->obj_field_addr<T>(map->offset());

    71   T*       p     = start + map->count();

    72 

    73   while (start < p) {

    74     --p;

    75     Devirtualizer<nv>::do_oop(closure, p);

    76   }

    77 }

    78 #endif

    79 

    80 template <bool nv, typename T, class OopClosureType>

    81 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_map_bounded(OopMapBlock* map, oop obj, OopClosureType* closure, MemRegion mr) {

    82   T* p   = (T*)obj->obj_field_addr<T>(map->offset());

    83   T* end = p + map->count();

    84 

    85   T* const l   = (T*)mr.start();

    86   T* const h   = (T*)mr.end();

    87   assert(mask_bits((intptr_t)l, sizeof(T)-1) == 0 &&

    88          mask_bits((intptr_t)h, sizeof(T)-1) == 0,

    89          "bounded region must be properly aligned");

    90 

    91   if (p < l) {

    92     p = l;

    93   }

    94   if (end > h) {

    95     end = h;

    96   }

    97 

    98   for (;p < end; ++p) {

    99     Devirtualizer<nv>::do_oop(closure, p);

   100   }

   101 }

   102 

   103 template <bool nv, typename T, class OopClosureType>

   104 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_maps_specialized(oop obj, OopClosureType* closure) {

   105   OopMapBlock* map           = start_of_nonstatic_oop_maps();

   106   OopMapBlock* const end_map = map + nonstatic_oop_map_count();

   107 

   108   for (; map < end_map; ++map) {

   109     oop_oop_iterate_oop_map<nv, T>(map, obj, closure);

   110   }

   111 }

   112 

   113 #if INCLUDE_ALL_GCS

   114 template <bool nv, typename T, class OopClosureType>

   115 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_maps_specialized_reverse(oop obj, OopClosureType* closure) {

   116   OopMapBlock* const start_map = start_of_nonstatic_oop_maps();

   117   OopMapBlock* map             = start_map + nonstatic_oop_map_count();

   118 

   119   while (start_map < map) {

   120     --map;

   121     oop_oop_iterate_oop_map_reverse<nv, T>(map, obj, closure);

   122   }

   123 }

   124 #endif

   125 

   126 template <bool nv, typename T, class OopClosureType>

   127 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_maps_specialized_bounded(oop obj, OopClosureType* closure, MemRegion mr) {

   128   OopMapBlock* map           = start_of_nonstatic_oop_maps();

   129   OopMapBlock* const end_map = map + nonstatic_oop_map_count();

   130 

   131   for (;map < end_map; ++map) {

   132     oop_oop_iterate_oop_map_bounded<nv, T>(map, obj, closure, mr);

   133   }

   134 }

   135 

   136 template <bool nv, class OopClosureType>

   137 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_maps(oop obj, OopClosureType* closure) {

   138   if (UseCompressedOops) {

   139     oop_oop_iterate_oop_maps_specialized<nv, narrowOop>(obj, closure);

   140   } else {

   141     oop_oop_iterate_oop_maps_specialized<nv, oop>(obj, closure);

   142   }

   143 }

   144 

   145 #if INCLUDE_ALL_GCS

   146 template <bool nv, class OopClosureType>

   147 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_maps_reverse(oop obj, OopClosureType* closure) {

   148   if (UseCompressedOops) {

   149     oop_oop_iterate_oop_maps_specialized_reverse<nv, narrowOop>(obj, closure);

   150   } else {

   151     oop_oop_iterate_oop_maps_specialized_reverse<nv, oop>(obj, closure);

   152   }

   153 }

   154 #endif

   155 

   156 template <bool nv, class OopClosureType>

   157 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_maps_bounded(oop obj, OopClosureType* closure, MemRegion mr) {

   158   if (UseCompressedOops) {

   159     oop_oop_iterate_oop_maps_specialized_bounded<nv, narrowOop>(obj, closure, mr);

   160   } else {

   161     oop_oop_iterate_oop_maps_specialized_bounded<nv, oop>(obj, closure, mr);

   162   }

   163 }

   164 

   165 template <bool nv, class OopClosureType>

   166 ALWAYSINLINE int InstanceKlass::oop_oop_iterate(oop obj, OopClosureType* closure) {

   167   if (Devirtualizer<nv>::do_metadata(closure)) {

   168     Devirtualizer<nv>::do_klass(closure, this);

   169   }

   170 

   171   oop_oop_iterate_oop_maps<nv>(obj, closure);

   172 

   173   return size_helper();

   174 }

   175 

   176 #if INCLUDE_ALL_GCS

   177 template <bool nv, class OopClosureType>

   178 ALWAYSINLINE int InstanceKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) {

   179   assert(!Devirtualizer<nv>::do_metadata(closure),

   180       "Code to handle metadata is not implemented");

   181 

   182   oop_oop_iterate_oop_maps_reverse<nv>(obj, closure);

   183 

   184   return size_helper();

   185 }

   186 #endif

   187 

   188 template <bool nv, class OopClosureType>

   189 ALWAYSINLINE int InstanceKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) {

   190   if (Devirtualizer<nv>::do_metadata(closure)) {

   191     if (mr.contains(obj)) {

   192       Devirtualizer<nv>::do_klass(closure, this);

   193     }

   194   }

   195 

   196   oop_oop_iterate_oop_maps_bounded<nv>(obj, closure, mr);

   197 

   198   return size_helper();

   199 }

   200 

   201 #define ALL_INSTANCE_KLASS_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix)  \

   202   OOP_OOP_ITERATE_DEFN(          InstanceKlass, OopClosureType, nv_suffix)  \

   203   OOP_OOP_ITERATE_DEFN_BOUNDED(  InstanceKlass, OopClosureType, nv_suffix)  \

   204   OOP_OOP_ITERATE_DEFN_BACKWARDS(InstanceKlass, OopClosureType, nv_suffix)

   205 

   206 #endif // SHARE_VM_OOPS_INSTANCEKLASS_INLINE_HPP