graal-compiler: src/cpu/x86/vm/templateInterpreter_x86

comparison src/cpu/x86/vm/templateInterpreter_x86_32.cpp @ 304:dc7f315e41f7

5108146: Merge i486 and amd64 cpu directories 6459804: Want client (c1) compiler for x86_64 (amd64) for faster start-up Reviewed-by: kvn

author	never
date	Wed, 27 Aug 2008 00:21:55 -0700
parents	a61af66fc99e
children	9ee9cf798b59

comparison

equal deleted inserted replaced

-:fa4d1d240383
+:dc7f315e41f7
 // Note: There should be a minimal interpreter frame set up when stack
 // overflow occurs since we check explicitly for it now.
 //
 #ifdef ASSERT
 { Label L;
-__ leal(rax, Address(rbp,
+__ lea(rax, Address(rbp,
 frame::interpreter_frame_monitor_block_top_offset * wordSize));
-__ cmpl(rax, rsp);  // rax, = maximal rsp for current rbp,
+__ cmpptr(rax, rsp);  // rax, = maximal rsp for current rbp,
 //  (stack grows negative)
 __ jcc(Assembler::aboveEqual, L); // check if frame is complete
 __ stop ("interpreter frame not set up");
 __ bind(L);
 }
 }
 address TemplateInterpreterGenerator::generate_ClassCastException_handler() {
 address entry = __ pc();
 // object is at TOS
-__ popl(rax);
+__ pop(rax);
 // expression stack must be empty before entering the VM if an exception
 // happened
 __ empty_expression_stack();
 __ empty_FPU_stack();
 __ call_VM(noreg,
 address TemplateInterpreterGenerator::generate_exception_handler_common(const char* name, const char* message, bool pass_oop) {
 assert(!pass_oop || message == NULL, "either oop or message but not both");
 address entry = __ pc();
 if (pass_oop) {
 // object is at TOS
-__ popl(rbx);
+__ pop(rbx);
 }
 // expression stack must be empty before entering the VM if an exception happened
 __ empty_expression_stack();
 __ empty_FPU_stack();
 // setup parameters
 __ call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_klass_exception), rax, rbx);
 } else {
 if (message != NULL) {
 __ lea(rbx, ExternalAddress((address)message));
 } else {
-__ movl(rbx, NULL_WORD);
+__ movptr(rbx, (int32_t)NULL_WORD);
 }
 __ call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception), rax, rbx);
 }
 // throw exception
 __ jump(ExternalAddress(Interpreter::throw_exception_entry()));
 address TemplateInterpreterGenerator::generate_continuation_for(TosState state) {
 address entry = __ pc();
 // NULL last_sp until next java call
-__ movl(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);
+__ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
 __ dispatch_next(state);
 return entry;
 }
 __ bind(interpreter_entry);
 // In SSE mode, interpreter returns FP results in xmm0 but they need
 // to end up back on the FPU so it can operate on them.
 if (state == ftos && UseSSE >= 1) {
-__ subl(rsp, wordSize);
+__ subptr(rsp, wordSize);
 __ movflt(Address(rsp, 0), xmm0);
 __ fld_s(Address(rsp, 0));
-__ addl(rsp, wordSize);
+__ addptr(rsp, wordSize);
 } else if (state == dtos && UseSSE >= 2) {
-__ subl(rsp, 2*wordSize);
+__ subptr(rsp, 2*wordSize);
 __ movdbl(Address(rsp, 0), xmm0);
 __ fld_d(Address(rsp, 0));
-__ addl(rsp, 2*wordSize);
+__ addptr(rsp, 2*wordSize);
 }
 __ MacroAssembler::verify_FPU(state == ftos || state == dtos ? 1 : 0, "generate_return_entry_for in interpreter");
 // Restore stack bottom in case i2c adjusted stack
-__ movl(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));
+__ movptr(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));
 // and NULL it as marker that rsp is now tos until next java call
-__ movl(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);
+__ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
 __ restore_bcp();
 __ restore_locals();
 __ get_cache_and_index_at_bcp(rbx, rcx, 1);
 __ movl(rbx, Address(rbx, rcx,
-Address::times_4, constantPoolCacheOopDesc::base_offset() +
+Address::times_ptr, constantPoolCacheOopDesc::base_offset() +
 ConstantPoolCacheEntry::flags_offset()));
