src/hotspot/share/oops/klassVtable.cpp
author coleenp
Fri, 28 Sep 2018 16:07:39 -0400
changeset 51959 db0c3952de52
parent 51608 625a5bdde0c5
child 52276 ad9077f044be
permissions -rw-r--r--
8209645: Split ClassLoaderData and ClassLoaderDataGraph into separate files Reviewed-by: iklam, stuefe
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
48794
ea0d0781c63c 8178351: Simplify MetaspaceShared::is_in_shared_space and MetaspaceObj::is_shared
iklam
parents: 48463
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: 5403
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    25
#include "precompiled.hpp"
47765
b7c7428eaab9 8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents: 47554
diff changeset
    26
#include "jvm.h"
51959
db0c3952de52 8209645: Split ClassLoaderData and ClassLoaderDataGraph into separate files
coleenp
parents: 51608
diff changeset
    27
#include "classfile/classLoaderDataGraph.hpp"
50036
e0dbf14885b8 8199852: Print more information about class loaders in LinkageErrors.
goetz
parents: 49902
diff changeset
    28
#include "classfile/javaClasses.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    29
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    30
#include "classfile/vmSymbols.hpp"
49593
4dd58ecc9912 8200105: Remove cyclic dependency between oop.inline.hpp and collectedHeap.inline.hpp
stefank
parents: 49359
diff changeset
    31
#include "interpreter/linkResolver.hpp"
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
    32
#include "logging/log.hpp"
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
    33
#include "logging/logStream.hpp"
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
    34
#include "memory/metaspaceShared.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    35
#include "memory/resourceArea.hpp"
49359
59f6547e151f 8199264: Remove universe.inline.hpp to simplify include dependencies
stefank
parents: 48819
diff changeset
    36
#include "memory/universe.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    37
#include "oops/instanceKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    38
#include "oops/klassVtable.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
    39
#include "oops/method.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    40
#include "oops/objArrayOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    41
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    42
#include "runtime/arguments.hpp"
49902
3661f31c6df4 8202150: [REDO] Split globals.hpp to factor out the Flag class
gziemski
parents: 49860
diff changeset
    43
#include "runtime/flags/flagSetting.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    44
#include "runtime/handles.inline.hpp"
49594
898ef81cbc0e 8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents: 49593
diff changeset
    45
#include "runtime/safepointVerifiers.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    46
#include "utilities/copy.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
    48
