26 #include "c1/c1_Defs.hpp"
27 #include "c1/c1_MacroAssembler.hpp"
28 #include "c1/c1_Runtime1.hpp"
29 #include "ci/ciUtilities.hpp"
30 #include "gc/shared/cardTable.hpp"
31 #include "gc/shared/cardTableBarrierSet.hpp"
32 #include "interpreter/interpreter.hpp"
33 #include "nativeInst_sparc.hpp"
34 #include "oops/compiledICHolder.hpp"
35 #include "oops/oop.inline.hpp"
36 #include "prims/jvmtiExport.hpp"
37 #include "runtime/sharedRuntime.hpp"
38 #include "runtime/signature.hpp"
39 #include "runtime/vframeArray.hpp"
40 #include "utilities/macros.hpp"
41 #include "utilities/align.hpp"
42 #include "vmreg_sparc.inline.hpp"
43 #if INCLUDE_ALL_GCS
44 #include "gc/g1/g1BarrierSet.hpp"
45 #include "gc/g1/g1CardTable.hpp"
46 #endif
47
48 // Implementation of StubAssembler
49
50 int StubAssembler::call_RT(Register oop_result1, Register metadata_result, address entry_point, int number_of_arguments) {
51 // for sparc changing the number of arguments doesn't change
52 // anything about the frame size so we'll always lie and claim that
53 // we are only passing 1 argument.
54 set_num_rt_args(1);
55
56 assert_not_delayed();
57 // bang stack before going to runtime
58 set(-os::vm_page_size() + STACK_BIAS, G3_scratch);
59 st(G0, SP, G3_scratch);
60
61 // debugging support
62 assert(number_of_arguments >= 0 , "cannot have negative number of arguments");
63
64 set_last_Java_frame(SP, noreg);
65 if (VerifyThread) mov(G2_thread, O0); // about to be smashed; pass early
760
761 #if INCLUDE_ALL_GCS
762 case g1_pre_barrier_slow_id:
763 { // G4: previous value of memory
764 BarrierSet* bs = Universe::heap()->barrier_set();
765 if (bs->kind() != BarrierSet::G1BarrierSet) {
766 __ save_frame(0);
767 __ set((int)id, O1);
768 __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), I0);
769 __ should_not_reach_here();
770 break;
771 }
772
773 __ set_info("g1_pre_barrier_slow_id", dont_gc_arguments);
774
775 Register pre_val = G4;
776 Register tmp = G1_scratch;
777 Register tmp2 = G3_scratch;
778
779 Label refill, restart;
780 int satb_q_active_byte_offset =
781 in_bytes(JavaThread::satb_mark_queue_offset() +
782 SATBMarkQueue::byte_offset_of_active());
783 int satb_q_index_byte_offset =
784 in_bytes(JavaThread::satb_mark_queue_offset() +
785 SATBMarkQueue::byte_offset_of_index());
786 int satb_q_buf_byte_offset =
787 in_bytes(JavaThread::satb_mark_queue_offset() +
788 SATBMarkQueue::byte_offset_of_buf());
789
790 // Is marking still active?
791 if (in_bytes(SATBMarkQueue::byte_width_of_active()) == 4) {
792 __ ld(G2_thread, satb_q_active_byte_offset, tmp);
793 } else {
794 assert(in_bytes(SATBMarkQueue::byte_width_of_active()) == 1, "Assumption");
795 __ ldsb(G2_thread, satb_q_active_byte_offset, tmp);
796 }
797 __ cmp_and_br_short(tmp, G0, Assembler::notEqual, Assembler::pt, restart);
798 __ retl();
799 __ delayed()->nop();
800
801 __ bind(restart);
802 // Load the index into the SATB buffer. SATBMarkQueue::_index is a
803 // size_t so ld_ptr is appropriate
804 __ ld_ptr(G2_thread, satb_q_index_byte_offset, tmp);
805
806 // index == 0?
807 __ cmp_and_brx_short(tmp, G0, Assembler::equal, Assembler::pn, refill);
808
869 // We didn't take the branch, so we're already dirty: return.
870 // Use return-from-leaf
871 __ retl();
872 __ delayed()->nop();
873
874 // Not dirty.
875 __ bind(not_already_dirty);
876
877 // Get cardtable + tmp into a reg by itself
878 __ add(addr, cardtable, tmp2);
879
880 // First, dirty it.
881 __ stb(G0, tmp2, 0); // [cardPtr] := 0 (i.e., dirty).
882
883 Register tmp3 = cardtable;
884 Register tmp4 = tmp;
885
886 // these registers are now dead
887 addr = cardtable = tmp = noreg;
888
889 int dirty_card_q_index_byte_offset =
890 in_bytes(JavaThread::dirty_card_queue_offset() +
891 DirtyCardQueue::byte_offset_of_index());
892 int dirty_card_q_buf_byte_offset =
893 in_bytes(JavaThread::dirty_card_queue_offset() +
894 DirtyCardQueue::byte_offset_of_buf());
895
896 __ bind(restart);
897
898 // Get the index into the update buffer. DirtyCardQueue::_index is
899 // a size_t so ld_ptr is appropriate here.
900 __ ld_ptr(G2_thread, dirty_card_q_index_byte_offset, tmp3);
901
902 // index == 0?
903 __ cmp_and_brx_short(tmp3, G0, Assembler::equal, Assembler::pn, refill);
904
905 __ ld_ptr(G2_thread, dirty_card_q_buf_byte_offset, tmp4);
906 __ sub(tmp3, oopSize, tmp3);
907
908 __ st_ptr(tmp2, tmp4, tmp3); // [_buf + index] := <address_of_card>
909 // Use return-from-leaf
910 __ retl();
911 __ delayed()->st_ptr(tmp3, G2_thread, dirty_card_q_index_byte_offset);
912
913 __ bind(refill);
914
|
26 #include "c1/c1_Defs.hpp"
27 #include "c1/c1_MacroAssembler.hpp"
28 #include "c1/c1_Runtime1.hpp"
29 #include "ci/ciUtilities.hpp"
30 #include "gc/shared/cardTable.hpp"
31 #include "gc/shared/cardTableBarrierSet.hpp"
32 #include "interpreter/interpreter.hpp"
33 #include "nativeInst_sparc.hpp"
34 #include "oops/compiledICHolder.hpp"
35 #include "oops/oop.inline.hpp"
36 #include "prims/jvmtiExport.hpp"
37 #include "runtime/sharedRuntime.hpp"
38 #include "runtime/signature.hpp"
39 #include "runtime/vframeArray.hpp"
40 #include "utilities/macros.hpp"
41 #include "utilities/align.hpp"
42 #include "vmreg_sparc.inline.hpp"
43 #if INCLUDE_ALL_GCS
44 #include "gc/g1/g1BarrierSet.hpp"
45 #include "gc/g1/g1CardTable.hpp"
46 #include "gc/g1/g1ThreadLocalData.hpp"
47 #endif
48
49 // Implementation of StubAssembler
50
51 int StubAssembler::call_RT(Register oop_result1, Register metadata_result, address entry_point, int number_of_arguments) {
52 // for sparc changing the number of arguments doesn't change
53 // anything about the frame size so we'll always lie and claim that
54 // we are only passing 1 argument.
55 set_num_rt_args(1);
56
57 assert_not_delayed();
58 // bang stack before going to runtime
59 set(-os::vm_page_size() + STACK_BIAS, G3_scratch);
60 st(G0, SP, G3_scratch);
61
62 // debugging support
63 assert(number_of_arguments >= 0 , "cannot have negative number of arguments");
64
65 set_last_Java_frame(SP, noreg);
66 if (VerifyThread) mov(G2_thread, O0); // about to be smashed; pass early
761
762 #if INCLUDE_ALL_GCS
763 case g1_pre_barrier_slow_id:
764 { // G4: previous value of memory
765 BarrierSet* bs = Universe::heap()->barrier_set();
766 if (bs->kind() != BarrierSet::G1BarrierSet) {
767 __ save_frame(0);
768 __ set((int)id, O1);
769 __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), I0);
770 __ should_not_reach_here();
771 break;
772 }
773
774 __ set_info("g1_pre_barrier_slow_id", dont_gc_arguments);
775
776 Register pre_val = G4;
777 Register tmp = G1_scratch;
778 Register tmp2 = G3_scratch;
779
780 Label refill, restart;
781 int satb_q_active_byte_offset = in_bytes(G1ThreadLocalData::satb_mark_queue_active_offset());
782 int satb_q_index_byte_offset = in_bytes(G1ThreadLocalData::satb_mark_queue_index_offset());
783 int satb_q_buf_byte_offset = in_bytes(G1ThreadLocalData::satb_mark_queue_buffer_offset());
784
785 // Is marking still active?
786 if (in_bytes(SATBMarkQueue::byte_width_of_active()) == 4) {
787 __ ld(G2_thread, satb_q_active_byte_offset, tmp);
788 } else {
789 assert(in_bytes(SATBMarkQueue::byte_width_of_active()) == 1, "Assumption");
790 __ ldsb(G2_thread, satb_q_active_byte_offset, tmp);
791 }
792 __ cmp_and_br_short(tmp, G0, Assembler::notEqual, Assembler::pt, restart);
793 __ retl();
794 __ delayed()->nop();
795
796 __ bind(restart);
797 // Load the index into the SATB buffer. SATBMarkQueue::_index is a
798 // size_t so ld_ptr is appropriate
799 __ ld_ptr(G2_thread, satb_q_index_byte_offset, tmp);
800
801 // index == 0?
802 __ cmp_and_brx_short(tmp, G0, Assembler::equal, Assembler::pn, refill);
803
864 // We didn't take the branch, so we're already dirty: return.
865 // Use return-from-leaf
866 __ retl();
867 __ delayed()->nop();
868
869 // Not dirty.
870 __ bind(not_already_dirty);
871
872 // Get cardtable + tmp into a reg by itself
873 __ add(addr, cardtable, tmp2);
874
875 // First, dirty it.
876 __ stb(G0, tmp2, 0); // [cardPtr] := 0 (i.e., dirty).
877
878 Register tmp3 = cardtable;
879 Register tmp4 = tmp;
880
881 // these registers are now dead
882 addr = cardtable = tmp = noreg;
883
884 int dirty_card_q_index_byte_offset = in_bytes(G1ThreadLocalData::dirty_card_queue_index_offset());
885 int dirty_card_q_buf_byte_offset = in_bytes(G1ThreadLocalData::dirty_card_queue_buffer_offset());
886
887 __ bind(restart);
888
889 // Get the index into the update buffer. DirtyCardQueue::_index is
890 // a size_t so ld_ptr is appropriate here.
891 __ ld_ptr(G2_thread, dirty_card_q_index_byte_offset, tmp3);
892
893 // index == 0?
894 __ cmp_and_brx_short(tmp3, G0, Assembler::equal, Assembler::pn, refill);
895
896 __ ld_ptr(G2_thread, dirty_card_q_buf_byte_offset, tmp4);
897 __ sub(tmp3, oopSize, tmp3);
898
899 __ st_ptr(tmp2, tmp4, tmp3); // [_buf + index] := <address_of_card>
900 // Use return-from-leaf
901 __ retl();
902 __ delayed()->st_ptr(tmp3, G2_thread, dirty_card_q_index_byte_offset);
903
904 __ bind(refill);
905
|