-__ andl(rbx, 0xFF);
+__ andptr(rbx, 0xFF);
-__ leal(rsp, Address(rsp, rbx, Interpreter::stackElementScale()));
+__ lea(rsp, Address(rsp, rbx, Interpreter::stackElementScale()));
 __ dispatch_next(state, step);
 return entry;
 }
 address TemplateInterpreterGenerator::generate_deopt_entry_for(TosState state, int step) {
 address entry = __ pc();
 // In SSE mode, FP results are in xmm0
 if (state == ftos && UseSSE > 0) {
-__ subl(rsp, wordSize);
+__ subptr(rsp, wordSize);
 __ movflt(Address(rsp, 0), xmm0);
 __ fld_s(Address(rsp, 0));
-__ addl(rsp, wordSize);
+__ addptr(rsp, wordSize);
 } else if (state == dtos && UseSSE >= 2) {
-__ subl(rsp, 2*wordSize);
+__ subptr(rsp, 2*wordSize);
 __ movdbl(Address(rsp, 0), xmm0);
 __ fld_d(Address(rsp, 0));
-__ addl(rsp, 2*wordSize);
+__ addptr(rsp, 2*wordSize);
 }
 __ MacroAssembler::verify_FPU(state == ftos || state == dtos ? 1 : 0, "generate_deopt_entry_for in interpreter");
 // The stack is not extended by deopt but we must NULL last_sp as this
 // entry is like a "return".
-__ movl(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);
+__ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
 __ restore_bcp();
 __ restore_locals();
 // handle exceptions
 { Label L;
 const Register thread = rcx;
 __ get_thread(thread);
-__ cmpl(Address(thread, Thread::pending_exception_offset()), NULL_WORD);
+__ cmpptr(Address(thread, Thread::pending_exception_offset()), (int32_t)NULL_WORD);
 __ jcc(Assembler::zero, L);
 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_pending_exception));
 __ should_not_reach_here();
 __ bind(L);
 }
 address TemplateInterpreterGenerator::generate_result_handler_for(BasicType type) {
 address entry = __ pc();
 switch (type) {
 case T_BOOLEAN: __ c2bool(rax);            break;
-case T_CHAR   : __ andl(rax, 0xFFFF);      break;
+case T_CHAR   : __ andptr(rax, 0xFFFF);    break;
 case T_BYTE   : __ sign_extend_byte (rax); break;
 case T_SHORT  : __ sign_extend_short(rax); break;
 case T_INT    : /* nothing to do */        break;
 case T_DOUBLE :
 case T_FLOAT  :
 { const Register t = InterpreterRuntime::SignatureHandlerGenerator::temp();
-__ popl(t);                            // remove return address first
+__ pop(t);                            // remove return address first
 __ pop_dtos_to_rsp();
 // Must return a result for interpreter or compiler. In SSE
 // mode, results are returned in xmm0 and the FPU stack must
 // be empty.
 if (type == T_FLOAT && UseSSE >= 1) {
 } else {
 // restore ST0
 __ fld_d(Address(rsp, 0));
 }
 // and pop the temp
-__ addl(rsp, 2 * wordSize);
+__ addptr(rsp, 2 * wordSize);
-__ pushl(t);                           // restore return address
+__ push(t);                           // restore return address
 }
 break;
 case T_OBJECT :
 // retrieve result from frame
-__ movl(rax, Address(rbp, frame::interpreter_frame_oop_temp_offset*wordSize));
+__ movptr(rax, Address(rbp, frame::interpreter_frame_oop_temp_offset*wordSize));
 // and verify it
 __ verify_oop(rax);
 break;
 default       : ShouldNotReachHere();
 }
 const Address invocation_counter(rbx, methodOopDesc::invocation_counter_offset() + InvocationCounter::counter_offset());
 const Address backedge_counter  (rbx, methodOopDesc::backedge_counter_offset() + InvocationCounter::counter_offset());
 if (ProfileInterpreter) { // %%% Merge this into methodDataOop
-__ increment(Address(rbx,methodOopDesc::interpreter_invocation_counter_offset()));
+__ incrementl(Address(rbx,methodOopDesc::interpreter_invocation_counter_offset()));
 }
 // Update standard invocation counters
 __ movl(rax, backedge_counter);               // load backedge counter
-__ increment(rcx, InvocationCounter::count_increment);
+__ incrementl(rcx, InvocationCounter::count_increment);
 __ andl(rax, InvocationCounter::count_mask_value);  // mask out the status bits
 __ movl(invocation_counter, rcx);             // save invocation count
 __ addl(rcx, rax);                            // add both counters
 // InterpreterRuntime::frequency_counter_overflow takes one argument
 // indicating if the counter overflow occurs at a backwards branch (non-NULL bcp).
 // The call returns the address of the verified entry point for the method or NULL
 // if the compilation did not complete (either went background or bailed out).
-__ movl(rax, (int)false);
+__ movptr(rax, (int32_t)false);
 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::frequency_counter_overflow), rax);
-__ movl(rbx, Address(rbp, method_offset));   // restore methodOop
+__ movptr(rbx, Address(rbp, method_offset));   // restore methodOop
 // Preserve invariant that rsi/rdi contain bcp/locals of sender frame
 // and jump to the interpreted entry.
 __ jmp(*do_continue, relocInfo::none);
 // compute rsp as if this were going to be the last frame on
 // the stack before the red zone
 Label after_frame_check_pop;
-__ pushl(rsi);
+__ push(rsi);
 const Register thread = rsi;
 __ get_thread(thread);
 const Address stack_base(thread, Thread::stack_base_offset());
 const Address stack_size(thread, Thread::stack_size_offset());
 // locals + overhead, in bytes
-__ leal(rax, Address(noreg, rdx, Interpreter::stackElementScale(), overhead_size));
+__ lea(rax, Address(noreg, rdx, Interpreter::stackElementScale(), overhead_size));
 #ifdef ASSERT
 Label stack_base_okay, stack_size_okay;
 // verify that thread stack base is non-zero
-__ cmpl(stack_base, 0);
+__ cmpptr(stack_base, (int32_t)NULL_WORD);
 __ jcc(Assembler::notEqual, stack_base_okay);
 __ stop("stack base is zero");
 __ bind(stack_base_okay);
 // verify that thread stack size is non-zero
-__ cmpl(stack_size, 0);
+__ cmpptr(stack_size, 0);
 __ jcc(Assembler::notEqual, stack_size_okay);
 __ stop("stack size is zero");
 __ bind(stack_size_okay);
 #endif
 // Add stack base to locals and subtract stack size
