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