Tue, 26 Jul 2016 17:06:17 +0800
Add multiply word to GPR instruction (mul) in MIPS assembler.
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();
536 // x86 version pop saved bcp and return address here, FIXME
537 __ jmp(Interpreter::throw_StackOverflowError_entry(), relocInfo::runtime_call_type);
538 __ delayed()->nop();
540 // all done with frame size check
541 __ bind(after_frame_check);
542 }
544 // Allocate monitor and lock method (asm interpreter)
545 // Rmethod - Method*
546 void InterpreterGenerator::lock_method(void) {
547 // synchronize method
548 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
550 #ifdef ASSERT
551 { Label L;
552 __ lw(T0, Rmethod, in_bytes(Method::access_flags_offset()));
553 __ andi(T0, T0, JVM_ACC_SYNCHRONIZED);
554 __ bne(T0, R0, L);
555 __ delayed()->nop();
556 __ stop("method doesn't need synchronization");
557 __ bind(L);
558 }
559 #endif // ASSERT
560 // get synchronization object
561 { Label done;
562 const int mirror_offset = in_bytes(Klass::java_mirror_offset());
563 __ lw(T0, Rmethod, in_bytes(Method::access_flags_offset()));
564 __ andi(T2, T0, JVM_ACC_STATIC);
565 __ ld(T0, LVP, Interpreter::local_offset_in_bytes(0));
566 __ beq(T2, R0, done);
567 __ delayed()->nop();
568 __ ld(T0, Rmethod, in_bytes(Method::const_offset()));
569 __ ld(T0, T0, in_bytes(ConstMethod::constants_offset()));
570 __ ld(T0, T0, ConstantPool::pool_holder_offset_in_bytes());
571 __ ld(T0, T0, mirror_offset);
572 __ bind(done);
573 }
574 // add space for monitor & lock
575 __ daddi(SP, SP, (-1) * entry_size); // add space for a monitor entry
576 __ sd(SP, FP, frame::interpreter_frame_monitor_block_top_offset * wordSize);
577 // set new monitor block top
578 __ sd(T0, SP, BasicObjectLock::obj_offset_in_bytes()); // store object
579 // FIXME: I do not know what lock_object will do and what it will need
580 __ move(c_rarg0, SP); // object address
581 __ lock_object(c_rarg0);
582 }
584 // Generate a fixed interpreter frame. This is identical setup for
585 // interpreted methods and for native methods hence the shared code.
586 void TemplateInterpreterGenerator::generate_fixed_frame(bool native_call) {
588 // [ local var m-1 ] <--- sp
589 // ...
590 // [ local var 0 ]
591 // [ argumnet word n-1 ] <--- T0(sender's sp)
592 // ...
593 // [ argument word 0 ] <--- S7
595 // initialize fixed part of activation frame
596 // sender's sp in Rsender
597 int i = 0;
598 __ sd(RA, SP, (-1) * wordSize); // save return address
599 __ sd(FP, SP, (-2) * wordSize); // save sender's fp
600 __ daddiu(FP, SP, (-2) * wordSize);
601 __ sd(Rsender, FP, (-++i) * wordSize); // save sender's sp
602 __ sd(R0, FP,(-++i)*wordSize); //save last_sp as null, FIXME aoqi
603 __ sd(LVP, FP, (-++i) * wordSize); // save locals offset
604 __ ld(BCP, Rmethod, in_bytes(Method::const_offset())); // get constMethodOop
605 __ daddiu(BCP, BCP, in_bytes(ConstMethod::codes_offset())); // get codebase
606 __ sd(Rmethod, FP, (-++i) * wordSize); // save Method*
607 #ifndef CORE
608 if (ProfileInterpreter) {
609 Label method_data_continue;
610 __ ld(AT, Rmethod, in_bytes(Method::method_data_offset()));
611 __ beq(AT, R0, method_data_continue);
612 __ delayed()->nop();
613 __ daddi(AT, AT, in_bytes(MethodData::data_offset()));
614 __ bind(method_data_continue);
615 __ sd(AT, FP, (-++i) * wordSize);
616 } else {
617 __ sd(R0, FP, (-++i) * wordSize);
618 }
619 #endif // !CORE
621 __ ld(T2, Rmethod, in_bytes(Method::const_offset()));
622 __ ld(T2, T2, in_bytes(ConstMethod::constants_offset()));
623 __ ld(T2, T2, ConstantPool::cache_offset_in_bytes());
624 __ sd(T2, FP, (-++i) * wordSize); // set constant pool cache
625 if (native_call) {
626 __ sd(R0, FP, (-++i) * wordSize); // no bcp
627 } else {
628 __ sd(BCP, FP, (-++i) * wordSize); // set bcp
629 }
630 __ daddiu(SP, FP, (-++i) * wordSize);
631 __ sd(SP, FP, (-i) * wordSize); // reserve word for pointer to expression stack bottom
632 }
634 // End of helpers
636 // Various method entries
637 //------------------------------------------------------------------------------------------------------------------------
638 //
639 //
641 // Call an accessor method (assuming it is resolved, otherwise drop
642 // into vanilla (slow path) entry
643 address InterpreterGenerator::generate_accessor_entry(void) {
645 // Rmethod: Method*
646 // V0: receiver (preserve for slow entry into asm interpreter)
647 // Rsender: senderSP must preserved for slow path, set SP to it on fast path
649 address entry_point = __ pc();
650 Label xreturn_path;
651 // do fastpath for resolved accessor methods
652 if (UseFastAccessorMethods) {
653 Label slow_path;
654 __ li(T2, SafepointSynchronize::address_of_state());
655 __ lw(AT, T2, 0);
656 __ daddi(AT, AT, -(SafepointSynchronize::_not_synchronized));
657 __ bne(AT, R0, slow_path);
658 __ delayed()->nop();
659 // Code: _aload_0, _(i|a)getfield, _(i|a)return or any rewrites thereof;
660 // parameter size = 1
661 // Note: We can only use this code if the getfield has been resolved
662 // and if we don't have a null-pointer exception => check for
663 // these conditions first and use slow path if necessary.
664 // Rmethod: method
665 // V0: receiver
667 // [ receiver ] <-- sp
668 __ ld(T0, SP, 0);
670 // check if local 0 != NULL and read field
671 __ beq(T0, R0, slow_path);
672 __ delayed()->nop();
673 __ ld(T2, Rmethod, in_bytes(Method::const_offset()));
674 // __ movptr(rdi, Address(rdx, ConstMethod::constants_offset()));
675 __ ld(T2, T2, in_bytes(ConstMethod::constants_offset()));
676 // read first instruction word and extract bytecode @ 1 and index @ 2
677 __ ld(T3, Rmethod, in_bytes(Method::const_offset()));
678 __ lw(T3, T3, in_bytes(ConstMethod::codes_offset()));
679 // Shift codes right to get the index on the right.
680 // The bytecode fetched looks like <index><0xb4><0x2a>
681 __ dsrl(T3, T3, 2 * BitsPerByte);
682 // FIXME: maybe it's wrong
683 __ dsll(T3, T3, exact_log2(in_words(ConstantPoolCacheEntry::size())));
684 __ ld(T2, T2, ConstantPool::cache_offset_in_bytes());
686 // T0: local 0 eax
687 // Rmethod: method ebx
688 // V0: receiver - do not destroy since it is needed for slow path! ecx
689 // ecx: scratch use which register instead ?
690 // T1: scratch use which register instead ?
691 // T3: constant pool cache index edx
692 // T2: constant pool cache edi
693 // esi: send's sp
694 // Rsender: send's sp
695 // check if getfield has been resolved and read constant pool cache entry
696 // check the validity of the cache entry by testing whether _indices field
697 // contains Bytecode::_getfield in b1 byte.
698 assert(in_words(ConstantPoolCacheEntry::size()) == 4, "adjust shift below");
699 // __ movl(esi,
700 // Address(edi,
701 // edx,
702 // Address::times_4, ConstantPoolCache::base_offset()
703 // + ConstantPoolCacheEntry::indices_offset()));
706 __ dsll(T8, T3, Address::times_8);
707 __ move(T1, in_bytes(ConstantPoolCache::base_offset()
708 + ConstantPoolCacheEntry::indices_offset()));
709 __ dadd(T1, T8, T1);
710 __ dadd(T1, T1, T2);
711 __ lw(T1, T1, 0);
712 __ dsrl(T1, T1, 2 * BitsPerByte);
713 __ andi(T1, T1, 0xFF);
714 __ daddi(T1, T1, (-1) * Bytecodes::_getfield);
715 __ bne(T1, R0, slow_path);
716 __ delayed()->nop();
718 // __ shrl(esi, 2*BitsPerByte);
719 // __ andl(esi, 0xFF);
720 // __ cmpl(esi, Bytecodes::_getfield);
721 // __ jcc(Assembler::notEqual, slow_path);
723 // Note: constant pool entry is not valid before bytecode is resolved
725 // __ movl(esi,
726 // Address(edi,
727 // edx,
728 // Address::times_4, ConstantPoolCache::base_offset()
729 // + ConstantPoolCacheEntry::f2_offset()));
730 __ move(T1, in_bytes(ConstantPoolCache::base_offset()
731 + ConstantPoolCacheEntry::f2_offset()));
732 __ dadd(T1, T1, T8);
733 __ dadd(T1, T1, T2);
734 __ lw(AT, T1, 0);
735 // __ movl(edx,
736 // Address(edi,
737 // edx,
738 // Address::times_4, ConstantPoolCache::base_offset()
739 // + ConstantPoolCacheEntry::flags_offset()));
742 __ move(T1, in_bytes(ConstantPoolCache::base_offset()
743 + ConstantPoolCacheEntry::flags_offset()));
744 __ dadd(T1, T1, T8);
745 __ dadd(T1, T1, T2);
746 __ lw(T3, T1, 0);
748 Label notByte, notShort, notChar, notObj;
749 // const Address field_address (eax, esi, Address::times_1);
751 // Need to differentiate between igetfield, agetfield, bgetfield etc.
752 // because they are different sizes.
753 // Use the type from the constant pool cache
754 __ dsrl(T3, T3, ConstantPoolCacheEntry::tos_state_shift);
755 // Make sure we don't need to mask edx for tosBits after the above shift
756 ConstantPoolCacheEntry::verify_tos_state_shift();
757 // btos = 0
758 __ bne(T3, R0, notByte);
759 __ delayed()->dadd(T0, T0, AT);
761 __ sync();
762 __ lb(V0, T0, 0);
763 __ b(xreturn_path);
764 __ delayed()->nop();
766 //stos
767 __ bind(notByte);
768 __ daddi(T1, T3, (-1) * stos);
769 __ bne(T1, R0, notShort);
770 __ delayed()->nop();
771 __ sync();
772 __ lh(V0, T0, 0);
773 __ b(xreturn_path);
774 __ delayed()->nop();
776 //ctos
777 __ bind(notShort);
778 __ daddi(T1, T3, (-1) * ctos);
779 __ bne(T1, R0, notChar);
780 __ delayed()->nop();
781 __ sync();
782 __ lhu(V0, T0, 0);
783 __ b(xreturn_path);
784 __ delayed()->nop();
786 //atos
787 __ bind(notChar);
788 __ daddi(T1, T3, (-1) * atos);
789 __ bne(T1, R0, notObj);
790 __ delayed()->nop();
791 //add for compressedoops
792 __ sync();
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 __ sync();
808 __ lw(V0, T0, 0);
810 __ bind(xreturn_path);
812 // _ireturn/_areturn
813 //FIXME
814 __ move(SP, Rsender);//FIXME, set sender's fp to SP
815 __ jr(RA);
816 __ delayed()->nop();
818 // generate a vanilla interpreter entry as the slow path
819 __ bind(slow_path);
820 __ sync();
821 (void) generate_normal_entry(false);
822 } else {
823 __ sync();
824 (void) generate_normal_entry(false);
825 }
827 return entry_point;
828 }
830 // Method entry for java.lang.ref.Reference.get.
831 address InterpreterGenerator::generate_Reference_get_entry(void) {
832 #ifndef SERIALGC
833 // Code: _aload_0, _getfield, _areturn
834 // parameter size = 1
835 //
836 // The code that gets generated by this routine is split into 2 parts:
837 // 1. The "intrinsified" code for G1 (or any SATB based GC),
838 // 2. The slow path - which is an expansion of the regular method entry.
839 //
840 // Notes:-
841 // * In the G1 code we do not check whether we need to block for
842 // a safepoint. If G1 is enabled then we must execute the specialized
843 // code for Reference.get (except when the Reference object is null)
844 // so that we can log the value in the referent field with an SATB
845 // update buffer.
846 // If the code for the getfield template is modified so that the
847 // G1 pre-barrier code is executed when the current method is
848 // Reference.get() then going through the normal method entry
849 // will be fine.
850 // * The G1 code can, however, check the receiver object (the instance
851 // of java.lang.Reference) and jump to the slow path if null. If the
852 // Reference object is null then we obviously cannot fetch the referent
853 // and so we don't need to call the G1 pre-barrier. Thus we can use the
854 // regular method entry code to generate the NPE.
855 //
856 // This code is based on generate_accessor_enty.
857 //
858 // rbx: Method*
860 // r13: senderSP must preserve for slow path, set SP to it on fast path
862 address entry = __ pc();
864 const int referent_offset = java_lang_ref_Reference::referent_offset;
865 guarantee(referent_offset > 0, "referent offset not initialized");
867 if (UseG1GC) {
868 Label slow_path;
869 // rbx: method
871 // Check if local 0 != NULL
872 // If the receiver is null then it is OK to jump to the slow path.
873 /* __ movptr(rax, Address(rsp, wordSize));
875 __ testptr(rax, rax);
876 __ jcc(Assembler::zero, slow_path);*/
878 // rax: local 0
879 // rbx: method (but can be used as scratch now)
880 // rdx: scratch
881 // rdi: scratch
883 // Generate the G1 pre-barrier code to log the value of
884 // the referent field in an SATB buffer.
886 // Load the value of the referent field.
887 //const Address field_address(rax, referent_offset);
888 // __ load_heap_oop(rax, field_address);
890 // Generate the G1 pre-barrier code to log the value of
891 // the referent field in an SATB buffer.
892 // __ g1_write_barrier_pre(noreg /* obj */,
893 // rax /* pre_val */,
894 // r15_thread /* thread */,
895 // rbx /* tmp */,
896 // true /* tosca_live */,
897 // true /* expand_call */);
899 // _areturn
900 /* __ pop(rdi); // get return address
901 __ mov(rsp, r13); // set sp to sender sp
902 __ jmp(rdi);
903 __ ret(0);
905 // generate a vanilla interpreter entry as the slow path
906 __ bind(slow_path);
907 (void) generate_normal_entry(false);
908 */
909 return entry;
910 }
911 #endif // SERIALGC
913 // If G1 is not enabled then attempt to go through the accessor entry point
914 // Reference.get is an accessor
915 return generate_accessor_entry();
916 }
917 // Interpreter stub for calling a native method. (asm interpreter)
918 // This sets up a somewhat different looking stack for calling the
919 // native method than the typical interpreter frame setup.
920 address InterpreterGenerator::generate_native_entry(bool synchronized) {
921 // determine code generation flags
922 bool inc_counter = UseCompiler || CountCompiledCalls;
923 // Rsender: sender's sp
924 // Rmethod: Method*
925 address entry_point = __ pc();
927 #ifndef CORE
928 const Address invocation_counter(Rmethod,in_bytes(MethodCounters::invocation_counter_offset() + // Fu: 20130814
929 InvocationCounter::counter_offset()));
930 #endif
932 // get parameter size (always needed)
933 // the size in the java stack
934 //__ lhu(V0, Rmethod, in_bytes(Method::size_of_parameters_offset()));
935 __ ld(V0, Rmethod, in_bytes(Method::const_offset()));
936 __ lhu(V0, V0, in_bytes(ConstMethod::size_of_parameters_offset())); // Fu: 20130814
938 // native calls don't need the stack size check since they have no expression stack
939 // and the arguments are already on the stack and we only add a handful of words
940 // to the stack
942 // Rmethod: Method*
943 // V0: size of parameters
944 // Layout of frame at this point
945 //
946 // [ argument word n-1 ] <--- sp
947 // ...
948 // [ argument word 0 ]
950 // for natives the size of locals is zero
952 // compute beginning of parameters (S7)
953 __ dsll(LVP, V0, Address::times_8);
954 __ daddiu(LVP, LVP, (-1) * wordSize);
955 __ dadd(LVP, LVP, SP);
957 //__ move(T0, SP); // remember sender sp for generate_fixed_frame
960 // add 2 zero-initialized slots for native calls
961 __ daddi(SP, SP, (-2) * wordSize);
962 __ sd(R0, SP, 1 * wordSize); // slot for native oop temp offset (setup via runtime)
963 __ sd(R0, SP, 0 * wordSize); // slot for static native result handler3 (setup via runtime)
965 // Layout of frame at this point
966 // [ method holder mirror ] <--- sp
967 // [ result type info ]
968 // [ argument word n-1 ] <--- T0
969 // ...
970 // [ argument word 0 ] <--- LVP
973 #ifndef CORE
974 if (inc_counter) __ lw(T3, invocation_counter); // (pre-)fetch invocation count
975 #endif
977 // initialize fixed part of activation frame
978 generate_fixed_frame(true);
979 // after this function, the layout of frame is as following
980 //
981 // [ monitor block top ] <--- sp ( the top monitor entry )
982 // [ byte code pointer (0) ] (if native, bcp = 0)
983 // [ constant pool cache ]
984 // [ Method* ]
985 // [ locals offset ]
986 // [ sender's sp ]
987 // [ sender's fp ]
988 // [ return address ] <--- fp
989 // [ method holder mirror ]
990 // [ result type info ]
991 // [ argumnet word n-1 ] <--- sender's sp
992 // ...
993 // [ argument word 0 ] <--- S7
996 // make sure method is native & not abstract
997 #ifdef ASSERT
998 __ lw(T0, Rmethod, in_bytes(Method::access_flags_offset()));
999 {
1000 Label L;
1001 __ andi(AT, T0, JVM_ACC_NATIVE);
1002 __ bne(AT, R0, L);
1003 __ delayed()->nop();
1004 __ stop("tried to execute native method as non-native");
1005 __ bind(L);
1006 }
1007 { Label L;
1008 __ andi(AT, T0, JVM_ACC_ABSTRACT);
1009 __ beq(AT, R0, L);
1010 __ delayed()->nop();
1011 __ stop("tried to execute abstract method in interpreter");
1012 __ bind(L);
1013 }
1014 #endif
1016 // Since at this point in the method invocation the exception handler
1017 // would try to exit the monitor of synchronized methods which hasn't
1018 // been entered yet, we set the thread local variable
1019 // _do_not_unlock_if_synchronized to true. The remove_activation will
1020 // check this flag.
1021 Register thread = TREG;
1022 #ifndef OPT_THREAD
1023 __ get_thread(thread);
1024 #endif
1025 __ move(AT, (int)true);
1026 __ sb(AT, thread, in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()));
1028 #ifndef CORE
1029 // increment invocation count & check for overflow
1030 Label invocation_counter_overflow;
1031 if (inc_counter) {
1032 generate_counter_incr(&invocation_counter_overflow, NULL, NULL);
1033 }
1034 Label continue_after_compile;
1035 __ bind(continue_after_compile);
1036 #endif // CORE
1038 bang_stack_shadow_pages(true);
1040 // reset the _do_not_unlock_if_synchronized flag
1041 #ifndef OPT_THREAD
1042 __ get_thread(thread);
1043 #endif
1044 __ sb(R0, thread, in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()));
1046 // check for synchronized methods
1047 // Must happen AFTER invocation_counter check and stack overflow check,
1048 // so method is not locked if overflows.
1049 if (synchronized) {
1050 lock_method();
1051 } else {
1052 // no synchronization necessary
1053 #ifdef ASSERT
1054 {
1055 Label L;
1056 __ lw(T0, Rmethod, in_bytes(Method::access_flags_offset()));
1057 __ andi(AT, T0, JVM_ACC_SYNCHRONIZED);
1058 __ beq(AT, R0, L);
1059 __ delayed()->nop();
1060 __ stop("method needs synchronization");
1061 __ bind(L);
1062 }
1063 #endif
1064 }
1066 // after method_lock, the layout of frame is as following
1067 //
1068 // [ monitor entry ] <--- sp
1069 // ...
1070 // [ monitor entry ]
1071 // [ monitor block top ] ( the top monitor entry )
1072 // [ byte code pointer (0) ] (if native, bcp = 0)
1073 // [ constant pool cache ]
1074 // [ Method* ]
1075 // [ locals offset ]
1076 // [ sender's sp ]
1077 // [ sender's fp ]
1078 // [ return address ] <--- fp
1079 // [ method holder mirror ]
1080 // [ result type info ]
1081 // [ argumnet word n-1 ] <--- ( sender's sp )
1082 // ...
1083 // [ argument word 0 ] <--- S7
1085 // start execution
1086 #ifdef ASSERT
1087 { Label L;
1088 __ ld(AT, FP, frame::interpreter_frame_monitor_block_top_offset * wordSize);
1089 __ beq(AT, SP, L);
1090 __ delayed()->nop();
1091 __ stop("broken stack frame setup in interpreter in asm");
1092 __ bind(L);
1093 }
1094 #endif
1096 // jvmti/jvmpi support
1097 __ notify_method_entry();
1099 // work registers
1100 const Register method = Rmethod;
1101 //const Register thread = T2;
1102 const Register t = RT4;
1104 __ get_method(method);
1105 __ verify_oop(method);
1106 { Label L, Lstatic;
1107 __ ld(t,method,in_bytes(Method::const_offset()));
1108 __ lhu(t, t, in_bytes(ConstMethod::size_of_parameters_offset())); // Fu: 20130814
1109 {//aoqi_test
1110 Label L;
1111 __ daddi(AT, t, -8);
1112 __ blez(AT, L);
1113 __ delayed()->nop();
1114 __ bind(L);
1115 }
1116 // MIPS n64 ABI: caller does not reserve space for the register auguments.
1117 //FIXME, aoqi: A1?
1118 // A0 and A1(if needed)
1119 __ lw(AT, Rmethod, in_bytes(Method::access_flags_offset()));
1120 __ andi(AT, AT, JVM_ACC_STATIC);
1121 __ beq(AT, R0, Lstatic);
1122 __ delayed()->nop();
1123 __ daddiu(t, t, 1);
1124 __ bind(Lstatic);
1125 __ daddiu(t, t, -7);
1126 __ blez(t, L);
1127 __ delayed()->nop();
1128 __ dsll(t, t, Address::times_8);
1129 __ dsub(SP, SP, t);
1130 __ bind(L);
1131 }
1132 __ move(AT, -(StackAlignmentInBytes));
1133 __ andr(SP, SP, AT);
1134 __ move(AT, SP);
1135 // [ ] <--- sp
1136 // ... (size of parameters - 8 )
1137 // [ monitor entry ]
1138 // ...
1139 // [ monitor entry ]
1140 // [ monitor block top ] ( the top monitor entry )
1141 // [ byte code pointer (0) ] (if native, bcp = 0)
1142 // [ constant pool cache ]
1143 // [ Method* ]
1144 // [ locals offset ]
1145 // [ sender's sp ]
1146 // [ sender's fp ]
1147 // [ return address ] <--- fp
1148 // [ method holder mirror ]
1149 // [ result type info ]
1150 // [ argumnet word n-1 ] <--- ( sender's sp )
1151 // ...
1152 // [ argument word 0 ] <--- LVP
1154 // get signature handler
1155 {
1156 Label L;
1157 __ ld(T9, method, in_bytes(Method::signature_handler_offset()));
1158 __ bne(T9, R0, L);
1159 __ delayed()->nop();
1160 __ call_VM(NOREG, CAST_FROM_FN_PTR(address,
1161 InterpreterRuntime::prepare_native_call), method);
1162 __ get_method(method);
1163 __ ld(T9, method, in_bytes(Method::signature_handler_offset()));
1164 __ bind(L);
1165 }
1167 // call signature handler
1168 // FIXME: when change codes in InterpreterRuntime, note this point
1169 // from: begin of parameters
1170 assert(InterpreterRuntime::SignatureHandlerGenerator::from() == LVP, "adjust this code");
1171 // to: current sp
1172 assert(InterpreterRuntime::SignatureHandlerGenerator::to () == SP, "adjust this code");
1173 // temp: T3
1174 assert(InterpreterRuntime::SignatureHandlerGenerator::temp() == t , "adjust this code");
1176 __ jalr(T9);
1177 __ delayed()->nop();
1178 __ get_method(method); // slow path call blows EBX on DevStudio 5.0
1180 /*
1181 if native function is static, and its second parameter has type length of double word,
1182 and first parameter has type length of word, we have to reserve one word
1183 for the first parameter, according to mips o32 abi.
1184 if native function is not static, and its third parameter has type length of double word,
1185 and second parameter has type length of word, we have to reserve one word for the second
1186 parameter.
1187 */
1190 // result handler is in V0
1191 // set result handler
1192 __ sd(V0, FP, (frame::interpreter_frame_result_handler_offset)*wordSize);
1194 #define FIRSTPARA_SHIFT_COUNT 5
1195 #define SECONDPARA_SHIFT_COUNT 9
1196 #define THIRDPARA_SHIFT_COUNT 13
1197 #define PARA_MASK 0xf
1199 // pass mirror handle if static call
1200 {
1201 Label L;
1202 const int mirror_offset = in_bytes(Klass::java_mirror_offset());
1203 __ lw(t, method, in_bytes(Method::access_flags_offset()));
1204 __ andi(AT, t, JVM_ACC_STATIC);
1205 __ beq(AT, R0, L);
1206 __ delayed()->nop();
1208 // get mirror
1209 __ ld(t, method, in_bytes(Method:: const_offset()));
1210 __ ld(t, t, in_bytes(ConstMethod::constants_offset())); //??
1211 __ ld(t, t, ConstantPool::pool_holder_offset_in_bytes());
1212 __ ld(t, t, mirror_offset);
1213 // copy mirror into activation frame
1214 //__ sw(t, FP, frame::interpreter_frame_oop_temp_offset * wordSize);
1215 // pass handle to mirror
1216 __ sd(t, FP, frame::interpreter_frame_oop_temp_offset * wordSize);
1217 __ daddi(t, FP, frame::interpreter_frame_oop_temp_offset * wordSize);
1218 // __ ld_ptr(t,Address(SP ,wordSize));
1219 //FIXME, aoqi
1220 //__ st_ptr(t, Address(SP, wordSize));
1221 __ move(A1, t);
1222 __ bind(L);
1223 }
1225 // [ mthd holder mirror ptr ] <--- sp --------------------| (only for static method)
1226 // [ ] |
1227 // ... size of parameters(or +1) |
1228 // [ monitor entry ] |
1229 // ... |
1230 // [ monitor entry ] |
1231 // [ monitor block top ] ( the top monitor entry ) |
1232 // [ byte code pointer (0) ] (if native, bcp = 0) |
1233 // [ constant pool cache ] |
1234 // [ Method* ] |
1235 // [ locals offset ] |
1236 // [ sender's sp ] |
1237 // [ sender's fp ] |
1238 // [ return address ] <--- fp |
1239 // [ method holder mirror ] <----------------------------|
1240 // [ result type info ]
1241 // [ argumnet word n-1 ] <--- ( sender's sp )
1242 // ...
1243 // [ argument word 0 ] <--- S7
1245 // get native function entry point
1246 { Label L;
1247 __ ld(T9, method, in_bytes(Method::native_function_offset()));
1248 __ li(V1, SharedRuntime::native_method_throw_unsatisfied_link_error_entry());
1249 __ bne(V1, T9, L);
1250 __ delayed()->nop();
1251 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), method);
1252 __ get_method(method);
1253 __ verify_oop(method);
1254 __ ld(T9, method, in_bytes(Method::native_function_offset()));
1255 __ bind(L);
1256 }
1257 /*
1258 __ pushad();
1259 __ move(A0, T9);
1260 __ call(CAST_FROM_FN_PTR(address, SharedRuntime::func_debug),relocInfo::runtime_call_type);
1261 __ popad();
1262 */
1264 // pass JNIEnv
1265 // native function in T9
1266 #ifndef OPT_THREAD
1267 __ get_thread(thread);
1268 #endif
1269 __ daddi(t, thread, in_bytes(JavaThread::jni_environment_offset()));
1270 //__ addi(SP, SP, (-1) * wordSize);
1271 //__ sw(t, SP, 0);
1272 // stack,but I think it won't work when pass float,double etc @jerome,10/17,2006
1273 __ move(A0, t);
1274 // [ jni environment ] <--- sp
1275 // [ mthd holder mirror ptr ] ---------------------------->| (only for static method)
1276 // [ ] |
1277 // ... size of parameters |
1278 // [ monitor entry ] |
1279 // ... |
1280 // [ monitor entry ] |
1281 // [ monitor block top ] ( the top monitor entry ) |
1282 // [ byte code pointer (0) ] (if native, bcp = 0) |
1283 // [ constant pool cache ] |
1284 // [ Method* ] |
1285 // [ locals offset ] |
1286 // [ sender's sp ] |
1287 // [ sender's fp ] |
1288 // [ return address ] <--- fp |
1289 // [ method holder mirror ] <----------------------------|
1290 // [ result type info ]
1291 // [ argumnet word n-1 ] <--- ( sender's sp )
1292 // ...
1293 // [ argument word 0 ] <--- S7
1295 /*
1296 // reset handle block
1297 __ lw(t, thread, in_bytes(JavaThread::active_handles_offset()));
1298 __ sw(R0, t, JNIHandleBlock::top_offset_in_bytes());
1300 */
1301 // set_last_Java_frame_before_call
1302 __ sd(FP, thread, in_bytes(JavaThread::last_Java_fp_offset()));
1303 // Change state to native (we save the return address in the thread, since it might not
1304 // be pushed on the stack when we do a a stack traversal). It is enough that the pc()
1305 // points into the right code segment. It does not have to be the correct return pc.
1306 __ li(t, __ pc());
1307 // __ sw(t, thread, in_bytes(JavaThread::frame_anchor_offset()
1308 // + JavaFrameAnchor::last_Java_pc_offset()));
1309 __ sd(t, thread, in_bytes(JavaThread::last_Java_pc_offset()));
1310 __ sd(SP, thread, in_bytes(JavaThread::last_Java_sp_offset()));
1312 // change thread state
1313 #ifdef ASSERT
1314 { Label L;
1315 __ lw(t, thread, in_bytes(JavaThread::thread_state_offset()));
1316 __ daddi(t, t, (-1) * _thread_in_Java);
1317 __ beq(t, R0, L);
1318 __ delayed()->nop();
1319 __ stop("Wrong thread state in native stub");
1320 __ bind(L);
1321 }
1322 #endif
1324 __ move(t, _thread_in_native);
1325 __ sw(t, thread, in_bytes(JavaThread::thread_state_offset()));
1327 // call native method
1328 __ jalr(T9);
1329 __ delayed()->nop();
1330 // result potentially in V2:V1 or F0:F1
1333 if (CheckJNICalls) {
1334 //FIXME
1335 // __ call(StubRoutines::gs2::verify_fpu_cntrl_wrd_entry(),
1336 // relocInfo::runtime_call_type);
1337 }
1339 // restore S0 to have legal interpreter frame, i.e., bci == 0 <=> S0 == code_base()
1340 //__ lw(BCP, method, in_bytes(Method::const_offset())); // get constMethodOop
1341 //__ addi(BCP, BCP, in_bytes(ConstMethod::codes_offset())); // get codebase
1343 // via _last_native_pc and not via _last_jave_sp
1344 // NOTE: the order of theses push(es) is known to frame::interpreter_frame_result.
1345 // If the order changes or anything else is added to the stack the code in
1346 // interpreter_frame_result will have to be changed.
1347 //FIXME, should modify here
1348 // save return value to keep the value from being destroyed by other calls
1349 //__ addi(SP, SP, (-4) * wordSize);
1350 //__ sw(V0, SP, 3 * wordSize);
1351 //__ sw(V1, SP, 2 * wordSize);
1352 //__ swc1(F0, SP, 1 * wordSize);
1353 //__ swc1(F1, SP, 0 * wordSize);
1354 __ move(S1, V0);
1355 __ move(S3, V1);
1356 __ dmfc1(S4, F0);
1357 __ dmfc1(S2, F1);
1359 // change thread state
1360 __ get_thread(thread);
1361 __ move(t, _thread_in_native_trans);
1362 __ sw(t, thread, in_bytes(JavaThread::thread_state_offset()));
1364 if( os::is_MP() ) __ sync(); // Force this write out before the read below
1366 // check for safepoint operation in progress and/or pending suspend requests
1367 { Label Continue;
1369 // Don't use call_VM as it will see a possible pending exception and forward it
1370 // and never return here preventing us from clearing _last_native_pc down below.
1371 // Also can't use call_VM_leaf either as it will check to see if esi & edi are
1372 // preserved and correspond to the bcp/locals pointers. So we do a runtime call
1373 // by hand.
1374 //
1375 Label L;
1376 __ li(AT, SafepointSynchronize::address_of_state());
1377 __ lw(AT, AT, 0);
1378 __ bne(AT, R0, L);
1379 __ delayed()->nop();
1380 __ lw(AT, thread, in_bytes(JavaThread::suspend_flags_offset()));
1381 __ beq(AT, R0, Continue);
1382 __ delayed()->nop();
1383 __ bind(L);
1384 // __ addi(SP, SP, (-1) * wordSize);
1385 __ move(A0, thread);
1386 __ call(CAST_FROM_FN_PTR(address,
1387 JavaThread::check_special_condition_for_native_trans),
1388 relocInfo::runtime_call_type);
1389 __ delayed()->nop();
1390 // __ addi(SP, SP, wordSize);
1392 // __ get_method(method);
1393 #ifndef OPT_THREAD
1394 __ get_thread(thread);
1395 #endif
1396 //add for compressedoops
1397 __ reinit_heapbase();
1398 __ bind(Continue);
1399 }
1401 // change thread state
1402 __ move(t, _thread_in_Java);
1403 __ sw(t, thread, in_bytes(JavaThread::thread_state_offset()));
1404 __ reset_last_Java_frame(thread, true, true);
1406 // reset handle block
1407 __ ld(t, thread, in_bytes(JavaThread::active_handles_offset()));
1408 __ sw(R0, t, JNIHandleBlock::top_offset_in_bytes());
1410 // If result was an oop then unbox and save it in the frame
1411 { Label L;
1412 Label no_oop, store_result;
1413 //FIXME, addi only support 16-bit imeditate
1414 __ ld(AT, FP, frame::interpreter_frame_result_handler_offset*wordSize);
1415 // __ addi(AT,AT,-(int)AbstractInterpreter::result_handler(T_OBJECT));
1416 __ li(T0, AbstractInterpreter::result_handler(T_OBJECT));
1417 __ bne(AT, T0, no_oop);
1418 __ delayed()->nop();
1419 //__ cmpl(Address(esp), NULL_WORD);
1420 //FIXME, do we need pop here ? @jerome
1421 //__ pop(ltos);
1422 //__ testl(eax, eax);
1423 //__ jcc(Assembler::zero, store_result);
1424 __ move(V0, S1);
1425 __ beq(V0, R0, store_result);
1426 __ delayed()->nop();
1427 // unbox
1428 __ ld(V0, V0, 0);
1429 __ bind(store_result);
1430 __ sd(V0, FP, (frame::interpreter_frame_oop_temp_offset)*wordSize);
1431 // keep stack depth as expected by pushing oop which will eventually be discarded
1432 __ bind(no_oop);
1433 }
1434 {
1435 Label no_reguard;
1436 __ lw(t, thread, in_bytes(JavaThread::stack_guard_state_offset()));
1437 //__ bne(t, JavaThread::stack_guard_yellow_disabled, no_reguard);
1438 __ move(AT,(int) JavaThread::stack_guard_yellow_disabled);
1439 __ bne(t, AT, no_reguard);
1440 __ delayed()->nop();
1441 __ pushad();
1442 __ call(CAST_FROM_FN_PTR(address, SharedRuntime::reguard_yellow_pages),
1443 relocInfo::runtime_call_type);
1444 __ delayed()->nop();
1445 __ popad();
1446 //add for compressedoops
1447 __ reinit_heapbase();
1448 __ bind(no_reguard);
1449 }
1450 // restore esi to have legal interpreter frame,
1451 // i.e., bci == 0 <=> esi == code_base()
1452 // Can't call_VM until bcp is within reasonable.
1453 __ get_method(method); // method is junk from thread_in_native to now.
1454 __ verify_oop(method);
1455 // __ movl(esi, Address(method,Method::const_offset())); // get constMethodOop
1456 __ ld(BCP, method, in_bytes(Method::const_offset()));
1457 // __ leal(esi, Address(esi,ConstMethod::codes_offset())); // get codebase
1458 __ lea(BCP, Address(BCP, in_bytes(ConstMethod::codes_offset())));
1459 // handle exceptions (exception handling will handle unlocking!)
1460 {
1461 Label L;
1462 __ lw(t, thread, in_bytes(Thread::pending_exception_offset()));
1463 __ beq(t, R0, L);
1464 __ delayed()->nop();
1465 // Note: At some point we may want to unify this with the code used in
1466 // call_VM_base();
1467 // i.e., we should use the StubRoutines::forward_exception code. For now this
1468 // doesn't work here because the esp is not correctly set at this point.
1469 __ MacroAssembler::call_VM(noreg, CAST_FROM_FN_PTR(address,
1470 InterpreterRuntime::throw_pending_exception));
1471 __ should_not_reach_here();
1472 __ bind(L);
1473 }
1475 // do unlocking if necessary
1476 { Label L;
1477 __ lw(t, method, in_bytes(Method::access_flags_offset()));
1478 __ andi(t, t, JVM_ACC_SYNCHRONIZED);
1479 __ beq(t, R0, L);
1480 // the code below should be shared with interpreter macro assembler implementation
1481 { Label unlock;
1482 // BasicObjectLock will be first in list,
1483 // since this is a synchronized method. However, need
1484 // to check that the object has not been unlocked by
1485 // an explicit monitorexit bytecode.
1486 __ delayed()->daddi(c_rarg0, FP, frame::interpreter_frame_initial_sp_offset
1487 * wordSize - (int)sizeof(BasicObjectLock));
1488 // address of first monitor
1490 __ ld(t, c_rarg0, BasicObjectLock::obj_offset_in_bytes());
1491 __ bne(t, R0, unlock);
1492 __ delayed()->nop();
1494 // Entry already unlocked, need to throw exception
1495 __ MacroAssembler::call_VM(NOREG, CAST_FROM_FN_PTR(address,
1496 InterpreterRuntime::throw_illegal_monitor_state_exception));
1497 __ should_not_reach_here();
1499 __ bind(unlock);
1500 __ unlock_object(c_rarg0);
1501 }
1502 __ bind(L);
1503 }
1505 // jvmti/jvmpi support
1506 // Note: This must happen _after_ handling/throwing any exceptions since
1507 // the exception handler code notifies the runtime of method exits
1508 // too. If this happens before, method entry/exit notifications are
1509 // not properly paired (was bug - gri 11/22/99).
1510 __ notify_method_exit(false, vtos, InterpreterMacroAssembler::NotifyJVMTI );
1512 // restore potential result in V0:V1,
1513 // call result handler to restore potential result in ST0 & handle result
1514 //__ lw(V0, SP, 3 * wordSize);
1515 //__ lw(V1, SP, 2 * wordSize);
1516 //__ lwc1(F0, SP, 1 * wordSize);
1517 //__ lwc1(F1, SP, 0 * wordSize);
1518 //__ addi(SP, SP, 4 * wordSize);
1519 __ move(V0, S1);
1520 __ move(V1, S3);
1521 __ dmtc1(S4, F0);
1522 __ dmtc1(S2, F1);
1523 __ ld(t, FP, (frame::interpreter_frame_result_handler_offset) * wordSize);
1524 __ jalr(t);
1525 __ delayed()->nop();
1526 //jerome_for_debug
1527 //__ move(AT, (int)(&jerome4));
1528 //__ sw(FP, AT, 0);
1531 // remove activation
1532 __ ld(SP, FP, frame::interpreter_frame_sender_sp_offset * wordSize); // get sender sp
1533 __ ld(RA, FP, frame::interpreter_frame_return_addr_offset * wordSize); // get return address
1534 __ ld(FP, FP, frame::interpreter_frame_sender_fp_offset * wordSize); // restore sender's fp
1535 __ jr(RA);
1536 __ delayed()->nop();
1538 #ifndef CORE
1539 if (inc_counter) {
1540 // Handle overflow of counter and compile method
1541 __ bind(invocation_counter_overflow);
1542 generate_counter_overflow(&continue_after_compile);
1543 // entry_point is the beginning of this
1544 // function and checks again for compiled code
1545 }
1546 #endif
1547 return entry_point;
1548 }
1550 //
1551 // Generic interpreted method entry to (asm) interpreter
1552 //
1553 // Layout of frame just at the entry
1554 //
1555 // [ argument word n-1 ] <--- sp
1556 // ...
1557 // [ argument word 0 ]
1558 // assume Method* in Rmethod before call this method.
1559 // prerequisites to the generated stub : the callee Method* in Rmethod
1560 // note you must save the caller bcp before call the generated stub
1561 //
1562 address InterpreterGenerator::generate_normal_entry(bool synchronized) {
1563 // determine code generation flags
1564 bool inc_counter = UseCompiler || CountCompiledCalls;
1566 // Rmethod: Method*
1567 // Rsender: sender 's sp
1568 address entry_point = __ pc();
1569 /*
1570 #ifndef CORE
1571 // check if compiled code exists
1572 Label run_compiled_code;
1573 if (!CompileTheWorld) {
1574 check_for_compiled_code(run_compiled_code);
1575 }
1576 #endif
1577 */
1578 #ifndef CORE
1579 const Address invocation_counter(Rmethod,
1580 in_bytes(MethodCounters::invocation_counter_offset() + InvocationCounter::counter_offset()));
1581 #endif
1583 // get parameter size (always needed)
1584 __ ld(T3, Rmethod, in_bytes(Method::const_offset())); //T3 --> Rmethod._constMethod
1585 __ lhu(V0, T3, in_bytes(ConstMethod::size_of_parameters_offset()));
1587 // Rmethod: Method*
1588 // V0: size of parameters
1589 // Rsender: sender 's sp ,could be different frome sp+ wordSize if we call via c2i
1590 // get size of locals in words to T2
1591 __ lhu(T2, T3, in_bytes(ConstMethod::size_of_locals_offset()));
1592 // T2 = no. of additional locals, locals include parameters
1593 __ dsub(T2, T2, V0);
1595 // see if we've got enough room on the stack for locals plus overhead.
1596 // Layout of frame at this point
1597 //
1598 // [ argument word n-1 ] <--- sp
1599 // ...
1600 // [ argument word 0 ]
1601 generate_stack_overflow_check();
1602 // after this function, the layout of frame does not change
1604 // compute beginning of parameters (LVP)
1605 __ dsll(LVP, V0, LogBytesPerWord);
1606 __ daddiu(LVP, LVP, (-1) * wordSize);
1607 __ dadd(LVP, LVP, SP);
1609 // T2 - # of additional locals
1610 // allocate space for locals
1611 // explicitly initialize locals
1612 {
1613 Label exit, loop;
1614 // for test
1615 // __ slt(AT, R0, T2);
1616 // __ beq(AT, R0, exit);
1617 __ beq(T2, R0, exit);
1618 __ delayed()->nop();
1619 __ bind(loop);
1620 // if(TaggedStackInterpreter)__ daddi(SP, SP, -1 * wordSize);
1621 __ sd(R0, SP, -1 * wordSize); // initialize local variables
1622 __ daddiu(T2, T2, -1); // until everything initialized
1623 __ bne(T2, R0, loop);
1624 // __ slt(AT, R0, T2);
1625 // __ bne(AT, R0, loop);
1626 __ delayed();
1627 __ daddiu(SP, SP, (-1) * wordSize); //fill delay slot
1628 __ bind(exit);
1629 }
1631 #ifndef CORE
1632 if (inc_counter) __ lw(T3, invocation_counter); // (pre-)fetch invocation count
1633 #endif
1634 //
1635 // [ local var m-1 ] <--- sp
1636 // ...
1637 // [ local var 0 ]
1638 // [ argument word n-1 ] <--- T0?
1639 // ...
1640 // [ argument word 0 ] <--- LVP
1642 // initialize fixed part of activation frame
1644 generate_fixed_frame(false);
1647 // after this function, the layout of frame is as following
1648 //
1649 // [ monitor block top ] <--- sp ( the top monitor entry )
1650 // [ byte code pointer ] (if native, bcp = 0)
1651 // [ constant pool cache ]
1652 // [ Method* ]
1653 // [ locals offset ]
1654 // [ sender's sp ]
1655 // [ sender's fp ] <--- fp
1656 // [ return address ]
1657 // [ local var m-1 ]
1658 // ...
1659 // [ local var 0 ]
1660 // [ argumnet word n-1 ] <--- ( sender's sp )
1661 // ...
1662 // [ argument word 0 ] <--- LVP
1665 // make sure method is not native & not abstract
1666 #ifdef ASSERT
1667 __ ld(AT, Rmethod, in_bytes(Method::access_flags_offset()));
1668 {
1669 Label L;
1670 __ andi(T2, AT, JVM_ACC_NATIVE);
1671 __ beq(T2, R0, L);
1672 __ delayed()->nop();
1673 __ stop("tried to execute native method as non-native");
1674 __ bind(L);
1675 }
1676 { Label L;
1677 __ andi(T2, AT, JVM_ACC_ABSTRACT);
1678 __ beq(T2, R0, L);
1679 __ delayed()->nop();
1680 __ stop("tried to execute abstract method in interpreter");
1681 __ bind(L);
1682 }
1683 #endif
1685 // Since at this point in the method invocation the exception handler
1686 // would try to exit the monitor of synchronized methods which hasn't
1687 // been entered yet, we set the thread local variable
1688 // _do_not_unlock_if_synchronized to true. The remove_activation will
1689 // check this flag.
1691 #ifndef OPT_THREAD
1692 Register thread = T8;
1693 __ get_thread(thread);
1694 #else
1695 Register thread = TREG;
1696 #endif
1697 __ move(AT, (int)true);
1698 __ sb(AT, thread, in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()));
1700 #ifndef CORE
1702 // 2014/11/24 Fu
1703 // mdp : T8
1704 // tmp1: T9
1705 // tmp2: T2
1706 __ profile_parameters_type(T8, T9, T2);
1708 // increment invocation count & check for overflow
1709 Label invocation_counter_overflow;
1710 Label profile_method;
1711 Label profile_method_continue;
1712 if (inc_counter) {
1713 generate_counter_incr(&invocation_counter_overflow, &profile_method,
1714 &profile_method_continue);
1715 if (ProfileInterpreter) {
1716 __ bind(profile_method_continue);
1717 }
1718 }
1720 Label continue_after_compile;
1721 __ bind(continue_after_compile);
1723 #endif // CORE
1725 bang_stack_shadow_pages(false);
1727 // reset the _do_not_unlock_if_synchronized flag
1728 #ifndef OPT_THREAD
1729 __ get_thread(thread);
1730 #endif
1731 __ sb(R0, thread, in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()));
1733 // check for synchronized methods
1734 // Must happen AFTER invocation_counter check and stack overflow check,
1735 // so method is not locked if overflows.
1736 //
1737 if (synchronized) {
1738 // Allocate monitor and lock method
1739 lock_method();
1740 } else {
1741 // no synchronization necessary
1742 #ifdef ASSERT
1743 { Label L;
1744 __ lw(AT, Rmethod, in_bytes(Method::access_flags_offset()));
1745 __ andi(T2, AT, JVM_ACC_SYNCHRONIZED);
1746 __ beq(T2, R0, L);
1747 __ delayed()->nop();
1748 __ stop("method needs synchronization");
1749 __ bind(L);
1750 }
1751 #endif
1752 }
1754 // layout of frame after lock_method
1755 // [ monitor entry ] <--- sp
1756 // ...
1757 // [ monitor entry ]
1758 // [ monitor block top ] ( the top monitor entry )
1759 // [ byte code pointer ] (if native, bcp = 0)
1760 // [ constant pool cache ]
1761 // [ Method* ]
1762 // [ locals offset ]
1763 // [ sender's sp ]
1764 // [ sender's fp ]
1765 // [ return address ] <--- fp
1766 // [ local var m-1 ]
1767 // ...
1768 // [ local var 0 ]
1769 // [ argumnet word n-1 ] <--- ( sender's sp )
1770 // ...
1771 // [ argument word 0 ] <--- LVP
1774 // start execution
1775 #ifdef ASSERT
1776 { Label L;
1777 __ ld(AT, FP, frame::interpreter_frame_monitor_block_top_offset * wordSize);
1778 __ beq(AT, SP, L);
1779 __ delayed()->nop();
1780 __ stop("broken stack frame setup in interpreter in native");
1781 __ bind(L);
1782 }
1783 #endif
1785 // jvmti/jvmpi support
1786 __ notify_method_entry();
1788 __ dispatch_next(vtos);
1790 #ifndef CORE
1791 // invocation counter overflow
1792 if (inc_counter) {
1793 if (ProfileInterpreter) {
1794 // We have decided to profile this method in the interpreter
1795 __ bind(profile_method);
1796 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
1797 InterpreterRuntime::profile_method));
1798 __ set_method_data_pointer_for_bcp();
1799 __ get_method(Rmethod);
1800 __ b(profile_method_continue);
1801 __ delayed()->nop();
1802 }
1803 // Handle overflow of counter and compile method
1804 __ bind(invocation_counter_overflow);
1805 generate_counter_overflow(&continue_after_compile);
1806 }
1808 #endif
1809 return entry_point;
1810 }
1812 // Entry points
1813 //
1814 // Here we generate the various kind of entries into the interpreter.
1815 // The two main entry type are generic bytecode methods and native
1816 // call method. These both come in synchronized and non-synchronized
1817 // versions but the frame layout they create is very similar. The
1818 // other method entry types are really just special purpose entries
1819 // that are really entry and interpretation all in one. These are for
1820 // trivial methods like accessor, empty, or special math methods.
1821 //
1822 // When control flow reaches any of the entry types for the interpreter
1823 // the following holds ->
1824 //
1825 // Arguments:
1826 //
1827 // Rmethod: Method*
1828 // V0: receiver
1829 //
1830 //
1831 // Stack layout immediately at entry
1832 //
1833 // [ parameter n-1 ] <--- sp
1834 // ...
1835 // [ parameter 0 ]
1836 // [ expression stack ] (caller's java expression stack)
1838 // Assuming that we don't go to one of the trivial specialized entries
1839 // the stack will look like below when we are ready to execute the
1840 // first bytecode (or call the native routine). The register usage
1841 // will be as the template based interpreter expects (see
1842 // interpreter_amd64.hpp).
1843 //
1844 // local variables follow incoming parameters immediately; i.e.
1845 // the return address is moved to the end of the locals).
1846 //
1847 // [ monitor entry ] <--- sp
1848 // ...
1849 // [ monitor entry ]
1850 // [ monitor block top ] ( the top monitor entry )
1851 // [ byte code pointer ] (if native, bcp = 0)
1852 // [ constant pool cache ]
1853 // [ Method* ]
1854 // [ locals offset ]
1855 // [ sender's sp ]
1856 // [ sender's fp ]
1857 // [ return address ] <--- fp
1858 // [ local var m-1 ]
1859 // ...
1860 // [ local var 0 ]
1861 // [ argumnet word n-1 ] <--- ( sender's sp )
1862 // ...
1863 // [ argument word 0 ] <--- S7
1865 address AbstractInterpreterGenerator::generate_method_entry(
1866 AbstractInterpreter::MethodKind kind) {
1867 // determine code generation flags
1868 bool synchronized = false;
1869 address entry_point = NULL;
1870 switch (kind) {
1871 case Interpreter::zerolocals : break;
1872 case Interpreter::zerolocals_synchronized: synchronized = true; break;
1873 case Interpreter::native :
1874 entry_point = ((InterpreterGenerator*)this)->generate_native_entry(false);
1875 break;
1876 case Interpreter::native_synchronized :
1877 entry_point = ((InterpreterGenerator*)this)->generate_native_entry(true);
1878 break;
1879 case Interpreter::empty :
1880 entry_point = ((InterpreterGenerator*)this)->generate_empty_entry();
1881 break;
1882 case Interpreter::accessor :
1883 entry_point = ((InterpreterGenerator*)this)->generate_accessor_entry();
1884 break;
1885 case Interpreter::abstract :
1886 entry_point = ((InterpreterGenerator*)this)->generate_abstract_entry();
1887 break;
1889 case Interpreter::java_lang_math_sin : // fall thru
1890 case Interpreter::java_lang_math_cos : // fall thru
1891 case Interpreter::java_lang_math_tan : // fall thru
1892 case Interpreter::java_lang_math_log : // fall thru
1893 case Interpreter::java_lang_math_log10 : // fall thru
1894 case Interpreter::java_lang_math_pow : // fall thru
1895 case Interpreter::java_lang_math_exp : break;
1896 case Interpreter::java_lang_math_abs : // fall thru
1897 case Interpreter::java_lang_math_sqrt :
1898 entry_point = ((InterpreterGenerator*)this)->generate_math_entry(kind); break;
1899 case Interpreter::java_lang_ref_reference_get:
1900 entry_point = ((InterpreterGenerator*)this)->generate_Reference_get_entry(); break;
1901 default:
1902 fatal(err_msg("unexpected method kind: %d", kind));
1903 break;
1904 }
1905 if (entry_point) return entry_point;
1907 return ((InterpreterGenerator*)this)->generate_normal_entry(synchronized);
1908 }
1910 // These should never be compiled since the interpreter will prefer
1911 // // the compiled version to the intrinsic version.
1912 bool AbstractInterpreter::can_be_compiled(methodHandle m) {
1913 switch (method_kind(m)) {
1914 case Interpreter::java_lang_math_sin : // fall thru
1915 case Interpreter::java_lang_math_cos : // fall thru
1916 case Interpreter::java_lang_math_tan : // fall thru
1917 case Interpreter::java_lang_math_abs : // fall thru
1918 case Interpreter::java_lang_math_log : // fall thru
1919 case Interpreter::java_lang_math_log10 : // fall thru
1920 case Interpreter::java_lang_math_sqrt : // fall thru
1921 case Interpreter::java_lang_math_pow : // fall thru
1922 case Interpreter::java_lang_math_exp :
1923 return false;
1924 default:
1925 return true;
1926 }
1927 }
1929 // How much stack a method activation needs in words.
1930 int AbstractInterpreter::size_top_interpreter_activation(Method* method) {
1932 const int entry_size = frame::interpreter_frame_monitor_size();
1934 // total overhead size: entry_size + (saved ebp thru expr stack bottom).
1935 // be sure to change this if you add/subtract anything to/from the overhead area
1936 const int overhead_size = -(frame::interpreter_frame_initial_sp_offset) + entry_size;
1938 const int stub_code = 6; // see generate_call_stub
1939 // return overhead_size + method->max_locals() + method->max_stack() + stub_code;
1940 const int method_stack = (method->max_locals() + method->max_stack()) *
1941 Interpreter::stackElementWords;
1942 return overhead_size + method_stack + stub_code;
1943 }
1945 void AbstractInterpreter::layout_activation(Method* method,
1946 int tempcount,
1947 int popframe_extra_args,
1948 int moncount,
1949 int caller_actual_parameters,
1950 int callee_param_count,
1951 int callee_locals,
1952 frame* caller,
1953 frame* interpreter_frame,
1954 bool is_top_frame,
1955 bool is_bottom_frame) {
1956 // Note: This calculation must exactly parallel the frame setup
1957 // in AbstractInterpreterGenerator::generate_method_entry.
1958 // If interpreter_frame!=NULL, set up the method, locals, and monitors.
1959 // The frame interpreter_frame, if not NULL, is guaranteed to be the
1960 // right size, as determined by a previous call to this method.
1961 // It is also guaranteed to be walkable even though it is in a skeletal state
1963 // fixed size of an interpreter frame:
1964 // int max_locals = method->max_locals();
1966 int max_locals = method->max_locals() * Interpreter::stackElementWords;
1967 int extra_locals = (method->max_locals() - method->size_of_parameters()) * Interpreter::stackElementWords;
1969 #ifdef ASSERT
1970 if (!EnableInvokeDynamic) {
1971 // @@@ FIXME: Should we correct interpreter_frame_sender_sp in the calling sequences?
1972 // Probably, since deoptimization doesn't work yet.
1973 assert(caller->unextended_sp() == interpreter_frame->interpreter_frame_sender_sp(), "Frame not properly walkable");
1974 }
1975 assert(caller->sp() == interpreter_frame->interpreter_frame_sender_sp(), "Frame not properly walkable(2)");
1976 #endif
1978 interpreter_frame->interpreter_frame_set_method(method);
1979 // NOTE the difference in using sender_sp and interpreter_frame_sender_sp
1980 // interpreter_frame_sender_sp is the original sp of the caller (the unextended_sp)
1981 // and sender_sp is fp+8
1982 intptr_t* locals = interpreter_frame->sender_sp() + max_locals - 1;
1984 #ifdef ASSERT
1985 if (caller->is_interpreted_frame()) {
1986 assert(locals < caller->fp() + frame::interpreter_frame_initial_sp_offset, "bad placement");
1987 }
1988 #endif
1990 interpreter_frame->interpreter_frame_set_locals(locals);
1991 BasicObjectLock* montop = interpreter_frame->interpreter_frame_monitor_begin();
1992 BasicObjectLock* monbot = montop - moncount;
1993 interpreter_frame->interpreter_frame_set_monitor_end(montop - moncount);
1995 //set last sp;
1996 intptr_t* esp = (intptr_t*) monbot - tempcount*Interpreter::stackElementWords -
1997 popframe_extra_args;
1998 interpreter_frame->interpreter_frame_set_last_sp(esp);
1999 // All frames but the initial interpreter frame we fill in have a
2000 // value for sender_sp that allows walking the stack but isn't
2001 // truly correct. Correct the value here.
2002 //
2003 // int extra_locals = method->max_locals() - method->size_of_parameters();
2004 if (extra_locals != 0 &&
2005 interpreter_frame->sender_sp() == interpreter_frame->interpreter_frame_sender_sp() ) {
2006 interpreter_frame->set_interpreter_frame_sender_sp(caller->sp() + extra_locals);
2007 }
2008 *interpreter_frame->interpreter_frame_cache_addr() =
2009 method->constants()->cache();
2010 }
2012 //-----------------------------------------------------------------------------
2013 // Exceptions
2015 void TemplateInterpreterGenerator::generate_throw_exception() {
2016 // Entry point in previous activation (i.e., if the caller was
2017 // interpreted)
2018 Interpreter::_rethrow_exception_entry = __ pc();
2020 // Restore sp to interpreter_frame_last_sp even though we are going
2021 // to empty the expression stack for the exception processing.
2022 __ sd(R0,FP, frame::interpreter_frame_last_sp_offset * wordSize);
2024 // V0: exception
2025 // V1: return address/pc that threw exception
2026 __ restore_bcp(); // esi points to call/send
2027 __ restore_locals();
2029 //add for compressedoops
2030 __ reinit_heapbase();
2031 // Entry point for exceptions thrown within interpreter code
2032 Interpreter::_throw_exception_entry = __ pc();
2033 // expression stack is undefined here
2034 // V0: exception
2035 // BCP: exception bcp
2036 __ verify_oop(V0);
2038 // expression stack must be empty before entering the VM in case of an exception
2039 __ empty_expression_stack();
2040 // find exception handler address and preserve exception oop
2041 __ move(A1, V0);
2042 __ call_VM(V1, CAST_FROM_FN_PTR(address, InterpreterRuntime::exception_handler_for_exception), A1);
2043 // V0: exception handler entry point
2044 // V1: preserved exception oop
2045 // S0: bcp for exception handler
2046 __ daddi(SP, SP, (-1) * wordSize);
2047 __ sd(V1, SP, 0); // push exception which is now the only value on the stack
2048 __ jr(V0); // jump to exception handler (may be _remove_activation_entry!)
2049 __ delayed()->nop();
2051 // If the exception is not handled in the current frame the frame is removed and
2052 // the exception is rethrown (i.e. exception continuation is _rethrow_exception).
2053 //
2054 // Note: At this point the bci is still the bxi for the instruction which caused
2055 // the exception and the expression stack is empty. Thus, for any VM calls
2056 // at this point, GC will find a legal oop map (with empty expression stack).
2058 // In current activation
2059 // V0: exception
2060 // BCP: exception bcp
2062 //
2063 // JVMTI PopFrame support
2064 //
2066 Interpreter::_remove_activation_preserving_args_entry = __ pc();
2067 __ empty_expression_stack();
2068 // Set the popframe_processing bit in pending_popframe_condition indicating that we are
2069 // currently handling popframe, so that call_VMs that may happen later do not trigger new
2070 // popframe handling cycles.
2071 #ifndef OPT_THREAD
2072 Register thread = T2;
2073 __ get_thread(T2);
2074 #else
2075 Register thread = TREG;
2076 #endif
2077 __ lw(T3, thread, in_bytes(JavaThread::popframe_condition_offset()));
2078 __ ori(T3, T3, JavaThread::popframe_processing_bit);
2079 __ sw(T3, thread, in_bytes(JavaThread::popframe_condition_offset()));
2081 #ifndef CORE
2082 {
2083 // Check to see whether we are returning to a deoptimized frame.
2084 // (The PopFrame call ensures that the caller of the popped frame is
2085 // either interpreted or compiled and deoptimizes it if compiled.)
2086 // In this case, we can't call dispatch_next() after the frame is
2087 // popped, but instead must save the incoming arguments and restore
2088 // them after deoptimization has occurred.
2089 //
2090 // Note that we don't compare the return PC against the
2091 // deoptimization blob's unpack entry because of the presence of
2092 // adapter frames in C2.
2093 Label caller_not_deoptimized;
2094 __ ld(A0, FP, frame::return_addr_offset * wordSize);
2095 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::interpreter_contains), A0);
2096 __ bne(V0, R0, caller_not_deoptimized);
2097 __ delayed()->nop();
2099 // Compute size of arguments for saving when returning to deoptimized caller
2100 __ get_method(A1);
2101 __ verify_oop(A1);
2102 __ ld(A1,A1,in_bytes(Method::const_offset()));
2103 __ lhu(A1, A1, in_bytes(ConstMethod::size_of_parameters_offset()));
2104 __ shl(A1, Interpreter::logStackElementSize);
2105 __ restore_locals();
2106 __ dsub(A2, LVP, T0);
2107 __ daddiu(A2, A2, wordSize);
2108 // Save these arguments
2109 #ifndef OPT_THREAD
2110 __ get_thread(A0);
2111 #else
2112 __ move(A0, TREG);
2113 #endif
2114 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, Deoptimization::popframe_preserve_args), A0, A1, A2);
2118 __ remove_activation(vtos, T9, false, false, false);
2120 // Inform deoptimization that it is responsible for restoring these arguments
2121 #ifndef OPT_THREAD
2122 __ get_thread(thread);
2123 #endif
2124 __ move(AT, JavaThread::popframe_force_deopt_reexecution_bit);
2125 __ sw(AT, thread, in_bytes(JavaThread::popframe_condition_offset()));
2126 // Continue in deoptimization handler
2127 ///__ jmp(edx);
2128 __ jr(T9);
2129 __ delayed()->nop();
2131 __ bind(caller_not_deoptimized);
2132 }
2133 #endif /* !CORE */
2136 __ remove_activation(vtos, T3,
2137 /* throw_monitor_exception */ false,
2138 /* install_monitor_exception */ false,
2139 /* notify_jvmdi */ false);
2141 // Clear the popframe condition flag
2142 // Finish with popframe handling
2143 // A previous I2C followed by a deoptimization might have moved the
2144 // outgoing arguments further up the stack. PopFrame expects the
2145 // mutations to those outgoing arguments to be preserved and other
2146 // constraints basically require this frame to look exactly as
2147 // though it had previously invoked an interpreted activation with
2148 // no space between the top of the expression stack (current
2149 // last_sp) and the top of stack. Rather than force deopt to
2150 // maintain this kind of invariant all the time we call a small
2151 // fixup routine to move the mutated arguments onto the top of our
2152 // expression stack if necessary.
2153 //why x86 write this , i think it is no use ,@jerome
2154 //__ movl(eax, esp);
2155 //__ movl(ebx, Address(ebp, frame::interpreter_frame_last_sp_offset * wordSize));
2156 __ move(T8, SP);
2157 __ ld(A2, FP, frame::interpreter_frame_last_sp_offset * wordSize);
2158 #ifndef OPT_THREAD
2159 __ get_thread(thread);
2160 #endif
2161 // PC must point into interpreter here
2162 //__ set_last_Java_frame(ecx, noreg, ebp, __ pc());
2163 __ set_last_Java_frame(thread, noreg, FP, __ pc());
2164 // __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::popframe_move_outgoing_args), ecx, eax, ebx);
2165 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::popframe_move_outgoing_args), thread, T8, A2);
2166 __ reset_last_Java_frame(thread, true, true);
2167 // Restore the last_sp and null it out
2168 __ ld(SP, FP, frame::interpreter_frame_last_sp_offset * wordSize);
2169 __ sd(R0, FP, frame::interpreter_frame_last_sp_offset * wordSize);
2173 __ move(AT, JavaThread::popframe_inactive);
2174 __ sw(AT, thread, in_bytes(JavaThread::popframe_condition_offset()));
2176 // Finish with popframe handling
2177 __ restore_bcp();
2178 __ restore_locals();
2179 #ifndef CORE
2180 // The method data pointer was incremented already during
2181 // call profiling. We have to restore the mdp for the current bcp.
2182 if (ProfileInterpreter) {
2183 __ set_method_data_pointer_for_bcp();
2184 }
2185 #endif // !CORE
2186 // Clear the popframe condition flag
2187 // __ get_thread(ecx);
2188 // __ movl(Address(ecx, JavaThread::popframe_condition_offset()), JavaThread::popframe_inactive);
2189 #ifndef OPT_THREAD
2190 __ get_thread(thread);
2191 #endif
2192 __ move(AT, JavaThread::popframe_inactive);
2193 __ sw(AT, thread, in_bytes(JavaThread::popframe_condition_offset()));
2194 __ dispatch_next(vtos);
2195 // end of PopFrame support
2197 Interpreter::_remove_activation_entry = __ pc();
2199 // preserve exception over this code sequence
2200 __ ld(T0, SP, 0);
2201 __ daddi(SP, SP, wordSize);
2202 #ifndef OPT_THREAD
2203 __ get_thread(thread);
2204 #endif
2205 __ sd(T0, thread, in_bytes(JavaThread::vm_result_offset()));
2206 // remove the activation (without doing throws on illegalMonitorExceptions)
2207 __ remove_activation(vtos, T3, false, true, false);
2208 // restore exception
2209 __ get_vm_result(T0, thread);
2210 __ verify_oop(T0);
2212 // Inbetween activations - previous activation type unknown yet
2213 // compute continuation point - the continuation point expects
2214 // the following registers set up:
2215 //
2216 // T0: exception eax
2217 // T1: return address/pc that threw exception edx
2218 // SP: expression stack of caller esp
2219 // FP: ebp of caller ebp
2220 __ daddi(SP, SP, (-2) * wordSize);
2221 __ sd(T0, SP, wordSize); // save exception
2222 __ sd(T3, SP, 0); // save return address
2223 __ move(A1, T3);
2224 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address), thread, A1);
2225 __ move(T9, V0); // save exception handler
2226 __ ld(V0, SP, wordSize); // restore exception
2227 __ ld(V1, SP, 0); // restore return address
2228 __ daddi(SP, SP, 2 * wordSize);
2230 // Note that an "issuing PC" is actually the next PC after the call
2231 __ jr(T9); // jump to exception handler of caller
2232 __ delayed()->nop();
2233 }
2236 //
2237 // JVMTI ForceEarlyReturn support
2238 //
2239 address TemplateInterpreterGenerator::generate_earlyret_entry_for(TosState state) {
2240 address entry = __ pc();
2241 __ restore_bcp();
2242 __ restore_locals();
2243 __ empty_expression_stack();
2244 __ empty_FPU_stack();
2245 __ load_earlyret_value(state);
2247 //__ get_thread(ecx);
2248 #ifndef OPT_THREAD
2249 __ get_thread(TREG);
2250 #endif
2251 // __ movl(TREG, Address(TREG, JavaThread::jvmti_thread_state_offset()));
2252 __ ld_ptr(T9, TREG, in_bytes(JavaThread::jvmti_thread_state_offset()));
2253 //const Address cond_addr(ecx, JvmtiThreadState::earlyret_state_offset());
2254 const Address cond_addr(T9, in_bytes(JvmtiThreadState::earlyret_state_offset()));
2255 // Clear the earlyret state
2256 // __ movl(cond_addr, JvmtiThreadState::earlyret_inactive);
2257 __ move(AT,JvmtiThreadState::earlyret_inactive);
2258 __ sw(AT,cond_addr);
2259 __ sync();
2260 //__ remove_activation(state, esi,
2264 __ remove_activation(state, T0,
2265 false, /* throw_monitor_exception */
2266 false, /* install_monitor_exception */
2267 true); /* notify_jvmdi */
2268 __ sync();
2269 // __ jmp(esi);
2270 //__ jmp(T0);
2271 __ jr(T0);
2272 __ delayed()->nop();
2273 return entry;
2274 } // end of ForceEarlyReturn support
2277 //-----------------------------------------------------------------------------
2278 // Helper for vtos entry point generation
2280 void TemplateInterpreterGenerator::set_vtos_entry_points(Template* t,
2281 address& bep,
2282 address& cep,
2283 address& sep,
2284 address& aep,
2285 address& iep,
2286 address& lep,
2287 address& fep,
2288 address& dep,
2289 address& vep) {
2290 assert(t->is_valid() && t->tos_in() == vtos, "illegal template");
2291 Label L;
2292 fep = __ pc(); __ push(ftos); __ b(L); __ delayed()->nop();
2293 dep = __ pc(); __ push(dtos); __ b(L); __ delayed()->nop();
2294 lep = __ pc(); __ push(ltos); __ b(L); __ delayed()->nop();
2295 aep =__ pc(); __ push(atos); __ b(L); __ delayed()->nop();
2296 bep = cep = sep = iep = __ pc(); __ push(itos);
2297 vep = __ pc(); __ bind(L); // fall through
2298 generate_and_dispatch(t);
2299 }
2302 //-----------------------------------------------------------------------------
2303 // Generation of individual instructions
2305 // helpers for generate_and_dispatch
2308 InterpreterGenerator::InterpreterGenerator(StubQueue* code)
2309 : TemplateInterpreterGenerator(code) {
2310 generate_all(); // down here so it can be "virtual"
2311 }
2313 //-----------------------------------------------------------------------------
2315 // Non-product code
2316 #ifndef PRODUCT
2317 address TemplateInterpreterGenerator::generate_trace_code(TosState state) {
2318 address entry = __ pc();
2320 // prepare expression stack
2321 __ push(state); // save tosca
2323 // tos & tos2, added by yjl 7/15/2005
2324 // trace_bytecode need actually 4 args, the last two is tos&tos2
2325 // this work fine for x86. but mips o32 call convention will store A2-A3
2326 // to the stack position it think is the tos&tos2
2327 // when the expression stack have no more than 2 data, error occur.
2328 __ ld(A2, SP, 0);
2329 __ ld(A3, SP, 1 * wordSize);
2330 {
2331 //aoqi_test
2332 /*
2333 __ pushad();
2334 __ li(A0, (long)0);
2335 __ call(CAST_FROM_FN_PTR(address, SharedRuntime::func_debug),relocInfo::runtime_call_type);
2336 __ popad();
2337 */
2338 }
2340 // pass arguments & call tracer
2341 __ call_VM(noreg, CAST_FROM_FN_PTR(address, SharedRuntime::trace_bytecode), RA, A2, A3);
2342 __ move(RA, V0); // make sure return address is not destroyed by pop(state)
2344 // restore expression stack
2345 __ pop(state); // restore tosca
2347 // return
2348 __ jr(RA);
2349 __ delayed()->nop();
2351 return entry;
2352 }
2354 void TemplateInterpreterGenerator::count_bytecode() {
2355 __ li(T8, (long)&BytecodeCounter::_counter_value);
2356 __ lw(AT, T8, 0);
2357 __ daddi(AT, AT, 1);
2358 __ sw(AT, T8, 0);
2359 }
2361 void TemplateInterpreterGenerator::histogram_bytecode(Template* t) {
2362 __ li(T8, (long)&BytecodeHistogram::_counters[t->bytecode()]);
2363 __ lw(AT, T8, 0);
2364 __ daddi(AT, AT, 1);
2365 __ sw(AT, T8, 0);
2366 }
2368 void TemplateInterpreterGenerator::histogram_bytecode_pair(Template* t) {
2369 __ li(T8, (long)&BytecodePairHistogram::_index);
2370 __ lw(T9, T8, 0);
2371 __ dsrl(T9, T9, BytecodePairHistogram::log2_number_of_codes);
2372 __ li(T8, ((long)t->bytecode()) << BytecodePairHistogram::log2_number_of_codes);
2373 __ orr(T9, T9, T8);
2374 __ li(T8, (long)&BytecodePairHistogram::_index);
2375 __ sw(T9, T8, 0);
2376 __ dsll(T9, T9, 2);
2377 __ li(T8, (long)BytecodePairHistogram::_counters);
2378 __ dadd(T8, T8, T9);
2379 __ lw(AT, T8, 0);
2380 __ daddi(AT, AT, 1);
2381 __ sw(AT, T8, 0);
2382 }
2385 void TemplateInterpreterGenerator::trace_bytecode(Template* t) {
2386 // Call a little run-time stub to avoid blow-up for each bytecode.
2387 // The run-time runtime saves the right registers, depending on
2388 // the tosca in-state for the given template.
2390 address entry = Interpreter::trace_code(t->tos_in());
2391 assert(entry != NULL, "entry must have been generated");
2392 __ call(entry, relocInfo::none);
2393 __ delayed()->nop();
2394 //add for compressedoops
2395 __ reinit_heapbase();
2396 }
2399 void TemplateInterpreterGenerator::stop_interpreter_at() {
2400 Label L;
2401 __ li(T8, long(&BytecodeCounter::_counter_value));
2402 __ lw(T8, T8, 0);
2403 __ move(AT, StopInterpreterAt);
2404 __ bne(T8, AT, L);
2405 __ delayed()->nop();
2406 __ call(CAST_FROM_FN_PTR(address, os::breakpoint), relocInfo::runtime_call_type);
2407 __ delayed()->nop();
2408 __ bind(L);
2409 }
2410 #endif // !PRODUCT
2411 #endif // ! CC_INTERP