jdk-sandbox: comparison hotspot/src/cpu/sparc/vm/templateTable

equal deleted inserted replaced

-:ecc7862946d4
+:6c972d3d2144
 /*
-* 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.
 // Miscelaneous helper routines
 Address TemplateTable::at_bcp(int offset) {
 assert(_desc->uses_bcp(), "inconsistent uses_bcp information");
-return Address( Lbcp, 0, offset);
+return Address(Lbcp, offset);
 }
 void TemplateTable::patch_bytecode(Bytecodes::Code bc, Register Rbyte_code,
 Register Rscratch,
 default: ShouldNotReachHere();
 case 0:  p = &zero;  break;
 case 1:  p = &one;   break;
 case 2:  p = &two;   break;
 }
-Address a(G3_scratch, (address)p);
+AddressLiteral a(p);
-__ sethi(a);
+__ sethi(a, G3_scratch);
-__ ldf(FloatRegisterImpl::S, a, Ftos_f);
+__ ldf(FloatRegisterImpl::S, G3_scratch, a.low10(), Ftos_f);
 }
 void TemplateTable::dconst(int value) {
 transition(vtos, dtos);
 switch( value ) {
 default: ShouldNotReachHere();
 case 0:  p = &zero;  break;
 case 1:  p = &one;   break;
 }
-Address a(G3_scratch, (address)p);
+AddressLiteral a(p);
-__ sethi(a);
+__ sethi(a, G3_scratch);
-__ ldf(FloatRegisterImpl::D, a, Ftos_d);
+__ ldf(FloatRegisterImpl::D, G3_scratch, a.low10(), Ftos_d);
 }
 // %%%%% Should factore most snippet templates across platforms
 // Handle all the JSR stuff here, then exit.
 // It's much shorter and cleaner than intermingling with the
 // non-JSR normal-branch stuff occurring below.
 if( is_jsr ) {
 // compute return address as bci in Otos_i
-__ ld_ptr(Address(Lmethod, 0, in_bytes(methodOopDesc::const_offset())), G3_scratch);
+__ ld_ptr(Lmethod, methodOopDesc::const_offset(), G3_scratch);
 __ sub(Lbcp, G3_scratch, G3_scratch);
 __ sub(G3_scratch, in_bytes(constMethodOopDesc::codes_offset()) - (is_wide ? 5 : 3), Otos_i);
 // Bump Lbcp to target of JSR
 __ add(Lbcp, O1_disp, Lbcp);
 #endif
 #endif
 __ profile_ret(vtos, Otos_i, G4_scratch);
-__ ld_ptr(Address(Lmethod, 0, in_bytes(methodOopDesc::const_offset())), G3_scratch);
+__ ld_ptr(Lmethod, methodOopDesc::const_offset(), G3_scratch);
 __ add(G3_scratch, Otos_i, G3_scratch);
 __ add(G3_scratch, in_bytes(constMethodOopDesc::codes_offset()), Lbcp);
 __ dispatch_next(vtos);
 }
 __ access_local_returnAddress(G3_scratch, Otos_i);
 // Otos_i contains the bci, compute the bcp from that
 __ profile_ret(vtos, Otos_i, G4_scratch);
-__ ld_ptr(Address(Lmethod, 0, in_bytes(methodOopDesc::const_offset())), G3_scratch);
+__ ld_ptr(Lmethod, methodOopDesc::const_offset(), G3_scratch);
 __ add(G3_scratch, Otos_i, G3_scratch);
 __ add(G3_scratch, in_bytes(constMethodOopDesc::codes_offset()), Lbcp);
 __ dispatch_next(vtos);
 }
 // Depends on cpCacheOop layout!
 const int shift_count = (1 + byte_no)*BitsPerByte;
 Label resolved;
 __ get_cache_and_index_at_bcp(Rcache, index, 1);
-__ ld_ptr(Address(Rcache, 0, in_bytes(constantPoolCacheOopDesc::base_offset() +
+__ ld_ptr(Rcache, constantPoolCacheOopDesc::base_offset() +
-ConstantPoolCacheEntry::indices_offset())), Lbyte_code);
+ConstantPoolCacheEntry::indices_offset(), Lbyte_code);
 __ srl(  Lbyte_code, shift_count, Lbyte_code );
 __ and3( Lbyte_code,        0xFF, Lbyte_code );
 __ cmp(  Lbyte_code, (int)bytecode());
 __ br(   Assembler::equal, false, Assembler::pt, resolved);
 __ get_cache_and_index_at_bcp(Rcache, Rscratch, 1);
 } else {
 resolve_cache_and_index(byte_no, Rcache, Rscratch);
 }
-__ ld_ptr(Address(Rcache, 0, method_offset), Rmethod);
+__ ld_ptr(Rcache, method_offset, Rmethod);
 if (Ritable_index != noreg) {
-__ ld_ptr(Address(Rcache, 0, index_offset), Ritable_index);
+__ ld_ptr(Rcache, index_offset, Ritable_index);
 }
-__ ld_ptr(Address(Rcache, 0, flags_offset),  Rflags);
+__ ld_ptr(Rcache, flags_offset, Rflags);
 }
 // The Rcache register must be set before call
 void TemplateTable::load_field_cp_cache_entry(Register Robj,
 Register Rcache,
 bool is_static) {
 assert_different_registers(Rcache, Rflags, Roffset);
 ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset();
-__ ld_ptr(Address(Rcache, 0, in_bytes(cp_base_offset +
+__ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::flags_offset(), Rflags);
-ConstantPoolCacheEntry::flags_offset())), Rflags);
+__ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f2_offset(), Roffset);
-__ ld_ptr(Address(Rcache, 0, in_bytes(cp_base_offset +
-ConstantPoolCacheEntry::f2_offset())), Roffset);
 if (is_static) {
-__ ld_ptr(Address(Rcache, 0, in_bytes(cp_base_offset +
+__ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f1_offset(), Robj);
-ConstantPoolCacheEntry::f1_offset())), Robj);
 }
 }
 // The registers Rcache and index expected to be set before call.
 // Correct values of the Rcache and index registers are preserved.
 if (JvmtiExport::can_post_field_access()) {
 // Check to see if a field access watch has been set before we take
 // the time to call into the VM.
 Label Label1;
 assert_different_registers(Rcache, index, G1_scratch);
-Address get_field_access_count_addr(G1_scratch,
+AddressLiteral get_field_access_count_addr(JvmtiExport::get_field_access_count_addr());
-(address)JvmtiExport::get_field_access_count_addr(),
-relocInfo::none);
 __ load_contents(get_field_access_count_addr, G1_scratch);
 __ tst(G1_scratch);
 __ br(Assembler::zero, false, Assembler::pt, Label1);
 __ delayed()->nop();
 ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset();
 __ get_cache_and_index_at_bcp(Rcache, index, 1);
 jvmti_post_field_access(Rcache, index, /*is_static*/false, /*has_tos*/true);
