jdk-sandbox: comparison src/hotspot/cpu/sparc/stubGenerator

equal deleted inserted replaced

-:c749ecf599c0
+:3f3dc00a69a5
 __ srl(left_shift, LogBitsPerByte, left_shift);    // misaligned bytes
 __ br(Assembler::always, false, Assembler::pt, L_copy_bytes);
 __ delayed()->add(end_from, left_shift, end_from); // restore address
 }
+address generate_unsafecopy_common_error_exit() {
+address start_pc = __ pc();
+if (UseBlockCopy) {
+__ wrasi(G0, Assembler::ASI_PRIMARY_NOFAULT);
+__ membar(Assembler::StoreLoad);
+}
+__ retl();
+__ delayed()->mov(G0, O0); // return 0
+return start_pc;
+}
 //
 //  Generate stub for disjoint byte copy.  If "aligned" is true, the
 //  "from" and "to" addresses are assumed to be heapword aligned.
 //
 // Arguments for generated stub:
 *entry = __ pc();
 // caller can pass a 64-bit byte count here (from Unsafe.copyMemory)
 BLOCK_COMMENT("Entry:");
 }
-// for short arrays, just do single element copy
+{
-__ cmp(count, 23); // 16 + 7
+// UnsafeCopyMemory page error: continue at UnsafeCopyMemory common_error_exit
-__ brx(Assembler::less, false, Assembler::pn, L_copy_byte);
+UnsafeCopyMemoryMark ucmm(this, !aligned, false);
-__ delayed()->mov(G0, offset);
+// for short arrays, just do single element copy
-if (aligned) {
+__ cmp(count, 23); // 16 + 7
-// 'aligned' == true when it is known statically during compilation
+__ brx(Assembler::less, false, Assembler::pn, L_copy_byte);
-// of this arraycopy call site that both 'from' and 'to' addresses
+__ delayed()->mov(G0, offset);
-// are HeapWordSize aligned (see LibraryCallKit::basictype2arraycopy()).
-//
+if (aligned) {
-// Aligned arrays have 4 bytes alignment in 32-bits VM
+// 'aligned' == true when it is known statically during compilation
-// and 8 bytes - in 64-bits VM. So we do it only for 32-bits VM
+// of this arraycopy call site that both 'from' and 'to' addresses
-//
+// are HeapWordSize aligned (see LibraryCallKit::basictype2arraycopy()).
-} else {
+//
-// copy bytes to align 'to' on 8 byte boundary
+// Aligned arrays have 4 bytes alignment in 32-bits VM
-__ andcc(to, 7, G1); // misaligned bytes
+// and 8 bytes - in 64-bits VM. So we do it only for 32-bits VM
-__ br(Assembler::zero, false, Assembler::pt, L_skip_alignment);
+//
-__ delayed()->neg(G1);
+} else {
-__ inc(G1, 8);       // bytes need to copy to next 8-bytes alignment
+// copy bytes to align 'to' on 8 byte boundary
-__ sub(count, G1, count);
+__ andcc(to, 7, G1); // misaligned bytes
-__ BIND(L_align);
+__ br(Assembler::zero, false, Assembler::pt, L_skip_alignment);
-__ ldub(from, 0, O3);
+__ delayed()->neg(G1);
-__ deccc(G1);
+__ inc(G1, 8);       // bytes need to copy to next 8-bytes alignment
-__ inc(from);
+__ sub(count, G1, count);
-__ stb(O3, to, 0);
+__ BIND(L_align);
-__ br(Assembler::notZero, false, Assembler::pt, L_align);
+__ ldub(from, 0, O3);
-__ delayed()->inc(to);
+__ deccc(G1);
-__ BIND(L_skip_alignment);
+__ inc(from);
-}
+__ stb(O3, to, 0);
-if (!aligned) {
+__ br(Assembler::notZero, false, Assembler::pt, L_align);
-// Copy with shift 16 bytes per iteration if arrays do not have
+__ delayed()->inc(to);
-// the same alignment mod 8, otherwise fall through to the next
+__ BIND(L_skip_alignment);
-// code for aligned copy.
+}
-// The compare above (count >= 23) guarantes 'count' >= 16 bytes.
+if (!aligned) {
-// Also jump over aligned copy after the copy with shift completed.
+// Copy with shift 16 bytes per iteration if arrays do not have
+// the same alignment mod 8, otherwise fall through to the next
-copy_16_bytes_forward_with_shift(from, to, count, 0, L_copy_byte);
+// code for aligned copy.
-}
+// The compare above (count >= 23) guarantes 'count' >= 16 bytes.
+// Also jump over aligned copy after the copy with shift completed.
-// Both array are 8 bytes aligned, copy 16 bytes at a time
+copy_16_bytes_forward_with_shift(from, to, count, 0, L_copy_byte);
+}
+// Both array are 8 bytes aligned, copy 16 bytes at a time
 __ and3(count, 7, G4); // Save count
 __ srl(count, 3, count);
 generate_disjoint_long_copy_core(aligned);
 __ mov(G4, count);     // Restore count
 // copy tailing bytes
 __ BIND(L_copy_byte);
 __ cmp_and_br_short(count, 0, Assembler::equal, Assembler::pt, L_exit);
 __ align(OptoLoopAlignment);
 __ BIND(L_copy_byte_loop);
 __ ldub(from, offset, O3);
 __ deccc(count);
 __ stb(O3, to, offset);
 __ brx(Assembler::notZero, false, Assembler::pt, L_copy_byte_loop);
 __ delayed()->inc(offset);
+}
 __ BIND(L_exit);
 // O3, O4 are used as temp registers
 inc_counter_np(SharedRuntime::_jbyte_array_copy_ctr, O3, O4);
 __ retl();
 BLOCK_COMMENT("Entry:");
 }
 array_overlap_test(nooverlap_target, 0);
