truffle: src/share/vm/runtime/frame.hpp annotate

annotate src/share/vm/runtime/frame.hpp @ 13212:eb03a7335eb0

Use fixed instead of virtual register for target in far foreign call, since the register allocator does not support virtual registers to be used at call sites.

author	Christian Wimmer <christian.wimmer@oracle.com>
date	Mon, 02 Dec 2013 14:20:32 -0800
parents	cefad50507d8
children	d8041d695d19

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10390 diff changeset	2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	25 #ifndef SHARE_VM_RUNTIME_FRAME_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	26 #define SHARE_VM_RUNTIME_FRAME_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	27
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	28 #include "oops/method.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	29 #include "runtime/basicLock.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	30 #include "runtime/monitorChunk.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	31 #include "runtime/registerMap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	32 #include "utilities/top.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	33 #ifdef COMPILER2
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	34 #ifdef TARGET_ARCH_MODEL_x86_32
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	35 # include "adfiles/adGlobals_x86_32.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	36 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	37 #ifdef TARGET_ARCH_MODEL_x86_64
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	38 # include "adfiles/adGlobals_x86_64.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	39 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	40 #ifdef TARGET_ARCH_MODEL_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	41 # include "adfiles/adGlobals_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	42 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	43 #ifdef TARGET_ARCH_MODEL_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	44 # include "adfiles/adGlobals_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	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 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	52 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	53 #ifdef ZERO
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	54 #ifdef TARGET_ARCH_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	55 # include "stack_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	56 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	57 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	58
0 a61af66fc99e Initial load duke parents: diff changeset	59 typedef class BytecodeInterpreter* interpreterState;
a61af66fc99e Initial load duke parents: diff changeset	60
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	64
a61af66fc99e Initial load duke parents: diff changeset	65
a61af66fc99e Initial load duke parents: diff changeset	66 // A frame represents a physical stack frame (an activation). Frames
a61af66fc99e Initial load duke parents: diff changeset	67 // can be C or Java frames, and the Java frames can be interpreted or
a61af66fc99e Initial load duke parents: diff changeset	68 // compiled. In contrast, vframes represent source-level activations,
a61af66fc99e Initial load duke parents: diff changeset	69 // so that one physical frame can correspond to multiple source level
a61af66fc99e Initial load duke parents: diff changeset	70 // frames because of inlining.
a61af66fc99e Initial load duke parents: diff changeset	71
a61af66fc99e Initial load duke parents: diff changeset	72 class frame VALUE_OBJ_CLASS_SPEC {
a61af66fc99e Initial load duke parents: diff changeset	73 private:
a61af66fc99e Initial load duke parents: diff changeset	74 // Instance variables:
a61af66fc99e Initial load duke parents: diff changeset	75 intptr_t* _sp; // stack pointer (from Thread::last_Java_sp)
a61af66fc99e Initial load duke parents: diff changeset	76 address _pc; // program counter (the next instruction after the call)
a61af66fc99e Initial load duke parents: diff changeset	77
a61af66fc99e Initial load duke parents: diff changeset	78 CodeBlob* _cb; // CodeBlob that "owns" pc
a61af66fc99e Initial load duke parents: diff changeset	79 enum deopt_state {
a61af66fc99e Initial load duke parents: diff changeset	80 not_deoptimized,
a61af66fc99e Initial load duke parents: diff changeset	81 is_deoptimized,
a61af66fc99e Initial load duke parents: diff changeset	82 unknown
a61af66fc99e Initial load duke parents: diff changeset	83 };
a61af66fc99e Initial load duke parents: diff changeset	84
a61af66fc99e Initial load duke parents: diff changeset	85 deopt_state _deopt_state;
a61af66fc99e Initial load duke parents: diff changeset	86
a61af66fc99e Initial load duke parents: diff changeset	87 public:
a61af66fc99e Initial load duke parents: diff changeset	88 // Constructors
a61af66fc99e Initial load duke parents: diff changeset	89 frame();
a61af66fc99e Initial load duke parents: diff changeset	90
a61af66fc99e Initial load duke parents: diff changeset	91 // Accessors
a61af66fc99e Initial load duke parents: diff changeset	92
a61af66fc99e Initial load duke parents: diff changeset	93 // pc: Returns the pc at which this frame will continue normally.
a61af66fc99e Initial load duke parents: diff changeset	94 // It must point at the beginning of the next instruction to execute.
a61af66fc99e Initial load duke parents: diff changeset	95 address pc() const { return _pc; }
a61af66fc99e Initial load duke parents: diff changeset	96
a61af66fc99e Initial load duke parents: diff changeset	97 // This returns the pc that if you were in the debugger you'd see. Not
a61af66fc99e Initial load duke parents: diff changeset	98 // the idealized value in the frame object. This undoes the magic conversion
a61af66fc99e Initial load duke parents: diff changeset	99 // that happens for deoptimized frames. In addition it makes the value the
a61af66fc99e Initial load duke parents: diff changeset	100 // hardware would want to see in the native frame. The only user (at this point)
a61af66fc99e Initial load duke parents: diff changeset	101 // is deoptimization. It likely no one else should ever use it.
a61af66fc99e Initial load duke parents: diff changeset	102 address raw_pc() const;
a61af66fc99e Initial load duke parents: diff changeset	103
a61af66fc99e Initial load duke parents: diff changeset	104 void set_pc( address newpc );
a61af66fc99e Initial load duke parents: diff changeset	105
a61af66fc99e Initial load duke parents: diff changeset	106 intptr_t* sp() const { return _sp; }
a61af66fc99e Initial load duke parents: diff changeset	107 void set_sp( intptr_t* newsp ) { _sp = newsp; }
a61af66fc99e Initial load duke parents: diff changeset	108
a61af66fc99e Initial load duke parents: diff changeset	109
a61af66fc99e Initial load duke parents: diff changeset	110 CodeBlob* cb() const { return _cb; }
a61af66fc99e Initial load duke parents: diff changeset	111
a61af66fc99e Initial load duke parents: diff changeset	112 // patching operations
a61af66fc99e Initial load duke parents: diff changeset	113 void patch_pc(Thread* thread, address pc);
a61af66fc99e Initial load duke parents: diff changeset	114
a61af66fc99e Initial load duke parents: diff changeset	115 // Every frame needs to return a unique id which distinguishes it from all other frames.
a61af66fc99e Initial load duke parents: diff changeset	116 // For sparc and ia32 use sp. ia64 can have memory frames that are empty so multiple frames
a61af66fc99e Initial load duke parents: diff changeset	117 // will have identical sp values. For ia64 the bsp (fp) value will serve. No real frame
a61af66fc99e Initial load duke parents: diff changeset	118 // should have an id() of NULL so it is a distinguishing value for an unmatchable frame.
a61af66fc99e Initial load duke parents: diff changeset	119 // We also have relationals which allow comparing a frame to anoth frame's id() allow
a61af66fc99e Initial load duke parents: diff changeset	120 // us to distinguish younger (more recent activation) from older (less recent activations)
a61af66fc99e Initial load duke parents: diff changeset	121 // A NULL id is only valid when comparing for equality.
a61af66fc99e Initial load duke parents: diff changeset	122
a61af66fc99e Initial load duke parents: diff changeset	123 intptr_t* id(void) const;
a61af66fc99e Initial load duke parents: diff changeset	124 bool is_younger(intptr_t* id) const;
a61af66fc99e Initial load duke parents: diff changeset	125 bool is_older(intptr_t* id) const;
a61af66fc99e Initial load duke parents: diff changeset	126
a61af66fc99e Initial load duke parents: diff changeset	127 // testers
a61af66fc99e Initial load duke parents: diff changeset	128
a61af66fc99e Initial load duke parents: diff changeset	129 // Compares for strict equality. Rarely used or needed.
a61af66fc99e Initial load duke parents: diff changeset	130 // It can return a different result than f1.id() == f2.id()
a61af66fc99e Initial load duke parents: diff changeset	131 bool equal(frame other) const;
a61af66fc99e Initial load duke parents: diff changeset	132
a61af66fc99e Initial load duke parents: diff changeset	133 // type testers
a61af66fc99e Initial load duke parents: diff changeset	134 bool is_interpreted_frame() const;
a61af66fc99e Initial load duke parents: diff changeset	135 bool is_java_frame() const;
a61af66fc99e Initial load duke parents: diff changeset	136 bool is_entry_frame() const; // Java frame called from C?
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10390 diff changeset	137 bool is_stub_frame() const;
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 a61af66fc99e Initial load duke parents: diff changeset	139 bool is_native_frame() const;
a61af66fc99e Initial load duke parents: diff changeset	140 bool is_runtime_frame() const;
a61af66fc99e Initial load duke parents: diff changeset	141 bool is_compiled_frame() const;
a61af66fc99e Initial load duke parents: diff changeset	142 bool is_safepoint_blob_frame() const;
a61af66fc99e Initial load duke parents: diff changeset	143 bool is_deoptimized_frame() const;
a61af66fc99e Initial load duke parents: diff changeset	144
a61af66fc99e Initial load duke parents: diff changeset	145 // testers
a61af66fc99e Initial load duke parents: diff changeset	146 bool is_first_frame() const; // oldest frame? (has no sender)
a61af66fc99e Initial load duke parents: diff changeset	147 bool is_first_java_frame() const; // same for Java frame
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	150
a61af66fc99e Initial load duke parents: diff changeset	151 // tells whether this frame is marked for deoptimization
a61af66fc99e Initial load duke parents: diff changeset	152 bool should_be_deoptimized() const;
a61af66fc99e Initial load duke parents: diff changeset	153
a61af66fc99e Initial load duke parents: diff changeset	154 // tells whether this frame can be deoptimized
a61af66fc99e Initial load duke parents: diff changeset	155 bool can_be_deoptimized() const;
a61af66fc99e Initial load duke parents: diff changeset	156
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	159
a61af66fc99e Initial load duke parents: diff changeset	160 // returns the sending frame
a61af66fc99e Initial load duke parents: diff changeset	161 frame sender(RegisterMap* map) const;
a61af66fc99e Initial load duke parents: diff changeset	162
a61af66fc99e Initial load duke parents: diff changeset	163 // for Profiling - acting on another frame. walks sender frames
a61af66fc99e Initial load duke parents: diff changeset	164 // if valid.
a61af66fc99e Initial load duke parents: diff changeset	165 frame profile_find_Java_sender_frame(JavaThread *thread);
a61af66fc99e Initial load duke parents: diff changeset	166 bool safe_for_sender(JavaThread *thread);
a61af66fc99e Initial load duke parents: diff changeset	167
a61af66fc99e Initial load duke parents: diff changeset	168 // returns the sender, but skips conversion frames
a61af66fc99e Initial load duke parents: diff changeset	169 frame real_sender(RegisterMap* map) const;
a61af66fc99e Initial load duke parents: diff changeset	170
a61af66fc99e Initial load duke parents: diff changeset	171 // returns the the sending Java frame, skipping any intermediate C frames
a61af66fc99e Initial load duke parents: diff changeset	172 // NB: receiver must not be first frame
a61af66fc99e Initial load duke parents: diff changeset	173 frame java_sender() const;
a61af66fc99e Initial load duke parents: diff changeset	174
a61af66fc99e Initial load duke parents: diff changeset	175 private:
a61af66fc99e Initial load duke parents: diff changeset	176 // Helper methods for better factored code in frame::sender
a61af66fc99e Initial load duke parents: diff changeset	177 frame sender_for_compiled_frame(RegisterMap* map) const;
a61af66fc99e Initial load duke parents: diff changeset	178 frame sender_for_entry_frame(RegisterMap* map) const;
a61af66fc99e Initial load duke parents: diff changeset	179 frame sender_for_interpreter_frame(RegisterMap* map) const;
a61af66fc99e Initial load duke parents: diff changeset	180 frame sender_for_native_frame(RegisterMap* map) const;
a61af66fc99e Initial load duke parents: diff changeset	181
a61af66fc99e Initial load duke parents: diff changeset	182 // All frames:
a61af66fc99e Initial load duke parents: diff changeset	183
a61af66fc99e Initial load duke parents: diff changeset	184 // A low-level interface for vframes:
a61af66fc99e Initial load duke parents: diff changeset	185
a61af66fc99e Initial load duke parents: diff changeset	186 public:
a61af66fc99e Initial load duke parents: diff changeset	187
a61af66fc99e Initial load duke parents: diff changeset	188 intptr_t* addr_at(int index) const { return &fp()[index]; }
a61af66fc99e Initial load duke parents: diff changeset	189 intptr_t at(int index) const { return *addr_at(index); }
a61af66fc99e Initial load duke parents: diff changeset	190
a61af66fc99e Initial load duke parents: diff changeset	191 // accessors for locals
a61af66fc99e Initial load duke parents: diff changeset	192 oop obj_at(int offset) const { return *obj_at_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	193 void obj_at_put(int offset, oop value) { *obj_at_addr(offset) = value; }
a61af66fc99e Initial load duke parents: diff changeset	194
a61af66fc99e Initial load duke parents: diff changeset	195 jint int_at(int offset) const { return *int_at_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	196 void int_at_put(int offset, jint value) { *int_at_addr(offset) = value; }
a61af66fc99e Initial load duke parents: diff changeset	197
a61af66fc99e Initial load duke parents: diff changeset	198 oop* obj_at_addr(int offset) const { return (oop*) addr_at(offset); }
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	201
a61af66fc99e Initial load duke parents: diff changeset	202 private:
a61af66fc99e Initial load duke parents: diff changeset	203 jint* int_at_addr(int offset) const { return (jint*) addr_at(offset); }
a61af66fc99e Initial load duke parents: diff changeset	204
a61af66fc99e Initial load duke parents: diff changeset	205 public:
a61af66fc99e Initial load duke parents: diff changeset	206 // Link (i.e., the pointer to the previous frame)
a61af66fc99e Initial load duke parents: diff changeset	207 intptr_t* link() const;
a61af66fc99e Initial load duke parents: diff changeset	208 void set_link(intptr_t* addr);
a61af66fc99e Initial load duke parents: diff changeset	209
a61af66fc99e Initial load duke parents: diff changeset	210 // Return address
a61af66fc99e Initial load duke parents: diff changeset	211 address sender_pc() const;
a61af66fc99e Initial load duke parents: diff changeset	212
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	215
a61af66fc99e Initial load duke parents: diff changeset	216 // The frame's original SP, before any extension by an interpreted callee;
a61af66fc99e Initial load duke parents: diff changeset	217 // used for packing debug info into vframeArray objects and vframeArray lookup.
a61af66fc99e Initial load duke parents: diff changeset	218 intptr_t* unextended_sp() const;
a61af66fc99e Initial load duke parents: diff changeset	219
a61af66fc99e Initial load duke parents: diff changeset	220 // returns the stack pointer of the calling frame
a61af66fc99e Initial load duke parents: diff changeset	221 intptr_t* sender_sp() const;
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	236
a61af66fc99e Initial load duke parents: diff changeset	237 // Interpreter frames:
a61af66fc99e Initial load duke parents: diff changeset	238
a61af66fc99e Initial load duke parents: diff changeset	239 private:
a61af66fc99e Initial load duke parents: diff changeset	240 intptr_t** interpreter_frame_locals_addr() const;
a61af66fc99e Initial load duke parents: diff changeset	241 intptr_t* interpreter_frame_bcx_addr() const;
a61af66fc99e Initial load duke parents: diff changeset	242 intptr_t* interpreter_frame_mdx_addr() const;
a61af66fc99e Initial load duke parents: diff changeset	243
a61af66fc99e Initial load duke parents: diff changeset	244 public:
a61af66fc99e Initial load duke parents: diff changeset	245 // Locals
a61af66fc99e Initial load duke parents: diff changeset	246
a61af66fc99e Initial load duke parents: diff changeset	247 // The _at version returns a pointer because the address is used for GC.
a61af66fc99e Initial load duke parents: diff changeset	248 intptr_t* interpreter_frame_local_at(int index) const;
a61af66fc99e Initial load duke parents: diff changeset	249
a61af66fc99e Initial load duke parents: diff changeset	250 void interpreter_frame_set_locals(intptr_t* locs);
a61af66fc99e Initial load duke parents: diff changeset	251
a61af66fc99e Initial load duke parents: diff changeset	252 // byte code index/pointer (use these functions for unchecked frame access only!)
a61af66fc99e Initial load duke parents: diff changeset	253 intptr_t interpreter_frame_bcx() const { return *interpreter_frame_bcx_addr(); }
a61af66fc99e Initial load duke parents: diff changeset	254 void interpreter_frame_set_bcx(intptr_t bcx);
a61af66fc99e Initial load duke parents: diff changeset	255
a61af66fc99e Initial load duke parents: diff changeset	256 // byte code index
a61af66fc99e Initial load duke parents: diff changeset	257 jint interpreter_frame_bci() const;
a61af66fc99e Initial load duke parents: diff changeset	258 void interpreter_frame_set_bci(jint bci);
a61af66fc99e Initial load duke parents: diff changeset	259
a61af66fc99e Initial load duke parents: diff changeset	260 // byte code pointer
a61af66fc99e Initial load duke parents: diff changeset	261 address interpreter_frame_bcp() const;
a61af66fc99e Initial load duke parents: diff changeset	262 void interpreter_frame_set_bcp(address bcp);
a61af66fc99e Initial load duke parents: diff changeset	263
a61af66fc99e Initial load duke parents: diff changeset	264 // Unchecked access to the method data index/pointer.
a61af66fc99e Initial load duke parents: diff changeset	265 // Only use this if you know what you are doing.
a61af66fc99e Initial load duke parents: diff changeset	266 intptr_t interpreter_frame_mdx() const { return *interpreter_frame_mdx_addr(); }
a61af66fc99e Initial load duke parents: diff changeset	267 void interpreter_frame_set_mdx(intptr_t mdx);
a61af66fc99e Initial load duke parents: diff changeset	268
a61af66fc99e Initial load duke parents: diff changeset	269 // method data pointer
a61af66fc99e Initial load duke parents: diff changeset	270 address interpreter_frame_mdp() const;
a61af66fc99e Initial load duke parents: diff changeset	271 void interpreter_frame_set_mdp(address dp);
a61af66fc99e Initial load duke parents: diff changeset	272
a61af66fc99e Initial load duke parents: diff changeset	273 // Find receiver out of caller's (compiled) argument list
a61af66fc99e Initial load duke parents: diff changeset	274 oop retrieve_receiver(RegisterMap *reg_map);
a61af66fc99e Initial load duke parents: diff changeset	275
a61af66fc99e Initial load duke parents: diff changeset	276 // Return the monitor owner and BasicLock for compiled synchronized
a61af66fc99e Initial load duke parents: diff changeset	277 // native methods so that biased locking can revoke the receiver's
2019 09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	278 // bias if necessary. This is also used by JVMTI's GetLocalInstance method
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	279 // (via VM_GetReceiver) to retrieve the receiver from a native wrapper frame.
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	280 BasicLock* get_native_monitor();
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	281 oop get_native_receiver();
0 a61af66fc99e Initial load duke parents: diff changeset	282
a61af66fc99e Initial load duke parents: diff changeset	283 // Find receiver for an invoke when arguments are just pushed on stack (i.e., callee stack-frame is
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	286
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	289
a61af66fc99e Initial load duke parents: diff changeset	290
a61af66fc99e Initial load duke parents: diff changeset	291 // expression stack (may go up or down, direction == 1 or -1)
a61af66fc99e Initial load duke parents: diff changeset	292 public:
a61af66fc99e Initial load duke parents: diff changeset	293 intptr_t* interpreter_frame_expression_stack() const;
a61af66fc99e Initial load duke parents: diff changeset	294 static jint interpreter_frame_expression_stack_direction();
a61af66fc99e Initial load duke parents: diff changeset	295
a61af66fc99e Initial load duke parents: diff changeset	296 // The _at version returns a pointer because the address is used for GC.
a61af66fc99e Initial load duke parents: diff changeset	297 intptr_t* interpreter_frame_expression_stack_at(jint offset) const;
a61af66fc99e Initial load duke parents: diff changeset	298
a61af66fc99e Initial load duke parents: diff changeset	299 // top of expression stack
a61af66fc99e Initial load duke parents: diff changeset	300 intptr_t* interpreter_frame_tos_at(jint offset) const;
a61af66fc99e Initial load duke parents: diff changeset	301 intptr_t* interpreter_frame_tos_address() const;
a61af66fc99e Initial load duke parents: diff changeset	302
a61af66fc99e Initial load duke parents: diff changeset	303
a61af66fc99e Initial load duke parents: diff changeset	304 jint interpreter_frame_expression_stack_size() const;
a61af66fc99e Initial load duke parents: diff changeset	305
a61af66fc99e Initial load duke parents: diff changeset	306 intptr_t* interpreter_frame_sender_sp() const;
a61af66fc99e Initial load duke parents: diff changeset	307
a61af66fc99e Initial load duke parents: diff changeset	308 #ifndef CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	309 // template based interpreter deoptimization support
a61af66fc99e Initial load duke parents: diff changeset	310 void set_interpreter_frame_sender_sp(intptr_t* sender_sp);
a61af66fc99e Initial load duke parents: diff changeset	311 void interpreter_frame_set_monitor_end(BasicObjectLock* value);
a61af66fc99e Initial load duke parents: diff changeset	312 #endif // CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	313
a61af66fc99e Initial load duke parents: diff changeset	314 // BasicObjectLocks:
a61af66fc99e Initial load duke parents: diff changeset	315 //
a61af66fc99e Initial load duke parents: diff changeset	316 // interpreter_frame_monitor_begin is higher in memory than interpreter_frame_monitor_end
a61af66fc99e Initial load duke parents: diff changeset	317 // Interpreter_frame_monitor_begin points to one element beyond the oldest one,
a61af66fc99e Initial load duke parents: diff changeset	318 // interpreter_frame_monitor_end points to the youngest one, or if there are none,
a61af66fc99e Initial load duke parents: diff changeset	319 // it points to one beyond where the first element will be.
a61af66fc99e Initial load duke parents: diff changeset	320 // interpreter_frame_monitor_size reports the allocation size of a monitor in the interpreter stack.
a61af66fc99e Initial load duke parents: diff changeset	321 // this value is >= BasicObjectLock::size(), and may be rounded up
a61af66fc99e Initial load duke parents: diff changeset	322
a61af66fc99e Initial load duke parents: diff changeset	323 BasicObjectLock* interpreter_frame_monitor_begin() const;
a61af66fc99e Initial load duke parents: diff changeset	324 BasicObjectLock* interpreter_frame_monitor_end() const;
a61af66fc99e Initial load duke parents: diff changeset	325 BasicObjectLock* next_monitor_in_interpreter_frame(BasicObjectLock* current) const;
a61af66fc99e Initial load duke parents: diff changeset	326 BasicObjectLock* previous_monitor_in_interpreter_frame(BasicObjectLock* current) const;
a61af66fc99e Initial load duke parents: diff changeset	327 static int interpreter_frame_monitor_size();
a61af66fc99e Initial load duke parents: diff changeset	328
a61af66fc99e Initial load duke parents: diff changeset	329 void interpreter_frame_verify_monitor(BasicObjectLock* value) const;
a61af66fc99e Initial load duke parents: diff changeset	330
a61af66fc99e Initial load duke parents: diff changeset	331 // Tells whether the current interpreter_frame frame pointer
a61af66fc99e Initial load duke parents: diff changeset	332 // corresponds to the old compiled/deoptimized fp
a61af66fc99e Initial load duke parents: diff changeset	333 // The receiver used to be a top level frame
a61af66fc99e Initial load duke parents: diff changeset	334 bool interpreter_frame_equals_unpacked_fp(intptr_t* fp);
a61af66fc99e Initial load duke parents: diff changeset	335
a61af66fc99e Initial load duke parents: diff changeset	336 // Return/result value from this interpreter frame
a61af66fc99e Initial load duke parents: diff changeset	337 // If the method return type is T_OBJECT or T_ARRAY populates oop_result
a61af66fc99e Initial load duke parents: diff changeset	338 // For other (non-T_VOID) the appropriate field in the jvalue is populated
a61af66fc99e Initial load duke parents: diff changeset	339 // with the result value.
a61af66fc99e Initial load duke parents: diff changeset	340 // Should only be called when at method exit when the method is not
a61af66fc99e Initial load duke parents: diff changeset	341 // exiting due to an exception.
a61af66fc99e Initial load duke parents: diff changeset	342 BasicType interpreter_frame_result(oop* oop_result, jvalue* value_result);
a61af66fc99e Initial load duke parents: diff changeset	343
a61af66fc99e Initial load duke parents: diff changeset	344 public:
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	353
a61af66fc99e Initial load duke parents: diff changeset	354 public:
a61af66fc99e Initial load duke parents: diff changeset	355 // Entry frames
11146 e619a2766bcc 8016131: nsk/sysdict/vm/stress/chain tests crash the VM in 'entry_frame_is_first()' rbackman parents: 10405 diff changeset	356 JavaCallWrapper* entry_frame_call_wrapper() const { return *entry_frame_call_wrapper_addr(); }
e619a2766bcc 8016131: nsk/sysdict/vm/stress/chain tests crash the VM in 'entry_frame_is_first()' rbackman parents: 10405 diff changeset	357 JavaCallWrapper* entry_frame_call_wrapper_if_safe(JavaThread* thread) const;
e619a2766bcc 8016131: nsk/sysdict/vm/stress/chain tests crash the VM in 'entry_frame_is_first()' rbackman parents: 10405 diff changeset	358 JavaCallWrapper** entry_frame_call_wrapper_addr() const;
0 a61af66fc99e Initial load duke parents: diff changeset	359 intptr_t* entry_frame_argument_at(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	360
a61af66fc99e Initial load duke parents: diff changeset	361 // tells whether there is another chunk of Delta stack above
a61af66fc99e Initial load duke parents: diff changeset	362 bool entry_frame_is_first() const;
a61af66fc99e Initial load duke parents: diff changeset	363
a61af66fc99e Initial load duke parents: diff changeset	364 // Compiled frames:
a61af66fc99e Initial load duke parents: diff changeset	365
a61af66fc99e Initial load duke parents: diff changeset	366 public:
a61af66fc99e Initial load duke parents: diff changeset	367 // Given the index of a local, and the number of argument words
a61af66fc99e Initial load duke parents: diff changeset	368 // in this stack frame, tell which word of the stack frame to find
a61af66fc99e Initial load duke parents: diff changeset	369 // the local in. Arguments are stored above the ofp/rpc pair,
a61af66fc99e Initial load duke parents: diff changeset	370 // while other locals are stored below it.
a61af66fc99e Initial load duke parents: diff changeset	371 // Since monitors (BasicLock blocks) are also assigned indexes,
a61af66fc99e Initial load duke parents: diff changeset	372 // but may have different storage requirements, their presence
a61af66fc99e Initial load duke parents: diff changeset	373 // can also affect the calculation of offsets.
a61af66fc99e Initial load duke parents: diff changeset	374 static int local_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors);
a61af66fc99e Initial load duke parents: diff changeset	375
a61af66fc99e Initial load duke parents: diff changeset	376 // Given the index of a monitor, etc., tell which word of the
a61af66fc99e Initial load duke parents: diff changeset	377 // stack frame contains the start of the BasicLock block.
a61af66fc99e Initial load duke parents: diff changeset	378 // Note that the local index by convention is the __higher__
a61af66fc99e Initial load duke parents: diff changeset	379 // of the two indexes allocated to the block.
a61af66fc99e Initial load duke parents: diff changeset	380 static int monitor_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors);
a61af66fc99e Initial load duke parents: diff changeset	381
a61af66fc99e Initial load duke parents: diff changeset	382 // Tell the smallest value that local_offset_for_compiler will attain.
a61af66fc99e Initial load duke parents: diff changeset	383 // This is used to help determine how much stack frame to allocate.
a61af66fc99e Initial load duke parents: diff changeset	384 static int min_local_offset_for_compiler(int nof_args, int max_nof_locals, int max_nof_monitors);
a61af66fc99e Initial load duke parents: diff changeset	385
a61af66fc99e Initial load duke parents: diff changeset	386 // Tells if this register must be spilled during a call.
a61af66fc99e Initial load duke parents: diff changeset	387 // On Intel, all registers are smashed by calls.
a61af66fc99e Initial load duke parents: diff changeset	388 static bool volatile_across_calls(Register reg);
a61af66fc99e Initial load duke parents: diff changeset	389
a61af66fc99e Initial load duke parents: diff changeset	390
a61af66fc99e Initial load duke parents: diff changeset	391 // Safepoints
a61af66fc99e Initial load duke parents: diff changeset	392
a61af66fc99e Initial load duke parents: diff changeset	393 public:
a61af66fc99e Initial load duke parents: diff changeset	394 oop saved_oop_result(RegisterMap* map) const;
a61af66fc99e Initial load duke parents: diff changeset	395 void set_saved_oop_result(RegisterMap* map, oop obj);
a61af66fc99e Initial load duke parents: diff changeset	396
a61af66fc99e Initial load duke parents: diff changeset	397 // For debugging
a61af66fc99e Initial load duke parents: diff changeset	398 private:
a61af66fc99e Initial load duke parents: diff changeset	399 const char* print_name() const;
a61af66fc99e Initial load duke parents: diff changeset	400
3336 2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	401 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	402
0 a61af66fc99e Initial load duke parents: diff changeset	403 public:
a61af66fc99e Initial load duke parents: diff changeset	404 void print_value() const { print_value_on(tty,NULL); }
a61af66fc99e Initial load duke parents: diff changeset	405 void print_value_on(outputStream* st, JavaThread *thread) const;
a61af66fc99e Initial load duke parents: diff changeset	406 void print_on(outputStream* st) const;
a61af66fc99e Initial load duke parents: diff changeset	407 void interpreter_frame_print_on(outputStream* st) const;
a61af66fc99e Initial load duke parents: diff changeset	408 void print_on_error(outputStream* st, char* buf, int buflen, bool verbose = false) const;
12199 38f750491293 8022335: Native stack walk while generating hs_err does not work on Windows x64 iklam parents: 11146 diff changeset	409 static void print_C_frame(outputStream* st, char* buf, int buflen, address pc);
0 a61af66fc99e Initial load duke parents: diff changeset	410
3336 2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	411 // 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	412 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	413
0 a61af66fc99e Initial load duke parents: diff changeset	414 // Conversion from an VMReg to physical stack location
a61af66fc99e Initial load duke parents: diff changeset	415 oop* oopmapreg_to_location(VMReg reg, const RegisterMap* regmap) const;
a61af66fc99e Initial load duke parents: diff changeset	416
a61af66fc99e Initial load duke parents: diff changeset	417 // Oops-do's
10390 28e5aed7f3a6 8009981: nashorn tests fail with -XX:+VerifyStack roland parents: 7206 diff changeset	418 void oops_compiled_arguments_do(Symbol* signature, bool has_receiver, bool has_appendix, const RegisterMap* reg_map, OopClosure* f);
7179 d0aa87f04bd5 8003720: NPG: Method in interpreter stack frame can be deallocated stefank parents: 6725 diff changeset	419 void oops_interpreted_do(OopClosure* f, CLDToOopClosure* cld_f, const RegisterMap* map, bool query_oop_map_cache = true);
0 a61af66fc99e Initial load duke parents: diff changeset	420
a61af66fc99e Initial load duke parents: diff changeset	421 private:
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2019 diff changeset	422 void oops_interpreted_arguments_do(Symbol* signature, bool has_receiver, OopClosure* f);
0 a61af66fc99e Initial load duke parents: diff changeset	423
a61af66fc99e Initial load duke parents: diff changeset	424 // Iteration of oops
7179 d0aa87f04bd5 8003720: NPG: Method in interpreter stack frame can be deallocated stefank parents: 6725 diff changeset	425 void oops_do_internal(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf, RegisterMap* map, bool use_interpreter_oop_map_cache);
0 a61af66fc99e Initial load duke parents: diff changeset	426 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	427 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	428 int adjust_offset(Method* method, int index); // helper for above fn
0 a61af66fc99e Initial load duke parents: diff changeset	429 public:
a61af66fc99e Initial load duke parents: diff changeset	430 // Memory management
7179 d0aa87f04bd5 8003720: NPG: Method in interpreter stack frame can be deallocated stefank parents: 6725 diff changeset	431 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	432 void nmethods_do(CodeBlobClosure* cf);
0 a61af66fc99e Initial load duke parents: diff changeset	433
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	434 // 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	435 void metadata_do(void f(Metadata*));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	436
0 a61af66fc99e Initial load duke parents: diff changeset	437 void gc_prologue();
a61af66fc99e Initial load duke parents: diff changeset	438 void gc_epilogue();
a61af66fc99e Initial load duke parents: diff changeset	439 void pd_gc_epilog();
a61af66fc99e Initial load duke parents: diff changeset	440
a61af66fc99e Initial load duke parents: diff changeset	441 # ifdef ENABLE_ZAP_DEAD_LOCALS
a61af66fc99e Initial load duke parents: diff changeset	442 private:
a61af66fc99e Initial load duke parents: diff changeset	443 class CheckValueClosure: public OopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 107 diff changeset	444 public:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 107 diff changeset	445 void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 107 diff changeset	446 void do_oop(narrowOop* p) { ShouldNotReachHere(); }
0 a61af66fc99e Initial load duke parents: diff changeset	447 };
a61af66fc99e Initial load duke parents: diff changeset	448 static CheckValueClosure _check_value;
a61af66fc99e Initial load duke parents: diff changeset	449
a61af66fc99e Initial load duke parents: diff changeset	450 class CheckOopClosure: public OopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 107 diff changeset	451 public:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 107 diff changeset	452 void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 107 diff changeset	453 void do_oop(narrowOop* p) { ShouldNotReachHere(); }
0 a61af66fc99e Initial load duke parents: diff changeset	454 };
a61af66fc99e Initial load duke parents: diff changeset	455 static CheckOopClosure _check_oop;
a61af66fc99e Initial load duke parents: diff changeset	456
a61af66fc99e Initial load duke parents: diff changeset	457 static void check_derived_oop(oop* base, oop* derived);
a61af66fc99e Initial load duke parents: diff changeset	458
a61af66fc99e Initial load duke parents: diff changeset	459 class ZapDeadClosure: public OopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 107 diff changeset	460 public:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 107 diff changeset	461 void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 107 diff changeset	462 void do_oop(narrowOop* p) { ShouldNotReachHere(); }
0 a61af66fc99e Initial load duke parents: diff changeset	463 };
a61af66fc99e Initial load duke parents: diff changeset	464 static ZapDeadClosure _zap_dead;
a61af66fc99e Initial load duke parents: diff changeset	465
a61af66fc99e Initial load duke parents: diff changeset	466 public:
a61af66fc99e Initial load duke parents: diff changeset	467 // Zapping
a61af66fc99e Initial load duke parents: diff changeset	468 void zap_dead_locals (JavaThread* thread, const RegisterMap* map);
a61af66fc99e Initial load duke parents: diff changeset	469 void zap_dead_interpreted_locals(JavaThread* thread, const RegisterMap* map);
a61af66fc99e Initial load duke parents: diff changeset	470 void zap_dead_compiled_locals (JavaThread* thread, const RegisterMap* map);
a61af66fc99e Initial load duke parents: diff changeset	471 void zap_dead_entry_locals (JavaThread* thread, const RegisterMap* map);
a61af66fc99e Initial load duke parents: diff changeset	472 void zap_dead_deoptimized_locals(JavaThread* thread, const RegisterMap* map);
a61af66fc99e Initial load duke parents: diff changeset	473 # endif
a61af66fc99e Initial load duke parents: diff changeset	474 // Verification
a61af66fc99e Initial load duke parents: diff changeset	475 void verify(const RegisterMap* map);
a61af66fc99e Initial load duke parents: diff changeset	476 static bool verify_return_pc(address x);
a61af66fc99e Initial load duke parents: diff changeset	477 static bool is_bci(intptr_t bcx);
a61af66fc99e Initial load duke parents: diff changeset	478 // Usage:
a61af66fc99e Initial load duke parents: diff changeset	479 // assert(frame::verify_return_pc(return_address), "must be a return pc");
a61af66fc99e Initial load duke parents: diff changeset	480
a61af66fc99e Initial load duke parents: diff changeset	481 int pd_oop_map_offset_adjustment() const;
a61af66fc99e Initial load duke parents: diff changeset	482
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	483 #ifdef TARGET_ARCH_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	484 # include "frame_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	485 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	486 #ifdef TARGET_ARCH_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	487 # include "frame_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	488 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	489 #ifdef TARGET_ARCH_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	490 # include "frame_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	491 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	492 #ifdef TARGET_ARCH_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	493 # include "frame_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	494 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	495 #ifdef TARGET_ARCH_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	496 # include "frame_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	497 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	498
0 a61af66fc99e Initial load duke parents: diff changeset	499 };
a61af66fc99e Initial load duke parents: diff changeset	500
4824 5dbed2f542ff 7120468: SPARC/x86: use frame::describe to enhance trace_method_handle bdelsart parents: 4806 diff changeset	501 #ifndef PRODUCT
3336 2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	502 // 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	503 class FrameValue VALUE_OBJ_CLASS_SPEC {
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	504 public:
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	505 intptr_t* location;
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	506 char* description;
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	507 int owner;
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	508 int priority;
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	509 };
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
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	512 // 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	513 // 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	514 // 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	515 // sorted before being printed.
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	516 class FrameValues {
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	517 private:
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	518 GrowableArray<FrameValue> _values;
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 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	521 if (a->location == b->location) {
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	522 return a->priority - b->priority;
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 return a->location - b->location;
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	525 }
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	526
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	527 public:
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	528 // 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	529 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	530
4824 5dbed2f542ff 7120468: SPARC/x86: use frame::describe to enhance trace_method_handle bdelsart parents: 4806 diff changeset	531 #ifdef ASSERT
3365 3cfb240033d1 7043301: assert(locals < caller->fp() \|\| locals > (caller->fp() + 16)) failed: locals in save area never parents: 3363 diff changeset	532 void validate();
4824 5dbed2f542ff 7120468: SPARC/x86: use frame::describe to enhance trace_method_handle bdelsart parents: 4806 diff changeset	533 #endif
4042 b20d64f83668 7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop twisti parents: 3931 diff changeset	534 void print(JavaThread* thread);
3336 2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	535 };
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	536
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2426 diff changeset	537 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	538
a61af66fc99e Initial load duke parents: diff changeset	539 //
a61af66fc99e Initial load duke parents: diff changeset	540 // StackFrameStream iterates through the frames of a thread starting from
a61af66fc99e Initial load duke parents: diff changeset	541 // top most frame. It automatically takes care of updating the location of
a61af66fc99e Initial load duke parents: diff changeset	542 // all (callee-saved) registers. Notice: If a thread is stopped at
a61af66fc99e Initial load duke parents: diff changeset	543 // a safepoint, all registers are saved, not only the callee-saved ones.
a61af66fc99e Initial load duke parents: diff changeset	544 //
a61af66fc99e Initial load duke parents: diff changeset	545 // Use:
a61af66fc99e Initial load duke parents: diff changeset	546 //
a61af66fc99e Initial load duke parents: diff changeset	547 // for(StackFrameStream fst(thread); !fst.is_done(); fst.next()) {
a61af66fc99e Initial load duke parents: diff changeset	548 // ...
a61af66fc99e Initial load duke parents: diff changeset	549 // }
a61af66fc99e Initial load duke parents: diff changeset	550 //
a61af66fc99e Initial load duke parents: diff changeset	551 class StackFrameStream : public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	552 private:
a61af66fc99e Initial load duke parents: diff changeset	553 frame _fr;
a61af66fc99e Initial load duke parents: diff changeset	554 RegisterMap _reg_map;
a61af66fc99e Initial load duke parents: diff changeset	555 bool _is_done;
a61af66fc99e Initial load duke parents: diff changeset	556 public:
a61af66fc99e Initial load duke parents: diff changeset	557 StackFrameStream(JavaThread *thread, bool update = true);
a61af66fc99e Initial load duke parents: diff changeset	558
a61af66fc99e Initial load duke parents: diff changeset	559 // Iteration
a61af66fc99e Initial load duke parents: diff changeset	560 bool is_done() { return (_is_done) ? true : (_is_done = _fr.is_first_frame(), false); }
a61af66fc99e Initial load duke parents: diff changeset	561 void next() { if (!_is_done) _fr = _fr.sender(&_reg_map); }
a61af66fc99e Initial load duke parents: diff changeset	562
a61af66fc99e Initial load duke parents: diff changeset	563 // Query
a61af66fc99e Initial load duke parents: diff changeset	564 frame *current() { return &_fr; }
a61af66fc99e Initial load duke parents: diff changeset	565 RegisterMap* register_map() { return &_reg_map; }
a61af66fc99e Initial load duke parents: diff changeset	566 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	567
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1727 diff changeset	568 #endif // SHARE_VM_RUNTIME_FRAME_HPP

Mercurial > hg > truffle

annotate src/share/vm/runtime/frame.hpp @ 13212:eb03a7335eb0