inline InstanceKlass* klassVtable::ik() const {
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
    49
  return InstanceKlass::cast(_klass);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
    52
bool klassVtable::is_preinitialized_vtable() {
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
    53
  return _klass->is_shared() && !MetaspaceShared::remapped_readwrite();
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
    54
}
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
    55
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
// this function computes the vtable size (including the size needed for miranda
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
    58
// methods) and the number of miranda methods in this class.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
// Note on Miranda methods: Let's say there is a class C that implements
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
    60
// interface I, and none of C's superclasses implements I.
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
    61
// Let's say there is an abstract method m in I that neither C
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
    62
// nor any of its super classes implement (i.e there is no method of any access,
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
    63
// with the same name and signature as m), then m is a Miranda method which is
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
// entered as a public abstract method in C's vtable.  From then on it should
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
// treated as any other public method in C for method over-ride purposes.
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
    66
void klassVtable::compute_vtable_size_and_num_mirandas(
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
    67
    int* vtable_length_ret, int* num_new_mirandas,
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
    68
    GrowableArray<Method*>* all_mirandas, const Klass* super,
40633
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
    69
    Array<Method*>* methods, AccessFlags class_flags, u2 major_version,
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
    70
    Handle classloader, Symbol* classname, Array<InstanceKlass*>* local_interfaces,
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
    71
    TRAPS) {
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35463
diff changeset
    72
  NoSafepointVerifier nsv;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  // set up default result values
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
    75
  int vtable_length = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  // start off with super's vtable length
33602
16053580a684 8139163: InstanceKlass::cast passes through NULL
coleenp
parents: 33148
diff changeset
    78
  vtable_length = super == NULL ? 0 : super->vtable_length();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  // go thru each method in the methods table to see if it needs a new entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  int len = methods->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  for (int i = 0; i < len; i++) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
    83
    assert(methods->at(i)->is_method(), "must be a Method*");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
    84
    methodHandle mh(THREAD, methods->at(i));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
40633
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
    86
    if (needs_new_vtable_entry(mh, super, classloader, classname, class_flags, major_version, THREAD)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
      vtable_length += vtableEntry::size(); // we need a new entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
    91
  GrowableArray<Method*> new_mirandas(20);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  // compute the number of mirandas methods that must be added to the end
48463
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
    93
  get_mirandas(&new_mirandas, all_mirandas, super, methods, NULL, local_interfaces,
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
    94
               class_flags.is_interface());
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
    95
  *num_new_mirandas = new_mirandas.length();
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
    96
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
    97
  // Interfaces do not need interface methods in their vtables
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
    98
  // This includes miranda methods and during later processing, default methods
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
    99
  if (!class_flags.is_interface()) {
48463
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   100
     vtable_length += *num_new_mirandas * vtableEntry::size();
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
   101
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  if (Universe::is_bootstrapping() && vtable_length == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
    // array classes don't have their superclass set correctly during
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
    // bootstrapping
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
    vtable_length = Universe::base_vtable_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
28373
26fdc99d32f8 6583051: crash when adding non-static methods to java.lang.Object class
coleenp
parents: 25504
diff changeset
   109
  if (super == NULL && vtable_length != Universe::base_vtable_size()) {
26fdc99d32f8 6583051: crash when adding non-static methods to java.lang.Object class
coleenp
parents: 25504
diff changeset
   110
    if (Universe::is_bootstrapping()) {
26fdc99d32f8 6583051: crash when adding non-static methods to java.lang.Object class
coleenp
parents: 25504
diff changeset
   111
      // Someone is attempting to override java.lang.Object incorrectly on the
26fdc99d32f8 6583051: crash when adding non-static methods to java.lang.Object class
coleenp
parents: 25504
diff changeset
   112
      // bootclasspath.  The JVM cannot recover from this error including throwing
26fdc99d32f8 6583051: crash when adding non-static methods to java.lang.Object class
coleenp
parents: 25504
diff changeset
   113
      // an exception
26fdc99d32f8 6583051: crash when adding non-static methods to java.lang.Object class
coleenp
parents: 25504
diff changeset
   114
      vm_exit_during_initialization("Incompatible definition of java.lang.Object");
26fdc99d32f8 6583051: crash when adding non-static methods to java.lang.Object class
coleenp
parents: 25504
diff changeset
   115
    } else {
26fdc99d32f8 6583051: crash when adding non-static methods to java.lang.Object class
coleenp
parents: 25504
diff changeset
   116
      // Someone is attempting to redefine java.lang.Object incorrectly.  The
26fdc99d32f8 6583051: crash when adding non-static methods to java.lang.Object class
coleenp
parents: 25504
diff changeset
   117
      // only way this should happen is from
26fdc99d32f8 6583051: crash when adding non-static methods to java.lang.Object class
coleenp
parents: 25504
diff changeset
   118
      // SystemDictionary::resolve_from_stream(), which will detect this later
26fdc99d32f8 6583051: crash when adding non-static methods to java.lang.Object class
coleenp
parents: 25504
diff changeset
   119
      // and throw a security exception.  So don't assert here to let
26fdc99d32f8 6583051: crash when adding non-static methods to java.lang.Object class
coleenp
parents: 25504
diff changeset
   120
      // the exception occur.
26fdc99d32f8 6583051: crash when adding non-static methods to java.lang.Object class
coleenp
parents: 25504
diff changeset
   121
      vtable_length = Universe::base_vtable_size();
26fdc99d32f8 6583051: crash when adding non-static methods to java.lang.Object class
coleenp
parents: 25504
diff changeset
   122
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  assert(vtable_length % vtableEntry::size() == 0, "bad vtable length");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  assert(vtable_length >= Universe::base_vtable_size(), "vtable too small");
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   126
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   127
  *vtable_length_ret = vtable_length;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   130
int klassVtable::index_of(Method* m, int len) const {
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   131
  assert(m->has_vtable_index(), "do not ask this of non-vtable methods");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  return m->vtable_index();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   135
// Copy super class's vtable to the first part (prefix) of this class's vtable,
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   136
// and return the number of entries copied.  Expects that 'super' is the Java
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   137
// super class (arrays can have "array" super classes that must be skipped).
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
   138
int klassVtable::initialize_from_super(Klass* super) {
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
   139
  if (super == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
    return 0;
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   141
  } else if (is_preinitialized_vtable()) {
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   142
    // A shared class' vtable is preinitialized at dump time. No need to copy
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   143
    // methods from super class for shared class, as that was already done
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   144
    // during archiving time. However, if Jvmti has redefined a class,
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   145
    // copy super class's vtable in case the super class has changed.
46408
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
   146
    return super->vtable().length();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
    // copy methods from superKlass
46408
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
   149
    klassVtable superVtable = super->vtable();
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
   150
    assert(superVtable.length() <= _length, "vtable too short");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
#ifdef ASSERT
46408
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
   152
    superVtable.verify(tty, true);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
#endif
46408
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
   154
    superVtable.copy_vtable_to(table());
35901
f5028c67e7cb 8147918: Rename develop_log_is_enabled() to log_develop_is_enabled()
pliden
parents: 35898
diff changeset
   155
    if (log_develop_is_enabled(Trace, vtables)) {
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   156
      ResourceMark rm;
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   157
      log_develop_trace(vtables)("copy vtable from %s to %s size %d",
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   158
                                 super->internal_name(), klass()->internal_name(),
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   159
                                 _length);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
    }
46408
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
   161
    return superVtable.length();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   165
//
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   166
// Revised lookup semantics   introduced 1.3 (Kestrel beta)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
void klassVtable::initialize_vtable(bool checkconstraints, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  // Note:  Arrays can have intermediate array supers.  Use java_super to skip them.
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
   170
  InstanceKlass* super = _klass->java_super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  int nofNewEntries = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   173
  bool is_shared = _klass->is_shared();
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   174
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
   175
  if (!_klass->is_array_klass()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
    ResourceMark rm(THREAD);
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   177
    log_develop_debug(vtables)("Initializing: %s", _klass->name()->as_C_string());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
#ifdef ASSERT
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
   181
  oop* end_of_obj = (oop*)_klass + _klass->size();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  oop* end_of_vtable = (oop*)&table()[_length];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  assert(end_of_vtable <= end_of_obj, "vtable extends beyond end");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  if (Universe::is_bootstrapping()) {
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   187
    assert(!is_shared, "sanity");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
    // just clear everything
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
    for (int i = 0; i < _length; i++) table()[i].clear();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  int super_vtable_len = initialize_from_super(super);
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
   194
  if (_klass->is_array_klass()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
    assert(super_vtable_len == _length, "arrays shouldn't introduce new methods");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  } else {
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33602
diff changeset
   197
    assert(_klass->is_instance_klass(), "must be InstanceKlass");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   199
    Array<Method*>* methods = ik()->methods();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   200
    int len = methods->length();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
    int initialized = super_vtable_len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   203
    // Check each of this class's methods against super;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   204
    // if override, replace in copy of super vtable, otherwise append to end
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
    for (int i = 0; i < len; i++) {
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   206
      // update_inherited_vtable can stop for gc - ensure using handles
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
      HandleMark hm(THREAD);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   208
      assert(methods->at(i)->is_method(), "must be a Method*");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   209
      methodHandle mh(THREAD, methods->at(i));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   211
      bool needs_new_entry = update_inherited_vtable(ik(), mh, super_vtable_len, -1, checkconstraints, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
      if (needs_new_entry) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
        put_method_at(mh(), initialized);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
        mh()->set_vtable_index(initialized); // set primary vtable index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
        initialized++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   220
    // update vtable with default_methods
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   221
    Array<Method*>* default_methods = ik()->default_methods();
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   222
    if (default_methods != NULL) {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   223
      len = default_methods->length();
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   224
      if (len > 0) {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   225
        Array<int>* def_vtable_indices = NULL;
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   226
        if ((def_vtable_indices = ik()->default_vtable_indices()) == NULL) {
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   227
          assert(!is_shared, "shared class def_vtable_indices does not exist");
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   228
          def_vtable_indices = ik()->create_new_default_vtable_indices(len, CHECK);
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   229
        } else {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   230
          assert(def_vtable_indices->length() == len, "reinit vtable len?");
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   231
        }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   232
        for (int i = 0; i < len; i++) {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   233
          HandleMark hm(THREAD);
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   234
          assert(default_methods->at(i)->is_method(), "must be a Method*");
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   235
          methodHandle mh(THREAD, default_methods->at(i));
41669
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   236
          assert(!mh->is_private(), "private interface method in the default method list");
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   237
          bool needs_new_entry = update_inherited_vtable(ik(), mh, super_vtable_len, i, checkconstraints, CHECK);
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   238
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   239
          // needs new entry
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   240
          if (needs_new_entry) {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   241
            put_method_at(mh(), initialized);
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   242
            if (is_preinitialized_vtable()) {
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   243
              // At runtime initialize_vtable is rerun for a shared class
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   244
              // (loaded by the non-boot loader) as part of link_class_impl().
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   245
              // The dumptime vtable index should be the same as the runtime index.
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   246
              assert(def_vtable_indices->at(i) == initialized,
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   247
                     "dump time vtable index is different from runtime index");
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   248
            } else {
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   249
              def_vtable_indices->at_put(i, initialized); //set vtable index
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   250
            }
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   251
            initialized++;
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   252
          }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   253
        }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   254
      }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   255
    }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   256
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   257
    // add miranda methods; it will also return the updated initialized
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
   258
    // Interfaces do not need interface methods in their vtables
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
   259
    // This includes miranda methods and during later processing, default methods
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
   260
    if (!ik()->is_interface()) {
51096
695dff91a997 8178712: ResourceMark may be missing inside initialize_[vi]table
lfoltan
parents: 50735
diff changeset
   261
      initialized = fill_in_mirandas(initialized, THREAD);
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
   262
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   264
    // In class hierarchies where the accessibility is not increasing (i.e., going from private ->
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   265
    // package_private -> public/protected), the vtable might actually be smaller than our initial
40633
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   266
    // calculation, for classfile versions for which we do not do transitive override
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   267
    // calculations.
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   268
    if (ik()->major_version() >= VTABLE_TRANSITIVE_OVERRIDE_VERSION) {
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   269
      assert(initialized == _length, "vtable initialization failed");
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   270
    } else {
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   271
      assert(initialized <= _length, "vtable initialization failed");
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   272
      for(;initialized < _length; initialized++) {
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   273
        table()[initialized].clear();
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   274
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
    NOT_PRODUCT(verify(tty, true));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   280
// Called for cases where a method does not override its superclass' vtable entry
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   281
// For bytecodes not produced by javac together it is possible that a method does not override
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   282
// the superclass's method, but might indirectly override a super-super class's vtable entry
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   283
// If none found, return a null superk, else return the superk of the method this does override
25504
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   284
// For public and protected methods: if they override a superclass, they will
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   285
// also be overridden themselves appropriately.
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   286
// Private methods do not override and are not overridden.
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   287
// Package Private methods are trickier:
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   288
// e.g. P1.A, pub m
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   289
// P2.B extends A, package private m
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   290
// P1.C extends B, public m
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   291
// P1.C.m needs to override P1.A.m and can not override P2.B.m
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   292
// Therefore: all package private methods need their own vtable entries for
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   293
// them to be the root of an inheritance overriding decision
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   294
// Package private methods may also override other vtable entries
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46701
diff changeset
   295
InstanceKlass* klassVtable::find_transitive_override(InstanceKlass* initialsuper, const methodHandle& target_method,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7443
diff changeset
   296
                            int vtable_index, Handle target_loader, Symbol* target_classname, Thread * THREAD) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   297
  InstanceKlass* superk = initialsuper;
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   298
  while (superk != NULL && superk->super() != NULL) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   299
    InstanceKlass* supersuperklass = InstanceKlass::cast(superk->super());
46408
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
   300
    klassVtable ssVtable = supersuperklass->vtable();
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
   301
    if (vtable_index < ssVtable.length()) {
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
   302
      Method* super_method = ssVtable.method_at(vtable_index);
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   303
#ifndef PRODUCT
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7443
diff changeset
   304
      Symbol* name= target_method()->name();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7443
diff changeset
   305
      Symbol* signature = target_method()->signature();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7443
diff changeset
   306
      assert(super_method->name() == name && super_method->signature() == signature, "vtable entry name/sig mismatch");
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   307
#endif
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   308
      if (supersuperklass->is_override(super_method, target_loader, target_classname, THREAD)) {
35901
f5028c67e7cb 8147918: Rename develop_log_is_enabled() to log_develop_is_enabled()
pliden
parents: 35898
diff changeset
   309
        if (log_develop_is_enabled(Trace, vtables)) {
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   310
          ResourceMark rm(THREAD);
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   311
          LogTarget(Trace, vtables) lt;
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   312
          LogStream ls(lt);
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   313
          char* sig = target_method()->name_and_sig_as_C_string();
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   314
          ls.print("transitive overriding superclass %s with %s index %d, original flags: ",
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   315
                       supersuperklass->internal_name(),
40633
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   316
                       sig, vtable_index);
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   317
          super_method->print_linkage_flags(&ls);
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   318
          ls.print("overriders flags: ");
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   319
          target_method->print_linkage_flags(&ls);
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   320
          ls.cr();
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   321
        }
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   322
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   323
        break; // return found superk
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   324
      }
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   325
    } else  {
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   326
      // super class has no vtable entry here, stop transitive search
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   327
      superk = (InstanceKlass*)NULL;
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   328
      break;
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   329
    }
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   330
    // if no override found yet, continue to search up
33602
16053580a684 8139163: InstanceKlass::cast passes through NULL
coleenp
parents: 33148
diff changeset
   331
    superk = superk->super() == NULL ? NULL : InstanceKlass::cast(superk->super());
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   332
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   334
  return superk;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46701
diff changeset
   337
static void log_vtables(int i, bool overrides, const methodHandle& target_method,
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
   338
                        Klass* target_klass, Method* super_method,
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   339
                        Thread* thread) {
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   340
#ifndef PRODUCT
35901
f5028c67e7cb 8147918: Rename develop_log_is_enabled() to log_develop_is_enabled()
pliden
parents: 35898
diff changeset
   341
  if (log_develop_is_enabled(Trace, vtables)) {
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   342
    ResourceMark rm(thread);
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   343
    LogTarget(Trace, vtables) lt;
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   344
    LogStream ls(lt);
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   345
    char* sig = target_method()->name_and_sig_as_C_string();
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   346
    if (overrides) {
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   347
      ls.print("overriding with %s index %d, original flags: ",
40633
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   348
                   sig, i);
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   349
    } else {
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   350
      ls.print("NOT overriding with %s index %d, original flags: ",
40633
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   351
                   sig, i);
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   352
    }
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   353
    super_method->print_linkage_flags(&ls);
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   354
    ls.print("overriders flags: ");
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   355
    target_method->print_linkage_flags(&ls);
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   356
    ls.cr();
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   357
  }
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   358
#endif
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   359
}
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   360
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
// Update child's copy of super vtable for overrides
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   362
// OR return true if a new vtable entry is required.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   363
// Only called for InstanceKlass's, i.e. not for arrays
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
// If that changed, could not use _klass as handle for klass
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46701
diff changeset
   365
bool klassVtable::update_inherited_vtable(InstanceKlass* klass, const methodHandle& target_method,
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   366
                                          int super_vtable_len, int default_index,
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   367
                                          bool checkconstraints, TRAPS) {
51096
695dff91a997 8178712: ResourceMark may be missing inside initialize_[vi]table
lfoltan
parents: 50735
diff changeset
   368
  ResourceMark rm(THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  bool allocate_new = true;
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33602
diff changeset
   370
  assert(klass->is_instance_klass(), "must be InstanceKlass");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   372
  Array<int>* def_vtable_indices = NULL;
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   373
  bool is_default = false;
41669
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   374
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   375
  // default methods are non-private concrete methods in superinterfaces which are added
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   376
  // to the vtable with their real method_holder.
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   377
  // Since vtable and itable indices share the same storage, don't touch
41669
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   378
  // the default method's real vtable/itable index.
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   379
  // default_vtable_indices stores the vtable value relative to this inheritor
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   380
  if (default_index >= 0 ) {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   381
    is_default = true;
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   382
    def_vtable_indices = klass->default_vtable_indices();
41669
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   383
    assert(!target_method()->is_private(), "private interface method flagged as default");
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   384
    assert(def_vtable_indices != NULL, "def vtable alloc?");
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   385
    assert(default_index <= def_vtable_indices->length(), "def vtable len?");
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   386
  } else {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   387
    assert(klass == target_method()->method_holder(), "caller resp.");
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   388
    // Initialize the method's vtable index to "nonvirtual".
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   389
    // If we allocate a vtable entry, we will update it to a non-negative number.
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   390
    target_method()->set_vtable_index(Method::nonvirtual_vtable_index);
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   391
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  // Static and <init> methods are never in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
  if (target_method()->is_static() || target_method()->name() ==  vmSymbols::object_initializer_name()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   398
  if (target_method->is_final_method(klass->access_flags())) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
    // a final method never needs a new entry; final methods can be statically
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
    // resolved and they have to be present in the vtable only if they override
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
    // a super's method, in which case they re-use its entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
    allocate_new = false;
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   403
  } else if (klass->is_interface()) {
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   404
    allocate_new = false;  // see note below in needs_new_vtable_entry
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   405
    // An interface never allocates new vtable slots, only inherits old ones.
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   406
    // This method will either be assigned its own itable index later,
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   407
    // or be assigned an inherited vtable index in the loop below.
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
   408
    // default methods inherited by classes store their vtable indices
41669
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   409
    // in the inheritor's default_vtable_indices.
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
   410
    // default methods inherited by interfaces may already have a
41669
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   411
    // valid itable index, if so, don't change it.
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   412
    // Overpass methods in an interface will be assigned an itable index later
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   413
    // by an inheriting class.
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   414
    // Private interface methods have no itable index and are always invoked nonvirtually,
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   415
    // so they retain their nonvirtual_vtable_index value, and therefore can_be_statically_bound()
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   416
    // will return true.
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   417
    if ((!is_default || !target_method()->has_itable_index()) && !target_method()->is_private()) {
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
   418
      target_method()->set_vtable_index(Method::pending_itable_index);
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
   419
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  // we need a new entry if there is no superclass
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   423
  Klass* super = klass->super();
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   424
  if (super == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
    return allocate_new;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
20284
595a25ab9474 8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default.
acorn
parents: 20017
diff changeset
   428
  // private methods in classes always have a new entry in the vtable
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   429
  // specification interpretation since classic has
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   430
  // private methods not overriding
20284
595a25ab9474 8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default.
acorn
parents: 20017
diff changeset
   431
  // JDK8 adds private methods in interfaces which require invokespecial
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  if (target_method()->is_private()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
    return allocate_new;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  // search through the vtable and update overridden entries
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  // Since check_signature_loaders acquires SystemDictionary_lock
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   438
  // which can block for gc, once we are in this loop, use handles
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   439
  // For classfiles built with >= jdk7, we now look for transitive overrides
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7443
diff changeset
   441
  Symbol* name = target_method()->name();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7443
diff changeset
   442
  Symbol* signature = target_method()->signature();
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   443
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
   444
  Klass* target_klass = target_method()->method_holder();
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   445
  if (target_klass == NULL) {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   446
    target_klass = _klass;
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   447
  }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   448
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   449
  Handle target_loader(THREAD, target_klass->class_loader());
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   450
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   451
  Symbol* target_classname = target_klass->name();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  for(int i = 0; i < super_vtable_len; i++) {
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   453
    Method* super_method;
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   454
    if (is_preinitialized_vtable()) {
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   455
      // If this is a shared class, the vtable is already in the final state (fully
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   456
      // initialized). Need to look at the super's vtable.
46408
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
   457
      klassVtable superVtable = super->vtable();
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
   458
      super_method = superVtable.method_at(i);
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   459
    } else {
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   460
      super_method = method_at(i);
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   461
    }
48463
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   462
    // Check if method name matches.  Ignore match if klass is an interface and the
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   463
    // matching method is a non-public java.lang.Object method.  (See JVMS 5.4.3.4)
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   464
    // This is safe because the method at this slot should never get invoked.
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   465
    // (TBD: put in a method to throw NoSuchMethodError if this slot is ever used.)
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   466
    if (super_method->name() == name && super_method->signature() == signature &&
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   467
        (!_klass->is_interface() ||
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   468
         !SystemDictionary::is_nonpublic_Object_method(super_method))) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   470
      // get super_klass for method_holder for the found method
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 14385
diff changeset
   471
      InstanceKlass* super_klass =  super_method->method_holder();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   473
      // Whether the method is being overridden
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   474
      bool overrides = false;
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   475
29871
77e7fe063568 8065366: Better private method resolution
acorn
parents: 29320
diff changeset
   476
      // private methods are also never overridden
77e7fe063568 8065366: Better private method resolution
acorn
parents: 29320
diff changeset
   477
      if (!super_method->is_private() &&
77e7fe063568 8065366: Better private method resolution
acorn
parents: 29320
diff changeset
   478
          (is_default
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   479
          || ((super_klass->is_override(super_method, target_loader, target_classname, THREAD))
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   480
          || ((klass->major_version() >= VTABLE_TRANSITIVE_OVERRIDE_VERSION)
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   481
          && ((super_klass = find_transitive_override(super_klass,
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   482
                             target_method, i, target_loader,
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   483
                             target_classname, THREAD))
29871
77e7fe063568 8065366: Better private method resolution
acorn
parents: 29320
diff changeset
   484
                             != (InstanceKlass*)NULL)))))
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   485
        {
25504
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   486
        // Package private methods always need a new entry to root their own
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   487
        // overriding. They may also override other methods.
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   488
        if (!target_method()->is_package_private()) {
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   489
          allocate_new = false;
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   490
        }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
47554
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
   492
        // Do not check loader constraints for overpass methods because overpass
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
   493
        // methods are created by the jvm to throw exceptions.
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
   494
        if (checkconstraints && !target_method()->is_overpass()) {
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
   495
          // Override vtable entry if passes loader constraint check
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
   496
          // if loader constraint checking requested
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
   497
          // No need to visit his super, since he and his super
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
   498
          // have already made any needed loader constraints.
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
   499
          // Since loader constraints are transitive, it is enough
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
   500
          // to link to the first super, and we get all the others.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
          Handle super_loader(THREAD, super_klass->class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
49658
8237a91c1cca 8199781: Don't use naked == for comparing oops
rkennke
parents: 49594
diff changeset
   503
          if (!oopDesc::equals(target_loader(), super_loader())) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
            ResourceMark rm(THREAD);
16591
73047b0eb568 8009731: Confusing error message for loader constraint violation
acorn
parents: 15591
diff changeset
   505
            Symbol* failed_type_symbol =
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   506
              SystemDictionary::check_signature_loaders(signature, target_loader,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
                                                        super_loader, true,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
                                                        CHECK_(false));
16591
73047b0eb568 8009731: Confusing error message for loader constraint violation
acorn
parents: 15591
diff changeset
   509
            if (failed_type_symbol != NULL) {
51097
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
   510
              stringStream ss;
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
   511
              ss.print("loader constraint violation for class %s: when selecting "
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
   512
                       "overriding method %s the class loader %s of the "
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
   513
                       "selected method's type %s, and the class loader %s for its super "
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
   514
                       "type %s have different Class objects for the type %s used in the signature (%s; %s)",
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
   515
                       klass->external_name(),
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
   516
                       target_method()->name_and_sig_as_C_string(),
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
   517
                       target_klass->class_loader_data()->loader_name_and_id(),
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
   518
                       target_klass->external_name(),
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
   519
                       super_klass->class_loader_data()->loader_name_and_id(),
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
   520
                       super_klass->external_name(),
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
   521
                       failed_type_symbol->as_klass_external_name(),
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
   522
                       target_klass->class_in_module_of_loader(false, true),
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
   523
                       super_klass->class_in_module_of_loader(false, true));
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
   524
              THROW_MSG_(vmSymbols::java_lang_LinkageError(), ss.as_string(), false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
          }
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   527
        }
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   528
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   529
        put_method_at(target_method(), i);
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   530
        overrides = true;
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   531
        if (!is_default) {
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   532
          target_method()->set_vtable_index(i);
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   533
        } else {
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   534
          if (def_vtable_indices != NULL) {
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   535
            if (is_preinitialized_vtable()) {
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   536
              // At runtime initialize_vtable is rerun as part of link_class_impl()
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   537
              // for a shared class loaded by the non-boot loader.
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   538
              // The dumptime vtable index should be the same as the runtime index.
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   539
              assert(def_vtable_indices->at(default_index) == i,
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   540
                     "dump time vtable index is different from runtime index");
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   541
            } else {
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   542
              def_vtable_indices->at_put(default_index, i);
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   543
            }
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   544
          }
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   545
          assert(super_method->is_default_method() || super_method->is_overpass()
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   546
                 || super_method->is_abstract(), "default override error");
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   547
        }
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   548
      } else {
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   549
        overrides = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
      }
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   551
      log_vtables(i, overrides, target_method, target_klass, super_method, THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  return allocate_new;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   557
void klassVtable::put_method_at(Method* m, int index) {
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   558
  if (is_preinitialized_vtable()) {
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   559
    // At runtime initialize_vtable is rerun as part of link_class_impl()
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   560
    // for shared class loaded by the non-boot loader to obtain the loader
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   561
    // constraints based on the runtime classloaders' context. The dumptime
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   562
    // method at the vtable index should be the same as the runtime method.
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   563
    assert(table()[index].method() == m,
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   564
           "archived method is different from the runtime method");
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   565
  } else {
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   566
    if (log_develop_is_enabled(Trace, vtables)) {
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   567
      ResourceMark rm;
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   568
      LogTarget(Trace, vtables) lt;
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   569
      LogStream ls(lt);
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   570
      const char* sig = (m != NULL) ? m->name_and_sig_as_C_string() : "<NULL>";
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   571
      ls.print("adding %s at index %d, flags: ", sig, index);
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   572
      if (m != NULL) {
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   573
        m->print_linkage_flags(&ls);
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   574
      }
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   575
      ls.cr();
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
   576
    }
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
   577
    table()[index].set(m);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
// Find out if a method "m" with superclass "super", loader "classloader" and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
// name "classname" needs a new vtable entry.  Let P be a class package defined
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
// by "classloader" and "classname".
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
// NOTE: The logic used here is very similar to the one used for computing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
// the vtables indices for a method. We cannot directly use that function because,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   586
// we allocate the InstanceKlass at load time, and that requires that the
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   587
// superclass has been loaded.
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   588
// However, the vtable entries are filled in at link time, and therefore
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   589
// the superclass' vtable may not yet have been filled in.
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46701
diff changeset
   590
bool klassVtable::needs_new_vtable_entry(const methodHandle& target_method,
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   591
                                         const Klass* super,
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   592
                                         Handle classloader,
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7443
diff changeset
   593
                                         Symbol* classname,
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   594
                                         AccessFlags class_flags,
40633
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   595
                                         u2 major_version,
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   596
                                         TRAPS) {
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   597
  if (class_flags.is_interface()) {
25504
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   598
    // Interfaces do not use vtables, except for java.lang.Object methods,
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   599
    // so there is no point to assigning
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   600
    // a vtable index to any of their local methods.  If we refrain from doing this,
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   601
    // we can use Method::_vtable_index to hold the itable index
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   602
    return false;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   603
  }
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   604
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   605
  if (target_method->is_final_method(class_flags) ||
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
      // a final method never needs a new entry; final methods can be statically
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
      // resolved and they have to be present in the vtable only if they override
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
      // a super's method, in which case they re-use its entry
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   609
      (target_method()->is_static()) ||
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
      // static methods don't need to be in vtable
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   611
      (target_method()->name() ==  vmSymbols::object_initializer_name())
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
      // <init> is never called dynamically-bound
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
      ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   617
  // Concrete interface methods do not need new entries, they override
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   618
  // abstract method entries using default inheritance rules
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   619
  if (target_method()->method_holder() != NULL &&
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   620
      target_method()->method_holder()->is_interface()  &&
41669
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   621
      !target_method()->is_abstract()) {
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   622
    assert(target_method()->is_default_method() || target_method()->is_private(),
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   623
           "unexpected interface method type");
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   624
    return false;
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   625
  }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   626
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
  // we need a new entry if there is no superclass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
  if (super == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
41669
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   632
  // private methods in classes always have a new entry in the vtable.
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40633
diff changeset
   633
  // Specification interpretation since classic has private methods not overriding.
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   634
  if (target_method()->is_private()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
25504
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   638
  // Package private methods always need a new entry to root their own
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   639
  // overriding. This allows transitive overriding to work.
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   640
  if (target_method()->is_package_private()) {
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   641
    return true;
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   642
  }
69de8357bc53 8032536: JVM resolves wrong method in some unusual cases
hseigel
parents: 24424
diff changeset
   643
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
  // search through the super class hierarchy to see if we need
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
  // a new entry
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   646
  ResourceMark rm;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7443
diff changeset
   647
  Symbol* name = target_method()->name();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7443
diff changeset
   648
  Symbol* signature = target_method()->signature();
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   649
  const Klass* k = super;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   650
  Method* super_method = NULL;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   651
  InstanceKlass *holder = NULL;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   652
  Method* recheck_method =  NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
  while (k != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
    // lookup through the hierarchy for a method with matching name and sign.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   655
    super_method = InstanceKlass::cast(k)->lookup_method(name, signature);
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   656
    if (super_method == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
      break; // we still have to search for a matching miranda method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
    // get the class holding the matching method
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   660
    // make sure you use that class for is_override
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 14385
diff changeset
   661
    InstanceKlass* superk = super_method->method_holder();
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   662
    // we want only instance method matches
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   663
    // pretend private methods are not in the super vtable
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   664
    // since we do override around them: e.g. a.m pub/b.m private/c.m pub,
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   665
    // ignore private, c.m pub does override a.m pub
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   666
    // For classes that were not javac'd together, we also do transitive overriding around
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   667
    // methods that have less accessibility
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   668
    if ((!super_method->is_static()) &&
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   669
       (!super_method->is_private())) {
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   670
      if (superk->is_override(super_method, classloader, classname, THREAD)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
        return false;
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   672
      // else keep looking for transitive overrides
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
40633
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   676
    // Start with lookup result and continue to search up, for versions supporting transitive override
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   677
    if (major_version >= VTABLE_TRANSITIVE_OVERRIDE_VERSION) {
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   678
      k = superk->super(); // haven't found an override match yet; continue to look
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   679
    } else {
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   680
      break;
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
   681
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
  // if the target method is public or protected it may have a matching
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
  // miranda method in the super, whose entry it should re-use.
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   686
  // Actually, to handle cases that javac would not generate, we need
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   687
  // this check for all access permissions.
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   688
  const InstanceKlass *sk = InstanceKlass::cast(super);
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   689
  if (sk->has_miranda_methods()) {
28731
f7339cba0a6a 8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents: 28373
diff changeset
   690
    if (sk->lookup_method_in_all_interfaces(name, signature, Klass::find_defaults) != NULL) {
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
   691
      return false;  // found a matching miranda; we do not need a new entry
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
  return true; // found no match; we need a new entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
// Support for miranda methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
// get the vtable index of a miranda method with matching "name" and "signature"
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7443
diff changeset
   700
int klassVtable::index_of_miranda(Symbol* name, Symbol* signature) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
  // search from the bottom, might be faster
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
  for (int i = (length() - 1); i >= 0; i--) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   703
    Method* m = table()[i].method();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
    if (is_miranda_entry_at(i) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
        m->name() == name && m->signature() == signature) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
      return i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   709
  return Method::invalid_vtable_index;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   712
// check if an entry at an index is miranda
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   713
// requires that method m at entry be declared ("held") by an interface.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
bool klassVtable::is_miranda_entry_at(int i) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   715
  Method* m = method_at(i);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   716
  Klass* method_holder = m->method_holder();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   717
  InstanceKlass *mhk = InstanceKlass::cast(method_holder);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
20284
595a25ab9474 8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default.
acorn
parents: 20017
diff changeset
   719
  // miranda methods are public abstract instance interface methods in a class's vtable
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  if (mhk->is_interface()) {
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   721
    assert(m->is_public(), "should be public");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
    assert(ik()->implements_interface(method_holder) , "this class should implement the interface");
48463
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   723
    if (is_miranda(m, ik()->methods(), ik()->default_methods(), ik()->super(), klass()->is_interface())) {
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
   724
      return true;
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
   725
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
32189
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   730
// Check if a method is a miranda method, given a class's methods array,
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   731
// its default_method table and its super class.
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   732
// "Miranda" means an abstract non-private method that would not be
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   733
// overridden for the local class.
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   734
// A "miranda" method should only include non-private interface
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   735
// instance methods, i.e. not private methods, not static methods,
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   736
// not default methods (concrete interface methods), not overpass methods.
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   737
// If a given class already has a local (including overpass) method, a
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   738
// default method, or any of its superclasses has the same which would have
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   739
// overridden an abstract method, then this is not a miranda method.
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   740
//
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   741
// Miranda methods are checked multiple times.
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   742
// Pass 1: during class load/class file parsing: before vtable size calculation:
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   743
// include superinterface abstract and default methods (non-private instance).
29871
77e7fe063568 8065366: Better private method resolution
acorn
parents: 29320
diff changeset
   744
// We include potential default methods to give them space in the vtable.
32189
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   745
// During the first run, the current instanceKlass has not yet been
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   746
// created, the superclasses and superinterfaces do have instanceKlasses
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   747
// but may not have vtables, the default_methods list is empty, no overpasses.
48463
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   748
// Default method generation uses the all_mirandas array as the starter set for
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   749
// maximally-specific default method calculation.  So, for both classes and
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   750
// interfaces, it is necessary that the first pass will find all non-private
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   751
// interface instance methods, whether or not they are concrete.
32189
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   752
//
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   753
// Pass 2: recalculated during vtable initialization: only include abstract methods.
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   754
// The goal of pass 2 is to walk through the superinterfaces to see if any of
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   755
// the superinterface methods (which were all abstract pre-default methods)
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   756
// need to be added to the vtable.
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   757
// With the addition of default methods, we have three new challenges:
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   758
// overpasses, static interface methods and private interface methods.
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   759
// Static and private interface methods do not get added to the vtable and
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   760
// are not seen by the method resolution process, so we skip those.
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   761
// Overpass methods are already in the vtable, so vtable lookup will
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   762
// find them and we don't need to add a miranda method to the end of
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   763
// the vtable. So we look for overpass methods and if they are found we
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   764
// return false. Note that we inherit our superclasses vtable, so
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   765
// the superclass' search also needs to use find_overpass so that if
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   766
// one is found we return false.
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   767
// False means - we don't need a miranda method added to the vtable.
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   768
//
29871
77e7fe063568 8065366: Better private method resolution
acorn
parents: 29320
diff changeset
   769
// During the second run, default_methods is set up, so concrete methods from
77e7fe063568 8065366: Better private method resolution
acorn
parents: 29320
diff changeset
   770
// superinterfaces with matching names/signatures to default_methods are already
77e7fe063568 8065366: Better private method resolution
acorn
parents: 29320
diff changeset
   771
// in the default_methods list and do not need to be appended to the vtable
32189
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   772
// as mirandas. Abstract methods may already have been handled via
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   773
// overpasses - either local or superclass overpasses, which may be
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   774
// in the vtable already.
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   775
//
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   776
// Pass 3: They are also checked by link resolution and selection,
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   777
// for invocation on a method (not interface method) reference that
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   778
// resolves to a method with an interface as its method_holder.
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   779
// Used as part of walking from the bottom of the vtable to find
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   780
// the vtable index for the miranda method.
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   781
//
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   782
// Part of the Miranda Rights in the US mean that if you do not have
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   783
// an attorney one will be appointed for you.
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   784
bool klassVtable::is_miranda(Method* m, Array<Method*>* class_methods,
48463
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   785
                             Array<Method*>* default_methods, const Klass* super,
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   786
                             bool is_interface) {
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
   787
  if (m->is_static() || m->is_private() || m->is_overpass()) {
17092
8d0bef547de9 8013418: assert(i == total_args_passed) in AdapterHandlerLibrary::get_adapter since 8-b87
bharadwaj
parents: 16591
diff changeset
   788
    return false;
8d0bef547de9 8013418: assert(i == total_args_passed) in AdapterHandlerLibrary::get_adapter since 8-b87
bharadwaj
parents: 16591
diff changeset
   789
  }
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7443
diff changeset
   790
  Symbol* name = m->name();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7443
diff changeset
   791
  Symbol* signature = m->signature();
21913
0e2fd7282ac6 8028438: static superclass method masks default methods
acorn
parents: 21770
diff changeset
   792
32189
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   793
  // First look in local methods to see if already covered
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   794
  if (InstanceKlass::find_local_method(class_methods, name, signature,
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   795
              Klass::find_overpass, Klass::skip_static, Klass::skip_private) != NULL)
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   796
  {
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   797
    return false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
  }
7443
39c85d63abf2 6989076: JVM crashes in klassItable::initialize_itable_for_interface
dsamersoff
parents: 7397
diff changeset
   799
32189
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   800
  // Check local default methods
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   801
  if ((default_methods != NULL) &&
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   802
    (InstanceKlass::find_method(default_methods, name, signature) != NULL))
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   803
   {
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   804
     return false;
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   805
   }
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   806
33602
16053580a684 8139163: InstanceKlass::cast passes through NULL
coleenp
parents: 33148
diff changeset
   807
  // Iterate on all superclasses, which should be InstanceKlasses.
32189
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   808
  // Note that we explicitly look for overpasses at each level.
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   809
  // Overpasses may or may not exist for supers for pass 1,
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   810
  // they should have been created for pass 2 and later.
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   811
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   812
  for (const Klass* cursuper = super; cursuper != NULL; cursuper = cursuper->super())
32189
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   813
  {
48463
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   814
     Method* found_mth = InstanceKlass::cast(cursuper)->find_local_method(name, signature,
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   815
       Klass::find_overpass, Klass::skip_static, Klass::skip_private);
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   816
     // Ignore non-public methods in java.lang.Object if klass is an interface.
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   817
     if (found_mth != NULL && (!is_interface ||
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   818
         !SystemDictionary::is_nonpublic_Object_method(found_mth))) {
32189
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   819
       return false;
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   820
     }
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   821
  }
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   822
5264b560ab1b 8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents: 31019
diff changeset
   823
  return true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   826
// Scans current_interface_methods for miranda methods that do not
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   827
// already appear in new_mirandas, or default methods,  and are also not defined-and-non-private
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   828
// in super (superclass).  These mirandas are added to all_mirandas if it is
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   829
// not null; in addition, those that are not duplicates of miranda methods
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   830
// inherited by super from its interfaces are added to new_mirandas.
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   831
// Thus, new_mirandas will be the set of mirandas that this class introduces,
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   832
// all_mirandas will be the set of all mirandas applicable to this class
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   833
// including all defined in superclasses.
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   834
void klassVtable::add_new_mirandas_to_lists(
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   835
    GrowableArray<Method*>* new_mirandas, GrowableArray<Method*>* all_mirandas,
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   836
    Array<Method*>* current_interface_methods, Array<Method*>* class_methods,
48463
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   837
    Array<Method*>* default_methods, const Klass* super, bool is_interface) {
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   838
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
  // iterate thru the current interface's method to see if it a miranda
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  int num_methods = current_interface_methods->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  for (int i = 0; i < num_methods; i++) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   842
    Method* im = current_interface_methods->at(i);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
    bool is_duplicate = false;
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   844
    int num_of_current_mirandas = new_mirandas->length();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
    // check for duplicate mirandas in different interfaces we implement
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
    for (int j = 0; j < num_of_current_mirandas; j++) {
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   847
      Method* miranda = new_mirandas->at(j);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
      if ((im->name() == miranda->name()) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
          (im->signature() == miranda->signature())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
        is_duplicate = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
    if (!is_duplicate) { // we don't want duplicate miranda entries in the vtable
48463
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   856
      if (is_miranda(im, class_methods, default_methods, super, is_interface)) { // is it a miranda at all?
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   857
        const InstanceKlass *sk = InstanceKlass::cast(super);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
        // check if it is a duplicate of a super's miranda
28731
f7339cba0a6a 8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents: 28373
diff changeset
   859
        if (sk->lookup_method_in_all_interfaces(im->name(), im->signature(), Klass::find_defaults) == NULL) {
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   860
          new_mirandas->append(im);
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   861
        }
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   862
        if (all_mirandas != NULL) {
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   863
          all_mirandas->append(im);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   870
void klassVtable::get_mirandas(GrowableArray<Method*>* new_mirandas,
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   871
                               GrowableArray<Method*>* all_mirandas,
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   872
                               const Klass* super,
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33611
diff changeset
   873
                               Array<Method*>* class_methods,
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   874
                               Array<Method*>* default_methods,
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
   875
                               Array<InstanceKlass*>* local_interfaces,
48463
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   876
                               bool is_interface) {
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   877
  assert((new_mirandas->length() == 0) , "current mirandas must be 0");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
  // iterate thru the local interfaces looking for a miranda
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
  int num_local_ifs = local_interfaces->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
  for (int i = 0; i < num_local_ifs; i++) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
   882
    InstanceKlass *ik = InstanceKlass::cast(local_interfaces->at(i));
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   883
    add_new_mirandas_to_lists(new_mirandas, all_mirandas,
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   884
                              ik->methods(), class_methods,
48463
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   885
                              default_methods, super, is_interface);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
    // iterate thru each local's super interfaces
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
   887
    Array<InstanceKlass*>* super_ifs = ik->transitive_interfaces();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
    int num_super_ifs = super_ifs->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
    for (int j = 0; j < num_super_ifs; j++) {
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
   890
      InstanceKlass *sik = super_ifs->at(j);
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   891
      add_new_mirandas_to_lists(new_mirandas, all_mirandas,
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   892
                                sik->methods(), class_methods,
48463
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   893
                                default_methods, super, is_interface);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   898
// Discover miranda methods ("miranda" = "interface abstract, no binding"),
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   899
// and append them into the vtable starting at index initialized,
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   900
// return the new value of initialized.
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
   901
// Miranda methods use vtable entries, but do not get assigned a vtable_index
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
   902
// The vtable_index is discovered by searching from the end of the vtable
51096
695dff91a997 8178712: ResourceMark may be missing inside initialize_[vi]table
lfoltan
parents: 50735
diff changeset
   903
int klassVtable::fill_in_mirandas(int initialized, TRAPS) {
695dff91a997 8178712: ResourceMark may be missing inside initialize_[vi]table
lfoltan
parents: 50735
diff changeset
   904
  ResourceMark rm(THREAD);
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   905
  GrowableArray<Method*> mirandas(20);
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   906
  get_mirandas(&mirandas, NULL, ik()->super(), ik()->methods(),
48463
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   907
               ik()->default_methods(), ik()->local_interfaces(),
474cec233fb2 8154587: Resolution fails for default method named 'clone'
hseigel
parents: 47765
diff changeset
   908
               klass()->is_interface());
14385
959bbcc16725 7200776: Implement default methods in interfaces
kamg
parents: 13952
diff changeset
   909
  for (int i = 0; i < mirandas.length(); i++) {
35901
f5028c67e7cb 8147918: Rename develop_log_is_enabled() to log_develop_is_enabled()
pliden
parents: 35898
diff changeset
   910
    if (log_develop_is_enabled(Trace, vtables)) {
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   911
      Method* meth = mirandas.at(i);
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   912
      LogTarget(Trace, vtables) lt;
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   913
      LogStream ls(lt);
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   914
      if (meth != NULL) {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   915
        char* sig = meth->name_and_sig_as_C_string();
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   916
        ls.print("fill in mirandas with %s index %d, flags: ",
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
   917
                     sig, initialized);
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   918
        meth->print_linkage_flags(&ls);
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
   919
        ls.cr();
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   920
      }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   921
    }
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   922
    put_method_at(mirandas.at(i), initialized);
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   923
    ++initialized;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
  }
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   925
  return initialized;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   928
// Copy this class's vtable to the vtable beginning at start.
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
   929
// Used to copy superclass vtable to prefix of subclass's vtable.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
void klassVtable::copy_vtable_to(vtableEntry* start) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
  Copy::disjoint_words((HeapWord*)table(), (HeapWord*)start, _length * vtableEntry::size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
   934
#if INCLUDE_JVMTI
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   935
bool klassVtable::adjust_default_method(int vtable_index, Method* old_method, Method* new_method) {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   936
  // If old_method is default, find this vtable index in default_vtable_indices
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   937
  // and replace that method in the _default_methods list
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   938
  bool updated = false;
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   939
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   940
  Array<Method*>* default_methods = ik()->default_methods();
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   941
  if (default_methods != NULL) {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   942
    int len = default_methods->length();
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   943
    for (int idx = 0; idx < len; idx++) {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   944
      if (vtable_index == ik()->default_vtable_indices()->at(idx)) {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   945
        if (default_methods->at(idx) == old_method) {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   946
          default_methods->at_put(idx, new_method);
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   947
          updated = true;
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   948
        }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   949
        break;
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   950
      }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   951
    }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   952
  }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   953
  return updated;
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
   954
}
29316
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   955
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   956
// search the vtable for uses of either obsolete or EMCP methods
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   957
void klassVtable::adjust_method_entries(InstanceKlass* holder, bool * trace_name_printed) {
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   958
  int prn_enabled = 0;
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   959
  for (int index = 0; index < length(); index++) {
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   960
    Method* old_method = unchecked_method_at(index);
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   961
    if (old_method == NULL || old_method->method_holder() != holder || !old_method->is_old()) {
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   962
      continue; // skip uninteresting entries
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   963
    }
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   964
    assert(!old_method->is_deleted(), "vtable methods may not be deleted");
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   965
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   966
    Method* new_method = holder->method_with_idnum(old_method->orig_method_idnum());
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   967
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   968
    assert(new_method != NULL, "method_with_idnum() should not be NULL");
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   969
    assert(old_method != new_method, "sanity check");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
29316
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   971
    put_method_at(new_method, index);
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   972
    // For default methods, need to update the _default_methods array
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   973
    // which can only have one method entry for a given signature
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   974
    bool updated_default = false;
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   975
    if (old_method->is_default_method()) {
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   976
      updated_default = adjust_default_method(index, old_method, new_method);
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   977
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
38259
b495d1cfe673 8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents: 37242
diff changeset
   979
    if (log_is_enabled(Info, redefine, class, update)) {
b495d1cfe673 8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents: 37242
diff changeset
   980
      ResourceMark rm;
29316
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   981
      if (!(*trace_name_printed)) {
38259
b495d1cfe673 8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents: 37242
diff changeset
   982
        log_info(redefine, class, update)
b495d1cfe673 8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents: 37242
diff changeset
   983
          ("adjust: klassname=%s for methods from name=%s",
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
   984
           _klass->external_name(), old_method->method_holder()->external_name());
29316
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
   985
        *trace_name_printed = true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
      }
38259
b495d1cfe673 8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents: 37242
diff changeset
   987
      log_debug(redefine, class, update, vtables)
b495d1cfe673 8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents: 37242
diff changeset
   988
        ("vtable method update: %s(%s), updated default = %s",
b495d1cfe673 8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents: 37242
diff changeset
   989
         new_method->name()->as_C_string(), new_method->signature()->as_C_string(), updated_default ? "true" : "false");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
   994
// a vtable should never contain old or obsolete methods
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
   995
bool klassVtable::check_no_old_or_obsolete_entries() {
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
   996
  for (int i = 0; i < length(); i++) {
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
   997
    Method* m = unchecked_method_at(i);
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
   998
    if (m != NULL &&
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
   999
        (NOT_PRODUCT(!m->is_valid() ||) m->is_old() || m->is_obsolete())) {
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1000
      return false;
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1001
    }
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1002
  }
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1003
  return true;
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1004
}
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1005
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1006
void klassVtable::dump_vtable() {
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1007
  tty->print_cr("vtable dump --");
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1008
  for (int i = 0; i < length(); i++) {
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1009
    Method* m = unchecked_method_at(i);
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1010
    if (m != NULL) {
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1011
      tty->print("      (%5d)  ", i);
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1012
      m->access_flags().print_on(tty);
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
  1013
      if (m->is_default_method()) {
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
  1014
        tty->print("default ");
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
  1015
      }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
  1016
      if (m->is_overpass()) {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
  1017
        tty->print("overpass");
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
  1018
      }
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1019
      tty->print(" --  ");
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1020
      m->print_name(tty);
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1021
      tty->cr();
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1022
    }
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1023
  }
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1024
}
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1025
#endif // INCLUDE_JVMTI
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1026
9172
a4e13ccafc44 7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents: 8725
diff changeset
  1027
// CDS/RedefineClasses support - clear vtables so they can be reinitialized
a4e13ccafc44 7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents: 8725
diff changeset
  1028
void klassVtable::clear_vtable() {
a4e13ccafc44 7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents: 8725
diff changeset
  1029
  for (int i = 0; i < _length; i++) table()[i].clear();
a4e13ccafc44 7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents: 8725
diff changeset
  1030
}
a4e13ccafc44 7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents: 8725
diff changeset
  1031
a4e13ccafc44 7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents: 8725
diff changeset
  1032
bool klassVtable::is_initialized() {
a4e13ccafc44 7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents: 8725
diff changeset
  1033
  return _length == 0 || table()[0].method() != NULL;
a4e13ccafc44 7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents: 8725
diff changeset
  1034
}
a4e13ccafc44 7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents: 8725
diff changeset
  1035
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
//-----------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
// Itable code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
// Initialize a itableMethodEntry
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
  1040
void itableMethodEntry::initialize(Method* m) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
  if (m == NULL) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
46413
b0f67ec8f6be 8178543: Optimize Klass::is_shared()
iklam
parents: 46408
diff changeset
  1043
#ifdef ASSERT
48794
ea0d0781c63c 8178351: Simplify MetaspaceShared::is_in_shared_space and MetaspaceObj::is_shared
iklam
parents: 48463
diff changeset
  1044
  if (MetaspaceShared::is_in_shared_metaspace((void*)&_method) &&
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
  1045
     !MetaspaceShared::remapped_readwrite()) {
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
  1046
    // At runtime initialize_itable is rerun as part of link_class_impl()
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
  1047
    // for a shared class loaded by the non-boot loader.
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
  1048
    // The dumptime itable method entry should be the same as the runtime entry.
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
  1049
    assert(_method == m, "sanity");
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
  1050
  }
46413
b0f67ec8f6be 8178543: Optimize Klass::is_shared()
iklam
parents: 46408
diff changeset
  1051
#endif
b0f67ec8f6be 8178543: Optimize Klass::is_shared()
iklam
parents: 46408
diff changeset
  1052
  _method = m;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
  1055
klassItable::klassItable(InstanceKlass* klass) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
  _klass = klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
  if (klass->itable_length() > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
    itableOffsetEntry* offset_entry = (itableOffsetEntry*)klass->start_of_itable();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
    if (offset_entry  != NULL && offset_entry->interface_klass() != NULL) { // Check that itable is initialized
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
      // First offset entry points to the first method_entry
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
  1062
      intptr_t* method_entry  = (intptr_t *)(((address)klass) + offset_entry->offset());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
      intptr_t* end         = klass->end_of_itable();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
  1065
      _table_offset      = (intptr_t*)offset_entry - (intptr_t*)klass;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
      _size_offset_table = (method_entry - ((intptr_t*)offset_entry)) / itableOffsetEntry::size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
      _size_method_table = (end - method_entry)                  / itableMethodEntry::size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
      assert(_table_offset >= 0 && _size_offset_table >= 0 && _size_method_table >= 0, "wrong computation");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
189
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
  1073
  // The length of the itable was either zero, or it has not yet been initialized.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
  _table_offset      = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
  _size_offset_table = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
  _size_method_table = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
static int initialize_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
// Initialization
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
void klassItable::initialize_itable(bool checkconstraints, TRAPS) {
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1083
  if (_klass->is_interface()) {
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
  1084
    // This needs to go after vtable indices are assigned but
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
  1085
    // before implementors need to know the number of itable indices.
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1086
    assign_itable_indices_for_interface(InstanceKlass::cast(_klass), THREAD);
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1087
  }
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1088
189
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
  1089
  // Cannot be setup doing bootstrapping, interfaces don't have
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
  1090
  // itables, and klass with only ones entry have empty itables
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
  1091
  if (Universe::is_bootstrapping() ||
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
  1092
      _klass->is_interface() ||
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
  1093
      _klass->itable_length() == itableOffsetEntry::size()) return;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
189
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
  1095
  // There's alway an extra itable entry so we can null-terminate it.
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
  1096
  guarantee(size_offset_table() >= 1, "too small");
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
  1097
  int num_interfaces = size_offset_table() - 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
  if (num_interfaces > 0) {
51096
695dff91a997 8178712: ResourceMark may be missing inside initialize_[vi]table
lfoltan
parents: 50735
diff changeset
  1099
    ResourceMark rm(THREAD);
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
  1100
    log_develop_debug(itables)("%3d: Initializing itables for %s", ++initialize_count,
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
  1101
                       _klass->name()->as_C_string());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
2264
55d0115a54fe 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 2136
diff changeset
  1104
    // Iterate through all interfaces
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
    int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
    for(i = 0; i < num_interfaces; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
      itableOffsetEntry* ioe = offset_entry(i);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
  1108
      HandleMark hm(THREAD);
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
  1109
      Klass* interf = ioe->interface_klass();
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
  1110
      assert(interf != NULL && ioe->offset() != 0, "bad offset entry in itable");
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1111
      initialize_itable_for_interface(ioe->offset(), InstanceKlass::cast(interf), checkconstraints, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
  }
189
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
  1115
  // Check that the last entry is empty
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
  1116
  itableOffsetEntry* ioe = offset_entry(size_offset_table() - 1);
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
  1117
  guarantee(ioe->interface_klass() == NULL && ioe->offset() == 0, "terminator entry missing");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1121
inline bool interface_method_needs_itable_index(Method* m) {
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1122
  if (m->is_static())           return false;   // e.g., Stream.empty
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1123
  if (m->is_initializer())      return false;   // <init> or <clinit>
50735
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 50036
diff changeset
  1124
  if (m->is_private())          return false;   // uses direct call
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1125
  // If an interface redeclares a method from java.lang.Object,
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1126
  // it should already have a vtable index, don't touch it.
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1127
  // e.g., CharSequence.toString (from initialize_vtable)
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1128
  // if (m->has_vtable_index())  return false; // NO!
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1129
  return true;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1130
}
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1131
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1132
int klassItable::assign_itable_indices_for_interface(InstanceKlass* klass, TRAPS) {
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1133
  // an interface does not have an itable, but its methods need to be numbered
51096
695dff91a997 8178712: ResourceMark may be missing inside initialize_[vi]table
lfoltan
parents: 50735
diff changeset
  1134
  ResourceMark rm(THREAD);
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
  1135
  log_develop_debug(itables)("%3d: Initializing itable indices for interface %s",
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
  1136
                             ++initialize_count, klass->name()->as_C_string());
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1137
  Array<Method*>* methods = klass->methods();
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1138
  int nof_methods = methods->length();
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1139
  int ime_num = 0;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1140
  for (int i = 0; i < nof_methods; i++) {
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1141
    Method* m = methods->at(i);
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1142
    if (interface_method_needs_itable_index(m)) {
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1143
      assert(!m->is_final_method(), "no final interface methods");
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1144
      // If m is already assigned a vtable index, do not disturb it.
35901
f5028c67e7cb 8147918: Rename develop_log_is_enabled() to log_develop_is_enabled()
pliden
parents: 35898
diff changeset
  1145
      if (log_develop_is_enabled(Trace, itables)) {
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
  1146
        LogTarget(Trace, itables) lt;
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
  1147
        LogStream ls(lt);
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
  1148
        assert(m != NULL, "methods can never be null");
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
  1149
        const char* sig = m->name_and_sig_as_C_string();
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
  1150
        if (m->has_vtable_index()) {
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
  1151
          ls.print("vtable index %d for method: %s, flags: ", m->vtable_index(), sig);
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
  1152
        } else {
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
  1153
          ls.print("itable index %d for method: %s, flags: ", ime_num, sig);
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
  1154
        }
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
  1155
        m->print_linkage_flags(&ls);
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
  1156
        ls.cr();
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
  1157
      }
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1158
      if (!m->has_vtable_index()) {
39714
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
  1159
        // A shared method could have an initialized itable_index that
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
  1160
        // is < 0.
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
  1161
        assert(m->vtable_index() == Method::pending_itable_index ||
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
  1162
               m->is_shared(),
976b97b59d87 8153312: Constrain AppCDS behavior
jiangli
parents: 38259
diff changeset
  1163
               "set by initialize_vtable");
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1164
        m->set_itable_index(ime_num);
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1165
        // Progress to next itable entry
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1166
        ime_num++;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1167
      }
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1168
    }
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1169
  }
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1170
  assert(ime_num == method_count_for_interface(klass), "proper sizing");
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1171
  return ime_num;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1172
}
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1173
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1174
int klassItable::method_count_for_interface(InstanceKlass* interf) {
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1175
  assert(interf->is_interface(), "must be");
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1176
  Array<Method*>* methods = interf->methods();
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1177
  int nof_methods = methods->length();
30615
4713e7c7b96f 8030680: 292 cleanup from default method code assessment
acorn
parents: 29871
diff changeset
  1178
  int length = 0;
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1179
  while (nof_methods > 0) {
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1180
    Method* m = methods->at(nof_methods-1);
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1181
    if (m->has_itable_index()) {
30615
4713e7c7b96f 8030680: 292 cleanup from default method code assessment
acorn
parents: 29871
diff changeset
  1182
      length = m->itable_index() + 1;
4713e7c7b96f 8030680: 292 cleanup from default method code assessment
acorn
parents: 29871
diff changeset
  1183
      break;
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1184
    }
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1185
    nof_methods -= 1;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1186
  }
30615
4713e7c7b96f 8030680: 292 cleanup from default method code assessment
acorn
parents: 29871
diff changeset
  1187
#ifdef ASSERT
4713e7c7b96f 8030680: 292 cleanup from default method code assessment
acorn
parents: 29871
diff changeset
  1188
  int nof_methods_copy = nof_methods;
4713e7c7b96f 8030680: 292 cleanup from default method code assessment
acorn
parents: 29871
diff changeset
  1189
  while (nof_methods_copy > 0) {
4713e7c7b96f 8030680: 292 cleanup from default method code assessment
acorn
parents: 29871
diff changeset
  1190
    Method* mm = methods->at(--nof_methods_copy);
4713e7c7b96f 8030680: 292 cleanup from default method code assessment
acorn
parents: 29871
diff changeset
  1191
    assert(!mm->has_itable_index() || mm->itable_index() < length, "");
4713e7c7b96f 8030680: 292 cleanup from default method code assessment
acorn
parents: 29871
diff changeset
  1192
  }
4713e7c7b96f 8030680: 292 cleanup from default method code assessment
acorn
parents: 29871
diff changeset
  1193
#endif //ASSERT
4713e7c7b96f 8030680: 292 cleanup from default method code assessment
acorn
parents: 29871
diff changeset
  1194
  // return the rightmost itable index, plus one; or 0 if no methods have
4713e7c7b96f 8030680: 292 cleanup from default method code assessment
acorn
parents: 29871
diff changeset
  1195
  // itable indices
4713e7c7b96f 8030680: 292 cleanup from default method code assessment
acorn
parents: 29871
diff changeset
  1196
  return length;
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1197
}
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1198
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1199
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1200
void klassItable::initialize_itable_for_interface(int method_table_offset, InstanceKlass* interf, bool checkconstraints, TRAPS) {
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1201
  assert(interf->is_interface(), "must be");
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1202
  Array<Method*>* methods = interf->methods();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
  1203
  int nof_methods = methods->length();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
  HandleMark hm;
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1205
  Handle interface_loader (THREAD, interf->class_loader());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
  1207
  int ime_count = method_count_for_interface(interf);
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1208
  for (int i = 0; i < nof_methods; i++) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
  1209
    Method* m = methods->at(i);
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1210
    methodHandle target;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1211
    if (m->has_itable_index()) {
22232
26acfad336c0 8027804: JCK resolveMethod test fails expecting AbstractMethodError
hseigel
parents: 21913
diff changeset
  1212
      // This search must match the runtime resolution, i.e. selection search for invokeinterface
50735
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 50036
diff changeset
  1213
      // to correctly enforce loader constraints for interface method inheritance.
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 50036
diff changeset
  1214
      // Private methods are skipped as a private class method can never be the implementation
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 50036
diff changeset
  1215
      // of an interface method.
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 50036
diff changeset
  1216
      // Invokespecial does not perform selection based on the receiver, so it does not use
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 50036
diff changeset
  1217
      // the cached itable.
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 50036
diff changeset
  1218
      target = LinkResolver::lookup_instance_method_in_klasses(_klass, m->name(), m->signature(),
2f2af62dfac7 8010319: Implementation of JEP 181: Nest-Based Access Control
dholmes
parents: 50036
diff changeset
  1219
                                                               Klass::skip_private, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
    }
47554
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
  1221
    if (target == NULL || !target->is_public() || target->is_abstract() || target->is_overpass()) {
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
  1222
      assert(target == NULL || !target->is_overpass() || target->is_public(),
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
  1223
             "Non-public overpass method!");
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
  1224
      // Entry does not resolve. Leave it empty for AbstractMethodError or other error.
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
  1225
      if (!(target == NULL) && !target->is_public()) {
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
  1226
        // Stuff an IllegalAccessError throwing method in there instead.
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
  1227
        itableOffsetEntry::method_entry(_klass, method_table_offset)[m->itable_index()].
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
  1228
            initialize(Universe::throw_illegal_access_error());
bc112140e089 8186092: Unnecessary loader constraints produced when there are multiple defaults
hseigel
parents: 47216
diff changeset
  1229
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
      // Entry did resolve, check loader constraints before initializing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
      // if checkconstraints requested
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
      if (checkconstraints) {
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 14385
diff changeset
  1234
        Handle method_holder_loader (THREAD, target->method_holder()->class_loader());
49658
8237a91c1cca 8199781: Don't use naked == for comparing oops
rkennke
parents: 49594
diff changeset
  1235
        if (!oopDesc::equals(method_holder_loader(), interface_loader())) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
          ResourceMark rm(THREAD);
16591
73047b0eb568 8009731: Confusing error message for loader constraint violation
acorn
parents: 15591
diff changeset
  1237
          Symbol* failed_type_symbol =
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1238
            SystemDictionary::check_signature_loaders(m->signature(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
                                                      method_holder_loader,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
                                                      interface_loader,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
                                                      true, CHECK);
16591
73047b0eb568 8009731: Confusing error message for loader constraint violation
acorn
parents: 15591
diff changeset
  1242
          if (failed_type_symbol != NULL) {
51097
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
  1243
            stringStream ss;
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
  1244
            ss.print("loader constraint violation in interface itable"
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
  1245
                     " initialization for class %s: when selecting method %s the"
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
  1246
                     " class loader %s for super interface %s, and the class"
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
  1247
                     " loader %s of the selected method's type, %s have"
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
  1248
                     " different Class objects for the type %s used in the signature (%s; %s)",
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
  1249
                     _klass->external_name(),
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
  1250
                     m->name_and_sig_as_C_string(),
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
  1251
                     interf->class_loader_data()->loader_name_and_id(),
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
  1252
                     interf->external_name(),
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
  1253
                     target()->method_holder()->class_loader_data()->loader_name_and_id(),
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
  1254
                     target()->method_holder()->external_name(),
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
  1255
                     failed_type_symbol->as_klass_external_name(),
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
  1256
                     interf->class_in_module_of_loader(false, true),
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
  1257
                     target()->method_holder()->class_in_module_of_loader(false, true));
bef02342d179 8205611: Improve the wording of LinkageErrors to include module and class loader information
lfoltan
parents: 51096
diff changeset
  1258
            THROW_MSG(vmSymbols::java_lang_LinkageError(), ss.as_string());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
      // ime may have moved during GC so recalculate address
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1264
      int ime_num = m->itable_index();
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1265
      assert(ime_num < ime_count, "oob");
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
  1266
      itableOffsetEntry::method_entry(_klass, method_table_offset)[ime_num].initialize(target());
35901
f5028c67e7cb 8147918: Rename develop_log_is_enabled() to log_develop_is_enabled()
pliden
parents: 35898
diff changeset
  1267
      if (log_develop_is_enabled(Trace, itables)) {
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
  1268
        ResourceMark rm(THREAD);
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
  1269
        if (target() != NULL) {
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
  1270
          LogTarget(Trace, itables) lt;
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
  1271
          LogStream ls(lt);
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
  1272
          char* sig = target()->name_and_sig_as_C_string();
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
  1273
          ls.print("interface: %s, ime_num: %d, target: %s, method_holder: %s ",
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
  1274
                       interf->internal_name(), ime_num, sig,
35463
b32e362563bb 8141564: Convert TraceItables and PrintVtables to Unified Logging
rprotacio
parents: 34666
diff changeset
  1275
                       target()->method_holder()->internal_name());
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
  1276
          ls.print("target_method flags: ");
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
  1277
          target()->print_linkage_flags(&ls);
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46560
diff changeset
  1278
          ls.cr();
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
  1279
        }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
  1280
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1285
#if INCLUDE_JVMTI
29316
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1286
// search the itable for uses of either obsolete or EMCP methods
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1287
void klassItable::adjust_method_entries(InstanceKlass* holder, bool * trace_name_printed) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
29316
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1289
  itableMethodEntry* ime = method_entry(0);
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1290
  for (int i = 0; i < _size_method_table; i++, ime++) {
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1291
    Method* old_method = ime->method();
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1292
    if (old_method == NULL || old_method->method_holder() != holder || !old_method->is_old()) {
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1293
      continue; // skip uninteresting entries
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1294
    }
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1295
    assert(!old_method->is_deleted(), "itable methods may not be deleted");
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1296
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1297
    Method* new_method = holder->method_with_idnum(old_method->orig_method_idnum());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
29316
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1299
    assert(new_method != NULL, "method_with_idnum() should not be NULL");
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1300
    assert(old_method != new_method, "sanity check");
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1301
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1302
    ime->initialize(new_method);
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1303
38259
b495d1cfe673 8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents: 37242
diff changeset
  1304
    if (log_is_enabled(Info, redefine, class, update)) {
b495d1cfe673 8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents: 37242
diff changeset
  1305
      ResourceMark rm;
29316
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1306
      if (!(*trace_name_printed)) {
38259
b495d1cfe673 8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents: 37242
diff changeset
  1307
        log_info(redefine, class, update)("adjust: name=%s", old_method->method_holder()->external_name());
29316
5287df8a8972 8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents: 28731
diff changeset
  1308
        *trace_name_printed = true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
      }
38259
b495d1cfe673 8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents: 37242
diff changeset
  1310
      log_trace(redefine, class, update, itables)
b495d1cfe673 8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents: 37242
diff changeset
  1311
        ("itable method update: %s(%s)", new_method->name()->as_C_string(), new_method->signature()->as_C_string());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1316
// an itable should never contain old or obsolete methods
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1317
bool klassItable::check_no_old_or_obsolete_entries() {
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1318
  itableMethodEntry* ime = method_entry(0);
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1319
  for (int i = 0; i < _size_method_table; i++) {
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1320
    Method* m = ime->method();
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1321
    if (m != NULL &&
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1322
        (NOT_PRODUCT(!m->is_valid() ||) m->is_old() || m->is_obsolete())) {
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1323
      return false;
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1324
    }
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1325
    ime++;
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1326
  }
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1327
  return true;
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1328
}
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1329
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1330
void klassItable::dump_itable() {
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1331
  itableMethodEntry* ime = method_entry(0);
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1332
  tty->print_cr("itable dump --");
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1333
  for (int i = 0; i < _size_method_table; i++) {
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1334
    Method* m = ime->method();
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1335
    if (m != NULL) {
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1336
      tty->print("      (%5d)  ", i);
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1337
      m->access_flags().print_on(tty);
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
  1338
      if (m->is_default_method()) {
21556
e75cd34a59e0 8027229: ICCE expected for >=2 maximally specific default methods.
acorn
parents: 20391
diff changeset
  1339
        tty->print("default ");
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
  1340
      }
15591
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1341
      tty->print(" --  ");
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1342
      m->print_name(tty);
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1343
      tty->cr();
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1344
    }
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1345
    ime++;
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1346
  }
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1347
}
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1348
#endif // INCLUDE_JVMTI
b8aa0577f137 7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents: 14488
diff changeset
  1349
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
// Setup
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
class InterfaceVisiterClosure : public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
 public:
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1353
  virtual void doit(InstanceKlass* intf, int method_count) = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1356
// Visit all interfaces with at least one itable method
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1357
void visit_all_interfaces(Array<InstanceKlass*>* transitive_intf, InterfaceVisiterClosure *blk) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
  // Handle array argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
  for(int i = 0; i < transitive_intf->length(); i++) {
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1360
    InstanceKlass* intf = transitive_intf->at(i);
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
  1361
    assert(intf->is_interface(), "sanity check");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1363
    // Find no. of itable methods
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1364
    int method_count = 0;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1365
    // method_count = klassItable::method_count_for_interface(intf);
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1366
    Array<Method*>* methods = intf->methods();
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1367
    if (methods->length() > 0) {
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1368
      for (int i = methods->length(); --i >= 0; ) {
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1369
        if (interface_method_needs_itable_index(methods->at(i))) {
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1370
          method_count++;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1371
        }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
48557
2e867226b914 8174962: Better interface invocations
vlivanov
parents: 47765
diff changeset
  1375
    // Visit all interfaces which either have any methods or can participate in receiver type check.
2e867226b914 8174962: Better interface invocations
vlivanov
parents: 47765
diff changeset
  1376
    // We do not bother to count methods in transitive interfaces, although that would allow us to skip
2e867226b914 8174962: Better interface invocations
vlivanov
parents: 47765
diff changeset
  1377
    // this step in the rare case of a zero-method interface extending another zero-method interface.
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1378
    if (method_count > 0 || intf->transitive_interfaces()->length() > 0) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
      blk->doit(intf, method_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
class CountInterfacesClosure : public InterfaceVisiterClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
  int _nof_methods;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1387
  int _nof_interfaces;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
   CountInterfacesClosure() { _nof_methods = 0; _nof_interfaces = 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1391
   int nof_methods() const    { return _nof_methods; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
   int nof_interfaces() const { return _nof_interfaces; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1394
   void doit(InstanceKlass* intf, int method_count) { _nof_methods += method_count; _nof_interfaces++; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
class SetupItableClosure : public InterfaceVisiterClosure  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
  itableOffsetEntry* _offset_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
  itableMethodEntry* _method_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
  address            _klass_begin;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
  SetupItableClosure(address klass_begin, itableOffsetEntry* offset_entry, itableMethodEntry* method_entry) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
    _klass_begin  = klass_begin;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
    _offset_entry = offset_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
    _method_entry = method_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
  itableMethodEntry* method_entry() const { return _method_entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1411
  void doit(InstanceKlass* intf, int method_count) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
    int offset = ((address)_method_entry) - _klass_begin;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
    _offset_entry->initialize(intf, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
    _offset_entry++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
    _method_entry += method_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1419
int klassItable::compute_itable_size(Array<InstanceKlass*>* transitive_interfaces) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
  // Count no of interfaces and total number of interface methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
  CountInterfacesClosure cic;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
  1422
  visit_all_interfaces(transitive_interfaces, &cic);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
189
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
  1424
  // There's alway an extra itable entry so we can null-terminate it.
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
  1425
  int itable_size = calc_itable_size(cic.nof_interfaces() + 1, cic.nof_methods());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
  // Statistics
35898
ddc274f0052f 8145628: hotspot metadata classes shouldn't use HeapWordSize or heap related macros like align_object_size
coleenp
parents: 35492
diff changeset
  1428
  update_stats(itable_size * wordSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
  return itable_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1432
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1433
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
// Fill out offset table and interface klasses into the itable space
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
  1435
void klassItable::setup_itable_offset_table(InstanceKlass* klass) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
  if (klass->itable_length() == 0) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
  assert(!klass->is_interface(), "Should have zero length itable");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
  // Count no of interfaces and total number of interface methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
  CountInterfacesClosure cic;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
  visit_all_interfaces(klass->transitive_interfaces(), &cic);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
  int nof_methods    = cic.nof_methods();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
  int nof_interfaces = cic.nof_interfaces();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
189
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
  1445
  // Add one extra entry so we can null-terminate the table
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
  1446
  nof_interfaces++;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
  1448
  assert(compute_itable_size(klass->transitive_interfaces()) ==
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
         calc_itable_size(nof_interfaces, nof_methods),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
         "mismatch calculation of itable size");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
  // Fill-out offset table
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
  itableOffsetEntry* ioe = (itableOffsetEntry*)klass->start_of_itable();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1454
  itableMethodEntry* ime = (itableMethodEntry*)(ioe + nof_interfaces);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
  intptr_t* end               = klass->end_of_itable();
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8653
diff changeset
  1456
  assert((oop*)(ime + nof_methods) <= (oop*)klass->start_of_nonstatic_oop_maps(), "wrong offset calculation (1)");
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 189
diff changeset
  1457
  assert((oop*)(end) == (oop*)(ime + nof_methods),                      "wrong offset calculation (2)");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
  // Visit all interfaces and initialize itable offset table
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
  1460
  SetupItableClosure sic((address)klass, ioe, ime);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
  visit_all_interfaces(klass->transitive_interfaces(), &sic);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1462
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
  ime  = sic.method_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
  oop* v = (oop*) klass->end_of_itable();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
  assert( (oop*)(ime) == v, "wrong offset calculation (2)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1467
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1471
// inverse to itable_index
51329
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1472
Method* klassItable::method_for_itable_index(InstanceKlass* intf, int itable_index) {
9c68699bebe5 8208999: Some use of Klass* should be replaced by InstanceKlass*
iklam
parents: 51097
diff changeset
  1473
  assert(intf->is_interface(), "sanity check");
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1474
  assert(intf->verify_itable_index(itable_index), "");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
  1475
  Array<Method*>* methods = InstanceKlass::cast(intf)->methods();
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 2136
diff changeset
  1476
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1477
  if (itable_index < 0 || itable_index >= method_count_for_interface(intf))
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20284
diff changeset
  1478
    return NULL;                // help caller defend against bad indices
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1479
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 2136
diff changeset
  1480
  int index = itable_index;
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1481
  Method* m = methods->at(index);
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1482
  int index2 = -1;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1483
  while (!m->has_itable_index() ||
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1484
         (index2 = m->itable_index()) != itable_index) {
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1485
    assert(index2 < itable_index, "monotonic");
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1486
    if (++index == methods->length())
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1487
      return NULL;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1488
    m = methods->at(index);
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 2136
diff changeset
  1489
  }
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17092
diff changeset
  1490
  assert(m->itable_index() == itable_index, "correct inverse");
2332
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 2136
diff changeset
  1491
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 2136
diff changeset
  1492
  return m;
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 2136
diff changeset
  1493
}
5c7b6f4ce0a1 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 2136
diff changeset
  1494
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
void klassVtable::verify(outputStream* st, bool forced) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
  // make sure table is initialized
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
  if (!Universe::is_fully_initialized()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1499
  // avoid redundant verifies
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
  if (!forced && _verify_count == Universe::verify_count()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
  _verify_count = Universe::verify_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1502
#endif
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
  1503
  oop* end_of_obj = (oop*)_klass + _klass->size();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1504
  oop* end_of_vtable = (oop *)&table()[_length];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1505
  if (end_of_vtable > end_of_obj) {
51096
695dff91a997 8178712: ResourceMark may be missing inside initialize_[vi]table
lfoltan
parents: 50735
diff changeset
  1506
    ResourceMark rm;
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32189
diff changeset
  1507
    fatal("klass %s: klass object too short (vtable extends beyond end)",
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32189
diff changeset
  1508
          _klass->internal_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
  for (int i = 0; i < _length; i++) table()[i].verify(this, st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
  // verify consistency with superKlass vtable
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
  1513
  Klass* super = _klass->super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
  if (super != NULL) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
  1515
    InstanceKlass* sk = InstanceKlass::cast(super);
46408
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
  1516
    klassVtable vt = sk->vtable();
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
  1517
    for (int i = 0; i < vt.length(); i++) {
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
  1518
      verify_against(st, &vt, i);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
void klassVtable::verify_against(outputStream* st, klassVtable* vt, int index) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
  vtableEntry* vte = &vt->table()[index];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
  if (vte->method()->name()      != table()[index].method()->name() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1526
      vte->method()->signature() != table()[index].method()->signature()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
    fatal("mismatched name/signature of vtable entries");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1530
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
void klassVtable::print() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1533
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1534
  tty->print("klassVtable for klass %s (length %d):\n", _klass->internal_name(), length());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1535
  for (int i = 0; i < length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
    table()[i].print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
    tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1539
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
void vtableEntry::verify(klassVtable* vt, outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
  NOT_PRODUCT(FlagSetting fs(IgnoreLockingAssertions, true));
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
  1544
  Klass* vtklass = vt->klass();
40633
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
  1545
  if (vtklass->is_instance_klass() &&
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
  1546
     (InstanceKlass::cast(vtklass)->major_version() >= klassVtable::VTABLE_TRANSITIVE_OVERRIDE_VERSION)) {
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
  1547
    assert(method() != NULL, "must have set method");
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
  1548
  }
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
  1549
  if (method() != NULL) {
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
  1550
    method()->verify();
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
  1551
    // we sub_type, because it could be a miranda method
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 41669
diff changeset
  1552
    if (!vtklass->is_subtype_of(method()->method_holder())) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
#ifndef PRODUCT
40633
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
  1554
      print();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1555
#endif
40633
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
  1556
      fatal("vtableEntry " PTR_FORMAT ": method is from subclass", p2i(this));
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
  1557
    }
c33ad2ff51de 8163808: Fix asserts and logging for old classfile vtable construction
acorn
parents: 39714
diff changeset
  1558
 }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
void vtableEntry::print() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
  tty->print("vtableEntry %s: ", method()->name()->as_C_string());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
  if (Verbose) {
33148
68fa8b6c4340 8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 33105
diff changeset
  1567
    tty->print("m " PTR_FORMAT " ", p2i(method()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
class VtableStats : AllStatic {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
  static int no_klasses;                // # classes with vtables
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
  static int no_array_klasses;          // # array classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
  static int no_instance_klasses;       // # instanceKlasses
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
  static int sum_of_vtable_len;         // total # of vtable entries
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
  static int sum_of_array_vtable_len;   // total # of vtable entries in array klasses only
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
  static int fixed;                     // total fixed overhead in bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
  static int filler;                    // overhead caused by filler bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1580
  static int entries;                   // total bytes consumed by vtable entries
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
  static int array_entries;             // total bytes consumed by array vtable entries
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
  1583
  static void do_class(Klass* k) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 9172
diff changeset
  1584
    Klass* kl = k;
46408
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
  1585
    klassVtable vt = kl->vtable();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
    no_klasses++;
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33602
diff changeset
  1587
    if (kl->is_instance_klass()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
      no_instance_klasses++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
      kl->array_klasses_do(do_class);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
    }
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33602
diff changeset
  1591
    if (kl->is_array_klass()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
      no_array_klasses++;
46408
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
  1593
      sum_of_array_vtable_len += vt.length();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
    }
46408
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 46329
diff changeset
  1595
    sum_of_vtable_len += vt.length();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
  static void compute() {
51608
625a5bdde0c5 8210155: Lock ClassLoaderDataGraph
coleenp
parents: 51329
diff changeset
  1599
    LockedClassesDo locked_do_class(&do_class);
625a5bdde0c5 8210155: Lock ClassLoaderDataGraph
coleenp
parents: 51329
diff changeset
  1600
    ClassLoaderDataGraph::classes_do(&locked_do_class);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
    fixed  = no_klasses * oopSize;      // vtable length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
    // filler size is a conservative approximation
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
  1603
    filler = oopSize * (no_klasses - no_instance_klasses) * (sizeof(InstanceKlass) - sizeof(ArrayKlass) - 1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
    entries = sizeof(vtableEntry) * sum_of_vtable_len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
    array_entries = sizeof(vtableEntry) * sum_of_array_vtable_len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
int VtableStats::no_klasses = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
int VtableStats::no_array_klasses = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
int VtableStats::no_instance_klasses = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
int VtableStats::sum_of_vtable_len = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
int VtableStats::sum_of_array_vtable_len = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
int VtableStats::fixed = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
int VtableStats::filler = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
int VtableStats::entries = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
int VtableStats::array_entries = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1618
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
void klassVtable::print_statistics() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
  HandleMark hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1622
  VtableStats::compute();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
  tty->print_cr("vtable statistics:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
  tty->print_cr("%6d classes (%d instance, %d array)", VtableStats::no_klasses, VtableStats::no_instance_klasses, VtableStats::no_array_klasses);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
  int total = VtableStats::fixed + VtableStats::filler + VtableStats::entries;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
  tty->print_cr("%6d bytes fixed overhead (refs + vtable object header)", VtableStats::fixed);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1627
  tty->print_cr("%6d bytes filler overhead", VtableStats::filler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1628
  tty->print_cr("%6d bytes for vtable entries (%d for arrays)", VtableStats::entries, VtableStats::array_entries);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1629
  tty->print_cr("%6d bytes total", total);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1631
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
int  klassItable::_total_classes;   // Total no. of classes with itables
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
long klassItable::_total_size;      // Total no. of bytes used for itables
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
void klassItable::print_statistics() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1636
 tty->print_cr("itable statistics:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
 tty->print_cr("%6d classes with itables", _total_classes);
33148
68fa8b6c4340 8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 33105
diff changeset
  1638
 tty->print_cr("%6lu K uses for itables (average by class: %ld bytes)", _total_size / K, _total_size / _total_classes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
#endif // PRODUCT