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

annotate src/share/vm/oops/instanceKlass.cpp @ 17716:cdb71841f4bc

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	85318d1fe8fe
children	e6195383bcaf b8413a9cbb84 752ba2e5f6d0

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

Mercurial > hg > truffle

annotate src/share/vm/oops/instanceKlass.cpp @ 17716:cdb71841f4bc