-__ ld_ptr(Address(Rcache, 0, in_bytes(cp_base_offset + ConstantPoolCacheEntry::f2_offset())), Roffset);
+__ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f2_offset(), Roffset);
 __ null_check(Otos_i);
 __ verify_oop(Otos_i);
 Label exit;
 Assembler::Membar_mask_bits membar_bits =
 Assembler::Membar_mask_bits(Assembler::LoadLoad | Assembler::LoadStore);
 if (__ membar_has_effect(membar_bits)) {
 // Get volatile flag
-__ ld_ptr(Address(Rcache, 0, in_bytes(cp_base_offset + ConstantPoolCacheEntry::f2_offset())), Rflags);
+__ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f2_offset(), Rflags);
 __ set((1 << ConstantPoolCacheEntry::volatileField), Lscratch);
 }
 switch (bytecode()) {
 case Bytecodes::_fast_bgetfield:
 void TemplateTable::jvmti_post_fast_field_mod() {
 if (JvmtiExport::can_post_field_modification()) {
 // Check to see if a field modification watch has been set before we take
 // the time to call into the VM.
 Label done;
-Address get_field_modification_count_addr(G4_scratch, (address)JvmtiExport::get_field_modification_count_addr(), relocInfo::none);
+AddressLiteral get_field_modification_count_addr(JvmtiExport::get_field_modification_count_addr());
 __ load_contents(get_field_modification_count_addr, G4_scratch);
 __ tst(G4_scratch);
 __ br(Assembler::zero, false, Assembler::pt, done);
 __ delayed()->nop();
 __ pop_ptr(G4_scratch);     // copy the object pointer from tos
 if (JvmtiExport::can_post_field_modification()) {
 // Check to see if a field modification watch has been set before we take
 // the time to call into the VM.
 Label Label1;
 assert_different_registers(Rcache, index, G1_scratch);
-Address get_field_modification_count_addr(G1_scratch,
+AddressLiteral get_field_modification_count_addr(JvmtiExport::get_field_modification_count_addr());
-(address)JvmtiExport::get_field_modification_count_addr(),
-relocInfo::none);
 __ load_contents(get_field_modification_count_addr, G1_scratch);
 __ tst(G1_scratch);
 __ br(Assembler::zero, false, Assembler::pt, Label1);
 __ delayed()->nop();
 // object.  We don't know the size of the value, though; it could be
 // one or two words depending on its type. As a result, we must find
 // the type to determine where the object is.
 Label two_word, valsizeknown;
-__ ld_ptr(Address(G1_scratch, 0, in_bytes(cp_base_offset + ConstantPoolCacheEntry::flags_offset())), Rflags);
+__ ld_ptr(G1_scratch, cp_base_offset + ConstantPoolCacheEntry::flags_offset(), Rflags);
 __ mov(Lesp, G4_scratch);
 __ srl(Rflags, ConstantPoolCacheEntry::tosBits, Rflags);
 // Make sure we don't need to mask Rflags for tosBits after the above shift
 ConstantPoolCacheEntry::verify_tosBits();
 __ cmp(Rflags, ltos);
 Assembler::Membar_mask_bits(Assembler::LoadStore | Assembler::StoreStore);
 Assembler::Membar_mask_bits write_bits = Assembler::StoreLoad;
 Label notVolatile, checkVolatile, exit;
 if (__ membar_has_effect(read_bits) || __ membar_has_effect(write_bits)) {
-__ ld_ptr(Address(Rcache, 0, in_bytes(cp_base_offset +
+__ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::flags_offset(), Rflags);
-ConstantPoolCacheEntry::flags_offset())), Rflags);
 __ set((1 << ConstantPoolCacheEntry::volatileField), Lscratch);
 __ and3(Rflags, Lscratch, Lscratch);
 if (__ membar_has_effect(read_bits)) {
 __ tst(Lscratch);
 __ br(Assembler::zero, false, Assembler::pt, notVolatile);
 volatile_barrier(read_bits);
 __ bind(notVolatile);
 }
 }
-__ ld_ptr(Address(Rcache, 0, in_bytes(cp_base_offset +
+__ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f2_offset(), Roffset);
-ConstantPoolCacheEntry::f2_offset())), Roffset);
 pop_and_check_object(Rclass);
 switch (bytecode()) {
 case Bytecodes::_fast_bputfield: __ stb(Otos_i, Rclass, Roffset); break;
 case Bytecodes::_fast_cputfield: /* fall through */
 __ ld_ptr(Llocals, Interpreter::value_offset_in_bytes(), Rreceiver);
 // access constant pool cache  (is resolved)
 __ get_cache_and_index_at_bcp(Rcache, G4_scratch, 2);
-__ ld_ptr(Address(Rcache, 0, in_bytes(constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::f2_offset())), Roffset);
+__ ld_ptr(Rcache, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::f2_offset(), Roffset);
 __ add(Lbcp, 1, Lbcp);       // needed to report exception at the correct bcp
 __ verify_oop(Rreceiver);
 __ null_check(Rreceiver);
 if (state == atos) {
 Assembler::Membar_mask_bits membar_bits =
 Assembler::Membar_mask_bits(Assembler::LoadLoad | Assembler::LoadStore);
 if (__ membar_has_effect(membar_bits)) {
 // Get is_volatile value in Rflags and check if membar is needed
-__ ld_ptr(Address(Rcache, 0, in_bytes(constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::flags_offset())), Rflags);
+__ ld_ptr(Rcache, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::flags_offset(), Rflags);
 // Test volatile
 Label notVolatile;
 __ set((1 << ConstantPoolCacheEntry::volatileField), Lscratch);
 __ btst(Rflags, Lscratch);
 __ load_receiver(G4_scratch, O0);  // gets receiverOop
 // receiver is in O0
 __ verify_oop(O0);
 // get return address
-Address table(Rtemp, (address)Interpreter::return_3_addrs_by_index_table());
+AddressLiteral table(Interpreter::return_3_addrs_by_index_table());
-__ load_address(table);
+__ set(table, Rtemp);
 __ srl(Rret, ConstantPoolCacheEntry::tosBits, Rret);          // get return type
 // Make sure we don't need to mask Rret for tosBits after the above shift
 ConstantPoolCacheEntry::verify_tosBits();
 __ sll(Rret,  LogBytesPerWord, Rret);
 __ ld_ptr(Rtemp, Rret, Rret);         // get return address
 Register Rtemp = G4_scratch;
 __ verify_oop(G5_method);
 // Load receiver from stack slot
-__ lduh(Address(G5_method, 0, in_bytes(methodOopDesc::size_of_parameters_offset())), G4_scratch);
+__ lduh(G5_method, in_bytes(methodOopDesc::size_of_parameters_offset()), G4_scratch);
 __ load_receiver(G4_scratch, O0);
 // receiver NULL check
 __ null_check(O0);
 __ profile_final_call(O4);
 // get return address
-Address table(Rtemp, (address)Interpreter::return_3_addrs_by_index_table());
+AddressLiteral table(Interpreter::return_3_addrs_by_index_table());
-__ load_address(table);
+__ set(table, Rtemp);
 __ srl(Rret, ConstantPoolCacheEntry::tosBits, Rret);          // get return type
 // Make sure we don't need to mask Rret for tosBits after the above shift
 ConstantPoolCacheEntry::verify_tosBits();
 __ sll(Rret,  LogBytesPerWord, Rret);
 __ ld_ptr(Rtemp, Rret, Rret);         // get return address
 load_invoke_cp_cache_entry(byte_no, G5_method, noreg, Rret, false);
 __ mov(SP, O5_savedSP); // record SP that we wanted the callee to restore
 __ verify_oop(G5_method);
-__ lduh(Address(G5_method, 0, in_bytes(methodOopDesc::size_of_parameters_offset())), G4_scratch);
+__ lduh(G5_method, in_bytes(methodOopDesc::size_of_parameters_offset()), G4_scratch);
 __ load_receiver(G4_scratch, O0);
 // receiver NULL check
 __ null_check(O0);
 __ profile_call(O4);
 // get return address
-Address table(Rtemp, (address)Interpreter::return_3_addrs_by_index_table());
+AddressLiteral table(Interpreter::return_3_addrs_by_index_table());
-__ load_address(table);
+__ set(table, Rtemp);
 __ srl(Rret, ConstantPoolCacheEntry::tosBits, Rret);          // get return type
 // Make sure we don't need to mask Rret for tosBits after the above shift
 ConstantPoolCacheEntry::verify_tosBits();
 __ sll(Rret,  LogBytesPerWord, Rret);
 __ ld_ptr(Rtemp, Rret, Rret);         // get return address
 __ verify_oop(G5_method);
 __ profile_call(O4);
 // get return address
-Address table(Rtemp, (address)Interpreter::return_3_addrs_by_index_table());
+AddressLiteral table(Interpreter::return_3_addrs_by_index_table());
-__ load_address(table);
+__ set(table, Rtemp);
 __ srl(Rret, ConstantPoolCacheEntry::tosBits, Rret);          // get return type
 // Make sure we don't need to mask Rret for tosBits after the above shift
 ConstantPoolCacheEntry::verify_tosBits();
 __ sll(Rret,  LogBytesPerWord, Rret);
 __ ld_ptr(Rtemp, Rret, Rret);         // get return address
 __ verify_oop(O0);
 __ mov(Rflags, Rret);
 // get return address
-Address table(Rscratch, (address)Interpreter::return_5_addrs_by_index_table());
+AddressLiteral table(Interpreter::return_5_addrs_by_index_table());
-__ load_address(table);
+__ set(table, Rscratch);
 __ srl(Rret, ConstantPoolCacheEntry::tosBits, Rret);          // get return type
 // Make sure we don't need to mask Rret for tosBits after the above shift
 ConstantPoolCacheEntry::verify_tosBits();
 __ sll(Rret,  LogBytesPerWord, Rret);
 __ ld_ptr(Rscratch, Rret, Rret);      // get return address
 // compute start of first itableOffsetEntry (which is at end of vtable)
 const int base = instanceKlass::vtable_start_offset() * wordSize;
 Label search;
 Register Rtemp = Rflags;
-__ ld(Address(RklassOop, 0, instanceKlass::vtable_length_offset() * wordSize), Rtemp);
+__ ld(RklassOop, instanceKlass::vtable_length_offset() * wordSize, Rtemp);
 if (align_object_offset(1) > 1) {
 __ round_to(Rtemp, align_object_offset(1));
 }
 __ sll(Rtemp, LogBytesPerWord, Rtemp);   // Rscratch *= 4;
 if (Assembler::is_simm13(base)) {
 void TemplateTable::wide() {
 transition(vtos, vtos);
 __ ldub(Lbcp, 1, G3_scratch);// get next bc
 __ sll(G3_scratch, LogBytesPerWord, G3_scratch);
-Address ep(G4_scratch, (address)Interpreter::_wentry_point);
+AddressLiteral ep(Interpreter::_wentry_point);
-__ load_address(ep);
+__ set(ep, G4_scratch);
-__ ld_ptr(ep.base(), G3_scratch, G3_scratch);
+__ ld_ptr(G4_scratch, G3_scratch, G3_scratch);
 __ jmp(G3_scratch, G0);
 __ delayed()->nop();
 // Note: the Lbcp increment step is part of the individual wide bytecode implementations
 }

changeset 2572	6c972d3d2144
parent 2570	ecc7862946d4
parent 2571	d602ad6538bd
child 5416	5f6377fcfd3e