1 /* 2 * Copyright (c) 2019, 2025, 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 "cds/cdsConfig.hpp" 26 #include "cds/serializeClosure.hpp" 27 #include "classfile/vmClasses.hpp" 28 #include "compiler/oopMap.inline.hpp" 29 #include "gc/shared/gc_globals.hpp" 30 #include "memory/oopFactory.hpp" 31 #include "memory/resourceArea.hpp" 32 #include "oops/instanceStackChunkKlass.inline.hpp" 33 #include "oops/stackChunkOop.inline.hpp" 34 #include "runtime/continuation.hpp" 35 #include "runtime/continuationJavaClasses.inline.hpp" 36 #include "runtime/frame.hpp" 37 #include "runtime/handles.hpp" 38 #include "runtime/registerMap.hpp" 39 #include "runtime/smallRegisterMap.inline.hpp" 40 #include "runtime/stackChunkFrameStream.inline.hpp" 41 #include "utilities/devirtualizer.inline.hpp" 42 #include "utilities/globalDefinitions.hpp" 43 #include "utilities/macros.hpp" 44 #include "utilities/ostream.hpp" 45 46 int InstanceStackChunkKlass::_offset_of_stack = 0; 47 48 #if INCLUDE_CDS 49 void InstanceStackChunkKlass::serialize_offsets(SerializeClosure* f) { 50 f->do_int(&_offset_of_stack); 51 } 52 #endif 53 54 InstanceStackChunkKlass::InstanceStackChunkKlass() { 55 assert(CDSConfig::is_dumping_static_archive() || CDSConfig::is_using_archive(), "only for CDS"); 56 } 57 58 InstanceStackChunkKlass::InstanceStackChunkKlass(const ClassFileParser& parser) 59 : InstanceKlass(parser, Kind) { 60 // Change the layout_helper to use the slow path because StackChunkOops are 61 // variable sized InstanceOops. 62 const jint lh = Klass::instance_layout_helper(size_helper(), true); 63 set_layout_helper(lh); 64 } 65 66 size_t InstanceStackChunkKlass::oop_size(oop obj) const { 67 return instance_size(jdk_internal_vm_StackChunk::size(obj)); 68 } 69 70 #ifndef PRODUCT 71 void InstanceStackChunkKlass::oop_print_on(oop obj, outputStream* st) { 72 print_chunk(stackChunkOopDesc::cast(obj), false, st); 73 } 74 #endif 75 76 template<typename OopClosureType> 77 class StackChunkOopIterateFilterClosure: public OopClosure { 78 private: 79 OopClosureType* const _closure; 80 MemRegion _bound; 81 82 public: 83 84 StackChunkOopIterateFilterClosure(OopClosureType* closure, MemRegion bound) 85 : _closure(closure), 86 _bound(bound) {} 87 88 virtual void do_oop(oop* p) override { do_oop_work(p); } 89 virtual void do_oop(narrowOop* p) override { do_oop_work(p); } 90 91 template <typename T> 92 void do_oop_work(T* p) { 93 if (_bound.contains(p)) { 94 Devirtualizer::do_oop(_closure, p); 95 } 96 } 97 }; 98 99 class DoMethodsStackChunkFrameClosure { 100 OopIterateClosure* _closure; 101 102 public: 103 DoMethodsStackChunkFrameClosure(OopIterateClosure* cl) : _closure(cl) {} 104 105 template <ChunkFrames frame_kind, typename RegisterMapT> 106 bool do_frame(const StackChunkFrameStream<frame_kind>& f, const RegisterMapT* map) { 107 if (f.is_interpreted()) { 108 Method* m = f.to_frame().interpreter_frame_method(); 109 _closure->do_method(m); 110 } else if (f.is_compiled()) { 111 nmethod* nm = f.cb()->as_nmethod(); 112 // The do_nmethod function takes care of having the right synchronization 113 // when keeping the nmethod alive during concurrent execution. 114 _closure->do_nmethod(nm); 115 // There is no need to mark the Method, as class redefinition will walk the 116 // CodeCache, noting their Methods 117 } 118 return true; 119 } 120 }; 121 122 void InstanceStackChunkKlass::do_methods(stackChunkOop chunk, OopIterateClosure* cl) { 123 DoMethodsStackChunkFrameClosure closure(cl); 124 chunk->iterate_stack(&closure); 125 } 126 127 class OopIterateStackChunkFrameClosure { 128 OopIterateClosure* const _closure; 129 MemRegion _bound; 130 const bool _do_metadata; 131 132 public: 133 OopIterateStackChunkFrameClosure(OopIterateClosure* closure, MemRegion mr) 134 : _closure(closure), 135 _bound(mr), 136 _do_metadata(_closure->do_metadata()) { 137 assert(_closure != nullptr, "must be set"); 138 } 139 140 template <ChunkFrames frame_kind, typename RegisterMapT> 141 bool do_frame(const StackChunkFrameStream<frame_kind>& f, const RegisterMapT* map) { 142 if (_do_metadata) { 143 DoMethodsStackChunkFrameClosure(_closure).do_frame(f, map); 144 } 145 146 StackChunkOopIterateFilterClosure<OopIterateClosure> cl(_closure, _bound); 147 f.iterate_oops(&cl, map); 148 149 return true; 150 } 151 }; 152 153 void InstanceStackChunkKlass::oop_oop_iterate_stack_slow(stackChunkOop chunk, OopIterateClosure* closure, MemRegion mr) { 154 if (UseZGC || UseShenandoahGC) { 155 // An OopClosure could apply barriers to a stack chunk. The side effects 156 // of the load barriers could destroy derived pointers, which must be 157 // processed before their base oop is processed. So we force processing 158 // of derived pointers before applying the closures. 159 chunk->relativize_derived_pointers_concurrently(); 160 } 161 OopIterateStackChunkFrameClosure frame_closure(closure, mr); 162 chunk->iterate_stack(&frame_closure); 163 } 164 165 template <typename OopT> 166 void InstanceStackChunkKlass::oop_oop_iterate_lockstack(stackChunkOop chunk, OopIterateClosure* closure, MemRegion mr) { 167 if (LockingMode != LM_LIGHTWEIGHT) { 168 return; 169 } 170 171 StackChunkOopIterateFilterClosure<OopIterateClosure> cl(closure, mr); 172 if (chunk->has_bitmap()) { 173 chunk->iterate_lockstack<OopT>(&cl); 174 } else { 175 chunk->iterate_lockstack<oop>(&cl); 176 } 177 } 178 179 template void InstanceStackChunkKlass::oop_oop_iterate_lockstack<oop>(stackChunkOop chunk, OopIterateClosure* closure, MemRegion mr); 180 template void InstanceStackChunkKlass::oop_oop_iterate_lockstack<narrowOop>(stackChunkOop chunk, OopIterateClosure* closure, MemRegion mr); 181 182 #ifdef ASSERT 183 184 class DescribeStackChunkClosure { 185 stackChunkOop _chunk; 186 FrameValues _values; 187 RegisterMap _map; 188 int _frame_no; 189 190 public: 191 DescribeStackChunkClosure(stackChunkOop chunk) 192 : _chunk(chunk), 193 _map(nullptr, 194 RegisterMap::UpdateMap::include, 195 RegisterMap::ProcessFrames::skip, 196 RegisterMap::WalkContinuation::include), 197 _frame_no(0) { 198 _map.set_include_argument_oops(false); 199 } 200 201 const RegisterMap* get_map(const RegisterMap* map, intptr_t* sp) { return map; } 202 const RegisterMap* get_map(const SmallRegisterMap* map, intptr_t* sp) { return map->copy_to_RegisterMap(&_map, sp); } 203 204 template <ChunkFrames frame_kind, typename RegisterMapT> 205 bool do_frame(const StackChunkFrameStream<frame_kind>& f, const RegisterMapT* map) { 206 ResetNoHandleMark rnhm; 207 HandleMark hm(Thread::current()); 208 209 frame fr = f.to_frame(); 210 fr.describe(_values, _frame_no++, get_map(map, f.sp())); 211 return true; 212 } 213 214 void describe_chunk() { 215 // _values.describe(-1, _chunk->start_address(), "CHUNK START"); 216 _values.describe(-1, _chunk->sp_address(), "CHUNK SP"); 217 _values.describe(-1, _chunk->bottom_address() - 1, "CHUNK ARGS"); 218 _values.describe(-1, _chunk->end_address() - 1, "CHUNK END"); 219 } 220 221 void print_on(outputStream* out) { 222 if (_frame_no > 0) { 223 describe_chunk(); 224 _values.print_on(_chunk, out); 225 } else { 226 out->print_cr(" EMPTY"); 227 } 228 } 229 }; 230 #endif 231 232 class PrintStackChunkClosure { 233 outputStream* _st; 234 235 public: 236 PrintStackChunkClosure(outputStream* st) : _st(st) {} 237 238 template <ChunkFrames frame_kind, typename RegisterMapT> 239 bool do_frame(const StackChunkFrameStream<frame_kind>& fs, const RegisterMapT* map) { 240 frame f = fs.to_frame(); 241 _st->print_cr("-- frame sp: " PTR_FORMAT " interpreted: %d size: %d argsize: %d", 242 p2i(fs.sp()), fs.is_interpreted(), f.frame_size(), 243 fs.is_interpreted() || fs.is_stub() ? 0 : f.compiled_frame_stack_argsize()); 244 #ifdef ASSERT 245 f.print_value_on(_st); 246 #else 247 f.print_on(_st); 248 #endif 249 const ImmutableOopMap* oopmap = fs.oopmap(); 250 if (oopmap != nullptr) { 251 oopmap->print_on(_st); 252 _st->cr(); 253 } 254 return true; 255 } 256 }; 257 258 void InstanceStackChunkKlass::print_chunk(const stackChunkOop c, bool verbose, outputStream* st) { 259 if (c == nullptr) { 260 st->print_cr("CHUNK null"); 261 return; 262 } 263 264 st->print_cr("CHUNK " PTR_FORMAT " " PTR_FORMAT " - " PTR_FORMAT " :: " INTPTR_FORMAT, 265 p2i(c), p2i(c->start_address()), p2i(c->end_address()), c->identity_hash()); 266 st->print_cr(" barriers: %d gc_mode: %d bitmap: %d parent: " PTR_FORMAT, 267 c->requires_barriers(), c->is_gc_mode(), c->has_bitmap(), p2i(c->parent())); 268 st->print_cr(" flags mixed: %d", c->has_mixed_frames()); 269 st->print_cr(" size: %d bottom: %d max_size: %d sp: %d pc: " PTR_FORMAT, 270 c->stack_size(), c->bottom(), c->max_thawing_size(), c->sp(), p2i(c->pc())); 271 272 if (verbose) { 273 st->cr(); 274 st->print_cr("------ chunk frames end: " PTR_FORMAT, p2i(c->bottom_address())); 275 PrintStackChunkClosure closure(st); 276 c->iterate_stack(&closure); 277 st->print_cr("------"); 278 279 #ifdef ASSERT 280 ResourceMark rm; 281 DescribeStackChunkClosure describe(c); 282 c->iterate_stack(&describe); 283 describe.print_on(st); 284 st->print_cr("======"); 285 #endif 286 } 287 } 288 289 void InstanceStackChunkKlass::init_offset_of_stack() { 290 // Cache the offset of the static fields in the Class instance 291 assert(_offset_of_stack == 0, "once"); 292 _offset_of_stack = cast(vmClasses::StackChunk_klass())->size_helper() << LogHeapWordSize; 293 }