-__ addl(rax, stack_base);
+__ addptr(rax, stack_base);
-__ subl(rax, stack_size);
+__ subptr(rax, stack_size);
 // Use the maximum number of pages we might bang.
 const int max_pages = StackShadowPages > (StackRedPages+StackYellowPages) ? StackShadowPages :
 (StackRedPages+StackYellowPages);
-__ addl(rax, max_pages * page_size);
+__ addptr(rax, max_pages * page_size);
 // check against the current stack bottom
-__ cmpl(rsp, rax);
+__ cmpptr(rsp, rax);
 __ jcc(Assembler::above, after_frame_check_pop);
-__ popl(rsi);  // get saved bcp / (c++ prev state ).
+__ pop(rsi);  // get saved bcp / (c++ prev state ).
-__ popl(rax);  // get return address
+__ pop(rax);  // get return address
 __ jump(ExternalAddress(Interpreter::throw_StackOverflowError_entry()));
 // all done with frame size check
 __ bind(after_frame_check_pop);
-__ popl(rsi);
+__ pop(rsi);
 __ bind(after_frame_check);
 }
 // Allocate monitor and lock method (asm interpreter)
 // get synchronization object
 { Label done;
 const int mirror_offset = klassOopDesc::klass_part_offset_in_bytes() + Klass::java_mirror_offset_in_bytes();
 __ movl(rax, access_flags);
 __ testl(rax, JVM_ACC_STATIC);
-__ movl(rax, Address(rdi, Interpreter::local_offset_in_bytes(0)));                                         // get receiver (assume this is frequent case)
+__ movptr(rax, Address(rdi, Interpreter::local_offset_in_bytes(0)));  // get receiver (assume this is frequent case)
 __ jcc(Assembler::zero, done);
-__ movl(rax, Address(rbx, methodOopDesc::constants_offset()));
+__ movptr(rax, Address(rbx, methodOopDesc::constants_offset()));
-__ movl(rax, Address(rax, constantPoolOopDesc::pool_holder_offset_in_bytes()));
+__ movptr(rax, Address(rax, constantPoolOopDesc::pool_holder_offset_in_bytes()));
-__ movl(rax, Address(rax, mirror_offset));
+__ movptr(rax, Address(rax, mirror_offset));
 __ bind(done);
 }
 // add space for monitor & lock
-__ subl(rsp, entry_size);                                             // add space for a monitor entry
+__ subptr(rsp, entry_size);                                           // add space for a monitor entry
-__ movl(monitor_block_top, rsp);                                      // set new monitor block top
+__ movptr(monitor_block_top, rsp);                                    // set new monitor block top
-__ movl(Address(rsp, BasicObjectLock::obj_offset_in_bytes()), rax);   // store object
+__ movptr(Address(rsp, BasicObjectLock::obj_offset_in_bytes()), rax); // store object
-__ movl(rdx, rsp);                                                    // object address
+__ mov(rdx, rsp);                                                    // object address
 __ lock_object(rdx);
 }
 //
 // Generate a fixed interpreter frame. This is identical setup for interpreted methods
 // and for native methods hence the shared code.
 void TemplateInterpreterGenerator::generate_fixed_frame(bool native_call) {
 // initialize fixed part of activation frame
-__ pushl(rax);                                      // save return address
+__ push(rax);                                       // save return address
 __ enter();                                         // save old & set new rbp,
-__ pushl(rsi);                                      // set sender sp
+__ push(rsi);                                       // set sender sp
-__ pushl(NULL_WORD);                                // leave last_sp as null
+__ push((int32_t)NULL_WORD);                        // leave last_sp as null
-__ movl(rsi, Address(rbx,methodOopDesc::const_offset())); // get constMethodOop
+__ movptr(rsi, Address(rbx,methodOopDesc::const_offset())); // get constMethodOop
-__ leal(rsi, Address(rsi,constMethodOopDesc::codes_offset())); // get codebase
+__ lea(rsi, Address(rsi,constMethodOopDesc::codes_offset())); // get codebase
-__ pushl(rbx);                                      // save methodOop
+__ push(rbx);                                      // save methodOop
 if (ProfileInterpreter) {
 Label method_data_continue;
-__ movl(rdx, Address(rbx, in_bytes(methodOopDesc::method_data_offset())));
+__ movptr(rdx, Address(rbx, in_bytes(methodOopDesc::method_data_offset())));
-__ testl(rdx, rdx);
+__ testptr(rdx, rdx);
 __ jcc(Assembler::zero, method_data_continue);
-__ addl(rdx, in_bytes(methodDataOopDesc::data_offset()));
+__ addptr(rdx, in_bytes(methodDataOopDesc::data_offset()));
 __ bind(method_data_continue);
-__ pushl(rdx);                                      // set the mdp (method data pointer)
+__ push(rdx);                                       // set the mdp (method data pointer)
 } else {
-__ pushl(0);
+__ push(0);
 }
-__ movl(rdx, Address(rbx, methodOopDesc::constants_offset()));
+__ movptr(rdx, Address(rbx, methodOopDesc::constants_offset()));
-__ movl(rdx, Address(rdx, constantPoolOopDesc::cache_offset_in_bytes()));
+__ movptr(rdx, Address(rdx, constantPoolOopDesc::cache_offset_in_bytes()));
-__ pushl(rdx);                                      // set constant pool cache
+__ push(rdx);                                       // set constant pool cache
-__ pushl(rdi);                                      // set locals pointer
+__ push(rdi);                                       // set locals pointer
 if (native_call) {
-__ pushl(0);                                      // no bcp
+__ push(0);                                       // no bcp
 } else {
-__ pushl(rsi);                                    // set bcp
+__ push(rsi);                                     // set bcp
 }
-__ pushl(0);                                        // reserve word for pointer to expression stack bottom
+__ push(0);                                         // reserve word for pointer to expression stack bottom
-__ movl(Address(rsp, 0), rsp);                      // set expression stack bottom
+__ movptr(Address(rsp, 0), rsp);                    // set expression stack bottom
 }
 // End of helpers
 //
 // Note: We can only use this code if the getfield has been resolved
 //       and if we don't have a null-pointer exception => check for
 //       these conditions first and use slow path if necessary.
 // rbx,: method
 // rcx: receiver
