hotspot/src/share/vm/oops/instanceKlassKlass.cpp
author stefank
Tue, 08 Feb 2011 12:33:19 +0100
changeset 8297 f05d10c1c4b8
parent 8076 96d498ec7ae1
child 8725 8c1e3dd5fe1b
permissions -rw-r--r--
7014851: Remove unused parallel compaction code Summary: Removed. Reviewed-by: jcoomes, brutisso
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
8297
f05d10c1c4b8 7014851: Remove unused parallel compaction code
stefank
parents: 8076
diff changeset
     2
 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    26
#include "classfile/javaClasses.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    27
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    28
#include "gc_implementation/shared/markSweep.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    29
#include "gc_interface/collectedHeap.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    30
#include "interpreter/oopMapCache.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    31
#include "memory/gcLocker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    32
#include "oops/constantPoolOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    33
#include "oops/instanceKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    34
#include "oops/instanceKlassKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    35
#include "oops/instanceRefKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    36
#include "oops/objArrayKlassKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    37
#include "oops/objArrayOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    38
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    39
#include "oops/oop.inline2.hpp"
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    40
#include "oops/symbol.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    41
#include "oops/typeArrayOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    42
#include "prims/jvmtiExport.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    43
#include "runtime/fieldDescriptor.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    44
#ifndef SERIALGC
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    45
#include "gc_implementation/parNew/parOopClosures.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    46
#include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    47
#include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    48
#include "memory/cardTableRS.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    49
#include "oops/oop.pcgc.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6248
diff changeset
    50
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
klassOop instanceKlassKlass::create_klass(TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  instanceKlassKlass o;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  KlassHandle h_this_klass(THREAD, Universe::klassKlassObj());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  KlassHandle k = base_create_klass(h_this_klass, header_size(), o.vtbl_value(), CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  // Make sure size calculation is right
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  assert(k()->size() == align_object_size(header_size()), "wrong size for object");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  java_lang_Class::create_mirror(k, CHECK_NULL); // Allocate mirror
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  return k();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
int instanceKlassKlass::oop_size(oop obj) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  assert(obj->is_klass(), "must be klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  return instanceKlass::cast(klassOop(obj))->object_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
bool instanceKlassKlass::oop_is_parsable(oop obj) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  assert(obj->is_klass(), "must be klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  instanceKlass* ik = instanceKlass::cast(klassOop(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  return (!ik->null_vtbl()) && ik->object_is_parsable();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
void instanceKlassKlass::iterate_c_heap_oops(instanceKlass* ik,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
                                             OopClosure* closure) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  if (ik->oop_map_cache() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
    ik->oop_map_cache()->oop_iterate(closure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  if (ik->jni_ids() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
    ik->jni_ids()->oops_do(closure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
void instanceKlassKlass::oop_follow_contents(oop obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  assert(obj->is_klass(),"must be a klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  instanceKlass* ik = instanceKlass::cast(klassOop(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  ik->follow_static_fields();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
    HandleMark hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
    ik->vtable()->oop_follow_contents();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
    ik->itable()->oop_follow_contents();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  MarkSweep::mark_and_push(ik->adr_array_klasses());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  MarkSweep::mark_and_push(ik->adr_methods());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  MarkSweep::mark_and_push(ik->adr_method_ordering());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  MarkSweep::mark_and_push(ik->adr_local_interfaces());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  MarkSweep::mark_and_push(ik->adr_transitive_interfaces());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  MarkSweep::mark_and_push(ik->adr_fields());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  MarkSweep::mark_and_push(ik->adr_constants());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  MarkSweep::mark_and_push(ik->adr_class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  MarkSweep::mark_and_push(ik->adr_inner_classes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  MarkSweep::mark_and_push(ik->adr_protection_domain());
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   106
  MarkSweep::mark_and_push(ik->adr_host_klass());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  MarkSweep::mark_and_push(ik->adr_signers());
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2332
diff changeset
   108
  MarkSweep::mark_and_push(ik->adr_bootstrap_method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  MarkSweep::mark_and_push(ik->adr_class_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  MarkSweep::mark_and_push(ik->adr_fields_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  MarkSweep::mark_and_push(ik->adr_methods_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  MarkSweep::mark_and_push(ik->adr_methods_parameter_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  MarkSweep::mark_and_push(ik->adr_methods_default_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  // We do not follow adr_implementors() here. It is followed later
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  // in instanceKlass::follow_weak_klass_links()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  klassKlass::oop_follow_contents(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  iterate_c_heap_oops(ik, &MarkSweep::mark_and_push_closure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
#ifndef SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
void instanceKlassKlass::oop_follow_contents(ParCompactionManager* cm,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
                                             oop obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  assert(obj->is_klass(),"must be a klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  instanceKlass* ik = instanceKlass::cast(klassOop(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  ik->follow_static_fields(cm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  ik->vtable()->oop_follow_contents(cm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  ik->itable()->oop_follow_contents(cm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  PSParallelCompact::mark_and_push(cm, ik->adr_array_klasses());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  PSParallelCompact::mark_and_push(cm, ik->adr_methods());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  PSParallelCompact::mark_and_push(cm, ik->adr_method_ordering());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  PSParallelCompact::mark_and_push(cm, ik->adr_local_interfaces());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  PSParallelCompact::mark_and_push(cm, ik->adr_transitive_interfaces());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  PSParallelCompact::mark_and_push(cm, ik->adr_fields());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  PSParallelCompact::mark_and_push(cm, ik->adr_constants());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  PSParallelCompact::mark_and_push(cm, ik->adr_class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  PSParallelCompact::mark_and_push(cm, ik->adr_inner_classes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  PSParallelCompact::mark_and_push(cm, ik->adr_protection_domain());
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   144
  PSParallelCompact::mark_and_push(cm, ik->adr_host_klass());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  PSParallelCompact::mark_and_push(cm, ik->adr_signers());
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2332
diff changeset
   146
  PSParallelCompact::mark_and_push(cm, ik->adr_bootstrap_method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  PSParallelCompact::mark_and_push(cm, ik->adr_class_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  PSParallelCompact::mark_and_push(cm, ik->adr_fields_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  PSParallelCompact::mark_and_push(cm, ik->adr_methods_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  PSParallelCompact::mark_and_push(cm, ik->adr_methods_parameter_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  PSParallelCompact::mark_and_push(cm, ik->adr_methods_default_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // We do not follow adr_implementor() here. It is followed later
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  // in instanceKlass::follow_weak_klass_links()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  klassKlass::oop_follow_contents(cm, obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  iterate_c_heap_oops(ik, &mark_and_push_closure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
#endif // SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
int instanceKlassKlass::oop_oop_iterate(oop obj, OopClosure* blk) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  assert(obj->is_klass(),"must be a klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  instanceKlass* ik = instanceKlass::cast(klassOop(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  // Get size before changing pointers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  // Don't call size() or oop_size() since that is a virtual call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  int size = ik->object_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  ik->iterate_static_fields(blk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  ik->vtable()->oop_oop_iterate(blk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  ik->itable()->oop_oop_iterate(blk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  blk->do_oop(ik->adr_array_klasses());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  blk->do_oop(ik->adr_methods());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  blk->do_oop(ik->adr_method_ordering());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  blk->do_oop(ik->adr_local_interfaces());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  blk->do_oop(ik->adr_transitive_interfaces());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  blk->do_oop(ik->adr_fields());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  blk->do_oop(ik->adr_constants());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  blk->do_oop(ik->adr_class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  blk->do_oop(ik->adr_protection_domain());
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   184
  blk->do_oop(ik->adr_host_klass());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  blk->do_oop(ik->adr_signers());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  blk->do_oop(ik->adr_inner_classes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  for (int i = 0; i < instanceKlass::implementors_limit; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
    blk->do_oop(&ik->adr_implementors()[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  }
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2332
diff changeset
   190
  blk->do_oop(ik->adr_bootstrap_method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  blk->do_oop(ik->adr_class_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  blk->do_oop(ik->adr_fields_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  blk->do_oop(ik->adr_methods_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  blk->do_oop(ik->adr_methods_parameter_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  blk->do_oop(ik->adr_methods_default_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  klassKlass::oop_oop_iterate(obj, blk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  if(ik->oop_map_cache() != NULL) ik->oop_map_cache()->oop_iterate(blk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  return size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
int instanceKlassKlass::oop_oop_iterate_m(oop obj, OopClosure* blk,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
                                           MemRegion mr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  assert(obj->is_klass(),"must be a klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  instanceKlass* ik = instanceKlass::cast(klassOop(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  // Get size before changing pointers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  // Don't call size() or oop_size() since that is a virtual call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  int size = ik->object_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  ik->iterate_static_fields(blk, mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  ik->vtable()->oop_oop_iterate_m(blk, mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  ik->itable()->oop_oop_iterate_m(blk, mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  oop* adr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  adr = ik->adr_array_klasses();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  if (mr.contains(adr)) blk->do_oop(adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  adr = ik->adr_methods();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  if (mr.contains(adr)) blk->do_oop(adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  adr = ik->adr_method_ordering();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  if (mr.contains(adr)) blk->do_oop(adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  adr = ik->adr_local_interfaces();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  if (mr.contains(adr)) blk->do_oop(adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  adr = ik->adr_transitive_interfaces();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  if (mr.contains(adr)) blk->do_oop(adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  adr = ik->adr_fields();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  if (mr.contains(adr)) blk->do_oop(adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  adr = ik->adr_constants();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  if (mr.contains(adr)) blk->do_oop(adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  adr = ik->adr_class_loader();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  if (mr.contains(adr)) blk->do_oop(adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  adr = ik->adr_protection_domain();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  if (mr.contains(adr)) blk->do_oop(adr);
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   235
  adr = ik->adr_host_klass();
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   236
  if (mr.contains(adr)) blk->do_oop(adr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  adr = ik->adr_signers();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  if (mr.contains(adr)) blk->do_oop(adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  adr = ik->adr_inner_classes();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  if (mr.contains(adr)) blk->do_oop(adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  adr = ik->adr_implementors();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  for (int i = 0; i < instanceKlass::implementors_limit; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
    if (mr.contains(&adr[i])) blk->do_oop(&adr[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  }
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2332
diff changeset
   245
  adr = ik->adr_bootstrap_method();
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2332
diff changeset
   246
  if (mr.contains(adr)) blk->do_oop(adr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  adr = ik->adr_class_annotations();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  if (mr.contains(adr)) blk->do_oop(adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  adr = ik->adr_fields_annotations();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  if (mr.contains(adr)) blk->do_oop(adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  adr = ik->adr_methods_annotations();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  if (mr.contains(adr)) blk->do_oop(adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  adr = ik->adr_methods_parameter_annotations();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  if (mr.contains(adr)) blk->do_oop(adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  adr = ik->adr_methods_default_annotations();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  if (mr.contains(adr)) blk->do_oop(adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  klassKlass::oop_oop_iterate_m(obj, blk, mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  if(ik->oop_map_cache() != NULL) ik->oop_map_cache()->oop_iterate(blk, mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  return size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
int instanceKlassKlass::oop_adjust_pointers(oop obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  assert(obj->is_klass(),"must be a klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  instanceKlass* ik = instanceKlass::cast(klassOop(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  ik->adjust_static_fields();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  ik->vtable()->oop_adjust_pointers();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  ik->itable()->oop_adjust_pointers();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  MarkSweep::adjust_pointer(ik->adr_array_klasses());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  MarkSweep::adjust_pointer(ik->adr_methods());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  MarkSweep::adjust_pointer(ik->adr_method_ordering());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  MarkSweep::adjust_pointer(ik->adr_local_interfaces());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  MarkSweep::adjust_pointer(ik->adr_transitive_interfaces());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  MarkSweep::adjust_pointer(ik->adr_fields());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  MarkSweep::adjust_pointer(ik->adr_constants());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
  MarkSweep::adjust_pointer(ik->adr_class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  MarkSweep::adjust_pointer(ik->adr_protection_domain());
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   282
  MarkSweep::adjust_pointer(ik->adr_host_klass());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  MarkSweep::adjust_pointer(ik->adr_signers());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  MarkSweep::adjust_pointer(ik->adr_inner_classes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  for (int i = 0; i < instanceKlass::implementors_limit; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
    MarkSweep::adjust_pointer(&ik->adr_implementors()[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  }
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2332
diff changeset
   288
  MarkSweep::adjust_pointer(ik->adr_bootstrap_method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  MarkSweep::adjust_pointer(ik->adr_class_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  MarkSweep::adjust_pointer(ik->adr_fields_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  MarkSweep::adjust_pointer(ik->adr_methods_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  MarkSweep::adjust_pointer(ik->adr_methods_parameter_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  MarkSweep::adjust_pointer(ik->adr_methods_default_annotations());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  iterate_c_heap_oops(ik, &MarkSweep::adjust_root_pointer_closure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  return klassKlass::oop_adjust_pointers(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
#ifndef SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
void instanceKlassKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  instanceKlass* ik = instanceKlass::cast(klassOop(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  ik->push_static_fields(pm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  oop* loader_addr = ik->adr_class_loader();
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   306
  if (PSScavenge::should_scavenge(loader_addr)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
    pm->claim_or_forward_depth(loader_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  oop* pd_addr = ik->adr_protection_domain();
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   311
  if (PSScavenge::should_scavenge(pd_addr)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
    pm->claim_or_forward_depth(pd_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   315
  oop* hk_addr = ik->adr_host_klass();
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   316
  if (PSScavenge::should_scavenge(hk_addr)) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   317
    pm->claim_or_forward_depth(hk_addr);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   318
  }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   319
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  oop* sg_addr = ik->adr_signers();
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   321
  if (PSScavenge::should_scavenge(sg_addr)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
    pm->claim_or_forward_depth(sg_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
4429
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 3822
diff changeset
   325
  oop* bsm_addr = ik->adr_bootstrap_method();
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 3822
diff changeset
   326
  if (PSScavenge::should_scavenge(bsm_addr)) {
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 3822
diff changeset
   327
    pm->claim_or_forward_depth(bsm_addr);
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 3822
diff changeset
   328
  }
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 3822
diff changeset
   329
6248
2e661807cef0 6962589: remove breadth first scanning code from parallel gc
tonyp
parents: 5547
diff changeset
   330
  klassKlass::oop_push_contents(pm, obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
int instanceKlassKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  assert(obj->is_klass(),"must be a klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  assert(klassOop(obj)->klass_part()->oop_is_instance_slow(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
         "must be instance klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  instanceKlass* ik = instanceKlass::cast(klassOop(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  ik->update_static_fields();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  ik->vtable()->oop_update_pointers(cm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  ik->itable()->oop_update_pointers(cm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  oop* const beg_oop = ik->oop_block_beg();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  oop* const end_oop = ik->oop_block_end();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  for (oop* cur_oop = beg_oop; cur_oop < end_oop; ++cur_oop) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
    PSParallelCompact::adjust_pointer(cur_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  OopClosure* closure = PSParallelCompact::adjust_root_pointer_closure();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  iterate_c_heap_oops(ik, closure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  klassKlass::oop_update_pointers(cm, obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  return ik->object_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
#endif // SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 2570
diff changeset
   358
klassOop
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 2570
diff changeset
   359
instanceKlassKlass::allocate_instance_klass(int vtable_len, int itable_len,
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 2570
diff changeset
   360
                                            int static_field_size,
3694
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
   361
                                            unsigned nonstatic_oop_map_count,
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 2570
diff changeset
   362
                                            ReferenceType rt, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 2570
diff changeset
   364
  const int nonstatic_oop_map_size =
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 2570
diff changeset
   365
    instanceKlass::nonstatic_oop_map_size(nonstatic_oop_map_count);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  int size = instanceKlass::object_size(align_object_offset(vtable_len) + align_object_offset(itable_len) + static_field_size + nonstatic_oop_map_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  // Allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  KlassHandle h_this_klass(THREAD, as_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  KlassHandle k;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  if (rt == REF_NONE) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
    // regular klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
    instanceKlass o;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
    k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
    // reference klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
    instanceRefKlass o;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
    k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
    No_Safepoint_Verifier no_safepoint; // until k becomes parsable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
    instanceKlass* ik = (instanceKlass*) k()->klass_part();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
    assert(!k()->is_parsable(), "not expecting parsability yet.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
    // The sizes of these these three variables are used for determining the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
    // size of the instanceKlassOop. It is critical that these are set to the right
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
    // sizes before the first GC, i.e., when we allocate the mirror.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
    ik->set_vtable_length(vtable_len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
    ik->set_itable_length(itable_len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
    ik->set_static_field_size(static_field_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
    ik->set_nonstatic_oop_map_size(nonstatic_oop_map_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
    assert(k()->size() == size, "wrong size for object");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
    ik->set_array_klasses(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
    ik->set_methods(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
    ik->set_method_ordering(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
    ik->set_local_interfaces(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
    ik->set_transitive_interfaces(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
    ik->init_implementor();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
    ik->set_fields(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
    ik->set_constants(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
    ik->set_class_loader(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
    ik->set_protection_domain(NULL);
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   404
    ik->set_host_klass(NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
    ik->set_signers(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
    ik->set_source_file_name(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
    ik->set_source_debug_extension(NULL);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   408
    ik->set_source_debug_extension(NULL);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   409
    ik->set_array_name(NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
    ik->set_inner_classes(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
    ik->set_static_oop_field_size(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
    ik->set_nonstatic_field_size(0);
3822
388b0393a042 6879572: SA fails _is_marked_dependent not found
acorn
parents: 3821
diff changeset
   413
    ik->set_is_marked_dependent(false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
    ik->set_init_state(instanceKlass::allocated);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
    ik->set_init_thread(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
    ik->set_reference_type(rt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
    ik->set_oop_map_cache(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
    ik->set_jni_ids(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
    ik->set_osr_nmethods_head(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
    ik->set_breakpoints(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
    ik->init_previous_versions();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
    ik->set_generic_signature(NULL);
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2332
diff changeset
   423
    ik->set_bootstrap_method(NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
    ik->release_set_methods_jmethod_ids(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
    ik->release_set_methods_cached_itable_indices(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
    ik->set_class_annotations(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
    ik->set_fields_annotations(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
    ik->set_methods_annotations(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
    ik->set_methods_parameter_annotations(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
    ik->set_methods_default_annotations(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
    ik->set_enclosing_method_indices(0, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
    ik->set_jvmti_cached_class_field_map(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
    ik->set_initial_method_idnum(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
    assert(k()->is_parsable(), "should be parsable here.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
    // initialize the non-header words to zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
    intptr_t* p = (intptr_t*)k();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
    for (int index = instanceKlass::header_size(); index < size; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
      p[index] = NULL_WORD;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
    // To get verify to work - must be set to partial loaded before first GC point.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
    k()->set_partially_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  // GC can happen here
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  java_lang_Class::create_mirror(k, CHECK_NULL); // Allocate mirror
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  return k();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
// Printing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   457
#define BULLET  " - "
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   458
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
static const char* state_names[] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  "unparseable_by_gc", "allocated", "loaded", "linked", "being_initialized", "fully_initialized", "initialization_error"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
void instanceKlassKlass::oop_print_on(oop obj, outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  assert(obj->is_klass(), "must be klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  instanceKlass* ik = instanceKlass::cast(klassOop(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  klassKlass::oop_print_on(obj, st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   469
  st->print(BULLET"instance size:     %d", ik->size_helper());                        st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   470
  st->print(BULLET"klass size:        %d", ik->object_size());                        st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   471
  st->print(BULLET"access:            "); ik->access_flags().print_on(st);            st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   472
  st->print(BULLET"state:             "); st->print_cr(state_names[ik->_init_state]);
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   473
  st->print(BULLET"name:              "); ik->name()->print_value_on(st);             st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   474
  st->print(BULLET"super:             "); ik->super()->print_value_on(st);            st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   475
  st->print(BULLET"sub:               ");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
  Klass* sub = ik->subklass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  int n;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  for (n = 0; sub != NULL; n++, sub = sub->next_sibling()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
    if (n < MaxSubklassPrintSize) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
      sub->as_klassOop()->print_value_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
      st->print("   ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  if (n >= MaxSubklassPrintSize) st->print("(%d more klasses...)", n - MaxSubklassPrintSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  if (ik->is_interface()) {
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   488
    st->print_cr(BULLET"nof implementors:  %d", ik->nof_implementors());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
    int print_impl = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
    for (int i = 0; i < instanceKlass::implementors_limit; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
      if (ik->implementor(i) != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
        if (++print_impl == 1)
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   493
          st->print_cr(BULLET"implementor:    ");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
        st->print("   ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
        ik->implementor(i)->print_value_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
    if (print_impl > 0)  st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   501
  st->print(BULLET"arrays:            "); ik->array_klasses()->print_value_on(st);     st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   502
  st->print(BULLET"methods:           "); ik->methods()->print_value_on(st);           st->cr();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  if (Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
    objArrayOop methods = ik->methods();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
    for(int i = 0; i < methods->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
      tty->print("%d : ", i); methods->obj_at(i)->print_value(); tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  }
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   509
  st->print(BULLET"method ordering:   "); ik->method_ordering()->print_value_on(st);       st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   510
  st->print(BULLET"local interfaces:  "); ik->local_interfaces()->print_value_on(st);      st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   511
  st->print(BULLET"trans. interfaces: "); ik->transitive_interfaces()->print_value_on(st); st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   512
  st->print(BULLET"constants:         "); ik->constants()->print_value_on(st);         st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   513
  st->print(BULLET"class loader:      "); ik->class_loader()->print_value_on(st);      st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   514
  st->print(BULLET"protection domain: "); ik->protection_domain()->print_value_on(st); st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   515
  st->print(BULLET"host class:        "); ik->host_klass()->print_value_on(st);        st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   516
  st->print(BULLET"signers:           "); ik->signers()->print_value_on(st);           st->cr();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  if (ik->source_file_name() != NULL) {
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   518
    st->print(BULLET"source file:       ");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
    ik->source_file_name()->print_value_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
    st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  if (ik->source_debug_extension() != NULL) {
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   523
    st->print(BULLET"source debug extension:       ");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
    ik->source_debug_extension()->print_value_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
    st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
    ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
    // PreviousVersionInfo objects returned via PreviousVersionWalker
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
    // contain a GrowableArray of handles. We have to clean up the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
    // GrowableArray _after_ the PreviousVersionWalker destructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
    // has destroyed the handles.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
    {
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   535
      bool have_pv = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
      PreviousVersionWalker pvw(ik);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
      for (PreviousVersionInfo * pv_info = pvw.next_previous_version();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
           pv_info != NULL; pv_info = pvw.next_previous_version()) {
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   539
        if (!have_pv)
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   540
          st->print(BULLET"previous version:  ");
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   541
        have_pv = true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
        pv_info->prev_constant_pool_handle()()->print_value_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
      }
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   544
      if (have_pv)  st->cr();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
    } // pvw is cleaned up
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
  } // rm is cleaned up
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2332
diff changeset
   548
  if (ik->bootstrap_method() != NULL) {
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2332
diff changeset
   549
    st->print(BULLET"bootstrap method:  ");
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2332
diff changeset
   550
    ik->bootstrap_method()->print_value_on(st);
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2332
diff changeset
   551
    st->cr();
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2332
diff changeset
   552
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  if (ik->generic_signature() != NULL) {
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   554
    st->print(BULLET"generic signature: ");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
    ik->generic_signature()->print_value_on(st);
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   556
    st->cr();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  }
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   558
  st->print(BULLET"inner classes:     "); ik->inner_classes()->print_value_on(st);     st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   559
  st->print(BULLET"java mirror:       "); ik->java_mirror()->print_value_on(st);       st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   560
  st->print(BULLET"vtable length      %d  (start addr: " INTPTR_FORMAT ")", ik->vtable_length(), ik->start_of_vtable());  st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   561
  st->print(BULLET"itable length      %d (start addr: " INTPTR_FORMAT ")", ik->itable_length(), ik->start_of_itable()); st->cr();
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   562
  st->print_cr(BULLET"---- static fields (%d words):", ik->static_field_size());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
  FieldPrinter print_static_field(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  ik->do_local_static_fields(&print_static_field);
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   565
  st->print_cr(BULLET"---- non-static fields (%d words):", ik->nonstatic_field_size());
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   566
  FieldPrinter print_nonstatic_field(st);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  ik->do_nonstatic_fields(&print_nonstatic_field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   569
  st->print(BULLET"static oop maps:     ");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
  if (ik->static_oop_field_size() > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
    int first_offset = ik->offset_of_static_fields();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
    st->print("%d-%d", first_offset, first_offset + ik->static_oop_field_size() - 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 1550
diff changeset
   576
  st->print(BULLET"non-static oop maps: ");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
  OopMapBlock* map     = ik->start_of_nonstatic_oop_maps();
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 2570
diff changeset
   578
  OopMapBlock* end_map = map + ik->nonstatic_oop_map_count();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
  while (map < end_map) {
3693
af387bf37e8d 6861660: OopMapBlock count/size confusion
jcoomes
parents: 2570
diff changeset
   580
    st->print("%d-%d ", map->offset(), map->offset() + heapOopSize*(map->count() - 1));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
    map++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
4584
e2a449e8cc6f 6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents: 4429
diff changeset
   586
#endif //PRODUCT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
void instanceKlassKlass::oop_print_value_on(oop obj, outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
  assert(obj->is_klass(), "must be klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  instanceKlass* ik = instanceKlass::cast(klassOop(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  ik->name()->print_value_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
const char* instanceKlassKlass::internal_name() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
  return "{instance class}";
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
// Verification
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
class VerifyFieldClosure: public OopClosure {
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   601
 protected:
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   602
  template <class T> void do_oop_work(T* p) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
    guarantee(Universe::heap()->is_in(p), "should be in heap");
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   604
    oop obj = oopDesc::load_decode_heap_oop(p);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   605
    guarantee(obj->is_oop_or_null(), "should be in heap");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  }
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   607
 public:
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   608
  virtual void do_oop(oop* p)       { VerifyFieldClosure::do_oop_work(p); }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   609
  virtual void do_oop(narrowOop* p) { VerifyFieldClosure::do_oop_work(p); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
void instanceKlassKlass::oop_verify_on(oop obj, outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  klassKlass::oop_verify_on(obj, st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
  if (!obj->partially_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
    Thread *thread = Thread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
    instanceKlass* ik = instanceKlass::cast(klassOop(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
    // Avoid redundant verifies
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
    if (ik->_verify_count == Universe::verify_count()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
    ik->_verify_count = Universe::verify_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
    // Verify that klass is present in SystemDictionary
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   624
    if (ik->is_loaded() && !ik->is_anonymous()) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   625
      Symbol* h_name = ik->name();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
      Handle h_loader (thread, ik->class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
      Handle h_obj(thread, obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
      SystemDictionary::verify_obj_klass_present(h_obj, h_name, h_loader);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
    // Verify static fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
    VerifyFieldClosure blk;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
    ik->iterate_static_fields(&blk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
    // Verify vtables
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
    if (ik->is_linked()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
      ResourceMark rm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
      // $$$ This used to be done only for m/s collections.  Doing it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
      // always seemed a valid generalization.  (DLD -- 6/00)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
      ik->vtable()->verify(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
    // Verify oop map cache
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
    if (ik->oop_map_cache() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
      ik->oop_map_cache()->verify();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
    // Verify first subklass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
    if (ik->subklass_oop() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
      guarantee(ik->subklass_oop()->is_perm(),  "should be in permspace");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
      guarantee(ik->subklass_oop()->is_klass(), "should be klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
    // Verify siblings
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
    klassOop super = ik->super();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
    Klass* sib = ik->next_sibling();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
    int sib_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
    while (sib != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
      if (sib == ik) {
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 4584
diff changeset
   660
        fatal(err_msg("subclass cycle of length %d", sib_count));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
      if (sib_count >= 100000) {
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 4584
diff changeset
   663
        fatal(err_msg("suspiciously long subclass list %d", sib_count));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
      guarantee(sib->as_klassOop()->is_klass(), "should be klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
      guarantee(sib->as_klassOop()->is_perm(),  "should be in permspace");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
      guarantee(sib->super() == super, "siblings should have same superklass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
      sib = sib->next_sibling();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
    // Verify implementor fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
    bool saw_null_impl = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
    for (int i = 0; i < instanceKlass::implementors_limit; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
      klassOop im = ik->implementor(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
      if (im == NULL) { saw_null_impl = true; continue; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
      guarantee(!saw_null_impl, "non-nulls must preceded all nulls");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
      guarantee(ik->is_interface(), "only interfaces should have implementor set");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
      guarantee(i < ik->nof_implementors(), "should only have one implementor");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
      guarantee(im->is_perm(),  "should be in permspace");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
      guarantee(im->is_klass(), "should be klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
      guarantee(!Klass::cast(klassOop(im))->is_interface(), "implementors cannot be interfaces");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
    // Verify local interfaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
    objArrayOop local_interfaces = ik->local_interfaces();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
    guarantee(local_interfaces->is_perm(),          "should be in permspace");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
    guarantee(local_interfaces->is_objArray(),      "should be obj array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
    int j;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
    for (j = 0; j < local_interfaces->length(); j++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
      oop e = local_interfaces->obj_at(j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
      guarantee(e->is_klass() && Klass::cast(klassOop(e))->is_interface(), "invalid local interface");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
    // Verify transitive interfaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
    objArrayOop transitive_interfaces = ik->transitive_interfaces();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
    guarantee(transitive_interfaces->is_perm(),          "should be in permspace");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
    guarantee(transitive_interfaces->is_objArray(),      "should be obj array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
    for (j = 0; j < transitive_interfaces->length(); j++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
      oop e = transitive_interfaces->obj_at(j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
      guarantee(e->is_klass() && Klass::cast(klassOop(e))->is_interface(), "invalid transitive interface");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
    // Verify methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
    objArrayOop methods = ik->methods();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
    guarantee(methods->is_perm(),              "should be in permspace");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
    guarantee(methods->is_objArray(),          "should be obj array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
    for (j = 0; j < methods->length(); j++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
      guarantee(methods->obj_at(j)->is_method(), "non-method in methods array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
    for (j = 0; j < methods->length() - 1; j++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
      methodOop m1 = methodOop(methods->obj_at(j));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
      methodOop m2 = methodOop(methods->obj_at(j + 1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
      guarantee(m1->name()->fast_compare(m2->name()) <= 0, "methods not sorted correctly");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
    // Verify method ordering
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
    typeArrayOop method_ordering = ik->method_ordering();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
    guarantee(method_ordering->is_perm(),              "should be in permspace");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
    guarantee(method_ordering->is_typeArray(),         "should be type array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
    int length = method_ordering->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
    if (JvmtiExport::can_maintain_original_method_order()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
      guarantee(length == methods->length(),           "invalid method ordering length");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
      jlong sum = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
      for (j = 0; j < length; j++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
        int original_index = method_ordering->int_at(j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
        guarantee(original_index >= 0 && original_index < length, "invalid method ordering index");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
        sum += original_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
      // Verify sum of indices 0,1,...,length-1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
      guarantee(sum == ((jlong)length*(length-1))/2,   "invalid method ordering sum");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
      guarantee(length == 0,                           "invalid method ordering length");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
    // Verify JNI static field identifiers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
    if (ik->jni_ids() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
      ik->jni_ids()->verify(ik->as_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
    // Verify other fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
    if (ik->array_klasses() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
      guarantee(ik->array_klasses()->is_perm(),      "should be in permspace");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
      guarantee(ik->array_klasses()->is_klass(),     "should be klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
    guarantee(ik->fields()->is_perm(),               "should be in permspace");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
    guarantee(ik->fields()->is_typeArray(),          "should be type array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
    guarantee(ik->constants()->is_perm(),            "should be in permspace");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
    guarantee(ik->constants()->is_constantPool(),    "should be constant pool");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
    guarantee(ik->inner_classes()->is_perm(),        "should be in permspace");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
    guarantee(ik->inner_classes()->is_typeArray(),   "should be type array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
    if (ik->protection_domain() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
      guarantee(ik->protection_domain()->is_oop(),  "should be oop");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
    }
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   754
    if (ik->host_klass() != NULL) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   755
      guarantee(ik->host_klass()->is_oop(),  "should be oop");
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   756
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
    if (ik->signers() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
      guarantee(ik->signers()->is_objArray(),       "should be obj array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
    if (ik->class_annotations() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
      guarantee(ik->class_annotations()->is_typeArray(), "should be type array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
    if (ik->fields_annotations() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
      guarantee(ik->fields_annotations()->is_objArray(), "should be obj array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
    if (ik->methods_annotations() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
      guarantee(ik->methods_annotations()->is_objArray(), "should be obj array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
    if (ik->methods_parameter_annotations() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
      guarantee(ik->methods_parameter_annotations()->is_objArray(), "should be obj array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
    if (ik->methods_default_annotations() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
      guarantee(ik->methods_default_annotations()->is_objArray(), "should be obj array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
bool instanceKlassKlass::oop_partially_loaded(oop obj) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
  assert(obj->is_klass(), "object must be klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
  instanceKlass* ik = instanceKlass::cast(klassOop(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
  assert(ik->oop_is_instance(), "object must be instanceKlass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
  return ik->transitive_interfaces() == (objArrayOop) obj;   // Check whether transitive_interfaces points to self
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
// The transitive_interfaces is the last field set when loading an object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
void instanceKlassKlass::oop_set_partially_loaded(oop obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
  assert(obj->is_klass(), "object must be klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
  instanceKlass* ik = instanceKlass::cast(klassOop(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
  // Set the layout helper to a place-holder value, until fuller initialization.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
  // (This allows asserts in oop_is_instance to succeed.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
  ik->set_layout_helper(Klass::instance_layout_helper(0, true));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
  assert(ik->oop_is_instance(), "object must be instanceKlass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
  assert(ik->transitive_interfaces() == NULL, "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
  ik->set_transitive_interfaces((objArrayOop) obj);   // Temporarily set transitive_interfaces to point to self
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
}