truffle: src/cpu/sparc/vm/assembler

comparison src/cpu/sparc/vm/assembler_sparc.cpp @ 1503:c640000b7cc1

6829193: JSR 292 needs to support SPARC Summary: There are unimplemented portions of the hotspot code for method handles and invokedynamic specific to SPARC. Reviewed-by: kvn, never, jrose

author	twisti
date	Thu, 29 Apr 2010 06:30:25 -0700
parents	dcf03e02b020
children	2338d41fbd81

comparison

equal deleted inserted replaced

-:90acda19b80f
+:c640000b7cc1
 /*
-* Copyright 1997-2009 Sun Microsystems, Inc.  All Rights Reserved.
+* Copyright 1997-2010 Sun Microsystems, Inc.  All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 movcc(greater, false, xcc,  1, Rresult);
 }
 #endif
+void MacroAssembler::load_sized_value(Address src, Register dst,
+size_t size_in_bytes, bool is_signed) {
+switch (size_in_bytes) {
+case  8: ldx(src, dst); break;
+case  4: ld( src, dst); break;
+case  2: is_signed ? ldsh(src, dst) : lduh(src, dst); break;
+case  1: is_signed ? ldsb(src, dst) : ldub(src, dst); break;
+default: ShouldNotReachHere();
+}
+}
 void MacroAssembler::float_cmp( bool is_float, int unordered_result,
 FloatRegister Fa, FloatRegister Fb,
 Register Rresult) {
 fcmp(is_float ? FloatRegisterImpl::S : FloatRegisterImpl::D, fcc0, Fa, Fb);
 return RegisterOrConstant(tmp);
 }
-void MacroAssembler::regcon_inc_ptr( RegisterOrConstant& dest, RegisterOrConstant src, Register temp ) {
+RegisterOrConstant MacroAssembler::regcon_andn_ptr(RegisterOrConstant s1, RegisterOrConstant s2, RegisterOrConstant d, Register temp) {
-assert(dest.register_or_noreg() != G0, "lost side effect");
+assert(d.register_or_noreg() != G0, "lost side effect");
-if ((src.is_constant() && src.as_constant() == 0) ||
+if ((s2.is_constant() && s2.as_constant() == 0) ||
-(src.is_register() && src.as_register() == G0)) {
+(s2.is_register() && s2.as_register() == G0)) {
-// do nothing
+// Do nothing, just move value.
-} else if (dest.is_register()) {
+if (s1.is_register()) {
-add(dest.as_register(), ensure_simm13_or_reg(src, temp), dest.as_register());
+if (d.is_constant())  d = temp;
-} else if (src.is_constant()) {
+mov(s1.as_register(), d.as_register());
-intptr_t res = dest.as_constant() + src.as_constant();
+return d;
-dest = RegisterOrConstant(res); // side effect seen by caller
+} else {
+return s1;
+}
+}
+if (s1.is_register()) {
+assert_different_registers(s1.as_register(), temp);
+if (d.is_constant())  d = temp;
+andn(s1.as_register(), ensure_simm13_or_reg(s2, temp), d.as_register());
+return d;
 } else {
-assert(temp != noreg, "cannot handle constant += register");
+if (s2.is_register()) {
-add(src.as_register(), ensure_simm13_or_reg(dest, temp), temp);
+assert_different_registers(s2.as_register(), temp);
-dest = RegisterOrConstant(temp); // side effect seen by caller
+if (d.is_constant())  d = temp;
-}
+set(s1.as_constant(), temp);
-}
+andn(temp, s2.as_register(), d.as_register());
+return d;
-void MacroAssembler::regcon_sll_ptr( RegisterOrConstant& dest, RegisterOrConstant src, Register temp ) {
+} else {
-assert(dest.register_or_noreg() != G0, "lost side effect");
+intptr_t res = s1.as_constant() & ~s2.as_constant();
-if (!is_simm13(src.constant_or_zero()))
+return res;
-src = (src.as_constant() & 0xFF);
+}
-if ((src.is_constant() && src.as_constant() == 0) ||
+}
-(src.is_register() && src.as_register() == G0)) {
+}
-// do nothing
-} else if (dest.is_register()) {
+RegisterOrConstant MacroAssembler::regcon_inc_ptr(RegisterOrConstant s1, RegisterOrConstant s2, RegisterOrConstant d, Register temp) {
-sll_ptr(dest.as_register(), src, dest.as_register());
+assert(d.register_or_noreg() != G0, "lost side effect");
-} else if (src.is_constant()) {
+if ((s2.is_constant() && s2.as_constant() == 0) ||
-intptr_t res = dest.as_constant() << src.as_constant();
+(s2.is_register() && s2.as_register() == G0)) {
-dest = RegisterOrConstant(res); // side effect seen by caller
+// Do nothing, just move value.
+if (s1.is_register()) {
+if (d.is_constant())  d = temp;
+mov(s1.as_register(), d.as_register());
+return d;
+} else {
+return s1;
+}
+}
+if (s1.is_register()) {
+assert_different_registers(s1.as_register(), temp);
+if (d.is_constant())  d = temp;
+add(s1.as_register(), ensure_simm13_or_reg(s2, temp), d.as_register());
+return d;
 } else {
-assert(temp != noreg, "cannot handle constant <<= register");
+if (s2.is_register()) {
-set(dest.as_constant(), temp);
+assert_different_registers(s2.as_register(), temp);
-sll_ptr(temp, src, temp);
+if (d.is_constant())  d = temp;
-dest = RegisterOrConstant(temp); // side effect seen by caller
+add(s2.as_register(), ensure_simm13_or_reg(s1, temp), d.as_register());
+return d;
+} else {
+intptr_t res = s1.as_constant() + s2.as_constant();
+return res;
+}
+}
+}
+RegisterOrConstant MacroAssembler::regcon_sll_ptr(RegisterOrConstant s1, RegisterOrConstant s2, RegisterOrConstant d, Register temp) {
+assert(d.register_or_noreg() != G0, "lost side effect");
+if (!is_simm13(s2.constant_or_zero()))
+s2 = (s2.as_constant() & 0xFF);
+if ((s2.is_constant() && s2.as_constant() == 0) ||
+(s2.is_register() && s2.as_register() == G0)) {
+// Do nothing, just move value.
+if (s1.is_register()) {
+if (d.is_constant())  d = temp;
+mov(s1.as_register(), d.as_register());
+return d;
+} else {
+return s1;
+}
+}
+if (s1.is_register()) {
+assert_different_registers(s1.as_register(), temp);
+if (d.is_constant())  d = temp;
+sll_ptr(s1.as_register(), ensure_simm13_or_reg(s2, temp), d.as_register());
+return d;
+} else {
+if (s2.is_register()) {
+assert_different_registers(s2.as_register(), temp);
+if (d.is_constant())  d = temp;
+set(s1.as_constant(), temp);
+sll_ptr(temp, s2.as_register(), d.as_register());
+return d;
+} else {
+intptr_t res = s1.as_constant() << s2.as_constant();
+return res;
+}
 }
 }
 // Look up the method for a megamorphic invokeinterface call.
 }
 add(recv_klass, scan_temp, scan_temp);
 // Adjust recv_klass by scaled itable_index, so we can free itable_index.
 RegisterOrConstant itable_offset = itable_index;
-regcon_sll_ptr(itable_offset, exact_log2(itableMethodEntry::size() * wordSize));
+itable_offset = regcon_sll_ptr(itable_index, exact_log2(itableMethodEntry::size() * wordSize), itable_offset);
-regcon_inc_ptr(itable_offset, itableMethodEntry::method_offset_in_bytes());
+itable_offset = regcon_inc_ptr(itable_offset, itableMethodEntry::method_offset_in_bytes(), itable_offset);
 add(recv_klass, ensure_simm13_or_reg(itable_offset, sethi_temp), recv_klass);
 // for (scan = klass->itable(); scan->interface() != NULL; scan += scan_step) {
 //   if (scan->interface() == intf) {
 //     result = (klass + scan->offset() + itable_index);
 bool need_slow_path = (must_load_sco ||
 super_check_offset.constant_or_zero() == sco_offset);
 assert_different_registers(sub_klass, super_klass, temp_reg);
 if (super_check_offset.is_register()) {
-assert_different_registers(sub_klass, super_klass,
+assert_different_registers(sub_klass, super_klass, temp_reg,
 super_check_offset.as_register());
 } else if (must_load_sco) {
 assert(temp2_reg != noreg, "supply either a temp or a register offset");
 }
 // Check the supertype display:
 if (must_load_sco) {
 // The super check offset is always positive...
 lduw(super_klass, sco_offset, temp2_reg);
 super_check_offset = RegisterOrConstant(temp2_reg);
+// super_check_offset is register.
+assert_different_registers(sub_klass, super_klass, temp_reg, super_check_offset.as_register());
 }
 ld_ptr(sub_klass, super_check_offset, temp_reg);
 cmp(super_klass, temp_reg);
 // This check has worked decisively for primary supers.
 bind(L_fallthrough);
 }
 void MacroAssembler::check_method_handle_type(Register mtype_reg, Register mh_reg,
 Register temp_reg,
 Label& wrong_method_type) {
+if (UseCompressedOops)  unimplemented("coop");  // field accesses must decode
 assert_different_registers(mtype_reg, mh_reg, temp_reg);
 // compare method type against that of the receiver
 RegisterOrConstant mhtype_offset = delayed_value(java_dyn_MethodHandle::type_offset_in_bytes, temp_reg);
 ld_ptr(mh_reg, mhtype_offset, temp_reg);
 cmp(temp_reg, mtype_reg);
 br(Assembler::notEqual, false, Assembler::pn, wrong_method_type);
 delayed()->nop();
 }
-void MacroAssembler::jump_to_method_handle_entry(Register mh_reg, Register temp_reg) {
+// A method handle has a "vmslots" field which gives the size of its
+// argument list in JVM stack slots.  This field is either located directly
+// in every method handle, or else is indirectly accessed through the
+// method handle's MethodType.  This macro hides the distinction.
+void MacroAssembler::load_method_handle_vmslots(Register vmslots_reg, Register mh_reg,
+Register temp_reg) {
+assert_different_registers(vmslots_reg, mh_reg, temp_reg);
+if (UseCompressedOops)  unimplemented("coop");  // field accesses must decode
+// load mh.type.form.vmslots
+if (java_dyn_MethodHandle::vmslots_offset_in_bytes() != 0) {
+// hoist vmslots into every mh to avoid dependent load chain
+ld(    Address(mh_reg,    delayed_value(java_dyn_MethodHandle::vmslots_offset_in_bytes, temp_reg)),   vmslots_reg);
+} else {
+Register temp2_reg = vmslots_reg;
+ld_ptr(Address(mh_reg,    delayed_value(java_dyn_MethodHandle::type_offset_in_bytes, temp_reg)),      temp2_reg);
+ld_ptr(Address(temp2_reg, delayed_value(java_dyn_MethodType::form_offset_in_bytes, temp_reg)),        temp2_reg);
+ld(    Address(temp2_reg, delayed_value(java_dyn_MethodTypeForm::vmslots_offset_in_bytes, temp_reg)), vmslots_reg);
+}
+}
+void MacroAssembler::jump_to_method_handle_entry(Register mh_reg, Register temp_reg, bool emit_delayed_nop) {
 assert(mh_reg == G3_method_handle, "caller must put MH object in G3");
 assert_different_registers(mh_reg, temp_reg);
+if (UseCompressedOops)  unimplemented("coop");  // field accesses must decode
 // pick out the interpreted side of the handler
 ld_ptr(mh_reg, delayed_value(java_dyn_MethodHandle::vmentry_offset_in_bytes, temp_reg), temp_reg);
 // off we go...
 jmp(temp_reg, 0);
 // for the various stubs which take control at this point,
 // see MethodHandles::generate_method_handle_stub
-// (Can any caller use this delay slot?  If so, add an option for supression.)
+// Some callers can fill the delay slot.
-delayed()->nop();
+if (emit_delayed_nop) {
-}
+delayed()->nop();
+}
+}
 RegisterOrConstant MacroAssembler::argument_offset(RegisterOrConstant arg_slot,
 int extra_slot_offset) {
 // cf. TemplateTable::prepare_invoke(), if (load_receiver).
-int stackElementSize = Interpreter::stackElementWords() * wordSize;
+int stackElementSize = Interpreter::stackElementSize();
-int offset = Interpreter::expr_offset_in_bytes(extra_slot_offset+0);
+int offset = extra_slot_offset * stackElementSize;
-int offset1 = Interpreter::expr_offset_in_bytes(extra_slot_offset+1);
-assert(offset1 - offset == stackElementSize, "correct arithmetic");
 if (arg_slot.is_constant()) {
 offset += arg_slot.as_constant() * stackElementSize;
 return offset;
 } else {
 Register temp = arg_slot.as_register();
 add(temp, offset, temp);
 return temp;
 }
 }
+Address MacroAssembler::argument_address(RegisterOrConstant arg_slot,
+int extra_slot_offset) {
+return Address(Gargs, argument_offset(arg_slot, extra_slot_offset));
+}
 void MacroAssembler::biased_locking_enter(Register obj_reg, Register mark_reg,
 Register temp_reg,
 Label& done, Label* slow_case,

Mercurial > hg > truffle

comparison src/cpu/sparc/vm/assembler_sparc.cpp @ 1503:c640000b7cc1