hotspot/src/share/vm/oops/klass.cpp
author coleenp
Wed, 22 May 2013 14:37:49 -0400
changeset 17826 9ad5cd464a75
parent 17370 59a0620561fa
child 17858 c292f8791cca
permissions -rw-r--r--
8003421: NPG: Move oops out of InstanceKlass into mirror Summary: Inject protection_domain, signers, init_lock into java_lang_Class Reviewed-by: stefank, dholmes, sla
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
15437
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
     2
 * Copyright (c) 1997, 2013, 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"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    26
#include "classfile/javaClasses.hpp"
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    27
#include "classfile/dictionary.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    28
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    29
#include "classfile/vmSymbols.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    30
#include "gc_implementation/shared/markSweep.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    31
#include "gc_interface/collectedHeap.inline.hpp"
15437
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
    32
#include "memory/heapInspection.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    33
#include "memory/metadataFactory.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    34
#include "memory/oopFactory.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    35
#include "memory/resourceArea.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    36
#include "oops/instanceKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    37
#include "oops/klass.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    38
#include "oops/oop.inline2.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    39
#include "runtime/atomic.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    40
#include "utilities/stack.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14588
diff changeset
    41
#include "utilities/macros.hpp"
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14588
diff changeset
    42
#if INCLUDE_ALL_GCS
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    43
#include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    44
#include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    45
#include "gc_implementation/parallelScavenge/psScavenge.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14588
diff changeset
    46
