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

src/cpu/x86/vm/frame_x86.hpp@710a3c8b516e (annotated)

src/cpu/x86/vm/frame_x86.hpp

Tue, 08 Aug 2017 15:57:29 +0800

author

aoqi

date

Tue, 08 Aug 2017 15:57:29 +0800

changeset 6876

710a3c8b516e

parent 6198

55fb97c4c58d

parent 0

f90c822e73f8

child 7994

04ff2f6cd0eb

permissions

-rw-r--r--

merge

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