Mercurial > hg > graal-jvmci-8
annotate src/share/vm/runtime/frame.hpp @ 3979:4dfb2df418f2
6484982: G1: process references during evacuation pauses
Summary: G1 now uses two reference processors - one is used by concurrent marking and the other is used by STW GCs (both full and incremental evacuation pauses). In an evacuation pause, the reference processor is embedded into the closures used to scan objects. Doing so causes causes reference objects to be 'discovered' by the reference processor. At the end of the evacuation pause, these discovered reference objects are processed - preserving (and copying) referent objects (and their reachable graphs) as appropriate.
Reviewed-by: ysr, jwilhelm, brutisso, stefank, tonyp
| author | johnc |
|---|---|
| date | Thu, 22 Sep 2011 10:57:37 -0700 |
| parents | 5432047c7db7 |
| children | b20d64f83668 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2426
1d1603768966
7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents:
2192
diff
changeset
|
2 * Copyright (c) 1997, 2011, 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 | |
| 1972 | 25 #ifndef SHARE_VM_RUNTIME_FRAME_HPP |
| 26 #define SHARE_VM_RUNTIME_FRAME_HPP | |
| 27 | |
| 28 #include "asm/assembler.hpp" | |
| 29 #include "oops/methodOop.hpp" | |
| 30 #include "runtime/basicLock.hpp" | |
| 31 #include "runtime/monitorChunk.hpp" | |
| 32 #include "runtime/registerMap.hpp" | |
| 33 #include "utilities/top.hpp" | |
| 34 #ifdef COMPILER2 | |
| 35 #ifdef TARGET_ARCH_MODEL_x86_32 | |
| 36 # include "adfiles/adGlobals_x86_32.hpp" | |
| 37 #endif | |
| 38 #ifdef TARGET_ARCH_MODEL_x86_64 | |
| 39 # include "adfiles/adGlobals_x86_64.hpp" | |
| 40 #endif | |
| 41 #ifdef TARGET_ARCH_MODEL_sparc | |
| 42 # include "adfiles/adGlobals_sparc.hpp" | |
| 43 #endif | |
| 44 #ifdef TARGET_ARCH_MODEL_zero | |
| 45 # include "adfiles/adGlobals_zero.hpp" | |
| 46 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
47 #ifdef TARGET_ARCH_MODEL_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
48 # include "adfiles/adGlobals_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
49 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
50 #ifdef TARGET_ARCH_MODEL_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
51 # include "adfiles/adGlobals_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
52 #endif |
| 1972 | 53 #endif |
| 54 #ifdef ZERO | |
| 55 #ifdef TARGET_ARCH_zero | |
| 56 # include "stack_zero.hpp" | |
| 57 #endif | |
| 58 #endif | |
| 59 | |
| 0 | 60 typedef class BytecodeInterpreter* interpreterState; |
| 61 | |
| 62 class CodeBlob; | |
|
3336
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
63 class FrameValues; |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
64 class vframeArray; |
| 0 | 65 |
| 66 | |
| 67 // A frame represents a physical stack frame (an activation). Frames | |
| 68 // can be C or Java frames, and the Java frames can be interpreted or | |
| 69 // compiled. In contrast, vframes represent source-level activations, | |
| 70 // so that one physical frame can correspond to multiple source level | |
| 71 // frames because of inlining. | |
| 72 | |
| 73 class frame VALUE_OBJ_CLASS_SPEC { | |
| 74 private: | |
| 75 // Instance variables: | |
| 76 intptr_t* _sp; // stack pointer (from Thread::last_Java_sp) | |
| 77 address _pc; // program counter (the next instruction after the call) | |
| 78 | |
| 79 CodeBlob* _cb; // CodeBlob that "owns" pc | |
| 80 enum deopt_state { | |
| 81 not_deoptimized, | |
| 82 is_deoptimized, | |
| 83 unknown | |
| 84 }; | |
| 85 | |
| 86 deopt_state _deopt_state; | |
| 87 | |
| 88 public: | |
| 89 // Constructors | |
| 90 frame(); | |
| 91 | |
| 92 // Accessors | |
| 93 | |
| 94 // pc: Returns the pc at which this frame will continue normally. | |
| 95 // It must point at the beginning of the next instruction to execute. | |
| 96 address pc() const { return _pc; } | |
| 97 | |
| 98 // This returns the pc that if you were in the debugger you'd see. Not | |
| 99 // the idealized value in the frame object. This undoes the magic conversion | |
| 100 // that happens for deoptimized frames. In addition it makes the value the | |
| 101 // hardware would want to see in the native frame. The only user (at this point) | |
| 102 // is deoptimization. It likely no one else should ever use it. | |
| 103 address raw_pc() const; | |
| 104 | |
| 105 void set_pc( address newpc ); | |
| 106 | |
| 107 intptr_t* sp() const { return _sp; } | |
| 108 void set_sp( intptr_t* newsp ) { _sp = newsp; } | |
| 109 | |
| 110 | |
| 111 CodeBlob* cb() const { return _cb; } | |
| 112 | |
| 113 // patching operations | |
| 114 void patch_pc(Thread* thread, address pc); | |
| 115 | |
| 116 // Every frame needs to return a unique id which distinguishes it from all other frames. | |
| 117 // For sparc and ia32 use sp. ia64 can have memory frames that are empty so multiple frames | |
| 118 // will have identical sp values. For ia64 the bsp (fp) value will serve. No real frame | |
| 119 // should have an id() of NULL so it is a distinguishing value for an unmatchable frame. | |
| 120 // We also have relationals which allow comparing a frame to anoth frame's id() allow | |
| 121 // us to distinguish younger (more recent activation) from older (less recent activations) | |
| 122 // A NULL id is only valid when comparing for equality. | |
| 123 | |
| 124 intptr_t* id(void) const; | |
| 125 bool is_younger(intptr_t* id) const; | |
| 126 bool is_older(intptr_t* id) const; | |
| 127 | |
| 128 // testers | |
| 129 | |
| 130 // Compares for strict equality. Rarely used or needed. | |
| 131 // It can return a different result than f1.id() == f2.id() | |
| 132 bool equal(frame other) const; | |
| 133 | |
| 134 // type testers | |
| 135 bool is_interpreted_frame() const; | |
| 136 bool is_java_frame() const; | |
| 137 bool is_entry_frame() const; // Java frame called from C? | |
|
3363
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
3336
diff
changeset
|
138 bool is_ricochet_frame() const; |
| 0 | 139 bool is_native_frame() const; |
| 140 bool is_runtime_frame() const; | |
| 141 bool is_compiled_frame() const; | |
| 142 bool is_safepoint_blob_frame() const; | |
| 143 bool is_deoptimized_frame() const; | |
| 144 | |
| 145 // testers | |
| 146 bool is_first_frame() const; // oldest frame? (has no sender) | |
| 147 bool is_first_java_frame() const; // same for Java frame | |
| 148 | |
|
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
149 bool is_interpreted_frame_valid(JavaThread* thread) const; // performs sanity checks on interpreted frames. |
| 0 | 150 |
| 151 // tells whether this frame is marked for deoptimization | |
| 152 bool should_be_deoptimized() const; | |
| 153 | |
| 154 // tells whether this frame can be deoptimized | |
| 155 bool can_be_deoptimized() const; | |
| 156 | |
| 157 // returns the frame size in stack slots | |
|
793
eacd97c88873
6848466: frame::frame_size() assertion failure with -XX:+DebugDeoptimization
cfang
parents:
196
diff
changeset
|
158 int frame_size(RegisterMap* map) const; |
| 0 | 159 |
| 160 // returns the sending frame | |
| 161 frame sender(RegisterMap* map) const; | |
| 162 | |
| 163 // for Profiling - acting on another frame. walks sender frames | |
| 164 // if valid. | |
| 165 frame profile_find_Java_sender_frame(JavaThread *thread); | |
| 166 bool safe_for_sender(JavaThread *thread); | |
| 167 | |
| 168 // returns the sender, but skips conversion frames | |
| 169 frame real_sender(RegisterMap* map) const; | |
| 170 | |
| 171 // returns the the sending Java frame, skipping any intermediate C frames | |
| 172 // NB: receiver must not be first frame | |
| 173 frame java_sender() const; | |
| 174 | |
| 175 private: | |
| 176 // Helper methods for better factored code in frame::sender | |
| 177 frame sender_for_compiled_frame(RegisterMap* map) const; | |
| 178 frame sender_for_entry_frame(RegisterMap* map) const; | |
|
3363
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
3336
diff
changeset
|
179 frame sender_for_ricochet_frame(RegisterMap* map) const; |
| 0 | 180 frame sender_for_interpreter_frame(RegisterMap* map) const; |
| 181 frame sender_for_native_frame(RegisterMap* map) const; | |
| 182 | |
| 183 // All frames: | |
| 184 | |
| 185 // A low-level interface for vframes: | |
| 186 | |
| 187 public: | |
| 188 | |
| 189 intptr_t* addr_at(int index) const { return &fp()[index]; } | |
| 190 intptr_t at(int index) const { return *addr_at(index); } | |
| 191 | |
| 192 // accessors for locals | |
| 193 oop obj_at(int offset) const { return *obj_at_addr(offset); } | |
| 194 void obj_at_put(int offset, oop value) { *obj_at_addr(offset) = value; } | |
| 195 | |
| 196 jint int_at(int offset) const { return *int_at_addr(offset); } | |
| 197 void int_at_put(int offset, jint value) { *int_at_addr(offset) = value; } | |
| 198 | |
| 199 oop* obj_at_addr(int offset) const { return (oop*) addr_at(offset); } | |
| 200 | |
| 201 oop* adjusted_obj_at_addr(methodOop method, int index) { return obj_at_addr(adjust_offset(method, index)); } | |
| 202 | |
| 203 private: | |
| 204 jint* int_at_addr(int offset) const { return (jint*) addr_at(offset); } | |
| 205 | |
| 206 public: | |
| 207 // Link (i.e., the pointer to the previous frame) | |
| 208 intptr_t* link() const; | |
| 209 void set_link(intptr_t* addr); | |
| 210 | |
| 211 // Return address | |
| 212 address sender_pc() const; | |
| 213 | |
| 214 // Support for deoptimization | |
|
1727
da877bdc9000
6975006: assert(check.is_deoptimized_frame()) failed: missed deopt
never
parents:
1681
diff
changeset
|
215 void deoptimize(JavaThread* thread); |
| 0 | 216 |
| 217 // The frame's original SP, before any extension by an interpreted callee; | |
| 218 // used for packing debug info into vframeArray objects and vframeArray lookup. | |
| 219 intptr_t* unextended_sp() const; | |
| 220 | |
| 221 // returns the stack pointer of the calling frame | |
| 222 intptr_t* sender_sp() const; | |
| 223 | |
|
3931
5432047c7db7
7087445: Improve platform independence of JSR292 shared code
bdelsart
parents:
3365
diff
changeset
|
224 // Deoptimization info, if needed (platform dependent). |
|
5432047c7db7
7087445: Improve platform independence of JSR292 shared code
bdelsart
parents:
3365
diff
changeset
|
225 // Stored in the initial_info field of the unroll info, to be used by |
|
5432047c7db7
7087445: Improve platform independence of JSR292 shared code
bdelsart
parents:
3365
diff
changeset
|
226 // the platform dependent deoptimization blobs. |
|
5432047c7db7
7087445: Improve platform independence of JSR292 shared code
bdelsart
parents:
3365
diff
changeset
|
227 intptr_t *initial_deoptimization_info(); |
| 0 | 228 |
| 229 // Interpreter frames: | |
| 230 | |
| 231 private: | |
| 232 intptr_t** interpreter_frame_locals_addr() const; | |
| 233 intptr_t* interpreter_frame_bcx_addr() const; | |
| 234 intptr_t* interpreter_frame_mdx_addr() const; | |
| 235 | |
| 236 public: | |
| 237 // Locals | |
| 238 | |
| 239 // The _at version returns a pointer because the address is used for GC. | |
| 240 intptr_t* interpreter_frame_local_at(int index) const; | |
| 241 | |
| 242 void interpreter_frame_set_locals(intptr_t* locs); | |
| 243 | |
| 244 // byte code index/pointer (use these functions for unchecked frame access only!) | |
| 245 intptr_t interpreter_frame_bcx() const { return *interpreter_frame_bcx_addr(); } | |
| 246 void interpreter_frame_set_bcx(intptr_t bcx); | |
| 247 | |
| 248 // byte code index | |
| 249 jint interpreter_frame_bci() const; | |
| 250 void interpreter_frame_set_bci(jint bci); | |
| 251 | |
| 252 // byte code pointer | |
| 253 address interpreter_frame_bcp() const; | |
| 254 void interpreter_frame_set_bcp(address bcp); | |
| 255 | |
| 256 // Unchecked access to the method data index/pointer. | |
| 257 // Only use this if you know what you are doing. | |
| 258 intptr_t interpreter_frame_mdx() const { return *interpreter_frame_mdx_addr(); } | |
| 259 void interpreter_frame_set_mdx(intptr_t mdx); | |
| 260 | |
| 261 // method data pointer | |
| 262 address interpreter_frame_mdp() const; | |
| 263 void interpreter_frame_set_mdp(address dp); | |
| 264 | |
| 265 // Find receiver out of caller's (compiled) argument list | |
| 266 oop retrieve_receiver(RegisterMap *reg_map); | |
| 267 | |
| 268 // Return the monitor owner and BasicLock for compiled synchronized | |
| 269 // native methods so that biased locking can revoke the receiver's | |
| 2019 | 270 // bias if necessary. This is also used by JVMTI's GetLocalInstance method |
| 271 // (via VM_GetReceiver) to retrieve the receiver from a native wrapper frame. | |
| 272 BasicLock* get_native_monitor(); | |
| 273 oop get_native_receiver(); | |
| 0 | 274 |
| 275 // Find receiver for an invoke when arguments are just pushed on stack (i.e., callee stack-frame is | |
| 276 // not setup) | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2019
diff
changeset
|
277 oop interpreter_callee_receiver(Symbol* signature) { return *interpreter_callee_receiver_addr(signature); } |
| 0 | 278 |
| 279 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2019
diff
changeset
|
280 oop* interpreter_callee_receiver_addr(Symbol* signature); |
| 0 | 281 |
| 282 | |
| 283 // expression stack (may go up or down, direction == 1 or -1) | |
| 284 public: | |
| 285 intptr_t* interpreter_frame_expression_stack() const; | |
| 286 static jint interpreter_frame_expression_stack_direction(); | |
| 287 | |
| 288 // The _at version returns a pointer because the address is used for GC. | |
| 289 intptr_t* interpreter_frame_expression_stack_at(jint offset) const; | |
| 290 | |
| 291 // top of expression stack | |
| 292 intptr_t* interpreter_frame_tos_at(jint offset) const; | |
| 293 intptr_t* interpreter_frame_tos_address() const; | |
| 294 | |
| 295 | |
| 296 jint interpreter_frame_expression_stack_size() const; | |
| 297 | |
| 298 intptr_t* interpreter_frame_sender_sp() const; | |
| 299 | |
| 300 #ifndef CC_INTERP | |
| 301 // template based interpreter deoptimization support | |
| 302 void set_interpreter_frame_sender_sp(intptr_t* sender_sp); | |
| 303 void interpreter_frame_set_monitor_end(BasicObjectLock* value); | |
| 304 #endif // CC_INTERP | |
| 305 | |
| 306 // BasicObjectLocks: | |
| 307 // | |
| 308 // interpreter_frame_monitor_begin is higher in memory than interpreter_frame_monitor_end | |
| 309 // Interpreter_frame_monitor_begin points to one element beyond the oldest one, | |
| 310 // interpreter_frame_monitor_end points to the youngest one, or if there are none, | |
| 311 // it points to one beyond where the first element will be. | |
| 312 // interpreter_frame_monitor_size reports the allocation size of a monitor in the interpreter stack. | |
| 313 // this value is >= BasicObjectLock::size(), and may be rounded up | |
| 314 | |
| 315 BasicObjectLock* interpreter_frame_monitor_begin() const; | |
| 316 BasicObjectLock* interpreter_frame_monitor_end() const; | |
| 317 BasicObjectLock* next_monitor_in_interpreter_frame(BasicObjectLock* current) const; | |
| 318 BasicObjectLock* previous_monitor_in_interpreter_frame(BasicObjectLock* current) const; | |
| 319 static int interpreter_frame_monitor_size(); | |
| 320 | |
| 321 void interpreter_frame_verify_monitor(BasicObjectLock* value) const; | |
| 322 | |
| 323 // Tells whether the current interpreter_frame frame pointer | |
| 324 // corresponds to the old compiled/deoptimized fp | |
| 325 // The receiver used to be a top level frame | |
| 326 bool interpreter_frame_equals_unpacked_fp(intptr_t* fp); | |
| 327 | |
| 328 // Return/result value from this interpreter frame | |
| 329 // If the method return type is T_OBJECT or T_ARRAY populates oop_result | |
| 330 // For other (non-T_VOID) the appropriate field in the jvalue is populated | |
| 331 // with the result value. | |
| 332 // Should only be called when at method exit when the method is not | |
| 333 // exiting due to an exception. | |
| 334 BasicType interpreter_frame_result(oop* oop_result, jvalue* value_result); | |
| 335 | |
| 336 public: | |
| 337 // Method & constant pool cache | |
| 338 methodOop interpreter_frame_method() const; | |
| 339 void interpreter_frame_set_method(methodOop method); | |
| 340 methodOop* interpreter_frame_method_addr() const; | |
| 341 constantPoolCacheOop* interpreter_frame_cache_addr() const; | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
342 #ifdef PPC |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
343 oop* interpreter_frame_mirror_addr() const; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
344 #endif |
| 0 | 345 |
| 346 public: | |
| 347 // Entry frames | |
| 348 JavaCallWrapper* entry_frame_call_wrapper() const; | |
| 349 intptr_t* entry_frame_argument_at(int offset) const; | |
| 350 | |
| 351 // tells whether there is another chunk of Delta stack above | |
| 352 bool entry_frame_is_first() const; | |
| 353 | |
| 354 // Compiled frames: | |
| 355 | |
| 356 public: | |
| 357 // Given the index of a local, and the number of argument words | |
| 358 // in this stack frame, tell which word of the stack frame to find | |
| 359 // the local in. Arguments are stored above the ofp/rpc pair, | |
| 360 // while other locals are stored below it. | |
| 361 // Since monitors (BasicLock blocks) are also assigned indexes, | |
| 362 // but may have different storage requirements, their presence | |
| 363 // can also affect the calculation of offsets. | |
| 364 static int local_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors); | |
| 365 | |
| 366 // Given the index of a monitor, etc., tell which word of the | |
| 367 // stack frame contains the start of the BasicLock block. | |
| 368 // Note that the local index by convention is the __higher__ | |
| 369 // of the two indexes allocated to the block. | |
| 370 static int monitor_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors); | |
| 371 | |
| 372 // Tell the smallest value that local_offset_for_compiler will attain. | |
| 373 // This is used to help determine how much stack frame to allocate. | |
| 374 static int min_local_offset_for_compiler(int nof_args, int max_nof_locals, int max_nof_monitors); | |
| 375 | |
| 376 // Tells if this register must be spilled during a call. | |
| 377 // On Intel, all registers are smashed by calls. | |
| 378 static bool volatile_across_calls(Register reg); | |
| 379 | |
| 380 | |
| 381 // Safepoints | |
| 382 | |
| 383 public: | |
| 384 oop saved_oop_result(RegisterMap* map) const; | |
| 385 void set_saved_oop_result(RegisterMap* map, oop obj); | |
| 386 | |
| 387 // For debugging | |
| 388 private: | |
| 389 const char* print_name() const; | |
| 390 | |
|
3336
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
391 void describe_pd(FrameValues& values, int frame_no); |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
392 |
| 0 | 393 public: |
| 394 void print_value() const { print_value_on(tty,NULL); } | |
| 395 void print_value_on(outputStream* st, JavaThread *thread) const; | |
| 396 void print_on(outputStream* st) const; | |
| 397 void interpreter_frame_print_on(outputStream* st) const; | |
| 398 void print_on_error(outputStream* st, char* buf, int buflen, bool verbose = false) const; | |
| 399 | |
|
3336
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
400 // Add annotated descriptions of memory locations belonging to this frame to values |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
401 void describe(FrameValues& values, int frame_no); |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
402 |
| 0 | 403 // Conversion from an VMReg to physical stack location |
| 404 oop* oopmapreg_to_location(VMReg reg, const RegisterMap* regmap) const; | |
| 405 | |
| 406 // Oops-do's | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2019
diff
changeset
|
407 void oops_compiled_arguments_do(Symbol* signature, bool has_receiver, const RegisterMap* reg_map, OopClosure* f); |
| 0 | 408 void oops_interpreted_do(OopClosure* f, const RegisterMap* map, bool query_oop_map_cache = true); |
|
3363
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
3336
diff
changeset
|
409 void oops_ricochet_do(OopClosure* f, const RegisterMap* map); |
| 0 | 410 |
| 411 private: | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2019
diff
changeset
|
412 void oops_interpreted_arguments_do(Symbol* signature, bool has_receiver, OopClosure* f); |
| 0 | 413 |
| 414 // Iteration of oops | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
415 void oops_do_internal(OopClosure* f, CodeBlobClosure* cf, RegisterMap* map, bool use_interpreter_oop_map_cache); |
| 0 | 416 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
|
417 void oops_code_blob_do(OopClosure* f, CodeBlobClosure* cf, const RegisterMap* map); |
| 0 | 418 int adjust_offset(methodOop method, int index); // helper for above fn |
| 419 public: | |
| 420 // Memory management | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
421 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
|
422 void nmethods_do(CodeBlobClosure* cf); |
| 0 | 423 |
| 424 void gc_prologue(); | |
| 425 void gc_epilogue(); | |
| 426 void pd_gc_epilog(); | |
| 427 | |
| 428 # ifdef ENABLE_ZAP_DEAD_LOCALS | |
| 429 private: | |
| 430 class CheckValueClosure: public OopClosure { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
431 public: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
432 void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
433 void do_oop(narrowOop* p) { ShouldNotReachHere(); } |
| 0 | 434 }; |
| 435 static CheckValueClosure _check_value; | |
| 436 | |
| 437 class CheckOopClosure: public OopClosure { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
438 public: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
439 void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
440 void do_oop(narrowOop* p) { ShouldNotReachHere(); } |
| 0 | 441 }; |
| 442 static CheckOopClosure _check_oop; | |
| 443 | |
| 444 static void check_derived_oop(oop* base, oop* derived); | |
| 445 | |
| 446 class ZapDeadClosure: public OopClosure { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
447 public: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
448 void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
449 void do_oop(narrowOop* p) { ShouldNotReachHere(); } |
| 0 | 450 }; |
| 451 static ZapDeadClosure _zap_dead; | |
| 452 | |
| 453 public: | |
| 454 // Zapping | |
| 455 void zap_dead_locals (JavaThread* thread, const RegisterMap* map); | |
| 456 void zap_dead_interpreted_locals(JavaThread* thread, const RegisterMap* map); | |
| 457 void zap_dead_compiled_locals (JavaThread* thread, const RegisterMap* map); | |
| 458 void zap_dead_entry_locals (JavaThread* thread, const RegisterMap* map); | |
| 459 void zap_dead_deoptimized_locals(JavaThread* thread, const RegisterMap* map); | |
| 460 # endif | |
| 461 // Verification | |
| 462 void verify(const RegisterMap* map); | |
| 463 static bool verify_return_pc(address x); | |
| 464 static bool is_bci(intptr_t bcx); | |
| 465 // Usage: | |
| 466 // assert(frame::verify_return_pc(return_address), "must be a return pc"); | |
| 467 | |
| 468 int pd_oop_map_offset_adjustment() const; | |
| 469 | |
| 1972 | 470 #ifdef TARGET_ARCH_x86 |
| 471 # include "frame_x86.hpp" | |
| 472 #endif | |
| 473 #ifdef TARGET_ARCH_sparc | |
| 474 # include "frame_sparc.hpp" | |
| 475 #endif | |
| 476 #ifdef TARGET_ARCH_zero | |
| 477 # include "frame_zero.hpp" | |
| 478 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
479 #ifdef TARGET_ARCH_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
480 # include "frame_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
481 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
482 #ifdef TARGET_ARCH_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
483 # include "frame_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
484 #endif |
| 1972 | 485 |
| 0 | 486 }; |
| 487 | |
|
3336
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
488 #ifdef ASSERT |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
489 // A simple class to describe a location on the stack |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
490 class FrameValue VALUE_OBJ_CLASS_SPEC { |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
491 public: |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
492 intptr_t* location; |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
493 char* description; |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
494 int owner; |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
495 int priority; |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
496 }; |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
497 |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
498 |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
499 // A collection of described stack values that can print a symbolic |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
500 // description of the stack memory. Interpreter frame values can be |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
501 // in the caller frames so all the values are collected first and then |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
502 // sorted before being printed. |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
503 class FrameValues { |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
504 private: |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
505 GrowableArray<FrameValue> _values; |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
506 |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
507 static int compare(FrameValue* a, FrameValue* b) { |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
508 if (a->location == b->location) { |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
509 return a->priority - b->priority; |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
510 } |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
511 return a->location - b->location; |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
512 } |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
513 |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
514 public: |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
515 // Used by frame functions to describe locations. |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
516 void describe(int owner, intptr_t* location, const char* description, int priority = 0); |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
517 |
|
3365
3cfb240033d1
7043301: assert(locals < caller->fp() || locals > (caller->fp() + 16)) failed: locals in save area
never
parents:
3363
diff
changeset
|
518 void validate(); |
|
3336
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
519 void print(); |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
520 }; |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
521 |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
522 #endif |
| 0 | 523 |
| 524 // | |
| 525 // StackFrameStream iterates through the frames of a thread starting from | |
| 526 // top most frame. It automatically takes care of updating the location of | |
| 527 // all (callee-saved) registers. Notice: If a thread is stopped at | |
| 528 // a safepoint, all registers are saved, not only the callee-saved ones. | |
| 529 // | |
| 530 // Use: | |
| 531 // | |
| 532 // for(StackFrameStream fst(thread); !fst.is_done(); fst.next()) { | |
| 533 // ... | |
| 534 // } | |
| 535 // | |
| 536 class StackFrameStream : public StackObj { | |
| 537 private: | |
| 538 frame _fr; | |
| 539 RegisterMap _reg_map; | |
| 540 bool _is_done; | |
| 541 public: | |
| 542 StackFrameStream(JavaThread *thread, bool update = true); | |
| 543 | |
| 544 // Iteration | |
| 545 bool is_done() { return (_is_done) ? true : (_is_done = _fr.is_first_frame(), false); } | |
| 546 void next() { if (!_is_done) _fr = _fr.sender(&_reg_map); } | |
| 547 | |
| 548 // Query | |
| 549 frame *current() { return &_fr; } | |
| 550 RegisterMap* register_map() { return &_reg_map; } | |
| 551 }; | |
| 1972 | 552 |
| 553 #endif // SHARE_VM_RUNTIME_FRAME_HPP |