-__ add(to, count, end_to);       // offset after last copied element
-// for short arrays, just do single element copy
-__ cmp(count, 23); // 16 + 7
-__ brx(Assembler::less, false, Assembler::pn, L_copy_byte);
-__ delayed()->add(from, count, end_from);
 {
-// Align end of arrays since they could be not aligned even
+// UnsafeCopyMemory page error: continue at UnsafeCopyMemory common_error_exit
-// when arrays itself are aligned.
+UnsafeCopyMemoryMark ucmm(this, !aligned, false);
-// copy bytes to align 'end_to' on 8 byte boundary
+__ add(to, count, end_to);       // offset after last copied element
-__ andcc(end_to, 7, G1); // misaligned bytes
-__ br(Assembler::zero, false, Assembler::pt, L_skip_alignment);
+// for short arrays, just do single element copy
-__ delayed()->nop();
+__ cmp(count, 23); // 16 + 7
-__ sub(count, G1, count);
+__ brx(Assembler::less, false, Assembler::pn, L_copy_byte);
-__ BIND(L_align);
+__ delayed()->add(from, count, end_from);
-__ dec(end_from);
-__ dec(end_to);
+{
-__ ldub(end_from, 0, O3);
+// Align end of arrays since they could be not aligned even
-__ deccc(G1);
+// when arrays itself are aligned.
-__ brx(Assembler::notZero, false, Assembler::pt, L_align);
-__ delayed()->stb(O3, end_to, 0);
+// copy bytes to align 'end_to' on 8 byte boundary
-__ BIND(L_skip_alignment);
+__ andcc(end_to, 7, G1); // misaligned bytes
-}
+__ br(Assembler::zero, false, Assembler::pt, L_skip_alignment);
-if (aligned) {
+__ delayed()->nop();
-// Both arrays are aligned to 8-bytes in 64-bits VM.
+__ sub(count, G1, count);
-// The 'count' is decremented in copy_16_bytes_backward_with_shift()
+__ BIND(L_align);
-// in unaligned case.
+__ dec(end_from);
-__ dec(count, 16);
+__ dec(end_to);
-} else {
+__ ldub(end_from, 0, O3);
-// Copy with shift 16 bytes per iteration if arrays do not have
+__ deccc(G1);
-// the same alignment mod 8, otherwise jump to the next
+__ brx(Assembler::notZero, false, Assembler::pt, L_align);
-// code for aligned copy (and substracting 16 from 'count' before jump).
+__ delayed()->stb(O3, end_to, 0);
-// The compare above (count >= 11) guarantes 'count' >= 16 bytes.
+__ BIND(L_skip_alignment);
-// Also jump over aligned copy after the copy with shift completed.
+}
+if (aligned) {
-copy_16_bytes_backward_with_shift(end_from, end_to, count, 16,
+// Both arrays are aligned to 8-bytes in 64-bits VM.
-L_aligned_copy, L_copy_byte);
+// The 'count' is decremented in copy_16_bytes_backward_with_shift()
-}
+// in unaligned case.
-// copy 4 elements (16 bytes) at a time
+__ dec(count, 16);
-__ align(OptoLoopAlignment);
+} else {
-__ BIND(L_aligned_copy);
+// Copy with shift 16 bytes per iteration if arrays do not have
-__ dec(end_from, 16);
+// the same alignment mod 8, otherwise jump to the next
-__ ldx(end_from, 8, O3);
+// code for aligned copy (and substracting 16 from 'count' before jump).
-__ ldx(end_from, 0, O4);
+// The compare above (count >= 11) guarantes 'count' >= 16 bytes.
-__ dec(end_to, 16);
+// Also jump over aligned copy after the copy with shift completed.
-__ deccc(count, 16);
-__ stx(O3, end_to, 8);
+copy_16_bytes_backward_with_shift(end_from, end_to, count, 16,
-__ brx(Assembler::greaterEqual, false, Assembler::pt, L_aligned_copy);
+L_aligned_copy, L_copy_byte);
-__ delayed()->stx(O4, end_to, 0);
+}
-__ inc(count, 16);
+// copy 4 elements (16 bytes) at a time
+__ align(OptoLoopAlignment);
-// copy 1 element (2 bytes) at a time
+__ BIND(L_aligned_copy);
-__ BIND(L_copy_byte);
+__ dec(end_from, 16);
-__ cmp_and_br_short(count, 0, Assembler::equal, Assembler::pt, L_exit);
+__ ldx(end_from, 8, O3);
-__ align(OptoLoopAlignment);
+__ ldx(end_from, 0, O4);
-__ BIND(L_copy_byte_loop);
+__ dec(end_to, 16);
-__ dec(end_from);
+__ deccc(count, 16);
-__ dec(end_to);
+__ stx(O3, end_to, 8);
-__ ldub(end_from, 0, O4);
+__ brx(Assembler::greaterEqual, false, Assembler::pt, L_aligned_copy);
-__ deccc(count);
+__ delayed()->stx(O4, end_to, 0);
-__ brx(Assembler::greater, false, Assembler::pt, L_copy_byte_loop);
+__ inc(count, 16);
-__ delayed()->stb(O4, end_to, 0);
+// copy 1 element (2 bytes) at a time
+__ BIND(L_copy_byte);
+__ cmp_and_br_short(count, 0, Assembler::equal, Assembler::pt, L_exit);
+__ align(OptoLoopAlignment);
+__ BIND(L_copy_byte_loop);
+__ dec(end_from);
+__ dec(end_to);
+__ ldub(end_from, 0, O4);
+__ deccc(count);
+__ brx(Assembler::greater, false, Assembler::pt, L_copy_byte_loop);
+__ delayed()->stb(O4, end_to, 0);
+}
 __ BIND(L_exit);
 // O3, O4 are used as temp registers
 inc_counter_np(SharedRuntime::_jbyte_array_copy_ctr, O3, O4);
 __ retl();
 *entry = __ pc();
 // caller can pass a 64-bit byte count here (from Unsafe.copyMemory)
 BLOCK_COMMENT("Entry:");
 }
