Mercurial > jdk8-mips64-public > hotspot / file revision
src/share/vm/utilities/array.hpp@78bbf4d43a14
src/share/vm/utilities/array.hpp
Thu, 22 May 2014 15:52:41 -0400
- author
- drchase
- date
- Thu, 22 May 2014 15:52:41 -0400
- changeset 6680
- 78bbf4d43a14
- parent 6307
- 10c9507f544a
- child 6876
- 710a3c8b516e
- child 6911
- ce8f6bb717c9
- permissions
- -rw-r--r--
8037816: Fix for 8036122 breaks build with Xcode5/clang
8043029: Change 8037816 breaks HS build with older GCC versions which don't support diagnostic pragmas
8043164: Format warning in traceStream.hpp
Summary: Backport of main fix + two corrections, enables clang compilation, turns on format attributes, corrects/mutes warnings
Reviewed-by: kvn, coleenp, iveresov, twisti
1 /*
2 * Copyright (c) 2000, 2014, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #ifndef SHARE_VM_UTILITIES_ARRAY_HPP
26 #define SHARE_VM_UTILITIES_ARRAY_HPP
28 #include "memory/allocation.hpp"
29 #include "memory/allocation.inline.hpp"
30 #include "memory/metaspace.hpp"
32 // correct linkage required to compile w/o warnings
33 // (must be on file level - cannot be local)
34 extern "C" { typedef int (*ftype)(const void*, const void*); }
37 class ResourceArray: public ResourceObj {
38 protected:
39 int _length; // the number of array elements
40 void* _data; // the array memory
41 #ifdef ASSERT
42 int _nesting; // the resource area nesting level
43 #endif
45 // creation
46 ResourceArray() {
47 _length = 0;
48 _data = NULL;
49 DEBUG_ONLY(init_nesting();)
50 // client may call initialize, at most once
51 }
54 ResourceArray(size_t esize, int length) {
55 DEBUG_ONLY(_data = NULL);
56 initialize(esize, length);
57 }
59 void initialize(size_t esize, int length) {
60 assert(length >= 0, "illegal length");
61 assert(StressRewriter || _data == NULL, "must be new object");
62 _length = length;
63 _data = resource_allocate_bytes(esize * length);
64 DEBUG_ONLY(init_nesting();)
65 }
67 #ifdef ASSERT
68 void init_nesting();
69 #endif
71 // helper functions
72 void sort (size_t esize, ftype f); // sort the array
73 void expand (size_t esize, int i, int& size);// expand the array to include slot i
74 void remove_at(size_t esize, int i); // remove the element in slot i
76 public:
77 // standard operations
78 int length() const { return _length; }
79 bool is_empty() const { return length() == 0; }
80 };
83 template <MEMFLAGS F>class CHeapArray: public CHeapObj<F> {
84 protected:
85 int _length; // the number of array elements
86 void* _data; // the array memory
88 // creation
89 CHeapArray() {
90 _length = 0;
91 _data = NULL;
92 }
95 CHeapArray(size_t esize, int length) {
96 assert(length >= 0, "illegal length");
97 _length = length;
98 _data = (void*) NEW_C_HEAP_ARRAY(char *, esize * length, F);
99 }
101 void initialize(size_t esize, int length) {
102 // In debug set array to 0?
103 }
105 #ifdef ASSERT
106 void init_nesting();
107 #endif
109 // helper functions
110 void sort (size_t esize, ftype f); // sort the array
111 void expand (size_t esize, int i, int& size);// expand the array to include slot i
112 void remove_at(size_t esize, int i); // remove the element in slot i
114 public:
115 // standard operations
116 int length() const { return _length; }
117 bool is_empty() const { return length() == 0; }
118 };
120 #define define_generic_array(array_name,element_type, base_class) \
121 class array_name: public base_class { \
122 protected: \
123 typedef element_type etype; \
124 enum { esize = sizeof(etype) }; \
125 \
126 void base_remove_at(size_t size, int i) { base_class::remove_at(size, i); } \
127 \
128 public: \
129 /* creation */ \
130 array_name() : base_class() {} \
131 explicit array_name(const int length) : base_class(esize, length) {} \
132 array_name(const int length, const etype fx) { initialize(length, fx); } \
133 void initialize(const int length) { base_class::initialize(esize, length); } \
134 void initialize(const int length, const etype fx) { \
135 initialize(length); \
136 for (int i = 0; i < length; i++) ((etype*)_data)[i] = fx; \
137 } \
138 \
139 /* standard operations */ \
140 etype& operator [] (const int i) const { \
141 assert(0 <= i && i < length(), "index out of bounds"); \
142 return ((etype*)_data)[i]; \
143 } \
144 \
145 int index_of(const etype x) const { \
146 int i = length(); \
147 while (i-- > 0 && ((etype*)_data)[i] != x) ; \
148 /* i < 0 || ((etype*)_data)_data[i] == x */ \
149 return i; \
150 } \
151 \
152 void sort(int f(etype*, etype*)) { base_class::sort(esize, (ftype)f); } \
153 bool contains(const etype x) const { return index_of(x) >= 0; } \
154 \
155 /* deprecated operations - for compatibility with GrowableArray only */ \
156 etype at(const int i) const { return (*this)[i]; } \
157 void at_put(const int i, const etype x) { (*this)[i] = x; } \
158 etype* adr_at(const int i) { return &(*this)[i]; } \
159 int find(const etype x) { return index_of(x); } \
160 }; \
163 #define define_array(array_name,element_type) \
164 define_generic_array(array_name, element_type, ResourceArray)
167 #define define_stack(stack_name,array_name) \
168 class stack_name: public array_name { \
169 protected: \
170 int _size; \
171 \
172 void grow(const int i, const etype fx) { \
173 assert(i >= length(), "index too small"); \
174 if (i >= size()) expand(esize, i, _size); \
175 for (int j = length(); j <= i; j++) ((etype*)_data)[j] = fx; \
176 _length = i+1; \
177 } \
178 \
179 public: \
180 /* creation */ \
181 stack_name() : array_name() { _size = 0; } \
182 stack_name(const int size) { initialize(size); } \
183 stack_name(const int size, const etype fx) { initialize(size, fx); } \
184 void initialize(const int size, const etype fx) { \
185 _size = size; \
186 array_name::initialize(size, fx); \
187 /* _length == size, allocation and size are the same */ \
188 } \
189 void initialize(const int size) { \
190 _size = size; \
191 array_name::initialize(size); \
192 _length = 0; /* reset length to zero; _size records the allocation */ \
193 } \
194 \
195 /* standard operations */ \
196 int size() const { return _size; } \
197 \
198 int push(const etype x) { \
199 int len = length(); \
200 if (len >= size()) expand(esize, len, _size); \
201 ((etype*)_data)[len] = x; \
202 _length = len+1; \
203 return len; \
204 } \
205 \
206 etype pop() { \
207 assert(!is_empty(), "stack is empty"); \
208 return ((etype*)_data)[--_length]; \
209 } \
210 \
211 etype top() const { \
212 assert(!is_empty(), "stack is empty"); \
213 return ((etype*)_data)[length() - 1]; \
214 } \
215 \
216 void push_all(const stack_name* stack) { \
217 const int l = stack->length(); \
218 for (int i = 0; i < l; i++) push(((etype*)(stack->_data))[i]); \
219 } \
220 \
221 etype at_grow(const int i, const etype fx) { \
222 if (i >= length()) grow(i, fx); \
223 return ((etype*)_data)[i]; \
224 } \
225 \
226 void at_put_grow(const int i, const etype x, const etype fx) { \
227 if (i >= length()) grow(i, fx); \
228 ((etype*)_data)[i] = x; \
229 } \
230 \
231 void truncate(const int length) { \
232 assert(0 <= length && length <= this->length(), "illegal length"); \
233 _length = length; \
234 } \
235 \
236 void remove_at(int i) { base_remove_at(esize, i); } \
237 void remove(etype x) { remove_at(index_of(x)); } \
238 \
239 /* inserts the given element before the element at index i */ \
240 void insert_before(const int i, const etype el) { \
241 int len = length(); \
242 int new_length = len + 1; \
243 if (new_length >= size()) expand(esize, new_length, _size); \
244 for (int j = len - 1; j >= i; j--) { \
245 ((etype*)_data)[j + 1] = ((etype*)_data)[j]; \
246 } \
247 _length = new_length; \
248 at_put(i, el); \
249 } \
250 \
251 /* inserts contents of the given stack before the element at index i */ \
252 void insert_before(const int i, const stack_name *st) { \
253 if (st->length() == 0) return; \
254 int len = length(); \
255 int st_len = st->length(); \
256 int new_length = len + st_len; \
257 if (new_length >= size()) expand(esize, new_length, _size); \
258 int j; \
259 for (j = len - 1; j >= i; j--) { \
260 ((etype*)_data)[j + st_len] = ((etype*)_data)[j]; \
261 } \
262 for (j = 0; j < st_len; j++) { \
263 ((etype*)_data)[i + j] = ((etype*)st->_data)[j]; \
264 } \
265 _length = new_length; \
266 } \
267 \
268 /* deprecated operations - for compatibility with GrowableArray only */ \
269 int capacity() const { return size(); } \
270 void clear() { truncate(0); } \
271 void trunc_to(const int length) { truncate(length); } \
272 int append(const etype x) { return push(x); } \
273 void appendAll(const stack_name* stack) { push_all(stack); } \
274 etype last() const { return top(); } \
275 }; \
278 #define define_resource_list(element_type) \
279 define_generic_array(element_type##Array, element_type, ResourceArray) \
280 define_stack(element_type##List, element_type##Array)
282 #define define_resource_pointer_list(element_type) \
283 define_generic_array(element_type##Array, element_type *, ResourceArray) \
284 define_stack(element_type##List, element_type##Array)
286 #define define_c_heap_list(element_type) \
287 define_generic_array(element_type##Array, element_type, CHeapArray) \
288 define_stack(element_type##List, element_type##Array)
290 #define define_c_heap_pointer_list(element_type) \
291 define_generic_array(element_type##Array, element_type *, CHeapArray) \
292 define_stack(element_type##List, element_type##Array)
295 // Arrays for basic types
297 define_array(boolArray, bool) define_stack(boolStack, boolArray)
298 define_array(intArray , int ) define_stack(intStack , intArray )
300 // Array for metadata allocation
302 template <typename T>
303 class Array: public MetaspaceObj {
304 friend class MetadataFactory;
305 friend class VMStructs;
306 friend class MethodHandleCompiler; // special case
307 protected:
308 int _length; // the number of array elements
309 T _data[1]; // the array memory
311 void initialize(int length) {
312 _length = length;
313 }
315 private:
316 // Turn off copy constructor and assignment operator.
317 Array(const Array<T>&);
318 void operator=(const Array<T>&);
320 void* operator new(size_t size, ClassLoaderData* loader_data, int length, bool read_only, TRAPS) throw() {
321 size_t word_size = Array::size(length);
322 return (void*) Metaspace::allocate(loader_data, word_size, read_only,
323 MetaspaceObj::array_type(sizeof(T)), CHECK_NULL);
324 }
326 static size_t byte_sizeof(int length) { return sizeof(Array<T>) + MAX2(length - 1, 0) * sizeof(T); }
328 explicit Array(int length) : _length(length) {
329 assert(length >= 0, "illegal length");
330 }
332 Array(int length, T init) : _length(length) {
333 assert(length >= 0, "illegal length");
334 for (int i = 0; i < length; i++) {
335 _data[i] = init;
336 }
337 }
339 public:
341 // standard operations
342 int length() const { return _length; }
343 T* data() { return _data; }
344 bool is_empty() const { return length() == 0; }
346 int index_of(const T& x) const {
347 int i = length();
348 while (i-- > 0 && _data[i] != x) ;
350 return i;
351 }
353 // sort the array.
354 bool contains(const T& x) const { return index_of(x) >= 0; }
356 T at(int i) const { assert(i >= 0 && i< _length, err_msg("oob: 0 <= %d < %d", i, _length)); return _data[i]; }
357 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; }
358 T* adr_at(const int i) { assert(i >= 0 && i< _length, err_msg("oob: 0 <= %d < %d", i, _length)); return &_data[i]; }
359 int find(const T& x) { return index_of(x); }
361 T at_acquire(const int which) { return OrderAccess::load_acquire(adr_at(which)); }
362 void release_at_put(int which, T contents) { OrderAccess::release_store(adr_at(which), contents); }
364 static int size(int length) {
365 return align_size_up(byte_sizeof(length), BytesPerWord) / BytesPerWord;
366 }
368 int size() {
369 return size(_length);
370 }
372 static int length_offset_in_bytes() { return (int) (offset_of(Array<T>, _length)); }
373 // Note, this offset don't have to be wordSize aligned.
374 static int base_offset_in_bytes() { return (int) (offset_of(Array<T>, _data)); };
376 // FIXME: How to handle this?
377 void print_value_on(outputStream* st) const {
378 st->print("Array<T>(" INTPTR_FORMAT ")", p2i(this));
379 }
381 #ifndef PRODUCT
382 void print(outputStream* st) {
383 for (int i = 0; i< _length; i++) {
384 st->print_cr("%d: " INTPTR_FORMAT, i, (intptr_t)at(i));
385 }
386 }
387 void print() { print(tty); }
388 #endif // PRODUCT
389 };
392 #endif // SHARE_VM_UTILITIES_ARRAY_HPP
