klass.cpp 22.0 KB
Newer Older
D
duke 已提交
1
/*
2
 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
D
duke 已提交
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
19 20 21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
D
duke 已提交
22 23 24
 *
 */

25
#include "precompiled.hpp"
26 27
#include "classfile/javaClasses.hpp"
#include "classfile/dictionary.hpp"
28 29
#include "classfile/systemDictionary.hpp"
#include "classfile/vmSymbols.hpp"
30
#include "gc_implementation/shared/markSweep.inline.hpp"
31
#include "gc_interface/collectedHeap.inline.hpp"
32
#include "memory/heapInspection.hpp"
33
#include "memory/metadataFactory.hpp"
34 35 36 37 38 39
#include "memory/oopFactory.hpp"
#include "memory/resourceArea.hpp"
#include "oops/instanceKlass.hpp"
#include "oops/klass.inline.hpp"
#include "oops/oop.inline2.hpp"
#include "runtime/atomic.hpp"
S
sla 已提交
40
#include "trace/traceMacros.hpp"
41
#include "utilities/stack.hpp"
42 43
#include "utilities/macros.hpp"
#if INCLUDE_ALL_GCS
44 45 46
#include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
#include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
#include "gc_implementation/parallelScavenge/psScavenge.hpp"
47
#endif // INCLUDE_ALL_GCS
D
duke 已提交
48

49 50 51 52
void Klass::set_name(Symbol* n) {
  _name = n;
  if (_name != NULL) _name->increment_refcount();
}
D
duke 已提交
53

54
bool Klass::is_subclass_of(const Klass* k) const {
D
duke 已提交
55
  // Run up the super chain and check
56
  if (this == k) return true;
D
duke 已提交
57

58
  Klass* t = const_cast<Klass*>(this)->super();
D
duke 已提交
59 60 61

  while (t != NULL) {
    if (t == k) return true;
H
hseigel 已提交
62
    t = t->super();
D
duke 已提交
63 64 65 66
  }
  return false;
}

67
bool Klass::search_secondary_supers(Klass* k) const {
D
duke 已提交
68 69 70 71
  // Put some extra logic here out-of-line, before the search proper.
  // This cuts down the size of the inline method.

  // This is necessary, since I am never in my own secondary_super list.
72
  if (this == k)
D
duke 已提交
73 74 75 76
    return true;
  // Scan the array-of-objects for a match
  int cnt = secondary_supers()->length();
  for (int i = 0; i < cnt; i++) {
77
    if (secondary_supers()->at(i) == k) {
D
duke 已提交
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
      ((Klass*)this)->set_secondary_super_cache(k);
      return true;
    }
  }
  return false;
}

// Return self, except for abstract classes with exactly 1
// implementor.  Then return the 1 concrete implementation.
Klass *Klass::up_cast_abstract() {
  Klass *r = this;
  while( r->is_abstract() ) {   // Receiver is abstract?
    Klass *s = r->subklass();   // Check for exactly 1 subklass
    if( !s || s->next_sibling() ) // Oops; wrong count; give up
      return this;              // Return 'this' as a no-progress flag
    r = s;                    // Loop till find concrete class
  }
  return r;                   // Return the 1 concrete class
}

T
twisti 已提交
98
// Find LCA in class hierarchy
D
duke 已提交
99 100 101
Klass *Klass::LCA( Klass *k2 ) {
  Klass *k1 = this;
  while( 1 ) {
102 103 104 105
    if( k1->is_subtype_of(k2) ) return k2;
    if( k2->is_subtype_of(k1) ) return k1;
    k1 = k1->super();
    k2 = k2->super();
D
duke 已提交
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
  }
}


void Klass::check_valid_for_instantiation(bool throwError, TRAPS) {
  ResourceMark rm(THREAD);
  THROW_MSG(throwError ? vmSymbols::java_lang_InstantiationError()
            : vmSymbols::java_lang_InstantiationException(), external_name());
}


