src/hotspot/share/oops/klass.cpp
author coleenp
Wed, 06 Jun 2018 10:45:40 -0400
changeset 50429 83aec1d357d4
parent 50113 caf115bb98ad
child 50532 a18c60527166
child 56726 3a9b7a1f9197
permissions -rw-r--r--
8204301: Make OrderAccess functions available to hpp rather than inline.hpp files Summary: move orderAccess.inline.hpp into orderAccess.hpp and remove os.hpp inclusion and conditional os::is_MP() for fence on x86 platforms Reviewed-by: dholmes, hseigel
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
49056
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
     2
 * Copyright (c) 1997, 2018, 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: 4584
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4584
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: 4584
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: 6176
diff changeset
    25
#include "precompiled.hpp"
49824
e242740a92b8 8201556: Disallow reading oops in ClassLoaderData if unloading
coleenp
parents: 49821
diff changeset
    26
#include "classfile/classLoaderData.inline.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30150
diff changeset
    27
#include "classfile/dictionary.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    28
#include "classfile/javaClasses.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    29
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    30
#include "classfile/vmSymbols.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30150
diff changeset
    31
#include "gc/shared/collectedHeap.inline.hpp"
35917
463d67f86eaa 8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents: 35900
diff changeset
    32
#include "logging/log.hpp"
15437
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
    33
#include "memory/heapInspection.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    34
#include "memory/metadataFactory.hpp"
46746
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
    35
#include "memory/metaspaceClosure.hpp"
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
    36
#include "memory/metaspaceShared.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    37
#include "memory/oopFactory.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    38
#include "memory/resourceArea.hpp"
49592
77fb0be7d19f 8199946: Move load/store and encode/decode out of oopDesc
stefank
parents: 49393
diff changeset
    39
#include "oops/compressedOops.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    40
#include "oops/instanceKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    41
#include "oops/klass.inline.hpp"
29081
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 28731
diff changeset
    42
#include "oops/oop.inline.hpp"
49816
a3e79f97e86b 8200555: OopHandle should use Access API
coleenp
parents: 49786
diff changeset
    43
#include "oops/oopHandle.inline.hpp"
40655
9f644073d3a0 8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents: 39400
diff changeset
    44
#include "runtime/atomic.hpp"
49393
93fe2fc5c093 8199472: Fix non-PCH build after JDK-8199319
simonis
parents: 49368
diff changeset
    45
#include "runtime/handles.inline.hpp"
50429
83aec1d357d4 8204301: Make OrderAccess functions available to hpp rather than inline.hpp files
coleenp
parents: 50113
diff changeset
    46
#include "runtime/orderAccess.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14588
diff changeset
    47
#include "utilities/macros.hpp"
29702
9ed339a5e096 8075809: Add missing includes of stack.inline.hpp
stefank
parents: 29081
diff changeset
    48
#include "utilities/stack.inline.hpp"
47580
96392e113a0a 8186777: Make Klass::_java_mirror an OopHandle
coleenp
parents: 47216
diff changeset
    49
96392e113a0a 8186777: Make Klass::_java_mirror an OopHandle
coleenp
parents: 47216
diff changeset
    50
void Klass::set_java_mirror(Handle m) {
96392e113a0a 8186777: Make Klass::_java_mirror an OopHandle
coleenp
parents: 47216
diff changeset
    51
  assert(!m.is_null(), "New mirror should never be null.");
96392e113a0a 8186777: Make Klass::_java_mirror an OopHandle
coleenp
parents: 47216
diff changeset
    52
  assert(_java_mirror.resolve() == NULL, "should only be used to initialize mirror");
96392e113a0a 8186777: Make Klass::_java_mirror an OopHandle
coleenp
parents: 47216
diff changeset
    53
  _java_mirror = class_loader_data()->add_handle(m);
96392e113a0a 8186777: Make Klass::_java_mirror an OopHandle
coleenp
parents: 47216
diff changeset
    54
}
96392e113a0a 8186777: Make Klass::_java_mirror an OopHandle
coleenp
parents: 47216
diff changeset
    55
96392e113a0a 8186777: Make Klass::_java_mirror an OopHandle
coleenp
parents: 47216
diff changeset
    56
