• file
• revisions
• annotate
• diff
• comparison
• raw

src/cpu/x86/vm/frame_x86.hpp@448691f285a5 (annotated)

src/cpu/x86/vm/frame_x86.hpp

Thu, 03 Nov 2011 04:12:49 -0700

author

twisti

date

Thu, 03 Nov 2011 04:12:49 -0700

changeset 3252

448691f285a5

parent 2895

167b70ff3abc

child 3433

eaa9557116a2

permissions

-rw-r--r--

7106944: assert(_pc == *pc_addr) failed may be too strong
Reviewed-by: kvn, never

duke@435	1	/*
iveresov@2689	2	* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
duke@435	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435	4	*
duke@435	5	* This code is free software; you can redistribute it and/or modify it
duke@435	6	* under the terms of the GNU General Public License version 2 only, as
duke@435	7	* published by the Free Software Foundation.
duke@435	8	*
duke@435	9	* This code is distributed in the hope that it will be useful, but WITHOUT
duke@435	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435	12	* version 2 for more details (a copy is included in the LICENSE file that
duke@435	13	* accompanied this code).
duke@435	14	*
duke@435	15	* You should have received a copy of the GNU General Public License version
duke@435	16	* 2 along with this work; if not, write to the Free Software Foundation,
duke@435	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435	18	*
trims@1907	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907	20	* or visit www.oracle.com if you need additional information or have any
trims@1907	21	* questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
stefank@2314	25	#ifndef CPU_X86_VM_FRAME_X86_HPP
stefank@2314	26	#define CPU_X86_VM_FRAME_X86_HPP
stefank@2314	27
stefank@2314	28	#include "runtime/synchronizer.hpp"
stefank@2314	29	#include "utilities/top.hpp"
stefank@2314	30
duke@435	31	// A frame represents a physical stack frame (an activation). Frames can be
duke@435	32	// C or Java frames, and the Java frames can be interpreted or compiled.
duke@435	33	// In contrast, vframes represent source-level activations, so that one physical frame
duke@435	34	// can correspond to multiple source level frames because of inlining.
duke@435	35	// A frame is comprised of {pc, fp, sp}
duke@435	36	// ------------------------------ Asm interpreter ----------------------------------------
duke@435	37	// Layout of asm interpreter frame:
duke@435	38	// [expression stack ] * <- sp
duke@435	39	// [monitors ] \
duke@435	40	// ... | monitor block size
duke@435	41	// [monitors ] /
duke@435	42	// [monitor block size ]
duke@435	43	// [byte code index/pointr] = bcx() bcx_offset
duke@435	44	// [pointer to locals ] = locals() locals_offset
duke@435	45	// [constant pool cache ] = cache() cache_offset
duke@435	46	// [methodData ] = mdp() mdx_offset
duke@435	47	// [methodOop ] = method() method_offset
duke@435	48	// [last sp ] = last_sp() last_sp_offset
duke@435	49	// [old stack pointer ] (sender_sp) sender_sp_offset
duke@435	50	// [old frame pointer ] <- fp = link()
duke@435	51	// [return pc ]
duke@435	52	// [oop temp ] (only for native calls)
duke@435	53	// [locals and parameters ]
duke@435	54	// <- sender sp
duke@435	55	// ------------------------------ Asm interpreter ----------------------------------------
duke@435	56
duke@435	57	// ------------------------------ C++ interpreter ----------------------------------------
duke@435	58	//
duke@435	59	// Layout of C++ interpreter frame: (While executing in BytecodeInterpreter::run)
duke@435	60	//
duke@435	61	// <- SP (current esp/rsp)
duke@435	62	// [local variables ] BytecodeInterpreter::run local variables
duke@435	63	// ... BytecodeInterpreter::run local variables
duke@435	64	// [local variables ] BytecodeInterpreter::run local variables
duke@435	65	// [old frame pointer ] fp [ BytecodeInterpreter::run's ebp/rbp ]
duke@435	66	// [return pc ] (return to frame manager)
duke@435	67	// [interpreter_state* ] (arg to BytecodeInterpreter::run) --------------
duke@435	68	// [expression stack ] <- last_Java_sp |
duke@435	69	// [... ] * <- interpreter_state.stack |
duke@435	70	// [expression stack ] * <- interpreter_state.stack_base |
duke@435	71	// [monitors ] \ |
duke@435	72	// ... | monitor block size |
duke@435	73	// [monitors ] / <- interpreter_state.monitor_base |
duke@435	74	// [struct interpretState ] <-----------------------------------------|
duke@435	75	// [return pc ] (return to callee of frame manager [1]
duke@435	76	// [locals and parameters ]
duke@435	77	// <- sender sp
duke@435	78
duke@435	79	// [1] When the c++ interpreter calls a new method it returns to the frame
duke@435	80	// manager which allocates a new frame on the stack. In that case there
duke@435	81	// is no real callee of this newly allocated frame. The frame manager is
duke@435	82	// aware of the additional frame(s) and will pop them as nested calls
duke@435	83	// complete. Howevers tTo make it look good in the debugger the frame
duke@435	84	// manager actually installs a dummy pc pointing to RecursiveInterpreterActivation
duke@435	85	// with a fake interpreter_state* parameter to make it easy to debug
duke@435	86	// nested calls.
duke@435	87
duke@435	88	// Note that contrary to the layout for the assembly interpreter the
duke@435	89	// expression stack allocated for the C++ interpreter is full sized.
duke@435	90	// However this is not as bad as it seems as the interpreter frame_manager
duke@435	91	// will truncate the unused space on succesive method calls.
duke@435	92	//
duke@435	93	// ------------------------------ C++ interpreter ----------------------------------------
duke@435	94
duke@435	95	public:
duke@435	96	enum {
duke@435	97	pc_return_offset = 0,
duke@435	98	// All frames
duke@435	99	link_offset = 0,
duke@435	100	return_addr_offset = 1,
duke@435	101	// non-interpreter frames
duke@435	102	sender_sp_offset = 2,
duke@435	103
duke@435	104	#ifndef CC_INTERP
duke@435	105
duke@435	106	// Interpreter frames
duke@435	107	interpreter_frame_result_handler_offset = 3, // for native calls only
duke@435	108	interpreter_frame_oop_temp_offset = 2, // for native calls only
duke@435	109
duke@435	110	interpreter_frame_sender_sp_offset = -1,
duke@435	111	// outgoing sp before a call to an invoked method
duke@435	112	interpreter_frame_last_sp_offset = interpreter_frame_sender_sp_offset - 1,
duke@435	113	interpreter_frame_method_offset = interpreter_frame_last_sp_offset - 1,
duke@435	114	interpreter_frame_mdx_offset = interpreter_frame_method_offset - 1,
duke@435	115	interpreter_frame_cache_offset = interpreter_frame_mdx_offset - 1,
duke@435	116	interpreter_frame_locals_offset = interpreter_frame_cache_offset - 1,
duke@435	117	interpreter_frame_bcx_offset = interpreter_frame_locals_offset - 1,
duke@435	118	interpreter_frame_initial_sp_offset = interpreter_frame_bcx_offset - 1,
duke@435	119
duke@435	120	interpreter_frame_monitor_block_top_offset = interpreter_frame_initial_sp_offset,
duke@435	121	interpreter_frame_monitor_block_bottom_offset = interpreter_frame_initial_sp_offset,
duke@435	122
duke@435	123	#endif // CC_INTERP
duke@435	124
duke@435	125	// Entry frames
duke@435	126	#ifdef AMD64
duke@435	127	#ifdef _WIN64
iveresov@2689	128	entry_frame_after_call_words = 28,
duke@435	129	entry_frame_call_wrapper_offset = 2,
duke@435	130
duke@435	131	arg_reg_save_area_bytes = 32, // Register argument save area
duke@435	132	#else
duke@435	133	entry_frame_after_call_words = 13,
duke@435	134	entry_frame_call_wrapper_offset = -6,
duke@435	135
duke@435	136	arg_reg_save_area_bytes = 0,
duke@435	137	#endif // _WIN64
duke@435	138	#else
duke@435	139	entry_frame_call_wrapper_offset = 2,
duke@435	140	#endif // AMD64
duke@435	141
duke@435	142	// Native frames
duke@435	143
duke@435	144	native_frame_initial_param_offset = 2
duke@435	145
duke@435	146	};
duke@435	147
duke@435	148	intptr_t ptr_at(int offset) const {
duke@435	149	return *ptr_at_addr(offset);
duke@435	150	}
duke@435	151
duke@435	152	void ptr_at_put(int offset, intptr_t value) {
duke@435	153	*ptr_at_addr(offset) = value;
duke@435	154	}
duke@435	155
duke@435	156	private:
duke@435	157	// an additional field beyond _sp and _pc:
duke@435	158	intptr_t* _fp; // frame pointer
duke@435	159	// The interpreter and adapters will extend the frame of the caller.
duke@435	160	// Since oopMaps are based on the sp of the caller before extension
duke@435	161	// we need to know that value. However in order to compute the address
duke@435	162	// of the return address we need the real "raw" sp. Since sparc already
duke@435	163	// uses sp() to mean "raw" sp and unextended_sp() to mean the caller's
duke@435	164	// original sp we use that convention.
duke@435	165
duke@435	166	intptr_t* _unextended_sp;
never@2895	167	void adjust_unextended_sp();
duke@435	168
duke@435	169	intptr_t* ptr_at_addr(int offset) const {
duke@435	170	return (intptr_t*) addr_at(offset);
duke@435	171	}
duke@435	172
twisti@1639	173	#if ASSERT
twisti@1639	174	// Used in frame::sender_for_{interpreter,compiled}_frame
twisti@1639	175	static void verify_deopt_original_pc( nmethod* nm, intptr_t* unextended_sp, bool is_method_handle_return = false);
twisti@1639	176	static void verify_deopt_mh_original_pc(nmethod* nm, intptr_t* unextended_sp) {
twisti@1639	177	verify_deopt_original_pc(nm, unextended_sp, true);
twisti@1639	178	}
twisti@1639	179	#endif
twisti@1639	180
duke@435	181	public:
duke@435	182	// Constructors
duke@435	183
duke@435	184	frame(intptr_t* sp, intptr_t* fp, address pc);
duke@435	185
duke@435	186	frame(intptr_t* sp, intptr_t* unextended_sp, intptr_t* fp, address pc);
duke@435	187
duke@435	188	frame(intptr_t* sp, intptr_t* fp);
duke@435	189
duke@435	190	// accessors for the instance variables
duke@435	191	intptr_t* fp() const { return _fp; }
duke@435	192
duke@435	193	inline address* sender_pc_addr() const;
duke@435	194
duke@435	195	// return address of param, zero origin index.
duke@435	196	inline address* native_param_addr(int idx) const;
duke@435	197
duke@435	198	// expression stack tos if we are nested in a java call
duke@435	199	intptr_t* interpreter_frame_last_sp() const;
duke@435	200
never@2895	201	// helper to update a map with callee-saved RBP
never@2895	202	static void update_map_with_saved_link(RegisterMap* map, intptr_t** link_addr);
never@2895	203
duke@435	204	#ifndef CC_INTERP
duke@435	205	// deoptimization support
duke@435	206	void interpreter_frame_set_last_sp(intptr_t* sp);
duke@435	207	#endif // CC_INTERP
duke@435	208
duke@435	209	#ifdef CC_INTERP
duke@435	210	inline interpreterState get_interpreterState() const;
duke@435	211	#endif // CC_INTERP
stefank@2314	212
stefank@2314	213	#endif // CPU_X86_VM_FRAME_X86_HPP