-// for short arrays, just do single element copy
+{
-__ cmp(count, 11); // 8 + 3  (22 bytes)
+// UnsafeCopyMemory page error: continue at UnsafeCopyMemory common_error_exit
-__ brx(Assembler::less, false, Assembler::pn, L_copy_2_bytes);
+UnsafeCopyMemoryMark ucmm(this, !aligned, false);
-__ delayed()->mov(G0, offset);
+// for short arrays, just do single element copy
+__ cmp(count, 11); // 8 + 3  (22 bytes)
-if (aligned) {
+__ brx(Assembler::less, false, Assembler::pn, L_copy_2_bytes);
-// 'aligned' == true when it is known statically during compilation
+__ delayed()->mov(G0, offset);
-// of this arraycopy call site that both 'from' and 'to' addresses
-// are HeapWordSize aligned (see LibraryCallKit::basictype2arraycopy()).
+if (aligned) {
-//
+// 'aligned' == true when it is known statically during compilation
-// Aligned arrays have 4 bytes alignment in 32-bits VM
+// of this arraycopy call site that both 'from' and 'to' addresses
-// and 8 bytes - in 64-bits VM.
+// are HeapWordSize aligned (see LibraryCallKit::basictype2arraycopy()).
 //
-} else {
+// Aligned arrays have 4 bytes alignment in 32-bits VM
-// copy 1 element if necessary to align 'to' on an 4 bytes
+// and 8 bytes - in 64-bits VM.
-__ andcc(to, 3, G0);
+//
-__ br(Assembler::zero, false, Assembler::pt, L_skip_alignment);
+} else {
-__ delayed()->lduh(from, 0, O3);
+// copy 1 element if necessary to align 'to' on an 4 bytes
-__ inc(from, 2);
+__ andcc(to, 3, G0);
-__ inc(to, 2);
+__ br(Assembler::zero, false, Assembler::pt, L_skip_alignment);
-__ dec(count);
+__ delayed()->lduh(from, 0, O3);
-__ sth(O3, to, -2);
+__ inc(from, 2);
-__ BIND(L_skip_alignment);
+__ inc(to, 2);
+__ dec(count);
-// copy 2 elements to align 'to' on an 8 byte boundary
+__ sth(O3, to, -2);
-__ andcc(to, 7, G0);
+__ BIND(L_skip_alignment);
-__ br(Assembler::zero, false, Assembler::pn, L_skip_alignment2);
-__ delayed()->lduh(from, 0, O3);
+// copy 2 elements to align 'to' on an 8 byte boundary
-__ dec(count, 2);
+__ andcc(to, 7, G0);
-__ lduh(from, 2, O4);
+__ br(Assembler::zero, false, Assembler::pn, L_skip_alignment2);
-__ inc(from, 4);
+__ delayed()->lduh(from, 0, O3);
-__ inc(to, 4);
+__ dec(count, 2);
-__ sth(O3, to, -4);
+__ lduh(from, 2, O4);
-__ sth(O4, to, -2);
+__ inc(from, 4);
-__ BIND(L_skip_alignment2);
+__ inc(to, 4);
-}
+__ sth(O3, to, -4);
-if (!aligned) {
+__ sth(O4, to, -2);
-// Copy with shift 16 bytes per iteration if arrays do not have
+__ BIND(L_skip_alignment2);
-// the same alignment mod 8, otherwise fall through to the next
+}
-// code for aligned copy.
+if (!aligned) {
-// The compare above (count >= 11) guarantes 'count' >= 16 bytes.
+// Copy with shift 16 bytes per iteration if arrays do not have
-// Also jump over aligned copy after the copy with shift completed.
+// the same alignment mod 8, otherwise fall through to the next
+// code for aligned copy.
-copy_16_bytes_forward_with_shift(from, to, count, 1, L_copy_2_bytes);
+// The compare above (count >= 11) guarantes 'count' >= 16 bytes.
-}
+// Also jump over aligned copy after the copy with shift completed.
-// Both array are 8 bytes aligned, copy 16 bytes at a time
+copy_16_bytes_forward_with_shift(from, to, count, 1, L_copy_2_bytes);
-__ and3(count, 3, G4); // Save
+}
-__ srl(count, 2, count);
-generate_disjoint_long_copy_core(aligned);
+// Both array are 8 bytes aligned, copy 16 bytes at a time
-__ mov(G4, count); // restore
+__ and3(count, 3, G4); // Save
+__ srl(count, 2, count);
-// copy 1 element at a time
+generate_disjoint_long_copy_core(aligned);
-__ BIND(L_copy_2_bytes);
+__ mov(G4, count); // restore
-__ cmp_and_br_short(count, 0, Assembler::equal, Assembler::pt, L_exit);
-__ align(OptoLoopAlignment);
+// copy 1 element at a time
-__ BIND(L_copy_2_bytes_loop);
+__ BIND(L_copy_2_bytes);
-__ lduh(from, offset, O3);
+__ cmp_and_br_short(count, 0, Assembler::equal, Assembler::pt, L_exit);
-__ deccc(count);
+__ align(OptoLoopAlignment);
-__ sth(O3, to, offset);
+__ BIND(L_copy_2_bytes_loop);
-__ brx(Assembler::notZero, false, Assembler::pt, L_copy_2_bytes_loop);
+__ lduh(from, offset, O3);
-__ delayed()->inc(offset, 2);
+__ deccc(count);
+__ sth(O3, to, offset);
+__ brx(Assembler::notZero, false, Assembler::pt, L_copy_2_bytes_loop);
+__ delayed()->inc(offset, 2);
+}
 __ BIND(L_exit);
 // O3, O4 are used as temp registers
 inc_counter_np(SharedRuntime::_jshort_array_copy_ctr, O3, O4);
 __ retl();
 BLOCK_COMMENT("Entry:");
 }
 array_overlap_test(nooverlap_target, 1);
