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