Tue, 16 May 2017 11:53:48 -0400
#5401 Fix compiler/7116216/StackOverflow.java for MIPS.
1 /*
2 * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2015, 2016, Loongson Technology. All rights reserved.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
26 #include "precompiled.hpp"
27 #include "asm/macroAssembler.hpp"
28 #include "interpreter/bytecodeHistogram.hpp"
29 #include "interpreter/interpreter.hpp"
30 #include "interpreter/interpreterGenerator.hpp"
31 #include "interpreter/interpreterRuntime.hpp"
32 #include "interpreter/templateTable.hpp"
33 #include "oops/arrayOop.hpp"
34 #include "oops/methodData.hpp"
35 #include "oops/method.hpp"
36 #include "oops/oop.inline.hpp"
37 #include "prims/jvmtiExport.hpp"
38 #include "prims/jvmtiThreadState.hpp"
39 #include "runtime/arguments.hpp"
40 #include "runtime/deoptimization.hpp"
41 #include "runtime/frame.inline.hpp"
42 #include "runtime/sharedRuntime.hpp"
43 #include "runtime/stubRoutines.hpp"
44 #include "runtime/synchronizer.hpp"
45 #include "runtime/timer.hpp"
46 #include "runtime/vframeArray.hpp"
47 #include "utilities/debug.hpp"
49 #define __ _masm->
51 #ifndef CC_INTERP
53 // asm based interpreter deoptimization helpers
54 int AbstractInterpreter::size_activation(int max_stack,
55 int temps,
56 int extra_args,
57 int monitors,
58 int callee_params,
59 int callee_locals,
60 bool is_top_frame) {
61 // Note: This calculation must exactly parallel the frame setup
62 // in AbstractInterpreterGenerator::generate_method_entry.
64 // fixed size of an interpreter frame:
65 int overhead = frame::sender_sp_offset -
66 frame::interpreter_frame_initial_sp_offset;
67 // Our locals were accounted for by the caller (or last_frame_adjust
68 // on the transistion) Since the callee parameters already account
69 // for the callee's params we only need to account for the extra
70 // locals.
71 int size = overhead +
72 (callee_locals - callee_params)*Interpreter::stackElementWords +
73 monitors * frame::interpreter_frame_monitor_size() +
74 temps* Interpreter::stackElementWords + extra_args;
76 return size;
77 }
80 const int Interpreter::return_sentinel = 0xfeedbeed;
81 const int method_offset = frame::interpreter_frame_method_offset * wordSize;
82 const int bci_offset = frame::interpreter_frame_bcx_offset * wordSize;
83 const int locals_offset = frame::interpreter_frame_locals_offset * wordSize;
85 //-----------------------------------------------------------------------------
87 address TemplateInterpreterGenerator::generate_StackOverflowError_handler() {
88 address entry = __ pc();
90 #ifdef ASSERT
91 {
92 Label L;
93 __ addi(T1, FP, frame::interpreter_frame_monitor_block_top_offset * wordSize);
94 __ sub(T1, T1, SP); // T1 = maximal sp for current fp
95 __ bgez(T1, L); // check if frame is complete
96 __ delayed()->nop();
97 __ stop("interpreter frame not set up");
98 __ bind(L);
99 }
100 #endif // ASSERT
101 // Restore bcp under the assumption that the current frame is still
102 // interpreted
103 // FIXME: please change the func restore_bcp
104 // S0 is the conventional register for bcp
105 __ restore_bcp();
107 // expression stack must be empty before entering the VM if an
108 // exception happened
109 __ empty_expression_stack();
110 // throw exception
111 //__ call_VM(noreg,
112 // CAST_FROM_FN_PTR(address,
113 // InterpreterRuntime::throw_StackOverflowError));
114 // FIXME: why do not pass parameter thread ?
115 __ call_VM(NOREG, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_StackOverflowError));
116 return entry;
117 }
119 address TemplateInterpreterGenerator::generate_ArrayIndexOutOfBounds_handler(
120 const char* name) {
121 address entry = __ pc();
122 // expression stack must be empty before entering the VM if an
123 // exception happened
124 __ empty_expression_stack();
125 __ li(A1, (long)name);
126 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
127 InterpreterRuntime::throw_ArrayIndexOutOfBoundsException), A1, A2);
128 return entry;
129 }
131 address TemplateInterpreterGenerator::generate_ClassCastException_handler() {
132 address entry = __ pc();
134 // object is at TOS
135 //FIXME, I am not sure if the object is at TOS as x86 do now @jerome, 04/20,2007
136 //__ pop(c_rarg1);
138 // expression stack must be empty before entering the VM if an
139 // exception happened
140 __ empty_expression_stack();
141 __ empty_FPU_stack();
142 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_ClassCastException), FSR);
143 return entry;
144 }
146 address TemplateInterpreterGenerator::generate_exception_handler_common(
147 const char* name, const char* message, bool pass_oop) {
148 assert(!pass_oop || message == NULL, "either oop or message but not both");
149 address entry = __ pc();
151 // expression stack must be empty before entering the VM if an exception happened
152 __ empty_expression_stack();
153 // setup parameters
154 __ li(A1, (long)name);
155 if (pass_oop) {
156 __ call_VM(V0,
157 CAST_FROM_FN_PTR(address, InterpreterRuntime::create_klass_exception), A1, FSR);
158 } else {
159 __ li(A2, (long)message);
160 __ call_VM(V0,
161 CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception), A1, A2);
162 }
163 // throw exception
164 __ jmp(Interpreter::throw_exception_entry(), relocInfo::none);
165 __ delayed()->nop();
166 return entry;
167 }
170 address TemplateInterpreterGenerator::generate_continuation_for(TosState state) {
171 address entry = __ pc();
172 // NULL last_sp until next java call
173 __ sd(R0,Address(FP, frame::interpreter_frame_last_sp_offset * wordSize));
174 __ dispatch_next(state);
175 return entry;
176 }
179 address TemplateInterpreterGenerator::generate_return_entry_for(TosState state, int step, size_t index_size) {
181 address entry = __ pc();
183 // Restore stack bottom in case i2c adjusted stack
184 // __ movptr(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));
185 __ ld(SP, Address(FP, frame::interpreter_frame_last_sp_offset * wordSize));
186 // and NULL it as marker that esp is now tos until next java call
187 // __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
188 __ sd(R0, FP, frame::interpreter_frame_last_sp_offset * wordSize);
190 __ restore_bcp();
191 __ restore_locals();
193 // 2014/11/24 Fu
194 // mdp: T8
195 // ret: FSR
196 // tmp: T9
197 if (state == atos) {
198 Register mdp = T8;
199 Register tmp = T9;
200 __ profile_return_type(mdp, FSR, tmp);
201 }
204 const Register cache = T9;
205 const Register index = T3;
206 __ get_cache_and_index_at_bcp(cache, index, 1, index_size);
208 const Register flags = cache;
209 // __ movl(flags, Address(cache, index, Address::times_ptr, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset()));
210 __ dsll(AT, index, Address::times_ptr);
211 __ daddu(AT, cache, AT);
212 __ lw(flags, AT, in_bytes(ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset()));
213 // __ andl(flags, ConstantPoolCacheEntry::parameter_size_mask);
214 __ andi(flags, flags, ConstantPoolCacheEntry::parameter_size_mask);
215 // __ lea(rsp, Address(rsp, flags, Interpreter::stackElementScale()));
216 __ dsll(AT, flags, Interpreter::stackElementScale());
217 __ daddu(SP, SP, AT);
219 __ dispatch_next(state, step);
221 return entry;
222 }
225 address TemplateInterpreterGenerator::generate_deopt_entry_for(TosState state,
226 int step) {
227 address entry = __ pc();
228 // NULL last_sp until next java call
229 //__ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
230 __ sd(R0, FP, frame::interpreter_frame_last_sp_offset * wordSize);
231 __ restore_bcp();
232 __ restore_locals();
233 // handle exceptions
234 {
235 Label L;
236 const Register thread = TREG;
237 #ifndef OPT_THREAD
238 __ get_thread(thread);
239 #endif
240 __ lw(AT, thread, in_bytes(Thread::pending_exception_offset()));
241 __ beq(AT, R0, L);
242 __ delayed()->nop();
243 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_pending_exception));
244 __ should_not_reach_here();
245 __ bind(L);
246 }
247 __ dispatch_next(state, step);
248 return entry;
249 }
251 int AbstractInterpreter::BasicType_as_index(BasicType type) {
252 int i = 0;
253 /*
254 switch (type) {
255 case T_BOOLEAN: i = 0; break;
256 case T_CHAR : i = 1; break;
257 case T_BYTE : i = 2; break;
258 case T_SHORT : i = 3; break;
259 case T_INT : i = 4; break;
260 case T_LONG : i = 5; break;
261 case T_VOID : i = 6; break;
262 case T_FLOAT : i = 7; break;
263 case T_DOUBLE : i = 8; break;
264 case T_OBJECT : i = 9; break;
265 case T_ARRAY : i = 9; break;
266 default : ShouldNotReachHere();
267 }
268 */
269 switch (type) {
270 case T_BOOLEAN: i = 0; break;
271 case T_CHAR : i = 1; break;
272 case T_BYTE : i = 2; break;
273 case T_SHORT : i = 3; break;
274 case T_INT : // fall through
275 case T_LONG : // fall through
276 case T_VOID : i = 4; break;
277 case T_FLOAT : i = 5; break;
278 case T_DOUBLE : i = 6; break;
279 case T_OBJECT : // fall through
280 case T_ARRAY : i = 7; break;
281 default : ShouldNotReachHere();
282 }
283 assert(0 <= i && i < AbstractInterpreter::number_of_result_handlers,
284 "index out of bounds");
285 return i;
286 }
289 // why do not consider float and double , @jerome, 12/27,06, @jerome
290 //FIXME, aoqi
291 address TemplateInterpreterGenerator::generate_result_handler_for(
292 BasicType type) {
293 address entry = __ pc();
294 switch (type) {
295 case T_BOOLEAN: __ c2bool(V0); break;
296 case T_CHAR : __ andi(V0, V0, 0xFFFF); break;
297 case T_BYTE : __ sign_extend_byte (V0); break;
298 case T_SHORT : __ sign_extend_short(V0); break;
299 case T_INT : /* nothing to do */ break;
300 case T_FLOAT : /* nothing to do */ break;
301 case T_DOUBLE : /* nothing to do */ break;
302 case T_OBJECT :
303 {
304 // __ beq(V0, R0, L); // test if NULL handle
305 // __ delayed()->nop(); // if not then
306 // __ lw(V0, V0, 0); // unbox result
307 __ ld(V0, FP, frame::interpreter_frame_oop_temp_offset * wordSize);
308 __ verify_oop(V0); // and verify it
309 }
310 break;
311 default : ShouldNotReachHere();
312 }
313 __ jr(RA); // return from result handler
314 __ delayed()->nop();
315 return entry;
316 }
318 address TemplateInterpreterGenerator::generate_safept_entry_for(
319 TosState state,
320 address runtime_entry) {
321 address entry = __ pc();
322 __ push(state);
323 __ call_VM(noreg, runtime_entry);
324 __ dispatch_via(vtos, Interpreter::_normal_table.table_for(vtos));
325 return entry;
326 }
330 // Helpers for commoning out cases in the various type of method entries.
331 //
334 // increment invocation count & check for overflow
335 //
336 // Note: checking for negative value instead of overflow
337 // so we have a 'sticky' overflow test
338 //
339 // prerequisites : method in T0, invocation counter in T3
340 void InterpreterGenerator::generate_counter_incr(
341 Label* overflow,
342 Label* profile_method,
343 Label* profile_method_continue) {
344 Label done;
345 const Address invocation_counter(FSR, in_bytes(MethodCounters::invocation_counter_offset()) //Fu:20130814 Wang:Rmethod --> FSR
346 + in_bytes(InvocationCounter::counter_offset()));
347 const Address backedge_counter (FSR, in_bytes(MethodCounters::backedge_counter_offset())
348 + in_bytes(InvocationCounter::counter_offset()));
350 __ get_method_counters(Rmethod, FSR, done);
352 if (ProfileInterpreter) { // %%% Merge this into methodDataOop
353 __ lw(T9, FSR, in_bytes(MethodCounters::interpreter_invocation_counter_offset()));
354 __ incrementl(T9, 1);
355 __ sw(T9, FSR, in_bytes(MethodCounters::interpreter_invocation_counter_offset()));
356 }
357 // Update standard invocation counters
358 __ lw(T3, invocation_counter);
359 __ increment(T3, InvocationCounter::count_increment);
360 __ sw(T3, invocation_counter); // save invocation count
362 __ lw(FSR, backedge_counter); // load backedge counter
363 __ li(AT, InvocationCounter::count_mask_value); // mask out the status bits
364 __ andr(FSR, FSR, AT);
366 __ dadd(T3, T3, FSR); // add both counters
368 // profile_method is non-null only for interpreted method so
369 // profile_method != NULL == !native_call
371 if (ProfileInterpreter && profile_method != NULL) {
372 // Test to see if we should create a method data oop
373 /*
374 __ lui(AT, Assembler::split_high(
375 int(&InvocationCounter::InterpreterProfileLimit)));
376 __ ld(AT, AT, Assembler::split_low(
377 int(&InvocationCounter::InterpreterProfileLimit)));
378 */
379 __ li(AT, (long)&InvocationCounter::InterpreterProfileLimit);
380 __ lw(AT, AT, 0);
381 __ slt(AT, T3, AT);
382 __ bne_far(AT, R0, *profile_method_continue);
383 __ delayed()->nop();
385 // if no method data exists, go to profile_method
386 __ test_method_data_pointer(FSR, *profile_method);
387 }
389 //__ lui(AT, Assembler::split_high(intptr_t(&InvocationCounter::InterpreterInvocationLimit)));
390 //__ ld(AT, AT, Assembler::split_low(intptr_t(&InvocationCounter::InterpreterInvocationLimit)));
391 __ li(AT, (long)&InvocationCounter::InterpreterInvocationLimit);
392 __ lw(AT, AT, 0);
393 __ slt(AT, T3, AT);
394 __ beq_far(AT, R0, *overflow);
395 __ delayed()->nop();
396 __ bind(done);
397 }
399 void InterpreterGenerator::generate_counter_overflow(Label* do_continue) {
401 // Asm interpreter on entry
402 // S7 - locals
403 // S0 - bcp
404 // Rmethod - method
405 // FP - interpreter frame
407 // On return (i.e. jump to entry_point)
408 // Rmethod - method
409 // RA - return address of interpreter caller
410 // tos - the last parameter to Java method
411 // SP - sender_sp
413 //const Address size_of_parameters(Rmethod,in_bytes( Method::size_of_parameters_offset()));
415 // the bcp is valid if and only if it's not null
416 __ call_VM(NOREG, CAST_FROM_FN_PTR(address,
417 InterpreterRuntime::frequency_counter_overflow), R0);
418 __ ld(Rmethod, FP, method_offset);
419 /*
420 // method has been compiled - remove activation frame
421 // (leave return address on stack) and continue at
422 // verified entry point (eax). (eax in some past life maybe, seems to use methodoop these days)
423 //
424 // Note: continuation at verified entry point works if the method that has been
425 // compiled is the right one (in case of virtual calls); i.e., the inline
426 // cache check must have happened before the invocation counter overflow
427 // check.
428 __ lhu(V0, size_of_parameters);
429 __ move(SP, FP);
430 __ lw(FP, SP, frame::interpreter_frame_sender_fp_offset * wordSize);
431 __ lw(RA, SP, frame::interpreter_frame_return_addr_offset * wordSize);
432 __ sll(V0, V0, 2);
433 __ addi(V0, V0, - 1 * wordSize);
434 __ sub(SP, LVP, V0);
435 // __ lw(T0, LVP, 0);
436 */
437 // Preserve invariant that esi/edi contain bcp/locals of sender frame
438 __ b_far(*do_continue);
439 __ delayed()->nop();
440 }
442 // See if we've got enough room on the stack for locals plus overhead.
443 // The expression stack grows down incrementally, so the normal guard
444 // page mechanism will work for that.
445 //
446 // NOTE: Since the additional locals are also always pushed (wasn't
447 // obvious in generate_method_entry) so the guard should work for them
448 // too.
449 //
450 // Args:
451 // rdx: number of additional locals this frame needs (what we must check)
452 // rbx: Method*
453 //
454 // Kills:
455 // rax
456 void InterpreterGenerator::generate_stack_overflow_check(void) {
457 // see if we've got enough room on the stack for locals plus overhead.
458 // the expression stack grows down incrementally, so the normal guard
459 // page mechanism will work for that.
460 //
461 // Registers live on entry:
462 //
463 // T0: Method*
464 // T2: number of additional locals this frame needs (what we must check)
466 // NOTE: since the additional locals are also always pushed (wasn't obvious in
467 // generate_method_entry) so the guard should work for them too.
468 //
470 // monitor entry size: see picture of stack set (generate_method_entry) and frame_i486.hpp
471 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
473 // total overhead size: entry_size + (saved ebp thru expr stack bottom).
474 // be sure to change this if you add/subtract anything to/from the overhead area
475 const int overhead_size = -(frame::interpreter_frame_initial_sp_offset*wordSize)
476 + entry_size;
478 const int page_size = os::vm_page_size();
480 Label after_frame_check;
482 // see if the frame is greater than one page in size. If so,
483 // then we need to verify there is enough stack space remaining
484 // for the additional locals.
485 __ move(AT, (page_size - overhead_size) / Interpreter::stackElementSize);
486 __ slt(AT, AT, T2);
487 __ beq(AT, R0, after_frame_check);
488 __ delayed()->nop();
490 // compute sp as if this were going to be the last frame on
491 // the stack before the red zone
492 #ifndef OPT_THREAD
493 Register thread = T1;
494 __ get_thread(thread);
495 #else
496 Register thread = TREG;
497 #endif
499 // locals + overhead, in bytes
500 //FIXME aoqi
501 __ dsll(T3, T2, Interpreter::stackElementScale());
502 //__ dsll(T9, T9, Address::times_8);
503 __ daddiu(T3, T3, overhead_size); // locals * 4 + overhead_size --> T3
505 #ifdef ASSERT
506 Label stack_base_okay, stack_size_okay;
507 // verify that thread stack base is non-zero
508 __ ld(AT, thread, in_bytes(Thread::stack_base_offset()));
509 __ bne(AT, R0, stack_base_okay);
510 __ delayed()->nop();
511 __ stop("stack base is zero");
512 __ bind(stack_base_okay);
513 // verify that thread stack size is non-zero
514 __ ld(AT, thread, in_bytes(Thread::stack_size_offset()));
515 __ bne(AT, R0, stack_size_okay);
516 __ delayed()->nop();
517 __ stop("stack size is zero");
518 __ bind(stack_size_okay);
519 #endif
521 // Add stack base to locals and subtract stack size
522 __ ld(AT, thread, in_bytes(Thread::stack_base_offset())); // stack_base --> AT
523 __ dadd(T3, T3, AT); // locals * 4 + overhead_size + stack_base--> T3
524 __ ld(AT, thread, in_bytes(Thread::stack_size_offset())); // stack_size --> AT
525 __ dsub(T3, T3, AT); // locals * 4 + overhead_size + stack_base - stack_size --> T3
528 // add in the redzone and yellow size
529 __ move(AT, (StackRedPages+StackYellowPages) * page_size);
530 __ add(T3, T3, AT);
532 // check against the current stack bottom
533 __ slt(AT, T3, SP);
534 __ bne(AT, R0, after_frame_check);
535 __ delayed()->nop();
537 // Note: the restored frame is not necessarily interpreted.
538 // Use the shared runtime version of the StackOverflowError.
539 __ move(SP, Rsender);
540 assert(StubRoutines::throw_StackOverflowError_entry() != NULL, "stub not yet generated");
541 __ jmp(StubRoutines::throw_StackOverflowError_entry(), relocInfo::runtime_call_type);
542 __ delayed()->nop();
544 // all done with frame size check
545 __ bind(after_frame_check);
546 }
548 // Allocate monitor and lock method (asm interpreter)
549 // Rmethod - Method*
550 void InterpreterGenerator::lock_method(void) {
551 // synchronize method
552 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
554 #ifdef ASSERT
555 { Label L;
556 __ lw(T0, Rmethod, in_bytes(Method::access_flags_offset()));
557 __ andi(T0, T0, JVM_ACC_SYNCHRONIZED);
558 __ bne(T0, R0, L);
559 __ delayed()->nop();
560 __ stop("method doesn't need synchronization");
561 __ bind(L);
562 }
563 #endif // ASSERT
564 // get synchronization object
565 { Label done;
566 const int mirror_offset = in_bytes(Klass::java_mirror_offset());
567 __ lw(T0, Rmethod, in_bytes(Method::access_flags_offset()));
568 __ andi(T2, T0, JVM_ACC_STATIC);
569 __ ld(T0, LVP, Interpreter::local_offset_in_bytes(0));
570 __ beq(T2, R0, done);
571 __ delayed()->nop();
572 __ ld(T0, Rmethod, in_bytes(Method::const_offset()));
573 __ ld(T0, T0, in_bytes(ConstMethod::constants_offset()));
574 __ ld(T0, T0, ConstantPool::pool_holder_offset_in_bytes());
575 __ ld(T0, T0, mirror_offset);
576 __ bind(done);
577 }
578 // add space for monitor & lock
579 __ daddi(SP, SP, (-1) * entry_size); // add space for a monitor entry
580 __ sd(SP, FP, frame::interpreter_frame_monitor_block_top_offset * wordSize);
581 // set new monitor block top
582 __ sd(T0, SP, BasicObjectLock::obj_offset_in_bytes()); // store object
583 // FIXME: I do not know what lock_object will do and what it will need
584 __ move(c_rarg0, SP); // object address
585 __ lock_object(c_rarg0);
586 }
588 // Generate a fixed interpreter frame. This is identical setup for
589 // interpreted methods and for native methods hence the shared code.
590 void TemplateInterpreterGenerator::generate_fixed_frame(bool native_call) {
592 // [ local var m-1 ] <--- sp
593 // ...
594 // [ local var 0 ]
595 // [ argumnet word n-1 ] <--- T0(sender's sp)
596 // ...
597 // [ argument word 0 ] <--- S7
599 // initialize fixed part of activation frame
600 // sender's sp in Rsender
601 int i = 0;
602 __ sd(RA, SP, (-1) * wordSize); // save return address
603 __ sd(FP, SP, (-2) * wordSize); // save sender's fp
604 __ daddiu(FP, SP, (-2) * wordSize);
605 __ sd(Rsender, FP, (-++i) * wordSize); // save sender's sp
606 __ sd(R0, FP,(-++i)*wordSize); //save last_sp as null, FIXME aoqi
607 __ sd(LVP, FP, (-++i) * wordSize); // save locals offset
608 __ ld(BCP, Rmethod, in_bytes(Method::const_offset())); // get constMethodOop
609 __ daddiu(BCP, BCP, in_bytes(ConstMethod::codes_offset())); // get codebase
610 __ sd(Rmethod, FP, (-++i) * wordSize); // save Method*
611 #ifndef CORE
612 if (ProfileInterpreter) {
613 Label method_data_continue;
614 __ ld(AT, Rmethod, in_bytes(Method::method_data_offset()));
615 __ beq(AT, R0, method_data_continue);
616 __ delayed()->nop();
617 __ daddi(AT, AT, in_bytes(MethodData::data_offset()));
618 __ bind(method_data_continue);
619 __ sd(AT, FP, (-++i) * wordSize);
620 } else {
621 __ sd(R0, FP, (-++i) * wordSize);
622 }
623 #endif // !CORE
625 __ ld(T2, Rmethod, in_bytes(Method::const_offset()));
626 __ ld(T2, T2, in_bytes(ConstMethod::constants_offset()));
627 __ ld(T2, T2, ConstantPool::cache_offset_in_bytes());
628 __ sd(T2, FP, (-++i) * wordSize); // set constant pool cache
629 if (native_call) {
630 __ sd(R0, FP, (-++i) * wordSize); // no bcp
631 } else {
632 __ sd(BCP, FP, (-++i) * wordSize); // set bcp
633 }
634 __ daddiu(SP, FP, (-++i) * wordSize);
635 __ sd(SP, FP, (-i) * wordSize); // reserve word for pointer to expression stack bottom
636 }
638 // End of helpers
640 // Various method entries
641 //------------------------------------------------------------------------------------------------------------------------
642 //
643 //
645 // Call an accessor method (assuming it is resolved, otherwise drop
646 // into vanilla (slow path) entry
647 address InterpreterGenerator::generate_accessor_entry(void) {
649 // Rmethod: Method*
650 // V0: receiver (preserve for slow entry into asm interpreter)
651 // Rsender: senderSP must preserved for slow path, set SP to it on fast path
653 address entry_point = __ pc();
654 Label xreturn_path;
655 // do fastpath for resolved accessor methods
656 if (UseFastAccessorMethods) {
657 Label slow_path;
658 __ li(T2, SafepointSynchronize::address_of_state());
659 __ lw(AT, T2, 0);
660 __ daddi(AT, AT, -(SafepointSynchronize::_not_synchronized));
661 __ bne(AT, R0, slow_path);
662 __ delayed()->nop();
663 // Code: _aload_0, _(i|a)getfield, _(i|a)return or any rewrites thereof;
664 // parameter size = 1
665 // Note: We can only use this code if the getfield has been resolved
666 // and if we don't have a null-pointer exception => check for
667 // these conditions first and use slow path if necessary.
668 // Rmethod: method
669 // V0: receiver
671 // [ receiver ] <-- sp
672 __ ld(T0, SP, 0);
674 // check if local 0 != NULL and read field
675 __ beq(T0, R0, slow_path);
676 __ delayed()->nop();
677 __ ld(T2, Rmethod, in_bytes(Method::const_offset()));
678 // __ movptr(rdi, Address(rdx, ConstMethod::constants_offset()));
679 __ ld(T2, T2, in_bytes(ConstMethod::constants_offset()));
680 // read first instruction word and extract bytecode @ 1 and index @ 2
681 __ ld(T3, Rmethod, in_bytes(Method::const_offset()));
682 __ lw(T3, T3, in_bytes(ConstMethod::codes_offset()));
683 // Shift codes right to get the index on the right.
684 // The bytecode fetched looks like <index><0xb4><0x2a>
685 __ dsrl(T3, T3, 2 * BitsPerByte);
686 // FIXME: maybe it's wrong
687 __ dsll(T3, T3, exact_log2(in_words(ConstantPoolCacheEntry::size())));
688 __ ld(T2, T2, ConstantPool::cache_offset_in_bytes());
690 // T0: local 0 eax
691 // Rmethod: method ebx
692 // V0: receiver - do not destroy since it is needed for slow path! ecx
693 // ecx: scratch use which register instead ?
694 // T1: scratch use which register instead ?
695 // T3: constant pool cache index edx
696 // T2: constant pool cache edi
697 // esi: send's sp
698 // Rsender: send's sp
699 // check if getfield has been resolved and read constant pool cache entry
700 // check the validity of the cache entry by testing whether _indices field
701 // contains Bytecode::_getfield in b1 byte.
702 assert(in_words(ConstantPoolCacheEntry::size()) == 4, "adjust shift below");
703 // __ movl(esi,
704 // Address(edi,
705 // edx,
706 // Address::times_4, ConstantPoolCache::base_offset()
707 // + ConstantPoolCacheEntry::indices_offset()));
710 __ dsll(T8, T3, Address::times_8);
711 __ move(T1, in_bytes(ConstantPoolCache::base_offset()
712 + ConstantPoolCacheEntry::indices_offset()));
713 __ dadd(T1, T8, T1);
714 __ dadd(T1, T1, T2);
715 __ lw(T1, T1, 0);
716 __ dsrl(T1, T1, 2 * BitsPerByte);
717 __ andi(T1, T1, 0xFF);
718 __ daddi(T1, T1, (-1) * Bytecodes::_getfield);
719 __ bne(T1, R0, slow_path);
720 __ delayed()->nop();
722 // __ shrl(esi, 2*BitsPerByte);
723 // __ andl(esi, 0xFF);
724 // __ cmpl(esi, Bytecodes::_getfield);
725 // __ jcc(Assembler::notEqual, slow_path);
727 // Note: constant pool entry is not valid before bytecode is resolved
729 // __ movl(esi,
730 // Address(edi,
731 // edx,
732 // Address::times_4, ConstantPoolCache::base_offset()
733 // + ConstantPoolCacheEntry::f2_offset()));
734 __ move(T1, in_bytes(ConstantPoolCache::base_offset()
735 + ConstantPoolCacheEntry::f2_offset()));
736 __ dadd(T1, T1, T8);
737 __ dadd(T1, T1, T2);
738 __ lw(AT, T1, 0);
739 // __ movl(edx,
740 // Address(edi,
741 // edx,
742 // Address::times_4, ConstantPoolCache::base_offset()
743 // + ConstantPoolCacheEntry::flags_offset()));
746 __ move(T1, in_bytes(ConstantPoolCache::base_offset()
747 + ConstantPoolCacheEntry::flags_offset()));
748 __ dadd(T1, T1, T8);
749 __ dadd(T1, T1, T2);
750 __ lw(T3, T1, 0);
752 Label notByte, notShort, notChar, notObj;
753 // const Address field_address (eax, esi, Address::times_1);
755 // Need to differentiate between igetfield, agetfield, bgetfield etc.
756 // because they are different sizes.
757 // Use the type from the constant pool cache
758 __ dsrl(T3, T3, ConstantPoolCacheEntry::tos_state_shift);
759 // Make sure we don't need to mask edx for tosBits after the above shift
760 ConstantPoolCacheEntry::verify_tos_state_shift();
761 // btos = 0
762 __ bne(T3, R0, notByte);
763 __ delayed()->dadd(T0, T0, AT);
765 __ lb(V0, T0, 0);
766 __ b(xreturn_path);
767 __ delayed()->nop();
769 //stos
770 __ bind(notByte);
771 __ daddi(T1, T3, (-1) * stos);
772 __ bne(T1, R0, notShort);
773 __ delayed()->nop();
774 __ lh(V0, T0, 0);
775 __ b(xreturn_path);
776 __ delayed()->nop();
778 //ctos
779 __ bind(notShort);
780 __ daddi(T1, T3, (-1) * ctos);
781 __ bne(T1, R0, notChar);
782 __ delayed()->nop();
783 __ lhu(V0, T0, 0);
784 __ b(xreturn_path);
785 __ delayed()->nop();
787 //atos
788 __ bind(notChar);
789 __ daddi(T1, T3, (-1) * atos);
790 __ bne(T1, R0, notObj);
791 __ delayed()->nop();
792 //add for compressedoops
793 __ load_heap_oop(V0, Address(T0, 0));
794 __ b(xreturn_path);
795 __ delayed()->nop();
797 //itos
798 __ bind(notObj);
799 #ifdef ASSERT
800 Label okay;
801 __ daddi(T1, T3, (-1) * itos);
802 __ beq(T1, R0, okay);
803 __ delayed()->nop();
804 __ stop("what type is this?");
805 __ bind(okay);
806 #endif // ASSERT
807 __ lw(V0, T0, 0);
809 __ bind(xreturn_path);
811 // _ireturn/_areturn
812 //FIXME
813 __ move(SP, Rsender);//FIXME, set sender's fp to SP
814 __ jr(RA);
815 __ delayed()->nop();
817 // generate a vanilla interpreter entry as the slow path
818 __ bind(slow_path);
819 (void) generate_normal_entry(false);
820 } else {
821 (void) generate_normal_entry(false);
822 }
824 return entry_point;
825 }
827 // Method entry for java.lang.ref.Reference.get.
828 address InterpreterGenerator::generate_Reference_get_entry(void) {
829 #ifndef SERIALGC
830 // Code: _aload_0, _getfield, _areturn
831 // parameter size = 1
832 //
833 // The code that gets generated by this routine is split into 2 parts:
834 // 1. The "intrinsified" code for G1 (or any SATB based GC),
835 // 2. The slow path - which is an expansion of the regular method entry.
836 //
837 // Notes:-
838 // * In the G1 code we do not check whether we need to block for
839 // a safepoint. If G1 is enabled then we must execute the specialized
840 // code for Reference.get (except when the Reference object is null)
841 // so that we can log the value in the referent field with an SATB
842 // update buffer.
843 // If the code for the getfield template is modified so that the
844 // G1 pre-barrier code is executed when the current method is
845 // Reference.get() then going through the normal method entry
846 // will be fine.
847 // * The G1 code can, however, check the receiver object (the instance
848 // of java.lang.Reference) and jump to the slow path if null. If the
849 // Reference object is null then we obviously cannot fetch the referent
850 // and so we don't need to call the G1 pre-barrier. Thus we can use the
851 // regular method entry code to generate the NPE.
852 //
853 // This code is based on generate_accessor_enty.
854 //
855 // rbx: Method*
857 // r13: senderSP must preserve for slow path, set SP to it on fast path
859 address entry = __ pc();
861 const int referent_offset = java_lang_ref_Reference::referent_offset;
862 guarantee(referent_offset > 0, "referent offset not initialized");
864 if (UseG1GC) {
865 Label slow_path;
866 // rbx: method
868 // Check if local 0 != NULL
869 // If the receiver is null then it is OK to jump to the slow path.
870 /* __ movptr(rax, Address(rsp, wordSize));
872 __ testptr(rax, rax);
873 __ jcc(Assembler::zero, slow_path);*/
875 // rax: local 0
876 // rbx: method (but can be used as scratch now)
877 // rdx: scratch
878 // rdi: scratch
880 // Generate the G1 pre-barrier code to log the value of
881 // the referent field in an SATB buffer.
883 // Load the value of the referent field.
884 //const Address field_address(rax, referent_offset);
885 // __ load_heap_oop(rax, field_address);
887 // Generate the G1 pre-barrier code to log the value of
888 // the referent field in an SATB buffer.
889 // __ g1_write_barrier_pre(noreg /* obj */,
890 // rax /* pre_val */,
891 // r15_thread /* thread */,
892 // rbx /* tmp */,
893 // true /* tosca_live */,
894 // true /* expand_call */);
896 // _areturn
897 /* __ pop(rdi); // get return address
898 __ mov(rsp, r13); // set sp to sender sp
899 __ jmp(rdi);
900 __ ret(0);
902 // generate a vanilla interpreter entry as the slow path
903 __ bind(slow_path);
904 (void) generate_normal_entry(false);
905 */
906 return entry;
907 }
908 #endif // SERIALGC
910 // If G1 is not enabled then attempt to go through the accessor entry point
911 // Reference.get is an accessor
912 return generate_accessor_entry();
913 }
914 // Interpreter stub for calling a native method. (asm interpreter)
915 // This sets up a somewhat different looking stack for calling the
916 // native method than the typical interpreter frame setup.
917 address InterpreterGenerator::generate_native_entry(bool synchronized) {
918 // determine code generation flags
919 bool inc_counter = UseCompiler || CountCompiledCalls;
920 // Rsender: sender's sp
921 // Rmethod: Method*
922 address entry_point = __ pc();
924 #ifndef CORE
925 const Address invocation_counter(Rmethod,in_bytes(MethodCounters::invocation_counter_offset() + // Fu: 20130814
926 InvocationCounter::counter_offset()));
927 #endif
929 // get parameter size (always needed)
930 // the size in the java stack
931 //__ lhu(V0, Rmethod, in_bytes(Method::size_of_parameters_offset()));
932 __ ld(V0, Rmethod, in_bytes(Method::const_offset()));
933 __ lhu(V0, V0, in_bytes(ConstMethod::size_of_parameters_offset())); // Fu: 20130814
935 // native calls don't need the stack size check since they have no expression stack
936 // and the arguments are already on the stack and we only add a handful of words
937 // to the stack
939 // Rmethod: Method*
940 // V0: size of parameters
941 // Layout of frame at this point
942 //
943 // [ argument word n-1 ] <--- sp
944 // ...
945 // [ argument word 0 ]
947 // for natives the size of locals is zero
949 // compute beginning of parameters (S7)
950 __ dsll(LVP, V0, Address::times_8);
951 __ daddiu(LVP, LVP, (-1) * wordSize);
952 __ dadd(LVP, LVP, SP);
954 //__ move(T0, SP); // remember sender sp for generate_fixed_frame
957 // add 2 zero-initialized slots for native calls
958 __ daddi(SP, SP, (-2) * wordSize);
959 __ sd(R0, SP, 1 * wordSize); // slot for native oop temp offset (setup via runtime)
960 __ sd(R0, SP, 0 * wordSize); // slot for static native result handler3 (setup via runtime)
962 // Layout of frame at this point
963 // [ method holder mirror ] <--- sp
964 // [ result type info ]
965 // [ argument word n-1 ] <--- T0
966 // ...
967 // [ argument word 0 ] <--- LVP
970 #ifndef CORE
971 if (inc_counter) __ lw(T3, invocation_counter); // (pre-)fetch invocation count
972 #endif
974 // initialize fixed part of activation frame
975 generate_fixed_frame(true);
976 // after this function, the layout of frame is as following
977 //
978 // [ monitor block top ] <--- sp ( the top monitor entry )
979 // [ byte code pointer (0) ] (if native, bcp = 0)
980 // [ constant pool cache ]
981 // [ Method* ]
982 // [ locals offset ]
983 // [ sender's sp ]
984 // [ sender's fp ]
985 // [ return address ] <--- fp
986 // [ method holder mirror ]
987 // [ result type info ]
988 // [ argumnet word n-1 ] <--- sender's sp
989 // ...
990 // [ argument word 0 ] <--- S7
993 // make sure method is native & not abstract
994 #ifdef ASSERT
995 __ lw(T0, Rmethod, in_bytes(Method::access_flags_offset()));
996 {
997 Label L;
998 __ andi(AT, T0, JVM_ACC_NATIVE);
999 __ bne(AT, R0, L);
1000 __ delayed()->nop();
1001 __ stop("tried to execute native method as non-native");
1002 __ bind(L);
1003 }
1004 { Label L;
1005 __ andi(AT, T0, JVM_ACC_ABSTRACT);
1006 __ beq(AT, R0, L);
1007 __ delayed()->nop();
1008 __ stop("tried to execute abstract method in interpreter");
1009 __ bind(L);
1010 }
1011 #endif
1013 // Since at this point in the method invocation the exception handler
1014 // would try to exit the monitor of synchronized methods which hasn't
1015 // been entered yet, we set the thread local variable
1016 // _do_not_unlock_if_synchronized to true. The remove_activation will
1017 // check this flag.
1018 Register thread = TREG;
1019 #ifndef OPT_THREAD
1020 __ get_thread(thread);
1021 #endif
1022 __ move(AT, (int)true);
1023 __ sb(AT, thread, in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()));
1025 #ifndef CORE
1026 // increment invocation count & check for overflow
1027 Label invocation_counter_overflow;
1028 if (inc_counter) {
1029 generate_counter_incr(&invocation_counter_overflow, NULL, NULL);
1030 }
1031 Label continue_after_compile;
1032 __ bind(continue_after_compile);
1033 #endif // CORE
1035 bang_stack_shadow_pages(true);
1037 // reset the _do_not_unlock_if_synchronized flag
1038 #ifndef OPT_THREAD
1039 __ get_thread(thread);
1040 #endif
1041 __ sb(R0, thread, in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()));
1043 // check for synchronized methods
1044 // Must happen AFTER invocation_counter check and stack overflow check,
1045 // so method is not locked if overflows.
1046 if (synchronized) {
1047 lock_method();
1048 } else {
1049 // no synchronization necessary
1050 #ifdef ASSERT
1051 {
1052 Label L;
1053 __ lw(T0, Rmethod, in_bytes(Method::access_flags_offset()));
1054 __ andi(AT, T0, JVM_ACC_SYNCHRONIZED);
1055 __ beq(AT, R0, L);
1056 __ delayed()->nop();
1057 __ stop("method needs synchronization");
1058 __ bind(L);
1059 }
1060 #endif
1061 }
1063 // after method_lock, the layout of frame is as following
1064 //
1065 // [ monitor entry ] <--- sp
1066 // ...
1067 // [ monitor entry ]
1068 // [ monitor block top ] ( the top monitor entry )
1069 // [ byte code pointer (0) ] (if native, bcp = 0)
1070 // [ constant pool cache ]
1071 // [ Method* ]
1072 // [ locals offset ]
1073 // [ sender's sp ]
1074 // [ sender's fp ]
1075 // [ return address ] <--- fp
1076 // [ method holder mirror ]
1077 // [ result type info ]
1078 // [ argumnet word n-1 ] <--- ( sender's sp )
1079 // ...
1080 // [ argument word 0 ] <--- S7
1082 // start execution
1083 #ifdef ASSERT
1084 { Label L;
1085 __ ld(AT, FP, frame::interpreter_frame_monitor_block_top_offset * wordSize);
1086 __ beq(AT, SP, L);
1087 __ delayed()->nop();
1088 __ stop("broken stack frame setup in interpreter in asm");
1089 __ bind(L);
1090 }
1091 #endif
1093 // jvmti/jvmpi support
1094 __ notify_method_entry();
1096 // work registers
1097 const Register method = Rmethod;
1098 //const Register thread = T2;
1099 const Register t = RT4;
1101 __ get_method(method);
1102 __ verify_oop(method);
1103 { Label L, Lstatic;
1104 __ ld(t,method,in_bytes(Method::const_offset()));
1105 __ lhu(t, t, in_bytes(ConstMethod::size_of_parameters_offset())); // Fu: 20130814
1106 {//aoqi_test
1107 Label L;
1108 __ daddi(AT, t, -8);
1109 __ blez(AT, L);
1110 __ delayed()->nop();
1111 __ bind(L);
1112 }
1113 // MIPS n64 ABI: caller does not reserve space for the register auguments.
1114 //FIXME, aoqi: A1?
1115 // A0 and A1(if needed)
1116 __ lw(AT, Rmethod, in_bytes(Method::access_flags_offset()));
1117 __ andi(AT, AT, JVM_ACC_STATIC);
1118 __ beq(AT, R0, Lstatic);
1119 __ delayed()->nop();
1120 __ daddiu(t, t, 1);
1121 __ bind(Lstatic);
1122 __ daddiu(t, t, -7);
1123 __ blez(t, L);
1124 __ delayed()->nop();
1125 __ dsll(t, t, Address::times_8);
1126 __ dsub(SP, SP, t);
1127 __ bind(L);
1128 }
1129 __ move(AT, -(StackAlignmentInBytes));
1130 __ andr(SP, SP, AT);
1131 __ move(AT, SP);
1132 // [ ] <--- sp
1133 // ... (size of parameters - 8 )
1134 // [ monitor entry ]
1135 // ...
1136 // [ monitor entry ]
1137 // [ monitor block top ] ( the top monitor entry )
1138 // [ byte code pointer (0) ] (if native, bcp = 0)
1139 // [ constant pool cache ]
1140 // [ Method* ]
1141 // [ locals offset ]
1142 // [ sender's sp ]
1143 // [ sender's fp ]
1144 // [ return address ] <--- fp
1145 // [ method holder mirror ]
1146 // [ result type info ]
1147 // [ argumnet word n-1 ] <--- ( sender's sp )
1148 // ...
1149 // [ argument word 0 ] <--- LVP
1151 // get signature handler
1152 {
1153 Label L;
1154 __ ld(T9, method, in_bytes(Method::signature_handler_offset()));
1155 __ bne(T9, R0, L);
1156 __ delayed()->nop();
1157 __ call_VM(NOREG, CAST_FROM_FN_PTR(address,
1158 InterpreterRuntime::prepare_native_call), method);
1159 __ get_method(method);
1160 __ ld(T9, method, in_bytes(Method::signature_handler_offset()));
1161 __ bind(L);
1162 }
1164 // call signature handler
1165 // FIXME: when change codes in InterpreterRuntime, note this point
1166 // from: begin of parameters
1167 assert(InterpreterRuntime::SignatureHandlerGenerator::from() == LVP, "adjust this code");
1168 // to: current sp
1169 assert(InterpreterRuntime::SignatureHandlerGenerator::to () == SP, "adjust this code");
1170 // temp: T3
1171 assert(InterpreterRuntime::SignatureHandlerGenerator::temp() == t , "adjust this code");
1173 __ jalr(T9);
1174 __ delayed()->nop();
1175 __ get_method(method); // slow path call blows EBX on DevStudio 5.0
1177 /*
1178 if native function is static, and its second parameter has type length of double word,
1179 and first parameter has type length of word, we have to reserve one word
1180 for the first parameter, according to mips o32 abi.
1181 if native function is not static, and its third parameter has type length of double word,
1182 and second parameter has type length of word, we have to reserve one word for the second
1183 parameter.
1184 */
1187 // result handler is in V0
1188 // set result handler
1189 __ sd(V0, FP, (frame::interpreter_frame_result_handler_offset)*wordSize);
1191 #define FIRSTPARA_SHIFT_COUNT 5
1192 #define SECONDPARA_SHIFT_COUNT 9
1193 #define THIRDPARA_SHIFT_COUNT 13
1194 #define PARA_MASK 0xf
1196 // pass mirror handle if static call
1197 {
1198 Label L;
1199 const int mirror_offset = in_bytes(Klass::java_mirror_offset());
1200 __ lw(t, method, in_bytes(Method::access_flags_offset()));
1201 __ andi(AT, t, JVM_ACC_STATIC);
1202 __ beq(AT, R0, L);
1203 __ delayed()->nop();
1205 // get mirror
1206 __ ld(t, method, in_bytes(Method:: const_offset()));
1207 __ ld(t, t, in_bytes(ConstMethod::constants_offset())); //??
1208 __ ld(t, t, ConstantPool::pool_holder_offset_in_bytes());
1209 __ ld(t, t, mirror_offset);
1210 // copy mirror into activation frame
1211 //__ sw(t, FP, frame::interpreter_frame_oop_temp_offset * wordSize);
1212 // pass handle to mirror
1213 __ sd(t, FP, frame::interpreter_frame_oop_temp_offset * wordSize);
1214 __ daddi(t, FP, frame::interpreter_frame_oop_temp_offset * wordSize);
1215 // __ ld_ptr(t,Address(SP ,wordSize));
1216 //FIXME, aoqi
1217 //__ st_ptr(t, Address(SP, wordSize));
1218 __ move(A1, t);
1219 __ bind(L);
1220 }
1222 // [ mthd holder mirror ptr ] <--- sp --------------------| (only for static method)
1223 // [ ] |
1224 // ... size of parameters(or +1) |
1225 // [ monitor entry ] |
1226 // ... |
1227 // [ monitor entry ] |
1228 // [ monitor block top ] ( the top monitor entry ) |
1229 // [ byte code pointer (0) ] (if native, bcp = 0) |
1230 // [ constant pool cache ] |
1231 // [ Method* ] |
1232 // [ locals offset ] |
1233 // [ sender's sp ] |
1234 // [ sender's fp ] |
1235 // [ return address ] <--- fp |
1236 // [ method holder mirror ] <----------------------------|
1237 // [ result type info ]
1238 // [ argumnet word n-1 ] <--- ( sender's sp )
1239 // ...
1240 // [ argument word 0 ] <--- S7
1242 // get native function entry point
1243 { Label L;
1244 __ ld(T9, method, in_bytes(Method::native_function_offset()));
1245 __ li(V1, SharedRuntime::native_method_throw_unsatisfied_link_error_entry());
1246 __ bne(V1, T9, L);
1247 __ delayed()->nop();
1248 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), method);
1249 __ get_method(method);
1250 __ verify_oop(method);
1251 __ ld(T9, method, in_bytes(Method::native_function_offset()));
1252 __ bind(L);
1253 }
1254 /*
1255 __ pushad();
1256 __ move(A0, T9);
1257 __ call(CAST_FROM_FN_PTR(address, SharedRuntime::func_debug),relocInfo::runtime_call_type);
1258 __ popad();
1259 */
1261 // pass JNIEnv
1262 // native function in T9
1263 #ifndef OPT_THREAD
1264 __ get_thread(thread);
1265 #endif
1266 __ daddi(t, thread, in_bytes(JavaThread::jni_environment_offset()));
1267 //__ addi(SP, SP, (-1) * wordSize);
1268 //__ sw(t, SP, 0);
1269 // stack,but I think it won't work when pass float,double etc @jerome,10/17,2006
1270 __ move(A0, t);
1271 // [ jni environment ] <--- sp
1272 // [ mthd holder mirror ptr ] ---------------------------->| (only for static method)
1273 // [ ] |
1274 // ... size of parameters |
1275 // [ monitor entry ] |
1276 // ... |
1277 // [ monitor entry ] |
1278 // [ monitor block top ] ( the top monitor entry ) |
1279 // [ byte code pointer (0) ] (if native, bcp = 0) |
1280 // [ constant pool cache ] |
1281 // [ Method* ] |
1282 // [ locals offset ] |
1283 // [ sender's sp ] |
1284 // [ sender's fp ] |
1285 // [ return address ] <--- fp |
1286 // [ method holder mirror ] <----------------------------|
1287 // [ result type info ]
1288 // [ argumnet word n-1 ] <--- ( sender's sp )
1289 // ...
1290 // [ argument word 0 ] <--- S7
1292 /*
1293 // reset handle block
1294 __ lw(t, thread, in_bytes(JavaThread::active_handles_offset()));
1295 __ sw(R0, t, JNIHandleBlock::top_offset_in_bytes());
1297 */
1298 // set_last_Java_frame_before_call
1299 __ sd(FP, thread, in_bytes(JavaThread::last_Java_fp_offset()));
1300 // Change state to native (we save the return address in the thread, since it might not
1301 // be pushed on the stack when we do a a stack traversal). It is enough that the pc()
1302 // points into the right code segment. It does not have to be the correct return pc.
1303 __ li(t, __ pc());
1304 // __ sw(t, thread, in_bytes(JavaThread::frame_anchor_offset()
1305 // + JavaFrameAnchor::last_Java_pc_offset()));
1306 __ sd(t, thread, in_bytes(JavaThread::last_Java_pc_offset()));
1307 __ sd(SP, thread, in_bytes(JavaThread::last_Java_sp_offset()));
1309 // change thread state
1310 #ifdef ASSERT
1311 { Label L;
1312 __ lw(t, thread, in_bytes(JavaThread::thread_state_offset()));
1313 __ daddi(t, t, (-1) * _thread_in_Java);
1314 __ beq(t, R0, L);
1315 __ delayed()->nop();
1316 __ stop("Wrong thread state in native stub");
1317 __ bind(L);
1318 }
1319 #endif
1321 __ move(t, _thread_in_native);
1322 __ sw(t, thread, in_bytes(JavaThread::thread_state_offset()));
1324 // call native method
1325 __ jalr(T9);
1326 __ delayed()->nop();
1327 // result potentially in V2:V1 or F0:F1
1330 if (CheckJNICalls) {
1331 //FIXME
1332 // __ call(StubRoutines::gs2::verify_fpu_cntrl_wrd_entry(),
1333 // relocInfo::runtime_call_type);
1334 }
1336 // restore S0 to have legal interpreter frame, i.e., bci == 0 <=> S0 == code_base()
1337 //__ lw(BCP, method, in_bytes(Method::const_offset())); // get constMethodOop
1338 //__ addi(BCP, BCP, in_bytes(ConstMethod::codes_offset())); // get codebase
1340 // via _last_native_pc and not via _last_jave_sp
1341 // NOTE: the order of theses push(es) is known to frame::interpreter_frame_result.
1342 // If the order changes or anything else is added to the stack the code in
1343 // interpreter_frame_result will have to be changed.
1344 //FIXME, should modify here
1345 // save return value to keep the value from being destroyed by other calls
1346 //__ addi(SP, SP, (-4) * wordSize);
1347 //__ sw(V0, SP, 3 * wordSize);
1348 //__ sw(V1, SP, 2 * wordSize);
1349 //__ swc1(F0, SP, 1 * wordSize);
1350 //__ swc1(F1, SP, 0 * wordSize);
1351 __ move(S1, V0);
1352 __ move(S3, V1);
1353 __ dmfc1(S4, F0);
1354 __ dmfc1(S2, F1);
1356 // change thread state
1357 __ get_thread(thread);
1358 __ move(t, _thread_in_native_trans);
1359 __ sw(t, thread, in_bytes(JavaThread::thread_state_offset()));
1361 if( os::is_MP() ) __ sync(); // Force this write out before the read below
1363 // check for safepoint operation in progress and/or pending suspend requests
1364 { Label Continue;
1366 // Don't use call_VM as it will see a possible pending exception and forward it
1367 // and never return here preventing us from clearing _last_native_pc down below.
1368 // Also can't use call_VM_leaf either as it will check to see if esi & edi are
1369 // preserved and correspond to the bcp/locals pointers. So we do a runtime call
1370 // by hand.
1371 //
1372 Label L;
1373 __ li(AT, SafepointSynchronize::address_of_state());
1374 __ lw(AT, AT, 0);
1375 __ bne(AT, R0, L);
1376 __ delayed()->nop();
1377 __ lw(AT, thread, in_bytes(JavaThread::suspend_flags_offset()));
1378 __ beq(AT, R0, Continue);
1379 __ delayed()->nop();
1380 __ bind(L);
1381 // __ addi(SP, SP, (-1) * wordSize);
1382 __ move(A0, thread);
1383 __ call(CAST_FROM_FN_PTR(address,
1384 JavaThread::check_special_condition_for_native_trans),
1385 relocInfo::runtime_call_type);
1386 __ delayed()->nop();
1387 // __ addi(SP, SP, wordSize);
1389 // __ get_method(method);
1390 #ifndef OPT_THREAD
1391 __ get_thread(thread);
1392 #endif
1393 //add for compressedoops
1394 __ reinit_heapbase();
1395 __ bind(Continue);
1396 }
1398 // change thread state
1399 __ move(t, _thread_in_Java);
1400 __ sw(t, thread, in_bytes(JavaThread::thread_state_offset()));
1401 __ reset_last_Java_frame(thread, true, true);
1403 // reset handle block
1404 __ ld(t, thread, in_bytes(JavaThread::active_handles_offset()));
1405 __ sw(R0, t, JNIHandleBlock::top_offset_in_bytes());
1407 // If result was an oop then unbox and save it in the frame
1408 { Label L;
1409 Label no_oop, store_result;
1410 //FIXME, addi only support 16-bit imeditate
1411 __ ld(AT, FP, frame::interpreter_frame_result_handler_offset*wordSize);
1412 // __ addi(AT,AT,-(int)AbstractInterpreter::result_handler(T_OBJECT));
1413 __ li(T0, AbstractInterpreter::result_handler(T_OBJECT));
1414 __ bne(AT, T0, no_oop);
1415 __ delayed()->nop();
1416 //__ cmpl(Address(esp), NULL_WORD);
1417 //FIXME, do we need pop here ? @jerome
1418 //__ pop(ltos);
1419 //__ testl(eax, eax);
1420 //__ jcc(Assembler::zero, store_result);
1421 __ move(V0, S1);
1422 __ beq(V0, R0, store_result);
1423 __ delayed()->nop();
1424 // unbox
1425 __ ld(V0, V0, 0);
1426 __ bind(store_result);
1427 __ sd(V0, FP, (frame::interpreter_frame_oop_temp_offset)*wordSize);
1428 // keep stack depth as expected by pushing oop which will eventually be discarded
1429 __ bind(no_oop);
1430 }
1431 {
1432 Label no_reguard;
1433 __ lw(t, thread, in_bytes(JavaThread::stack_guard_state_offset()));
1434 //__ bne(t, JavaThread::stack_guard_yellow_disabled, no_reguard);
1435 __ move(AT,(int) JavaThread::stack_guard_yellow_disabled);
1436 __ bne(t, AT, no_reguard);
1437 __ delayed()->nop();
1438 __ pushad();
1439 __ call(CAST_FROM_FN_PTR(address, SharedRuntime::reguard_yellow_pages),
1440 relocInfo::runtime_call_type);
1441 __ delayed()->nop();
1442 __ popad();
1443 //add for compressedoops
1444 __ reinit_heapbase();
1445 __ bind(no_reguard);
1446 }
1447 // restore esi to have legal interpreter frame,
1448 // i.e., bci == 0 <=> esi == code_base()
1449 // Can't call_VM until bcp is within reasonable.
1450 __ get_method(method); // method is junk from thread_in_native to now.
1451 __ verify_oop(method);
1452 // __ movl(esi, Address(method,Method::const_offset())); // get constMethodOop
1453 __ ld(BCP, method, in_bytes(Method::const_offset()));
1454 // __ leal(esi, Address(esi,ConstMethod::codes_offset())); // get codebase
1455 __ lea(BCP, Address(BCP, in_bytes(ConstMethod::codes_offset())));
1456 // handle exceptions (exception handling will handle unlocking!)
1457 {
1458 Label L;
1459 __ lw(t, thread, in_bytes(Thread::pending_exception_offset()));
1460 __ beq(t, R0, L);
1461 __ delayed()->nop();
1462 // Note: At some point we may want to unify this with the code used in
1463 // call_VM_base();
1464 // i.e., we should use the StubRoutines::forward_exception code. For now this
1465 // doesn't work here because the esp is not correctly set at this point.
1466 __ MacroAssembler::call_VM(noreg, CAST_FROM_FN_PTR(address,
1467 InterpreterRuntime::throw_pending_exception));
1468 __ should_not_reach_here();
1469 __ bind(L);
1470 }
1472 // do unlocking if necessary
1473 { Label L;
1474 __ lw(t, method, in_bytes(Method::access_flags_offset()));
1475 __ andi(t, t, JVM_ACC_SYNCHRONIZED);
1476 __ beq(t, R0, L);
1477 // the code below should be shared with interpreter macro assembler implementation
1478 { Label unlock;
1479 // BasicObjectLock will be first in list,
1480 // since this is a synchronized method. However, need
1481 // to check that the object has not been unlocked by
1482 // an explicit monitorexit bytecode.
1483 __ delayed()->daddi(c_rarg0, FP, frame::interpreter_frame_initial_sp_offset
1484 * wordSize - (int)sizeof(BasicObjectLock));
1485 // address of first monitor
1487 __ ld(t, c_rarg0, BasicObjectLock::obj_offset_in_bytes());
1488 __ bne(t, R0, unlock);
1489 __ delayed()->nop();
1491 // Entry already unlocked, need to throw exception
1492 __ MacroAssembler::call_VM(NOREG, CAST_FROM_FN_PTR(address,
1493 InterpreterRuntime::throw_illegal_monitor_state_exception));
1494 __ should_not_reach_here();
1496 __ bind(unlock);
1497 __ unlock_object(c_rarg0);
1498 }
1499 __ bind(L);
1500 }
1502 // jvmti/jvmpi support
1503 // Note: This must happen _after_ handling/throwing any exceptions since
1504 // the exception handler code notifies the runtime of method exits
1505 // too. If this happens before, method entry/exit notifications are
1506 // not properly paired (was bug - gri 11/22/99).
1507 __ notify_method_exit(false, vtos, InterpreterMacroAssembler::NotifyJVMTI );
1509 // restore potential result in V0:V1,
1510 // call result handler to restore potential result in ST0 & handle result
1511 //__ lw(V0, SP, 3 * wordSize);
1512 //__ lw(V1, SP, 2 * wordSize);
1513 //__ lwc1(F0, SP, 1 * wordSize);
1514 //__ lwc1(F1, SP, 0 * wordSize);
1515 //__ addi(SP, SP, 4 * wordSize);
1516 __ move(V0, S1);
1517 __ move(V1, S3);
1518 __ dmtc1(S4, F0);
1519 __ dmtc1(S2, F1);
1520 __ ld(t, FP, (frame::interpreter_frame_result_handler_offset) * wordSize);
1521 __ jalr(t);
1522 __ delayed()->nop();
1523 //jerome_for_debug
1524 //__ move(AT, (int)(&jerome4));
1525 //__ sw(FP, AT, 0);
1528 // remove activation
1529 __ ld(SP, FP, frame::interpreter_frame_sender_sp_offset * wordSize); // get sender sp
1530 __ ld(RA, FP, frame::interpreter_frame_return_addr_offset * wordSize); // get return address
1531 __ ld(FP, FP, frame::interpreter_frame_sender_fp_offset * wordSize); // restore sender's fp
1532 __ jr(RA);
1533 __ delayed()->nop();
1535 #ifndef CORE
1536 if (inc_counter) {
1537 // Handle overflow of counter and compile method
1538 __ bind(invocation_counter_overflow);
1539 generate_counter_overflow(&continue_after_compile);
1540 // entry_point is the beginning of this
1541 // function and checks again for compiled code
1542 }
1543 #endif
1544 return entry_point;
1545 }
1547 //
1548 // Generic interpreted method entry to (asm) interpreter
1549 //
1550 // Layout of frame just at the entry
1551 //
1552 // [ argument word n-1 ] <--- sp
1553 // ...
1554 // [ argument word 0 ]
1555 // assume Method* in Rmethod before call this method.
1556 // prerequisites to the generated stub : the callee Method* in Rmethod
1557 // note you must save the caller bcp before call the generated stub
1558 //
1559 address InterpreterGenerator::generate_normal_entry(bool synchronized) {
1560 // determine code generation flags
1561 bool inc_counter = UseCompiler || CountCompiledCalls;
1563 // Rmethod: Method*
1564 // Rsender: sender 's sp
1565 address entry_point = __ pc();
1566 /*
1567 #ifndef CORE
1568 // check if compiled code exists
1569 Label run_compiled_code;
1570 if (!CompileTheWorld) {
1571 check_for_compiled_code(run_compiled_code);
1572 }
1573 #endif
1574 */
1575 #ifndef CORE
1576 const Address invocation_counter(Rmethod,
1577 in_bytes(MethodCounters::invocation_counter_offset() + InvocationCounter::counter_offset()));
1578 #endif
1580 // get parameter size (always needed)
1581 __ ld(T3, Rmethod, in_bytes(Method::const_offset())); //T3 --> Rmethod._constMethod
1582 __ lhu(V0, T3, in_bytes(ConstMethod::size_of_parameters_offset()));
1584 // Rmethod: Method*
1585 // V0: size of parameters
1586 // Rsender: sender 's sp ,could be different frome sp+ wordSize if we call via c2i
1587 // get size of locals in words to T2
1588 __ lhu(T2, T3, in_bytes(ConstMethod::size_of_locals_offset()));
1589 // T2 = no. of additional locals, locals include parameters
1590 __ dsub(T2, T2, V0);
1592 // see if we've got enough room on the stack for locals plus overhead.
1593 // Layout of frame at this point
1594 //
1595 // [ argument word n-1 ] <--- sp
1596 // ...
1597 // [ argument word 0 ]
1598 generate_stack_overflow_check();
1599 // after this function, the layout of frame does not change
1601 // compute beginning of parameters (LVP)
1602 __ dsll(LVP, V0, LogBytesPerWord);
1603 __ daddiu(LVP, LVP, (-1) * wordSize);
1604 __ dadd(LVP, LVP, SP);
1606 // T2 - # of additional locals
1607 // allocate space for locals
1608 // explicitly initialize locals
1609 {
1610 Label exit, loop;
1611 // for test
1612 // __ slt(AT, R0, T2);
1613 // __ beq(AT, R0, exit);
1614 __ beq(T2, R0, exit);
1615 __ delayed()->nop();
1616 __ bind(loop);
1617 // if(TaggedStackInterpreter)__ daddi(SP, SP, -1 * wordSize);
1618 __ sd(R0, SP, -1 * wordSize); // initialize local variables
1619 __ daddiu(T2, T2, -1); // until everything initialized
1620 __ bne(T2, R0, loop);
1621 // __ slt(AT, R0, T2);
1622 // __ bne(AT, R0, loop);
1623 __ delayed();
1624 __ daddiu(SP, SP, (-1) * wordSize); //fill delay slot
1625 __ bind(exit);
1626 }
1628 #ifndef CORE
1629 if (inc_counter) __ lw(T3, invocation_counter); // (pre-)fetch invocation count
1630 #endif
1631 //
1632 // [ local var m-1 ] <--- sp
1633 // ...
1634 // [ local var 0 ]
1635 // [ argument word n-1 ] <--- T0?
1636 // ...
1637 // [ argument word 0 ] <--- LVP
1639 // initialize fixed part of activation frame
1641 generate_fixed_frame(false);
1644 // after this function, the layout of frame is as following
1645 //
1646 // [ monitor block top ] <--- sp ( the top monitor entry )
1647 // [ byte code pointer ] (if native, bcp = 0)
1648 // [ constant pool cache ]
1649 // [ Method* ]
1650 // [ locals offset ]
1651 // [ sender's sp ]
1652 // [ sender's fp ] <--- fp
1653 // [ return address ]
1654 // [ local var m-1 ]
1655 // ...
1656 // [ local var 0 ]
1657 // [ argumnet word n-1 ] <--- ( sender's sp )
1658 // ...
1659 // [ argument word 0 ] <--- LVP
1662 // make sure method is not native & not abstract
1663 #ifdef ASSERT
1664 __ ld(AT, Rmethod, in_bytes(Method::access_flags_offset()));
1665 {
1666 Label L;
1667 __ andi(T2, AT, JVM_ACC_NATIVE);
1668 __ beq(T2, R0, L);
1669 __ delayed()->nop();
1670 __ stop("tried to execute native method as non-native");
1671 __ bind(L);
1672 }
1673 { Label L;
1674 __ andi(T2, AT, JVM_ACC_ABSTRACT);
1675 __ beq(T2, R0, L);
1676 __ delayed()->nop();
1677 __ stop("tried to execute abstract method in interpreter");
1678 __ bind(L);
1679 }
1680 #endif
1682 // Since at this point in the method invocation the exception handler
1683 // would try to exit the monitor of synchronized methods which hasn't
1684 // been entered yet, we set the thread local variable
1685 // _do_not_unlock_if_synchronized to true. The remove_activation will
1686 // check this flag.
1688 #ifndef OPT_THREAD
1689 Register thread = T8;
1690 __ get_thread(thread);
1691 #else
1692 Register thread = TREG;
1693 #endif
1694 __ move(AT, (int)true);
1695 __ sb(AT, thread, in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()));
1697 #ifndef CORE
1699 // 2014/11/24 Fu
1700 // mdp : T8
1701 // tmp1: T9
1702 // tmp2: T2
1703 __ profile_parameters_type(T8, T9, T2);
1705 // increment invocation count & check for overflow
1706 Label invocation_counter_overflow;
1707 Label profile_method;
1708 Label profile_method_continue;
1709 if (inc_counter) {
1710 generate_counter_incr(&invocation_counter_overflow, &profile_method,
1711 &profile_method_continue);
1712 if (ProfileInterpreter) {
1713 __ bind(profile_method_continue);
1714 }
1715 }
1717 Label continue_after_compile;
1718 __ bind(continue_after_compile);
1720 #endif // CORE
1722 bang_stack_shadow_pages(false);
1724 // reset the _do_not_unlock_if_synchronized flag
1725 #ifndef OPT_THREAD
1726 __ get_thread(thread);
1727 #endif
1728 __ sb(R0, thread, in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()));
1730 // check for synchronized methods
1731 // Must happen AFTER invocation_counter check and stack overflow check,
1732 // so method is not locked if overflows.
1733 //
1734 if (synchronized) {
1735 // Allocate monitor and lock method
1736 lock_method();
1737 } else {
1738 // no synchronization necessary
1739 #ifdef ASSERT
1740 { Label L;
1741 __ lw(AT, Rmethod, in_bytes(Method::access_flags_offset()));
1742 __ andi(T2, AT, JVM_ACC_SYNCHRONIZED);
1743 __ beq(T2, R0, L);
1744 __ delayed()->nop();
1745 __ stop("method needs synchronization");
1746 __ bind(L);
1747 }
1748 #endif
1749 }
1751 // layout of frame after lock_method
1752 // [ monitor entry ] <--- sp
1753 // ...
1754 // [ monitor entry ]
1755 // [ monitor block top ] ( the top monitor entry )
1756 // [ byte code pointer ] (if native, bcp = 0)
1757 // [ constant pool cache ]
1758 // [ Method* ]
1759 // [ locals offset ]
1760 // [ sender's sp ]
1761 // [ sender's fp ]
1762 // [ return address ] <--- fp
1763 // [ local var m-1 ]
1764 // ...
1765 // [ local var 0 ]
1766 // [ argumnet word n-1 ] <--- ( sender's sp )
1767 // ...
1768 // [ argument word 0 ] <--- LVP
1771 // start execution
1772 #ifdef ASSERT
1773 { Label L;
1774 __ ld(AT, FP, frame::interpreter_frame_monitor_block_top_offset * wordSize);
1775 __ beq(AT, SP, L);
1776 __ delayed()->nop();
1777 __ stop("broken stack frame setup in interpreter in native");
1778 __ bind(L);
1779 }
1780 #endif
1782 // jvmti/jvmpi support
1783 __ notify_method_entry();
1785 __ dispatch_next(vtos);
1787 #ifndef CORE
1788 // invocation counter overflow
1789 if (inc_counter) {
1790 if (ProfileInterpreter) {
1791 // We have decided to profile this method in the interpreter
1792 __ bind(profile_method);
1793 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
1794 InterpreterRuntime::profile_method));
1795 __ set_method_data_pointer_for_bcp();
1796 __ get_method(Rmethod);
1797 __ b(profile_method_continue);
1798 __ delayed()->nop();
1799 }
1800 // Handle overflow of counter and compile method
1801 __ bind(invocation_counter_overflow);
1802 generate_counter_overflow(&continue_after_compile);
1803 }
1805 #endif
1806 return entry_point;
1807 }
1809 // Entry points
1810 //
1811 // Here we generate the various kind of entries into the interpreter.
1812 // The two main entry type are generic bytecode methods and native
1813 // call method. These both come in synchronized and non-synchronized
1814 // versions but the frame layout they create is very similar. The
1815 // other method entry types are really just special purpose entries
1816 // that are really entry and interpretation all in one. These are for
1817 // trivial methods like accessor, empty, or special math methods.
1818 //
1819 // When control flow reaches any of the entry types for the interpreter
1820 // the following holds ->
1821 //
1822 // Arguments:
1823 //
1824 // Rmethod: Method*
1825 // V0: receiver
1826 //
1827 //
1828 // Stack layout immediately at entry
1829 //
1830 // [ parameter n-1 ] <--- sp
1831 // ...
1832 // [ parameter 0 ]
1833 // [ expression stack ] (caller's java expression stack)
1835 // Assuming that we don't go to one of the trivial specialized entries
1836 // the stack will look like below when we are ready to execute the
1837 // first bytecode (or call the native routine). The register usage
1838 // will be as the template based interpreter expects (see
1839 // interpreter_amd64.hpp).
1840 //
1841 // local variables follow incoming parameters immediately; i.e.
1842 // the return address is moved to the end of the locals).
1843 //
1844 // [ monitor entry ] <--- sp
1845 // ...
1846 // [ monitor entry ]
1847 // [ monitor block top ] ( the top monitor entry )
1848 // [ byte code pointer ] (if native, bcp = 0)
1849 // [ constant pool cache ]
1850 // [ Method* ]
1851 // [ locals offset ]
1852 // [ sender's sp ]
1853 // [ sender's fp ]
1854 // [ return address ] <--- fp
1855 // [ local var m-1 ]
1856 // ...
1857 // [ local var 0 ]
1858 // [ argumnet word n-1 ] <--- ( sender's sp )
1859 // ...
1860 // [ argument word 0 ] <--- S7
1862 address AbstractInterpreterGenerator::generate_method_entry(
1863 AbstractInterpreter::MethodKind kind) {
1864 // determine code generation flags
1865 bool synchronized = false;
1866 address entry_point = NULL;
1867 switch (kind) {
1868 case Interpreter::zerolocals : break;
1869 case Interpreter::zerolocals_synchronized: synchronized = true; break;
1870 case Interpreter::native :
1871 entry_point = ((InterpreterGenerator*)this)->generate_native_entry(false);
1872 break;
1873 case Interpreter::native_synchronized :
1874 entry_point = ((InterpreterGenerator*)this)->generate_native_entry(true);
1875 break;
1876 case Interpreter::empty :
1877 entry_point = ((InterpreterGenerator*)this)->generate_empty_entry();
1878 break;
1879 case Interpreter::accessor :
1880 entry_point = ((InterpreterGenerator*)this)->generate_accessor_entry();
1881 break;
1882 case Interpreter::abstract :
1883 entry_point = ((InterpreterGenerator*)this)->generate_abstract_entry();
1884 break;
1886 case Interpreter::java_lang_math_sin : // fall thru
1887 case Interpreter::java_lang_math_cos : // fall thru
1888 case Interpreter::java_lang_math_tan : // fall thru
1889 case Interpreter::java_lang_math_log : // fall thru
1890 case Interpreter::java_lang_math_log10 : // fall thru
1891 case Interpreter::java_lang_math_pow : // fall thru
1892 case Interpreter::java_lang_math_exp : break;
1893 case Interpreter::java_lang_math_abs : // fall thru
1894 case Interpreter::java_lang_math_sqrt :
1895 entry_point = ((InterpreterGenerator*)this)->generate_math_entry(kind); break;
1896 case Interpreter::java_lang_ref_reference_get:
1897 entry_point = ((InterpreterGenerator*)this)->generate_Reference_get_entry(); break;
1898 default:
1899 fatal(err_msg("unexpected method kind: %d", kind));
1900 break;
1901 }
1902 if (entry_point) return entry_point;
1904 return ((InterpreterGenerator*)this)->generate_normal_entry(synchronized);
1905 }
1907 // These should never be compiled since the interpreter will prefer
1908 // // the compiled version to the intrinsic version.
1909 bool AbstractInterpreter::can_be_compiled(methodHandle m) {
1910 switch (method_kind(m)) {
1911 case Interpreter::java_lang_math_sin : // fall thru
1912 case Interpreter::java_lang_math_cos : // fall thru
1913 case Interpreter::java_lang_math_tan : // fall thru
1914 case Interpreter::java_lang_math_abs : // fall thru
1915 case Interpreter::java_lang_math_log : // fall thru
1916 case Interpreter::java_lang_math_log10 : // fall thru
1917 case Interpreter::java_lang_math_sqrt : // fall thru
1918 case Interpreter::java_lang_math_pow : // fall thru
1919 case Interpreter::java_lang_math_exp :
1920 return false;
1921 default:
1922 return true;
1923 }
1924 }
1926 // How much stack a method activation needs in words.
1927 int AbstractInterpreter::size_top_interpreter_activation(Method* method) {
1929 const int entry_size = frame::interpreter_frame_monitor_size();
1931 // total overhead size: entry_size + (saved ebp thru expr stack bottom).
1932 // be sure to change this if you add/subtract anything to/from the overhead area
1933 const int overhead_size = -(frame::interpreter_frame_initial_sp_offset) + entry_size;
1935 const int stub_code = 6; // see generate_call_stub
1936 // return overhead_size + method->max_locals() + method->max_stack() + stub_code;
1937 const int method_stack = (method->max_locals() + method->max_stack()) *
1938 Interpreter::stackElementWords;
1939 return overhead_size + method_stack + stub_code;
1940 }
1942 void AbstractInterpreter::layout_activation(Method* method,
1943 int tempcount,
1944 int popframe_extra_args,
1945 int moncount,
1946 int caller_actual_parameters,
1947 int callee_param_count,
1948 int callee_locals,
1949 frame* caller,
1950 frame* interpreter_frame,
1951 bool is_top_frame,
1952 bool is_bottom_frame) {
1953 // Note: This calculation must exactly parallel the frame setup
1954 // in AbstractInterpreterGenerator::generate_method_entry.
1955 // If interpreter_frame!=NULL, set up the method, locals, and monitors.
1956 // The frame interpreter_frame, if not NULL, is guaranteed to be the
1957 // right size, as determined by a previous call to this method.
1958 // It is also guaranteed to be walkable even though it is in a skeletal state
1960 // fixed size of an interpreter frame:
1961 // int max_locals = method->max_locals();
1963 int max_locals = method->max_locals() * Interpreter::stackElementWords;
1964 int extra_locals = (method->max_locals() - method->size_of_parameters()) * Interpreter::stackElementWords;
1966 #ifdef ASSERT
1967 if (!EnableInvokeDynamic) {
1968 // @@@ FIXME: Should we correct interpreter_frame_sender_sp in the calling sequences?
1969 // Probably, since deoptimization doesn't work yet.
1970 assert(caller->unextended_sp() == interpreter_frame->interpreter_frame_sender_sp(), "Frame not properly walkable");
1971 }
1972 assert(caller->sp() == interpreter_frame->interpreter_frame_sender_sp(), "Frame not properly walkable(2)");
1973 #endif
1975 interpreter_frame->interpreter_frame_set_method(method);
1976 // NOTE the difference in using sender_sp and interpreter_frame_sender_sp
1977 // interpreter_frame_sender_sp is the original sp of the caller (the unextended_sp)
1978 // and sender_sp is fp+8
1979 intptr_t* locals = interpreter_frame->sender_sp() + max_locals - 1;
1981 #ifdef ASSERT
1982 if (caller->is_interpreted_frame()) {
1983 assert(locals < caller->fp() + frame::interpreter_frame_initial_sp_offset, "bad placement");
1984 }
1985 #endif
1987 interpreter_frame->interpreter_frame_set_locals(locals);
1988 BasicObjectLock* montop = interpreter_frame->interpreter_frame_monitor_begin();
1989 BasicObjectLock* monbot = montop - moncount;
1990 interpreter_frame->interpreter_frame_set_monitor_end(montop - moncount);
1992 //set last sp;
1993 intptr_t* esp = (intptr_t*) monbot - tempcount*Interpreter::stackElementWords -
1994 popframe_extra_args;
1995 interpreter_frame->interpreter_frame_set_last_sp(esp);
1996 // All frames but the initial interpreter frame we fill in have a
1997 // value for sender_sp that allows walking the stack but isn't
1998 // truly correct. Correct the value here.
1999 //
2000 // int extra_locals = method->max_locals() - method->size_of_parameters();
2001 if (extra_locals != 0 &&
2002 interpreter_frame->sender_sp() == interpreter_frame->interpreter_frame_sender_sp() ) {
2003 interpreter_frame->set_interpreter_frame_sender_sp(caller->sp() + extra_locals);
2004 }
2005 *interpreter_frame->interpreter_frame_cache_addr() =
2006 method->constants()->cache();
2007 }
2009 //-----------------------------------------------------------------------------
2010 // Exceptions
2012 void TemplateInterpreterGenerator::generate_throw_exception() {
2013 // Entry point in previous activation (i.e., if the caller was
2014 // interpreted)
2015 Interpreter::_rethrow_exception_entry = __ pc();
2017 // Restore sp to interpreter_frame_last_sp even though we are going
2018 // to empty the expression stack for the exception processing.
2019 __ sd(R0,FP, frame::interpreter_frame_last_sp_offset * wordSize);
2021 // V0: exception
2022 // V1: return address/pc that threw exception
2023 __ restore_bcp(); // esi points to call/send
2024 __ restore_locals();
2026 //add for compressedoops
2027 __ reinit_heapbase();
2028 // Entry point for exceptions thrown within interpreter code
2029 Interpreter::_throw_exception_entry = __ pc();
2030 // expression stack is undefined here
2031 // V0: exception
2032 // BCP: exception bcp
2033 __ verify_oop(V0);
2035 // expression stack must be empty before entering the VM in case of an exception
2036 __ empty_expression_stack();
2037 // find exception handler address and preserve exception oop
2038 __ move(A1, V0);
2039 __ call_VM(V1, CAST_FROM_FN_PTR(address, InterpreterRuntime::exception_handler_for_exception), A1);
2040 // V0: exception handler entry point
2041 // V1: preserved exception oop
2042 // S0: bcp for exception handler
2043 __ daddi(SP, SP, (-1) * wordSize);
2044 __ sd(V1, SP, 0); // push exception which is now the only value on the stack
2045 __ jr(V0); // jump to exception handler (may be _remove_activation_entry!)
2046 __ delayed()->nop();
2048 // If the exception is not handled in the current frame the frame is removed and
2049 // the exception is rethrown (i.e. exception continuation is _rethrow_exception).
2050 //
2051 // Note: At this point the bci is still the bxi for the instruction which caused
2052 // the exception and the expression stack is empty. Thus, for any VM calls
2053 // at this point, GC will find a legal oop map (with empty expression stack).
2055 // In current activation
2056 // V0: exception
2057 // BCP: exception bcp
2059 //
2060 // JVMTI PopFrame support
2061 //
2063 Interpreter::_remove_activation_preserving_args_entry = __ pc();
2064 __ empty_expression_stack();
2065 // Set the popframe_processing bit in pending_popframe_condition indicating that we are
2066 // currently handling popframe, so that call_VMs that may happen later do not trigger new
2067 // popframe handling cycles.
2068 #ifndef OPT_THREAD
2069 Register thread = T2;
2070 __ get_thread(T2);
2071 #else
2072 Register thread = TREG;
2073 #endif
2074 __ lw(T3, thread, in_bytes(JavaThread::popframe_condition_offset()));
2075 __ ori(T3, T3, JavaThread::popframe_processing_bit);
2076 __ sw(T3, thread, in_bytes(JavaThread::popframe_condition_offset()));
2078 #ifndef CORE
2079 {
2080 // Check to see whether we are returning to a deoptimized frame.
2081 // (The PopFrame call ensures that the caller of the popped frame is
2082 // either interpreted or compiled and deoptimizes it if compiled.)
2083 // In this case, we can't call dispatch_next() after the frame is
2084 // popped, but instead must save the incoming arguments and restore
2085 // them after deoptimization has occurred.
2086 //
2087 // Note that we don't compare the return PC against the
2088 // deoptimization blob's unpack entry because of the presence of
2089 // adapter frames in C2.
2090 Label caller_not_deoptimized;
2091 __ ld(A0, FP, frame::return_addr_offset * wordSize);
2092 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::interpreter_contains), A0);
2093 __ bne(V0, R0, caller_not_deoptimized);
2094 __ delayed()->nop();
2096 // Compute size of arguments for saving when returning to deoptimized caller
2097 __ get_method(A1);
2098 __ verify_oop(A1);
2099 __ ld(A1,A1,in_bytes(Method::const_offset()));
2100 __ lhu(A1, A1, in_bytes(ConstMethod::size_of_parameters_offset()));
2101 __ shl(A1, Interpreter::logStackElementSize);
2102 __ restore_locals();
2103 __ dsub(A2, LVP, T0);
2104 __ daddiu(A2, A2, wordSize);
2105 // Save these arguments
2106 #ifndef OPT_THREAD
2107 __ get_thread(A0);
2108 #else
2109 __ move(A0, TREG);
2110 #endif
2111 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, Deoptimization::popframe_preserve_args), A0, A1, A2);
2115 __ remove_activation(vtos, T9, false, false, false);
2117 // Inform deoptimization that it is responsible for restoring these arguments
2118 #ifndef OPT_THREAD
2119 __ get_thread(thread);
2120 #endif
2121 __ move(AT, JavaThread::popframe_force_deopt_reexecution_bit);
2122 __ sw(AT, thread, in_bytes(JavaThread::popframe_condition_offset()));
2123 // Continue in deoptimization handler
2124 ///__ jmp(edx);
2125 __ jr(T9);
2126 __ delayed()->nop();
2128 __ bind(caller_not_deoptimized);
2129 }
2130 #endif /* !CORE */
2133 __ remove_activation(vtos, T3,
2134 /* throw_monitor_exception */ false,
2135 /* install_monitor_exception */ false,
2136 /* notify_jvmdi */ false);
2138 // Clear the popframe condition flag
2139 // Finish with popframe handling
2140 // A previous I2C followed by a deoptimization might have moved the
2141 // outgoing arguments further up the stack. PopFrame expects the
2142 // mutations to those outgoing arguments to be preserved and other
2143 // constraints basically require this frame to look exactly as
2144 // though it had previously invoked an interpreted activation with
2145 // no space between the top of the expression stack (current
2146 // last_sp) and the top of stack. Rather than force deopt to
2147 // maintain this kind of invariant all the time we call a small
2148 // fixup routine to move the mutated arguments onto the top of our
2149 // expression stack if necessary.
2150 //why x86 write this , i think it is no use ,@jerome
2151 //__ movl(eax, esp);
2152 //__ movl(ebx, Address(ebp, frame::interpreter_frame_last_sp_offset * wordSize));
2153 __ move(T8, SP);
2154 __ ld(A2, FP, frame::interpreter_frame_last_sp_offset * wordSize);
2155 #ifndef OPT_THREAD
2156 __ get_thread(thread);
2157 #endif
2158 // PC must point into interpreter here
2159 //__ set_last_Java_frame(ecx, noreg, ebp, __ pc());
2160 __ set_last_Java_frame(thread, noreg, FP, __ pc());
2161 // __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::popframe_move_outgoing_args), ecx, eax, ebx);
2162 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::popframe_move_outgoing_args), thread, T8, A2);
2163 __ reset_last_Java_frame(thread, true, true);
2164 // Restore the last_sp and null it out
2165 __ ld(SP, FP, frame::interpreter_frame_last_sp_offset * wordSize);
2166 __ sd(R0, FP, frame::interpreter_frame_last_sp_offset * wordSize);
2170 __ move(AT, JavaThread::popframe_inactive);
2171 __ sw(AT, thread, in_bytes(JavaThread::popframe_condition_offset()));
2173 // Finish with popframe handling
2174 __ restore_bcp();
2175 __ restore_locals();
2176 #ifndef CORE
2177 // The method data pointer was incremented already during
2178 // call profiling. We have to restore the mdp for the current bcp.
2179 if (ProfileInterpreter) {
2180 __ set_method_data_pointer_for_bcp();
2181 }
2182 #endif // !CORE
2183 // Clear the popframe condition flag
2184 // __ get_thread(ecx);
2185 // __ movl(Address(ecx, JavaThread::popframe_condition_offset()), JavaThread::popframe_inactive);
2186 #ifndef OPT_THREAD
2187 __ get_thread(thread);
2188 #endif
2189 __ move(AT, JavaThread::popframe_inactive);
2190 __ sw(AT, thread, in_bytes(JavaThread::popframe_condition_offset()));
2191 __ dispatch_next(vtos);
2192 // end of PopFrame support
2194 Interpreter::_remove_activation_entry = __ pc();
2196 // preserve exception over this code sequence
2197 __ ld(T0, SP, 0);
2198 __ daddi(SP, SP, wordSize);
2199 #ifndef OPT_THREAD
2200 __ get_thread(thread);
2201 #endif
2202 __ sd(T0, thread, in_bytes(JavaThread::vm_result_offset()));
2203 // remove the activation (without doing throws on illegalMonitorExceptions)
2204 __ remove_activation(vtos, T3, false, true, false);
2205 // restore exception
2206 __ get_vm_result(T0, thread);
2207 __ verify_oop(T0);
2209 // Inbetween activations - previous activation type unknown yet
2210 // compute continuation point - the continuation point expects
2211 // the following registers set up:
2212 //
2213 // T0: exception eax
2214 // T1: return address/pc that threw exception edx
2215 // SP: expression stack of caller esp
2216 // FP: ebp of caller ebp
2217 __ daddi(SP, SP, (-2) * wordSize);
2218 __ sd(T0, SP, wordSize); // save exception
2219 __ sd(T3, SP, 0); // save return address
2220 __ move(A1, T3);
2221 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address), thread, A1);
2222 __ move(T9, V0); // save exception handler
2223 __ ld(V0, SP, wordSize); // restore exception
2224 __ ld(V1, SP, 0); // restore return address
2225 __ daddi(SP, SP, 2 * wordSize);
2227 // Note that an "issuing PC" is actually the next PC after the call
2228 __ jr(T9); // jump to exception handler of caller
2229 __ delayed()->nop();
2230 }
2233 //
2234 // JVMTI ForceEarlyReturn support
2235 //
2236 address TemplateInterpreterGenerator::generate_earlyret_entry_for(TosState state) {
2237 address entry = __ pc();
2238 __ restore_bcp();
2239 __ restore_locals();
2240 __ empty_expression_stack();
2241 __ empty_FPU_stack();
2242 __ load_earlyret_value(state);
2244 //__ get_thread(ecx);
2245 #ifndef OPT_THREAD
2246 __ get_thread(TREG);
2247 #endif
2248 // __ movl(TREG, Address(TREG, JavaThread::jvmti_thread_state_offset()));
2249 __ ld_ptr(T9, TREG, in_bytes(JavaThread::jvmti_thread_state_offset()));
2250 //const Address cond_addr(ecx, JvmtiThreadState::earlyret_state_offset());
2251 const Address cond_addr(T9, in_bytes(JvmtiThreadState::earlyret_state_offset()));
2252 // Clear the earlyret state
2253 // __ movl(cond_addr, JvmtiThreadState::earlyret_inactive);
2254 __ move(AT,JvmtiThreadState::earlyret_inactive);
2255 __ sw(AT,cond_addr);
2256 __ sync();
2257 //__ remove_activation(state, esi,
2261 __ remove_activation(state, T0,
2262 false, /* throw_monitor_exception */
2263 false, /* install_monitor_exception */
2264 true); /* notify_jvmdi */
2265 __ sync();
2266 // __ jmp(esi);
2267 //__ jmp(T0);
2268 __ jr(T0);
2269 __ delayed()->nop();
2270 return entry;
2271 } // end of ForceEarlyReturn support
2274 //-----------------------------------------------------------------------------
2275 // Helper for vtos entry point generation
2277 void TemplateInterpreterGenerator::set_vtos_entry_points(Template* t,
2278 address& bep,
2279 address& cep,
2280 address& sep,
2281 address& aep,
2282 address& iep,
2283 address& lep,
2284 address& fep,
2285 address& dep,
2286 address& vep) {
2287 assert(t->is_valid() && t->tos_in() == vtos, "illegal template");
2288 Label L;
2289 fep = __ pc(); __ push(ftos); __ b(L); __ delayed()->nop();
2290 dep = __ pc(); __ push(dtos); __ b(L); __ delayed()->nop();
2291 lep = __ pc(); __ push(ltos); __ b(L); __ delayed()->nop();
2292 aep =__ pc(); __ push(atos); __ b(L); __ delayed()->nop();
2293 bep = cep = sep = iep = __ pc(); __ push(itos);
2294 vep = __ pc(); __ bind(L); // fall through
2295 generate_and_dispatch(t);
2296 }
2299 //-----------------------------------------------------------------------------
2300 // Generation of individual instructions
2302 // helpers for generate_and_dispatch
2305 InterpreterGenerator::InterpreterGenerator(StubQueue* code)
2306 : TemplateInterpreterGenerator(code) {
2307 generate_all(); // down here so it can be "virtual"
2308 }
2310 //-----------------------------------------------------------------------------
2312 // Non-product code
2313 #ifndef PRODUCT
2314 address TemplateInterpreterGenerator::generate_trace_code(TosState state) {
2315 address entry = __ pc();
2317 // prepare expression stack
2318 __ push(state); // save tosca
2320 // tos & tos2, added by yjl 7/15/2005
2321 // trace_bytecode need actually 4 args, the last two is tos&tos2
2322 // this work fine for x86. but mips o32 call convention will store A2-A3
2323 // to the stack position it think is the tos&tos2
2324 // when the expression stack have no more than 2 data, error occur.
2325 __ ld(A2, SP, 0);
2326 __ ld(A3, SP, 1 * wordSize);
2327 {
2328 //aoqi_test
2329 /*
2330 __ pushad();
2331 __ li(A0, (long)0);
2332 __ call(CAST_FROM_FN_PTR(address, SharedRuntime::func_debug),relocInfo::runtime_call_type);
2333 __ popad();
2334 */
2335 }
2337 // pass arguments & call tracer
2338 __ call_VM(noreg, CAST_FROM_FN_PTR(address, SharedRuntime::trace_bytecode), RA, A2, A3);
2339 __ move(RA, V0); // make sure return address is not destroyed by pop(state)
2341 // restore expression stack
2342 __ pop(state); // restore tosca
2344 // return
2345 __ jr(RA);
2346 __ delayed()->nop();
2348 return entry;
2349 }
2351 void TemplateInterpreterGenerator::count_bytecode() {
2352 __ li(T8, (long)&BytecodeCounter::_counter_value);
2353 __ lw(AT, T8, 0);
2354 __ daddi(AT, AT, 1);
2355 __ sw(AT, T8, 0);
2356 }
2358 void TemplateInterpreterGenerator::histogram_bytecode(Template* t) {
2359 __ li(T8, (long)&BytecodeHistogram::_counters[t->bytecode()]);
2360 __ lw(AT, T8, 0);
2361 __ daddi(AT, AT, 1);
2362 __ sw(AT, T8, 0);
2363 }
2365 void TemplateInterpreterGenerator::histogram_bytecode_pair(Template* t) {
2366 __ li(T8, (long)&BytecodePairHistogram::_index);
2367 __ lw(T9, T8, 0);
2368 __ dsrl(T9, T9, BytecodePairHistogram::log2_number_of_codes);
2369 __ li(T8, ((long)t->bytecode()) << BytecodePairHistogram::log2_number_of_codes);
2370 __ orr(T9, T9, T8);
2371 __ li(T8, (long)&BytecodePairHistogram::_index);
2372 __ sw(T9, T8, 0);
2373 __ dsll(T9, T9, 2);
2374 __ li(T8, (long)BytecodePairHistogram::_counters);
2375 __ dadd(T8, T8, T9);
2376 __ lw(AT, T8, 0);
2377 __ daddi(AT, AT, 1);
2378 __ sw(AT, T8, 0);
2379 }
2382 void TemplateInterpreterGenerator::trace_bytecode(Template* t) {
2383 // Call a little run-time stub to avoid blow-up for each bytecode.
2384 // The run-time runtime saves the right registers, depending on
2385 // the tosca in-state for the given template.
2387 address entry = Interpreter::trace_code(t->tos_in());
2388 assert(entry != NULL, "entry must have been generated");
2389 __ call(entry, relocInfo::none);
2390 __ delayed()->nop();
2391 //add for compressedoops
2392 __ reinit_heapbase();
2393 }
2396 void TemplateInterpreterGenerator::stop_interpreter_at() {
2397 Label L;
2398 __ li(T8, long(&BytecodeCounter::_counter_value));
2399 __ lw(T8, T8, 0);
2400 __ move(AT, StopInterpreterAt);
2401 __ bne(T8, AT, L);
2402 __ delayed()->nop();
2403 __ call(CAST_FROM_FN_PTR(address, os::breakpoint), relocInfo::runtime_call_type);
2404 __ delayed()->nop();
2405 __ bind(L);
2406 }
2407 #endif // !PRODUCT
2408 #endif // ! CC_INTERP