1 /*
  2  * Copyright (c) 2021, 2024, 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 #ifndef SHARE_GC_Z_ZITERATOR_INLINE_HPP
 25 #define SHARE_GC_Z_ZITERATOR_INLINE_HPP
 26 
 27 #include "gc/z/zIterator.hpp"
 28 
 29 #include "gc/z/zVerify.hpp"
 30 #include "memory/iterator.inline.hpp"
 31 #include "oops/objArrayOop.hpp"
 32 #include "oops/oop.inline.hpp"
 33 
 34 inline bool ZIterator::is_invisible_object(oop obj) {
 35   // This is a good place to make sure that we can't concurrently iterate over
 36   // objects while VMThread operations think they have exclusive access to the
 37   // object graph.
 38   //
 39   // One example that have caused problems is the JFR Leak Profiler, which
 40   // sets the mark word to a value that makes the object arrays look like
 41   // invisible objects.
 42   z_verify_safepoints_are_blocked();
 43 
 44   return obj->mark_acquire().is_marked();
 45 }
 46 
 47 inline bool ZIterator::is_invisible_object_array(oop obj) {
 48   return is_invisible_object_array(obj, obj->klass());
 49 }
 50 
 51 inline bool ZIterator::is_invisible_object_array(oop obj, Klass* klass) {
 52   return klass->is_objArray_klass() && is_invisible_object(obj);
 53 }
 54 
 55 // These iterators skips invisible object arrays
 56 
 57 template <typename OopClosureT>
 58 void ZIterator::oop_iterate_safe(oop obj, OopClosureT* cl) {
 59   oop_iterate_safe(obj, obj->klass(), cl);
 60 }
 61 
 62 template <typename OopClosureT>
 63 void ZIterator::oop_iterate_safe(oop obj, Klass* klass, OopClosureT* cl) {
 64   // Skip invisible object arrays - we only filter out *object* arrays,
 65   // because that check is arguably faster than the is_invisible_object
 66   // check, and primitive arrays are cheap to call oop_iterate on.
 67   if (!is_invisible_object_array(obj, klass)) {
 68     OopIteratorClosureDispatch::oop_oop_iterate(cl, obj, klass);
 69   }
 70 }
 71 
 72 template <typename OopClosureT>
 73 void ZIterator::oop_iterate(oop obj, OopClosureT* cl) {
 74   assert(!is_invisible_object_array(obj), "not safe");
 75   obj->oop_iterate(cl);
 76 }
 77 
 78 template <typename OopClosureT>
 79 void ZIterator::oop_iterate_elements_range(objArrayOop obj, OopClosureT* cl, int start, int end) {
 80   assert(!is_invisible_object_array(obj), "not safe");
 81   obj->oop_iterate_elements_range(cl, start, end);
 82 }
 83 
 84 template <typename Function>
 85 class ZBasicOopIterateClosure : public BasicOopIterateClosure {
 86 private:
 87   Function _function;
 88 
 89 public:
 90   ZBasicOopIterateClosure(Function function)
 91     : _function(function) {}
 92 
 93   virtual void do_oop(oop* p) {
 94     _function((volatile zpointer*)p);
 95   }
 96 
 97   virtual void do_oop(narrowOop* p_) {
 98     ShouldNotReachHere();
 99   }
100 };
101 
102 // These functions skip invisible roots
103 
104 template <typename Function>
105 void ZIterator::basic_oop_iterate_safe(oop obj, Function function) {
106   basic_oop_iterate_safe(obj, obj->klass(), function);
107 }
108 
109 template <typename Function>
110 void ZIterator::basic_oop_iterate_safe(oop obj, Klass* klass, Function function) {
111   ZBasicOopIterateClosure<Function> cl(function);
112   oop_iterate_safe(obj, klass, &cl);
113 }
114 
115 template <typename Function>
116 void ZIterator::basic_oop_iterate(oop obj, Function function) {
117   ZBasicOopIterateClosure<Function> cl(function);
118   oop_iterate(obj, &cl);
119 }
120 
121 template <typename Function>
122 ZObjectClosure<Function>::ZObjectClosure(Function function)
123   : _function(function) {}
124 
125 template <typename Function>
126 void ZObjectClosure<Function>::do_object(oop obj) {
127   _function(obj);
128 }
129 
130 #endif // SHARE_GC_Z_ZITERATOR_INLINE_HPP