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

comparison src/cpu/x86/vm/templateTable_x86_64.cpp @ 1513:df736661d0c8

Merge

author	jrose
date	Tue, 11 May 2010 15:19:19 -0700
parents	2338d41fbd81
children	c18cbe5936b8 ab102d5d923e

comparison

equal deleted inserted replaced

-:e8e83be27dd7
+:df736661d0c8
 static inline Address aaddress(int n) {
 return iaddress(n);
 }
 static inline Address iaddress(Register r) {
-return Address(r14, r, Address::times_8, Interpreter::value_offset_in_bytes());
+return Address(r14, r, Address::times_8);
 }
 static inline Address laddress(Register r) {
 return Address(r14, r, Address::times_8, Interpreter::local_offset_in_bytes(1));
 }
 }
 void TemplateTable::locals_index(Register reg, int offset) {
 __ load_unsigned_byte(reg, at_bcp(offset));
 __ negptr(reg);
-if (TaggedStackInterpreter) __ shlptr(reg, 1);  // index = index*2
 }
 void TemplateTable::iload() {
 transition(vtos, itos);
 if (RewriteFrequentPairs) {
 }
 // Get the local value into tos
 locals_index(rbx);
 __ movl(rax, iaddress(rbx));
-debug_only(__ verify_local_tag(frame::TagValue, rbx));
 }
 void TemplateTable::fast_iload2() {
 transition(vtos, itos);
 locals_index(rbx);
 __ movl(rax, iaddress(rbx));
-debug_only(__ verify_local_tag(frame::TagValue, rbx));
 __ push(itos);
 locals_index(rbx, 3);
 __ movl(rax, iaddress(rbx));
-debug_only(__ verify_local_tag(frame::TagValue, rbx));
 }
 void TemplateTable::fast_iload() {
 transition(vtos, itos);
 locals_index(rbx);
 __ movl(rax, iaddress(rbx));
-debug_only(__ verify_local_tag(frame::TagValue, rbx));
 }
 void TemplateTable::lload() {
 transition(vtos, ltos);
 locals_index(rbx);
 __ movq(rax, laddress(rbx));
-debug_only(__ verify_local_tag(frame::TagCategory2, rbx));
 }
 void TemplateTable::fload() {
 transition(vtos, ftos);
 locals_index(rbx);
 __ movflt(xmm0, faddress(rbx));
-debug_only(__ verify_local_tag(frame::TagValue, rbx));
 }
 void TemplateTable::dload() {
 transition(vtos, dtos);
 locals_index(rbx);
 __ movdbl(xmm0, daddress(rbx));
-debug_only(__ verify_local_tag(frame::TagCategory2, rbx));
 }
 void TemplateTable::aload() {
 transition(vtos, atos);
 locals_index(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);
 __ negptr(reg);
-if (TaggedStackInterpreter) __ shlptr(reg, 1);  // index = index*2
 }
 void TemplateTable::wide_iload() {
 transition(vtos, itos);
 locals_index_wide(rbx);
 __ movl(rax, iaddress(rbx));
-debug_only(__ verify_local_tag(frame::TagValue, rbx));
 }
 void TemplateTable::wide_lload() {
 transition(vtos, ltos);
 locals_index_wide(rbx);
 __ movq(rax, laddress(rbx));
-debug_only(__ verify_local_tag(frame::TagCategory2, rbx));
 }
 void TemplateTable::wide_fload() {
 transition(vtos, ftos);
 locals_index_wide(rbx);
 __ movflt(xmm0, faddress(rbx));
-debug_only(__ verify_local_tag(frame::TagValue, rbx));
 }
 void TemplateTable::wide_dload() {
 transition(vtos, dtos);
 locals_index_wide(rbx);
 __ movdbl(xmm0, daddress(rbx));
-debug_only(__ verify_local_tag(frame::TagCategory2, rbx));
 }
 void TemplateTable::wide_aload() {
 transition(vtos, atos);
 locals_index_wide(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
 void TemplateTable::fast_icaload() {
 transition(vtos, itos);
 // load index out of locals
 locals_index(rbx);
 __ movl(rax, iaddress(rbx));
-debug_only(__ verify_local_tag(frame::TagValue, rbx));
 // eax: index
 // rdx: array
 __ pop_ptr(rdx);
 index_check(rdx, rax); // kills rbx
 }
 void TemplateTable::iload(int n) {
 transition(vtos, itos);
 __ movl(rax, iaddress(n));
-debug_only(__ verify_local_tag(frame::TagValue, n));
 }
 void TemplateTable::lload(int n) {
 transition(vtos, ltos);
 __ movq(rax, laddress(n));
-debug_only(__ verify_local_tag(frame::TagCategory2, n));
 }
 void TemplateTable::fload(int n) {
 transition(vtos, ftos);
 __ movflt(xmm0, faddress(n));
-debug_only(__ verify_local_tag(frame::TagValue, n));
 }
 void TemplateTable::dload(int n) {
 transition(vtos, dtos);
 __ movdbl(xmm0, daddress(n));
-debug_only(__ verify_local_tag(frame::TagCategory2, n));
 }
 void TemplateTable::aload(int n) {
 transition(vtos, atos);
 __ movptr(rax, aaddress(n));
-debug_only(__ verify_local_tag(frame::TagReference, n));
 }
 void TemplateTable::aload_0() {
 transition(vtos, atos);
 // According to bytecode histograms, the pairs:
 void TemplateTable::istore() {
 transition(itos, vtos);
 locals_index(rbx);
 __ movl(iaddress(rbx), rax);
-__ tag_local(frame::TagValue, rbx);
 }
 void TemplateTable::lstore() {
 transition(ltos, vtos);
 locals_index(rbx);
 __ movq(laddress(rbx), rax);
-__ tag_local(frame::TagCategory2, rbx);
 }
 void TemplateTable::fstore() {
 transition(ftos, vtos);
 locals_index(rbx);
 __ movflt(faddress(rbx), xmm0);
-__ tag_local(frame::TagValue, rbx);
 }
 void TemplateTable::dstore() {
 transition(dtos, vtos);
 locals_index(rbx);
 __ movdbl(daddress(rbx), xmm0);
-__ tag_local(frame::TagCategory2, rbx);
 }
 void TemplateTable::astore() {
 transition(vtos, vtos);
-__ pop_ptr(rax, rdx);    // will need to pop tag too
+__ pop_ptr(rax);
 locals_index(rbx);
 __ movptr(aaddress(rbx), rax);
-__ tag_local(rdx, rbx);  // store tag from stack, might be returnAddr
 }
 void TemplateTable::wide_istore() {
 transition(vtos, vtos);
 __ pop_i();
 locals_index_wide(rbx);
 __ movl(iaddress(rbx), rax);
-__ tag_local(frame::TagValue, rbx);
 }
 void TemplateTable::wide_lstore() {
 transition(vtos, vtos);
 __ pop_l();
 locals_index_wide(rbx);
 __ movq(laddress(rbx), rax);
-__ tag_local(frame::TagCategory2, rbx);
 }
 void TemplateTable::wide_fstore() {
 transition(vtos, vtos);
 __ pop_f();
 locals_index_wide(rbx);
 __ movflt(faddress(rbx), xmm0);
-__ tag_local(frame::TagValue, rbx);
 }
 void TemplateTable::wide_dstore() {
 transition(vtos, vtos);
 __ pop_d();
 locals_index_wide(rbx);
 __ movdbl(daddress(rbx), xmm0);
-__ tag_local(frame::TagCategory2, rbx);
 }
 void TemplateTable::wide_astore() {
 transition(vtos, vtos);
-__ pop_ptr(rax, rdx);    // will need to pop tag too
+__ pop_ptr(rax);
 locals_index_wide(rbx);
 __ movptr(aaddress(rbx), rax);
-__ tag_local(rdx, rbx);  // store tag from stack, might be returnAddr
 }
 void TemplateTable::iastore() {
 transition(itos, vtos);
 __ pop_i(rbx);
 // Store a NULL
 do_oop_store(_masm, element_address, noreg, _bs->kind(), true);
 // Pop stack arguments
 __ bind(done);
-__ addptr(rsp, 3 * Interpreter::stackElementSize());
+__ addptr(rsp, 3 * Interpreter::stackElementSize);
 }
 void TemplateTable::bastore() {
 transition(itos, vtos);
 __ pop_i(rbx);
 }
 void TemplateTable::istore(int n) {
 transition(itos, vtos);
 __ movl(iaddress(n), rax);
-__ tag_local(frame::TagValue, n);
 }
 void TemplateTable::lstore(int n) {
 transition(ltos, vtos);
 __ movq(laddress(n), rax);
-__ tag_local(frame::TagCategory2, n);
 }
 void TemplateTable::fstore(int n) {
 transition(ftos, vtos);
 __ movflt(faddress(n), xmm0);
-__ tag_local(frame::TagValue, n);
 }
 void TemplateTable::dstore(int n) {
 transition(dtos, vtos);
 __ movdbl(daddress(n), xmm0);
-__ tag_local(frame::TagCategory2, n);
 }
 void TemplateTable::astore(int n) {
 transition(vtos, vtos);
-__ pop_ptr(rax, rdx);
+__ pop_ptr(rax);
 __ movptr(aaddress(n), rax);
-__ tag_local(rdx, n);
 }
 void TemplateTable::pop() {
 transition(vtos, vtos);
-__ addptr(rsp, Interpreter::stackElementSize());
+__ addptr(rsp, Interpreter::stackElementSize);
 }
 void TemplateTable::pop2() {
 transition(vtos, vtos);
-__ addptr(rsp, 2 * Interpreter::stackElementSize());
+__ addptr(rsp, 2 * Interpreter::stackElementSize);
 }
 void TemplateTable::dup() {
 transition(vtos, vtos);
-__ load_ptr_and_tag(0, rax, rdx);
+__ load_ptr(0, rax);
-__ push_ptr(rax, rdx);
+__ push_ptr(rax);
 // stack: ..., a, a
 }
 void TemplateTable::dup_x1() {
 transition(vtos, vtos);
 // stack: ..., a, b
-__ load_ptr_and_tag(0, rax, rdx);  // load b
+__ load_ptr( 0, rax);  // load b
-__ load_ptr_and_tag(1, rcx, rbx);  // load a
+__ load_ptr( 1, rcx);  // load a
-__ store_ptr_and_tag(1, rax, rdx); // store b
+__ store_ptr(1, rax);  // store b
-__ store_ptr_and_tag(0, rcx, rbx); // store a
+__ store_ptr(0, rcx);  // store a
-__ push_ptr(rax, rdx);             // push b
+__ push_ptr(rax);      // push b
 // stack: ..., b, a, b
 }
 void TemplateTable::dup_x2() {
 transition(vtos, vtos);
 // stack: ..., a, b, c
-__ load_ptr_and_tag(0, rax, rdx);  // load c
+__ load_ptr( 0, rax);  // load c
-__ load_ptr_and_tag(2, rcx, rbx);  // load a
+__ load_ptr( 2, rcx);  // load a
-__ store_ptr_and_tag(2, rax, rdx); // store c in a
+__ store_ptr(2, rax);  // store c in a
-__ push_ptr(rax, rdx);             // push c
+__ push_ptr(rax);      // push c
 // stack: ..., c, b, c, c
-__ load_ptr_and_tag(2, rax, rdx);  // load b
+__ load_ptr( 2, rax);  // load b
-__ store_ptr_and_tag(2, rcx, rbx); // store a in b
+__ store_ptr(2, rcx);  // store a in b
 // stack: ..., c, a, c, c
-__ store_ptr_and_tag(1, rax, rdx); // store b in c
+__ store_ptr(1, rax);  // store b in c
 // stack: ..., c, a, b, c
 }
 void TemplateTable::dup2() {
 transition(vtos, vtos);
 // stack: ..., a, b
-__ load_ptr_and_tag(1, rax, rdx);  // load a
+__ load_ptr(1, rax);  // load a
-__ push_ptr(rax, rdx);             // push a
+__ push_ptr(rax);     // push a
-__ load_ptr_and_tag(1, rax, rdx);  // load b
+__ load_ptr(1, rax);  // load b
-__ push_ptr(rax, rdx);             // push b
+__ push_ptr(rax);     // push b
 // stack: ..., a, b, a, b
 }
 void TemplateTable::dup2_x1() {
 transition(vtos, vtos);
 // stack: ..., a, b, c
-__ load_ptr_and_tag(0, rcx, rbx);  // load c
+__ load_ptr( 0, rcx);  // load c
-__ load_ptr_and_tag(1, rax, rdx);  // load b
+__ load_ptr( 1, rax);  // load b
-__ push_ptr(rax, rdx);             // push b
+__ push_ptr(rax);      // push b
-__ push_ptr(rcx, rbx);             // push c
+__ push_ptr(rcx);      // push c
 // stack: ..., a, b, c, b, c
-__ store_ptr_and_tag(3, rcx, rbx); // store c in b
+__ store_ptr(3, rcx);  // store c in b
 // stack: ..., a, c, c, b, c
-__ load_ptr_and_tag(4, rcx, rbx);  // load a
+__ load_ptr( 4, rcx);  // load a
-__ store_ptr_and_tag(2, rcx, rbx); // store a in 2nd c
+__ store_ptr(2, rcx);  // store a in 2nd c
 // stack: ..., a, c, a, b, c
-__ store_ptr_and_tag(4, rax, rdx); // store b in a
+__ store_ptr(4, rax);  // store b in a
 // stack: ..., b, c, a, b, c
 }
 void TemplateTable::dup2_x2() {
 transition(vtos, vtos);
 // stack: ..., a, b, c, d
-__ load_ptr_and_tag(0, rcx, rbx);  // load d
+__ load_ptr( 0, rcx);  // load d
-__ load_ptr_and_tag(1, rax, rdx);  // load c
+__ load_ptr( 1, rax);  // load c
-__ push_ptr(rax, rdx);             // push c
+__ push_ptr(rax);      // push c
-__ push_ptr(rcx, rbx);             // push d
+__ push_ptr(rcx);      // push d
 // stack: ..., a, b, c, d, c, d
-__ load_ptr_and_tag(4, rax, rdx);  // load b
+__ load_ptr( 4, rax);  // load b
-__ store_ptr_and_tag(2, rax, rdx); // store b in d
+__ store_ptr(2, rax);  // store b in d
-__ store_ptr_and_tag(4, rcx, rbx); // store d in b
+__ store_ptr(4, rcx);  // store d in b
 // stack: ..., a, d, c, b, c, d
-__ load_ptr_and_tag(5, rcx, rbx);  // load a
+__ load_ptr( 5, rcx);  // load a
-__ load_ptr_and_tag(3, rax, rdx);  // load c
+__ load_ptr( 3, rax);  // load c
-__ store_ptr_and_tag(3, rcx, rbx); // store a in c
+__ store_ptr(3, rcx);  // store a in c
-__ store_ptr_and_tag(5, rax, rdx); // store c in a
+__ store_ptr(5, rax);  // store c in a
 // stack: ..., c, d, a, b, c, d
 }
 void TemplateTable::swap() {
 transition(vtos, vtos);
 // stack: ..., a, b
-__ load_ptr_and_tag(1, rcx, rbx);  // load a
+__ load_ptr( 1, rcx);  // load a
-__ load_ptr_and_tag(0, rax, rdx);  // load b
+__ load_ptr( 0, rax);  // load b
-__ store_ptr_and_tag(0, rcx, rbx); // store a in b
+__ store_ptr(0, rcx);  // store a in b
-__ store_ptr_and_tag(1, rax, rdx); // store b in a
+__ store_ptr(1, rax);  // store b in a
 // stack: ..., b, a
 }
 void TemplateTable::iop2(Operation op) {
 transition(itos, itos);
 }
 void TemplateTable::lop2(Operation op) {
 transition(ltos, ltos);
 switch (op) {
-case add  :                    __ pop_l(rdx); __ addptr (rax, rdx); break;
+case add  :                    __ pop_l(rdx); __ addptr(rax, rdx); break;
-case sub  : __ mov(rdx, rax);  __ pop_l(rax); __ subptr (rax, rdx); break;
+case sub  : __ mov(rdx, rax);  __ pop_l(rax); __ subptr(rax, rdx); break;
-case _and :                    __ pop_l(rdx); __ andptr (rax, rdx); break;
+case _and :                    __ pop_l(rdx); __ andptr(rax, rdx); break;
-case _or  :                    __ pop_l(rdx); __ orptr  (rax, rdx); break;
+case _or  :                    __ pop_l(rdx); __ orptr (rax, rdx); break;
-case _xor :                    __ pop_l(rdx); __ xorptr (rax, rdx); break;
+case _xor :                    __ pop_l(rdx); __ xorptr(rax, rdx); break;
-default : ShouldNotReachHere();
+default   : ShouldNotReachHere();
 }
 }
 void TemplateTable::idiv() {
 transition(itos, itos);
 void TemplateTable::fop2(Operation op) {
 transition(ftos, ftos);
 switch (op) {
 case add:
 __ addss(xmm0, at_rsp());
-__ addptr(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());
-__ addptr(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());
-__ addptr(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());
-__ addptr(rsp, 2 * Interpreter::stackElementSize());
+__ addptr(rsp, 2 * Interpreter::stackElementSize);
 break;
 case div:
 __ movdbl(xmm1, xmm0);
 __ pop_d(xmm0);
 __ divsd(xmm0, xmm1);
 void TemplateTable::fast_xaccess(TosState state) {
 transition(vtos, state);
 // get receiver
 __ 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);
 __ movptr(rbx,
 Address(rcx, rdx, Address::times_8,
 in_bytes(constantPoolCacheOopDesc::base_offset() +
 // 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
 Address recv_addr(rsp, recv, Address::times_8, -Interpreter::expr_offset_in_bytes(1));
 __ movptr(recv, recv_addr);
 __ verify_oop(recv);
 }
 void TemplateTable::multianewarray() {
 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
 __ 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
 __ lea(rsp, Address(rsp, rbx, Address::times_8));
 }
 #endif // !CC_INTERP

Mercurial > hg > graal-compiler

comparison src/cpu/x86/vm/templateTable_x86_64.cpp @ 1513:df736661d0c8