-__ sllx(count, LogBytesPerShort, byte_count);
-__ add(to, byte_count, end_to);  // offset after last copied element
-// for short arrays, just do single element copy
-__ cmp(count, 11); // 8 + 3  (22 bytes)
-__ brx(Assembler::less, false, Assembler::pn, L_copy_2_bytes);
-__ delayed()->add(from, byte_count, end_from);
 {
-// Align end of arrays since they could be not aligned even
+// UnsafeCopyMemory page error: continue at UnsafeCopyMemory common_error_exit
-// when arrays itself are aligned.
+UnsafeCopyMemoryMark ucmm(this, !aligned, false);
-// copy 1 element if necessary to align 'end_to' on an 4 bytes
+__ sllx(count, LogBytesPerShort, byte_count);
-__ andcc(end_to, 3, G0);
+__ add(to, byte_count, end_to);  // offset after last copied element
-__ br(Assembler::zero, false, Assembler::pt, L_skip_alignment);
-__ delayed()->lduh(end_from, -2, O3);
+// for short arrays, just do single element copy
-__ dec(end_from, 2);
+__ cmp(count, 11); // 8 + 3  (22 bytes)
-__ dec(end_to, 2);
+__ brx(Assembler::less, false, Assembler::pn, L_copy_2_bytes);
-__ dec(count);
+__ delayed()->add(from, byte_count, end_from);
-__ sth(O3, end_to, 0);
-__ BIND(L_skip_alignment);
+{
+// Align end of arrays since they could be not aligned even
-// copy 2 elements to align 'end_to' on an 8 byte boundary
+// when arrays itself are aligned.
-__ andcc(end_to, 7, G0);
-__ br(Assembler::zero, false, Assembler::pn, L_skip_alignment2);
+// copy 1 element if necessary to align 'end_to' on an 4 bytes
-__ delayed()->lduh(end_from, -2, O3);
+__ andcc(end_to, 3, G0);
-__ dec(count, 2);
+__ br(Assembler::zero, false, Assembler::pt, L_skip_alignment);
-__ lduh(end_from, -4, O4);
+__ delayed()->lduh(end_from, -2, O3);
-__ dec(end_from, 4);
+__ dec(end_from, 2);
-__ dec(end_to, 4);
+__ dec(end_to, 2);
-__ sth(O3, end_to, 2);
+__ dec(count);
-__ sth(O4, end_to, 0);
+__ sth(O3, end_to, 0);
-__ BIND(L_skip_alignment2);
+__ BIND(L_skip_alignment);
-}
-if (aligned) {
+// copy 2 elements to align 'end_to' on an 8 byte boundary
-// Both arrays are aligned to 8-bytes in 64-bits VM.
+__ andcc(end_to, 7, G0);
-// The 'count' is decremented in copy_16_bytes_backward_with_shift()
+__ br(Assembler::zero, false, Assembler::pn, L_skip_alignment2);
-// in unaligned case.
+__ delayed()->lduh(end_from, -2, O3);
-__ dec(count, 8);
+__ dec(count, 2);
-} else {
+__ lduh(end_from, -4, O4);
-// Copy with shift 16 bytes per iteration if arrays do not have
+__ dec(end_from, 4);
-// the same alignment mod 8, otherwise jump to the next
+__ dec(end_to, 4);
-// code for aligned copy (and substracting 8 from 'count' before jump).
+__ sth(O3, end_to, 2);
-// The compare above (count >= 11) guarantes 'count' >= 16 bytes.
+__ sth(O4, end_to, 0);
-// Also jump over aligned copy after the copy with shift completed.
+__ BIND(L_skip_alignment2);
+}
-copy_16_bytes_backward_with_shift(end_from, end_to, count, 8,
+if (aligned) {
+// Both arrays are aligned to 8-bytes in 64-bits VM.
+// The 'count' is decremented in copy_16_bytes_backward_with_shift()
+// in unaligned case.
+__ dec(count, 8);
+} else {
+// Copy with shift 16 bytes per iteration if arrays do not have
+// the same alignment mod 8, otherwise jump to the next
+// code for aligned copy (and substracting 8 from 'count' before jump).
+// The compare above (count >= 11) guarantes 'count' >= 16 bytes.
+// Also jump over aligned copy after the copy with shift completed.
+copy_16_bytes_backward_with_shift(end_from, end_to, count, 8,
 L_aligned_copy, L_copy_2_bytes);
 }
 // copy 4 elements (16 bytes) at a time
 __ align(OptoLoopAlignment);
 __ BIND(L_aligned_copy);
 __ dec(end_from, 16);
 __ ldx(end_from, 8, O3);
 __ ldx(end_from, 0, O4);
 __ dec(end_to, 16);
 __ deccc(count, 8);
 __ stx(O3, end_to, 8);
 __ brx(Assembler::greaterEqual, false, Assembler::pt, L_aligned_copy);
 __ delayed()->stx(O4, end_to, 0);
 __ inc(count, 8);
 // copy 1 element (2 bytes) at a time
 __ BIND(L_copy_2_bytes);
 __ cmp_and_br_short(count, 0, Assembler::equal, Assembler::pt, L_exit);
 __ BIND(L_copy_2_bytes_loop);
 __ dec(end_from, 2);
 __ dec(end_to, 2);
 __ lduh(end_from, 0, O4);
 __ deccc(count);
 __ brx(Assembler::greater, false, Assembler::pt, L_copy_2_bytes_loop);
 __ delayed()->sth(O4, end_to, 0);
+}
 __ BIND(L_exit);
 // O3, O4 are used as temp registers
 inc_counter_np(SharedRuntime::_jshort_array_copy_ctr, O3, O4);
 __ retl();
 __ delayed()->mov(G0, O0); // return 0
 if (entry != NULL) {
 *entry = __ pc();
 // caller can pass a 64-bit byte count here (from Unsafe.copyMemory)
 BLOCK_COMMENT("Entry:");
 }
+{
-generate_disjoint_int_copy_core(aligned);
+// UnsafeCopyMemory page error: continue at UnsafeCopyMemory common_error_exit
+UnsafeCopyMemoryMark ucmm(this, !aligned, false);
+generate_disjoint_int_copy_core(aligned);
+}
 // O3, O4 are used as temp registers
 inc_counter_np(SharedRuntime::_jint_array_copy_ctr, O3, O4);
 __ retl();
 __ delayed()->mov(G0, O0); // return 0
 return start;
 // caller can pass a 64-bit byte count here (from Unsafe.copyMemory)
 BLOCK_COMMENT("Entry:");
 }
 array_overlap_test(nooverlap_target, 2);