-__ movl(rax, Address(rsp, wordSize));
+__ movptr(rax, Address(rsp, wordSize));
 // check if local 0 != NULL and read field
-__ testl(rax, rax);
+__ testptr(rax, rax);
 __ jcc(Assembler::zero, slow_path);
-__ movl(rdi, Address(rbx, methodOopDesc::constants_offset()));
+__ movptr(rdi, Address(rbx, methodOopDesc::constants_offset()));
 // read first instruction word and extract bytecode @ 1 and index @ 2
-__ movl(rdx, Address(rbx, methodOopDesc::const_offset()));
+__ movptr(rdx, Address(rbx, methodOopDesc::const_offset()));
 __ movl(rdx, Address(rdx, constMethodOopDesc::codes_offset()));
 // Shift codes right to get the index on the right.
 // The bytecode fetched looks like <index><0xb4><0x2a>
 __ shrl(rdx, 2*BitsPerByte);
 __ shll(rdx, exact_log2(in_words(ConstantPoolCacheEntry::size())));
-__ movl(rdi, Address(rdi, constantPoolOopDesc::cache_offset_in_bytes()));
+__ movptr(rdi, Address(rdi, constantPoolOopDesc::cache_offset_in_bytes()));
 // rax,: local 0
 // rbx,: method
 // rcx: receiver - do not destroy since it is needed for slow path!
 // rcx: scratch
 // contains Bytecode::_getfield in b1 byte.
 assert(in_words(ConstantPoolCacheEntry::size()) == 4, "adjust shift below");
 __ movl(rcx,
 Address(rdi,
 rdx,
-Address::times_4, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::indices_offset()));
+Address::times_ptr, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::indices_offset()));
 __ shrl(rcx, 2*BitsPerByte);
 __ andl(rcx, 0xFF);
 __ cmpl(rcx, Bytecodes::_getfield);
 __ jcc(Assembler::notEqual, slow_path);
 // Note: constant pool entry is not valid before bytecode is resolved
-__ movl(rcx,
+__ movptr(rcx,
 Address(rdi,
 rdx,
-Address::times_4, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::f2_offset()));
+Address::times_ptr, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::f2_offset()));
 __ movl(rdx,
 Address(rdi,
 rdx,
-Address::times_4, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::flags_offset()));
+Address::times_ptr, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::flags_offset()));
 Label notByte, notShort, notChar;
 const Address field_address (rax, rcx, Address::times_1);
 // Need to differentiate between igetfield, agetfield, bgetfield etc.
 __ jcc(Assembler::equal, okay);
 __ stop("what type is this?");
 __ bind(okay);
 #endif // ASSERT
 // All the rest are a 32 bit wordsize
-__ movl(rax, field_address);
+// This is ok for now. Since fast accessors should be going away
+__ movptr(rax, field_address);
 __ bind(xreturn_path);
 // _ireturn/_areturn
-__ popl(rdi);                              // get return address
+__ pop(rdi);                               // get return address
-__ movl(rsp, rsi);                         // set sp to sender sp
+__ mov(rsp, rsi);                          // set sp to sender sp
 __ jmp(rdi);
 // generate a vanilla interpreter entry as the slow path
 __ bind(slow_path);
 // rbx,: methodOop
 // rcx: size of parameters
 // rsi: sender sp
-__ popl(rax);                                       // get return address
+__ pop(rax);                                       // get return address
 // for natives the size of locals is zero
 // compute beginning of parameters (rdi)
-__ leal(rdi, Address(rsp, rcx, Interpreter::stackElementScale(), -wordSize));
+__ lea(rdi, Address(rsp, rcx, Interpreter::stackElementScale(), -wordSize));
 // add 2 zero-initialized slots for native calls
 // NULL result handler
-__ pushl(NULL_WORD);
+__ push((int32_t)NULL_WORD);
 // NULL oop temp (mirror or jni oop result)
-__ pushl(NULL_WORD);
+__ push((int32_t)NULL_WORD);
 if (inc_counter) __ movl(rcx, invocation_counter);  // (pre-)fetch invocation count
 // initialize fixed part of activation frame
 generate_fixed_frame(true);
 // start execution
 #ifdef ASSERT
 { Label L;
 const Address monitor_block_top (rbp,
 frame::interpreter_frame_monitor_block_top_offset * wordSize);
-__ movl(rax, monitor_block_top);
+__ movptr(rax, monitor_block_top);
-__ cmpl(rax, rsp);
+__ cmpptr(rax, rsp);
 __ jcc(Assembler::equal, L);
 __ stop("broken stack frame setup in interpreter");
 __ bind(L);
 }
 #endif
 // allocate space for parameters
 __ get_method(method);
 __ verify_oop(method);
 __ load_unsigned_word(t, Address(method, methodOopDesc::size_of_parameters_offset()));