void Klass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) {
  THROW(vmSymbols::java_lang_ArrayStoreException());
}


void Klass::initialize(TRAPS) {
  ShouldNotReachHere();
}

126
bool Klass::compute_is_subtype_of(Klass* k) {
D
duke 已提交
127 128 129 130 131
  assert(k->is_klass(), "argument must be a class");
  return is_subclass_of(k);
}


132
Method* Klass::uncached_lookup_method(Symbol* name, Symbol* signature) const {
D
duke 已提交
133 134 135 136 137 138 139 140 141
#ifdef ASSERT
  tty->print_cr("Error: uncached_lookup_method called on a klass oop."
                " Likely error: reflection method does not correctly"
                " wrap return value in a mirror object.");
#endif
  ShouldNotReachHere();
  return NULL;
}

142
void* Klass::operator new(size_t size, ClassLoaderData* loader_data, size_t word_size, TRAPS) throw() {
143
  return Metaspace::allocate(loader_data, word_size, /*read_only*/false,
144
                             MetaspaceObj::ClassType, CHECK_NULL);
145 146 147 148
}

Klass::Klass() {
  Klass* k = this;
D
duke 已提交
149

150 151 152 153 154
  // Preinitialize supertype information.
  // A later call to initialize_supers() may update these settings:
  set_super(NULL);
  for (juint i = 0; i < Klass::primary_super_limit(); i++) {
    _primary_supers[i] = NULL;
D
duke 已提交
155
  }
156 157 158 159
  set_secondary_supers(NULL);
  set_secondary_super_cache(NULL);
  _primary_supers[0] = k;
  set_super_check_offset(in_bytes(primary_supers_offset()));
D
duke 已提交
160

161 162 163 164
  set_java_mirror(NULL);
  set_modifier_flags(0);
  set_layout_helper(Klass::_lh_neutral_value);
  set_name(NULL);
D
duke 已提交
165 166
  AccessFlags af;
  af.set_flags(0);
167 168 169 170
  set_access_flags(af);
  set_subklass(NULL);
  set_next_sibling(NULL);
  set_next_link(NULL);
S
sla 已提交
171
  TRACE_INIT_ID(this);
D
duke 已提交
172

173 174 175
  set_prototype_header(markOopDesc::prototype());
  set_biased_lock_revocation_count(0);
  set_last_biased_lock_bulk_revocation_time(0);
D
duke 已提交
176

177 178 179
  // The klass doesn't have any references at this point.
  clear_modified_oops();
  clear_accumulated_modified_oops();
D
duke 已提交
180 181 182 183 184 185
}

jint Klass::array_layout_helper(BasicType etype) {
  assert(etype >= T_BOOLEAN && etype <= T_OBJECT, "valid etype");
  // Note that T_ARRAY is not allowed here.
  int  hsize = arrayOopDesc::base_offset_in_bytes(etype);
186
  int  esize = type2aelembytes(etype);
D
duke 已提交
187 188 189 190 191
  bool isobj = (etype == T_OBJECT);
  int  tag   =  isobj ? _lh_array_tag_obj_value : _lh_array_tag_type_value;
  int lh = array_layout_helper(tag, hsize, etype, exact_log2(esize));

  assert(lh < (int)_lh_neutral_value, "must look like an array layout");
192
  assert(layout_helper_is_array(lh), "correct kind");
D
duke 已提交
193 194 195 196 197 198 199 200 201 202 203 204
  assert(layout_helper_is_objArray(lh) == isobj, "correct kind");
  assert(layout_helper_is_typeArray(lh) == !isobj, "correct kind");
  assert(layout_helper_header_size(lh) == hsize, "correct decode");
  assert(layout_helper_element_type(lh) == etype, "correct decode");
  assert(1 << layout_helper_log2_element_size(lh) == esize, "correct decode");

  return lh;
}

bool Klass::can_be_primary_super_slow() const {
  if (super() == NULL)
    return true;
205
  else if (super()->super_depth() >= primary_super_limit()-1)
D
duke 已提交
206 207 208 209 210
    return false;
  else
    return true;
}

