truffle: src/cpu/x86/vm/templateTable_x86

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

Merge

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

comparison

equal deleted inserted replaced

-:ce2272390558
+:7bb995fbd3c0
 }
 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);
 // rdx: array
 index_check(rdx, rax);  // kills rbx,
 // rax,: index
 // can do better code for P5 - may want to improve this at some point
-__ load_unsigned_word(rbx, Address(rdx, rax, Address::times_2, arrayOopDesc::base_offset_in_bytes(T_CHAR)));
+__ load_unsigned_short(rbx, Address(rdx, rax, Address::times_2, arrayOopDesc::base_offset_in_bytes(T_CHAR)));
 __ mov(rax, rbx);
 }
 // iload followed by caload frequent pair
 void TemplateTable::fast_icaload() {
 debug_only(__ verify_local_tag(frame::TagValue, rbx));
 // rdx: array
 index_check(rdx, rax);
 // rax,: index
-__ load_unsigned_word(rbx, Address(rdx, rax, Address::times_2, arrayOopDesc::base_offset_in_bytes(T_CHAR)));
+__ load_unsigned_short(rbx, Address(rdx, rax, Address::times_2, arrayOopDesc::base_offset_in_bytes(T_CHAR)));
 __ mov(rax, rbx);
 }
 void TemplateTable::saload() {
 transition(itos, itos);
 // rdx: array
 index_check(rdx, rax);  // kills rbx,
 // rax,: index
 // can do better code for P5 - may want to improve this at some point
-__ load_signed_word(rbx, Address(rdx, rax, Address::times_2, arrayOopDesc::base_offset_in_bytes(T_SHORT)));
+__ load_signed_short(rbx, Address(rdx, rax, Address::times_2, arrayOopDesc::base_offset_in_bytes(T_SHORT)));
 __ mov(rax, rbx);
 }
 void TemplateTable::iload(int n) {
 LP64_ONLY(__ movslq(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.
+// non-JSR normal-branch stuff occurring below.
 if (is_jsr) {
 // Pre-load the next target bytecode into EBX
 __ load_unsigned_byte(rbx, Address(rsi, rdx, Address::times_1, 0));
 // compute return address as bci in rax,
 __ bind(notObj);
 // ctos
 __ cmpl(flags, ctos );
 __ jcc(Assembler::notEqual, notChar);
-__ load_unsigned_word(rax, lo );
+__ load_unsigned_short(rax, lo );
 __ push(ctos);
 if (!is_static) {
 patch_bytecode(Bytecodes::_fast_cgetfield, rcx, rbx);
 }
 __ jmp(Done);
 __ bind(notChar);
 // stos
 __ cmpl(flags, stos );
 __ jcc(Assembler::notEqual, notShort);
-__ load_signed_word(rax, lo );
+__ load_signed_short(rax, lo );
 __ push(stos);
 if (!is_static) {
 patch_bytecode(Bytecodes::_fast_sgetfield, rcx, rbx);
 }
 __ jmp(Done);
 const Address hi = Address(rax, rbx, Address::times_1, 1*wordSize);
 // access field
 switch (bytecode()) {
 case Bytecodes::_fast_bgetfield: __ movsbl(rax, lo );                 break;
-case Bytecodes::_fast_sgetfield: __ load_signed_word(rax, lo );       break;
+case Bytecodes::_fast_sgetfield: __ load_signed_short(rax, lo );      break;
-case Bytecodes::_fast_cgetfield: __ load_unsigned_word(rax, lo );     break;
+case Bytecodes::_fast_cgetfield: __ load_unsigned_short(rax, lo );    break;
 case Bytecodes::_fast_igetfield: __ movl(rax, lo);                    break;
 case Bytecodes::_fast_lgetfield: __ stop("should not be rewritten");  break;
 case Bytecodes::_fast_fgetfield: __ fld_s(lo);                        break;
 case Bytecodes::_fast_dgetfield: __ fld_d(lo);                        break;
 case Bytecodes::_fast_agetfield: __ movptr(rax, lo); __ verify_oop(rax); break;
 __ verify_oop(rdx);
 // profile this call
 __ profile_virtual_call(rdx, rsi, rdi);
-__ mov(rdi, rdx); // Save klassOop in rdi
+Label no_such_interface, no_such_method;
-// Compute start of first itableOffsetEntry (which is at the end of the vtable)
+__ lookup_interface_method(// inputs: rec. class, interface, itable index
-const int base = instanceKlass::vtable_start_offset() * wordSize;
+rdx, rax, rbx,
-assert(vtableEntry::size() * wordSize == (1 << (int)Address::times_ptr), "adjust the scaling in the code below");
+// outputs: method, scan temp. reg
-__ movl(rsi, Address(rdx, instanceKlass::vtable_length_offset() * wordSize)); // Get length of vtable
+rbx, rsi,
-__ lea(rdx, Address(rdx, rsi, Address::times_4, base));
+no_such_interface);
-if (HeapWordsPerLong > 1) {
-// Round up to align_object_offset boundary
+// rbx,: methodOop to call
-__ round_to(rdx, BytesPerLong);
+// rcx: receiver
-}
+// Check for abstract method error
+// Note: This should be done more efficiently via a throw_abstract_method_error
-Label entry, search, interface_ok;
+//       interpreter entry point and a conditional jump to it in case of a null
+//       method.
-__ jmpb(entry);
+__ testptr(rbx, rbx);
-__ bind(search);
+__ jcc(Assembler::zero, no_such_method);
-__ addptr(rdx, itableOffsetEntry::size() * wordSize);
+// do the call
-__ bind(entry);
+// rcx: receiver
+// rbx,: methodOop
-// Check that the entry is non-null.  A null entry means that the receiver
+__ jump_from_interpreted(rbx, rdx);
-// class doesn't implement the interface, and wasn't the same as the
+__ should_not_reach_here();
-// receiver class checked when the interface was resolved.
-__ push(rdx);
+// exception handling code follows...
-__ movptr(rdx, Address(rdx, itableOffsetEntry::interface_offset_in_bytes()));
+// note: must restore interpreter registers to canonical
-__ testptr(rdx, rdx);
+//       state for exception handling to work correctly!
-__ jcc(Assembler::notZero, interface_ok);
+__ bind(no_such_method);
 // throw exception
-__ pop(rdx);           // pop saved register first.
+__ pop(rbx);           // pop return address (pushed by prepare_invoke)
+__ restore_bcp();      // rsi 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(no_such_interface);
+// throw exception
 __ pop(rbx);           // pop return address (pushed by prepare_invoke)
 __ restore_bcp();      // rsi 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);
-__ 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, rdi); // Add offset to klassOop
-assert(itableMethodEntry::size() * wordSize == (1 << (int)Address::times_ptr), "adjust the scaling in the code below");
-__ movptr(rbx, Address(rdx, rbx, Address::times_ptr));
-// 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();      // rsi 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);
-}
-// do the call
-// rcx: receiver
-// rbx,: methodOop
-__ jump_from_interpreted(rbx, rdx);
 }
 //----------------------------------------------------------------------------------------------------
 // Allocation

Mercurial > hg > truffle

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