annotate src/cpu/sparc/vm/copy_sparc.hpp @ 196:d1605aabd0a1 jdk7-b30

6719955: Update copyright year Summary: Update copyright year for files that have been modified in 2008 Reviewed-by: ohair, tbell
author xdono
date Wed, 02 Jul 2008 12:55:16 -0700
parents ba764ed4b6f2
children c18cbe5936b8 2d127394260e
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
196
d1605aabd0a1 6719955: Update copyright year
xdono
parents: 113
diff changeset
2 * Copyright 2003-2008 Sun Microsystems, Inc. All Rights Reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
a61af66fc99e Initial load
duke
parents:
diff changeset
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
a61af66fc99e Initial load
duke
parents:
diff changeset
20 * CA 95054 USA or visit www.sun.com if you need additional information or
a61af66fc99e Initial load
duke
parents:
diff changeset
21 * have any questions.
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
a61af66fc99e Initial load
duke
parents:
diff changeset
25 // Inline functions for memory copy and fill.
a61af66fc99e Initial load
duke
parents:
diff changeset
26
a61af66fc99e Initial load
duke
parents:
diff changeset
27 static void pd_conjoint_words(HeapWord* from, HeapWord* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
28 (void)memmove(to, from, count * HeapWordSize);
a61af66fc99e Initial load
duke
parents:
diff changeset
29 }
a61af66fc99e Initial load
duke
parents:
diff changeset
30
a61af66fc99e Initial load
duke
parents:
diff changeset
31 static void pd_disjoint_words(HeapWord* from, HeapWord* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
32 switch (count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
33 case 8: to[7] = from[7];
a61af66fc99e Initial load
duke
parents:
diff changeset
34 case 7: to[6] = from[6];
a61af66fc99e Initial load
duke
parents:
diff changeset
35 case 6: to[5] = from[5];
a61af66fc99e Initial load
duke
parents:
diff changeset
36 case 5: to[4] = from[4];
a61af66fc99e Initial load
duke
parents:
diff changeset
37 case 4: to[3] = from[3];
a61af66fc99e Initial load
duke
parents:
diff changeset
38 case 3: to[2] = from[2];
a61af66fc99e Initial load
duke
parents:
diff changeset
39 case 2: to[1] = from[1];
a61af66fc99e Initial load
duke
parents:
diff changeset
40 case 1: to[0] = from[0];
a61af66fc99e Initial load
duke
parents:
diff changeset
41 case 0: break;
a61af66fc99e Initial load
duke
parents:
diff changeset
42 default: (void)memcpy(to, from, count * HeapWordSize);
a61af66fc99e Initial load
duke
parents:
diff changeset
43 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
44 }
a61af66fc99e Initial load
duke
parents:
diff changeset
45 }
a61af66fc99e Initial load
duke
parents:
diff changeset
46
a61af66fc99e Initial load
duke
parents:
diff changeset
47 static void pd_disjoint_words_atomic(HeapWord* from, HeapWord* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
48 switch (count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
49 case 8: to[7] = from[7];
a61af66fc99e Initial load
duke
parents:
diff changeset
50 case 7: to[6] = from[6];
a61af66fc99e Initial load
duke
parents:
diff changeset
51 case 6: to[5] = from[5];
a61af66fc99e Initial load
duke
parents:
diff changeset
52 case 5: to[4] = from[4];
a61af66fc99e Initial load
duke
parents:
diff changeset
53 case 4: to[3] = from[3];
a61af66fc99e Initial load
duke
parents:
diff changeset
54 case 3: to[2] = from[2];
a61af66fc99e Initial load
duke
parents:
diff changeset
55 case 2: to[1] = from[1];
a61af66fc99e Initial load
duke
parents:
diff changeset
56 case 1: to[0] = from[0];
a61af66fc99e Initial load
duke
parents:
diff changeset
57 case 0: break;
a61af66fc99e Initial load
duke
parents:
diff changeset
58 default: while (count-- > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
59 *to++ = *from++;
a61af66fc99e Initial load
duke
parents:
diff changeset
60 }
a61af66fc99e Initial load
duke
parents:
diff changeset
61 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
62 }
a61af66fc99e Initial load
duke
parents:
diff changeset
63 }
a61af66fc99e Initial load
duke
parents:
diff changeset
64
a61af66fc99e Initial load
duke
parents:
diff changeset
65 static void pd_aligned_conjoint_words(HeapWord* from, HeapWord* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
66 (void)memmove(to, from, count * HeapWordSize);
a61af66fc99e Initial load
duke
parents:
diff changeset
67 }
a61af66fc99e Initial load
duke
parents:
diff changeset
68
a61af66fc99e Initial load
duke
parents:
diff changeset
69 static void pd_aligned_disjoint_words(HeapWord* from, HeapWord* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
70 pd_disjoint_words(from, to, count);
a61af66fc99e Initial load
duke
parents:
diff changeset
71 }
a61af66fc99e Initial load
duke
parents:
diff changeset
72
a61af66fc99e Initial load
duke
parents:
diff changeset
73 static void pd_conjoint_bytes(void* from, void* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
74 (void)memmove(to, from, count);
a61af66fc99e Initial load
duke
parents:
diff changeset
75 }
a61af66fc99e Initial load
duke
parents:
diff changeset
76
a61af66fc99e Initial load
duke
parents:
diff changeset
77 static void pd_conjoint_bytes_atomic(void* from, void* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
78 (void)memmove(to, from, count);
a61af66fc99e Initial load
duke
parents:
diff changeset
79 }
a61af66fc99e Initial load
duke
parents:
diff changeset
80
a61af66fc99e Initial load
duke
parents:
diff changeset
81 static void pd_conjoint_jshorts_atomic(jshort* from, jshort* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
82 // FIXME
a61af66fc99e Initial load
duke
parents:
diff changeset
83 (void)memmove(to, from, count << LogBytesPerShort);
a61af66fc99e Initial load
duke
parents:
diff changeset
84 }
a61af66fc99e Initial load
duke
parents:
diff changeset
85
a61af66fc99e Initial load
duke
parents:
diff changeset
86 static void pd_conjoint_jints_atomic(jint* from, jint* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
87 // FIXME
a61af66fc99e Initial load
duke
parents:
diff changeset
88 (void)memmove(to, from, count << LogBytesPerInt);
a61af66fc99e Initial load
duke
parents:
diff changeset
89 }
a61af66fc99e Initial load
duke
parents:
diff changeset
90
a61af66fc99e Initial load
duke
parents:
diff changeset
91 static void pd_conjoint_jlongs_atomic(jlong* from, jlong* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
92 #ifdef _LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
93 assert(BytesPerLong == BytesPerOop, "jlongs and oops must be the same size");
a61af66fc99e Initial load
duke
parents:
diff changeset
94 pd_conjoint_oops_atomic((oop*)from, (oop*)to, count);
a61af66fc99e Initial load
duke
parents:
diff changeset
95 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
96 // Guarantee use of ldd/std via some asm code, because compiler won't.
a61af66fc99e Initial load
duke
parents:
diff changeset
97 // See solaris_sparc.il.
a61af66fc99e Initial load
duke
parents:
diff changeset
98 _Copy_conjoint_jlongs_atomic(from, to, count);
a61af66fc99e Initial load
duke
parents:
diff changeset
99 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
100 }
a61af66fc99e Initial load
duke
parents:
diff changeset
101
a61af66fc99e Initial load
duke
parents:
diff changeset
102 static void pd_conjoint_oops_atomic(oop* from, oop* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
103 // Do better than this: inline memmove body NEEDS CLEANUP
a61af66fc99e Initial load
duke
parents:
diff changeset
104 if (from > to) {
a61af66fc99e Initial load
duke
parents:
diff changeset
105 while (count-- > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
106 // Copy forwards
a61af66fc99e Initial load
duke
parents:
diff changeset
107 *to++ = *from++;
a61af66fc99e Initial load
duke
parents:
diff changeset
108 }
a61af66fc99e Initial load
duke
parents:
diff changeset
109 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
110 from += count - 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
111 to += count - 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
112 while (count-- > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
113 // Copy backwards
a61af66fc99e Initial load
duke
parents:
diff changeset
114 *to-- = *from--;
a61af66fc99e Initial load
duke
parents:
diff changeset
115 }
a61af66fc99e Initial load
duke
parents:
diff changeset
116 }
a61af66fc99e Initial load
duke
parents:
diff changeset
117 }
a61af66fc99e Initial load
duke
parents:
diff changeset
118
a61af66fc99e Initial load
duke
parents:
diff changeset
119 static void pd_arrayof_conjoint_bytes(HeapWord* from, HeapWord* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
120 pd_conjoint_bytes_atomic(from, to, count);
a61af66fc99e Initial load
duke
parents:
diff changeset
121 }
a61af66fc99e Initial load
duke
parents:
diff changeset
122
a61af66fc99e Initial load
duke
parents:
diff changeset
123 static void pd_arrayof_conjoint_jshorts(HeapWord* from, HeapWord* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
124 pd_conjoint_jshorts_atomic((jshort*)from, (jshort*)to, count);
a61af66fc99e Initial load
duke
parents:
diff changeset
125 }
a61af66fc99e Initial load
duke
parents:
diff changeset
126
a61af66fc99e Initial load
duke
parents:
diff changeset
127 static void pd_arrayof_conjoint_jints(HeapWord* from, HeapWord* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
128 pd_conjoint_jints_atomic((jint*)from, (jint*)to, count);
a61af66fc99e Initial load
duke
parents:
diff changeset
129 }
a61af66fc99e Initial load
duke
parents:
diff changeset
130
a61af66fc99e Initial load
duke
parents:
diff changeset
131 static void pd_arrayof_conjoint_jlongs(HeapWord* from, HeapWord* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
132 pd_conjoint_jlongs_atomic((jlong*)from, (jlong*)to, count);
a61af66fc99e Initial load
duke
parents:
diff changeset
133 }
a61af66fc99e Initial load
duke
parents:
diff changeset
134
a61af66fc99e Initial load
duke
parents:
diff changeset
135 static void pd_arrayof_conjoint_oops(HeapWord* from, HeapWord* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
136 pd_conjoint_oops_atomic((oop*)from, (oop*)to, count);
a61af66fc99e Initial load
duke
parents:
diff changeset
137 }
a61af66fc99e Initial load
duke
parents:
diff changeset
138
a61af66fc99e Initial load
duke
parents:
diff changeset
139 static void pd_fill_to_words(HeapWord* tohw, size_t count, juint value) {
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
140 #ifdef _LP64
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
141 guarantee(mask_bits((uintptr_t)tohw, right_n_bits(LogBytesPerLong)) == 0,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
142 "unaligned fill words");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
143 julong* to = (julong*)tohw;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
144 julong v = ((julong)value << 32) | value;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
145 while (count-- > 0) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
146 *to++ = v;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
147 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
148 #else // _LP64
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
149 juint* to = (juint*)tohw;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
150 while (count-- > 0) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
151 *to++ = value;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
152 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
153 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
154 }
a61af66fc99e Initial load
duke
parents:
diff changeset
155
a61af66fc99e Initial load
duke
parents:
diff changeset
156 static void pd_fill_to_aligned_words(HeapWord* tohw, size_t count, juint value) {
a61af66fc99e Initial load
duke
parents:
diff changeset
157 assert(MinObjAlignmentInBytes == BytesPerLong, "need alternate implementation");
a61af66fc99e Initial load
duke
parents:
diff changeset
158
a61af66fc99e Initial load
duke
parents:
diff changeset
159 julong* to = (julong*)tohw;
a61af66fc99e Initial load
duke
parents:
diff changeset
160 julong v = ((julong)value << 32) | value;
a61af66fc99e Initial load
duke
parents:
diff changeset
161 // If count is odd, odd will be equal to 1 on 32-bit platform
a61af66fc99e Initial load
duke
parents:
diff changeset
162 // and be equal to 0 on 64-bit platform.
a61af66fc99e Initial load
duke
parents:
diff changeset
163 size_t odd = count % (BytesPerLong / HeapWordSize) ;
a61af66fc99e Initial load
duke
parents:
diff changeset
164
a61af66fc99e Initial load
duke
parents:
diff changeset
165 size_t aligned_count = align_object_size(count - odd) / HeapWordsPerLong;
a61af66fc99e Initial load
duke
parents:
diff changeset
166 julong* end = ((julong*)tohw) + aligned_count - 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
167 while (to <= end) {
a61af66fc99e Initial load
duke
parents:
diff changeset
168 DEBUG_ONLY(count -= BytesPerLong / HeapWordSize ;)
a61af66fc99e Initial load
duke
parents:
diff changeset
169 *to++ = v;
a61af66fc99e Initial load
duke
parents:
diff changeset
170 }
a61af66fc99e Initial load
duke
parents:
diff changeset
171 assert(count == odd, "bad bounds on loop filling to aligned words");
a61af66fc99e Initial load
duke
parents:
diff changeset
172 if (odd) {
a61af66fc99e Initial load
duke
parents:
diff changeset
173 *((juint*)to) = value;
a61af66fc99e Initial load
duke
parents:
diff changeset
174
a61af66fc99e Initial load
duke
parents:
diff changeset
175 }
a61af66fc99e Initial load
duke
parents:
diff changeset
176 }
a61af66fc99e Initial load
duke
parents:
diff changeset
177
a61af66fc99e Initial load
duke
parents:
diff changeset
178 static void pd_fill_to_bytes(void* to, size_t count, jubyte value) {
a61af66fc99e Initial load
duke
parents:
diff changeset
179 (void)memset(to, value, count);
a61af66fc99e Initial load
duke
parents:
diff changeset
180 }
a61af66fc99e Initial load
duke
parents:
diff changeset
181
a61af66fc99e Initial load
duke
parents:
diff changeset
182 static void pd_zero_to_words(HeapWord* tohw, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
183 pd_fill_to_words(tohw, count, 0);
a61af66fc99e Initial load
duke
parents:
diff changeset
184 }
a61af66fc99e Initial load
duke
parents:
diff changeset
185
a61af66fc99e Initial load
duke
parents:
diff changeset
186 static void pd_zero_to_bytes(void* to, size_t count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
187 (void)memset(to, 0, count);
a61af66fc99e Initial load
duke
parents:
diff changeset
188 }