Mercurial > hg > truffle
annotate src/share/vm/utilities/copy.hpp @ 1721:413ad0331a0c
6977924: Changes for 6975078 produce build error with certain gcc versions
Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error.
Reviewed-by: jcoomes, ysr, phh
| author | johnc |
|---|---|
| date | Wed, 18 Aug 2010 10:59:06 -0700 |
| parents | d93949c5bdcc |
| children | f95d63e2154a |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
diff
changeset
|
2 * Copyright (c) 2003, 2008, 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:
196
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
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:
196
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 25 // Assembly code for platforms that need it. | |
| 26 extern "C" { | |
| 27 void _Copy_conjoint_words(HeapWord* from, HeapWord* to, size_t count); | |
| 28 void _Copy_disjoint_words(HeapWord* from, HeapWord* to, size_t count); | |
| 29 | |
| 30 void _Copy_conjoint_words_atomic(HeapWord* from, HeapWord* to, size_t count); | |
| 31 void _Copy_disjoint_words_atomic(HeapWord* from, HeapWord* to, size_t count); | |
| 32 | |
| 33 void _Copy_aligned_conjoint_words(HeapWord* from, HeapWord* to, size_t count); | |
| 34 void _Copy_aligned_disjoint_words(HeapWord* from, HeapWord* to, size_t count); | |
| 35 | |
| 36 void _Copy_conjoint_bytes(void* from, void* to, size_t count); | |
| 37 | |
| 38 void _Copy_conjoint_bytes_atomic (void* from, void* to, size_t count); | |
| 39 void _Copy_conjoint_jshorts_atomic(jshort* from, jshort* to, size_t count); | |
| 40 void _Copy_conjoint_jints_atomic (jint* from, jint* to, size_t count); | |
| 41 void _Copy_conjoint_jlongs_atomic (jlong* from, jlong* to, size_t count); | |
| 42 void _Copy_conjoint_oops_atomic (oop* from, oop* to, size_t count); | |
| 43 | |
| 44 void _Copy_arrayof_conjoint_bytes (HeapWord* from, HeapWord* to, size_t count); | |
| 45 void _Copy_arrayof_conjoint_jshorts(HeapWord* from, HeapWord* to, size_t count); | |
| 46 void _Copy_arrayof_conjoint_jints (HeapWord* from, HeapWord* to, size_t count); | |
| 47 void _Copy_arrayof_conjoint_jlongs (HeapWord* from, HeapWord* to, size_t count); | |
| 48 void _Copy_arrayof_conjoint_oops (HeapWord* from, HeapWord* to, size_t count); | |
| 49 } | |
| 50 | |
| 51 class Copy : AllStatic { | |
| 52 public: | |
| 53 // Block copy methods have four attributes. We don't define all possibilities. | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
54 // alignment: aligned to BytesPerLong |
| 0 | 55 // arrayof: arraycopy operation with both operands aligned on the same |
| 56 // boundary as the first element of an array of the copy unit. | |
| 57 // This is currently a HeapWord boundary on all platforms, except | |
| 58 // for long and double arrays, which are aligned on an 8-byte | |
| 59 // boundary on all platforms. | |
| 60 // arraycopy operations are implicitly atomic on each array element. | |
| 61 // overlap: disjoint or conjoint. | |
| 62 // copy unit: bytes or words (i.e., HeapWords) or oops (i.e., pointers). | |
| 63 // atomicity: atomic or non-atomic on the copy unit. | |
| 64 // | |
| 65 // Names are constructed thusly: | |
| 66 // | |
| 67 // [ 'aligned_' | 'arrayof_' ] | |
| 68 // ('conjoint_' | 'disjoint_') | |
| 69 // ('words' | 'bytes' | 'jshorts' | 'jints' | 'jlongs' | 'oops') | |
| 70 // [ '_atomic' ] | |
| 71 // | |
| 72 // Except in the arrayof case, whatever the alignment is, we assume we can copy | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
73 // whole alignment units. E.g., if BytesPerLong is 2x word alignment, an odd |
| 0 | 74 // count may copy an extra word. In the arrayof case, we are allowed to copy |
| 75 // only the number of copy units specified. | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1579
diff
changeset
|
76 // |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1579
diff
changeset
|
77 // All callees check count for 0. |
|
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1579
diff
changeset
|
78 // |
| 0 | 79 |
| 80 // HeapWords | |
| 81 | |
| 82 // Word-aligned words, conjoint, not atomic on each word | |
| 83 static void conjoint_words(HeapWord* from, HeapWord* to, size_t count) { | |
| 84 assert_params_ok(from, to, LogHeapWordSize); | |
| 85 pd_conjoint_words(from, to, count); | |
| 86 } | |
| 87 | |
| 88 // Word-aligned words, disjoint, not atomic on each word | |
| 89 static void disjoint_words(HeapWord* from, HeapWord* to, size_t count) { | |
| 90 assert_params_ok(from, to, LogHeapWordSize); | |
| 91 assert_disjoint(from, to, count); | |
| 92 pd_disjoint_words(from, to, count); | |
| 93 } | |
| 94 | |
| 95 // Word-aligned words, disjoint, atomic on each word | |
| 96 static void disjoint_words_atomic(HeapWord* from, HeapWord* to, size_t count) { | |
| 97 assert_params_ok(from, to, LogHeapWordSize); | |
| 98 assert_disjoint(from, to, count); | |
| 99 pd_disjoint_words_atomic(from, to, count); | |
| 100 } | |
| 101 | |
| 102 // Object-aligned words, conjoint, not atomic on each word | |
| 103 static void aligned_conjoint_words(HeapWord* from, HeapWord* to, size_t count) { | |
| 104 assert_params_aligned(from, to); | |
| 105 pd_aligned_conjoint_words(from, to, count); | |
| 106 } | |
| 107 | |
| 108 // Object-aligned words, disjoint, not atomic on each word | |
| 109 static void aligned_disjoint_words(HeapWord* from, HeapWord* to, size_t count) { | |
| 110 assert_params_aligned(from, to); | |
| 111 assert_disjoint(from, to, count); | |
| 112 pd_aligned_disjoint_words(from, to, count); | |
| 113 } | |
| 114 | |
| 115 // bytes, jshorts, jints, jlongs, oops | |
| 116 | |
| 117 // bytes, conjoint, not atomic on each byte (not that it matters) | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1579
diff
changeset
|
118 static void conjoint_jbytes(void* from, void* to, size_t count) { |
| 0 | 119 pd_conjoint_bytes(from, to, count); |
| 120 } | |
| 121 | |
| 122 // bytes, conjoint, atomic on each byte (not that it matters) | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1579
diff
changeset
|
123 static void conjoint_jbytes_atomic(void* from, void* to, size_t count) { |
| 0 | 124 pd_conjoint_bytes(from, to, count); |
| 125 } | |
| 126 | |
| 127 // jshorts, conjoint, atomic on each jshort | |
| 128 static void conjoint_jshorts_atomic(jshort* from, jshort* to, size_t count) { | |
| 129 assert_params_ok(from, to, LogBytesPerShort); | |
| 130 pd_conjoint_jshorts_atomic(from, to, count); | |
| 131 } | |
| 132 | |
| 133 // jints, conjoint, atomic on each jint | |
| 134 static void conjoint_jints_atomic(jint* from, jint* to, size_t count) { | |
| 135 assert_params_ok(from, to, LogBytesPerInt); | |
| 136 pd_conjoint_jints_atomic(from, to, count); | |
| 137 } | |
| 138 | |
| 139 // jlongs, conjoint, atomic on each jlong | |
| 140 static void conjoint_jlongs_atomic(jlong* from, jlong* to, size_t count) { | |
| 141 assert_params_ok(from, to, LogBytesPerLong); | |
| 142 pd_conjoint_jlongs_atomic(from, to, count); | |
| 143 } | |
| 144 | |
| 145 // oops, conjoint, atomic on each oop | |
| 146 static void conjoint_oops_atomic(oop* from, oop* to, size_t count) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
147 assert_params_ok(from, to, LogBytesPerHeapOop); |
| 0 | 148 pd_conjoint_oops_atomic(from, to, count); |
| 149 } | |
| 150 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
151 // overloaded for UseCompressedOops |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
152 static void conjoint_oops_atomic(narrowOop* from, narrowOop* to, size_t count) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
153 assert(sizeof(narrowOop) == sizeof(jint), "this cast is wrong"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
154 assert_params_ok(from, to, LogBytesPerInt); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
155 pd_conjoint_jints_atomic((jint*)from, (jint*)to, count); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
156 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
157 |
| 0 | 158 // Copy a span of memory. If the span is an integral number of aligned |
| 159 // longs, words, or ints, copy those units atomically. | |
| 160 // The largest atomic transfer unit is 8 bytes, or the largest power | |
| 161 // of two which divides all of from, to, and size, whichever is smaller. | |
| 162 static void conjoint_memory_atomic(void* from, void* to, size_t size); | |
| 163 | |
| 164 // bytes, conjoint array, atomic on each byte (not that it matters) | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1579
diff
changeset
|
165 static void arrayof_conjoint_jbytes(HeapWord* from, HeapWord* to, size_t count) { |
| 0 | 166 pd_arrayof_conjoint_bytes(from, to, count); |
| 167 } | |
| 168 | |
| 169 // jshorts, conjoint array, atomic on each jshort | |
| 170 static void arrayof_conjoint_jshorts(HeapWord* from, HeapWord* to, size_t count) { | |
| 171 assert_params_ok(from, to, LogBytesPerShort); | |
| 172 pd_arrayof_conjoint_jshorts(from, to, count); | |
| 173 } | |
| 174 | |
| 175 // jints, conjoint array, atomic on each jint | |
| 176 static void arrayof_conjoint_jints(HeapWord* from, HeapWord* to, size_t count) { | |
| 177 assert_params_ok(from, to, LogBytesPerInt); | |
| 178 pd_arrayof_conjoint_jints(from, to, count); | |
| 179 } | |
| 180 | |
| 181 // jlongs, conjoint array, atomic on each jlong | |
| 182 static void arrayof_conjoint_jlongs(HeapWord* from, HeapWord* to, size_t count) { | |
| 183 assert_params_ok(from, to, LogBytesPerLong); | |
| 184 pd_arrayof_conjoint_jlongs(from, to, count); | |
| 185 } | |
| 186 | |
| 187 // oops, conjoint array, atomic on each oop | |
| 188 static void arrayof_conjoint_oops(HeapWord* from, HeapWord* to, size_t count) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
189 assert_params_ok(from, to, LogBytesPerHeapOop); |
| 0 | 190 pd_arrayof_conjoint_oops(from, to, count); |
| 191 } | |
| 192 | |
| 193 // Known overlap methods | |
| 194 | |
| 195 // Copy word-aligned words from higher to lower addresses, not atomic on each word | |
| 196 inline static void conjoint_words_to_lower(HeapWord* from, HeapWord* to, size_t byte_count) { | |
| 197 // byte_count is in bytes to check its alignment | |
| 198 assert_params_ok(from, to, LogHeapWordSize); | |
| 199 assert_byte_count_ok(byte_count, HeapWordSize); | |
| 200 | |
| 201 size_t count = (size_t)round_to(byte_count, HeapWordSize) >> LogHeapWordSize; | |
| 202 assert(to <= from || from + count <= to, "do not overwrite source data"); | |
| 203 | |
| 204 while (count-- > 0) { | |
| 205 *to++ = *from++; | |
| 206 } | |
| 207 } | |
| 208 | |
| 209 // Copy word-aligned words from lower to higher addresses, not atomic on each word | |
| 210 inline static void conjoint_words_to_higher(HeapWord* from, HeapWord* to, size_t byte_count) { | |
| 211 // byte_count is in bytes to check its alignment | |
| 212 assert_params_ok(from, to, LogHeapWordSize); | |
| 213 assert_byte_count_ok(byte_count, HeapWordSize); | |
| 214 | |
| 215 size_t count = (size_t)round_to(byte_count, HeapWordSize) >> LogHeapWordSize; | |
| 216 assert(from <= to || to + count <= from, "do not overwrite source data"); | |
| 217 | |
| 218 from += count - 1; | |
| 219 to += count - 1; | |
| 220 while (count-- > 0) { | |
| 221 *to-- = *from--; | |
| 222 } | |
| 223 } | |
| 224 | |
| 225 // Fill methods | |
| 226 | |
| 227 // Fill word-aligned words, not atomic on each word | |
| 228 // set_words | |
| 229 static void fill_to_words(HeapWord* to, size_t count, juint value = 0) { | |
| 230 assert_params_ok(to, LogHeapWordSize); | |
| 231 pd_fill_to_words(to, count, value); | |
| 232 } | |
| 233 | |
| 234 static void fill_to_aligned_words(HeapWord* to, size_t count, juint value = 0) { | |
| 235 assert_params_aligned(to); | |
| 236 pd_fill_to_aligned_words(to, count, value); | |
| 237 } | |
| 238 | |
| 239 // Fill bytes | |
| 240 static void fill_to_bytes(void* to, size_t count, jubyte value = 0) { | |
| 241 pd_fill_to_bytes(to, count, value); | |
| 242 } | |
| 243 | |
| 244 // Fill a span of memory. If the span is an integral number of aligned | |
| 245 // longs, words, or ints, store to those units atomically. | |
| 246 // The largest atomic transfer unit is 8 bytes, or the largest power | |
| 247 // of two which divides both to and size, whichever is smaller. | |
| 248 static void fill_to_memory_atomic(void* to, size_t size, jubyte value = 0); | |
| 249 | |
| 250 // Zero-fill methods | |
| 251 | |
| 252 // Zero word-aligned words, not atomic on each word | |
| 253 static void zero_to_words(HeapWord* to, size_t count) { | |
| 254 assert_params_ok(to, LogHeapWordSize); | |
| 255 pd_zero_to_words(to, count); | |
| 256 } | |
| 257 | |
| 258 // Zero bytes | |
| 259 static void zero_to_bytes(void* to, size_t count) { | |
| 260 pd_zero_to_bytes(to, count); | |
| 261 } | |
| 262 | |
| 263 private: | |
| 264 static bool params_disjoint(HeapWord* from, HeapWord* to, size_t count) { | |
| 265 if (from < to) { | |
| 266 return pointer_delta(to, from) >= count; | |
| 267 } | |
| 268 return pointer_delta(from, to) >= count; | |
| 269 } | |
| 270 | |
| 271 // These methods raise a fatal if they detect a problem. | |
| 272 | |
| 273 static void assert_disjoint(HeapWord* from, HeapWord* to, size_t count) { | |
| 274 #ifdef ASSERT | |
| 275 if (!params_disjoint(from, to, count)) | |
| 276 basic_fatal("source and dest overlap"); | |
| 277 #endif | |
| 278 } | |
| 279 | |
| 280 static void assert_params_ok(void* from, void* to, intptr_t log_align) { | |
| 281 #ifdef ASSERT | |
| 282 if (mask_bits((uintptr_t)from, right_n_bits(log_align)) != 0) | |
| 283 basic_fatal("not aligned"); | |
| 284 if (mask_bits((uintptr_t)to, right_n_bits(log_align)) != 0) | |
| 285 basic_fatal("not aligned"); | |
| 286 #endif | |
| 287 } | |
| 288 | |
| 289 static void assert_params_ok(HeapWord* to, intptr_t log_align) { | |
| 290 #ifdef ASSERT | |
| 291 if (mask_bits((uintptr_t)to, right_n_bits(log_align)) != 0) | |
| 292 basic_fatal("not word aligned"); | |
| 293 #endif | |
| 294 } | |
| 295 static void assert_params_aligned(HeapWord* from, HeapWord* to) { | |
| 296 #ifdef ASSERT | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
297 if (mask_bits((uintptr_t)from, BytesPerLong-1) != 0) |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
298 basic_fatal("not long aligned"); |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
299 if (mask_bits((uintptr_t)to, BytesPerLong-1) != 0) |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
300 basic_fatal("not long aligned"); |
| 0 | 301 #endif |
| 302 } | |
| 303 | |
| 304 static void assert_params_aligned(HeapWord* to) { | |
| 305 #ifdef ASSERT | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
306 if (mask_bits((uintptr_t)to, BytesPerLong-1) != 0) |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
307 basic_fatal("not long aligned"); |
| 0 | 308 #endif |
| 309 } | |
| 310 | |
| 311 static void assert_byte_count_ok(size_t byte_count, size_t unit_size) { | |
| 312 #ifdef ASSERT | |
| 313 if ((size_t)round_to(byte_count, unit_size) != byte_count) { | |
| 314 basic_fatal("byte count must be aligned"); | |
| 315 } | |
| 316 #endif | |
| 317 } | |
| 318 | |
| 319 // Platform dependent implementations of the above methods. | |
| 320 #include "incls/_copy_pd.hpp.incl" | |
| 321 }; |