Print this page
| Split |
Close |
| Expand all |
| Collapse all |
--- old/src/cpu/zero/vm/frame_zero.cpp
+++ new/src/cpu/zero/vm/frame_zero.cpp
1 1 /*
2 2 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
3 - * Copyright 2007, 2008, 2009, 2010 Red Hat, Inc.
3 + * Copyright 2007, 2008, 2009, 2010, 2011 Red Hat, Inc.
4 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 5 *
6 6 * This code is free software; you can redistribute it and/or modify it
7 7 * under the terms of the GNU General Public License version 2 only, as
8 8 * published by the Free Software Foundation.
9 9 *
10 10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 13 * version 2 for more details (a copy is included in the LICENSE file that
14 14 * accompanied this code).
15 15 *
16 16 * You should have received a copy of the GNU General Public License version
17 17 * 2 along with this work; if not, write to the Free Software Foundation,
18 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 19 *
20 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 21 * or visit www.oracle.com if you need additional information or have any
22 22 * questions.
23 23 *
24 24 */
25 25
26 26 #include "precompiled.hpp"
27 27 #include "code/scopeDesc.hpp"
28 28 #include "interpreter/interpreter.hpp"
29 29 #include "interpreter/interpreterRuntime.hpp"
30 30 #include "memory/resourceArea.hpp"
31 31 #include "oops/markOop.hpp"
32 32 #include "oops/methodOop.hpp"
33 33 #include "oops/oop.inline.hpp"
34 34 #include "runtime/frame.inline.hpp"
35 35 #include "runtime/handles.inline.hpp"
36 36 #include "runtime/javaCalls.hpp"
37 37 #include "runtime/monitorChunk.hpp"
38 38 #include "runtime/signature.hpp"
39 39 #include "runtime/stubCodeGenerator.hpp"
40 40 #include "runtime/stubRoutines.hpp"
41 41 #include "vmreg_zero.inline.hpp"
42 42 #ifdef COMPILER1
43 43 #include "c1/c1_Runtime1.hpp"
44 44 #include "runtime/vframeArray.hpp"
45 45 #endif
46 46
47 47 #ifdef ASSERT
48 48 void RegisterMap::check_location_valid() {
49 49 ShouldNotCallThis();
50 50 }
51 51 #endif
52 52
53 53 bool frame::is_interpreted_frame() const {
54 54 return zeroframe()->is_interpreter_frame();
55 55 }
56 56
57 57 bool frame::is_fake_stub_frame() const {
58 58 return zeroframe()->is_fake_stub_frame();
59 59 }
60 60
61 61 frame frame::sender_for_entry_frame(RegisterMap *map) const {
62 62 assert(zeroframe()->is_entry_frame(), "wrong type of frame");
63 63 assert(map != NULL, "map must be set");
64 64 assert(!entry_frame_is_first(), "next Java fp must be non zero");
65 65 assert(entry_frame_call_wrapper()->anchor()->last_Java_sp() == sender_sp(),
66 66 "sender should be next Java frame");
67 67 map->clear();
68 68 assert(map->include_argument_oops(), "should be set by clear");
69 69 return frame(zeroframe()->next(), sender_sp());
70 70 }
71 71
72 72 frame frame::sender_for_nonentry_frame(RegisterMap *map) const {
73 73 assert(zeroframe()->is_interpreter_frame() ||
74 74 zeroframe()->is_shark_frame() ||
75 75 zeroframe()->is_fake_stub_frame(), "wrong type of frame");
76 76 return frame(zeroframe()->next(), sender_sp());
77 77 }
78 78
79 79 frame frame::sender(RegisterMap* map) const {
80 80 // Default is not to follow arguments; the various
81 81 // sender_for_xxx methods update this accordingly.
82 82 map->set_include_argument_oops(false);
83 83
84 84 if (is_entry_frame())
85 85 return sender_for_entry_frame(map);
86 86 else
87 87 return sender_for_nonentry_frame(map);
88 88 }
89 89
90 90 #ifdef CC_INTERP
91 91 BasicObjectLock* frame::interpreter_frame_monitor_begin() const {
92 92 return get_interpreterState()->monitor_base();
93 93 }
94 94
95 95 BasicObjectLock* frame::interpreter_frame_monitor_end() const {
96 96 return (BasicObjectLock*) get_interpreterState()->stack_base();
97 97 }
98 98 #endif // CC_INTERP
99 99
100 100 void frame::patch_pc(Thread* thread, address pc) {
101 101 // We borrow this call to set the thread pointer in the interpreter
102 102 // state; the hook to set up deoptimized frames isn't supplied it.
103 103 assert(pc == NULL, "should be");
104 104 get_interpreterState()->set_thread((JavaThread *) thread);
105 105 }
106 106
107 107 bool frame::safe_for_sender(JavaThread *thread) {
108 108 ShouldNotCallThis();
109 109 }
110 110
111 111 void frame::pd_gc_epilog() {
112 112 }
113 113
114 114 bool frame::is_interpreted_frame_valid(JavaThread *thread) const {
115 115 ShouldNotCallThis();
116 116 }
117 117
118 118 BasicType frame::interpreter_frame_result(oop* oop_result,
119 119 jvalue* value_result) {
120 120 assert(is_interpreted_frame(), "interpreted frame expected");
121 121 methodOop method = interpreter_frame_method();
122 122 BasicType type = method->result_type();
123 123 intptr_t* tos_addr = (intptr_t *) interpreter_frame_tos_address();
124 124 oop obj;
125 125
126 126 switch (type) {
127 127 case T_VOID:
128 128 break;
129 129 case T_BOOLEAN:
130 130 value_result->z = *(jboolean *) tos_addr;
131 131 break;
132 132 case T_BYTE:
133 133 value_result->b = *(jbyte *) tos_addr;
134 134 break;
135 135 case T_CHAR:
136 136 value_result->c = *(jchar *) tos_addr;
137 137 break;
138 138 case T_SHORT:
139 139 value_result->s = *(jshort *) tos_addr;
140 140 break;
141 141 case T_INT:
142 142 value_result->i = *(jint *) tos_addr;
143 143 break;
144 144 case T_LONG:
145 145 value_result->j = *(jlong *) tos_addr;
146 146 break;
147 147 case T_FLOAT:
148 148 value_result->f = *(jfloat *) tos_addr;
149 149 break;
150 150 case T_DOUBLE:
151 151 value_result->d = *(jdouble *) tos_addr;
152 152 break;
153 153
154 154 case T_OBJECT:
155 155 case T_ARRAY:
156 156 if (method->is_native()) {
157 157 obj = get_interpreterState()->oop_temp();
158 158 }
159 159 else {
160 160 oop* obj_p = (oop *) tos_addr;
161 161 obj = (obj_p == NULL) ? (oop) NULL : *obj_p;
162 162 }
163 163 assert(obj == NULL || Universe::heap()->is_in(obj), "sanity check");
164 164 *oop_result = obj;
165 165 break;
166 166
167 167 default:
168 168 ShouldNotReachHere();
169 169 }
170 170
171 171 return type;
172 172 }
173 173
174 174 int frame::frame_size(RegisterMap* map) const {
175 175 #ifdef PRODUCT
176 176 ShouldNotCallThis();
177 177 #else
178 178 return 0; // make javaVFrame::print_value work
179 179 #endif // PRODUCT
180 180 }
181 181
182 182 intptr_t* frame::interpreter_frame_tos_at(jint offset) const {
183 183 int index = (Interpreter::expr_offset_in_bytes(offset) / wordSize);
184 184 return &interpreter_frame_tos_address()[index];
185 185 }
186 186
187 187 void frame::zero_print_on_error(int frame_index,
188 188 outputStream* st,
189 189 char* buf,
190 190 int buflen) const {
191 191 // Divide the buffer between the field and the value
192 192 buflen >>= 1;
193 193 char *fieldbuf = buf;
194 194 char *valuebuf = buf + buflen;
195 195
196 196 // Print each word of the frame
197 197 for (intptr_t *addr = sp(); addr <= fp(); addr++) {
198 198 int offset = fp() - addr;
199 199
200 200 // Fill in default values, then try and improve them
201 201 snprintf(fieldbuf, buflen, "word[%d]", offset);
202 202 snprintf(valuebuf, buflen, PTR_FORMAT, *addr);
203 203 zeroframe()->identify_word(frame_index, offset, fieldbuf, valuebuf, buflen);
204 204 fieldbuf[buflen - 1] = '\0';
205 205 valuebuf[buflen - 1] = '\0';
206 206
207 207 // Print the result
208 208 st->print_cr(" " PTR_FORMAT ": %-21s = %s", addr, fieldbuf, valuebuf);
209 209 }
210 210 }
211 211
212 212 void ZeroFrame::identify_word(int frame_index,
213 213 int offset,
214 214 char* fieldbuf,
215 215 char* valuebuf,
216 216 int buflen) const {
217 217 switch (offset) {
218 218 case next_frame_off:
219 219 strncpy(fieldbuf, "next_frame", buflen);
220 220 break;
221 221
222 222 case frame_type_off:
223 223 strncpy(fieldbuf, "frame_type", buflen);
224 224 if (is_entry_frame())
225 225 strncpy(valuebuf, "ENTRY_FRAME", buflen);
226 226 else if (is_interpreter_frame())
227 227 strncpy(valuebuf, "INTERPRETER_FRAME", buflen);
228 228 else if (is_shark_frame())
229 229 strncpy(valuebuf, "SHARK_FRAME", buflen);
230 230 else if (is_fake_stub_frame())
231 231 strncpy(valuebuf, "FAKE_STUB_FRAME", buflen);
232 232 break;
233 233
234 234 default:
235 235 if (is_entry_frame()) {
236 236 as_entry_frame()->identify_word(
237 237 frame_index, offset, fieldbuf, valuebuf, buflen);
238 238 }
239 239 else if (is_interpreter_frame()) {
240 240 as_interpreter_frame()->identify_word(
241 241 frame_index, offset, fieldbuf, valuebuf, buflen);
242 242 }
243 243 else if (is_shark_frame()) {
244 244 as_shark_frame()->identify_word(
245 245 frame_index, offset, fieldbuf, valuebuf, buflen);
246 246 }
247 247 else if (is_fake_stub_frame()) {
248 248 as_fake_stub_frame()->identify_word(
249 249 frame_index, offset, fieldbuf, valuebuf, buflen);
250 250 }
251 251 }
252 252 }
253 253
254 254 void EntryFrame::identify_word(int frame_index,
255 255 int offset,
256 256 char* fieldbuf,
257 257 char* valuebuf,
258 258 int buflen) const {
259 259 switch (offset) {
260 260 case call_wrapper_off:
261 261 strncpy(fieldbuf, "call_wrapper", buflen);
262 262 break;
263 263
264 264 default:
265 265 snprintf(fieldbuf, buflen, "local[%d]", offset - 3);
266 266 }
267 267 }
268 268
269 269 void InterpreterFrame::identify_word(int frame_index,
270 270 int offset,
271 271 char* fieldbuf,
272 272 char* valuebuf,
273 273 int buflen) const {
274 274 interpreterState istate = interpreter_state();
275 275 bool is_valid = istate->self_link() == istate;
276 276 intptr_t *addr = addr_of_word(offset);
277 277
278 278 // Fixed part
279 279 if (addr >= (intptr_t *) istate) {
280 280 const char *field = istate->name_of_field_at_address((address) addr);
281 281 if (field) {
282 282 if (is_valid && !strcmp(field, "_method")) {
283 283 istate->method()->name_and_sig_as_C_string(valuebuf, buflen);
284 284 }
285 285 else if (is_valid && !strcmp(field, "_bcp") && istate->bcp()) {
286 286 snprintf(valuebuf, buflen, PTR_FORMAT " (bci %d)",
287 287 (intptr_t) istate->bcp(),
288 288 istate->method()->bci_from(istate->bcp()));
289 289 }
290 290 snprintf(fieldbuf, buflen, "%sistate->%s",
291 291 field[strlen(field) - 1] == ')' ? "(": "", field);
292 292 }
293 293 else if (addr == (intptr_t *) istate) {
294 294 strncpy(fieldbuf, "(vtable for istate)", buflen);
295 295 }
296 296 return;
297 297 }
298 298
299 299 // Variable part
300 300 if (!is_valid)
301 301 return;
302 302
303 303 // JNI stuff
304 304 if (istate->method()->is_native() && addr < istate->stack_base()) {
305 305 address hA = istate->method()->signature_handler();
306 306 if (hA != NULL) {
307 307 if (hA != (address) InterpreterRuntime::slow_signature_handler) {
308 308 InterpreterRuntime::SignatureHandler *handler =
309 309 InterpreterRuntime::SignatureHandler::from_handlerAddr(hA);
310 310
311 311 intptr_t *params = istate->stack_base() - handler->argument_count();
312 312 if (addr >= params) {
313 313 int param = addr - params;
314 314 const char *desc = "";
315 315 if (param == 0)
316 316 desc = " (JNIEnv)";
317 317 else if (param == 1) {
318 318 if (istate->method()->is_static())
319 319 desc = " (mirror)";
320 320 else
321 321 desc = " (this)";
322 322 }
323 323 snprintf(fieldbuf, buflen, "parameter[%d]%s", param, desc);
324 324 return;
325 325 }
326 326
327 327 for (int i = 0; i < handler->argument_count(); i++) {
328 328 if (params[i] == (intptr_t) addr) {
329 329 snprintf(fieldbuf, buflen, "unboxed parameter[%d]", i);
330 330 return;
331 331 }
332 332 }
333 333 }
334 334 }
335 335 return;
336 336 }
337 337
338 338 // Monitors and stack
339 339 identify_vp_word(frame_index, addr,
340 340 (intptr_t *) istate->monitor_base(),
341 341 istate->stack_base(),
342 342 fieldbuf, buflen);
343 343 }
344 344
345 345 void SharkFrame::identify_word(int frame_index,
346 346 int offset,
347 347 char* fieldbuf,
348 348 char* valuebuf,
349 349 int buflen) const {
350 350 // Fixed part
351 351 switch (offset) {
352 352 case pc_off:
353 353 strncpy(fieldbuf, "pc", buflen);
354 354 if (method()->is_oop()) {
355 355 nmethod *code = method()->code();
356 356 if (code && code->pc_desc_at(pc())) {
357 357 SimpleScopeDesc ssd(code, pc());
358 358 snprintf(valuebuf, buflen, PTR_FORMAT " (bci %d)",
359 359 (intptr_t) pc(), ssd.bci());
360 360 }
361 361 }
362 362 return;
363 363
364 364 case unextended_sp_off:
365 365 strncpy(fieldbuf, "unextended_sp", buflen);
366 366 return;
367 367
368 368 case method_off:
369 369 strncpy(fieldbuf, "method", buflen);
370 370 if (method()->is_oop()) {
371 371 method()->name_and_sig_as_C_string(valuebuf, buflen);
372 372 }
373 373 return;
374 374
375 375 case oop_tmp_off:
376 376 strncpy(fieldbuf, "oop_tmp", buflen);
377 377 return;
378 378 }
379 379
380 380 // Variable part
381 381 if (method()->is_oop()) {
382 382 identify_vp_word(frame_index, addr_of_word(offset),
383 383 addr_of_word(header_words + 1),
384 384 unextended_sp() + method()->max_stack(),
385 385 fieldbuf, buflen);
386 386 }
387 387 }
388 388
389 389 void ZeroFrame::identify_vp_word(int frame_index,
390 390 intptr_t* addr,
391 391 intptr_t* monitor_base,
392 392 intptr_t* stack_base,
393 393 char* fieldbuf,
394 394 int buflen) const {
395 395 // Monitors
396 396 if (addr >= stack_base && addr < monitor_base) {
397 397 int monitor_size = frame::interpreter_frame_monitor_size();
398 398 int last_index = (monitor_base - stack_base) / monitor_size - 1;
399 399 int index = last_index - (addr - stack_base) / monitor_size;
400 400 intptr_t monitor = (intptr_t) (
401 401 (BasicObjectLock *) monitor_base - 1 - index);
402 402 intptr_t offset = (intptr_t) addr - monitor;
403 403
404 404 if (offset == BasicObjectLock::obj_offset_in_bytes())
405 405 snprintf(fieldbuf, buflen, "monitor[%d]->_obj", index);
406 406 else if (offset == BasicObjectLock::lock_offset_in_bytes())
407 407 snprintf(fieldbuf, buflen, "monitor[%d]->_lock", index);
408 408
409 409 return;
|
↓ open down ↓ |
396 lines elided |
↑ open up ↑ |
410 410 }
411 411
412 412 // Expression stack
413 413 if (addr < stack_base) {
414 414 snprintf(fieldbuf, buflen, "%s[%d]",
415 415 frame_index == 0 ? "stack_word" : "local",
416 416 (int) (stack_base - addr - 1));
417 417 return;
418 418 }
419 419 }
420 +
421 +#ifdef ASSERT
422 +
423 +void frame::describe_pd(FrameValues& values, int frame_no) {
424 +
425 +}
426 +
427 +#endif
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX