| File: | jdk/src/hotspot/share/oops/objArrayKlass.cpp |
| Warning: | line 83, column 11 Value stored to 'super_klass' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | /* |
| 2 | * Copyright (c) 1997, 2021, 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 | */ |
| 24 | |
| 25 | #include "precompiled.hpp" |
| 26 | #include "classfile/moduleEntry.hpp" |
| 27 | #include "classfile/packageEntry.hpp" |
| 28 | #include "classfile/symbolTable.hpp" |
| 29 | #include "classfile/vmClasses.hpp" |
| 30 | #include "classfile/vmSymbols.hpp" |
| 31 | #include "gc/shared/collectedHeap.inline.hpp" |
| 32 | #include "memory/iterator.inline.hpp" |
| 33 | #include "memory/metadataFactory.hpp" |
| 34 | #include "memory/metaspaceClosure.hpp" |
| 35 | #include "memory/resourceArea.hpp" |
| 36 | #include "memory/universe.hpp" |
| 37 | #include "oops/arrayKlass.inline.hpp" |
| 38 | #include "oops/instanceKlass.hpp" |
| 39 | #include "oops/klass.inline.hpp" |
| 40 | #include "oops/objArrayKlass.inline.hpp" |
| 41 | #include "oops/objArrayOop.inline.hpp" |
| 42 | #include "oops/oop.inline.hpp" |
| 43 | #include "oops/symbol.hpp" |
| 44 | #include "runtime/handles.inline.hpp" |
| 45 | #include "runtime/mutexLocker.hpp" |
| 46 | #include "utilities/macros.hpp" |
| 47 | |
| 48 | ObjArrayKlass* ObjArrayKlass::allocate(ClassLoaderData* loader_data, int n, Klass* k, Symbol* name, TRAPSJavaThread* __the_thread__) { |
| 49 | assert(ObjArrayKlass::header_size() <= InstanceKlass::header_size(),do { if (!(ObjArrayKlass::header_size() <= InstanceKlass:: header_size())) { (*g_assert_poison) = 'X';; report_vm_error( "/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 50, "assert(" "ObjArrayKlass::header_size() <= InstanceKlass::header_size()" ") failed", "array klasses must be same size as InstanceKlass" ); ::breakpoint(); } } while (0) |
| 50 | "array klasses must be same size as InstanceKlass")do { if (!(ObjArrayKlass::header_size() <= InstanceKlass:: header_size())) { (*g_assert_poison) = 'X';; report_vm_error( "/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 50, "assert(" "ObjArrayKlass::header_size() <= InstanceKlass::header_size()" ") failed", "array klasses must be same size as InstanceKlass" ); ::breakpoint(); } } while (0); |
| 51 | |
| 52 | int size = ArrayKlass::static_size(ObjArrayKlass::header_size()); |
| 53 | |
| 54 | return new (loader_data, size, THREAD__the_thread__) ObjArrayKlass(n, k, name); |
| 55 | } |
| 56 | |
| 57 | ObjArrayKlass* ObjArrayKlass::allocate_objArray_klass(ClassLoaderData* loader_data, |
| 58 | int n, Klass* element_klass, TRAPSJavaThread* __the_thread__) { |
| 59 | |
| 60 | // Eagerly allocate the direct array supertype. |
| 61 | Klass* super_klass = NULL__null; |
| 62 | if (!Universe::is_bootstrapping() || vmClasses::Object_klass_loaded()) { |
| 63 | Klass* element_super = element_klass->super(); |
| 64 | if (element_super != NULL__null) { |
| 65 | // The element type has a direct super. E.g., String[] has direct super of Object[]. |
| 66 | super_klass = element_super->array_klass_or_null(); |
| 67 | bool supers_exist = super_klass != NULL__null; |
| 68 | // Also, see if the element has secondary supertypes. |
| 69 | // We need an array type for each. |
| 70 | const Array<Klass*>* element_supers = element_klass->secondary_supers(); |
| 71 | for( int i = element_supers->length()-1; i >= 0; i-- ) { |
| 72 | Klass* elem_super = element_supers->at(i); |
| 73 | if (elem_super->array_klass_or_null() == NULL__null) { |
| 74 | supers_exist = false; |
| 75 | break; |
| 76 | } |
| 77 | } |
| 78 | if (!supers_exist) { |
| 79 | // Oops. Not allocated yet. Back out, allocate it, and retry. |
| 80 | Klass* ek = NULL__null; |
| 81 | { |
| 82 | MutexUnlocker mu(MultiArray_lock); |
| 83 | super_klass = element_super->array_klass(CHECK_NULL__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception ())) return __null; (void)(0); |
Value stored to 'super_klass' is never read | |
| 84 | for( int i = element_supers->length()-1; i >= 0; i-- ) { |
| 85 | Klass* elem_super = element_supers->at(i); |
| 86 | elem_super->array_klass(CHECK_NULL__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception ())) return __null; (void)(0); |
| 87 | } |
| 88 | // Now retry from the beginning |
| 89 | ek = element_klass->array_klass(n, CHECK_NULL__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception ())) return __null; (void)(0); |
| 90 | } // re-lock |
| 91 | return ObjArrayKlass::cast(ek); |
| 92 | } |
| 93 | } else { |
| 94 | // The element type is already Object. Object[] has direct super of Object. |
| 95 | super_klass = vmClasses::Object_klass(); |
| 96 | } |
| 97 | } |
| 98 | |
| 99 | // Create type name for klass. |
| 100 | Symbol* name = NULL__null; |
| 101 | { |
| 102 | ResourceMark rm(THREAD__the_thread__); |
| 103 | char *name_str = element_klass->name()->as_C_string(); |
| 104 | int len = element_klass->name()->utf8_length(); |
| 105 | char *new_str = NEW_RESOURCE_ARRAY(char, len + 4)(char*) resource_allocate_bytes((len + 4) * sizeof(char)); |
| 106 | int idx = 0; |
| 107 | new_str[idx++] = JVM_SIGNATURE_ARRAY; |
| 108 | if (element_klass->is_instance_klass()) { // it could be an array or simple type |
| 109 | new_str[idx++] = JVM_SIGNATURE_CLASS; |
| 110 | } |
| 111 | memcpy(&new_str[idx], name_str, len * sizeof(char)); |
| 112 | idx += len; |
| 113 | if (element_klass->is_instance_klass()) { |
| 114 | new_str[idx++] = JVM_SIGNATURE_ENDCLASS; |
| 115 | } |
| 116 | new_str[idx++] = '\0'; |
| 117 | name = SymbolTable::new_symbol(new_str); |
| 118 | } |
| 119 | |
| 120 | // Initialize instance variables |
| 121 | ObjArrayKlass* oak = ObjArrayKlass::allocate(loader_data, n, element_klass, name, CHECK_NULL__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception ())) return __null; (void)(0); |
| 122 | |
| 123 | ModuleEntry* module = oak->module(); |
| 124 | assert(module != NULL, "No module entry for array")do { if (!(module != __null)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 124, "assert(" "module != __null" ") failed", "No module entry for array" ); ::breakpoint(); } } while (0); |
| 125 | |
| 126 | // Call complete_create_array_klass after all instance variables has been initialized. |
| 127 | ArrayKlass::complete_create_array_klass(oak, super_klass, module, CHECK_NULL__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception ())) return __null; (void)(0); |
| 128 | |
| 129 | // Add all classes to our internal class loader list here, |
| 130 | // including classes in the bootstrap (NULL) class loader. |
| 131 | // Do this step after creating the mirror so that if the |
| 132 | // mirror creation fails, loaded_classes_do() doesn't find |
| 133 | // an array class without a mirror. |
| 134 | loader_data->add_class(oak); |
| 135 | |
| 136 | return oak; |
| 137 | } |
| 138 | |
| 139 | ObjArrayKlass::ObjArrayKlass(int n, Klass* element_klass, Symbol* name) : ArrayKlass(name, ID) { |
| 140 | set_dimension(n); |
| 141 | set_element_klass(element_klass); |
| 142 | |
| 143 | Klass* bk; |
| 144 | if (element_klass->is_objArray_klass()) { |
| 145 | bk = ObjArrayKlass::cast(element_klass)->bottom_klass(); |
| 146 | } else { |
| 147 | bk = element_klass; |
| 148 | } |
| 149 | assert(bk != NULL && (bk->is_instance_klass() || bk->is_typeArray_klass()), "invalid bottom klass")do { if (!(bk != __null && (bk->is_instance_klass( ) || bk->is_typeArray_klass()))) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 149, "assert(" "bk != __null && (bk->is_instance_klass() || bk->is_typeArray_klass())" ") failed", "invalid bottom klass"); ::breakpoint(); } } while (0); |
| 150 | set_bottom_klass(bk); |
| 151 | set_class_loader_data(bk->class_loader_data()); |
| 152 | |
| 153 | set_layout_helper(array_layout_helper(T_OBJECT)); |
| 154 | assert(is_array_klass(), "sanity")do { if (!(is_array_klass())) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 154, "assert(" "is_array_klass()" ") failed", "sanity"); :: breakpoint(); } } while (0); |
| 155 | assert(is_objArray_klass(), "sanity")do { if (!(is_objArray_klass())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 155, "assert(" "is_objArray_klass()" ") failed", "sanity"); ::breakpoint(); } } while (0); |
| 156 | } |
| 157 | |
| 158 | size_t ObjArrayKlass::oop_size(oop obj) const { |
| 159 | assert(obj->is_objArray(), "must be object array")do { if (!(obj->is_objArray())) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 159, "assert(" "obj->is_objArray()" ") failed", "must be object array" ); ::breakpoint(); } } while (0); |
| 160 | return objArrayOop(obj)->object_size(); |
| 161 | } |
| 162 | |
| 163 | objArrayOop ObjArrayKlass::allocate(int length, TRAPSJavaThread* __the_thread__) { |
| 164 | check_array_allocation_length(length, arrayOopDesc::max_array_length(T_OBJECT), CHECK_NULL__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception ())) return __null; (void)(0); |
| 165 | size_t size = objArrayOopDesc::object_size(length); |
| 166 | return (objArrayOop)Universe::heap()->array_allocate(this, size, length, |
| 167 | /* do_zero */ true, THREAD__the_thread__); |
| 168 | } |
| 169 | |
| 170 | oop ObjArrayKlass::multi_allocate(int rank, jint* sizes, TRAPSJavaThread* __the_thread__) { |
| 171 | int length = *sizes; |
| 172 | // Call to lower_dimension uses this pointer, so most be called before a |
| 173 | // possible GC |
| 174 | Klass* ld_klass = lower_dimension(); |
| 175 | // If length < 0 allocate will throw an exception. |
| 176 | objArrayOop array = allocate(length, CHECK_NULL__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception ())) return __null; (void)(0); |
| 177 | objArrayHandle h_array (THREAD__the_thread__, array); |
| 178 | if (rank > 1) { |
| 179 | if (length != 0) { |
| 180 | for (int index = 0; index < length; index++) { |
| 181 | ArrayKlass* ak = ArrayKlass::cast(ld_klass); |
| 182 | oop sub_array = ak->multi_allocate(rank-1, &sizes[1], CHECK_NULL__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception ())) return __null; (void)(0); |
| 183 | h_array->obj_at_put(index, sub_array); |
| 184 | } |
| 185 | } else { |
| 186 | // Since this array dimension has zero length, nothing will be |
| 187 | // allocated, however the lower dimension values must be checked |
| 188 | // for illegal values. |
| 189 | for (int i = 0; i < rank - 1; ++i) { |
| 190 | sizes += 1; |
| 191 | if (*sizes < 0) { |
| 192 | THROW_MSG_0(vmSymbols::java_lang_NegativeArraySizeException(), err_msg("%d", *sizes)){ Exceptions::_throw_msg(__the_thread__, "/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 192, vmSymbols::java_lang_NegativeArraySizeException(), err_msg ("%d", *sizes)); return 0; }; |
| 193 | } |
| 194 | } |
| 195 | } |
| 196 | } |
| 197 | return h_array(); |
| 198 | } |
| 199 | |
| 200 | // Either oop or narrowOop depending on UseCompressedOops. |
| 201 | void ObjArrayKlass::do_copy(arrayOop s, size_t src_offset, |
| 202 | arrayOop d, size_t dst_offset, int length, TRAPSJavaThread* __the_thread__) { |
| 203 | if (s == d) { |
| 204 | // since source and destination are equal we do not need conversion checks. |
| 205 | assert(length > 0, "sanity check")do { if (!(length > 0)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 205, "assert(" "length > 0" ") failed", "sanity check"); ::breakpoint(); } } while (0); |
| 206 | ArrayAccess<>::oop_arraycopy(s, src_offset, d, dst_offset, length); |
| 207 | } else { |
| 208 | // We have to make sure all elements conform to the destination array |
| 209 | Klass* bound = ObjArrayKlass::cast(d->klass())->element_klass(); |
| 210 | Klass* stype = ObjArrayKlass::cast(s->klass())->element_klass(); |
| 211 | if (stype == bound || stype->is_subtype_of(bound)) { |
| 212 | // elements are guaranteed to be subtypes, so no check necessary |
| 213 | ArrayAccess<ARRAYCOPY_DISJOINT>::oop_arraycopy(s, src_offset, d, dst_offset, length); |
| 214 | } else { |
| 215 | // slow case: need individual subtype checks |
| 216 | // note: don't use obj_at_put below because it includes a redundant store check |
| 217 | if (!ArrayAccess<ARRAYCOPY_DISJOINT | ARRAYCOPY_CHECKCAST>::oop_arraycopy(s, src_offset, d, dst_offset, length)) { |
| 218 | ResourceMark rm(THREAD__the_thread__); |
| 219 | stringStream ss; |
| 220 | if (!bound->is_subtype_of(stype)) { |
| 221 | ss.print("arraycopy: type mismatch: can not copy %s[] into %s[]", |
| 222 | stype->external_name(), bound->external_name()); |
| 223 | } else { |
| 224 | // oop_arraycopy should return the index in the source array that |
| 225 | // contains the problematic oop. |
| 226 | ss.print("arraycopy: element type mismatch: can not cast one of the elements" |
| 227 | " of %s[] to the type of the destination array, %s", |
| 228 | stype->external_name(), bound->external_name()); |
| 229 | } |
| 230 | THROW_MSG(vmSymbols::java_lang_ArrayStoreException(), ss.as_string()){ Exceptions::_throw_msg(__the_thread__, "/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 230, vmSymbols::java_lang_ArrayStoreException(), ss.as_string ()); return; }; |
| 231 | } |
| 232 | } |
| 233 | } |
| 234 | } |
| 235 | |
| 236 | void ObjArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, |
| 237 | int dst_pos, int length, TRAPSJavaThread* __the_thread__) { |
| 238 | assert(s->is_objArray(), "must be obj array")do { if (!(s->is_objArray())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 238, "assert(" "s->is_objArray()" ") failed", "must be obj array" ); ::breakpoint(); } } while (0); |
| 239 | |
| 240 | if (!d->is_objArray()) { |
| 241 | ResourceMark rm(THREAD__the_thread__); |
| 242 | stringStream ss; |
| 243 | if (d->is_typeArray()) { |
| 244 | ss.print("arraycopy: type mismatch: can not copy object array[] into %s[]", |
| 245 | type2name_tab[ArrayKlass::cast(d->klass())->element_type()]); |
| 246 | } else { |
| 247 | ss.print("arraycopy: destination type %s is not an array", d->klass()->external_name()); |
| 248 | } |
| 249 | THROW_MSG(vmSymbols::java_lang_ArrayStoreException(), ss.as_string()){ Exceptions::_throw_msg(__the_thread__, "/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 249, vmSymbols::java_lang_ArrayStoreException(), ss.as_string ()); return; }; |
| 250 | } |
| 251 | |
| 252 | // Check is all offsets and lengths are non negative |
| 253 | if (src_pos < 0 || dst_pos < 0 || length < 0) { |
| 254 | // Pass specific exception reason. |
| 255 | ResourceMark rm(THREAD__the_thread__); |
| 256 | stringStream ss; |
| 257 | if (src_pos < 0) { |
| 258 | ss.print("arraycopy: source index %d out of bounds for object array[%d]", |
| 259 | src_pos, s->length()); |
| 260 | } else if (dst_pos < 0) { |
| 261 | ss.print("arraycopy: destination index %d out of bounds for object array[%d]", |
| 262 | dst_pos, d->length()); |
| 263 | } else { |
| 264 | ss.print("arraycopy: length %d is negative", length); |
| 265 | } |
| 266 | THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), ss.as_string()){ Exceptions::_throw_msg(__the_thread__, "/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 266, vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), ss.as_string()); return; }; |
| 267 | } |
| 268 | // Check if the ranges are valid |
| 269 | if ((((unsigned int) length + (unsigned int) src_pos) > (unsigned int) s->length()) || |
| 270 | (((unsigned int) length + (unsigned int) dst_pos) > (unsigned int) d->length())) { |
| 271 | // Pass specific exception reason. |
| 272 | ResourceMark rm(THREAD__the_thread__); |
| 273 | stringStream ss; |
| 274 | if (((unsigned int) length + (unsigned int) src_pos) > (unsigned int) s->length()) { |
| 275 | ss.print("arraycopy: last source index %u out of bounds for object array[%d]", |
| 276 | (unsigned int) length + (unsigned int) src_pos, s->length()); |
| 277 | } else { |
| 278 | ss.print("arraycopy: last destination index %u out of bounds for object array[%d]", |
| 279 | (unsigned int) length + (unsigned int) dst_pos, d->length()); |
| 280 | } |
| 281 | THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), ss.as_string()){ Exceptions::_throw_msg(__the_thread__, "/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 281, vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), ss.as_string()); return; }; |
| 282 | } |
| 283 | |
| 284 | // Special case. Boundary cases must be checked first |
| 285 | // This allows the following call: copy_array(s, s.length(), d.length(), 0). |
| 286 | // This is correct, since the position is supposed to be an 'in between point', i.e., s.length(), |
| 287 | // points to the right of the last element. |
| 288 | if (length==0) { |
| 289 | return; |
| 290 | } |
| 291 | if (UseCompressedOops) { |
| 292 | size_t src_offset = (size_t) objArrayOopDesc::obj_at_offset<narrowOop>(src_pos); |
| 293 | size_t dst_offset = (size_t) objArrayOopDesc::obj_at_offset<narrowOop>(dst_pos); |
| 294 | assert(arrayOopDesc::obj_offset_to_raw<narrowOop>(s, src_offset, NULL) ==do { if (!(arrayOopDesc::obj_offset_to_raw<narrowOop>(s , src_offset, __null) == objArrayOop(s)->obj_at_addr<narrowOop >(src_pos))) { (*g_assert_poison) = 'X';; report_vm_error( "/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 295, "assert(" "arrayOopDesc::obj_offset_to_raw<narrowOop>(s, src_offset, __null) == objArrayOop(s)->obj_at_addr<narrowOop>(src_pos)" ") failed", "sanity"); ::breakpoint(); } } while (0) |
| 295 | objArrayOop(s)->obj_at_addr<narrowOop>(src_pos), "sanity")do { if (!(arrayOopDesc::obj_offset_to_raw<narrowOop>(s , src_offset, __null) == objArrayOop(s)->obj_at_addr<narrowOop >(src_pos))) { (*g_assert_poison) = 'X';; report_vm_error( "/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 295, "assert(" "arrayOopDesc::obj_offset_to_raw<narrowOop>(s, src_offset, __null) == objArrayOop(s)->obj_at_addr<narrowOop>(src_pos)" ") failed", "sanity"); ::breakpoint(); } } while (0); |
| 296 | assert(arrayOopDesc::obj_offset_to_raw<narrowOop>(d, dst_offset, NULL) ==do { if (!(arrayOopDesc::obj_offset_to_raw<narrowOop>(d , dst_offset, __null) == objArrayOop(d)->obj_at_addr<narrowOop >(dst_pos))) { (*g_assert_poison) = 'X';; report_vm_error( "/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 297, "assert(" "arrayOopDesc::obj_offset_to_raw<narrowOop>(d, dst_offset, __null) == objArrayOop(d)->obj_at_addr<narrowOop>(dst_pos)" ") failed", "sanity"); ::breakpoint(); } } while (0) |
| 297 | objArrayOop(d)->obj_at_addr<narrowOop>(dst_pos), "sanity")do { if (!(arrayOopDesc::obj_offset_to_raw<narrowOop>(d , dst_offset, __null) == objArrayOop(d)->obj_at_addr<narrowOop >(dst_pos))) { (*g_assert_poison) = 'X';; report_vm_error( "/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 297, "assert(" "arrayOopDesc::obj_offset_to_raw<narrowOop>(d, dst_offset, __null) == objArrayOop(d)->obj_at_addr<narrowOop>(dst_pos)" ") failed", "sanity"); ::breakpoint(); } } while (0); |
| 298 | do_copy(s, src_offset, d, dst_offset, length, CHECK__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception ())) return ; (void)(0); |
| 299 | } else { |
| 300 | size_t src_offset = (size_t) objArrayOopDesc::obj_at_offset<oop>(src_pos); |
| 301 | size_t dst_offset = (size_t) objArrayOopDesc::obj_at_offset<oop>(dst_pos); |
| 302 | assert(arrayOopDesc::obj_offset_to_raw<oop>(s, src_offset, NULL) ==do { if (!(arrayOopDesc::obj_offset_to_raw<oop>(s, src_offset , __null) == objArrayOop(s)->obj_at_addr<oop>(src_pos ))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 303, "assert(" "arrayOopDesc::obj_offset_to_raw<oop>(s, src_offset, __null) == objArrayOop(s)->obj_at_addr<oop>(src_pos)" ") failed", "sanity"); ::breakpoint(); } } while (0) |
| 303 | objArrayOop(s)->obj_at_addr<oop>(src_pos), "sanity")do { if (!(arrayOopDesc::obj_offset_to_raw<oop>(s, src_offset , __null) == objArrayOop(s)->obj_at_addr<oop>(src_pos ))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 303, "assert(" "arrayOopDesc::obj_offset_to_raw<oop>(s, src_offset, __null) == objArrayOop(s)->obj_at_addr<oop>(src_pos)" ") failed", "sanity"); ::breakpoint(); } } while (0); |
| 304 | assert(arrayOopDesc::obj_offset_to_raw<oop>(d, dst_offset, NULL) ==do { if (!(arrayOopDesc::obj_offset_to_raw<oop>(d, dst_offset , __null) == objArrayOop(d)->obj_at_addr<oop>(dst_pos ))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 305, "assert(" "arrayOopDesc::obj_offset_to_raw<oop>(d, dst_offset, __null) == objArrayOop(d)->obj_at_addr<oop>(dst_pos)" ") failed", "sanity"); ::breakpoint(); } } while (0) |
| 305 | objArrayOop(d)->obj_at_addr<oop>(dst_pos), "sanity")do { if (!(arrayOopDesc::obj_offset_to_raw<oop>(d, dst_offset , __null) == objArrayOop(d)->obj_at_addr<oop>(dst_pos ))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 305, "assert(" "arrayOopDesc::obj_offset_to_raw<oop>(d, dst_offset, __null) == objArrayOop(d)->obj_at_addr<oop>(dst_pos)" ") failed", "sanity"); ::breakpoint(); } } while (0); |
| 306 | do_copy(s, src_offset, d, dst_offset, length, CHECK__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception ())) return ; (void)(0); |
| 307 | } |
| 308 | } |
| 309 | |
| 310 | |
| 311 | Klass* ObjArrayKlass::array_klass(int n, TRAPSJavaThread* __the_thread__) { |
| 312 | |
| 313 | assert(dimension() <= n, "check order of chain")do { if (!(dimension() <= n)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 313, "assert(" "dimension() <= n" ") failed", "check order of chain" ); ::breakpoint(); } } while (0); |
| 314 | int dim = dimension(); |
| 315 | if (dim == n) return this; |
| 316 | |
| 317 | // lock-free read needs acquire semantics |
| 318 | if (higher_dimension_acquire() == NULL__null) { |
| 319 | |
| 320 | ResourceMark rm(THREAD__the_thread__); |
| 321 | { |
| 322 | // Ensure atomic creation of higher dimensions |
| 323 | MutexLocker mu(THREAD__the_thread__, MultiArray_lock); |
| 324 | |
| 325 | // Check if another thread beat us |
| 326 | if (higher_dimension() == NULL__null) { |
| 327 | |
| 328 | // Create multi-dim klass object and link them together |
| 329 | Klass* k = |
| 330 | ObjArrayKlass::allocate_objArray_klass(class_loader_data(), dim + 1, this, CHECK_NULL__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception ())) return __null; (void)(0); |
| 331 | ObjArrayKlass* ak = ObjArrayKlass::cast(k); |
| 332 | ak->set_lower_dimension(this); |
| 333 | // use 'release' to pair with lock-free load |
| 334 | release_set_higher_dimension(ak); |
| 335 | assert(ak->is_objArray_klass(), "incorrect initialization of ObjArrayKlass")do { if (!(ak->is_objArray_klass())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 335, "assert(" "ak->is_objArray_klass()" ") failed", "incorrect initialization of ObjArrayKlass" ); ::breakpoint(); } } while (0); |
| 336 | } |
| 337 | } |
| 338 | } |
| 339 | |
| 340 | ObjArrayKlass *ak = ObjArrayKlass::cast(higher_dimension()); |
| 341 | THREAD__the_thread__->check_possible_safepoint(); |
| 342 | return ak->array_klass(n, THREAD__the_thread__); |
| 343 | } |
| 344 | |
| 345 | Klass* ObjArrayKlass::array_klass_or_null(int n) { |
| 346 | |
| 347 | assert(dimension() <= n, "check order of chain")do { if (!(dimension() <= n)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 347, "assert(" "dimension() <= n" ") failed", "check order of chain" ); ::breakpoint(); } } while (0); |
| 348 | int dim = dimension(); |
| 349 | if (dim == n) return this; |
| 350 | |
| 351 | // lock-free read needs acquire semantics |
| 352 | if (higher_dimension_acquire() == NULL__null) { |
| 353 | return NULL__null; |
| 354 | } |
| 355 | |
| 356 | ObjArrayKlass *ak = ObjArrayKlass::cast(higher_dimension()); |
| 357 | return ak->array_klass_or_null(n); |
| 358 | } |
| 359 | |
| 360 | Klass* ObjArrayKlass::array_klass(TRAPSJavaThread* __the_thread__) { |
| 361 | return array_klass(dimension() + 1, THREAD__the_thread__); |
| 362 | } |
| 363 | |
| 364 | Klass* ObjArrayKlass::array_klass_or_null() { |
| 365 | return array_klass_or_null(dimension() + 1); |
| 366 | } |
| 367 | |
| 368 | bool ObjArrayKlass::can_be_primary_super_slow() const { |
| 369 | if (!bottom_klass()->can_be_primary_super()) |
| 370 | // array of interfaces |
| 371 | return false; |
| 372 | else |
| 373 | return Klass::can_be_primary_super_slow(); |
| 374 | } |
| 375 | |
| 376 | GrowableArray<Klass*>* ObjArrayKlass::compute_secondary_supers(int num_extra_slots, |
| 377 | Array<InstanceKlass*>* transitive_interfaces) { |
| 378 | assert(transitive_interfaces == NULL, "sanity")do { if (!(transitive_interfaces == __null)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 378, "assert(" "transitive_interfaces == __null" ") failed" , "sanity"); ::breakpoint(); } } while (0); |
| 379 | // interfaces = { cloneable_klass, serializable_klass, elemSuper[], ... }; |
| 380 | const Array<Klass*>* elem_supers = element_klass()->secondary_supers(); |
| 381 | int num_elem_supers = elem_supers == NULL__null ? 0 : elem_supers->length(); |
| 382 | int num_secondaries = num_extra_slots + 2 + num_elem_supers; |
| 383 | if (num_secondaries == 2) { |
| 384 | // Must share this for correct bootstrapping! |
| 385 | set_secondary_supers(Universe::the_array_interfaces_array()); |
| 386 | return NULL__null; |
| 387 | } else { |
| 388 | GrowableArray<Klass*>* secondaries = new GrowableArray<Klass*>(num_elem_supers+2); |
| 389 | secondaries->push(vmClasses::Cloneable_klass()); |
| 390 | secondaries->push(vmClasses::Serializable_klass()); |
| 391 | for (int i = 0; i < num_elem_supers; i++) { |
| 392 | Klass* elem_super = elem_supers->at(i); |
| 393 | Klass* array_super = elem_super->array_klass_or_null(); |
| 394 | assert(array_super != NULL, "must already have been created")do { if (!(array_super != __null)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 394, "assert(" "array_super != __null" ") failed", "must already have been created" ); ::breakpoint(); } } while (0); |
| 395 | secondaries->push(array_super); |
| 396 | } |
| 397 | return secondaries; |
| 398 | } |
| 399 | } |
| 400 | |
| 401 | void ObjArrayKlass::initialize(TRAPSJavaThread* __the_thread__) { |
| 402 | bottom_klass()->initialize(THREAD__the_thread__); // dispatches to either InstanceKlass or TypeArrayKlass |
| 403 | } |
| 404 | |
| 405 | void ObjArrayKlass::metaspace_pointers_do(MetaspaceClosure* it) { |
| 406 | ArrayKlass::metaspace_pointers_do(it); |
| 407 | it->push(&_element_klass); |
| 408 | it->push(&_bottom_klass); |
| 409 | } |
| 410 | |
| 411 | jint ObjArrayKlass::compute_modifier_flags() const { |
| 412 | // The modifier for an objectArray is the same as its element |
| 413 | if (element_klass() == NULL__null) { |
| 414 | assert(Universe::is_bootstrapping(), "partial objArray only at startup")do { if (!(Universe::is_bootstrapping())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 414, "assert(" "Universe::is_bootstrapping()" ") failed", "partial objArray only at startup" ); ::breakpoint(); } } while (0); |
| 415 | return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC; |
| 416 | } |
| 417 | // Return the flags of the bottom element type. |
| 418 | jint element_flags = bottom_klass()->compute_modifier_flags(); |
| 419 | |
| 420 | return (element_flags & (JVM_ACC_PUBLIC | JVM_ACC_PRIVATE | JVM_ACC_PROTECTED)) |
| 421 | | (JVM_ACC_ABSTRACT | JVM_ACC_FINAL); |
| 422 | } |
| 423 | |
| 424 | ModuleEntry* ObjArrayKlass::module() const { |
| 425 | assert(bottom_klass() != NULL, "ObjArrayKlass returned unexpected NULL bottom_klass")do { if (!(bottom_klass() != __null)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 425, "assert(" "bottom_klass() != __null" ") failed", "ObjArrayKlass returned unexpected NULL bottom_klass" ); ::breakpoint(); } } while (0); |
| 426 | // The array is defined in the module of its bottom class |
| 427 | return bottom_klass()->module(); |
| 428 | } |
| 429 | |
| 430 | PackageEntry* ObjArrayKlass::package() const { |
| 431 | assert(bottom_klass() != NULL, "ObjArrayKlass returned unexpected NULL bottom_klass")do { if (!(bottom_klass() != __null)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 431, "assert(" "bottom_klass() != __null" ") failed", "ObjArrayKlass returned unexpected NULL bottom_klass" ); ::breakpoint(); } } while (0); |
| 432 | return bottom_klass()->package(); |
| 433 | } |
| 434 | |
| 435 | // Printing |
| 436 | |
| 437 | void ObjArrayKlass::print_on(outputStream* st) const { |
| 438 | #ifndef PRODUCT |
| 439 | Klass::print_on(st); |
| 440 | st->print(" - instance klass: "); |
| 441 | element_klass()->print_value_on(st); |
| 442 | st->cr(); |
| 443 | #endif //PRODUCT |
| 444 | } |
| 445 | |
| 446 | void ObjArrayKlass::print_value_on(outputStream* st) const { |
| 447 | assert(is_klass(), "must be klass")do { if (!(is_klass())) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 447, "assert(" "is_klass()" ") failed", "must be klass"); :: breakpoint(); } } while (0); |
| 448 | |
| 449 | element_klass()->print_value_on(st); |
| 450 | st->print("[]"); |
| 451 | } |
| 452 | |
| 453 | #ifndef PRODUCT |
| 454 | |
| 455 | void ObjArrayKlass::oop_print_on(oop obj, outputStream* st) { |
| 456 | ArrayKlass::oop_print_on(obj, st); |
| 457 | assert(obj->is_objArray(), "must be objArray")do { if (!(obj->is_objArray())) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 457, "assert(" "obj->is_objArray()" ") failed", "must be objArray" ); ::breakpoint(); } } while (0); |
| 458 | objArrayOop oa = objArrayOop(obj); |
| 459 | int print_len = MIN2((intx) oa->length(), MaxElementPrintSize); |
| 460 | for(int index = 0; index < print_len; index++) { |
| 461 | st->print(" - %3d : ", index); |
| 462 | if (oa->obj_at(index) != NULL__null) { |
| 463 | oa->obj_at(index)->print_value_on(st); |
| 464 | st->cr(); |
| 465 | } else { |
| 466 | st->print_cr("NULL"); |
| 467 | } |
| 468 | } |
| 469 | int remaining = oa->length() - print_len; |
| 470 | if (remaining > 0) { |
| 471 | st->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining); |
| 472 | } |
| 473 | } |
| 474 | |
| 475 | #endif //PRODUCT |
| 476 | |
| 477 | void ObjArrayKlass::oop_print_value_on(oop obj, outputStream* st) { |
| 478 | assert(obj->is_objArray(), "must be objArray")do { if (!(obj->is_objArray())) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 478, "assert(" "obj->is_objArray()" ") failed", "must be objArray" ); ::breakpoint(); } } while (0); |
| 479 | st->print("a "); |
| 480 | element_klass()->print_value_on(st); |
| 481 | int len = objArrayOop(obj)->length(); |
| 482 | st->print("[%d] ", len); |
| 483 | if (obj != NULL__null) { |
| 484 | obj->print_address_on(st); |
| 485 | } else { |
| 486 | st->print_cr("NULL"); |
| 487 | } |
| 488 | } |
| 489 | |
| 490 | const char* ObjArrayKlass::internal_name() const { |
| 491 | return external_name(); |
| 492 | } |
| 493 | |
| 494 | |
| 495 | // Verification |
| 496 | |
| 497 | void ObjArrayKlass::verify_on(outputStream* st) { |
| 498 | ArrayKlass::verify_on(st); |
| 499 | guarantee(element_klass()->is_klass(), "should be klass")do { if (!(element_klass()->is_klass())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 499, "guarantee(" "element_klass()->is_klass()" ") failed" , "should be klass"); ::breakpoint(); } } while (0); |
| 500 | guarantee(bottom_klass()->is_klass(), "should be klass")do { if (!(bottom_klass()->is_klass())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 500, "guarantee(" "bottom_klass()->is_klass()" ") failed" , "should be klass"); ::breakpoint(); } } while (0); |
| 501 | Klass* bk = bottom_klass(); |
| 502 | guarantee(bk->is_instance_klass() || bk->is_typeArray_klass(), "invalid bottom klass")do { if (!(bk->is_instance_klass() || bk->is_typeArray_klass ())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 502, "guarantee(" "bk->is_instance_klass() || bk->is_typeArray_klass()" ") failed", "invalid bottom klass"); ::breakpoint(); } } while (0); |
| 503 | } |
| 504 | |
| 505 | void ObjArrayKlass::oop_verify_on(oop obj, outputStream* st) { |
| 506 | ArrayKlass::oop_verify_on(obj, st); |
| 507 | guarantee(obj->is_objArray(), "must be objArray")do { if (!(obj->is_objArray())) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 507, "guarantee(" "obj->is_objArray()" ") failed", "must be objArray" ); ::breakpoint(); } } while (0); |
| 508 | objArrayOop oa = objArrayOop(obj); |
| 509 | for(int index = 0; index < oa->length(); index++) { |
| 510 | guarantee(oopDesc::is_oop_or_null(oa->obj_at(index)), "should be oop")do { if (!(oopDesc::is_oop_or_null(oa->obj_at(index)))) { ( *g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/objArrayKlass.cpp" , 510, "guarantee(" "oopDesc::is_oop_or_null(oa->obj_at(index))" ") failed", "should be oop"); ::breakpoint(); } } while (0); |
| 511 | } |
| 512 | } |