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

comparison src/cpu/x86/vm/templateTable_x86_64.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	d1605aabd0a1
children	f8199438385b

comparison

equal deleted inserted replaced

-:fa4d1d240383
+:dc7f315e41f7
 */
 #include "incls/_precompiled.incl"
 #include "incls/_templateTable_x86_64.cpp.incl"
+#ifndef CC_INTERP
 #define __ _masm->
 // Platform-dependent initialization
 void TemplateTable::pd_initialize() {
 __ movl(rax, Address(rcx, rbx, Address::times_8, base_offset));
 __ push_i(rax);
 __ jmp(Done);
 __ bind(isOop);
-__ movq(rax, Address(rcx, rbx, Address::times_8, base_offset));
+__ movptr(rax, Address(rcx, rbx, Address::times_8, base_offset));
 __ push_ptr(rax);
 if (VerifyOops) {
 __ verify_oop(rax);
 }
 __ bind(Done);
 }
 void TemplateTable::locals_index(Register reg, int offset) {
 __ load_unsigned_byte(reg, at_bcp(offset));
-__ negq(reg);
+__ negptr(reg);
-if (TaggedStackInterpreter) __ shlq(reg, 1);  // index = index*2
+if (TaggedStackInterpreter) __ shlptr(reg, 1);  // index = index*2
 }
 void TemplateTable::iload() {
 transition(vtos, itos);
 if (RewriteFrequentPairs) {
 }
 void TemplateTable::aload() {
 transition(vtos, atos);
 locals_index(rbx);
-__ movq(rax, aaddress(rbx));
+__ movptr(rax, aaddress(rbx));
 debug_only(__ verify_local_tag(frame::TagReference, rbx));
 }
 void TemplateTable::locals_index_wide(Register reg) {
 __ movl(reg, at_bcp(2));
 __ bswapl(reg);
 __ shrl(reg, 16);
-__ negq(reg);
+__ negptr(reg);
-if (TaggedStackInterpreter) __ shlq(reg, 1);  // index = index*2
+if (TaggedStackInterpreter) __ shlptr(reg, 1);  // index = index*2
 }
 void TemplateTable::wide_iload() {
 transition(vtos, itos);
 locals_index_wide(rbx);
 }
 void TemplateTable::wide_aload() {
 transition(vtos, atos);
 locals_index_wide(rbx);
-__ movq(rax, aaddress(rbx));
+__ movptr(rax, aaddress(rbx));
 debug_only(__ verify_local_tag(frame::TagReference, rbx));
 }
 void TemplateTable::index_check(Register array, Register index) {
 // destroys rbx
 // check array
 __ null_check(array, arrayOopDesc::length_offset_in_bytes());
 // sign extend index for use by indexed load
-__ movslq(index, index);
+__ movl2ptr(index, index);
 // check index
 __ cmpl(index, Address(array, arrayOopDesc::length_offset_in_bytes()));
 if (index != rbx) {
 // ??? convention: move aberrant index into ebx for exception message
 assert(rbx != array, "different registers");
 debug_only(__ verify_local_tag(frame::TagCategory2, n));
 }
 void TemplateTable::aload(int n) {
 transition(vtos, atos);
-__ movq(rax, aaddress(n));
+__ movptr(rax, aaddress(n));
 debug_only(__ verify_local_tag(frame::TagReference, n));
 }
 void TemplateTable::aload_0() {
 transition(vtos, atos);
 void TemplateTable::astore() {
 transition(vtos, vtos);
 __ pop_ptr(rax, rdx);    // will need to pop tag too
 locals_index(rbx);
-__ movq(aaddress(rbx), rax);
+__ movptr(aaddress(rbx), rax);
 __ tag_local(rdx, rbx);  // store tag from stack, might be returnAddr
 }
 void TemplateTable::wide_istore() {
 transition(vtos, vtos);
 void TemplateTable::wide_astore() {
 transition(vtos, vtos);
 __ pop_ptr(rax, rdx);    // will need to pop tag too
 locals_index_wide(rbx);
-__ movq(aaddress(rbx), rax);
+__ movptr(aaddress(rbx), rax);
 __ tag_local(rdx, rbx);  // store tag from stack, might be returnAddr
 }
 void TemplateTable::iastore() {
 transition(itos, vtos);
 void TemplateTable::aastore() {
 Label is_null, ok_is_subtype, done;
 transition(vtos, vtos);
 // stack: ..., array, index, value
-__ movq(rax, at_tos());    // value
+__ movptr(rax, at_tos());    // value
 __ movl(rcx, at_tos_p1()); // index
-__ movq(rdx, at_tos_p2()); // array
+__ movptr(rdx, at_tos_p2()); // array
 index_check(rdx, rcx);     // kills rbx
 // do array store check - check for NULL value first
-__ testq(rax, rax);
+__ testptr(rax, rax);
 __ jcc(Assembler::zero, is_null);
 // Move subklass into rbx
 __ load_klass(rbx, rax);
 // Move superklass into rax
 __ load_klass(rax, rdx);
-__ movq(rax, Address(rax,
+__ movptr(rax, Address(rax,
 sizeof(oopDesc) +
 objArrayKlass::element_klass_offset_in_bytes()));
 // Compress array + index*oopSize + 12 into a single register.  Frees rcx.
-__ leaq(rdx, Address(rdx, rcx,
+__ lea(rdx, Address(rdx, rcx,
 UseCompressedOops ? Address::times_4 : Address::times_8,
 arrayOopDesc::base_offset_in_bytes(T_OBJECT)));
 // Generate subtype check.  Blows rcx, rdi
 // Superklass in rax.  Subklass in rbx.
 __ gen_subtype_check(rbx, ok_is_subtype);
 // object is at TOS
 __ jump(ExternalAddress(Interpreter::_throw_ArrayStoreException_entry));
 // Come here on success
 __ bind(ok_is_subtype);
-__ movq(rax, at_tos()); // Value
+__ movptr(rax, at_tos()); // Value
 __ store_heap_oop(Address(rdx, 0), rax);
 __ store_check(rdx);
 __ jmp(done);
 // Have a NULL in rax, rdx=array, ecx=index.  Store NULL at ary[idx]
 arrayOopDesc::base_offset_in_bytes(T_OBJECT)),
 rax);
 // Pop stack arguments
 __ bind(done);
-__ addq(rsp, 3 * Interpreter::stackElementSize());
+__ addptr(rsp, 3 * Interpreter::stackElementSize());
 }
 void TemplateTable::bastore() {
 transition(itos, vtos);
 __ pop_i(rbx);
 }
 void TemplateTable::astore(int n) {
 transition(vtos, vtos);
 __ pop_ptr(rax, rdx);
-__ movq(aaddress(n), rax);
+__ movptr(aaddress(n), rax);
 __ tag_local(rdx, n);
 }
 void TemplateTable::pop() {
 transition(vtos, vtos);
-__ addq(rsp, Interpreter::stackElementSize());
+__ addptr(rsp, Interpreter::stackElementSize());
 }
 void TemplateTable::pop2() {
 transition(vtos, vtos);
-__ addq(rsp, 2 * Interpreter::stackElementSize());
+__ addptr(rsp, 2 * Interpreter::stackElementSize());
 }
 void TemplateTable::dup() {
 transition(vtos, vtos);
 __ load_ptr_and_tag(0, rax, rdx);
 }
 void TemplateTable::lop2(Operation op) {
 transition(ltos, ltos);
 switch (op) {
-case add  :                    __ pop_l(rdx); __ addq (rax, rdx); break;
+case add  :                    __ pop_l(rdx); __ addptr (rax, rdx); break;
-case sub  : __ movq(rdx, rax); __ pop_l(rax); __ subq (rax, rdx); break;
+case sub  : __ mov(rdx, rax);  __ pop_l(rax); __ subptr (rax, rdx); break;
-case _and :                    __ pop_l(rdx); __ andq (rax, rdx); break;
+case _and :                    __ pop_l(rdx); __ andptr (rax, rdx); break;
-case _or  :                    __ pop_l(rdx); __ orq  (rax, rdx); break;
+case _or  :                    __ pop_l(rdx); __ orptr  (rax, rdx); break;
-case _xor :                    __ pop_l(rdx); __ xorq (rax, rdx); break;
+case _xor :                    __ pop_l(rdx); __ xorptr (rax, rdx); break;
 default : ShouldNotReachHere();
 }
 }
 void TemplateTable::idiv() {
 __ imulq(rax, rdx);
 }
 void TemplateTable::ldiv() {
 transition(ltos, ltos);
-__ movq(rcx, rax);
+__ mov(rcx, rax);
 __ pop_l(rax);
 // generate explicit div0 check
 __ testq(rcx, rcx);
 __ jump_cc(Assembler::zero,
 ExternalAddress(Interpreter::_throw_ArithmeticException_entry));
 __ corrected_idivq(rcx); // kills rbx
 }
 void TemplateTable::lrem() {
 transition(ltos, ltos);
-__ movq(rcx, rax);
+__ mov(rcx, rax);
 __ pop_l(rax);
 __ testq(rcx, rcx);
 __ jump_cc(Assembler::zero,
 ExternalAddress(Interpreter::_throw_ArithmeticException_entry));
 // Note: could xor rax and rcx and compare with (-1 ^ min_int). If
 //       they are not equal, one could do a normal division (no correction
 //       needed), which may speed up this implementation for the common case.
 //       (see also JVM spec., p.243 & p.271)
 __ corrected_idivq(rcx); // kills rbx
-__ movq(rax, rdx);
+__ mov(rax, rdx);
 }
 void TemplateTable::lshl() {
 transition(itos, ltos);
 __ movl(rcx, rax);                             // get shift count
 void TemplateTable::fop2(Operation op) {
 transition(ftos, ftos);
 switch (op) {
 case add:
 __ addss(xmm0, at_rsp());
-__ addq(rsp, Interpreter::stackElementSize());
+__ addptr(rsp, Interpreter::stackElementSize());
 break;
 case sub:
 __ movflt(xmm1, xmm0);
 __ pop_f(xmm0);
 __ subss(xmm0, xmm1);
 break;
 case mul:
 __ mulss(xmm0, at_rsp());
-__ addq(rsp, Interpreter::stackElementSize());
+__ addptr(rsp, Interpreter::stackElementSize());
 break;
 case div:
 __ movflt(xmm1, xmm0);
 __ pop_f(xmm0);
 __ divss(xmm0, xmm1);
 void TemplateTable::dop2(Operation op) {
 transition(dtos, dtos);
 switch (op) {
 case add:
 __ addsd(xmm0, at_rsp());
-__ addq(rsp, 2 * Interpreter::stackElementSize());
+__ addptr(rsp, 2 * Interpreter::stackElementSize());
 break;
 case sub:
 __ movdbl(xmm1, xmm0);
 __ pop_d(xmm0);
 __ subsd(xmm0, xmm1);
 break;
 case mul:
 __ mulsd(xmm0, at_rsp());
-__ addq(rsp, 2 * Interpreter::stackElementSize());
+__ addptr(rsp, 2 * Interpreter::stackElementSize());
 break;
 case div:
 __ movdbl(xmm1, xmm0);
 __ pop_d(xmm0);
 __ divsd(xmm0, xmm1);
 __ bswapl(rdx);
 if (!is_wide) {
 __ sarl(rdx, 16);
 }
-__ movslq(rdx, rdx);
+__ movl2ptr(rdx, rdx);
 // Handle all the JSR stuff here, then exit.
 // It's much shorter and cleaner than intermingling with the non-JSR
 // normal-branch stuff occuring below.
 if (is_jsr) {
 // Pre-load the next target bytecode into rbx
 __ load_unsigned_byte(rbx, Address(r13, rdx, Address::times_1, 0));
 // compute return address as bci in rax
-__ leaq(rax, at_bcp((is_wide ? 5 : 3) -
+__ lea(rax, at_bcp((is_wide ? 5 : 3) -
 in_bytes(constMethodOopDesc::codes_offset())));
-__ subq(rax, Address(rcx, methodOopDesc::const_offset()));
+__ subptr(rax, Address(rcx, methodOopDesc::const_offset()));
 // Adjust the bcp in r13 by the displacement in rdx
-__ addq(r13, rdx);
+__ addptr(r13, rdx);
 // jsr returns atos that is not an oop
 __ push_i(rax);
 __ dispatch_only(vtos);
 return;
 }
 // Normal (non-jsr) branch handling
 // Adjust the bcp in r13 by the displacement in rdx
-__ addq(r13, rdx);
+__ addptr(r13, rdx);
 assert(UseLoopCounter || !UseOnStackReplacement,
 "on-stack-replacement requires loop counters");
 Label backedge_counter_overflow;
 Label profile_method;
 __ bind(profile_method);
 __ call_VM(noreg,
 CAST_FROM_FN_PTR(address,
 InterpreterRuntime::profile_method), r13);
 __ load_unsigned_byte(rbx, Address(r13, 0));  // restore target bytecode
-__ movq(rcx, Address(rbp, method_offset));
+__ movptr(rcx, Address(rbp, method_offset));
-__ movq(rcx, Address(rcx,
+__ movptr(rcx, Address(rcx,
 in_bytes(methodOopDesc::method_data_offset())));
-__ movq(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize),
+__ movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize),
 rcx);
 __ test_method_data_pointer(rcx, dispatch);
 // offset non-null mdp by MDO::data_offset() + IR::profile_method()
-__ addq(rcx, in_bytes(methodDataOopDesc::data_offset()));
+__ addptr(rcx, in_bytes(methodDataOopDesc::data_offset()));
-__ addq(rcx, rax);
+__ addptr(rcx, rax);
-__ movq(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize),
+__ movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize),
 rcx);
 __ jmp(dispatch);
 }
 if (UseOnStackReplacement) {
 // invocation counter overflow
 __ bind(backedge_counter_overflow);
-__ negq(rdx);
+__ negptr(rdx);
-__ addq(rdx, r13); // branch bcp
+__ addptr(rdx, r13); // branch bcp
 // IcoResult frequency_counter_overflow([JavaThread*], address branch_bcp)
 __ call_VM(noreg,
 CAST_FROM_FN_PTR(address,
 InterpreterRuntime::frequency_counter_overflow),
 rdx);
 // rax: osr nmethod (osr ok) or NULL (osr not possible)
 // ebx: target bytecode
 // rdx: scratch
 // r14: locals pointer
 // r13: bcp
-__ testq(rax, rax);                        // test result
+__ testptr(rax, rax);                        // test result
 __ jcc(Assembler::zero, dispatch);         // no osr if null
 // nmethod may have been invalidated (VM may block upon call_VM return)
 __ movl(rcx, Address(rax, nmethod::entry_bci_offset()));
 __ cmpl(rcx, InvalidOSREntryBci);
 __ jcc(Assembler::equal, dispatch);
 // We have the address of an on stack replacement routine in eax
 // We need to prepare to execute the OSR method. First we must
 // migrate the locals and monitors off of the stack.
-__ movq(r13, rax);                             // save the nmethod
+__ mov(r13, rax);                             // save the nmethod
 call_VM(noreg, CAST_FROM_FN_PTR(address, SharedRuntime::OSR_migration_begin));
 // eax is OSR buffer, move it to expected parameter location
-__ movq(j_rarg0, rax);
+__ mov(j_rarg0, rax);
 // We use j_rarg definitions here so that registers don't conflict as parameter
 // registers change across platforms as we are in the midst of a calling
 // sequence to the OSR nmethod and we don't want collision. These are NOT parameters.
 const Register retaddr = j_rarg2;
 const Register sender_sp = j_rarg1;
 // pop the interpreter frame
-__ movq(sender_sp, Address(rbp, frame::interpreter_frame_sender_sp_offset * wordSize)); // get sender sp
+__ movptr(sender_sp, Address(rbp, frame::interpreter_frame_sender_sp_offset * wordSize)); // get sender sp
 __ leave();                                // remove frame anchor
-__ popq(retaddr);                            // get return address
+__ pop(retaddr);                           // get return address
-__ movq(rsp, sender_sp);                   // set sp to sender sp
+__ mov(rsp, sender_sp);                   // set sp to sender sp
 // Ensure compiled code always sees stack at proper alignment
-__ andq(rsp, -(StackAlignmentInBytes));
+__ andptr(rsp, -(StackAlignmentInBytes));
 // unlike x86 we need no specialized return from compiled code
 // to the interpreter or the call stub.
 // push the return address
-__ pushq(retaddr);
+__ push(retaddr);
 // and begin the OSR nmethod
 __ jmp(Address(r13, nmethod::osr_entry_point_offset()));
 }
 }
 void TemplateTable::if_nullcmp(Condition cc) {
 transition(atos, vtos);
 // assume branch is more often taken than not (loops use backward branches)
 Label not_taken;
-__ testq(rax, rax);
+__ testptr(rax, rax);
 __ jcc(j_not(cc), not_taken);
 branch(false, false);
 __ bind(not_taken);
 __ profile_not_taken_branch(rax);
 }
 void TemplateTable::if_acmp(Condition cc) {
 transition(atos, vtos);
 // assume branch is more often taken than not (loops use backward branches)
 Label not_taken;
 __ pop_ptr(rdx);
-__ cmpq(rdx, rax);
+__ cmpptr(rdx, rax);
 __ jcc(j_not(cc), not_taken);
 branch(false, false);
 __ bind(not_taken);
 __ profile_not_taken_branch(rax);
 }
 void TemplateTable::ret() {
 transition(vtos, vtos);
 locals_index(rbx);
-__ movq(rbx, aaddress(rbx)); // get return bci, compute return bcp
+__ movslq(rbx, iaddress(rbx)); // get return bci, compute return bcp
 __ profile_ret(rbx, rcx);
 __ get_method(rax);
-__ movq(r13, Address(rax, methodOopDesc::const_offset()));
+__ movptr(r13, Address(rax, methodOopDesc::const_offset()));
-__ leaq(r13, Address(r13, rbx, Address::times_1,
+__ lea(r13, Address(r13, rbx, Address::times_1,
 constMethodOopDesc::codes_offset()));
 __ dispatch_next(vtos);
 }
 void TemplateTable::wide_ret() {
 transition(vtos, vtos);
 locals_index_wide(rbx);
-__ movq(rbx, aaddress(rbx)); // get return bci, compute return bcp
+__ movptr(rbx, aaddress(rbx)); // get return bci, compute return bcp
 __ profile_ret(rbx, rcx);
 __ get_method(rax);
-__ movq(r13, Address(rax, methodOopDesc::const_offset()));
+__ movptr(r13, Address(rax, methodOopDesc::const_offset()));
-__ leaq(r13, Address(r13, rbx, Address::times_1, constMethodOopDesc::codes_offset()));
+__ lea(r13, Address(r13, rbx, Address::times_1, constMethodOopDesc::codes_offset()));
 __ dispatch_next(vtos);
 }
 void TemplateTable::tableswitch() {
 Label default_case, continue_execution;
 transition(itos, vtos);
 // align r13
-__ leaq(rbx, at_bcp(BytesPerInt));
+__ lea(rbx, at_bcp(BytesPerInt));
-__ andq(rbx, -BytesPerInt);
+__ andptr(rbx, -BytesPerInt);
 // load lo & hi
 __ movl(rcx, Address(rbx, BytesPerInt));
 __ movl(rdx, Address(rbx, 2 * BytesPerInt));
 __ bswapl(rcx);
 __ bswapl(rdx);
 __ movl(rdx, Address(rbx, rax, Address::times_4, 3 * BytesPerInt));
 __ profile_switch_case(rax, rbx, rcx);
 // continue execution
 __ bind(continue_execution);
 __ bswapl(rdx);
-__ movslq(rdx, rdx);
+__ movl2ptr(rdx, rdx);
 __ load_unsigned_byte(rbx, Address(r13, rdx, Address::times_1));
-__ addq(r13, rdx);
+__ addptr(r13, rdx);
 __ dispatch_only(vtos);
 // handle default
 __ bind(default_case);
 __ profile_switch_default(rax);
 __ movl(rdx, Address(rbx, 0));
 transition(itos, vtos);
 Label loop_entry, loop, found, continue_execution;
 // bswap rax so we can avoid bswapping the table entries
 __ bswapl(rax);
 // align r13
-__ leaq(rbx, at_bcp(BytesPerInt)); // btw: should be able to get rid of
+__ lea(rbx, at_bcp(BytesPerInt)); // btw: should be able to get rid of
 // this instruction (change offsets
 // below)
-__ andq(rbx, -BytesPerInt);
+__ andptr(rbx, -BytesPerInt);
 // set counter
 __ movl(rcx, Address(rbx, BytesPerInt));
 __ bswapl(rcx);
 __ jmpb(loop_entry);
 // table search
 __ movl(rdx, Address(rbx, rcx, Address::times_8, 3 * BytesPerInt));
 __ profile_switch_case(rcx, rax, rbx);
 // continue execution
 __ bind(continue_execution);
 __ bswapl(rdx);
-__ movslq(rdx, rdx);
+__ movl2ptr(rdx, rdx);
 __ load_unsigned_byte(rbx, Address(r13, rdx, Address::times_1));
-__ addq(r13, rdx);
+__ addptr(r13, rdx);
 __ dispatch_only(vtos);
 }
 void TemplateTable::fast_binaryswitch() {
 transition(itos, vtos);
 const Register j     = rdx;
 const Register h     = rdi;
 const Register temp  = rsi;
 // Find array start
-__ leaq(array, at_bcp(3 * BytesPerInt)); // btw: should be able to
+__ lea(array, at_bcp(3 * BytesPerInt)); // btw: should be able to
 // get rid of this
 // instruction (change
 // offsets below)
-__ andq(array, -BytesPerInt);
+__ andptr(array, -BytesPerInt);
 // Initialize i & j
 __ xorl(i, i);                            // i = 0;
 __ movl(j, Address(array, -BytesPerInt)); // j = length(array);
 // entry found -> j = offset
 __ movl(j , Address(array, i, Address::times_8, BytesPerInt));
 __ profile_switch_case(i, key, array);
 __ bswapl(j);
-__ movslq(j, j);
+__ movl2ptr(j, j);
 __ load_unsigned_byte(rbx, Address(r13, j, Address::times_1));
-__ addq(r13, j);
+__ addptr(r13, j);
 __ dispatch_only(vtos);
 // default case -> j = default offset
 __ bind(default_case);
 __ profile_switch_default(i);
 __ movl(j, Address(array, -2 * BytesPerInt));
 __ bswapl(j);
-__ movslq(j, j);
+__ movl2ptr(j, j);
 __ load_unsigned_byte(rbx, Address(r13, j, Address::times_1));
-__ addq(r13, j);
+__ addptr(r13, j);
 __ dispatch_only(vtos);
 }
 void TemplateTable::_return(TosState state) {
 assert(_desc->calls_vm(),
 "inconsistent calls_vm information"); // call in remove_activation
 if (_desc->bytecode() == Bytecodes::_return_register_finalizer) {
 assert(state == vtos, "only valid state");
-__ movq(c_rarg1, aaddress(0));
+__ movptr(c_rarg1, aaddress(0));
 __ load_klass(rdi, c_rarg1);
 __ movl(rdi, Address(rdi, Klass::access_flags_offset_in_bytes() + sizeof(oopDesc)));
 __ testl(rdi, JVM_ACC_HAS_FINALIZER);
 Label skip_register_finalizer;
 __ jcc(Assembler::zero, skip_register_finalizer);
 bool is_static = false) {
 assert_different_registers(cache, index, flags, off);
 ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset();
 // Field offset
-__ movq(off, Address(cache, index, Address::times_8,
+__ movptr(off, Address(cache, index, Address::times_8,
 in_bytes(cp_base_offset +
 ConstantPoolCacheEntry::f2_offset())));
 // Flags
 __ movl(flags, Address(cache, index, Address::times_8,
 in_bytes(cp_base_offset +
 ConstantPoolCacheEntry::flags_offset())));
 // klass overwrite register
 if (is_static) {
-__ movq(obj, Address(cache, index, Address::times_8,
+__ movptr(obj, Address(cache, index, Address::times_8,
 in_bytes(cp_base_offset +
 ConstantPoolCacheEntry::f1_offset())));
 }
 }
 void TemplateTable::load_invoke_cp_cache_entry(int byte_no,
 Register method,
 ConstantPoolCacheEntry::f2_offset());
 resolve_cache_and_index(byte_no, cache, index);
 assert(wordSize == 8, "adjust code below");
-__ movq(method, Address(cache, index, Address::times_8, method_offset));
+__ movptr(method, Address(cache, index, Address::times_8, method_offset));
 if (itable_index != noreg) {
-__ movq(itable_index,
+__ movptr(itable_index,
 Address(cache, index, Address::times_8, index_offset));
 }
 __ movl(flags , Address(cache, index, Address::times_8, flags_offset));
 }
 __ jcc(Assembler::zero, L1);
 __ get_cache_and_index_at_bcp(c_rarg2, c_rarg3, 1);
 // cache entry pointer
-__ addq(c_rarg2, in_bytes(constantPoolCacheOopDesc::base_offset()));
+__ addptr(c_rarg2, in_bytes(constantPoolCacheOopDesc::base_offset()));
 __ shll(c_rarg3, LogBytesPerWord);
-__ addq(c_rarg2, c_rarg3);
+__ addptr(c_rarg2, c_rarg3);
 if (is_static) {
 __ xorl(c_rarg1, c_rarg1); // NULL object reference
 } else {
-__ movq(c_rarg1, at_tos()); // get object pointer without popping it
+__ movptr(c_rarg1, at_tos()); // get object pointer without popping it
 __ verify_oop(c_rarg1);
 }
 // c_rarg1: object pointer or NULL
 // c_rarg2: cache entry pointer
 // c_rarg3: jvalue object on the stack
 ConstantPoolCacheEntry::flags_offset())));
 __ shrl(c_rarg3, ConstantPoolCacheEntry::tosBits);
 // Make sure we don't need to mask rcx for tosBits after the
 // above shift
 ConstantPoolCacheEntry::verify_tosBits();
-__ movq(c_rarg1, at_tos_p1());  // initially assume a one word jvalue
+__ movptr(c_rarg1, at_tos_p1());  // initially assume a one word jvalue
 __ cmpl(c_rarg3, ltos);
-__ cmovq(Assembler::equal,
+__ cmovptr(Assembler::equal,
 c_rarg1, at_tos_p2()); // ltos (two word jvalue)
 __ cmpl(c_rarg3, dtos);
-__ cmovq(Assembler::equal,
+__ cmovptr(Assembler::equal,
 c_rarg1, at_tos_p2()); // dtos (two word jvalue)
 }
 // cache entry pointer
-__ addq(c_rarg2, in_bytes(cp_base_offset));
+__ addptr(c_rarg2, in_bytes(cp_base_offset));
 __ shll(rscratch1, LogBytesPerWord);
-__ addq(c_rarg2, rscratch1);
+__ addptr(c_rarg2, rscratch1);
 // object (tos)
-__ movq(c_rarg3, rsp);
+__ mov(c_rarg3, rsp);
 // c_rarg1: object pointer set up above (NULL if static)
 // c_rarg2: cache entry pointer
 // c_rarg3: jvalue object on the stack
 __ call_VM(noreg,
 CAST_FROM_FN_PTR(address,
 __ testl(c_rarg3, c_rarg3);
 __ jcc(Assembler::zero, L2);
 __ pop_ptr(rbx);                  // copy the object pointer from tos
 __ verify_oop(rbx);
 __ push_ptr(rbx);                 // put the object pointer back on tos
-__ subq(rsp, sizeof(jvalue));  // add space for a jvalue object
+__ subptr(rsp, sizeof(jvalue));  // add space for a jvalue object
-__ movq(c_rarg3, rsp);
+__ mov(c_rarg3, rsp);
 const Address field(c_rarg3, 0);
 switch (bytecode()) {          // load values into the jvalue object
 case Bytecodes::_fast_aputfield: __ movq(field, rax); break;
 case Bytecodes::_fast_lputfield: __ movq(field, rax); break;
 ShouldNotReachHere();
 }
 // Save rax because call_VM() will clobber it, then use it for
 // JVMTI purposes
-__ pushq(rax);
+__ push(rax);
 // access constant pool cache entry
 __ get_cache_entry_pointer_at_bcp(c_rarg2, rax, 1);
 __ verify_oop(rbx);
 // rbx: object pointer copied above
 // c_rarg2: cache entry pointer
 // c_rarg3: jvalue object on the stack
 __ call_VM(noreg,
 CAST_FROM_FN_PTR(address,
 InterpreterRuntime::post_field_modification),
 rbx, c_rarg2, c_rarg3);
-__ popq(rax);     // restore lower value
+__ pop(rax);     // restore lower value
-__ addq(rsp, sizeof(jvalue));  // release jvalue object space
+__ addptr(rsp, sizeof(jvalue));  // release jvalue object space
 __ bind(L2);
 }
 }
 void TemplateTable::fast_storefield(TosState state) {
 __ movl(rdx, Address(rcx, rbx, Address::times_8,
 in_bytes(base +
 ConstantPoolCacheEntry::flags_offset())));
 // replace index with field offset from cache entry
-__ movq(rbx, Address(rcx, rbx, Address::times_8,
+__ movptr(rbx, Address(rcx, rbx, Address::times_8,
 in_bytes(base + ConstantPoolCacheEntry::f2_offset())));
 // [jk] not needed currently
 // volatile_barrier(Assembler::Membar_mask_bits(Assembler::LoadStore |
 //                                              Assembler::StoreStore));
 __ testl(rcx, rcx);
 __ jcc(Assembler::zero, L1);
 // access constant pool cache entry
 __ get_cache_entry_pointer_at_bcp(c_rarg2, rcx, 1);
 __ verify_oop(rax);
-__ movq(r12, rax);  // save object pointer before call_VM() clobbers it
+__ mov(r12, rax);  // save object pointer before call_VM() clobbers it
-__ movq(c_rarg1, rax);
+__ mov(c_rarg1, rax);
 // c_rarg1: object pointer copied above
 // c_rarg2: cache entry pointer
 __ call_VM(noreg,
 CAST_FROM_FN_PTR(address,
 InterpreterRuntime::post_field_access),
 c_rarg1, c_rarg2);
-__ movq(rax, r12); // restore object pointer
+__ mov(rax, r12); // restore object pointer
 __ reinit_heapbase();
 __ bind(L1);
 }
 // access constant pool cache
 //                        in_bytes(constantPoolCacheOopDesc::base_offset() +
 //                                 ConstantPoolCacheEntry::flags_offset())));
 //   __ shrl(rdx, ConstantPoolCacheEntry::volatileField);
 //   __ andl(rdx, 0x1);
 // }
-__ movq(rbx, Address(rcx, rbx, Address::times_8,
+__ movptr(rbx, Address(rcx, rbx, Address::times_8,
 in_bytes(constantPoolCacheOopDesc::base_offset() +
 ConstantPoolCacheEntry::f2_offset())));
 // rax: object
 __ verify_oop(rax);
 __ null_check(rax);
 Address field(rax, rbx, Address::times_1);
 void TemplateTable::fast_xaccess(TosState state) {
 transition(vtos, state);
 // get receiver
-__ movq(rax, aaddress(0));
+__ movptr(rax, aaddress(0));
 debug_only(__ verify_local_tag(frame::TagReference, 0));
 // access constant pool cache
 __ get_cache_and_index_at_bcp(rcx, rdx, 2);
-__ movq(rbx,
+__ movptr(rbx,
 Address(rcx, rdx, Address::times_8,
 in_bytes(constantPoolCacheOopDesc::base_offset() +
 ConstantPoolCacheEntry::f2_offset())));
 // make sure exception is reported in correct bcp range (getfield is
 // next instruction)
-__ incrementq(r13);
+__ increment(r13);
 __ null_check(rax);
 switch (state) {
 case itos:
 __ movl(rax, Address(rax, rbx, Address::times_1));
 break;
 //   __ jcc(Assembler::zero, notVolatile);
 //   __ membar(Assembler::LoadLoad);
 //   __ bind(notVolatile);
 // }
-__ decrementq(r13);
+__ decrement(r13);
 }
 //-----------------------------------------------------------------------------
 // load receiver if needed (note: no return address pushed yet)
 if (load_receiver) {
 __ movl(recv, flags);
 __ andl(recv, 0xFF);
 if (TaggedStackInterpreter) __ shll(recv, 1);  // index*2
-__ movq(recv, Address(rsp, recv, Address::times_8,
+__ movptr(recv, Address(rsp, recv, Address::times_8,
 -Interpreter::expr_offset_in_bytes(1)));
 __ verify_oop(recv);
 }
 // do null check if needed
 // load return address
 {
 ExternalAddress return_5((address)Interpreter::return_5_addrs_by_index_table());
 ExternalAddress return_3((address)Interpreter::return_3_addrs_by_index_table());
 __ lea(rscratch1, (is_invokeinterface ? return_5 : return_3));
-__ movq(flags, Address(rscratch1, flags, Address::times_8));
+__ movptr(flags, Address(rscratch1, flags, Address::times_8));
 }
 // push return address
-__ pushq(flags);
+__ push(flags);
 // Restore flag field from the constant pool cache, and restore esi
 // for later null checks.  r13 is the bytecode pointer
 if (save_flags) {
 __ movl(flags, r13);
 // get target methodOop & entry point
 const int base = instanceKlass::vtable_start_offset() * wordSize;
 assert(vtableEntry::size() * wordSize == 8,
 "adjust the scaling in the code below");
-__ movq(method, Address(rax, index,
+__ movptr(method, Address(rax, index,
 Address::times_8,
 base + vtableEntry::method_offset_in_bytes()));
-__ movq(rdx, Address(method, methodOopDesc::interpreter_entry_offset()));
+__ movptr(rdx, Address(method, methodOopDesc::interpreter_entry_offset()));
 __ jump_from_interpreted(method, rdx);
 }
 void TemplateTable::invokevirtual(int byte_no) {
 __ verify_oop(rdx);
 // profile this call
 __ profile_virtual_call(rdx, r13, r14);
-__ movq(r14, rdx); // Save klassOop in r14
+__ mov(r14, rdx); // Save klassOop in r14
 // Compute start of first itableOffsetEntry (which is at the end of
 // the vtable)
 const int base = instanceKlass::vtable_start_offset() * wordSize;
 // Get length of vtable
 assert(vtableEntry::size() * wordSize == 8,
 "adjust the scaling in the code below");
 __ movl(r13, Address(rdx,
 instanceKlass::vtable_length_offset() * wordSize));
-__ leaq(rdx, Address(rdx, r13, Address::times_8, base));
+__ lea(rdx, Address(rdx, r13, Address::times_8, base));
 if (HeapWordsPerLong > 1) {
 // Round up to align_object_offset boundary
-__ round_to_q(rdx, BytesPerLong);
+__ round_to(rdx, BytesPerLong);
 }
 Label entry, search, interface_ok;
 __ jmpb(entry);
 __ bind(search);
-__ addq(rdx, itableOffsetEntry::size() * wordSize);
+__ addptr(rdx, itableOffsetEntry::size() * wordSize);
 __ bind(entry);
 // Check that the entry is non-null.  A null entry means that the
 // receiver class doesn't implement the interface, and wasn't the
 // same as the receiver class checked when the interface was
 // resolved.
-__ pushq(rdx);
+__ push(rdx);
-__ movq(rdx, Address(rdx, itableOffsetEntry::interface_offset_in_bytes()));
+__ movptr(rdx, Address(rdx, itableOffsetEntry::interface_offset_in_bytes()));
-__ testq(rdx, rdx);
+__ testptr(rdx, rdx);
 __ jcc(Assembler::notZero, interface_ok);
 // throw exception
-__ popq(rdx); // pop saved register first.
+__ pop(rdx); // pop saved register first.
-__ popq(rbx); // pop return address (pushed by prepare_invoke)
+__ pop(rbx); // pop return address (pushed by prepare_invoke)
 __ restore_bcp(); // r13 must be correct for exception handler (was
 // destroyed)
 __ restore_locals(); // make sure locals pointer is correct as well
 // (was destroyed)
 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
 InterpreterRuntime::throw_IncompatibleClassChangeError));
 // the call_VM checks for exception, so we should never return here.
 __ should_not_reach_here();
 __ bind(interface_ok);
-__ popq(rdx);
+__ pop(rdx);
-__ cmpq(rax, Address(rdx, itableOffsetEntry::interface_offset_in_bytes()));
+__ cmpptr(rax, Address(rdx, itableOffsetEntry::interface_offset_in_bytes()));
 __ jcc(Assembler::notEqual, search);
 __ movl(rdx, Address(rdx, itableOffsetEntry::offset_offset_in_bytes()));
-__ addq(rdx, r14); // Add offset to klassOop
+__ addptr(rdx, r14); // Add offset to klassOop
 assert(itableMethodEntry::size() * wordSize == 8,
 "adjust the scaling in the code below");
-__ movq(rbx, Address(rdx, rbx, Address::times_8));
+__ movptr(rbx, Address(rdx, rbx, Address::times_8));
 // rbx: methodOop to call
 // rcx: receiver
 // Check for abstract method error
 // Note: This should be done more efficiently via a
 // throw_abstract_method_error interpreter entry point and a
 // conditional jump to it in case of a null method.
 {
 Label L;
-__ testq(rbx, rbx);
+__ testptr(rbx, rbx);
 __ jcc(Assembler::notZero, L);
 // throw exception
 // note: must restore interpreter registers to canonical
 //       state for exception handling to work correctly!
-__ popq(rbx);  // pop return address (pushed by prepare_invoke)
+__ pop(rbx);  // pop return address (pushed by prepare_invoke)
 __ restore_bcp(); // r13 must be correct for exception handler
 // (was destroyed)
 __ restore_locals(); // make sure locals pointer is correct as
 // well (was destroyed)
 __ call_VM(noreg,
 // the call_VM checks for exception, so we should never return here.
 __ should_not_reach_here();
 __ bind(L);
 }
-__ movq(rcx, Address(rbx, methodOopDesc::interpreter_entry_offset()));
+__ movptr(rcx, Address(rbx, methodOopDesc::interpreter_entry_offset()));
 // do the call
 // rcx: receiver
 // rbx: methodOop
 __ jump_from_interpreted(rbx, rdx);
 ExternalAddress top((address)Universe::heap()->top_addr());
 ExternalAddress end((address)Universe::heap()->end_addr());
 __ get_cpool_and_tags(rsi, rax);
 // get instanceKlass
-__ movq(rsi, Address(rsi, rdx,
+__ movptr(rsi, Address(rsi, rdx,
 Address::times_8, sizeof(constantPoolOopDesc)));
 // make sure the class we're about to instantiate has been
 // resolved. Note: slow_case does a pop of stack, which is why we
 // loaded class/pushed above
 const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize;
 const bool allow_shared_alloc =
 Universe::heap()->supports_inline_contig_alloc() && !CMSIncrementalMode;
 if (UseTLAB) {
-__ movq(rax, Address(r15_thread, in_bytes(JavaThread::tlab_top_offset())));
+__ movptr(rax, Address(r15_thread, in_bytes(JavaThread::tlab_top_offset())));
-__ leaq(rbx, Address(rax, rdx, Address::times_1));
+__ lea(rbx, Address(rax, rdx, Address::times_1));
-__ cmpq(rbx, Address(r15_thread, in_bytes(JavaThread::tlab_end_offset())));
+__ cmpptr(rbx, Address(r15_thread, in_bytes(JavaThread::tlab_end_offset())));
 __ jcc(Assembler::above, allow_shared_alloc ? allocate_shared : slow_case);
-__ movq(Address(r15_thread, in_bytes(JavaThread::tlab_top_offset())), rbx);
+__ movptr(Address(r15_thread, in_bytes(JavaThread::tlab_top_offset())), rbx);
 if (ZeroTLAB) {
 // the fields have been already cleared
 __ jmp(initialize_header);
 } else {
 // initialize both the header and fields
 const Register RtopAddr = rscratch1;
 const Register RendAddr = rscratch2;
 __ lea(RtopAddr, top);
 __ lea(RendAddr, end);
-__ movq(rax, Address(RtopAddr, 0));
+__ movptr(rax, Address(RtopAddr, 0));
 // For retries rax gets set by cmpxchgq
 Label retry;
 __ bind(retry);
-__ leaq(rbx, Address(rax, rdx, Address::times_1));
+__ lea(rbx, Address(rax, rdx, Address::times_1));
-__ cmpq(rbx, Address(RendAddr, 0));
+__ cmpptr(rbx, Address(RendAddr, 0));
 __ jcc(Assembler::above, slow_case);
 // Compare rax with the top addr, and if still equal, store the new
 // top addr in rbx at the address of the top addr pointer. Sets ZF if was
 // equal, and clears it otherwise. Use lock prefix for atomicity on MPs.
 // rbx: object end
 // rdx: instance size in bytes
 if (os::is_MP()) {
 __ lock();
 }
-__ cmpxchgq(rbx, Address(RtopAddr, 0));
+__ cmpxchgptr(rbx, Address(RtopAddr, 0));
 // if someone beat us on the allocation, try again, otherwise continue
 __ jcc(Assembler::notEqual, retry);
 }
 }
 // initialize object header only.
 __ bind(initialize_header);
 if (UseBiasedLocking) {
-__ movq(rscratch1, Address(rsi, Klass::prototype_header_offset_in_bytes() + klassOopDesc::klass_part_offset_in_bytes()));
+__ movptr(rscratch1, Address(rsi, Klass::prototype_header_offset_in_bytes() + klassOopDesc::klass_part_offset_in_bytes()));
-__ movq(Address(rax, oopDesc::mark_offset_in_bytes()), rscratch1);
+__ movptr(Address(rax, oopDesc::mark_offset_in_bytes()), rscratch1);
 } else {
 __ movptr(Address(rax, oopDesc::mark_offset_in_bytes()),
 (intptr_t) markOopDesc::prototype()); // header (address 0x1)
 }
 __ xorl(rcx, rcx); // use zero reg to clear memory (shorter code)
 }
 void TemplateTable::checkcast() {
 transition(atos, atos);
 Label done, is_null, ok_is_subtype, quicked, resolved;
-__ testq(rax, rax); // object is in rax
+__ testptr(rax, rax); // object is in rax
 __ jcc(Assembler::zero, is_null);
 // Get cpool & tags index
 __ get_cpool_and_tags(rcx, rdx); // rcx=cpool, rdx=tags array
 __ get_unsigned_2_byte_index_at_bcp(rbx, 1); // rbx=index
 Address::times_1,
 typeArrayOopDesc::header_size(T_BYTE) * wordSize),
 JVM_CONSTANT_Class);
 __ jcc(Assembler::equal, quicked);
 __ push(atos); // save receiver for result, and for GC
-__ movq(r12, rcx); // save rcx XXX
+__ mov(r12, rcx); // save rcx XXX
 call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc));
 __ movq(rcx, r12); // restore rcx XXX
 __ reinit_heapbase();
 __ pop_ptr(rdx); // restore receiver
 __ jmpb(resolved);
 // Get superklass in rax and subklass in rbx
 __ bind(quicked);
-__ movq(rdx, rax); // Save object in rdx; rax needed for subtype check
+__ mov(rdx, rax); // Save object in rdx; rax needed for subtype check
-__ movq(rax, Address(rcx, rbx,
+__ movptr(rax, Address(rcx, rbx,
 Address::times_8, sizeof(constantPoolOopDesc)));
 __ bind(resolved);
 __ load_klass(rbx, rdx);
 // object is at TOS
 __ jump(ExternalAddress(Interpreter::_throw_ClassCastException_entry));
 // Come here on success
 __ bind(ok_is_subtype);
-__ movq(rax, rdx); // Restore object in rdx
+__ mov(rax, rdx); // Restore object in rdx
 // Collect counts on whether this check-cast sees NULLs a lot or not.
 if (ProfileInterpreter) {
 __ jmp(done);
 __ bind(is_null);
 }
 void TemplateTable::instanceof() {
 transition(atos, itos);
 Label done, is_null, ok_is_subtype, quicked, resolved;
-__ testq(rax, rax);
+__ testptr(rax, rax);
 __ jcc(Assembler::zero, is_null);
 // Get cpool & tags index
 __ get_cpool_and_tags(rcx, rdx); // rcx=cpool, rdx=tags array
 __ get_unsigned_2_byte_index_at_bcp(rbx, 1); // rbx=index
 typeArrayOopDesc::header_size(T_BYTE) * wordSize),
 JVM_CONSTANT_Class);
 __ jcc(Assembler::equal, quicked);
 __ push(atos); // save receiver for result, and for GC
-__ movq(r12, rcx); // save rcx
+__ mov(r12, rcx); // save rcx
 call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc));
 __ movq(rcx, r12); // restore rcx
 __ reinit_heapbase();
 __ pop_ptr(rdx); // restore receiver
 __ load_klass(rdx, rdx);
 __ jmpb(resolved);
 // Get superklass in rax and subklass in rdx
 __ bind(quicked);
 __ load_klass(rdx, rax);
-__ movq(rax, Address(rcx, rbx,
+__ movptr(rax, Address(rcx, rbx,
 Address::times_8, sizeof(constantPoolOopDesc)));
 __ bind(resolved);
 // Generate subtype check.  Blows rcx, rdi
 // Superklass in rax.  Subklass in rdx.
 __ get_method(c_rarg1);
 __ call_VM(noreg,
 CAST_FROM_FN_PTR(address,
 InterpreterRuntime::get_original_bytecode_at),
 c_rarg1, r13);
-__ movq(rbx, rax);
+__ mov(rbx, rax);
 // post the breakpoint event
 __ get_method(c_rarg1);
 __ call_VM(noreg,
 CAST_FROM_FN_PTR(address, InterpreterRuntime::_breakpoint),
 __ xorl(c_rarg1, c_rarg1); // points to free slot or NULL
 // find a free slot in the monitor block (result in c_rarg1)
 {
 Label entry, loop, exit;
-__ movq(c_rarg3, monitor_block_top); // points to current entry,
+__ movptr(c_rarg3, monitor_block_top); // points to current entry,
 // starting with top-most entry
-__ leaq(c_rarg2, monitor_block_bot); // points to word before bottom
+__ lea(c_rarg2, monitor_block_bot); // points to word before bottom
 // of monitor block
 __ jmpb(entry);
 __ bind(loop);
 // check if current entry is used
-__ cmpq(Address(c_rarg3, BasicObjectLock::obj_offset_in_bytes()), (int) NULL);
+__ cmpptr(Address(c_rarg3, BasicObjectLock::obj_offset_in_bytes()), (int32_t) NULL_WORD);
 // if not used then remember entry in c_rarg1
-__ cmovq(Assembler::equal, c_rarg1, c_rarg3);
+__ cmov(Assembler::equal, c_rarg1, c_rarg3);
 // check if current entry is for same object
-__ cmpq(rax, Address(c_rarg3, BasicObjectLock::obj_offset_in_bytes()));
+__ cmpptr(rax, Address(c_rarg3, BasicObjectLock::obj_offset_in_bytes()));
 // if same object then stop searching
 __ jccb(Assembler::equal, exit);
 // otherwise advance to next entry
-__ addq(c_rarg3, entry_size);
+__ addptr(c_rarg3, entry_size);
 __ bind(entry);
 // check if bottom reached
-__ cmpq(c_rarg3, c_rarg2);
+__ cmpptr(c_rarg3, c_rarg2);
 // if not at bottom then check this entry
 __ jcc(Assembler::notEqual, loop);
 __ bind(exit);
 }
-__ testq(c_rarg1, c_rarg1); // check if a slot has been found
+__ testptr(c_rarg1, c_rarg1); // check if a slot has been found
 __ jcc(Assembler::notZero, allocated); // if found, continue with that one
 // allocate one if there's no free slot
 {
 Label entry, loop;
-// 1. compute new pointers       // rsp: old expression stack top
+// 1. compute new pointers             // rsp: old expression stack top
-__ movq(c_rarg1, monitor_block_bot); // c_rarg1: old expression stack bottom
+__ movptr(c_rarg1, monitor_block_bot); // c_rarg1: old expression stack bottom
-__ subq(rsp, entry_size);        // move expression stack top
+__ subptr(rsp, entry_size);            // move expression stack top
-__ subq(c_rarg1, entry_size);        // move expression stack bottom
+__ subptr(c_rarg1, entry_size);        // move expression stack bottom
-__ movq(c_rarg3, rsp);               // set start value for copy loop
+__ mov(c_rarg3, rsp);                  // set start value for copy loop
-__ movq(monitor_block_bot, c_rarg1); // set new monitor block bottom
+__ movptr(monitor_block_bot, c_rarg1); // set new monitor block bottom
 __ jmp(entry);
 // 2. move expression stack contents
 __ bind(loop);
-__ movq(c_rarg2, Address(c_rarg3, entry_size)); // load expression stack
+__ movptr(c_rarg2, Address(c_rarg3, entry_size)); // load expression stack
 // word from old location
-__ movq(Address(c_rarg3, 0), c_rarg2);  // and store it at new location
+__ movptr(Address(c_rarg3, 0), c_rarg2);          // and store it at new location
-__ addq(c_rarg3, wordSize);             // advance to next word
+__ addptr(c_rarg3, wordSize);                     // advance to next word
 __ bind(entry);
-__ cmpq(c_rarg3, c_rarg1);              // check if bottom reached
+__ cmpptr(c_rarg3, c_rarg1);            // check if bottom reached
 __ jcc(Assembler::notEqual, loop);      // if not at bottom then
 // copy next word
 }
 // call run-time routine
 // Increment bcp to point to the next bytecode, so exception
 // handling for async. exceptions work correctly.
 // The object has already been poped from the stack, so the
 // expression stack looks correct.
-__ incrementq(r13);
+__ increment(r13);
 // store object
-__ movq(Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes()), rax);
+__ movptr(Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes()), rax);
 __ lock_object(c_rarg1);
 // check to make sure this monitor doesn't cause stack overflow after locking
 __ save_bcp();  // in case of exception
 __ generate_stack_overflow_check(0);
 Label found;
 // find matching slot
 {
 Label entry, loop;
-__ movq(c_rarg1, monitor_block_top); // points to current entry,
+__ movptr(c_rarg1, monitor_block_top); // points to current entry,
 // starting with top-most entry
-__ leaq(c_rarg2, monitor_block_bot); // points to word before bottom
+__ lea(c_rarg2, monitor_block_bot); // points to word before bottom
 // of monitor block
 __ jmpb(entry);
 __ bind(loop);
 // check if current entry is for same object
-__ cmpq(rax, Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes()));
+__ cmpptr(rax, Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes()));
 // if same object then stop searching
 __ jcc(Assembler::equal, found);
 // otherwise advance to next entry
-__ addq(c_rarg1, entry_size);
+__ addptr(c_rarg1, entry_size);
 __ bind(entry);
 // check if bottom reached
-__ cmpq(c_rarg1, c_rarg2);
+__ cmpptr(c_rarg1, c_rarg2);
 // if not at bottom then check this entry
 __ jcc(Assembler::notEqual, loop);
 }
 // error handling. Unlocking was not block-structured
 transition(vtos, atos);
 __ load_unsigned_byte(rax, at_bcp(3)); // get number of dimensions
 // last dim is on top of stack; we want address of first one:
 // first_addr = last_addr + (ndims - 1) * wordSize
 if (TaggedStackInterpreter) __ shll(rax, 1);  // index*2
-__ leaq(c_rarg1, Address(rsp, rax, Address::times_8, -wordSize));
+__ lea(c_rarg1, Address(rsp, rax, Address::times_8, -wordSize));
 call_VM(rax,
 CAST_FROM_FN_PTR(address, InterpreterRuntime::multianewarray),
 c_rarg1);
 __ load_unsigned_byte(rbx, at_bcp(3));
 if (TaggedStackInterpreter) __ shll(rbx, 1);  // index*2
-__ leaq(rsp, Address(rsp, rbx, Address::times_8));
+__ lea(rsp, Address(rsp, rbx, Address::times_8));
 }
+#endif // !CC_INTERP

Mercurial > hg > graal-compiler

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