truffle: src/share/vm/oops/instanceKlass.cpp annotate

annotate src/share/vm/oops/instanceKlass.cpp @ 14649:f6301b007a16

6498581: ThreadInterruptTest3 produces wrong output on Windows Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set. Reviewed-by: acorn, kvn Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com

author	minqi
date	Wed, 26 Feb 2014 15:20:41 -0800
parents	016b6a289fc4
children	7d30d4f37d31

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
14378 48314d596a04 8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on coleenp parents: 14221 diff changeset	2 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1490 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1490 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1490 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	26 #include "classfile/javaClasses.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	27 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	28 #include "classfile/verifier.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	29 #include "classfile/vmSymbols.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	30 #include "compiler/compileBroker.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	31 #include "gc_implementation/shared/markSweep.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	32 #include "gc_interface/collectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	33 #include "interpreter/oopMapCache.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	34 #include "interpreter/rewriter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	35 #include "jvmtifiles/jvmti.h"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	36 #include "memory/genOopClosures.inline.hpp"
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	37 #include "memory/heapInspection.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	38 #include "memory/metadataFactory.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	39 #include "memory/oopFactory.hpp"
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	40 #include "oops/fieldStreams.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	41 #include "oops/instanceClassLoaderKlass.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	42 #include "oops/instanceKlass.hpp"
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	43 #include "oops/instanceMirrorKlass.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	44 #include "oops/instanceOop.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	45 #include "oops/klass.inline.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	46 #include "oops/method.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	47 #include "oops/oop.inline.hpp"
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	48 #include "oops/symbol.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	49 #include "prims/jvmtiExport.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	50 #include "prims/jvmtiRedefineClassesTrace.hpp"
11148 825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	51 #include "prims/jvmtiRedefineClasses.hpp"
14481 016b6a289fc4 4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException jbachorik parents: 14465 diff changeset	52 #include "prims/jvmtiThreadState.hpp"
7459 cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	53 #include "prims/methodComparator.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	54 #include "runtime/fieldDescriptor.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	55 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	56 #include "runtime/javaCalls.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	57 #include "runtime/mutexLocker.hpp"
7180 f34d701e952e 8003935: Simplify the needed includes for using Thread::current() stefank parents: 6985 diff changeset	58 #include "runtime/thread.inline.hpp"
10149 d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	59 #include "services/classLoadingService.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	60 #include "services/threadService.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	61 #include "utilities/dtrace.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	62 #include "utilities/macros.hpp"
db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	63 #if INCLUDE_ALL_GCS
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	64 #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	65 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	66 #include "gc_implementation/g1/g1OopClosures.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	67 #include "gc_implementation/g1/g1RemSet.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	68 #include "gc_implementation/g1/heapRegionSeq.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	69 #include "gc_implementation/parNew/parOopClosures.inline.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	70 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.inline.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	71 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	72 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	73 #include "oops/oop.pcgc.inline.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	74 #endif // INCLUDE_ALL_GCS
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	75 #ifdef COMPILER1
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	76 #include "c1/c1_Compiler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	77 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	78
1324 e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	79 #ifdef DTRACE_ENABLED
e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	80
4006 436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	81
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	82 #define HOTSPOT_CLASS_INITIALIZATION_required HOTSPOT_CLASS_INITIALIZATION_REQUIRED
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	83 #define HOTSPOT_CLASS_INITIALIZATION_recursive HOTSPOT_CLASS_INITIALIZATION_RECURSIVE
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	84 #define HOTSPOT_CLASS_INITIALIZATION_concurrent HOTSPOT_CLASS_INITIALIZATION_CONCURRENT
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	85 #define HOTSPOT_CLASS_INITIALIZATION_erroneous HOTSPOT_CLASS_INITIALIZATION_ERRONEOUS
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	86 #define HOTSPOT_CLASS_INITIALIZATION_super__failed HOTSPOT_CLASS_INITIALIZATION_SUPER_FAILED
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	87 #define HOTSPOT_CLASS_INITIALIZATION_clinit HOTSPOT_CLASS_INITIALIZATION_CLINIT
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	88 #define HOTSPOT_CLASS_INITIALIZATION_error HOTSPOT_CLASS_INITIALIZATION_ERROR
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	89 #define HOTSPOT_CLASS_INITIALIZATION_end HOTSPOT_CLASS_INITIALIZATION_END
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	90 #define DTRACE_CLASSINIT_PROBE(type, clss, thread_type) \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	91 { \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	92 char* data = NULL; \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	93 int len = 0; \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	94 Symbol* name = (clss)->name(); \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	95 if (name != NULL) { \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	96 data = (char*)name->bytes(); \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	97 len = name->utf8_length(); \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	98 } \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	99 HOTSPOT_CLASS_INITIALIZATION_##type( \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	100 data, len, (clss)->class_loader(), thread_type); \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	101 }
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	102
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	103 #define DTRACE_CLASSINIT_PROBE_WAIT(type, clss, thread_type, wait) \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	104 { \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	105 char* data = NULL; \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	106 int len = 0; \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	107 Symbol* name = (clss)->name(); \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	108 if (name != NULL) { \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	109 data = (char*)name->bytes(); \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	110 len = name->utf8_length(); \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	111 } \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	112 HOTSPOT_CLASS_INITIALIZATION_##type( \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	113 data, len, (clss)->class_loader(), thread_type, wait); \
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 3960 diff changeset	114 }
1324 e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	115
e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	116 #else // ndef DTRACE_ENABLED
e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	117
e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	118 #define DTRACE_CLASSINIT_PROBE(type, clss, thread_type)
e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	119 #define DTRACE_CLASSINIT_PROBE_WAIT(type, clss, thread_type, wait)
e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	120
e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	121 #endif // ndef DTRACE_ENABLED
e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	122
7464 ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 7180 diff changeset	123 volatile int InstanceKlass::_total_instanceKlass_count = 0;
ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 7180 diff changeset	124
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	125 InstanceKlass* InstanceKlass::allocate_instance_klass(
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	126 ClassLoaderData* loader_data,
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	127 int vtable_len,
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	128 int itable_len,
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	129 int static_field_size,
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	130 int nonstatic_oop_map_size,
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	131 ReferenceType rt,
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	132 AccessFlags access_flags,
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	133 Symbol* name,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	134 Klass* super_klass,
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	135 bool is_anonymous,
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	136 TRAPS) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	137
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	138 int size = InstanceKlass::size(vtable_len, itable_len, nonstatic_oop_map_size,
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	139 access_flags.is_interface(), is_anonymous);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	140
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	141 // Allocation
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	142 InstanceKlass* ik;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	143 if (rt == REF_NONE) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	144 if (name == vmSymbols::java_lang_Class()) {
6735 aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6733 diff changeset	145 ik = new (loader_data, size, THREAD) InstanceMirrorKlass(
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	146 vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	147 access_flags, is_anonymous);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	148 } else if (name == vmSymbols::java_lang_ClassLoader() \|\|
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	149 (SystemDictionary::ClassLoader_klass_loaded() &&
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	150 super_klass != NULL &&
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	151 super_klass->is_subtype_of(SystemDictionary::ClassLoader_klass()))) {
6735 aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6733 diff changeset	152 ik = new (loader_data, size, THREAD) InstanceClassLoaderKlass(
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	153 vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	154 access_flags, is_anonymous);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	155 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	156 // normal class
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	157 ik = new (loader_data, size, THREAD) InstanceKlass(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	158 vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	159 access_flags, is_anonymous);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	160 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	161 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	162 // reference klass
6735 aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6733 diff changeset	163 ik = new (loader_data, size, THREAD) InstanceRefKlass(
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	164 vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	165 access_flags, is_anonymous);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	166 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	167
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	168 // Check for pending exception before adding to the loader data and incrementing
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	169 // class count. Can get OOM here.
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	170 if (HAS_PENDING_EXCEPTION) {
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	171 return NULL;
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	172 }
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	173
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	174 // Add all classes to our internal class loader list here,
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	175 // including classes in the bootstrap (NULL) class loader.
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	176 loader_data->add_class(ik);
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	177
7464 ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 7180 diff changeset	178 Atomic::inc(&_total_instanceKlass_count);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	179 return ik;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	180 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	181
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	182
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	183 // copy method ordering from resource area to Metaspace
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	184 void InstanceKlass::copy_method_ordering(intArray* m, TRAPS) {
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	185 if (m != NULL) {
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	186 // allocate a new array and copy contents (memcpy?)
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	187 _method_ordering = MetadataFactory::new_array<int>(class_loader_data(), m->length(), CHECK);
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	188 for (int i = 0; i < m->length(); i++) {
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	189 _method_ordering->at_put(i, m->at(i));
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	190 }
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	191 } else {
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	192 _method_ordering = Universe::the_empty_int_array();
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	193 }
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	194 }
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	195
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	196 // create a new array of vtable_indices for default methods
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	197 Array<int>* InstanceKlass::create_new_default_vtable_indices(int len, TRAPS) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	198 Array<int>* vtable_indices = MetadataFactory::new_array<int>(class_loader_data(), len, CHECK_NULL);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	199 assert(default_vtable_indices() == NULL, "only create once");
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	200 set_default_vtable_indices(vtable_indices);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	201 return vtable_indices;
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	202 }
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	203
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	204 InstanceKlass::InstanceKlass(int vtable_len,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	205 int itable_len,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	206 int static_field_size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	207 int nonstatic_oop_map_size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	208 ReferenceType rt,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	209 AccessFlags access_flags,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	210 bool is_anonymous) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	211 No_Safepoint_Verifier no_safepoint; // until k becomes parsable
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	212
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	213 int iksize = InstanceKlass::size(vtable_len, itable_len, nonstatic_oop_map_size,
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	214 access_flags.is_interface(), is_anonymous);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	215
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	216 set_vtable_length(vtable_len);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	217 set_itable_length(itable_len);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	218 set_static_field_size(static_field_size);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	219 set_nonstatic_oop_map_size(nonstatic_oop_map_size);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	220 set_access_flags(access_flags);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	221 _misc_flags = 0; // initialize to zero
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	222 set_is_anonymous(is_anonymous);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	223 assert(size() == iksize, "wrong size for object");
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	224
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	225 set_array_klasses(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	226 set_methods(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	227 set_method_ordering(NULL);
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	228 set_default_methods(NULL);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	229 set_default_vtable_indices(NULL);
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	230 set_local_interfaces(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	231 set_transitive_interfaces(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	232 init_implementor();
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	233 set_fields(NULL, 0);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	234 set_constants(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	235 set_class_loader_data(NULL);
12067 e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	236 set_source_file_name_index(0);
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	237 set_source_debug_extension(NULL, 0);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	238 set_array_name(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	239 set_inner_classes(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	240 set_static_oop_field_count(0);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	241 set_nonstatic_field_size(0);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	242 set_is_marked_dependent(false);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	243 set_init_state(InstanceKlass::allocated);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	244 set_init_thread(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	245 set_reference_type(rt);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	246 set_oop_map_cache(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	247 set_jni_ids(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	248 set_osr_nmethods_head(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	249 set_breakpoints(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	250 init_previous_versions();
12067 e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	251 set_generic_signature_index(0);
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	252 release_set_methods_jmethod_ids(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	253 set_annotations(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	254 set_jvmti_cached_class_field_map(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	255 set_initial_method_idnum(0);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	256 _dependencies = NULL;
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	257 set_jvmti_cached_class_field_map(NULL);
11148 825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	258 set_cached_class_file(NULL);
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	259 set_initial_method_idnum(0);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	260 set_minor_version(0);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	261 set_major_version(0);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	262 NOT_PRODUCT(_verify_count = 0;)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	263
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	264 // initialize the non-header words to zero
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	265 intptr_t* p = (intptr_t*)this;
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	266 for (int index = InstanceKlass::header_size(); index < iksize; index++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	267 p[index] = NULL_WORD;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	268 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	269
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	270 // Set temporary value until parseClassFile updates it with the real instance
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	271 // size.
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	272 set_layout_helper(Klass::instance_layout_helper(0, true));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	273 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	274
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	275
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	276 void InstanceKlass::deallocate_methods(ClassLoaderData* loader_data,
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	277 Array<Method> methods) {
12857 d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	278 if (methods != NULL && methods != Universe::the_empty_method_array() &&
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	279 !methods->is_shared()) {
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	280 for (int i = 0; i < methods->length(); i++) {
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	281 Method* method = methods->at(i);
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	282 if (method == NULL) continue; // maybe null if error processing
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	283 // Only want to delete methods that are not executing for RedefineClasses.
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	284 // The previous version will point to them so they're not totally dangling
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	285 assert (!method->on_stack(), "shouldn't be called with methods on stack");
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	286 MetadataFactory::free_metadata(loader_data, method);
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	287 }
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	288 MetadataFactory::free_array<Method*>(loader_data, methods);
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	289 }
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	290 }
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	291
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	292 void InstanceKlass::deallocate_interfaces(ClassLoaderData* loader_data,
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	293 Klass* super_klass,
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	294 Array<Klass> local_interfaces,
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	295 Array<Klass> transitive_interfaces) {
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	296 // Only deallocate transitive interfaces if not empty, same as super class
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	297 // or same as local interfaces. See code in parseClassFile.
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	298 Array<Klass> ti = transitive_interfaces;
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	299 if (ti != Universe::the_empty_klass_array() && ti != local_interfaces) {
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	300 // check that the interfaces don't come from super class
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	301 Array<Klass> sti = (super_klass == NULL) ? NULL :
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	302 InstanceKlass::cast(super_klass)->transitive_interfaces();
12857 d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	303 if (ti != sti && ti != NULL && !ti->is_shared()) {
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	304 MetadataFactory::free_array<Klass*>(loader_data, ti);
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	305 }
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	306 }
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	307
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	308 // local interfaces can be empty
12857 d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	309 if (local_interfaces != Universe::the_empty_klass_array() &&
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	310 local_interfaces != NULL && !local_interfaces->is_shared()) {
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	311 MetadataFactory::free_array<Klass*>(loader_data, local_interfaces);
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	312 }
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	313 }
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	314
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	315 // This function deallocates the metadata and C heap pointers that the
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	316 // InstanceKlass points to.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	317 void InstanceKlass::deallocate_contents(ClassLoaderData* loader_data) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	318
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	319 // Orphan the mirror first, CMS thinks it's still live.
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	320 if (java_mirror() != NULL) {
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	321 java_lang_Class::set_klass(java_mirror(), NULL);
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	322 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	323
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	324 // Need to take this class off the class loader data list.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	325 loader_data->remove_class(this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	326
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	327 // The array_klass for this class is created later, after error handling.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	328 // For class redefinition, we keep the original class so this scratch class
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	329 // doesn't have an array class. Either way, assert that there is nothing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	330 // to deallocate.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	331 assert(array_klasses() == NULL, "array classes shouldn't be created for this class yet");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	332
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	333 // Release C heap allocated data that this might point to, which includes
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	334 // reference counting symbol names.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	335 release_C_heap_structures();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	336
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	337 deallocate_methods(loader_data, methods());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	338 set_methods(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	339
12857 d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	340 if (method_ordering() != NULL &&
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	341 method_ordering() != Universe::the_empty_int_array() &&
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	342 !method_ordering()->is_shared()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	343 MetadataFactory::free_array<int>(loader_data, method_ordering());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	344 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	345 set_method_ordering(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	346
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	347 // default methods can be empty
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	348 if (default_methods() != NULL &&
12857 d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	349 default_methods() != Universe::the_empty_method_array() &&
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	350 !default_methods()->is_shared()) {
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	351 MetadataFactory::free_array<Method*>(loader_data, default_methods());
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	352 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	353 // Do NOT deallocate the default methods, they are owned by superinterfaces.
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	354 set_default_methods(NULL);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	355
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	356 // default methods vtable indices can be empty
12857 d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	357 if (default_vtable_indices() != NULL &&
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	358 !default_vtable_indices()->is_shared()) {
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	359 MetadataFactory::free_array<int>(loader_data, default_vtable_indices());
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	360 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	361 set_default_vtable_indices(NULL);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	362
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	363
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	364 // This array is in Klass, but remove it with the InstanceKlass since
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	365 // this place would be the only caller and it can share memory with transitive
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	366 // interfaces.
12857 d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	367 if (secondary_supers() != NULL &&
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	368 secondary_supers() != Universe::the_empty_klass_array() &&
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	369 secondary_supers() != transitive_interfaces() &&
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	370 !secondary_supers()->is_shared()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	371 MetadataFactory::free_array<Klass*>(loader_data, secondary_supers());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	372 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	373 set_secondary_supers(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	374
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	375 deallocate_interfaces(loader_data, super(), local_interfaces(), transitive_interfaces());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	376 set_transitive_interfaces(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	377 set_local_interfaces(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	378
12857 d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	379 if (fields() != NULL && !fields()->is_shared()) {
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	380 MetadataFactory::free_array<jushort>(loader_data, fields());
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	381 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	382 set_fields(NULL, 0);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	383
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	384 // If a method from a redefined class is using this constant pool, don't
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	385 // delete it, yet. The new class's previous version will point to this.
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	386 if (constants() != NULL) {
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	387 assert (!constants()->on_stack(), "shouldn't be called if anything is onstack");
12857 d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	388 if (!constants()->is_shared()) {
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	389 MetadataFactory::free_metadata(loader_data, constants());
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	390 }
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	391 set_constants(NULL);
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	392 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	393
12857 d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	394 if (inner_classes() != NULL &&
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	395 inner_classes() != Universe::the_empty_short_array() &&
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	396 !inner_classes()->is_shared()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	397 MetadataFactory::free_array<jushort>(loader_data, inner_classes());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	398 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	399 set_inner_classes(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	400
12857 d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	401 // We should deallocate the Annotations instance if it's not in shared spaces.
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	402 if (annotations() != NULL && !annotations()->is_shared()) {
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	403 MetadataFactory::free_metadata(loader_data, annotations());
d37a0525c0fe 8024667: VM crashes with "assert(method() != NULL) failed: must have set method" hseigel parents: 12828 diff changeset	404 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	405 set_annotations(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	406 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	407
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	408 bool InstanceKlass::should_be_initialized() const {
0 a61af66fc99e Initial load duke parents: diff changeset	409 return !is_initialized();
a61af66fc99e Initial load duke parents: diff changeset	410 }
a61af66fc99e Initial load duke parents: diff changeset	411
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	412 klassVtable* InstanceKlass::vtable() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	413 return new klassVtable(this, start_of_vtable(), vtable_length() / vtableEntry::size());
0 a61af66fc99e Initial load duke parents: diff changeset	414 }
a61af66fc99e Initial load duke parents: diff changeset	415
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	416 klassItable* InstanceKlass::itable() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	417 return new klassItable(instanceKlassHandle(this));
0 a61af66fc99e Initial load duke parents: diff changeset	418 }
a61af66fc99e Initial load duke parents: diff changeset	419
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	420 void InstanceKlass::eager_initialize(Thread *thread) {
0 a61af66fc99e Initial load duke parents: diff changeset	421 if (!EagerInitialization) return;
a61af66fc99e Initial load duke parents: diff changeset	422
a61af66fc99e Initial load duke parents: diff changeset	423 if (this->is_not_initialized()) {
a61af66fc99e Initial load duke parents: diff changeset	424 // abort if the the class has a class initializer
a61af66fc99e Initial load duke parents: diff changeset	425 if (this->class_initializer() != NULL) return;
a61af66fc99e Initial load duke parents: diff changeset	426
a61af66fc99e Initial load duke parents: diff changeset	427 // abort if it is java.lang.Object (initialization is handled in genesis)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	428 Klass* super = this->super();
0 a61af66fc99e Initial load duke parents: diff changeset	429 if (super == NULL) return;
a61af66fc99e Initial load duke parents: diff changeset	430
a61af66fc99e Initial load duke parents: diff changeset	431 // abort if the super class should be initialized
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	432 if (!InstanceKlass::cast(super)->is_initialized()) return;
0 a61af66fc99e Initial load duke parents: diff changeset	433
a61af66fc99e Initial load duke parents: diff changeset	434 // call body to expose the this pointer
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	435 instanceKlassHandle this_oop(thread, this);
0 a61af66fc99e Initial load duke parents: diff changeset	436 eager_initialize_impl(this_oop);
a61af66fc99e Initial load duke parents: diff changeset	437 }
a61af66fc99e Initial load duke parents: diff changeset	438 }
a61af66fc99e Initial load duke parents: diff changeset	439
10343 6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	440 // JVMTI spec thinks there are signers and protection domain in the
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	441 // instanceKlass. These accessors pretend these fields are there.
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	442 // The hprof specification also thinks these fields are in InstanceKlass.
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	443 oop InstanceKlass::protection_domain() const {
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	444 // return the protection_domain from the mirror
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	445 return java_lang_Class::protection_domain(java_mirror());
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	446 }
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	447
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	448 // To remove these from requires an incompatible change and CCC request.
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	449 objArrayOop InstanceKlass::signers() const {
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	450 // return the signers from the mirror
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	451 return java_lang_Class::signers(java_mirror());
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	452 }
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	453
12811 3374b92de2d9 8025004: -XX:+CheckUnhandledOops asserts for JDK 8 Solaris fastdebug binaries coleenp parents: 12318 diff changeset	454 oop InstanceKlass::init_lock() const {
10343 6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	455 // return the init lock from the mirror
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	456 oop lock = java_lang_Class::init_lock(java_mirror());
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	457 assert((oop)lock != NULL \|\| !is_not_initialized(), // initialized or in_error state
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	458 "only fully initialized state can have a null lock");
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	459 return lock;
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	460 }
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	461
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	462 // Set the initialization lock to null so the object can be GC'ed. Any racing
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	463 // threads to get this lock will see a null lock and will not lock.
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	464 // That's okay because they all check for initialized state after getting
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	465 // the lock and return.
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	466 void InstanceKlass::fence_and_clear_init_lock() {
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	467 // make sure previous stores are all done, notably the init_state.
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	468 OrderAccess::storestore();
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	469 java_lang_Class::set_init_lock(java_mirror(), NULL);
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	470 assert(!is_not_initialized(), "class must be initialized now");
10343 6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	471 }
0 a61af66fc99e Initial load duke parents: diff changeset	472
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	473 void InstanceKlass::eager_initialize_impl(instanceKlassHandle this_oop) {
0 a61af66fc99e Initial load duke parents: diff changeset	474 EXCEPTION_MARK;
12811 3374b92de2d9 8025004: -XX:+CheckUnhandledOops asserts for JDK 8 Solaris fastdebug binaries coleenp parents: 12318 diff changeset	475 oop init_lock = this_oop->init_lock();
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	476 ObjectLocker ol(init_lock, THREAD, init_lock != NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	477
a61af66fc99e Initial load duke parents: diff changeset	478 // abort if someone beat us to the initialization
a61af66fc99e Initial load duke parents: diff changeset	479 if (!this_oop->is_not_initialized()) return; // note: not equivalent to is_initialized()
a61af66fc99e Initial load duke parents: diff changeset	480
4739 52b5d32fbfaf 7117052: instanceKlass::_init_state can be u1 type coleenp parents: 4006 diff changeset	481 ClassState old_state = this_oop->init_state();
0 a61af66fc99e Initial load duke parents: diff changeset	482 link_class_impl(this_oop, true, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	483 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	484 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	485 // Abort if linking the class throws an exception.
a61af66fc99e Initial load duke parents: diff changeset	486
a61af66fc99e Initial load duke parents: diff changeset	487 // Use a test to avoid redundantly resetting the state if there's
a61af66fc99e Initial load duke parents: diff changeset	488 // no change. Set_init_state() asserts that state changes make
a61af66fc99e Initial load duke parents: diff changeset	489 // progress, whereas here we might just be spinning in place.
a61af66fc99e Initial load duke parents: diff changeset	490 if( old_state != this_oop->_init_state )
a61af66fc99e Initial load duke parents: diff changeset	491 this_oop->set_init_state (old_state);
a61af66fc99e Initial load duke parents: diff changeset	492 } else {
a61af66fc99e Initial load duke parents: diff changeset	493 // linking successfull, mark class as initialized
a61af66fc99e Initial load duke parents: diff changeset	494 this_oop->set_init_state (fully_initialized);
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	495 this_oop->fence_and_clear_init_lock();
0 a61af66fc99e Initial load duke parents: diff changeset	496 // trace
a61af66fc99e Initial load duke parents: diff changeset	497 if (TraceClassInitialization) {
a61af66fc99e Initial load duke parents: diff changeset	498 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	499 tty->print_cr("[Initialized %s without side effects]", this_oop->external_name());
a61af66fc99e Initial load duke parents: diff changeset	500 }
a61af66fc99e Initial load duke parents: diff changeset	501 }
a61af66fc99e Initial load duke parents: diff changeset	502 }
a61af66fc99e Initial load duke parents: diff changeset	503
a61af66fc99e Initial load duke parents: diff changeset	504
a61af66fc99e Initial load duke parents: diff changeset	505 // See "The Virtual Machine Specification" section 2.16.5 for a detailed explanation of the class initialization
a61af66fc99e Initial load duke parents: diff changeset	506 // process. The step comments refers to the procedure described in that section.
a61af66fc99e Initial load duke parents: diff changeset	507 // Note: implementation moved to static method to expose the this pointer.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	508 void InstanceKlass::initialize(TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	509 if (this->should_be_initialized()) {
a61af66fc99e Initial load duke parents: diff changeset	510 HandleMark hm(THREAD);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	511 instanceKlassHandle this_oop(THREAD, this);
0 a61af66fc99e Initial load duke parents: diff changeset	512 initialize_impl(this_oop, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	513 // Note: at this point the class may be initialized
a61af66fc99e Initial load duke parents: diff changeset	514 // OR it may be in the state of being initialized
a61af66fc99e Initial load duke parents: diff changeset	515 // in case of recursive initialization!
a61af66fc99e Initial load duke parents: diff changeset	516 } else {
a61af66fc99e Initial load duke parents: diff changeset	517 assert(is_initialized(), "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	518 }
a61af66fc99e Initial load duke parents: diff changeset	519 }
a61af66fc99e Initial load duke parents: diff changeset	520
a61af66fc99e Initial load duke parents: diff changeset	521
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	522 bool InstanceKlass::verify_code(
0 a61af66fc99e Initial load duke parents: diff changeset	523 instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	524 // 1) Verify the bytecodes
a61af66fc99e Initial load duke parents: diff changeset	525 Verifier::Mode mode =
a61af66fc99e Initial load duke parents: diff changeset	526 throw_verifyerror ? Verifier::ThrowException : Verifier::NoException;
973 ad6585fd4087 6830542: Performance: JVM_DefineClass already verified. acorn parents: 964 diff changeset	527 return Verifier::verify(this_oop, mode, this_oop->should_verify_class(), CHECK_false);
0 a61af66fc99e Initial load duke parents: diff changeset	528 }
a61af66fc99e Initial load duke parents: diff changeset	529
a61af66fc99e Initial load duke parents: diff changeset	530
a61af66fc99e Initial load duke parents: diff changeset	531 // Used exclusively by the shared spaces dump mechanism to prevent
a61af66fc99e Initial load duke parents: diff changeset	532 // classes mapped into the shared regions in new VMs from appearing linked.
a61af66fc99e Initial load duke parents: diff changeset	533
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	534 void InstanceKlass::unlink_class() {
0 a61af66fc99e Initial load duke parents: diff changeset	535 assert(is_linked(), "must be linked");
a61af66fc99e Initial load duke parents: diff changeset	536 _init_state = loaded;
a61af66fc99e Initial load duke parents: diff changeset	537 }
a61af66fc99e Initial load duke parents: diff changeset	538
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	539 void InstanceKlass::link_class(TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	540 assert(is_loaded(), "must be loaded");
a61af66fc99e Initial load duke parents: diff changeset	541 if (!is_linked()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	542 HandleMark hm(THREAD);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	543 instanceKlassHandle this_oop(THREAD, this);
0 a61af66fc99e Initial load duke parents: diff changeset	544 link_class_impl(this_oop, true, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	545 }
a61af66fc99e Initial load duke parents: diff changeset	546 }
a61af66fc99e Initial load duke parents: diff changeset	547
a61af66fc99e Initial load duke parents: diff changeset	548 // Called to verify that a class can link during initialization, without
a61af66fc99e Initial load duke parents: diff changeset	549 // throwing a VerifyError.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	550 bool InstanceKlass::link_class_or_fail(TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	551 assert(is_loaded(), "must be loaded");
a61af66fc99e Initial load duke parents: diff changeset	552 if (!is_linked()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	553 HandleMark hm(THREAD);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	554 instanceKlassHandle this_oop(THREAD, this);
0 a61af66fc99e Initial load duke parents: diff changeset	555 link_class_impl(this_oop, false, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	556 }
a61af66fc99e Initial load duke parents: diff changeset	557 return is_linked();
a61af66fc99e Initial load duke parents: diff changeset	558 }
a61af66fc99e Initial load duke parents: diff changeset	559
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	560 bool InstanceKlass::link_class_impl(
0 a61af66fc99e Initial load duke parents: diff changeset	561 instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	562 // check for error state
a61af66fc99e Initial load duke parents: diff changeset	563 if (this_oop->is_in_error_state()) {
a61af66fc99e Initial load duke parents: diff changeset	564 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	565 THROW_MSG_(vmSymbols::java_lang_NoClassDefFoundError(),
a61af66fc99e Initial load duke parents: diff changeset	566 this_oop->external_name(), false);
a61af66fc99e Initial load duke parents: diff changeset	567 }
a61af66fc99e Initial load duke parents: diff changeset	568 // return if already verified
a61af66fc99e Initial load duke parents: diff changeset	569 if (this_oop->is_linked()) {
a61af66fc99e Initial load duke parents: diff changeset	570 return true;
a61af66fc99e Initial load duke parents: diff changeset	571 }
a61af66fc99e Initial load duke parents: diff changeset	572
a61af66fc99e Initial load duke parents: diff changeset	573 // Timing
a61af66fc99e Initial load duke parents: diff changeset	574 // timer handles recursion
a61af66fc99e Initial load duke parents: diff changeset	575 assert(THREAD->is_Java_thread(), "non-JavaThread in link_class_impl");
a61af66fc99e Initial load duke parents: diff changeset	576 JavaThread* jt = (JavaThread*)THREAD;
a61af66fc99e Initial load duke parents: diff changeset	577
a61af66fc99e Initial load duke parents: diff changeset	578 // link super class before linking this class
a61af66fc99e Initial load duke parents: diff changeset	579 instanceKlassHandle super(THREAD, this_oop->super());
a61af66fc99e Initial load duke parents: diff changeset	580 if (super.not_null()) {
a61af66fc99e Initial load duke parents: diff changeset	581 if (super->is_interface()) { // check if super class is an interface
a61af66fc99e Initial load duke parents: diff changeset	582 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	583 Exceptions::fthrow(
a61af66fc99e Initial load duke parents: diff changeset	584 THREAD_AND_LOCATION,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	585 vmSymbols::java_lang_IncompatibleClassChangeError(),
0 a61af66fc99e Initial load duke parents: diff changeset	586 "class %s has interface %s as super class",
a61af66fc99e Initial load duke parents: diff changeset	587 this_oop->external_name(),
a61af66fc99e Initial load duke parents: diff changeset	588 super->external_name()
a61af66fc99e Initial load duke parents: diff changeset	589 );
a61af66fc99e Initial load duke parents: diff changeset	590 return false;
a61af66fc99e Initial load duke parents: diff changeset	591 }
a61af66fc99e Initial load duke parents: diff changeset	592
a61af66fc99e Initial load duke parents: diff changeset	593 link_class_impl(super, throw_verifyerror, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	594 }
a61af66fc99e Initial load duke parents: diff changeset	595
a61af66fc99e Initial load duke parents: diff changeset	596 // link all interfaces implemented by this class before linking this class
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	597 Array<Klass> interfaces = this_oop->local_interfaces();
0 a61af66fc99e Initial load duke parents: diff changeset	598 int num_interfaces = interfaces->length();
a61af66fc99e Initial load duke parents: diff changeset	599 for (int index = 0; index < num_interfaces; index++) {
a61af66fc99e Initial load duke parents: diff changeset	600 HandleMark hm(THREAD);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	601 instanceKlassHandle ih(THREAD, interfaces->at(index));
0 a61af66fc99e Initial load duke parents: diff changeset	602 link_class_impl(ih, throw_verifyerror, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	603 }
a61af66fc99e Initial load duke parents: diff changeset	604
a61af66fc99e Initial load duke parents: diff changeset	605 // in case the class is linked in the process of linking its superclasses
a61af66fc99e Initial load duke parents: diff changeset	606 if (this_oop->is_linked()) {
a61af66fc99e Initial load duke parents: diff changeset	607 return true;
a61af66fc99e Initial load duke parents: diff changeset	608 }
a61af66fc99e Initial load duke parents: diff changeset	609
875 6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	610 // trace only the link time for this klass that includes
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	611 // the verification time
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	612 PerfClassTraceTime vmtimer(ClassLoader::perf_class_link_time(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	613 ClassLoader::perf_class_link_selftime(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	614 ClassLoader::perf_classes_linked(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	615 jt->get_thread_stat()->perf_recursion_counts_addr(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	616 jt->get_thread_stat()->perf_timers_addr(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	617 PerfClassTraceTime::CLASS_LINK);
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	618
0 a61af66fc99e Initial load duke parents: diff changeset	619 // verification & rewriting
a61af66fc99e Initial load duke parents: diff changeset	620 {
12811 3374b92de2d9 8025004: -XX:+CheckUnhandledOops asserts for JDK 8 Solaris fastdebug binaries coleenp parents: 12318 diff changeset	621 oop init_lock = this_oop->init_lock();
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	622 ObjectLocker ol(init_lock, THREAD, init_lock != NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	623 // rewritten will have been set if loader constraint error found
a61af66fc99e Initial load duke parents: diff changeset	624 // on an earlier link attempt
a61af66fc99e Initial load duke parents: diff changeset	625 // don't verify or rewrite if already rewritten
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	626
0 a61af66fc99e Initial load duke parents: diff changeset	627 if (!this_oop->is_linked()) {
a61af66fc99e Initial load duke parents: diff changeset	628 if (!this_oop->is_rewritten()) {
a61af66fc99e Initial load duke parents: diff changeset	629 {
a61af66fc99e Initial load duke parents: diff changeset	630 // Timer includes any side effects of class verification (resolution,
a61af66fc99e Initial load duke parents: diff changeset	631 // etc), but not recursive entry into verify_code().
875 6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	632 PerfClassTraceTime timer(ClassLoader::perf_class_verify_time(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	633 ClassLoader::perf_class_verify_selftime(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	634 ClassLoader::perf_classes_verified(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	635 jt->get_thread_stat()->perf_recursion_counts_addr(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	636 jt->get_thread_stat()->perf_timers_addr(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	637 PerfClassTraceTime::CLASS_VERIFY);
0 a61af66fc99e Initial load duke parents: diff changeset	638 bool verify_ok = verify_code(this_oop, throw_verifyerror, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	639 if (!verify_ok) {
a61af66fc99e Initial load duke parents: diff changeset	640 return false;
a61af66fc99e Initial load duke parents: diff changeset	641 }
a61af66fc99e Initial load duke parents: diff changeset	642 }
a61af66fc99e Initial load duke parents: diff changeset	643
a61af66fc99e Initial load duke parents: diff changeset	644 // Just in case a side-effect of verify linked this class already
a61af66fc99e Initial load duke parents: diff changeset	645 // (which can sometimes happen since the verifier loads classes
a61af66fc99e Initial load duke parents: diff changeset	646 // using custom class loaders, which are free to initialize things)
a61af66fc99e Initial load duke parents: diff changeset	647 if (this_oop->is_linked()) {
a61af66fc99e Initial load duke parents: diff changeset	648 return true;
a61af66fc99e Initial load duke parents: diff changeset	649 }
a61af66fc99e Initial load duke parents: diff changeset	650
a61af66fc99e Initial load duke parents: diff changeset	651 // also sets rewritten
a61af66fc99e Initial load duke parents: diff changeset	652 this_oop->rewrite_class(CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	653 }
a61af66fc99e Initial load duke parents: diff changeset	654
3748 d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob coleenp parents: 2408 diff changeset	655 // relocate jsrs and link methods after they are all rewritten
7459 cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	656 this_oop->link_methods(CHECK_false);
3748 d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob coleenp parents: 2408 diff changeset	657
0 a61af66fc99e Initial load duke parents: diff changeset	658 // Initialize the vtable and interface table after
a61af66fc99e Initial load duke parents: diff changeset	659 // methods have been rewritten since rewrite may
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	660 // fabricate new Method*s.
0 a61af66fc99e Initial load duke parents: diff changeset	661 // also does loader constraint checking
a61af66fc99e Initial load duke parents: diff changeset	662 if (!this_oop()->is_shared()) {
a61af66fc99e Initial load duke parents: diff changeset	663 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	664 this_oop->vtable()->initialize_vtable(true, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	665 this_oop->itable()->initialize_itable(true, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	666 }
a61af66fc99e Initial load duke parents: diff changeset	667 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	668 else {
a61af66fc99e Initial load duke parents: diff changeset	669 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	670 this_oop->vtable()->verify(tty, true);
a61af66fc99e Initial load duke parents: diff changeset	671 // In case itable verification is ever added.
a61af66fc99e Initial load duke parents: diff changeset	672 // this_oop->itable()->verify(tty, true);
a61af66fc99e Initial load duke parents: diff changeset	673 }
a61af66fc99e Initial load duke parents: diff changeset	674 #endif
a61af66fc99e Initial load duke parents: diff changeset	675 this_oop->set_init_state(linked);
a61af66fc99e Initial load duke parents: diff changeset	676 if (JvmtiExport::should_post_class_prepare()) {
a61af66fc99e Initial load duke parents: diff changeset	677 Thread *thread = THREAD;
a61af66fc99e Initial load duke parents: diff changeset	678 assert(thread->is_Java_thread(), "thread->is_Java_thread()");
a61af66fc99e Initial load duke parents: diff changeset	679 JvmtiExport::post_class_prepare((JavaThread *) thread, this_oop());
a61af66fc99e Initial load duke parents: diff changeset	680 }
a61af66fc99e Initial load duke parents: diff changeset	681 }
a61af66fc99e Initial load duke parents: diff changeset	682 }
a61af66fc99e Initial load duke parents: diff changeset	683 return true;
a61af66fc99e Initial load duke parents: diff changeset	684 }
a61af66fc99e Initial load duke parents: diff changeset	685
a61af66fc99e Initial load duke parents: diff changeset	686
a61af66fc99e Initial load duke parents: diff changeset	687 // Rewrite the byte codes of all of the methods of a class.
a61af66fc99e Initial load duke parents: diff changeset	688 // The rewriter must be called exactly once. Rewriting must happen after
a61af66fc99e Initial load duke parents: diff changeset	689 // verification but before the first method of the class is executed.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	690 void InstanceKlass::rewrite_class(TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	691 assert(is_loaded(), "must be loaded");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	692 instanceKlassHandle this_oop(THREAD, this);
0 a61af66fc99e Initial load duke parents: diff changeset	693 if (this_oop->is_rewritten()) {
a61af66fc99e Initial load duke parents: diff changeset	694 assert(this_oop()->is_shared(), "rewriting an unshared class?");
a61af66fc99e Initial load duke parents: diff changeset	695 return;
a61af66fc99e Initial load duke parents: diff changeset	696 }
3748 d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob coleenp parents: 2408 diff changeset	697 Rewriter::rewrite(this_oop, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	698 this_oop->set_rewritten();
a61af66fc99e Initial load duke parents: diff changeset	699 }
a61af66fc99e Initial load duke parents: diff changeset	700
3748 d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob coleenp parents: 2408 diff changeset	701 // Now relocate and link method entry points after class is rewritten.
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob coleenp parents: 2408 diff changeset	702 // This is outside is_rewritten flag. In case of an exception, it can be
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob coleenp parents: 2408 diff changeset	703 // executed more than once.
7459 cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	704 void InstanceKlass::link_methods(TRAPS) {
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	705 int len = methods()->length();
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	706 for (int i = len-1; i >= 0; i--) {
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	707 methodHandle m(THREAD, methods()->at(i));
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	708
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	709 // Set up method entry points for compiler and interpreter .
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	710 m->link_method(m, CHECK);
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	711
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	712 // This is for JVMTI and unrelated to relocator but the last thing we do
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	713 #ifdef ASSERT
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	714 if (StressMethodComparator) {
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	715 ResourceMark rm(THREAD);
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	716 static int nmc = 0;
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	717 for (int j = i; j >= 0 && j >= i-4; j--) {
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	718 if ((++nmc % 1000) == 0) tty->print_cr("Have run MethodComparator %d times...", nmc);
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	719 bool z = MethodComparator::methods_EMCP(m(),
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	720 methods()->at(j));
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	721 if (j == i && !z) {
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	722 tty->print("MethodComparator FAIL: "); m->print(); m->print_codes();
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	723 assert(z, "method must compare equal to itself");
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	724 }
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	725 }
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	726 }
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	727 #endif //ASSERT
cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	728 }
3748 d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob coleenp parents: 2408 diff changeset	729 }
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob coleenp parents: 2408 diff changeset	730
0 a61af66fc99e Initial load duke parents: diff changeset	731
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	732 void InstanceKlass::initialize_impl(instanceKlassHandle this_oop, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	733 // Make sure klass is linked (verified) before initialization
a61af66fc99e Initial load duke parents: diff changeset	734 // A class could already be verified, since it has been reflected upon.
a61af66fc99e Initial load duke parents: diff changeset	735 this_oop->link_class(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	736
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	737 DTRACE_CLASSINIT_PROBE(required, InstanceKlass::cast(this_oop()), -1);
1324 e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	738
e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	739 bool wait = false;
e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	740
0 a61af66fc99e Initial load duke parents: diff changeset	741 // refer to the JVM book page 47 for description of steps
a61af66fc99e Initial load duke parents: diff changeset	742 // Step 1
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	743 {
12811 3374b92de2d9 8025004: -XX:+CheckUnhandledOops asserts for JDK 8 Solaris fastdebug binaries coleenp parents: 12318 diff changeset	744 oop init_lock = this_oop->init_lock();
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	745 ObjectLocker ol(init_lock, THREAD, init_lock != NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	746
a61af66fc99e Initial load duke parents: diff changeset	747 Thread *self = THREAD; // it's passed the current thread
a61af66fc99e Initial load duke parents: diff changeset	748
a61af66fc99e Initial load duke parents: diff changeset	749 // Step 2
a61af66fc99e Initial load duke parents: diff changeset	750 // If we were to use wait() instead of waitInterruptibly() then
a61af66fc99e Initial load duke parents: diff changeset	751 // we might end up throwing IE from link/symbol resolution sites
a61af66fc99e Initial load duke parents: diff changeset	752 // that aren't expected to throw. This would wreak havoc. See 6320309.
a61af66fc99e Initial load duke parents: diff changeset	753 while(this_oop->is_being_initialized() && !this_oop->is_reentrant_initialization(self)) {
1324 e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	754 wait = true;
0 a61af66fc99e Initial load duke parents: diff changeset	755 ol.waitUninterruptibly(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	756 }
a61af66fc99e Initial load duke parents: diff changeset	757
a61af66fc99e Initial load duke parents: diff changeset	758 // Step 3
1324 e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	759 if (this_oop->is_being_initialized() && this_oop->is_reentrant_initialization(self)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	760 DTRACE_CLASSINIT_PROBE_WAIT(recursive, InstanceKlass::cast(this_oop()), -1,wait);
0 a61af66fc99e Initial load duke parents: diff changeset	761 return;
1324 e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	762 }
0 a61af66fc99e Initial load duke parents: diff changeset	763
a61af66fc99e Initial load duke parents: diff changeset	764 // Step 4
1324 e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	765 if (this_oop->is_initialized()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	766 DTRACE_CLASSINIT_PROBE_WAIT(concurrent, InstanceKlass::cast(this_oop()), -1,wait);
0 a61af66fc99e Initial load duke parents: diff changeset	767 return;
1324 e392695de029 6935224: Adding new DTrace probes to work with Palantir fparain parents: 1155 diff changeset	768 }
0 a61af66fc99e Initial load duke parents: diff changeset	769
a61af66fc99e Initial load duke parents: diff changeset	770 // Step 5
a61af66fc99e Initial load duke parents: diff changeset	771 if (this_oop->is_in_error_state()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	772 DTRACE_CLASSINIT_PROBE_WAIT(erroneous, InstanceKlass::cast(this_oop()), -1,wait);
0 a61af66fc99e Initial load duke parents: diff changeset	773 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	774 const char* desc = "Could not initialize class ";
a61af66fc99e Initial load duke parents: diff changeset	775 const char* className = this_oop->external_name();
a61af66fc99e Initial load duke parents: diff changeset	776 size_t msglen = strlen(desc) + strlen(className) + 1;
1751 2528b5bd749c 6980262: Memory leak when exception is thrown in static initializer kamg parents: 1706 diff changeset	777 char* message = NEW_RESOURCE_ARRAY(char, msglen);
0 a61af66fc99e Initial load duke parents: diff changeset	778 if (NULL == message) {
a61af66fc99e Initial load duke parents: diff changeset	779 // Out of memory: can't create detailed error message
a61af66fc99e Initial load duke parents: diff changeset	780 THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), className);
a61af66fc99e Initial load duke parents: diff changeset	781 } else {
a61af66fc99e Initial load duke parents: diff changeset	782 jio_snprintf(message, msglen, "%s%s", desc, className);
a61af66fc99e Initial load duke parents: diff changeset	783 THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), message);
a61af66fc99e Initial load duke parents: diff changeset	784 }
a61af66fc99e Initial load duke parents: diff changeset	785 }
a61af66fc99e Initial load duke parents: diff changeset	786
a61af66fc99e Initial load duke parents: diff changeset	787 // Step 6
a61af66fc99e Initial load duke parents: diff changeset	788 this_oop->set_init_state(being_initialized);
a61af66fc99e Initial load duke parents: diff changeset	789 this_oop->set_init_thread(self);
a61af66fc99e Initial load duke parents: diff changeset	790 }
a61af66fc99e Initial load duke parents: diff changeset	791
a61af66fc99e Initial load duke parents: diff changeset	792 // Step 7
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	793 Klass* super_klass = this_oop->super();
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	794 if (super_klass != NULL && !this_oop->is_interface() && super_klass->should_be_initialized()) {
070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	795 super_klass->initialize(THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	796
a61af66fc99e Initial load duke parents: diff changeset	797 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	798 Handle e(THREAD, PENDING_EXCEPTION);
a61af66fc99e Initial load duke parents: diff changeset	799 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	800 {
a61af66fc99e Initial load duke parents: diff changeset	801 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	802 this_oop->set_initialization_state_and_notify(initialization_error, THREAD); // Locks object, set state, and notify all waiting threads
a61af66fc99e Initial load duke parents: diff changeset	803 CLEAR_PENDING_EXCEPTION; // ignore any exception thrown, superclass initialization error is thrown below
a61af66fc99e Initial load duke parents: diff changeset	804 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	805 DTRACE_CLASSINIT_PROBE_WAIT(super__failed, InstanceKlass::cast(this_oop()), -1,wait);
0 a61af66fc99e Initial load duke parents: diff changeset	806 THROW_OOP(e());
a61af66fc99e Initial load duke parents: diff changeset	807 }
a61af66fc99e Initial load duke parents: diff changeset	808 }
a61af66fc99e Initial load duke parents: diff changeset	809
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	810 if (this_oop->has_default_methods()) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	811 // Step 7.5: initialize any interfaces which have default methods
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	812 for (int i = 0; i < this_oop->local_interfaces()->length(); ++i) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	813 Klass* iface = this_oop->local_interfaces()->at(i);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	814 InstanceKlass* ik = InstanceKlass::cast(iface);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	815 if (ik->has_default_methods() && ik->should_be_initialized()) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	816 ik->initialize(THREAD);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	817
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	818 if (HAS_PENDING_EXCEPTION) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	819 Handle e(THREAD, PENDING_EXCEPTION);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	820 CLEAR_PENDING_EXCEPTION;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	821 {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	822 EXCEPTION_MARK;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	823 // Locks object, set state, and notify all waiting threads
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	824 this_oop->set_initialization_state_and_notify(
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	825 initialization_error, THREAD);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	826
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	827 // ignore any exception thrown, superclass initialization error is
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	828 // thrown below
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	829 CLEAR_PENDING_EXCEPTION;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	830 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	831 DTRACE_CLASSINIT_PROBE_WAIT(
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	832 super__failed, InstanceKlass::cast(this_oop()), -1, wait);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	833 THROW_OOP(e());
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	834 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	835 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	836 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	837 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	838
0 a61af66fc99e Initial load duke parents: diff changeset	839 // Step 8
a61af66fc99e Initial load duke parents: diff changeset	840 {
a61af66fc99e Initial load duke parents: diff changeset	841 assert(THREAD->is_Java_thread(), "non-JavaThread in initialize_impl");
a61af66fc99e Initial load duke parents: diff changeset	842 JavaThread* jt = (JavaThread*)THREAD;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	843 DTRACE_CLASSINIT_PROBE_WAIT(clinit, InstanceKlass::cast(this_oop()), -1,wait);
0 a61af66fc99e Initial load duke parents: diff changeset	844 // Timer includes any side effects of class initialization (resolution,
a61af66fc99e Initial load duke parents: diff changeset	845 // etc), but not recursive entry into call_class_initializer().
875 6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	846 PerfClassTraceTime timer(ClassLoader::perf_class_init_time(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	847 ClassLoader::perf_class_init_selftime(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	848 ClassLoader::perf_classes_inited(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	849 jt->get_thread_stat()->perf_recursion_counts_addr(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	850 jt->get_thread_stat()->perf_timers_addr(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement mchung parents: 676 diff changeset	851 PerfClassTraceTime::CLASS_CLINIT);
0 a61af66fc99e Initial load duke parents: diff changeset	852 this_oop->call_class_initializer(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	853 }
a61af66fc99e Initial load duke parents: diff changeset	854
a61af66fc99e Initial load duke parents: diff changeset	855 // Step 9
a61af66fc99e Initial load duke parents: diff changeset	856 if (!HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	857 this_oop->set_initialization_state_and_notify(fully_initialized, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	858 { ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	859 debug_only(this_oop->vtable()->verify(tty, true);)
a61af66fc99e Initial load duke parents: diff changeset	860 }
a61af66fc99e Initial load duke parents: diff changeset	861 }
a61af66fc99e Initial load duke parents: diff changeset	862 else {
a61af66fc99e Initial load duke parents: diff changeset	863 // Step 10 and 11
a61af66fc99e Initial load duke parents: diff changeset	864 Handle e(THREAD, PENDING_EXCEPTION);
a61af66fc99e Initial load duke parents: diff changeset	865 CLEAR_PENDING_EXCEPTION;
14481 016b6a289fc4 4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException jbachorik parents: 14465 diff changeset	866 // JVMTI has already reported the pending exception
016b6a289fc4 4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException jbachorik parents: 14465 diff changeset	867 // JVMTI internal flag reset is needed in order to report ExceptionInInitializerError
016b6a289fc4 4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException jbachorik parents: 14465 diff changeset	868 JvmtiExport::clear_detected_exception((JavaThread*)THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	869 {
a61af66fc99e Initial load duke parents: diff changeset	870 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	871 this_oop->set_initialization_state_and_notify(initialization_error, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	872 CLEAR_PENDING_EXCEPTION; // ignore any exception thrown, class initialization error is thrown below
14481 016b6a289fc4 4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException jbachorik parents: 14465 diff changeset	873 // JVMTI has already reported the pending exception
016b6a289fc4 4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException jbachorik parents: 14465 diff changeset	874 // JVMTI internal flag reset is needed in order to report ExceptionInInitializerError
016b6a289fc4 4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException jbachorik parents: 14465 diff changeset	875 JvmtiExport::clear_detected_exception((JavaThread*)THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	876 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	877 DTRACE_CLASSINIT_PROBE_WAIT(error, InstanceKlass::cast(this_oop()), -1,wait);
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1039 diff changeset	878 if (e->is_a(SystemDictionary::Error_klass())) {
0 a61af66fc99e Initial load duke parents: diff changeset	879 THROW_OOP(e());
a61af66fc99e Initial load duke parents: diff changeset	880 } else {
a61af66fc99e Initial load duke parents: diff changeset	881 JavaCallArguments args(e);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	882 THROW_ARG(vmSymbols::java_lang_ExceptionInInitializerError(),
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	883 vmSymbols::throwable_void_signature(),
0 a61af66fc99e Initial load duke parents: diff changeset	884 &args);
a61af66fc99e Initial load duke parents: diff changeset	885 }
a61af66fc99e Initial load duke parents: diff changeset	886 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	887 DTRACE_CLASSINIT_PROBE_WAIT(end, InstanceKlass::cast(this_oop()), -1,wait);
0 a61af66fc99e Initial load duke parents: diff changeset	888 }
a61af66fc99e Initial load duke parents: diff changeset	889
a61af66fc99e Initial load duke parents: diff changeset	890
a61af66fc99e Initial load duke parents: diff changeset	891 // Note: implementation moved to static method to expose the this pointer.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	892 void InstanceKlass::set_initialization_state_and_notify(ClassState state, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	893 instanceKlassHandle kh(THREAD, this);
0 a61af66fc99e Initial load duke parents: diff changeset	894 set_initialization_state_and_notify_impl(kh, state, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	895 }
a61af66fc99e Initial load duke parents: diff changeset	896
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	897 void InstanceKlass::set_initialization_state_and_notify_impl(instanceKlassHandle this_oop, ClassState state, TRAPS) {
12811 3374b92de2d9 8025004: -XX:+CheckUnhandledOops asserts for JDK 8 Solaris fastdebug binaries coleenp parents: 12318 diff changeset	898 oop init_lock = this_oop->init_lock();
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	899 ObjectLocker ol(init_lock, THREAD, init_lock != NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	900 this_oop->set_init_state(state);
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12857 diff changeset	901 this_oop->fence_and_clear_init_lock();
0 a61af66fc99e Initial load duke parents: diff changeset	902 ol.notify_all(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	903 }
a61af66fc99e Initial load duke parents: diff changeset	904
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	905 // The embedded _implementor field can only record one implementor.
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	906 // When there are more than one implementors, the _implementor field
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	907 // is set to the interface Klass* itself. Following are the possible
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	908 // values for the _implementor field:
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	909 // NULL - no implementor
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	910 // implementor Klass* - one implementor
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	911 // self - more than one implementor
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	912 //
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	913 // The _implementor field only exists for interfaces.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	914 void InstanceKlass::add_implementor(Klass* k) {
0 a61af66fc99e Initial load duke parents: diff changeset	915 assert(Compile_lock->owned_by_self(), "");
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	916 assert(is_interface(), "not interface");
0 a61af66fc99e Initial load duke parents: diff changeset	917 // Filter out my subinterfaces.
a61af66fc99e Initial load duke parents: diff changeset	918 // (Note: Interfaces are never on the subklass list.)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	919 if (InstanceKlass::cast(k)->is_interface()) return;
0 a61af66fc99e Initial load duke parents: diff changeset	920
a61af66fc99e Initial load duke parents: diff changeset	921 // Filter out subclasses whose supers already implement me.
a61af66fc99e Initial load duke parents: diff changeset	922 // (Note: CHA must walk subclasses of direct implementors
a61af66fc99e Initial load duke parents: diff changeset	923 // in order to locate indirect implementors.)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	924 Klass* sk = InstanceKlass::cast(k)->super();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	925 if (sk != NULL && InstanceKlass::cast(sk)->implements_interface(this))
0 a61af66fc99e Initial load duke parents: diff changeset	926 // We only need to check one immediate superclass, since the
a61af66fc99e Initial load duke parents: diff changeset	927 // implements_interface query looks at transitive_interfaces.
a61af66fc99e Initial load duke parents: diff changeset	928 // Any supers of the super have the same (or fewer) transitive_interfaces.
a61af66fc99e Initial load duke parents: diff changeset	929 return;
a61af66fc99e Initial load duke parents: diff changeset	930
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	931 Klass* ik = implementor();
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	932 if (ik == NULL) {
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	933 set_implementor(k);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	934 } else if (ik != this) {
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	935 // There is already an implementor. Use itself as an indicator of
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	936 // more than one implementors.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	937 set_implementor(this);
0 a61af66fc99e Initial load duke parents: diff changeset	938 }
a61af66fc99e Initial load duke parents: diff changeset	939
a61af66fc99e Initial load duke parents: diff changeset	940 // The implementor also implements the transitive_interfaces
a61af66fc99e Initial load duke parents: diff changeset	941 for (int index = 0; index < local_interfaces()->length(); index++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	942 InstanceKlass::cast(local_interfaces()->at(index))->add_implementor(k);
0 a61af66fc99e Initial load duke parents: diff changeset	943 }
a61af66fc99e Initial load duke parents: diff changeset	944 }
a61af66fc99e Initial load duke parents: diff changeset	945
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	946 void InstanceKlass::init_implementor() {
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	947 if (is_interface()) {
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	948 set_implementor(NULL);
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	949 }
0 a61af66fc99e Initial load duke parents: diff changeset	950 }
a61af66fc99e Initial load duke parents: diff changeset	951
a61af66fc99e Initial load duke parents: diff changeset	952
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	953 void InstanceKlass::process_interfaces(Thread *thread) {
0 a61af66fc99e Initial load duke parents: diff changeset	954 // link this class into the implementors list of every interface it implements
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	955 Klass* this_as_klass_oop = this;
0 a61af66fc99e Initial load duke parents: diff changeset	956 for (int i = local_interfaces()->length() - 1; i >= 0; i--) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	957 assert(local_interfaces()->at(i)->is_klass(), "must be a klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	958 InstanceKlass* interf = InstanceKlass::cast(local_interfaces()->at(i));
0 a61af66fc99e Initial load duke parents: diff changeset	959 assert(interf->is_interface(), "expected interface");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	960 interf->add_implementor(this_as_klass_oop);
0 a61af66fc99e Initial load duke parents: diff changeset	961 }
a61af66fc99e Initial load duke parents: diff changeset	962 }
a61af66fc99e Initial load duke parents: diff changeset	963
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	964 bool InstanceKlass::can_be_primary_super_slow() const {
0 a61af66fc99e Initial load duke parents: diff changeset	965 if (is_interface())
a61af66fc99e Initial load duke parents: diff changeset	966 return false;
a61af66fc99e Initial load duke parents: diff changeset	967 else
a61af66fc99e Initial load duke parents: diff changeset	968 return Klass::can_be_primary_super_slow();
a61af66fc99e Initial load duke parents: diff changeset	969 }
a61af66fc99e Initial load duke parents: diff changeset	970
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	971 GrowableArray<Klass> InstanceKlass::compute_secondary_supers(int num_extra_slots) {
0 a61af66fc99e Initial load duke parents: diff changeset	972 // The secondaries are the implemented interfaces.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	973 InstanceKlass* ik = InstanceKlass::cast(this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	974 Array<Klass> interfaces = ik->transitive_interfaces();
0 a61af66fc99e Initial load duke parents: diff changeset	975 int num_secondaries = num_extra_slots + interfaces->length();
a61af66fc99e Initial load duke parents: diff changeset	976 if (num_secondaries == 0) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	977 // Must share this for correct bootstrapping!
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	978 set_secondary_supers(Universe::the_empty_klass_array());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	979 return NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	980 } else if (num_extra_slots == 0) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	981 // The secondary super list is exactly the same as the transitive interfaces.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	982 // Redefine classes has to be careful not to delete this!
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	983 set_secondary_supers(interfaces);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	984 return NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	985 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	986 // Copy transitive interfaces to a temporary growable array to be constructed
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	987 // into the secondary super list with extra slots.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	988 GrowableArray<Klass> secondaries = new GrowableArray<Klass*>(interfaces->length());
0 a61af66fc99e Initial load duke parents: diff changeset	989 for (int i = 0; i < interfaces->length(); i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	990 secondaries->push(interfaces->at(i));
0 a61af66fc99e Initial load duke parents: diff changeset	991 }
a61af66fc99e Initial load duke parents: diff changeset	992 return secondaries;
a61af66fc99e Initial load duke parents: diff changeset	993 }
a61af66fc99e Initial load duke parents: diff changeset	994 }
a61af66fc99e Initial load duke parents: diff changeset	995
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	996 bool InstanceKlass::compute_is_subtype_of(Klass* k) {
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	997 if (k->is_interface()) {
0 a61af66fc99e Initial load duke parents: diff changeset	998 return implements_interface(k);
a61af66fc99e Initial load duke parents: diff changeset	999 } else {
a61af66fc99e Initial load duke parents: diff changeset	1000 return Klass::compute_is_subtype_of(k);
a61af66fc99e Initial load duke parents: diff changeset	1001 }
a61af66fc99e Initial load duke parents: diff changeset	1002 }
a61af66fc99e Initial load duke parents: diff changeset	1003
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1004 bool InstanceKlass::implements_interface(Klass* k) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1005 if (this == k) return true;
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	1006 assert(k->is_interface(), "should be an interface class");
0 a61af66fc99e Initial load duke parents: diff changeset	1007 for (int i = 0; i < transitive_interfaces()->length(); i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1008 if (transitive_interfaces()->at(i) == k) {
0 a61af66fc99e Initial load duke parents: diff changeset	1009 return true;
a61af66fc99e Initial load duke parents: diff changeset	1010 }
a61af66fc99e Initial load duke parents: diff changeset	1011 }
a61af66fc99e Initial load duke parents: diff changeset	1012 return false;
a61af66fc99e Initial load duke parents: diff changeset	1013 }
a61af66fc99e Initial load duke parents: diff changeset	1014
13401 22eaa15b7960 8026065: InterfaceMethodref for invokespecial must name a direct superinterface hseigel parents: 13080 diff changeset	1015 bool InstanceKlass::is_same_or_direct_interface(Klass *k) const {
22eaa15b7960 8026065: InterfaceMethodref for invokespecial must name a direct superinterface hseigel parents: 13080 diff changeset	1016 // Verify direct super interface
22eaa15b7960 8026065: InterfaceMethodref for invokespecial must name a direct superinterface hseigel parents: 13080 diff changeset	1017 if (this == k) return true;
22eaa15b7960 8026065: InterfaceMethodref for invokespecial must name a direct superinterface hseigel parents: 13080 diff changeset	1018 assert(k->is_interface(), "should be an interface class");
22eaa15b7960 8026065: InterfaceMethodref for invokespecial must name a direct superinterface hseigel parents: 13080 diff changeset	1019 for (int i = 0; i < local_interfaces()->length(); i++) {
22eaa15b7960 8026065: InterfaceMethodref for invokespecial must name a direct superinterface hseigel parents: 13080 diff changeset	1020 if (local_interfaces()->at(i) == k) {
22eaa15b7960 8026065: InterfaceMethodref for invokespecial must name a direct superinterface hseigel parents: 13080 diff changeset	1021 return true;
22eaa15b7960 8026065: InterfaceMethodref for invokespecial must name a direct superinterface hseigel parents: 13080 diff changeset	1022 }
22eaa15b7960 8026065: InterfaceMethodref for invokespecial must name a direct superinterface hseigel parents: 13080 diff changeset	1023 }
22eaa15b7960 8026065: InterfaceMethodref for invokespecial must name a direct superinterface hseigel parents: 13080 diff changeset	1024 return false;
22eaa15b7960 8026065: InterfaceMethodref for invokespecial must name a direct superinterface hseigel parents: 13080 diff changeset	1025 }
22eaa15b7960 8026065: InterfaceMethodref for invokespecial must name a direct superinterface hseigel parents: 13080 diff changeset	1026
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1027 objArrayOop InstanceKlass::allocate_objArray(int n, int length, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	1028 if (length < 0) THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
a61af66fc99e Initial load duke parents: diff changeset	1029 if (length > arrayOopDesc::max_array_length(T_OBJECT)) {
876 1413494da700 6850957: Honor -XX:OnOutOfMemoryError when array size exceeds VM limit martin parents: 875 diff changeset	1030 report_java_out_of_memory("Requested array size exceeds VM limit");
5935 a735aec54ea4 7123170: JCK vm/jvmti/ResourceExhausted/resexh001/resexh00101/ tests fails since 7u4 b02 sspitsyn parents: 4739 diff changeset	1031 JvmtiExport::post_array_size_exhausted();
0 a61af66fc99e Initial load duke parents: diff changeset	1032 THROW_OOP_0(Universe::out_of_memory_error_array_size());
a61af66fc99e Initial load duke parents: diff changeset	1033 }
a61af66fc99e Initial load duke parents: diff changeset	1034 int size = objArrayOopDesc::object_size(length);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1035 Klass* ak = array_klass(n, CHECK_NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	1036 KlassHandle h_ak (THREAD, ak);
a61af66fc99e Initial load duke parents: diff changeset	1037 objArrayOop o =
a61af66fc99e Initial load duke parents: diff changeset	1038 (objArrayOop)CollectedHeap::array_allocate(h_ak, size, length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	1039 return o;
a61af66fc99e Initial load duke parents: diff changeset	1040 }
a61af66fc99e Initial load duke parents: diff changeset	1041
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1042 instanceOop InstanceKlass::register_finalizer(instanceOop i, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	1043 if (TraceFinalizerRegistration) {
a61af66fc99e Initial load duke parents: diff changeset	1044 tty->print("Registered ");
a61af66fc99e Initial load duke parents: diff changeset	1045 i->print_value_on(tty);
a61af66fc99e Initial load duke parents: diff changeset	1046 tty->print_cr(" (" INTPTR_FORMAT ") as finalizable", (address)i);
a61af66fc99e Initial load duke parents: diff changeset	1047 }
a61af66fc99e Initial load duke parents: diff changeset	1048 instanceHandle h_i(THREAD, i);
a61af66fc99e Initial load duke parents: diff changeset	1049 // Pass the handle as argument, JavaCalls::call expects oop as jobjects
a61af66fc99e Initial load duke parents: diff changeset	1050 JavaValue result(T_VOID);
a61af66fc99e Initial load duke parents: diff changeset	1051 JavaCallArguments args(h_i);
a61af66fc99e Initial load duke parents: diff changeset	1052 methodHandle mh (THREAD, Universe::finalizer_register_method());
a61af66fc99e Initial load duke parents: diff changeset	1053 JavaCalls::call(&result, mh, &args, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	1054 return h_i();
a61af66fc99e Initial load duke parents: diff changeset	1055 }
a61af66fc99e Initial load duke parents: diff changeset	1056
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1057 instanceOop InstanceKlass::allocate_instance(TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	1058 bool has_finalizer_flag = has_finalizer(); // Query before possible GC
a61af66fc99e Initial load duke parents: diff changeset	1059 int size = size_helper(); // Query before forming handle.
a61af66fc99e Initial load duke parents: diff changeset	1060
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1061 KlassHandle h_k(THREAD, this);
0 a61af66fc99e Initial load duke parents: diff changeset	1062
a61af66fc99e Initial load duke parents: diff changeset	1063 instanceOop i;
a61af66fc99e Initial load duke parents: diff changeset	1064
a61af66fc99e Initial load duke parents: diff changeset	1065 i = (instanceOop)CollectedHeap::obj_allocate(h_k, size, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	1066 if (has_finalizer_flag && !RegisterFinalizersAtInit) {
a61af66fc99e Initial load duke parents: diff changeset	1067 i = register_finalizer(i, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	1068 }
a61af66fc99e Initial load duke parents: diff changeset	1069 return i;
a61af66fc99e Initial load duke parents: diff changeset	1070 }
a61af66fc99e Initial load duke parents: diff changeset	1071
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1072 void InstanceKlass::check_valid_for_instantiation(bool throwError, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	1073 if (is_interface() \|\| is_abstract()) {
a61af66fc99e Initial load duke parents: diff changeset	1074 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	1075 THROW_MSG(throwError ? vmSymbols::java_lang_InstantiationError()
a61af66fc99e Initial load duke parents: diff changeset	1076 : vmSymbols::java_lang_InstantiationException(), external_name());
a61af66fc99e Initial load duke parents: diff changeset	1077 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1078 if (this == SystemDictionary::Class_klass()) {
0 a61af66fc99e Initial load duke parents: diff changeset	1079 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	1080 THROW_MSG(throwError ? vmSymbols::java_lang_IllegalAccessError()
a61af66fc99e Initial load duke parents: diff changeset	1081 : vmSymbols::java_lang_IllegalAccessException(), external_name());
a61af66fc99e Initial load duke parents: diff changeset	1082 }
a61af66fc99e Initial load duke parents: diff changeset	1083 }
a61af66fc99e Initial load duke parents: diff changeset	1084
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1085 Klass* InstanceKlass::array_klass_impl(bool or_null, int n, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1086 instanceKlassHandle this_oop(THREAD, this);
0 a61af66fc99e Initial load duke parents: diff changeset	1087 return array_klass_impl(this_oop, or_null, n, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	1088 }
a61af66fc99e Initial load duke parents: diff changeset	1089
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1090 Klass* InstanceKlass::array_klass_impl(instanceKlassHandle this_oop, bool or_null, int n, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	1091 if (this_oop->array_klasses() == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1092 if (or_null) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1093
a61af66fc99e Initial load duke parents: diff changeset	1094 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1095 JavaThread jt = (JavaThread )THREAD;
a61af66fc99e Initial load duke parents: diff changeset	1096 {
a61af66fc99e Initial load duke parents: diff changeset	1097 // Atomic creation of array_klasses
a61af66fc99e Initial load duke parents: diff changeset	1098 MutexLocker mc(Compile_lock, THREAD); // for vtables
a61af66fc99e Initial load duke parents: diff changeset	1099 MutexLocker ma(MultiArray_lock, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	1100
a61af66fc99e Initial load duke parents: diff changeset	1101 // Check if update has already taken place
a61af66fc99e Initial load duke parents: diff changeset	1102 if (this_oop->array_klasses() == NULL) {
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6735 diff changeset	1103 Klass* k = ObjArrayKlass::allocate_objArray_klass(this_oop->class_loader_data(), 1, this_oop, CHECK_NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	1104 this_oop->set_array_klasses(k);
a61af66fc99e Initial load duke parents: diff changeset	1105 }
a61af66fc99e Initial load duke parents: diff changeset	1106 }
a61af66fc99e Initial load duke parents: diff changeset	1107 }
a61af66fc99e Initial load duke parents: diff changeset	1108 // _this will always be set at this point
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6735 diff changeset	1109 ObjArrayKlass* oak = (ObjArrayKlass*)this_oop->array_klasses();
0 a61af66fc99e Initial load duke parents: diff changeset	1110 if (or_null) {
a61af66fc99e Initial load duke parents: diff changeset	1111 return oak->array_klass_or_null(n);
a61af66fc99e Initial load duke parents: diff changeset	1112 }
a61af66fc99e Initial load duke parents: diff changeset	1113 return oak->array_klass(n, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	1114 }
a61af66fc99e Initial load duke parents: diff changeset	1115
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1116 Klass* InstanceKlass::array_klass_impl(bool or_null, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	1117 return array_klass_impl(or_null, 1, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	1118 }
a61af66fc99e Initial load duke parents: diff changeset	1119
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1120 void InstanceKlass::call_class_initializer(TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1121 instanceKlassHandle ik (THREAD, this);
0 a61af66fc99e Initial load duke parents: diff changeset	1122 call_class_initializer_impl(ik, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	1123 }
a61af66fc99e Initial load duke parents: diff changeset	1124
a61af66fc99e Initial load duke parents: diff changeset	1125 static int call_class_initializer_impl_counter = 0; // for debugging
a61af66fc99e Initial load duke parents: diff changeset	1126
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1127 Method* InstanceKlass::class_initializer() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1128 Method* clinit = find_method(
2334 dbad0519a1c4 6845426: non-static <clinit> method with no args is called during the class initialization process kamg parents: 2227 diff changeset	1129 vmSymbols::class_initializer_name(), vmSymbols::void_method_signature());
dbad0519a1c4 6845426: non-static <clinit> method with no args is called during the class initialization process kamg parents: 2227 diff changeset	1130 if (clinit != NULL && clinit->has_valid_initializer_flags()) {
dbad0519a1c4 6845426: non-static <clinit> method with no args is called during the class initialization process kamg parents: 2227 diff changeset	1131 return clinit;
dbad0519a1c4 6845426: non-static <clinit> method with no args is called during the class initialization process kamg parents: 2227 diff changeset	1132 }
dbad0519a1c4 6845426: non-static <clinit> method with no args is called during the class initialization process kamg parents: 2227 diff changeset	1133 return NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	1134 }
a61af66fc99e Initial load duke parents: diff changeset	1135
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1136 void InstanceKlass::call_class_initializer_impl(instanceKlassHandle this_oop, TRAPS) {
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6934 diff changeset	1137 if (ReplayCompiles &&
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6934 diff changeset	1138 (ReplaySuppressInitializers == 1 \|\|
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6934 diff changeset	1139 ReplaySuppressInitializers >= 2 && this_oop->class_loader() != NULL)) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6934 diff changeset	1140 // Hide the existence of the initializer for the purpose of replaying the compile
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6934 diff changeset	1141 return;
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6934 diff changeset	1142 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6934 diff changeset	1143
0 a61af66fc99e Initial load duke parents: diff changeset	1144 methodHandle h_method(THREAD, this_oop->class_initializer());
a61af66fc99e Initial load duke parents: diff changeset	1145 assert(!this_oop->is_initialized(), "we cannot initialize twice");
a61af66fc99e Initial load duke parents: diff changeset	1146 if (TraceClassInitialization) {
a61af66fc99e Initial load duke parents: diff changeset	1147 tty->print("%d Initializing ", call_class_initializer_impl_counter++);
a61af66fc99e Initial load duke parents: diff changeset	1148 this_oop->name()->print_value();
a61af66fc99e Initial load duke parents: diff changeset	1149 tty->print_cr("%s (" INTPTR_FORMAT ")", h_method() == NULL ? "(no method)" : "", (address)this_oop());
a61af66fc99e Initial load duke parents: diff changeset	1150 }
a61af66fc99e Initial load duke parents: diff changeset	1151 if (h_method() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1152 JavaCallArguments args; // No arguments
a61af66fc99e Initial load duke parents: diff changeset	1153 JavaValue result(T_VOID);
a61af66fc99e Initial load duke parents: diff changeset	1154 JavaCalls::call(&result, h_method, &args, CHECK); // Static call (no args)
a61af66fc99e Initial load duke parents: diff changeset	1155 }
a61af66fc99e Initial load duke parents: diff changeset	1156 }
a61af66fc99e Initial load duke parents: diff changeset	1157
a61af66fc99e Initial load duke parents: diff changeset	1158
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1159 void InstanceKlass::mask_for(methodHandle method, int bci,
0 a61af66fc99e Initial load duke parents: diff changeset	1160 InterpreterOopMap* entry_for) {
a61af66fc99e Initial load duke parents: diff changeset	1161 // Dirty read, then double-check under a lock.
a61af66fc99e Initial load duke parents: diff changeset	1162 if (_oop_map_cache == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1163 // Otherwise, allocate a new one.
a61af66fc99e Initial load duke parents: diff changeset	1164 MutexLocker x(OopMapCacheAlloc_lock);
a61af66fc99e Initial load duke parents: diff changeset	1165 // First time use. Allocate a cache in C heap
a61af66fc99e Initial load duke parents: diff changeset	1166 if (_oop_map_cache == NULL) {
14443 3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 13401 diff changeset	1167 // Release stores from OopMapCache constructor before assignment
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 13401 diff changeset	1168 // to _oop_map_cache. C++ compilers on ppc do not emit the
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 13401 diff changeset	1169 // required memory barrier only because of the volatile
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 13401 diff changeset	1170 // qualifier of _oop_map_cache.
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 13401 diff changeset	1171 OrderAccess::release_store_ptr(&_oop_map_cache, new OopMapCache());
0 a61af66fc99e Initial load duke parents: diff changeset	1172 }
a61af66fc99e Initial load duke parents: diff changeset	1173 }
a61af66fc99e Initial load duke parents: diff changeset	1174 // _oop_map_cache is constant after init; lookup below does is own locking.
a61af66fc99e Initial load duke parents: diff changeset	1175 _oop_map_cache->lookup(method, bci, entry_for);
a61af66fc99e Initial load duke parents: diff changeset	1176 }
a61af66fc99e Initial load duke parents: diff changeset	1177
a61af66fc99e Initial load duke parents: diff changeset	1178
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1179 bool InstanceKlass::find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1180 for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1181 Symbol* f_name = fs.name();
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1182 Symbol* f_sig = fs.signature();
0 a61af66fc99e Initial load duke parents: diff changeset	1183 if (f_name == name && f_sig == sig) {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	1184 fd->reinitialize(const_cast<InstanceKlass*>(this), fs.index());
0 a61af66fc99e Initial load duke parents: diff changeset	1185 return true;
a61af66fc99e Initial load duke parents: diff changeset	1186 }
a61af66fc99e Initial load duke parents: diff changeset	1187 }
a61af66fc99e Initial load duke parents: diff changeset	1188 return false;
a61af66fc99e Initial load duke parents: diff changeset	1189 }
a61af66fc99e Initial load duke parents: diff changeset	1190
a61af66fc99e Initial load duke parents: diff changeset	1191
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1192 Klass* InstanceKlass::find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1193 const int n = local_interfaces()->length();
a61af66fc99e Initial load duke parents: diff changeset	1194 for (int i = 0; i < n; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1195 Klass* intf1 = local_interfaces()->at(i);
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	1196 assert(intf1->is_interface(), "just checking type");
0 a61af66fc99e Initial load duke parents: diff changeset	1197 // search for field in current interface
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1198 if (InstanceKlass::cast(intf1)->find_local_field(name, sig, fd)) {
0 a61af66fc99e Initial load duke parents: diff changeset	1199 assert(fd->is_static(), "interface field must be static");
a61af66fc99e Initial load duke parents: diff changeset	1200 return intf1;
a61af66fc99e Initial load duke parents: diff changeset	1201 }
a61af66fc99e Initial load duke parents: diff changeset	1202 // search for field in direct superinterfaces
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1203 Klass* intf2 = InstanceKlass::cast(intf1)->find_interface_field(name, sig, fd);
0 a61af66fc99e Initial load duke parents: diff changeset	1204 if (intf2 != NULL) return intf2;
a61af66fc99e Initial load duke parents: diff changeset	1205 }
a61af66fc99e Initial load duke parents: diff changeset	1206 // otherwise field lookup fails
a61af66fc99e Initial load duke parents: diff changeset	1207 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1208 }
a61af66fc99e Initial load duke parents: diff changeset	1209
a61af66fc99e Initial load duke parents: diff changeset	1210
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1211 Klass* InstanceKlass::find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1212 // search order according to newest JVM spec (5.4.3.2, p.167).
a61af66fc99e Initial load duke parents: diff changeset	1213 // 1) search for field in current klass
a61af66fc99e Initial load duke parents: diff changeset	1214 if (find_local_field(name, sig, fd)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1215 return const_cast<InstanceKlass*>(this);
0 a61af66fc99e Initial load duke parents: diff changeset	1216 }
a61af66fc99e Initial load duke parents: diff changeset	1217 // 2) search for field recursively in direct superinterfaces
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1218 { Klass* intf = find_interface_field(name, sig, fd);
0 a61af66fc99e Initial load duke parents: diff changeset	1219 if (intf != NULL) return intf;
a61af66fc99e Initial load duke parents: diff changeset	1220 }
a61af66fc99e Initial load duke parents: diff changeset	1221 // 3) apply field lookup recursively if superclass exists
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1222 { Klass* supr = super();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1223 if (supr != NULL) return InstanceKlass::cast(supr)->find_field(name, sig, fd);
0 a61af66fc99e Initial load duke parents: diff changeset	1224 }
a61af66fc99e Initial load duke parents: diff changeset	1225 // 4) otherwise field lookup fails
a61af66fc99e Initial load duke parents: diff changeset	1226 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1227 }
a61af66fc99e Initial load duke parents: diff changeset	1228
a61af66fc99e Initial load duke parents: diff changeset	1229
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1230 Klass* InstanceKlass::find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1231 // search order according to newest JVM spec (5.4.3.2, p.167).
a61af66fc99e Initial load duke parents: diff changeset	1232 // 1) search for field in current klass
a61af66fc99e Initial load duke parents: diff changeset	1233 if (find_local_field(name, sig, fd)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1234 if (fd->is_static() == is_static) return const_cast<InstanceKlass*>(this);
0 a61af66fc99e Initial load duke parents: diff changeset	1235 }
a61af66fc99e Initial load duke parents: diff changeset	1236 // 2) search for field recursively in direct superinterfaces
a61af66fc99e Initial load duke parents: diff changeset	1237 if (is_static) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1238 Klass* intf = find_interface_field(name, sig, fd);
0 a61af66fc99e Initial load duke parents: diff changeset	1239 if (intf != NULL) return intf;
a61af66fc99e Initial load duke parents: diff changeset	1240 }
a61af66fc99e Initial load duke parents: diff changeset	1241 // 3) apply field lookup recursively if superclass exists
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1242 { Klass* supr = super();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1243 if (supr != NULL) return InstanceKlass::cast(supr)->find_field(name, sig, is_static, fd);
0 a61af66fc99e Initial load duke parents: diff changeset	1244 }
a61af66fc99e Initial load duke parents: diff changeset	1245 // 4) otherwise field lookup fails
a61af66fc99e Initial load duke parents: diff changeset	1246 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1247 }
a61af66fc99e Initial load duke parents: diff changeset	1248
a61af66fc99e Initial load duke parents: diff changeset	1249
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1250 bool InstanceKlass::find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1251 for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1252 if (fs.offset() == offset) {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	1253 fd->reinitialize(const_cast<InstanceKlass*>(this), fs.index());
0 a61af66fc99e Initial load duke parents: diff changeset	1254 if (fd->is_static() == is_static) return true;
a61af66fc99e Initial load duke parents: diff changeset	1255 }
a61af66fc99e Initial load duke parents: diff changeset	1256 }
a61af66fc99e Initial load duke parents: diff changeset	1257 return false;
a61af66fc99e Initial load duke parents: diff changeset	1258 }
a61af66fc99e Initial load duke parents: diff changeset	1259
a61af66fc99e Initial load duke parents: diff changeset	1260
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1261 bool InstanceKlass::find_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1262 Klass* klass = const_cast<InstanceKlass*>(this);
0 a61af66fc99e Initial load duke parents: diff changeset	1263 while (klass != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1264 if (InstanceKlass::cast(klass)->find_local_field_from_offset(offset, is_static, fd)) {
0 a61af66fc99e Initial load duke parents: diff changeset	1265 return true;
a61af66fc99e Initial load duke parents: diff changeset	1266 }
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	1267 klass = klass->super();
0 a61af66fc99e Initial load duke parents: diff changeset	1268 }
a61af66fc99e Initial load duke parents: diff changeset	1269 return false;
a61af66fc99e Initial load duke parents: diff changeset	1270 }
a61af66fc99e Initial load duke parents: diff changeset	1271
a61af66fc99e Initial load duke parents: diff changeset	1272
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1273 void InstanceKlass::methods_do(void f(Method* method)) {
0 a61af66fc99e Initial load duke parents: diff changeset	1274 int len = methods()->length();
a61af66fc99e Initial load duke parents: diff changeset	1275 for (int index = 0; index < len; index++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1276 Method* m = methods()->at(index);
0 a61af66fc99e Initial load duke parents: diff changeset	1277 assert(m->is_method(), "must be method");
a61af66fc99e Initial load duke parents: diff changeset	1278 f(m);
a61af66fc99e Initial load duke parents: diff changeset	1279 }
a61af66fc99e Initial load duke parents: diff changeset	1280 }
a61af66fc99e Initial load duke parents: diff changeset	1281
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	1282
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1283 void InstanceKlass::do_local_static_fields(FieldClosure* cl) {
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1284 for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1285 if (fs.access_flags().is_static()) {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	1286 fieldDescriptor& fd = fs.field_descriptor();
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1287 cl->do_field(&fd);
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1288 }
0 a61af66fc99e Initial load duke parents: diff changeset	1289 }
a61af66fc99e Initial load duke parents: diff changeset	1290 }
a61af66fc99e Initial load duke parents: diff changeset	1291
a61af66fc99e Initial load duke parents: diff changeset	1292
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1293 void InstanceKlass::do_local_static_fields(void f(fieldDescriptor*, TRAPS), TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1294 instanceKlassHandle h_this(THREAD, this);
0 a61af66fc99e Initial load duke parents: diff changeset	1295 do_local_static_fields_impl(h_this, f, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	1296 }
a61af66fc99e Initial load duke parents: diff changeset	1297
a61af66fc99e Initial load duke parents: diff changeset	1298
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1299 void InstanceKlass::do_local_static_fields_impl(instanceKlassHandle this_oop, void f(fieldDescriptor* fd, TRAPS), TRAPS) {
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1300 for (JavaFieldStream fs(this_oop()); !fs.done(); fs.next()) {
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1301 if (fs.access_flags().is_static()) {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	1302 fieldDescriptor& fd = fs.field_descriptor();
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1303 f(&fd, CHECK);
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1304 }
0 a61af66fc99e Initial load duke parents: diff changeset	1305 }
a61af66fc99e Initial load duke parents: diff changeset	1306 }
a61af66fc99e Initial load duke parents: diff changeset	1307
a61af66fc99e Initial load duke parents: diff changeset	1308
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1309 static int compare_fields_by_offset(int* a, int* b) {
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1310 return a[0] - b[0];
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1311 }
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1312
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1313 void InstanceKlass::do_nonstatic_fields(FieldClosure* cl) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1314 InstanceKlass* super = superklass();
0 a61af66fc99e Initial load duke parents: diff changeset	1315 if (super != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1316 super->do_nonstatic_fields(cl);
a61af66fc99e Initial load duke parents: diff changeset	1317 }
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1318 fieldDescriptor fd;
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1319 int length = java_fields_count();
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1320 // In DebugInfo nonstatic fields are sorted by offset.
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6038 diff changeset	1321 int* fields_sorted = NEW_C_HEAP_ARRAY(int, 2*(length+1), mtClass);
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1322 int j = 0;
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1323 for (int i = 0; i < length; i += 1) {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	1324 fd.reinitialize(this, i);
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1325 if (!fd.is_static()) {
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1326 fields_sorted[j + 0] = fd.offset();
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1327 fields_sorted[j + 1] = i;
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1328 j += 2;
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1329 }
0 a61af66fc99e Initial load duke parents: diff changeset	1330 }
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1331 if (j > 0) {
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1332 length = j;
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1333 // _sort_Fn is defined in growableArray.hpp.
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1334 qsort(fields_sorted, length/2, 2*sizeof(int), (_sort_Fn)compare_fields_by_offset);
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1335 for (int i = 0; i < length; i += 2) {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	1336 fd.reinitialize(this, fields_sorted[i + 1]);
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1337 assert(!fd.is_static() && fd.offset() == fields_sorted[i], "only nonstatic fields");
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1338 cl->do_field(&fd);
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1339 }
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1340 }
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6038 diff changeset	1341 FREE_C_HEAP_ARRAY(int, fields_sorted, mtClass);
0 a61af66fc99e Initial load duke parents: diff changeset	1342 }
a61af66fc99e Initial load duke parents: diff changeset	1343
a61af66fc99e Initial load duke parents: diff changeset	1344
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1345 void InstanceKlass::array_klasses_do(void f(Klass* k, TRAPS), TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1346 if (array_klasses() != NULL)
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6735 diff changeset	1347 ArrayKlass::cast(array_klasses())->array_klasses_do(f, THREAD);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1348 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1349
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1350 void InstanceKlass::array_klasses_do(void f(Klass* k)) {
0 a61af66fc99e Initial load duke parents: diff changeset	1351 if (array_klasses() != NULL)
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6735 diff changeset	1352 ArrayKlass::cast(array_klasses())->array_klasses_do(f);
0 a61af66fc99e Initial load duke parents: diff changeset	1353 }
a61af66fc99e Initial load duke parents: diff changeset	1354
a61af66fc99e Initial load duke parents: diff changeset	1355 #ifdef ASSERT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1356 static int linear_search(Array<Method> methods, Symbol* name, Symbol* signature) {
0 a61af66fc99e Initial load duke parents: diff changeset	1357 int len = methods->length();
a61af66fc99e Initial load duke parents: diff changeset	1358 for (int index = 0; index < len; index++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1359 Method* m = methods->at(index);
0 a61af66fc99e Initial load duke parents: diff changeset	1360 assert(m->is_method(), "must be method");
a61af66fc99e Initial load duke parents: diff changeset	1361 if (m->signature() == signature && m->name() == name) {
a61af66fc99e Initial load duke parents: diff changeset	1362 return index;
a61af66fc99e Initial load duke parents: diff changeset	1363 }
a61af66fc99e Initial load duke parents: diff changeset	1364 }
a61af66fc99e Initial load duke parents: diff changeset	1365 return -1;
a61af66fc99e Initial load duke parents: diff changeset	1366 }
a61af66fc99e Initial load duke parents: diff changeset	1367 #endif
a61af66fc99e Initial load duke parents: diff changeset	1368
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1369 static int binary_search(Array<Method> methods, Symbol* name) {
0 a61af66fc99e Initial load duke parents: diff changeset	1370 int len = methods->length();
a61af66fc99e Initial load duke parents: diff changeset	1371 // methods are sorted, so do binary search
a61af66fc99e Initial load duke parents: diff changeset	1372 int l = 0;
a61af66fc99e Initial load duke parents: diff changeset	1373 int h = len - 1;
a61af66fc99e Initial load duke parents: diff changeset	1374 while (l <= h) {
a61af66fc99e Initial load duke parents: diff changeset	1375 int mid = (l + h) >> 1;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1376 Method* m = methods->at(mid);
0 a61af66fc99e Initial load duke parents: diff changeset	1377 assert(m->is_method(), "must be method");
a61af66fc99e Initial load duke parents: diff changeset	1378 int res = m->name()->fast_compare(name);
a61af66fc99e Initial load duke parents: diff changeset	1379 if (res == 0) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1380 return mid;
0 a61af66fc99e Initial load duke parents: diff changeset	1381 } else if (res < 0) {
a61af66fc99e Initial load duke parents: diff changeset	1382 l = mid + 1;
a61af66fc99e Initial load duke parents: diff changeset	1383 } else {
a61af66fc99e Initial load duke parents: diff changeset	1384 h = mid - 1;
a61af66fc99e Initial load duke parents: diff changeset	1385 }
a61af66fc99e Initial load duke parents: diff changeset	1386 }
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1387 return -1;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1388 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1389
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1390 // find_method looks up the name/signature in the local methods array
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1391 Method* InstanceKlass::find_method(Symbol* name, Symbol* signature) const {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1392 return InstanceKlass::find_method(methods(), name, signature);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1393 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1394
13414 379f11bc04fc 8028438: static superclass method masks default methods acorn parents: 13401 diff changeset	1395 // find_instance_method looks up the name/signature in the local methods array
379f11bc04fc 8028438: static superclass method masks default methods acorn parents: 13401 diff changeset	1396 // and skips over static methods
379f11bc04fc 8028438: static superclass method masks default methods acorn parents: 13401 diff changeset	1397 Method* InstanceKlass::find_instance_method(
379f11bc04fc 8028438: static superclass method masks default methods acorn parents: 13401 diff changeset	1398 Array<Method> methods, Symbol* name, Symbol* signature) {
379f11bc04fc 8028438: static superclass method masks default methods acorn parents: 13401 diff changeset	1399 Method* meth = InstanceKlass::find_method(methods, name, signature);
379f11bc04fc 8028438: static superclass method masks default methods acorn parents: 13401 diff changeset	1400 if (meth != NULL && meth->is_static()) {
379f11bc04fc 8028438: static superclass method masks default methods acorn parents: 13401 diff changeset	1401 meth = NULL;
379f11bc04fc 8028438: static superclass method masks default methods acorn parents: 13401 diff changeset	1402 }
379f11bc04fc 8028438: static superclass method masks default methods acorn parents: 13401 diff changeset	1403 return meth;
379f11bc04fc 8028438: static superclass method masks default methods acorn parents: 13401 diff changeset	1404 }
379f11bc04fc 8028438: static superclass method masks default methods acorn parents: 13401 diff changeset	1405
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1406 // find_method looks up the name/signature in the local methods array
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1407 Method* InstanceKlass::find_method(
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1408 Array<Method> methods, Symbol* name, Symbol* signature) {
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1409 int hit = find_method_index(methods, name, signature);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1410 return hit >= 0 ? methods->at(hit): NULL;
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1411 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1412
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1413 // Used directly for default_methods to find the index into the
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1414 // default_vtable_indices, and indirectly by find_method
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1415 // find_method_index looks in the local methods array to return the index
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1416 // of the matching name/signature
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1417 int InstanceKlass::find_method_index(
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1418 Array<Method> methods, Symbol* name, Symbol* signature) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1419 int hit = binary_search(methods, name);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1420 if (hit != -1) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1421 Method* m = methods->at(hit);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1422 // Do linear search to find matching signature. First, quick check
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1423 // for common case
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1424 if (m->signature() == signature) return hit;
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1425 // search downwards through overloaded methods
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1426 int i;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1427 for (i = hit - 1; i >= 0; --i) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1428 Method* m = methods->at(i);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1429 assert(m->is_method(), "must be method");
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1430 if (m->name() != name) break;
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1431 if (m->signature() == signature) return i;
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1432 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1433 // search upwards
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1434 for (i = hit + 1; i < methods->length(); ++i) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1435 Method* m = methods->at(i);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1436 assert(m->is_method(), "must be method");
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1437 if (m->name() != name) break;
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1438 if (m->signature() == signature) return i;
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1439 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1440 // not found
0 a61af66fc99e Initial load duke parents: diff changeset	1441 #ifdef ASSERT
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1442 int index = linear_search(methods, name, signature);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1443 assert(index == -1, err_msg("binary search should have found entry %d", index));
0 a61af66fc99e Initial load duke parents: diff changeset	1444 #endif
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1445 }
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1446 return -1;
0 a61af66fc99e Initial load duke parents: diff changeset	1447 }
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1448 int InstanceKlass::find_method_by_name(Symbol* name, int* end) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1449 return find_method_by_name(methods(), name, end);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1450 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1451
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1452 int InstanceKlass::find_method_by_name(
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1453 Array<Method> methods, Symbol* name, int* end_ptr) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1454 assert(end_ptr != NULL, "just checking");
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1455 int start = binary_search(methods, name);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1456 int end = start + 1;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1457 if (start != -1) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1458 while (start - 1 >= 0 && (methods->at(start - 1))->name() == name) --start;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1459 while (end < methods->length() && (methods->at(end))->name() == name) ++end;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1460 *end_ptr = end;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1461 return start;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1462 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1463 return -1;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1464 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1465
14221 2353011244bd 8027804: JCK resolveMethod test fails expecting AbstractMethodError hseigel parents: 14210 diff changeset	1466 // uncached_lookup_method searches both the local class methods array and all
2353011244bd 8027804: JCK resolveMethod test fails expecting AbstractMethodError hseigel parents: 14210 diff changeset	1467 // superclasses methods arrays, skipping any overpass methods in superclasses.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1468 Method* InstanceKlass::uncached_lookup_method(Symbol* name, Symbol* signature) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1469 Klass* klass = const_cast<InstanceKlass*>(this);
14221 2353011244bd 8027804: JCK resolveMethod test fails expecting AbstractMethodError hseigel parents: 14210 diff changeset	1470 bool dont_ignore_overpasses = true; // For the class being searched, find its overpasses.
0 a61af66fc99e Initial load duke parents: diff changeset	1471 while (klass != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1472 Method* method = InstanceKlass::cast(klass)->find_method(name, signature);
14221 2353011244bd 8027804: JCK resolveMethod test fails expecting AbstractMethodError hseigel parents: 14210 diff changeset	1473 if ((method != NULL) && (dont_ignore_overpasses \|\| !method->is_overpass())) {
2353011244bd 8027804: JCK resolveMethod test fails expecting AbstractMethodError hseigel parents: 14210 diff changeset	1474 return method;
2353011244bd 8027804: JCK resolveMethod test fails expecting AbstractMethodError hseigel parents: 14210 diff changeset	1475 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1476 klass = InstanceKlass::cast(klass)->super();
14221 2353011244bd 8027804: JCK resolveMethod test fails expecting AbstractMethodError hseigel parents: 14210 diff changeset	1477 dont_ignore_overpasses = false; // Ignore overpass methods in all superclasses.
0 a61af66fc99e Initial load duke parents: diff changeset	1478 }
a61af66fc99e Initial load duke parents: diff changeset	1479 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1480 }
a61af66fc99e Initial load duke parents: diff changeset	1481
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1482 // lookup a method in the default methods list then in all transitive interfaces
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1483 // Do NOT return private or static methods
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1484 Method* InstanceKlass::lookup_method_in_ordered_interfaces(Symbol* name,
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1485 Symbol* signature) const {
12828 d25557d03ec0 8026185: nsk/jvmit/GetMethodDeclaringClass/declcls001 failed acorn parents: 12823 diff changeset	1486 Method* m = NULL;
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1487 if (default_methods() != NULL) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1488 m = find_method(default_methods(), name, signature);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1489 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1490 // Look up interfaces
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1491 if (m == NULL) {
14221 2353011244bd 8027804: JCK resolveMethod test fails expecting AbstractMethodError hseigel parents: 14210 diff changeset	1492 m = lookup_method_in_all_interfaces(name, signature, false);
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1493 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1494 return m;
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1495 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1496
0 a61af66fc99e Initial load duke parents: diff changeset	1497 // lookup a method in all the interfaces that this class implements
12318 36b97be47bde 8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default. acorn parents: 12316 diff changeset	1498 // Do NOT return private or static methods, new in JDK8 which are not externally visible
36b97be47bde 8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default. acorn parents: 12316 diff changeset	1499 // They should only be found in the initial InterfaceMethodRef
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1500 Method* InstanceKlass::lookup_method_in_all_interfaces(Symbol* name,
14221 2353011244bd 8027804: JCK resolveMethod test fails expecting AbstractMethodError hseigel parents: 14210 diff changeset	1501 Symbol* signature,
2353011244bd 8027804: JCK resolveMethod test fails expecting AbstractMethodError hseigel parents: 14210 diff changeset	1502 bool skip_default_methods) const {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1503 Array<Klass> all_ifs = transitive_interfaces();
0 a61af66fc99e Initial load duke parents: diff changeset	1504 int num_ifs = all_ifs->length();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1505 InstanceKlass *ik = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	1506 for (int i = 0; i < num_ifs; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1507 ik = InstanceKlass::cast(all_ifs->at(i));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1508 Method* m = ik->lookup_method(name, signature);
14221 2353011244bd 8027804: JCK resolveMethod test fails expecting AbstractMethodError hseigel parents: 14210 diff changeset	1509 if (m != NULL && m->is_public() && !m->is_static() &&
2353011244bd 8027804: JCK resolveMethod test fails expecting AbstractMethodError hseigel parents: 14210 diff changeset	1510 (!skip_default_methods \|\| !m->is_default_method())) {
0 a61af66fc99e Initial load duke parents: diff changeset	1511 return m;
a61af66fc99e Initial load duke parents: diff changeset	1512 }
a61af66fc99e Initial load duke parents: diff changeset	1513 }
a61af66fc99e Initial load duke parents: diff changeset	1514 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1515 }
a61af66fc99e Initial load duke parents: diff changeset	1516
a61af66fc99e Initial load duke parents: diff changeset	1517 /* jni_id_for_impl for jfieldIds only */
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1518 JNIid* InstanceKlass::jni_id_for_impl(instanceKlassHandle this_oop, int offset) {
0 a61af66fc99e Initial load duke parents: diff changeset	1519 MutexLocker ml(JfieldIdCreation_lock);
a61af66fc99e Initial load duke parents: diff changeset	1520 // Retry lookup after we got the lock
a61af66fc99e Initial load duke parents: diff changeset	1521 JNIid* probe = this_oop->jni_ids() == NULL ? NULL : this_oop->jni_ids()->find(offset);
a61af66fc99e Initial load duke parents: diff changeset	1522 if (probe == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1523 // Slow case, allocate new static field identifier
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1524 probe = new JNIid(this_oop(), offset, this_oop->jni_ids());
0 a61af66fc99e Initial load duke parents: diff changeset	1525 this_oop->set_jni_ids(probe);
a61af66fc99e Initial load duke parents: diff changeset	1526 }
a61af66fc99e Initial load duke parents: diff changeset	1527 return probe;
a61af66fc99e Initial load duke parents: diff changeset	1528 }
a61af66fc99e Initial load duke parents: diff changeset	1529
a61af66fc99e Initial load duke parents: diff changeset	1530
a61af66fc99e Initial load duke parents: diff changeset	1531 /* jni_id_for for jfieldIds only */
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1532 JNIid* InstanceKlass::jni_id_for(int offset) {
0 a61af66fc99e Initial load duke parents: diff changeset	1533 JNIid* probe = jni_ids() == NULL ? NULL : jni_ids()->find(offset);
a61af66fc99e Initial load duke parents: diff changeset	1534 if (probe == NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1535 probe = jni_id_for_impl(this, offset);
0 a61af66fc99e Initial load duke parents: diff changeset	1536 }
a61af66fc99e Initial load duke parents: diff changeset	1537 return probe;
a61af66fc99e Initial load duke parents: diff changeset	1538 }
a61af66fc99e Initial load duke parents: diff changeset	1539
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1540 u2 InstanceKlass::enclosing_method_data(int offset) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1541 Array<jushort>* inner_class_list = inner_classes();
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1542 if (inner_class_list == NULL) {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1543 return 0;
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1544 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1545 int length = inner_class_list->length();
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1546 if (length % inner_class_next_offset == 0) {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1547 return 0;
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1548 } else {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1549 int index = length - enclosing_method_attribute_size;
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1550 assert(offset < enclosing_method_attribute_size, "invalid offset");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1551 return inner_class_list->at(index + offset);
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1552 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1553 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1554
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1555 void InstanceKlass::set_enclosing_method_indices(u2 class_index,
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1556 u2 method_index) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1557 Array<jushort>* inner_class_list = inner_classes();
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1558 assert (inner_class_list != NULL, "_inner_classes list is not set up");
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1559 int length = inner_class_list->length();
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1560 if (length % inner_class_next_offset == enclosing_method_attribute_size) {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1561 int index = length - enclosing_method_attribute_size;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1562 inner_class_list->at_put(
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1563 index + enclosing_method_class_index_offset, class_index);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1564 inner_class_list->at_put(
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1565 index + enclosing_method_method_index_offset, method_index);
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1566 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1567 }
0 a61af66fc99e Initial load duke parents: diff changeset	1568
a61af66fc99e Initial load duke parents: diff changeset	1569 // Lookup or create a jmethodID.
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1570 // This code is called by the VMThread and JavaThreads so the
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1571 // locking has to be done very carefully to avoid deadlocks
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1572 // and/or other cache consistency problems.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1573 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1574 jmethodID InstanceKlass::get_jmethod_id(instanceKlassHandle ik_h, methodHandle method_h) {
0 a61af66fc99e Initial load duke parents: diff changeset	1575 size_t idnum = (size_t)method_h->method_idnum();
a61af66fc99e Initial load duke parents: diff changeset	1576 jmethodID* jmeths = ik_h->methods_jmethod_ids_acquire();
a61af66fc99e Initial load duke parents: diff changeset	1577 size_t length = 0;
a61af66fc99e Initial load duke parents: diff changeset	1578 jmethodID id = NULL;
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1579
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1580 // We use a double-check locking idiom here because this cache is
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1581 // performance sensitive. In the normal system, this cache only
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1582 // transitions from NULL to non-NULL which is safe because we use
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1583 // release_set_methods_jmethod_ids() to advertise the new cache.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1584 // A partially constructed cache should never be seen by a racing
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1585 // thread. We also use release_store_ptr() to save a new jmethodID
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1586 // in the cache so a partially constructed jmethodID should never be
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1587 // seen either. Cache reads of existing jmethodIDs proceed without a
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1588 // lock, but cache writes of a new jmethodID requires uniqueness and
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1589 // creation of the cache itself requires no leaks so a lock is
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1590 // generally acquired in those two cases.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1591 //
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1592 // If the RedefineClasses() API has been used, then this cache can
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1593 // grow and we'll have transitions from non-NULL to bigger non-NULL.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1594 // Cache creation requires no leaks and we require safety between all
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1595 // cache accesses and freeing of the old cache so a lock is generally
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1596 // acquired when the RedefineClasses() API has been used.
0 a61af66fc99e Initial load duke parents: diff changeset	1597
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1598 if (jmeths != NULL) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1599 // the cache already exists
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1600 if (!ik_h->idnum_can_increment()) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1601 // the cache can't grow so we can just get the current values
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1602 get_jmethod_id_length_value(jmeths, idnum, &length, &id);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1603 } else {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1604 // cache can grow so we have to be more careful
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1605 if (Threads::number_of_threads() == 0 \|\|
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1606 SafepointSynchronize::is_at_safepoint()) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1607 // we're single threaded or at a safepoint - no locking needed
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1608 get_jmethod_id_length_value(jmeths, idnum, &length, &id);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1609 } else {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1610 MutexLocker ml(JmethodIdCreation_lock);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1611 get_jmethod_id_length_value(jmeths, idnum, &length, &id);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1612 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1613 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1614 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1615 // implied else:
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1616 // we need to allocate a cache so default length and id values are good
0 a61af66fc99e Initial load duke parents: diff changeset	1617
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1618 if (jmeths == NULL \|\| // no cache yet
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1619 length <= idnum \|\| // cache is too short
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1620 id == NULL) { // cache doesn't contain entry
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1621
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1622 // This function can be called by the VMThread so we have to do all
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1623 // things that might block on a safepoint before grabbing the lock.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1624 // Otherwise, we can deadlock with the VMThread or have a cache
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1625 // consistency issue. These vars keep track of what we might have
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1626 // to free after the lock is dropped.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1627 jmethodID to_dealloc_id = NULL;
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1628 jmethodID* to_dealloc_jmeths = NULL;
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1629
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1630 // may not allocate new_jmeths or use it if we allocate it
0 a61af66fc99e Initial load duke parents: diff changeset	1631 jmethodID* new_jmeths = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1632 if (length <= idnum) {
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1633 // allocate a new cache that might be used
0 a61af66fc99e Initial load duke parents: diff changeset	1634 size_t size = MAX2(idnum+1, (size_t)ik_h->idnum_allocated_count());
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6038 diff changeset	1635 new_jmeths = NEW_C_HEAP_ARRAY(jmethodID, size+1, mtClass);
0 a61af66fc99e Initial load duke parents: diff changeset	1636 memset(new_jmeths, 0, (size+1)*sizeof(jmethodID));
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1637 // cache size is stored in element[0], other elements offset by one
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1638 new_jmeths[0] = (jmethodID)size;
0 a61af66fc99e Initial load duke parents: diff changeset	1639 }
a61af66fc99e Initial load duke parents: diff changeset	1640
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1641 // allocate a new jmethodID that might be used
0 a61af66fc99e Initial load duke parents: diff changeset	1642 jmethodID new_id = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1643 if (method_h->is_old() && !method_h->is_obsolete()) {
a61af66fc99e Initial load duke parents: diff changeset	1644 // The method passed in is old (but not obsolete), we need to use the current version
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1645 Method* current_method = ik_h->method_with_idnum((int)idnum);
0 a61af66fc99e Initial load duke parents: diff changeset	1646 assert(current_method != NULL, "old and but not obsolete, so should exist");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1647 new_id = Method::make_jmethod_id(ik_h->class_loader_data(), current_method);
0 a61af66fc99e Initial load duke parents: diff changeset	1648 } else {
a61af66fc99e Initial load duke parents: diff changeset	1649 // It is the current version of the method or an obsolete method,
a61af66fc99e Initial load duke parents: diff changeset	1650 // use the version passed in
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1651 new_id = Method::make_jmethod_id(ik_h->class_loader_data(), method_h());
0 a61af66fc99e Initial load duke parents: diff changeset	1652 }
a61af66fc99e Initial load duke parents: diff changeset	1653
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1654 if (Threads::number_of_threads() == 0 \|\|
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1655 SafepointSynchronize::is_at_safepoint()) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1656 // we're single threaded or at a safepoint - no locking needed
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1657 id = get_jmethod_id_fetch_or_update(ik_h, idnum, new_id, new_jmeths,
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1658 &to_dealloc_id, &to_dealloc_jmeths);
49 31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1659 } else {
0 a61af66fc99e Initial load duke parents: diff changeset	1660 MutexLocker ml(JmethodIdCreation_lock);
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1661 id = get_jmethod_id_fetch_or_update(ik_h, idnum, new_id, new_jmeths,
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1662 &to_dealloc_id, &to_dealloc_jmeths);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1663 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1664
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1665 // The lock has been dropped so we can free resources.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1666 // Free up either the old cache or the new cache if we allocated one.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1667 if (to_dealloc_jmeths != NULL) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1668 FreeHeap(to_dealloc_jmeths);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1669 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1670 // free up the new ID since it wasn't needed
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1671 if (to_dealloc_id != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1672 Method::destroy_jmethod_id(ik_h->class_loader_data(), to_dealloc_id);
49 31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1673 }
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1674 }
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1675 return id;
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1676 }
0 a61af66fc99e Initial load duke parents: diff changeset	1677
49 31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1678
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1679 // Common code to fetch the jmethodID from the cache or update the
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1680 // cache with the new jmethodID. This function should never do anything
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1681 // that causes the caller to go to a safepoint or we can deadlock with
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1682 // the VMThread or have cache consistency issues.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1683 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1684 jmethodID InstanceKlass::get_jmethod_id_fetch_or_update(
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1685 instanceKlassHandle ik_h, size_t idnum, jmethodID new_id,
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1686 jmethodID* new_jmeths, jmethodID* to_dealloc_id_p,
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1687 jmethodID** to_dealloc_jmeths_p) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1688 assert(new_id != NULL, "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1689 assert(to_dealloc_id_p != NULL, "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1690 assert(to_dealloc_jmeths_p != NULL, "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1691 assert(Threads::number_of_threads() == 0 \|\|
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1692 SafepointSynchronize::is_at_safepoint() \|\|
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1693 JmethodIdCreation_lock->owned_by_self(), "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1694
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1695 // reacquire the cache - we are locked, single threaded or at a safepoint
49 31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1696 jmethodID* jmeths = ik_h->methods_jmethod_ids_acquire();
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1697 jmethodID id = NULL;
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1698 size_t length = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	1699
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1700 if (jmeths == NULL \|\| // no cache yet
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1701 (length = (size_t)jmeths[0]) <= idnum) { // cache is too short
49 31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1702 if (jmeths != NULL) {
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1703 // copy any existing entries from the old cache
49 31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1704 for (size_t index = 0; index < length; index++) {
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1705 new_jmeths[index+1] = jmeths[index+1];
0 a61af66fc99e Initial load duke parents: diff changeset	1706 }
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1707 *to_dealloc_jmeths_p = jmeths; // save old cache for later delete
0 a61af66fc99e Initial load duke parents: diff changeset	1708 }
49 31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1709 ik_h->release_set_methods_jmethod_ids(jmeths = new_jmeths);
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1710 } else {
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1711 // fetch jmethodID (if any) from the existing cache
49 31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1712 id = jmeths[idnum+1];
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1713 *to_dealloc_jmeths_p = new_jmeths; // save new cache for later delete
49 31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1714 }
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1715 if (id == NULL) {
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1716 // No matching jmethodID in the existing cache or we have a new
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1717 // cache or we just grew the cache. This cache write is done here
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1718 // by the first thread to win the foot race because a jmethodID
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1719 // needs to be unique once it is generally available.
49 31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1720 id = new_id;
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1721
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1722 // The jmethodID cache can be read while unlocked so we have to
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1723 // make sure the new jmethodID is complete before installing it
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1724 // in the cache.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1725 OrderAccess::release_store_ptr(&jmeths[idnum+1], id);
49 31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1726 } else {
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1727 *to_dealloc_id_p = new_id; // save new id for later delete
0 a61af66fc99e Initial load duke parents: diff changeset	1728 }
a61af66fc99e Initial load duke parents: diff changeset	1729 return id;
a61af66fc99e Initial load duke parents: diff changeset	1730 }
a61af66fc99e Initial load duke parents: diff changeset	1731
a61af66fc99e Initial load duke parents: diff changeset	1732
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1733 // Common code to get the jmethodID cache length and the jmethodID
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1734 // value at index idnum if there is one.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1735 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1736 void InstanceKlass::get_jmethod_id_length_value(jmethodID* cache,
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1737 size_t idnum, size_t length_p, jmethodID id_p) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1738 assert(cache != NULL, "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1739 assert(length_p != NULL, "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1740 assert(id_p != NULL, "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1741
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1742 // cache size is stored in element[0], other elements offset by one
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1743 *length_p = (size_t)cache[0];
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1744 if (*length_p <= idnum) { // cache is too short
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1745 *id_p = NULL;
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1746 } else {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1747 *id_p = cache[idnum+1]; // fetch jmethodID (if any)
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1748 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1749 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1750
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1751
0 a61af66fc99e Initial load duke parents: diff changeset	1752 // Lookup a jmethodID, NULL if not found. Do no blocking, no allocations, no handles
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1753 jmethodID InstanceKlass::jmethod_id_or_null(Method* method) {
0 a61af66fc99e Initial load duke parents: diff changeset	1754 size_t idnum = (size_t)method->method_idnum();
a61af66fc99e Initial load duke parents: diff changeset	1755 jmethodID* jmeths = methods_jmethod_ids_acquire();
a61af66fc99e Initial load duke parents: diff changeset	1756 size_t length; // length assigned as debugging crumb
a61af66fc99e Initial load duke parents: diff changeset	1757 jmethodID id = NULL;
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1758 if (jmeths != NULL && // If there is a cache
0 a61af66fc99e Initial load duke parents: diff changeset	1759 (length = (size_t)jmeths[0]) > idnum) { // and if it is long enough,
a61af66fc99e Initial load duke parents: diff changeset	1760 id = jmeths[idnum+1]; // Look up the id (may be NULL)
a61af66fc99e Initial load duke parents: diff changeset	1761 }
a61af66fc99e Initial load duke parents: diff changeset	1762 return id;
a61af66fc99e Initial load duke parents: diff changeset	1763 }
a61af66fc99e Initial load duke parents: diff changeset	1764
a61af66fc99e Initial load duke parents: diff changeset	1765
a61af66fc99e Initial load duke parents: diff changeset	1766 //
a61af66fc99e Initial load duke parents: diff changeset	1767 // Walk the list of dependent nmethods searching for nmethods which
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3748 diff changeset	1768 // are dependent on the changes that were passed in and mark them for
0 a61af66fc99e Initial load duke parents: diff changeset	1769 // deoptimization. Returns the number of nmethods found.
a61af66fc99e Initial load duke parents: diff changeset	1770 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1771 int InstanceKlass::mark_dependent_nmethods(DepChange& changes) {
0 a61af66fc99e Initial load duke parents: diff changeset	1772 assert_locked_or_safepoint(CodeCache_lock);
a61af66fc99e Initial load duke parents: diff changeset	1773 int found = 0;
a61af66fc99e Initial load duke parents: diff changeset	1774 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load duke parents: diff changeset	1775 while (b != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1776 nmethod* nm = b->get_nmethod();
a61af66fc99e Initial load duke parents: diff changeset	1777 // since dependencies aren't removed until an nmethod becomes a zombie,
a61af66fc99e Initial load duke parents: diff changeset	1778 // the dependency list may contain nmethods which aren't alive.
a61af66fc99e Initial load duke parents: diff changeset	1779 if (nm->is_alive() && !nm->is_marked_for_deoptimization() && nm->check_dependency_on(changes)) {
a61af66fc99e Initial load duke parents: diff changeset	1780 if (TraceDependencies) {
a61af66fc99e Initial load duke parents: diff changeset	1781 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1782 tty->print_cr("Marked for deoptimization");
a61af66fc99e Initial load duke parents: diff changeset	1783 tty->print_cr(" context = %s", this->external_name());
a61af66fc99e Initial load duke parents: diff changeset	1784 changes.print();
a61af66fc99e Initial load duke parents: diff changeset	1785 nm->print();
a61af66fc99e Initial load duke parents: diff changeset	1786 nm->print_dependencies();
a61af66fc99e Initial load duke parents: diff changeset	1787 }
a61af66fc99e Initial load duke parents: diff changeset	1788 nm->mark_for_deoptimization();
a61af66fc99e Initial load duke parents: diff changeset	1789 found++;
a61af66fc99e Initial load duke parents: diff changeset	1790 }
a61af66fc99e Initial load duke parents: diff changeset	1791 b = b->next();
a61af66fc99e Initial load duke parents: diff changeset	1792 }
a61af66fc99e Initial load duke parents: diff changeset	1793 return found;
a61af66fc99e Initial load duke parents: diff changeset	1794 }
a61af66fc99e Initial load duke parents: diff changeset	1795
a61af66fc99e Initial load duke parents: diff changeset	1796
a61af66fc99e Initial load duke parents: diff changeset	1797 //
a61af66fc99e Initial load duke parents: diff changeset	1798 // Add an nmethodBucket to the list of dependencies for this nmethod.
a61af66fc99e Initial load duke parents: diff changeset	1799 // It's possible that an nmethod has multiple dependencies on this klass
a61af66fc99e Initial load duke parents: diff changeset	1800 // so a count is kept for each bucket to guarantee that creation and
a61af66fc99e Initial load duke parents: diff changeset	1801 // deletion of dependencies is consistent.
a61af66fc99e Initial load duke parents: diff changeset	1802 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1803 void InstanceKlass::add_dependent_nmethod(nmethod* nm) {
0 a61af66fc99e Initial load duke parents: diff changeset	1804 assert_locked_or_safepoint(CodeCache_lock);
a61af66fc99e Initial load duke parents: diff changeset	1805 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load duke parents: diff changeset	1806 nmethodBucket* last = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1807 while (b != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1808 if (nm == b->get_nmethod()) {
a61af66fc99e Initial load duke parents: diff changeset	1809 b->increment();
a61af66fc99e Initial load duke parents: diff changeset	1810 return;
a61af66fc99e Initial load duke parents: diff changeset	1811 }
a61af66fc99e Initial load duke parents: diff changeset	1812 b = b->next();
a61af66fc99e Initial load duke parents: diff changeset	1813 }
a61af66fc99e Initial load duke parents: diff changeset	1814 _dependencies = new nmethodBucket(nm, _dependencies);
a61af66fc99e Initial load duke parents: diff changeset	1815 }
a61af66fc99e Initial load duke parents: diff changeset	1816
a61af66fc99e Initial load duke parents: diff changeset	1817
a61af66fc99e Initial load duke parents: diff changeset	1818 //
a61af66fc99e Initial load duke parents: diff changeset	1819 // Decrement count of the nmethod in the dependency list and remove
a61af66fc99e Initial load duke parents: diff changeset	1820 // the bucket competely when the count goes to 0. This method must
a61af66fc99e Initial load duke parents: diff changeset	1821 // find a corresponding bucket otherwise there's a bug in the
a61af66fc99e Initial load duke parents: diff changeset	1822 // recording of dependecies.
a61af66fc99e Initial load duke parents: diff changeset	1823 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1824 void InstanceKlass::remove_dependent_nmethod(nmethod* nm) {
0 a61af66fc99e Initial load duke parents: diff changeset	1825 assert_locked_or_safepoint(CodeCache_lock);
a61af66fc99e Initial load duke parents: diff changeset	1826 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load duke parents: diff changeset	1827 nmethodBucket* last = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1828 while (b != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1829 if (nm == b->get_nmethod()) {
a61af66fc99e Initial load duke parents: diff changeset	1830 if (b->decrement() == 0) {
a61af66fc99e Initial load duke parents: diff changeset	1831 if (last == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1832 _dependencies = b->next();
a61af66fc99e Initial load duke parents: diff changeset	1833 } else {
a61af66fc99e Initial load duke parents: diff changeset	1834 last->set_next(b->next());
a61af66fc99e Initial load duke parents: diff changeset	1835 }
a61af66fc99e Initial load duke parents: diff changeset	1836 delete b;
a61af66fc99e Initial load duke parents: diff changeset	1837 }
a61af66fc99e Initial load duke parents: diff changeset	1838 return;
a61af66fc99e Initial load duke parents: diff changeset	1839 }
a61af66fc99e Initial load duke parents: diff changeset	1840 last = b;
a61af66fc99e Initial load duke parents: diff changeset	1841 b = b->next();
a61af66fc99e Initial load duke parents: diff changeset	1842 }
a61af66fc99e Initial load duke parents: diff changeset	1843 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1844 tty->print_cr("### %s can't find dependent nmethod:", this->external_name());
a61af66fc99e Initial load duke parents: diff changeset	1845 nm->print();
a61af66fc99e Initial load duke parents: diff changeset	1846 #endif // ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1847 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	1848 }
a61af66fc99e Initial load duke parents: diff changeset	1849
a61af66fc99e Initial load duke parents: diff changeset	1850
a61af66fc99e Initial load duke parents: diff changeset	1851 #ifndef PRODUCT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1852 void InstanceKlass::print_dependent_nmethods(bool verbose) {
0 a61af66fc99e Initial load duke parents: diff changeset	1853 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load duke parents: diff changeset	1854 int idx = 0;
a61af66fc99e Initial load duke parents: diff changeset	1855 while (b != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1856 nmethod* nm = b->get_nmethod();
a61af66fc99e Initial load duke parents: diff changeset	1857 tty->print("[%d] count=%d { ", idx++, b->count());
a61af66fc99e Initial load duke parents: diff changeset	1858 if (!verbose) {
a61af66fc99e Initial load duke parents: diff changeset	1859 nm->print_on(tty, "nmethod");
a61af66fc99e Initial load duke parents: diff changeset	1860 tty->print_cr(" } ");
a61af66fc99e Initial load duke parents: diff changeset	1861 } else {
a61af66fc99e Initial load duke parents: diff changeset	1862 nm->print();
a61af66fc99e Initial load duke parents: diff changeset	1863 nm->print_dependencies();
a61af66fc99e Initial load duke parents: diff changeset	1864 tty->print_cr("--- } ");
a61af66fc99e Initial load duke parents: diff changeset	1865 }
a61af66fc99e Initial load duke parents: diff changeset	1866 b = b->next();
a61af66fc99e Initial load duke parents: diff changeset	1867 }
a61af66fc99e Initial load duke parents: diff changeset	1868 }
a61af66fc99e Initial load duke parents: diff changeset	1869
a61af66fc99e Initial load duke parents: diff changeset	1870
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1871 bool InstanceKlass::is_dependent_nmethod(nmethod* nm) {
0 a61af66fc99e Initial load duke parents: diff changeset	1872 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load duke parents: diff changeset	1873 while (b != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1874 if (nm == b->get_nmethod()) {
a61af66fc99e Initial load duke parents: diff changeset	1875 return true;
a61af66fc99e Initial load duke parents: diff changeset	1876 }
a61af66fc99e Initial load duke parents: diff changeset	1877 b = b->next();
a61af66fc99e Initial load duke parents: diff changeset	1878 }
a61af66fc99e Initial load duke parents: diff changeset	1879 return false;
a61af66fc99e Initial load duke parents: diff changeset	1880 }
a61af66fc99e Initial load duke parents: diff changeset	1881 #endif //PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1882
a61af66fc99e Initial load duke parents: diff changeset	1883
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1884 // Garbage collection
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1885
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1886 #ifdef ASSERT
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1887 template <class T> void assert_is_in(T *p) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1888 T heap_oop = oopDesc::load_heap_oop(p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1889 if (!oopDesc::is_null(heap_oop)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1890 oop o = oopDesc::decode_heap_oop_not_null(heap_oop);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1891 assert(Universe::heap()->is_in(o), "should be in heap");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1892 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1893 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1894 template <class T> void assert_is_in_closed_subset(T *p) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1895 T heap_oop = oopDesc::load_heap_oop(p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1896 if (!oopDesc::is_null(heap_oop)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1897 oop o = oopDesc::decode_heap_oop_not_null(heap_oop);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1898 assert(Universe::heap()->is_in_closed_subset(o),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1899 err_msg("should be in closed *p " INTPTR_FORMAT " " INTPTR_FORMAT, (address)p, (address)o));
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1900 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1901 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1902 template <class T> void assert_is_in_reserved(T *p) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1903 T heap_oop = oopDesc::load_heap_oop(p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1904 if (!oopDesc::is_null(heap_oop)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1905 oop o = oopDesc::decode_heap_oop_not_null(heap_oop);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1906 assert(Universe::heap()->is_in_reserved(o), "should be in reserved");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1907 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1908 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1909 template <class T> void assert_nothing(T *p) {}
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1910
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1911 #else
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1912 template <class T> void assert_is_in(T *p) {}
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1913 template <class T> void assert_is_in_closed_subset(T *p) {}
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1914 template <class T> void assert_is_in_reserved(T *p) {}
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1915 template <class T> void assert_nothing(T *p) {}
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1916 #endif // ASSERT
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1917
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1918 //
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1919 // Macros that iterate over areas of oops which are specialized on type of
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1920 // oop pointer either narrow or wide, depending on UseCompressedOops
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1921 //
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1922 // Parameters are:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1923 // T - type of oop to point to (either oop or narrowOop)
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1924 // start_p - starting pointer for region to iterate over
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1925 // count - number of oops or narrowOops to iterate over
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1926 // do_oop - action to perform on each oop (it's arbitrary C code which
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1927 // makes it more efficient to put in a macro rather than making
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1928 // it a template function)
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1929 // assert_fn - assert function which is template function because performance
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1930 // doesn't matter when enabled.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1931 #define InstanceKlass_SPECIALIZED_OOP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1932 T, start_p, count, do_oop, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1933 assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1934 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1935 T* p = (T*)(start_p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1936 T* const end = p + (count); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1937 while (p < end) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1938 (assert_fn)(p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1939 do_oop; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1940 ++p; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1941 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1942 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1943
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1944 #define InstanceKlass_SPECIALIZED_OOP_REVERSE_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1945 T, start_p, count, do_oop, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1946 assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1947 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1948 T* const start = (T*)(start_p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1949 T* p = start + (count); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1950 while (start < p) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1951 --p; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1952 (assert_fn)(p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1953 do_oop; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1954 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1955 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1956
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1957 #define InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1958 T, start_p, count, low, high, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1959 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1960 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1961 T* const l = (T*)(low); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1962 T* const h = (T*)(high); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1963 assert(mask_bits((intptr_t)l, sizeof(T)-1) == 0 && \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1964 mask_bits((intptr_t)h, sizeof(T)-1) == 0, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1965 "bounded region must be properly aligned"); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1966 T* p = (T*)(start_p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1967 T* end = p + (count); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1968 if (p < l) p = l; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1969 if (end > h) end = h; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1970 while (p < end) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1971 (assert_fn)(p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1972 do_oop; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1973 ++p; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1974 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1975 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1976
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1977
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1978 // The following macros call specialized macros, passing either oop or
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1979 // narrowOop as the specialization type. These test the UseCompressedOops
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1980 // flag.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1981 #define InstanceKlass_OOP_MAP_ITERATE(obj, do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1982 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1983 /* Compute oopmap block range. The common case \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1984 is nonstatic_oop_map_size == 1. */ \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1985 OopMapBlock* map = start_of_nonstatic_oop_maps(); \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	1986 OopMapBlock* const end_map = map + nonstatic_oop_map_count(); \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1987 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1988 while (map < end_map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1989 InstanceKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	1990 obj->obj_field_addr<narrowOop>(map->offset()), map->count(), \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1991 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1992 ++map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1993 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1994 } else { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1995 while (map < end_map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1996 InstanceKlass_SPECIALIZED_OOP_ITERATE(oop, \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	1997 obj->obj_field_addr<oop>(map->offset()), map->count(), \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1998 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1999 ++map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2000 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2001 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2002 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2003
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2004 #define InstanceKlass_OOP_MAP_REVERSE_ITERATE(obj, do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2005 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2006 OopMapBlock* const start_map = start_of_nonstatic_oop_maps(); \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	2007 OopMapBlock* map = start_map + nonstatic_oop_map_count(); \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2008 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2009 while (start_map < map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2010 --map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2011 InstanceKlass_SPECIALIZED_OOP_REVERSE_ITERATE(narrowOop, \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	2012 obj->obj_field_addr<narrowOop>(map->offset()), map->count(), \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2013 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2014 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2015 } else { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2016 while (start_map < map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2017 --map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2018 InstanceKlass_SPECIALIZED_OOP_REVERSE_ITERATE(oop, \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	2019 obj->obj_field_addr<oop>(map->offset()), map->count(), \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2020 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2021 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2022 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2023 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2024
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2025 #define InstanceKlass_BOUNDED_OOP_MAP_ITERATE(obj, low, high, do_oop, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2026 assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2027 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2028 /* Compute oopmap block range. The common case is \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2029 nonstatic_oop_map_size == 1, so we accept the \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2030 usually non-existent extra overhead of examining \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2031 all the maps. */ \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2032 OopMapBlock* map = start_of_nonstatic_oop_maps(); \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	2033 OopMapBlock* const end_map = map + nonstatic_oop_map_count(); \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2034 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2035 while (map < end_map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2036 InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	2037 obj->obj_field_addr<narrowOop>(map->offset()), map->count(), \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2038 low, high, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2039 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2040 ++map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2041 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2042 } else { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2043 while (map < end_map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2044 InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	2045 obj->obj_field_addr<oop>(map->offset()), map->count(), \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2046 low, high, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2047 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2048 ++map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2049 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2050 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2051 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2052
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2053 void InstanceKlass::oop_follow_contents(oop obj) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2054 assert(obj != NULL, "can't follow the content of NULL object");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2055 MarkSweep::follow_klass(obj->klass());
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2056 InstanceKlass_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2057 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2058 MarkSweep::mark_and_push(p), \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2059 assert_is_in_closed_subset)
0 a61af66fc99e Initial load duke parents: diff changeset	2060 }
a61af66fc99e Initial load duke parents: diff changeset	2061
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	2062 #if INCLUDE_ALL_GCS
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2063 void InstanceKlass::oop_follow_contents(ParCompactionManager* cm,
0 a61af66fc99e Initial load duke parents: diff changeset	2064 oop obj) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2065 assert(obj != NULL, "can't follow the content of NULL object");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2066 PSParallelCompact::follow_klass(cm, obj->klass());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2067 // Only mark the header and let the scan of the meta-data mark
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2068 // everything else.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2069 InstanceKlass_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2070 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2071 PSParallelCompact::mark_and_push(cm, p), \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2072 assert_is_in)
0 a61af66fc99e Initial load duke parents: diff changeset	2073 }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	2074 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	2075
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2076 // closure's do_metadata() method dictates whether the given closure should be
0 a61af66fc99e Initial load duke parents: diff changeset	2077 // applied to the klass ptr in the object header.
a61af66fc99e Initial load duke parents: diff changeset	2078
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2079 #define if_do_metadata_checked(closure, nv_suffix) \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2080 /* Make sure the non-virtual and the virtual versions match. */ \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2081 assert(closure->do_metadata##nv_suffix() == closure->do_metadata(), \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2082 "Inconsistency in do_metadata"); \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2083 if (closure->do_metadata##nv_suffix())
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2084
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2085 #define InstanceKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2086 \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2087 int InstanceKlass::oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) { \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2088 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::ik);\
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2089 /* header */ \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2090 if_do_metadata_checked(closure, nv_suffix) { \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2091 closure->do_klass##nv_suffix(obj->klass()); \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2092 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2093 InstanceKlass_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2094 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2095 SpecializationStats:: \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2096 record_do_oop_call##nv_suffix(SpecializationStats::ik); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2097 (closure)->do_oop##nv_suffix(p), \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2098 assert_is_in_closed_subset) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2099 return size_helper(); \
0 a61af66fc99e Initial load duke parents: diff changeset	2100 }
a61af66fc99e Initial load duke parents: diff changeset	2101
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	2102 #if INCLUDE_ALL_GCS
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2103 #define InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2104 \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2105 int InstanceKlass::oop_oop_iterate_backwards##nv_suffix(oop obj, \
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2106 OopClosureType* closure) { \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2107 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::ik); \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2108 /* header */ \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2109 if_do_metadata_checked(closure, nv_suffix) { \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2110 closure->do_klass##nv_suffix(obj->klass()); \
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2111 } \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2112 /* instance variables */ \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2113 InstanceKlass_OOP_MAP_REVERSE_ITERATE( \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2114 obj, \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2115 SpecializationStats::record_do_oop_call##nv_suffix(SpecializationStats::ik);\
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2116 (closure)->do_oop##nv_suffix(p), \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2117 assert_is_in_closed_subset) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2118 return size_helper(); \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2119 }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	2120 #endif // INCLUDE_ALL_GCS
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2121
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2122 #define InstanceKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2123 \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2124 int InstanceKlass::oop_oop_iterate##nv_suffix##_m(oop obj, \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2125 OopClosureType* closure, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2126 MemRegion mr) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2127 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::ik);\
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2128 if_do_metadata_checked(closure, nv_suffix) { \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2129 if (mr.contains(obj)) { \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2130 closure->do_klass##nv_suffix(obj->klass()); \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2131 } \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2132 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2133 InstanceKlass_BOUNDED_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2134 obj, mr.start(), mr.end(), \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2135 (closure)->do_oop##nv_suffix(p), \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2136 assert_is_in_closed_subset) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2137 return size_helper(); \
0 a61af66fc99e Initial load duke parents: diff changeset	2138 }
a61af66fc99e Initial load duke parents: diff changeset	2139
a61af66fc99e Initial load duke parents: diff changeset	2140 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_DEFN)
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2141 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DEFN)
0 a61af66fc99e Initial load duke parents: diff changeset	2142 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_DEFN_m)
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2143 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DEFN_m)
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	2144 #if INCLUDE_ALL_GCS
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2145 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2146 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	2147 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	2148
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2149 int InstanceKlass::oop_adjust_pointers(oop obj) {
0 a61af66fc99e Initial load duke parents: diff changeset	2150 int size = size_helper();
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2151 InstanceKlass_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2152 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2153 MarkSweep::adjust_pointer(p), \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2154 assert_is_in)
0 a61af66fc99e Initial load duke parents: diff changeset	2155 return size;
a61af66fc99e Initial load duke parents: diff changeset	2156 }
a61af66fc99e Initial load duke parents: diff changeset	2157
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	2158 #if INCLUDE_ALL_GCS
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2159 void InstanceKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2160 InstanceKlass_OOP_MAP_REVERSE_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2161 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2162 if (PSScavenge::should_scavenge(p)) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2163 pm->claim_or_forward_depth(p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2164 }, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2165 assert_nothing )
0 a61af66fc99e Initial load duke parents: diff changeset	2166 }
a61af66fc99e Initial load duke parents: diff changeset	2167
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2168 int InstanceKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2169 int size = size_helper();
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2170 InstanceKlass_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2171 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2172 PSParallelCompact::adjust_pointer(p), \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2173 assert_is_in)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2174 return size;
0 a61af66fc99e Initial load duke parents: diff changeset	2175 }
a61af66fc99e Initial load duke parents: diff changeset	2176
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	2177 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	2178
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2179 void InstanceKlass::clean_implementors_list(BoolObjectClosure* is_alive) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2180 assert(is_loader_alive(is_alive), "this klass should be live");
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	2181 if (is_interface()) {
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	2182 if (ClassUnloading) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2183 Klass* impl = implementor();
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	2184 if (impl != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2185 if (!impl->is_loader_alive(is_alive)) {
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	2186 // remove this guy
8693 872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	2187 Klass** klass = adr_implementor();
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	2188 assert(klass != NULL, "null klass");
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	2189 if (klass != NULL) {
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	2190 *klass = NULL;
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	2191 }
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	2192 }
0 a61af66fc99e Initial load duke parents: diff changeset	2193 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2194 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2195 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2196 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2197
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2198 void InstanceKlass::clean_method_data(BoolObjectClosure* is_alive) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2199 for (int m = 0; m < methods()->length(); m++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2200 MethodData* mdo = methods()->at(m)->method_data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2201 if (mdo != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2202 for (ProfileData* data = mdo->first_data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2203 mdo->is_valid(data);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2204 data = mdo->next_data(data)) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2205 data->clean_weak_klass_links(is_alive);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2206 }
13080 6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12995 diff changeset	2207 ParametersTypeData* parameters = mdo->parameters_type_data();
6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12995 diff changeset	2208 if (parameters != NULL) {
6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12995 diff changeset	2209 parameters->clean_weak_klass_links(is_alive);
6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12995 diff changeset	2210 }
0 a61af66fc99e Initial load duke parents: diff changeset	2211 }
a61af66fc99e Initial load duke parents: diff changeset	2212 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2213 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2214
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2215
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2216 static void remove_unshareable_in_class(Klass* k) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2217 // remove klass's unshareable info
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2218 k->remove_unshareable_info();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2219 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2220
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2221 void InstanceKlass::remove_unshareable_info() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2222 Klass::remove_unshareable_info();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2223 // Unlink the class
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2224 if (is_linked()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2225 unlink_class();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2226 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2227 init_implementor();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2228
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2229 constants()->remove_unshareable_info();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2230
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2231 for (int i = 0; i < methods()->length(); i++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2232 Method* m = methods()->at(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2233 m->remove_unshareable_info();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2234 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2235
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2236 // do array classes also.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2237 array_klasses_do(remove_unshareable_in_class);
0 a61af66fc99e Initial load duke parents: diff changeset	2238 }
a61af66fc99e Initial load duke parents: diff changeset	2239
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2240 void restore_unshareable_in_class(Klass* k, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2241 k->restore_unshareable_info(CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	2242 }
a61af66fc99e Initial load duke parents: diff changeset	2243
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2244 void InstanceKlass::restore_unshareable_info(TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2245 Klass::restore_unshareable_info(CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2246 instanceKlassHandle ik(THREAD, this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2247
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2248 Array<Method> methods = ik->methods();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2249 int num_methods = methods->length();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2250 for (int index2 = 0; index2 < num_methods; ++index2) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2251 methodHandle m(THREAD, methods->at(index2));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2252 m()->link_method(m, CHECK);
6733 fa6e618671d7 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type coleenp parents: 6725 diff changeset	2253 // restore method's vtable by calling a virtual function
fa6e618671d7 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type coleenp parents: 6725 diff changeset	2254 m->restore_vtable();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2255 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2256 if (JvmtiExport::has_redefined_a_class()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2257 // Reinitialize vtable because RedefineClasses may have changed some
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2258 // entries in this vtable for super classes so the CDS vtable might
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2259 // point to old or obsolete entries. RedefineClasses doesn't fix up
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2260 // vtables in the shared system dictionary, only the main one.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2261 // It also redefines the itable too so fix that too.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2262 ResourceMark rm(THREAD);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2263 ik->vtable()->initialize_vtable(false, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2264 ik->itable()->initialize_itable(false, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2265 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2266
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2267 // restore constant pool resolved references
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2268 ik->constants()->restore_unshareable_info(CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2269
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2270 ik->array_klasses_do(restore_unshareable_in_class, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2271 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2272
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2273 static void clear_all_breakpoints(Method* m) {
0 a61af66fc99e Initial load duke parents: diff changeset	2274 m->clear_all_breakpoints();
a61af66fc99e Initial load duke parents: diff changeset	2275 }
a61af66fc99e Initial load duke parents: diff changeset	2276
10149 d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2277
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2278 void InstanceKlass::notify_unload_class(InstanceKlass* ik) {
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2279 // notify the debugger
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2280 if (JvmtiExport::should_post_class_unload()) {
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2281 JvmtiExport::post_class_unload(ik);
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2282 }
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2283
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2284 // notify ClassLoadingService of class unload
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2285 ClassLoadingService::notify_class_unloaded(ik);
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2286 }
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2287
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2288 void InstanceKlass::release_C_heap_structures(InstanceKlass* ik) {
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2289 // Clean up C heap
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2290 ik->release_C_heap_structures();
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2291 ik->constants()->release_C_heap_structures();
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2292 }
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2293
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2294 void InstanceKlass::release_C_heap_structures() {
10149 d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2295
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2296 // Can't release the constant pool here because the constant pool can be
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2297 // deallocated separately from the InstanceKlass for default methods and
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2298 // redefine classes.
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2299
0 a61af66fc99e Initial load duke parents: diff changeset	2300 // Deallocate oop map cache
a61af66fc99e Initial load duke parents: diff changeset	2301 if (_oop_map_cache != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2302 delete _oop_map_cache;
a61af66fc99e Initial load duke parents: diff changeset	2303 _oop_map_cache = NULL;
a61af66fc99e Initial load duke parents: diff changeset	2304 }
a61af66fc99e Initial load duke parents: diff changeset	2305
a61af66fc99e Initial load duke parents: diff changeset	2306 // Deallocate JNI identifiers for jfieldIDs
a61af66fc99e Initial load duke parents: diff changeset	2307 JNIid::deallocate(jni_ids());
a61af66fc99e Initial load duke parents: diff changeset	2308 set_jni_ids(NULL);
a61af66fc99e Initial load duke parents: diff changeset	2309
a61af66fc99e Initial load duke parents: diff changeset	2310 jmethodID* jmeths = methods_jmethod_ids_acquire();
a61af66fc99e Initial load duke parents: diff changeset	2311 if (jmeths != (jmethodID*)NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2312 release_set_methods_jmethod_ids(NULL);
a61af66fc99e Initial load duke parents: diff changeset	2313 FreeHeap(jmeths);
a61af66fc99e Initial load duke parents: diff changeset	2314 }
a61af66fc99e Initial load duke parents: diff changeset	2315
10347 6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock sspitsyn parents: 10345 diff changeset	2316 // Deallocate MemberNameTable
6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock sspitsyn parents: 10345 diff changeset	2317 {
6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock sspitsyn parents: 10345 diff changeset	2318 Mutex* lock_or_null = SafepointSynchronize::is_at_safepoint() ? NULL : MemberNameTable_lock;
6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock sspitsyn parents: 10345 diff changeset	2319 MutexLockerEx ml(lock_or_null, Mutex::_no_safepoint_check_flag);
6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock sspitsyn parents: 10345 diff changeset	2320 MemberNameTable* mnt = member_names();
6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock sspitsyn parents: 10345 diff changeset	2321 if (mnt != NULL) {
6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock sspitsyn parents: 10345 diff changeset	2322 delete mnt;
6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock sspitsyn parents: 10345 diff changeset	2323 set_member_names(NULL);
6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock sspitsyn parents: 10345 diff changeset	2324 }
10133 6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 9062 diff changeset	2325 }
6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 9062 diff changeset	2326
0 a61af66fc99e Initial load duke parents: diff changeset	2327 // release dependencies
a61af66fc99e Initial load duke parents: diff changeset	2328 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load duke parents: diff changeset	2329 _dependencies = NULL;
a61af66fc99e Initial load duke parents: diff changeset	2330 while (b != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2331 nmethodBucket* next = b->next();
a61af66fc99e Initial load duke parents: diff changeset	2332 delete b;
a61af66fc99e Initial load duke parents: diff changeset	2333 b = next;
a61af66fc99e Initial load duke parents: diff changeset	2334 }
a61af66fc99e Initial load duke parents: diff changeset	2335
a61af66fc99e Initial load duke parents: diff changeset	2336 // Deallocate breakpoint records
a61af66fc99e Initial load duke parents: diff changeset	2337 if (breakpoints() != 0x0) {
a61af66fc99e Initial load duke parents: diff changeset	2338 methods_do(clear_all_breakpoints);
a61af66fc99e Initial load duke parents: diff changeset	2339 assert(breakpoints() == 0x0, "should have cleared breakpoints");
a61af66fc99e Initial load duke parents: diff changeset	2340 }
a61af66fc99e Initial load duke parents: diff changeset	2341
a61af66fc99e Initial load duke parents: diff changeset	2342 // deallocate information about previous versions
a61af66fc99e Initial load duke parents: diff changeset	2343 if (_previous_versions != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2344 for (int i = _previous_versions->length() - 1; i >= 0; i--) {
a61af66fc99e Initial load duke parents: diff changeset	2345 PreviousVersionNode * pv_node = _previous_versions->at(i);
a61af66fc99e Initial load duke parents: diff changeset	2346 delete pv_node;
a61af66fc99e Initial load duke parents: diff changeset	2347 }
a61af66fc99e Initial load duke parents: diff changeset	2348 delete _previous_versions;
a61af66fc99e Initial load duke parents: diff changeset	2349 _previous_versions = NULL;
a61af66fc99e Initial load duke parents: diff changeset	2350 }
a61af66fc99e Initial load duke parents: diff changeset	2351
a61af66fc99e Initial load duke parents: diff changeset	2352 // deallocate the cached class file
11148 825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	2353 if (_cached_class_file != NULL) {
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	2354 os::free(_cached_class_file, mtClass);
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	2355 _cached_class_file = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	2356 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2357
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2358 // Decrement symbol reference counts associated with the unloaded class.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2359 if (_name != NULL) _name->decrement_refcount();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2360 // unreference array name derived from this class name (arrays of an unloaded
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2361 // class can't be referenced anymore).
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2362 if (_array_name != NULL) _array_name->decrement_refcount();
6203 04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2363 if (_source_debug_extension != NULL) FREE_C_HEAP_ARRAY(char, _source_debug_extension, mtClass);
7464 ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 7180 diff changeset	2364
ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 7180 diff changeset	2365 assert(_total_instanceKlass_count >= 1, "Sanity check");
ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 7180 diff changeset	2366 Atomic::dec(&_total_instanceKlass_count);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2367 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2368
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2369 void InstanceKlass::set_source_debug_extension(char* array, int length) {
6203 04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2370 if (array == NULL) {
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2371 _source_debug_extension = NULL;
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2372 } else {
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2373 // Adding one to the attribute length in order to store a null terminator
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2374 // character could cause an overflow because the attribute length is
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2375 // already coded with an u4 in the classfile, but in practice, it's
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2376 // unlikely to happen.
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2377 assert((length+1) > length, "Overflow checking");
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2378 char* sde = NEW_C_HEAP_ARRAY(char, (length + 1), mtClass);
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2379 for (int i = 0; i < length; i++) {
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2380 sde[i] = array[i];
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2381 }
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2382 sde[length] = '\0';
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2383 _source_debug_extension = sde;
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2384 }
0 a61af66fc99e Initial load duke parents: diff changeset	2385 }
a61af66fc99e Initial load duke parents: diff changeset	2386
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2387 address InstanceKlass::static_field_addr(int offset) {
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12287 diff changeset	2388 return (address)(offset + InstanceMirrorKlass::offset_of_static_fields() + cast_from_oop<intptr_t>(java_mirror()));
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	2389 }
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	2390
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	2391
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2392 const char* InstanceKlass::signature_name() const {
12995 e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2393 int hash_len = 0;
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2394 char hash_buf[40];
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2395
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2396 // If this is an anonymous class, append a hash to make the name unique
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2397 if (is_anonymous()) {
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2398 assert(EnableInvokeDynamic, "EnableInvokeDynamic was not set.");
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2399 intptr_t hash = (java_mirror() != NULL) ? java_mirror()->identity_hash() : 0;
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2400 sprintf(hash_buf, "/" UINTX_FORMAT, (uintx)hash);
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2401 hash_len = (int)strlen(hash_buf);
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2402 }
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2403
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2404 // Get the internal name as a c string
0 a61af66fc99e Initial load duke parents: diff changeset	2405 const char* src = (const char*) (name()->as_C_string());
a61af66fc99e Initial load duke parents: diff changeset	2406 const int src_length = (int)strlen(src);
12995 e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2407
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2408 char* dest = NEW_RESOURCE_ARRAY(char, src_length + hash_len + 3);
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2409
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2410 // Add L as type indicator
0 a61af66fc99e Initial load duke parents: diff changeset	2411 int dest_index = 0;
a61af66fc99e Initial load duke parents: diff changeset	2412 dest[dest_index++] = 'L';
12995 e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2413
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2414 // Add the actual class name
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2415 for (int src_index = 0; src_index < src_length; ) {
0 a61af66fc99e Initial load duke parents: diff changeset	2416 dest[dest_index++] = src[src_index++];
a61af66fc99e Initial load duke parents: diff changeset	2417 }
12995 e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2418
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2419 // If we have a hash, append it
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2420 for (int hash_index = 0; hash_index < hash_len; ) {
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2421 dest[dest_index++] = hash_buf[hash_index++];
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2422 }
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2423
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2424 // Add the semicolon and the NULL
0 a61af66fc99e Initial load duke parents: diff changeset	2425 dest[dest_index++] = ';';
a61af66fc99e Initial load duke parents: diff changeset	2426 dest[dest_index] = '\0';
a61af66fc99e Initial load duke parents: diff changeset	2427 return dest;
a61af66fc99e Initial load duke parents: diff changeset	2428 }
a61af66fc99e Initial load duke parents: diff changeset	2429
a61af66fc99e Initial load duke parents: diff changeset	2430 // different verisons of is_same_class_package
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2431 bool InstanceKlass::is_same_class_package(Klass* class2) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2432 Klass* class1 = this;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2433 oop classloader1 = InstanceKlass::cast(class1)->class_loader();
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	2434 Symbol* classname1 = class1->name();
070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	2435
070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	2436 if (class2->oop_is_objArray()) {
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6735 diff changeset	2437 class2 = ObjArrayKlass::cast(class2)->bottom_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	2438 }
a61af66fc99e Initial load duke parents: diff changeset	2439 oop classloader2;
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	2440 if (class2->oop_is_instance()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2441 classloader2 = InstanceKlass::cast(class2)->class_loader();
0 a61af66fc99e Initial load duke parents: diff changeset	2442 } else {
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	2443 assert(class2->oop_is_typeArray(), "should be type array");
0 a61af66fc99e Initial load duke parents: diff changeset	2444 classloader2 = NULL;
a61af66fc99e Initial load duke parents: diff changeset	2445 }
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	2446 Symbol* classname2 = class2->name();
0 a61af66fc99e Initial load duke parents: diff changeset	2447
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2448 return InstanceKlass::is_same_class_package(classloader1, classname1,
0 a61af66fc99e Initial load duke parents: diff changeset	2449 classloader2, classname2);
a61af66fc99e Initial load duke parents: diff changeset	2450 }
a61af66fc99e Initial load duke parents: diff changeset	2451
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2452 bool InstanceKlass::is_same_class_package(oop classloader2, Symbol* classname2) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2453 Klass* class1 = this;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2454 oop classloader1 = InstanceKlass::cast(class1)->class_loader();
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	2455 Symbol* classname1 = class1->name();
0 a61af66fc99e Initial load duke parents: diff changeset	2456
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2457 return InstanceKlass::is_same_class_package(classloader1, classname1,
0 a61af66fc99e Initial load duke parents: diff changeset	2458 classloader2, classname2);
a61af66fc99e Initial load duke parents: diff changeset	2459 }
a61af66fc99e Initial load duke parents: diff changeset	2460
a61af66fc99e Initial load duke parents: diff changeset	2461 // return true if two classes are in the same package, classloader
a61af66fc99e Initial load duke parents: diff changeset	2462 // and classname information is enough to determine a class's package
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2463 bool InstanceKlass::is_same_class_package(oop class_loader1, Symbol* class_name1,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2464 oop class_loader2, Symbol* class_name2) {
0 a61af66fc99e Initial load duke parents: diff changeset	2465 if (class_loader1 != class_loader2) {
a61af66fc99e Initial load duke parents: diff changeset	2466 return false;
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2467 } else if (class_name1 == class_name2) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2468 return true; // skip painful bytewise comparison
0 a61af66fc99e Initial load duke parents: diff changeset	2469 } else {
a61af66fc99e Initial load duke parents: diff changeset	2470 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	2471
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2472 // The Symbol*'s are in UTF8 encoding. Since we only need to check explicitly
0 a61af66fc99e Initial load duke parents: diff changeset	2473 // for ASCII characters ('/', 'L', '['), we can keep them in UTF8 encoding.
a61af66fc99e Initial load duke parents: diff changeset	2474 // Otherwise, we just compare jbyte values between the strings.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2475 const jbyte *name1 = class_name1->base();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2476 const jbyte *name2 = class_name2->base();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2477
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2478 const jbyte *last_slash1 = UTF8::strrchr(name1, class_name1->utf8_length(), '/');
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2479 const jbyte *last_slash2 = UTF8::strrchr(name2, class_name2->utf8_length(), '/');
0 a61af66fc99e Initial load duke parents: diff changeset	2480
a61af66fc99e Initial load duke parents: diff changeset	2481 if ((last_slash1 == NULL) \|\| (last_slash2 == NULL)) {
a61af66fc99e Initial load duke parents: diff changeset	2482 // One of the two doesn't have a package. Only return true
a61af66fc99e Initial load duke parents: diff changeset	2483 // if the other one also doesn't have a package.
a61af66fc99e Initial load duke parents: diff changeset	2484 return last_slash1 == last_slash2;
a61af66fc99e Initial load duke parents: diff changeset	2485 } else {
a61af66fc99e Initial load duke parents: diff changeset	2486 // Skip over '['s
a61af66fc99e Initial load duke parents: diff changeset	2487 if (*name1 == '[') {
a61af66fc99e Initial load duke parents: diff changeset	2488 do {
a61af66fc99e Initial load duke parents: diff changeset	2489 name1++;
a61af66fc99e Initial load duke parents: diff changeset	2490 } while (*name1 == '[');
a61af66fc99e Initial load duke parents: diff changeset	2491 if (*name1 != 'L') {
a61af66fc99e Initial load duke parents: diff changeset	2492 // Something is terribly wrong. Shouldn't be here.
a61af66fc99e Initial load duke parents: diff changeset	2493 return false;
a61af66fc99e Initial load duke parents: diff changeset	2494 }
a61af66fc99e Initial load duke parents: diff changeset	2495 }
a61af66fc99e Initial load duke parents: diff changeset	2496 if (*name2 == '[') {
a61af66fc99e Initial load duke parents: diff changeset	2497 do {
a61af66fc99e Initial load duke parents: diff changeset	2498 name2++;
a61af66fc99e Initial load duke parents: diff changeset	2499 } while (*name2 == '[');
a61af66fc99e Initial load duke parents: diff changeset	2500 if (*name2 != 'L') {
a61af66fc99e Initial load duke parents: diff changeset	2501 // Something is terribly wrong. Shouldn't be here.
a61af66fc99e Initial load duke parents: diff changeset	2502 return false;
a61af66fc99e Initial load duke parents: diff changeset	2503 }
a61af66fc99e Initial load duke parents: diff changeset	2504 }
a61af66fc99e Initial load duke parents: diff changeset	2505
a61af66fc99e Initial load duke parents: diff changeset	2506 // Check that package part is identical
a61af66fc99e Initial load duke parents: diff changeset	2507 int length1 = last_slash1 - name1;
a61af66fc99e Initial load duke parents: diff changeset	2508 int length2 = last_slash2 - name2;
a61af66fc99e Initial load duke parents: diff changeset	2509
a61af66fc99e Initial load duke parents: diff changeset	2510 return UTF8::equal(name1, length1, name2, length2);
a61af66fc99e Initial load duke parents: diff changeset	2511 }
a61af66fc99e Initial load duke parents: diff changeset	2512 }
a61af66fc99e Initial load duke parents: diff changeset	2513 }
a61af66fc99e Initial load duke parents: diff changeset	2514
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2515 // Returns true iff super_method can be overridden by a method in targetclassname
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2516 // See JSL 3rd edition 8.4.6.1
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2517 // Assumes name-signature match
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2518 // "this" is InstanceKlass of super_method which must exist
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2519 // note that the InstanceKlass of the method in the targetclassname has not always been created yet
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2520 bool InstanceKlass::is_override(methodHandle super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS) {
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2521 // Private methods can not be overridden
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2522 if (super_method->is_private()) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2523 return false;
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2524 }
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2525 // If super method is accessible, then override
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2526 if ((super_method->is_protected()) \|\|
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2527 (super_method->is_public())) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2528 return true;
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2529 }
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2530 // Package-private methods are not inherited outside of package
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2531 assert(super_method->is_package_private(), "must be package private");
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2532 return(is_same_class_package(targetclassloader(), targetclassname));
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2533 }
0 a61af66fc99e Initial load duke parents: diff changeset	2534
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2535 /* defined for now in jvm.cpp, for historical reasons *--
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2536 Klass* InstanceKlass::compute_enclosing_class_impl(instanceKlassHandle self,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2537 Symbol*& simple_name_result, TRAPS) {
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2538 ...
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2539 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2540 */
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2541
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2542 // tell if two classes have the same enclosing class (at package level)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2543 bool InstanceKlass::is_same_package_member_impl(instanceKlassHandle class1,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2544 Klass* class2_oop, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2545 if (class2_oop == class1()) return true;
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	2546 if (!class2_oop->oop_is_instance()) return false;
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2547 instanceKlassHandle class2(THREAD, class2_oop);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2548
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2549 // must be in same package before we try anything else
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2550 if (!class1->is_same_class_package(class2->class_loader(), class2->name()))
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2551 return false;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2552
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2553 // As long as there is an outer1.getEnclosingClass,
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2554 // shift the search outward.
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2555 instanceKlassHandle outer1 = class1;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2556 for (;;) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2557 // As we walk along, look for equalities between outer1 and class2.
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2558 // Eventually, the walks will terminate as outer1 stops
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2559 // at the top-level class around the original class.
1126 933a3e806ce6 6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build xlu parents: 1039 diff changeset	2560 bool ignore_inner_is_member;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2561 Klass* next = outer1->compute_enclosing_class(&ignore_inner_is_member,
1126 933a3e806ce6 6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build xlu parents: 1039 diff changeset	2562 CHECK_false);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2563 if (next == NULL) break;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2564 if (next == class2()) return true;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2565 outer1 = instanceKlassHandle(THREAD, next);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2566 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2567
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2568 // Now do the same for class2.
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2569 instanceKlassHandle outer2 = class2;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2570 for (;;) {
1126 933a3e806ce6 6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build xlu parents: 1039 diff changeset	2571 bool ignore_inner_is_member;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2572 Klass* next = outer2->compute_enclosing_class(&ignore_inner_is_member,
1126 933a3e806ce6 6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build xlu parents: 1039 diff changeset	2573 CHECK_false);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2574 if (next == NULL) break;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2575 // Might as well check the new outer against all available values.
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2576 if (next == class1()) return true;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2577 if (next == outer1()) return true;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2578 outer2 = instanceKlassHandle(THREAD, next);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2579 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2580
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2581 // If by this point we have not found an equality between the
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2582 // two classes, we know they are in separate package members.
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2583 return false;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2584 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2585
0 a61af66fc99e Initial load duke parents: diff changeset	2586
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2587 jint InstanceKlass::compute_modifier_flags(TRAPS) const {
0 a61af66fc99e Initial load duke parents: diff changeset	2588 jint access = access_flags().as_int();
a61af66fc99e Initial load duke parents: diff changeset	2589
a61af66fc99e Initial load duke parents: diff changeset	2590 // But check if it happens to be member class.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2591 instanceKlassHandle ik(THREAD, this);
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2592 InnerClassesIterator iter(ik);
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2593 for (; !iter.done(); iter.next()) {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2594 int ioff = iter.inner_class_info_index();
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2595 // Inner class attribute can be zero, skip it.
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2596 // Strange but true: JVM spec. allows null inner class refs.
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2597 if (ioff == 0) continue;
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2598
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2599 // only look at classes that are already loaded
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2600 // since we are looking for the flags for our self.
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2601 Symbol* inner_name = ik->constants()->klass_name_at(ioff);
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2602 if ((ik->name() == inner_name)) {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2603 // This is really a member class.
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2604 access = iter.inner_access_flags();
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2605 break;
0 a61af66fc99e Initial load duke parents: diff changeset	2606 }
a61af66fc99e Initial load duke parents: diff changeset	2607 }
a61af66fc99e Initial load duke parents: diff changeset	2608 // Remember to strip ACC_SUPER bit
a61af66fc99e Initial load duke parents: diff changeset	2609 return (access & (~JVM_ACC_SUPER)) & JVM_ACC_WRITTEN_FLAGS;
a61af66fc99e Initial load duke parents: diff changeset	2610 }
a61af66fc99e Initial load duke parents: diff changeset	2611
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2612 jint InstanceKlass::jvmti_class_status() const {
0 a61af66fc99e Initial load duke parents: diff changeset	2613 jint result = 0;
a61af66fc99e Initial load duke parents: diff changeset	2614
a61af66fc99e Initial load duke parents: diff changeset	2615 if (is_linked()) {
a61af66fc99e Initial load duke parents: diff changeset	2616 result \|= JVMTI_CLASS_STATUS_VERIFIED \| JVMTI_CLASS_STATUS_PREPARED;
a61af66fc99e Initial load duke parents: diff changeset	2617 }
a61af66fc99e Initial load duke parents: diff changeset	2618
a61af66fc99e Initial load duke parents: diff changeset	2619 if (is_initialized()) {
a61af66fc99e Initial load duke parents: diff changeset	2620 assert(is_linked(), "Class status is not consistent");
a61af66fc99e Initial load duke parents: diff changeset	2621 result \|= JVMTI_CLASS_STATUS_INITIALIZED;
a61af66fc99e Initial load duke parents: diff changeset	2622 }
a61af66fc99e Initial load duke parents: diff changeset	2623 if (is_in_error_state()) {
a61af66fc99e Initial load duke parents: diff changeset	2624 result \|= JVMTI_CLASS_STATUS_ERROR;
a61af66fc99e Initial load duke parents: diff changeset	2625 }
a61af66fc99e Initial load duke parents: diff changeset	2626 return result;
a61af66fc99e Initial load duke parents: diff changeset	2627 }
a61af66fc99e Initial load duke parents: diff changeset	2628
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2629 Method* InstanceKlass::method_at_itable(Klass* holder, int index, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	2630 itableOffsetEntry* ioe = (itableOffsetEntry*)start_of_itable();
a61af66fc99e Initial load duke parents: diff changeset	2631 int method_table_offset_in_words = ioe->offset()/wordSize;
a61af66fc99e Initial load duke parents: diff changeset	2632 int nof_interfaces = (method_table_offset_in_words - itable_offset_in_words())
a61af66fc99e Initial load duke parents: diff changeset	2633 / itableOffsetEntry::size();
a61af66fc99e Initial load duke parents: diff changeset	2634
a61af66fc99e Initial load duke parents: diff changeset	2635 for (int cnt = 0 ; ; cnt ++, ioe ++) {
605 98cb887364d3 6810672: Comment typos twisti parents: 356 diff changeset	2636 // If the interface isn't implemented by the receiver class,
0 a61af66fc99e Initial load duke parents: diff changeset	2637 // the VM should throw IncompatibleClassChangeError.
a61af66fc99e Initial load duke parents: diff changeset	2638 if (cnt >= nof_interfaces) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2639 THROW_NULL(vmSymbols::java_lang_IncompatibleClassChangeError());
0 a61af66fc99e Initial load duke parents: diff changeset	2640 }
a61af66fc99e Initial load duke parents: diff changeset	2641
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2642 Klass* ik = ioe->interface_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	2643 if (ik == holder) break;
a61af66fc99e Initial load duke parents: diff changeset	2644 }
a61af66fc99e Initial load duke parents: diff changeset	2645
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2646 itableMethodEntry* ime = ioe->first_method_entry(this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2647 Method* m = ime[index].method();
0 a61af66fc99e Initial load duke parents: diff changeset	2648 if (m == NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2649 THROW_NULL(vmSymbols::java_lang_AbstractMethodError());
0 a61af66fc99e Initial load duke parents: diff changeset	2650 }
a61af66fc99e Initial load duke parents: diff changeset	2651 return m;
a61af66fc99e Initial load duke parents: diff changeset	2652 }
a61af66fc99e Initial load duke parents: diff changeset	2653
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2654
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2655 #if INCLUDE_JVMTI
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2656 // update default_methods for redefineclasses for methods that are
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2657 // not yet in the vtable due to concurrent subclass define and superinterface
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2658 // redefinition
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2659 // Note: those in the vtable, should have been updated via adjust_method_entries
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2660 void InstanceKlass::adjust_default_methods(Method old_methods, Method new_methods,
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2661 int methods_length, bool* trace_name_printed) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2662 // search the default_methods for uses of either obsolete or EMCP methods
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2663 if (default_methods() != NULL) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2664 for (int j = 0; j < methods_length; j++) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2665 Method* old_method = old_methods[j];
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2666 Method* new_method = new_methods[j];
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2667
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2668 for (int index = 0; index < default_methods()->length(); index ++) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2669 if (default_methods()->at(index) == old_method) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2670 default_methods()->at_put(index, new_method);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2671 if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2672 if (!(*trace_name_printed)) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2673 // RC_TRACE_MESG macro has an embedded ResourceMark
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2674 RC_TRACE_MESG(("adjust: klassname=%s default methods from name=%s",
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2675 external_name(),
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2676 old_method->method_holder()->external_name()));
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2677 *trace_name_printed = true;
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2678 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2679 RC_TRACE(0x00100000, ("default method update: %s(%s) ",
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2680 new_method->name()->as_C_string(),
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2681 new_method->signature()->as_C_string()));
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2682 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2683 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2684 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2685 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2686 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2687 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2688 #endif // INCLUDE_JVMTI
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2689
0 a61af66fc99e Initial load duke parents: diff changeset	2690 // On-stack replacement stuff
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2691 void InstanceKlass::add_osr_nmethod(nmethod* n) {
0 a61af66fc99e Initial load duke parents: diff changeset	2692 // only one compilation can be active
a61af66fc99e Initial load duke parents: diff changeset	2693 NEEDS_CLEANUP
a61af66fc99e Initial load duke parents: diff changeset	2694 // This is a short non-blocking critical region, so the no safepoint check is ok.
a61af66fc99e Initial load duke parents: diff changeset	2695 OsrList_lock->lock_without_safepoint_check();
a61af66fc99e Initial load duke parents: diff changeset	2696 assert(n->is_osr_method(), "wrong kind of nmethod");
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 876 diff changeset	2697 n->set_osr_link(osr_nmethods_head());
0 a61af66fc99e Initial load duke parents: diff changeset	2698 set_osr_nmethods_head(n);
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2699 // Raise the highest osr level if necessary
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2700 if (TieredCompilation) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2701 Method* m = n->method();
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2702 m->set_highest_osr_comp_level(MAX2(m->highest_osr_comp_level(), n->comp_level()));
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2703 }
0 a61af66fc99e Initial load duke parents: diff changeset	2704 // Remember to unlock again
a61af66fc99e Initial load duke parents: diff changeset	2705 OsrList_lock->unlock();
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2706
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2707 // Get rid of the osr methods for the same bci that have lower levels.
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2708 if (TieredCompilation) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2709 for (int l = CompLevel_limited_profile; l < n->comp_level(); l++) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2710 nmethod *inv = lookup_osr_nmethod(n->method(), n->osr_entry_bci(), l, true);
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2711 if (inv != NULL && inv->is_in_use()) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2712 inv->make_not_entrant();
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2713 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2714 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2715 }
0 a61af66fc99e Initial load duke parents: diff changeset	2716 }
a61af66fc99e Initial load duke parents: diff changeset	2717
a61af66fc99e Initial load duke parents: diff changeset	2718
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2719 void InstanceKlass::remove_osr_nmethod(nmethod* n) {
0 a61af66fc99e Initial load duke parents: diff changeset	2720 // This is a short non-blocking critical region, so the no safepoint check is ok.
a61af66fc99e Initial load duke parents: diff changeset	2721 OsrList_lock->lock_without_safepoint_check();
a61af66fc99e Initial load duke parents: diff changeset	2722 assert(n->is_osr_method(), "wrong kind of nmethod");
a61af66fc99e Initial load duke parents: diff changeset	2723 nmethod* last = NULL;
a61af66fc99e Initial load duke parents: diff changeset	2724 nmethod* cur = osr_nmethods_head();
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2725 int max_level = CompLevel_none; // Find the max comp level excluding n
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2726 Method* m = n->method();
0 a61af66fc99e Initial load duke parents: diff changeset	2727 // Search for match
a61af66fc99e Initial load duke parents: diff changeset	2728 while(cur != NULL && cur != n) {
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2729 if (TieredCompilation) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2730 // Find max level before n
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2731 max_level = MAX2(max_level, cur->comp_level());
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2732 }
0 a61af66fc99e Initial load duke parents: diff changeset	2733 last = cur;
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 876 diff changeset	2734 cur = cur->osr_link();
0 a61af66fc99e Initial load duke parents: diff changeset	2735 }
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2736 nmethod* next = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	2737 if (cur == n) {
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2738 next = cur->osr_link();
0 a61af66fc99e Initial load duke parents: diff changeset	2739 if (last == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2740 // Remove first element
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2741 set_osr_nmethods_head(next);
0 a61af66fc99e Initial load duke parents: diff changeset	2742 } else {
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2743 last->set_osr_link(next);
0 a61af66fc99e Initial load duke parents: diff changeset	2744 }
a61af66fc99e Initial load duke parents: diff changeset	2745 }
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 876 diff changeset	2746 n->set_osr_link(NULL);
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2747 if (TieredCompilation) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2748 cur = next;
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2749 while (cur != NULL) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2750 // Find max level after n
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2751 max_level = MAX2(max_level, cur->comp_level());
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2752 cur = cur->osr_link();
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2753 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2754 m->set_highest_osr_comp_level(max_level);
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2755 }
0 a61af66fc99e Initial load duke parents: diff changeset	2756 // Remember to unlock again
a61af66fc99e Initial load duke parents: diff changeset	2757 OsrList_lock->unlock();
a61af66fc99e Initial load duke parents: diff changeset	2758 }
a61af66fc99e Initial load duke parents: diff changeset	2759
10265 92ef81e2f571 8003557: NPG: Klass* const k should be const Klass* k. minqi parents: 10152 diff changeset	2760 nmethod* InstanceKlass::lookup_osr_nmethod(const Method* m, int bci, int comp_level, bool match_level) const {
0 a61af66fc99e Initial load duke parents: diff changeset	2761 // This is a short non-blocking critical region, so the no safepoint check is ok.
a61af66fc99e Initial load duke parents: diff changeset	2762 OsrList_lock->lock_without_safepoint_check();
a61af66fc99e Initial load duke parents: diff changeset	2763 nmethod* osr = osr_nmethods_head();
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2764 nmethod* best = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	2765 while (osr != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2766 assert(osr->is_osr_method(), "wrong kind of nmethod found in chain");
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2767 // There can be a time when a c1 osr method exists but we are waiting
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2768 // for a c2 version. When c2 completes its osr nmethod we will trash
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2769 // the c1 version and only be able to find the c2 version. However
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2770 // while we overflow in the c1 code at back branches we don't want to
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2771 // try and switch to the same code as we are already running
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2772
0 a61af66fc99e Initial load duke parents: diff changeset	2773 if (osr->method() == m &&
a61af66fc99e Initial load duke parents: diff changeset	2774 (bci == InvocationEntryBci \|\| osr->osr_entry_bci() == bci)) {
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2775 if (match_level) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2776 if (osr->comp_level() == comp_level) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2777 // Found a match - return it.
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2778 OsrList_lock->unlock();
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2779 return osr;
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2780 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2781 } else {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2782 if (best == NULL \|\| (osr->comp_level() > best->comp_level())) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2783 if (osr->comp_level() == CompLevel_highest_tier) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2784 // Found the best possible - return it.
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2785 OsrList_lock->unlock();
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2786 return osr;
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2787 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2788 best = osr;
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2789 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2790 }
0 a61af66fc99e Initial load duke parents: diff changeset	2791 }
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 876 diff changeset	2792 osr = osr->osr_link();
0 a61af66fc99e Initial load duke parents: diff changeset	2793 }
a61af66fc99e Initial load duke parents: diff changeset	2794 OsrList_lock->unlock();
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2795 if (best != NULL && best->comp_level() >= comp_level && match_level == false) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2796 return best;
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2797 }
0 a61af66fc99e Initial load duke parents: diff changeset	2798 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	2799 }
a61af66fc99e Initial load duke parents: diff changeset	2800
10345 b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2801 void InstanceKlass::add_member_name(int index, Handle mem_name) {
10133 6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 9062 diff changeset	2802 jweak mem_name_wref = JNIHandles::make_weak_global(mem_name);
6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 9062 diff changeset	2803 MutexLocker ml(MemberNameTable_lock);
10345 b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2804 assert(0 <= index && index < idnum_allocated_count(), "index is out of bounds");
10133 6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 9062 diff changeset	2805 DEBUG_ONLY(No_Safepoint_Verifier nsv);
6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 9062 diff changeset	2806
6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 9062 diff changeset	2807 if (_member_names == NULL) {
10345 b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2808 _member_names = new (ResourceObj::C_HEAP, mtClass) MemberNameTable(idnum_allocated_count());
10133 6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 9062 diff changeset	2809 }
10345 b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2810 _member_names->add_member_name(index, mem_name_wref);
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2811 }
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2812
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2813 oop InstanceKlass::get_member_name(int index) {
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2814 MutexLocker ml(MemberNameTable_lock);
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2815 assert(0 <= index && index < idnum_allocated_count(), "index is out of bounds");
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2816 DEBUG_ONLY(No_Safepoint_Verifier nsv);
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2817
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2818 if (_member_names == NULL) {
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2819 return NULL;
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2820 }
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2821 oop mem_name =_member_names->get_member_name(index);
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2822 return mem_name;
10133 6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 9062 diff changeset	2823 }
6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 9062 diff changeset	2824
0 a61af66fc99e Initial load duke parents: diff changeset	2825 // -----------------------------------------------------------------------------------------------------
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2826 // Printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2827
0 a61af66fc99e Initial load duke parents: diff changeset	2828 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	2829
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2830 #define BULLET " - "
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2831
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2832 static const char* state_names[] = {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2833 "allocated", "loaded", "linked", "being_initialized", "fully_initialized", "initialization_error"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2834 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2835
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2836 static void print_vtable(intptr_t* start, int len, outputStream* st) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2837 for (int i = 0; i < len; i++) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2838 intptr_t e = start[i];
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2839 st->print("%d : " INTPTR_FORMAT, i, e);
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2840 if (e != 0 && ((Metadata*)e)->is_metaspace_object()) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2841 st->print(" ");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2842 ((Metadata*)e)->print_value_on(st);
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2843 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2844 st->cr();
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2845 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2846 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2847
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2848 void InstanceKlass::print_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2849 assert(is_klass(), "must be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2850 Klass::print_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2851
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2852 st->print(BULLET"instance size: %d", size_helper()); st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2853 st->print(BULLET"klass size: %d", size()); st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2854 st->print(BULLET"access: "); access_flags().print_on(st); st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2855 st->print(BULLET"state: "); st->print_cr(state_names[_init_state]);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2856 st->print(BULLET"name: "); name()->print_value_on(st); st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2857 st->print(BULLET"super: "); super()->print_value_on_maybe_null(st); st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2858 st->print(BULLET"sub: ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2859 Klass* sub = subklass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2860 int n;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2861 for (n = 0; sub != NULL; n++, sub = sub->next_sibling()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2862 if (n < MaxSubklassPrintSize) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2863 sub->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2864 st->print(" ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2865 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2866 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2867 if (n >= MaxSubklassPrintSize) st->print("(%d more klasses...)", n - MaxSubklassPrintSize);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2868 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2869
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2870 if (is_interface()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2871 st->print_cr(BULLET"nof implementors: %d", nof_implementors());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2872 if (nof_implementors() == 1) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2873 st->print_cr(BULLET"implementor: ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2874 st->print(" ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2875 implementor()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2876 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2877 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2878 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2879
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2880 st->print(BULLET"arrays: "); array_klasses()->print_value_on_maybe_null(st); st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2881 st->print(BULLET"methods: "); methods()->print_value_on(st); st->cr();
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2882 if (Verbose \|\| WizardMode) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2883 Array<Method> method_array = methods();
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2884 for (int i = 0; i < method_array->length(); i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2885 st->print("%d : ", i); method_array->at(i)->print_value(); st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2886 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2887 }
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2888 st->print(BULLET"method ordering: "); method_ordering()->print_value_on(st); st->cr();
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2889 st->print(BULLET"default_methods: "); default_methods()->print_value_on(st); st->cr();
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2890 if (Verbose && default_methods() != NULL) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2891 Array<Method> method_array = default_methods();
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2892 for (int i = 0; i < method_array->length(); i++) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2893 st->print("%d : ", i); method_array->at(i)->print_value(); st->cr();
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2894 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2895 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2896 if (default_vtable_indices() != NULL) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2897 st->print(BULLET"default vtable indices: "); default_vtable_indices()->print_value_on(st); st->cr();
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2898 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2899 st->print(BULLET"local interfaces: "); local_interfaces()->print_value_on(st); st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2900 st->print(BULLET"trans. interfaces: "); transitive_interfaces()->print_value_on(st); st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2901 st->print(BULLET"constants: "); constants()->print_value_on(st); st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2902 if (class_loader_data() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2903 st->print(BULLET"class loader data: ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2904 class_loader_data()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2905 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2906 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2907 st->print(BULLET"host class: "); host_klass()->print_value_on_maybe_null(st); st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2908 if (source_file_name() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2909 st->print(BULLET"source file: ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2910 source_file_name()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2911 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2912 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2913 if (source_debug_extension() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2914 st->print(BULLET"source debug extension: ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2915 st->print("%s", source_debug_extension());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2916 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2917 }
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	2918 st->print(BULLET"class annotations: "); class_annotations()->print_value_on(st); st->cr();
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	2919 st->print(BULLET"class type annotations: "); class_type_annotations()->print_value_on(st); st->cr();
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	2920 st->print(BULLET"field annotations: "); fields_annotations()->print_value_on(st); st->cr();
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	2921 st->print(BULLET"field type annotations: "); fields_type_annotations()->print_value_on(st); st->cr();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2922 {
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2923 bool have_pv = false;
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2924 PreviousVersionWalker pvw(Thread::current(), (InstanceKlass*)this);
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2925 for (PreviousVersionNode * pv_node = pvw.next_previous_version();
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2926 pv_node != NULL; pv_node = pvw.next_previous_version()) {
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2927 if (!have_pv)
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2928 st->print(BULLET"previous version: ");
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2929 have_pv = true;
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2930 pv_node->prev_constant_pool()->print_value_on(st);
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2931 }
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2932 if (have_pv) st->cr();
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2933 } // pvw is cleaned up
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2934
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2935 if (generic_signature() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2936 st->print(BULLET"generic signature: ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2937 generic_signature()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2938 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2939 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2940 st->print(BULLET"inner classes: "); inner_classes()->print_value_on(st); st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2941 st->print(BULLET"java mirror: "); java_mirror()->print_value_on(st); st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2942 st->print(BULLET"vtable length %d (start addr: " INTPTR_FORMAT ")", vtable_length(), start_of_vtable()); st->cr();
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2943 if (vtable_length() > 0 && (Verbose \|\| WizardMode)) print_vtable(start_of_vtable(), vtable_length(), st);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2944 st->print(BULLET"itable length %d (start addr: " INTPTR_FORMAT ")", itable_length(), start_of_itable()); st->cr();
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2945 if (itable_length() > 0 && (Verbose \|\| WizardMode)) print_vtable(start_of_itable(), itable_length(), st);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2946 st->print_cr(BULLET"---- static fields (%d words):", static_field_size());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2947 FieldPrinter print_static_field(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2948 ((InstanceKlass*)this)->do_local_static_fields(&print_static_field);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2949 st->print_cr(BULLET"---- non-static fields (%d words):", nonstatic_field_size());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2950 FieldPrinter print_nonstatic_field(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2951 ((InstanceKlass*)this)->do_nonstatic_fields(&print_nonstatic_field);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2952
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2953 st->print(BULLET"non-static oop maps: ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2954 OopMapBlock* map = start_of_nonstatic_oop_maps();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2955 OopMapBlock* end_map = map + nonstatic_oop_map_count();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2956 while (map < end_map) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2957 st->print("%d-%d ", map->offset(), map->offset() + heapOopSize*(map->count() - 1));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2958 map++;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2959 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2960 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2961 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2962
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2963 #endif //PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2964
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2965 void InstanceKlass::print_value_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2966 assert(is_klass(), "must be klass");
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2967 if (Verbose \|\| WizardMode) access_flags().print_on(st);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2968 name()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2969 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2970
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2971 #ifndef PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2972
0 a61af66fc99e Initial load duke parents: diff changeset	2973 void FieldPrinter::do_field(fieldDescriptor* fd) {
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2974 _st->print(BULLET);
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	2975 if (_obj == NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	2976 fd->print_on(_st);
a61af66fc99e Initial load duke parents: diff changeset	2977 _st->cr();
a61af66fc99e Initial load duke parents: diff changeset	2978 } else {
a61af66fc99e Initial load duke parents: diff changeset	2979 fd->print_on_for(_st, _obj);
a61af66fc99e Initial load duke parents: diff changeset	2980 _st->cr();
a61af66fc99e Initial load duke parents: diff changeset	2981 }
a61af66fc99e Initial load duke parents: diff changeset	2982 }
a61af66fc99e Initial load duke parents: diff changeset	2983
a61af66fc99e Initial load duke parents: diff changeset	2984
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2985 void InstanceKlass::oop_print_on(oop obj, outputStream* st) {
0 a61af66fc99e Initial load duke parents: diff changeset	2986 Klass::oop_print_on(obj, st);
a61af66fc99e Initial load duke parents: diff changeset	2987
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2988 if (this == SystemDictionary::String_klass()) {
0 a61af66fc99e Initial load duke parents: diff changeset	2989 typeArrayOop value = java_lang_String::value(obj);
a61af66fc99e Initial load duke parents: diff changeset	2990 juint offset = java_lang_String::offset(obj);
a61af66fc99e Initial load duke parents: diff changeset	2991 juint length = java_lang_String::length(obj);
a61af66fc99e Initial load duke parents: diff changeset	2992 if (value != NULL &&
a61af66fc99e Initial load duke parents: diff changeset	2993 value->is_typeArray() &&
a61af66fc99e Initial load duke parents: diff changeset	2994 offset <= (juint) value->length() &&
a61af66fc99e Initial load duke parents: diff changeset	2995 offset + length <= (juint) value->length()) {
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2996 st->print(BULLET"string: ");
0 a61af66fc99e Initial load duke parents: diff changeset	2997 Handle h_obj(obj);
a61af66fc99e Initial load duke parents: diff changeset	2998 java_lang_String::print(h_obj, st);
a61af66fc99e Initial load duke parents: diff changeset	2999 st->cr();
a61af66fc99e Initial load duke parents: diff changeset	3000 if (!WizardMode) return; // that is enough
a61af66fc99e Initial load duke parents: diff changeset	3001 }
a61af66fc99e Initial load duke parents: diff changeset	3002 }
a61af66fc99e Initial load duke parents: diff changeset	3003
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3004 st->print_cr(BULLET"---- fields (total size %d words):", oop_size(obj));
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	3005 FieldPrinter print_field(st, obj);
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	3006 do_nonstatic_fields(&print_field);
0 a61af66fc99e Initial load duke parents: diff changeset	3007
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3008 if (this == SystemDictionary::Class_klass()) {
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3009 st->print(BULLET"signature: ");
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3010 java_lang_Class::print_signature(obj, st);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3011 st->cr();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3012 Klass* mirrored_klass = java_lang_Class::as_Klass(obj);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3013 st->print(BULLET"fake entry for mirror: ");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3014 mirrored_klass->print_value_on_maybe_null(st);
0 a61af66fc99e Initial load duke parents: diff changeset	3015 st->cr();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3016 Klass* array_klass = java_lang_Class::array_klass(obj);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3017 st->print(BULLET"fake entry for array: ");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3018 array_klass->print_value_on_maybe_null(st);
0 a61af66fc99e Initial load duke parents: diff changeset	3019 st->cr();
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	3020 st->print_cr(BULLET"fake entry for oop_size: %d", java_lang_Class::oop_size(obj));
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	3021 st->print_cr(BULLET"fake entry for static_oop_field_count: %d", java_lang_Class::static_oop_field_count(obj));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3022 Klass* real_klass = java_lang_Class::as_Klass(obj);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3023 if (real_klass != NULL && real_klass->oop_is_instance()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3024 InstanceKlass::cast(real_klass)->do_local_static_fields(&print_field);
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	3025 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3026 } else if (this == SystemDictionary::MethodType_klass()) {
1039 987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 997 diff changeset	3027 st->print(BULLET"signature: ");
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2334 diff changeset	3028 java_lang_invoke_MethodType::print_signature(obj, st);
1039 987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 997 diff changeset	3029 st->cr();
0 a61af66fc99e Initial load duke parents: diff changeset	3030 }
a61af66fc99e Initial load duke parents: diff changeset	3031 }
a61af66fc99e Initial load duke parents: diff changeset	3032
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1144 diff changeset	3033 #endif //PRODUCT
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1144 diff changeset	3034
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3035 void InstanceKlass::oop_print_value_on(oop obj, outputStream* st) {
0 a61af66fc99e Initial load duke parents: diff changeset	3036 st->print("a ");
a61af66fc99e Initial load duke parents: diff changeset	3037 name()->print_value_on(st);
a61af66fc99e Initial load duke parents: diff changeset	3038 obj->print_address_on(st);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3039 if (this == SystemDictionary::String_klass()
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3040 && java_lang_String::value(obj) != NULL) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3041 ResourceMark rm;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3042 int len = java_lang_String::length(obj);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3043 int plen = (len < 24 ? len : 12);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3044 char* str = java_lang_String::as_utf8_string(obj, 0, plen);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3045 st->print(" = \"%s\"", str);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3046 if (len > plen)
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3047 st->print("...[%d]", len);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3048 } else if (this == SystemDictionary::Class_klass()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3049 Klass* k = java_lang_Class::as_Klass(obj);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3050 st->print(" = ");
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3051 if (k != NULL) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3052 k->print_value_on(st);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3053 } else {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3054 const char* tname = type2name(java_lang_Class::primitive_type(obj));
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3055 st->print("%s", tname ? tname : "type?");
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3056 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3057 } else if (this == SystemDictionary::MethodType_klass()) {
1039 987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 997 diff changeset	3058 st->print(" = ");
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2334 diff changeset	3059 java_lang_invoke_MethodType::print_signature(obj, st);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3060 } else if (java_lang_boxing_object::is_instance(obj)) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3061 st->print(" = ");
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3062 java_lang_boxing_object::print(obj, st);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3063 } else if (this == SystemDictionary::LambdaForm_klass()) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3064 oop vmentry = java_lang_invoke_LambdaForm::vmentry(obj);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3065 if (vmentry != NULL) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3066 st->print(" => ");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3067 vmentry->print_value_on(st);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3068 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3069 } else if (this == SystemDictionary::MemberName_klass()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3070 Metadata* vmtarget = java_lang_invoke_MemberName::vmtarget(obj);
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3071 if (vmtarget != NULL) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3072 st->print(" = ");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3073 vmtarget->print_value_on(st);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3074 } else {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3075 java_lang_invoke_MemberName::clazz(obj)->print_value_on(st);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3076 st->print(".");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3077 java_lang_invoke_MemberName::name(obj)->print_value_on(st);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3078 }
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3079 }
0 a61af66fc99e Initial load duke parents: diff changeset	3080 }
a61af66fc99e Initial load duke parents: diff changeset	3081
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3082 const char* InstanceKlass::internal_name() const {
0 a61af66fc99e Initial load duke parents: diff changeset	3083 return external_name();
a61af66fc99e Initial load duke parents: diff changeset	3084 }
a61af66fc99e Initial load duke parents: diff changeset	3085
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3086 #if INCLUDE_SERVICES
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3087 // Size Statistics
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3088 void InstanceKlass::collect_statistics(KlassSizeStats *sz) const {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3089 Klass::collect_statistics(sz);
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3090
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3091 sz->_inst_size = HeapWordSize * size_helper();
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3092 sz->_vtab_bytes = HeapWordSize * align_object_offset(vtable_length());
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3093 sz->_itab_bytes = HeapWordSize * align_object_offset(itable_length());
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3094 sz->_nonstatic_oopmap_bytes = HeapWordSize *
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3095 ((is_interface() \|\| is_anonymous()) ?
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3096 align_object_offset(nonstatic_oop_map_size()) :
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3097 nonstatic_oop_map_size());
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3098
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3099 int n = 0;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3100 n += (sz->_methods_array_bytes = sz->count_array(methods()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3101 n += (sz->_method_ordering_bytes = sz->count_array(method_ordering()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3102 n += (sz->_local_interfaces_bytes = sz->count_array(local_interfaces()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3103 n += (sz->_transitive_interfaces_bytes = sz->count_array(transitive_interfaces()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3104 n += (sz->_fields_bytes = sz->count_array(fields()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3105 n += (sz->_inner_classes_bytes = sz->count_array(inner_classes()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3106 sz->_ro_bytes += n;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3107
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3108 const ConstantPool* cp = constants();
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3109 if (cp) {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3110 cp->collect_statistics(sz);
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3111 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3112
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3113 const Annotations* anno = annotations();
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3114 if (anno) {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3115 anno->collect_statistics(sz);
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3116 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3117
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3118 const Array<Method> methods_array = methods();
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3119 if (methods()) {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3120 for (int i = 0; i < methods_array->length(); i++) {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3121 Method* method = methods_array->at(i);
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3122 if (method) {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3123 sz->_method_count ++;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3124 method->collect_statistics(sz);
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3125 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3126 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3127 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3128 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3129 #endif // INCLUDE_SERVICES
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3130
0 a61af66fc99e Initial load duke parents: diff changeset	3131 // Verification
a61af66fc99e Initial load duke parents: diff changeset	3132
a61af66fc99e Initial load duke parents: diff changeset	3133 class VerifyFieldClosure: public OopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3134 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3135 template <class T> void do_oop_work(T* p) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3136 oop obj = oopDesc::load_decode_heap_oop(p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3137 if (!obj->is_oop_or_null()) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3138 tty->print_cr("Failed: " PTR_FORMAT " -> " PTR_FORMAT, p, (address)obj);
0 a61af66fc99e Initial load duke parents: diff changeset	3139 Universe::print();
a61af66fc99e Initial load duke parents: diff changeset	3140 guarantee(false, "boom");
a61af66fc99e Initial load duke parents: diff changeset	3141 }
a61af66fc99e Initial load duke parents: diff changeset	3142 }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3143 public:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3144 virtual void do_oop(oop* p) { VerifyFieldClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3145 virtual void do_oop(narrowOop* p) { VerifyFieldClosure::do_oop_work(p); }
0 a61af66fc99e Initial load duke parents: diff changeset	3146 };
a61af66fc99e Initial load duke parents: diff changeset	3147
14378 48314d596a04 8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on coleenp parents: 14221 diff changeset	3148 void InstanceKlass::verify_on(outputStream* st) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3149 #ifndef PRODUCT
11034 e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10347 diff changeset	3150 // Avoid redundant verifies, this really should be in product.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3151 if (_verify_count == Universe::verify_count()) return;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3152 _verify_count = Universe::verify_count();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3153 #endif
11034 e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10347 diff changeset	3154
e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10347 diff changeset	3155 // Verify Klass
14378 48314d596a04 8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on coleenp parents: 14221 diff changeset	3156 Klass::verify_on(st);
48314d596a04 8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on coleenp parents: 14221 diff changeset	3157
48314d596a04 8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on coleenp parents: 14221 diff changeset	3158 // Verify that klass is present in ClassLoaderData
48314d596a04 8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on coleenp parents: 14221 diff changeset	3159 guarantee(class_loader_data()->contains_klass(this),
48314d596a04 8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on coleenp parents: 14221 diff changeset	3160 "this class isn't found in class loader data");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3161
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3162 // Verify vtables
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3163 if (is_linked()) {
11034 e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10347 diff changeset	3164 ResourceMark rm;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3165 // $$$ This used to be done only for m/s collections. Doing it
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3166 // always seemed a valid generalization. (DLD -- 6/00)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3167 vtable()->verify(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3168 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3169
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3170 // Verify first subklass
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3171 if (subklass_oop() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3172 guarantee(subklass_oop()->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3173 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3174
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3175 // Verify siblings
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3176 Klass* super = this->super();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3177 Klass* sib = next_sibling();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3178 if (sib != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3179 if (sib == this) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3180 fatal(err_msg("subclass points to itself " PTR_FORMAT, sib));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3181 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3182
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3183 guarantee(sib->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3184 guarantee(sib->super() == super, "siblings should have same superklass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3185 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3186
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3187 // Verify implementor fields
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3188 Klass* im = implementor();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3189 if (im != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3190 guarantee(is_interface(), "only interfaces should have implementor set");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3191 guarantee(im->is_klass(), "should be klass");
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	3192 guarantee(!im->is_interface() \|\| im == this,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3193 "implementors cannot be interfaces");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3194 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3195
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3196 // Verify local interfaces
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3197 if (local_interfaces()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3198 Array<Klass> local_interfaces = this->local_interfaces();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3199 for (int j = 0; j < local_interfaces->length(); j++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3200 Klass* e = local_interfaces->at(j);
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	3201 guarantee(e->is_klass() && e->is_interface(), "invalid local interface");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3202 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3203 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3204
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3205 // Verify transitive interfaces
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3206 if (transitive_interfaces() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3207 Array<Klass> transitive_interfaces = this->transitive_interfaces();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3208 for (int j = 0; j < transitive_interfaces->length(); j++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3209 Klass* e = transitive_interfaces->at(j);
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	3210 guarantee(e->is_klass() && e->is_interface(), "invalid transitive interface");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3211 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3212 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3213
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3214 // Verify methods
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3215 if (methods() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3216 Array<Method> methods = this->methods();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3217 for (int j = 0; j < methods->length(); j++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3218 guarantee(methods->at(j)->is_method(), "non-method in methods array");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3219 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3220 for (int j = 0; j < methods->length() - 1; j++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3221 Method* m1 = methods->at(j);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3222 Method* m2 = methods->at(j + 1);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3223 guarantee(m1->name()->fast_compare(m2->name()) <= 0, "methods not sorted correctly");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3224 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3225 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3226
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3227 // Verify method ordering
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3228 if (method_ordering() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3229 Array<int>* method_ordering = this->method_ordering();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3230 int length = method_ordering->length();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3231 if (JvmtiExport::can_maintain_original_method_order() \|\|
9057 8554c55669b0 8010943: guarantee(length == 0) failed: invalid method ordering length hseigel parents: 8719 diff changeset	3232 ((UseSharedSpaces \|\| DumpSharedSpaces) && length != 0)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3233 guarantee(length == methods()->length(), "invalid method ordering length");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3234 jlong sum = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3235 for (int j = 0; j < length; j++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3236 int original_index = method_ordering->at(j);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3237 guarantee(original_index >= 0, "invalid method ordering index");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3238 guarantee(original_index < length, "invalid method ordering index");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3239 sum += original_index;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3240 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3241 // Verify sum of indices 0,1,...,length-1
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3242 guarantee(sum == ((jlong)length*(length-1))/2, "invalid method ordering sum");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3243 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3244 guarantee(length == 0, "invalid method ordering length");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3245 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3246 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3247
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3248 // Verify default methods
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3249 if (default_methods() != NULL) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3250 Array<Method> methods = this->default_methods();
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3251 for (int j = 0; j < methods->length(); j++) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3252 guarantee(methods->at(j)->is_method(), "non-method in methods array");
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3253 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3254 for (int j = 0; j < methods->length() - 1; j++) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3255 Method* m1 = methods->at(j);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3256 Method* m2 = methods->at(j + 1);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3257 guarantee(m1->name()->fast_compare(m2->name()) <= 0, "methods not sorted correctly");
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3258 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3259 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3260
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3261 // Verify JNI static field identifiers
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3262 if (jni_ids() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3263 jni_ids()->verify(this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3264 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3265
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3266 // Verify other fields
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3267 if (array_klasses() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3268 guarantee(array_klasses()->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3269 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3270 if (constants() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3271 guarantee(constants()->is_constantPool(), "should be constant pool");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3272 }
8693 872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	3273 const Klass* host = host_klass();
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	3274 if (host != NULL) {
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	3275 guarantee(host->is_klass(), "should be klass");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3276 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3277 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3278
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3279 void InstanceKlass::oop_verify_on(oop obj, outputStream* st) {
0 a61af66fc99e Initial load duke parents: diff changeset	3280 Klass::oop_verify_on(obj, st);
a61af66fc99e Initial load duke parents: diff changeset	3281 VerifyFieldClosure blk;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3282 obj->oop_iterate_no_header(&blk);
0 a61af66fc99e Initial load duke parents: diff changeset	3283 }
a61af66fc99e Initial load duke parents: diff changeset	3284
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3285
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3286 // JNIid class for jfieldIDs only
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3287 // Note to reviewers:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3288 // These JNI functions are just moved over to column 1 and not changed
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3289 // in the compressed oops workspace.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3290 JNIid::JNIid(Klass* holder, int offset, JNIid* next) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3291 _holder = holder;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3292 _offset = offset;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3293 _next = next;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3294 debug_only(_is_static_field_id = false;)
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3295 }
0 a61af66fc99e Initial load duke parents: diff changeset	3296
a61af66fc99e Initial load duke parents: diff changeset	3297
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3298 JNIid* JNIid::find(int offset) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3299 JNIid* current = this;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3300 while (current != NULL) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3301 if (current->offset() == offset) return current;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3302 current = current->next();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3303 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3304 return NULL;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3305 }
0 a61af66fc99e Initial load duke parents: diff changeset	3306
a61af66fc99e Initial load duke parents: diff changeset	3307 void JNIid::deallocate(JNIid* current) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3308 while (current != NULL) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3309 JNIid* next = current->next();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3310 delete current;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3311 current = next;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3312 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3313 }
0 a61af66fc99e Initial load duke parents: diff changeset	3314
a61af66fc99e Initial load duke parents: diff changeset	3315
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3316 void JNIid::verify(Klass* holder) {
6735 aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6733 diff changeset	3317 int first_field_offset = InstanceMirrorKlass::offset_of_static_fields();
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3318 int end_field_offset;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3319 end_field_offset = first_field_offset + (InstanceKlass::cast(holder)->static_field_size() * wordSize);
0 a61af66fc99e Initial load duke parents: diff changeset	3320
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3321 JNIid* current = this;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3322 while (current != NULL) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3323 guarantee(current->holder() == holder, "Invalid klass in JNIid");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3324 #ifdef ASSERT
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3325 int o = current->offset();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3326 if (current->is_static_field_id()) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3327 guarantee(o >= first_field_offset && o < end_field_offset, "Invalid static field offset in JNIid");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3328 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3329 #endif
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3330 current = current->next();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3331 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3332 }
0 a61af66fc99e Initial load duke parents: diff changeset	3333
a61af66fc99e Initial load duke parents: diff changeset	3334
a61af66fc99e Initial load duke parents: diff changeset	3335 #ifdef ASSERT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3336 void InstanceKlass::set_init_state(ClassState state) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3337 bool good_state = is_shared() ? (_init_state <= state)
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3338 : (_init_state < state);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3339 assert(good_state \|\| state == allocated, "illegal state transition");
4739 52b5d32fbfaf 7117052: instanceKlass::_init_state can be u1 type coleenp parents: 4006 diff changeset	3340 _init_state = (u1)state;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3341 }
0 a61af66fc99e Initial load duke parents: diff changeset	3342 #endif
a61af66fc99e Initial load duke parents: diff changeset	3343
a61af66fc99e Initial load duke parents: diff changeset	3344
a61af66fc99e Initial load duke parents: diff changeset	3345 // RedefineClasses() support for previous versions:
a61af66fc99e Initial load duke parents: diff changeset	3346
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3347 // Purge previous versions
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3348 static void purge_previous_versions_internal(InstanceKlass* ik, int emcp_method_count) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3349 if (ik->previous_versions() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3350 // This klass has previous versions so see what we can cleanup
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3351 // while it is safe to do so.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3352
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3353 int deleted_count = 0; // leave debugging breadcrumbs
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3354 int live_count = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3355 ClassLoaderData* loader_data = ik->class_loader_data() == NULL ?
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3356 ClassLoaderData::the_null_class_loader_data() :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3357 ik->class_loader_data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3358
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3359 // RC_TRACE macro has an embedded ResourceMark
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3360 RC_TRACE(0x00000200, ("purge: %s: previous version length=%d",
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3361 ik->external_name(), ik->previous_versions()->length()));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3362
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3363 for (int i = ik->previous_versions()->length() - 1; i >= 0; i--) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3364 // check the previous versions array
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3365 PreviousVersionNode * pv_node = ik->previous_versions()->at(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3366 ConstantPool* cp_ref = pv_node->prev_constant_pool();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3367 assert(cp_ref != NULL, "cp ref was unexpectedly cleared");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3368
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3369 ConstantPool* pvcp = cp_ref;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3370 if (!pvcp->on_stack()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3371 // If the constant pool isn't on stack, none of the methods
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3372 // are executing. Delete all the methods, the constant pool and
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3373 // and this previous version node.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3374 GrowableArray<Method> method_refs = pv_node->prev_EMCP_methods();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3375 if (method_refs != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3376 for (int j = method_refs->length() - 1; j >= 0; j--) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3377 Method* method = method_refs->at(j);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3378 assert(method != NULL, "method ref was unexpectedly cleared");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3379 method_refs->remove_at(j);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3380 // method will be freed with associated class.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3381 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3382 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3383 // Remove the constant pool
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3384 delete pv_node;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3385 // Since we are traversing the array backwards, we don't have to
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3386 // do anything special with the index.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3387 ik->previous_versions()->remove_at(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3388 deleted_count++;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3389 continue;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3390 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3391 RC_TRACE(0x00000200, ("purge: previous version @%d is alive", i));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3392 assert(pvcp->pool_holder() != NULL, "Constant pool with no holder");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3393 guarantee (!loader_data->is_unloading(), "unloaded classes can't be on the stack");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3394 live_count++;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3395 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3396
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3397 // At least one method is live in this previous version, clean out
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3398 // the others or mark them as obsolete.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3399 GrowableArray<Method> method_refs = pv_node->prev_EMCP_methods();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3400 if (method_refs != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3401 RC_TRACE(0x00000200, ("purge: previous methods length=%d",
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3402 method_refs->length()));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3403 for (int j = method_refs->length() - 1; j >= 0; j--) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3404 Method* method = method_refs->at(j);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3405 assert(method != NULL, "method ref was unexpectedly cleared");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3406
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3407 // Remove the emcp method if it's not executing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3408 // If it's been made obsolete by a redefinition of a non-emcp
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3409 // method, mark it as obsolete but leave it to clean up later.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3410 if (!method->on_stack()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3411 method_refs->remove_at(j);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3412 } else if (emcp_method_count == 0) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3413 method->set_is_obsolete();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3414 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3415 // RC_TRACE macro has an embedded ResourceMark
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3416 RC_TRACE(0x00000200,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3417 ("purge: %s(%s): prev method @%d in version @%d is alive",
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3418 method->name()->as_C_string(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3419 method->signature()->as_C_string(), j, i));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3420 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3421 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3422 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3423 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3424 assert(ik->previous_versions()->length() == live_count, "sanity check");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3425 RC_TRACE(0x00000200,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3426 ("purge: previous version stats: live=%d, deleted=%d", live_count,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3427 deleted_count));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3428 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3429 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3430
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3431 // External interface for use during class unloading.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3432 void InstanceKlass::purge_previous_versions(InstanceKlass* ik) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3433 // Call with >0 emcp methods since they are not currently being redefined.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3434 purge_previous_versions_internal(ik, 1);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3435 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3436
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3437
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3438 // Potentially add an information node that contains pointers to the
0 a61af66fc99e Initial load duke parents: diff changeset	3439 // interesting parts of the previous version of the_class.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3440 // This is also where we clean out any unused references.
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	3441 // Note that while we delete nodes from the _previous_versions
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	3442 // array, we never delete the array itself until the klass is
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	3443 // unloaded. The has_been_redefined() query depends on that fact.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	3444 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3445 void InstanceKlass::add_previous_version(instanceKlassHandle ikh,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3446 BitMap* emcp_methods, int emcp_method_count) {
0 a61af66fc99e Initial load duke parents: diff changeset	3447 assert(Thread::current()->is_VM_thread(),
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3448 "only VMThread can add previous versions");
0 a61af66fc99e Initial load duke parents: diff changeset	3449
a61af66fc99e Initial load duke parents: diff changeset	3450 if (_previous_versions == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	3451 // This is the first previous version so make some space.
a61af66fc99e Initial load duke parents: diff changeset	3452 // Start with 2 elements under the assumption that the class
a61af66fc99e Initial load duke parents: diff changeset	3453 // won't be redefined much.
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6038 diff changeset	3454 _previous_versions = new (ResourceObj::C_HEAP, mtClass)
0 a61af66fc99e Initial load duke parents: diff changeset	3455 GrowableArray<PreviousVersionNode *>(2, true);
a61af66fc99e Initial load duke parents: diff changeset	3456 }
a61af66fc99e Initial load duke parents: diff changeset	3457
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3458 ConstantPool* cp_ref = ikh->constants();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3459
0 a61af66fc99e Initial load duke parents: diff changeset	3460 // RC_TRACE macro has an embedded ResourceMark
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3461 RC_TRACE(0x00000400, ("adding previous version ref for %s @%d, EMCP_cnt=%d "
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3462 "on_stack=%d",
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3463 ikh->external_name(), _previous_versions->length(), emcp_method_count,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3464 cp_ref->on_stack()));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3465
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3466 // If the constant pool for this previous version of the class
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3467 // is not marked as being on the stack, then none of the methods
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3468 // in this previous version of the class are on the stack so
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3469 // we don't need to create a new PreviousVersionNode. However,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3470 // we still need to examine older previous versions below.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3471 Array<Method> old_methods = ikh->methods();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3472
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3473 if (cp_ref->on_stack()) {
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3474 PreviousVersionNode * pv_node = NULL;
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3475 if (emcp_method_count == 0) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3476 // non-shared ConstantPool gets a reference
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3477 pv_node = new PreviousVersionNode(cp_ref, NULL);
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3478 RC_TRACE(0x00000400,
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3479 ("add: all methods are obsolete; flushing any EMCP refs"));
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3480 } else {
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3481 int local_count = 0;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3482 GrowableArray<Method> method_refs = new (ResourceObj::C_HEAP, mtClass)
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3483 GrowableArray<Method*>(emcp_method_count, true);
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3484 for (int i = 0; i < old_methods->length(); i++) {
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3485 if (emcp_methods->at(i)) {
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3486 // this old method is EMCP. Save it only if it's on the stack
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3487 Method* old_method = old_methods->at(i);
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3488 if (old_method->on_stack()) {
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3489 method_refs->append(old_method);
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3490 }
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3491 if (++local_count >= emcp_method_count) {
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3492 // no more EMCP methods so bail out now
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3493 break;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3494 }
0 a61af66fc99e Initial load duke parents: diff changeset	3495 }
a61af66fc99e Initial load duke parents: diff changeset	3496 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3497 // non-shared ConstantPool gets a reference
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3498 pv_node = new PreviousVersionNode(cp_ref, method_refs);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3499 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3500 // append new previous version.
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3501 _previous_versions->append(pv_node);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3502 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3503
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3504 // Since the caller is the VMThread and we are at a safepoint, this
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3505 // is a good time to clear out unused references.
0 a61af66fc99e Initial load duke parents: diff changeset	3506
a61af66fc99e Initial load duke parents: diff changeset	3507 RC_TRACE(0x00000400, ("add: previous version length=%d",
a61af66fc99e Initial load duke parents: diff changeset	3508 _previous_versions->length()));
a61af66fc99e Initial load duke parents: diff changeset	3509
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3510 // Purge previous versions not executing on the stack
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3511 purge_previous_versions_internal(this, emcp_method_count);
0 a61af66fc99e Initial load duke parents: diff changeset	3512
a61af66fc99e Initial load duke parents: diff changeset	3513 int obsolete_method_count = old_methods->length() - emcp_method_count;
a61af66fc99e Initial load duke parents: diff changeset	3514
a61af66fc99e Initial load duke parents: diff changeset	3515 if (emcp_method_count != 0 && obsolete_method_count != 0 &&
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3516 _previous_versions->length() > 0) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3517 // We have a mix of obsolete and EMCP methods so we have to
0 a61af66fc99e Initial load duke parents: diff changeset	3518 // clear out any matching EMCP method entries the hard way.
a61af66fc99e Initial load duke parents: diff changeset	3519 int local_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	3520 for (int i = 0; i < old_methods->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	3521 if (!emcp_methods->at(i)) {
a61af66fc99e Initial load duke parents: diff changeset	3522 // only obsolete methods are interesting
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3523 Method* old_method = old_methods->at(i);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	3524 Symbol* m_name = old_method->name();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	3525 Symbol* m_signature = old_method->signature();
0 a61af66fc99e Initial load duke parents: diff changeset	3526
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3527 // we might not have added the last entry
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3528 for (int j = _previous_versions->length() - 1; j >= 0; j--) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3529 // check the previous versions array for non executing obsolete methods
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3530 PreviousVersionNode * pv_node = _previous_versions->at(j);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3531
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3532 GrowableArray<Method> method_refs = pv_node->prev_EMCP_methods();
0 a61af66fc99e Initial load duke parents: diff changeset	3533 if (method_refs == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	3534 // We have run into a PreviousVersion generation where
a61af66fc99e Initial load duke parents: diff changeset	3535 // all methods were made obsolete during that generation's
a61af66fc99e Initial load duke parents: diff changeset	3536 // RedefineClasses() operation. At the time of that
a61af66fc99e Initial load duke parents: diff changeset	3537 // operation, all EMCP methods were flushed so we don't
a61af66fc99e Initial load duke parents: diff changeset	3538 // have to go back any further.
a61af66fc99e Initial load duke parents: diff changeset	3539 //
a61af66fc99e Initial load duke parents: diff changeset	3540 // A NULL method_refs is different than an empty method_refs.
a61af66fc99e Initial load duke parents: diff changeset	3541 // We cannot infer any optimizations about older generations
a61af66fc99e Initial load duke parents: diff changeset	3542 // from an empty method_refs for the current generation.
a61af66fc99e Initial load duke parents: diff changeset	3543 break;
a61af66fc99e Initial load duke parents: diff changeset	3544 }
a61af66fc99e Initial load duke parents: diff changeset	3545
a61af66fc99e Initial load duke parents: diff changeset	3546 for (int k = method_refs->length() - 1; k >= 0; k--) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3547 Method* method = method_refs->at(k);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3548
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3549 if (!method->is_obsolete() &&
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3550 method->name() == m_name &&
0 a61af66fc99e Initial load duke parents: diff changeset	3551 method->signature() == m_signature) {
a61af66fc99e Initial load duke parents: diff changeset	3552 // The current RedefineClasses() call has made all EMCP
a61af66fc99e Initial load duke parents: diff changeset	3553 // versions of this method obsolete so mark it as obsolete
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3554 // and remove the reference.
0 a61af66fc99e Initial load duke parents: diff changeset	3555 RC_TRACE(0x00000400,
a61af66fc99e Initial load duke parents: diff changeset	3556 ("add: %s(%s): flush obsolete method @%d in version @%d",
a61af66fc99e Initial load duke parents: diff changeset	3557 m_name->as_C_string(), m_signature->as_C_string(), k, j));
a61af66fc99e Initial load duke parents: diff changeset	3558
a61af66fc99e Initial load duke parents: diff changeset	3559 method->set_is_obsolete();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3560 // Leave obsolete methods on the previous version list to
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3561 // clean up later.
0 a61af66fc99e Initial load duke parents: diff changeset	3562 break;
a61af66fc99e Initial load duke parents: diff changeset	3563 }
a61af66fc99e Initial load duke parents: diff changeset	3564 }
a61af66fc99e Initial load duke parents: diff changeset	3565
a61af66fc99e Initial load duke parents: diff changeset	3566 // The previous loop may not find a matching EMCP method, but
a61af66fc99e Initial load duke parents: diff changeset	3567 // that doesn't mean that we can optimize and not go any
a61af66fc99e Initial load duke parents: diff changeset	3568 // further back in the PreviousVersion generations. The EMCP
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3569 // method for this generation could have already been deleted,
0 a61af66fc99e Initial load duke parents: diff changeset	3570 // but there still may be an older EMCP method that has not
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3571 // been deleted.
0 a61af66fc99e Initial load duke parents: diff changeset	3572 }
a61af66fc99e Initial load duke parents: diff changeset	3573
a61af66fc99e Initial load duke parents: diff changeset	3574 if (++local_count >= obsolete_method_count) {
a61af66fc99e Initial load duke parents: diff changeset	3575 // no more obsolete methods so bail out now
a61af66fc99e Initial load duke parents: diff changeset	3576 break;
a61af66fc99e Initial load duke parents: diff changeset	3577 }
a61af66fc99e Initial load duke parents: diff changeset	3578 }
a61af66fc99e Initial load duke parents: diff changeset	3579 }
a61af66fc99e Initial load duke parents: diff changeset	3580 }
a61af66fc99e Initial load duke parents: diff changeset	3581 } // end add_previous_version()
a61af66fc99e Initial load duke parents: diff changeset	3582
a61af66fc99e Initial load duke parents: diff changeset	3583
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3584 // Determine if InstanceKlass has a previous version.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3585 bool InstanceKlass::has_previous_version() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3586 return (_previous_versions != NULL && _previous_versions->length() > 0);
0 a61af66fc99e Initial load duke parents: diff changeset	3587 } // end has_previous_version()
a61af66fc99e Initial load duke parents: diff changeset	3588
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3589
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3590 Method* InstanceKlass::method_with_idnum(int idnum) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3591 Method* m = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	3592 if (idnum < methods()->length()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3593 m = methods()->at(idnum);
0 a61af66fc99e Initial load duke parents: diff changeset	3594 }
a61af66fc99e Initial load duke parents: diff changeset	3595 if (m == NULL \|\| m->method_idnum() != idnum) {
a61af66fc99e Initial load duke parents: diff changeset	3596 for (int index = 0; index < methods()->length(); ++index) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3597 m = methods()->at(index);
0 a61af66fc99e Initial load duke parents: diff changeset	3598 if (m->method_idnum() == idnum) {
a61af66fc99e Initial load duke parents: diff changeset	3599 return m;
a61af66fc99e Initial load duke parents: diff changeset	3600 }
a61af66fc99e Initial load duke parents: diff changeset	3601 }
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3602 // None found, return null for the caller to handle.
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3603 return NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	3604 }
a61af66fc99e Initial load duke parents: diff changeset	3605 return m;
a61af66fc99e Initial load duke parents: diff changeset	3606 }
a61af66fc99e Initial load duke parents: diff changeset	3607
11148 825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	3608 jint InstanceKlass::get_cached_class_file_len() {
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	3609 return VM_RedefineClasses::get_cached_class_file_len(_cached_class_file);
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	3610 }
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	3611
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	3612 unsigned char * InstanceKlass::get_cached_class_file_bytes() {
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	3613 return VM_RedefineClasses::get_cached_class_file_bytes(_cached_class_file);
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	3614 }
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	3615
0 a61af66fc99e Initial load duke parents: diff changeset	3616
a61af66fc99e Initial load duke parents: diff changeset	3617 // Construct a PreviousVersionNode entry for the array hung off
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3618 // the InstanceKlass.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3619 PreviousVersionNode::PreviousVersionNode(ConstantPool* prev_constant_pool,
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3620 GrowableArray<Method> prev_EMCP_methods) {
0 a61af66fc99e Initial load duke parents: diff changeset	3621
a61af66fc99e Initial load duke parents: diff changeset	3622 _prev_constant_pool = prev_constant_pool;
a61af66fc99e Initial load duke parents: diff changeset	3623 _prev_EMCP_methods = prev_EMCP_methods;
a61af66fc99e Initial load duke parents: diff changeset	3624 }
a61af66fc99e Initial load duke parents: diff changeset	3625
a61af66fc99e Initial load duke parents: diff changeset	3626
a61af66fc99e Initial load duke parents: diff changeset	3627 // Destroy a PreviousVersionNode
a61af66fc99e Initial load duke parents: diff changeset	3628 PreviousVersionNode::~PreviousVersionNode() {
a61af66fc99e Initial load duke parents: diff changeset	3629 if (_prev_constant_pool != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3630 _prev_constant_pool = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	3631 }
a61af66fc99e Initial load duke parents: diff changeset	3632
a61af66fc99e Initial load duke parents: diff changeset	3633 if (_prev_EMCP_methods != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	3634 delete _prev_EMCP_methods;
a61af66fc99e Initial load duke parents: diff changeset	3635 }
a61af66fc99e Initial load duke parents: diff changeset	3636 }
a61af66fc99e Initial load duke parents: diff changeset	3637
a61af66fc99e Initial load duke parents: diff changeset	3638 // Construct a helper for walking the previous versions array
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3639 PreviousVersionWalker::PreviousVersionWalker(Thread* thread, InstanceKlass *ik) {
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3640 _thread = thread;
0 a61af66fc99e Initial load duke parents: diff changeset	3641 _previous_versions = ik->previous_versions();
a61af66fc99e Initial load duke parents: diff changeset	3642 _current_index = 0;
a61af66fc99e Initial load duke parents: diff changeset	3643 _current_p = NULL;
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3644 _current_constant_pool_handle = constantPoolHandle(thread, ik->constants());
0 a61af66fc99e Initial load duke parents: diff changeset	3645 }
a61af66fc99e Initial load duke parents: diff changeset	3646
a61af66fc99e Initial load duke parents: diff changeset	3647
a61af66fc99e Initial load duke parents: diff changeset	3648 // Return the interesting information for the next previous version
a61af66fc99e Initial load duke parents: diff changeset	3649 // of the klass. Returns NULL if there are no more previous versions.
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3650 PreviousVersionNode* PreviousVersionWalker::next_previous_version() {
0 a61af66fc99e Initial load duke parents: diff changeset	3651 if (_previous_versions == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	3652 // no previous versions so nothing to return
a61af66fc99e Initial load duke parents: diff changeset	3653 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	3654 }
a61af66fc99e Initial load duke parents: diff changeset	3655
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3656 _current_p = NULL; // reset to NULL
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3657 _current_constant_pool_handle = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	3658
a61af66fc99e Initial load duke parents: diff changeset	3659 int length = _previous_versions->length();
a61af66fc99e Initial load duke parents: diff changeset	3660
a61af66fc99e Initial load duke parents: diff changeset	3661 while (_current_index < length) {
a61af66fc99e Initial load duke parents: diff changeset	3662 PreviousVersionNode * pv_node = _previous_versions->at(_current_index++);
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3663
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3664 // Save a handle to the constant pool for this previous version,
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3665 // which keeps all the methods from being deallocated.
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3666 _current_constant_pool_handle = constantPoolHandle(_thread, pv_node->prev_constant_pool());
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3667 _current_p = pv_node;
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3668 return pv_node;
0 a61af66fc99e Initial load duke parents: diff changeset	3669 }
a61af66fc99e Initial load duke parents: diff changeset	3670
a61af66fc99e Initial load duke parents: diff changeset	3671 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	3672 } // end next_previous_version()

Mercurial > hg > truffle

annotate src/share/vm/oops/instanceKlass.cpp @ 14649:f6301b007a16