+{
-generate_conjoint_int_copy_core(aligned);
+// UnsafeCopyMemory page error: continue at UnsafeCopyMemory common_error_exit
+UnsafeCopyMemoryMark ucmm(this, !aligned, false);
+generate_conjoint_int_copy_core(aligned);
+}
 // O3, O4 are used as temp registers
 inc_counter_np(SharedRuntime::_jint_array_copy_ctr, O3, O4);
 __ retl();
 __ delayed()->mov(G0, O0); // return 0
 return start;
 *entry = __ pc();
 // caller can pass a 64-bit byte count here (from Unsafe.copyMemory)
 BLOCK_COMMENT("Entry:");
 }
-generate_disjoint_long_copy_core(aligned);
+{
+// UnsafeCopyMemory page error: continue at UnsafeCopyMemory common_error_exit
+UnsafeCopyMemoryMark ucmm(this, true, false);
+generate_disjoint_long_copy_core(aligned);
+}
 // O3, O4 are used as temp registers
 inc_counter_np(SharedRuntime::_jlong_array_copy_ctr, O3, O4);
 __ retl();
 __ delayed()->mov(G0, O0); // return 0
 return start;
 // caller can pass a 64-bit byte count here (from Unsafe.copyMemory)
 BLOCK_COMMENT("Entry:");
 }
 array_overlap_test(nooverlap_target, 3);