#endif // INCLUDE_ALL_GCS
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    48
void Klass::set_name(Symbol* n) {
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    49
  _name = n;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    50
  if (_name != NULL) _name->increment_refcount();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    51
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
17370
59a0620561fa 8003557: NPG: Klass* const k should be const Klass* k.
minqi
parents: 16352
diff changeset
    53
bool Klass::is_subclass_of(const Klass* k) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  // Run up the super chain and check
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    55
  if (this == k) return true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    57
  Klass* t = const_cast<Klass*>(this)->super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  while (t != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
    if (t == k) return true;
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14078
diff changeset
    61
    t = t->super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    66
bool Klass::search_secondary_supers(Klass* k) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  // Put some extra logic here out-of-line, before the search proper.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  // This cuts down the size of the inline method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  // 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
    71
  if (this == k)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  // Scan the array-of-objects for a match
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  int cnt = secondary_supers()->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  for (int i = 0; i < cnt; i++) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    76
    if (secondary_supers()->at(i) == k) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
      ((Klass*)this)->set_secondary_super_cache(k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
// Return self, except for abstract classes with exactly 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
// implementor.  Then return the 1 concrete implementation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
Klass *Klass::up_cast_abstract() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  Klass *r = this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  while( r->is_abstract() ) {   // Receiver is abstract?
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
    Klass *s = r->subklass();   // Check for exactly 1 subklass
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
    if( !s || s->next_sibling() ) // Oops; wrong count; give up
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
      return this;              // Return 'this' as a no-progress flag
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
    r = s;                    // Loop till find concrete class
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  return r;                   // Return the 1 concrete class
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 1550
diff changeset
    97
// Find LCA in class hierarchy
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
Klass *Klass::LCA( Klass *k2 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  Klass *k1 = this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  while( 1 ) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   101
    if( k1->is_subtype_of(k2) ) return k2;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   102
    if( k2->is_subtype_of(k1) ) return k1;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   103
    k1 = k1->super();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   104
    k2 = k2->super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
void Klass::check_valid_for_instantiation(bool throwError, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  THROW_MSG(throwError ? vmSymbols::java_lang_InstantiationError()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
            : vmSymbols::java_lang_InstantiationException(), external_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
void Klass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  THROW(vmSymbols::java_lang_ArrayStoreException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
void Klass::initialize(TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   125
bool Klass::compute_is_subtype_of(Klass* k) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  assert(k->is_klass(), "argument must be a class");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  return is_subclass_of(k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   131
Method* Klass::uncached_lookup_method(Symbol* name, Symbol* signature) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  tty->print_cr("Error: uncached_lookup_method called on a klass oop."
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
                " Likely error: reflection method does not correctly"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
                " wrap return value in a mirror object.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   141
void* Klass::operator new(size_t size, ClassLoaderData* loader_data, size_t word_size, TRAPS) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   142
  return Metaspace::allocate(loader_data, word_size, /*read_only*/false,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   143
                             Metaspace::ClassType, CHECK_NULL);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   144
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   145
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   146
Klass::Klass() {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   147
  Klass* k = this;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
15928
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15484
diff changeset
   149
  // Preinitialize supertype information.
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15484
diff changeset
   150
  // A later call to initialize_supers() may update these settings:
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15484
diff changeset
   151
  set_super(NULL);
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15484
diff changeset
   152
  for (juint i = 0; i < Klass::primary_super_limit(); i++) {
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15484
diff changeset
   153
    _primary_supers[i] = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  }
15928
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15484
diff changeset
   155
  set_secondary_supers(NULL);
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15484
diff changeset
   156
  set_secondary_super_cache(NULL);
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15484
diff changeset
   157
  _primary_supers[0] = k;
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15484
diff changeset
   158
  set_super_check_offset(in_bytes(primary_supers_offset()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   160
  set_java_mirror(NULL);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   161
  set_modifier_flags(0);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   162
  set_layout_helper(Klass::_lh_neutral_value);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   163
  set_name(NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  AccessFlags af;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  af.set_flags(0);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   166
  set_access_flags(af);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   167
  set_subklass(NULL);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   168
  set_next_sibling(NULL);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   169
  set_next_link(NULL);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   170
  set_alloc_count(0);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   171
  TRACE_SET_KLASS_TRACE_ID(this, 0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   173
  set_prototype_header(markOopDesc::prototype());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   174
  set_biased_lock_revocation_count(0);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   175
  set_last_biased_lock_bulk_revocation_time(0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   177
  // The klass doesn't have any references at this point.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   178
  clear_modified_oops();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   179
  clear_accumulated_modified_oops();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
jint Klass::array_layout_helper(BasicType etype) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  assert(etype >= T_BOOLEAN && etype <= T_OBJECT, "valid etype");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  // Note that T_ARRAY is not allowed here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  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
   186
  int  esize = type2aelembytes(etype);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  bool isobj = (etype == T_OBJECT);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  int  tag   =  isobj ? _lh_array_tag_obj_value : _lh_array_tag_type_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  int lh = array_layout_helper(tag, hsize, etype, exact_log2(esize));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  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
   192
  assert(layout_helper_is_array(lh), "correct kind");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  assert(layout_helper_is_objArray(lh) == isobj, "correct kind");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  assert(layout_helper_is_typeArray(lh) == !isobj, "correct kind");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  assert(layout_helper_header_size(lh) == hsize, "correct decode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  assert(layout_helper_element_type(lh) == etype, "correct decode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  assert(1 << layout_helper_log2_element_size(lh) == esize, "correct decode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  return lh;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
bool Klass::can_be_primary_super_slow() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  if (super() == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
    return true;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   205
  else if (super()->super_depth() >= primary_super_limit()-1)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   211
void Klass::initialize_supers(Klass* k, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  if (FastSuperclassLimit == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
    // None of the other machinery matters.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
    set_super(k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  if (k == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
    set_super(NULL);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   219
    _primary_supers[0] = this;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
    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
   221
  } else if (k != super() || k == SystemDictionary::Object_klass()) {
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4094
diff changeset
   222
    assert(super() == NULL || super() == SystemDictionary::Object_klass(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
           "initialize this only once to a non-trivial value");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
    set_super(k);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   225
    Klass* sup = k;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
    int sup_depth = sup->super_depth();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
    juint my_depth  = MIN2(sup_depth + 1, (int)primary_super_limit());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
    if (!can_be_primary_super_slow())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
      my_depth = primary_super_limit();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
    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
   231
      _primary_supers[i] = sup->_primary_supers[i];
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   233
    Klass* *super_check_cell;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    if (my_depth < primary_super_limit()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   235
      _primary_supers[my_depth] = this;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
      super_check_cell = &_primary_supers[my_depth];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
      // Overflow of the primary_supers array forces me to be secondary.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
      super_check_cell = &_secondary_super_cache;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   241
    set_super_check_offset((address)super_check_cell - (address) this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
      juint j = super_depth();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
      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
   247
      Klass* t = this;
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14078
diff changeset
   248
      while (!t->can_be_primary_super()) {
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14078
diff changeset
   249
        t = t->super();
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14078
diff changeset
   250
        j = t->super_depth();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
      for (juint j1 = j+1; j1 < primary_super_limit(); j1++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
        assert(primary_super_of_depth(j1) == NULL, "super list padding");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
      while (t != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
        assert(primary_super_of_depth(j) == t, "super list initialization");
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14078
diff changeset
   257
        t = t->super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
        --j;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
      assert(j == (juint)-1, "correct depth count");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  if (secondary_supers() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
    KlassHandle this_kh (THREAD, this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
    // Now compute the list of secondary supertypes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
    // Secondaries can occasionally be on the super chain,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
    // if the inline "_primary_supers" array overflows.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
    int extras = 0;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   272
    Klass* p;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   273
    for (p = super(); !(p == NULL || p->can_be_primary_super()); p = p->super()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
      ++extras;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   277
    ResourceMark rm(THREAD);  // need to reclaim GrowableArrays allocated below
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   279
    // Compute the "real" non-extra secondaries.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   280
    GrowableArray<Klass*>* secondaries = compute_secondary_supers(extras);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   281
    if (secondaries == NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   282
      // secondary_supers set by compute_secondary_supers
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   283
      return;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   284
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   285
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   286
    GrowableArray<Klass*>* primaries = new GrowableArray<Klass*>(extras);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   287
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   288
    for (p = this_kh->super(); !(p == NULL || p->can_be_primary_super()); p = p->super()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
      int i;                    // Scan for overflow primaries being duplicates of 2nd'arys
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
      // This happens frequently for very deeply nested arrays: the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
      // primary superclass chain overflows into the secondary.  The
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
      // secondary list contains the element_klass's secondaries with
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
      // an extra array dimension added.  If the element_klass's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
      // secondary list already contains some primary overflows, they
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
      // (with the extra level of array-ness) will collide with the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
      // normal primary superclass overflows.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   298
      for( i = 0; i < secondaries->length(); i++ ) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   299
        if( secondaries->at(i) == p )
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
          break;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   301
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
      if( i < secondaries->length() )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
        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
   304
      primaries->push(p);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   306
    // 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
   307
    // 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
   308
    int new_length = primaries->length() + secondaries->length();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   309
    Array<Klass*>* s2 = MetadataFactory::new_array<Klass*>(
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   310
                                       class_loader_data(), new_length, CHECK);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   311
    int fill_p = primaries->length();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   312
    for (int j = 0; j < fill_p; j++) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   313
      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
   314
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   315
    for( int j = 0; j < secondaries->length(); j++ ) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   316
      s2->at_put(j+fill_p, secondaries->at(j));  // add secondaries on the end.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  #ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
      // 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
   321
    for (int j = 0; j < s2->length(); j++) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   322
      assert(s2->at(j) != NULL, "correct bootstrapping order");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  #endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   326
    this_kh->set_secondary_supers(s2);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   330
GrowableArray<Klass*>* Klass::compute_secondary_supers(int num_extra_slots) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  assert(num_extra_slots == 0, "override for complex klasses");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   332
  set_secondary_supers(Universe::the_empty_klass_array());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   333
  return NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
Klass* Klass::subklass() const {
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14078
diff changeset
   338
  return _subklass == NULL ? NULL : _subklass;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   341
InstanceKlass* Klass::superklass() const {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   342
  assert(super() == NULL || super()->oop_is_instance(), "must be instance klass");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   343
  return _super == NULL ? NULL : InstanceKlass::cast(_super);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
Klass* Klass::next_sibling() const {
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14078
diff changeset
   347
  return _next_sibling == NULL ? NULL : _next_sibling;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   350
void Klass::set_subklass(Klass* s) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   351
  assert(s != this, "sanity check");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   352
  _subklass = s;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   355
void Klass::set_next_sibling(Klass* s) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   356
  assert(s != this, "sanity check");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   357
  _next_sibling = s;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
void Klass::append_to_sibling_list() {
14078
2b2b8833c422 7199068: NPG: SharedSkipVerify is meaningless
coleenp
parents: 13952
diff changeset
   361
  debug_only(verify();)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  // add ourselves to superklass' subklass list
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   363
  InstanceKlass* super = superklass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  if (super == NULL) return;        // special case: class Object
14078
2b2b8833c422 7199068: NPG: SharedSkipVerify is meaningless
coleenp
parents: 13952
diff changeset
   365
  assert((!super->is_interface()    // interfaces cannot be supers
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
          && (super->superklass() == NULL || !is_interface())),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
         "an interface can only be a subklass of Object");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   368
  Klass* prev_first_subklass = super->subklass_oop();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  if (prev_first_subklass != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
    // set our sibling to be the superklass' previous first subklass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
    set_next_sibling(prev_first_subklass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  // make ourselves the superklass' first subklass
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   374
  super->set_subklass(this);
14078
2b2b8833c422 7199068: NPG: SharedSkipVerify is meaningless
coleenp
parents: 13952
diff changeset
   375
  debug_only(verify();)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   378
bool Klass::is_loader_alive(BoolObjectClosure* is_alive) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   379
  assert(is_metadata(), "p is not meta-data");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   380
  assert(ClassLoaderDataGraph::contains((address)this), "is in the metaspace");
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   381
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   382
#ifdef ASSERT
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   383
  // The class is alive iff the class loader is alive.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   384
  oop loader = class_loader();
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   385
  bool loader_alive = (loader == NULL) || is_alive->do_object_b(loader);
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   386
#endif // ASSERT
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   387
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   388
  // The class is alive if it's mirror is alive (which should be marked if the
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   389
  // loader is alive) unless it's an anoymous class.
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   390
  bool mirror_alive = is_alive->do_object_b(java_mirror());
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   391
  assert(!mirror_alive || loader_alive, "loader must be alive if the mirror is"
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   392
                        " but not the other way around with anonymous classes");
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   393
  return mirror_alive;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   394
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   395
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   396
void Klass::clean_weak_klass_links(BoolObjectClosure* is_alive) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   397
  if (!ClassUnloading) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   398
    return;
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
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   401
  Klass* root = SystemDictionary::Object_klass();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   402
  Stack<Klass*, mtGC> stack;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   403
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   404
  stack.push(root);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   405
  while (!stack.is_empty()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   406
    Klass* current = stack.pop();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   407
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   408
    assert(current->is_loader_alive(is_alive), "just checking, this should be live");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   409
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   410
    // Find and set the first alive subklass
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   411
    Klass* sub = current->subklass_oop();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   412
    while (sub != NULL && !sub->is_loader_alive(is_alive)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
#ifndef PRODUCT
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   414
      if (TraceClassUnloading && WizardMode) {
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   415
        ResourceMark rm;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   416
        tty->print_cr("[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
   417
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
#endif
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   419
      sub = sub->next_sibling_oop();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   421
    current->set_subklass(sub);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   422
    if (sub != NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   423
      stack.push(sub);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   424
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   425
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   426
    // Find and set the first alive sibling
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   427
    Klass* sibling = current->next_sibling_oop();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   428
    while (sibling != NULL && !sibling->is_loader_alive(is_alive)) {
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   429
      if (TraceClassUnloading && WizardMode) {
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   430
        ResourceMark rm;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   431
        tty->print_cr("[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
   432
      }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   433
      sibling = sibling->next_sibling_oop();
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   434
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   435
    current->set_next_sibling(sibling);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   436
    if (sibling != NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   437
      stack.push(sibling);
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   438
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   439
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   440
    // Clean the implementors list and method data.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   441
    if (current->oop_is_instance()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   442
      InstanceKlass* ik = InstanceKlass::cast(current);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   443
      ik->clean_implementors_list(is_alive);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   444
      ik->clean_method_data(is_alive);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   449
void Klass::klass_update_barrier_set(oop v) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   450
  record_modified_oops();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   451
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   452
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   453
void Klass::klass_update_barrier_set_pre(void* p, oop v) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   454
  // This barrier used by G1, where it's used remember the old oop values,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   455
  // so that we don't forget any objects that were live at the snapshot at
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   456
  // the beginning. This function is only used when we write oops into
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   457
  // Klasses. Since the Klasses are used as roots in G1, we don't have to
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   458
  // do anything here.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   459
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   460
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   461
void Klass::klass_oop_store(oop* p, oop v) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   462
  assert(!Universe::heap()->is_in_reserved((void*)p), "Should store pointer into metadata");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   463
  assert(v == NULL || Universe::heap()->is_in_reserved((void*)v), "Should store pointer to an object");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   464
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   465
  // do the store
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   466
  if (always_do_update_barrier) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   467
    klass_oop_store((volatile oop*)p, v);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   468
  } else {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   469
    klass_update_barrier_set_pre((void*)p, v);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   470
    *p = v;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   471
    klass_update_barrier_set(v);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   472
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   473
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   474
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   475
void Klass::klass_oop_store(volatile oop* p, oop v) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   476
  assert(!Universe::heap()->is_in_reserved((void*)p), "Should store pointer into metadata");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   477
  assert(v == NULL || Universe::heap()->is_in_reserved((void*)v), "Should store pointer to an object");
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
  klass_update_barrier_set_pre((void*)p, v);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   480
  OrderAccess::release_store_ptr(p, v);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   481
  klass_update_barrier_set(v);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   482
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   483
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   484
void Klass::oops_do(OopClosure* cl) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   485
  cl->do_oop(&_java_mirror);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   486
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
void Klass::remove_unshareable_info() {
16352
1ff72c6eaa70 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL)
coleenp
parents: 15928
diff changeset
   489
  if (!DumpSharedSpaces) {
1ff72c6eaa70 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL)
coleenp
parents: 15928
diff changeset
   490
    // Clean up after OOM during class loading
1ff72c6eaa70 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL)
coleenp
parents: 15928
diff changeset
   491
    if (class_loader_data() != NULL) {
1ff72c6eaa70 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL)
coleenp
parents: 15928
diff changeset
   492
      class_loader_data()->remove_class(this);
1ff72c6eaa70 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL)
coleenp
parents: 15928
diff changeset
   493
    }
1ff72c6eaa70 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL)
coleenp
parents: 15928
diff changeset
   494
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  set_subklass(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  set_next_sibling(NULL);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   497
  // Clear the java mirror
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   498
  set_java_mirror(NULL);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   499
  set_next_link(NULL);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   500
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   501
  // 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
   502
  set_class_loader_data(NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   505
void Klass::restore_unshareable_info(TRAPS) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   506
  ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   507
  // Restore class_loader_data to the null class loader data
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   508
  set_class_loader_data(loader_data);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   510
  // Add to null class loader list first before creating the mirror
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   511
  // (same order as class file parsing)
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   512
  loader_data->add_class(this);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   513
17826
9ad5cd464a75 8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents: 17370
diff changeset
   514
  // Recreate the class mirror.  The protection_domain is always null for
9ad5cd464a75 8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents: 17370
diff changeset
   515
  // boot loader, for now.
9ad5cd464a75 8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents: 17370
diff changeset
   516
  java_lang_Class::create_mirror(this, Handle(NULL), CHECK);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   517
}
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   518
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   519
Klass* Klass::array_klass_or_null(int rank) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
  EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  // No exception can be thrown by array_klass_impl when called with or_null == true.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  // (In anycase, the execption mark will fail if it do so)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
  return array_klass_impl(true, rank, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   527
Klass* Klass::array_klass_or_null() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  // No exception can be thrown by array_klass_impl when called with or_null == true.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  // (In anycase, the execption mark will fail if it do so)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  return array_klass_impl(true, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   535
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
   536
  fatal("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   541
Klass* Klass::array_klass_impl(bool or_null, TRAPS) {
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
   542
  fatal("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   547
void Klass::with_array_klasses_do(void f(Klass* k)) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   548
  f(this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   552
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
   553
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
const char* Klass::external_name() const {
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   555
  if (oop_is_instance()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   556
    InstanceKlass* ik = (InstanceKlass*) this;
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   557
    if (ik->is_anonymous()) {
8883
5569135acca3 6817525: turn on method handle functionality by default for JSR 292
twisti
parents: 8076
diff changeset
   558
      assert(EnableInvokeDynamic, "");
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   559
      intptr_t hash = 0;
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   560
      if (ik->java_mirror() != NULL) {
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   561
        // java_mirror might not be created yet, return 0 as hash.
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   562
        hash = ik->java_mirror()->identity_hash();
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   563
      }
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   564
      char     hash_buf[40];
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   565
      sprintf(hash_buf, "/" UINTX_FORMAT, (uintx)hash);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   566
      size_t   hash_len = strlen(hash_buf);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   567
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   568
      size_t result_len = name()->utf8_length();
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   569
      char*  result     = NEW_RESOURCE_ARRAY(char, result_len + hash_len + 1);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   570
      name()->as_klass_external_name(result, (int) result_len + 1);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   571
      assert(strlen(result) == result_len, "");
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   572
      strcpy(result + result_len, hash_buf);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   573
      assert(strlen(result) == result_len + hash_len, "");
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   574
      return result;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   575
    }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 670
diff changeset
   576
  }
4094
1f424b2b2171 6815692: method handle code needs some cleanup (post-6655638)
jrose
parents: 2131
diff changeset
   577
  if (name() == NULL)  return "<unknown>";
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  return name()->as_klass_external_name();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
4094
1f424b2b2171 6815692: method handle code needs some cleanup (post-6655638)
jrose
parents: 2131
diff changeset
   582
const char* Klass::signature_name() const {
1f424b2b2171 6815692: method handle code needs some cleanup (post-6655638)
jrose
parents: 2131
diff changeset
   583
  if (name() == NULL)  return "<unknown>";
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
  return name()->as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
// Unless overridden, modifier_flags is 0.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
jint Klass::compute_modifier_flags(TRAPS) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
int Klass::atomic_incr_biased_lock_revocation_count() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  return (int) Atomic::add(1, &_biased_lock_revocation_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
// Unless overridden, jvmti_class_status has no flags set.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
jint Klass::jvmti_class_status() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   601
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
// Printing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   604
void Klass::print_on(outputStream* st) const {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   605
  ResourceMark rm;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   606
  // print title
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   607
  st->print("%s", internal_name());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   608
  print_address_on(st);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   609
  st->cr();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   610
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   611
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
void Klass::oop_print_on(oop obj, outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
  // print title
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
  st->print_cr("%s ", internal_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  obj->print_address_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
  if (WizardMode) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
     // print header
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
     obj->mark()->print_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
  // print class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
  st->print(" - klass: ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
  obj->klass()->print_value_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
  st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
void Klass::oop_print_value_on(oop obj, outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
  // print title
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  ResourceMark rm;              // Cannot print in debug mode without this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  st->print("%s", internal_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
  obj->print_address_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
15437
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   636
#if INCLUDE_SERVICES
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   637
// Size Statistics
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   638
void Klass::collect_statistics(KlassSizeStats *sz) const {
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   639
  sz->_klass_bytes = sz->count(this);
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   640
  sz->_mirror_bytes = sz->count(java_mirror());
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   641
  sz->_secondary_supers_bytes = sz->count_array(secondary_supers());
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   642
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   643
  sz->_ro_bytes += sz->_secondary_supers_bytes;
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   644
  sz->_rw_bytes += sz->_klass_bytes + sz->_mirror_bytes;
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   645
}
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 14588
diff changeset
   646
#endif // INCLUDE_SERVICES
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   647
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
// Verification
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   650
void Klass::verify_on(outputStream* st) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   651
  guarantee(!Universe::heap()->is_in_reserved(this), "Shouldn't be");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   652
  guarantee(this->is_metadata(), "should be in metaspace");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   653
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   654
  assert(ClassLoaderDataGraph::contains((address)this), "Should be");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   655
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   656
  guarantee(this->is_klass(),"should be klass");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   657
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   658
  if (super() != NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   659
    guarantee(super()->is_metadata(), "should be in metaspace");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   660
    guarantee(super()->is_klass(), "should be klass");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   661
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   662
  if (secondary_super_cache() != NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   663
    Klass* ko = secondary_super_cache();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   664
    guarantee(ko->is_metadata(), "should be in metaspace");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   665
    guarantee(ko->is_klass(), "should be klass");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   666
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   667
  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
   668
    Klass* ko = _primary_supers[i];
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   669
    if (ko != NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   670
      guarantee(ko->is_metadata(), "should be in metaspace");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   671
      guarantee(ko->is_klass(), "should be klass");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   672
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   673
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   674
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   675
  if (java_mirror() != NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   676
    guarantee(java_mirror()->is_oop(), "should be instance");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   677
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   678
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   679
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
void Klass::oop_verify_on(oop obj, outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
  guarantee(obj->is_oop(),  "should be oop");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   682
  guarantee(obj->klass()->is_metadata(), "should not be in Java heap");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
  guarantee(obj->klass()->is_klass(), "klass field is not a klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
void Klass::verify_vtable_index(int i) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
  if (oop_is_instance()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   690
    assert(i>=0 && i<((InstanceKlass*)this)->vtable_length()/vtableEntry::size(), "index out of bounds");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
  } else {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
   692
    assert(oop_is_array(), "Must be");
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
   693
    assert(i>=0 && i<((ArrayKlass*)this)->vtable_length()/vtableEntry::size(), "index out of bounds");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
#endif