211
void Klass::initialize_supers(Klass* k, TRAPS) {
D
duke 已提交
212 213 214 215 216 217 218
  if (FastSuperclassLimit == 0) {
    // None of the other machinery matters.
    set_super(k);
    return;
  }
  if (k == NULL) {
    set_super(NULL);
219
    _primary_supers[0] = this;
D
duke 已提交
220
    assert(super_depth() == 0, "Object must already be initialized properly");
221 222
  } else if (k != super() || k == SystemDictionary::Object_klass()) {
    assert(super() == NULL || super() == SystemDictionary::Object_klass(),
D
duke 已提交
223 224
           "initialize this only once to a non-trivial value");
    set_super(k);
225
    Klass* sup = k;
D
duke 已提交
226 227 228 229 230
    int sup_depth = sup->super_depth();
    juint my_depth  = MIN2(sup_depth + 1, (int)primary_super_limit());
    if (!can_be_primary_super_slow())
      my_depth = primary_super_limit();
    for (juint i = 0; i < my_depth; i++) {
231
      _primary_supers[i] = sup->_primary_supers[i];
D
duke 已提交
232
    }
233
    Klass* *super_check_cell;
D
duke 已提交
234
    if (my_depth < primary_super_limit()) {
235
      _primary_supers[my_depth] = this;
D
duke 已提交
236 237 238 239 240
      super_check_cell = &_primary_supers[my_depth];
    } else {
      // Overflow of the primary_supers array forces me to be secondary.
      super_check_cell = &_secondary_super_cache;
    }
241
    set_super_check_offset((address)super_check_cell - (address) this);
D
duke 已提交
242 243 244 245 246

#ifdef ASSERT
    {
      juint j = super_depth();
      assert(j == my_depth, "computed accessor gets right answer");
247
      Klass* t = this;
H
hseigel 已提交
248 249 250
      while (!t->can_be_primary_super()) {
        t = t->super();
        j = t->super_depth();
D
duke 已提交
251 252 253 254 255 256
      }
      for (juint j1 = j+1; j1 < primary_super_limit(); j1++) {
        assert(primary_super_of_depth(j1) == NULL, "super list padding");
      }
      while (t != NULL) {
        assert(primary_super_of_depth(j) == t, "super list initialization");
H
hseigel 已提交
257
        t = t->super();
D
duke 已提交
258 259 260 261 262 263 264 265 266 267 268 269 270 271
        --j;
      }
      assert(j == (juint)-1, "correct depth count");
    }
#endif
  }

  if (secondary_supers() == NULL) {
    KlassHandle this_kh (THREAD, this);

    // Now compute the list of secondary supertypes.
    // Secondaries can occasionally be on the super chain,
    // if the inline "_primary_supers" array overflows.
    int extras = 0;
272 273
    Klass* p;
    for (p = super(); !(p == NULL || p->can_be_primary_super()); p = p->super()) {
D
duke 已提交
274 275 276
      ++extras;
    }

277 278
    ResourceMark rm(THREAD);  // need to reclaim GrowableArrays allocated below

D
duke 已提交
279
    // Compute the "real" non-extra secondaries.
280 281 282 283 284
    GrowableArray<Klass*>* secondaries = compute_secondary_supers(extras);
    if (secondaries == NULL) {
      // secondary_supers set by compute_secondary_supers
      return;
    }
D
duke 已提交
285

286 287 288
    GrowableArray<Klass*>* primaries = new GrowableArray<Klass*>(extras);

    for (p = this_kh->super(); !(p == NULL || p->can_be_primary_super()); p = p->super()) {
D
duke 已提交
289 290 291 292 293 294 295 296 297
      int i;                    // Scan for overflow primaries being duplicates of 2nd'arys

      // This happens frequently for very deeply nested arrays: the
      // primary superclass chain overflows into the secondary.  The
      // secondary list contains the element_klass's secondaries with
      // an extra array dimension added.  If the element_klass's
      // secondary list already contains some primary overflows, they
      // (with the extra level of array-ness) will collide with the
      // normal primary superclass overflows.
298 299
      for( i = 0; i < secondaries->length(); i++ ) {
        if( secondaries->at(i) == p )
D
duke 已提交
300
          break;
301
      }
D
duke 已提交
302 303
      if( i < secondaries->length() )
        continue;               // It's a dup, don't put it in
304
      primaries->push(p);
D
duke 已提交
305
    }
306 307 308 309 310 311 312 313 314 315 316
    // Combine the two arrays into a metadata object to pack the array.
    // The primaries are added in the reverse order, then the secondaries.
    int new_length = primaries->length() + secondaries->length();
    Array<Klass*>* s2 = MetadataFactory::new_array<Klass*>(
                                       class_loader_data(), new_length, CHECK);
    int fill_p = primaries->length();
    for (int j = 0; j < fill_p; j++) {
      s2->at_put(j, primaries->pop());  // add primaries in reverse order.
    }
    for( int j = 0; j < secondaries->length(); j++ ) {
      s2->at_put(j+fill_p, secondaries->at(j));  // add secondaries on the end.
D
duke 已提交
317 318 319 320
    }

  #ifdef ASSERT
      // We must not copy any NULL placeholders left over from bootstrap.
321 322
    for (int j = 0; j < s2->length(); j++) {
      assert(s2->at(j) != NULL, "correct bootstrapping order");
D
duke 已提交
323 324 325
    }
  #endif

326
    this_kh->set_secondary_supers(s2);
D
duke 已提交
327 328 329
  }
}