oop Klass::java_mirror() const {
96392e113a0a 8186777: Make Klass::_java_mirror an OopHandle
coleenp
parents: 47216
diff changeset
    57
  return _java_mirror.resolve();
96392e113a0a 8186777: Make Klass::_java_mirror an OopHandle
coleenp
parents: 47216
diff changeset
    58
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
35544
c7ec868d0923 8133612: new clone logic added in 8042235 is missing from compiler intrinsics
vlivanov
parents: 34666
diff changeset
    60
bool Klass::is_cloneable() const {
c7ec868d0923 8133612: new clone logic added in 8042235 is missing from compiler intrinsics
vlivanov
parents: 34666
diff changeset
    61
  return _access_flags.is_cloneable_fast() ||
c7ec868d0923 8133612: new clone logic added in 8042235 is missing from compiler intrinsics
vlivanov
parents: 34666
diff changeset
    62
         is_subtype_of(SystemDictionary::Cloneable_klass());
c7ec868d0923 8133612: new clone logic added in 8042235 is missing from compiler intrinsics
vlivanov
parents: 34666
diff changeset
    63
}
c7ec868d0923 8133612: new clone logic added in 8042235 is missing from compiler intrinsics
vlivanov
parents: 34666
diff changeset
    64
c7ec868d0923 8133612: new clone logic added in 8042235 is missing from compiler intrinsics
vlivanov
parents: 34666
diff changeset
    65
void Klass::set_is_cloneable() {
49786
7444101401b2 8192025: Less referential references
kbarrett
parents: 49592
diff changeset
    66
  if (name() == vmSymbols::java_lang_invoke_MemberName()) {
35544
c7ec868d0923 8133612: new clone logic added in 8042235 is missing from compiler intrinsics
vlivanov
parents: 34666
diff changeset
    67
    assert(is_final(), "no subclasses allowed");
c7ec868d0923 8133612: new clone logic added in 8042235 is missing from compiler intrinsics
vlivanov
parents: 34666
diff changeset
    68
    // MemberName cloning should not be intrinsified and always happen in JVM_Clone.
49786
7444101401b2 8192025: Less referential references
kbarrett
parents: 49592
diff changeset
    69
  } else if (is_instance_klass() && InstanceKlass::cast(this)->reference_type() != REF_NONE) {
7444101401b2 8192025: Less referential references
kbarrett
parents: 49592
diff changeset
    70
    // Reference cloning should not be intrinsified and always happen in JVM_Clone.
7444101401b2 8192025: Less referential references
kbarrett
parents: 49592
diff changeset
    71
  } else {
7444101401b2 8192025: Less referential references
kbarrett
parents: 49592
diff changeset
    72
    _access_flags.set_is_cloneable_fast();
35544
c7ec868d0923 8133612: new clone logic added in 8042235 is missing from compiler intrinsics
vlivanov
parents: 34666
diff changeset
    73
  }
c7ec868d0923 8133612: new clone logic added in 8042235 is missing from compiler intrinsics
vlivanov
parents: 34666
diff changeset
    74
}
c7ec868d0923 8133612: new clone logic added in 8042235 is missing from compiler intrinsics
vlivanov
parents: 34666
diff changeset
    75
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    76
void Klass::set_name(Symbol* n) {
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    77
  _name = n;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    78
  if (_name != NULL) _name->increment_refcount();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    79
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
17370
59a0620561fa 8003557: NPG: Klass* const k should be const Klass* k.
minqi
parents: 16352
diff changeset
    81
bool Klass::is_subclass_of(const Klass* k) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  // Run up the super chain and check
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    83
  if (this == k) return true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    85
  Klass* t = const_cast<Klass*>(this)->super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  while (t != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
    if (t == k) return true;
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14078
diff changeset
    89
    t = t->super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    94
bool Klass::search_secondary_supers(Klass* k) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  // Put some extra logic here out-of-line, before the search proper.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  // This cuts down the size of the inline method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  // This is necessary, since I am never in my own secondary_super list.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    99
  if (this == k)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  // Scan the array-of-objects for a match
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  int cnt = secondary_supers()->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  for (int i = 0; i < cnt; i++) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   104
    if (secondary_supers()->at(i) == k) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
      ((Klass*)this)->set_secondary_super_cache(k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
// Return self, except for abstract classes with exactly 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
// implementor.  Then return the 1 concrete implementation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
Klass *Klass::up_cast_abstract() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  Klass *r = this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  while( r->is_abstract() ) {   // Receiver is abstract?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
    Klass *s = r->subklass();   // Check for exactly 1 subklass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
    if( !s || s->next_sibling() ) // Oops; wrong count; give up
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
      return this;              // Return 'this' as a no-progress flag
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
    r = s;                    // Loop till find concrete class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  return r;                   // Return the 1 concrete class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 1550
diff changeset
   125
// Find LCA in class hierarchy
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
Klass *Klass::LCA( Klass *k2 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  Klass *k1 = this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  while( 1 ) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   129
    if( k1->is_subtype_of(k2) ) return k2;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   130
    if( k2->is_subtype_of(k1) ) return k1;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   131
    k1 = k1->super();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   132
    k2 = k2->super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
void Klass::check_valid_for_instantiation(bool throwError, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  THROW_MSG(throwError ? vmSymbols::java_lang_InstantiationError()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
            : vmSymbols::java_lang_InstantiationException(), external_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
void Klass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  THROW(vmSymbols::java_lang_ArrayStoreException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
void Klass::initialize(TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   153
bool Klass::compute_is_subtype_of(Klass* k) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  assert(k->is_klass(), "argument must be a class");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  return is_subclass_of(k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
27020
a7c8010446c2 8036805: Correct linker method lookup.
lfoltan
parents: 26135
diff changeset
   158
Klass* Klass::find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const {
a7c8010446c2 8036805: Correct linker method lookup.
lfoltan
parents: 26135
diff changeset
   159
#ifdef ASSERT
a7c8010446c2 8036805: Correct linker method lookup.
lfoltan
parents: 26135
diff changeset
   160
  tty->print_cr("Error: find_field called on a klass oop."
a7c8010446c2 8036805: Correct linker method lookup.
lfoltan
parents: 26135
diff changeset
   161
                " Likely error: reflection method does not correctly"
a7c8010446c2 8036805: Correct linker method lookup.
lfoltan
parents: 26135
diff changeset
   162
                " wrap return value in a mirror object.");
a7c8010446c2 8036805: Correct linker method lookup.
lfoltan
parents: 26135
diff changeset
   163
#endif
a7c8010446c2 8036805: Correct linker method lookup.
lfoltan
parents: 26135
diff changeset
   164
  ShouldNotReachHere();
a7c8010446c2 8036805: Correct linker method lookup.
lfoltan
parents: 26135
diff changeset
   165
  return NULL;
a7c8010446c2 8036805: Correct linker method lookup.
lfoltan
parents: 26135
diff changeset
   166
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   168
Method* Klass::uncached_lookup_method(const Symbol* name, const Symbol* signature, OverpassLookupMode overpass_mode) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  tty->print_cr("Error: uncached_lookup_method called on a klass oop."
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
                " Likely error: reflection method does not correctly"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
                " wrap return value in a mirror object.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
19696
bd5a0131bde1 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents: 18687
diff changeset
   178
void* Klass::operator new(size_t size, ClassLoaderData* loader_data, size_t word_size, TRAPS) throw() {
46746
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   179
  return Metaspace::allocate(loader_data, word_size, MetaspaceObj::ClassType, THREAD);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   180
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   181
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   182
// "Normal" instantiation is preceeded by a MetaspaceObj allocation
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   183
// which zeros out memory - calloc equivalent.
46324
8764956ec928 8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents: 46271
diff changeset
   184
// The constructor is also used from CppVtableCloner,
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   185
// which doesn't zero out the memory before calling the constructor.
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   186
// Need to set the _java_mirror field explicitly to not hit an assert that the field
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   187
// should be NULL before setting it.
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   188
Klass::Klass() : _prototype_header(markOopDesc::prototype()),
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   189
                 _shared_class_path_index(-1),
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   190
                 _java_mirror(NULL) {
49329
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   191
  CDS_ONLY(_shared_class_flags = 0;)
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   192
  CDS_JAVA_HEAP_ONLY(_archived_mirror = 0;)
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   193
  _primary_supers[0] = this;
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   194
  set_super_check_offset(in_bytes(primary_supers_offset()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
jint Klass::array_layout_helper(BasicType etype) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  assert(etype >= T_BOOLEAN && etype <= T_OBJECT, "valid etype");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  // Note that T_ARRAY is not allowed here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  int  hsize = arrayOopDesc::base_offset_in_bytes(etype);
202
dc13bf0e5d5d 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents: 1
diff changeset
   201
  int  esize = type2aelembytes(etype);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  bool isobj = (etype == T_OBJECT);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  int  tag   =  isobj ? _lh_array_tag_obj_value : _lh_array_tag_type_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  int lh = array_layout_helper(tag, hsize, etype, exact_log2(esize));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  assert(lh < (int)_lh_neutral_value, "must look like an array layout");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   207
  assert(layout_helper_is_array(lh), "correct kind");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  assert(layout_helper_is_objArray(lh) == isobj, "correct kind");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  assert(layout_helper_is_typeArray(lh) == !isobj, "correct kind");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  assert(layout_helper_header_size(lh) == hsize, "correct decode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  assert(layout_helper_element_type(lh) == etype, "correct decode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  assert(1 << layout_helper_log2_element_size(lh) == esize, "correct decode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  return lh;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
bool Klass::can_be_primary_super_slow() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  if (super() == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
    return true;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   220
  else if (super()->super_depth() >= primary_super_limit()-1)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
49948
ff8dbb56740a 8200466: Revisit the setting of _transitive_interfaces in InstanceKlass
ccheung
parents: 49824
diff changeset
   226
void Klass::initialize_supers(Klass* k, Array<Klass*>* transitive_interfaces, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  if (FastSuperclassLimit == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
    // None of the other machinery matters.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
    set_super(k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  if (k == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
    set_super(NULL);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   234
    _primary_supers[0] = this;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
    assert(super_depth() == 0, "Object must already be initialized properly");
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4094
diff changeset
   236
  } else if (k != super() || k == SystemDictionary::Object_klass()) {
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4094
diff changeset
   237
    assert(super() == NULL || super() == SystemDictionary::Object_klass(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
           "initialize this only once to a non-trivial value");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
    set_super(k);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   240
    Klass* sup = k;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
    int sup_depth = sup->super_depth();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
    juint my_depth  = MIN2(sup_depth + 1, (int)primary_super_limit());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
    if (!can_be_primary_super_slow())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
      my_depth = primary_super_limit();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
    for (juint i = 0; i < my_depth; i++) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   246
      _primary_supers[i] = sup->_primary_supers[i];
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   248
    Klass* *super_check_cell;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
    if (my_depth < primary_super_limit()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   250
      _primary_supers[my_depth] = this;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
      super_check_cell = &_primary_supers[my_depth];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
      // Overflow of the primary_supers array forces me to be secondary.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
      super_check_cell = &_secondary_super_cache;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   256
    set_super_check_offset((address)super_check_cell - (address) this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
      juint j = super_depth();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
      assert(j == my_depth, "computed accessor gets right answer");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   262
      Klass* t = this;
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14078
diff changeset
   263
      while (!t->can_be_primary_super()) {
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14078
diff changeset
   264
        t = t->super();
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14078
diff changeset
   265
        j = t->super_depth();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
      for (juint j1 = j+1; j1 < primary_super_limit(); j1++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
        assert(primary_super_of_depth(j1) == NULL, "super list padding");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
      while (t != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
        assert(primary_super_of_depth(j) == t, "super list initialization");
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14078
diff changeset
   272
        t = t->super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
        --j;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
      assert(j == (juint)-1, "correct depth count");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
  if (secondary_supers() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
    // Now compute the list of secondary supertypes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
    // Secondaries can occasionally be on the super chain,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    // if the inline "_primary_supers" array overflows.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
    int extras = 0;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   286
    Klass* p;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   287
    for (p = super(); !(p == NULL || p->can_be_primary_super()); p = p->super()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
      ++extras;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   291
    ResourceMark rm(THREAD);  // need to reclaim GrowableArrays allocated below
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   293
    // Compute the "real" non-extra secondaries.
49948
ff8dbb56740a 8200466: Revisit the setting of _transitive_interfaces in InstanceKlass
ccheung
parents: 49824
diff changeset
   294
    GrowableArray<Klass*>* secondaries = compute_secondary_supers(extras, transitive_interfaces);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   295
    if (secondaries == NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   296
      // secondary_supers set by compute_secondary_supers
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   297
      return;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   298
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   299
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   300
    GrowableArray<Klass*>* primaries = new GrowableArray<Klass*>(extras);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   301
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46324
diff changeset
   302
    for (p = super(); !(p == NULL || p->can_be_primary_super()); p = p->super()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
      int i;                    // Scan for overflow primaries being duplicates of 2nd'arys
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
      // This happens frequently for very deeply nested arrays: the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
      // primary superclass chain overflows into the secondary.  The
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
      // secondary list contains the element_klass's secondaries with
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
      // an extra array dimension added.  If the element_klass's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
      // secondary list already contains some primary overflows, they
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
      // (with the extra level of array-ness) will collide with the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
      // normal primary superclass overflows.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   312
      for( i = 0; i < secondaries->length(); i++ ) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   313
        if( secondaries->at(i) == p )
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
          break;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   315
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
      if( i < secondaries->length() )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
        continue;               // It's a dup, don't put it in
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   318
      primaries->push(p);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   320
    // Combine the two arrays into a metadata object to pack the array.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   321
    // The primaries are added in the reverse order, then the secondaries.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   322
    int new_length = primaries->length() + secondaries->length();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   323
    Array<Klass*>* s2 = MetadataFactory::new_array<Klass*>(
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   324
                                       class_loader_data(), new_length, CHECK);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   325
    int fill_p = primaries->length();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   326
    for (int j = 0; j < fill_p; j++) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   327
      s2->at_put(j, primaries->pop());  // add primaries in reverse order.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   328
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   329
    for( int j = 0; j < secondaries->length(); j++ ) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   330
      s2->at_put(j+fill_p, secondaries->at(j));  // add secondaries on the end.
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
  #ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
      // We must not copy any NULL placeholders left over from bootstrap.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   335
    for (int j = 0; j < s2->length(); j++) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   336
      assert(s2->at(j) != NULL, "correct bootstrapping order");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  #endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46324
diff changeset
   340
    set_secondary_supers(s2);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
49948
ff8dbb56740a 8200466: Revisit the setting of _transitive_interfaces in InstanceKlass
ccheung
parents: 49824
diff changeset
   344
GrowableArray<Klass*>* Klass::compute_secondary_supers(int num_extra_slots,
ff8dbb56740a 8200466: Revisit the setting of _transitive_interfaces in InstanceKlass
ccheung
parents: 49824
diff changeset
   345
                                                       Array<Klass*>* transitive_interfaces) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  assert(num_extra_slots == 0, "override for complex klasses");
49948
ff8dbb56740a 8200466: Revisit the setting of _transitive_interfaces in InstanceKlass
ccheung
parents: 49824
diff changeset
   347
  assert(transitive_interfaces == NULL, "sanity");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   348
  set_secondary_supers(Universe::the_empty_klass_array());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   349
  return NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   353
InstanceKlass* Klass::superklass() const {
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33602
diff changeset
   354
  assert(super() == NULL || super()->is_instance_klass(), "must be instance klass");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   355
  return _super == NULL ? NULL : InstanceKlass::cast(_super);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   358
void Klass::set_subklass(Klass* s) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   359
  assert(s != this, "sanity check");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   360
  _subklass = s;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   363
void Klass::set_next_sibling(Klass* s) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   364
  assert(s != this, "sanity check");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   365
  _next_sibling = s;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
void Klass::append_to_sibling_list() {
14078
2b2b8833c422 7199068: NPG: SharedSkipVerify is meaningless
coleenp
parents: 13952
diff changeset
   369
  debug_only(verify();)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  // add ourselves to superklass' subklass list
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   371
  InstanceKlass* super = superklass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  if (super == NULL) return;        // special case: class Object
14078
2b2b8833c422 7199068: NPG: SharedSkipVerify is meaningless
coleenp
parents: 13952
diff changeset
   373
  assert((!super->is_interface()    // interfaces cannot be supers
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
          && (super->superklass() == NULL || !is_interface())),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
         "an interface can only be a subklass of Object");
23515
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 22908
diff changeset
   376
  Klass* prev_first_subklass = super->subklass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  if (prev_first_subklass != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
    // set our sibling to be the superklass' previous first subklass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
    set_next_sibling(prev_first_subklass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  // make ourselves the superklass' first subklass
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   382
  super->set_subklass(this);
14078
2b2b8833c422 7199068: NPG: SharedSkipVerify is meaningless
coleenp
parents: 13952
diff changeset
   383
  debug_only(verify();)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
49969
8624981f1ffa 8202447: Fix unloading_occurred to mean unloading_occurred
coleenp
parents: 49948
diff changeset
   386
void Klass::clean_weak_klass_links(bool unloading_occurred, bool clean_alive_klasses) {
8624981f1ffa 8202447: Fix unloading_occurred to mean unloading_occurred
coleenp
parents: 49948
diff changeset
   387
  if (!ClassUnloading || !unloading_occurred) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   388
    return;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   389
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   390
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   391
  Klass* root = SystemDictionary::Object_klass();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   392
  Stack<Klass*, mtGC> stack;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   393
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   394
  stack.push(root);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   395
  while (!stack.is_empty()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   396
    Klass* current = stack.pop();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   397
49821
02c08e20d66c 8201537: Remove is_alive closure from Klass::is_loader_alive()
coleenp
parents: 49816
diff changeset
   398
    assert(current->is_loader_alive(), "just checking, this should be live");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   399
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   400
    // Find and set the first alive subklass
23515
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 22908
diff changeset
   401
    Klass* sub = current->subklass();
49821
02c08e20d66c 8201537: Remove is_alive closure from Klass::is_loader_alive()
coleenp
parents: 49816
diff changeset
   402
    while (sub != NULL && !sub->is_loader_alive()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
#ifndef PRODUCT
38151
fffedc5e5cf8 8154110: Update class* and safepoint* logging subsystems
mockner
parents: 36508
diff changeset
   404
      if (log_is_enabled(Trace, class, unload)) {
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   405
        ResourceMark rm;
38151
fffedc5e5cf8 8154110: Update class* and safepoint* logging subsystems
mockner
parents: 36508
diff changeset
   406
        log_trace(class, unload)("unlinking class (subclass): %s", sub->external_name());
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   407
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
#endif
23515
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 22908
diff changeset
   409
      sub = sub->next_sibling();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   411
    current->set_subklass(sub);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   412
    if (sub != NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   413
      stack.push(sub);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   414
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   415
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   416
    // Find and set the first alive sibling
23515
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 22908
diff changeset
   417
    Klass* sibling = current->next_sibling();
49821
02c08e20d66c 8201537: Remove is_alive closure from Klass::is_loader_alive()
coleenp
parents: 49816
diff changeset
   418
    while (sibling != NULL && !sibling->is_loader_alive()) {
38151
fffedc5e5cf8 8154110: Update class* and safepoint* logging subsystems
mockner
parents: 36508
diff changeset
   419
      if (log_is_enabled(Trace, class, unload)) {
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   420
        ResourceMark rm;
38151
fffedc5e5cf8 8154110: Update class* and safepoint* logging subsystems
mockner
parents: 36508
diff changeset
   421
        log_trace(class, unload)("[Unlinking class (sibling) %s]", sibling->external_name());
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   422
      }
23515
f4872ef5df09 8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents: 22908
diff changeset
   423
      sibling = sibling->next_sibling();
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   424
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   425
    current->set_next_sibling(sibling);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   426
    if (sibling != NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   427
      stack.push(sibling);
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   428
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   429
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   430
    // Clean the implementors list and method data.
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33602
diff changeset
   431
    if (clean_alive_klasses && current->is_instance_klass()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   432
      InstanceKlass* ik = InstanceKlass::cast(current);
49821
02c08e20d66c 8201537: Remove is_alive closure from Klass::is_loader_alive()
coleenp
parents: 49816
diff changeset
   433
      ik->clean_weak_instanceklass_links();
41060
c72f3248ea0c 8156137: SIGSEGV in ReceiverTypeData::clean_weak_klass_links
dlong
parents: 40655
diff changeset
   434
c72f3248ea0c 8156137: SIGSEGV in ReceiverTypeData::clean_weak_klass_links
dlong
parents: 40655
diff changeset
   435
      // JVMTI RedefineClasses creates previous versions that are not in
c72f3248ea0c 8156137: SIGSEGV in ReceiverTypeData::clean_weak_klass_links
dlong
parents: 40655
diff changeset
   436
      // the class hierarchy, so process them here.
c72f3248ea0c 8156137: SIGSEGV in ReceiverTypeData::clean_weak_klass_links
dlong
parents: 40655
diff changeset
   437
      while ((ik = ik->previous_versions()) != NULL) {
49821
02c08e20d66c 8201537: Remove is_alive closure from Klass::is_loader_alive()
coleenp
parents: 49816
diff changeset
   438
        ik->clean_weak_instanceklass_links();
41060
c72f3248ea0c 8156137: SIGSEGV in ReceiverTypeData::clean_weak_klass_links
dlong
parents: 40655
diff changeset
   439
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
46746
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   444
void Klass::metaspace_pointers_do(MetaspaceClosure* it) {
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   445
  if (log_is_enabled(Trace, cds)) {
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   446
    ResourceMark rm;
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   447
    log_trace(cds)("Iter(Klass): %p (%s)", this, external_name());
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   448
  }
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   449
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   450
  it->push(&_name);
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   451
  it->push(&_secondary_super_cache);
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   452
  it->push(&_secondary_supers);
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   453
  for (int i = 0; i < _primary_super_limit; i++) {
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   454
    it->push(&_primary_supers[i]);
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   455
  }
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   456
  it->push(&_super);
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   457
  it->push(&_subklass);
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   458
  it->push(&_next_sibling);
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   459
  it->push(&_next_link);
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   460
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   461
  vtableEntry* vt = start_of_vtable();
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   462
  for (int i=0; i<vtable_length(); i++) {
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   463
    it->push(vt[i].method_addr());
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   464
  }
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   465
}
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46413
diff changeset
   466
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
void Klass::remove_unshareable_info() {
23872
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23515
diff changeset
   468
  assert (DumpSharedSpaces, "only called for DumpSharedSpaces");
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents: 50056
diff changeset
   469
  JFR_ONLY(REMOVE_ID(this);)
47103
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   470
  if (log_is_enabled(Trace, cds, unshareable)) {
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   471
    ResourceMark rm;
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   472
    log_trace(cds, unshareable)("remove: %s", external_name());
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   473
  }
23872
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23515
diff changeset
   474
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  set_subklass(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
  set_next_sibling(NULL);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   477
  set_next_link(NULL);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   478
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   479
  // Null out class_loader_data because we don't share that yet.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   480
  set_class_loader_data(NULL);
46413
b0f67ec8f6be 8178543: Optimize Klass::is_shared()
iklam
parents: 46408
diff changeset
   481
  set_is_shared();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
47103
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   484
void Klass::remove_java_mirror() {
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   485
  assert (DumpSharedSpaces, "only called for DumpSharedSpaces");
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   486
  if (log_is_enabled(Trace, cds, unshareable)) {
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   487
    ResourceMark rm;
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   488
    log_trace(cds, unshareable)("remove java_mirror: %s", external_name());
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   489
  }
47580
96392e113a0a 8186777: Make Klass::_java_mirror an OopHandle
coleenp
parents: 47216
diff changeset
   490
  // Just null out the mirror.  The class_loader_data() no longer exists.
96392e113a0a 8186777: Make Klass::_java_mirror an OopHandle
coleenp
parents: 47216
diff changeset
   491
  _java_mirror = NULL;
47103
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   492
}
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   493
26135
82b516c550f7 8046070: Class Data Sharing clean up and refactoring
iklam
parents: 25492
diff changeset
   494
void Klass::restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS) {
46324
8764956ec928 8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents: 46271
diff changeset
   495
  assert(is_klass(), "ensure C++ vtable is restored");
46413
b0f67ec8f6be 8178543: Optimize Klass::is_shared()
iklam
parents: 46408
diff changeset
   496
  assert(is_shared(), "must be set");
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents: 50056
diff changeset
   497
  JFR_ONLY(RESTORE_ID(this);)
47103
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   498
  if (log_is_enabled(Trace, cds, unshareable)) {
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   499
    ResourceMark rm;
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   500
    log_trace(cds, unshareable)("restore: %s", external_name());
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46968
diff changeset
   501
  }
39400
daf3af35d6bf 8159666: Better CDS support for Event-based tracing
iklam
parents: 38151
diff changeset
   502
23872
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23515
diff changeset
   503
  // If an exception happened during CDS restore, some of these fields may already be
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23515
diff changeset
   504
  // set.  We leave the class on the CLD list, even if incomplete so that we don't
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23515
diff changeset
   505
  // modify the CLD list outside a safepoint.
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23515
diff changeset
   506
  if (class_loader_data() == NULL) {
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23515
diff changeset
   507
    // Restore class_loader_data to the null class loader data
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23515
diff changeset
   508
    set_class_loader_data(loader_data);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
23872
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23515
diff changeset
   510
    // Add to null class loader list first before creating the mirror
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23515
diff changeset
   511
    // (same order as class file parsing)
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23515
diff changeset
   512
    loader_data->add_class(this);
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23515
diff changeset
   513
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   514
49329
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   515
  Handle loader(THREAD, loader_data->class_loader());
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   516
  ModuleEntry* module_entry = NULL;
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   517
  Klass* k = this;
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   518
  if (k->is_objArray_klass()) {
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   519
    k = ObjArrayKlass::cast(k)->bottom_klass();
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   520
  }
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   521
  // Obtain klass' module.
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   522
  if (k->is_instance_klass()) {
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   523
    InstanceKlass* ik = (InstanceKlass*) k;
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   524
    module_entry = ik->module();
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   525
  } else {
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   526
    module_entry = ModuleEntryTable::javabase_moduleEntry();
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   527
  }
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   528
  // Obtain java.lang.Module, if available
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   529
  Handle module_handle(THREAD, ((module_entry != NULL) ? module_entry->module() : (oop)NULL));
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   530
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   531
  if (this->has_raw_archived_mirror()) {
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   532
    log_debug(cds, mirror)("%s has raw archived mirror", external_name());
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   533
    if (MetaspaceShared::open_archive_heap_region_mapped()) {
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   534
      oop m = archived_java_mirror();
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   535
      log_debug(cds, mirror)("Archived mirror is: " PTR_FORMAT, p2i(m));
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   536
      if (m != NULL) {
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   537
        // mirror is archived, restore
50056
ca1f2d4d4ec8 8202709: Move oopDesc::is_archive_object to MetaspaceShared::is_archive_object
stefank
parents: 49969
diff changeset
   538
        assert(MetaspaceShared::is_archive_object(m), "must be archived mirror object");
49329
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   539
        Handle m_h(THREAD, m);
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   540
        java_lang_Class::restore_archived_mirror(this, m_h, loader, module_handle, protection_domain, CHECK);
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   541
        return;
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   542
      }
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   543
    }
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   544
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   545
    // No archived mirror data
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   546
    _java_mirror = NULL;
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   547
    this->clear_has_raw_archived_mirror();
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   548
  }
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   549
23872
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23515
diff changeset
   550
  // Only recreate it if not present.  A previous attempt to restore may have
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23515
diff changeset
   551
  // gotten an OOM later but keep the mirror if it was created.
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23515
diff changeset
   552
  if (java_mirror() == NULL) {
49329
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   553
    log_trace(cds, mirror)("Recreate mirror for %s", external_name());
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36384
diff changeset
   554
    java_lang_Class::create_mirror(this, loader, module_handle, protection_domain, CHECK);
23872
536c66fc43d3 8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents: 23515
diff changeset
   555
  }
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   556
}
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   557
49329
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   558
#if INCLUDE_CDS_JAVA_HEAP
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   559
// Used at CDS dump time to access the archived mirror. No GC barrier.
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   560
oop Klass::archived_java_mirror_raw() {
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   561
  assert(DumpSharedSpaces, "called only during runtime");
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   562
  assert(has_raw_archived_mirror(), "must have raw archived mirror");
49592
77fb0be7d19f 8199946: Move load/store and encode/decode out of oopDesc
stefank
parents: 49393
diff changeset
   563
  return CompressedOops::decode(_archived_mirror);
49329
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   564
}
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   565
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   566
// Used at CDS runtime to get the archived mirror from shared class. Uses GC barrier.
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   567
oop Klass::archived_java_mirror() {
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   568
  assert(UseSharedSpaces, "UseSharedSpaces expected.");
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   569
  assert(has_raw_archived_mirror(), "must have raw archived mirror");
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   570
  return RootAccess<IN_ARCHIVE_ROOT>::oop_load(&_archived_mirror);
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   571
}
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   572
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   573
// No GC barrier
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   574
void Klass::set_archived_java_mirror_raw(oop m) {
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   575
  assert(DumpSharedSpaces, "called only during runtime");
49592
77fb0be7d19f 8199946: Move load/store and encode/decode out of oopDesc
stefank
parents: 49393
diff changeset
   576
  _archived_mirror = CompressedOops::encode(m);
49329
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   577
}
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   578
#endif // INCLUDE_CDS_JAVA_HEAP
04ed29f9ef33 8194759: Support caching class mirror objects.
jiangli
parents: 49066
diff changeset
   579
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   580
Klass* Klass::array_klass_or_null(int rank) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  // No exception can be thrown by array_klass_impl when called with or_null == true.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  // (In anycase, the execption mark will fail if it do so)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
  return array_klass_impl(true, rank, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   588
Klass* Klass::array_klass_or_null() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
  EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  // No exception can be thrown by array_klass_impl when called with or_null == true.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  // (In anycase, the execption mark will fail if it do so)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  return array_klass_impl(true, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   596
Klass* Klass::array_klass_impl(bool or_null, int rank, TRAPS) {
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
   597
  fatal("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   602
Klass* Klass::array_klass_impl(bool or_null, TRAPS) {
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
   603
  fatal("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   607
oop Klass::class_loader() const { return class_loader_data()->class_loader(); }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   608
33602
16053580a684 8139163: InstanceKlass::cast passes through NULL
coleenp
parents: 33576
diff changeset
   609
// In product mode, this function doesn't have virtual function calls so
16053580a684 8139163: InstanceKlass::cast passes through NULL
coleenp
parents: 33576
diff changeset
   610
// there might be some performance advantage to handling InstanceKlass here.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
const char* Klass::external_name() const {
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33602
diff changeset
   612
  if (is_instance_klass()) {
33602
16053580a684 8139163: InstanceKlass::cast passes through NULL
coleenp
parents: 33576
diff changeset
   613
    const InstanceKlass* ik = static_cast<const InstanceKlass*>(this);
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   614
    if (ik->is_anonymous()) {
49066
4aa67aba6c85 8197901: Crash during GC when logging level is debug
lmesnik
parents: 49056
diff changeset
   615
      char addr_buf[20];
4aa67aba6c85 8197901: Crash during GC when logging level is debug
lmesnik
parents: 49056
diff changeset
   616
      jio_snprintf(addr_buf, 20, "/" INTPTR_FORMAT, p2i(ik));
4aa67aba6c85 8197901: Crash during GC when logging level is debug
lmesnik
parents: 49056
diff changeset
   617
      size_t addr_len = strlen(addr_buf);
4aa67aba6c85 8197901: Crash during GC when logging level is debug
lmesnik
parents: 49056
diff changeset
   618
      size_t name_len = name()->utf8_length();
4aa67aba6c85 8197901: Crash during GC when logging level is debug
lmesnik
parents: 49056
diff changeset
   619
      char*  result   = NEW_RESOURCE_ARRAY(char, name_len + addr_len + 1);
4aa67aba6c85 8197901: Crash during GC when logging level is debug
lmesnik
parents: 49056
diff changeset
   620
      name()->as_klass_external_name(result, (int) name_len + 1);
4aa67aba6c85 8197901: Crash during GC when logging level is debug
lmesnik
parents: 49056
diff changeset
   621
      assert(strlen(result) == name_len, "");
4aa67aba6c85 8197901: Crash during GC when logging level is debug
lmesnik
parents: 49056
diff changeset
   622
      strcpy(result + name_len, addr_buf);
4aa67aba6c85 8197901: Crash during GC when logging level is debug
lmesnik
parents: 49056
diff changeset
   623
      assert(strlen(result) == name_len + addr_len, "");
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   624
      return result;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   625
    }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   626
  }
4094
1f424b2b2171 6815692: method handle code needs some cleanup (post-6655638)
jrose
parents: 2131
diff changeset
   627
  if (name() == NULL)  return "<unknown>";
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
  return name()->as_klass_external_name();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
4094
1f424b2b2171 6815692: method handle code needs some cleanup (post-6655638)
jrose
parents: 2131
diff changeset
   631
const char* Klass::signature_name() const {
1f424b2b2171 6815692: method handle code needs some cleanup (post-6655638)
jrose
parents: 2131
diff changeset
   632
  if (name() == NULL)  return "<unknown>";
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
  return name()->as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
49368
2ed1c37df3a5 8197405: Improve messages of AbstractMethodErrors and IncompatibleClassChangeErrors.
goetz
parents: 49329
diff changeset
   636
const char* Klass::external_kind() const {
2ed1c37df3a5 8197405: Improve messages of AbstractMethodErrors and IncompatibleClassChangeErrors.
goetz
parents: 49329
diff changeset
   637
  if (is_interface()) return "interface";
2ed1c37df3a5 8197405: Improve messages of AbstractMethodErrors and IncompatibleClassChangeErrors.
goetz
parents: 49329
diff changeset
   638
  if (is_abstract()) return "abstract class";
2ed1c37df3a5 8197405: Improve messages of AbstractMethodErrors and IncompatibleClassChangeErrors.
goetz
parents: 49329
diff changeset
   639
  return "class";
2ed1c37df3a5 8197405: Improve messages of AbstractMethodErrors and IncompatibleClassChangeErrors.
goetz
parents: 49329
diff changeset
   640
}
2ed1c37df3a5 8197405: Improve messages of AbstractMethodErrors and IncompatibleClassChangeErrors.
goetz
parents: 49329
diff changeset
   641
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
// Unless overridden, modifier_flags is 0.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
jint Klass::compute_modifier_flags(TRAPS) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
int Klass::atomic_incr_biased_lock_revocation_count() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
  return (int) Atomic::add(1, &_biased_lock_revocation_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
// Unless overridden, jvmti_class_status has no flags set.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
jint Klass::jvmti_class_status() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   656
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
// Printing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   659
void Klass::print_on(outputStream* st) const {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   660
  ResourceMark rm;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   661
  // print title
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   662
  st->print("%s", internal_name());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   663
  print_address_on(st);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   664
  st->cr();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   665
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   666
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
void Klass::oop_print_on(oop obj, outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
  // print title
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
  st->print_cr("%s ", internal_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
  obj->print_address_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
  if (WizardMode) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
     // print header
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
     obj->mark()->print_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
  // print class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
  st->print(" - klass: ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
  obj->klass()->print_value_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
  st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
void Klass::oop_print_value_on(oop obj, outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
  // print title
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
  ResourceMark rm;              // Cannot print in debug mode without this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
  st->print("%s", internal_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
  obj->print_address_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
15437
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   691
#if INCLUDE_SERVICES
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   692
// Size Statistics
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   693
void Klass::collect_statistics(KlassSizeStats *sz) const {
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   694
  sz->_klass_bytes = sz->count(this);
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   695
  sz->_mirror_bytes = sz->count(java_mirror());
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   696
  sz->_secondary_supers_bytes = sz->count_array(secondary_supers());
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   697
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   698
  sz->_ro_bytes += sz->_secondary_supers_bytes;
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   699
  sz->_rw_bytes += sz->_klass_bytes + sz->_mirror_bytes;
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   700
}
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   701
#endif // INCLUDE_SERVICES
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   702
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
// Verification
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
22794
f1c014ad3754 8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents: 22201
diff changeset
   705
void Klass::verify_on(outputStream* st) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   706
18439
725ce18186b3 8016325: JVM hangs verifying system dictionary
coleenp
parents: 18025
diff changeset
   707
  // This can be expensive, but it is worth checking that this klass is actually
725ce18186b3 8016325: JVM hangs verifying system dictionary
coleenp
parents: 18025
diff changeset
   708
  // in the CLD graph but not in production.
24457
0e20b36df5c4 8038212: Method::is_valid_method() check has performance regression impact for stackwalking
coleenp
parents: 24351
diff changeset
   709
  assert(Metaspace::contains((address)this), "Should be");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   710
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   711
  guarantee(this->is_klass(),"should be klass");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   712
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   713
  if (super() != NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   714
    guarantee(super()->is_klass(), "should be klass");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   715
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   716
  if (secondary_super_cache() != NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   717
    Klass* ko = secondary_super_cache();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   718
    guarantee(ko->is_klass(), "should be klass");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   719
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   720
  for ( uint i = 0; i < primary_super_limit(); i++ ) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   721
    Klass* ko = _primary_supers[i];
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   722
    if (ko != NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   723
      guarantee(ko->is_klass(), "should be klass");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   724
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   725
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   726
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   727
  if (java_mirror() != NULL) {
46968
9119841280f4 8160399: is_oop_or_null involves undefined behavior
coleenp
parents: 46773
diff changeset
   728
    guarantee(oopDesc::is_oop(java_mirror()), "should be instance");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   729
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   730
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   731
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
void Klass::oop_verify_on(oop obj, outputStream* st) {
46968
9119841280f4 8160399: is_oop_or_null involves undefined behavior
coleenp
parents: 46773
diff changeset
   733
  guarantee(oopDesc::is_oop(obj),  "should be oop");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
  guarantee(obj->klass()->is_klass(), "klass field is not a klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
46408
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46388
diff changeset
   737
klassVtable Klass::vtable() const {
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46388
diff changeset
   738
  return klassVtable(const_cast<Klass*>(this), start_of_vtable(), vtable_length() / vtableEntry::size());
35900
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35899
diff changeset
   739
}
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35899
diff changeset
   740
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35899
diff changeset
   741
vtableEntry* Klass::start_of_vtable() const {
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35899
diff changeset
   742
  return (vtableEntry*) ((address)this + in_bytes(vtable_start_offset()));
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35899
diff changeset
   743
}
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35899
diff changeset
   744
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35899
diff changeset
   745
Method* Klass::method_at_vtable(int index)  {
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35899
diff changeset
   746
#ifndef PRODUCT
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35899
diff changeset
   747
  assert(index >= 0, "valid vtable index");
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35899
diff changeset
   748
  if (DebugVtables) {
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35899
diff changeset
   749
    verify_vtable_index(index);
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35899
diff changeset
   750
  }
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35899
diff changeset
   751
#endif
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35899
diff changeset
   752
  return start_of_vtable()[index].method();
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35899
diff changeset
   753
}
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35899
diff changeset
   754
35899
0dbc821628fc 8148047: Move the vtable length field to Klass
mgerdin
parents: 34666
diff changeset
   755
ByteSize Klass::vtable_start_offset() {
0dbc821628fc 8148047: Move the vtable length field to Klass
mgerdin
parents: 34666
diff changeset
   756
  return in_ByteSize(InstanceKlass::header_size() * wordSize);
0dbc821628fc 8148047: Move the vtable length field to Klass
mgerdin
parents: 34666
diff changeset
   757
}
0dbc821628fc 8148047: Move the vtable length field to Klass
mgerdin
parents: 34666
diff changeset
   758
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19696
diff changeset
   761
bool Klass::verify_vtable_index(int i) {
33602
16053580a684 8139163: InstanceKlass::cast passes through NULL
coleenp
parents: 33576
diff changeset
   762
  int limit = vtable_length()/vtableEntry::size();
16053580a684 8139163: InstanceKlass::cast passes through NULL
coleenp
parents: 33576
diff changeset
   763
  assert(i >= 0 && i < limit, "index %d out of bounds %d", i, limit);
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19696
diff changeset
   764
  return true;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19696
diff changeset
   765
}
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19696
diff changeset
   766
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19696
diff changeset
   767
bool Klass::verify_itable_index(int i) {
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33602
diff changeset
   768
  assert(is_instance_klass(), "");
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19696
diff changeset
   769
  int method_count = klassItable::method_count_for_interface(this);
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19696
diff changeset
   770
  assert(i >= 0 && i < method_count, "index out of bounds");
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19696
diff changeset
   771
  return true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
49056
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   774
#endif // PRODUCT
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   775
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   776
// The caller of class_loader_and_module_name() (or one of its callers)
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   777
// must use a ResourceMark in order to correctly free the result.
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   778
const char* Klass::class_loader_and_module_name() const {
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   779
  const char* delim = "/";
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   780
  size_t delim_len = strlen(delim);
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   781
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   782
  const char* fqn = external_name();
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   783
  // Length of message to return; always include FQN
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   784
  size_t msglen = strlen(fqn) + 1;
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   785
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   786
  bool has_cl_name = false;
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   787
  bool has_mod_name = false;
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   788
  bool has_version = false;
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   789
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   790
  // Use class loader name, if exists and not builtin
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   791
  const char* class_loader_name = "";
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   792
  ClassLoaderData* cld = class_loader_data();
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   793
  assert(cld != NULL, "class_loader_data should not be NULL");
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   794
  if (!cld->is_builtin_class_loader_data()) {
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   795
    // If not builtin, look for name
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   796
    oop loader = class_loader();
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   797
    if (loader != NULL) {
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   798
      oop class_loader_name_oop = java_lang_ClassLoader::name(loader);
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   799
      if (class_loader_name_oop != NULL) {
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   800
        class_loader_name = java_lang_String::as_utf8_string(class_loader_name_oop);
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   801
        if (class_loader_name != NULL && class_loader_name[0] != '\0') {
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   802
          has_cl_name = true;
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   803
          msglen += strlen(class_loader_name) + delim_len;
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   804
        }
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   805
      }
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   806
    }
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   807
  }
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   808
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   809
  const char* module_name = "";
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   810
  const char* version = "";
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   811
  const Klass* bottom_klass = is_objArray_klass() ?
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   812
    ObjArrayKlass::cast(this)->bottom_klass() : this;
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   813
  if (bottom_klass->is_instance_klass()) {
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   814
    ModuleEntry* module = InstanceKlass::cast(bottom_klass)->module();
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   815
    // Use module name, if exists
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   816
    if (module->is_named()) {
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   817
      has_mod_name = true;
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   818
      module_name = module->name()->as_C_string();
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   819
      msglen += strlen(module_name);
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   820
      // Use version if exists and is not a jdk module
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   821
      if (module->is_non_jdk_module() && module->version() != NULL) {
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   822
        has_version = true;
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   823
        version = module->version()->as_C_string();
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   824
        msglen += strlen("@") + strlen(version);
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   825
      }
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   826
    }
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   827
  } else {
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   828
    // klass is an array of primitives, so its module is java.base
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   829
    module_name = JAVA_BASE_NAME;
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   830
  }
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   831
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   832
  if (has_cl_name || has_mod_name) {
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   833
    msglen += delim_len;
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   834
  }
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   835
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   836
  char* message = NEW_RESOURCE_ARRAY_RETURN_NULL(char, msglen);
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   837
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   838
  // Just return the FQN if error in allocating string
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   839
  if (message == NULL) {
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   840
    return fqn;
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   841
  }
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   842
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   843
  jio_snprintf(message, msglen, "%s%s%s%s%s%s%s",
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   844
               class_loader_name,
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   845
               (has_cl_name) ? delim : "",
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   846
               (has_mod_name) ? module_name : "",
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   847
               (has_version) ? "@" : "",
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   848
               (has_version) ? version : "",
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   849
               (has_cl_name || has_mod_name) ? delim : "",
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   850
               fqn);
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   851
  return message;
91ada5977172 8197780: Null pointer dereference in Klass::is_instance_klass of klass.hpp:532
coleenp
parents: 47580
diff changeset
   852
}