Mercurial > hg > graal-compiler
annotate src/share/vm/runtime/stubRoutines.cpp @ 8804:91bf0bdae37b
8008217: CDS: Class data sharing limits the malloc heap on Solaris
Summary: In 64bit VM move CDS archive address to 32G on all platforms using new flag SharedBaseAddress. In 32bit VM set CDS archive address to 3Gb on Linux and let other OSs pick the address.
Reviewed-by: kvn, dcubed, zgu, hseigel
| author | coleenp |
|---|---|
| date | Wed, 20 Mar 2013 08:04:54 -0400 |
| parents | a3ecd773a7b9 |
| children | 746b070f5022 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6842
b9a9ed0f8eeb
7197424: update copyright year to match last edit in jdk8 hotspot repository
mikael
parents:
6266
diff
changeset
|
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "asm/codeBuffer.hpp" | |
| 27 #include "memory/resourceArea.hpp" | |
| 28 #include "oops/oop.inline.hpp" | |
| 29 #include "runtime/interfaceSupport.hpp" | |
| 30 #include "runtime/sharedRuntime.hpp" | |
| 31 #include "runtime/stubRoutines.hpp" | |
| 32 #include "runtime/timer.hpp" | |
| 33 #include "utilities/copy.hpp" | |
| 34 #ifdef COMPILER2 | |
| 35 #include "opto/runtime.hpp" | |
| 36 #endif | |
| 0 | 37 |
| 38 | |
| 39 // Implementation of StubRoutines - for a description | |
| 40 // of how to extend it, see the header file. | |
| 41 | |
| 42 // Class Variables | |
| 43 | |
| 44 BufferBlob* StubRoutines::_code1 = NULL; | |
| 45 BufferBlob* StubRoutines::_code2 = NULL; | |
| 46 | |
| 47 address StubRoutines::_call_stub_return_address = NULL; | |
| 48 address StubRoutines::_call_stub_entry = NULL; | |
| 49 | |
| 50 address StubRoutines::_catch_exception_entry = NULL; | |
| 51 address StubRoutines::_forward_exception_entry = NULL; | |
| 52 address StubRoutines::_throw_AbstractMethodError_entry = NULL; | |
|
16
f8236e79048a
6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents:
0
diff
changeset
|
53 address StubRoutines::_throw_IncompatibleClassChangeError_entry = NULL; |
| 0 | 54 address StubRoutines::_throw_NullPointerException_at_call_entry = NULL; |
| 55 address StubRoutines::_throw_StackOverflowError_entry = NULL; | |
| 56 address StubRoutines::_handler_for_unsafe_access_entry = NULL; | |
| 57 jint StubRoutines::_verify_oop_count = 0; | |
| 58 address StubRoutines::_verify_oop_subroutine_entry = NULL; | |
| 59 address StubRoutines::_atomic_xchg_entry = NULL; | |
| 60 address StubRoutines::_atomic_xchg_ptr_entry = NULL; | |
| 61 address StubRoutines::_atomic_store_entry = NULL; | |
| 62 address StubRoutines::_atomic_store_ptr_entry = NULL; | |
| 63 address StubRoutines::_atomic_cmpxchg_entry = NULL; | |
| 64 address StubRoutines::_atomic_cmpxchg_ptr_entry = NULL; | |
| 65 address StubRoutines::_atomic_cmpxchg_long_entry = NULL; | |
| 66 address StubRoutines::_atomic_add_entry = NULL; | |
| 67 address StubRoutines::_atomic_add_ptr_entry = NULL; | |
| 68 address StubRoutines::_fence_entry = NULL; | |
| 69 address StubRoutines::_d2i_wrapper = NULL; | |
| 70 address StubRoutines::_d2l_wrapper = NULL; | |
| 71 | |
| 72 jint StubRoutines::_fpu_cntrl_wrd_std = 0; | |
| 73 jint StubRoutines::_fpu_cntrl_wrd_24 = 0; | |
| 74 jint StubRoutines::_fpu_cntrl_wrd_64 = 0; | |
| 75 jint StubRoutines::_fpu_cntrl_wrd_trunc = 0; | |
| 76 jint StubRoutines::_mxcsr_std = 0; | |
| 77 jint StubRoutines::_fpu_subnormal_bias1[3] = { 0, 0, 0 }; | |
| 78 jint StubRoutines::_fpu_subnormal_bias2[3] = { 0, 0, 0 }; | |
| 79 | |
| 80 // Compiled code entry points default values | |
| 2324 | 81 // The default functions don't have separate disjoint versions. |
| 0 | 82 address StubRoutines::_jbyte_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::jbyte_copy); |
| 83 address StubRoutines::_jshort_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::jshort_copy); | |
| 84 address StubRoutines::_jint_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::jint_copy); | |
| 85 address StubRoutines::_jlong_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::jlong_copy); | |
| 86 address StubRoutines::_oop_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::oop_copy); | |
| 2324 | 87 address StubRoutines::_oop_arraycopy_uninit = CAST_FROM_FN_PTR(address, StubRoutines::oop_copy_uninit); |
| 0 | 88 address StubRoutines::_jbyte_disjoint_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::jbyte_copy); |
| 89 address StubRoutines::_jshort_disjoint_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::jshort_copy); | |
| 90 address StubRoutines::_jint_disjoint_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::jint_copy); | |
| 91 address StubRoutines::_jlong_disjoint_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::jlong_copy); | |
| 92 address StubRoutines::_oop_disjoint_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::oop_copy); | |
| 2324 | 93 address StubRoutines::_oop_disjoint_arraycopy_uninit = CAST_FROM_FN_PTR(address, StubRoutines::oop_copy_uninit); |
| 0 | 94 |
| 95 address StubRoutines::_arrayof_jbyte_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_jbyte_copy); | |
| 96 address StubRoutines::_arrayof_jshort_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_jshort_copy); | |
| 97 address StubRoutines::_arrayof_jint_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_jint_copy); | |
| 98 address StubRoutines::_arrayof_jlong_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_jlong_copy); | |
| 99 address StubRoutines::_arrayof_oop_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_oop_copy); | |
| 2324 | 100 address StubRoutines::_arrayof_oop_arraycopy_uninit = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_oop_copy_uninit); |
| 0 | 101 address StubRoutines::_arrayof_jbyte_disjoint_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_jbyte_copy); |
| 102 address StubRoutines::_arrayof_jshort_disjoint_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_jshort_copy); | |
| 103 address StubRoutines::_arrayof_jint_disjoint_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_jint_copy); | |
| 104 address StubRoutines::_arrayof_jlong_disjoint_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_jlong_copy); | |
| 2324 | 105 address StubRoutines::_arrayof_oop_disjoint_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_oop_copy); |
| 106 address StubRoutines::_arrayof_oop_disjoint_arraycopy_uninit = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_oop_copy_uninit); | |
| 107 | |
| 3892 | 108 address StubRoutines::_zero_aligned_words = CAST_FROM_FN_PTR(address, Copy::zero_to_words); |
| 0 | 109 |
| 110 address StubRoutines::_checkcast_arraycopy = NULL; | |
| 2324 | 111 address StubRoutines::_checkcast_arraycopy_uninit = NULL; |
| 0 | 112 address StubRoutines::_unsafe_arraycopy = NULL; |
| 113 address StubRoutines::_generic_arraycopy = NULL; | |
| 114 | |
| 1763 | 115 |
| 116 address StubRoutines::_jbyte_fill; | |
| 117 address StubRoutines::_jshort_fill; | |
| 118 address StubRoutines::_jint_fill; | |
| 119 address StubRoutines::_arrayof_jbyte_fill; | |
| 120 address StubRoutines::_arrayof_jshort_fill; | |
| 121 address StubRoutines::_arrayof_jint_fill; | |
| 122 | |
| 6894 | 123 address StubRoutines::_aescrypt_encryptBlock = NULL; |
| 124 address StubRoutines::_aescrypt_decryptBlock = NULL; | |
| 125 address StubRoutines::_cipherBlockChaining_encryptAESCrypt = NULL; | |
| 126 address StubRoutines::_cipherBlockChaining_decryptAESCrypt = NULL; | |
| 1763 | 127 |
|
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
16
diff
changeset
|
128 double (* StubRoutines::_intrinsic_log )(double) = NULL; |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
16
diff
changeset
|
129 double (* StubRoutines::_intrinsic_log10 )(double) = NULL; |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
16
diff
changeset
|
130 double (* StubRoutines::_intrinsic_exp )(double) = NULL; |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
16
diff
changeset
|
131 double (* StubRoutines::_intrinsic_pow )(double, double) = NULL; |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
16
diff
changeset
|
132 double (* StubRoutines::_intrinsic_sin )(double) = NULL; |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
16
diff
changeset
|
133 double (* StubRoutines::_intrinsic_cos )(double) = NULL; |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
16
diff
changeset
|
134 double (* StubRoutines::_intrinsic_tan )(double) = NULL; |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
16
diff
changeset
|
135 |
| 0 | 136 // Initialization |
| 137 // | |
| 138 // Note: to break cycle with universe initialization, stubs are generated in two phases. | |
| 139 // The first one generates stubs needed during universe init (e.g., _handle_must_compile_first_entry). | |
| 140 // The second phase includes all other stubs (which may depend on universe being initialized.) | |
| 141 | |
| 142 extern void StubGenerator_generate(CodeBuffer* code, bool all); // only interface to generators | |
| 143 | |
| 144 void StubRoutines::initialize1() { | |
| 145 if (_code1 == NULL) { | |
| 146 ResourceMark rm; | |
| 147 TraceTime timer("StubRoutines generation 1", TraceStartupTime); | |
| 148 _code1 = BufferBlob::create("StubRoutines (1)", code_size1); | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1245
diff
changeset
|
149 if (_code1 == NULL) { |
| 1748 | 150 vm_exit_out_of_memory(code_size1, "CodeCache: no room for StubRoutines (1)"); |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1245
diff
changeset
|
151 } |
| 1748 | 152 CodeBuffer buffer(_code1); |
| 0 | 153 StubGenerator_generate(&buffer, false); |
| 154 } | |
| 155 } | |
| 156 | |
| 157 | |
| 158 #ifdef ASSERT | |
| 159 typedef void (*arraycopy_fn)(address src, address dst, int count); | |
| 160 | |
| 161 // simple tests of generated arraycopy functions | |
| 162 static void test_arraycopy_func(address func, int alignment) { | |
| 163 int v = 0xcc; | |
| 164 int v2 = 0x11; | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
165 jlong lbuffer[8]; |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
166 jlong lbuffer2[8]; |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
167 address fbuffer = (address) lbuffer; |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
168 address fbuffer2 = (address) lbuffer2; |
| 0 | 169 unsigned int i; |
| 170 for (i = 0; i < sizeof(lbuffer); i++) { | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
171 fbuffer[i] = v; fbuffer2[i] = v2; |
| 0 | 172 } |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
173 // C++ does not guarantee jlong[] array alignment to 8 bytes. |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
174 // Use middle of array to check that memory before it is not modified. |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
175 address buffer = (address) round_to((intptr_t)&lbuffer[4], BytesPerLong); |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
176 address buffer2 = (address) round_to((intptr_t)&lbuffer2[4], BytesPerLong); |
| 0 | 177 // do an aligned copy |
| 178 ((arraycopy_fn)func)(buffer, buffer2, 0); | |
| 179 for (i = 0; i < sizeof(lbuffer); i++) { | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
180 assert(fbuffer[i] == v && fbuffer2[i] == v2, "shouldn't have copied anything"); |
| 0 | 181 } |
| 182 // adjust destination alignment | |
| 183 ((arraycopy_fn)func)(buffer, buffer2 + alignment, 0); | |
| 184 for (i = 0; i < sizeof(lbuffer); i++) { | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
185 assert(fbuffer[i] == v && fbuffer2[i] == v2, "shouldn't have copied anything"); |
| 0 | 186 } |
| 187 // adjust source alignment | |
| 188 ((arraycopy_fn)func)(buffer + alignment, buffer2, 0); | |
| 189 for (i = 0; i < sizeof(lbuffer); i++) { | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
190 assert(fbuffer[i] == v && fbuffer2[i] == v2, "shouldn't have copied anything"); |
| 0 | 191 } |
| 192 } | |
| 193 #endif | |
| 194 | |
| 195 | |
| 196 void StubRoutines::initialize2() { | |
| 197 if (_code2 == NULL) { | |
| 198 ResourceMark rm; | |
| 199 TraceTime timer("StubRoutines generation 2", TraceStartupTime); | |
| 200 _code2 = BufferBlob::create("StubRoutines (2)", code_size2); | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1245
diff
changeset
|
201 if (_code2 == NULL) { |
| 1748 | 202 vm_exit_out_of_memory(code_size2, "CodeCache: no room for StubRoutines (2)"); |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1245
diff
changeset
|
203 } |
| 1748 | 204 CodeBuffer buffer(_code2); |
| 0 | 205 StubGenerator_generate(&buffer, true); |
| 206 } | |
| 207 | |
| 208 #ifdef ASSERT | |
| 209 | |
| 210 #define TEST_ARRAYCOPY(type) \ | |
| 211 test_arraycopy_func( type##_arraycopy(), sizeof(type)); \ | |
| 212 test_arraycopy_func( type##_disjoint_arraycopy(), sizeof(type)); \ | |
| 213 test_arraycopy_func(arrayof_##type##_arraycopy(), sizeof(HeapWord)); \ | |
| 214 test_arraycopy_func(arrayof_##type##_disjoint_arraycopy(), sizeof(HeapWord)) | |
| 215 | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
216 // Make sure all the arraycopy stubs properly handle zero count |
| 0 | 217 TEST_ARRAYCOPY(jbyte); |
| 218 TEST_ARRAYCOPY(jshort); | |
| 219 TEST_ARRAYCOPY(jint); | |
| 220 TEST_ARRAYCOPY(jlong); | |
| 221 | |
| 222 #undef TEST_ARRAYCOPY | |
| 223 | |
| 1763 | 224 #define TEST_FILL(type) \ |
| 225 if (_##type##_fill != NULL) { \ | |
| 226 union { \ | |
| 227 double d; \ | |
| 228 type body[96]; \ | |
| 229 } s; \ | |
| 230 \ | |
| 231 int v = 32; \ | |
| 232 for (int offset = -2; offset <= 2; offset++) { \ | |
| 233 for (int i = 0; i < 96; i++) { \ | |
| 234 s.body[i] = 1; \ | |
| 235 } \ | |
| 236 type* start = s.body + 8 + offset; \ | |
| 237 for (int aligned = 0; aligned < 2; aligned++) { \ | |
| 238 if (aligned) { \ | |
| 239 if (((intptr_t)start) % HeapWordSize == 0) { \ | |
| 240 ((void (*)(type*, int, int))StubRoutines::_arrayof_##type##_fill)(start, v, 80); \ | |
| 241 } else { \ | |
| 242 continue; \ | |
| 243 } \ | |
| 244 } else { \ | |
| 245 ((void (*)(type*, int, int))StubRoutines::_##type##_fill)(start, v, 80); \ | |
| 246 } \ | |
| 247 for (int i = 0; i < 96; i++) { \ | |
| 248 if (i < (8 + offset) || i >= (88 + offset)) { \ | |
| 249 assert(s.body[i] == 1, "what?"); \ | |
| 250 } else { \ | |
| 251 assert(s.body[i] == 32, "what?"); \ | |
| 252 } \ | |
| 253 } \ | |
| 254 } \ | |
| 255 } \ | |
| 256 } \ | |
| 257 | |
| 258 TEST_FILL(jbyte); | |
| 259 TEST_FILL(jshort); | |
| 260 TEST_FILL(jint); | |
| 261 | |
| 262 #undef TEST_FILL | |
| 263 | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
264 #define TEST_COPYRTN(type) \ |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
265 test_arraycopy_func(CAST_FROM_FN_PTR(address, Copy::conjoint_##type##s_atomic), sizeof(type)); \ |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
266 test_arraycopy_func(CAST_FROM_FN_PTR(address, Copy::arrayof_conjoint_##type##s), (int)MAX2(sizeof(HeapWord), sizeof(type))) |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
267 |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
268 // Make sure all the copy runtime routines properly handle zero count |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
269 TEST_COPYRTN(jbyte); |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
270 TEST_COPYRTN(jshort); |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
271 TEST_COPYRTN(jint); |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
272 TEST_COPYRTN(jlong); |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
273 |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
274 #undef TEST_COPYRTN |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
275 |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
276 test_arraycopy_func(CAST_FROM_FN_PTR(address, Copy::conjoint_words), sizeof(HeapWord)); |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
277 test_arraycopy_func(CAST_FROM_FN_PTR(address, Copy::disjoint_words), sizeof(HeapWord)); |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
278 test_arraycopy_func(CAST_FROM_FN_PTR(address, Copy::disjoint_words_atomic), sizeof(HeapWord)); |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
279 // Aligned to BytesPerLong |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
280 test_arraycopy_func(CAST_FROM_FN_PTR(address, Copy::aligned_conjoint_words), sizeof(jlong)); |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
281 test_arraycopy_func(CAST_FROM_FN_PTR(address, Copy::aligned_disjoint_words), sizeof(jlong)); |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
282 |
| 0 | 283 #endif |
| 284 } | |
| 285 | |
| 286 | |
| 287 void stubRoutines_init1() { StubRoutines::initialize1(); } | |
| 288 void stubRoutines_init2() { StubRoutines::initialize2(); } | |
| 289 | |
| 290 // | |
| 291 // Default versions of arraycopy functions | |
| 292 // | |
| 293 | |
| 2324 | 294 static void gen_arraycopy_barrier_pre(oop* dest, size_t count, bool dest_uninitialized) { |
|
1245
6484c4ee11cb
6904516: More object array barrier fixes, following up on 6906727
ysr
parents:
1174
diff
changeset
|
295 assert(count != 0, "count should be non-zero"); |
|
6484c4ee11cb
6904516: More object array barrier fixes, following up on 6906727
ysr
parents:
1174
diff
changeset
|
296 assert(count <= (size_t)max_intx, "count too large"); |
|
6484c4ee11cb
6904516: More object array barrier fixes, following up on 6906727
ysr
parents:
1174
diff
changeset
|
297 BarrierSet* bs = Universe::heap()->barrier_set(); |
|
6484c4ee11cb
6904516: More object array barrier fixes, following up on 6906727
ysr
parents:
1174
diff
changeset
|
298 assert(bs->has_write_ref_array_pre_opt(), "Must have pre-barrier opt"); |
| 2324 | 299 bs->write_ref_array_pre(dest, (int)count, dest_uninitialized); |
|
1245
6484c4ee11cb
6904516: More object array barrier fixes, following up on 6906727
ysr
parents:
1174
diff
changeset
|
300 } |
|
6484c4ee11cb
6904516: More object array barrier fixes, following up on 6906727
ysr
parents:
1174
diff
changeset
|
301 |
| 0 | 302 static void gen_arraycopy_barrier(oop* dest, size_t count) { |
| 303 assert(count != 0, "count should be non-zero"); | |
| 304 BarrierSet* bs = Universe::heap()->barrier_set(); | |
| 305 assert(bs->has_write_ref_array_opt(), "Barrier set must have ref array opt"); | |
|
1245
6484c4ee11cb
6904516: More object array barrier fixes, following up on 6906727
ysr
parents:
1174
diff
changeset
|
306 bs->write_ref_array((HeapWord*)dest, count); |
| 0 | 307 } |
| 308 | |
| 309 JRT_LEAF(void, StubRoutines::jbyte_copy(jbyte* src, jbyte* dest, size_t count)) | |
| 310 #ifndef PRODUCT | |
| 311 SharedRuntime::_jbyte_array_copy_ctr++; // Slow-path byte array copy | |
| 312 #endif // !PRODUCT | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
313 Copy::conjoint_jbytes_atomic(src, dest, count); |
| 0 | 314 JRT_END |
| 315 | |
| 316 JRT_LEAF(void, StubRoutines::jshort_copy(jshort* src, jshort* dest, size_t count)) | |
| 317 #ifndef PRODUCT | |
| 318 SharedRuntime::_jshort_array_copy_ctr++; // Slow-path short/char array copy | |
| 319 #endif // !PRODUCT | |
| 320 Copy::conjoint_jshorts_atomic(src, dest, count); | |
| 321 JRT_END | |
| 322 | |
| 323 JRT_LEAF(void, StubRoutines::jint_copy(jint* src, jint* dest, size_t count)) | |
| 324 #ifndef PRODUCT | |
| 325 SharedRuntime::_jint_array_copy_ctr++; // Slow-path int/float array copy | |
| 326 #endif // !PRODUCT | |
| 327 Copy::conjoint_jints_atomic(src, dest, count); | |
| 328 JRT_END | |
| 329 | |
| 330 JRT_LEAF(void, StubRoutines::jlong_copy(jlong* src, jlong* dest, size_t count)) | |
| 331 #ifndef PRODUCT | |
| 332 SharedRuntime::_jlong_array_copy_ctr++; // Slow-path long/double array copy | |
| 333 #endif // !PRODUCT | |
| 334 Copy::conjoint_jlongs_atomic(src, dest, count); | |
| 335 JRT_END | |
| 336 | |
| 337 JRT_LEAF(void, StubRoutines::oop_copy(oop* src, oop* dest, size_t count)) | |
| 338 #ifndef PRODUCT | |
| 339 SharedRuntime::_oop_array_copy_ctr++; // Slow-path oop array copy | |
| 340 #endif // !PRODUCT | |
| 341 assert(count != 0, "count should be non-zero"); | |
| 2324 | 342 gen_arraycopy_barrier_pre(dest, count, /*dest_uninitialized*/false); |
| 343 Copy::conjoint_oops_atomic(src, dest, count); | |
| 344 gen_arraycopy_barrier(dest, count); | |
| 345 JRT_END | |
| 346 | |
| 347 JRT_LEAF(void, StubRoutines::oop_copy_uninit(oop* src, oop* dest, size_t count)) | |
| 348 #ifndef PRODUCT | |
| 349 SharedRuntime::_oop_array_copy_ctr++; // Slow-path oop array copy | |
| 350 #endif // !PRODUCT | |
| 351 assert(count != 0, "count should be non-zero"); | |
| 352 gen_arraycopy_barrier_pre(dest, count, /*dest_uninitialized*/true); | |
| 0 | 353 Copy::conjoint_oops_atomic(src, dest, count); |
| 354 gen_arraycopy_barrier(dest, count); | |
| 355 JRT_END | |
| 356 | |
| 357 JRT_LEAF(void, StubRoutines::arrayof_jbyte_copy(HeapWord* src, HeapWord* dest, size_t count)) | |
| 358 #ifndef PRODUCT | |
| 359 SharedRuntime::_jbyte_array_copy_ctr++; // Slow-path byte array copy | |
| 360 #endif // !PRODUCT | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1552
diff
changeset
|
361 Copy::arrayof_conjoint_jbytes(src, dest, count); |
| 0 | 362 JRT_END |
| 363 | |
| 364 JRT_LEAF(void, StubRoutines::arrayof_jshort_copy(HeapWord* src, HeapWord* dest, size_t count)) | |
| 365 #ifndef PRODUCT | |
| 366 SharedRuntime::_jshort_array_copy_ctr++; // Slow-path short/char array copy | |
| 367 #endif // !PRODUCT | |
| 368 Copy::arrayof_conjoint_jshorts(src, dest, count); | |
| 369 JRT_END | |
| 370 | |
| 371 JRT_LEAF(void, StubRoutines::arrayof_jint_copy(HeapWord* src, HeapWord* dest, size_t count)) | |
| 372 #ifndef PRODUCT | |
| 373 SharedRuntime::_jint_array_copy_ctr++; // Slow-path int/float array copy | |
| 374 #endif // !PRODUCT | |
| 375 Copy::arrayof_conjoint_jints(src, dest, count); | |
| 376 JRT_END | |
| 377 | |
| 378 JRT_LEAF(void, StubRoutines::arrayof_jlong_copy(HeapWord* src, HeapWord* dest, size_t count)) | |
| 379 #ifndef PRODUCT | |
| 380 SharedRuntime::_jlong_array_copy_ctr++; // Slow-path int/float array copy | |
| 381 #endif // !PRODUCT | |
| 382 Copy::arrayof_conjoint_jlongs(src, dest, count); | |
| 383 JRT_END | |
| 384 | |
| 385 JRT_LEAF(void, StubRoutines::arrayof_oop_copy(HeapWord* src, HeapWord* dest, size_t count)) | |
| 386 #ifndef PRODUCT | |
| 387 SharedRuntime::_oop_array_copy_ctr++; // Slow-path oop array copy | |
| 388 #endif // !PRODUCT | |
| 389 assert(count != 0, "count should be non-zero"); | |
| 2324 | 390 gen_arraycopy_barrier_pre((oop *) dest, count, /*dest_uninitialized*/false); |
| 0 | 391 Copy::arrayof_conjoint_oops(src, dest, count); |
| 392 gen_arraycopy_barrier((oop *) dest, count); | |
| 393 JRT_END | |
| 1763 | 394 |
| 2324 | 395 JRT_LEAF(void, StubRoutines::arrayof_oop_copy_uninit(HeapWord* src, HeapWord* dest, size_t count)) |
| 396 #ifndef PRODUCT | |
| 397 SharedRuntime::_oop_array_copy_ctr++; // Slow-path oop array copy | |
| 398 #endif // !PRODUCT | |
| 399 assert(count != 0, "count should be non-zero"); | |
| 400 gen_arraycopy_barrier_pre((oop *) dest, count, /*dest_uninitialized*/true); | |
| 401 Copy::arrayof_conjoint_oops(src, dest, count); | |
| 402 gen_arraycopy_barrier((oop *) dest, count); | |
| 403 JRT_END | |
| 1763 | 404 |
| 405 address StubRoutines::select_fill_function(BasicType t, bool aligned, const char* &name) { | |
| 406 #define RETURN_STUB(xxx_fill) { \ | |
| 407 name = #xxx_fill; \ | |
| 408 return StubRoutines::xxx_fill(); } | |
| 409 | |
| 410 switch (t) { | |
| 411 case T_BYTE: | |
| 412 case T_BOOLEAN: | |
| 413 if (!aligned) RETURN_STUB(jbyte_fill); | |
| 414 RETURN_STUB(arrayof_jbyte_fill); | |
| 415 case T_CHAR: | |
| 416 case T_SHORT: | |
| 417 if (!aligned) RETURN_STUB(jshort_fill); | |
| 418 RETURN_STUB(arrayof_jshort_fill); | |
| 419 case T_INT: | |
| 420 case T_FLOAT: | |
| 421 if (!aligned) RETURN_STUB(jint_fill); | |
| 422 RETURN_STUB(arrayof_jint_fill); | |
| 423 case T_DOUBLE: | |
| 424 case T_LONG: | |
| 425 case T_ARRAY: | |
| 426 case T_OBJECT: | |
| 427 case T_NARROWOOP: | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6266
diff
changeset
|
428 case T_NARROWKLASS: |
| 1763 | 429 case T_ADDRESS: |
| 430 // Currently unsupported | |
| 431 return NULL; | |
| 432 | |
| 433 default: | |
| 434 ShouldNotReachHere(); | |
| 435 return NULL; | |
| 436 } | |
| 437 | |
| 438 #undef RETURN_STUB | |
| 439 } | |
| 2446 | 440 |
| 441 // constants for computing the copy function | |
| 442 enum { | |
| 443 COPYFUNC_UNALIGNED = 0, | |
| 444 COPYFUNC_ALIGNED = 1, // src, dest aligned to HeapWordSize | |
| 445 COPYFUNC_CONJOINT = 0, | |
| 446 COPYFUNC_DISJOINT = 2 // src != dest, or transfer can descend | |
| 447 }; | |
| 448 | |
| 449 // Note: The condition "disjoint" applies also for overlapping copies | |
| 450 // where an descending copy is permitted (i.e., dest_offset <= src_offset). | |
| 451 address | |
| 452 StubRoutines::select_arraycopy_function(BasicType t, bool aligned, bool disjoint, const char* &name, bool dest_uninitialized) { | |
| 453 int selector = | |
| 454 (aligned ? COPYFUNC_ALIGNED : COPYFUNC_UNALIGNED) + | |
| 455 (disjoint ? COPYFUNC_DISJOINT : COPYFUNC_CONJOINT); | |
| 456 | |
| 457 #define RETURN_STUB(xxx_arraycopy) { \ | |
| 458 name = #xxx_arraycopy; \ | |
| 459 return StubRoutines::xxx_arraycopy(); } | |
| 460 | |
| 461 #define RETURN_STUB_PARM(xxx_arraycopy, parm) { \ | |
| 462 name = #xxx_arraycopy; \ | |
| 463 return StubRoutines::xxx_arraycopy(parm); } | |
| 464 | |
| 465 switch (t) { | |
| 466 case T_BYTE: | |
| 467 case T_BOOLEAN: | |
| 468 switch (selector) { | |
| 469 case COPYFUNC_CONJOINT | COPYFUNC_UNALIGNED: RETURN_STUB(jbyte_arraycopy); | |
| 470 case COPYFUNC_CONJOINT | COPYFUNC_ALIGNED: RETURN_STUB(arrayof_jbyte_arraycopy); | |
| 471 case COPYFUNC_DISJOINT | COPYFUNC_UNALIGNED: RETURN_STUB(jbyte_disjoint_arraycopy); | |
| 472 case COPYFUNC_DISJOINT | COPYFUNC_ALIGNED: RETURN_STUB(arrayof_jbyte_disjoint_arraycopy); | |
| 473 } | |
| 474 case T_CHAR: | |
| 475 case T_SHORT: | |
| 476 switch (selector) { | |
| 477 case COPYFUNC_CONJOINT | COPYFUNC_UNALIGNED: RETURN_STUB(jshort_arraycopy); | |
| 478 case COPYFUNC_CONJOINT | COPYFUNC_ALIGNED: RETURN_STUB(arrayof_jshort_arraycopy); | |
| 479 case COPYFUNC_DISJOINT | COPYFUNC_UNALIGNED: RETURN_STUB(jshort_disjoint_arraycopy); | |
| 480 case COPYFUNC_DISJOINT | COPYFUNC_ALIGNED: RETURN_STUB(arrayof_jshort_disjoint_arraycopy); | |
| 481 } | |
| 482 case T_INT: | |
| 483 case T_FLOAT: | |
| 484 switch (selector) { | |
| 485 case COPYFUNC_CONJOINT | COPYFUNC_UNALIGNED: RETURN_STUB(jint_arraycopy); | |
| 486 case COPYFUNC_CONJOINT | COPYFUNC_ALIGNED: RETURN_STUB(arrayof_jint_arraycopy); | |
| 487 case COPYFUNC_DISJOINT | COPYFUNC_UNALIGNED: RETURN_STUB(jint_disjoint_arraycopy); | |
| 488 case COPYFUNC_DISJOINT | COPYFUNC_ALIGNED: RETURN_STUB(arrayof_jint_disjoint_arraycopy); | |
| 489 } | |
| 490 case T_DOUBLE: | |
| 491 case T_LONG: | |
| 492 switch (selector) { | |
| 493 case COPYFUNC_CONJOINT | COPYFUNC_UNALIGNED: RETURN_STUB(jlong_arraycopy); | |
| 494 case COPYFUNC_CONJOINT | COPYFUNC_ALIGNED: RETURN_STUB(arrayof_jlong_arraycopy); | |
| 495 case COPYFUNC_DISJOINT | COPYFUNC_UNALIGNED: RETURN_STUB(jlong_disjoint_arraycopy); | |
| 496 case COPYFUNC_DISJOINT | COPYFUNC_ALIGNED: RETURN_STUB(arrayof_jlong_disjoint_arraycopy); | |
| 497 } | |
| 498 case T_ARRAY: | |
| 499 case T_OBJECT: | |
| 500 switch (selector) { | |
| 501 case COPYFUNC_CONJOINT | COPYFUNC_UNALIGNED: RETURN_STUB_PARM(oop_arraycopy, dest_uninitialized); | |
| 502 case COPYFUNC_CONJOINT | COPYFUNC_ALIGNED: RETURN_STUB_PARM(arrayof_oop_arraycopy, dest_uninitialized); | |
| 503 case COPYFUNC_DISJOINT | COPYFUNC_UNALIGNED: RETURN_STUB_PARM(oop_disjoint_arraycopy, dest_uninitialized); | |
| 504 case COPYFUNC_DISJOINT | COPYFUNC_ALIGNED: RETURN_STUB_PARM(arrayof_oop_disjoint_arraycopy, dest_uninitialized); | |
| 505 } | |
| 506 default: | |
| 507 ShouldNotReachHere(); | |
| 508 return NULL; | |
| 509 } | |
| 510 | |
| 511 #undef RETURN_STUB | |
| 512 #undef RETURN_STUB_PARM | |
| 513 } |