330
GrowableArray<Klass*>* Klass::compute_secondary_supers(int num_extra_slots) {
D
duke 已提交
331
  assert(num_extra_slots == 0, "override for complex klasses");
332 333
  set_secondary_supers(Universe::the_empty_klass_array());
  return NULL;
D
duke 已提交
334 335 336 337
}


Klass* Klass::subklass() const {
H
hseigel 已提交
338
  return _subklass == NULL ? NULL : _subklass;
D
duke 已提交
339 340
}

341 342 343
InstanceKlass* Klass::superklass() const {
  assert(super() == NULL || super()->oop_is_instance(), "must be instance klass");
  return _super == NULL ? NULL : InstanceKlass::cast(_super);
D
duke 已提交
344 345 346
}

Klass* Klass::next_sibling() const {
H
hseigel 已提交
347
  return _next_sibling == NULL ? NULL : _next_sibling;
D
duke 已提交
348 349
}

350 351 352
void Klass::set_subklass(Klass* s) {
  assert(s != this, "sanity check");
  _subklass = s;
D
duke 已提交
353 354
}

355 356 357
void Klass::set_next_sibling(Klass* s) {
  assert(s != this, "sanity check");
  _next_sibling = s;
D
duke 已提交
358 359 360
}

void Klass::append_to_sibling_list() {
361
  debug_only(verify();)
D
duke 已提交
362
  // add ourselves to superklass' subklass list
363
  InstanceKlass* super = superklass();
D
duke 已提交
364
  if (super == NULL) return;        // special case: class Object
365
  assert((!super->is_interface()    // interfaces cannot be supers
D
duke 已提交
366 367
          && (super->superklass() == NULL || !is_interface())),
         "an interface can only be a subklass of Object");
368
  Klass* prev_first_subklass = super->subklass_oop();
D
duke 已提交
369 370 371 372 373
  if (prev_first_subklass != NULL) {
    // set our sibling to be the superklass' previous first subklass
    set_next_sibling(prev_first_subklass);
  }
  // make ourselves the superklass' first subklass
374
  super->set_subklass(this);
375
  debug_only(verify();)
D
duke 已提交
376 377
}

