Mercurial > hg > truffle

comparison src/share/vm/utilities/copy.hpp @ 0:a61af66fc99e jdk7-b24

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial load
author duke
date Sat, 01 Dec 2007 00:00:00 +0000
parents
children ba764ed4b6f2
comparison
equal deleted inserted replaced
-1:000000000000 0:a61af66fc99e
1 /*
2 * Copyright 2003-2006 Sun Microsystems, Inc. All Rights Reserved.
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 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
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.
54 // alignment: aligned according to minimum Java object alignment (MinObjAlignment)
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
73 // whole alignment units. E.g., if MinObjAlignment is 2x word alignment, an odd
74 // count may copy an extra word. In the arrayof case, we are allowed to copy
75 // only the number of copy units specified.
76
77 // HeapWords
78
79 // Word-aligned words, conjoint, not atomic on each word
80 static void conjoint_words(HeapWord* from, HeapWord* to, size_t count) {
81 assert_params_ok(from, to, LogHeapWordSize);
82 pd_conjoint_words(from, to, count);
83 }
84
85 // Word-aligned words, disjoint, not atomic on each word
86 static void disjoint_words(HeapWord* from, HeapWord* to, size_t count) {
87 assert_params_ok(from, to, LogHeapWordSize);
88 assert_disjoint(from, to, count);
89 pd_disjoint_words(from, to, count);
90 }
91
92 // Word-aligned words, disjoint, atomic on each word
93 static void disjoint_words_atomic(HeapWord* from, HeapWord* to, size_t count) {
94 assert_params_ok(from, to, LogHeapWordSize);
95 assert_disjoint(from, to, count);
96 pd_disjoint_words_atomic(from, to, count);
97 }
98
99 // Object-aligned words, conjoint, not atomic on each word
100 static void aligned_conjoint_words(HeapWord* from, HeapWord* to, size_t count) {
101 assert_params_aligned(from, to);
102 assert_non_zero(count);
103 pd_aligned_conjoint_words(from, to, count);
104 }
105
106 // Object-aligned words, disjoint, not atomic on each word
107 static void aligned_disjoint_words(HeapWord* from, HeapWord* to, size_t count) {
108 assert_params_aligned(from, to);
109 assert_disjoint(from, to, count);
110 assert_non_zero(count);
111 pd_aligned_disjoint_words(from, to, count);
112 }
113
114 // bytes, jshorts, jints, jlongs, oops
115
116 // bytes, conjoint, not atomic on each byte (not that it matters)
117 static void conjoint_bytes(void* from, void* to, size_t count) {
118 assert_non_zero(count);
119 pd_conjoint_bytes(from, to, count);
120 }
121
122 // bytes, conjoint, atomic on each byte (not that it matters)
123 static void conjoint_bytes_atomic(void* from, void* to, size_t count) {
124 assert_non_zero(count);
125 pd_conjoint_bytes(from, to, count);
126 }
127
128 // jshorts, conjoint, atomic on each jshort
129 static void conjoint_jshorts_atomic(jshort* from, jshort* to, size_t count) {
130 assert_params_ok(from, to, LogBytesPerShort);
131 assert_non_zero(count);
132 pd_conjoint_jshorts_atomic(from, to, count);
133 }
134
135 // jints, conjoint, atomic on each jint
136 static void conjoint_jints_atomic(jint* from, jint* to, size_t count) {
137 assert_params_ok(from, to, LogBytesPerInt);
138 assert_non_zero(count);
139 pd_conjoint_jints_atomic(from, to, count);
140 }
141
142 // jlongs, conjoint, atomic on each jlong
143 static void conjoint_jlongs_atomic(jlong* from, jlong* to, size_t count) {
144 assert_params_ok(from, to, LogBytesPerLong);
145 assert_non_zero(count);
146 pd_conjoint_jlongs_atomic(from, to, count);
147 }
148
149 // oops, conjoint, atomic on each oop
150 static void conjoint_oops_atomic(oop* from, oop* to, size_t count) {
151 assert_params_ok(from, to, LogBytesPerOop);
152 assert_non_zero(count);
153 pd_conjoint_oops_atomic(from, to, count);
154 }
155
156 // Copy a span of memory. If the span is an integral number of aligned
157 // longs, words, or ints, copy those units atomically.
158 // The largest atomic transfer unit is 8 bytes, or the largest power
159 // of two which divides all of from, to, and size, whichever is smaller.
160 static void conjoint_memory_atomic(void* from, void* to, size_t size);
161
162 // bytes, conjoint array, atomic on each byte (not that it matters)
163 static void arrayof_conjoint_bytes(HeapWord* from, HeapWord* to, size_t count) {
164 assert_non_zero(count);
165 pd_arrayof_conjoint_bytes(from, to, count);
166 }
167
168 // jshorts, conjoint array, atomic on each jshort
169 static void arrayof_conjoint_jshorts(HeapWord* from, HeapWord* to, size_t count) {
170 assert_params_ok(from, to, LogBytesPerShort);
171 assert_non_zero(count);
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 assert_non_zero(count);
179 pd_arrayof_conjoint_jints(from, to, count);
180 }
181
182 // jlongs, conjoint array, atomic on each jlong
183 static void arrayof_conjoint_jlongs(HeapWord* from, HeapWord* to, size_t count) {
184 assert_params_ok(from, to, LogBytesPerLong);
185 assert_non_zero(count);
186 pd_arrayof_conjoint_jlongs(from, to, count);
187 }
188
189 // oops, conjoint array, atomic on each oop
190 static void arrayof_conjoint_oops(HeapWord* from, HeapWord* to, size_t count) {
191 assert_params_ok(from, to, LogBytesPerOop);
192 assert_non_zero(count);
193 pd_arrayof_conjoint_oops(from, to, count);
194 }
195
196 // Known overlap methods
197
198 // Copy word-aligned words from higher to lower addresses, not atomic on each word
199 inline static void conjoint_words_to_lower(HeapWord* from, HeapWord* to, size_t byte_count) {
200 // byte_count is in bytes to check its alignment
201 assert_params_ok(from, to, LogHeapWordSize);
202 assert_byte_count_ok(byte_count, HeapWordSize);
203
204 size_t count = (size_t)round_to(byte_count, HeapWordSize) >> LogHeapWordSize;
205 assert(to <= from || from + count <= to, "do not overwrite source data");
206
207 while (count-- > 0) {
208 *to++ = *from++;
209 }
210 }
211
212 // Copy word-aligned words from lower to higher addresses, not atomic on each word
213 inline static void conjoint_words_to_higher(HeapWord* from, HeapWord* to, size_t byte_count) {
214 // byte_count is in bytes to check its alignment
215 assert_params_ok(from, to, LogHeapWordSize);
216 assert_byte_count_ok(byte_count, HeapWordSize);
217
218 size_t count = (size_t)round_to(byte_count, HeapWordSize) >> LogHeapWordSize;
219 assert(from <= to || to + count <= from, "do not overwrite source data");
220
221 from += count - 1;
222 to += count - 1;
223 while (count-- > 0) {
224 *to-- = *from--;
225 }
226 }
227
228 // Fill methods
229
230 // Fill word-aligned words, not atomic on each word
231 // set_words
232 static void fill_to_words(HeapWord* to, size_t count, juint value = 0) {
233 assert_params_ok(to, LogHeapWordSize);
234 pd_fill_to_words(to, count, value);
235 }
236
237 static void fill_to_aligned_words(HeapWord* to, size_t count, juint value = 0) {
238 assert_params_aligned(to);
239 pd_fill_to_aligned_words(to, count, value);
240 }
241
242 // Fill bytes
243 static void fill_to_bytes(void* to, size_t count, jubyte value = 0) {
244 pd_fill_to_bytes(to, count, value);
245 }
246
247 // Fill a span of memory. If the span is an integral number of aligned
248 // longs, words, or ints, store to those units atomically.
249 // The largest atomic transfer unit is 8 bytes, or the largest power
250 // of two which divides both to and size, whichever is smaller.
251 static void fill_to_memory_atomic(void* to, size_t size, jubyte value = 0);
252
253 // Zero-fill methods
254
255 // Zero word-aligned words, not atomic on each word
256 static void zero_to_words(HeapWord* to, size_t count) {
257 assert_params_ok(to, LogHeapWordSize);
258 pd_zero_to_words(to, count);
259 }
260
261 // Zero bytes
262 static void zero_to_bytes(void* to, size_t count) {
263 pd_zero_to_bytes(to, count);
264 }
265
266 private:
267 static bool params_disjoint(HeapWord* from, HeapWord* to, size_t count) {
268 if (from < to) {
269 return pointer_delta(to, from) >= count;
270 }
271 return pointer_delta(from, to) >= count;
272 }
273
274 // These methods raise a fatal if they detect a problem.
275
276 static void assert_disjoint(HeapWord* from, HeapWord* to, size_t count) {
277 #ifdef ASSERT
278 if (!params_disjoint(from, to, count))
279 basic_fatal("source and dest overlap");
280 #endif
281 }
282
283 static void assert_params_ok(void* from, void* to, intptr_t log_align) {
284 #ifdef ASSERT
285 if (mask_bits((uintptr_t)from, right_n_bits(log_align)) != 0)
286 basic_fatal("not aligned");
287 if (mask_bits((uintptr_t)to, right_n_bits(log_align)) != 0)
288 basic_fatal("not aligned");
289 #endif
290 }
291
292 static void assert_params_ok(HeapWord* to, intptr_t log_align) {
293 #ifdef ASSERT
294 if (mask_bits((uintptr_t)to, right_n_bits(log_align)) != 0)
295 basic_fatal("not word aligned");
296 #endif
297 }
298 static void assert_params_aligned(HeapWord* from, HeapWord* to) {
299 #ifdef ASSERT
300 if (mask_bits((uintptr_t)from, MinObjAlignmentInBytes-1) != 0)
301 basic_fatal("not object aligned");
302 if (mask_bits((uintptr_t)to, MinObjAlignmentInBytes-1) != 0)
303 basic_fatal("not object aligned");
304 #endif
305 }
306
307 static void assert_params_aligned(HeapWord* to) {
308 #ifdef ASSERT
309 if (mask_bits((uintptr_t)to, MinObjAlignmentInBytes-1) != 0)
310 basic_fatal("not object aligned");
311 #endif
312 }
313
314 static void assert_non_zero(size_t count) {
315 #ifdef ASSERT
316 if (count == 0) {
317 basic_fatal("count must be non-zero");
318 }
319 #endif
320 }
321
322 static void assert_byte_count_ok(size_t byte_count, size_t unit_size) {
323 #ifdef ASSERT
324 if ((size_t)round_to(byte_count, unit_size) != byte_count) {
325 basic_fatal("byte count must be aligned");
326 }
327 #endif
328 }
329
330 // Platform dependent implementations of the above methods.
331 #include "incls/_copy_pd.hpp.incl"
332 };