1 /*
   2  * Copyright (c) 1997, 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  */
  24 
  25 #include "precompiled.hpp"
  26 #include "classfile/symbolTable.hpp"
  27 #include "classfile/systemDictionary.hpp"
  28 #include "classfile/vmSymbols.hpp"
  29 #include "gc_implementation/shared/markSweep.inline.hpp"
  30 #include "gc_interface/collectedHeap.inline.hpp"
  31 #include "memory/genOopClosures.inline.hpp"
  32 #include "memory/iterator.inline.hpp"
  33 #include "memory/metadataFactory.hpp"
  34 #include "memory/resourceArea.hpp"
  35 #include "memory/universe.inline.hpp"
  36 #include "oops/instanceKlass.hpp"
  37 #include "oops/klass.inline.hpp"
  38 #include "oops/objArrayKlass.hpp"
  39 #include "oops/objArrayKlass.inline.hpp"
  40 #include "oops/objArrayOop.hpp"
  41 #include "oops/oop.inline.hpp"
  42 #include "oops/oop.inline2.hpp"
  43 #include "oops/symbol.hpp"
  44 #include "runtime/handles.inline.hpp"
  45 #include "runtime/mutexLocker.hpp"
  46 #include "runtime/orderAccess.inline.hpp"
  47 #include "utilities/copy.hpp"
  48 #include "utilities/macros.hpp"
  49 #if INCLUDE_ALL_GCS
  50 #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp"
  51 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
  52 #include "gc_implementation/g1/g1OopClosures.inline.hpp"
  53 #include "gc_implementation/g1/g1RemSet.inline.hpp"
  54 #include "gc_implementation/g1/heapRegionManager.inline.hpp"
  55 #include "gc_implementation/parNew/parOopClosures.inline.hpp"
  56 #include "gc_implementation/parallelScavenge/psCompactionManager.hpp"
  57 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
  58 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
  59 #include "oops/oop.pcgc.inline.hpp"
  60 #endif // INCLUDE_ALL_GCS
  61 
  62 ObjArrayKlass* ObjArrayKlass::allocate(ClassLoaderData* loader_data, int n, KlassHandle klass_handle, Symbol* name, TRAPS) {
  63   assert(ObjArrayKlass::header_size() <= InstanceKlass::header_size(),
  64       "array klasses must be same size as InstanceKlass");
  65 
  66   int size = ArrayKlass::static_size(ObjArrayKlass::header_size());
  67 
  68   return new (loader_data, size, THREAD) ObjArrayKlass(n, klass_handle, name);
  69 }
  70 
  71 Klass* ObjArrayKlass::allocate_objArray_klass(ClassLoaderData* loader_data,
  72                                                 int n, KlassHandle element_klass, TRAPS) {
  73 
  74   // Eagerly allocate the direct array supertype.
  75   KlassHandle super_klass = KlassHandle();
  76   if (!Universe::is_bootstrapping() || SystemDictionary::Object_klass_loaded()) {
  77     KlassHandle element_super (THREAD, element_klass->super());
  78     if (element_super.not_null()) {
  79       // The element type has a direct super.  E.g., String[] has direct super of Object[].
  80       super_klass = KlassHandle(THREAD, element_super->array_klass_or_null());
  81       bool supers_exist = super_klass.not_null();
  82       // Also, see if the element has secondary supertypes.
  83       // We need an array type for each.
  84       Array<Klass*>* element_supers = element_klass->secondary_supers();
  85       for( int i = element_supers->length()-1; i >= 0; i-- ) {
  86         Klass* elem_super = element_supers->at(i);
  87         if (elem_super->array_klass_or_null() == NULL) {
  88           supers_exist = false;
  89           break;
  90         }
  91       }
  92       if (!supers_exist) {
  93         // Oops.  Not allocated yet.  Back out, allocate it, and retry.
  94         KlassHandle ek;
  95         {
  96           MutexUnlocker mu(MultiArray_lock);
  97           MutexUnlocker mc(Compile_lock);   // for vtables
  98           Klass* sk = element_super->array_klass(CHECK_0);
  99           super_klass = KlassHandle(THREAD, sk);
 100           for( int i = element_supers->length()-1; i >= 0; i-- ) {
 101             KlassHandle elem_super (THREAD, element_supers->at(i));
 102             elem_super->array_klass(CHECK_0);
 103           }
 104           // Now retry from the beginning
 105           Klass* klass_oop = element_klass->array_klass(n, CHECK_0);
 106           // Create a handle because the enclosing brace, when locking
 107           // can cause a gc.  Better to have this function return a Handle.
 108           ek = KlassHandle(THREAD, klass_oop);
 109         }  // re-lock
 110         return ek();
 111       }
 112     } else {
 113       // The element type is already Object.  Object[] has direct super of Object.
 114       super_klass = KlassHandle(THREAD, SystemDictionary::Object_klass());
 115     }
 116   }
 117 
 118   // Create type name for klass.
 119   Symbol* name = NULL;
 120   if (!element_klass->oop_is_instance() ||
 121       (name = InstanceKlass::cast(element_klass())->array_name()) == NULL) {
 122 
 123     ResourceMark rm(THREAD);
 124     char *name_str = element_klass->name()->as_C_string();
 125     int len = element_klass->name()->utf8_length();
 126     char *new_str = NEW_RESOURCE_ARRAY(char, len + 4);
 127     int idx = 0;
 128     new_str[idx++] = '[';
 129     if (element_klass->oop_is_instance()) { // it could be an array or simple type
 130       new_str[idx++] = 'L';
 131     }
 132     memcpy(&new_str[idx], name_str, len * sizeof(char));
 133     idx += len;
 134     if (element_klass->oop_is_instance()) {
 135       new_str[idx++] = ';';
 136     }
 137     new_str[idx++] = '\0';
 138     name = SymbolTable::new_permanent_symbol(new_str, CHECK_0);
 139     if (element_klass->oop_is_instance()) {
 140       InstanceKlass* ik = InstanceKlass::cast(element_klass());
 141       ik->set_array_name(name);
 142     }
 143   }
 144 
 145   // Initialize instance variables
 146   ObjArrayKlass* oak = ObjArrayKlass::allocate(loader_data, n, element_klass, name, CHECK_0);
 147 
 148   // Add all classes to our internal class loader list here,
 149   // including classes in the bootstrap (NULL) class loader.
 150   // GC walks these as strong roots.
 151   loader_data->add_class(oak);
 152 
 153   // Call complete_create_array_klass after all instance variables has been initialized.
 154   ArrayKlass::complete_create_array_klass(oak, super_klass, CHECK_0);
 155 
 156   return oak;
 157 }
 158 
 159 ObjArrayKlass::ObjArrayKlass(int n, KlassHandle element_klass, Symbol* name) : ArrayKlass(name) {
 160   this->set_dimension(n);
 161   this->set_element_klass(element_klass());
 162   // decrement refcount because object arrays are not explicitly freed.  The
 163   // InstanceKlass array_name() keeps the name counted while the klass is
 164   // loaded.
 165   name->decrement_refcount();
 166 
 167   Klass* bk;
 168   if (element_klass->oop_is_objArray()) {
 169     bk = ObjArrayKlass::cast(element_klass())->bottom_klass();
 170   } else {
 171     bk = element_klass();
 172   }
 173   assert(bk != NULL && (bk->oop_is_instance() || bk->oop_is_typeArray()), "invalid bottom klass");
 174   this->set_bottom_klass(bk);
 175   this->set_class_loader_data(bk->class_loader_data());
 176 
 177   this->set_layout_helper(array_layout_helper(T_OBJECT));
 178   assert(this->oop_is_array(), "sanity");
 179   assert(this->oop_is_objArray(), "sanity");
 180 }
 181 
 182 int ObjArrayKlass::oop_size(oop obj) const {
 183   assert(obj->is_objArray(), "must be object array");
 184   return objArrayOop(obj)->object_size();
 185 }
 186 
 187 objArrayOop ObjArrayKlass::allocate(int length, TRAPS) {
 188   if (length >= 0) {
 189     if (length <= arrayOopDesc::max_array_length(T_OBJECT)) {
 190       int size = objArrayOopDesc::object_size(length);
 191       KlassHandle h_k(THREAD, this);
 192       return (objArrayOop)CollectedHeap::array_allocate(h_k, size, length, CHECK_NULL);
 193     } else {
 194       report_java_out_of_memory("Requested array size exceeds VM limit");
 195       JvmtiExport::post_array_size_exhausted();
 196       THROW_OOP_0(Universe::out_of_memory_error_array_size());
 197     }
 198   } else {
 199     THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
 200   }
 201 }
 202 
 203 static int multi_alloc_counter = 0;
 204 
 205 oop ObjArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
 206   int length = *sizes;
 207   // Call to lower_dimension uses this pointer, so most be called before a
 208   // possible GC
 209   KlassHandle h_lower_dimension(THREAD, lower_dimension());
 210   // If length < 0 allocate will throw an exception.
 211   objArrayOop array = allocate(length, CHECK_NULL);
 212   objArrayHandle h_array (THREAD, array);
 213   if (rank > 1) {
 214     if (length != 0) {
 215       for (int index = 0; index < length; index++) {
 216         ArrayKlass* ak = ArrayKlass::cast(h_lower_dimension());
 217         oop sub_array = ak->multi_allocate(rank-1, &sizes[1], CHECK_NULL);
 218         h_array->obj_at_put(index, sub_array);
 219       }
 220     } else {
 221       // Since this array dimension has zero length, nothing will be
 222       // allocated, however the lower dimension values must be checked
 223       // for illegal values.
 224       for (int i = 0; i < rank - 1; ++i) {
 225         sizes += 1;
 226         if (*sizes < 0) {
 227           THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
 228         }
 229       }
 230     }
 231   }
 232   return h_array();
 233 }
 234 
 235 // Either oop or narrowOop depending on UseCompressedOops.
 236 template <class T> void ObjArrayKlass::do_copy(arrayOop s, T* src,
 237                                arrayOop d, T* dst, int length, TRAPS) {
 238 
 239   BarrierSet* bs = Universe::heap()->barrier_set();
 240   // For performance reasons, we assume we are that the write barrier we
 241   // are using has optimized modes for arrays of references.  At least one
 242   // of the asserts below will fail if this is not the case.
 243   assert(bs->has_write_ref_array_opt(), "Barrier set must have ref array opt");
 244   assert(bs->has_write_ref_array_pre_opt(), "For pre-barrier as well.");
 245 
 246   if (s == d) {
 247     // since source and destination are equal we do not need conversion checks.
 248     assert(length > 0, "sanity check");
 249     bs->write_ref_array_pre(dst, length);
 250     Copy::conjoint_oops_atomic(src, dst, length);
 251   } else {
 252     // We have to make sure all elements conform to the destination array
 253     Klass* bound = ObjArrayKlass::cast(d->klass())->element_klass();
 254     Klass* stype = ObjArrayKlass::cast(s->klass())->element_klass();
 255     if (stype == bound || stype->is_subtype_of(bound)) {
 256       // elements are guaranteed to be subtypes, so no check necessary
 257       bs->write_ref_array_pre(dst, length);
 258       Copy::conjoint_oops_atomic(src, dst, length);
 259     } else {
 260       // slow case: need individual subtype checks
 261       // note: don't use obj_at_put below because it includes a redundant store check
 262       T* from = src;
 263       T* end = from + length;
 264       for (T* p = dst; from < end; from++, p++) {
 265         // XXX this is going to be slow.
 266         T element = *from;
 267         // even slower now
 268         bool element_is_null = oopDesc::is_null(element);
 269         oop new_val = element_is_null ? oop(NULL)
 270                                       : oopDesc::decode_heap_oop_not_null(element);
 271         if (element_is_null ||
 272             (new_val->klass())->is_subtype_of(bound)) {
 273           bs->write_ref_field_pre(p, new_val);
 274           *p = element;
 275         } else {
 276           // We must do a barrier to cover the partial copy.
 277           const size_t pd = pointer_delta(p, dst, (size_t)heapOopSize);
 278           // pointer delta is scaled to number of elements (length field in
 279           // objArrayOop) which we assume is 32 bit.
 280           assert(pd == (size_t)(int)pd, "length field overflow");
 281           bs->write_ref_array((HeapWord*)dst, pd);
 282           THROW(vmSymbols::java_lang_ArrayStoreException());
 283           return;
 284         }
 285       }
 286     }
 287   }
 288   bs->write_ref_array((HeapWord*)dst, length);
 289 }
 290 
 291 void ObjArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d,
 292                                int dst_pos, int length, TRAPS) {
 293   assert(s->is_objArray(), "must be obj array");
 294 
 295   if (!d->is_objArray()) {
 296     THROW(vmSymbols::java_lang_ArrayStoreException());
 297   }
 298 
 299   // Check is all offsets and lengths are non negative
 300   if (src_pos < 0 || dst_pos < 0 || length < 0) {
 301     THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
 302   }
 303   // Check if the ranges are valid
 304   if  ( (((unsigned int) length + (unsigned int) src_pos) > (unsigned int) s->length())
 305      || (((unsigned int) length + (unsigned int) dst_pos) > (unsigned int) d->length()) ) {
 306     THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
 307   }
 308 
 309   // Special case. Boundary cases must be checked first
 310   // This allows the following call: copy_array(s, s.length(), d.length(), 0).
 311   // This is correct, since the position is supposed to be an 'in between point', i.e., s.length(),
 312   // points to the right of the last element.
 313   if (length==0) {
 314     return;
 315   }
 316   if (UseCompressedOops) {
 317     narrowOop* const src = objArrayOop(s)->obj_at_addr<narrowOop>(src_pos);
 318     narrowOop* const dst = objArrayOop(d)->obj_at_addr<narrowOop>(dst_pos);
 319     do_copy<narrowOop>(s, src, d, dst, length, CHECK);
 320   } else {
 321     oop* const src = objArrayOop(s)->obj_at_addr<oop>(src_pos);
 322     oop* const dst = objArrayOop(d)->obj_at_addr<oop>(dst_pos);
 323     do_copy<oop> (s, src, d, dst, length, CHECK);
 324   }
 325 }
 326 
 327 
 328 Klass* ObjArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
 329 
 330   assert(dimension() <= n, "check order of chain");
 331   int dim = dimension();
 332   if (dim == n) return this;
 333 
 334   if (higher_dimension() == NULL) {
 335     if (or_null)  return NULL;
 336 
 337     ResourceMark rm;
 338     JavaThread *jt = (JavaThread *)THREAD;
 339     {
 340       MutexLocker mc(Compile_lock, THREAD);   // for vtables
 341       // Ensure atomic creation of higher dimensions
 342       MutexLocker mu(MultiArray_lock, THREAD);
 343 
 344       // Check if another thread beat us
 345       if (higher_dimension() == NULL) {
 346 
 347         // Create multi-dim klass object and link them together
 348         Klass* k =
 349           ObjArrayKlass::allocate_objArray_klass(class_loader_data(), dim + 1, this, CHECK_NULL);
 350         ObjArrayKlass* ak = ObjArrayKlass::cast(k);
 351         ak->set_lower_dimension(this);
 352         OrderAccess::storestore();
 353         set_higher_dimension(ak);
 354         assert(ak->oop_is_objArray(), "incorrect initialization of ObjArrayKlass");
 355       }
 356     }
 357   } else {
 358     CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
 359   }
 360 
 361   ObjArrayKlass *ak = ObjArrayKlass::cast(higher_dimension());
 362   if (or_null) {
 363     return ak->array_klass_or_null(n);
 364   }
 365   return ak->array_klass(n, CHECK_NULL);
 366 }
 367 
 368 Klass* ObjArrayKlass::array_klass_impl(bool or_null, TRAPS) {
 369   return array_klass_impl(or_null, dimension() +  1, CHECK_NULL);
 370 }
 371 
 372 bool ObjArrayKlass::can_be_primary_super_slow() const {
 373   if (!bottom_klass()->can_be_primary_super())
 374     // array of interfaces
 375     return false;
 376   else
 377     return Klass::can_be_primary_super_slow();
 378 }
 379 
 380 GrowableArray<Klass*>* ObjArrayKlass::compute_secondary_supers(int num_extra_slots) {
 381   // interfaces = { cloneable_klass, serializable_klass, elemSuper[], ... };
 382   Array<Klass*>* elem_supers = element_klass()->secondary_supers();
 383   int num_elem_supers = elem_supers == NULL ? 0 : elem_supers->length();
 384   int num_secondaries = num_extra_slots + 2 + num_elem_supers;
 385   if (num_secondaries == 2) {
 386     // Must share this for correct bootstrapping!
 387     set_secondary_supers(Universe::the_array_interfaces_array());
 388     return NULL;
 389   } else {
 390     GrowableArray<Klass*>* secondaries = new GrowableArray<Klass*>(num_elem_supers+2);
 391     secondaries->push(SystemDictionary::Cloneable_klass());
 392     secondaries->push(SystemDictionary::Serializable_klass());
 393     for (int i = 0; i < num_elem_supers; i++) {
 394       Klass* elem_super = (Klass*) elem_supers->at(i);
 395       Klass* array_super = elem_super->array_klass_or_null();
 396       assert(array_super != NULL, "must already have been created");
 397       secondaries->push(array_super);
 398     }
 399     return secondaries;
 400   }
 401 }
 402 
 403 bool ObjArrayKlass::compute_is_subtype_of(Klass* k) {
 404   if (!k->oop_is_objArray())
 405     return ArrayKlass::compute_is_subtype_of(k);
 406 
 407   ObjArrayKlass* oak = ObjArrayKlass::cast(k);
 408   return element_klass()->is_subtype_of(oak->element_klass());
 409 }
 410 
 411 void ObjArrayKlass::initialize(TRAPS) {
 412   bottom_klass()->initialize(THREAD);  // dispatches to either InstanceKlass or TypeArrayKlass
 413 }
 414 
 415 #define ObjArrayKlass_SPECIALIZED_OOP_ITERATE(T, a, p, do_oop) \
 416 {                                   \
 417   T* p         = (T*)(a)->base();   \
 418   T* const end = p + (a)->length(); \
 419   while (p < end) {                 \
 420     do_oop;                         \
 421     p++;                            \
 422   }                                 \
 423 }
 424 
 425 #define ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(T, a, p, low, high, do_oop) \
 426 {                                   \
 427   T* const l = (T*)(low);           \
 428   T* const h = (T*)(high);          \
 429   T* p       = (T*)(a)->base();     \
 430   T* end     = p + (a)->length();   \
 431   if (p < l) p = l;                 \
 432   if (end > h) end = h;             \
 433   while (p < end) {                 \
 434     do_oop;                         \
 435     ++p;                            \
 436   }                                 \
 437 }
 438 
 439 #define ObjArrayKlass_OOP_ITERATE(a, p, do_oop)      \
 440   if (UseCompressedOops) {                           \
 441     ObjArrayKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \
 442       a, p, do_oop)                                  \
 443   } else {                                           \
 444     ObjArrayKlass_SPECIALIZED_OOP_ITERATE(oop,       \
 445       a, p, do_oop)                                  \
 446   }
 447 
 448 #define ObjArrayKlass_BOUNDED_OOP_ITERATE(a, p, low, high, do_oop) \
 449   if (UseCompressedOops) {                                   \
 450     ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \
 451       a, p, low, high, do_oop)                               \
 452   } else {                                                   \
 453     ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop,       \
 454       a, p, low, high, do_oop)                               \
 455   }
 456 
 457 void ObjArrayKlass::oop_follow_contents(oop obj) {
 458   assert (obj->is_array(), "obj must be array");
 459   MarkSweep::follow_klass(obj->klass());
 460   if (UseCompressedOops) {
 461     objarray_follow_contents<narrowOop>(obj, 0);
 462   } else {
 463     objarray_follow_contents<oop>(obj, 0);
 464   }
 465 }
 466 
 467 #if INCLUDE_ALL_GCS
 468 void ObjArrayKlass::oop_follow_contents(ParCompactionManager* cm,
 469                                         oop obj) {
 470   assert(obj->is_array(), "obj must be array");
 471   PSParallelCompact::follow_klass(cm, obj->klass());
 472   if (UseCompressedOops) {
 473     objarray_follow_contents<narrowOop>(cm, obj, 0);
 474   } else {
 475     objarray_follow_contents<oop>(cm, obj, 0);
 476   }
 477 }
 478 #endif // INCLUDE_ALL_GCS
 479 
 480 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix)           \
 481                                                                                 \
 482 int ObjArrayKlass::oop_oop_iterate##nv_suffix(oop obj,                          \
 483                                               OopClosureType* closure) {        \
 484   SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
 485   assert (obj->is_array(), "obj must be array");                                \
 486   objArrayOop a = objArrayOop(obj);                                             \
 487   /* Get size before changing pointers. */                                      \
 488   /* Don't call size() or oop_size() since that is a virtual call. */           \
 489   int size = a->object_size();                                                  \
 490   if_do_metadata_checked(closure, nv_suffix) {                                  \
 491     closure->do_klass##nv_suffix(obj->klass());                                 \
 492   }                                                                             \
 493   ObjArrayKlass_OOP_ITERATE(a, p, (closure)->do_oop##nv_suffix(p))              \
 494   return size;                                                                  \
 495 }
 496 
 497 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix)         \
 498                                                                                 \
 499 int ObjArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj,                      \
 500                                                   OopClosureType* closure,      \
 501                                                   MemRegion mr) {               \
 502   SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
 503   assert(obj->is_array(), "obj must be array");                                 \
 504   objArrayOop a  = objArrayOop(obj);                                            \
 505   /* Get size before changing pointers. */                                      \
 506   /* Don't call size() or oop_size() since that is a virtual call */            \
 507   int size = a->object_size();                                                  \
 508   if_do_metadata_checked(closure, nv_suffix) {                                  \
 509     /* SSS: Do we need to pass down mr here? */                                 \
 510     closure->do_klass##nv_suffix(a->klass());                                   \
 511   }                                                                             \
 512   ObjArrayKlass_BOUNDED_OOP_ITERATE(                                            \
 513     a, p, mr.start(), mr.end(), (closure)->do_oop##nv_suffix(p))                \
 514   return size;                                                                  \
 515 }
 516 
 517 // Like oop_oop_iterate but only iterates over a specified range and only used
 518 // for objArrayOops.
 519 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r(OopClosureType, nv_suffix)         \
 520                                                                                 \
 521 int ObjArrayKlass::oop_oop_iterate_range##nv_suffix(oop obj,                    \
 522                                                   OopClosureType* closure,      \
 523                                                   int start, int end) {         \
 524   SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
 525   assert(obj->is_array(), "obj must be array");                                 \
 526   objArrayOop a  = objArrayOop(obj);                                            \
 527   /* Get size before changing pointers. */                                      \
 528   /* Don't call size() or oop_size() since that is a virtual call */            \
 529   int size = a->object_size();                                                  \
 530   if (UseCompressedOops) {                                                      \
 531     HeapWord* low = start == 0 ? (HeapWord*)a : (HeapWord*)a->obj_at_addr<narrowOop>(start);\
 532     /* this might be wierd if end needs to be aligned on HeapWord boundary */   \
 533     HeapWord* high = (HeapWord*)((narrowOop*)a->base() + end);                  \
 534     MemRegion mr(low, high);                                                    \
 535     if_do_metadata_checked(closure, nv_suffix) {                                \
 536       /* SSS: Do we need to pass down mr here? */                               \
 537       closure->do_klass##nv_suffix(a->klass());                                 \
 538     }                                                                           \
 539     ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop,                    \
 540       a, p, low, high, (closure)->do_oop##nv_suffix(p))                         \
 541   } else {                                                                      \
 542     HeapWord* low = start == 0 ? (HeapWord*)a : (HeapWord*)a->obj_at_addr<oop>(start);  \
 543     HeapWord* high = (HeapWord*)((oop*)a->base() + end);                        \
 544     MemRegion mr(low, high);                                                    \
 545     if_do_metadata_checked(closure, nv_suffix) {                                \
 546       /* SSS: Do we need to pass down mr here? */                               \
 547       closure->do_klass##nv_suffix(a->klass());                                 \
 548     }                                                                           \
 549     ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop,                          \
 550       a, p, low, high, (closure)->do_oop##nv_suffix(p))                         \
 551   }                                                                             \
 552   return size;                                                                  \
 553 }
 554 
 555 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN)
 556 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN)
 557 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m)
 558 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m)
 559 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r)
 560 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r)
 561 
 562 int ObjArrayKlass::oop_adjust_pointers(oop obj) {
 563   assert(obj->is_objArray(), "obj must be obj array");
 564   objArrayOop a = objArrayOop(obj);
 565   // Get size before changing pointers.
 566   // Don't call size() or oop_size() since that is a virtual call.
 567   int size = a->object_size();
 568   ObjArrayKlass_OOP_ITERATE(a, p, MarkSweep::adjust_pointer(p))
 569   return size;
 570 }
 571 
 572 #if INCLUDE_ALL_GCS
 573 void ObjArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
 574   assert(obj->is_objArray(), "obj must be obj array");
 575   ObjArrayKlass_OOP_ITERATE( \
 576     objArrayOop(obj), p, \
 577     if (PSScavenge::should_scavenge(p)) { \
 578       pm->claim_or_forward_depth(p); \
 579     })
 580 }
 581 
 582 int ObjArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
 583   assert (obj->is_objArray(), "obj must be obj array");
 584   objArrayOop a = objArrayOop(obj);
 585   int size = a->object_size();
 586   ObjArrayKlass_OOP_ITERATE(a, p, PSParallelCompact::adjust_pointer(p))
 587   return size;
 588 }
 589 #endif // INCLUDE_ALL_GCS
 590 
 591 // JVM support
 592 
 593 jint ObjArrayKlass::compute_modifier_flags(TRAPS) const {
 594   // The modifier for an objectArray is the same as its element
 595   if (element_klass() == NULL) {
 596     assert(Universe::is_bootstrapping(), "partial objArray only at startup");
 597     return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;
 598   }
 599   // Return the flags of the bottom element type.
 600   jint element_flags = bottom_klass()->compute_modifier_flags(CHECK_0);
 601 
 602   return (element_flags & (JVM_ACC_PUBLIC | JVM_ACC_PRIVATE | JVM_ACC_PROTECTED))
 603                         | (JVM_ACC_ABSTRACT | JVM_ACC_FINAL);
 604 }
 605 
 606 
 607 // Printing
 608 
 609 void ObjArrayKlass::print_on(outputStream* st) const {
 610 #ifndef PRODUCT
 611   Klass::print_on(st);
 612   st->print(" - instance klass: ");
 613   element_klass()->print_value_on(st);
 614   st->cr();
 615 #endif //PRODUCT
 616 }
 617 
 618 void ObjArrayKlass::print_value_on(outputStream* st) const {
 619   assert(is_klass(), "must be klass");
 620 
 621   element_klass()->print_value_on(st);
 622   st->print("[]");
 623 }
 624 
 625 #ifndef PRODUCT
 626 
 627 void ObjArrayKlass::oop_print_on(oop obj, outputStream* st) {
 628   ArrayKlass::oop_print_on(obj, st);
 629   assert(obj->is_objArray(), "must be objArray");
 630   objArrayOop oa = objArrayOop(obj);
 631   int print_len = MIN2((intx) oa->length(), MaxElementPrintSize);
 632   for(int index = 0; index < print_len; index++) {
 633     st->print(" - %3d : ", index);
 634     oa->obj_at(index)->print_value_on(st);
 635     st->cr();
 636   }
 637   int remaining = oa->length() - print_len;
 638   if (remaining > 0) {
 639     st->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining);
 640   }
 641 }
 642 
 643 #endif //PRODUCT
 644 
 645 static int max_objArray_print_length = 4;
 646 
 647 void ObjArrayKlass::oop_print_value_on(oop obj, outputStream* st) {
 648   assert(obj->is_objArray(), "must be objArray");
 649   st->print("a ");
 650   element_klass()->print_value_on(st);
 651   int len = objArrayOop(obj)->length();
 652   st->print("[%d] ", len);
 653   obj->print_address_on(st);
 654   if (NOT_PRODUCT(PrintOopAddress ||) PrintMiscellaneous && (WizardMode || Verbose)) {
 655     st->print("{");
 656     for (int i = 0; i < len; i++) {
 657       if (i > max_objArray_print_length) {
 658         st->print("..."); break;
 659       }
 660       st->print(" "INTPTR_FORMAT, (intptr_t)(void*)objArrayOop(obj)->obj_at(i));
 661     }
 662     st->print(" }");
 663   }
 664 }
 665 
 666 const char* ObjArrayKlass::internal_name() const {
 667   return external_name();
 668 }
 669 
 670 
 671 // Verification
 672 
 673 void ObjArrayKlass::verify_on(outputStream* st) {
 674   ArrayKlass::verify_on(st);
 675   guarantee(element_klass()->is_klass(), "should be klass");
 676   guarantee(bottom_klass()->is_klass(), "should be klass");
 677   Klass* bk = bottom_klass();
 678   guarantee(bk->oop_is_instance() || bk->oop_is_typeArray(),  "invalid bottom klass");
 679 }
 680 
 681 void ObjArrayKlass::oop_verify_on(oop obj, outputStream* st) {
 682   ArrayKlass::oop_verify_on(obj, st);
 683   guarantee(obj->is_objArray(), "must be objArray");
 684   objArrayOop oa = objArrayOop(obj);
 685   for(int index = 0; index < oa->length(); index++) {
 686     guarantee(oa->obj_at(index)->is_oop_or_null(), "should be oop");
 687   }
 688 }