truffle: src/cpu/x86/vm/templateTable_x86

comparison src/cpu/x86/vm/templateTable_x86_64.cpp @ 628:7bb995fbd3c0

Merge

author	trims
date	Thu, 12 Mar 2009 18:16:36 -0700
parents	9adddb8c0fc8
children	be93aad57795

comparison

equal deleted inserted replaced

-:ce2272390558
+:7bb995fbd3c0
 __ load_signed_byte(rax, at_bcp(1));
 }
 void TemplateTable::sipush() {
 transition(vtos, itos);
-__ load_unsigned_word(rax, at_bcp(1));
+__ load_unsigned_short(rax, at_bcp(1));
 __ bswapl(rax);
 __ sarl(rax, 16);
 }
 void TemplateTable::ldc(bool wide) {
 transition(itos, itos);
 __ pop_ptr(rdx);
 // eax: index
 // rdx: array
 index_check(rdx, rax); // kills rbx
-__ load_unsigned_word(rax,
+__ load_unsigned_short(rax,
 Address(rdx, rax,
 Address::times_2,
 arrayOopDesc::base_offset_in_bytes(T_CHAR)));
 }
 // iload followed by caload frequent pair
 void TemplateTable::fast_icaload() {
 transition(vtos, itos);
 // eax: index
 // rdx: array
 __ pop_ptr(rdx);
 index_check(rdx, rax); // kills rbx
-__ load_unsigned_word(rax,
+__ load_unsigned_short(rax,
 Address(rdx, rax,
 Address::times_2,
 arrayOopDesc::base_offset_in_bytes(T_CHAR)));
 }
 void TemplateTable::saload() {
 transition(itos, itos);
 __ pop_ptr(rdx);
 // eax: index
 // rdx: array
 index_check(rdx, rax); // kills rbx
-__ load_signed_word(rax,
+__ load_signed_short(rax,
 Address(rdx, rax,
 Address::times_2,
 arrayOopDesc::base_offset_in_bytes(T_SHORT)));
 }
 void TemplateTable::iload(int n) {
 transition(vtos, itos);
 __ movl(rax, iaddress(n));
 }
 __ 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.
+// normal-branch stuff occurring 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
 __ bind(notInt);
 __ cmpl(flags, ctos);
 __ jcc(Assembler::notEqual, notChar);
 // ctos
-__ load_unsigned_word(rax, field);
+__ load_unsigned_short(rax, field);
 __ push(ctos);
 // Rewrite bytecode to be faster
 if (!is_static) {
 patch_bytecode(Bytecodes::_fast_cgetfield, bc, rbx);
 }
 __ bind(notChar);
 __ cmpl(flags, stos);
 __ jcc(Assembler::notEqual, notShort);
 // stos
-__ load_signed_word(rax, field);
+__ load_signed_short(rax, field);
 __ push(stos);
 // Rewrite bytecode to be faster
 if (!is_static) {
 patch_bytecode(Bytecodes::_fast_sgetfield, bc, rbx);
 }
 break;
 case Bytecodes::_fast_bgetfield:
 __ movsbl(rax, field);
 break;
 case Bytecodes::_fast_sgetfield:
-__ load_signed_word(rax, field);
+__ load_signed_short(rax, field);
 break;
 case Bytecodes::_fast_cgetfield:
-__ load_unsigned_word(rax, field);
+__ load_unsigned_short(rax, field);
 break;
 case Bytecodes::_fast_fgetfield:
 __ movflt(xmm0, field);
 break;
 case Bytecodes::_fast_dgetfield:
 __ verify_oop(rdx);
 // profile this call
 __ profile_virtual_call(rdx, r13, r14);
-__ mov(r14, rdx); // Save klassOop in r14
+Label no_such_interface, no_such_method;
-// Compute start of first itableOffsetEntry (which is at the end of
+__ lookup_interface_method(// inputs: rec. class, interface, itable index
-// the vtable)
+rdx, rax, rbx,
-const int base = instanceKlass::vtable_start_offset() * wordSize;
+// outputs: method, scan temp. reg
-// Get length of vtable
+rbx, r13,
-assert(vtableEntry::size() * wordSize == 8,
+no_such_interface);
-"adjust the scaling in the code below");
-__ movl(r13, Address(rdx,
+// rbx,: methodOop to call
-instanceKlass::vtable_length_offset() * wordSize));
+// rcx: receiver
-__ lea(rdx, Address(rdx, r13, Address::times_8, base));
+// Check for abstract method error
+// Note: This should be done more efficiently via a throw_abstract_method_error
-if (HeapWordsPerLong > 1) {
+//       interpreter entry point and a conditional jump to it in case of a null
-// Round up to align_object_offset boundary
+//       method.
-__ round_to(rdx, BytesPerLong);
+__ testptr(rbx, rbx);
-}
+__ jcc(Assembler::zero, no_such_method);
-Label entry, search, interface_ok;
+// do the call
+// rcx: receiver
-__ jmpb(entry);
+// rbx,: methodOop
-__ bind(search);
+__ jump_from_interpreted(rbx, rdx);
-__ addptr(rdx, itableOffsetEntry::size() * wordSize);
+__ should_not_reach_here();
-__ bind(entry);
+// exception handling code follows...
+// note: must restore interpreter registers to canonical
-// Check that the entry is non-null.  A null entry means that the
+//       state for exception handling to work correctly!
-// receiver class doesn't implement the interface, and wasn't the
-// same as the receiver class checked when the interface was
+__ bind(no_such_method);
-// resolved.
-__ push(rdx);
-__ movptr(rdx, Address(rdx, itableOffsetEntry::interface_offset_in_bytes()));
-__ testptr(rdx, rdx);
-__ jcc(Assembler::notZero, interface_ok);
 // throw exception
-__ pop(rdx); // pop saved register first.
+__ pop(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_bcp(); // r13 must be correct for exception handler (was
+__ restore_locals();   // make sure locals pointer is correct as well (was destroyed)
-// destroyed)
+__ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodError));
-__ restore_locals(); // make sure locals pointer is correct as well
+// the call_VM checks for exception, so we should never return here.
-// (was destroyed)
+__ should_not_reach_here();
+__ bind(no_such_interface);
+// throw exception
+__ 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);
+return;
+}
-__ pop(rdx);
-__ cmpptr(rax, Address(rdx, itableOffsetEntry::interface_offset_in_bytes()));
-__ jcc(Assembler::notEqual, search);
-__ movl(rdx, Address(rdx, itableOffsetEntry::offset_offset_in_bytes()));
-__ addptr(rdx, r14); // Add offset to klassOop
-assert(itableMethodEntry::size() * wordSize == 8,
-"adjust the scaling in the code below");
-__ 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;
-__ testptr(rbx, rbx);
-__ jcc(Assembler::notZero, L);
-// throw exception
-// note: must restore interpreter registers to canonical
-//       state for exception handling to work correctly!
-__ 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_AbstractMethodError));
-// the call_VM checks for exception, so we should never return here.
-__ should_not_reach_here();
-__ bind(L);
-}
-__ movptr(rcx, Address(rbx, methodOopDesc::interpreter_entry_offset()));
-// do the call
-// rcx: receiver
-// rbx: methodOop
-__ jump_from_interpreted(rbx, rdx);
-}
 //-----------------------------------------------------------------------------
 // Allocation
 void TemplateTable::_new() {

Mercurial > hg > truffle

comparison src/cpu/x86/vm/templateTable_x86_64.cpp @ 628:7bb995fbd3c0