Mercurial > hg > graal-jvmci-8
annotate src/share/vm/utilities/array.hpp @ 24164:f98ea2d742a2
fixed missing exception propagation (JDK-8185790)
author | Doug Simon <doug.simon@oracle.com> |
---|---|
date | Tue, 08 Aug 2017 10:06:50 +0200 |
parents | 7848fc12602b |
children |
rev | line source |
---|---|
0 | 1 /* |
14333
26c3b944dc35
8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents:
12319
diff
changeset
|
2 * Copyright (c) 2000, 2014, 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:
470
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
470
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:
470
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #ifndef SHARE_VM_UTILITIES_ARRAY_HPP |
26 #define SHARE_VM_UTILITIES_ARRAY_HPP | |
27 | |
28 #include "memory/allocation.hpp" | |
29 #include "memory/allocation.inline.hpp" | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
30 #include "memory/metaspace.hpp" |
20197
ce8f6bb717c9
8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents:
17937
diff
changeset
|
31 #include "runtime/orderAccess.hpp" |
1972 | 32 |
0 | 33 // correct linkage required to compile w/o warnings |
34 // (must be on file level - cannot be local) | |
35 extern "C" { typedef int (*ftype)(const void*, const void*); } | |
36 | |
37 | |
38 class ResourceArray: public ResourceObj { | |
39 protected: | |
40 int _length; // the number of array elements | |
41 void* _data; // the array memory | |
42 #ifdef ASSERT | |
43 int _nesting; // the resource area nesting level | |
44 #endif | |
45 | |
46 // creation | |
47 ResourceArray() { | |
48 _length = 0; | |
49 _data = NULL; | |
50 DEBUG_ONLY(init_nesting();) | |
432 | 51 // client may call initialize, at most once |
0 | 52 } |
53 | |
54 | |
55 ResourceArray(size_t esize, int length) { | |
432 | 56 DEBUG_ONLY(_data = NULL); |
57 initialize(esize, length); | |
58 } | |
59 | |
60 void initialize(size_t esize, int length) { | |
0 | 61 assert(length >= 0, "illegal length"); |
14333
26c3b944dc35
8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents:
12319
diff
changeset
|
62 assert(StressRewriter || _data == NULL, "must be new object"); |
0 | 63 _length = length; |
64 _data = resource_allocate_bytes(esize * length); | |
65 DEBUG_ONLY(init_nesting();) | |
66 } | |
67 | |
68 #ifdef ASSERT | |
69 void init_nesting(); | |
70 #endif | |
71 | |
72 // helper functions | |
73 void sort (size_t esize, ftype f); // sort the array | |
74 void expand (size_t esize, int i, int& size);// expand the array to include slot i | |
75 void remove_at(size_t esize, int i); // remove the element in slot i | |
76 | |
77 public: | |
78 // standard operations | |
79 int length() const { return _length; } | |
80 bool is_empty() const { return length() == 0; } | |
81 }; | |
82 | |
83 | |
6197 | 84 template <MEMFLAGS F>class CHeapArray: public CHeapObj<F> { |
0 | 85 protected: |
86 int _length; // the number of array elements | |
87 void* _data; // the array memory | |
88 | |
89 // creation | |
90 CHeapArray() { | |
91 _length = 0; | |
92 _data = NULL; | |
93 } | |
94 | |
95 | |
96 CHeapArray(size_t esize, int length) { | |
97 assert(length >= 0, "illegal length"); | |
98 _length = length; | |
6197 | 99 _data = (void*) NEW_C_HEAP_ARRAY(char *, esize * length, F); |
0 | 100 } |
101 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
102 void initialize(size_t esize, int length) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
103 // In debug set array to 0? |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
104 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
105 |
0 | 106 #ifdef ASSERT |
107 void init_nesting(); | |
108 #endif | |
109 | |
110 // helper functions | |
111 void sort (size_t esize, ftype f); // sort the array | |
112 void expand (size_t esize, int i, int& size);// expand the array to include slot i | |
113 void remove_at(size_t esize, int i); // remove the element in slot i | |
114 | |
115 public: | |
116 // standard operations | |
117 int length() const { return _length; } | |
118 bool is_empty() const { return length() == 0; } | |
119 }; | |
120 | |
121 #define define_generic_array(array_name,element_type, base_class) \ | |
122 class array_name: public base_class { \ | |
123 protected: \ | |
124 typedef element_type etype; \ | |
125 enum { esize = sizeof(etype) }; \ | |
126 \ | |
127 void base_remove_at(size_t size, int i) { base_class::remove_at(size, i); } \ | |
128 \ | |
129 public: \ | |
130 /* creation */ \ | |
131 array_name() : base_class() {} \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
132 explicit array_name(const int length) : base_class(esize, length) {} \ |
432 | 133 array_name(const int length, const etype fx) { initialize(length, fx); } \ |
134 void initialize(const int length) { base_class::initialize(esize, length); } \ | |
135 void initialize(const int length, const etype fx) { \ | |
136 initialize(length); \ | |
0 | 137 for (int i = 0; i < length; i++) ((etype*)_data)[i] = fx; \ |
138 } \ | |
139 \ | |
140 /* standard operations */ \ | |
141 etype& operator [] (const int i) const { \ | |
142 assert(0 <= i && i < length(), "index out of bounds"); \ | |
143 return ((etype*)_data)[i]; \ | |
144 } \ | |
145 \ | |
146 int index_of(const etype x) const { \ | |
147 int i = length(); \ | |
148 while (i-- > 0 && ((etype*)_data)[i] != x) ; \ | |
149 /* i < 0 || ((etype*)_data)_data[i] == x */ \ | |
150 return i; \ | |
151 } \ | |
152 \ | |
153 void sort(int f(etype*, etype*)) { base_class::sort(esize, (ftype)f); } \ | |
154 bool contains(const etype x) const { return index_of(x) >= 0; } \ | |
155 \ | |
156 /* deprecated operations - for compatibility with GrowableArray only */ \ | |
157 etype at(const int i) const { return (*this)[i]; } \ | |
158 void at_put(const int i, const etype x) { (*this)[i] = x; } \ | |
159 etype* adr_at(const int i) { return &(*this)[i]; } \ | |
160 int find(const etype x) { return index_of(x); } \ | |
161 }; \ | |
162 | |
163 | |
164 #define define_array(array_name,element_type) \ | |
165 define_generic_array(array_name, element_type, ResourceArray) | |
166 | |
167 | |
168 #define define_stack(stack_name,array_name) \ | |
169 class stack_name: public array_name { \ | |
170 protected: \ | |
171 int _size; \ | |
172 \ | |
173 void grow(const int i, const etype fx) { \ | |
174 assert(i >= length(), "index too small"); \ | |
175 if (i >= size()) expand(esize, i, _size); \ | |
176 for (int j = length(); j <= i; j++) ((etype*)_data)[j] = fx; \ | |
177 _length = i+1; \ | |
178 } \ | |
179 \ | |
180 public: \ | |
181 /* creation */ \ | |
432 | 182 stack_name() : array_name() { _size = 0; } \ |
183 stack_name(const int size) { initialize(size); } \ | |
184 stack_name(const int size, const etype fx) { initialize(size, fx); } \ | |
185 void initialize(const int size, const etype fx) { \ | |
186 _size = size; \ | |
187 array_name::initialize(size, fx); \ | |
188 /* _length == size, allocation and size are the same */ \ | |
189 } \ | |
190 void initialize(const int size) { \ | |
191 _size = size; \ | |
192 array_name::initialize(size); \ | |
193 _length = 0; /* reset length to zero; _size records the allocation */ \ | |
194 } \ | |
0 | 195 \ |
196 /* standard operations */ \ | |
197 int size() const { return _size; } \ | |
198 \ | |
432 | 199 int push(const etype x) { \ |
200 int len = length(); \ | |
201 if (len >= size()) expand(esize, len, _size); \ | |
202 ((etype*)_data)[len] = x; \ | |
203 _length = len+1; \ | |
204 return len; \ | |
0 | 205 } \ |
206 \ | |
207 etype pop() { \ | |
208 assert(!is_empty(), "stack is empty"); \ | |
209 return ((etype*)_data)[--_length]; \ | |
210 } \ | |
211 \ | |
212 etype top() const { \ | |
213 assert(!is_empty(), "stack is empty"); \ | |
214 return ((etype*)_data)[length() - 1]; \ | |
215 } \ | |
216 \ | |
217 void push_all(const stack_name* stack) { \ | |
218 const int l = stack->length(); \ | |
219 for (int i = 0; i < l; i++) push(((etype*)(stack->_data))[i]); \ | |
220 } \ | |
221 \ | |
222 etype at_grow(const int i, const etype fx) { \ | |
223 if (i >= length()) grow(i, fx); \ | |
224 return ((etype*)_data)[i]; \ | |
225 } \ | |
226 \ | |
227 void at_put_grow(const int i, const etype x, const etype fx) { \ | |
228 if (i >= length()) grow(i, fx); \ | |
229 ((etype*)_data)[i] = x; \ | |
230 } \ | |
231 \ | |
232 void truncate(const int length) { \ | |
233 assert(0 <= length && length <= this->length(), "illegal length"); \ | |
234 _length = length; \ | |
235 } \ | |
236 \ | |
237 void remove_at(int i) { base_remove_at(esize, i); } \ | |
238 void remove(etype x) { remove_at(index_of(x)); } \ | |
239 \ | |
240 /* inserts the given element before the element at index i */ \ | |
241 void insert_before(const int i, const etype el) { \ | |
242 int len = length(); \ | |
243 int new_length = len + 1; \ | |
244 if (new_length >= size()) expand(esize, new_length, _size); \ | |
245 for (int j = len - 1; j >= i; j--) { \ | |
246 ((etype*)_data)[j + 1] = ((etype*)_data)[j]; \ | |
247 } \ | |
248 _length = new_length; \ | |
249 at_put(i, el); \ | |
250 } \ | |
251 \ | |
252 /* inserts contents of the given stack before the element at index i */ \ | |
253 void insert_before(const int i, const stack_name *st) { \ | |
254 if (st->length() == 0) return; \ | |
255 int len = length(); \ | |
256 int st_len = st->length(); \ | |
257 int new_length = len + st_len; \ | |
258 if (new_length >= size()) expand(esize, new_length, _size); \ | |
259 int j; \ | |
260 for (j = len - 1; j >= i; j--) { \ | |
261 ((etype*)_data)[j + st_len] = ((etype*)_data)[j]; \ | |
262 } \ | |
263 for (j = 0; j < st_len; j++) { \ | |
264 ((etype*)_data)[i + j] = ((etype*)st->_data)[j]; \ | |
265 } \ | |
266 _length = new_length; \ | |
267 } \ | |
268 \ | |
269 /* deprecated operations - for compatibility with GrowableArray only */ \ | |
270 int capacity() const { return size(); } \ | |
271 void clear() { truncate(0); } \ | |
272 void trunc_to(const int length) { truncate(length); } \ | |
432 | 273 int append(const etype x) { return push(x); } \ |
0 | 274 void appendAll(const stack_name* stack) { push_all(stack); } \ |
275 etype last() const { return top(); } \ | |
276 }; \ | |
277 | |
278 | |
279 #define define_resource_list(element_type) \ | |
280 define_generic_array(element_type##Array, element_type, ResourceArray) \ | |
281 define_stack(element_type##List, element_type##Array) | |
282 | |
283 #define define_resource_pointer_list(element_type) \ | |
284 define_generic_array(element_type##Array, element_type *, ResourceArray) \ | |
285 define_stack(element_type##List, element_type##Array) | |
286 | |
287 #define define_c_heap_list(element_type) \ | |
288 define_generic_array(element_type##Array, element_type, CHeapArray) \ | |
289 define_stack(element_type##List, element_type##Array) | |
290 | |
291 #define define_c_heap_pointer_list(element_type) \ | |
292 define_generic_array(element_type##Array, element_type *, CHeapArray) \ | |
293 define_stack(element_type##List, element_type##Array) | |
294 | |
295 | |
296 // Arrays for basic types | |
297 | |
298 define_array(boolArray, bool) define_stack(boolStack, boolArray) | |
299 define_array(intArray , int ) define_stack(intStack , intArray ) | |
1972 | 300 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
301 // Array for metadata allocation |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
302 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
303 template <typename T> |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
304 class Array: public MetaspaceObj { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
305 friend class MetadataFactory; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
306 friend class VMStructs; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
307 friend class MethodHandleCompiler; // special case |
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
308 friend class WhiteBox; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
309 protected: |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
310 int _length; // the number of array elements |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
311 T _data[1]; // the array memory |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
312 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
313 void initialize(int length) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
314 _length = length; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
315 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
316 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
317 private: |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
318 // Turn off copy constructor and assignment operator. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
319 Array(const Array<T>&); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
320 void operator=(const Array<T>&); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
321 |
12146
9758d9f36299
8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents:
10376
diff
changeset
|
322 void* operator new(size_t size, ClassLoaderData* loader_data, int length, bool read_only, TRAPS) throw() { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
323 size_t word_size = Array::size(length); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
324 return (void*) Metaspace::allocate(loader_data, word_size, read_only, |
10376
a1ebd310d5c1
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
6972
diff
changeset
|
325 MetaspaceObj::array_type(sizeof(T)), CHECK_NULL); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
326 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
327 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
328 static size_t byte_sizeof(int length) { return sizeof(Array<T>) + MAX2(length - 1, 0) * sizeof(T); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
329 |
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
330 // WhiteBox API helper. |
20279 | 331 // Can't distinguish between array of length 0 and length 1, |
332 // will always return 0 in those cases. | |
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
333 static int bytes_to_length(size_t bytes) { |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
334 assert(is_size_aligned(bytes, BytesPerWord), "Must be, for now"); |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
335 |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
336 if (sizeof(Array<T>) >= bytes) { |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
337 return 0; |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
338 } |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
339 |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
340 size_t left = bytes - sizeof(Array<T>); |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
341 assert(is_size_aligned(left, sizeof(T)), "Must be"); |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
342 |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
343 size_t elements = left / sizeof(T); |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
344 assert(elements <= (size_t)INT_MAX, err_msg("number of elements " SIZE_FORMAT "doesn't fit into an int.", elements)); |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
345 |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
346 int length = (int)elements; |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
347 |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
348 assert((size_t)size(length) * BytesPerWord == bytes, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
349 err_msg("Expected: " SIZE_FORMAT " got: " SIZE_FORMAT, |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
350 bytes, (size_t)size(length) * BytesPerWord)); |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
351 |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
352 return length; |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
353 } |
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20197
diff
changeset
|
354 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
355 explicit Array(int length) : _length(length) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
356 assert(length >= 0, "illegal length"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
357 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
358 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
359 Array(int length, T init) : _length(length) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
360 assert(length >= 0, "illegal length"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
361 for (int i = 0; i < length; i++) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
362 _data[i] = init; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
363 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
364 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
365 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
366 public: |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
367 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
368 // standard operations |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
369 int length() const { return _length; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
370 T* data() { return _data; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
371 bool is_empty() const { return length() == 0; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
372 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
373 int index_of(const T& x) const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
374 int i = length(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
375 while (i-- > 0 && _data[i] != x) ; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
376 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
377 return i; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
378 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
379 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
380 // sort the array. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
381 bool contains(const T& x) const { return index_of(x) >= 0; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
382 |
12319
de059a14e159
8022187: Missing ResourceMark crash when assertion using FormatBufferResource fails
zgu
parents:
12146
diff
changeset
|
383 T at(int i) const { assert(i >= 0 && i< _length, err_msg("oob: 0 <= %d < %d", i, _length)); return _data[i]; } |
de059a14e159
8022187: Missing ResourceMark crash when assertion using FormatBufferResource fails
zgu
parents:
12146
diff
changeset
|
384 void at_put(const int i, const T& x) { assert(i >= 0 && i< _length, err_msg("oob: 0 <= %d < %d", i, _length)); _data[i] = x; } |
de059a14e159
8022187: Missing ResourceMark crash when assertion using FormatBufferResource fails
zgu
parents:
12146
diff
changeset
|
385 T* adr_at(const int i) { assert(i >= 0 && i< _length, err_msg("oob: 0 <= %d < %d", i, _length)); return &_data[i]; } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
386 int find(const T& x) { return index_of(x); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
387 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
388 T at_acquire(const int which) { return OrderAccess::load_acquire(adr_at(which)); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
389 void release_at_put(int which, T contents) { OrderAccess::release_store(adr_at(which), contents); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
390 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
391 static int size(int length) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
392 return align_size_up(byte_sizeof(length), BytesPerWord) / BytesPerWord; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
393 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
394 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
395 int size() { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
396 return size(_length); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
397 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
398 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
399 static int length_offset_in_bytes() { return (int) (offset_of(Array<T>, _length)); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
400 // Note, this offset don't have to be wordSize aligned. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
401 static int base_offset_in_bytes() { return (int) (offset_of(Array<T>, _data)); }; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
402 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
403 // FIXME: How to handle this? |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
404 void print_value_on(outputStream* st) const { |
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
14333
diff
changeset
|
405 st->print("Array<T>(" INTPTR_FORMAT ")", p2i(this)); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
406 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
407 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
408 #ifndef PRODUCT |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
409 void print(outputStream* st) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
410 for (int i = 0; i< _length; i++) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
411 st->print_cr("%d: " INTPTR_FORMAT, i, (intptr_t)at(i)); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
412 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
413 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
414 void print() { print(tty); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
415 #endif // PRODUCT |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
416 }; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
417 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
418 |
1972 | 419 #endif // SHARE_VM_UTILITIES_ARRAY_HPP |