378
bool Klass::is_loader_alive(BoolObjectClosure* is_alive) {
379
#ifdef ASSERT
380 381
  // The class is alive iff the class loader is alive.
  oop loader = class_loader();
382 383 384 385 386 387 388 389 390
  bool loader_alive = (loader == NULL) || is_alive->do_object_b(loader);
#endif // ASSERT

  // The class is alive if it's mirror is alive (which should be marked if the
  // loader is alive) unless it's an anoymous class.
  bool mirror_alive = is_alive->do_object_b(java_mirror());
  assert(!mirror_alive || loader_alive, "loader must be alive if the mirror is"
                        " but not the other way around with anonymous classes");
  return mirror_alive;
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
}

void Klass::clean_weak_klass_links(BoolObjectClosure* is_alive) {
  if (!ClassUnloading) {
    return;
  }

  Klass* root = SystemDictionary::Object_klass();
  Stack<Klass*, mtGC> stack;

  stack.push(root);
  while (!stack.is_empty()) {
    Klass* current = stack.pop();

    assert(current->is_loader_alive(is_alive), "just checking, this should be live");

    // Find and set the first alive subklass
    Klass* sub = current->subklass_oop();
    while (sub != NULL && !sub->is_loader_alive(is_alive)) {
D
duke 已提交
410
#ifndef PRODUCT
411 412
      if (TraceClassUnloading && WizardMode) {
        ResourceMark rm;
413
        tty->print_cr("[Unlinking class (subclass) %s]", sub->external_name());
414
      }
D
duke 已提交
415
#endif
416
      sub = sub->next_sibling_oop();
D
duke 已提交
417
    }
418 419 420 421 422 423 424 425
    current->set_subklass(sub);
    if (sub != NULL) {
      stack.push(sub);
    }

    // Find and set the first alive sibling
    Klass* sibling = current->next_sibling_oop();
    while (sibling != NULL && !sibling->is_loader_alive(is_alive)) {
426 427
      if (TraceClassUnloading && WizardMode) {
        ResourceMark rm;
428
        tty->print_cr("[Unlinking class (sibling) %s]", sibling->external_name());
D
duke 已提交
429
      }
430 431
      sibling = sibling->next_sibling_oop();
    }
432 433 434
    current->set_next_sibling(sibling);
    if (sibling != NULL) {
      stack.push(sibling);
435
    }
436 437 438 439 440 441

    // Clean the implementors list and method data.
    if (current->oop_is_instance()) {
      InstanceKlass* ik = InstanceKlass::cast(current);
      ik->clean_implementors_list(is_alive);
      ik->clean_method_data(is_alive);
D
duke 已提交
442
    }
443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
  }
}

void Klass::klass_update_barrier_set(oop v) {
  record_modified_oops();
}

void Klass::klass_update_barrier_set_pre(void* p, oop v) {
  // This barrier used by G1, where it's used remember the old oop values,
  // so that we don't forget any objects that were live at the snapshot at
  // the beginning. This function is only used when we write oops into
  // Klasses. Since the Klasses are used as roots in G1, we don't have to
  // do anything here.
}

void Klass::klass_oop_store(oop* p, oop v) {
  assert(!Universe::heap()->is_in_reserved((void*)p), "Should store pointer into metadata");
  assert(v == NULL || Universe::heap()->is_in_reserved((void*)v), "Should store pointer to an object");

  // do the store
  if (always_do_update_barrier) {
    klass_oop_store((volatile oop*)p, v);
D
duke 已提交
465
  } else {
466 467 468
    klass_update_barrier_set_pre((void*)p, v);
    *p = v;
    klass_update_barrier_set(v);
D
duke 已提交
469 470 471
  }
}

472 473 474 475 476 477 478 479 480 481 482 483
void Klass::klass_oop_store(volatile oop* p, oop v) {
  assert(!Universe::heap()->is_in_reserved((void*)p), "Should store pointer into metadata");
  assert(v == NULL || Universe::heap()->is_in_reserved((void*)v), "Should store pointer to an object");

  klass_update_barrier_set_pre((void*)p, v);
  OrderAccess::release_store_ptr(p, v);
  klass_update_barrier_set(v);
}