+{
-generate_conjoint_long_copy_core(aligned);
+// UnsafeCopyMemory page error: continue at UnsafeCopyMemory common_error_exit
+UnsafeCopyMemoryMark ucmm(this, true, false);
+generate_conjoint_long_copy_core(aligned);
+}
 // O3, O4 are used as temp registers
 inc_counter_np(SharedRuntime::_jlong_array_copy_ctr, O3, O4);
 __ retl();
 __ delayed()->mov(G0, O0); // return 0
 return start;
 address entry_jshort_arraycopy;
 address entry_jint_arraycopy;
 address entry_oop_arraycopy;
 address entry_jlong_arraycopy;
 address entry_checkcast_arraycopy;
+address ucm_common_error_exit       =  generate_unsafecopy_common_error_exit();
+UnsafeCopyMemory::set_common_exit_stub_pc(ucm_common_error_exit);
 //*** jbyte
 // Always need aligned and unaligned versions
 StubRoutines::_jbyte_disjoint_arraycopy         = generate_disjoint_byte_copy(false, &entry,
 "jbyte_disjoint_arraycopy");
 }
 }
 }; // end class declaration
+#define UCM_TABLE_MAX_ENTRIES 8
 void StubGenerator_generate(CodeBuffer* code, bool all) {
+if (UnsafeCopyMemory::_table == NULL) {
+UnsafeCopyMemory::create_table(UCM_TABLE_MAX_ENTRIES);
+}
 StubGenerator g(code, all);
 }

changeset 55490	3f3dc00a69a5
parent 53591	bf4c38b9afaf
child 59249	29b0d0b61615