truffle: src/cpu/sparc/vm/assembler

comparison src/cpu/sparc/vm/assembler_sparc.cpp @ 665:c89f86385056

6814659: separable cleanups and subroutines for 6655638 Summary: preparatory but separable changes for method handles Reviewed-by: kvn, never

author	jrose
date	Fri, 20 Mar 2009 23:19:36 -0700
parents	c517646eef23
children	a80d48f6fde1

comparison

equal deleted inserted replaced

-:bd441136a5ce
+:c89f86385056
 /*
-* Copyright 1997-2008 Sun Microsystems, Inc.  All Rights Reserved.
+* Copyright 1997-2009 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.
 restore();
 }
 }
-RegisterConstant MacroAssembler::delayed_value(intptr_t* delayed_value_addr,
+RegisterOrConstant MacroAssembler::delayed_value_impl(intptr_t* delayed_value_addr,
 Register tmp,
 int offset) {
 intptr_t value = *delayed_value_addr;
 if (value != 0)
-return RegisterConstant(value + offset);
+return RegisterOrConstant(value + offset);
 // load indirectly to solve generation ordering problem
 Address a(tmp, (address) delayed_value_addr);
 load_ptr_contents(a, tmp);
 #endif
 if (offset != 0)
 add(tmp, offset, tmp);
-return RegisterConstant(tmp);
+return RegisterOrConstant(tmp);
 }
-void MacroAssembler::regcon_inc_ptr( RegisterConstant& dest, RegisterConstant src, Register temp ) {
+void MacroAssembler::regcon_inc_ptr( RegisterOrConstant& dest, RegisterOrConstant src, Register temp ) {
 assert(dest.register_or_noreg() != G0, "lost side effect");
 if ((src.is_constant() && src.as_constant() == 0) ||
 (src.is_register() && src.as_register() == G0)) {
 // do nothing
 } else if (dest.is_register()) {
 add(dest.as_register(), ensure_rs2(src, temp), dest.as_register());
 } else if (src.is_constant()) {
 intptr_t res = dest.as_constant() + src.as_constant();
-dest = RegisterConstant(res); // side effect seen by caller
+dest = RegisterOrConstant(res); // side effect seen by caller
 } else {
 assert(temp != noreg, "cannot handle constant += register");
 add(src.as_register(), ensure_rs2(dest, temp), temp);
-dest = RegisterConstant(temp); // side effect seen by caller
+dest = RegisterOrConstant(temp); // side effect seen by caller
 }
 }
-void MacroAssembler::regcon_sll_ptr( RegisterConstant& dest, RegisterConstant src, Register temp ) {
+void MacroAssembler::regcon_sll_ptr( RegisterOrConstant& dest, RegisterOrConstant src, Register temp ) {
 assert(dest.register_or_noreg() != G0, "lost side effect");
 if (!is_simm13(src.constant_or_zero()))
 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()) {
 sll_ptr(dest.as_register(), src, dest.as_register());
 } else if (src.is_constant()) {
 intptr_t res = dest.as_constant() << src.as_constant();
-dest = RegisterConstant(res); // side effect seen by caller
+dest = RegisterOrConstant(res); // side effect seen by caller
 } else {
 assert(temp != noreg, "cannot handle constant <<= register");
 set(dest.as_constant(), temp);
 sll_ptr(temp, src, temp);
-dest = RegisterConstant(temp); // side effect seen by caller
+dest = RegisterOrConstant(temp); // side effect seen by caller
 }
 }
 // Look up the method for a megamorphic invokeinterface call.
 // The receiver klass is in recv_klass.
 // On success, the result will be in method_result, and execution falls through.
 // On failure, execution transfers to the given label.
 void MacroAssembler::lookup_interface_method(Register recv_klass,
 Register intf_klass,
-RegisterConstant itable_index,
+RegisterOrConstant itable_index,
 Register method_result,
 Register scan_temp,
 Register sethi_temp,
 Label& L_no_such_interface) {
 assert_different_registers(recv_klass, intf_klass, method_result, scan_temp);
 and3(scan_temp, -round_to_unit, scan_temp);
 }
 add(recv_klass, scan_temp, scan_temp);
 // Adjust recv_klass by scaled itable_index, so we can free itable_index.
-RegisterConstant itable_offset = itable_index;
+RegisterOrConstant itable_offset = itable_index;
 regcon_sll_ptr(itable_offset, exact_log2(itableMethodEntry::size() * wordSize));
 regcon_inc_ptr(itable_offset, itableMethodEntry::method_offset_in_bytes());
 add(recv_klass, ensure_rs2(itable_offset, sethi_temp), recv_klass);
 // for (scan = klass->itable(); scan->interface() != NULL; scan += scan_step) {
 Register temp_reg,
 Register temp2_reg,
 Label* L_success,
 Label* L_failure,
 Label* L_slow_path,
-RegisterConstant super_check_offset,
+RegisterOrConstant super_check_offset,
 Register instanceof_hack) {
 int sc_offset = (klassOopDesc::header_size() * HeapWordSize +
 Klass::secondary_super_cache_offset_in_bytes());
 int sco_offset = (klassOopDesc::header_size() * HeapWordSize +
 Klass::super_check_offset_offset_in_bytes());
 // 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 = RegisterConstant(temp2_reg);
+super_check_offset = RegisterOrConstant(temp2_reg);
 }
 ld_ptr(sub_klass, super_check_offset, temp_reg);
 cmp(super_klass, temp_reg);
 // This check has worked decisively for primary supers.
 bs->kind() == BarrierSet::CardTableExtension, "wrong barrier");
 card_table_write(bs->byte_map_base, tmp, store_addr);
 }
 // Loading values by size and signed-ness
-void MacroAssembler::load_sized_value(Register s1, RegisterConstant s2, Register d,
+void MacroAssembler::load_sized_value(Register s1, RegisterOrConstant s2, Register d,
 int size_in_bytes, bool is_signed) {
 switch (size_in_bytes ^ (is_signed ? -1 : 0)) {
 case ~8:  // fall through:
 case  8:  ld_long( s1, s2, d ); break;
 case ~4:  ldsw(    s1, s2, d ); break;

Mercurial > hg > truffle

comparison src/cpu/sparc/vm/assembler_sparc.cpp @ 665:c89f86385056