-__ shll(t, Interpreter::logStackElementSize());
+__ shlptr(t, Interpreter::logStackElementSize());
-__ addl(t, 2*wordSize);     // allocate two more slots for JNIEnv and possible mirror
+__ addptr(t, 2*wordSize);     // allocate two more slots for JNIEnv and possible mirror
-__ subl(rsp, t);
+__ subptr(rsp, t);
-__ andl(rsp, -(StackAlignmentInBytes)); // gcc needs 16 byte aligned stacks to do XMM intrinsics
+__ andptr(rsp, -(StackAlignmentInBytes)); // gcc needs 16 byte aligned stacks to do XMM intrinsics
 // get signature handler
 { Label L;
-__ movl(t, Address(method, methodOopDesc::signature_handler_offset()));
+__ movptr(t, Address(method, methodOopDesc::signature_handler_offset()));
-__ testl(t, t);
+__ testptr(t, t);
 __ jcc(Assembler::notZero, L);
 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), method);
 __ get_method(method);
-__ movl(t, Address(method, methodOopDesc::signature_handler_offset()));
+__ movptr(t, Address(method, methodOopDesc::signature_handler_offset()));
 __ bind(L);
 }
 // call signature handler
 assert(InterpreterRuntime::SignatureHandlerGenerator::from() == rdi, "adjust this code");
 __ call(t);
 __ get_method(method);        // slow path call blows RBX on DevStudio 5.0
 // result handler is in rax,
 // set result handler
-__ movl(Address(rbp, frame::interpreter_frame_result_handler_offset*wordSize), rax);
+__ movptr(Address(rbp, frame::interpreter_frame_result_handler_offset*wordSize), rax);
 // pass mirror handle if static call
 { Label L;
 const int mirror_offset = klassOopDesc::klass_part_offset_in_bytes() + Klass::java_mirror_offset_in_bytes();
 __ movl(t, Address(method, methodOopDesc::access_flags_offset()));
 __ testl(t, JVM_ACC_STATIC);
 __ jcc(Assembler::zero, L);
 // get mirror
-__ movl(t, Address(method, methodOopDesc:: constants_offset()));
+__ movptr(t, Address(method, methodOopDesc:: constants_offset()));
-__ movl(t, Address(t, constantPoolOopDesc::pool_holder_offset_in_bytes()));
+__ movptr(t, Address(t, constantPoolOopDesc::pool_holder_offset_in_bytes()));
-__ movl(t, Address(t, mirror_offset));
+__ movptr(t, Address(t, mirror_offset));
 // copy mirror into activation frame
-__ movl(Address(rbp, frame::interpreter_frame_oop_temp_offset * wordSize), t);
+__ movptr(Address(rbp, frame::interpreter_frame_oop_temp_offset * wordSize), t);
 // pass handle to mirror
-__ leal(t, Address(rbp, frame::interpreter_frame_oop_temp_offset * wordSize));
+__ lea(t, Address(rbp, frame::interpreter_frame_oop_temp_offset * wordSize));
-__ movl(Address(rsp, wordSize), t);
+__ movptr(Address(rsp, wordSize), t);
 __ bind(L);
 }
 // get native function entry point
 { Label L;
-__ movl(rax, Address(method, methodOopDesc::native_function_offset()));
+__ movptr(rax, Address(method, methodOopDesc::native_function_offset()));
 ExternalAddress unsatisfied(SharedRuntime::native_method_throw_unsatisfied_link_error_entry());
-__ cmp32(rax, unsatisfied.addr());
+__ cmpptr(rax, unsatisfied.addr());
 __ jcc(Assembler::notEqual, L);
 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), method);
 __ get_method(method);
 __ verify_oop(method);
-__ movl(rax, Address(method, methodOopDesc::native_function_offset()));
+__ movptr(rax, Address(method, methodOopDesc::native_function_offset()));
 __ bind(L);
 }
 // pass JNIEnv
 __ get_thread(thread);
-__ leal(t, Address(thread, JavaThread::jni_environment_offset()));
+__ lea(t, Address(thread, JavaThread::jni_environment_offset()));
-__ movl(Address(rsp, 0), t);
+__ movptr(Address(rsp, 0), t);
 // set_last_Java_frame_before_call
 // It is enough that the pc()
 // points into the right code segment. It does not have to be the correct return pc.
 __ set_last_Java_frame(thread, noreg, rbp, __ pc());
 if (VM_Version::supports_sse()) {
 if (RestoreMXCSROnJNICalls) {
 __ ldmxcsr(ExternalAddress(StubRoutines::addr_mxcsr_std()));
 }
 else if (CheckJNICalls ) {
-__ call(RuntimeAddress(StubRoutines::i486::verify_mxcsr_entry()));
+__ call(RuntimeAddress(StubRoutines::x86::verify_mxcsr_entry()));
 }
 }
 // Either restore the x87 floating pointer control word after returning
 // from the JNI call or verify that it wasn't changed.
 if (CheckJNICalls) {
-__ call(RuntimeAddress(StubRoutines::i486::verify_fpu_cntrl_wrd_entry()));
+__ call(RuntimeAddress(StubRoutines::x86::verify_fpu_cntrl_wrd_entry()));
 }
 // save potential result in ST(0) & rdx:rax
 // (if result handler is the T_FLOAT or T_DOUBLE handler, result must be in ST0 -
 // the check is necessary to avoid potential Intel FPU overflow problems by saving/restoring 'empty' FPU registers)
 // change thread state
 __ get_thread(thread);
 __ movl(Address(thread, JavaThread::thread_state_offset()), _thread_in_native_trans);
 if(os::is_MP()) {
 if (UseMembar) {
-__ membar(); // Force this write out before the read below
+// Force this write out before the read below
+__ membar(Assembler::Membar_mask_bits(
+Assembler::LoadLoad | Assembler::LoadStore |
+Assembler::StoreLoad | Assembler::StoreStore));
 } else {
 // Write serialization page so VM thread can do a pseudo remote membar.
 // We use the current thread pointer to calculate a thread specific
 // offset to write to within the page. This minimizes bus traffic
 // due to cache line collision.
 // and never return here preventing us from clearing _last_native_pc down below.
 // Also can't use call_VM_leaf either as it will check to see if rsi & rdi are
 // preserved and correspond to the bcp/locals pointers. So we do a runtime call
 // by hand.
 //
-__ pushl(thread);
+__ push(thread);
 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address,
 JavaThread::check_special_condition_for_native_trans)));
 __ increment(rsp, wordSize);
 __ get_thread(thread);
 __ movl(Address(thread, JavaThread::thread_state_offset()), _thread_in_Java);
 __ reset_last_Java_frame(thread, true, true);
 // reset handle block