void Klass::oops_do(OopClosure* cl) {
  cl->do_oop(&_java_mirror);
}
D
duke 已提交
484 485

void Klass::remove_unshareable_info() {
486 487 488 489 490 491
  if (!DumpSharedSpaces) {
    // Clean up after OOM during class loading
    if (class_loader_data() != NULL) {
      class_loader_data()->remove_class(this);
    }
  }
D
duke 已提交
492 493
  set_subklass(NULL);
  set_next_sibling(NULL);
494 495 496 497 498 499
  // Clear the java mirror
  set_java_mirror(NULL);
  set_next_link(NULL);

  // Null out class_loader_data because we don't share that yet.
  set_class_loader_data(NULL);
D
duke 已提交
500 501
}

502 503 504 505
void Klass::restore_unshareable_info(TRAPS) {
  ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data();
  // Restore class_loader_data to the null class loader data
  set_class_loader_data(loader_data);
D
duke 已提交
506

507 508 509
  // Add to null class loader list first before creating the mirror
  // (same order as class file parsing)
  loader_data->add_class(this);
510

511 512 513
  // Recreate the class mirror.  The protection_domain is always null for
  // boot loader, for now.
  java_lang_Class::create_mirror(this, Handle(NULL), CHECK);
514
}
515

516
Klass* Klass::array_klass_or_null(int rank) {
D
duke 已提交
517 518 519 520 521 522 523
  EXCEPTION_MARK;
  // No exception can be thrown by array_klass_impl when called with or_null == true.
  // (In anycase, the execption mark will fail if it do so)
  return array_klass_impl(true, rank, THREAD);
}


524
Klass* Klass::array_klass_or_null() {
D
duke 已提交
525 526 527 528 529 530 531
  EXCEPTION_MARK;
  // No exception can be thrown by array_klass_impl when called with or_null == true.
  // (In anycase, the execption mark will fail if it do so)
  return array_klass_impl(true, THREAD);
}


