Mercurial > hg > truffle
annotate src/share/vm/runtime/frame.hpp @ 6862:8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
| author | johnc |
|---|---|
| date | Sat, 06 Oct 2012 01:17:44 -0700 |
| parents | da91efe96a93 |
| children | e522a00b91aa d0aa87f04bd5 cd3d6a6b95d9 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
4806
eaa9557116a2
7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents:
4042
diff
changeset
|
2 * Copyright (c) 1997, 2012, 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" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
29 #include "oops/method.hpp" |
| 1972 | 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? | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
4824
diff
changeset
|
138 bool is_ignored_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; | |
| 179 frame sender_for_interpreter_frame(RegisterMap* map) const; | |
| 180 frame sender_for_native_frame(RegisterMap* map) const; | |
| 181 | |
| 182 // All frames: | |
| 183 | |
| 184 // A low-level interface for vframes: | |
| 185 | |
| 186 public: | |
| 187 | |
| 188 intptr_t* addr_at(int index) const { return &fp()[index]; } | |
| 189 intptr_t at(int index) const { return *addr_at(index); } | |
| 190 | |
| 191 // accessors for locals | |
| 192 oop obj_at(int offset) const { return *obj_at_addr(offset); } | |
| 193 void obj_at_put(int offset, oop value) { *obj_at_addr(offset) = value; } | |
| 194 | |
| 195 jint int_at(int offset) const { return *int_at_addr(offset); } | |
| 196 void int_at_put(int offset, jint value) { *int_at_addr(offset) = value; } | |
| 197 | |
| 198 oop* obj_at_addr(int offset) const { return (oop*) addr_at(offset); } | |
| 199 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
200 oop* adjusted_obj_at_addr(Method* method, int index) { return obj_at_addr(adjust_offset(method, index)); } |
| 0 | 201 |
| 202 private: | |
| 203 jint* int_at_addr(int offset) const { return (jint*) addr_at(offset); } | |
| 204 | |
| 205 public: | |
| 206 // Link (i.e., the pointer to the previous frame) | |
| 207 intptr_t* link() const; | |
| 208 void set_link(intptr_t* addr); | |
| 209 | |
| 210 // Return address | |
| 211 address sender_pc() const; | |
| 212 | |
| 213 // Support for deoptimization | |
|
1727
da877bdc9000
6975006: assert(check.is_deoptimized_frame()) failed: missed deopt
never
parents:
1681
diff
changeset
|
214 void deoptimize(JavaThread* thread); |
| 0 | 215 |
| 216 // The frame's original SP, before any extension by an interpreted callee; | |
| 217 // used for packing debug info into vframeArray objects and vframeArray lookup. | |
| 218 intptr_t* unextended_sp() const; | |
| 219 | |
| 220 // returns the stack pointer of the calling frame | |
| 221 intptr_t* sender_sp() const; | |
| 222 | |
|
4806
eaa9557116a2
7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents:
4042
diff
changeset
|
223 // Returns the real 'frame pointer' for the current frame. |
|
eaa9557116a2
7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents:
4042
diff
changeset
|
224 // This is the value expected by the platform ABI when it defines a |
|
eaa9557116a2
7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents:
4042
diff
changeset
|
225 // frame pointer register. It may differ from the effective value of |
|
eaa9557116a2
7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents:
4042
diff
changeset
|
226 // the FP register when that register is used in the JVM for other |
|
eaa9557116a2
7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents:
4042
diff
changeset
|
227 // purposes (like compiled frames on some platforms). |
|
eaa9557116a2
7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents:
4042
diff
changeset
|
228 // On other platforms, it is defined so that the stack area used by |
|
eaa9557116a2
7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents:
4042
diff
changeset
|
229 // this frame goes from real_fp() to sp(). |
|
eaa9557116a2
7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents:
4042
diff
changeset
|
230 intptr_t* real_fp() const; |
|
eaa9557116a2
7120448: Fix FP values for compiled frames in frame::describe
bdelsart
parents:
4042
diff
changeset
|
231 |
|
3931
5432047c7db7
7087445: Improve platform independence of JSR292 shared code
bdelsart
parents:
3365
diff
changeset
|
232 // Deoptimization info, if needed (platform dependent). |
|
5432047c7db7
7087445: Improve platform independence of JSR292 shared code
bdelsart
parents:
3365
diff
changeset
|
233 // 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
|
234 // the platform dependent deoptimization blobs. |
|
5432047c7db7
7087445: Improve platform independence of JSR292 shared code
bdelsart
parents:
3365
diff
changeset
|
235 intptr_t *initial_deoptimization_info(); |
| 0 | 236 |
| 237 // Interpreter frames: | |
| 238 | |
| 239 private: | |
| 240 intptr_t** interpreter_frame_locals_addr() const; | |
| 241 intptr_t* interpreter_frame_bcx_addr() const; | |
| 242 intptr_t* interpreter_frame_mdx_addr() const; | |
| 243 | |
| 244 public: | |
| 245 // Locals | |
| 246 | |
| 247 // The _at version returns a pointer because the address is used for GC. | |
| 248 intptr_t* interpreter_frame_local_at(int index) const; | |
| 249 | |
| 250 void interpreter_frame_set_locals(intptr_t* locs); | |
| 251 | |
| 252 // byte code index/pointer (use these functions for unchecked frame access only!) | |
| 253 intptr_t interpreter_frame_bcx() const { return *interpreter_frame_bcx_addr(); } | |
| 254 void interpreter_frame_set_bcx(intptr_t bcx); | |
| 255 | |
| 256 // byte code index | |
| 257 jint interpreter_frame_bci() const; | |
| 258 void interpreter_frame_set_bci(jint bci); | |
| 259 | |
| 260 // byte code pointer | |
| 261 address interpreter_frame_bcp() const; | |
| 262 void interpreter_frame_set_bcp(address bcp); | |
| 263 | |
| 264 // Unchecked access to the method data index/pointer. | |
| 265 // Only use this if you know what you are doing. | |
| 266 intptr_t interpreter_frame_mdx() const { return *interpreter_frame_mdx_addr(); } | |
| 267 void interpreter_frame_set_mdx(intptr_t mdx); | |
| 268 | |
| 269 // method data pointer | |
| 270 address interpreter_frame_mdp() const; | |
| 271 void interpreter_frame_set_mdp(address dp); | |
| 272 | |
| 273 // Find receiver out of caller's (compiled) argument list | |
| 274 oop retrieve_receiver(RegisterMap *reg_map); | |
| 275 | |
| 276 // Return the monitor owner and BasicLock for compiled synchronized | |
| 277 // native methods so that biased locking can revoke the receiver's | |
| 2019 | 278 // bias if necessary. This is also used by JVMTI's GetLocalInstance method |
| 279 // (via VM_GetReceiver) to retrieve the receiver from a native wrapper frame. | |
| 280 BasicLock* get_native_monitor(); | |
| 281 oop get_native_receiver(); | |
| 0 | 282 |
| 283 // Find receiver for an invoke when arguments are just pushed on stack (i.e., callee stack-frame is | |
| 284 // not setup) | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2019
diff
changeset
|
285 oop interpreter_callee_receiver(Symbol* signature) { return *interpreter_callee_receiver_addr(signature); } |
| 0 | 286 |
| 287 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2019
diff
changeset
|
288 oop* interpreter_callee_receiver_addr(Symbol* signature); |
| 0 | 289 |
| 290 | |
| 291 // expression stack (may go up or down, direction == 1 or -1) | |
| 292 public: | |
| 293 intptr_t* interpreter_frame_expression_stack() const; | |
| 294 static jint interpreter_frame_expression_stack_direction(); | |
| 295 | |
| 296 // The _at version returns a pointer because the address is used for GC. | |
| 297 intptr_t* interpreter_frame_expression_stack_at(jint offset) const; | |
| 298 | |
| 299 // top of expression stack | |
| 300 intptr_t* interpreter_frame_tos_at(jint offset) const; | |
| 301 intptr_t* interpreter_frame_tos_address() const; | |
| 302 | |
| 303 | |
| 304 jint interpreter_frame_expression_stack_size() const; | |
| 305 | |
| 306 intptr_t* interpreter_frame_sender_sp() const; | |
| 307 | |
| 308 #ifndef CC_INTERP | |
| 309 // template based interpreter deoptimization support | |
| 310 void set_interpreter_frame_sender_sp(intptr_t* sender_sp); | |
| 311 void interpreter_frame_set_monitor_end(BasicObjectLock* value); | |
| 312 #endif // CC_INTERP | |
| 313 | |
| 314 // BasicObjectLocks: | |
| 315 // | |
| 316 // interpreter_frame_monitor_begin is higher in memory than interpreter_frame_monitor_end | |
| 317 // Interpreter_frame_monitor_begin points to one element beyond the oldest one, | |
| 318 // interpreter_frame_monitor_end points to the youngest one, or if there are none, | |
| 319 // it points to one beyond where the first element will be. | |
| 320 // interpreter_frame_monitor_size reports the allocation size of a monitor in the interpreter stack. | |
| 321 // this value is >= BasicObjectLock::size(), and may be rounded up | |
| 322 | |
| 323 BasicObjectLock* interpreter_frame_monitor_begin() const; | |
| 324 BasicObjectLock* interpreter_frame_monitor_end() const; | |
| 325 BasicObjectLock* next_monitor_in_interpreter_frame(BasicObjectLock* current) const; | |
| 326 BasicObjectLock* previous_monitor_in_interpreter_frame(BasicObjectLock* current) const; | |
| 327 static int interpreter_frame_monitor_size(); | |
| 328 | |
| 329 void interpreter_frame_verify_monitor(BasicObjectLock* value) const; | |
| 330 | |
| 331 // Tells whether the current interpreter_frame frame pointer | |
| 332 // corresponds to the old compiled/deoptimized fp | |
| 333 // The receiver used to be a top level frame | |
| 334 bool interpreter_frame_equals_unpacked_fp(intptr_t* fp); | |
| 335 | |
| 336 // Return/result value from this interpreter frame | |
| 337 // If the method return type is T_OBJECT or T_ARRAY populates oop_result | |
| 338 // For other (non-T_VOID) the appropriate field in the jvalue is populated | |
| 339 // with the result value. | |
| 340 // Should only be called when at method exit when the method is not | |
| 341 // exiting due to an exception. | |
| 342 BasicType interpreter_frame_result(oop* oop_result, jvalue* value_result); | |
| 343 | |
| 344 public: | |
| 345 // Method & constant pool cache | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
346 Method* interpreter_frame_method() const; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
347 void interpreter_frame_set_method(Method* method); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
348 Method** interpreter_frame_method_addr() const; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
349 ConstantPoolCache** interpreter_frame_cache_addr() const; |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
350 #ifdef PPC |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
351 oop* interpreter_frame_mirror_addr() const; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
352 #endif |
| 0 | 353 |
| 354 public: | |
| 355 // Entry frames | |
| 356 JavaCallWrapper* entry_frame_call_wrapper() const; | |
| 357 intptr_t* entry_frame_argument_at(int offset) const; | |
| 358 | |
| 359 // tells whether there is another chunk of Delta stack above | |
| 360 bool entry_frame_is_first() const; | |
| 361 | |
| 362 // Compiled frames: | |
| 363 | |
| 364 public: | |
| 365 // Given the index of a local, and the number of argument words | |
| 366 // in this stack frame, tell which word of the stack frame to find | |
| 367 // the local in. Arguments are stored above the ofp/rpc pair, | |
| 368 // while other locals are stored below it. | |
| 369 // Since monitors (BasicLock blocks) are also assigned indexes, | |
| 370 // but may have different storage requirements, their presence | |
| 371 // can also affect the calculation of offsets. | |
| 372 static int local_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors); | |
| 373 | |
| 374 // Given the index of a monitor, etc., tell which word of the | |
| 375 // stack frame contains the start of the BasicLock block. | |
| 376 // Note that the local index by convention is the __higher__ | |
| 377 // of the two indexes allocated to the block. | |
| 378 static int monitor_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors); | |
| 379 | |
| 380 // Tell the smallest value that local_offset_for_compiler will attain. | |
| 381 // This is used to help determine how much stack frame to allocate. | |
| 382 static int min_local_offset_for_compiler(int nof_args, int max_nof_locals, int max_nof_monitors); | |
| 383 | |
| 384 // Tells if this register must be spilled during a call. | |
| 385 // On Intel, all registers are smashed by calls. | |
| 386 static bool volatile_across_calls(Register reg); | |
| 387 | |
| 388 | |
| 389 // Safepoints | |
| 390 | |
| 391 public: | |
| 392 oop saved_oop_result(RegisterMap* map) const; | |
| 393 void set_saved_oop_result(RegisterMap* map, oop obj); | |
| 394 | |
| 395 // For debugging | |
| 396 private: | |
| 397 const char* print_name() const; | |
| 398 | |
|
3336
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
399 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
|
400 |
| 0 | 401 public: |
| 402 void print_value() const { print_value_on(tty,NULL); } | |
| 403 void print_value_on(outputStream* st, JavaThread *thread) const; | |
| 404 void print_on(outputStream* st) const; | |
| 405 void interpreter_frame_print_on(outputStream* st) const; | |
| 406 void print_on_error(outputStream* st, char* buf, int buflen, bool verbose = false) const; | |
| 407 | |
|
3336
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
408 // 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
|
409 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
|
410 |
| 0 | 411 // Conversion from an VMReg to physical stack location |
| 412 oop* oopmapreg_to_location(VMReg reg, const RegisterMap* regmap) const; | |
| 413 | |
| 414 // Oops-do's | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2019
diff
changeset
|
415 void oops_compiled_arguments_do(Symbol* signature, bool has_receiver, const RegisterMap* reg_map, OopClosure* f); |
| 0 | 416 void oops_interpreted_do(OopClosure* f, const RegisterMap* map, bool query_oop_map_cache = true); |
| 417 | |
| 418 private: | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2019
diff
changeset
|
419 void oops_interpreted_arguments_do(Symbol* signature, bool has_receiver, OopClosure* f); |
| 0 | 420 |
| 421 // Iteration of oops | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
422 void oops_do_internal(OopClosure* f, CodeBlobClosure* cf, RegisterMap* map, bool use_interpreter_oop_map_cache); |
| 0 | 423 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
|
424 void oops_code_blob_do(OopClosure* f, CodeBlobClosure* cf, const RegisterMap* map); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
425 int adjust_offset(Method* method, int index); // helper for above fn |
| 0 | 426 public: |
| 427 // Memory management | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
428 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
|
429 void nmethods_do(CodeBlobClosure* cf); |
| 0 | 430 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
431 // RedefineClasses support for finding live interpreted methods on the stack |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
432 void metadata_do(void f(Metadata*)); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
433 |
| 0 | 434 void gc_prologue(); |
| 435 void gc_epilogue(); | |
| 436 void pd_gc_epilog(); | |
| 437 | |
| 438 # ifdef ENABLE_ZAP_DEAD_LOCALS | |
| 439 private: | |
| 440 class CheckValueClosure: public OopClosure { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
441 public: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
442 void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
443 void do_oop(narrowOop* p) { ShouldNotReachHere(); } |
| 0 | 444 }; |
| 445 static CheckValueClosure _check_value; | |
| 446 | |
| 447 class CheckOopClosure: public OopClosure { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
448 public: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
449 void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
450 void do_oop(narrowOop* p) { ShouldNotReachHere(); } |
| 0 | 451 }; |
| 452 static CheckOopClosure _check_oop; | |
| 453 | |
| 454 static void check_derived_oop(oop* base, oop* derived); | |
| 455 | |
| 456 class ZapDeadClosure: public OopClosure { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
457 public: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
458 void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
107
diff
changeset
|
459 void do_oop(narrowOop* p) { ShouldNotReachHere(); } |
| 0 | 460 }; |
| 461 static ZapDeadClosure _zap_dead; | |
| 462 | |
| 463 public: | |
| 464 // Zapping | |
| 465 void zap_dead_locals (JavaThread* thread, const RegisterMap* map); | |
| 466 void zap_dead_interpreted_locals(JavaThread* thread, const RegisterMap* map); | |
| 467 void zap_dead_compiled_locals (JavaThread* thread, const RegisterMap* map); | |
| 468 void zap_dead_entry_locals (JavaThread* thread, const RegisterMap* map); | |
| 469 void zap_dead_deoptimized_locals(JavaThread* thread, const RegisterMap* map); | |
| 470 # endif | |
| 471 // Verification | |
| 472 void verify(const RegisterMap* map); | |
| 473 static bool verify_return_pc(address x); | |
| 474 static bool is_bci(intptr_t bcx); | |
| 475 // Usage: | |
| 476 // assert(frame::verify_return_pc(return_address), "must be a return pc"); | |
| 477 | |
| 478 int pd_oop_map_offset_adjustment() const; | |
| 479 | |
| 1972 | 480 #ifdef TARGET_ARCH_x86 |
| 481 # include "frame_x86.hpp" | |
| 482 #endif | |
| 483 #ifdef TARGET_ARCH_sparc | |
| 484 # include "frame_sparc.hpp" | |
| 485 #endif | |
| 486 #ifdef TARGET_ARCH_zero | |
| 487 # include "frame_zero.hpp" | |
| 488 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
489 #ifdef TARGET_ARCH_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
490 # include "frame_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
491 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
492 #ifdef TARGET_ARCH_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
493 # include "frame_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
494 #endif |
| 1972 | 495 |
| 0 | 496 }; |
| 497 | |
|
4824
5dbed2f542ff
7120468: SPARC/x86: use frame::describe to enhance trace_method_handle
bdelsart
parents:
4806
diff
changeset
|
498 #ifndef PRODUCT |
|
3336
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
499 // 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
|
500 class FrameValue VALUE_OBJ_CLASS_SPEC { |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
501 public: |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
502 intptr_t* location; |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
503 char* description; |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
504 int owner; |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
505 int priority; |
|
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 |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
508 |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
509 // 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
|
510 // 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
|
511 // 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
|
512 // sorted before being printed. |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
513 class FrameValues { |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
514 private: |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
515 GrowableArray<FrameValue> _values; |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
516 |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
517 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
|
518 if (a->location == b->location) { |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
519 return a->priority - b->priority; |
|
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 return a->location - b->location; |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
522 } |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
523 |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
524 public: |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
525 // 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
|
526 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
|
527 |
|
4824
5dbed2f542ff
7120468: SPARC/x86: use frame::describe to enhance trace_method_handle
bdelsart
parents:
4806
diff
changeset
|
528 #ifdef ASSERT |
|
3365
3cfb240033d1
7043301: assert(locals < caller->fp() || locals > (caller->fp() + 16)) failed: locals in save area
never
parents:
3363
diff
changeset
|
529 void validate(); |
|
4824
5dbed2f542ff
7120468: SPARC/x86: use frame::describe to enhance trace_method_handle
bdelsart
parents:
4806
diff
changeset
|
530 #endif |
|
4042
b20d64f83668
7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop
twisti
parents:
3931
diff
changeset
|
531 void print(JavaThread* thread); |
|
3336
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
532 }; |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
533 |
|
2e038ad0c1d0
7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents:
2426
diff
changeset
|
534 #endif |
| 0 | 535 |
| 536 // | |
| 537 // StackFrameStream iterates through the frames of a thread starting from | |
| 538 // top most frame. It automatically takes care of updating the location of | |
| 539 // all (callee-saved) registers. Notice: If a thread is stopped at | |
| 540 // a safepoint, all registers are saved, not only the callee-saved ones. | |
| 541 // | |
| 542 // Use: | |
| 543 // | |
| 544 // for(StackFrameStream fst(thread); !fst.is_done(); fst.next()) { | |
| 545 // ... | |
| 546 // } | |
| 547 // | |
| 548 class StackFrameStream : public StackObj { | |
| 549 private: | |
| 550 frame _fr; | |
| 551 RegisterMap _reg_map; | |
| 552 bool _is_done; | |
| 553 public: | |
| 554 StackFrameStream(JavaThread *thread, bool update = true); | |
| 555 | |
| 556 // Iteration | |
| 557 bool is_done() { return (_is_done) ? true : (_is_done = _fr.is_first_frame(), false); } | |
| 558 void next() { if (!_is_done) _fr = _fr.sender(&_reg_map); } | |
| 559 | |
| 560 // Query | |
| 561 frame *current() { return &_fr; } | |
| 562 RegisterMap* register_map() { return &_reg_map; } | |
| 563 }; | |
| 1972 | 564 |
| 565 #endif // SHARE_VM_RUNTIME_FRAME_HPP |