-__ movl(t, Address(thread, JavaThread::active_handles_offset()));
+__ movptr(t, Address(thread, JavaThread::active_handles_offset()));
-__ movl(Address(t, JNIHandleBlock::top_offset_in_bytes()), 0);
+__ movptr(Address(t, JNIHandleBlock::top_offset_in_bytes()), (int32_t)NULL_WORD);
 // If result was an oop then unbox and save it in the frame
 { Label L;
 Label no_oop, store_result;
 ExternalAddress handler(AbstractInterpreter::result_handler(T_OBJECT));
 __ cmpptr(Address(rbp, frame::interpreter_frame_result_handler_offset*wordSize),
 handler.addr());
 __ jcc(Assembler::notEqual, no_oop);
-__ cmpl(Address(rsp, 0), NULL_WORD);
+__ cmpptr(Address(rsp, 0), (int32_t)NULL_WORD);
 __ pop(ltos);
-__ testl(rax, rax);
+__ testptr(rax, rax);
 __ jcc(Assembler::zero, store_result);
 // unbox
-__ movl(rax, Address(rax, 0));
+__ movptr(rax, Address(rax, 0));
 __ bind(store_result);
-__ movl(Address(rbp, (frame::interpreter_frame_oop_temp_offset)*wordSize), rax);
+__ movptr(Address(rbp, (frame::interpreter_frame_oop_temp_offset)*wordSize), rax);
 // keep stack depth as expected by pushing oop which will eventually be discarded
 __ push(ltos);
 __ bind(no_oop);
 }
 {
 Label no_reguard;
 __ cmpl(Address(thread, JavaThread::stack_guard_state_offset()), JavaThread::stack_guard_yellow_disabled);
 __ jcc(Assembler::notEqual, no_reguard);
-__ pushad();
+__ pusha();
 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, SharedRuntime::reguard_yellow_pages)));
-__ popad();
+__ popa();
 __ bind(no_reguard);
 }
 // restore rsi to have legal interpreter frame,
 // i.e., bci == 0 <=> rsi == code_base()
 // Can't call_VM until bcp is within reasonable.
 __ get_method(method);      // method is junk from thread_in_native to now.
 __ verify_oop(method);
-__ movl(rsi, Address(method,methodOopDesc::const_offset())); // get constMethodOop
+__ movptr(rsi, Address(method,methodOopDesc::const_offset()));   // get constMethodOop
-__ leal(rsi, Address(rsi,constMethodOopDesc::codes_offset()));    // get codebase
+__ lea(rsi, Address(rsi,constMethodOopDesc::codes_offset()));    // get codebase
 // handle exceptions (exception handling will handle unlocking!)
 { Label L;
-__ cmpl(Address(thread, Thread::pending_exception_offset()), NULL_WORD);
+__ cmpptr(Address(thread, Thread::pending_exception_offset()), (int32_t)NULL_WORD);
 __ jcc(Assembler::zero, L);
 // Note: At some point we may want to unify this with the code used in call_VM_base();
 //       i.e., we should use the StubRoutines::forward_exception code. For now this
 //       doesn't work here because the rsp is not correctly set at this point.
 __ MacroAssembler::call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_pending_exception));
 { Label unlock;
 // BasicObjectLock will be first in list, since this is a synchronized method. However, need
 // to check that the object has not been unlocked by an explicit monitorexit bytecode.
 const Address monitor(rbp, frame::interpreter_frame_initial_sp_offset * wordSize - (int)sizeof(BasicObjectLock));
-__ leal(rdx, monitor);                   // address of first monitor
+__ lea(rdx, monitor);                   // address of first monitor
-__ movl(t, Address(rdx, BasicObjectLock::obj_offset_in_bytes()));
+__ movptr(t, Address(rdx, BasicObjectLock::obj_offset_in_bytes()));
-__ testl(t, t);
+__ testptr(t, t);
 __ jcc(Assembler::notZero, unlock);
 // Entry already unlocked, need to throw exception
 __ MacroAssembler::call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_illegal_monitor_state_exception));
 __ should_not_reach_here();
 //       not properly paired (was bug - gri 11/22/99).
 __ notify_method_exit(vtos, InterpreterMacroAssembler::NotifyJVMTI);
 // restore potential result in rdx:rax, call result handler to restore potential result in ST0 & handle result
 __ pop(ltos);
