|
0
|
1 /*
|
|
|
2 * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
|
|
|
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 *
|
|
|
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
|
20 * CA 95054 USA or visit www.sun.com if you need additional information or
|
|
|
21 * have any questions.
|
|
|
22 *
|
|
|
23 */
|
|
|
24
|
|
|
25 // Inline functions for SPARC frames:
|
|
|
26
|
|
|
27 // Constructors
|
|
|
28
|
|
|
29 inline frame::frame() {
|
|
|
30 _pc = NULL;
|
|
|
31 _sp = NULL;
|
|
|
32 _younger_sp = NULL;
|
|
|
33 _cb = NULL;
|
|
|
34 _deopt_state = unknown;
|
|
|
35 _sp_adjustment_by_callee = 0;
|
|
|
36 }
|
|
|
37
|
|
|
38 // Accessors:
|
|
|
39
|
|
|
40 inline bool frame::equal(frame other) const {
|
|
|
41 bool ret = sp() == other.sp()
|
|
|
42 && fp() == other.fp()
|
|
|
43 && pc() == other.pc();
|
|
|
44 assert(!ret || ret && cb() == other.cb() && _deopt_state == other._deopt_state, "inconsistent construction");
|
|
|
45 return ret;
|
|
|
46 }
|
|
|
47
|
|
|
48 // Return unique id for this frame. The id must have a value where we can distinguish
|
|
|
49 // identity and younger/older relationship. NULL represents an invalid (incomparable)
|
|
|
50 // frame.
|
|
|
51 inline intptr_t* frame::id(void) const { return unextended_sp(); }
|
|
|
52
|
|
|
53 // Relationals on frames based
|
|
|
54 // Return true if the frame is younger (more recent activation) than the frame represented by id
|
|
|
55 inline bool frame::is_younger(intptr_t* id) const { assert(this->id() != NULL && id != NULL, "NULL frame id");
|
|
|
56 return this->id() < id ; }
|
|
|
57
|
|
|
58 // Return true if the frame is older (less recent activation) than the frame represented by id
|
|
|
59 inline bool frame::is_older(intptr_t* id) const { assert(this->id() != NULL && id != NULL, "NULL frame id");
|
|
|
60 return this->id() > id ; }
|
|
|
61
|
|
|
62 inline int frame::frame_size() const { return sender_sp() - sp(); }
|
|
|
63
|
|
|
64 inline intptr_t* frame::link() const { return (intptr_t *)(fp()[FP->sp_offset_in_saved_window()] + STACK_BIAS); }
|
|
|
65
|
|
|
66 inline void frame::set_link(intptr_t* addr) { assert(link()==addr, "frame nesting is controlled by hardware"); }
|
|
|
67
|
|
|
68 inline intptr_t* frame::unextended_sp() const { return sp() + _sp_adjustment_by_callee; }
|
|
|
69
|
|
|
70 // return address:
|
|
|
71
|
|
|
72 inline address frame::sender_pc() const { return *I7_addr() + pc_return_offset; }
|
|
|
73
|
|
|
74 inline address* frame::I7_addr() const { return (address*) &sp()[ I7->sp_offset_in_saved_window()]; }
|
|
|
75 inline address* frame::I0_addr() const { return (address*) &sp()[ I0->sp_offset_in_saved_window()]; }
|
|
|
76
|
|
|
77 inline address* frame::O7_addr() const { return (address*) &younger_sp()[ I7->sp_offset_in_saved_window()]; }
|
|
|
78 inline address* frame::O0_addr() const { return (address*) &younger_sp()[ I0->sp_offset_in_saved_window()]; }
|
|
|
79
|
|
|
80 inline intptr_t* frame::sender_sp() const { return fp(); }
|
|
|
81
|
|
|
82 // Used only in frame::oopmapreg_to_location
|
|
|
83 // This return a value in VMRegImpl::slot_size
|
|
|
84 inline int frame::pd_oop_map_offset_adjustment() const {
|
|
|
85 return _sp_adjustment_by_callee * VMRegImpl::slots_per_word;
|
|
|
86 }
|
|
|
87
|
|
|
88 #ifdef CC_INTERP
|
|
|
89 inline intptr_t** frame::interpreter_frame_locals_addr() const {
|
|
|
90 interpreterState istate = get_interpreterState();
|
|
|
91 return (intptr_t**) &istate->_locals;
|
|
|
92 }
|
|
|
93
|
|
|
94 inline intptr_t* frame::interpreter_frame_bcx_addr() const {
|
|
|
95 interpreterState istate = get_interpreterState();
|
|
|
96 return (intptr_t*) &istate->_bcp;
|
|
|
97 }
|
|
|
98
|
|
|
99 inline intptr_t* frame::interpreter_frame_mdx_addr() const {
|
|
|
100 interpreterState istate = get_interpreterState();
|
|
|
101 return (intptr_t*) &istate->_mdx;
|
|
|
102 }
|
|
|
103
|
|
|
104 inline jint frame::interpreter_frame_expression_stack_direction() { return -1; }
|
|
|
105
|
|
|
106 // bottom(base) of the expression stack (highest address)
|
|
|
107 inline intptr_t* frame::interpreter_frame_expression_stack() const {
|
|
|
108 return (intptr_t*)interpreter_frame_monitor_end() - 1;
|
|
|
109 }
|
|
|
110
|
|
|
111 // top of expression stack (lowest address)
|
|
|
112 inline intptr_t* frame::interpreter_frame_tos_address() const {
|
|
|
113 interpreterState istate = get_interpreterState();
|
|
|
114 return istate->_stack + 1; // Is this off by one? QQQ
|
|
|
115 }
|
|
|
116
|
|
|
117 // monitor elements
|
|
|
118
|
|
|
119 // in keeping with Intel side: end is lower in memory than begin;
|
|
|
120 // and beginning element is oldest element
|
|
|
121 // Also begin is one past last monitor.
|
|
|
122
|
|
|
123 inline BasicObjectLock* frame::interpreter_frame_monitor_begin() const {
|
|
|
124 return get_interpreterState()->monitor_base();
|
|
|
125 }
|
|
|
126
|
|
|
127 inline BasicObjectLock* frame::interpreter_frame_monitor_end() const {
|
|
|
128 return (BasicObjectLock*) get_interpreterState()->stack_base();
|
|
|
129 }
|
|
|
130
|
|
|
131
|
|
|
132 inline int frame::interpreter_frame_monitor_size() {
|
|
|
133 return round_to(BasicObjectLock::size(), WordsPerLong);
|
|
|
134 }
|
|
|
135
|
|
|
136 inline methodOop* frame::interpreter_frame_method_addr() const {
|
|
|
137 interpreterState istate = get_interpreterState();
|
|
|
138 return &istate->_method;
|
|
|
139 }
|
|
|
140
|
|
|
141
|
|
|
142 // Constant pool cache
|
|
|
143
|
|
|
144 // where LcpoolCache is saved:
|
|
|
145 inline constantPoolCacheOop* frame::interpreter_frame_cpoolcache_addr() const {
|
|
|
146 interpreterState istate = get_interpreterState();
|
|
|
147 return &istate->_constants; // should really use accessor
|
|
|
148 }
|
|
|
149
|
|
|
150 inline constantPoolCacheOop* frame::interpreter_frame_cache_addr() const {
|
|
|
151 interpreterState istate = get_interpreterState();
|
|
|
152 return &istate->_constants;
|
|
|
153 }
|
|
|
154
|
|
|
155 #else // !CC_INTERP
|
|
|
156
|
|
|
157 inline intptr_t** frame::interpreter_frame_locals_addr() const {
|
|
|
158 return (intptr_t**) sp_addr_at( Llocals->sp_offset_in_saved_window());
|
|
|
159 }
|
|
|
160
|
|
|
161 inline intptr_t* frame::interpreter_frame_bcx_addr() const {
|
|
|
162 // %%%%% reinterpreting Lbcp as a bcx
|
|
|
163 return (intptr_t*) sp_addr_at( Lbcp->sp_offset_in_saved_window());
|
|
|
164 }
|
|
|
165
|
|
|
166 inline intptr_t* frame::interpreter_frame_mdx_addr() const {
|
|
|
167 // %%%%% reinterpreting ImethodDataPtr as a mdx
|
|
|
168 return (intptr_t*) sp_addr_at( ImethodDataPtr->sp_offset_in_saved_window());
|
|
|
169 }
|
|
|
170
|
|
|
171 inline jint frame::interpreter_frame_expression_stack_direction() { return -1; }
|
|
|
172
|
|
|
173 // bottom(base) of the expression stack (highest address)
|
|
|
174 inline intptr_t* frame::interpreter_frame_expression_stack() const {
|
|
|
175 return (intptr_t*)interpreter_frame_monitors() - 1;
|
|
|
176 }
|
|
|
177
|
|
|
178 // top of expression stack (lowest address)
|
|
|
179 inline intptr_t* frame::interpreter_frame_tos_address() const {
|
|
|
180 return *interpreter_frame_esp_addr() + 1;
|
|
|
181 }
|
|
|
182
|
|
|
183 inline void frame::interpreter_frame_set_tos_address( intptr_t* x ) {
|
|
|
184 *interpreter_frame_esp_addr() = x - 1;
|
|
|
185 }
|
|
|
186
|
|
|
187 // monitor elements
|
|
|
188
|
|
|
189 // in keeping with Intel side: end is lower in memory than begin;
|
|
|
190 // and beginning element is oldest element
|
|
|
191 // Also begin is one past last monitor.
|
|
|
192
|
|
|
193 inline BasicObjectLock* frame::interpreter_frame_monitor_begin() const {
|
|
|
194 int rounded_vm_local_words = round_to(frame::interpreter_frame_vm_local_words, WordsPerLong);
|
|
|
195 return (BasicObjectLock *)fp_addr_at(-rounded_vm_local_words);
|
|
|
196 }
|
|
|
197
|
|
|
198 inline BasicObjectLock* frame::interpreter_frame_monitor_end() const {
|
|
|
199 return interpreter_frame_monitors();
|
|
|
200 }
|
|
|
201
|
|
|
202
|
|
|
203 inline void frame::interpreter_frame_set_monitor_end(BasicObjectLock* value) {
|
|
|
204 interpreter_frame_set_monitors(value);
|
|
|
205 }
|
|
|
206
|
|
|
207 inline int frame::interpreter_frame_monitor_size() {
|
|
|
208 return round_to(BasicObjectLock::size(), WordsPerLong);
|
|
|
209 }
|
|
|
210
|
|
|
211 inline methodOop* frame::interpreter_frame_method_addr() const {
|
|
|
212 return (methodOop*)sp_addr_at( Lmethod->sp_offset_in_saved_window());
|
|
|
213 }
|
|
|
214
|
|
|
215
|
|
|
216 // Constant pool cache
|
|
|
217
|
|
|
218 // where LcpoolCache is saved:
|
|
|
219 inline constantPoolCacheOop* frame::interpreter_frame_cpoolcache_addr() const {
|
|
|
220 return (constantPoolCacheOop*)sp_addr_at(LcpoolCache->sp_offset_in_saved_window());
|
|
|
221 }
|
|
|
222
|
|
|
223 inline constantPoolCacheOop* frame::interpreter_frame_cache_addr() const {
|
|
|
224 return (constantPoolCacheOop*)sp_addr_at( LcpoolCache->sp_offset_in_saved_window());
|
|
|
225 }
|
|
|
226 #endif // CC_INTERP
|
|
|
227
|
|
|
228
|
|
|
229 inline JavaCallWrapper* frame::entry_frame_call_wrapper() const {
|
|
|
230 // note: adjust this code if the link argument in StubGenerator::call_stub() changes!
|
|
|
231 const Argument link = Argument(0, false);
|
|
|
232 return (JavaCallWrapper*)sp()[link.as_in().as_register()->sp_offset_in_saved_window()];
|
|
|
233 }
|
|
|
234
|
|
|
235
|
|
|
236 inline int frame::local_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors) {
|
|
|
237 // always allocate non-argument locals 0..5 as if they were arguments:
|
|
|
238 int allocated_above_frame = nof_args;
|
|
|
239 if (allocated_above_frame < callee_register_argument_save_area_words)
|
|
|
240 allocated_above_frame = callee_register_argument_save_area_words;
|
|
|
241 if (allocated_above_frame > max_nof_locals)
|
|
|
242 allocated_above_frame = max_nof_locals;
|
|
|
243
|
|
|
244 // Note: monitors (BasicLock blocks) are never allocated in argument slots
|
|
|
245 //assert(local_index >= 0 && local_index < max_nof_locals, "bad local index");
|
|
|
246 if (local_index < allocated_above_frame)
|
|
|
247 return local_index + callee_register_argument_save_area_sp_offset;
|
|
|
248 else
|
|
|
249 return local_index - (max_nof_locals + max_nof_monitors*2) + compiler_frame_vm_locals_fp_offset;
|
|
|
250 }
|
|
|
251
|
|
|
252 inline int frame::monitor_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors) {
|
|
|
253 assert(local_index >= max_nof_locals && ((local_index - max_nof_locals) & 1) && (local_index - max_nof_locals) < max_nof_monitors*2, "bad monitor index");
|
|
|
254
|
|
|
255 // The compiler uses the __higher__ of two indexes allocated to the monitor.
|
|
|
256 // Increasing local indexes are mapped to increasing memory locations,
|
|
|
257 // so the start of the BasicLock is associated with the __lower__ index.
|
|
|
258
|
|
|
259 int offset = (local_index-1) - (max_nof_locals + max_nof_monitors*2) + compiler_frame_vm_locals_fp_offset;
|
|
|
260
|
|
|
261 // We allocate monitors aligned zero mod 8:
|
|
|
262 assert((offset & 1) == 0, "monitor must be an an even address.");
|
|
|
263 // This works because all monitors are allocated after
|
|
|
264 // all locals, and because the highest address corresponding to any
|
|
|
265 // monitor index is always even.
|
|
|
266 assert((compiler_frame_vm_locals_fp_offset & 1) == 0, "end of monitors must be even address");
|
|
|
267
|
|
|
268 return offset;
|
|
|
269 }
|
|
|
270
|
|
|
271 inline int frame::min_local_offset_for_compiler(int nof_args, int max_nof_locals, int max_nof_monitors) {
|
|
|
272 // always allocate non-argument locals 0..5 as if they were arguments:
|
|
|
273 int allocated_above_frame = nof_args;
|
|
|
274 if (allocated_above_frame < callee_register_argument_save_area_words)
|
|
|
275 allocated_above_frame = callee_register_argument_save_area_words;
|
|
|
276 if (allocated_above_frame > max_nof_locals)
|
|
|
277 allocated_above_frame = max_nof_locals;
|
|
|
278
|
|
|
279 int allocated_in_frame = (max_nof_locals + max_nof_monitors*2) - allocated_above_frame;
|
|
|
280
|
|
|
281 return compiler_frame_vm_locals_fp_offset - allocated_in_frame;
|
|
|
282 }
|
|
|
283
|
|
|
284 // On SPARC, the %lN and %iN registers are non-volatile.
|
|
|
285 inline bool frame::volatile_across_calls(Register reg) {
|
|
|
286 // This predicate is (presently) applied only to temporary registers,
|
|
|
287 // and so it need not recognize non-volatile globals.
|
|
|
288 return reg->is_out() || reg->is_global();
|
|
|
289 }
|
|
|
290
|
|
|
291 inline oop frame::saved_oop_result(RegisterMap* map) const {
|
|
|
292 return *((oop*) map->location(O0->as_VMReg()));
|
|
|
293 }
|
|
|
294
|
|
|
295 inline void frame::set_saved_oop_result(RegisterMap* map, oop obj) {
|
|
|
296 *((oop*) map->location(O0->as_VMReg())) = obj;
|
|
|
297 }
|