532
Klass* Klass::array_klass_impl(bool or_null, int rank, TRAPS) {
533
  fatal("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
D
duke 已提交
534 535 536 537
  return NULL;
}


538
Klass* Klass::array_klass_impl(bool or_null, TRAPS) {
539
  fatal("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
D
duke 已提交
540 541 542
  return NULL;
}

543 544
oop Klass::class_loader() const { return class_loader_data()->class_loader(); }

D
duke 已提交
545
const char* Klass::external_name() const {
546
  if (oop_is_instance()) {
547
    InstanceKlass* ik = (InstanceKlass*) this;
548
    if (ik->is_anonymous()) {
549
      assert(EnableInvokeDynamic, "");
550 551 552 553 554
      intptr_t hash = 0;
      if (ik->java_mirror() != NULL) {
        // java_mirror might not be created yet, return 0 as hash.
        hash = ik->java_mirror()->identity_hash();
      }
555 556 557 558 559 560 561 562 563 564 565 566 567
      char     hash_buf[40];
      sprintf(hash_buf, "/" UINTX_FORMAT, (uintx)hash);
      size_t   hash_len = strlen(hash_buf);

      size_t result_len = name()->utf8_length();
      char*  result     = NEW_RESOURCE_ARRAY(char, result_len + hash_len + 1);
      name()->as_klass_external_name(result, (int) result_len + 1);
      assert(strlen(result) == result_len, "");
      strcpy(result + result_len, hash_buf);
      assert(strlen(result) == result_len + hash_len, "");
      return result;
    }
  }
568
  if (name() == NULL)  return "<unknown>";
D
duke 已提交
569 570 571 572
  return name()->as_klass_external_name();
}


573 574
const char* Klass::signature_name() const {
  if (name() == NULL)  return "<unknown>";
D
duke 已提交
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
  return name()->as_C_string();
}

// Unless overridden, modifier_flags is 0.
jint Klass::compute_modifier_flags(TRAPS) const {
  return 0;
}

int Klass::atomic_incr_biased_lock_revocation_count() {
  return (int) Atomic::add(1, &_biased_lock_revocation_count);
}

// Unless overridden, jvmti_class_status has no flags set.
jint Klass::jvmti_class_status() const {
  return 0;
}

592

D
duke 已提交
593 594
// Printing

595 596 597 598 599 600 601 602
void Klass::print_on(outputStream* st) const {
  ResourceMark rm;
  // print title
  st->print("%s", internal_name());
  print_address_on(st);
  st->cr();
}

D
duke 已提交
603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
void Klass::oop_print_on(oop obj, outputStream* st) {
  ResourceMark rm;
  // print title
  st->print_cr("%s ", internal_name());
  obj->print_address_on(st);

  if (WizardMode) {
     // print header
     obj->mark()->print_on(st);
  }

  // print class
  st->print(" - klass: ");
  obj->klass()->print_value_on(st);
  st->cr();
}

void Klass::oop_print_value_on(oop obj, outputStream* st) {
  // print title
  ResourceMark rm;              // Cannot print in debug mode without this
  st->print("%s", internal_name());
  obj->print_address_on(st);
}

627 628 629 630 631 632 633 634 635 636 637
#if INCLUDE_SERVICES
// Size Statistics
void Klass::collect_statistics(KlassSizeStats *sz) const {
  sz->_klass_bytes = sz->count(this);
  sz->_mirror_bytes = sz->count(java_mirror());
  sz->_secondary_supers_bytes = sz->count_array(secondary_supers());

  sz->_ro_bytes += sz->_secondary_supers_bytes;
  sz->_rw_bytes += sz->_klass_bytes + sz->_mirror_bytes;
}
#endif // INCLUDE_SERVICES
638

D
duke 已提交
639 640
// Verification

641
void Klass::verify_on(outputStream* st) {
642

643 644
  // This can be expensive, but it is worth checking that this klass is actually
  // in the CLD graph but not in production.
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667
  assert(ClassLoaderDataGraph::contains((address)this), "Should be");

  guarantee(this->is_klass(),"should be klass");

  if (super() != NULL) {
    guarantee(super()->is_klass(), "should be klass");
  }
  if (secondary_super_cache() != NULL) {
    Klass* ko = secondary_super_cache();
    guarantee(ko->is_klass(), "should be klass");
  }
  for ( uint i = 0; i < primary_super_limit(); i++ ) {
    Klass* ko = _primary_supers[i];
    if (ko != NULL) {
      guarantee(ko->is_klass(), "should be klass");
    }
  }

  if (java_mirror() != NULL) {
    guarantee(java_mirror()->is_oop(), "should be instance");
  }
}

D
duke 已提交
668 669 670 671 672 673 674
void Klass::oop_verify_on(oop obj, outputStream* st) {
  guarantee(obj->is_oop(),  "should be oop");
  guarantee(obj->klass()->is_klass(), "klass field is not a klass");
}

#ifndef PRODUCT

675
bool Klass::verify_vtable_index(int i) {
D
duke 已提交
676
  if (oop_is_instance()) {
677 678
    int limit = ((InstanceKlass*)this)->vtable_length()/vtableEntry::size();
    assert(i >= 0 && i < limit, err_msg("index %d out of bounds %d", i, limit));
D
duke 已提交
679
  } else {
680
    assert(oop_is_array(), "Must be");
681 682
    int limit = ((ArrayKlass*)this)->vtable_length()/vtableEntry::size();
    assert(i >= 0 && i < limit, err_msg("index %d out of bounds %d", i, limit));
D
duke 已提交
683
  }
684 685 686 687 688 689 690 691
  return true;
}

bool Klass::verify_itable_index(int i) {
  assert(oop_is_instance(), "");
  int method_count = klassItable::method_count_for_interface(this);
  assert(i >= 0 && i < method_count, "index out of bounds");
  return true;
D
duke 已提交
692 693 694
}

#endif