-__ movl(t, Address(rbp, frame::interpreter_frame_result_handler_offset*wordSize));
+__ movptr(t, Address(rbp, frame::interpreter_frame_result_handler_offset*wordSize));
 __ call(t);
 // remove activation
-__ movl(t, Address(rbp, frame::interpreter_frame_sender_sp_offset * wordSize)); // get sender sp
+__ movptr(t, Address(rbp, frame::interpreter_frame_sender_sp_offset * wordSize)); // get sender sp
 __ leave();                                // remove frame anchor
-__ popl(rdi);                              // get return address
+__ pop(rdi);                               // get return address
-__ movl(rsp, t);                           // set sp to sender sp
+__ mov(rsp, t);                            // set sp to sender sp
 __ jmp(rdi);
 if (inc_counter) {
 // Handle overflow of counter and compile method
 __ bind(invocation_counter_overflow);
 // see if we've got enough room on the stack for locals plus overhead.
 generate_stack_overflow_check();
 // get return address
-__ popl(rax);
+__ pop(rax);
 // compute beginning of parameters (rdi)
-__ leal(rdi, Address(rsp, rcx, Interpreter::stackElementScale(), -wordSize));
+__ lea(rdi, Address(rsp, rcx, Interpreter::stackElementScale(), -wordSize));
 // rdx - # of additional locals
 // allocate space for locals
 // explicitly initialize locals
 {
 Label exit, loop;
 __ testl(rdx, rdx);
 __ jcc(Assembler::lessEqual, exit);               // do nothing if rdx <= 0
 __ bind(loop);
-if (TaggedStackInterpreter) __ pushl(NULL_WORD);  // push tag
+if (TaggedStackInterpreter) {
-__ pushl(NULL_WORD);                              // initialize local variables
+__ push((int32_t)NULL_WORD);                    // push tag
+}
+__ push((int32_t)NULL_WORD);                      // initialize local variables
 __ decrement(rdx);                                // until everything initialized
 __ jcc(Assembler::greater, loop);
 __ bind(exit);
 }
 // start execution
 #ifdef ASSERT
 { Label L;
 const Address monitor_block_top (rbp,
 frame::interpreter_frame_monitor_block_top_offset * wordSize);
-__ movl(rax, monitor_block_top);
+__ movptr(rax, monitor_block_top);
-__ cmpl(rax, rsp);
+__ cmpptr(rax, rsp);
 __ jcc(Assembler::equal, L);
 __ stop("broken stack frame setup in interpreter");
 __ bind(L);
 }
 #endif
 // We have decided to profile this method in the interpreter
 __ bind(profile_method);
 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::profile_method), rsi, true);
-__ movl(rbx, Address(rbp, method_offset));   // restore methodOop
+__ movptr(rbx, Address(rbp, method_offset));   // restore methodOop
-__ movl(rax, Address(rbx, in_bytes(methodOopDesc::method_data_offset())));
+__ movptr(rax, Address(rbx, in_bytes(methodOopDesc::method_data_offset())));
-__ movl(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), rax);
+__ movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), rax);
 __ test_method_data_pointer(rax, profile_method_continue);
-__ addl(rax, in_bytes(methodDataOopDesc::data_offset()));
+__ addptr(rax, in_bytes(methodDataOopDesc::data_offset()));
-__ movl(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), rax);
+__ movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), rax);
 __ jmp(profile_method_continue);
 }
 // Handle overflow of counter and compile method
 __ bind(invocation_counter_overflow);
 generate_counter_overflow(&continue_after_compile);
 // Entry point in previous activation (i.e., if the caller was interpreted)
 Interpreter::_rethrow_exception_entry = __ pc();
 // Restore sp to interpreter_frame_last_sp even though we are going
 // to empty the expression stack for the exception processing.
-__ movl(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);
+__ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
 // rax,: exception
 // rdx: return address/pc that threw exception
 __ restore_bcp();                              // rsi points to call/send
 __ restore_locals();
 //
 // Note that we don't compare the return PC against the
 // deoptimization blob's unpack entry because of the presence of
 // adapter frames in C2.
 Label caller_not_deoptimized;
-__ movl(rdx, Address(rbp, frame::return_addr_offset * wordSize));
+__ movptr(rdx, Address(rbp, frame::return_addr_offset * wordSize));
 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::interpreter_contains), rdx);
 __ testl(rax, rax);
 __ jcc(Assembler::notZero, caller_not_deoptimized);
 // Compute size of arguments for saving when returning to deoptimized caller
 __ get_method(rax);
 __ verify_oop(rax);
 __ load_unsigned_word(rax, Address(rax, in_bytes(methodOopDesc::size_of_parameters_offset())));
-__ shll(rax, Interpreter::logStackElementSize());
+__ shlptr(rax, Interpreter::logStackElementSize());
 __ restore_locals();
