Mercurial > hg > graal-compiler
annotate src/share/vm/runtime/frame.hpp @ 1145:e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
Summary: Autonomic per-worker free block cache sizing, tunable coalition policies, fixes to per-size block statistics, retuned gain and bandwidth of some feedback loop filters to allow quicker reactivity to abrupt changes in ambient demand, and other heuristics to reduce fragmentation of the CMS old gen. Also tightened some assertions, including those related to locking.
Reviewed-by: jmasa
| author | ysr |
|---|---|
| date | Wed, 23 Dec 2009 09:23:54 -0800 |
| parents | 148e5441d916 |
| children | dd57230ba8fe |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 844 | 2 * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved. |
| 0 | 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 typedef class BytecodeInterpreter* interpreterState; | |
| 26 | |
| 27 class CodeBlob; | |
| 28 | |
| 29 | |
| 30 // A frame represents a physical stack frame (an activation). Frames | |
| 31 // can be C or Java frames, and the Java frames can be interpreted or | |
| 32 // compiled. In contrast, vframes represent source-level activations, | |
| 33 // so that one physical frame can correspond to multiple source level | |
| 34 // frames because of inlining. | |
| 35 | |
| 36 class frame VALUE_OBJ_CLASS_SPEC { | |
| 37 private: | |
| 38 // Instance variables: | |
| 39 intptr_t* _sp; // stack pointer (from Thread::last_Java_sp) | |
| 40 address _pc; // program counter (the next instruction after the call) | |
| 41 | |
| 42 CodeBlob* _cb; // CodeBlob that "owns" pc | |
| 43 enum deopt_state { | |
| 44 not_deoptimized, | |
| 45 is_deoptimized, | |
| 46 unknown | |
| 47 }; | |
| 48 | |
| 49 deopt_state _deopt_state; | |
| 50 | |
| 51 public: | |
| 52 // Constructors | |
| 53 frame(); | |
| 54 | |
| 55 // Accessors | |
| 56 | |
| 57 // pc: Returns the pc at which this frame will continue normally. | |
| 58 // It must point at the beginning of the next instruction to execute. | |
| 59 address pc() const { return _pc; } | |
| 60 | |
| 61 // This returns the pc that if you were in the debugger you'd see. Not | |
| 62 // the idealized value in the frame object. This undoes the magic conversion | |
| 63 // that happens for deoptimized frames. In addition it makes the value the | |
| 64 // hardware would want to see in the native frame. The only user (at this point) | |
| 65 // is deoptimization. It likely no one else should ever use it. | |
| 66 address raw_pc() const; | |
| 67 | |
| 68 void set_pc( address newpc ); | |
| 69 | |
| 70 intptr_t* sp() const { return _sp; } | |
| 71 void set_sp( intptr_t* newsp ) { _sp = newsp; } | |
| 72 | |
| 73 | |
| 74 CodeBlob* cb() const { return _cb; } | |
| 75 | |
| 76 // patching operations | |
| 77 void patch_pc(Thread* thread, address pc); | |
| 78 | |
| 79 // Every frame needs to return a unique id which distinguishes it from all other frames. | |
| 80 // For sparc and ia32 use sp. ia64 can have memory frames that are empty so multiple frames | |
| 81 // will have identical sp values. For ia64 the bsp (fp) value will serve. No real frame | |
| 82 // should have an id() of NULL so it is a distinguishing value for an unmatchable frame. | |
| 83 // We also have relationals which allow comparing a frame to anoth frame's id() allow | |
| 84 // us to distinguish younger (more recent activation) from older (less recent activations) | |
| 85 // A NULL id is only valid when comparing for equality. | |
| 86 | |
| 87 intptr_t* id(void) const; | |
| 88 bool is_younger(intptr_t* id) const; | |
| 89 bool is_older(intptr_t* id) const; | |
| 90 | |
| 91 // testers | |
| 92 | |
| 93 // Compares for strict equality. Rarely used or needed. | |
| 94 // It can return a different result than f1.id() == f2.id() | |
| 95 bool equal(frame other) const; | |
| 96 | |
| 97 // type testers | |
| 98 bool is_interpreted_frame() const; | |
| 99 bool is_java_frame() const; | |
| 100 bool is_entry_frame() const; // Java frame called from C? | |
| 101 bool is_native_frame() const; | |
| 102 bool is_runtime_frame() const; | |
| 103 bool is_compiled_frame() const; | |
| 104 bool is_safepoint_blob_frame() const; | |
| 105 bool is_deoptimized_frame() const; | |
| 106 | |
| 107 // testers | |
| 108 bool is_first_frame() const; // oldest frame? (has no sender) | |
| 109 bool is_first_java_frame() const; // same for Java frame | |
| 110 | |
|
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
111 bool is_interpreted_frame_valid(JavaThread* thread) const; // performs sanity checks on interpreted frames. |
| 0 | 112 |
| 113 // tells whether this frame is marked for deoptimization | |
| 114 bool should_be_deoptimized() const; | |
| 115 | |
| 116 // tells whether this frame can be deoptimized | |
| 117 bool can_be_deoptimized() const; | |
| 118 | |
| 119 // returns the frame size in stack slots | |
|
793
eacd97c88873
6848466: frame::frame_size() assertion failure with -XX:+DebugDeoptimization
cfang
parents:
196
diff
changeset
|
120 int frame_size(RegisterMap* map) const; |
| 0 | 121 |
| 122 // returns the sending frame | |
| 123 frame sender(RegisterMap* map) const; | |
| 124 | |
| 125 // for Profiling - acting on another frame. walks sender frames | |
| 126 // if valid. | |
| 127 frame profile_find_Java_sender_frame(JavaThread *thread); | |
| 128 bool safe_for_sender(JavaThread *thread); | |
| 129 | |
| 130 // returns the sender, but skips conversion frames | |
| 131 frame real_sender(RegisterMap* map) const; | |
| 132 | |
| 133 // returns the the sending Java frame, skipping any intermediate C frames | |
| 134 // NB: receiver must not be first frame | |
| 135 frame java_sender() const; | |
| 136 | |
| 137 private: | |
| 138 // Helper methods for better factored code in frame::sender | |
| 139 frame sender_for_compiled_frame(RegisterMap* map) const; | |
| 140 frame sender_for_entry_frame(RegisterMap* map) const; | |
| 141 frame sender_for_interpreter_frame(RegisterMap* map) const; | |
| 142 frame sender_for_native_frame(RegisterMap* map) const; | |
| 143 | |
| 144 // All frames: | |
| 145 | |
| 146 // A low-level interface for vframes: | |
| 147 | |
| 148 public: | |
| 149 | |
| 150 intptr_t* addr_at(int index) const { return &fp()[index]; } | |
| 151 intptr_t at(int index) const { return *addr_at(index); } | |
| 152 | |
| 153 // accessors for locals | |
| 154 oop obj_at(int offset) const { return *obj_at_addr(offset); } | |
| 155 void obj_at_put(int offset, oop value) { *obj_at_addr(offset) = value; } | |
| 156 | |
| 157 jint int_at(int offset) const { return *int_at_addr(offset); } | |
| 158 void int_at_put(int offset, jint value) { *int_at_addr(offset) = value; } | |
| 159 | |
| 160 oop* obj_at_addr(int offset) const { return (oop*) addr_at(offset); } | |
| 161 | |
| 162 oop* adjusted_obj_at_addr(methodOop method, int index) { return obj_at_addr(adjust_offset(method, index)); } | |
| 163 | |
| 164 private: | |
| 165 jint* int_at_addr(int offset) const { return (jint*) addr_at(offset); } | |
| 166 | |
| 167 public: | |
| 168 // Link (i.e., the pointer to the previous frame) | |
| 169 intptr_t* link() const; | |
| 170 void set_link(intptr_t* addr); | |
| 171 | |
| 172 // Return address | |
| 173 address sender_pc() const; | |
| 174 | |
| 175 // Support for deoptimization | |
| 176 void deoptimize(JavaThread* thread, bool thread_is_known_safe = false); | |
| 177 | |
| 178 // The frame's original SP, before any extension by an interpreted callee; | |
| 179 // used for packing debug info into vframeArray objects and vframeArray lookup. | |
| 180 intptr_t* unextended_sp() const; | |
| 181 | |
| 182 // returns the stack pointer of the calling frame | |
| 183 intptr_t* sender_sp() const; | |
| 184 | |
| 185 | |
| 186 // Interpreter frames: | |
| 187 | |
| 188 private: | |
| 189 intptr_t** interpreter_frame_locals_addr() const; | |
| 190 intptr_t* interpreter_frame_bcx_addr() const; | |
| 191 intptr_t* interpreter_frame_mdx_addr() const; | |
| 192 | |
| 193 public: | |
| 194 // Tags for TaggedStackInterpreter | |
| 195 enum Tag { | |
| 196 TagValue = 0, // Important: must be zero to use G0 on sparc. | |
| 197 TagReference = 0x555, // Reference type - is an oop that needs gc. | |
| 198 TagCategory2 = 0x666 // Only used internally by interpreter | |
| 199 // and not written to the java stack. | |
| 200 // The values above are chosen so that misuse causes a crash | |
| 201 // with a recognizable value. | |
| 202 }; | |
| 203 | |
| 204 static Tag tag_for_basic_type(BasicType typ) { | |
| 205 return (typ == T_OBJECT ? TagReference : TagValue); | |
| 206 } | |
| 207 | |
| 208 // Locals | |
| 209 | |
| 210 // The _at version returns a pointer because the address is used for GC. | |
| 211 intptr_t* interpreter_frame_local_at(int index) const; | |
| 212 Tag interpreter_frame_local_tag(int index) const; | |
| 213 void interpreter_frame_set_local_tag(int index, Tag tag) const; | |
| 214 | |
| 215 void interpreter_frame_set_locals(intptr_t* locs); | |
| 216 | |
| 217 // byte code index/pointer (use these functions for unchecked frame access only!) | |
| 218 intptr_t interpreter_frame_bcx() const { return *interpreter_frame_bcx_addr(); } | |
| 219 void interpreter_frame_set_bcx(intptr_t bcx); | |
| 220 | |
| 221 // byte code index | |
| 222 jint interpreter_frame_bci() const; | |
| 223 void interpreter_frame_set_bci(jint bci); | |
| 224 | |
| 225 // byte code pointer | |
| 226 address interpreter_frame_bcp() const; | |
| 227 void interpreter_frame_set_bcp(address bcp); | |
| 228 | |
| 229 // Unchecked access to the method data index/pointer. | |
| 230 // Only use this if you know what you are doing. | |
| 231 intptr_t interpreter_frame_mdx() const { return *interpreter_frame_mdx_addr(); } | |
| 232 void interpreter_frame_set_mdx(intptr_t mdx); | |
| 233 | |
| 234 // method data pointer | |
| 235 address interpreter_frame_mdp() const; | |
| 236 void interpreter_frame_set_mdp(address dp); | |
| 237 | |
| 238 // Find receiver out of caller's (compiled) argument list | |
| 239 oop retrieve_receiver(RegisterMap *reg_map); | |
| 240 | |
| 241 // Return the monitor owner and BasicLock for compiled synchronized | |
| 242 // native methods so that biased locking can revoke the receiver's | |
| 243 // bias if necessary. Takes optional nmethod for this frame as | |
| 244 // argument to avoid performing repeated lookups in code cache. | |
| 245 BasicLock* compiled_synchronized_native_monitor (nmethod* nm = NULL); | |
| 246 oop compiled_synchronized_native_monitor_owner(nmethod* nm = NULL); | |
| 247 | |
| 248 // Find receiver for an invoke when arguments are just pushed on stack (i.e., callee stack-frame is | |
| 249 // not setup) | |
| 250 oop interpreter_callee_receiver(symbolHandle signature) { return *interpreter_callee_receiver_addr(signature); } | |
| 251 | |
| 252 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
253 oop* interpreter_callee_receiver_addr(symbolHandle signature); |
| 0 | 254 |
| 255 | |
| 256 // expression stack (may go up or down, direction == 1 or -1) | |
| 257 public: | |
| 258 intptr_t* interpreter_frame_expression_stack() const; | |
| 259 static jint interpreter_frame_expression_stack_direction(); | |
| 260 | |
| 261 // The _at version returns a pointer because the address is used for GC. | |
| 262 intptr_t* interpreter_frame_expression_stack_at(jint offset) const; | |
| 263 Tag interpreter_frame_expression_stack_tag(jint offset) const; | |
| 264 void interpreter_frame_set_expression_stack_tag(jint offset, Tag tag) const; | |
| 265 | |
| 266 // top of expression stack | |
| 267 intptr_t* interpreter_frame_tos_at(jint offset) const; | |
| 268 intptr_t* interpreter_frame_tos_address() const; | |
| 269 | |
| 270 | |
| 271 jint interpreter_frame_expression_stack_size() const; | |
| 272 | |
| 273 intptr_t* interpreter_frame_sender_sp() const; | |
| 274 | |
| 275 #ifndef CC_INTERP | |
| 276 // template based interpreter deoptimization support | |
| 277 void set_interpreter_frame_sender_sp(intptr_t* sender_sp); | |
| 278 void interpreter_frame_set_monitor_end(BasicObjectLock* value); | |
| 279 #endif // CC_INTERP | |
| 280 | |
| 281 // BasicObjectLocks: | |
| 282 // | |
| 283 // interpreter_frame_monitor_begin is higher in memory than interpreter_frame_monitor_end | |
| 284 // Interpreter_frame_monitor_begin points to one element beyond the oldest one, | |
| 285 // interpreter_frame_monitor_end points to the youngest one, or if there are none, | |
| 286 // it points to one beyond where the first element will be. | |
| 287 // interpreter_frame_monitor_size reports the allocation size of a monitor in the interpreter stack. | |
| 288 // this value is >= BasicObjectLock::size(), and may be rounded up | |
| 289 | |
| 290 BasicObjectLock* interpreter_frame_monitor_begin() const; | |
| 291 BasicObjectLock* interpreter_frame_monitor_end() const; | |
| 292 BasicObjectLock* next_monitor_in_interpreter_frame(BasicObjectLock* current) const; | |
| 293 BasicObjectLock* previous_monitor_in_interpreter_frame(BasicObjectLock* current) const; | |
| 294 static int interpreter_frame_monitor_size(); | |
| 295 | |
| 296 void interpreter_frame_verify_monitor(BasicObjectLock* value) const; | |
| 297 | |
| 298 // Tells whether the current interpreter_frame frame pointer | |
| 299 // corresponds to the old compiled/deoptimized fp | |
| 300 // The receiver used to be a top level frame | |
| 301 bool interpreter_frame_equals_unpacked_fp(intptr_t* fp); | |
| 302 | |
| 303 // Return/result value from this interpreter frame | |
| 304 // If the method return type is T_OBJECT or T_ARRAY populates oop_result | |
| 305 // For other (non-T_VOID) the appropriate field in the jvalue is populated | |
| 306 // with the result value. | |
| 307 // Should only be called when at method exit when the method is not | |
| 308 // exiting due to an exception. | |
| 309 BasicType interpreter_frame_result(oop* oop_result, jvalue* value_result); | |
| 310 | |
| 311 public: | |
| 312 // Method & constant pool cache | |
| 313 methodOop interpreter_frame_method() const; | |
| 314 void interpreter_frame_set_method(methodOop method); | |
| 315 methodOop* interpreter_frame_method_addr() const; | |
| 316 constantPoolCacheOop* interpreter_frame_cache_addr() const; | |
| 317 | |
| 318 public: | |
| 319 // Entry frames | |
| 320 JavaCallWrapper* entry_frame_call_wrapper() const; | |
| 321 intptr_t* entry_frame_argument_at(int offset) const; | |
| 322 | |
| 323 // tells whether there is another chunk of Delta stack above | |
| 324 bool entry_frame_is_first() const; | |
| 325 | |
| 326 // Compiled frames: | |
| 327 | |
| 328 public: | |
| 329 // Given the index of a local, and the number of argument words | |
| 330 // in this stack frame, tell which word of the stack frame to find | |
| 331 // the local in. Arguments are stored above the ofp/rpc pair, | |
| 332 // while other locals are stored below it. | |
| 333 // Since monitors (BasicLock blocks) are also assigned indexes, | |
| 334 // but may have different storage requirements, their presence | |
| 335 // can also affect the calculation of offsets. | |
| 336 static int local_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors); | |
| 337 | |
| 338 // Given the index of a monitor, etc., tell which word of the | |
| 339 // stack frame contains the start of the BasicLock block. | |
| 340 // Note that the local index by convention is the __higher__ | |
| 341 // of the two indexes allocated to the block. | |
| 342 static int monitor_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors); | |
| 343 | |
| 344 // Tell the smallest value that local_offset_for_compiler will attain. | |
| 345 // This is used to help determine how much stack frame to allocate. | |
| 346 static int min_local_offset_for_compiler(int nof_args, int max_nof_locals, int max_nof_monitors); | |
| 347 | |
| 348 // Tells if this register must be spilled during a call. | |
| 349 // On Intel, all registers are smashed by calls. | |
| 350 static bool volatile_across_calls(Register reg); | |
| 351 | |
| 352 | |
| 353 // Safepoints | |
| 354 | |
| 355 public: | |
| 356 oop saved_oop_result(RegisterMap* map) const; | |
| 357 void set_saved_oop_result(RegisterMap* map, oop obj); | |
| 358 | |
| 359 // For debugging | |
| 360 private: | |
| 361 const char* print_name() const; | |
| 362 | |
| 363 public: | |
| 364 void print_value() const { print_value_on(tty,NULL); } | |
| 365 void print_value_on(outputStream* st, JavaThread *thread) const; | |
| 366 void print_on(outputStream* st) const; | |
| 367 void interpreter_frame_print_on(outputStream* st) const; | |
| 368 void print_on_error(outputStream* st, char* buf, int buflen, bool verbose = false) const; | |
| 369 | |
| 370 // Conversion from an VMReg to physical stack location | |
| 371 oop* oopmapreg_to_location(VMReg reg, const RegisterMap* regmap) const; | |
| 372 | |
| 373 // Oops-do's | |
| 374 void oops_compiled_arguments_do(symbolHandle signature, bool is_static, const RegisterMap* reg_map, OopClosure* f); | |
| 375 void oops_interpreted_do(OopClosure* f, const RegisterMap* map, bool query_oop_map_cache = true); | |
| 376 | |
| 377 private: | |
| 378 void oops_interpreted_locals_do(OopClosure *f, | |
| 379 int max_locals, | |
| 380 InterpreterOopMap *mask); | |
| 381 void oops_interpreted_expressions_do(OopClosure *f, symbolHandle signature, | |
| 382 bool is_static, int max_stack, int max_locals, | |
| 383 InterpreterOopMap *mask); | |
| 384 void oops_interpreted_arguments_do(symbolHandle signature, bool is_static, OopClosure* f); | |
| 385 | |
| 386 // Iteration of oops | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
387 void oops_do_internal(OopClosure* f, CodeBlobClosure* cf, RegisterMap* map, bool use_interpreter_oop_map_cache); |
| 0 | 388 void oops_entry_do(OopClosure* f, const RegisterMap* map); |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
389 void oops_code_blob_do(OopClosure* f, CodeBlobClosure* cf, const RegisterMap* map); |
| 0 | 390 int adjust_offset(methodOop method, int index); // helper for above fn |
| 391 public: | |
| 392 // Memory management | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
393 void oops_do(OopClosure* f, CodeBlobClosure* cf, RegisterMap* map) { oops_do_internal(f, cf, map, true); } |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
394 void nmethods_do(CodeBlobClosure* cf); |
| 0 | 395 |
| 396 void gc_prologue(); | |
| 397 void gc_epilogue(); | |
| 398 void pd_gc_epilog(); | |
| 399 | |
| 400 # ifdef ENABLE_ZAP_DEAD_LOCALS | |
| 401 private: | |
| 402 class CheckValueClosure: public OopClosure { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
403 public: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
404 void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
405 void do_oop(narrowOop* p) { ShouldNotReachHere(); } |
| 0 | 406 }; |
| 407 static CheckValueClosure _check_value; | |
| 408 | |
| 409 class CheckOopClosure: public OopClosure { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
410 public: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
411 void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
412 void do_oop(narrowOop* p) { ShouldNotReachHere(); } |
| 0 | 413 }; |
| 414 static CheckOopClosure _check_oop; | |
| 415 | |
| 416 static void check_derived_oop(oop* base, oop* derived); | |
| 417 | |
| 418 class ZapDeadClosure: public OopClosure { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
419 public: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
420 void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
421 void do_oop(narrowOop* p) { ShouldNotReachHere(); } |
| 0 | 422 }; |
| 423 static ZapDeadClosure _zap_dead; | |
| 424 | |
| 425 public: | |
| 426 // Zapping | |
| 427 void zap_dead_locals (JavaThread* thread, const RegisterMap* map); | |
| 428 void zap_dead_interpreted_locals(JavaThread* thread, const RegisterMap* map); | |
| 429 void zap_dead_compiled_locals (JavaThread* thread, const RegisterMap* map); | |
| 430 void zap_dead_entry_locals (JavaThread* thread, const RegisterMap* map); | |
| 431 void zap_dead_deoptimized_locals(JavaThread* thread, const RegisterMap* map); | |
| 432 # endif | |
| 433 // Verification | |
| 434 void verify(const RegisterMap* map); | |
| 435 static bool verify_return_pc(address x); | |
| 436 static bool is_bci(intptr_t bcx); | |
| 437 // Usage: | |
| 438 // assert(frame::verify_return_pc(return_address), "must be a return pc"); | |
| 439 | |
| 440 int pd_oop_map_offset_adjustment() const; | |
| 441 | |
| 442 # include "incls/_frame_pd.hpp.incl" | |
| 443 }; | |
| 444 | |
| 445 | |
| 446 // | |
| 447 // StackFrameStream iterates through the frames of a thread starting from | |
| 448 // top most frame. It automatically takes care of updating the location of | |
| 449 // all (callee-saved) registers. Notice: If a thread is stopped at | |
| 450 // a safepoint, all registers are saved, not only the callee-saved ones. | |
| 451 // | |
| 452 // Use: | |
| 453 // | |
| 454 // for(StackFrameStream fst(thread); !fst.is_done(); fst.next()) { | |
| 455 // ... | |
| 456 // } | |
| 457 // | |
| 458 class StackFrameStream : public StackObj { | |
| 459 private: | |
| 460 frame _fr; | |
| 461 RegisterMap _reg_map; | |
| 462 bool _is_done; | |
| 463 public: | |
| 464 StackFrameStream(JavaThread *thread, bool update = true); | |
| 465 | |
| 466 // Iteration | |
| 467 bool is_done() { return (_is_done) ? true : (_is_done = _fr.is_first_frame(), false); } | |
| 468 void next() { if (!_is_done) _fr = _fr.sender(&_reg_map); } | |
| 469 | |
| 470 // Query | |
| 471 frame *current() { return &_fr; } | |
| 472 RegisterMap* register_map() { return &_reg_map; } | |
| 473 }; |