-__ subl(rdi, rax);
+__ subptr(rdi, rax);
-__ addl(rdi, wordSize);
+__ addptr(rdi, wordSize);
 // Save these arguments
 __ get_thread(rcx);
 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, Deoptimization::popframe_preserve_args), rcx, rax, rdi);
 __ remove_activation(vtos, rdx,
 // no space between the top of the expression stack (current
 // last_sp) and the top of stack. Rather than force deopt to
 // maintain this kind of invariant all the time we call a small
 // fixup routine to move the mutated arguments onto the top of our
 // expression stack if necessary.
-__ movl(rax, rsp);
+__ mov(rax, rsp);
-__ movl(rbx, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));
+__ movptr(rbx, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));
 __ get_thread(rcx);
 // PC must point into interpreter here
 __ set_last_Java_frame(rcx, noreg, rbp, __ pc());
 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::popframe_move_outgoing_args), rcx, rax, rbx);
 __ get_thread(rcx);
 __ reset_last_Java_frame(rcx, true, true);
 // Restore the last_sp and null it out
-__ movl(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));
+__ movptr(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));
-__ movl(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);
+__ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
 __ restore_bcp();
 __ restore_locals();
 // The method data pointer was incremented already during
 // call profiling. We have to restore the mdp for the current bcp.
 Interpreter::_remove_activation_entry = __ pc();
 // preserve exception over this code sequence
 __ pop_ptr(rax);
 __ get_thread(rcx);
-__ movl(Address(rcx, JavaThread::vm_result_offset()), rax);
+__ movptr(Address(rcx, JavaThread::vm_result_offset()), rax);
 // remove the activation (without doing throws on illegalMonitorExceptions)
 __ remove_activation(vtos, rdx, false, true, false);
 // restore exception
 __ get_thread(rcx);
-__ movl(rax, Address(rcx, JavaThread::vm_result_offset()));
+__ movptr(rax, Address(rcx, JavaThread::vm_result_offset()));
-__ movl(Address(rcx, JavaThread::vm_result_offset()), NULL_WORD);
+__ movptr(Address(rcx, JavaThread::vm_result_offset()), (int32_t)NULL_WORD);
 __ verify_oop(rax);
 // Inbetween activations - previous activation type unknown yet
 // compute continuation point - the continuation point expects
 // the following registers set up:
 //
 // rax,: exception
 // rdx: return address/pc that threw exception
 // rsp: expression stack of caller
 // rbp,: rbp, of caller
-__ pushl(rax);                                 // save exception
+__ push(rax);                                  // save exception
-__ pushl(rdx);                                 // save return address
+__ push(rdx);                                  // save return address
 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address), rdx);
-__ movl(rbx, rax);                             // save exception handler
+__ mov(rbx, rax);                              // save exception handler
-__ popl(rdx);                                  // restore return address
+__ pop(rdx);                                   // restore return address
-__ popl(rax);                                  // restore exception
+__ pop(rax);                                   // restore exception
 // Note that an "issuing PC" is actually the next PC after the call
 __ jmp(rbx);                                   // jump to exception handler of caller
 }
 __ empty_expression_stack();
 __ empty_FPU_stack();
 __ load_earlyret_value(state);
 __ get_thread(rcx);
-__ movl(rcx, Address(rcx, JavaThread::jvmti_thread_state_offset()));
+__ movptr(rcx, Address(rcx, JavaThread::jvmti_thread_state_offset()));
 const Address cond_addr(rcx, JvmtiThreadState::earlyret_state_offset());
 // Clear the earlyret state
 __ movl(cond_addr, JvmtiThreadState::earlyret_inactive);
 #ifndef PRODUCT
 address TemplateInterpreterGenerator::generate_trace_code(TosState state) {
 address entry = __ pc();
 // prepare expression stack
-__ popl(rcx);         // pop return address so expression stack is 'pure'
+__ pop(rcx);          // pop return address so expression stack is 'pure'
 __ push(state);       // save tosca
 // pass tosca registers as arguments & call tracer
 __ call_VM(noreg, CAST_FROM_FN_PTR(address, SharedRuntime::trace_bytecode), rcx, rax, rdx);
-__ movl(rcx, rax);    // make sure return address is not destroyed by pop(state)
+__ mov(rcx, rax);     // make sure return address is not destroyed by pop(state)
 __ pop(state);        // restore tosca
 // return
 __ jmp(rcx);
 return entry;
 }
 void TemplateInterpreterGenerator::count_bytecode() {
-__ increment(ExternalAddress((address) &BytecodeCounter::_counter_value));
+__ incrementl(ExternalAddress((address) &BytecodeCounter::_counter_value));
 }
 void TemplateInterpreterGenerator::histogram_bytecode(Template* t) {
-__ increment(ExternalAddress((address) &BytecodeHistogram::_counters[t->bytecode()]));
+__ incrementl(ExternalAddress((address) &BytecodeHistogram::_counters[t->bytecode()]));
 }
 void TemplateInterpreterGenerator::histogram_bytecode_pair(Template* t) {
 __ mov32(ExternalAddress((address) &BytecodePairHistogram::_index), rbx);
 __ shrl(rbx, BytecodePairHistogram::log2_number_of_codes);
 __ orl(rbx, ((int)t->bytecode()) << BytecodePairHistogram::log2_number_of_codes);
 ExternalAddress table((address) BytecodePairHistogram::_counters);
 Address index(noreg, rbx, Address::times_4);
-__ increment(ArrayAddress(table, index));
+__ incrementl(ArrayAddress(table, index));
 }
 void TemplateInterpreterGenerator::trace_bytecode(Template* t) {
 // Call a little run-time stub to avoid blow-up for each bytecode.

Mercurial > hg > graal-compiler

comparison src/cpu/x86/vm/templateInterpreter_x86_32.cpp @ 304:dc7f315e41f7